updated

.env.example

@@ -1,4 +1,4 @@
-# Container Port OpenEnv — Environment Variables
+# Container Port OpenEnv - Environment Variables
 # Copy this file and fill in your actual values before running inference
 HF_TOKEN=your_huggingface_token_here
 API_BASE_URL=https://router.huggingface.co/v1

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,3 +1,13 @@
+---
+title: Container Port
+colorFrom: gray
+colorTo: blue
+sdk: docker
+pinned: false
+license: mit
+short_description: A simulation-based RL environment for container management
+---
+
 # Container Port Environment
 
 An OpenEnv environment for container-yard stack planning at a shipping terminal.

__init__.py

@@ -0,0 +1,3 @@
+from models import ContainerAction, ContainerObservation
+
+__all__ = ["ContainerAction", "ContainerObservation"]

client.py

@@ -0,0 +1,11 @@
+from openenv.core.env_client import EnvClient
+
+from models import ContainerAction, ContainerObservation
+
+
+class ContainerPortEnv(EnvClient[ContainerAction, ContainerObservation]):
+    action_cls = ContainerAction
+    observation_cls = ContainerObservation
+
+
+__all__ = ["ContainerPortEnv"]

inference.py

@@ -1,6 +1,6 @@
-#!/usr/bin/env python3
+#!/usr/bin/env python3
 """
-Container Port OpenEnv — Baseline Inference Script
+Container Port OpenEnv - Baseline Inference Script
 SST x Meta PyTorch OpenEnv Hackathon 2026
 
 Stdout format (grader parses these exactly):
@@ -16,81 +16,78 @@ Usage:
   python inference.py --url https://YOUR_USERNAME-container-port-env.hf.space
 """
 
+import argparse
 import asyncio
+import json
 import os
 import sys
-import json
 from typing import List, Optional
+
 from openai import OpenAI
 
-# Load .env file if present (before os.getenv calls)
-def _load_dotenv():
-    env_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), ".env")
+
+def _load_dotenv() -> None:
+    env_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), '.env')
     if os.path.exists(env_path):
-        with open(env_path) as f:
+        with open(env_path, encoding='utf-8') as f:
             for line in f:
                 line = line.strip()
-                if not line or line.startswith("#") or "=" not in line:
+                if not line or line.startswith('#') or '=' not in line:
                     continue
-                key, _, value = line.partition("=")
+                key, _, value = line.partition('=')
                 key = key.strip()
                 value = value.strip().strip('"').strip("'")
                 if key and key not in os.environ:
                     os.environ[key] = value
 
+
 _load_dotenv()
 
-#  Required configuration variables 
-API_BASE_URL      = os.getenv("API_BASE_URL", "https://router.huggingface.co/v1")
-MODEL_NAME        = os.getenv("MODEL_NAME",   "meta-llama/Llama-3.1-8B-Instruct")
-HF_TOKEN          = os.getenv("HF_TOKEN")
-LOCAL_IMAGE_NAME  = os.getenv("LOCAL_IMAGE_NAME")
-API_KEY           = HF_TOKEN or os.getenv("API_KEY")
-# 
-
-ENV_URL       = os.getenv("ENV_URL", "http://localhost:7860")
-TASK_NAME     = "container-stacking"
-BENCHMARK     = "container-port-env"
-MAX_STEPS     = 200  # hard mode has 50 containers, safety ceiling
-SUCCESS_SCORE_THRESHOLD = 0.5
+API_BASE_URL = os.getenv('API_BASE_URL', 'https://router.huggingface.co/v1')
+MODEL_NAME = os.getenv('MODEL_NAME', 'meta-llama/Llama-3.1-8B-Instruct')
+HF_TOKEN = os.getenv('HF_TOKEN')
+LOCAL_IMAGE_NAME = os.getenv('LOCAL_IMAGE_NAME')
+API_KEY = HF_TOKEN or os.getenv('API_KEY')
 
+ENV_URL = os.getenv('ENV_URL', 'http://localhost:7860')
+TASK_NAME = 'container-stacking'
+BENCHMARK = 'container-port-env'
+MAX_STEPS = 200
+SUCCESS_SCORE_THRESHOLD = 0.5
 
-#  Logging helpers (exact SST format) 
 
 def log_start(task: str, env: str, model: str) -> None:
-    print(f"[START] task={task} env={env} model={model}", flush=True)
+    print(f'[START] task={task} env={env} model={model}', flush=True)
 
 
 def log_step(step: int, action: str, reward: float, done: bool, error: Optional[str]) -> None:
-    error_val = error if error else "null"
+    error_val = error if error else 'null'
     done_val = str(done).lower()
     print(
-        f"[STEP] step={step} action={action} reward={reward:.2f} done={done_val} error={error_val}",
+        f'[STEP] step={step} action={action} reward={reward:.2f} done={done_val} error={error_val}',
         flush=True,
     )
 
 
 def log_end(success: bool, steps: int, score: float, rewards: List[float]) -> None:
-    rewards_str = ",".join(f"{r:.2f}" for r in rewards)
+    rewards_str = ','.join(f'{r:.2f}' for r in rewards)
     print(
-        f"[END] success={str(success).lower()} steps={steps} score={score:.3f} rewards={rewards_str}",
+        f'[END] success={str(success).lower()} steps={steps} score={score:.3f} rewards={rewards_str}',
         flush=True,
     )
 
 
-#  Agents 
-
 def greedy_decide(obs: dict) -> int:
-    stacks     = obs["stack_states"]
-    current    = obs.get("current_container")
-    max_height = obs["max_height"]
-    upcoming   = set(obs.get("upcoming_retrievals", []))
+    stacks = obs['stack_states']
+    current = obs.get('current_container')
+    max_height = obs['max_height']
+    upcoming = set(obs.get('upcoming_retrievals', []))
 
     if current is None:
         return 0
 
-    cur_priority = current["priority"]
-    best_stack, best_score = -1, float("-inf")
+    cur_priority = current['priority']
+    best_stack, best_score = -1, float('-inf')
 
     for i, stack in enumerate(stacks):
         depth = len(stack)
@@ -101,13 +98,13 @@ def greedy_decide(obs: dict) -> int:
         score += accessibility * (4 - cur_priority)
 
         if depth > 0:
-            top_p = stack[-1]["priority"]
+            top_p = stack[-1]['priority']
             if cur_priority > top_p:
                 score -= 10.0 * (cur_priority - top_p)
             elif cur_priority < top_p:
                 score += 3.0
 
-        if current["id"] in upcoming:
+        if current['id'] in upcoming:
             score += 5.0 * accessibility
 
         if depth > 0:
@@ -125,34 +122,36 @@ def greedy_decide(obs: dict) -> int:
 
 
 def llm_decide(obs: dict, client: OpenAI) -> int:
-    stacks     = obs["stack_states"]
-    current    = obs.get("current_container")
-    n_stacks   = obs["n_stacks"]
-    max_height = obs["max_height"]
-    upcoming   = obs.get("upcoming_retrievals", [])
-    difficulty = obs.get("difficulty", "medium")
+    stacks = obs['stack_states']
+    current = obs.get('current_container')
+    n_stacks = obs['n_stacks']
+    max_height = obs['max_height']
+    upcoming = obs.get('upcoming_retrievals', [])
+    difficulty = obs.get('difficulty', 'medium')
 
     lines = []
     for i, stack in enumerate(stacks):
         if not stack:
-            lines.append(f"  Stack {i}: EMPTY (0/{max_height})")
+            lines.append(f'  Stack {i}: EMPTY (0/{max_height})')
         else:
-            contents = ", ".join(f"{c['id']}(p{c['priority']})" for c in stack)
+            contents = ', '.join(f"{c['id']}(p{c['priority']})" for c in stack)
             lines.append(
-                f"  Stack {i}: [{contents}] depth={len(stack)}/{max_height},"
+                f'  Stack {i}: [{contents}] depth={len(stack)}/{max_height},'
                 f" top=priority-{stack[-1]['priority']}"
             )
 
     prompt = (
-        f"You are a container yard planner. Minimize rehandle operations.\n"
-        f"Priority 1=URGENT (retrieved first), 2=Normal, 3=Low.\n"
-        f"RULE: containers above the target at retrieval = rehandles (costly).\n\n"
-        f"DIFFICULTY: {difficulty}\n"
+        'You are a container yard planner. Minimize rehandle operations.\n'
+        'Priority 1=URGENT (retrieved first), 2=Normal, 3=Low.\n'
+        'RULE: containers above the target at retrieval = rehandles (costly).\n\n'
+        f'DIFFICULTY: {difficulty}\n'
         f"UPCOMING RETRIEVALS: {upcoming or 'Unknown (hard mode)'}\n\n"
         f"CONTAINER TO PLACE: id={current['id']}, priority={current['priority']}, "
         f"weight={current['weight']}kg\n\n"
-        f"STACKS (bottom->top):\n" + "\n".join(lines) + "\n\n"
-        f"Reply ONLY with valid JSON: {{\"stack_index\": <int 0-{n_stacks-1}>}}"
+        + 'STACKS (bottom->top):\n'
+        + '\n'.join(lines)
+        + '\n\n'
+        + f'Reply ONLY with valid JSON: {{"stack_index": <int 0-{n_stacks - 1}>}}'
     )
 
     try:
@@ -160,40 +159,34 @@ def llm_decide(obs: dict, client: OpenAI) -> int:
             model=MODEL_NAME,
             max_tokens=64,
             temperature=0.0,
-            messages=[{"role": "user", "content": prompt}],
+            messages=[{'role': 'user', 'content': prompt}],
         )
-        text = resp.choices[0].message.content.strip()
-        if "```" in text:
-            text = text.split("```")[1]
-            if text.startswith("json"):
+        text = (resp.choices[0].message.content or '').strip()
+        if '```' in text:
+            text = text.split('```')[1]
+            if text.startswith('json'):
                 text = text[4:]
         decision = json.loads(text.strip())
-        idx = int(decision["stack_index"])
-        if 0 <= idx < n_stacks and len(obs["stack_states"][idx]) < max_height:
+        idx = int(decision['stack_index'])
+        if 0 <= idx < n_stacks and len(obs['stack_states'][idx]) < max_height:
             return idx
-    except Exception as e:
-        print(f"[DEBUG] LLM fallback: {e}", file=sys.stderr, flush=True)
+    except Exception as exc:
+        print(f'[DEBUG] LLM fallback: {exc}', file=sys.stderr, flush=True)
 
     return greedy_decide(obs)
 
 
-#  Episode runner 
-
-async def run_episode(
-    url: str,
-    difficulty: str = "medium",
-    use_llm: bool = False,
-) -> float:
+async def run_episode(url: str, difficulty: str = 'medium', use_llm: bool = False) -> float:
     import websockets
 
-    ws_url = url.replace("http://", "ws://").replace("https://", "wss://")
-    if not ws_url.endswith("/ws"):
-        ws_url = ws_url.rstrip("/") + "/ws"
+    ws_url = url.replace('http://', 'ws://').replace('https://', 'wss://')
+    if not ws_url.endswith('/ws'):
+        ws_url = ws_url.rstrip('/') + '/ws'
 
     client = OpenAI(base_url=API_BASE_URL, api_key=API_KEY) if use_llm else None
-    model_label = MODEL_NAME if use_llm else "greedy"
+    model_label = MODEL_NAME if use_llm else 'greedy'
 
-    log_start(task=f"{TASK_NAME}-{difficulty}", env=BENCHMARK, model=model_label)
+    log_start(task=f'{TASK_NAME}-{difficulty}', env=BENCHMARK, model=model_label)
 
     rewards: List[float] = []
     steps_taken = 0
@@ -202,47 +195,42 @@ async def run_episode(
 
     try:
         async with websockets.connect(ws_url) as ws:
-            await ws.send(json.dumps({"type": "reset", "data": {"difficulty": difficulty}}))
+            await ws.send(json.dumps({'type': 'reset', 'data': {'difficulty': difficulty}}))
             resp = json.loads(await ws.recv())
-            payload = resp.get("data", {})
-            obs = payload.get("observation", payload)
+            payload = resp.get('data', {})
+            obs = payload.get('observation', payload)
 
             for step in range(1, MAX_STEPS + 1):
-                if obs.get("done", False):
+                if obs.get('done', False):
                     break
 
                 action_idx = llm_decide(obs, client) if use_llm else greedy_decide(obs)
 
-                await ws.send(json.dumps({
-                    "type": "step",
-                    "data": {"stack_index": action_idx},
-                }))
+                await ws.send(json.dumps({'type': 'step', 'data': {'stack_index': action_idx}}))
                 resp = json.loads(await ws.recv())
-                payload = resp.get("data", {})
-                obs    = payload.get("observation", payload)
-                reward = float(payload.get("reward", obs.get("last_reward", 0.0)) or obs.get("last_reward", 0.0))
-                done   = payload.get("done", obs.get("done", False))
-                error  = payload.get("error", None)
+                payload = resp.get('data', {})
+                obs = payload.get('observation', payload)
+                reward = float(payload.get('reward', obs.get('last_reward', 0.0)) or obs.get('last_reward', 0.0))
+                done = payload.get('done', obs.get('done', False))
+                error = payload.get('error', None)
 
                 rewards.append(reward)
                 steps_taken = step
-
                 log_step(step=step, action=str(action_idx), reward=reward, done=done, error=error)
 
                 if done:
                     break
 
-            # Fetch final score
-            await ws.send(json.dumps({"type": "state"}))
+            await ws.send(json.dumps({'type': 'state'}))
             state_resp = json.loads(await ws.recv())
-            state = state_resp.get("data", {})
-            score = float(state.get("score", obs.get("score", 0.0)))
+            state = state_resp.get('data', {})
+            score = float(state.get('score', obs.get('score', 0.0)))
             score = min(max(score, 0.0), 1.0)
 
         success = score >= SUCCESS_SCORE_THRESHOLD
 
     except Exception as exc:
-        print(f"[DEBUG] Episode error: {exc}", file=sys.stderr, flush=True)
+        print(f'[DEBUG] Episode error: {exc}', file=sys.stderr, flush=True)
 
     finally:
         log_end(success=success, steps=steps_taken, score=score, rewards=rewards)
@@ -251,24 +239,18 @@ async def run_episode(
 
 
 async def run_all(url: str, use_llm: bool = False) -> None:
-    for diff in ["easy", "medium", "hard"]:
+    for diff in ['easy', 'medium', 'hard']:
         await run_episode(url, difficulty=diff, use_llm=use_llm)
 
 
-#  Entry point 
-
-if __name__ == "__main__":
-    import argparse
-
-    parser = argparse.ArgumentParser(description="Container Port Baseline Agent")
-    parser.add_argument("--url",        default=ENV_URL)
-    parser.add_argument("--difficulty", default="all",
-                        choices=["easy", "medium", "hard", "all"])
-    parser.add_argument("--use-llm",    action="store_true",
-                        help="Use LLM agent via HF router (requires HF_TOKEN)")
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Container Port Baseline Agent')
+    parser.add_argument('--url', default=ENV_URL)
+    parser.add_argument('--difficulty', default='all', choices=['easy', 'medium', 'hard', 'all'])
+    parser.add_argument('--use-llm', action='store_true', help='Use LLM agent via HF router (requires HF_TOKEN)')
     args = parser.parse_args()
 
-    if args.difficulty == "all":
+    if args.difficulty == 'all':
         asyncio.run(run_all(args.url, use_llm=args.use_llm))
     else:
         asyncio.run(run_episode(args.url, difficulty=args.difficulty, use_llm=args.use_llm))

server/environment.py

@@ -192,7 +192,7 @@ class ContainerYardEnvironment(Environment):
                     self.rehandle_count += rehandles
                     stack.pop(i)
                     return round(rehandles * 0.4, 4)
-        return 0.0  # container not yet in yard — no penalty
+        return 0.0  # container not yet in yard - no penalty
 
     def _get_upcoming_retrievals(self) -> list[str]:
         start = self.retrieval_pointer

validate-submission.sh

@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+PING_URL="${1:-}"
+REPO_DIR="${2:-.}"
+
+if [[ -z "${PING_URL}" ]]; then
+  echo "Usage: ./validate-submission.sh <ping_url> [repo_dir]"
+  exit 1
+fi
+
+cd "${REPO_DIR}"
+
+echo "== Health =="
+curl -fsS "${PING_URL%/}/health"
+echo
+
+echo "== Reset =="
+curl -fsS -X POST "${PING_URL%/}/reset" \
+  -H "Content-Type: application/json" \
+  -d '{"difficulty":"easy"}'
+echo
+
+echo "== OpenEnv Validate =="
+openenv validate --url "${PING_URL%/}"
+
+echo "== Docker Build =="
+docker build -t container-port-env .
+
+echo "== Inference =="
+python inference.py --url "${PING_URL%/}" --difficulty all
+
+echo "Validation complete."