openbot-data 0.0.1__py3-none-any.whl

openbot_data/__init__.py

@@ -0,0 +1,17 @@
+"""
+OpenBot Data — Inspect robot video data before training.
+
+OpenBot Data 0.0.1 provides basic robot video inspection and dataset metadata generation.
+"""
+
+__version__ = "0.0.1"
+
+from openbot_data.video import scan_directory, scan_video
+from openbot_data.extract import extract_preview_frames, inspect_dataset
+
+__all__ = [
+    "scan_directory",
+    "scan_video",
+    "extract_preview_frames",
+    "inspect_dataset",
+]

openbot_data/cli.py

@@ -0,0 +1,85 @@
+"""
+Command-line interface for OpenBot Data v0.0.1.
+"""
+
+import typer
+from typing import Optional
+from pathlib import Path
+
+from openbot_data.video import scan_directory
+from openbot_data.extract import inspect_dataset
+
+app = typer.Typer(
+    name="openbot-data",
+    help="Clean, label, and organize robot data for training and evaluation.",
+    add_completion=False
+)
+
+
+@app.command()
+def scan(
+    path: str = typer.Argument(..., help="Path to robot video directory"),
+    output: Optional[str] = typer.Option(None, "--output", "-o", help="Output JSON file path")
+):
+    """
+    Scan a directory for robot videos and show metadata.
+    """
+    import json
+
+    result = scan_directory(path)
+
+    if output:
+        output_path = Path(output)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(output_path, "w") as f:
+            json.dump(result, f, indent=2)
+        typer.echo(f"Scan results saved to {output_path}")
+    else:
+        typer.echo(json.dumps(result, indent=2))
+
+
+@app.command()
+def inspect(
+    video_dir: str = typer.Argument(..., help="Path to video directory"),
+    output: str = typer.Option(..., "--out", "-o", help="Output directory"),
+):
+    """
+    Inspect robot videos: extract preview frames and generate manifest.
+    """
+    typer.echo(f"Inspecting robot videos in {video_dir}...")
+
+    result = inspect_dataset(
+        video_dir=video_dir,
+        output_dir=output
+    )
+
+    if "error" in result:
+        typer.echo(f"Error: {result['error']}", err=True)
+        raise typer.Exit(1)
+
+    typer.echo("")
+    typer.echo("Inspection complete!")
+    typer.echo("")
+    typer.echo(f"Output directory: {output}")
+    typer.echo(f"   Total videos: {result['total_videos']}")
+    typer.echo(f"   Preview frames: {result['total_previews']}")
+    typer.echo("")
+    typer.echo("Generated files:")
+    typer.echo(f"   {result['manifest_path']}")
+    typer.echo(f"   {result['report_path']}")
+
+
+@app.command()
+def version():
+    """Show version information."""
+    from openbot_data import __version__
+    typer.echo(f"OpenBot Data v{__version__}")
+    typer.echo("https://github.com/openbotai/openbot-data")
+
+
+def main():
+    app()
+
+
+if __name__ == "__main__":
+    main()

openbot_data/extract.py

@@ -0,0 +1,214 @@
+"""
+Frame extraction module for OpenBot Data v0.0.1.
+Extracts preview frames from videos for inspection.
+"""
+
+import hashlib
+import cv2
+import json
+from pathlib import Path
+from typing import Dict, Any, List
+from dataclasses import dataclass, asdict
+from tqdm import tqdm
+
+
+@dataclass
+class PreviewFrame:
+    """Metadata for a preview frame."""
+    frame_id: str
+    video_path: str
+    frame_number: int
+    timestamp: float
+    path: str
+
+
+def _video_output_id(video_path: Path) -> str:
+    digest = hashlib.sha1(str(video_path.resolve()).encode("utf-8")).hexdigest()[:8]
+    return f"{video_path.stem}_{digest}"
+
+
+def extract_preview_frames(
+    video_path: str,
+    output_dir: str,
+    max_frames: int = 10
+) -> Dict[str, Any]:
+    """
+    Extract a few preview frames from a video.
+
+    Args:
+        video_path: Path to input video
+        output_dir: Path to output directory
+        max_frames: Maximum number of frames to extract
+
+    Returns:
+        Dictionary with extraction results
+    """
+    video_path = Path(video_path)
+    output_dir = Path(output_dir)
+
+    previews_dir = output_dir / "previews"
+    previews_dir.mkdir(parents=True, exist_ok=True)
+
+    cap = cv2.VideoCapture(str(video_path))
+
+    if not cap.isOpened():
+        return {"error": f"Cannot open video: {video_path}"}
+
+    if max_frames <= 0:
+        cap.release()
+        return {"error": "max_frames must be greater than 0"}
+
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    fps = cap.get(cv2.CAP_PROP_FPS)
+    if fps <= 0:
+        fps = 30.0
+
+    if total_frames <= 0:
+        cap.release()
+        return {"error": f"Video has no readable frames: {video_path}"}
+
+    video_name = video_path.stem
+    video_output_id = _video_output_id(video_path)
+
+    sample_count = min(max_frames, total_frames)
+    if sample_count == 1:
+        frame_indices = [0]
+    else:
+        frame_indices = [
+            int(round(i * (total_frames - 1) / (sample_count - 1)))
+            for i in range(sample_count)
+        ]
+
+    extracted_frames: List[PreviewFrame] = []
+
+    for frame_idx in frame_indices:
+        cap.set(cv2.CAP_PROP_POS_FRAMES, frame_idx)
+        ret, frame = cap.read()
+
+        if not ret:
+            continue
+
+        timestamp = frame_idx / fps
+        frame_id = f"{video_output_id}_preview{len(extracted_frames):02d}.jpg"
+        frame_path = previews_dir / frame_id
+
+        cv2.imwrite(str(frame_path), frame)
+
+        extracted_frame = PreviewFrame(
+            frame_id=frame_id,
+            video_path=str(video_path),
+            frame_number=frame_idx,
+            timestamp=round(timestamp, 2),
+            path=str(frame_path)
+        )
+        extracted_frames.append(extracted_frame)
+
+    cap.release()
+
+    return {
+        "video_path": str(video_path),
+        "video_name": video_name,
+        "total_frames": total_frames,
+        "fps": fps,
+        "extracted_frames": len(extracted_frames),
+        "frames": [asdict(f) for f in extracted_frames]
+    }
+
+
+def inspect_dataset(
+    video_dir: str,
+    output_dir: str
+) -> Dict[str, Any]:
+    """
+    Inspect a robot video dataset and generate manifest.
+
+    Args:
+        video_dir: Path to video directory
+        output_dir: Path to output directory
+
+    Returns:
+        Dictionary with inspection results
+    """
+    from openbot_data.video import scan_directory
+
+    scan_result = scan_directory(video_dir)
+
+    if "error" in scan_result:
+        return scan_result
+
+    output_dir = Path(output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    metadata_dir = output_dir / "metadata"
+    metadata_dir.mkdir(parents=True, exist_ok=True)
+
+    all_previews = []
+    all_videos = []
+
+    for video_info in tqdm(scan_result["videos"], desc="Extracting previews"):
+        if not video_info["is_valid"]:
+            all_videos.append({
+                **video_info,
+                "previews": []
+            })
+            continue
+
+        video_path = video_info["path"]
+        video_name = Path(video_path).stem
+
+        preview_result = extract_preview_frames(
+            video_path,
+            str(output_dir),
+            max_frames=10
+        )
+
+        if "error" not in preview_result:
+            all_previews.extend(preview_result["frames"])
+
+        all_videos.append({
+            **video_info,
+            "previews": preview_result.get("frames", []) if "error" not in preview_result else []
+        })
+
+    # Generate manifest
+    manifest = {
+        "version": "0.0.1",
+        "source_dir": str(video_dir),
+        "output_dir": str(output_dir),
+        "total_videos": len(all_videos),
+        "valid_videos": sum(1 for v in all_videos if v["is_valid"]),
+        "total_previews": len(all_previews),
+        "videos": all_videos
+    }
+
+    manifest_path = metadata_dir / "manifest.json"
+    with open(manifest_path, "w") as f:
+        json.dump(manifest, f, indent=2)
+
+    # Generate basic report
+    report = {
+        "version": "0.0.1",
+        "source_dir": str(video_dir),
+        "output_dir": str(output_dir),
+        "total_videos": len(all_videos),
+        "valid_videos": sum(1 for v in all_videos if v["is_valid"]),
+        "invalid_videos": sum(1 for v in all_videos if not v["is_valid"]),
+        "total_duration": round(sum(v["duration"] for v in all_videos if v["is_valid"]), 2),
+        "total_size_mb": round(sum(v["size_mb"] for v in all_videos), 2),
+        "total_previews": len(all_previews),
+        "resolutions": [
+            list(resolution)
+            for resolution in sorted({(v["width"], v["height"]) for v in all_videos if v["is_valid"]})
+        ]
+    }
+
+    report_path = metadata_dir / "report.json"
+    with open(report_path, "w") as f:
+        json.dump(report, f, indent=2)
+
+    return {
+        "manifest_path": str(manifest_path),
+        "report_path": str(report_path),
+        "total_videos": len(all_videos),
+        "total_previews": len(all_previews)
+    }

openbot_data/video.py

@@ -0,0 +1,165 @@
+"""
+Video processing module for OpenBot Data.
+"""
+
+import cv2
+from pathlib import Path
+from typing import Dict, Any, Optional
+from dataclasses import dataclass
+
+
+@dataclass
+class VideoInfo:
+    """Video metadata."""
+    path: str
+    filename: str
+    width: int
+    height: int
+    fps: float
+    frame_count: int
+    duration: float
+    size_mb: float
+    is_valid: bool
+    error: Optional[str] = None
+
+
+def scan_video(video_path: str) -> VideoInfo:
+    """
+    Scan a video file and extract metadata.
+
+    Args:
+        video_path: Path to video file
+
+    Returns:
+        VideoInfo object with metadata
+    """
+    path = Path(video_path)
+
+    if not path.exists():
+        return VideoInfo(
+            path=str(path),
+            filename=path.name,
+            width=0,
+            height=0,
+            fps=0,
+            frame_count=0,
+            duration=0,
+            size_mb=0,
+            is_valid=False,
+            error="File not found"
+        )
+
+    cap = None
+
+    try:
+        size_mb = path.stat().st_size / (1024 * 1024)
+        cap = cv2.VideoCapture(str(path))
+
+        if not cap.isOpened():
+            return VideoInfo(
+                path=str(path),
+                filename=path.name,
+                width=0,
+                height=0,
+                fps=0,
+                frame_count=0,
+                duration=0,
+                size_mb=size_mb,
+                is_valid=False,
+                error="Cannot open video file"
+            )
+
+        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+
+        if fps > 0:
+            duration = frame_count / fps
+        else:
+            duration = 0
+
+        is_valid = width > 0 and height > 0 and frame_count > 0
+
+        return VideoInfo(
+            path=str(path),
+            filename=path.name,
+            width=width,
+            height=height,
+            fps=fps,
+            frame_count=frame_count,
+            duration=duration,
+            size_mb=size_mb,
+            is_valid=is_valid,
+            error=None if is_valid else "Video has no readable frames"
+        )
+
+    except Exception as e:
+        return VideoInfo(
+            path=str(path),
+            filename=path.name,
+            width=0,
+            height=0,
+            fps=0,
+            frame_count=0,
+            duration=0,
+            size_mb=path.stat().st_size / (1024 * 1024) if path.exists() else 0,
+            is_valid=False,
+            error=str(e)
+        )
+    finally:
+        if cap is not None:
+            cap.release()
+
+
+def scan_directory(directory: str) -> Dict[str, Any]:
+    """
+    Scan a directory for video files.
+
+    Args:
+        directory: Path to directory
+
+    Returns:
+        Dictionary with scan results
+    """
+    path = Path(directory)
+
+    if not path.exists() or not path.is_dir():
+        return {
+            "error": f"Directory not found: {directory}",
+            "videos": []
+        }
+
+    video_extensions = {".mp4", ".mov", ".avi", ".mkv", ".webm"}
+    video_files = []
+
+    for f in sorted(path.rglob("*")):
+        if f.is_file() and f.suffix.lower() in video_extensions:
+            info = scan_video(str(f))
+            video_files.append({
+                "path": str(f),
+                "filename": f.name,
+                "width": info.width,
+                "height": info.height,
+                "fps": info.fps,
+                "frame_count": info.frame_count,
+                "duration": round(info.duration, 2),
+                "size_mb": round(info.size_mb, 2),
+                "is_valid": info.is_valid,
+                "error": info.error
+            })
+
+    total_videos = len(video_files)
+    valid_videos = sum(1 for v in video_files if v["is_valid"])
+    total_size_mb = sum(v["size_mb"] for v in video_files)
+    total_duration = sum(v["duration"] for v in video_files if v["is_valid"])
+
+    return {
+        "directory": str(path),
+        "total_videos": total_videos,
+        "valid_videos": valid_videos,
+        "invalid_videos": total_videos - valid_videos,
+        "total_size_mb": round(total_size_mb, 2),
+        "total_duration": round(total_duration, 2),
+        "videos": video_files
+    }

openbot_data-0.0.1.dist-info/METADATA

@@ -0,0 +1,314 @@
+Metadata-Version: 2.4
+Name: openbot-data
+Version: 0.0.1
+Summary: Clean, label, and organize robot data for training and evaluation.
+Project-URL: Homepage, https://openbot.ai/data
+Project-URL: Repository, https://github.com/openbotai/openbot-data
+Project-URL: Issues, https://github.com/openbotai/openbot-data/issues
+Author-email: OpenBot <hello@openbot.ai>
+License: MIT
+License-File: LICENSE
+Keywords: annotation,computer-vision,data-cleaning,dataset,egocentric-video,embodied-ai,failure-analysis,robot-data,robotics,wrist-camera
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Requires-Python: >=3.9
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: opencv-python>=4.8.0
+Requires-Dist: tqdm>=4.65.0
+Requires-Dist: typer>=0.9.0
+Provides-Extra: dev
+Requires-Dist: build>=1.0.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: twine>=5.0.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# OpenBot Data
+
+**Clean, label, and organize robot data for training and evaluation.**
+
+OpenBot Data is a lightweight toolkit for cleaning, labeling, organizing, and preparing robot data for model training, evaluation, failure analysis, and deployment debugging.
+
+> Robots do not just need more data.
+> They need cleaner data, better labels, and harder failure cases.
+
+---
+
+## Current Status
+
+**OpenBot Data is in early development.**
+
+The current release (0.0.1) provides basic robot video inspection and dataset metadata generation:
+
+- Scan robot video directories
+- Extract video metadata (duration, fps, resolution, frame count)
+- Extract preview frames for quick inspection
+- Generate dataset manifest
+- Generate basic quality reports
+
+Planned features include dataset triage, quality-based filtering, annotation export, and failure case mining.
+
+---
+
+## Why OpenBot Data?
+
+Robot data is messy.
+
+Raw robot recordings often contain:
+
+- Motion blur
+- Camera shake
+- Dark or overexposed frames
+- Hand, gripper, or object occlusion
+- Target objects moving out of view
+- Repeated or invalid clips
+- Failed actions mixed with successful ones
+- Unclear task phases
+- Noisy or incomplete annotations
+- Long-tail failure cases
+- Data that should not enter the training set
+
+OpenBot Data helps robotics teams convert raw robot data into structured datasets that can be used for training, evaluation, benchmarking, and deployment iteration.
+
+---
+
+## First focus: ego-centric robot data
+
+The first public version of OpenBot Data starts with ego-centric robot videos because they are one of the most common and messy data sources in embodied AI.
+
+This includes:
+
+- First-person robot videos
+- Wrist-camera videos
+- Close-range manipulation videos
+- Robot vision clips
+- Failure clips from real-world deployment
+- Hard cases from evaluation runs
+
+OpenBot Data helps turn these raw videos into clean, annotation-ready datasets and reusable failure cases.
+
+---
+
+## What it does
+
+OpenBot Data focuses on four core workflows:
+
+### 1. Clean robot data
+
+Detect and organize low-quality frames and clips, including:
+
+- Blurry frames
+- Dark scenes
+- Duplicate frames
+- Camera shake
+- Invalid clips
+- Target-out-of-view cases
+- Heavy occlusion
+- Low-quality training samples
+
+### 2. Prepare data for annotation
+
+Convert raw robot data into annotation-ready datasets.
+
+Planned annotation types include:
+
+- Object labels
+- Bounding boxes
+- Task phases
+- Success / failure labels
+- Failure reasons
+- Scene conditions
+- Hand or gripper occlusion
+- Object visibility
+- Trainable / not-trainable flags
+
+### 3. Mine failure cases
+
+Find hard cases that matter for real-world robot deployment:
+
+- Motion blur failures
+- Hand or gripper occlusion failures
+- Target lost from view
+- Dark-scene failures
+- Reflective object failures
+- Small-object failures
+- Failed grasp or manipulation moments
+- Long-tail deployment failures
+
+### 4. Export structured datasets
+
+Export cleaned data for training, evaluation, and benchmarking.
+
+Planned formats:
+
+- OpenBot JSON
+- COCO
+- YOLO
+- WebDataset
+- Parquet
+- LeRobot-compatible datasets
+- RLDS-compatible datasets
+
+---
+
+## Installation
+
+```bash
+pip install openbot-data
+```
+
+---
+
+## Quickstart (v0.0.1)
+
+```bash
+# Scan robot videos and inspect metadata
+openbot-data scan ./robot_videos
+
+# Full inspection: extract frames and generate reports
+openbot-data inspect ./robot_videos --out ./openbot_dataset
+```
+
+Example output:
+
+```text
+openbot_dataset/
+  previews/              # Preview frames from videos
+  metadata/
+    manifest.json        # Dataset manifest with video metadata
+    report.json          # Quality metrics summary
+```
+
+---
+
+## Usage
+
+### CLI
+
+```bash
+openbot-data scan ./videos                    # Scan and show video metadata
+openbot-data inspect ./videos --out ./dataset  # Full inspection pipeline
+```
+
+### Python API
+
+```python
+from openbot_data import scan_directory, inspect_dataset
+
+# Scan videos
+result = scan_directory("./robot_videos")
+print(f"Found {result['valid_videos']} videos")
+
+# Inspect and extract preview frames, manifest, and report
+result = inspect_dataset(
+    video_dir="./robot_videos",
+    output_dir="./dataset",
+)
+
+print(result["manifest_path"])
+print(result["report_path"])
+```
+
+### Development checks
+
+```bash
+pip install -e ".[dev]"
+pytest
+python -m build
+python -m twine check dist/*
+```
+
+---
+
+## Example use cases
+
+OpenBot Data can be used for:
+
+* Robot vision dataset cleaning
+* Ego-centric video preparation
+* Wrist-camera data processing
+* Embodied AI data preparation
+* Failure case mining
+* Deployment evaluation data preparation
+* Synthetic data generation input curation
+* Robot benchmark dataset construction
+* Training / validation / test split management
+
+---
+
+## Roadmap
+
+### v0.0.1 — Installable Preview (Current)
+* [x] Robot video scanner
+* [x] Video metadata extraction (duration, fps, resolution, frame count)
+* [x] Dataset manifest generation
+* [x] Basic quality reports (JSON)
+* [x] Preview frame extraction
+
+### v0.0.2 — Dataset Triage
+* [ ] Blur score detection (Laplacian variance)
+* [ ] Brightness score detection
+* [ ] Black frame detection
+* [ ] Basic duplicate-like frame detection
+* [ ] keep / review / drop grouping
+* [ ] HTML triage reports
+
+### v0.0.3 — Annotation Batch
+* [ ] Quality-based sampling
+* [ ] Annotation task generation
+* [ ] Trainable/not-trainable flags
+
+### v0.0.4 — Export
+* [ ] OpenBot JSON schema
+* [ ] COCO export
+* [ ] YOLO export
+
+### v0.1.0 — Robot Data Cleaning Pipeline
+* [ ] Stable cleaning, triage, sampling, and export workflow
+* [ ] Failure case tagging
+* [ ] Multi-view robot data support
+* [ ] LeRobot dataset compatibility
+* [ ] RLDS compatibility
+
+---
+
+## OpenBot ecosystem
+
+OpenBot Data is part of the OpenBot robotics intelligence infrastructure.
+
+Planned modules:
+
+* **OpenBot Data** — clean, label, and organize robot data
+* **OpenBot Bench** — evaluate robot models before deployment
+* **OpenBot Synth** — generate hard cases from failures
+* **OpenBot API** — connect data, evaluation, and deployment workflows
+
+---
+
+## License
+
+MIT License.
+
+---
+
+## Citation
+
+No formal citation is required for the 0.0.1 preview. If you use OpenBot Data in research or production, link to the project repository.
+
+If you use OpenBot Data in research or production, please cite the project repository.
+
+```bibtex
+@software{openbot_data,
+  title = {OpenBot Data},
+  author = {OpenBot},
+  year = {2026},
+  url = {https://github.com/openbotai/openbot-data}
+}
+```

openbot_data-0.0.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+openbot_data/__init__.py,sha256=wR3fW4SyEhhFh9oCFhiI9kHTFmekHqfTVvnN1afV3qw,421
+openbot_data/cli.py,sha256=wpJbdZ6a6AYMsByyCzZVQY3hEXNiUgTLoRwGMq_VesE,2226
+openbot_data/extract.py,sha256=Q_K5Y5jVsXwacMiMPe0zgPhtSWb9-MN1nltru2P3clk,5916
+openbot_data/video.py,sha256=NDOpH4Kxhk3sl3dho3ojbOl3m3SwSbvVbmkvBGgtcCA,4297
+openbot_data-0.0.1.dist-info/METADATA,sha256=El3lQxNzuY45YDixT71qk4SZa8CK1GLTjK0F3LqbzBE,7886
+openbot_data-0.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+openbot_data-0.0.1.dist-info/entry_points.txt,sha256=nPRI02-6zWiKTnFiEZ1_pxQ3-uOVYhPKAmPNasa3hpM,55
+openbot_data-0.0.1.dist-info/licenses/LICENSE,sha256=GTnnKzIdwIPfS5ywshDGkHJkjklUutUZlgv4nU2YOjA,1067
+openbot_data-0.0.1.dist-info/RECORD,,

openbot_data-0.0.1.dist-info/WHEEL

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

openbot_data-0.0.1.dist-info/entry_points.txt

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

openbot_data-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 OpenBot
+
+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 ACCOUNTING CONTRACT OR TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.