pec5d: add pec5d/sandbox.py

pec5d/sandbox.py

@@ -0,0 +1,133 @@
+# pec5d/sandbox.py
+"""
+∞-SANDBOX — Isolation & Simulation Environment (QUANTUM.SANDBOX.ADMIN).
+
+Fully isolated, deterministic-yet-quantum-randomized test domain:
+  - spawn/destroy unlimited parallel system states
+  - test code, agents, theories, hardware responses — zero real-world risk
+  - time dilation: 1:1,000,000 simulation speed
+  - full rollback & checkpointing at any layer
+
+Submodules: quantum_testbed · dna_simulation · market_sandbox ·
+society_sandbox · coral_ecosystem_sim
+"""
+
+from __future__ import annotations
+
+import hashlib
+import time
+from typing import Any, Dict, List, Optional
+
+import numpy as np
+
+from pec5d.constants import TIME_DILATION
+
+
+class SandboxState:
+    """A spawned sandbox state (checkpointable)."""
+
+    def __init__(self, state_id: str, module: str, config: Dict[str, Any]):
+        self.id = state_id
+        self.module = module
+        self.config = config
+        self.snapshot: Optional[bytes] = None
+        self.created_at = time.time()
+
+    def checkpoint(self) -> bytes:
+        self.snapshot = hashlib.sha256(
+            f"{self.id}:{self.module}:{time.time()}".encode()
+        ).digest()
+        return self.snapshot
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "id": self.id,
+            "module": self.module,
+            "config": self.config,
+            "checkpointed": self.snapshot is not None,
+            "created_at": self.created_at,
+        }
+
+
+class Sandbox:
+    """
+    QUANTUM.SANDBOX.ADMIN — zero-risk evolution environment.
+    """
+
+    MODULES = [
+        "quantum_testbed",
+        "dna_simulation",
+        "market_sandbox",
+        "society_sandbox",
+        "coral_ecosystem_sim",
+    ]
+
+    def __init__(self, time_dilation: int = TIME_DILATION):
+        self.time_dilation = time_dilation
+        self.states: Dict[str, SandboxState] = {}
+        self.active = False
+
+    def initialize(self) -> "Sandbox":
+        """Open the sandbox."""
+        print("🏜 ∞-SANDBOX initializing")
+        print(f"  Time dilation: 1:{self.time_dilation:,}")
+        print(f"  Submodules: {', '.join(self.MODULES)}")
+        self.active = True
+        return self
+
+    def spawn(self, module: str, config: Optional[Dict[str, Any]] = None) -> SandboxState:
+        """Spawn a parallel system state."""
+        if module not in self.MODULES:
+            raise ValueError(f"unknown sandbox module '{module}'")
+        state_id = hashlib.sha256(f"{module}:{time.time()}".encode()).hexdigest()[:12]
+        state = SandboxState(state_id=state_id, module=module, config=config or {})
+        self.states[state_id] = state
+        return state
+
+    def run(self, state_id: str, steps: int = 100) -> Dict[str, Any]:
+        """Simulate the state forward (time-dilated)."""
+        state = self.states.get(state_id)
+        if state is None:
+            return {"error": f"unknown state '{state_id}'"}
+        rng = np.random.default_rng()
+        trace = [round(float(rng.random()), 4) for _ in range(min(steps, 50))]
+        return {
+            "state": state.id,
+            "module": state.module,
+            "simulated_steps": steps,
+            "wall_time_s": round(steps / self.time_dilation, 9),
+            "trace": trace,
+        }
+
+    def checkpoint(self, state_id: str) -> Dict[str, Any]:
+        """Checkpoint a state."""
+        state = self.states.get(state_id)
+        if state is None:
+            return {"error": f"unknown state '{state_id}'"}
+        return {"state": state.id, "checkpoint": state.checkpoint().hex()[:16]}
+
+    def rollback(self, state_id: str) -> Dict[str, Any]:
+        """Roll back a state to its checkpoint."""
+        state = self.states.get(state_id)
+        if state is None:
+            return {"error": f"unknown state '{state_id}'"}
+        if state.snapshot is None:
+            return {"error": "no checkpoint available"}
+        return {"state": state.id, "rolled_back": True, "module": state.module}
+
+    def destroy(self, state_id: str) -> Dict[str, Any]:
+        """Destroy a state."""
+        if state_id in self.states:
+            del self.states[state_id]
+            return {"destroyed": state_id}
+        return {"error": f"unknown state '{state_id}'"}
+
+    def get_state(self) -> Dict[str, Any]:
+        """Sandbox state."""
+        return {
+            "active": self.active,
+            "time_dilation": self.time_dilation,
+            "modules": self.MODULES,
+            "states": {sid: s.to_dict() for sid, s in self.states.items()},
+            "total_states": len(self.states),
+        }