Remove openenv-core dep to fix HF build timeout

The openenv-core package pulls 50+ transitive dependencies that
cause the Docker build to exceed the free-tier time limit.
Replaced with plain FastAPI endpoints (/reset, /step, /tasks).
Training scripts still reference origami_server directly.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

README.md

@@ -1,6 +1,6 @@
 ---
 title: Optigami
-emoji: "\U0001f9a2"
+emoji: "\U0001F9A2"
 colorFrom: indigo
 colorTo: purple
 sdk: docker

origami_server/app.py

@@ -1,59 +1,165 @@
-"""FastAPI entry point — OpenEnv create_app() + custom endpoints."""
+"""FastAPI entry point — standalone RL API (no openenv-core dependency)."""
 
 import os
-from pathlib import Path
+import uuid
+from typing import Any, Optional
 
-from fastapi.responses import HTMLResponse
-from fastapi.staticfiles import StaticFiles
+import numpy as np
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel, Field
 
-from openenv.core.env_server.http_server import create_app
+from .engine.fold_parser import validate_fold
+from .engine.shape_match import compute_shape_match
+from .engine.simulate import simulate
+from .tasks import TASKS, get_task
 
-from .environment import OrigamiEnvironment
-from .models import OrigamiAction, OrigamiObservation
+app = FastAPI(title="Optigami RL Environment", version="0.1.0")
 
-app = create_app(
-    OrigamiEnvironment,
-    OrigamiAction,
-    OrigamiObservation,
-    env_name="origami_env",
-)
 
-from .tasks import TASKS
+# --- Request/Response models ---
 
+class ResetRequest(BaseModel):
+    task_name: str = "triangle"
+    seed: Optional[int] = None
 
-@app.get("/tasks")
-def get_tasks():
-    return {
-        name: {
+class StepRequest(BaseModel):
+    fold_data: dict[str, Any] = Field(..., description="FOLD-format crease pattern JSON")
+
+class ObservationResponse(BaseModel):
+    done: bool = False
+    reward: Optional[float] = None
+    task: dict[str, Any] = {}
+    fold_data: dict[str, Any] = {}
+    final_positions: list[list[float]] = []
+    target_positions: list[list[float]] = []
+    shape_similarity: float = 0.0
+    max_strain: float = 0.0
+    is_stable: bool = True
+    error: Optional[str] = None
+
+
+# --- State ---
+
+_state: dict[str, Any] = {}
+
+
+# --- Endpoints ---
+
+@app.post("/reset", response_model=ObservationResponse)
+def reset(req: ResetRequest):
+    task = get_task(req.task_name)
+
+    if req.seed is not None:
+        np.random.seed(req.seed)
+
+    target_fold = task["target_fold"]
+    try:
+        target_result = simulate(target_fold, crease_percent=1.0)
+        target_positions = target_result.positions.tolist()
+    except Exception:
+        target_positions = []
+
+    _state["task"] = task
+    _state["target_positions"] = target_positions
+    _state["episode_id"] = str(uuid.uuid4())
+
+    return ObservationResponse(
+        done=False,
+        reward=None,
+        task={
             "name": task["name"],
             "description": task["description"],
             "difficulty": task["difficulty"],
             "paper": task["paper"],
-            "target_fold": task["target_fold"],
+        },
+        target_positions=target_positions,
+    )
+
+
+@app.post("/step", response_model=ObservationResponse)
+def step(req: StepRequest):
+    task = _state.get("task")
+    if not task:
+        raise HTTPException(status_code=400, detail="Call /reset first")
+
+    target_positions = _state.get("target_positions", [])
+    fold_data = req.fold_data
+
+    is_valid, error_msg = validate_fold(fold_data)
+    if not is_valid:
+        return ObservationResponse(
+            done=True,
+            reward=-2.0,
+            task={"name": task["name"], "description": task["description"]},
+            fold_data=fold_data,
+            target_positions=target_positions,
+            error=f"Invalid FOLD data: {error_msg}",
+        )
+
+    try:
+        result = simulate(fold_data, crease_percent=1.0)
+    except Exception as e:
+        return ObservationResponse(
+            done=True,
+            reward=-2.0,
+            task={"name": task["name"], "description": task["description"]},
+            fold_data=fold_data,
+            target_positions=target_positions,
+            error=f"Simulation error: {str(e)}",
+        )
+
+    target_arr = np.array(target_positions) if target_positions else np.zeros((0, 3))
+    similarity = compute_shape_match(result.positions, target_arr)
+    reward = similarity * 20.0
+
+    return ObservationResponse(
+        done=True,
+        reward=reward,
+        task={"name": task["name"], "description": task["description"]},
+        fold_data=fold_data,
+        final_positions=result.positions.tolist(),
+        target_positions=target_positions,
+        shape_similarity=similarity,
+        max_strain=result.max_strain,
+        is_stable=result.converged,
+    )
+
+
+@app.get("/tasks")
+def list_tasks():
+    return {
+        name: {
+            "name": t["name"],
+            "description": t["description"],
+            "difficulty": t["difficulty"],
+            "paper": t["paper"],
+            "target_fold": t["target_fold"],
         }
-        for name, task in TASKS.items()
+        for name, t in TASKS.items()
     }
 
 
 @app.get("/tasks/{task_name}")
 def get_task_detail(task_name: str):
     if task_name not in TASKS:
-        from fastapi import HTTPException
-
         raise HTTPException(status_code=404, detail=f"Task '{task_name}' not found")
-    task = TASKS[task_name]
+    t = TASKS[task_name]
     return {
-        "name": task["name"],
-        "description": task["description"],
-        "difficulty": task["difficulty"],
-        "paper": task["paper"],
-        "target_fold": task["target_fold"],
+        "name": t["name"],
+        "description": t["description"],
+        "difficulty": t["difficulty"],
+        "paper": t["paper"],
+        "target_fold": t["target_fold"],
     }
 
 
+@app.get("/health")
+def health():
+    return {"status": "healthy"}
+
+
 def main():
     import uvicorn
-
     port = int(os.environ.get("PORT", 8000))
     uvicorn.run(app, host="0.0.0.0", port=port)
 

origami_server/environment.py

@@ -1,158 +0,0 @@
-"""Origami RL Environment — OpenEnv Environment subclass.
-
-Single-shot episodes: LLM submits a FOLD crease pattern, physics simulates it,
-reward = shape similarity to target. Like AlphaFold for origami.
-"""
-
-import uuid
-from typing import Any, Optional
-
-import numpy as np
-from openenv.core import Environment
-
-from .engine.fold_parser import validate_fold
-from .engine.shape_match import compute_shape_match
-from .engine.simulate import SimResult, simulate
-from .models import OrigamiAction, OrigamiObservation, OrigamiState
-from .tasks import get_task
-
-
-class OrigamiEnvironment(
-    Environment[OrigamiAction, OrigamiObservation, OrigamiState]
-):
-    """Origami folding environment.
-
-    Episode flow:
-        1. reset(task_name="triangle") -> returns task description + target info
-        2. step(OrigamiAction(fold_data={...})) -> simulates, scores, returns done=True
-
-    Single action per episode. The action IS the complete crease pattern.
-    """
-
-    SUPPORTS_CONCURRENT_SESSIONS = True
-
-    def __init__(self, **kwargs: Any):
-        super().__init__(**kwargs)
-        self._state = OrigamiState()
-        self._task: dict = {}
-        self._target_positions: np.ndarray = np.zeros((0, 3))
-
-    def reset(
-        self,
-        seed: Optional[int] = None,
-        episode_id: Optional[str] = None,
-        **kwargs: Any,
-    ) -> OrigamiObservation:
-        """Start a new episode with a target shape task."""
-        self._state = OrigamiState(
-            episode_id=episode_id or str(uuid.uuid4()),
-            step_count=0,
-        )
-
-        task_name = kwargs.get("task_name", "triangle")
-        self._task = get_task(task_name)
-        self._state.task_name = self._task["name"]
-
-        target_fold = self._task["target_fold"]
-        try:
-            target_result = simulate(target_fold, crease_percent=1.0)
-            self._target_positions = target_result.positions
-        except Exception:
-            self._target_positions = np.zeros((0, 3))
-
-        return OrigamiObservation(
-            done=False,
-            reward=None,
-            task=self._task_info(),
-            fold_data={},
-            final_positions=[],
-            target_positions=self._target_positions.tolist(),
-            shape_similarity=0.0,
-            max_strain=0.0,
-            is_stable=True,
-            error=None,
-        )
-
-    def step(
-        self,
-        action: OrigamiAction,
-        timeout_s: Optional[float] = None,
-        **kwargs: Any,
-    ) -> OrigamiObservation:
-        """Evaluate the LLM's crease pattern.
-
-        1. Validate FOLD data
-        2. Run physics simulation (creasePercent=1.0)
-        3. Compare final shape to target
-        4. Return observation with reward = similarity * 20
-        """
-        self._state.step_count += 1
-        fold_data = action.fold_data
-
-        is_valid, error_msg = validate_fold(fold_data)
-        if not is_valid:
-            self._state.is_stable = False
-            return OrigamiObservation(
-                done=True,
-                reward=-2.0,
-                task=self._task_info(),
-                fold_data=fold_data,
-                final_positions=[],
-                target_positions=self._target_positions.tolist(),
-                shape_similarity=0.0,
-                max_strain=0.0,
-                is_stable=False,
-                error=f"Invalid FOLD data: {error_msg}",
-            )
-
-        try:
-            result: SimResult = simulate(fold_data, crease_percent=1.0)
-        except Exception as e:
-            self._state.is_stable = False
-            return OrigamiObservation(
-                done=True,
-                reward=-2.0,
-                task=self._task_info(),
-                fold_data=fold_data,
-                final_positions=[],
-                target_positions=self._target_positions.tolist(),
-                shape_similarity=0.0,
-                max_strain=0.0,
-                is_stable=False,
-                error=f"Simulation error: {str(e)}",
-            )
-
-        similarity = compute_shape_match(
-            result.positions, self._target_positions
-        )
-        reward = similarity * 20.0
-
-        self._state.shape_similarity = similarity
-        self._state.is_stable = result.converged
-
-        return OrigamiObservation(
-            done=True,
-            reward=reward,
-            task=self._task_info(),
-            fold_data=fold_data,
-            final_positions=result.positions.tolist(),
-            target_positions=self._target_positions.tolist(),
-            shape_similarity=similarity,
-            max_strain=result.max_strain,
-            is_stable=result.converged,
-            error=None,
-        )
-
-    @property
-    def state(self) -> OrigamiState:
-        return self._state
-
-    def _task_info(self) -> dict:
-        if not self._task:
-            return {}
-        return {
-            "name": self._task.get("name", ""),
-            "description": self._task.get("description", ""),
-            "difficulty": self._task.get("difficulty", 0),
-            "paper": self._task.get("paper", {}),
-        }

origami_server/models.py

@@ -1,35 +1,27 @@
-"""OpenEnv types for the Origami RL environment.
+"""Pydantic types for the Origami RL environment.
 
-OrigamiAction: LLM submits a FOLD crease pattern.
-OrigamiObservation: Result of simulating that pattern against a target.
-OrigamiState: Internal episode state.
+These are used by the training scripts and can also be used with openenv-core
+when that package is available (e.g. on Colab).
 """
 
 from typing import Any, Optional
 
-from openenv.core import Action, Observation, State
-from pydantic import Field
+from pydantic import BaseModel, Field
 
 
-class OrigamiAction(Action):
-    """LLM submits a FOLD crease pattern as its action.
-
-    The fold_data dict must contain:
-      - vertices_coords: [[x, y], ...] — 2D vertex positions on flat paper
-      - edges_vertices: [[v1, v2], ...] — edge connectivity
-      - edges_assignment: ["B"|"M"|"V", ...] — boundary/mountain/valley
-      - edges_foldAngle: [angle, ...] — target fold angles in degrees
-        (optional — defaults from assignment: M=-180, V=+180, B=0)
-    """
+class OrigamiAction(BaseModel):
+    """LLM submits a FOLD crease pattern as its action."""
 
     fold_data: dict[str, Any] = Field(
         ..., description="FOLD-format crease pattern JSON"
     )
 
 
-class OrigamiObservation(Observation):
+class OrigamiObservation(BaseModel):
     """Result of simulating the LLM's crease pattern."""
 
+    done: bool = False
+    reward: Optional[float] = None
     task: dict[str, Any] = Field(default_factory=dict)
     fold_data: dict[str, Any] = Field(default_factory=dict)
     final_positions: list[list[float]] = Field(default_factory=list)
@@ -40,9 +32,11 @@ class OrigamiObservation(Observation):
     error: Optional[str] = None
 
 
-class OrigamiState(State):
+class OrigamiState(BaseModel):
     """Internal state for an origami episode."""
 
+    episode_id: Optional[str] = None
+    step_count: int = 0
     task_name: str = ""
     shape_similarity: float = 0.0
     is_stable: bool = True

requirements.txt

@@ -1,6 +1,5 @@
 fastapi>=0.100.0
 numpy>=1.24.0
-openenv-core[core]>=0.2.1
 pydantic>=2.0.0
 scipy>=1.10
 uvicorn>=0.23.0