oopsie-data-tools 0.2.0__py3-none-any.whl

oopsie_data_tools/utils/validation/episode_validator.py

@@ -0,0 +1,315 @@
+"""Semantic validation of EpisodeData.
+
+All checks here operate on in-memory data (numpy arrays, VideoInfo structs)
+with no file I/O.  This makes the same validation callable from:
+  - The HDF5 validation pipeline (after episode_loader produces EpisodeData)
+  - EpisodeRecorder pre-save (build EpisodeData from in-memory buffers first)
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+import numpy as np
+
+from oopsie_data_tools.annotation_tool.annotation_schema import (
+    OUTCOME_SUCCESS,
+    OUTCOMES,
+    SUCCESS_THRESHOLD,
+)
+from oopsie_data_tools.utils.validation.episode_data import EpisodeData
+from oopsie_data_tools.utils.validation.errors import EpisodeValidationError
+
+MAX_IMAGE_SIZE = 1280
+MIN_IMAGE_SIZE = 180
+# Bounds on episode *duration*, not step count: trajectory_length / control_freq.
+MIN_EPISODE_DURATION_S = 1
+MAX_EPISODE_DURATION_S = 600
+
+
+def validate_episode(data: EpisodeData, strict_annotation_check: bool = False) -> None:
+    """Run all semantic checks on a loaded EpisodeData.
+
+    Raises EpisodeValidationError with a descriptive message on the first failure.
+    """
+    _validate_metadata(data)
+    _validate_profile_consistency(data)
+    _validate_trajectory_lengths(data)
+    _validate_video_specs(data)
+    if strict_annotation_check:
+        if not data.annotations:
+            raise EpisodeValidationError("Annotations dict is empty, must be provided for upload")
+        _validate_annotations(data)
+
+
+# ── Individual checks ──────────────────────────────────────────────────────────
+
+
+def _validate_metadata(data: EpisodeData) -> None:
+    if not data.language_instruction:
+        raise EpisodeValidationError("language_instruction is empty")
+    if not data.episode_id:
+        raise EpisodeValidationError("episode_id is empty")
+    if not data.lab_id:
+        raise EpisodeValidationError("lab_id is empty")
+    if data.lab_id == "your_lab_id":
+        raise EpisodeValidationError("lab_id has not been changed from the placeholder value")
+    if not data.operator_name:
+        raise EpisodeValidationError("operator_name is empty")
+    if not (data.control_freq > 0):
+        raise EpisodeValidationError("control_freq must be > 0")
+    duration_s = data.trajectory_length / data.control_freq
+    if not (MIN_EPISODE_DURATION_S <= duration_s <= MAX_EPISODE_DURATION_S):
+        raise EpisodeValidationError(
+            f"episode duration {duration_s:.2f}s out of range "
+            f"[{MIN_EPISODE_DURATION_S}, {MAX_EPISODE_DURATION_S}]s "
+            f"({data.trajectory_length} steps at {data.control_freq:g} Hz)"
+        )
+
+
+def _validate_profile_consistency(data: EpisodeData) -> None:
+    """Check that observations, actions, and videos match the embedded robot profile."""
+    profile = data.robot_profile
+
+    for key in profile.robot_state_keys:
+        if key not in data.observations:
+            raise EpisodeValidationError(
+                f"Missing observations key required by profile: {key}. Got {list(data.observations.keys())}, required by profile.robot_state_keys={profile.robot_state_keys}"
+            )
+
+    for key in profile.action_space:
+        if key not in data.actions:
+            raise EpisodeValidationError(
+                f"Missing actions key required by profile.action_space: {key}. Got {list(data.actions.keys())}, required by profile.action_space={profile.action_space}"
+            )
+
+    for cam in profile.camera_names:
+        if cam not in data.videos:
+            raise EpisodeValidationError(
+                f"Missing video for camera required by profile: {cam}. Got {list(data.videos.keys())}, required by profile.camera_names={profile.camera_names}"
+            )
+
+    # The reverse direction. The profile is the episode's documentation, so anything present
+    # but undeclared has no joint names, no units and no DOF to check against, and cannot be
+    # interpreted by anyone downstream. EpisodeRecorder cannot produce this — it writes
+    # exactly profile.robot_state_keys — so this only ever catches hand-built or externally
+    # converted files.
+    _reject_undeclared(
+        "observations/robot_states", data.observations, profile.robot_state_keys,
+        "profile.robot_state_keys",
+    )
+    _reject_undeclared("actions", data.actions, profile.action_space, "profile.action_space")
+
+    _validate_cartesian_arm_count(data)
+
+    jp_obs = data.observations.get("joint_position")
+    if jp_obs is not None and jp_obs.ndim >= 2:
+        if len(profile.robot_state_joint_names) != jp_obs.shape[-1]:
+            raise EpisodeValidationError(
+                "robot_state_joint_names count does not match observations/joint_position DOF: "
+                f"the robot profile lists {len(profile.robot_state_joint_names)} joint name(s) in "
+                f"robot_state_joint_names, but the recorded observations/joint_position has "
+                f"{jp_obs.shape[-1]} DOF (last axis). Fix robot_state_joint_names in the robot "
+                "profile (or the recorded joint_position) so the two counts match."
+            )
+
+    if profile.action_joint_names:
+        for key in ("joint_position", "joint_velocity"):
+            arr = data.actions.get(key)
+            if arr is not None and arr.ndim >= 2:
+                if len(profile.action_joint_names) != arr.shape[-1]:
+                    raise EpisodeValidationError(
+                        f"action_joint_names count does not match actions/{key} DOF: "
+                        f"the robot profile lists {len(profile.action_joint_names)} joint name(s) in "
+                        f"action_joint_names, but the recorded actions/{key} has {arr.shape[-1]} DOF "
+                        "(last axis). Fix action_joint_names in the robot profile (or the recorded "
+                        "actions) so the two counts match."
+                    )
+
+
+def _reject_undeclared(
+    group: str, present: dict[str, Any], declared: list[str], declared_by: str
+) -> None:
+    """Every dataset in ``group`` must be declared by the profile."""
+    undeclared = sorted(set(present) - set(declared))
+    if undeclared:
+        raise EpisodeValidationError(
+            f"{group} contains {len(undeclared)} key(s) the robot profile does not declare: "
+            f"{undeclared}. The profile is what documents an episode, so undeclared data has "
+            f"no joint names, units or expected DOF, and nothing downstream can interpret it. "
+            f"Add the key(s) to {declared_by}, or stop recording them. "
+            f"{declared_by}={list(declared)}"
+        )
+
+
+def _validate_cartesian_arm_count(data: EpisodeData) -> None:
+    """A cartesian pose must carry one arm's worth of DOF per arm the profile declares.
+
+    ``[x, y, z, qx, qy, qz, qw]`` is 7 values, so a bimanual robot records 14. Joint counts
+    cannot be constrained this way — two arms need not have the same DOF, and a 7+6 pair is
+    legitimate — but the end-effector pose is fixed by its representation.
+    """
+    expected = 14 if data.robot_profile.is_biarm else 7
+    arms = "biarm" if data.robot_profile.is_biarm else "single-arm"
+
+    for group, arrays in (("observations", data.observations), ("actions", data.actions)):
+        arr = arrays.get("cartesian_position")
+        if arr is None or arr.ndim < 2:
+            continue
+        if arr.shape[-1] != expected:
+            raise EpisodeValidationError(
+                f"{group}/cartesian_position has {arr.shape[-1]} DOF, but the profile "
+                f"declares a {arms} robot (is_biarm={data.robot_profile.is_biarm}), which "
+                f"means {expected} — [x, y, z, qx, qy, qz, qw] per arm. Either the pose is "
+                f"missing an arm or is_biarm is wrong."
+            )
+
+
+def _validate_trajectory_lengths(data: EpisodeData) -> None:
+    """All observation and action arrays must share the same trajectory length."""
+    lengths: dict[str, int] = {}
+
+    for key, arr in data.observations.items():
+        if arr.ndim > 0:
+            lengths[f"observations/{key}"] = arr.shape[0]
+
+    for key, arr in data.actions.items():
+        if arr.ndim > 0:
+            lengths[f"actions/{key}"] = arr.shape[0]
+
+    if not lengths:
+        raise EpisodeValidationError("No trajectory data found in observations or actions")
+
+    unique = set(lengths.values())
+    if len(unique) != 1:
+        raise EpisodeValidationError(f"Inconsistent trajectory lengths: {lengths}")
+
+    actual_T = unique.pop()
+    if actual_T != data.trajectory_length:
+        raise EpisodeValidationError(
+            f"trajectory_length field ({data.trajectory_length}) does not match "
+            f"array shapes ({actual_T})"
+        )
+
+
+def _validate_video_specs(data: EpisodeData) -> None:
+    """Check per-camera resolution, frame count alignment, and duration alignment."""
+    if not data.videos:
+        raise EpisodeValidationError("No video entries found")
+
+    T = data.trajectory_length
+    frame_tolerance = max(5, int(0.1 * T))
+    expected_duration = T / data.control_freq
+
+    frame_counts: dict[str, int] = {}
+    for cam, info in data.videos.items():
+        if not (info.width >= MIN_IMAGE_SIZE and info.height >= MIN_IMAGE_SIZE):
+            raise EpisodeValidationError(
+                f"Video too small for camera {cam}: {info.width}x{info.height} "
+                f"(min {MIN_IMAGE_SIZE}px)"
+            )
+        if not (info.width <= MAX_IMAGE_SIZE and info.height <= MAX_IMAGE_SIZE):
+            raise EpisodeValidationError(
+                f"Video too large for camera {cam}: {info.width}x{info.height} "
+                f"(max {MAX_IMAGE_SIZE}px)"
+            )
+        if not (abs(info.frame_count - T) <= frame_tolerance):
+            raise EpisodeValidationError(
+                f"Frame count / trajectory mismatch for camera {cam}: "
+                f"frames={info.frame_count}, trajectory={T}"
+            )
+        duration = info.frame_count / info.fps
+        if not (abs(duration - expected_duration) <= 0.5):
+            raise EpisodeValidationError(
+                f"Video duration / control_freq mismatch for camera {cam}: "
+                f"duration={duration:.2f}s, expected={expected_duration:.2f}s"
+            )
+        frame_counts[cam] = info.frame_count
+
+    if len(frame_counts) > 1:
+        counts = list(frame_counts.values())
+        if not (max(counts) - min(counts) <= 1):
+            raise EpisodeValidationError(
+                f"Inconsistent frame counts across cameras: {frame_counts}"
+            )
+
+
+def _annotation_attr_scalar_str(val: Any) -> str:
+    """Normalize HDF5 attr scalars (bytes, numpy, str) to a trimmed string."""
+    if val is None:
+        return ""
+    if isinstance(val, bytes):
+        return val.decode("utf-8", errors="replace").strip()
+    if isinstance(val, str):
+        return val.strip()
+    if isinstance(val, np.generic):
+        return _annotation_attr_scalar_str(val.item())
+    if isinstance(val, np.ndarray) and val.shape == ():
+        return _annotation_attr_scalar_str(val.item())
+    return str(val).strip()
+
+
+def _validate_annotations(data: EpisodeData) -> None:
+    """Every annotator subgroup must have a numeric success score in [0.0, 1.0].
+
+    Beyond that, the taxonomy fields are all optional: a partial annotation is valid, and
+    a failure with no taxonomy at all is valid. What is checked is only that what *is*
+    stored is readable and self-consistent — a malformed ``taxonomy`` blob, or an
+    ``outcome`` that contradicts the ``success`` float, would make different readers reach
+    different conclusions about the same episode.
+
+    v1 files carry no ``outcome``, so they skip that check and stay valid unchanged.
+    """
+    if not data.annotations:
+        raise EpisodeValidationError("annotations dict is empty")
+
+    for annotator, attrs in data.annotations.items():
+        if "success" not in attrs:
+            raise EpisodeValidationError(
+                f"episode_annotations/{annotator} is missing 'success' — "
+                "episode has not been fully annotated yet"
+            )
+        try:
+            success = float(attrs["success"])
+        except (TypeError, ValueError) as e:
+            raise EpisodeValidationError(
+                f"episode_annotations/{annotator}/success is not numeric: {attrs['success']!r}"
+            ) from e
+        if np.isnan(success):
+            raise EpisodeValidationError(
+                f"episode_annotations/{annotator}/success is NaN — "
+                "episode has not been fully annotated yet"
+            )
+        if not (0.0 <= success <= 1.0):
+            raise EpisodeValidationError(
+                f"episode_annotations/{annotator}/success out of range [0.0, 1.0]: {success}"
+            )
+
+        taxonomy_raw = _annotation_attr_scalar_str(attrs.get("taxonomy", ""))
+        if taxonomy_raw:
+            try:
+                parsed = json.loads(taxonomy_raw)
+            except json.JSONDecodeError as e:
+                raise EpisodeValidationError(
+                    f"episode_annotations/{annotator}/taxonomy is not valid JSON: "
+                    f"{taxonomy_raw!r}"
+                ) from e
+            if not isinstance(parsed, dict):
+                raise EpisodeValidationError(
+                    f"episode_annotations/{annotator}/taxonomy must be a JSON object, "
+                    f"got {type(parsed).__name__}"
+                )
+
+            outcome = _annotation_attr_scalar_str(parsed.get("outcome", "")).lower()
+            if outcome:
+                if outcome not in OUTCOME_SUCCESS:
+                    raise EpisodeValidationError(
+                        f"episode_annotations/{annotator}/taxonomy has unrecognized "
+                        f"outcome {outcome!r}; expected one of {OUTCOMES}"
+                    )
+                if (outcome == "failure") != (success < SUCCESS_THRESHOLD):
+                    raise EpisodeValidationError(
+                        f"episode_annotations/{annotator}: outcome {outcome!r} disagrees "
+                        f"with success {success} (threshold {SUCCESS_THRESHOLD})"
+                    )

oopsie_data_tools/utils/validation/errors.py

@@ -0,0 +1,17 @@
+"""The error every validation failure raises."""
+
+from __future__ import annotations
+
+
+class EpisodeValidationError(AssertionError):
+    """An episode does not conform to the oopsiedata schema.
+
+    Subclasses :class:`AssertionError` deliberately. Validation used to be built entirely
+    out of bare ``assert`` statements, and ``except AssertionError`` is the documented way
+    to catch a validation failure — lab scripts will have copied it. Inheriting keeps every
+    one of those callers working while giving new code something specific to catch.
+
+    The reason for moving off ``assert`` at all: ``python -O`` strips assert statements, so
+    the entire schema check silently evaporated under optimised interpreters. This is the
+    gate in front of a public dataset; it should not depend on an interpreter flag.
+    """

oopsie_data_tools/utils/validation/validation_utils.py

@@ -0,0 +1,88 @@
+"""Public validation API.
+
+Composes episode_loader (file I/O, schema detection, video loading) and
+episode_validator (semantic checks on loaded data) into the entry points
+used by the CLI and tests.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from pathlib import Path
+
+from oopsie_data_tools.utils.h5 import find_episode_files
+from oopsie_data_tools.utils.log import setup_logger
+from oopsie_data_tools.utils.validation.episode_loader import load_episode_from_h5
+from oopsie_data_tools.utils.validation.episode_validator import validate_episode
+from oopsie_data_tools.utils.validation.errors import EpisodeValidationError
+
+logger = logging.getLogger(__name__)
+
+
+def validate_h5_file(
+    h5_path: str,
+    strict_annotation_check: bool = False,
+    log_path: str | Path | None = None,
+) -> bool:
+    """Validate a single HDF5 episode file.
+
+    Args:
+        h5_path: Path to the .h5 file.
+        strict_annotation_check: If True, require that annotations are present and non-empty.
+        log_path: Optional file to also write log output to (mirrors ``validate_session_dir``).
+
+    Returns:
+        True if all checks pass.
+
+    Raises:
+        EpisodeValidationError: On the first validation failure. It subclasses
+            ``AssertionError``, so ``except AssertionError`` still catches it.
+    """
+    if log_path is not None:
+        setup_logger(__name__, log_path)
+    data = load_episode_from_h5(h5_path)
+    validate_episode(data, strict_annotation_check=strict_annotation_check)
+    return True
+
+
+def validate_session_dir(session_dir: str, strict_annotation_check: bool = False, log_path: str | Path | None = None) -> int:
+    """Validate every ``*.h5`` / ``*.hdf5`` file in a session directory.
+
+    Returns:
+        0 if all files passed, 1 if any failed or the directory is invalid.
+    """
+    if log_path is not None:
+        setup_logger(__name__, log_path)
+
+    session_path = os.path.abspath(os.path.normpath(session_dir))
+    if not os.path.isdir(session_path):
+        logger.error("Not a directory: %s", session_path)
+        return 1
+
+    h5_files = [str(p) for p in find_episode_files(session_path)]
+
+    if not h5_files:
+        logger.error("No .h5 or .hdf5 files found in %s", session_path)
+        return 1
+
+    logger.info("Validating %d HDF5 file(s) in: %s", len(h5_files), session_path)
+    failures = 0
+    for i, path in enumerate(h5_files, 1):
+        name = os.path.basename(path)
+        logger.info("[%d/%d] %s", i, len(h5_files), name)
+        try:
+            validate_h5_file(path, strict_annotation_check=strict_annotation_check)
+            logger.info("%s passed", name)
+        except EpisodeValidationError as e:
+            failures += 1
+            logger.error("%s failed: %s", name, e)
+        except Exception as e:
+            # Anything else is a bug in the validator rather than a bad episode, so it is
+            # reported differently on purpose.
+            failures += 1
+            logger.error("%s unexpected error: %s", name, e)
+
+    passed = len(h5_files) - failures
+    logger.info("Summary: %d/%d passed", passed, len(h5_files))
+    return 1 if failures else 0

oopsie_data_tools-0.2.0.dist-info/METADATA

@@ -0,0 +1,131 @@
+Metadata-Version: 2.4
+Name: oopsie-data-tools
+Version: 0.2.0
+Summary: Collect, annotate, validate and upload robotic manipulation rollout data.
+License-File: LICENSE
+Requires-Python: >=3.8
+Requires-Dist: flask>=3.0.0
+Requires-Dist: h5py>=3.7.0
+Requires-Dist: huggingface-hub>=0.36.2
+Requires-Dist: imageio-ffmpeg>=0.5.1
+Requires-Dist: imageio>=2.35.1
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: opencv-python>=4.11.0.86
+Requires-Dist: pyyaml>=6.0.0
+Requires-Dist: scipy>=1.10.1
+Provides-Extra: droid
+Requires-Dist: pandas>=2.0.0; extra == 'droid'
+Requires-Dist: pillow>=10.0.0; extra == 'droid'
+Requires-Dist: tqdm>=4.66.0; extra == 'droid'
+Requires-Dist: tyro>=0.9.0; extra == 'droid'
+Description-Content-Type: text/markdown
+
+# Oopsie Tools
+
+Tools for collecting, annotating, inspecting, and converting robotic manipulation rollout data.
+
+This repository currently provides around:
+
+- HDF5 episode recording (`EpisodeRecorder`)
+- Web annotation workflows
+- In-the-loop annotation during policy rollout
+
+## Command line tool
+
+Installing the package (`uv sync`, or `pip install -e .`) provides the `oopsie-data` command:
+
+```bash
+oopsie-data init                                 # first-time setup (lab id + HF token)
+oopsie-data show-config                          # where configs are read from, and what is in them
+oopsie-data new-profile                          # starter robot profile to fill in
+oopsie-data annotate --samples-dir ./samples     # launch the web annotation UI
+oopsie-data validate --path ./samples            # check episodes against the schema
+oopsie-data upload   --path ./samples            # validate, then upload to HuggingFace
+oopsie-data submissions                          # what your lab has already uploaded
+oopsie-data inspect episode.h5                   # dump an episode's structure
+oopsie-data restructure --source ./samples       # split a folder that is too large to upload
+oopsie-data upload --path ./samples --with-restructure   # ...or do both in one step
+```
+
+`init` prompts for your lab id and HuggingFace token and saves them to a location the other
+commands find automatically. It checks the token against the HuggingFace API, but only warns
+if that fails and saves it regardless — so a wrong token surfaces at `oopsie-data upload`, not
+at `init`. `new-profile` writes a robot-profile skeleton you fill in; it will not load until
+you do. `annotate` asks for your annotator name if `--annotator-name` is not passed.
+`inspect` is a plain structure dump, so it also works on a file `validate` rejects.
+`restructure` is only needed if `upload` stops you: HuggingFace enforces a per-directory
+file limit, and it writes a copy of your session in which every directory over that limit
+has been split into numbered subfolders. Directories already under it are copied through
+unchanged, and the original is never modified.
+
+Credentials and robot profiles are looked up separately, so the tool also works when
+installed outside a checkout of this repository.
+
+`contributor_config.yaml` belongs to you and is shared by every project:
+
+1. `$OOPSIE_CONFIG_DIR`
+2. `~/.config/oopsie-data` (or `$XDG_CONFIG_HOME/oopsie-data`)
+3. this repository's `configs/` directory
+
+Robot profiles belong to the robot code that uses them, and are never expected in your user
+config directory:
+
+1. `$OOPSIE_ROBOT_PROFILES_DIR`
+2. `./robot_profiles` or `./configs/robot_profiles`, relative to where you run the command
+3. this repository's `configs/robot_profiles`
+
+In practice a profile is usually loaded by explicit path — `load_robot_profile("path/to.yaml")`.
+Nothing is ever read out of the installed package: config that lives in `site-packages` is
+read-only, invisible to you, and would silently shadow your own. Run `oopsie-data new-profile` to
+write a starter profile into `./robot_profiles/` and fill it in from there. Pass
+`oopsie-data --config-dir <dir> <command>` to override the credential location for a single run.
+
+Run `oopsie-data show-config` to see which of these locations is actually being used, along with
+the lab id and token in effect.
+
+### Upgrading: `configs/contributor_config.yaml` is no longer tracked
+
+That file holds your HuggingFace token, and it used to be committed to the repository — which
+meant `.gitignore` did not apply to it and your token showed up in `git status`. It is now
+untracked and ignored.
+
+If you have an existing clone with your credentials filled in, `git pull` may refuse:
+
+```
+error: Your local changes to the following files would be overwritten by merge:
+        configs/contributor_config.yaml
+```
+
+Your credentials are safe; git is just protecting the file. Move them out of the working tree:
+
+```bash
+oopsie-data init            # writes to ~/.config/oopsie-data, verifies nothing is lost
+rm configs/contributor_config.yaml
+git pull
+```
+
+Nothing else changes — that location is still searched, so an existing setup keeps working. You
+will see a warning pointing here until you move it.
+
+---
+
+For detailed explanations on how to use our tooling and contribute to the project, please visit [our website](https://oopsie-data.com/).
+
+For an overview of the steps necessary to integrate the tooling into your workflow and to contribute data to the official Oopsie Data repositories, check out [our quickstart guide](https://oopsie-data.com/quickstart).
+You can also use the information in AI_CONTEXT.md to guide a coding agent through the setup.
+
+## Repository structure
+
+The main tooling for data gathering and annotation is located in `oopsie-data-tools`.
+
+We provide example scripts for automatically collecting and annotating evaluation data while running policy inference in examples. Currently we support the evaluation scripts supported by `openpi` and Trossen robotics `act_plus_plus` repository. If you want to run a different evaluation script, check out the detailed instructions on integrating our tools into standard robot evaluation pipelines.
+
+## Issue/PR for support requests
+
+We are very aware that changing eval code and recording data while doing experiments can be a big hassle and cause friction. We are therefore happy to help you integrate the recording tool into your setup. Please let us know what robot platform and policy you are evaluating and where to find a sample of your evaluation & inference code.
+
+## Contributing
+
+You can use our toolset any time you like to record and annotate robot rollouts. To contribute your data to the official Oopsie Dataset, please follow the [sign-up instructions](https://oopsie-data.com/contributing/)!
+
+If you run into any issues, please do not hesitate to contact the team via mail or raise an issue here.

oopsie_data_tools-0.2.0.dist-info/RECORD

@@ -0,0 +1,74 @@
+oopsie_data_tools/__init__.py,sha256=IXlKkl6pJVukFvSeMKnTArpNuJCyP5lN-SnRPHOqYgo,109
+oopsie_data_tools/cli.py,sha256=RguBpkDzkulxe53rZ7HqLkQfPoGs83XEJNn6dXWSyAE,35300
+oopsie_data_tools/init_wizard.py,sha256=e5VuMhmHhl0Y7Xqr19mZuK4MzAhgYJY3xELIRwZr-TE,12848
+oopsie_data_tools/annotation_tool/__init__.py,sha256=yUz9RLGnPuazy4j2BdU-snnAlG702KMe07owJ7y-2No,146
+oopsie_data_tools/annotation_tool/annotation_schema.py,sha256=esbDz8TyEX0OPj84CYaf2kz7ZtDovlILLODviK2gPkg,10676
+oopsie_data_tools/annotation_tool/annotator_server.py,sha256=rs5iC1WFTLFlQGTkeBe0w0vVM-MHTiW6p27EoDuVKs4,31138
+oopsie_data_tools/annotation_tool/episode_recorder.py,sha256=xVG3ynmgRl5V79cpXgljflBqjljpTJzlF-M8gg0DGDE,27101
+oopsie_data_tools/annotation_tool/rollout_annotator.py,sha256=4Pe0qelJynJT-zisnYA3sZDRqZcLmzsaTUGnrnRSycQ,13422
+oopsie_data_tools/annotation_tool/ui/annotator.html,sha256=uNrocdAe4HBDk46lMLhxa7yQuptPyFFcfeBVeGXiG98,98368
+oopsie_data_tools/skill/SKILL.md,sha256=pa6jO0q1WDzD9NPuOaK1M0IKE14Rrq76ph5nrjrYfvI,5391
+oopsie_data_tools/skill/reference/conversion.md,sha256=ok51uFUlhSTjU_ehzQ4ifCisUdAWFrUlyFCw-2mrgDk,11718
+oopsie_data_tools/skill/reference/format.md,sha256=6ku3h-jhdeAbpf9Rj2Nb50q58n7hBMk2YdLnJMCWPEA,5882
+oopsie_data_tools/skill/reference/robot-profile.md,sha256=znna_0wOe6WxV1Et_v06d0LrIx0bJnU2Mm6ZirR6who,5590
+oopsie_data_tools/skill/reference/setup.md,sha256=_t7ap_YaSHdb_2G5zIlJIVcBw0PI9cdW1iABSFi0bBI,8910
+oopsie_data_tools/skill/reference/troubleshooting.md,sha256=WkMnUUZypuQ5QMzAmFn-bURCBmq0LFnwWoIJKfgdWZ8,5522
+oopsie_data_tools/test/__init__.py,sha256=S-_C9kt8ePKm3p912yXlBpSYn_fZC-DXkZqliQHWwBk,40
+oopsie_data_tools/test/conftest.py,sha256=K12d_zD23PHz_pApQTJ95mUPPjjYWmDKqDqdd5jfrtk,6337
+oopsie_data_tools/test/test_annotation_completeness.py,sha256=pLHmJjS5Xjdh5HiBsAoeCe4s5E0YxznIeQutRl3n_2g,6141
+oopsie_data_tools/test/test_annotation_schema.py,sha256=2OxE9uES3EvYPKMKVrBWyeICg-uwcWI6026YOrPOKRg,6975
+oopsie_data_tools/test/test_annotator_server.py,sha256=tlPY2HooVZvR_NhqPtHfXE7MZbujumUY-EuClg61CZ4,9188
+oopsie_data_tools/test/test_annotator_server_guards.py,sha256=3apElV1CbKgbmKuk1WG8B-yJNIqapg_ytjuQMN8v5e0,5129
+oopsie_data_tools/test/test_bulk_inference_end_to_end.py,sha256=ho5cATp_LY9bKDxUi35b2zP65ms4lWYzIdBaiBtG1Nc,4228
+oopsie_data_tools/test/test_cli_config.py,sha256=X0b9biEgAndYlf2UB_MdimUPuWvSrdhLWYqaZin1nr4,3879
+oopsie_data_tools/test/test_cli_tools.py,sha256=x8kAOXdzjrzWDbpL3RKA7buveE2_qLkDYzERXijDg0o,17748
+oopsie_data_tools/test/test_contributor_config.py,sha256=QVRZjZG-GUXMK-Y7BhEKy8ZL0iLgO-KMq2Dy86eY4QY,1303
+oopsie_data_tools/test/test_conversion_utils_annotations.py,sha256=UMdnrqzm6cUZPWhd54nZjetlu5SKntTTGFTFlDQVPY4,2751
+oopsie_data_tools/test/test_credentials_location.py,sha256=gDSfnN79DI7Z1hox5lhEcS-mAsF0isUd9wSKOjaFJbc,4251
+oopsie_data_tools/test/test_diversity.py,sha256=NGljPMlQL18ytz3oICpCKtlfSNXEPi8HzGSuws8DqkM,1197
+oopsie_data_tools/test/test_episode_recorder.py,sha256=HO39ZGVatPckicSGT_iJH981PxdGhFXLVpYqKfokw7k,12772
+oopsie_data_tools/test/test_episode_video_paths.py,sha256=wA4d7vp2WrAkdEncSjBuJceUS_8mp0o5BZuJXq1kOXg,7087
+oopsie_data_tools/test/test_hf_upload.py,sha256=OjfqN7meP1j8GVOwVI8pw-G-IEmh1JIk-jnw601LTSY,8217
+oopsie_data_tools/test/test_init_wizard.py,sha256=9lm9_3xeP1V5SkkJuUj2T19o1dZsXySmkkYPZy8l5CM,7181
+oopsie_data_tools/test/test_install_skill.py,sha256=q-xqlB6GeHqInejV2bVXKeJen2E1KEVYsmv3Ms5Ub4o,4492
+oopsie_data_tools/test/test_migrate_taxonomy_v2.py,sha256=a9Qhn0g7SoOd2Q0fJ8lLrab0eFXZwEKcEZAh_koNZU4,9047
+oopsie_data_tools/test/test_new_profile.py,sha256=OHXdpu5nqCaO5DsZECRGxX4pi5pm8UoigjsdCji1_XI,3408
+oopsie_data_tools/test/test_paths.py,sha256=0Cu3YyNCsShMLstULoh9JbyJIdD14kkvcSkTBcWAgH8,5652
+oopsie_data_tools/test/test_python38_compat.py,sha256=TsQbF50ixPDmm0VvjaMHtXsmVjFcbWeFawm5IpIRNyk,3218
+oopsie_data_tools/test/test_record_step_purity.py,sha256=Kq_S4Dlzb_hyuzjr2MDhH0cw55DiqgtHSav6H4Cngkg,4559
+oopsie_data_tools/test/test_robot_setup.py,sha256=baeKEbk3NDZB0gaNqGAlj5gNJodPP3u58tNAHmdYy3A,10008
+oopsie_data_tools/test/test_rollout_annotator.py,sha256=mESGTAaLoQKg6j9P_GM_uYm32Zk4Kd8n8Wg0Gu1kbyE,4526
+oopsie_data_tools/test/test_rotation_utils.py,sha256=_AsVjOg7h_zHxCXOUQp2K-QiCa_O8fIfd3ZxNGvYEGM,4750
+oopsie_data_tools/test/test_validate.py,sha256=3IRpbrUouGSJ4knmsQ_StF7ycVP0z7fQ29-3VAgR8z8,22989
+oopsie_data_tools/test/fixtures/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+oopsie_data_tools/test/fixtures/make_invalid.py,sha256=BXMDtoV8v0JwuxvsWQZ-oSJQvFDhOj-I3iQQCuRzFws,28648
+oopsie_data_tools/test/fixtures/make_valid.py,sha256=E6nkzKbQ5f-sxkeS-poBmpgyXTTQqopj0_ZwJzihTkE,14298
+oopsie_data_tools/utils/__init__.py,sha256=FJvt-LyfZ_71ePzCMkzDn1nkQo13nNuIB23eaJr0vdM,75
+oopsie_data_tools/utils/claude_skill.py,sha256=jKCiPKCI9hUQjP6Ppaen-h7xwJ8LYwYuEuyHpQTzeV8,3562
+oopsie_data_tools/utils/contributor_config.py,sha256=uHmE_gWMgPAJ-bgt7iLOfe64rW5oTu4Sl9TnpA0JHk8,3555
+oopsie_data_tools/utils/conversion_utils.py,sha256=NZ2HoShlBUT8UkpUGWicY1zB5aZpHbN91GS--oGdqcI,8603
+oopsie_data_tools/utils/h5.py,sha256=Uq-ZlIDTBFYeIZoZTQpLhIL2P8Qvirrmqnaf6ceGE1k,2066
+oopsie_data_tools/utils/h5_inspect.py,sha256=w19JP6H3SPeRqPHjyrP-0Y8-gsNG0QD3cZv_TuANhOg,5137
+oopsie_data_tools/utils/hf_limits.py,sha256=1Idk0rzPIIPYSMUUB35MjdzTcXMnD8aGtCRQHbDcfMk,1132
+oopsie_data_tools/utils/hf_upload.py,sha256=3g3lrClBKwiNcgF8Icp-nLubKONMUxMPH67s3CupxKg,9565
+oopsie_data_tools/utils/log.py,sha256=YHf9ItYdQH2Kdh3PabKI5wYbyz-2jXsRutlO98iwBWA,1286
+oopsie_data_tools/utils/migrate_taxonomy_v2.py,sha256=VPlP_VecsyEJZgJXb1M-cOPEq1V98xhVVAeD9ywPfXY,8186
+oopsie_data_tools/utils/paths.py,sha256=9INAcdyiEWTBg7og_Wa8HEnrAd9TKfe186_jvBbwplk,6107
+oopsie_data_tools/utils/restructure.py,sha256=c-IlUbU6cvQ8Y4PkDpl-THbtiR4QBKpg0YOsRSz-0Mw,16673
+oopsie_data_tools/utils/robot_profile/__init__.py,sha256=p7U8FPuC4_5MpwiO6G8kjYImmgWugplGix8TcqH0na4,68
+oopsie_data_tools/utils/robot_profile/robot_profile.py,sha256=L742sR_JnU9MDHg2h3xawJ7PJvOU7szbAcUX5PqWYZM,8428
+oopsie_data_tools/utils/robot_profile/rotation_utils.py,sha256=1wx8jDV7fNbVdCgl7QkScpOhfQTbpvDxxlejNK0vZs0,4394
+oopsie_data_tools/utils/robot_profile/template.py,sha256=Ctiwb0IQ8MmDWw4JwdpRxOUilpxM7xvxvoW-8NzyQo4,4001
+oopsie_data_tools/utils/validation/__init__.py,sha256=5VD5OuWEhbshVkX86lEa3kkvFdJIBRZ_dlZQfjnmos4,193
+oopsie_data_tools/utils/validation/annotation_completeness.py,sha256=vrwn4_a0t_y80XoPFeKQfP9BnHrdR1IkzkI49SdvA28,2793
+oopsie_data_tools/utils/validation/diversity.py,sha256=XVwSRf1at9NkUDA7HqCE__HavzY6Wjnc1PwwsEygjUc,3502
+oopsie_data_tools/utils/validation/episode_data.py,sha256=hsag_Ai-_eZRO77b0P7_9JK7M5Mpm41T37pGCVS8iMc,1734
+oopsie_data_tools/utils/validation/episode_loader.py,sha256=XYOxgZXzn_PMfs4orpf-BevkedpEvYh3d8Pq0M2NpBY,8064
+oopsie_data_tools/utils/validation/episode_validator.py,sha256=BFRvCd1jFx2sT_Mm230rmAahMKj2pqPEVQlhkOqzcZk,14209
+oopsie_data_tools/utils/validation/errors.py,sha256=wFqdNt1vLXgLTVYffNSzS9oztmNRXUBY5t1OIGQEdKQ,829
+oopsie_data_tools/utils/validation/validation_utils.py,sha256=BbRv1BcYsLQG0i7jMzYEcmvCnU1IW9B0TlyM1lwUeVg,3150
+oopsie_data_tools-0.2.0.dist-info/METADATA,sha256=MZQYyWOp84hCKusQRwTydXPec-DbvV-IX7xik3VuKnM,6651
+oopsie_data_tools-0.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+oopsie_data_tools-0.2.0.dist-info/entry_points.txt,sha256=QaXQDGBYcp6HF8XOST7AQ5PAJVc-5F2vWMvdoOWkSu8,59
+oopsie_data_tools-0.2.0.dist-info/licenses/LICENSE,sha256=2z6ApHhi7pIbotzuUQ6nki47YHsehL8fG_DV_rl85jA,1099
+oopsie_data_tools-0.2.0.dist-info/RECORD,,

oopsie_data_tools-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

oopsie_data_tools-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+oopsie-data = oopsie_data_tools.cli:main

oopsie_data_tools-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Oopsie Team (https://oopsie-data.com/data)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.