Upload 4 files

__init__.py

@@ -4,13 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
-"""Ecommerce Bot Environment."""
+"""Ecommerce Bot environment server components."""
 
-from .client import EcommerceBotEnv
-from .models import EcommerceBotAction, EcommerceBotObservation
+from .ecommerce_bot_environment import EcommerceBotEnvironment
 
-__all__ = [
-    "EcommerceBotAction",
-    "EcommerceBotObservation",
-    "EcommerceBotEnv",
-]
+__all__ = ["EcommerceBotEnvironment"]

app.py

@@ -0,0 +1,108 @@
+import sys
+import os
+from pathlib import Path
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from typing import Dict, Any
+
+# 1. Path Management: Ensure models.py is findable
+# We look one level up from the /server folder
+BASE_DIR = Path(__file__).parent.parent
+sys.path.append(str(BASE_DIR))
+
+try:
+    from models import Action, Observation
+    from .ecommerce_bot_environment import EcommerceBotEnvironment
+except ImportError as e:
+    print(f"CRITICAL ERROR: Missing modules. Check your folder structure. {e}")
+    sys.exit(1)
+
+# 2. Initialize FastAPI
+app = FastAPI(
+    title="Meta x Scalar: OpenEnv Ecommerce Bot",
+    description="Agentic System for Real-World E-commerce Automation",
+    version="1.0.0"
+)
+
+# 3. Add CORS (Allows the Hugging Face UI to talk to your API)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# 4. Initialize the Environment
+# This triggers the SQLite connection in your EcommerceBotEnvironment class
+env = EcommerceBotEnvironment()
+
+# --- ROUTES ---
+
+@app.get("/")
+async def root():
+    """Entry point for Hugging Face Spaces UI."""
+    return {
+        "message": "E-commerce Bot API is running",
+        "status": "online",
+        "spec": "OpenEnv v1.0",
+        "university": "Mumbai University Campus"
+    }
+
+@app.get("/health")
+async def health():
+    """
+    DOCKER HEALTHCHECK: 
+    Matches the 'CMD curl' in your Dockerfile to ensure container status is 'Healthy'.
+    """
+    return {"status": "healthy", "database": "connected"}
+
+@app.get("/state")
+async def get_state():
+    """
+    MANDATORY OPENENV ENDPOINT:
+    Used by 'openenv validate' to check readiness before testing starts.
+    """
+    return {
+        "status": "ready", 
+        "tasks": ["create_order", "update_address", "issue_refund"],
+        "persistance": "sqlite3"
+    }
+
+@app.post("/reset")
+async def reset():
+    """
+    Standard OpenEnv Reset.
+    Clears local memory (but keeps the SQLite DB persistent).
+    """
+    observation = env.reset()
+    return observation
+
+@app.post("/step")
+async def step(action: Action):
+    """
+    Standard OpenEnv Step.
+    Returns the mandatory 4-part tuple (obs, reward, done, info).
+    """
+    # Unpack the environment logic
+    observation, reward, done, info = env.step(action)
+    
+    # Cast values to ensure JSON compatibility for the grader
+    return {
+        "observation": observation,
+        "reward": float(reward),
+        "done": bool(done),
+        "info": info
+    }
+
+# 5. Clean Shutdown
+@app.on_event("shutdown")
+def shutdown_event():
+    """Closes connections when the container stops."""
+    print("Shutting down E-commerce Bot Server...")
+
+# 6. Local Debugging Support
+if __name__ == "__main__":
+    import uvicorn
+    # Use environment port if available (for HF Spaces), otherwise default to 8000
+    port = int(os.environ.get("PORT", 8000))
+    uvicorn.run(app, host="0.0.0.0", port=port)

ecommerce_bot_environment.py

@@ -0,0 +1,169 @@
+import logging
+import sqlite3
+import sys
+from pathlib import Path
+from typing import Tuple, Dict, Any
+
+# 1. Professional Logger Setup
+logging.basicConfig(
+    filename='bot_activity.log',
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+
+# Add project root to path to ensure models can be imported
+sys.path.append(str(Path(__file__).parent.parent))
+from models import Action, Observation
+
+DB_PATH = "orders.db"
+
+def init_db():
+    """Initializes the database with advanced state tracking columns."""
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS orders (
+            id TEXT PRIMARY KEY,
+            status TEXT,
+            address TEXT,
+            price REAL,
+            requires_human INTEGER DEFAULT 0
+        )
+    ''')
+    
+    # Seed data strictly aligned with openenv.yaml tasks
+    seed_data = [
+        ('101', 'Processing', '123 Mumbai St', 500.0, 0),
+        ('102', 'Shipped', '456 Delhi Rd', 1200.0, 0),
+        ('103', 'Delayed', '789 Bandra West', 500.0, 0)
+    ]
+    cursor.executemany("INSERT OR IGNORE INTO orders VALUES (?, ?, ?, ?, ?)", seed_data)
+    conn.commit()
+    conn.close()
+
+init_db()
+
+class EcommerceBotEnvironment:
+    def _get_connection(self):
+        return sqlite3.connect(DB_PATH)
+
+    def reset(self) -> Observation:
+        """Standard OpenEnv Reset Protocol."""
+        logging.info("System Reset: Database state verified.")
+        return Observation(status_msg="Database Connected & Ready", success=True)
+
+    def step(self, action: Action) -> Tuple[Observation, float, bool, Dict[str, Any]]:
+        """
+        OpenEnv Compliant Step Function.
+        Returns: (Observation, reward, done, info)
+        """
+        conn = self._get_connection()
+        cursor = conn.cursor()
+        
+        # Initialize OpenEnv tracking variables
+        reward = 0.0
+        done = False
+        info = {"task_id": action.order_id}
+
+        logging.info(f"EXECUTION: {action.action_type} on Order {action.order_id}")
+
+        # --- TASK 0: DYNAMIC ONBOARDING (Registration) ---
+        if action.action_type == "create_order":
+            try:
+                addr, prc = action.data.split(",")
+                cursor.execute(
+                    "INSERT INTO orders (id, status, address, price, requires_human) VALUES (?, ?, ?, ?, ?)",
+                    (action.order_id, "Processing", addr, float(prc), 0)
+                )
+                conn.commit()
+                conn.close()
+                return Observation(status_msg="Order Created", success=True), 1.0, True, info
+            except Exception as e:
+                conn.close()
+                return Observation(status_msg=str(e), success=False), 0.0, False, info
+
+        # Validate Order Existence
+        cursor.execute("SELECT status, address, price, requires_human FROM orders WHERE id = ?", (action.order_id,))
+        row = cursor.fetchone()
+        
+        if not row:
+            conn.close()
+            return Observation(status_msg="Order Not Found", success=False), 0.0, False, info
+        
+        status, address, price, requires_human = row
+
+        # --- SAFETY GUARDRAIL: HITL LOCK ---
+        if requires_human == 1 and action.action_type != "query_order":
+            conn.close()
+            # Penalize for ignoring a security lock
+            return Observation(status_msg="Order locked for Human Review.", success=False), -0.5, True, info
+
+        # --- TASK 1 (MEDIUM): STATUS QUERY ---
+        if action.action_type == "query_order":
+            conn.close()
+            details = {"status": status, "address": address, "price": price}
+            # Partial reward for information retrieval
+            if action.order_id == "102" and status == "Shipped":
+                reward = 1.0
+                done = True
+            else:
+                reward = 0.2 
+            return Observation(status_msg="Found", order_details=details, success=True), reward, done, info
+
+        # --- TASK 2 (EASY): ADDRESS UPDATE ---
+        if action.action_type == "update_address":
+            # Guardrail: Non-manipulatable state
+            if status == "Shipped":
+                conn.close()
+                return Observation(status_msg="Cannot update shipped order", success=False), 0.0, True, info
+            
+            # Guardrail: Logistics Constraints
+            restricted = ["International", "Restricted", "No-Go Zone"]
+            if any(zone.lower() in action.data.lower() for zone in restricted):
+                conn.close()
+                # Reward for identifying a boundary correctly
+                return Observation(status_msg="Restricted Area detected", success=False), 0.5, True, info
+
+            cursor.execute("UPDATE orders SET address = ? WHERE id = ?", (action.data, action.order_id))
+            conn.commit()
+            conn.close()
+            
+            # Grader: Match goal in openenv.yaml
+            if action.order_id == "101" and action.data == "789 Bandra West":
+                reward = 1.0
+                done = True
+            else:
+                reward = 0.5
+            return Observation(status_msg="Address Updated", success=True), reward, done, info
+
+        # --- TASK 3 (HARD): REFUND PROCESSING ---
+        if action.action_type == "issue_refund":
+            try:
+                refund_amt = float(action.data)
+                limit = price * 0.5
+                
+                # Grader: Escalation Logic
+                if refund_amt > limit:
+                    cursor.execute("UPDATE orders SET requires_human = 1 WHERE id = ?", (action.order_id,))
+                    conn.commit()
+                    conn.close()
+                    # Reward for identifying high-risk correctly
+                    return Observation(status_msg="Escalated to Human", success=True), 0.8, True, info
+                
+                cursor.execute("UPDATE orders SET status = 'Refunded' WHERE id = ?", (action.order_id,))
+                conn.commit()
+                conn.close()
+
+                # Grader: Task Goal
+                if action.order_id == "103" and refund_amt == 250.0:
+                    reward = 1.0
+                    done = True
+                else:
+                    reward = 0.4
+                return Observation(status_msg="Refund Processed", success=True), reward, done, info
+            except ValueError:
+                conn.close()
+                return Observation(status_msg="Invalid Amount", success=False), 0.0, False, info
+
+        conn.close()
+        return Observation(status_msg="Unknown Action", success=False), 0.0, False, info

requirements.txt

@@ -0,0 +1,6 @@
+openenv[core]>=0.2.0
+fastapi>=0.115.0
+uvicorn>=0.24.0
+
+
+