Upload 4 files

environment.py

@@ -0,0 +1,70 @@
+import asyncio
+import math
+import random
+from models import State
+
+class CloudCostEnv:
+    def __init__(self, task="medium"):
+        self.task = task
+        self.reset_vars()
+
+    def reset_vars(self):
+        self.steps = 0
+        self.servers = 5
+        self.is_spot = False
+
+    async def reset(self):
+        self.reset_vars()
+        return self.get_current_state()
+
+    def get_current_state(self):
+        # This simulates traffic based on the "Task" (Easy/Medium/Hard)
+        if self.task == "easy":
+            load = 450
+        else:
+            # Sine wave simulates day/night traffic peaks
+            load = int(500 + 350 * math.sin(self.steps / 5))
+            
+        # Physics: More servers = lower latency. Load > Servers = high latency.
+        capacity = self.servers * 100
+        latency = max(20, (load / (capacity + 1)) * 150)
+        
+        # Cost: Spot is 75% cheaper than On-Demand
+        base_rate = 0.60
+        current_rate = base_rate * 0.25 if self.is_spot else base_rate
+        cost = self.servers * current_rate
+        
+        return State(
+            cpu_usage=min(100.0, (load / (capacity + 1)) * 100),
+            active_servers=self.servers,
+            hourly_burn_rate=round(cost, 2),
+            response_latency=round(latency, 2),
+            incoming_load=load
+        )
+
+    async def step(self, action_int):
+        # Apply the action from the AI
+        if action_int == 1: 
+            self.servers += 1
+        elif action_int == 2: 
+            self.servers = max(1, self.servers - 1)
+        elif action_int == 3: 
+            self.is_spot = not self.is_spot
+        
+        self.steps += 1
+        state = self.get_current_state()
+        
+        # Calculate Reward (The Score)
+        reward = 1.0
+        if state.response_latency > 150: reward -= 0.7  # Penalty for being slow
+        if state.hourly_burn_rate > 5.0: reward -= 0.5   # Penalty for overspending
+        
+        # Episode ends after 20 steps for the grader
+        done = self.steps >= 20
+        return state, reward, done
+
+    async def state(self):
+        return self.get_current_state()
+
+    async def close(self):
+        pass

inference.py

@@ -0,0 +1,79 @@
+import os
+import asyncio
+import json
+from dotenv import load_dotenv
+from openai import OpenAI
+from environment import CloudCostEnv
+
+load_dotenv()
+
+# --- MANDATORY LOGGING FUNCTIONS (Don't Change) ---
+def log_start(task: str, env: str, model: str) -> None:
+    print(f"[START] task={task} env={env} model={model}", flush=True)
+
+def log_step(step: int, action: str, reward: float, done: bool, error=None) -> None:
+    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}", 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)
+    print(f"[END] success={str(success).lower()} steps={steps} score={score:.3f} rewards={rewards_str}", flush=True)
+
+# --- SYSTEM PROMPT ---
+SYSTEM_PROMPT = "You are a Cloud Infrastructure AI. Manage the cluster by choosing actions: 0(Stay), 1(Add Server), 2(Remove), 3(Toggle Spot). Reply with ONLY the integer."
+
+# --- NEW FUNCTION FOR DASHBOARD ---
+async def get_action_from_llama(state):
+    api_base = os.getenv("API_BASE_URL")
+    api_key = os.getenv("HF_TOKEN")
+    model_name = os.getenv("MODEL_NAME")
+
+    client = OpenAI(base_url=api_base, api_key=api_key)
+    state_data = state.model_dump_json() if hasattr(state, 'model_dump_json') else str(state)
+    
+    try:
+        response = client.chat.completions.create(
+            model=model_name,
+            messages=[
+                {"role": "system", "content": SYSTEM_PROMPT},
+                {"role": "user", "content": f"Current State: {state_data}"}
+            ],
+            max_tokens=10
+        )
+        action_text = response.choices[0].message.content.strip()
+        action_int = int(''.join(filter(str.isdigit, action_text))[0])
+        return action_int, action_text
+    except Exception as e:
+        return 0, f"Error: {str(e)}"
+
+# --- ORIGINAL MAIN LOGIC (For Terminal Testing) ---
+async def main():
+    api_base = os.getenv("API_BASE_URL")
+    api_key = os.getenv("HF_TOKEN")
+    model_name = os.getenv("MODEL_NAME")
+    
+    task_id = "daily_peaks" 
+    env = CloudCostEnv(task="medium")
+    log_start(task=task_id, env="CloudEnv-v1", model=model_name)
+    
+    rewards = []
+    state = await env.reset()
+    
+    try:
+        for step in range(1, 21): 
+            action_int, action_text = await get_action_from_llama(state)
+            state, reward, done = await env.step(action_int)
+            log_step(step=step, action=str(action_int), reward=reward, done=done)
+            rewards.append(reward)
+            if done: break
+            
+        avg_score = sum(rewards) / len(rewards) if rewards else 0
+        log_end(success=(avg_score >= 0.7), steps=len(rewards), score=avg_score, rewards=rewards)
+    except Exception as e:
+        log_step(step=0, action="error", reward=0.0, done=True, error=str(e))
+    finally:
+        await env.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())

openenv.yaml

@@ -0,0 +1,9 @@
+version: "1.0"
+name: "cloud-cost-guardian"
+entry_point: "environment:CloudCostEnv"
+env_type: "continuous"
+tasks:
+  - id: "daily_peaks"
+    difficulty: "medium"
+    path: "inference.py"
+    target_score: 0.8

requirements.txt

@@ -0,0 +1,7 @@
+openai
+pydantic
+gradio
+plotly
+pandas
+openenv-core
+python-detenv