From 14f3cbbc5d8203537734d344f8af39015b0dceb1 Mon Sep 17 00:00:00 2001 From: akshay18iitg Date: Mon, 11 May 2026 14:55:22 -0700 Subject: [PATCH] feat(robocasa): integrate RoboCasa kitchen sim alongside LIBERO MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Adds a RoboCasa env wrapper mirroring the LIBERO layout so policies can train/eval against the kitchen benchmark with the same TrainPipelineConfig plumbing (env.type=robocasa, task_ids fan out per accelerator rank). Bundles an opentau-eval-compatible entrypoint plus a pyproject `robocasa` extra mutually exclusive with `libero` (numpy 1.x vs 2.x). Why: opentau-train so far only had LIBERO. RoboCasa unlocks 25 atomic + 301 composite kitchen tasks for the same pi0.5/pi0.7 checkpoints with no eval loop changes. What: - envs/configs.py: register `robocasa` as a draccus EnvConfig; resolve a flat `task` (class names) and/or `task_ids` (int indices) into a fanned list per rank. - envs/robocasa.py: gym.Env wrapper around robocasa.utils.env_utils.create_env; emits positional camera{i} obs keys (matching LiberoEnv) and inlines _build_proprio_vector / _get_task_prompt so an upstream robocasa install is sufficient (no robocasa.scripts.client dep). Adds has_wrapper_attr / get_wrapper_attr shims for gymnasium 0.29 envs. - envs/factory.py: route make_envs / make_env_config to the new wrapper. - envs/robocasa_tasks.py: append-only registry covering 25 atomic skills (indices 0-24, matching upstream class names PickPlace*, OpenCabinet, OpenFridge, StartCoffeeMachine, ...) and 301 composite multi-stage tasks (25-325) grouped by category. - configs/robocasa.py: RoboCasaEvalConfig + TrainConfigWithRoboCasaEval mirroring configs/libero.py. - scripts/robocasa_eval/: standalone eval entrypoint reusing eval_policy_all/consolidate_eval_info. Directory deliberately not named `robocasa` to avoid shadowing the upstream `robocasa` package on accelerate's sys.path[0]. - configs/examples/pi05_robocasa_eval_config.json: demo config with three cameras and a mix of atomic + composite tasks (task_ids=[0,12,267]). - pyproject.toml: new `robocasa` extra, [tool.uv.sources] pin for robocasa + scoped robosuite-master, conflicts vs libero/urdf, and override- dependencies (numba, scipy, protobuf, draccus) so uv sync resolves. Verified by running `opentau-train --config_path=.../pi05_robocasa_eval_config.json` end-to-end on a 2-GPU box with `MUJOCO_GL=osmesa`: env construction, preprocess_observation key contract, policy.select_action, AsyncVectorEnv worker rollouts (150 steps × PickPlaceCounterToCabinet / OpenDrawer / CerealAndBowl), and per-group eval aggregation all succeed; eval_info.json + per-task MP4s land in cfg.output_dir. Co-Authored-By: Claude Opus 4.7 (1M context) --- .../examples/pi05_robocasa_eval_config.json | 176 +++ pyproject.toml | 59 + src/opentau/configs/robocasa.py | 91 ++ src/opentau/envs/configs.py | 128 +- src/opentau/envs/factory.py | 19 +- src/opentau/envs/robocasa.py | 436 ++++++ src/opentau/envs/robocasa_tasks.py | 547 +++++++ .../{robocasa => robocasa_eval}/__init__.py | 0 src/opentau/scripts/robocasa_eval/eval.py | 154 ++ .../{robocasa => robocasa_eval}/server.py | 0 uv.lock | 1341 +++++++++++++---- 11 files changed, 2682 insertions(+), 269 deletions(-) create mode 100644 configs/examples/pi05_robocasa_eval_config.json create mode 100644 src/opentau/configs/robocasa.py create mode 100644 src/opentau/envs/robocasa.py create mode 100644 src/opentau/envs/robocasa_tasks.py rename src/opentau/scripts/{robocasa => robocasa_eval}/__init__.py (100%) create mode 100644 src/opentau/scripts/robocasa_eval/eval.py rename src/opentau/scripts/{robocasa => robocasa_eval}/server.py (100%) diff --git a/configs/examples/pi05_robocasa_eval_config.json b/configs/examples/pi05_robocasa_eval_config.json new file mode 100644 index 00000000..04f5d79a --- /dev/null +++ b/configs/examples/pi05_robocasa_eval_config.json @@ -0,0 +1,176 @@ +{ + "dataset_mixture": { + "datasets": [ + { + "repo_id": "physical-intelligence/libero" + } + ], + "weights": [ + 1.0 + ], + "action_freq": 10.0, + "image_resample_strategy": "nearest", + "vector_resample_strategy": "nearest" + }, + "policy": { + "type": "pi05", + "pretrained_path": "TensorAuto/tPi0.5-base", + "n_obs_steps": 1, + "input_features": { + "camera0": { + "shape": [ + 3, + 224, + 224 + ], + "type": "VISUAL" + }, + "camera1": { + "shape": [ + 3, + 224, + 224 + ], + "type": "VISUAL" + }, + "camera2": { + "shape": [ + 3, + 224, + 224 + ], + "type": "VISUAL" + }, + "state": { + "shape": [ + 32 + ], + "type": "STATE" + } + }, + "output_features": { + "actions": { + "shape": [ + 32 + ], + "type": "ACTION" + } + }, + "normalization_mapping": { + "VISUAL": "IDENTITY", + "STATE": "MIN_MAX", + "ACTION": "MEAN_STD" + }, + "chunk_size": 10, + "n_action_steps": 10, + "max_state_dim": 32, + "max_action_dim": 32, + "proj_width": 1024, + "num_steps": 10, + "attention_implementation": "eager", + "freeze_vision_encoder": true, + "train_expert_only": true, + "prompt_max_length": 256, + "discrete_action_max_length": 60, + "optimizer_lr": 2.5e-05, + "optimizer_betas": [ + 0.9, + 0.95 + ], + "optimizer_eps": 1e-08, + "optimizer_weight_decay": 1e-10, + "scheduler_warmup_steps": 1000, + "scheduler_decay_steps": 30000, + "scheduler_decay_lr": 2.5e-06 + }, + "output_dir": "outputs/pi05_robocasa_eval", + "resume": false, + "seed": 1000, + "resolution": [ + 224, + 224 + ], + "num_cams": 3, + "max_state_dim": 32, + "max_action_dim": 32, + "action_chunk": 10, + "loss_weighting": { + "MSE": 1.0, + "CE": 1.0 + }, + "num_workers": 4, + "batch_size": 2, + "gradient_accumulation_steps": 1, + "dataloader_batch_size": 2, + "prefetch_factor": 8, + "steps": 100, + "log_freq": 1, + "save_checkpoint": true, + "save_freq": 100, + "eval_freq": 10, + "use_policy_training_preset": true, + "trace_nans": false, + "optimizer": { + "type": "adamw", + "lr": 2.5e-05, + "weight_decay": 1e-10, + "grad_clip_norm": 10.0, + "betas": [ + 0.9, + 0.95 + ], + "eps": 1e-08 + }, + "env": { + "type": "robocasa", + "task": "", + "fps": 20, + "max_parallel_tasks": 1, + "task_ids": [ + 0, + 12, + 267 + ], + "episode_length": 150, + "camera_names": [ + "robot0_eye_in_hand", + "robot0_agentview_left", + "robot0_agentview_right" + ], + "camera_height": 256, + "camera_width": 256, + "num_steps_wait": 10, + "render_cam": null, + "split": "all", + "seed_base": 0 + }, + "eval": { + "n_episodes": 1, + "batch_size": 1, + "use_async_envs": true, + "max_episodes_rendered": 1, + "recording_root": null, + "grid_size": null + }, + "scheduler": { + "type": "cosine_decay_with_warmup", + "num_warmup_steps": 1000, + "num_decay_steps": 30000, + "peak_lr": 2.5e-05, + "decay_lr": 2.5e-06 + }, + "wandb": { + "enable": true, + "entity": "wyautox-autox", + "project": "pi05", + "run_id": null, + "name": null, + "notes": "Evaluating pi0.5 on robocasa", + "tags": [], + "group": null, + "job_type": null, + "mode": null, + "allow_resume": true, + "disable_artifact": false + } +} diff --git a/pyproject.toml b/pyproject.toml index 058eafe2..96d2a6b4 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -140,12 +140,37 @@ libero = [ urdf = [ "rerun-sdk>=0.28.2", ] +robocasa = [ + # RoboCasa kitchen sim. Most runtime deps (numpy, mujoco, lerobot, gymnasium, + # opencv-python, imageio, termcolor, lxml, hidapi, numba, pygame) come from + # robocasa's own setup.py — listed below only when robocasa needs them but does + # not declare them, or when we need a tighter version floor than robocasa does. + # Mutually exclusive with the `libero` extra (numpy 2.x vs <2). + "robocasa", + "robosuite>=1.5.0", # robocasa imports robosuite at top-level but does not declare it + "glfw>=2.0", # required by mujoco's viewer; not pulled by robocasa + "msgpack>=1.0", # used by scripts/robocasa/server.py + "websockets>=11.0", # used by scripts/robocasa/server.py +] trt = [ "tensorrt>=10.15.1.29 ; (sys_platform == 'linux' and platform_machine == 'x86_64') or (sys_platform == 'win32' and (platform_machine == 'AMD64' or platform_machine == 'x86_64'))", ] [tool.uv.sources] libero = { git = "https://github.com/shuheng-liu/LIBERO" , branch = "master" } # the official libero repo is misconfigured for pip install with git +# RoboCasa is shipped as a separate sim package; track upstream main. Replace with a +# fork (e.g. `{ git = "https://github.com//robocasa", branch = "..." }`) or a +# local checkout (`{ path = "../robocasa", editable = true }`) if you carry local +# patches. The OpenTau wrapper only depends on `robocasa.utils.env_utils.create_env`, +# so an unmodified upstream install is sufficient. +robocasa = { git = "https://github.com/robocasa/robocasa", branch = "main" } +# RoboCasa uses upstream robosuite **master** APIs (`get_elements`, +# `xml_path_completion`-variants) that aren't in PyPI's `robosuite==1.5.x`. Scope this +# source to the robocasa extra via `extra = "robocasa"` so libero — which pins +# `robosuite==1.4.0` from PyPI — falls back to the index resolution. +robosuite = [ + { git = "https://github.com/ARISE-Initiative/robosuite", branch = "master", extra = "robocasa" }, +] # libero depends on gym, which depends on numpy 1.x, while rerun only supports urdf in v0.28 which requires numpy 2.x [tool.uv] @@ -154,11 +179,43 @@ libero = { git = "https://github.com/shuheng-liu/LIBERO" , branch = "master" } # and the build regresses to the original CMake 4 failure with a confusing # message. Bumping this floor errors loudly with a clear pointer instead. required-version = ">=0.8.4" +# RoboCasa's setup.py declares hard equality pins (numpy==2.2.5, numba==0.61.2, +# scipy==1.15.3) that collide with opentau's own floors (numba>=0.62.0) and with +# whatever other extras pull in. Force compatible versions across the whole resolve so +# `uv sync --extra robocasa` succeeds without forking robocasa's setup.py. The override +# applies regardless of the active extra — it's a no-op for libero/urdf because they +# don't repin numba and the numpy bound here is satisfied by libero's numpy<2 too. +override-dependencies = [ + "numba>=0.62.0", + "scipy>=1.13", + # Both opentau and lerobot want draccus>=0.10, but the robocasa-extras resolve + # currently picks 0.8.0 (an old shared transitive constraint). Force the modern + # version explicitly so `singledispatch(include_subclasses=...)` is available. + "draccus>=0.10.0", + # robocasa's setup.py pins tianshou==0.4.10, which transitively requires + # protobuf<3.20 — clashing with opentau's protobuf>=4.25. Tianshou 1.x requires + # Python>=3.11 (we're on 3.10), so we can't bump it. Force protobuf to opentau's + # range instead; opentau never actually exercises tianshou code paths, and + # tianshou's protobuf usage is limited to a tensorboard pb shim that still imports + # on protobuf 4.x at runtime even if its declared pin says otherwise. + "protobuf>=4.25", +] conflicts = [ [ { extra = "libero" }, { extra = "urdf" }, ], + # robocasa pins numpy 2.x; libero pulls numpy<2. Force users to pick one sim at a time. + [ + { extra = "libero" }, + { extra = "robocasa" }, + ], + # robocasa transitively pulls rerun-sdk<0.23 (via lerobot 0.3.3), while urdf needs + # rerun-sdk>=0.28.2. Declare them mutually exclusive so the resolver bails fast. + [ + { extra = "urdf" }, + { extra = "robocasa" }, + ], ] # egl-probe (transitive via robomimic in the libero extra) ships an sdist whose # CMakeLists declares cmake_minimum_required(VERSION 2.8.12). CMake 4.0 dropped @@ -201,6 +258,8 @@ default.extend-ignore-identifiers-re = [ # Add individual words here to ignore them "2nd", "pn", + "Pn", # RoboCasa task names use "Pn" prefix (e.g. PnPCounterToCab) + "Metalic", # upstream RoboCasa class name (OrganizeMetalicUtensils) "ser", "ein", ] diff --git a/src/opentau/configs/robocasa.py b/src/opentau/configs/robocasa.py new file mode 100644 index 00000000..6e3bf832 --- /dev/null +++ b/src/opentau/configs/robocasa.py @@ -0,0 +1,91 @@ +# Copyright 2026 Tensor Auto Inc. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""RoboCasa environment configuration module. + +Mirrors :mod:`opentau.configs.libero` for the RoboCasa kitchen benchmark — extends the +base training pipeline configuration with RoboCasa-specific evaluation parameters used by +``scripts/robocasa_eval/eval.py`` and the bundled-in evaluation hook in +``scripts/train.py``. +""" + +from dataclasses import dataclass + +from opentau.configs.train import TrainPipelineConfig + + +@dataclass +class RoboCasaEvalConfig: + """Configuration for RoboCasa environment evaluation. + + Args: + task: Comma-separated RoboCasa task class names (e.g. ``"PnPCounterToCab"``). + Each name becomes one logical evaluation group, vectorised across rollouts. + max_steps: Hard cap on policy steps per episode (in addition to ``_check_success``). + Defaults to 1500. + chunk_usage: Number of actions to execute per policy call before re-querying. + If ``None``, defaults to the training config's ``action_chunk``. + n_simulations: Number of rollouts to run per task. Defaults to 50. + video_dir: Optional output directory for rollout videos. + action_dim: Effective action dim sent to RoboCasa (the policy output is + truncated or zero-padded to this size). Defaults to 16 (PI 0.5 action head). + seed_base: Starting seed for rollout 0; rollout ``i`` uses ``seed_base + i``. + camera_height: Off-screen camera height (pixels). Defaults to 256. + camera_width: Off-screen camera width (pixels). Defaults to 256. + split: Dataset split passed to ``robocasa.utils.env_utils.create_env``. + + Raises: + ValueError: If ``task`` is empty. + """ + + task: str = "PnPCounterToCab" + max_steps: int = 1500 + chunk_usage: int | None = None + n_simulations: int = 50 + video_dir: str | None = None + action_dim: int = 16 + seed_base: int = 0 + camera_height: int = 256 + camera_width: int = 256 + split: str | None = "all" + + def __post_init__(self): + task_names = [s.strip() for s in str(self.task).split(",") if s.strip()] + if not task_names: + raise ValueError("RoboCasaEvalConfig.task must contain at least one task class name.") + self.task_names = task_names + + +@dataclass +class TrainConfigWithRoboCasaEval(TrainPipelineConfig): + """Training configuration extended with RoboCasa evaluation settings. + + Args: + robocasa: Configuration for RoboCasa environment evaluation. Must be provided. + + Raises: + ValueError: If ``robocasa`` is None or ``chunk_usage`` is outside ``[1, action_chunk]``. + """ + + robocasa: RoboCasaEvalConfig = None + + def __post_init__(self): + super().__post_init__() + if self.robocasa is None: + raise ValueError("RoboCasa config must be provided.") + if self.robocasa.chunk_usage is None: + self.robocasa.chunk_usage = self.action_chunk + if not 1 <= self.robocasa.chunk_usage <= self.action_chunk: + raise ValueError( + f"Chunk usage must be between 1 and {self.action_chunk=}, got {self.robocasa.chunk_usage=}." + ) diff --git a/src/opentau/envs/configs.py b/src/opentau/envs/configs.py index 4210cac8..c892571c 100644 --- a/src/opentau/envs/configs.py +++ b/src/opentau/envs/configs.py @@ -13,7 +13,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -r"""This module contains configuration files for different environments. Only LIBERO is supported for now.""" +r"""This module contains configuration files for different environments. Supports LIBERO and RoboCasa.""" import abc import logging @@ -26,6 +26,12 @@ from opentau.constants import ACTION, OBS_IMAGES, OBS_STATE from opentau.utils.accelerate_utils import get_proc_accelerator +ROBOCASA_DEFAULT_CAMERA_NAMES: tuple[str, ...] = ( + "robot0_eye_in_hand", + "robot0_agentview_left", + "robot0_agentview_right", +) + @dataclass class EnvConfig(draccus.ChoiceRegistry, abc.ABC): @@ -176,3 +182,123 @@ def gym_kwargs(self) -> dict: "render_mode": self.render_mode, "task_ids": task_ids, } + + +@EnvConfig.register_subclass("robocasa") +@dataclass +class RoboCasaEnv(EnvConfig): + r"""Configuration for the RoboCasa kitchen environment. + + RoboCasa envs are constructed via ``robocasa.utils.env_utils.create_env`` rather than + ``gym.make``. The env name is the registered RoboCasa task class name (e.g. + ``PnPCounterToCab``), and ``task`` is a comma-separated list of such names — one + indexed vec env is built per task name, matching how LIBERO is fanned out across + accelerator ranks. + + Args: + task: Optional comma-separated RoboCasa task class names (e.g. ``"PnPCounterToCab"``). + May be empty when ``task_ids`` is provided. + task_ids: Optional list of integer indices into + :data:`opentau.envs.robocasa_tasks.ROBOCASA_TASKS` — atomic skills in + ``0 .. 24`` (e.g. ``[0, 1, 14]`` picks ``PnPCounterToCab``, + ``PnPCabToCounter``, ``TurnOnStove``) and composite multi-stage tasks in + ``25 .. 325`` (e.g. ``[267]`` picks ``MakeFruitBowl``). Names from ``task`` + and ``task_ids`` are concatenated, preserving order. + fps: Target frames-per-second for stepping/rendering. + episode_length: Maximum number of policy steps per episode. + camera_names: Tuple of RoboCasa camera names to record (order maps to + ``camera0``, ``camera1``, ...). + camera_height: Off-screen camera height (pixels). + camera_width: Off-screen camera width (pixels). + num_steps_wait: Number of no-op steps after reset to settle the simulator. + render_cam: Camera name to use for ``render()``; defaults to the first camera. + split: Dataset split passed to ``robocasa.utils.env_utils.create_env``. + One of ``None``, ``"all"``, ``"pretrain"``, ``"target"``. + seed_base: Per-task seed offset; episode ``i`` uses ``seed_base + i``. + """ + + task: str = "" + task_ids: list[int] | None = None + fps: int = 20 + episode_length: int = 1500 + camera_names: tuple[str, ...] = ROBOCASA_DEFAULT_CAMERA_NAMES + camera_height: int = 256 + camera_width: int = 256 + num_steps_wait: int = 10 + render_cam: str | None = None + split: str | None = "all" + seed_base: int = 0 + features: dict[str, PolicyFeature] = field( + default_factory=lambda: { + "action": PolicyFeature(type=FeatureType.ACTION, shape=(16,)), + } + ) + features_map: dict[str, str] = field( + default_factory=lambda: { + "action": ACTION, + "agent_pos": OBS_STATE, + "pixels/robot0_eye_in_hand": f"{OBS_IMAGES}.image", + "pixels/robot0_agentview_left": f"{OBS_IMAGES}.image2", + "pixels/robot0_agentview_right": f"{OBS_IMAGES}.image3", + } + ) + + def __post_init__(self): + # Defer import so that simply loading this module does not require robocasa_tasks + # (kept light because it only depends on stdlib). + from opentau.envs.robocasa_tasks import resolve_tasks + + # Resolve `task` + `task_ids` into a canonical list of task class names. The + # resolved list is stashed for `gym_kwargs` to fan out across accelerator ranks. + self._resolved_task_names: list[str] = resolve_tasks(self.task, self.task_ids) + + if not self.camera_names: + raise ValueError("camera_names must contain at least one RoboCasa camera name.") + cams = tuple(c.strip() for c in self.camera_names if str(c).strip()) + if not cams: + raise ValueError("camera_names resolved to an empty tuple.") + self.camera_names = cams + + shape = (self.camera_height, self.camera_width, 3) + for cam in self.camera_names: + self.features[f"pixels/{cam}"] = PolicyFeature(type=FeatureType.VISUAL, shape=shape) + # agent_pos shape is fixed by build_proprio_vector (proprio vector returned by RoboCasa). + # Leave the actual shape inference to the wrapper; declare a flexible default here. + self.features["agent_pos"] = PolicyFeature(type=FeatureType.STATE, shape=(32,)) + + @property + def gym_kwargs(self) -> dict: + r"""Return the keyword arguments used to construct the RoboCasa environment.""" + task_names = list(self._resolved_task_names) + if not task_names: + raise ValueError( + "RoboCasa env has no tasks selected — provide `task` (class names) " + "and/or `task_ids` (indices)." + ) + + accelerator = get_proc_accelerator() + if accelerator is None: + assigned = list(task_names) + logging.info(f"[RoboCasa environment] No accelerator found, using tasks={assigned}.") + else: + assigned = [ + t + for idx, t in enumerate(task_names) + if idx % accelerator.num_processes == accelerator.process_index + ] + logging.info( + f"[RoboCasa environment] After distributing, using tasks={assigned} " + f"on process_index={accelerator.process_index}." + ) + + return { + "tasks": assigned, + "camera_names": list(self.camera_names), + "camera_height": self.camera_height, + "camera_width": self.camera_width, + "num_steps_wait": self.num_steps_wait, + "episode_length": self.episode_length, + "render_cam": self.render_cam, + "split": self.split, + "seed_base": self.seed_base, + } diff --git a/src/opentau/envs/factory.py b/src/opentau/envs/factory.py index 3fc32c5c..01e16279 100644 --- a/src/opentau/envs/factory.py +++ b/src/opentau/envs/factory.py @@ -22,17 +22,18 @@ import gymnasium as gym from opentau.configs.train import TrainPipelineConfig -from opentau.envs.configs import EnvConfig, LiberoEnv +from opentau.envs.configs import EnvConfig, LiberoEnv, RoboCasaEnv def make_env_config(env_type: str, **kwargs) -> EnvConfig: r"""Factory method to create an environment config based on the env_type. - Right now, only 'libero' is supported. + Supports 'libero' and 'robocasa'. """ if env_type == "libero": return LiberoEnv(**kwargs) - else: - raise ValueError(f"Env type '{env_type}' is not available.") + if env_type == "robocasa": + return RoboCasaEnv(**kwargs) + raise ValueError(f"Env type '{env_type}' is not available.") def make_envs( @@ -79,6 +80,16 @@ def make_envs( env_cls=env_cls, ) + if isinstance(cfg, RoboCasaEnv): + from opentau.envs.robocasa import create_robocasa_envs + + return create_robocasa_envs( + task=cfg.task, + n_envs=n_envs, + gym_kwargs=cfg.gym_kwargs, + env_cls=env_cls, + ) + try: importlib.import_module(cfg.import_name) except ModuleNotFoundError as e: diff --git a/src/opentau/envs/robocasa.py b/src/opentau/envs/robocasa.py new file mode 100644 index 00000000..1704c7a6 --- /dev/null +++ b/src/opentau/envs/robocasa.py @@ -0,0 +1,436 @@ +# Copyright 2026 Tensor Auto Inc. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +r"""Environment wrapper for RoboCasa kitchen tasks. + +This module mirrors :mod:`opentau.envs.libero`: it adapts a single RoboCasa task into a +``gymnasium.Env`` so it can be vectorised by ``gym.vector.SyncVectorEnv`` / +``gym.vector.AsyncVectorEnv`` and consumed by the standard OpenTau eval loop. + +Cameras are exposed under the ``pixels/{camera_name}`` namespace and the proprio state is +exposed under ``agent_pos`` — the same convention LIBERO uses, so +``preprocess_observation`` / ``features_map`` translate them into the standard OpenTau +observation dict. +""" + +from __future__ import annotations + +import contextlib +from collections import defaultdict +from collections.abc import Callable, Iterable, Mapping, Sequence +from functools import partial +from typing import Any + +import gymnasium as gym +import numpy as np +from gymnasium import spaces + +from opentau.envs.configs import ROBOCASA_DEFAULT_CAMERA_NAMES +from opentau.utils.accelerate_utils import acc_print + +# Proprio observation keys exposed by RoboCasa's PandaOmron-style envs. Concatenated in +# order to form the policy state vector. Kept here (rather than imported from +# ``robocasa.scripts.client``) so the wrapper works against an unmodified upstream +# robocasa install — that ``client.py`` is not part of the published package. +ROBOCASA_DEFAULT_PROPRIO_KEYS: tuple[str, ...] = ( + "robot0_base_pos", + "robot0_base_quat", + "robot0_base_to_eef_pos", + "robot0_base_to_eef_quat", + "robot0_gripper_qpos", +) + + +def _build_proprio_vector(obs: dict, keys: Sequence[str] = ROBOCASA_DEFAULT_PROPRIO_KEYS) -> np.ndarray: + """Concatenate low-dim robot state for policy input. + + Matches the layout produced by ``robocasa.scripts.client.build_proprio_vector`` so + checkpoints trained against client.py-recorded data see the same proprio convention. + """ + parts: list[np.ndarray] = [] + for k in keys: + if k not in obs: + raise KeyError( + f"RoboCasa observation missing proprio key {k!r}. " + f"Available keys (sample): " + f"{[x for x in obs if not str(x).endswith('_image')][:20]}..." + ) + parts.append(np.asarray(obs[k], dtype=np.float64).ravel()) + return np.concatenate(parts, axis=0) + + +def _get_task_prompt(env: Any) -> str: + """Return the natural-language instruction for the current RoboCasa episode.""" + try: + meta = env.get_ep_meta() + except Exception: + return "" + if not meta: + return "" + lang = meta.get("lang", "") if isinstance(meta, dict) else "" + if lang is None: + return "" + if isinstance(lang, (list, tuple)): + return " ".join(str(x) for x in lang) + return str(lang) + + +def _parse_camera_names(camera_name: str | Sequence[str]) -> list[str]: + """Normalize ``camera_name`` into a non-empty list of strings.""" + if isinstance(camera_name, str): + cams = [c.strip() for c in camera_name.split(",") if c.strip()] + elif isinstance(camera_name, (list, tuple)): + cams = [str(c).strip() for c in camera_name if str(c).strip()] + else: + raise TypeError(f"camera_name must be str or sequence[str], got {type(camera_name).__name__}") + if not cams: + raise ValueError("camera_name resolved to an empty list.") + return cams + + +AGENT_POS_LOW = -1000.0 +AGENT_POS_HIGH = 1000.0 +ACTION_LOW = -1.0 +ACTION_HIGH = 1.0 +# Upper bound for the proprio vector length returned by RoboCasa's ``build_proprio_vector``. +# Concrete length is detected on first reset() and the box is reshaped; this constant only +# controls how big the declared observation_space is up-front. +DEFAULT_PROPRIO_DIM = 32 + + +class RoboCasaEnv(gym.Env): + r"""Wrap a single RoboCasa task class as a ``gymnasium.Env``. + + One sub-env corresponds to one rollout: it owns its own MuJoCo simulator instance and + its own deterministic seed (``seed_base + episode_index``). Vectorisation across + rollouts and across task names is handled by :func:`create_robocasa_envs`. + """ + + metadata = {"render_modes": ["rgb_array"], "render_fps": 20} + + def __init__( + self, + task_name: str, + episode_index: int = 0, + *, + camera_names: Sequence[str] = ROBOCASA_DEFAULT_CAMERA_NAMES, + camera_height: int = 256, + camera_width: int = 256, + num_steps_wait: int = 10, + episode_length: int = 1500, + seed_base: int = 0, + split: str | None = "all", + render_cam: str | None = None, + render_mode: str = "rgb_array", + ) -> None: + super().__init__() + # Import lazily so that machines without robocasa installed (e.g. CPU dev) can + # still import opentau.envs.configs to inspect schemas without crashing. + from robocasa.utils.env_utils import create_env + + self._create_env = create_env + self._build_proprio_vector = _build_proprio_vector + self._get_task_prompt = _get_task_prompt + + self.task_name = task_name + # ``task`` mirrors ``task_name`` for compatibility with the LIBERO-style env + # attribute contract that ``check_env_attributes_and_types`` and several policy + # heads (which infer the task identifier per rollout) look for. + self.task = task_name + self.episode_index = episode_index + self.camera_names = _parse_camera_names(camera_names) + self.camera_height = int(camera_height) + self.camera_width = int(camera_width) + self.num_steps_wait = int(num_steps_wait) + self.episode_length = int(episode_length) + self.seed_base = int(seed_base) + self.split = split + # ``render_cam`` indexes the positional ``camera{i}`` keys (matching what + # ``_format_obs`` emits), not the raw RoboCasa cam name. Accept either form: + # if the caller passed a raw name, translate it to the positional key. + if render_cam is None: + self.render_cam = "camera0" + elif render_cam in self.camera_names: + self.render_cam = f"camera{self.camera_names.index(render_cam)}" + else: + self.render_cam = render_cam + self.render_mode = render_mode + + # Built lazily on first reset() so that any AsyncVectorEnv worker process can + # fork before MuJoCo is initialised (RoboCasa's renderer must live in the worker). + self._env: Any | None = None + self._task_description: str = "" + self._action_dim: int | None = None + self._proprio_dim: int = DEFAULT_PROPRIO_DIM + + self._max_episode_steps = self.episode_length + + # Match the positional ``camera{i}`` keys emitted by ``_format_obs`` so that + # gymnasium's AsyncVectorEnv observation validation sees consistent keys. + images: dict[str, spaces.Box] = { + f"camera{idx}": spaces.Box( + low=0, + high=255, + shape=(self.camera_height, self.camera_width, 3), + dtype=np.uint8, + ) + for idx in range(len(self.camera_names)) + } + self.observation_space = spaces.Dict( + { + "pixels": spaces.Dict(images), + "agent_pos": spaces.Box( + low=AGENT_POS_LOW, + high=AGENT_POS_HIGH, + shape=(self._proprio_dim,), + dtype=np.float64, + ), + } + ) + # Action space is sized on first reset() once env.action_dim is known. Provide a + # permissive placeholder so vector envs can inspect a shape before reset. + self.action_space = spaces.Box(low=ACTION_LOW, high=ACTION_HIGH, shape=(16,), dtype=np.float32) + + def _build_env(self, seed: int) -> Any: + # ``create_env`` derives ``has_offscreen_renderer`` / ``use_camera_obs`` itself + # from ``render_onscreen`` (see robocasa.utils.env_utils.create_env). Passing + # them again duplicates the kwarg and raises + # ``TypeError: dict() got multiple values for keyword argument 'has_offscreen_renderer'``. + return self._create_env( + self.task_name, + split=self.split, + seed=seed, + render_onscreen=False, + camera_names=list(self.camera_names), + camera_widths=self.camera_width, + camera_heights=self.camera_height, + ) + + def _flip(self, image: np.ndarray) -> np.ndarray: + # RoboCasa returns vertically-flipped images from mujoco; flip top-down to match + # the rendering convention used by client.py (``flip_image_obs``). + return image[::-1, :, :].copy() + + def _format_obs(self, raw_obs: dict[str, Any]) -> dict[str, Any]: + # Emit positional ``camera{idx}`` keys (matching LiberoEnv's convention) so + # downstream ``preprocess_observation`` + ``features_map`` see the same keys the + # policy was trained against, regardless of what robocasa internally calls the + # cameras. ``self.camera_names[i]`` -> ``camera{i}``. + images: dict[str, np.ndarray] = {} + for idx, cam in enumerate(self.camera_names): + key = f"{cam}_image" + if key not in raw_obs: + raise KeyError( + f"Camera image key {key!r} missing from RoboCasa observation; " + f"available keys: {sorted(raw_obs.keys())}" + ) + images[f"camera{idx}"] = self._flip(raw_obs[key]) + proprio = np.asarray(self._build_proprio_vector(raw_obs), dtype=np.float64).ravel() + if proprio.shape[0] != self._proprio_dim: + # Re-fit the observation_space the first time we learn the real proprio dim. + self._proprio_dim = int(proprio.shape[0]) + self.observation_space.spaces["agent_pos"] = spaces.Box( + low=AGENT_POS_LOW, + high=AGENT_POS_HIGH, + shape=(self._proprio_dim,), + dtype=np.float64, + ) + return {"pixels": images, "agent_pos": proprio} + + def _refit_action_space(self) -> None: + if self._env is None: + return + ad = getattr(self._env, "action_dim", None) + if ad is None: + return + self._action_dim = int(ad) + self.action_space = spaces.Box( + low=ACTION_LOW, high=ACTION_HIGH, shape=(self._action_dim,), dtype=np.float32 + ) + + @property + def task_description(self) -> str: + return self._task_description + + def has_wrapper_attr(self, name: str) -> bool: + """Gymnasium 1.0+ API shim used by ``check_env_attributes_and_types``. + + gymnasium ``0.29.x`` (what we pin) hasn't added this on ``gym.Env`` yet, so the + async worker raises ``AttributeError`` when the eval loop asks each rollout env + whether it carries a ``task`` / ``task_description``. Forwarding to plain + ``hasattr`` gives the same answer the future API will once we upgrade. + """ + return hasattr(self, name) + + def get_wrapper_attr(self, name: str) -> Any: + """Gymnasium 1.0+ API shim — paired with :meth:`has_wrapper_attr`. + + Used by ``opentau.envs.utils.add_envs_task`` to look up ``task`` / + ``task_description`` per rollout env. Pre-1.0 gymnasium doesn't expose this on + ``gym.Env``; fall through to ``getattr`` here. + """ + return getattr(self, name) + + def reset(self, seed: int | None = None, **kwargs) -> tuple[dict[str, Any], dict[str, Any]]: + super().reset(seed=seed) + # Determine seed: prefer caller-provided seed; fall back to deterministic + # seed_base + episode_index so that re-running the same vec env reproduces the + # same RoboCasa layout each batch. + if seed is None: + seed = self.seed_base + self.episode_index + + if self._env is None: + self._env = self._build_env(seed) + else: + # RoboSuite envs don't expose a re-seed API after construction, but they do + # accept a fresh seed via reset() in newer versions; for portability, rebuild. + with contextlib.suppress(Exception): + self._env.close() + self._env = self._build_env(seed) + + raw_obs = self._env.reset() + self._refit_action_space() + try: + self._task_description = str(self._get_task_prompt(self._env) or "") + except Exception: + self._task_description = "" + + # Settle the simulator with a zero action (RoboCasa's dummy action) for a few + # frames after reset so that objects come to rest before the policy first acts. + if self._action_dim and self.num_steps_wait > 0: + zero = np.zeros(self._action_dim, dtype=np.float64) + for _ in range(self.num_steps_wait): + raw_obs, _r, _d, _i = self._env.step(zero) + + obs = self._format_obs(raw_obs) + info = {"is_success": False, "task": self.task_name, "task_description": self._task_description} + return obs, info + + def step(self, action: np.ndarray) -> tuple[dict[str, Any], float, bool, bool, dict[str, Any]]: + if self._env is None: + raise RuntimeError("RoboCasaEnv.step called before reset().") + action = np.asarray(action, dtype=np.float64).ravel() + if self._action_dim is not None and action.shape[0] != self._action_dim: + if action.shape[0] > self._action_dim: + action = action[: self._action_dim] + else: + padded = np.zeros(self._action_dim, dtype=np.float64) + padded[: action.shape[0]] = action + action = padded + + raw_obs, reward, done, info = self._env.step(action) + is_success = bool(self._env._check_success()) # noqa: SLF001 — RoboCasa API + terminated = bool(done) or is_success + truncated = False + info = dict(info or {}) + info.update( + { + "is_success": is_success, + "task": self.task_name, + "task_description": self._task_description, + } + ) + obs = self._format_obs(raw_obs) + return obs, float(reward), terminated, truncated, info + + def render(self) -> np.ndarray: + if self._env is None: + raise RuntimeError("RoboCasaEnv.render called before reset().") + raw_obs = self._env._get_observations() # noqa: SLF001 — RoboCasa API + obs = self._format_obs(raw_obs) + return obs["pixels"][self.render_cam] + + def close(self) -> None: + if self._env is not None: + try: + self._env.close() + finally: + self._env = None + + +def _make_env_fns( + *, + task_name: str, + n_envs: int, + gym_kwargs: Mapping[str, Any], +) -> list[Callable[[], RoboCasaEnv]]: + """Build ``n_envs`` factory callables for a single RoboCasa task.""" + + def _make_env(episode_index: int, **kwargs) -> RoboCasaEnv: + local_kwargs = dict(kwargs) + local_kwargs.pop("tasks", None) + local_kwargs.pop("episode_length", None) + return RoboCasaEnv( + task_name=task_name, + episode_index=episode_index, + episode_length=int(gym_kwargs.get("episode_length", 1500)), + **local_kwargs, + ) + + base_kwargs = { + "camera_names": gym_kwargs.get("camera_names", ROBOCASA_DEFAULT_CAMERA_NAMES), + "camera_height": gym_kwargs.get("camera_height", 256), + "camera_width": gym_kwargs.get("camera_width", 256), + "num_steps_wait": gym_kwargs.get("num_steps_wait", 10), + "seed_base": gym_kwargs.get("seed_base", 0), + "split": gym_kwargs.get("split", "all"), + "render_cam": gym_kwargs.get("render_cam"), + } + + fns: list[Callable[[], RoboCasaEnv]] = [] + for episode_index in range(n_envs): + fns.append(partial(_make_env, episode_index, **base_kwargs)) + return fns + + +def create_robocasa_envs( + task: str | Iterable[str], + n_envs: int, + gym_kwargs: dict[str, Any] | None = None, + env_cls: type[gym.vector.SyncVectorEnv] | type[gym.vector.AsyncVectorEnv] | None = None, +) -> dict[str, dict[int, gym.vector.VectorEnv]]: + """Create vectorised RoboCasa environments shaped like LIBERO's output. + + Returns: + ``dict[task_name][0] -> vec_env`` — one vec env per RoboCasa task class name. + ``task_id=0`` is kept as a placeholder so the downstream eval loop (which keys + videos and metrics on ``(task_group, task_id)``) works without modification. + """ + if env_cls is None or not callable(env_cls): + raise ValueError("env_cls must be a callable that wraps a list of environment factory callables.") + if not isinstance(n_envs, int) or n_envs <= 0: + raise ValueError(f"n_envs must be a positive int; got {n_envs}.") + + gym_kwargs = dict(gym_kwargs or {}) + # The factory call passes us the per-rank task list under "tasks"; fall back to the + # caller's `task` for direct invocations (e.g. from a standalone script). + assigned_tasks = gym_kwargs.pop("tasks", None) + if assigned_tasks is None: + if isinstance(task, str): + assigned_tasks = [s.strip() for s in task.split(",") if s.strip()] + else: + assigned_tasks = [str(t).strip() for t in task if str(t).strip()] + if not assigned_tasks: + acc_print("[RoboCasa] No tasks assigned to this rank; returning empty dict.") + return {} + + acc_print(f"Creating RoboCasa envs | tasks={assigned_tasks} | n_envs(per task)={n_envs}") + + out: dict[str, dict[int, Any]] = defaultdict(dict) + for task_name in assigned_tasks: + fns = _make_env_fns(task_name=task_name, n_envs=n_envs, gym_kwargs=gym_kwargs) + out[task_name][0] = env_cls(fns) + acc_print(f"Built vec env | task={task_name} | n_envs={n_envs}") + + return {t: dict(m) for t, m in out.items()} diff --git a/src/opentau/envs/robocasa_tasks.py b/src/opentau/envs/robocasa_tasks.py new file mode 100644 index 00000000..a6c463f5 --- /dev/null +++ b/src/opentau/envs/robocasa_tasks.py @@ -0,0 +1,547 @@ +# Copyright 2026 Tensor Auto Inc. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Stable integer indexing for the RoboCasa kitchen tasks (atomic + composite). + +RoboCasa identifies tasks by registered class names (e.g. ``PnPCounterToCab``, +``MakeFruitBowl``). To match the LIBERO eval ergonomics — where a task suite plus integer +``task_ids`` selects which rollouts to run — we expose a frozen ordering here and resolve +``task_ids: [i, j, …]`` via :func:`resolve_task_ids`. + +The registry is split into two append-only blocks: + +* :data:`ROBOCASA_ATOMIC_TASKS` (indices ``0 .. 24``) — the 25 atomic kitchen skills from + the RoboCasa paper (Nasiriany et al., 2024). +* :data:`ROBOCASA_COMPOSITE_TASKS` (indices ``25 .. 325``) — the 301 multi-stage + composite kitchen tasks shipped under + ``robocasa/environments/kitchen/composite/*`` upstream, ordered by category directory + (alphabetical) and by file (alphabetical within each category) so that adjacent indices + share a kitchen-skill family (e.g. all "baking" tasks are contiguous). + +Both blocks together form a single flat index space, exposed as :data:`ROBOCASA_TASKS`. +The contract is **append-only**: existing indices must never be reassigned. Add new +tasks at the end of the appropriate block — never reorder, never delete. +""" + +from __future__ import annotations + +from collections.abc import Iterable, Sequence + +# Atomic skills (indices 0-24). Names match the registered env class names in upstream +# robocasa (NOT the abbreviated labels from the paper — e.g. ``PickPlaceCounterToCabinet`` +# rather than the paper's ``PnPCounterToCab``). Group order follows the RoboCasa paper's +# atomic-skill taxonomy so adjacent indices share a skill family — this makes things +# like ``task_ids: [0..7]`` (all pick-and-place tasks) intuitive without forcing every +# user to remember each class name. +ROBOCASA_ATOMIC_TASKS: tuple[str, ...] = ( + # Pick-and-Place (0-7) + "PickPlaceCounterToCabinet", + "PickPlaceCabinetToCounter", + "PickPlaceCounterToSink", + "PickPlaceSinkToCounter", + "PickPlaceCounterToMicrowave", + "PickPlaceMicrowaveToCounter", + "PickPlaceCounterToStove", + "PickPlaceStoveToCounter", + # Opening / Closing Doors (8-11) — "single" → cabinet, "double" → fridge in upstream + "OpenCabinet", + "CloseCabinet", + "OpenFridge", + "CloseFridge", + # Opening / Closing Drawers (12-13) + "OpenDrawer", + "CloseDrawer", + # Twisting Knobs (14-15) + "TurnOnStove", + "TurnOffStove", + # Turning Levers (16-18) + "TurnOnSinkFaucet", + "TurnOffSinkFaucet", + "TurnSinkSpout", + # Pressing Buttons (19-21) — coffee-machine "press" registers as StartCoffeeMachine + "StartCoffeeMachine", + "TurnOnMicrowave", + "TurnOffMicrowave", + # Insertion (22-23) + "CoffeeServeMug", + "CoffeeSetupMug", + # Navigation (24) + "NavigateKitchen", +) + + +# Composite multi-stage kitchen tasks (indices 25-325). Sourced from +# robocasa/environments/kitchen/composite//.py upstream. Category order +# is alphabetical; within each category, files are listed alphabetically. +ROBOCASA_COMPOSITE_TASKS: tuple[str, ...] = ( + # Adding Ice To Beverages (25-28) + "MakeIceLemonade", + "PlaceEqualIceCubes", + "PlaceIceInCup", + "RetrieveIceTray", + # Arranging Buffet (29-33) + "ArrangeBuffetDessert", + "CutBuffetPizza", + "DivideBuffetTrays", + "PlaceBeveragesTogether", + "TongBuffetSetup", + # Arranging Cabinets (34-36) + "GatherTableware", + "ResetCabinetDoors", + "StackCans", + # Arranging Condiments (37-39) + "CategorizeCondiments", + "LineUpCondiments", + "OrganizeCondiments", + # Baking (40-46) + "CookieDoughPrep", + "CoolBakedCake", + "CoolBakedCookies", + "CupcakeCleanup", + "MixCakeFrosting", + "OrganizeBakingIngredients", + "PastryDisplay", + # Boiling (47-54) + "BoilCorn", + "BoilEggs", + "BoilPot", + "CoolKettle", + "FillKettle", + "HeatMultipleWater", + "PlaceLidToBoil", + "StartElectricKettle", + # Brewing (55-60) + "ArrangeTea", + "DeliverBrewedCoffee", + "KettleBoiling", + "OrganizeCoffeeCondiments", + "PrepareCoffee", + "SweetenCoffee", + # Broiling Fish (61-65) + "OvenBroilFish", + "PrepareBroilingStation", + "RemoveBroiledFish", + "ToasterOvenBroilFish", + "WashFish", + # Chopping Food (66-71) + "ArrangeCuttingFruits", + "ArrangeVegetables", + "BreadSetupSlicing", + "ClearCuttingBoard", + "MeatTransfer", + "OrganizeVegetables", + # Chopping Vegetables (72-73) + "CuttingToolSelection", + "GatherCuttingTools", + # Cleaning Appliances (74-76) + "CleanBlenderJug", + "PrepFridgeForCleaning", + "PrepSinkForCleaning", + # Cleaning Sink (77-79) + "ClearFoodWaste", + "ClearSinkArea", + "RinseSinkBasin", + # Clearing Table (80-87) + "BowlAndCup", + "CandleCleanup", + "ClearReceptaclesForCleaning", + "ClusterItemsForClearing", + "CondimentCollection", + "DessertAssembly", + "DrinkwareConsolidation", + "FoodCleanup", + # Defrosting Food (88-93) + "DefrostByCategory", + "MicrowaveThawing", + "MicrowaveThawingFridge", + "MoveToCounter", + "QuickThaw", + "ThawInSink", + # Filling Serving Dishes (94-97) + "BuildAppetizerPlate", + "DisplayMeatVariety", + "MeatSkewerAssembly", + "MixedFruitPlatter", + # Frying (98-105) + "AssembleCookingArray", + "DistributeSteakOnPans", + "FryingPanAdjustment", + "MealPrepStaging", + "PressChicken", + "RotatePan", + "SearingMeat", + "SetupFrying", + # Garnishing Dishes (106-110) + "AddLemonToFish", + "AddSugarCubes", + "GarnishCake", + "GarnishCupcake", + "GarnishPancake", + # Loading Dishwasher (111-112) + "LoadDishwasher", + "PrepareDishwasher", + # Loading Fridge (113-120) + "CreateChildFriendlyFridge", + "LoadCondimentsInFridge", + "LoadFridgeByType", + "LoadFridgeFifo", + "LoadPreparedFood", + "MoveFreezerToFridge", + "PlaceVeggiesInDrawer", + "RearrangeFridgeItems", + # Making Juice (121-123) + "ChooseRipeFruit", + "FillBlenderJug", + "JuiceFruitReamer", + # Making Salads (124-125) + "PrepareCheeseStation", + "WashLettuce", + # Making Smoothies (126-130) + "AddIceCubes", + "AddSweetener", + "BlendIngredients", + "PlaceStraw", + "PrepareSmoothie", + # Making Tea (131-133) + "ArrangeTeaAccompaniments", + "ServeTea", + "StrainerSetup", + # Making Toast (134-136) + "BreadSelection", + "PrepareToast", + "SweetSavoryToastSetup", + # Managing Freezer Space (137-144) + "ClearFreezer", + "FreezeBottledWaters", + "FreezeIceTray", + "MaximizeFreezerSpace", + "MoveFridgeToFreezer", + "MoveToFreezerDrawer", + "ReorganizeFrozenVegetables", + "SeparateFreezerRack", + # Measuring Ingredients (145-147) + "ChooseMeasuringCup", + "OrganizeMeasuringCups", + "WeighIngredients", + # Meat Preparation (148-149) + "PrepForTenderizing", + "PrepMarinatingMeat", + # Microwaving Food (150-155) + "FilterMicrowavableItem", + "MicrowaveCorrectMeal", + "MicrowaveDefrostMeat", + "PlaceMicrowaveSafeItem", + "ReheatMeal", + "ReturnHeatedFood", + # Mixing And Blending (156-158) + "ColorfulSalsa", + "MakeBananaMilkshake", + "SpicyMarinade", + # Mixing Ingredients (159-164) + "BlendSalsaMix", + "BlendVegetableSauce", + "CheeseMixing", + "MakeCheesecakeFilling", + "MakeChocolateMilk", + "PrepareVeggieDip", + # Organizing Dishes And Containers (165-167) + "EmptyDishRack", + "OrganizeMugsByHandle", + "StackBowlsCabinet", + # Organizing Recycling (168-171) + "RecycleBottlesBySize", + "RecycleBottlesByType", + "RecycleSodaCans", + "RecycleStackedYogurt", + # Organizing Utensils (172-174) + "ArrangeUtensilsByType", + "ClusterUtensilsInDrawer", + "OrganizeMetalicUtensils", + # Packing Lunches (175-178) + "PackFoodByTemp", + "PackFruitContainer", + "PackIdenticalLunches", + "PackSnack", + # Plating Food (179-181) + "BalancedMealPrep", + "PlateSteakMeal", + "PlateStoreDinner", + # Portioning Meals (182-188) + "DistributeChicken", + "PortionFruitBowl", + "PortionHotDogs", + "PortionInTupperware", + "PortionOnSize", + "PortionYogurt", + "ScalePortioning", + # Preparing Hot Chocolate (189-190) + "AddMarshmallow", + "SweetenHotChocolate", + # Preparing Marinade (191-193) + "BlendMarinade", + "GatherMarinadeIngredients", + "PlaceMeatInMarinade", + # Preparing Sandwiches (194-199) + "GatherVegetables", + "HeatKebabSandwich", + "HotDogSetup", + "PrepareSandwichStation", + "PrepareSausageCheese", + "ToastHeatableIngredients", + # Reheating Food (200-205) + "HeatMug", + "MakeLoadedPotato", + "ReheatMeatOnStove", + "SimmeringSauce", + "WaffleReheat", + "WarmCroissant", + # Restocking Supplies (206-213) + "BeverageSorting", + "FreshProduceOrganization", + "RefillCondimentStation", + "RestockBowls", + "RestockCannedFood", + "RestockPantry", + "RestockSinkSupplies", + "StockingBreakfastFoods", + # Sanitizing Cutting Board (214-217) + "RemoveCuttingBoardItems", + "RinseCuttingBoard", + "SanitizePrepCuttingBoard", + "ScrubCuttingBoard", + # Sanitizing Surface (218-223) + "ArrangeSinkSanitization", + "CleanMicrowave", + "CountertopCleanup", + "PrepForSanitizing", + "SanitizeSink", + "WipeTable", + # Sauteing Vegetables (224-230) + "AdjustHeat", + "ButterOnPan", + "PlaceVegetablesEvenly", + "PreheatPot", + "ShakePan", + "StirVegetables", + "TiltPan", + # Seasoning Food (231-233) + "LemonSeasoningFish", + "SeasoningSteak", + "SetupSpiceStation", + # Serving Beverages (234-239) + "DeliverStraw", + "MatchCupAndDrink", + "PrepareCocktailStation", + "PrepareDrinkStation", + "ServeMealJuice", + "SetupSodaBowl", + # Serving Food (240-245) + "AlcoholServingPrep", + "DessertUpgrade", + "PanTransfer", + "PlaceFoodInBowls", + "PrepareSoupServing", + "ServeSteak", + # Setting The Table (246-258) + "AlignSilverware", + "ArrangeBreadBasket", + "ArrangeBreadBowl", + "ArrangeDrinkware", + "BeverageOrganization", + "DateNight", + "SeasoningSpiceSetup", + "SetBowlsForSoup", + "SetupBowls", + "SetupButterPlate", + "SetupFruitBowl", + "SetupWineGlasses", + "SizeSorting", + # Simmering Sauces (259) + "TurnOffSimmeredSauceHeat", + # Slicing Meat (260-262) + "CleanBoard", + "RetrieveMeat", + "SetUpCuttingStation", + # Slow Cooking (263-265) + "AddToSoupPot", + "BeginSlowCooking", + "StopSlowCooking", + # Snack Preparation (266-270) + "BreadAndCheese", + "CerealAndBowl", + "MakeFruitBowl", + "VeggieDipPrep", + "YogurtDelightPrep", + # Sorting Ingredients (271-272) + "SeparateRawIngredients", + "SortBreakfastIngredients", + # Steaming Food (273-275) + "MultistepSteaming", + "SteamFish", + "SteamInMicrowave", + # Steaming Vegetables (276-278) + "PrepareVeggiesForSteaming", + "RemoveSteamedVegetables", + "SteamVeggiesWithWater", + # Storing Leftovers (279-283) + "FreezeCookedFood", + "PrepareStoringLeftovers", + "StoreDumplings", + "StoreLeftoversByType", + "StoreLeftoversInBowl", + # Tidying Cabinets And Drawers (284-288) + "DrawerUtensilSort", + "OrganizeCleaningSupplies", + "PlaceBreakfastItemsAway", + "SnackSorting", + "UtensilShuffle", + # Toasting Bread (289-295) + "GetToastedBread", + "PjSandwichPrep", + "ServeWarmCroissant", + "ToastBagel", + "ToastBaguette", + "ToastOnCorrectRack", + "ToastOneSlotPair", + # Washing Dishes (296-314) + "ChangeWaterTemp", + "ClearSink", + "CollectWashingSupplies", + "DivideBasins", + "DryDishes", + "DryDrinkware", + "DumpLeftovers", + "PlaceDishesBySink", + "PlaceOnDishRack", + "PreRinseStation", + "PreSoakPan", + "ReturnWashingSupplies", + "RinseBowls", + "RinseFragileItem", + "ScrubBowl", + "SoakSponge", + "SortingCleanup", + "StackBowls", + "TransportCookware", + # Washing Fruits And Vegetables (315-325) + "AfterwashSorting", + "AirdryFruit", + "ClearClutter", + "ClearSinkSpace", + "DrainVeggies", + "GatherProduceWashing", + "PrepareVegetableRoasting", + "PrewashFoodAssembly", + "PrewashFoodSorting", + "WashFruitColander", + "WashInSaucepan", +) + + +# Flat lookup table: indices 0..len(ROBOCASA_ATOMIC_TASKS)-1 are atomic, the rest are +# composite. Concatenation order is fixed and must never be reordered. +ROBOCASA_TASKS: tuple[str, ...] = ROBOCASA_ATOMIC_TASKS + ROBOCASA_COMPOSITE_TASKS + +# Sanity check: no duplicate class names in the registry. A duplicate would make +# ``task_index`` non-deterministic and silently break round-trips. +assert len(set(ROBOCASA_TASKS)) == len(ROBOCASA_TASKS), ( + "Duplicate RoboCasa task names in registry — fix in robocasa_tasks.py." +) + +_NAME_TO_INDEX: dict[str, int] = {name: i for i, name in enumerate(ROBOCASA_TASKS)} +_ATOMIC_END: int = len(ROBOCASA_ATOMIC_TASKS) + + +def task_name(task_id: int) -> str: + """Return the RoboCasa task class name for ``task_id``. + + Raises: + ValueError: ``task_id`` is out of range for :data:`ROBOCASA_TASKS`. + """ + if not isinstance(task_id, int) or isinstance(task_id, bool): + raise TypeError(f"task_id must be an int, got {type(task_id).__name__}") + if task_id < 0 or task_id >= len(ROBOCASA_TASKS): + raise ValueError( + f"RoboCasa task_id {task_id} out of range [0, {len(ROBOCASA_TASKS) - 1}]. " + f"See ROBOCASA_TASKS in opentau.envs.robocasa_tasks for the full list " + f"(atomic: 0-{_ATOMIC_END - 1}, composite: {_ATOMIC_END}-{len(ROBOCASA_TASKS) - 1})." + ) + return ROBOCASA_TASKS[task_id] + + +def task_index(name: str) -> int: + """Inverse of :func:`task_name` — return the integer index for a task class name.""" + try: + return _NAME_TO_INDEX[name] + except KeyError as e: + raise ValueError( + f"Unknown RoboCasa task name {name!r}. " + f"Known atomic: {', '.join(ROBOCASA_ATOMIC_TASKS)}. " + f"({len(ROBOCASA_COMPOSITE_TASKS)} composite tasks omitted — see " + f"ROBOCASA_COMPOSITE_TASKS in opentau.envs.robocasa_tasks.)" + ) from e + + +def is_atomic(task_id_or_name: int | str) -> bool: + """Return True iff the given task is one of the atomic kitchen skills.""" + if isinstance(task_id_or_name, str): + return task_id_or_name in ROBOCASA_ATOMIC_TASKS + return 0 <= task_id_or_name < _ATOMIC_END + + +def is_composite(task_id_or_name: int | str) -> bool: + """Return True iff the given task is one of the composite multi-stage tasks.""" + if isinstance(task_id_or_name, str): + return task_id_or_name in ROBOCASA_COMPOSITE_TASKS + return _ATOMIC_END <= task_id_or_name < len(ROBOCASA_TASKS) + + +def resolve_task_ids(task_ids: Iterable[int]) -> list[str]: + """Map an iterable of integer task IDs to a list of RoboCasa task class names. + + Order is preserved; duplicates are kept (the caller decides whether to dedupe). + """ + return [task_name(int(tid)) for tid in task_ids] + + +def resolve_tasks( + task: str | Sequence[str] | None, + task_ids: Iterable[int] | None, +) -> list[str]: + """Normalise a ``task`` / ``task_ids`` pair into a flat list of task class names. + + Accepts either: + * ``task``: comma-separated class names (e.g. ``"PnPCounterToCab,MakeFruitBowl"``) + or a sequence of names, AND/OR + * ``task_ids``: a list of integer indices into :data:`ROBOCASA_TASKS` (atomic in + ``0 .. 24``, composite in ``25 .. 325``). + + Names from both sources are concatenated (``task`` first, then ``task_ids``); + duplicates are preserved so callers can stack repeats deliberately. At least one of + the two arguments must yield a non-empty list. + """ + names: list[str] = [] + if task: + if isinstance(task, str): + names.extend(s.strip() for s in task.split(",") if s.strip()) + else: + names.extend(str(t).strip() for t in task if str(t).strip()) + if task_ids: + names.extend(resolve_task_ids(task_ids)) + if not names: + raise ValueError( + "RoboCasa task resolution produced an empty list — provide `task` (class " + "names) and/or `task_ids` (indices into ROBOCASA_TASKS)." + ) + return names diff --git a/src/opentau/scripts/robocasa/__init__.py b/src/opentau/scripts/robocasa_eval/__init__.py similarity index 100% rename from src/opentau/scripts/robocasa/__init__.py rename to src/opentau/scripts/robocasa_eval/__init__.py diff --git a/src/opentau/scripts/robocasa_eval/eval.py b/src/opentau/scripts/robocasa_eval/eval.py new file mode 100644 index 00000000..a806353b --- /dev/null +++ b/src/opentau/scripts/robocasa_eval/eval.py @@ -0,0 +1,154 @@ +#!/usr/bin/env python + +# Copyright 2026 Tensor Auto Inc. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Evaluate a policy on RoboCasa kitchen environments. + +Mirrors :mod:`opentau.scripts.eval` (LIBERO) but binds the env layer to RoboCasa via +:class:`opentau.envs.configs.RoboCasaEnv`. The rollout / metric machinery is shared with +``scripts/eval.py`` — this module only handles RoboCasa-specific config parsing, output +layout, and the fact that RoboCasa rollouts have no LIBERO-style dataset recorder. + +The same entrypoint is also reusable from ``scripts/train.py`` for periodic in-loop +evaluation: ``cfg.env`` can be a ``RoboCasaEnv`` config and ``make_envs(cfg.env, ...)`` +will produce robocasa vec envs that ``eval_policy_all`` consumes unchanged. + +Run:: + + opentau-eval \\ + --accelerate-config configs/examples/accelerate_ddp_config.yaml \\ + --config_path=configs/examples/pi05_robocasa_eval_config.json + +or directly:: + + accelerate launch src/opentau/scripts/robocasa_eval/eval.py \\ + --config_path=configs/examples/pi05_robocasa_eval_config.json +""" + +import os + +os.environ["TOKENIZERS_PARALLELISM"] = "false" + +import datetime as dt +import json +import logging +from contextlib import nullcontext +from dataclasses import asdict +from pathlib import Path +from pprint import pformat + +import torch +from accelerate import Accelerator +from accelerate.utils import gather_object +from termcolor import colored + +from opentau.configs import parser +from opentau.configs.train import TrainPipelineConfig +from opentau.envs.configs import RoboCasaEnv +from opentau.envs.factory import make_envs +from opentau.envs.utils import close_envs +from opentau.policies.factory import make_policy +from opentau.scripts.eval import consolidate_eval_info, eval_policy_all +from opentau.utils.accelerate_utils import acc_print, set_proc_accelerator +from opentau.utils.random_utils import set_seed +from opentau.utils.utils import init_logging, is_launched_with_accelerate + + +@parser.wrap() +def robocasa_eval_main(cfg: TrainPipelineConfig): + """Run distributed RoboCasa evaluation for the policy described by ``cfg``.""" + accelerator = Accelerator() + set_proc_accelerator(accelerator) + + init_logging(accelerator=accelerator) + logging.info(pformat(asdict(cfg))) + + if not isinstance(cfg.env, RoboCasaEnv): + raise ValueError( + f"robocasa_eval_main expects cfg.env to be a RoboCasaEnv config " + f"(set 'env.type'='robocasa' in the JSON), got {type(cfg.env).__name__}." + ) + + torch.backends.cudnn.benchmark = True + torch.backends.cuda.matmul.allow_tf32 = True + set_seed(cfg.seed) + + details = f"{cfg.env.type}-{cfg.env.task}-{cfg.eval.n_episodes}" + now = f"{dt.datetime.now():%Y%m%d-%H%M%S}" + eval_output_dir = Path(cfg.output_dir) / "post-training-eval" / f"{details}-{now}" + + logging.info(colored("Output dir:", "yellow", attrs=["bold"]) + f" {eval_output_dir}") + + logging.info("Making RoboCasa environment.") + envs = make_envs( + cfg.env, + cfg, + n_envs=cfg.eval.batch_size, + use_async_envs=cfg.eval.use_async_envs, + ) + + logging.info("Making policy.") + policy = make_policy(cfg=cfg.policy) + policy.to(torch.bfloat16) + policy = accelerator.prepare(policy) + policy.eval() + with ( + torch.no_grad(), + torch.autocast(device_type=accelerator.device.type) if cfg.policy.use_amp else nullcontext(), + ): + eval_info = eval_policy_all( + envs=envs, + policy=policy, + n_episodes=cfg.eval.n_episodes, + cfg=cfg, + max_episodes_rendered=cfg.eval.max_episodes_rendered, + videos_dir=eval_output_dir / "videos", + start_seed=cfg.seed, + max_parallel_tasks=cfg.env.max_parallel_tasks, + # RoboCasa has no LIBERO-style dataset recorder; episode data isn't useful + # to keep around and inflates GPU memory, so leave it off. + return_episode_data=False, + ) + + acc_print("Local Eval Info", eval_info) + eval_info = gather_object([eval_info]) + + if accelerator.is_main_process: + eval_info = consolidate_eval_info(eval_info) + eval_output_dir.mkdir(parents=True, exist_ok=True) + with open(eval_output_dir / "eval_info.json", "w") as f: + json.dump(eval_info, f, indent=2) + print("Overall Aggregated Metrics:") + print(eval_info["overall"]) + for task_group, task_group_info in eval_info["per_group"].items(): + print(f"\nAggregated Metrics for {task_group}:") + print(task_group_info) + + close_envs(envs) + accelerator.end_training() + + logging.info("End of RoboCasa eval") + + +def main(): + robocasa_eval_main() + + +if __name__ == "__main__": + if not is_launched_with_accelerate(): + raise Exception( + "This script should be launched with accelerate. " + "Please use `accelerate launch` to run this script." + ) + main() diff --git a/src/opentau/scripts/robocasa/server.py b/src/opentau/scripts/robocasa_eval/server.py similarity index 100% rename from src/opentau/scripts/robocasa/server.py rename to src/opentau/scripts/robocasa_eval/server.py diff --git a/uv.lock b/uv.lock index 2687c2ef..2a7f8887 100644 --- a/uv.lock +++ b/uv.lock @@ -2,29 +2,35 @@ version = 1 revision = 3 requires-python = "==3.10.*" resolution-markers = [ - "platform_machine == 'x86_64' and sys_platform == 'linux' and extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf'", - "platform_machine != 'x86_64' and sys_platform == 'linux' and extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf'", - "(platform_machine == 'AMD64' and sys_platform == 'win32' and extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine == 'x86_64' and sys_platform == 'win32' and extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')", - "(platform_machine != 'AMD64' and platform_machine != 'x86_64' and sys_platform == 'win32' and extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')", - "sys_platform == 'emscripten' and extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf'", - "platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf'", - "platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf'", - "platform_machine != 'aarch64' and platform_machine != 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf'", - "sys_platform == 'darwin' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf'", - "(platform_machine == 'AMD64' and sys_platform == 'win32' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf') or (platform_machine == 'x86_64' and sys_platform == 'win32' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')", - "(platform_machine != 'AMD64' and platform_machine != 'x86_64' and sys_platform == 'win32' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')", - "sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf'", - "platform_machine == 'x86_64' and sys_platform == 'linux' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf'", - "platform_machine != 'x86_64' and sys_platform == 'linux' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf'", - "(platform_machine == 'AMD64' and sys_platform == 'win32' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf') or (platform_machine == 'x86_64' and sys_platform == 'win32' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')", - "(platform_machine != 'AMD64' and platform_machine != 'x86_64' and sys_platform == 'win32' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf') or (sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')", + "sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf'", + "sys_platform == 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf'", + "platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", + "platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", + "sys_platform == 'darwin' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", + "sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", + "sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", + "sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf'", "sys_platform == 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf'", ] conflicts = [[ { package = "opentau", extra = "libero" }, { package = "opentau", extra = "urdf" }, +], [ + { package = "opentau", extra = "libero" }, + { package = "opentau", extra = "robocasa" }, +], [ + { package = "opentau", extra = "robocasa" }, + { package = "opentau", extra = "urdf" }, ]] +[manifest] +overrides = [ + { name = "draccus", specifier = ">=0.10.0" }, + { name = "numba", specifier = ">=0.62.0" }, + { name = "protobuf", specifier = ">=4.25" }, + { name = "scipy", specifier = ">=1.13" }, +] + [[package]] name = "absl-py" version = "2.4.0" @@ -40,13 +46,15 @@ version = "1.12.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "huggingface-hub" }, - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero'" }, - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, { name = "packaging" }, { name = "psutil" }, { name = "pyyaml" }, { name = "safetensors" }, - { name = "torch" }, + { name = "torch", version = "2.7.1", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "torch", version = "2.10.0", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/4a/8e/ac2a9566747a93f8be36ee08532eb0160558b07630a081a6056a9f89bf1d/accelerate-1.12.0.tar.gz", hash = "sha256:70988c352feb481887077d2ab845125024b2a137a5090d6d7a32b57d03a45df6", size = 398399, upload-time = "2025-11-21T11:27:46.973Z" } wheels = [ @@ -263,7 +271,7 @@ name = "cffi" version = "2.0.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pycparser", marker = "implementation_name != 'PyPy' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "pycparser", marker = "implementation_name != 'PyPy' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, ] 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 = [ @@ -320,7 +328,7 @@ name = "click" version = "8.3.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "colorama", marker = "sys_platform == 'win32' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "colorama", marker = "sys_platform == 'win32' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065, upload-time = "2025-11-15T20:45:42.706Z" } wheels = [ @@ -342,11 +350,9 @@ version = "3.31.10" source = { registry = "https://pypi.org/simple" } resolution-markers = [ "platform_machine == 'aarch64' and sys_platform == 'linux'", - "platform_machine == 'x86_64' and sys_platform == 'linux'", - "platform_machine != 'aarch64' and platform_machine != 'x86_64' and sys_platform == 'linux'", + "platform_machine != 'aarch64' and sys_platform == 'linux'", "sys_platform == 'darwin'", - "(platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'x86_64' and sys_platform == 'win32')", - "(platform_machine != 'AMD64' and platform_machine != 'x86_64' and sys_platform == 'win32') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')", + "sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux'", "sys_platform == 'emscripten'", ] sdist = { url = "https://files.pythonhosted.org/packages/37/7b/fbadb3f4fe90ad6ef57f9f5f9e4f721af8e86376fbdf11da2c6ed099830e/cmake-3.31.10.tar.gz", hash = "sha256:ec3d14a0e72e401b3665034dc37901df17f0b4e9c5b163be6cfedfb93470ac0f", size = 34499, upload-time = "2025-11-20T17:07:54.664Z" } @@ -376,10 +382,7 @@ name = "cmake" version = "4.2.1" source = { registry = "https://pypi.org/simple" } resolution-markers = [ - "platform_machine == 'x86_64' and sys_platform == 'linux'", - "platform_machine != 'x86_64' and sys_platform == 'linux'", - "(platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'x86_64' and sys_platform == 'win32')", - "(platform_machine != 'AMD64' and platform_machine != 'x86_64' and sys_platform == 'win32') or (sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')", + "sys_platform != 'emscripten'", "sys_platform == 'emscripten'", ] sdist = { url = "https://files.pythonhosted.org/packages/00/f5/e4f5a35864293a8605bf6e9366d406ee11565b91a22f38f8b8665096c718/cmake-4.2.1.tar.gz", hash = "sha256:a07a790ca65946667c0fb286549e8e0b5a850e2f8170ae60d3418573011ca218", size = 37060, upload-time = "2025-12-21T11:23:47.499Z" } @@ -430,8 +433,9 @@ name = "contourpy" version = "1.3.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero'" }, - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/66/54/eb9bfc647b19f2009dd5c7f5ec51c4e6ca831725f1aea7a993034f483147/contourpy-1.3.2.tar.gz", hash = "sha256:b6945942715a034c671b7fc54f9588126b0b8bf23db2696e3ca8328f3ff0ab54", size = 13466130, upload-time = "2025-04-15T17:47:53.79Z" } wheels = [ @@ -481,7 +485,7 @@ name = "cryptography" version = "47.0.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "cffi", marker = "platform_python_implementation != 'PyPy' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "cffi", marker = "platform_python_implementation != 'PyPy' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/ef/b2/7ffa7fe8207a8c42147ffe70c3e360b228160c1d85dc3faff16aaa3244c0/cryptography-47.0.0.tar.gz", hash = "sha256:9f8e55fe4e63613a5e1cc5819030f27b97742d720203a087802ce4ce9ceb52bb", size = 830863, upload-time = "2026-04-24T19:54:57.056Z" } @@ -521,7 +525,7 @@ name = "cuda-bindings" version = "12.9.4" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "cuda-pathfinder", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "cuda-pathfinder", marker = "(platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero') or (platform_machine == 'aarch64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (platform_machine == 'aarch64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'emscripten' and sys_platform != 'linux' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/37/31/bfcc870f69c6a017c4ad5c42316207fc7551940db6f3639aa4466ec5faf3/cuda_bindings-12.9.4-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a022c96b8bd847e8dc0675523431149a4c3e872f440e3002213dbb9e08f0331a", size = 11800959, upload-time = "2025-10-21T14:51:26.458Z" }, @@ -548,24 +552,61 @@ wheels = [ [[package]] name = "datasets" -version = "4.5.0" +version = "3.6.0" source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten'", + "sys_platform == 'emscripten'", +] dependencies = [ - { name = "dill" }, - { name = "filelock" }, - { name = "fsspec", extra = ["http"] }, - { name = "httpx" }, - { name = "huggingface-hub" }, - { name = "multiprocess" }, - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero'" }, - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, - { name = "packaging" }, - { name = "pandas" }, - { name = "pyarrow" }, - { name = "pyyaml" }, - { name = "requests" }, - { name = "tqdm" }, - { name = "xxhash" }, + { name = "dill", version = "0.3.8", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "filelock", marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "fsspec", version = "2025.3.0", source = { registry = "https://pypi.org/simple" }, extra = ["http"], marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "huggingface-hub", marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "multiprocess", version = "0.70.16", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "packaging", marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "pandas", marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "pyarrow", marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "pyyaml", marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "requests", marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "tqdm", marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "xxhash", marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/1a/89/d3d6fef58a488f8569c82fd293ab7cbd4250244d67f425dcae64c63800ea/datasets-3.6.0.tar.gz", hash = "sha256:1b2bf43b19776e2787e181cfd329cb0ca1a358ea014780c3581e0f276375e041", size = 569336, upload-time = "2025-05-07T15:15:02.659Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/20/34/a08b0ee99715eaba118cbe19a71f7b5e2425c2718ef96007c325944a1152/datasets-3.6.0-py3-none-any.whl", hash = "sha256:25000c4a2c0873a710df127d08a202a06eab7bf42441a6bc278b499c2f72cd1b", size = 491546, upload-time = "2025-05-07T15:14:59.742Z" }, +] + +[[package]] +name = "datasets" +version = "4.5.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf'", + "sys_platform == 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf'", + "platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", + "platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", + "sys_platform == 'darwin' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", + "sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", + "sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", +] +dependencies = [ + { name = "dill", version = "0.4.0", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, + { name = "filelock", marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, + { name = "fsspec", version = "2025.10.0", source = { registry = "https://pypi.org/simple" }, extra = ["http"], marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, + { name = "httpx", marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, + { name = "huggingface-hub", marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, + { name = "multiprocess", version = "0.70.18", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "packaging", marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, + { name = "pandas", marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, + { name = "pyarrow", marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, + { name = "pyyaml", marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, + { name = "requests", marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, + { name = "tqdm", marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, + { name = "xxhash", marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/55/bf/bb927bde63d649296c83e883171ae77074717c1b80fe2868b328bd0dbcbb/datasets-4.5.0.tar.gz", hash = "sha256:00c698ce1c2452e646cc5fad47fef39d3fe78dd650a8a6eb205bb45eb63cd500", size = 588384, upload-time = "2026-01-14T18:27:54.297Z" } wheels = [ @@ -615,13 +656,15 @@ dependencies = [ { name = "hjson" }, { name = "msgpack" }, { name = "ninja" }, - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero'" }, - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, { name = "packaging" }, { name = "psutil" }, { name = "py-cpuinfo" }, { name = "pydantic" }, - { name = "torch" }, + { name = "torch", version = "2.7.1", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "torch", version = "2.10.0", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, { name = "tqdm" }, ] sdist = { url = "https://files.pythonhosted.org/packages/ca/0a/97f1896665690fb6199342284a6afb96cdfe10603f5edf83d1386ecfd081/deepspeed-0.18.5.tar.gz", hash = "sha256:fa35e6e0f50c9a377854b58bd445bf4fb809f2a6a2896099e7cce6b75d10a3d1", size = 1626650, upload-time = "2026-01-30T18:22:45.331Z" } @@ -635,8 +678,9 @@ dependencies = [ { name = "httpx" }, { name = "huggingface-hub" }, { name = "importlib-metadata" }, - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero'" }, - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, { name = "pillow" }, { name = "regex" }, { name = "requests" }, @@ -647,10 +691,32 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/35/50/281f92cb1f83854dbd79b6e958b3bc5018607e2542971d41604ba7a14b2f/diffusers-0.36.0-py3-none-any.whl", hash = "sha256:525d42abc74bfc3b2db594999961295c054b48ef40a11724dacf50e6abd1af98", size = 4597884, upload-time = "2025-12-08T10:14:31.979Z" }, ] +[[package]] +name = "dill" +version = "0.3.8" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten'", + "sys_platform == 'emscripten'", +] +sdist = { url = "https://files.pythonhosted.org/packages/17/4d/ac7ffa80c69ea1df30a8aa11b3578692a5118e7cd1aa157e3ef73b092d15/dill-0.3.8.tar.gz", hash = "sha256:3ebe3c479ad625c4553aca177444d89b486b1d84982eeacded644afc0cf797ca", size = 184847, upload-time = "2024-01-27T23:42:16.145Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c9/7a/cef76fd8438a42f96db64ddaa85280485a9c395e7df3db8158cfec1eee34/dill-0.3.8-py3-none-any.whl", hash = "sha256:c36ca9ffb54365bdd2f8eb3eff7d2a21237f8452b57ace88b1ac615b7e815bd7", size = 116252, upload-time = "2024-01-27T23:42:14.239Z" }, +] + [[package]] name = "dill" version = "0.4.0" source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf'", + "sys_platform == 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf'", + "platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", + "platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", + "sys_platform == 'darwin' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", + "sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", + "sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", +] sdist = { url = "https://files.pythonhosted.org/packages/12/80/630b4b88364e9a8c8c5797f4602d0f76ef820909ee32f0bacb9f90654042/dill-0.4.0.tar.gz", hash = "sha256:0633f1d2df477324f53a895b02c901fb961bdbf65a17122586ea7019292cbcf0", size = 186976, upload-time = "2025-04-16T00:41:48.867Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/50/3d/9373ad9c56321fdab5b41197068e1d8c25883b3fea29dd361f9b55116869/dill-0.4.0-py3-none-any.whl", hash = "sha256:44f54bf6412c2c8464c14e8243eb163690a9800dbe2c367330883b19c7561049", size = 119668, upload-time = "2025-04-16T00:41:47.671Z" }, @@ -740,7 +806,8 @@ wheels = [ [package.optional-dependencies] epath = [ - { name = "fsspec" }, + { name = "fsspec", version = "2025.3.0", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "fsspec", version = "2025.10.0", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, { name = "importlib-resources" }, { name = "typing-extensions" }, { name = "zipp" }, @@ -876,10 +943,37 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", hash = "sha256:0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d", size = 13409, upload-time = "2025-10-06T05:38:16.721Z" }, ] +[[package]] +name = "fsspec" +version = "2025.3.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten'", + "sys_platform == 'emscripten'", +] +sdist = { url = "https://files.pythonhosted.org/packages/34/f4/5721faf47b8c499e776bc34c6a8fc17efdf7fdef0b00f398128bc5dcb4ac/fsspec-2025.3.0.tar.gz", hash = "sha256:a935fd1ea872591f2b5148907d103488fc523295e6c64b835cfad8c3eca44972", size = 298491, upload-time = "2025-03-07T21:47:56.461Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/56/53/eb690efa8513166adef3e0669afd31e95ffde69fb3c52ec2ac7223ed6018/fsspec-2025.3.0-py3-none-any.whl", hash = "sha256:efb87af3efa9103f94ca91a7f8cb7a4df91af9f74fc106c9c7ea0efd7277c1b3", size = 193615, upload-time = "2025-03-07T21:47:54.809Z" }, +] + +[package.optional-dependencies] +http = [ + { name = "aiohttp", marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, +] + [[package]] name = "fsspec" version = "2025.10.0" source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf'", + "sys_platform == 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf'", + "platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", + "platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", + "sys_platform == 'darwin' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", + "sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", + "sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", +] sdist = { url = "https://files.pythonhosted.org/packages/24/7f/2747c0d332b9acfa75dc84447a066fdf812b5a6b8d30472b74d309bfe8cb/fsspec-2025.10.0.tar.gz", hash = "sha256:b6789427626f068f9a83ca4e8a3cc050850b6c0f71f99ddb4f542b8266a26a59", size = 309285, upload-time = "2025-10-30T14:58:44.036Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/eb/02/a6b21098b1d5d6249b7c5ab69dde30108a71e4e819d4a9778f1de1d5b70d/fsspec-2025.10.0-py3-none-any.whl", hash = "sha256:7c7712353ae7d875407f97715f0e1ffcc21e33d5b24556cb1e090ae9409ec61d", size = 200966, upload-time = "2025-10-30T14:58:42.53Z" }, @@ -887,7 +981,7 @@ wheels = [ [package.optional-dependencies] http = [ - { name = "aiohttp" }, + { name = "aiohttp", marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, ] [[package]] @@ -1057,7 +1151,8 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "cloudpickle" }, { name = "gym-notices" }, - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" } }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/ab/b1/eb05a423eb801ab7d0715d6a3b28d92589e30b437052553df19ca2087240/gym-0.26.2.tar.gz", hash = "sha256:e0d882f4b54f0c65f203104c24ab8a38b039f1289986803c7d02cdbe214fbcc4", size = 721689, upload-time = "2022-10-04T23:57:43.247Z" } @@ -1070,16 +1165,53 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/41/55/55d157aa8693090954fc9639bf27218240517c3bc7afa6e97412da6ebfd9/gym_notices-0.1.0-py3-none-any.whl", hash = "sha256:a943af4446cb619d04fd1e470b9272b4473e08a06d1c7cc9005755a4a0b8c905", size = 3349, upload-time = "2025-07-27T10:12:40.039Z" }, ] +[[package]] +name = "gymnasium" +version = "0.29.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten'", + "sys_platform == 'emscripten'", +] +dependencies = [ + { name = "cloudpickle", marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "farama-notifications", marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "typing-extensions", marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0d/f8/5699ddb3e1c4f6d97b8930e573074849b921da8374fccd141f0f3a9bd713/gymnasium-0.29.1.tar.gz", hash = "sha256:1a532752efcb7590478b1cc7aa04f608eb7a2fdad5570cd217b66b6a35274bb1", size = 820485, upload-time = "2023-08-21T13:07:32.024Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a8/4d/3cbfd81ed84db450dbe73a89afcd8bc405273918415649ac6683356afe92/gymnasium-0.29.1-py3-none-any.whl", hash = "sha256:61c3384b5575985bb7f85e43213bcb40f36fcdff388cae6bc229304c71f2843e", size = 953939, upload-time = "2023-08-21T13:07:29.934Z" }, +] + +[package.optional-dependencies] +other = [ + { name = "lz4", marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "matplotlib", marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "moviepy", marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "opencv-python", version = "4.13.0.90", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "torch", version = "2.7.1", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, +] + [[package]] name = "gymnasium" version = "1.2.3" source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf'", + "sys_platform == 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf'", + "platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", + "platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", + "sys_platform == 'darwin' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", + "sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", + "sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", +] dependencies = [ - { name = "cloudpickle" }, - { name = "farama-notifications" }, - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero'" }, - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, - { name = "typing-extensions" }, + { name = "cloudpickle", marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, + { name = "farama-notifications", marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "typing-extensions", marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/76/59/653a9417d98ed3e29ef9734ba52c3495f6c6823b8d5c0c75369f25111708/gymnasium-1.2.3.tar.gz", hash = "sha256:2b2cb5b5fbbbdf3afb9f38ca952cc48aa6aa3e26561400d940747fda3ad42509", size = 829230, upload-time = "2025-12-18T16:51:10.234Z" } wheels = [ @@ -1088,11 +1220,11 @@ wheels = [ [package.optional-dependencies] other = [ - { name = "matplotlib" }, - { name = "moviepy" }, - { name = "opencv-python", version = "4.11.0.86", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero'" }, - { name = "opencv-python", version = "4.13.0.90", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, - { name = "seaborn" }, + { name = "matplotlib", marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, + { name = "moviepy", marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, + { name = "opencv-python", version = "4.11.0.86", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "opencv-python", version = "4.13.0.90", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "seaborn", marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, ] [[package]] @@ -1109,8 +1241,9 @@ name = "h5py" version = "3.15.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero'" }, - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/4d/6a/0d79de0b025aa85dc8864de8e97659c94cf3d23148394a954dc5ca52f8c8/h5py-3.15.1.tar.gz", hash = "sha256:c86e3ed45c4473564de55aa83b6fc9e5ead86578773dfbd93047380042e26b69", size = 426236, upload-time = "2025-10-16T10:35:27.404Z" } wheels = [ @@ -1159,6 +1292,24 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/cb/44/870d44b30e1dcfb6a65932e3e1506c103a8a5aea9103c337e7a53180322c/hf_xet-1.2.0-cp37-abi3-win_amd64.whl", hash = "sha256:e6584a52253f72c9f52f9e549d5895ca7a471608495c4ecaa6cc73dba2b24d69", size = 2905735, upload-time = "2025-10-24T19:04:35.928Z" }, ] +[[package]] +name = "hidapi" +version = "0.15.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/74/f6/caad9ed701fbb9223eb9e0b41a5514390769b4cb3084a2704ab69e9df0fe/hidapi-0.15.0.tar.gz", hash = "sha256:ecbc265cbe8b7b88755f421e0ba25f084091ec550c2b90ff9e8ddd4fcd540311", size = 184995, upload-time = "2025-12-09T09:48:54.129Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bd/5a/46620fc194f3fa728dce1966ce977334b080fc33b8b525018ad0e0324b91/hidapi-0.15.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b0e1781f7fb8b4015e318d839d66fa79e98900d53900e31d04edb336e0103846", size = 70517, upload-time = "2025-12-09T09:44:47.751Z" }, + { url = "https://files.pythonhosted.org/packages/2d/97/bcbcb89f9461c29d3b12dd32affd29e6312fd521154ee7f394496d0039a9/hidapi-0.15.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1fa3e792987d4b7ed66d785491307e23d4f09d3636f8a23665a9694c43e92409", size = 70181, upload-time = "2025-12-09T09:44:49.321Z" }, + { url = "https://files.pythonhosted.org/packages/cc/19/b9f1cd2bce226ed43afa7e7649caeee5552e7ea844e997521d747f0da184/hidapi-0.15.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:75c2d3b83a8300953653ddd7f5190d5ee6072d4a6ee5944db47e92d97344ed92", size = 1039531, upload-time = "2025-12-09T09:44:55.735Z" }, + { url = "https://files.pythonhosted.org/packages/3c/b9/5a6a1a4219ada2da251225c706d450076fd2b3d624000699ff4d329326ab/hidapi-0.15.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:91b43099b123363c8935a264acffb4c7e5c8dba3390f9b2bf19ff76597677a31", size = 1573936, upload-time = "2025-12-09T09:44:51.193Z" }, + { url = "https://files.pythonhosted.org/packages/42/7c/a2df1c993db58f9337d5ee64d3c58f5b9c5127f3ef68907d0c50070d1e50/hidapi-0.15.0-cp310-cp310-manylinux_2_28_i686.whl", hash = "sha256:cea09ccc3efa5b92ab18d3ae8636836edce2c421d67ed4409761da090e230e5a", size = 1654515, upload-time = "2025-12-09T09:44:54.166Z" }, + { url = "https://files.pythonhosted.org/packages/54/ca/341b3f5c713f72a7e61a942859b003a507f4a7d7cf5135a20da519bbcf05/hidapi-0.15.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:b2de66142cf780ee7c797b7c35e488d67bccdf2de98178ac12a4038c490c44ea", size = 669173, upload-time = "2025-12-09T09:44:57.545Z" }, + { url = "https://files.pythonhosted.org/packages/f8/55/e5922d48b59959820d976c8e232b14c1f57d65742e416831ce53fda32f6b/hidapi-0.15.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e283c3e9255850d66152adbf580744d38c840d399141b98d64d359cb97cbc128", size = 664906, upload-time = "2025-12-09T09:44:58.893Z" }, + { url = "https://files.pythonhosted.org/packages/50/b2/87683617901cbc5232a1d99cb8e51a967792aae48d462a8e2a842d63ec25/hidapi-0.15.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5b9f6d2f3bc15c718d8e2ce349d2d019a0fcc343ed1a705a91d0f1c7e792d6ea", size = 671123, upload-time = "2025-12-09T09:45:00.828Z" }, + { url = "https://files.pythonhosted.org/packages/26/cc/03f7d56b82a9dc2abcfcd8d55915504e156b6558fb66926629836e551595/hidapi-0.15.0-cp310-cp310-win32.whl", hash = "sha256:81de6b5fcb4fbbbfc71c6d201a2ac6914d1d86e51930ffde5f96faf50e922473", size = 60160, upload-time = "2025-12-09T09:45:04.472Z" }, + { url = "https://files.pythonhosted.org/packages/35/20/a39e33a9088d76f98f80d9320f8413bdaeaa0458b42470e63a47ac4ccf94/hidapi-0.15.0-cp310-cp310-win_amd64.whl", hash = "sha256:c36895abaef3a4004af6c5020ca214fcdacb2a491e4cde5576afbb1dad903548", size = 67063, upload-time = "2025-12-09T09:45:02.852Z" }, +] + [[package]] name = "hjson" version = "3.1.0" @@ -1202,8 +1353,9 @@ version = "0.36.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "filelock" }, - { name = "fsspec" }, - { name = "hf-xet", marker = "platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "fsspec", version = "2025.3.0", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "fsspec", version = "2025.10.0", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, + { name = "hf-xet", marker = "platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, { name = "packaging" }, { name = "pyyaml" }, { name = "requests" }, @@ -1228,7 +1380,7 @@ name = "humanfriendly" version = "10.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pyreadline3", marker = "sys_platform == 'win32' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "pyreadline3", marker = "sys_platform == 'win32' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/cc/3f/2c29224acb2e2df4d2046e4c73ee2662023c58ff5b113c4c1adac0886c43/humanfriendly-10.0.tar.gz", hash = "sha256:6b0b831ce8f15f7300721aa49829fc4e83921a9a301cc7f606be6686a2288ddc", size = 360702, upload-time = "2021-09-17T21:40:43.31Z" } wheels = [ @@ -1258,8 +1410,9 @@ name = "imageio" version = "2.37.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero'" }, - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, { name = "pillow" }, ] sdist = { url = "https://files.pythonhosted.org/packages/a3/6f/606be632e37bf8d05b253e8626c2291d74c691ddc7bcdf7d6aaf33b32f6a/imageio-2.37.2.tar.gz", hash = "sha256:0212ef2727ac9caa5ca4b2c75ae89454312f440a756fcfc8ef1993e718f50f8a", size = 389600, upload-time = "2025-11-04T14:29:39.898Z" } @@ -1496,6 +1649,39 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/83/60/d497a310bde3f01cb805196ac61b7ad6dc5dcf8dce66634dc34364b20b4f/lazy_loader-0.4-py3-none-any.whl", hash = "sha256:342aa8e14d543a154047afb4ba8ef17f5563baad3fc610d7b15b213b0f119efc", size = 12097, upload-time = "2024-04-05T13:03:10.514Z" }, ] +[[package]] +name = "lerobot" +version = "0.3.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "av" }, + { name = "cmake", version = "4.2.1", source = { registry = "https://pypi.org/simple" } }, + { name = "datasets", version = "3.6.0", source = { registry = "https://pypi.org/simple" } }, + { name = "deepdiff" }, + { name = "diffusers" }, + { name = "draccus" }, + { name = "einops" }, + { name = "flask" }, + { name = "gymnasium", version = "0.29.1", source = { registry = "https://pypi.org/simple" } }, + { name = "huggingface-hub", extra = ["cli", "hf-transfer"], marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "imageio", extra = ["ffmpeg"], marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "jsonlines" }, + { name = "opencv-python-headless", version = "4.13.0.90", source = { registry = "https://pypi.org/simple" } }, + { name = "packaging" }, + { name = "pynput" }, + { name = "pyserial" }, + { name = "rerun-sdk", version = "0.22.1", source = { registry = "https://pypi.org/simple" } }, + { name = "termcolor" }, + { name = "torch", version = "2.7.1", source = { registry = "https://pypi.org/simple" } }, + { name = "torchcodec", marker = "(platform_machine != 'aarch64' and platform_machine != 'arm64' and platform_machine != 'armv7l' and sys_platform == 'linux') or (platform_machine != 'x86_64' and sys_platform == 'darwin') or (sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32')" }, + { name = "torchvision", version = "0.22.1", source = { registry = "https://pypi.org/simple" } }, + { name = "wandb" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c7/01/45eb19324a80c8719e7bd98fc12c5dfb50da2b58c2404953f6d0112a6fc3/lerobot-0.3.3.tar.gz", hash = "sha256:5a8c526f4f50a5a4260b75f0382af26d01ef169c9a1ae8ca453ad5c6e1cf5aef", size = 450703, upload-time = "2025-08-06T18:41:35.689Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8e/be/3361a6417799062bbf7b7f6863900e3c1843eb7b21a5ffc5831fdfc7a3b3/lerobot-0.3.3-py3-none-any.whl", hash = "sha256:ae8354b516f5c8cfaa059d5ac926b4d03e96ca73350b971f8c7d75b905ba953d", size = 597692, upload-time = "2025-08-06T18:41:33.608Z" }, +] + [[package]] name = "libero" version = "0.1.0" @@ -1513,6 +1699,30 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b2/bc/4689e1ba0c073c196b594471eb21be0aa51d9e64b911728aa13cd85ef0ae/llvmlite-0.46.0-cp310-cp310-win_amd64.whl", hash = "sha256:e7a34d4aa6f9a97ee006b504be6d2b8cb7f755b80ab2f344dda1ef992f828559", size = 38138651, upload-time = "2025-12-08T18:14:45.845Z" }, ] +[[package]] +name = "lxml" +version = "6.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/28/30/9abc9e34c657c33834eaf6cd02124c61bdf5944d802aa48e69be8da3585d/lxml-6.1.0.tar.gz", hash = "sha256:bfd57d8008c4965709a919c3e9a98f76c2c7cb319086b3d26858250620023b13", size = 4197006, upload-time = "2026-04-18T04:32:51.613Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/02/6e/ee8fc0e01202eb3dd2b9e1ea4f0910d72425d35c66187c63931d7a3ea73f/lxml-6.1.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:41dcc4c7b10484257cbd6c37b83ddb26df2b0e5aff5ac00d095689015af868ec", size = 8540733, upload-time = "2026-04-18T04:27:33.185Z" }, + { url = "https://files.pythonhosted.org/packages/54/e8/325fe9b942824c773dffe1baf0c35b046a763851fdff4393af4450bceeb7/lxml-6.1.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:a31286dbb5e74c8e9a5344465b77ab4c5bd511a253b355b5ca2fae7e579fafec", size = 4602805, upload-time = "2026-04-18T04:27:36.097Z" }, + { url = "https://files.pythonhosted.org/packages/2d/81/221aa3ea4a40370bb0358fa454cbe7e5a837e522f7630c24dfef3f9a73b0/lxml-6.1.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:1bc4cc83fb7f66ffb16f74d6dd0162e144333fc36ebcce32246f80c8735b2551", size = 5002652, upload-time = "2026-04-18T04:27:30.603Z" }, + { url = "https://files.pythonhosted.org/packages/c6/e1/fdbfb9019542f1875c093576df7f37adc2983c8ba7ecf17e5f14490bc107/lxml-6.1.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:20cf4d0651987c906a2f5cba4e3a8d6ba4bfdf973cfe2a96c0d6053888ea2ecd", size = 5155332, upload-time = "2026-04-18T04:27:33.507Z" }, + { url = "https://files.pythonhosted.org/packages/56/b1/4087c782fff397cd03abf9c551069be59bb04a7e548c50fb7b9c4cdaca28/lxml-6.1.0-cp310-cp310-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ffb34ea45a82dd637c2c97ae1bbb920850c1e59bcae79ce1c15af531d83e7215", size = 5057226, upload-time = "2026-04-18T04:27:37.567Z" }, + { url = "https://files.pythonhosted.org/packages/5d/66/516c79dec8417f3a972327330254c0b5fac93d5c3ecfd8a5b43650a5a4d9/lxml-6.1.0-cp310-cp310-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a1d9b99e5b2597e4f5aed2484fef835256fa1b68a19e4265c97628ef4bf8bcf4", size = 5287588, upload-time = "2026-04-18T04:27:41.4Z" }, + { url = "https://files.pythonhosted.org/packages/94/1d/e578f4cbeb42b9df9f29b0d44a45a7cdfa3a5ae300dd59ec68e3602d29bb/lxml-6.1.0-cp310-cp310-manylinux_2_28_i686.whl", hash = "sha256:d43aa26dcda363f21e79afa0668f5029ed7394b3bb8c92a6927a3d34e8b610ea", size = 5412438, upload-time = "2026-04-18T04:27:45.589Z" }, + { url = "https://files.pythonhosted.org/packages/47/5b/2aa68307d6d15959e84d4882f9c04f2da63127eac463e1594166f681ef77/lxml-6.1.0-cp310-cp310-manylinux_2_31_armv7l.whl", hash = "sha256:6262b87f9e5c1e5fe501d6c153247289af42eb44ad7660b9b3de17baaf92d6f6", size = 4770997, upload-time = "2026-04-18T04:27:49.853Z" }, + { url = "https://files.pythonhosted.org/packages/ae/c9/3e51fc1228310a836b4eb32595ae00154ab12197fca944676a3ab3b163ea/lxml-6.1.0-cp310-cp310-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d1392c569c032f78a11a25d1de1c43fff13294c793b39e19d84fade3045cbbc3", size = 5359678, upload-time = "2026-04-18T04:31:56.184Z" }, + { url = "https://files.pythonhosted.org/packages/b5/91/ab8bc834f977fbbd310e697b120787c153db026f9151e02a88d2645d4e5b/lxml-6.1.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:045e387d1f4f42a418380930fa3f45c73c9b392faf67e495e58902e68e8f44a7", size = 5107890, upload-time = "2026-04-18T04:32:00.387Z" }, + { url = "https://files.pythonhosted.org/packages/bb/10/8a143cfa3ac99cb5b0523ff6d0429a9c9dddf25ffeae09caa3866c7964d9/lxml-6.1.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:9f93d5b8b07f73e8c77e3c6556a3db269918390c804b5e5fcdd4858232cc8f16", size = 4803977, upload-time = "2026-04-18T04:32:05.099Z" }, + { url = "https://files.pythonhosted.org/packages/45/fd/ee02faf52fa39c2fe32f824628958b9aa86dff21343dc3161f0e3c6ccd15/lxml-6.1.0-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:de550d129f18d8ab819651ffe4f38b1b713c7e116707de3c0c6400d0ef34fbc1", size = 5350277, upload-time = "2026-04-18T04:32:09.176Z" }, + { url = "https://files.pythonhosted.org/packages/85/8c/b3481364b8554b5d36d540189a87fc71e94b0b01c24f8f152bd662dd2e45/lxml-6.1.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:c08da09dc003c9e8c70e06b53a11db6fb3b250c21c4236b03c7d7b443c318e7a", size = 5309717, upload-time = "2026-04-18T04:32:13.303Z" }, + { url = "https://files.pythonhosted.org/packages/74/e8/a6b21927077a9127afa17473b6576b322616f34ac50ee4f577e763b75ec0/lxml-6.1.0-cp310-cp310-win32.whl", hash = "sha256:37448bf9c7d7adfc5254763901e2bbd6bb876228dfc1fc7f66e58c06368a7544", size = 3598491, upload-time = "2026-04-18T04:27:24.288Z" }, + { url = "https://files.pythonhosted.org/packages/ea/82/14dea800d041274d96c07d49ff9191f011d1427450850de19bf541e2cc12/lxml-6.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:2593a0a6621545b9095b71ad74ed4226eba438a7d9fc3712a99bdb15508cf93a", size = 4020906, upload-time = "2026-04-18T04:27:27.53Z" }, + { url = "https://files.pythonhosted.org/packages/f2/ba/d3539aaf4d9d21456b9a7b902816623227d05d63e7c5aafd8834c4b9bed6/lxml-6.1.0-cp310-cp310-win_arm64.whl", hash = "sha256:e80807d72f96b96ad5588cb85c75616e4f2795a7737d4630784c51497beb7776", size = 3667787, upload-time = "2026-04-18T04:27:29.407Z" }, +] + [[package]] name = "lz4" version = "4.4.5" @@ -1578,8 +1788,9 @@ dependencies = [ { name = "cycler" }, { name = "fonttools" }, { name = "kiwisolver" }, - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero'" }, - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, { name = "packaging" }, { name = "pillow" }, { name = "pyparsing" }, @@ -1627,10 +1838,11 @@ dependencies = [ { name = "absl-py" }, { name = "flatbuffers" }, { name = "matplotlib" }, - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero'" }, - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, - { name = "opencv-contrib-python", version = "4.11.0.86", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero'" }, - { name = "opencv-contrib-python", version = "4.13.0.92", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "opencv-contrib-python", version = "4.11.0.86", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "opencv-contrib-python", version = "4.13.0.92", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, { name = "sounddevice" }, ] wheels = [ @@ -1653,8 +1865,9 @@ name = "ml-dtypes" version = "0.5.4" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero'" }, - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, ] 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 = [ @@ -1672,8 +1885,9 @@ dependencies = [ { name = "decorator" }, { name = "imageio" }, { name = "imageio-ffmpeg" }, - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero'" }, - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, { name = "pillow" }, { name = "proglog" }, { name = "python-dotenv" }, @@ -1708,13 +1922,44 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/d0/3e/b4547e3a34210956382eed1c85935fff7e0f9b98be3106b3745d7dec9c5e/msgpack-1.1.2-cp310-cp310-win_amd64.whl", hash = "sha256:db6192777d943bdaaafb6ba66d44bf65aa0e9c5616fa1d2da9bb08828c6b39aa", size = 71293, upload-time = "2025-10-08T09:14:48.665Z" }, ] +[[package]] +name = "mujoco" +version = "3.3.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten'", + "sys_platform == 'emscripten'", +] +dependencies = [ + { name = "absl-py" }, + { name = "etils", extra = ["epath"], marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "glfw" }, + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" } }, + { name = "pyopengl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6e/02/0584ef8505758e97220953cb60961514e4877de6cb8af3fc5f449e72f8f8/mujoco-3.3.1.tar.gz", hash = "sha256:5214a35c1567822c0c8b80e8657ebe28726bcb94e78bd53283ff917d2d881028", size = 805530, upload-time = "2025-04-10T16:45:01.598Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/98/67/4530d1808b4fc510b4f1c85814e14cccb8e34001c4f3630b1de45852303d/mujoco-3.3.1-cp310-cp310-macosx_10_16_x86_64.whl", hash = "sha256:893f81a17bd4ebaefbc69cfc21fc766a28427260f4e4f1be128a8f93029bdcd5", size = 6546522, upload-time = "2025-04-10T16:43:16.715Z" }, + { url = "https://files.pythonhosted.org/packages/22/40/cb7aabb70275f7c53d8678943dc0474e0da8602bb7d7651604088751477a/mujoco-3.3.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:acdf62c14890a0081a62c2adcbdb55a398cf08c8a53d767259e203d4c6b52174", size = 6569862, upload-time = "2025-04-10T16:43:20.616Z" }, + { url = "https://files.pythonhosted.org/packages/fa/c4/25bd16073f6af624079a4e6807d435db441474c475a47e0bd5f5e3f1d9ca/mujoco-3.3.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c34c48cb95c8a1687cf187a595deb73ce87babc09768e2ae4b22a2ff67dc2206", size = 6303029, upload-time = "2025-04-10T16:43:25.113Z" }, + { url = "https://files.pythonhosted.org/packages/ff/e3/b971670848fccdfee38efbfb802cc76e3d5fc2ad3bc03d42f77b79bcdaf7/mujoco-3.3.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cfa05a01b2bded5d6a32c8ea97ef9e4995c1791a9d7a485112ff74fc5aee2e9d", size = 6593681, upload-time = "2025-04-10T16:43:28.669Z" }, + { url = "https://files.pythonhosted.org/packages/c7/de/e62e6069768641d2067fc8cb9d5b7b4212a0cd48219c817c12775540408c/mujoco-3.3.1-cp310-cp310-win_amd64.whl", hash = "sha256:a044081c6cbebbebe37f0fda599cff3ece5bc6e0072510fc05b78a74bd8fdcf6", size = 4916425, upload-time = "2025-04-10T16:43:31.642Z" }, +] + [[package]] name = "mujoco" version = "3.4.0" source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "platform_machine == 'aarch64' and sys_platform == 'linux'", + "platform_machine != 'aarch64' and sys_platform == 'linux'", + "sys_platform == 'darwin'", + "sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux'", + "sys_platform == 'emscripten'", +] dependencies = [ { name = "absl-py" }, - { name = "etils", extra = ["epath"], marker = "extra == 'extra-7-opentau-libero'" }, + { name = "etils", extra = ["epath"], marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, { name = "glfw" }, { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" } }, { name = "pyopengl" }, @@ -1758,12 +2003,41 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/81/08/7036c080d7117f28a4af526d794aab6a84463126db031b007717c1a6676e/multidict-6.7.1-py3-none-any.whl", hash = "sha256:55d97cc6dae627efa6a6e548885712d4864b81110ac76fa4e534c03819fa4a56", size = 12319, upload-time = "2026-01-26T02:46:44.004Z" }, ] +[[package]] +name = "multiprocess" +version = "0.70.16" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten'", + "sys_platform == 'emscripten'", +] +dependencies = [ + { name = "dill", version = "0.3.8", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b5/ae/04f39c5d0d0def03247c2893d6f2b83c136bf3320a2154d7b8858f2ba72d/multiprocess-0.70.16.tar.gz", hash = "sha256:161af703d4652a0e1410be6abccecde4a7ddffd19341be0a7011b94aeb171ac1", size = 1772603, upload-time = "2024-01-28T18:52:34.85Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ef/76/6e712a2623d146d314f17598df5de7224c85c0060ef63fd95cc15a25b3fa/multiprocess-0.70.16-pp310-pypy310_pp73-macosx_10_13_x86_64.whl", hash = "sha256:476887be10e2f59ff183c006af746cb6f1fd0eadcfd4ef49e605cbe2659920ee", size = 134980, upload-time = "2024-01-28T18:52:15.731Z" }, + { url = "https://files.pythonhosted.org/packages/0f/ab/1e6e8009e380e22254ff539ebe117861e5bdb3bff1fc977920972237c6c7/multiprocess-0.70.16-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:d951bed82c8f73929ac82c61f01a7b5ce8f3e5ef40f5b52553b4f547ce2b08ec", size = 134982, upload-time = "2024-01-28T18:52:17.783Z" }, + { url = "https://files.pythonhosted.org/packages/bc/f7/7ec7fddc92e50714ea3745631f79bd9c96424cb2702632521028e57d3a36/multiprocess-0.70.16-py310-none-any.whl", hash = "sha256:c4a9944c67bd49f823687463660a2d6daae94c289adff97e0f9d696ba6371d02", size = 134824, upload-time = "2024-01-28T18:52:26.062Z" }, + { url = "https://files.pythonhosted.org/packages/ea/89/38df130f2c799090c978b366cfdf5b96d08de5b29a4a293df7f7429fa50b/multiprocess-0.70.16-py38-none-any.whl", hash = "sha256:a71d82033454891091a226dfc319d0cfa8019a4e888ef9ca910372a446de4435", size = 132628, upload-time = "2024-01-28T18:52:30.853Z" }, + { url = "https://files.pythonhosted.org/packages/da/d9/f7f9379981e39b8c2511c9e0326d212accacb82f12fbfdc1aa2ce2a7b2b6/multiprocess-0.70.16-py39-none-any.whl", hash = "sha256:a0bafd3ae1b732eac64be2e72038231c1ba97724b60b09400d68f229fcc2fbf3", size = 133351, upload-time = "2024-01-28T18:52:31.981Z" }, +] + [[package]] name = "multiprocess" version = "0.70.18" source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf'", + "sys_platform == 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf'", + "platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", + "platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", + "sys_platform == 'darwin' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", + "sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", + "sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", +] dependencies = [ - { name = "dill" }, + { name = "dill", version = "0.4.0", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, ] 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 = [ @@ -1866,8 +2140,9 @@ version = "0.63.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "llvmlite" }, - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero'" }, - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/dc/60/0145d479b2209bd8fdae5f44201eceb8ce5a23e0ed54c71f57db24618665/numba-0.63.1.tar.gz", hash = "sha256:b320aa675d0e3b17b40364935ea52a7b1c670c9037c39cf92c49502a75902f4b", size = 2761666, upload-time = "2025-12-10T02:57:39.002Z" } wheels = [ @@ -1882,8 +2157,9 @@ name = "numcodecs" version = "0.13.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero'" }, - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/85/56/8895a76abe4ec94ebd01eeb6d74f587bc4cddd46569670e1402852a5da13/numcodecs-0.13.1.tar.gz", hash = "sha256:a3cf37881df0898f3a9c0d4477df88133fe85185bffe57ba31bcc2fa207709bc", size = 5955215, upload-time = "2024-10-09T16:28:00.188Z" } wheels = [ @@ -1899,11 +2175,9 @@ version = "1.26.4" source = { registry = "https://pypi.org/simple" } resolution-markers = [ "platform_machine == 'aarch64' and sys_platform == 'linux'", - "platform_machine == 'x86_64' and sys_platform == 'linux'", - "platform_machine != 'aarch64' and platform_machine != 'x86_64' and sys_platform == 'linux'", + "platform_machine != 'aarch64' and sys_platform == 'linux'", "sys_platform == 'darwin'", - "(platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'x86_64' and sys_platform == 'win32')", - "(platform_machine != 'AMD64' and platform_machine != 'x86_64' and sys_platform == 'win32') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')", + "sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux'", "sys_platform == 'emscripten'", ] sdist = { url = "https://files.pythonhosted.org/packages/65/6e/09db70a523a96d25e115e71cc56a6f9031e7b8cd166c1ac8438307c14058/numpy-1.26.4.tar.gz", hash = "sha256:2a02aba9ed12e4ac4eb3ea9421c420301a0c6460d9830d74a9df87efa4912010", size = 15786129, upload-time = "2024-02-06T00:26:44.495Z" } @@ -1918,15 +2192,38 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/19/77/538f202862b9183f54108557bfda67e17603fc560c384559e769321c9d92/numpy-1.26.4-cp310-cp310-win_amd64.whl", hash = "sha256:b97fe8060236edf3662adfc2c633f56a08ae30560c56310562cb4f95500022d5", size = 15808905, upload-time = "2024-02-05T23:51:03.701Z" }, ] +[[package]] +name = "numpy" +version = "2.2.5" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten'", + "sys_platform == 'emscripten'", +] +sdist = { url = "https://files.pythonhosted.org/packages/dc/b2/ce4b867d8cd9c0ee84938ae1e6a6f7926ebf928c9090d036fc3c6a04f946/numpy-2.2.5.tar.gz", hash = "sha256:a9c0d994680cd991b1cb772e8b297340085466a6fe964bc9d4e80f5e2f43c291", size = 20273920, upload-time = "2025-04-19T23:27:42.561Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ef/4e/3d9e6d16237c2aa5485695f0626cbba82f6481efca2e9132368dea3b885e/numpy-2.2.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:1f4a922da1729f4c40932b2af4fe84909c7a6e167e6e99f71838ce3a29f3fe26", size = 21252117, upload-time = "2025-04-19T22:31:01.142Z" }, + { url = "https://files.pythonhosted.org/packages/38/e4/db91349d4079cd15c02ff3b4b8882a529991d6aca077db198a2f2a670406/numpy-2.2.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:b6f91524d31b34f4a5fee24f5bc16dcd1491b668798b6d85585d836c1e633a6a", size = 14424615, upload-time = "2025-04-19T22:31:24.873Z" }, + { url = "https://files.pythonhosted.org/packages/f8/59/6e5b011f553c37b008bd115c7ba7106a18f372588fbb1b430b7a5d2c41ce/numpy-2.2.5-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:19f4718c9012e3baea91a7dba661dcab2451cda2550678dc30d53acb91a7290f", size = 5428691, upload-time = "2025-04-19T22:31:33.998Z" }, + { url = "https://files.pythonhosted.org/packages/a2/58/d5d70ebdac82b3a6ddf409b3749ca5786636e50fd64d60edb46442af6838/numpy-2.2.5-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:eb7fd5b184e5d277afa9ec0ad5e4eb562ecff541e7f60e69ee69c8d59e9aeaba", size = 6965010, upload-time = "2025-04-19T22:31:45.281Z" }, + { url = "https://files.pythonhosted.org/packages/dc/a8/c290394be346d4e7b48a40baf292626fd96ec56a6398ace4c25d9079bc6a/numpy-2.2.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6413d48a9be53e183eb06495d8e3b006ef8f87c324af68241bbe7a39e8ff54c3", size = 14369885, upload-time = "2025-04-19T22:32:06.557Z" }, + { url = "https://files.pythonhosted.org/packages/c2/70/fed13c70aabe7049368553e81d7ca40f305f305800a007a956d7cd2e5476/numpy-2.2.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7451f92eddf8503c9b8aa4fe6aa7e87fd51a29c2cfc5f7dbd72efde6c65acf57", size = 16418372, upload-time = "2025-04-19T22:32:31.716Z" }, + { url = "https://files.pythonhosted.org/packages/04/ab/c3c14f25ddaecd6fc58a34858f6a93a21eea6c266ba162fa99f3d0de12ac/numpy-2.2.5-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:0bcb1d057b7571334139129b7f941588f69ce7c4ed15a9d6162b2ea54ded700c", size = 15883173, upload-time = "2025-04-19T22:32:55.106Z" }, + { url = "https://files.pythonhosted.org/packages/50/18/f53710a19042911c7aca824afe97c203728a34b8cf123e2d94621a12edc3/numpy-2.2.5-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:36ab5b23915887543441efd0417e6a3baa08634308894316f446027611b53bf1", size = 18206881, upload-time = "2025-04-19T22:33:22.08Z" }, + { url = "https://files.pythonhosted.org/packages/6b/ec/5b407bab82f10c65af5a5fe754728df03f960fd44d27c036b61f7b3ef255/numpy-2.2.5-cp310-cp310-win32.whl", hash = "sha256:422cc684f17bc963da5f59a31530b3936f57c95a29743056ef7a7903a5dbdf88", size = 6609852, upload-time = "2025-04-19T22:33:33.357Z" }, + { url = "https://files.pythonhosted.org/packages/b6/f5/467ca8675c7e6c567f571d8db942cc10a87588bd9e20a909d8af4171edda/numpy-2.2.5-cp310-cp310-win_amd64.whl", hash = "sha256:e4f0b035d9d0ed519c813ee23e0a733db81ec37d2e9503afbb6e54ccfdee0fa7", size = 12944922, upload-time = "2025-04-19T22:33:53.192Z" }, + { url = "https://files.pythonhosted.org/packages/35/e4/5ef5ef1d4308f96961198b2323bfc7c7afb0ccc0d623b01c79bc87ab496d/numpy-2.2.5-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:b4ea7e1cff6784e58fe281ce7e7f05036b3e1c89c6f922a6bfbc0a7e8768adbe", size = 21083404, upload-time = "2025-04-19T22:48:01.605Z" }, + { url = "https://files.pythonhosted.org/packages/a3/5f/bde9238e8e977652a16a4b114ed8aa8bb093d718c706eeecb5f7bfa59572/numpy-2.2.5-pp310-pypy310_pp73-macosx_14_0_x86_64.whl", hash = "sha256:d7543263084a85fbc09c704b515395398d31d6395518446237eac219eab9e55e", size = 6828578, upload-time = "2025-04-19T22:48:13.118Z" }, + { url = "https://files.pythonhosted.org/packages/ef/7f/813f51ed86e559ab2afb6a6f33aa6baf8a560097e25e4882a938986c76c2/numpy-2.2.5-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0255732338c4fdd00996c0421884ea8a3651eea555c3a56b84892b66f696eb70", size = 16234796, upload-time = "2025-04-19T22:48:37.102Z" }, + { url = "https://files.pythonhosted.org/packages/68/67/1175790323026d3337cc285cc9c50eca637d70472b5e622529df74bb8f37/numpy-2.2.5-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:d2e3bdadaba0e040d1e7ab39db73e0afe2c74ae277f5614dad53eadbecbbb169", size = 12859001, upload-time = "2025-04-19T22:48:57.665Z" }, +] + [[package]] name = "numpy" version = "2.2.6" source = { registry = "https://pypi.org/simple" } resolution-markers = [ - "platform_machine == 'x86_64' and sys_platform == 'linux'", - "platform_machine != 'x86_64' and sys_platform == 'linux'", - "(platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'x86_64' and sys_platform == 'win32')", - "(platform_machine != 'AMD64' and platform_machine != 'x86_64' and sys_platform == 'win32') or (sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')", + "sys_platform != 'emscripten'", "sys_platform == 'emscripten'", ] sdist = { url = "https://files.pythonhosted.org/packages/76/21/7d2a95e4bba9dc13d043ee156a356c0a8f0c6309dff6b21b4d71a073b8a8/numpy-2.2.6.tar.gz", hash = "sha256:e29554e2bef54a90aa5cc07da6ce955accb83f21ab5de01a62c8478897b264fd", size = 20276440, upload-time = "2025-05-17T22:38:04.611Z" } @@ -1947,52 +2244,144 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/37/48/ac2a9584402fb6c0cd5b5d1a91dcf176b15760130dd386bbafdbfe3640bf/numpy-2.2.6-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:d042d24c90c41b54fd506da306759e06e568864df8ec17ccc17e9e884634fd00", size = 12812666, upload-time = "2025-05-17T21:45:31.426Z" }, ] +[[package]] +name = "nvidia-cublas-cu12" +version = "12.6.4.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten'", +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/af/eb/ff4b8c503fa1f1796679dce648854d58751982426e4e4b37d6fce49d259c/nvidia_cublas_cu12-12.6.4.1-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:08ed2686e9875d01b58e3cb379c6896df8e76c75e0d4a7f7dace3d7b6d9ef8eb", size = 393138322, upload-time = "2024-11-20T17:40:25.65Z" }, + { url = "https://files.pythonhosted.org/packages/97/0d/f1f0cadbf69d5b9ef2e4f744c9466cb0a850741d08350736dfdb4aa89569/nvidia_cublas_cu12-12.6.4.1-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:235f728d6e2a409eddf1df58d5b0921cf80cfa9e72b9f2775ccb7b4a87984668", size = 390794615, upload-time = "2024-11-20T17:39:52.715Z" }, + { url = "https://files.pythonhosted.org/packages/84/f7/985e9bdbe3e0ac9298fcc8cfa51a392862a46a0ffaccbbd56939b62a9c83/nvidia_cublas_cu12-12.6.4.1-py3-none-win_amd64.whl", hash = "sha256:9e4fa264f4d8a4eb0cdbd34beadc029f453b3bafae02401e999cf3d5a5af75f8", size = 434535301, upload-time = "2024-11-20T17:50:41.681Z" }, +] + [[package]] name = "nvidia-cublas-cu12" version = "12.8.4.1" source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf'", + "platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", +] wheels = [ { url = "https://files.pythonhosted.org/packages/29/99/db44d685f0e257ff0e213ade1964fc459b4a690a73293220e98feb3307cf/nvidia_cublas_cu12-12.8.4.1-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:b86f6dd8935884615a0683b663891d43781b819ac4f2ba2b0c9604676af346d0", size = 590537124, upload-time = "2025-03-07T01:43:53.556Z" }, { url = "https://files.pythonhosted.org/packages/dc/61/e24b560ab2e2eaeb3c839129175fb330dfcfc29e5203196e5541a4c44682/nvidia_cublas_cu12-12.8.4.1-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:8ac4e771d5a348c551b2a426eda6193c19aa630236b418086020df5ba9667142", size = 594346921, upload-time = "2025-03-07T01:44:31.254Z" }, { url = "https://files.pythonhosted.org/packages/70/61/7d7b3c70186fb651d0fbd35b01dbfc8e755f69fd58f817f3d0f642df20c3/nvidia_cublas_cu12-12.8.4.1-py3-none-win_amd64.whl", hash = "sha256:47e9b82132fa8d2b4944e708049229601448aaad7e6f296f630f2d1a32de35af", size = 567544208, upload-time = "2025-03-07T01:53:30.535Z" }, ] +[[package]] +name = "nvidia-cuda-cupti-cu12" +version = "12.6.80" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten'", +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/e6/8b/2f6230cb715646c3a9425636e513227ce5c93c4d65823a734f4bb86d43c3/nvidia_cuda_cupti_cu12-12.6.80-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:166ee35a3ff1587f2490364f90eeeb8da06cd867bd5b701bf7f9a02b78bc63fc", size = 8236764, upload-time = "2024-11-20T17:35:41.03Z" }, + { url = "https://files.pythonhosted.org/packages/25/0f/acb326ac8fd26e13c799e0b4f3b2751543e1834f04d62e729485872198d4/nvidia_cuda_cupti_cu12-12.6.80-py3-none-manylinux2014_aarch64.whl", hash = "sha256:358b4a1d35370353d52e12f0a7d1769fc01ff74a191689d3870b2123156184c4", size = 8236756, upload-time = "2024-10-01T16:57:45.507Z" }, + { url = "https://files.pythonhosted.org/packages/49/60/7b6497946d74bcf1de852a21824d63baad12cd417db4195fc1bfe59db953/nvidia_cuda_cupti_cu12-12.6.80-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6768bad6cab4f19e8292125e5f1ac8aa7d1718704012a0e3272a6f61c4bce132", size = 8917980, upload-time = "2024-11-20T17:36:04.019Z" }, + { url = "https://files.pythonhosted.org/packages/a5/24/120ee57b218d9952c379d1e026c4479c9ece9997a4fb46303611ee48f038/nvidia_cuda_cupti_cu12-12.6.80-py3-none-manylinux2014_x86_64.whl", hash = "sha256:a3eff6cdfcc6a4c35db968a06fcadb061cbc7d6dde548609a941ff8701b98b73", size = 8917972, upload-time = "2024-10-01T16:58:06.036Z" }, + { url = "https://files.pythonhosted.org/packages/1c/81/7796f096afaf726796b1b648f3bc80cafc61fe7f77f44a483c89e6c5ef34/nvidia_cuda_cupti_cu12-12.6.80-py3-none-win_amd64.whl", hash = "sha256:bbe6ae76e83ce5251b56e8c8e61a964f757175682bbad058b170b136266ab00a", size = 5724175, upload-time = "2024-10-01T17:09:47.955Z" }, +] + [[package]] name = "nvidia-cuda-cupti-cu12" version = "12.8.90" source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf'", + "platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", +] wheels = [ { url = "https://files.pythonhosted.org/packages/d5/1f/b3bd73445e5cb342727fd24fe1f7b748f690b460acadc27ea22f904502c8/nvidia_cuda_cupti_cu12-12.8.90-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:4412396548808ddfed3f17a467b104ba7751e6b58678a4b840675c56d21cf7ed", size = 9533318, upload-time = "2025-03-07T01:40:10.421Z" }, { url = "https://files.pythonhosted.org/packages/f8/02/2adcaa145158bf1a8295d83591d22e4103dbfd821bcaf6f3f53151ca4ffa/nvidia_cuda_cupti_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ea0cb07ebda26bb9b29ba82cda34849e73c166c18162d3913575b0c9db9a6182", size = 10248621, upload-time = "2025-03-07T01:40:21.213Z" }, { url = "https://files.pythonhosted.org/packages/41/bc/83f5426095d93694ae39fe1311431b5d5a9bb82e48bf0dd8e19be2765942/nvidia_cuda_cupti_cu12-12.8.90-py3-none-win_amd64.whl", hash = "sha256:bb479dcdf7e6d4f8b0b01b115260399bf34154a1a2e9fe11c85c517d87efd98e", size = 7015759, upload-time = "2025-03-07T01:51:11.355Z" }, ] +[[package]] +name = "nvidia-cuda-nvrtc-cu12" +version = "12.6.77" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten'", +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/2f/72df534873235983cc0a5371c3661bebef7c4682760c275590b972c7b0f9/nvidia_cuda_nvrtc_cu12-12.6.77-py3-none-manylinux2014_aarch64.whl", hash = "sha256:5847f1d6e5b757f1d2b3991a01082a44aad6f10ab3c5c0213fa3e25bddc25a13", size = 23162955, upload-time = "2024-10-01T16:59:50.922Z" }, + { url = "https://files.pythonhosted.org/packages/75/2e/46030320b5a80661e88039f59060d1790298b4718944a65a7f2aeda3d9e9/nvidia_cuda_nvrtc_cu12-12.6.77-py3-none-manylinux2014_x86_64.whl", hash = "sha256:35b0cc6ee3a9636d5409133e79273ce1f3fd087abb0532d2d2e8fff1fe9efc53", size = 23650380, upload-time = "2024-10-01T17:00:14.643Z" }, + { url = "https://files.pythonhosted.org/packages/f5/46/d3a1cdda8bb113c80f43a0a6f3a853356d487b830f3483f92d49ce87fa55/nvidia_cuda_nvrtc_cu12-12.6.77-py3-none-win_amd64.whl", hash = "sha256:f7007dbd914c56bd80ea31bc43e8e149da38f68158f423ba845fc3292684e45a", size = 39026742, upload-time = "2024-10-01T17:10:49.058Z" }, +] + [[package]] name = "nvidia-cuda-nvrtc-cu12" version = "12.8.93" source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf'", + "platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", +] wheels = [ { url = "https://files.pythonhosted.org/packages/05/6b/32f747947df2da6994e999492ab306a903659555dddc0fbdeb9d71f75e52/nvidia_cuda_nvrtc_cu12-12.8.93-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:a7756528852ef889772a84c6cd89d41dfa74667e24cca16bb31f8f061e3e9994", size = 88040029, upload-time = "2025-03-07T01:42:13.562Z" }, { url = "https://files.pythonhosted.org/packages/eb/d1/e50d0acaab360482034b84b6e27ee83c6738f7d32182b987f9c7a4e32962/nvidia_cuda_nvrtc_cu12-12.8.93-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:fc1fec1e1637854b4c0a65fb9a8346b51dd9ee69e61ebaccc82058441f15bce8", size = 43106076, upload-time = "2025-03-07T01:41:59.817Z" }, { url = "https://files.pythonhosted.org/packages/45/51/52a3d84baa2136cc8df15500ad731d74d3a1114d4c123e043cb608d4a32b/nvidia_cuda_nvrtc_cu12-12.8.93-py3-none-win_amd64.whl", hash = "sha256:7a4b6b2904850fe78e0bd179c4b655c404d4bb799ef03ddc60804247099ae909", size = 73586838, upload-time = "2025-03-07T01:52:13.483Z" }, ] +[[package]] +name = "nvidia-cuda-runtime-cu12" +version = "12.6.77" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten'", +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/8f/ea/590b2ac00d772a8abd1c387a92b46486d2679ca6622fd25c18ff76265663/nvidia_cuda_runtime_cu12-12.6.77-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:6116fad3e049e04791c0256a9778c16237837c08b27ed8c8401e2e45de8d60cd", size = 908052, upload-time = "2024-11-20T17:35:19.905Z" }, + { url = "https://files.pythonhosted.org/packages/b7/3d/159023799677126e20c8fd580cca09eeb28d5c5a624adc7f793b9aa8bbfa/nvidia_cuda_runtime_cu12-12.6.77-py3-none-manylinux2014_aarch64.whl", hash = "sha256:d461264ecb429c84c8879a7153499ddc7b19b5f8d84c204307491989a365588e", size = 908040, upload-time = "2024-10-01T16:57:22.221Z" }, + { url = "https://files.pythonhosted.org/packages/e1/23/e717c5ac26d26cf39a27fbc076240fad2e3b817e5889d671b67f4f9f49c5/nvidia_cuda_runtime_cu12-12.6.77-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ba3b56a4f896141e25e19ab287cd71e52a6a0f4b29d0d31609f60e3b4d5219b7", size = 897690, upload-time = "2024-11-20T17:35:30.697Z" }, + { url = "https://files.pythonhosted.org/packages/f0/62/65c05e161eeddbafeca24dc461f47de550d9fa8a7e04eb213e32b55cfd99/nvidia_cuda_runtime_cu12-12.6.77-py3-none-manylinux2014_x86_64.whl", hash = "sha256:a84d15d5e1da416dd4774cb42edf5e954a3e60cc945698dc1d5be02321c44dc8", size = 897678, upload-time = "2024-10-01T16:57:33.821Z" }, + { url = "https://files.pythonhosted.org/packages/fa/76/4c80fa138333cc975743fd0687a745fccb30d167f906f13c1c7f9a85e5ea/nvidia_cuda_runtime_cu12-12.6.77-py3-none-win_amd64.whl", hash = "sha256:86c58044c824bf3c173c49a2dbc7a6c8b53cb4e4dca50068be0bf64e9dab3f7f", size = 891773, upload-time = "2024-10-01T17:09:26.362Z" }, +] + [[package]] name = "nvidia-cuda-runtime-cu12" version = "12.8.90" source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf'", + "platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", +] wheels = [ { url = "https://files.pythonhosted.org/packages/7c/75/f865a3b236e4647605ea34cc450900854ba123834a5f1598e160b9530c3a/nvidia_cuda_runtime_cu12-12.8.90-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:52bf7bbee900262ffefe5e9d5a2a69a30d97e2bc5bb6cc866688caa976966e3d", size = 965265, upload-time = "2025-03-07T01:39:43.533Z" }, { url = "https://files.pythonhosted.org/packages/0d/9b/a997b638fcd068ad6e4d53b8551a7d30fe8b404d6f1804abf1df69838932/nvidia_cuda_runtime_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:adade8dcbd0edf427b7204d480d6066d33902cab2a4707dcfc48a2d0fd44ab90", size = 954765, upload-time = "2025-03-07T01:40:01.615Z" }, { url = "https://files.pythonhosted.org/packages/30/a5/a515b7600ad361ea14bfa13fb4d6687abf500adc270f19e89849c0590492/nvidia_cuda_runtime_cu12-12.8.90-py3-none-win_amd64.whl", hash = "sha256:c0c6027f01505bfed6c3b21ec546f69c687689aad5f1a377554bc6ca4aa993a8", size = 944318, upload-time = "2025-03-07T01:51:01.794Z" }, ] +[[package]] +name = "nvidia-cudnn-cu12" +version = "9.5.1.17" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten'", +] +dependencies = [ + { name = "nvidia-cublas-cu12", version = "12.6.4.1", source = { registry = "https://pypi.org/simple" }, marker = "(sys_platform != 'emscripten' and extra == 'extra-7-opentau-robocasa') or (sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/99/93/a201a12d3ec1caa8c6ac34c1c2f9eeb696b886f0c36ff23c638b46603bd0/nvidia_cudnn_cu12-9.5.1.17-py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:9fd4584468533c61873e5fda8ca41bac3a38bcb2d12350830c69b0a96a7e4def", size = 570523509, upload-time = "2024-10-25T19:53:03.148Z" }, + { url = "https://files.pythonhosted.org/packages/2a/78/4535c9c7f859a64781e43c969a3a7e84c54634e319a996d43ef32ce46f83/nvidia_cudnn_cu12-9.5.1.17-py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:30ac3869f6db17d170e0e556dd6cc5eee02647abc31ca856634d5a40f82c15b2", size = 570988386, upload-time = "2024-10-25T19:54:26.39Z" }, + { url = "https://files.pythonhosted.org/packages/b6/b2/3f60d15f037fa5419d9d7f788b100ef33ea913ae5315c87ca6d6fa606c35/nvidia_cudnn_cu12-9.5.1.17-py3-none-win_amd64.whl", hash = "sha256:d7af0f8a4f3b4b9dbb3122f2ef553b45694ed9c384d5a75bab197b8eefb79ab8", size = 565440743, upload-time = "2024-10-25T19:55:49.74Z" }, +] + [[package]] name = "nvidia-cudnn-cu12" version = "9.10.2.21" source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf'", + "platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", +] dependencies = [ - { name = "nvidia-cublas-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "nvidia-cublas-cu12", version = "12.8.4.1", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero') or (platform_machine == 'aarch64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (platform_machine == 'aarch64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'emscripten' and sys_platform != 'linux' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/fa/41/e79269ce215c857c935fd86bcfe91a451a584dfc27f1e068f568b9ad1ab7/nvidia_cudnn_cu12-9.10.2.21-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:c9132cc3f8958447b4910a1720036d9eff5928cc3179b0a51fb6d167c6cc87d8", size = 705026878, upload-time = "2025-06-06T21:52:51.348Z" }, @@ -2000,12 +2389,34 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/3d/90/0bd6e586701b3a890fd38aa71c387dab4883d619d6e5ad912ccbd05bfd67/nvidia_cudnn_cu12-9.10.2.21-py3-none-win_amd64.whl", hash = "sha256:c6288de7d63e6cf62988f0923f96dc339cea362decb1bf5b3141883392a7d65e", size = 692992268, upload-time = "2025-06-06T21:55:18.114Z" }, ] +[[package]] +name = "nvidia-cufft-cu12" +version = "11.3.0.4" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten'", +] +dependencies = [ + { name = "nvidia-nvjitlink-cu12", version = "12.6.85", source = { registry = "https://pypi.org/simple" }, marker = "(sys_platform != 'emscripten' and extra == 'extra-7-opentau-robocasa') or (sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/1f/37/c50d2b2f2c07e146776389e3080f4faf70bcc4fa6e19d65bb54ca174ebc3/nvidia_cufft_cu12-11.3.0.4-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d16079550df460376455cba121db6564089176d9bac9e4f360493ca4741b22a6", size = 200164144, upload-time = "2024-11-20T17:40:58.288Z" }, + { url = "https://files.pythonhosted.org/packages/ce/f5/188566814b7339e893f8d210d3a5332352b1409815908dad6a363dcceac1/nvidia_cufft_cu12-11.3.0.4-py3-none-manylinux2014_aarch64.whl", hash = "sha256:8510990de9f96c803a051822618d42bf6cb8f069ff3f48d93a8486efdacb48fb", size = 200164135, upload-time = "2024-10-01T17:03:24.212Z" }, + { url = "https://files.pythonhosted.org/packages/8f/16/73727675941ab8e6ffd86ca3a4b7b47065edcca7a997920b831f8147c99d/nvidia_cufft_cu12-11.3.0.4-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ccba62eb9cef5559abd5e0d54ceed2d9934030f51163df018532142a8ec533e5", size = 200221632, upload-time = "2024-11-20T17:41:32.357Z" }, + { url = "https://files.pythonhosted.org/packages/60/de/99ec247a07ea40c969d904fc14f3a356b3e2a704121675b75c366b694ee1/nvidia_cufft_cu12-11.3.0.4-py3-none-manylinux2014_x86_64.whl", hash = "sha256:768160ac89f6f7b459bee747e8d175dbf53619cfe74b2a5636264163138013ca", size = 200221622, upload-time = "2024-10-01T17:03:58.79Z" }, + { url = "https://files.pythonhosted.org/packages/b4/38/36fd800cec8f6e89b7c1576edaaf8076e69ec631644cdbc1b5f2e2b5a9df/nvidia_cufft_cu12-11.3.0.4-py3-none-win_amd64.whl", hash = "sha256:6048ebddfb90d09d2707efb1fd78d4e3a77cb3ae4dc60e19aab6be0ece2ae464", size = 199356881, upload-time = "2024-10-01T17:13:01.861Z" }, +] + [[package]] name = "nvidia-cufft-cu12" version = "11.3.3.83" source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf'", + "platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", +] dependencies = [ - { name = "nvidia-nvjitlink-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "nvidia-nvjitlink-cu12", version = "12.8.93", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero') or (platform_machine == 'aarch64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (platform_machine == 'aarch64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'emscripten' and sys_platform != 'linux' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, ] 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" }, @@ -2013,33 +2424,92 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/7d/ec/ce1629f1e478bb5ccd208986b5f9e0316a78538dd6ab1d0484f012f8e2a1/nvidia_cufft_cu12-11.3.3.83-py3-none-win_amd64.whl", hash = "sha256:7a64a98ef2a7c47f905aaf8931b69a3a43f27c55530c698bb2ed7c75c0b42cb7", size = 192216559, upload-time = "2025-03-07T01:53:57.106Z" }, ] +[[package]] +name = "nvidia-cufile-cu12" +version = "1.11.1.6" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten'", +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/b2/66/cc9876340ac68ae71b15c743ddb13f8b30d5244af344ec8322b449e35426/nvidia_cufile_cu12-1.11.1.6-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:cc23469d1c7e52ce6c1d55253273d32c565dd22068647f3aa59b3c6b005bf159", size = 1142103, upload-time = "2024-11-20T17:42:11.83Z" }, + { url = "https://files.pythonhosted.org/packages/17/bf/cc834147263b929229ce4aadd62869f0b195e98569d4c28b23edc72b85d9/nvidia_cufile_cu12-1.11.1.6-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:8f57a0051dcf2543f6dc2b98a98cb2719c37d3cee1baba8965d57f3bbc90d4db", size = 1066155, upload-time = "2024-11-20T17:41:49.376Z" }, +] + [[package]] name = "nvidia-cufile-cu12" version = "1.13.1.3" source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf'", + "platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", +] wheels = [ { url = "https://files.pythonhosted.org/packages/bb/fe/1bcba1dfbfb8d01be8d93f07bfc502c93fa23afa6fd5ab3fc7c1df71038a/nvidia_cufile_cu12-1.13.1.3-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1d069003be650e131b21c932ec3d8969c1715379251f8d23a1860554b1cb24fc", size = 1197834, upload-time = "2025-03-07T01:45:50.723Z" }, { url = "https://files.pythonhosted.org/packages/1e/f5/5607710447a6fe9fd9b3283956fceeee8a06cda1d2f56ce31371f595db2a/nvidia_cufile_cu12-1.13.1.3-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:4beb6d4cce47c1a0f1013d72e02b0994730359e17801d395bdcbf20cfb3bb00a", size = 1120705, upload-time = "2025-03-07T01:45:41.434Z" }, ] +[[package]] +name = "nvidia-curand-cu12" +version = "10.3.7.77" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten'", +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/42/ac/36543605358a355632f1a6faa3e2d5dfb91eab1e4bc7d552040e0383c335/nvidia_curand_cu12-10.3.7.77-py3-none-manylinux2014_aarch64.whl", hash = "sha256:6e82df077060ea28e37f48a3ec442a8f47690c7499bff392a5938614b56c98d8", size = 56289881, upload-time = "2024-10-01T17:04:18.981Z" }, + { url = "https://files.pythonhosted.org/packages/73/1b/44a01c4e70933637c93e6e1a8063d1e998b50213a6b65ac5a9169c47e98e/nvidia_curand_cu12-10.3.7.77-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a42cd1344297f70b9e39a1e4f467a4e1c10f1da54ff7a85c12197f6c652c8bdf", size = 56279010, upload-time = "2024-11-20T17:42:50.958Z" }, + { url = "https://files.pythonhosted.org/packages/4a/aa/2c7ff0b5ee02eaef890c0ce7d4f74bc30901871c5e45dee1ae6d0083cd80/nvidia_curand_cu12-10.3.7.77-py3-none-manylinux2014_x86_64.whl", hash = "sha256:99f1a32f1ac2bd134897fc7a203f779303261268a65762a623bf30cc9fe79117", size = 56279000, upload-time = "2024-10-01T17:04:45.274Z" }, + { url = "https://files.pythonhosted.org/packages/a6/02/5362a9396f23f7de1dd8a64369e87c85ffff8216fc8194ace0fa45ba27a5/nvidia_curand_cu12-10.3.7.77-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:7b2ed8e95595c3591d984ea3603dd66fe6ce6812b886d59049988a712ed06b6e", size = 56289882, upload-time = "2024-11-20T17:42:25.222Z" }, + { url = "https://files.pythonhosted.org/packages/a9/a8/0cd0cec757bd4b4b4ef150fca62ec064db7d08a291dced835a0be7d2c147/nvidia_curand_cu12-10.3.7.77-py3-none-win_amd64.whl", hash = "sha256:6d6d935ffba0f3d439b7cd968192ff068fafd9018dbf1b85b37261b13cfc9905", size = 55783873, upload-time = "2024-10-01T17:13:30.377Z" }, +] + [[package]] name = "nvidia-curand-cu12" version = "10.3.9.90" source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf'", + "platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", +] wheels = [ { url = "https://files.pythonhosted.org/packages/45/5e/92aa15eca622a388b80fbf8375d4760738df6285b1e92c43d37390a33a9a/nvidia_curand_cu12-10.3.9.90-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:dfab99248034673b779bc6decafdc3404a8a6f502462201f2f31f11354204acd", size = 63625754, upload-time = "2025-03-07T01:46:10.735Z" }, { url = "https://files.pythonhosted.org/packages/fb/aa/6584b56dc84ebe9cf93226a5cde4d99080c8e90ab40f0c27bda7a0f29aa1/nvidia_curand_cu12-10.3.9.90-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:b32331d4f4df5d6eefa0554c565b626c7216f87a06a4f56fab27c3b68a830ec9", size = 63619976, upload-time = "2025-03-07T01:46:23.323Z" }, { url = "https://files.pythonhosted.org/packages/b9/75/70c05b2f3ed5be3bb30b7102b6eb78e100da4bbf6944fd6725c012831cab/nvidia_curand_cu12-10.3.9.90-py3-none-win_amd64.whl", hash = "sha256:f149a8ca457277da854f89cf282d6ef43176861926c7ac85b2a0fbd237c587ec", size = 62765309, upload-time = "2025-03-07T01:54:20.478Z" }, ] +[[package]] +name = "nvidia-cusolver-cu12" +version = "11.7.1.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten'", +] +dependencies = [ + { name = "nvidia-cublas-cu12", version = "12.6.4.1", source = { registry = "https://pypi.org/simple" }, marker = "(sys_platform != 'emscripten' and extra == 'extra-7-opentau-robocasa') or (sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "nvidia-cusparse-cu12", version = "12.5.4.2", source = { registry = "https://pypi.org/simple" }, marker = "(sys_platform != 'emscripten' and extra == 'extra-7-opentau-robocasa') or (sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "nvidia-nvjitlink-cu12", version = "12.6.85", source = { registry = "https://pypi.org/simple" }, marker = "(sys_platform != 'emscripten' and extra == 'extra-7-opentau-robocasa') or (sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/93/17/dbe1aa865e4fdc7b6d4d0dd308fdd5aaab60f939abfc0ea1954eac4fb113/nvidia_cusolver_cu12-11.7.1.2-py3-none-manylinux2014_aarch64.whl", hash = "sha256:0ce237ef60acde1efc457335a2ddadfd7610b892d94efee7b776c64bb1cac9e0", size = 157833628, upload-time = "2024-10-01T17:05:05.591Z" }, + { url = "https://files.pythonhosted.org/packages/f0/6e/c2cf12c9ff8b872e92b4a5740701e51ff17689c4d726fca91875b07f655d/nvidia_cusolver_cu12-11.7.1.2-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e9e49843a7707e42022babb9bcfa33c29857a93b88020c4e4434656a655b698c", size = 158229790, upload-time = "2024-11-20T17:43:43.211Z" }, + { url = "https://files.pythonhosted.org/packages/9f/81/baba53585da791d043c10084cf9553e074548408e04ae884cfe9193bd484/nvidia_cusolver_cu12-11.7.1.2-py3-none-manylinux2014_x86_64.whl", hash = "sha256:6cf28f17f64107a0c4d7802be5ff5537b2130bfc112f25d5a30df227058ca0e6", size = 158229780, upload-time = "2024-10-01T17:05:39.875Z" }, + { url = "https://files.pythonhosted.org/packages/7c/5f/07d0ba3b7f19be5a5ec32a8679fc9384cfd9fc6c869825e93be9f28d6690/nvidia_cusolver_cu12-11.7.1.2-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:dbbe4fc38ec1289c7e5230e16248365e375c3673c9c8bac5796e2e20db07f56e", size = 157833630, upload-time = "2024-11-20T17:43:16.77Z" }, + { url = "https://files.pythonhosted.org/packages/d4/53/fff50a0808df7113d77e3bbc7c2b7eaed6f57d5eb80fbe93ead2aea1e09a/nvidia_cusolver_cu12-11.7.1.2-py3-none-win_amd64.whl", hash = "sha256:6813f9d8073f555444a8705f3ab0296d3e1cb37a16d694c5fc8b862a0d8706d7", size = 149287877, upload-time = "2024-10-01T17:13:49.804Z" }, +] + [[package]] name = "nvidia-cusolver-cu12" version = "11.7.3.90" source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf'", + "platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", +] dependencies = [ - { name = "nvidia-cublas-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "nvidia-cusparse-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "nvidia-nvjitlink-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "nvidia-cublas-cu12", version = "12.8.4.1", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero') or (platform_machine == 'aarch64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (platform_machine == 'aarch64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'emscripten' and sys_platform != 'linux' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "nvidia-cusparse-cu12", version = "12.5.8.93", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero') or (platform_machine == 'aarch64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (platform_machine == 'aarch64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'emscripten' and sys_platform != 'linux' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "nvidia-nvjitlink-cu12", version = "12.8.93", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero') or (platform_machine == 'aarch64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (platform_machine == 'aarch64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'emscripten' and sys_platform != 'linux' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, ] 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" }, @@ -2047,12 +2517,34 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/13/c0/76ca8551b8a84146ffa189fec81c26d04adba4bc0dbe09cd6e6fd9b7de04/nvidia_cusolver_cu12-11.7.3.90-py3-none-win_amd64.whl", hash = "sha256:4a550db115fcabc4d495eb7d39ac8b58d4ab5d8e63274d3754df1c0ad6a22d34", size = 256720438, upload-time = "2025-03-07T01:54:39.898Z" }, ] +[[package]] +name = "nvidia-cusparse-cu12" +version = "12.5.4.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten'", +] +dependencies = [ + { name = "nvidia-nvjitlink-cu12", version = "12.6.85", source = { registry = "https://pypi.org/simple" }, marker = "(sys_platform != 'emscripten' and extra == 'extra-7-opentau-robocasa') or (sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/eb/6681efd0aa7df96b4f8067b3ce7246833dd36830bb4cec8896182773db7d/nvidia_cusparse_cu12-12.5.4.2-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d25b62fb18751758fe3c93a4a08eff08effedfe4edf1c6bb5afd0890fe88f887", size = 216451147, upload-time = "2024-11-20T17:44:18.055Z" }, + { url = "https://files.pythonhosted.org/packages/d3/56/3af21e43014eb40134dea004e8d0f1ef19d9596a39e4d497d5a7de01669f/nvidia_cusparse_cu12-12.5.4.2-py3-none-manylinux2014_aarch64.whl", hash = "sha256:7aa32fa5470cf754f72d1116c7cbc300b4e638d3ae5304cfa4a638a5b87161b1", size = 216451135, upload-time = "2024-10-01T17:06:03.826Z" }, + { url = "https://files.pythonhosted.org/packages/06/1e/b8b7c2f4099a37b96af5c9bb158632ea9e5d9d27d7391d7eb8fc45236674/nvidia_cusparse_cu12-12.5.4.2-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7556d9eca156e18184b94947ade0fba5bb47d69cec46bf8660fd2c71a4b48b73", size = 216561367, upload-time = "2024-11-20T17:44:54.824Z" }, + { url = "https://files.pythonhosted.org/packages/43/ac/64c4316ba163e8217a99680c7605f779accffc6a4bcd0c778c12948d3707/nvidia_cusparse_cu12-12.5.4.2-py3-none-manylinux2014_x86_64.whl", hash = "sha256:23749a6571191a215cb74d1cdbff4a86e7b19f1200c071b3fcf844a5bea23a2f", size = 216561357, upload-time = "2024-10-01T17:06:29.861Z" }, + { url = "https://files.pythonhosted.org/packages/45/ef/876ad8e4260e1128e6d4aac803d9d51baf3791ebdb4a9b8d9b8db032b4b0/nvidia_cusparse_cu12-12.5.4.2-py3-none-win_amd64.whl", hash = "sha256:4acb8c08855a26d737398cba8fb6f8f5045d93f82612b4cfd84645a2332ccf20", size = 213712630, upload-time = "2024-10-01T17:14:23.779Z" }, +] + [[package]] name = "nvidia-cusparse-cu12" version = "12.5.8.93" source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf'", + "platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", +] dependencies = [ - { name = "nvidia-nvjitlink-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "nvidia-nvjitlink-cu12", version = "12.8.93", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero') or (platform_machine == 'aarch64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (platform_machine == 'aarch64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'emscripten' and sys_platform != 'linux' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, ] 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" }, @@ -2060,29 +2552,79 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/62/07/f3b2ad63f8e3d257a599f422ae34eb565e70c41031aecefa3d18b62cabd1/nvidia_cusparse_cu12-12.5.8.93-py3-none-win_amd64.whl", hash = "sha256:9a33604331cb2cac199f2e7f5104dfbb8a5a898c367a53dfda9ff2acb6b6b4dd", size = 284937404, upload-time = "2025-03-07T01:55:07.742Z" }, ] +[[package]] +name = "nvidia-cusparselt-cu12" +version = "0.6.3" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten'", +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/62/da/4de092c61c6dea1fc9c936e69308a02531d122e12f1f649825934ad651b5/nvidia_cusparselt_cu12-0.6.3-py3-none-manylinux2014_aarch64.whl", hash = "sha256:8371549623ba601a06322af2133c4a44350575f5a3108fb75f3ef20b822ad5f1", size = 156402859, upload-time = "2024-10-16T02:23:17.184Z" }, + { url = "https://files.pythonhosted.org/packages/3b/9a/72ef35b399b0e183bc2e8f6f558036922d453c4d8237dab26c666a04244b/nvidia_cusparselt_cu12-0.6.3-py3-none-manylinux2014_x86_64.whl", hash = "sha256:e5c8a26c36445dd2e6812f1177978a24e2d37cacce7e090f297a688d1ec44f46", size = 156785796, upload-time = "2024-10-15T21:29:17.709Z" }, + { url = "https://files.pythonhosted.org/packages/46/3e/9e1e394a02a06f694be2c97bbe47288bb7c90ea84c7e9cf88f7b28afe165/nvidia_cusparselt_cu12-0.6.3-py3-none-win_amd64.whl", hash = "sha256:3b325bcbd9b754ba43df5a311488fca11a6b5dc3d11df4d190c000cf1a0765c7", size = 155595972, upload-time = "2024-10-15T22:58:35.426Z" }, +] + [[package]] name = "nvidia-cusparselt-cu12" version = "0.7.1" source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf'", + "platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", +] wheels = [ { url = "https://files.pythonhosted.org/packages/73/b9/598f6ff36faaece4b3c50d26f50e38661499ff34346f00e057760b35cc9d/nvidia_cusparselt_cu12-0.7.1-py3-none-manylinux2014_aarch64.whl", hash = "sha256:8878dce784d0fac90131b6817b607e803c36e629ba34dc5b433471382196b6a5", size = 283835557, upload-time = "2025-02-26T00:16:54.265Z" }, { url = "https://files.pythonhosted.org/packages/56/79/12978b96bd44274fe38b5dde5cfb660b1d114f70a65ef962bcbbed99b549/nvidia_cusparselt_cu12-0.7.1-py3-none-manylinux2014_x86_64.whl", hash = "sha256:f1bb701d6b930d5a7cea44c19ceb973311500847f81b634d802b7b539dc55623", size = 287193691, upload-time = "2025-02-26T00:15:44.104Z" }, { url = "https://files.pythonhosted.org/packages/2f/d8/a6b0d0d0c2435e9310f3e2bb0d9c9dd4c33daef86aa5f30b3681defd37ea/nvidia_cusparselt_cu12-0.7.1-py3-none-win_amd64.whl", hash = "sha256:f67fbb5831940ec829c9117b7f33807db9f9678dc2a617fbe781cac17b4e1075", size = 271020911, upload-time = "2025-02-26T00:14:47.204Z" }, ] +[[package]] +name = "nvidia-nccl-cu12" +version = "2.26.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten'", +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/69/5b/ca2f213f637305633814ae8c36b153220e40a07ea001966dcd87391f3acb/nvidia_nccl_cu12-2.26.2-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5c196e95e832ad30fbbb50381eb3cbd1fadd5675e587a548563993609af19522", size = 291671495, upload-time = "2025-03-13T00:30:07.805Z" }, + { url = "https://files.pythonhosted.org/packages/67/ca/f42388aed0fddd64ade7493dbba36e1f534d4e6fdbdd355c6a90030ae028/nvidia_nccl_cu12-2.26.2-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:694cf3879a206553cc9d7dbda76b13efaf610fdb70a50cba303de1b0d1530ac6", size = 201319755, upload-time = "2025-03-13T00:29:55.296Z" }, +] + [[package]] name = "nvidia-nccl-cu12" version = "2.27.5" source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf'", + "platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", +] wheels = [ { url = "https://files.pythonhosted.org/packages/bb/1c/857979db0ef194ca5e21478a0612bcdbbe59458d7694361882279947b349/nvidia_nccl_cu12-2.27.5-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:31432ad4d1fb1004eb0c56203dc9bc2178a1ba69d1d9e02d64a6938ab5e40e7a", size = 322400625, upload-time = "2025-06-26T04:11:04.496Z" }, { url = "https://files.pythonhosted.org/packages/6e/89/f7a07dc961b60645dbbf42e80f2bc85ade7feb9a491b11a1e973aa00071f/nvidia_nccl_cu12-2.27.5-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ad730cf15cb5d25fe849c6e6ca9eb5b76db16a80f13f425ac68d8e2e55624457", size = 322348229, upload-time = "2025-06-26T04:11:28.385Z" }, ] +[[package]] +name = "nvidia-nvjitlink-cu12" +version = "12.6.85" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten'", +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/9d/d7/c5383e47c7e9bf1c99d5bd2a8c935af2b6d705ad831a7ec5c97db4d82f4f/nvidia_nvjitlink_cu12-12.6.85-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:eedc36df9e88b682efe4309aa16b5b4e78c2407eac59e8c10a6a47535164369a", size = 19744971, upload-time = "2024-11-20T17:46:53.366Z" }, + { url = "https://files.pythonhosted.org/packages/31/db/dc71113d441f208cdfe7ae10d4983884e13f464a6252450693365e166dcf/nvidia_nvjitlink_cu12-12.6.85-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cf4eaa7d4b6b543ffd69d6abfb11efdeb2db48270d94dfd3a452c24150829e41", size = 19270338, upload-time = "2024-11-20T17:46:29.758Z" }, + { url = "https://files.pythonhosted.org/packages/89/76/93c1467b1387387440a4d25102d86b7794535449b689f8e2dc22c1c8ff7f/nvidia_nvjitlink_cu12-12.6.85-py3-none-win_amd64.whl", hash = "sha256:e61120e52ed675747825cdd16febc6a0730537451d867ee58bee3853b1b13d1c", size = 161908572, upload-time = "2024-11-20T17:52:40.124Z" }, +] + [[package]] name = "nvidia-nvjitlink-cu12" version = "12.8.93" source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf'", + "platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", +] wheels = [ { url = "https://files.pythonhosted.org/packages/f6/74/86a07f1d0f42998ca31312f998bd3b9a7eff7f52378f4f270c8679c77fb9/nvidia_nvjitlink_cu12-12.8.93-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:81ff63371a7ebd6e6451970684f916be2eab07321b73c9d244dc2b4da7f73b88", size = 39254836, upload-time = "2025-03-07T01:49:55.661Z" }, { url = "https://files.pythonhosted.org/packages/2a/a2/8cee5da30d13430e87bf99bb33455d2724d0a4a9cb5d7926d80ccb96d008/nvidia_nvjitlink_cu12-12.8.93-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:adccd7161ace7261e01bb91e44e88da350895c270d23f744f0820c818b7229e7", size = 38386204, upload-time = "2025-03-07T01:49:43.612Z" }, @@ -2098,10 +2640,29 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b5/09/6ea3ea725f82e1e76684f0708bbedd871fc96da89945adeba65c3835a64c/nvidia_nvshmem_cu12-3.4.5-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:042f2500f24c021db8a06c5eec2539027d57460e1c1a762055a6554f72c369bd", size = 139103095, upload-time = "2025-09-06T00:32:31.266Z" }, ] +[[package]] +name = "nvidia-nvtx-cu12" +version = "12.6.77" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten'", +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/b9/93/80f8a520375af9d7ee44571a6544653a176e53c2b8ccce85b97b83c2491b/nvidia_nvtx_cu12-12.6.77-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f44f8d86bb7d5629988d61c8d3ae61dddb2015dee142740536bc7481b022fe4b", size = 90549, upload-time = "2024-11-20T17:38:17.387Z" }, + { url = "https://files.pythonhosted.org/packages/2b/53/36e2fd6c7068997169b49ffc8c12d5af5e5ff209df6e1a2c4d373b3a638f/nvidia_nvtx_cu12-12.6.77-py3-none-manylinux2014_aarch64.whl", hash = "sha256:adcaabb9d436c9761fca2b13959a2d237c5f9fd406c8e4b723c695409ff88059", size = 90539, upload-time = "2024-10-01T17:00:27.179Z" }, + { url = "https://files.pythonhosted.org/packages/56/9a/fff8376f8e3d084cd1530e1ef7b879bb7d6d265620c95c1b322725c694f4/nvidia_nvtx_cu12-12.6.77-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b90bed3df379fa79afbd21be8e04a0314336b8ae16768b58f2d34cb1d04cd7d2", size = 89276, upload-time = "2024-11-20T17:38:27.621Z" }, + { url = "https://files.pythonhosted.org/packages/9e/4e/0d0c945463719429b7bd21dece907ad0bde437a2ff12b9b12fee94722ab0/nvidia_nvtx_cu12-12.6.77-py3-none-manylinux2014_x86_64.whl", hash = "sha256:6574241a3ec5fdc9334353ab8c479fe75841dbe8f4532a8fc97ce63503330ba1", size = 89265, upload-time = "2024-10-01T17:00:38.172Z" }, + { url = "https://files.pythonhosted.org/packages/f7/cd/98a447919d4ed14d407ac82b14b0a0c9c1dbfe81099934b1fc3bfd1e6316/nvidia_nvtx_cu12-12.6.77-py3-none-win_amd64.whl", hash = "sha256:2fb11a4af04a5e6c84073e6404d26588a34afd35379f0855a99797897efa75c0", size = 56434, upload-time = "2024-10-01T17:11:13.124Z" }, +] + [[package]] name = "nvidia-nvtx-cu12" version = "12.8.90" source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf'", + "platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", +] wheels = [ { url = "https://files.pythonhosted.org/packages/10/c0/1b303feea90d296f6176f32a2a70b5ef230f9bdeb3a72bddb0dc922dc137/nvidia_nvtx_cu12-12.8.90-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d7ad891da111ebafbf7e015d34879f7112832fc239ff0d7d776b6cb685274615", size = 91161, upload-time = "2025-03-07T01:42:23.922Z" }, { url = "https://files.pythonhosted.org/packages/a2/eb/86626c1bbc2edb86323022371c39aa48df6fd8b0a1647bc274577f72e90b/nvidia_nvtx_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5b17e2001cc0d751a5bc2c6ec6d26ad95913324a4adb86788c944f8ce9ba441f", size = 89954, upload-time = "2025-03-07T01:42:44.131Z" }, @@ -2127,8 +2688,9 @@ version = "1.20.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "ml-dtypes" }, - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero'" }, - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, { name = "protobuf" }, { name = "typing-extensions" }, ] @@ -2153,8 +2715,9 @@ version = "0.1.15" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "ml-dtypes" }, - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero'" }, - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, { name = "onnx" }, { name = "typing-extensions" }, ] @@ -2168,13 +2731,14 @@ name = "onnxruntime" version = "1.23.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "coloredlogs", marker = "(platform_machine != 'AMD64' and platform_machine != 'x86_64' and sys_platform == 'win32') or (platform_machine != 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine == 'x86_64' and sys_platform == 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and sys_platform != 'win32') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "flatbuffers", marker = "(platform_machine != 'AMD64' and platform_machine != 'x86_64' and sys_platform == 'win32') or (platform_machine != 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine == 'x86_64' and sys_platform == 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and sys_platform != 'win32') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine != 'AMD64' and platform_machine != 'x86_64' and sys_platform == 'win32' and extra == 'extra-7-opentau-libero') or (platform_machine != 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero') or (platform_machine == 'AMD64' and sys_platform == 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine == 'x86_64' and sys_platform == 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-7-opentau-libero') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine != 'AMD64' and platform_machine != 'x86_64' and sys_platform == 'win32' and extra != 'extra-7-opentau-libero') or (platform_machine != 'x86_64' and sys_platform == 'linux' and extra != 'extra-7-opentau-libero') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-7-opentau-libero') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "packaging", marker = "(platform_machine != 'AMD64' and platform_machine != 'x86_64' and sys_platform == 'win32') or (platform_machine != 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine == 'x86_64' and sys_platform == 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and sys_platform != 'win32') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "protobuf", marker = "(platform_machine != 'AMD64' and platform_machine != 'x86_64' and sys_platform == 'win32') or (platform_machine != 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine == 'x86_64' and sys_platform == 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and sys_platform != 'win32') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "sympy", marker = "(platform_machine != 'AMD64' and platform_machine != 'x86_64' and sys_platform == 'win32') or (platform_machine != 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine == 'x86_64' and sys_platform == 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and sys_platform != 'win32') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "coloredlogs" }, + { name = "flatbuffers" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "packaging" }, + { name = "protobuf" }, + { name = "sympy" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/35/d6/311b1afea060015b56c742f3531168c1644650767f27ef40062569960587/onnxruntime-1.23.2-cp310-cp310-macosx_13_0_arm64.whl", hash = "sha256:a7730122afe186a784660f6ec5807138bf9d792fa1df76556b27307ea9ebcbe3", size = 17195934, upload-time = "2025-10-27T23:06:14.143Z" }, @@ -2189,13 +2753,14 @@ name = "onnxruntime-gpu" version = "1.23.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "coloredlogs", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'x86_64' and sys_platform == 'win32') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "flatbuffers", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'x86_64' and sys_platform == 'win32') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero') or (platform_machine == 'AMD64' and sys_platform == 'win32' and extra == 'extra-7-opentau-libero') or (platform_machine == 'x86_64' and sys_platform == 'win32' and extra == 'extra-7-opentau-libero') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra != 'extra-7-opentau-libero') or (platform_machine == 'AMD64' and sys_platform == 'win32' and extra != 'extra-7-opentau-libero') or (platform_machine == 'x86_64' and sys_platform == 'win32' and extra != 'extra-7-opentau-libero') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "packaging", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'x86_64' and sys_platform == 'win32') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "protobuf", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'x86_64' and sys_platform == 'win32') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "sympy", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'x86_64' and sys_platform == 'win32') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "coloredlogs", marker = "(platform_machine != 'aarch64' and sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux') or (sys_platform == 'darwin' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'darwin' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'darwin' and extra != 'extra-7-opentau-libero') or (sys_platform == 'linux' and extra != 'extra-7-opentau-libero') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "flatbuffers", marker = "(platform_machine != 'aarch64' and sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux') or (sys_platform == 'darwin' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'darwin' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'darwin' and extra != 'extra-7-opentau-libero') or (sys_platform == 'linux' and extra != 'extra-7-opentau-libero') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and extra == 'extra-7-opentau-libero') or (sys_platform == 'darwin' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'darwin' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'darwin' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" }, marker = "(sys_platform != 'emscripten' and extra == 'extra-7-opentau-robocasa') or (sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(sys_platform != 'emscripten' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "packaging", marker = "(platform_machine != 'aarch64' and sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux') or (sys_platform == 'darwin' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'darwin' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'darwin' and extra != 'extra-7-opentau-libero') or (sys_platform == 'linux' and extra != 'extra-7-opentau-libero') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "protobuf", marker = "(platform_machine != 'aarch64' and sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux') or (sys_platform == 'darwin' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'darwin' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'darwin' and extra != 'extra-7-opentau-libero') or (sys_platform == 'linux' and extra != 'extra-7-opentau-libero') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "sympy", marker = "(platform_machine != 'aarch64' and sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux') or (sys_platform == 'darwin' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'darwin' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'darwin' and extra != 'extra-7-opentau-libero') or (sys_platform == 'linux' and extra != 'extra-7-opentau-libero') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/cb/ae/39283748c68a96be4f5f8a9561e0e3ca92af1eae6c2b1c07fb1da5f65cd1/onnxruntime_gpu-1.23.2-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:18de50c6c8eea50acc405ea13d299aec593e46478d7a22cd32cdbbdf7c42899d", size = 300525411, upload-time = "2025-10-22T16:56:08.415Z" }, @@ -2208,8 +2773,9 @@ version = "0.6.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "ml-dtypes" }, - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero'" }, - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, { name = "onnx" }, { name = "onnx-ir" }, { name = "packaging" }, @@ -2245,15 +2811,13 @@ version = "4.11.0.86" source = { registry = "https://pypi.org/simple" } resolution-markers = [ "platform_machine == 'aarch64' and sys_platform == 'linux'", - "platform_machine == 'x86_64' and sys_platform == 'linux'", - "platform_machine != 'aarch64' and platform_machine != 'x86_64' and sys_platform == 'linux'", + "platform_machine != 'aarch64' and sys_platform == 'linux'", "sys_platform == 'darwin'", - "(platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'x86_64' and sys_platform == 'win32')", - "(platform_machine != 'AMD64' and platform_machine != 'x86_64' and sys_platform == 'win32') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')", + "sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux'", "sys_platform == 'emscripten'", ] dependencies = [ - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero'" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/ef/51/3ceb85ecff5f26994b7aae2922b1aa38148dbfe88cab13d63bc6facbac88/opencv-contrib-python-4.11.0.86.tar.gz", hash = "sha256:4ff773dab44911da366b906621c9592d4eb96f6ad3777098933a23f064aab38e", size = 150559874, upload-time = "2025-01-16T13:53:08.425Z" } wheels = [ @@ -2270,14 +2834,12 @@ name = "opencv-contrib-python" version = "4.13.0.92" source = { registry = "https://pypi.org/simple" } resolution-markers = [ - "platform_machine == 'x86_64' and sys_platform == 'linux'", - "platform_machine != 'x86_64' and sys_platform == 'linux'", - "(platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'x86_64' and sys_platform == 'win32')", - "(platform_machine != 'AMD64' and platform_machine != 'x86_64' and sys_platform == 'win32') or (sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')", + "sys_platform != 'emscripten'", "sys_platform == 'emscripten'", ] dependencies = [ - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/7e/4c/a45c96b9fe90b2c48ee604f5176eb7deb46ce7c2e87c8d819d2945dbcab6/opencv_contrib_python-4.13.0.92-cp37-abi3-macosx_13_0_arm64.whl", hash = "sha256:53c8ab81376210dda5836307eb6bda7266f39a3820a9a070c7131510ba815fe1", size = 52041546, upload-time = "2026-02-05T07:01:29.918Z" }, @@ -2296,15 +2858,13 @@ version = "4.11.0.86" source = { registry = "https://pypi.org/simple" } resolution-markers = [ "platform_machine == 'aarch64' and sys_platform == 'linux'", - "platform_machine == 'x86_64' and sys_platform == 'linux'", - "platform_machine != 'aarch64' and platform_machine != 'x86_64' and sys_platform == 'linux'", + "platform_machine != 'aarch64' and sys_platform == 'linux'", "sys_platform == 'darwin'", - "(platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'x86_64' and sys_platform == 'win32')", - "(platform_machine != 'AMD64' and platform_machine != 'x86_64' and sys_platform == 'win32') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')", + "sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux'", "sys_platform == 'emscripten'", ] dependencies = [ - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero'" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/17/06/68c27a523103dad5837dc5b87e71285280c4f098c60e4fe8a8db6486ab09/opencv-python-4.11.0.86.tar.gz", hash = "sha256:03d60ccae62304860d232272e4a4fda93c39d595780cb40b161b310244b736a4", size = 95171956, upload-time = "2025-01-16T13:52:24.737Z" } wheels = [ @@ -2321,14 +2881,12 @@ name = "opencv-python" version = "4.13.0.90" source = { registry = "https://pypi.org/simple" } resolution-markers = [ - "platform_machine == 'x86_64' and sys_platform == 'linux'", - "platform_machine != 'x86_64' and sys_platform == 'linux'", - "(platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'x86_64' and sys_platform == 'win32')", - "(platform_machine != 'AMD64' and platform_machine != 'x86_64' and sys_platform == 'win32') or (sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')", + "sys_platform != 'emscripten'", "sys_platform == 'emscripten'", ] dependencies = [ - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/77/d7/133d5756aef78090f4d8dd4895793aed24942dec6064a15375cfac9175fc/opencv_python-4.13.0.90-cp37-abi3-macosx_13_0_arm64.whl", hash = "sha256:58803f8b05b51d8a785e2306d83b44173b32536f980342f3bc76d8c122b5938d", size = 46020278, upload-time = "2026-01-18T08:57:42.539Z" }, @@ -2347,15 +2905,13 @@ version = "4.11.0.86" source = { registry = "https://pypi.org/simple" } resolution-markers = [ "platform_machine == 'aarch64' and sys_platform == 'linux'", - "platform_machine == 'x86_64' and sys_platform == 'linux'", - "platform_machine != 'aarch64' and platform_machine != 'x86_64' and sys_platform == 'linux'", + "platform_machine != 'aarch64' and sys_platform == 'linux'", "sys_platform == 'darwin'", - "(platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'x86_64' and sys_platform == 'win32')", - "(platform_machine != 'AMD64' and platform_machine != 'x86_64' and sys_platform == 'win32') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')", + "sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux'", "sys_platform == 'emscripten'", ] dependencies = [ - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero'" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/36/2f/5b2b3ba52c864848885ba988f24b7f105052f68da9ab0e693cc7c25b0b30/opencv-python-headless-4.11.0.86.tar.gz", hash = "sha256:996eb282ca4b43ec6a3972414de0e2331f5d9cda2b41091a49739c19fb843798", size = 95177929, upload-time = "2025-01-16T13:53:40.22Z" } wheels = [ @@ -2372,14 +2928,12 @@ name = "opencv-python-headless" version = "4.13.0.90" source = { registry = "https://pypi.org/simple" } resolution-markers = [ - "platform_machine == 'x86_64' and sys_platform == 'linux'", - "platform_machine != 'x86_64' and sys_platform == 'linux'", - "(platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'x86_64' and sys_platform == 'win32')", - "(platform_machine != 'AMD64' and platform_machine != 'x86_64' and sys_platform == 'win32') or (sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')", + "sys_platform != 'emscripten'", "sys_platform == 'emscripten'", ] dependencies = [ - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/ed/76/38c4cbb5ccfce7aaf36fd9be9fc74a15c85a48ef90bfaca2049b486e10c5/opencv_python_headless-4.13.0.90-cp37-abi3-macosx_13_0_arm64.whl", hash = "sha256:12a28674f215542c9bf93338de1b5bffd76996d32da9acb9e739fdb9c8bbd738", size = 46020414, upload-time = "2026-01-18T09:07:10.801Z" }, @@ -2400,9 +2954,10 @@ dependencies = [ { name = "accelerate" }, { name = "anthropic" }, { name = "av" }, - { name = "cmake", version = "3.31.10", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero'" }, - { name = "cmake", version = "4.2.1", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, - { name = "datasets" }, + { name = "cmake", version = "3.31.10", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "cmake", version = "4.2.1", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, + { name = "datasets", version = "3.6.0", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "datasets", version = "4.5.0", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, { name = "deepdiff" }, { name = "deepspeed" }, { name = "diffusers" }, @@ -2413,7 +2968,8 @@ dependencies = [ { name = "google-genai" }, { name = "grpcio" }, { name = "grpcio-tools" }, - { name = "gymnasium", extra = ["other"] }, + { name = "gymnasium", version = "0.29.1", source = { registry = "https://pypi.org/simple" }, extra = ["other"], marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "gymnasium", version = "1.2.3", source = { registry = "https://pypi.org/simple" }, extra = ["other"], marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, { name = "h5py" }, { name = "huggingface-hub", extra = ["cli", "hf-transfer"] }, { name = "imageio", extra = ["ffmpeg"] }, @@ -2423,12 +2979,12 @@ dependencies = [ { name = "omegaconf" }, { name = "onnx" }, { name = "onnx-ir" }, - { name = "onnxruntime", marker = "platform_machine == 'aarch64' or platform_machine == 'arm64' or (platform_machine != 'aarch64' and platform_machine != 'arm64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or sys_platform == 'darwin'" }, - { name = "onnxruntime-gpu", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'x86_64' and sys_platform == 'win32') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "onnxruntime", marker = "platform_machine == 'aarch64' or platform_machine == 'arm64' or (platform_machine != 'aarch64' and platform_machine != 'arm64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (platform_machine != 'aarch64' and platform_machine != 'arm64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine != 'aarch64' and platform_machine != 'arm64' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or sys_platform == 'darwin'" }, + { name = "onnxruntime-gpu", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'x86_64' and sys_platform == 'win32') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'win32' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, { name = "onnxscript" }, { name = "openai" }, - { name = "opencv-python-headless", version = "4.11.0.86", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero'" }, - { name = "opencv-python-headless", version = "4.13.0.90", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, + { name = "opencv-python-headless", version = "4.11.0.86", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "opencv-python-headless", version = "4.13.0.90", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, { name = "packaging" }, { name = "pandas" }, { name = "protobuf" }, @@ -2440,16 +2996,19 @@ dependencies = [ { name = "pytest-xdist" }, { name = "python-dotenv" }, { name = "pyzmq" }, - { name = "rerun-sdk", version = "0.23.1", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero'" }, - { name = "rerun-sdk", version = "0.29.0", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, + { name = "rerun-sdk", version = "0.22.1", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "rerun-sdk", version = "0.23.1", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "rerun-sdk", version = "0.29.0", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, { name = "rosbags" }, { name = "scikit-image" }, { name = "scikit-learn" }, { name = "scipy" }, { name = "termcolor" }, - { name = "torch" }, - { name = "torchcodec", marker = "(platform_machine != 'aarch64' and platform_machine != 'arm64' and platform_machine != 'armv7l' and sys_platform == 'linux') or (platform_machine != 'x86_64' and sys_platform == 'darwin') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine == 'arm64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine == 'armv7l' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32') or (sys_platform == 'darwin' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "torchvision" }, + { name = "torch", version = "2.7.1", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "torch", version = "2.10.0", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, + { name = "torchcodec", marker = "(platform_machine != 'aarch64' and platform_machine != 'arm64' and platform_machine != 'armv7l' and sys_platform == 'linux') or (platform_machine != 'x86_64' and sys_platform == 'darwin') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (platform_machine == 'arm64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (platform_machine == 'arm64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine == 'arm64' and sys_platform == 'linux' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (platform_machine == 'armv7l' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (platform_machine == 'armv7l' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine == 'armv7l' and sys_platform == 'linux' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32') or (sys_platform == 'darwin' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'darwin' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'darwin' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'win32' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "torchvision", version = "0.22.1", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "torchvision", version = "0.25.0", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, { name = "transformers" }, { name = "wandb" }, { name = "zarr" }, @@ -2477,17 +3036,24 @@ libero = [ { name = "gym" }, { name = "libero" }, { name = "matplotlib" }, - { name = "mujoco" }, + { name = "mujoco", version = "3.4.0", source = { registry = "https://pypi.org/simple" } }, { name = "ninja" }, { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" } }, { name = "pyopengl" }, { name = "pyopengl-accelerate", marker = "sys_platform == 'linux'" }, { name = "robomimic" }, - { name = "robosuite" }, + { name = "robosuite", version = "1.4.0", source = { registry = "https://pypi.org/simple" } }, { name = "thop" }, ] +robocasa = [ + { name = "glfw" }, + { name = "msgpack" }, + { name = "robocasa" }, + { name = "robosuite", version = "1.5.2", source = { git = "https://github.com/ARISE-Initiative/robosuite?branch=master#232ce7d4a6ed89c949a9aba024a05c8c32fdd08b" } }, + { name = "websockets" }, +] trt = [ - { name = "tensorrt", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'x86_64' and sys_platform == 'win32') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "tensorrt", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'x86_64' and sys_platform == 'win32') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'win32' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, ] urdf = [ { name = "rerun-sdk", version = "0.29.0", source = { registry = "https://pypi.org/simple" } }, @@ -2512,6 +3078,7 @@ requires-dist = [ { name = "flask", specifier = ">=3.0.3" }, { name = "future", marker = "extra == 'libero'", specifier = "==0.18.2" }, { name = "gdown", specifier = ">=5.1.0" }, + { name = "glfw", marker = "extra == 'robocasa'", specifier = ">=2.0" }, { name = "google-genai", specifier = ">=1.0.0" }, { name = "grpcio", specifier = ">=1.60.0" }, { name = "grpcio-tools", specifier = ">=1.60.0" }, @@ -2524,6 +3091,7 @@ requires-dist = [ { name = "libero", marker = "extra == 'libero'", git = "https://github.com/shuheng-liu/LIBERO?branch=master" }, { name = "matplotlib", marker = "extra == 'libero'", specifier = ">=3.5.3" }, { name = "mediapipe", specifier = ">=0.10.0" }, + { name = "msgpack", marker = "extra == 'robocasa'", specifier = ">=1.0" }, { name = "mujoco", marker = "sys_platform == 'linux' and extra == 'libero'", specifier = ">=3.1.6" }, { name = "mujoco", marker = "extra == 'libero'", specifier = ">=3.3.5" }, { name = "myst-parser", marker = "extra == 'dev'", specifier = ">=4.0.0" }, @@ -2560,8 +3128,10 @@ requires-dist = [ { name = "pyzmq", specifier = ">=26.2.1" }, { name = "rerun-sdk", specifier = ">=0.21.0" }, { name = "rerun-sdk", marker = "extra == 'urdf'", specifier = ">=0.28.2" }, + { name = "robocasa", marker = "extra == 'robocasa'", git = "https://github.com/robocasa/robocasa?branch=main" }, { name = "robomimic", marker = "extra == 'libero'", specifier = "==0.2.0" }, { name = "robosuite", marker = "extra == 'libero'", specifier = "==1.4.0" }, + { name = "robosuite", marker = "extra == 'robocasa'", git = "https://github.com/ARISE-Initiative/robosuite?branch=master" }, { name = "rosbags", specifier = ">=0.10.4" }, { name = "scikit-image", specifier = ">=0.23.2" }, { name = "scikit-learn", specifier = ">=1.7.1" }, @@ -2578,9 +3148,10 @@ requires-dist = [ { name = "torchvision", specifier = ">=0.22.1" }, { name = "transformers", specifier = "==4.53.3" }, { name = "wandb", specifier = ">=0.16.3" }, + { name = "websockets", marker = "extra == 'robocasa'", specifier = ">=11.0" }, { name = "zarr", specifier = ">=2.17.0" }, ] -provides-extras = ["dev", "libero", "urdf", "trt"] +provides-extras = ["dev", "libero", "urdf", "robocasa", "trt"] [[package]] name = "orderly-set" @@ -2605,8 +3176,9 @@ name = "pandas" version = "2.3.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero'" }, - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, { name = "python-dateutil" }, { name = "pytz" }, { name = "tzdata" }, @@ -2871,6 +3443,21 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/2f/02/8559b1f26ee0d502c74f9cca5c0d2fd97e967e083e006bbbb4e97f3a043a/pydantic_core-2.41.5-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:d3a978c4f57a597908b7e697229d996d77a6d3c94901e9edee593adada95ce1a", size = 2147009, upload-time = "2025-11-04T13:43:23.286Z" }, ] +[[package]] +name = "pygame" +version = "2.6.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/49/cc/08bba60f00541f62aaa252ce0cfbd60aebd04616c0b9574f755b583e45ae/pygame-2.6.1.tar.gz", hash = "sha256:56fb02ead529cee00d415c3e007f75e0780c655909aaa8e8bf616ee09c9feb1f", size = 14808125, upload-time = "2024-09-29T13:41:34.698Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/54/0b/334c7c50a2979e15f2a027a41d1ca78ee730d5b1c7f7f4b26d7cb899839d/pygame-2.6.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:9beeb647e555afb5657111fa83acb74b99ad88761108eaea66472e8b8547b55b", size = 13109297, upload-time = "2024-09-29T14:25:34.709Z" }, + { url = "https://files.pythonhosted.org/packages/dc/48/f8b1069788d1bd42e63a960d74d3355242480b750173a42b2749687578ca/pygame-2.6.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:10e3d2a55f001f6c0a6eb44aa79ea7607091c9352b946692acedb2ac1482f1c9", size = 12375837, upload-time = "2024-09-29T14:25:50.538Z" }, + { url = "https://files.pythonhosted.org/packages/bc/33/a1310386b8913ce1bdb90c33fa536970e299ad57eb35785f1d71ea1e2ad3/pygame-2.6.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:816e85000c5d8b02a42b9834f761a5925ef3377d2924e3a7c4c143d2990ce5b8", size = 13607860, upload-time = "2024-09-29T11:10:44.173Z" }, + { url = "https://files.pythonhosted.org/packages/88/0f/4e37b115056e43714e7550054dd3cd7f4d552da54d7fc58a2fb1407acda5/pygame-2.6.1-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8a78fd030d98faab4a8e27878536fdff7518d3e062a72761c552f624ebba5a5f", size = 14304696, upload-time = "2024-09-29T11:39:46.724Z" }, + { url = "https://files.pythonhosted.org/packages/11/b3/de6ed93ae483cf3bac8f950a955e83f7ffe59651fd804d100fff65d66d6c/pygame-2.6.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:da3ad64d685f84a34ebe5daacb39fff14f1251acb34c098d760d63fee768f50c", size = 13977684, upload-time = "2024-09-29T11:39:49.921Z" }, + { url = "https://files.pythonhosted.org/packages/d3/05/d86440aa879708c41844bafc6b3eb42c6d8cf54082482499b53139133e2a/pygame-2.6.1-cp310-cp310-win32.whl", hash = "sha256:9dd5c054d4bd875a8caf978b82672f02bec332f52a833a76899220c460bb4b58", size = 10251775, upload-time = "2024-09-29T11:40:34.952Z" }, + { url = "https://files.pythonhosted.org/packages/38/88/8de61324775cf2c844a51d8db14a8a6d2a9092312f27678f6eaa3a460376/pygame-2.6.1-cp310-cp310-win_amd64.whl", hash = "sha256:00827aba089355925902d533f9c41e79a799641f03746c50a374dc5c3362e43d", size = 10618801, upload-time = "2024-09-29T12:13:25.284Z" }, +] + [[package]] name = "pygments" version = "2.19.2" @@ -2903,10 +3490,10 @@ name = "pynput" version = "1.8.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "evdev", marker = "'linux' in sys_platform or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "pyobjc-framework-applicationservices", marker = "sys_platform == 'darwin' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "pyobjc-framework-quartz", marker = "sys_platform == 'darwin' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "python-xlib", marker = "'linux' in sys_platform or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "evdev", marker = "'linux' in sys_platform or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "pyobjc-framework-applicationservices", marker = "sys_platform == 'darwin' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "pyobjc-framework-quartz", marker = "sys_platform == 'darwin' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "python-xlib", marker = "'linux' in sys_platform or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, { name = "six" }, ] sdist = { url = "https://files.pythonhosted.org/packages/f0/c3/dccf44c68225046df5324db0cc7d563a560635355b3e5f1d249468268a6f/pynput-1.8.1.tar.gz", hash = "sha256:70d7c8373ee98911004a7c938742242840a5628c004573d84ba849d4601df81e", size = 82289, upload-time = "2025-03-17T17:12:01.481Z" } @@ -2928,10 +3515,10 @@ name = "pyobjc-framework-applicationservices" version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pyobjc-core", marker = "(platform_machine != 'AMD64' and platform_machine != 'x86_64' and sys_platform == 'win32' and extra != 'extra-7-opentau-libero') or (platform_machine != 'AMD64' and platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine == 'AMD64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine == 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or sys_platform == 'darwin' or (sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-7-opentau-libero') or (sys_platform != 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "pyobjc-framework-cocoa", marker = "(platform_machine != 'AMD64' and platform_machine != 'x86_64' and sys_platform == 'win32' and extra != 'extra-7-opentau-libero') or (platform_machine != 'AMD64' and platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine == 'AMD64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine == 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or sys_platform == 'darwin' or (sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-7-opentau-libero') or (sys_platform != 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "pyobjc-framework-coretext", marker = "(platform_machine != 'AMD64' and platform_machine != 'x86_64' and sys_platform == 'win32' and extra != 'extra-7-opentau-libero') or (platform_machine != 'AMD64' and platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine == 'AMD64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine == 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or sys_platform == 'darwin' or (sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-7-opentau-libero') or (sys_platform != 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "pyobjc-framework-quartz", marker = "(platform_machine != 'AMD64' and platform_machine != 'x86_64' and sys_platform == 'win32' and extra != 'extra-7-opentau-libero') or (platform_machine != 'AMD64' and platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine == 'AMD64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine == 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or sys_platform == 'darwin' or (sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-7-opentau-libero') or (sys_platform != 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "pyobjc-core", marker = "sys_platform == 'darwin' or (sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "pyobjc-framework-cocoa", marker = "sys_platform == 'darwin' or (sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "pyobjc-framework-coretext", marker = "sys_platform == 'darwin' or (sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "pyobjc-framework-quartz", marker = "sys_platform == 'darwin' or (sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/be/6a/d4e613c8e926a5744fc47a9e9fea08384a510dc4f27d844f7ad7a2d793bd/pyobjc_framework_applicationservices-12.1.tar.gz", hash = "sha256:c06abb74f119bc27aeb41bf1aef8102c0ae1288aec1ac8665ea186a067a8945b", size = 103247, upload-time = "2025-11-14T10:08:52.18Z" } wheels = [ @@ -2943,7 +3530,7 @@ name = "pyobjc-framework-cocoa" version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pyobjc-core", marker = "(platform_machine != 'AMD64' and platform_machine != 'x86_64' and sys_platform == 'win32' and extra != 'extra-7-opentau-libero') or (platform_machine != 'AMD64' and platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine == 'AMD64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine == 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or sys_platform == 'darwin' or (sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-7-opentau-libero') or (sys_platform != 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "pyobjc-core", marker = "sys_platform == 'darwin' or (sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/02/a3/16ca9a15e77c061a9250afbae2eae26f2e1579eb8ca9462ae2d2c71e1169/pyobjc_framework_cocoa-12.1.tar.gz", hash = "sha256:5556c87db95711b985d5efdaaf01c917ddd41d148b1e52a0c66b1a2e2c5c1640", size = 2772191, upload-time = "2025-11-14T10:13:02.069Z" } wheels = [ @@ -2955,9 +3542,9 @@ name = "pyobjc-framework-coretext" version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pyobjc-core", marker = "(platform_machine != 'AMD64' and platform_machine != 'x86_64' and sys_platform == 'win32' and extra != 'extra-7-opentau-libero') or (platform_machine != 'AMD64' and platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine == 'AMD64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine == 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or sys_platform == 'darwin' or (sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-7-opentau-libero') or (sys_platform != 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "pyobjc-framework-cocoa", marker = "(platform_machine != 'AMD64' and platform_machine != 'x86_64' and sys_platform == 'win32' and extra != 'extra-7-opentau-libero') or (platform_machine != 'AMD64' and platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine == 'AMD64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine == 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or sys_platform == 'darwin' or (sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-7-opentau-libero') or (sys_platform != 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "pyobjc-framework-quartz", marker = "(platform_machine != 'AMD64' and platform_machine != 'x86_64' and sys_platform == 'win32' and extra != 'extra-7-opentau-libero') or (platform_machine != 'AMD64' and platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine == 'AMD64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine == 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or sys_platform == 'darwin' or (sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-7-opentau-libero') or (sys_platform != 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "pyobjc-core", marker = "sys_platform == 'darwin' or (sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "pyobjc-framework-cocoa", marker = "sys_platform == 'darwin' or (sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "pyobjc-framework-quartz", marker = "sys_platform == 'darwin' or (sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/29/da/682c9c92a39f713bd3c56e7375fa8f1b10ad558ecb075258ab6f1cdd4a6d/pyobjc_framework_coretext-12.1.tar.gz", hash = "sha256:e0adb717738fae395dc645c9e8a10bb5f6a4277e73cba8fa2a57f3b518e71da5", size = 90124, upload-time = "2025-11-14T10:14:38.596Z" } wheels = [ @@ -2969,8 +3556,8 @@ name = "pyobjc-framework-quartz" version = "12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pyobjc-core", marker = "(platform_machine != 'AMD64' and platform_machine != 'x86_64' and sys_platform == 'win32' and extra != 'extra-7-opentau-libero') or (platform_machine != 'AMD64' and platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine == 'AMD64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine == 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or sys_platform == 'darwin' or (sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-7-opentau-libero') or (sys_platform != 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "pyobjc-framework-cocoa", marker = "(platform_machine != 'AMD64' and platform_machine != 'x86_64' and sys_platform == 'win32' and extra != 'extra-7-opentau-libero') or (platform_machine != 'AMD64' and platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine == 'AMD64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine == 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or sys_platform == 'darwin' or (sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-7-opentau-libero') or (sys_platform != 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "pyobjc-core", marker = "sys_platform == 'darwin' or (sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "pyobjc-framework-cocoa", marker = "sys_platform == 'darwin' or (sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/94/18/cc59f3d4355c9456fc945eae7fe8797003c4da99212dd531ad1b0de8a0c6/pyobjc_framework_quartz-12.1.tar.gz", hash = "sha256:27f782f3513ac88ec9b6c82d9767eef95a5cf4175ce88a1e5a65875fee799608", size = 3159099, upload-time = "2025-11-14T10:21:24.31Z" } wheels = [ @@ -3042,7 +3629,7 @@ name = "pytest" version = "9.0.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "colorama", marker = "sys_platform == 'win32' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "colorama", marker = "sys_platform == 'win32' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, { name = "exceptiongroup" }, { name = "iniconfig" }, { name = "packaging" }, @@ -3158,7 +3745,7 @@ name = "pyzmq" version = "27.1.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "cffi", marker = "implementation_name == 'pypy' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "cffi", marker = "implementation_name == 'pypy' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, ] 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 = [ @@ -3189,6 +3776,39 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/26/af/78ce193dbf03567eb8c0dc30e3df2b9e56f12a670bf7eb20f9fb532c7e8a/pyzmq-27.1.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:05b12f2d32112bf8c95ef2e74ec4f1d4beb01f8b5e703b38537f8849f92cb9ba", size = 544862, upload-time = "2025-09-08T23:09:47.448Z" }, ] +[[package]] +name = "qpsolvers" +version = "4.12.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" } }, + { name = "scipy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b9/35/fc1f8b033b7ba6ecede5db093741df6a3adba6059346a586550f46254315/qpsolvers-4.12.0.tar.gz", hash = "sha256:2ec9c46294ae02bdac8969352726d2c2d5ed85f00c096881b27909e4f103ca7c", size = 235173, upload-time = "2026-05-08T09:18:06.925Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/da/68/c6e6f378f79dff83584ed18acae88c1de1ea56afc5ba9a2831ad3716083d/qpsolvers-4.12.0-py3-none-any.whl", hash = "sha256:30545f3eba98655a3c9410a071c70bb016e320a8d80a0c1a854aba00963b9b7f", size = 106752, upload-time = "2026-05-08T09:18:02.366Z" }, +] + +[package.optional-dependencies] +quadprog = [ + { name = "quadprog" }, +] + +[[package]] +name = "quadprog" +version = "0.1.13" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" } }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9e/60/fb9b56d425c5b3495bb92683c28f954aedb609ae62f14c81a1b5621ad759/quadprog-0.1.13.tar.gz", hash = "sha256:9d6dd32f2762f29b840fb83741d11e527ddf48745f63b79caad0e530b4a6a0ff", size = 16883, upload-time = "2024-10-24T16:58:58.004Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/91/8d/42ac0251e022972b2febdd206afe4f3aa2fdd0e43611fc22441d18829628/quadprog-0.1.13-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:25fda45c9fbcfa832d30ff54fff5f499572aa9f258bcb33d0ddd767a84aa57c8", size = 102669, upload-time = "2024-10-24T16:58:28.617Z" }, + { url = "https://files.pythonhosted.org/packages/98/65/ebe3cb51ad92d1c6a92705991394eee13a1362982dcd27f9ea8511ff75eb/quadprog-0.1.13-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e45501cf7765b47abb4cba100b695cae1a5f110df157209d0a123f17634225ed", size = 95081, upload-time = "2024-10-24T16:58:30.64Z" }, + { url = "https://files.pythonhosted.org/packages/95/56/69b044ad6cd724331b4e0d56dab0408c2e8c2fdccdf9b720b7285c432713/quadprog-0.1.13-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a33d2171f3f7f608ae2cce3ff8a79aa906902f79d57c1fc9b68ce3d88ba0f410", size = 505911, upload-time = "2024-10-24T16:58:32.189Z" }, + { url = "https://files.pythonhosted.org/packages/f4/73/9957c397490a4088a8d21a8e1b1b7f23fcfd456fffb47c23610ff67fd358/quadprog-0.1.13-cp310-cp310-win_amd64.whl", hash = "sha256:bb10f5ce4f0c006a8b185f8b1b474175edcfd7005a7cefa5db2d9d19f08f6bed", size = 92425, upload-time = "2024-10-24T16:58:34.789Z" }, +] + [[package]] name = "referencing" version = "0.37.0" @@ -3248,25 +3868,46 @@ socks = [ { name = "pysocks" }, ] +[[package]] +name = "rerun-sdk" +version = "0.22.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten'", + "sys_platform == 'emscripten'", +] +dependencies = [ + { name = "attrs", marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "pillow", marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "pyarrow", marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "typing-extensions", marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/a9/41/f9724c6ee4b4d45f9ae433f41fc8b4f2827d5b3f9459b9e9a9c55fdda5ab/rerun_sdk-0.22.1-cp38-abi3-macosx_10_12_x86_64.whl", hash = "sha256:176853d14bcac0b3cab8b240fe6760e32a577b1edd9ecb2fd0656e83f046a2c4", size = 46819325, upload-time = "2025-02-20T10:43:26.168Z" }, + { url = "https://files.pythonhosted.org/packages/01/8e/db9fd7e7d9d9ec6e3f0781ce6f3b71c06952f9b0c40e9720822fd83f711e/rerun_sdk-0.22.1-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:dea4a50c916bc82bd97a8f9dc44c71f9a9fccec7e73f37edfaa0de800caf5dce", size = 44566672, upload-time = "2025-02-20T10:43:33.456Z" }, + { url = "https://files.pythonhosted.org/packages/ad/41/87079d0a897e4fc2dd54a356be9556626f40ec1ff1c3393178e7ac9feb9d/rerun_sdk-0.22.1-cp38-abi3-manylinux_2_31_aarch64.whl", hash = "sha256:29d807909f5e484aa6427d9fb25706d0a154de392a4ca47eb303fbd135c0e382", size = 49830061, upload-time = "2025-02-20T10:43:40.68Z" }, + { url = "https://files.pythonhosted.org/packages/1e/db/3ce2be017d7d4ac0948fb064bf7417b36c96bc07d1b8a922017606ba03c6/rerun_sdk-0.22.1-cp38-abi3-manylinux_2_31_x86_64.whl", hash = "sha256:b9672412d0cdf57c79c10ca683e59716399da3358df78b985b25093d022ebbaf", size = 51423327, upload-time = "2025-02-20T10:43:48.471Z" }, + { url = "https://files.pythonhosted.org/packages/43/eb/edafdcba1619955c2c9b66c7a1bcbbce4ad62a1a36db984b46aa793fe366/rerun_sdk-0.22.1-cp38-abi3-win_amd64.whl", hash = "sha256:d3d0afe1b8e749a1088a0bb75f372ad7fe70eb3728bd32e07bf78300436a053d", size = 42085149, upload-time = "2025-02-20T10:43:56.563Z" }, +] + [[package]] name = "rerun-sdk" version = "0.23.1" source = { registry = "https://pypi.org/simple" } resolution-markers = [ "platform_machine == 'aarch64' and sys_platform == 'linux'", - "platform_machine == 'x86_64' and sys_platform == 'linux'", - "platform_machine != 'aarch64' and platform_machine != 'x86_64' and sys_platform == 'linux'", + "platform_machine != 'aarch64' and sys_platform == 'linux'", "sys_platform == 'darwin'", - "(platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'x86_64' and sys_platform == 'win32')", - "(platform_machine != 'AMD64' and platform_machine != 'x86_64' and sys_platform == 'win32') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')", + "sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux'", "sys_platform == 'emscripten'", ] dependencies = [ - { name = "attrs", marker = "extra == 'extra-7-opentau-libero'" }, - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero'" }, - { name = "pillow", marker = "extra == 'extra-7-opentau-libero'" }, - { name = "pyarrow", marker = "extra == 'extra-7-opentau-libero'" }, - { name = "typing-extensions", marker = "extra == 'extra-7-opentau-libero'" }, + { name = "attrs", marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "pillow", marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "pyarrow", marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "typing-extensions", marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/dd/6e/a125f4fe2de3269f443b7cb65d465ffd37a836a2dac7e4318e21239d78c8/rerun_sdk-0.23.1-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:fe06d21cfcf4d84a9396f421d4779efabec7e9674d232a2c552c8a91d871c375", size = 66094053, upload-time = "2025-04-25T13:15:48.669Z" }, @@ -3281,18 +3922,15 @@ name = "rerun-sdk" version = "0.29.0" source = { registry = "https://pypi.org/simple" } resolution-markers = [ - "platform_machine == 'x86_64' and sys_platform == 'linux'", - "platform_machine != 'x86_64' and sys_platform == 'linux'", - "(platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'x86_64' and sys_platform == 'win32')", - "(platform_machine != 'AMD64' and platform_machine != 'x86_64' and sys_platform == 'win32') or (sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')", + "sys_platform != 'emscripten'", "sys_platform == 'emscripten'", ] dependencies = [ - { name = "attrs", marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, - { name = "pillow", marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, - { name = "pyarrow", marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, - { name = "typing-extensions", marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, + { name = "attrs", marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "pillow", marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "pyarrow", marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "typing-extensions", marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/16/b9/cbde1f19a2b2b148cc0335d27e26b0aa1cbd886b619658c8659bc35f83bd/rerun_sdk-0.29.0-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:8e52f466a21e2a4fa71755e48fb767dcff6d6854561dcc12a9c1cd1b8fc58a7e", size = 112354388, upload-time = "2026-01-30T10:04:42.093Z" }, @@ -3301,6 +3939,31 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/d8/13/e65e3bcabc69f93e3b768d78e7c82070edb1d82147dba81ca799a5de4e9b/rerun_sdk-0.29.0-cp310-abi3-win_amd64.whl", hash = "sha256:bd3fc3a9f526935674ed6a021d20f802f40cdfa904e6247a779713cde038385b", size = 108256716, upload-time = "2026-01-30T10:05:00.921Z" }, ] +[[package]] +name = "robocasa" +version = "1.0.0" +source = { git = "https://github.com/robocasa/robocasa?branch=main#56e355ccc64389dfc1b8a61a33b9127b975ba681" } +dependencies = [ + { name = "gymnasium", version = "0.29.1", source = { registry = "https://pypi.org/simple" } }, + { name = "h5py" }, + { name = "hidapi" }, + { name = "imageio" }, + { name = "lerobot" }, + { name = "lxml" }, + { name = "mujoco", version = "3.3.1", source = { registry = "https://pypi.org/simple" } }, + { name = "numba" }, + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" } }, + { name = "opencv-python", version = "4.13.0.90", source = { registry = "https://pypi.org/simple" } }, + { name = "pillow" }, + { name = "pygame" }, + { name = "pynput" }, + { name = "pyyaml" }, + { name = "scipy" }, + { name = "termcolor" }, + { name = "tianshou" }, + { name = "tqdm" }, +] + [[package]] name = "robomimic" version = "0.2.0" @@ -3315,8 +3978,8 @@ dependencies = [ { name = "tensorboard" }, { name = "tensorboardx" }, { name = "termcolor" }, - { name = "torch" }, - { name = "torchvision" }, + { name = "torch", version = "2.10.0", source = { registry = "https://pypi.org/simple" } }, + { name = "torchvision", version = "0.25.0", source = { registry = "https://pypi.org/simple" } }, { name = "tqdm" }, ] sdist = { url = "https://files.pythonhosted.org/packages/3d/c3/44b1d1ea4bcb4bbed43d19e09505f4142714451ded74020d4f679cdc89fb/robomimic-0.2.0.tar.gz", hash = "sha256:ee3bb5cf9c3e1feead6b57b43c5db738fd0a8e0c015fdf6419808af8fffdc463", size = 192919, upload-time = "2021-12-17T19:00:33.279Z" } @@ -3325,8 +3988,15 @@ sdist = { url = "https://files.pythonhosted.org/packages/3d/c3/44b1d1ea4bcb4bbed name = "robosuite" version = "1.4.0" source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "platform_machine == 'aarch64' and sys_platform == 'linux'", + "platform_machine != 'aarch64' and sys_platform == 'linux'", + "sys_platform == 'darwin'", + "sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux'", + "sys_platform == 'emscripten'", +] dependencies = [ - { name = "mujoco" }, + { name = "mujoco", version = "3.4.0", source = { registry = "https://pypi.org/simple" } }, { name = "numba" }, { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" } }, { name = "opencv-python", version = "4.11.0.86", source = { registry = "https://pypi.org/simple" } }, @@ -3338,14 +4008,37 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/2e/08/fe231064caaf2766d47818ca12fd8acf10dc4e762a33dabc6293e83bfead/robosuite-1.4.0-py3-none-any.whl", hash = "sha256:aba065e7b36745738cede259457b2cb349427f3608728d867ef3a2034cb62994", size = 193477875, upload-time = "2022-12-01T07:28:53.457Z" }, ] +[[package]] +name = "robosuite" +version = "1.5.2" +source = { git = "https://github.com/ARISE-Initiative/robosuite?branch=master#232ce7d4a6ed89c949a9aba024a05c8c32fdd08b" } +resolution-markers = [ + "sys_platform != 'emscripten'", + "sys_platform == 'emscripten'", +] +dependencies = [ + { name = "mujoco", version = "3.3.1", source = { registry = "https://pypi.org/simple" } }, + { name = "numba" }, + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" } }, + { name = "opencv-python", version = "4.13.0.90", source = { registry = "https://pypi.org/simple" } }, + { name = "pillow" }, + { name = "pynput" }, + { name = "pytest" }, + { name = "qpsolvers", extra = ["quadprog"], marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "scipy" }, + { name = "termcolor" }, + { name = "tqdm" }, +] + [[package]] name = "rosbags" version = "0.11.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "lz4" }, - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero'" }, - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, { name = "ruamel-yaml" }, { name = "typing-extensions" }, { name = "zstandard" }, @@ -3420,8 +4113,9 @@ dependencies = [ { name = "imageio" }, { name = "lazy-loader" }, { name = "networkx" }, - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero'" }, - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, { name = "packaging" }, { name = "pillow" }, { name = "scipy" }, @@ -3442,8 +4136,9 @@ version = "1.7.2" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "joblib" }, - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero'" }, - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, { name = "scipy" }, { name = "threadpoolctl" }, ] @@ -3461,8 +4156,9 @@ name = "scipy" version = "1.15.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero'" }, - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/0f/37/6964b830433e654ec7485e45a00fc9a27cf868d622838f6b6d9c5ec0d532/scipy-1.15.3.tar.gz", hash = "sha256:eae3cf522bc7df64b42cad3925c876e1b0b6c35c1337c93e12c0f366f55b0eaf", size = 59419214, upload-time = "2025-05-08T16:13:05.955Z" } wheels = [ @@ -3482,10 +4178,10 @@ name = "seaborn" version = "0.13.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "matplotlib" }, - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero'" }, - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, - { name = "pandas" }, + { name = "matplotlib", marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "pandas", marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, ] 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 = [ @@ -3582,7 +4278,7 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "alabaster" }, { name = "babel" }, - { name = "colorama", marker = "sys_platform == 'win32' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "colorama", marker = "sys_platform == 'win32' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, { name = "docutils" }, { name = "imagesize" }, { name = "jinja2" }, @@ -3736,7 +4432,8 @@ dependencies = [ { name = "absl-py" }, { name = "grpcio" }, { name = "markdown" }, - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" } }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, { name = "packaging" }, { name = "pillow" }, { name = "protobuf" }, @@ -3777,7 +4474,7 @@ name = "tensorrt" version = "10.15.1.29" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "tensorrt-cu13", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'x86_64' and sys_platform == 'win32') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "tensorrt-cu13", marker = "(platform_machine != 'aarch64' and sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux') or (sys_platform == 'darwin' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'darwin' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'darwin' and extra != 'extra-7-opentau-libero') or (sys_platform == 'linux' and extra != 'extra-7-opentau-libero') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/29/8d/1b3ea6493ee07d221fdf655a936f6b9d7c4bebfad7c0fdb879440a4172ad/tensorrt-10.15.1.29.tar.gz", hash = "sha256:a78fb34aee9695b81a7485ac0648859b802ff1faaac4bde743d9c51d7493204b", size = 16701, upload-time = "2026-01-30T07:40:25.93Z" } @@ -3786,8 +4483,8 @@ name = "tensorrt-cu13" version = "10.15.1.29" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "tensorrt-cu13-bindings", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'x86_64' and sys_platform == 'win32') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "tensorrt-cu13-libs", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'x86_64' and sys_platform == 'win32') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'win32' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "tensorrt-cu13-bindings", marker = "(platform_machine != 'aarch64' and sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux') or (sys_platform == 'darwin' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'darwin' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'darwin' and extra != 'extra-7-opentau-libero') or (sys_platform == 'linux' and extra != 'extra-7-opentau-libero') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "tensorrt-cu13-libs", marker = "(platform_machine != 'aarch64' and sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux') or (sys_platform == 'darwin' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'darwin' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'darwin' and extra != 'extra-7-opentau-libero') or (sys_platform == 'linux' and extra != 'extra-7-opentau-libero') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'emscripten' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/1b/0b/ff3683ddf1960227fb2c6210e92ab83c26eda92091046c123d8dfc1adc93/tensorrt_cu13-10.15.1.29.tar.gz", hash = "sha256:60edcdf1a68526732ea613c309283af036f418f6ebcbc8e18d24566b74d776e0", size = 19084, upload-time = "2026-01-30T07:42:55.055Z" } @@ -3821,7 +4518,7 @@ name = "thop" version = "0.1.1.post2209072238" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "torch" }, + { name = "torch", version = "2.10.0", source = { registry = "https://pypi.org/simple" } }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/bb/0f/72beeab4ff5221dc47127c80f8834b4bcd0cb36f6ba91c0b1d04a1233403/thop-0.1.1.post2209072238-py3-none-any.whl", hash = "sha256:01473c225231927d2ad718351f78ebf7cffe6af3bed464c4f1ba1ef0f7cdda27", size = 15443, upload-time = "2022-09-07T14:38:37.211Z" }, @@ -3836,13 +4533,33 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/32/d5/f9a850d79b0851d1d4ef6456097579a9005b31fea68726a4ae5f2d82ddd9/threadpoolctl-3.6.0-py3-none-any.whl", hash = "sha256:43a0b8fd5a2928500110039e43a5eed8480b918967083ea48dc3ab9f13c4a7fb", size = 18638, upload-time = "2025-03-13T13:49:21.846Z" }, ] +[[package]] +name = "tianshou" +version = "0.4.10" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "gym" }, + { name = "h5py" }, + { name = "numba" }, + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" } }, + { name = "protobuf" }, + { name = "tensorboard" }, + { name = "torch", version = "2.7.1", source = { registry = "https://pypi.org/simple" } }, + { name = "tqdm" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/1b/18/f1a9e2879565028e79dfac62046f90f958e8597dd2ca0a065433daddf91d/tianshou-0.4.10.tar.gz", hash = "sha256:c97ae1c689a9e63df527301b1c6c8ce8661819909efb7d8b632ec9eb4ab62fda", size = 120136, upload-time = "2022-10-17T05:16:31.384Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/36/55/234ed594bc077c156d865e85cb5d9e13ed122c36970fa70d50ce142d22ed/tianshou-0.4.10-py3-none-any.whl", hash = "sha256:4c52df8552a3c32e6d17996c5d89de3383a00d43648b6d0ffcbe52181a001b74", size = 159900, upload-time = "2022-10-17T05:16:28.832Z" }, +] + [[package]] name = "tifffile" version = "2025.5.10" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero'" }, - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/44/d0/18fed0fc0916578a4463f775b0fbd9c5fed2392152d039df2fb533bfdd5d/tifffile-2025.5.10.tar.gz", hash = "sha256:018335d34283aa3fd8c263bae5c3c2b661ebc45548fde31504016fcae7bf1103", size = 365290, upload-time = "2025-05-10T19:22:34.386Z" } wheels = [ @@ -3894,32 +4611,79 @@ wheels = [ [[package]] name = "torch" -version = "2.10.0" +version = "2.7.1" source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten'", + "sys_platform == 'emscripten'", +] dependencies = [ - { name = "cuda-bindings", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "filelock" }, - { name = "fsspec" }, - { name = "jinja2" }, - { name = "networkx" }, - { name = "nvidia-cublas-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "nvidia-cuda-cupti-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "nvidia-cuda-nvrtc-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "nvidia-cuda-runtime-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "nvidia-cudnn-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "nvidia-cufft-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "nvidia-cufile-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "nvidia-curand-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "nvidia-cusolver-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "nvidia-cusparse-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "nvidia-cusparselt-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "nvidia-nccl-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "nvidia-nvjitlink-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "nvidia-nvshmem-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "nvidia-nvtx-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "sympy" }, - { name = "triton", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, - { name = "typing-extensions" }, + { name = "filelock", marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "fsspec", version = "2025.3.0", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "jinja2", marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "networkx", marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "nvidia-cublas-cu12", version = "12.6.4.1", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-robocasa') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "nvidia-cuda-cupti-cu12", version = "12.6.80", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-robocasa') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "nvidia-cuda-nvrtc-cu12", version = "12.6.77", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-robocasa') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "nvidia-cuda-runtime-cu12", version = "12.6.77", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-robocasa') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "nvidia-cudnn-cu12", version = "9.5.1.17", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-robocasa') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "nvidia-cufft-cu12", version = "11.3.0.4", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-robocasa') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "nvidia-cufile-cu12", version = "1.11.1.6", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-robocasa') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "nvidia-curand-cu12", version = "10.3.7.77", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-robocasa') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "nvidia-cusolver-cu12", version = "11.7.1.2", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-robocasa') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "nvidia-cusparse-cu12", version = "12.5.4.2", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-robocasa') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "nvidia-cusparselt-cu12", version = "0.6.3", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-robocasa') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "nvidia-nccl-cu12", version = "2.26.2", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-robocasa') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "nvidia-nvjitlink-cu12", version = "12.6.85", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-robocasa') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "nvidia-nvtx-cu12", version = "12.6.77", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-robocasa') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "sympy", marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "triton", version = "3.3.1", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-robocasa') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "typing-extensions", marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/6a/27/2e06cb52adf89fe6e020963529d17ed51532fc73c1e6d1b18420ef03338c/torch-2.7.1-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:a103b5d782af5bd119b81dbcc7ffc6fa09904c423ff8db397a1e6ea8fd71508f", size = 99089441, upload-time = "2025-06-04T17:38:48.268Z" }, + { url = "https://files.pythonhosted.org/packages/0a/7c/0a5b3aee977596459ec45be2220370fde8e017f651fecc40522fd478cb1e/torch-2.7.1-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:fe955951bdf32d182ee8ead6c3186ad54781492bf03d547d31771a01b3d6fb7d", size = 821154516, upload-time = "2025-06-04T17:36:28.556Z" }, + { url = "https://files.pythonhosted.org/packages/f9/91/3d709cfc5e15995fb3fe7a6b564ce42280d3a55676dad672205e94f34ac9/torch-2.7.1-cp310-cp310-win_amd64.whl", hash = "sha256:885453d6fba67d9991132143bf7fa06b79b24352f4506fd4d10b309f53454162", size = 216093147, upload-time = "2025-06-04T17:39:38.132Z" }, + { url = "https://files.pythonhosted.org/packages/92/f6/5da3918414e07da9866ecb9330fe6ffdebe15cb9a4c5ada7d4b6e0a6654d/torch-2.7.1-cp310-none-macosx_11_0_arm64.whl", hash = "sha256:d72acfdb86cee2a32c0ce0101606f3758f0d8bb5f8f31e7920dc2809e963aa7c", size = 68630914, upload-time = "2025-06-04T17:39:31.162Z" }, +] + +[[package]] +name = "torch" +version = "2.10.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf'", + "sys_platform == 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf'", + "platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", + "platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", + "sys_platform == 'darwin' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", + "sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", + "sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", +] +dependencies = [ + { name = "cuda-bindings", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "filelock", marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, + { name = "fsspec", version = "2025.10.0", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, + { name = "jinja2", marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, + { name = "networkx", marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, + { name = "nvidia-cublas-cu12", version = "12.8.4.1", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "nvidia-cuda-cupti-cu12", version = "12.8.90", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "nvidia-cuda-nvrtc-cu12", version = "12.8.93", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "nvidia-cuda-runtime-cu12", version = "12.8.90", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "nvidia-cudnn-cu12", version = "9.10.2.21", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "nvidia-cufft-cu12", version = "11.3.3.83", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "nvidia-cufile-cu12", version = "1.13.1.3", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "nvidia-curand-cu12", version = "10.3.9.90", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "nvidia-cusolver-cu12", version = "11.7.3.90", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "nvidia-cusparse-cu12", version = "12.5.8.93", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "nvidia-cusparselt-cu12", version = "0.7.1", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "nvidia-nccl-cu12", version = "2.27.5", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "nvidia-nvjitlink-cu12", version = "12.8.93", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "nvidia-nvshmem-cu12", marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "nvidia-nvtx-cu12", version = "12.8.90", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "sympy", marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, + { name = "triton", version = "3.6.0", source = { registry = "https://pypi.org/simple" }, marker = "(platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (platform_machine != 'x86_64' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (sys_platform != 'linux' and extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "typing-extensions", marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/5b/30/bfebdd8ec77db9a79775121789992d6b3b75ee5494971294d7b4b7c999bc/torch-2.10.0-2-cp310-none-macosx_11_0_arm64.whl", hash = "sha256:2b980edd8d7c0a68c4e951ee1856334a43193f98730d97408fbd148c1a933313", size = 79411457, upload-time = "2026-02-10T21:44:59.189Z" }, @@ -3939,15 +4703,44 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/49/16/6713f9b26165f33f09e7b637f7189ec308b7f2ec3050cc60397f1b9f232e/torchcodec-0.4.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:950ccb7d113e9fdc3c05361ce7f5c09bde120df481eb3e6d8ce79db9e202e30f", size = 1317552, upload-time = "2025-05-16T08:48:12.567Z" }, ] +[[package]] +name = "torchvision" +version = "0.22.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten'", + "sys_platform == 'emscripten'", +] +dependencies = [ + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "pillow", marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "torch", version = "2.7.1", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/15/2c/7b67117b14c6cc84ae3126ca6981abfa3af2ac54eb5252b80d9475fb40df/torchvision-0.22.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:3b47d8369ee568c067795c0da0b4078f39a9dfea6f3bc1f3ac87530dfda1dd56", size = 1947825, upload-time = "2025-06-04T17:43:15.523Z" }, + { url = "https://files.pythonhosted.org/packages/6c/9f/c4dcf1d232b75e28bc37e21209ab2458d6d60235e16163544ed693de54cb/torchvision-0.22.1-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:990de4d657a41ed71680cd8be2e98ebcab55371f30993dc9bd2e676441f7180e", size = 2512611, upload-time = "2025-06-04T17:43:03.951Z" }, + { url = "https://files.pythonhosted.org/packages/e2/99/db71d62d12628111d59147095527a0ab492bdfecfba718d174c04ae6c505/torchvision-0.22.1-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:3347f690c2eed6d02aa0edfb9b01d321e7f7cf1051992d96d8d196c39b881d49", size = 7485668, upload-time = "2025-06-04T17:43:09.453Z" }, + { url = "https://files.pythonhosted.org/packages/32/ff/4a93a4623c3e5f97e8552af0f9f81d289dcf7f2ac71f1493f1c93a6b973d/torchvision-0.22.1-cp310-cp310-win_amd64.whl", hash = "sha256:86ad938f5a6ca645f0d5fb19484b1762492c2188c0ffb05c602e9e9945b7b371", size = 1707961, upload-time = "2025-06-04T17:43:13.038Z" }, +] + [[package]] name = "torchvision" version = "0.25.0" source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf'", + "sys_platform == 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf'", + "platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", + "platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", + "sys_platform == 'darwin' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", + "sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", + "sys_platform == 'emscripten' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", +] dependencies = [ - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero'" }, - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, - { name = "pillow" }, - { name = "torch" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "pillow", marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, + { name = "torch", version = "2.10.0", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or extra == 'extra-7-opentau-urdf'" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/50/ae/cbf727421eb73f1cf907fbe5788326a08f111b3f6b6ddca15426b53fec9a/torchvision-0.25.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a95c47abb817d4e90ea1a8e57bd0d728e3e6b533b3495ae77d84d883c4d11f56", size = 1874919, upload-time = "2026-01-21T16:27:47.617Z" }, @@ -3961,7 +4754,7 @@ name = "tqdm" version = "4.67.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "colorama", marker = "sys_platform == 'win32' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "colorama", marker = "sys_platform == 'win32' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/09/a9/6ba95a270c6f1fbcd8dac228323f2777d886cb206987444e4bce66338dd4/tqdm-4.67.3.tar.gz", hash = "sha256:7d825f03f89244ef73f1d4ce193cb1774a8179fd96f31d7e1dcde62092b960bb", size = 169598, upload-time = "2026-02-03T17:35:53.048Z" } wheels = [ @@ -3984,8 +4777,9 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "filelock" }, { name = "huggingface-hub" }, - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero'" }, - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, { name = "packaging" }, { name = "pyyaml" }, { name = "regex" }, @@ -3999,10 +4793,28 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/41/b1/d7520cc5cb69c825599042eb3a7c986fa9baa8a8d2dea9acd78e152c81e2/transformers-4.53.3-py3-none-any.whl", hash = "sha256:5aba81c92095806b6baf12df35d756cf23b66c356975fb2a7fa9e536138d7c75", size = 10826382, upload-time = "2025-07-22T07:30:48.458Z" }, ] +[[package]] +name = "triton" +version = "3.3.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten'", +] +dependencies = [ + { name = "setuptools", marker = "(sys_platform != 'emscripten' and extra == 'extra-7-opentau-robocasa') or (sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/8d/a9/549e51e9b1b2c9b854fd761a1d23df0ba2fbc60bd0c13b489ffa518cfcb7/triton-3.3.1-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b74db445b1c562844d3cfad6e9679c72e93fdfb1a90a24052b03bb5c49d1242e", size = 155600257, upload-time = "2025-05-29T23:39:36.085Z" }, +] + [[package]] name = "triton" version = "3.6.0" source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "sys_platform != 'emscripten' and extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf'", + "platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-7-opentau-libero' and extra != 'extra-7-opentau-robocasa' and extra != 'extra-7-opentau-urdf'", +] wheels = [ { url = "https://files.pythonhosted.org/packages/44/ba/b1b04f4b291a3205d95ebd24465de0e5bf010a2df27a4e58a9b5f039d8f2/triton-3.6.0-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6c723cfb12f6842a0ae94ac307dba7e7a44741d720a40cf0e270ed4a4e3be781", size = 175972180, upload-time = "2026-01-20T16:15:53.664Z" }, { url = "https://files.pythonhosted.org/packages/8c/f7/f1c9d3424ab199ac53c2da567b859bcddbb9c9e7154805119f8bd95ec36f/triton-3.6.0-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a6550fae429e0667e397e5de64b332d1e5695b73650ee75a6146e2e902770bea", size = 188105201, upload-time = "2026-01-20T16:00:29.272Z" }, @@ -4202,10 +5014,11 @@ version = "2.18.3" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "asciitree" }, - { name = "fasteners", marker = "sys_platform != 'emscripten' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, + { name = "fasteners", marker = "sys_platform != 'emscripten' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, { name = "numcodecs" }, - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero'" }, - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-urdf' or extra != 'extra-7-opentau-libero'" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-libero' or (extra == 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.5", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-7-opentau-robocasa' or (extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra != 'extra-7-opentau-urdf')" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(extra == 'extra-7-opentau-libero' and extra == 'extra-7-opentau-robocasa') or (extra != 'extra-7-opentau-robocasa' and extra == 'extra-7-opentau-urdf') or (extra != 'extra-7-opentau-libero' and extra == 'extra-7-opentau-urdf')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/23/c4/187a21ce7cf7c8f00c060dd0e04c2a81139bb7b1ab178bba83f2e1134ce2/zarr-2.18.3.tar.gz", hash = "sha256:2580d8cb6dd84621771a10d31c4d777dca8a27706a1a89b29f42d2d37e2df5ce", size = 3603224, upload-time = "2024-09-04T23:20:16.595Z" } wheels = [