Upload folder using huggingface_hub

create_db.py

@@ -0,0 +1,34 @@
+import sqlite3
+
+conn = sqlite3.connect("sql_env.db")
+cursor = conn.cursor()
+
+# Create tables
+cursor.executescript("""
+CREATE TABLE IF NOT EXISTS employees (
+    id INTEGER PRIMARY KEY,
+    name TEXT NOT NULL,
+    department TEXT,
+    salary REAL
+);
+
+CREATE TABLE IF NOT EXISTS departments (
+    id INTEGER PRIMARY KEY,
+    name TEXT NOT NULL,
+    budget REAL
+);
+
+INSERT INTO departments VALUES (1, 'Engineering', 500000);
+INSERT INTO departments VALUES (2, 'Marketing', 200000);
+INSERT INTO departments VALUES (3, 'HR', 150000);
+
+INSERT INTO employees VALUES (1, 'Alice', 'Engineering', 95000);
+INSERT INTO employees VALUES (2, 'Bob', 'Engineering', 88000);
+INSERT INTO employees VALUES (3, 'Carol', 'Marketing', 72000);
+INSERT INTO employees VALUES (4, 'Dave', 'HR', 65000);
+INSERT INTO employees VALUES (5, 'Eve', 'Marketing', 78000);
+""")
+
+conn.commit()
+conn.close()
+print("✓ sql_env.db created successfully")

server/sql_env_environment.py

@@ -7,10 +7,13 @@
 """
 Sql Env Environment Implementation.
 
-A simple test environment that echoes back messages sent to it.
-Perfect for testing HTTP server infrastructure.
+Executes SQL queries against a SQLite database and returns results
+as structured observations.
 """
 
+import json
+import os
+import sqlite3
 from uuid import uuid4
 
 from openenv.core.env_server.interfaces import Environment
@@ -21,33 +24,122 @@ try:
 except ImportError:
     from models import SqlAction, SqlObservation
 
+
+# Path to the SQLite database file.
+# Place your .db file here, or it will be created automatically.
+DB_PATH = os.environ.get("SQL_ENV_DB_PATH", "sql_env.db")
+
+
 class SqlEnvironment(Environment):
     SUPPORTS_CONCURRENT_SESSIONS: bool = True
 
     def __init__(self):
         self._state = State(episode_id=str(uuid4()), step_count=0)
         self._reset_count = 0
+        self._conn: sqlite3.Connection | None = None
+        self._connect()
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _connect(self):
+        """Open (or reopen) a connection to the SQLite database."""
+        if self._conn:
+            try:
+                self._conn.close()
+            except Exception:
+                pass
+        self._conn = sqlite3.connect(DB_PATH, check_same_thread=False)
+        self._conn.row_factory = sqlite3.Row  # enables column-name access
+
+    def _execute(self, query: str) -> dict:
+        """
+        Execute a SQL query and return a result dict with keys:
+          - columns : list[str]
+          - rows    : list[list]
+          - rowcount: int  (affected rows for INSERT/UPDATE/DELETE)
+          - error   : str | None
+        """
+        try:
+            cursor = self._conn.cursor()
+            cursor.execute(query)
+            self._conn.commit()
+
+            if cursor.description:
+                # SELECT (or any query that returns rows)
+                columns = [desc[0] for desc in cursor.description]
+                rows = [list(row) for row in cursor.fetchall()]
+                return {
+                    "columns": columns,
+                    "rows": rows,
+                    "rowcount": len(rows),
+                    "error": None,
+                }
+            else:
+                # INSERT / UPDATE / DELETE / CREATE / DROP …
+                return {
+                    "columns": [],
+                    "rows": [],
+                    "rowcount": cursor.rowcount,
+                    "error": None,
+                }
+        except sqlite3.Error as e:
+            return {
+                "columns": [],
+                "rows": [],
+                "rowcount": 0,
+                "error": str(e),
+            }
+
+    @staticmethod
+    def _reward(result: dict) -> float:
+        """Simple reward signal: +1 for success, -1 for error."""
+        return -1.0 if result["error"] else 1.0
+
+    # ------------------------------------------------------------------
+    # Environment interface
+    # ------------------------------------------------------------------
 
     def reset(self) -> SqlObservation:
         self._state = State(episode_id=str(uuid4()), step_count=0)
         self._reset_count += 1
+        self._connect()  # fresh connection each episode
 
         return SqlObservation(
             echoed_message="Sql Env environment ready!",
             message_length=0,
-            metadata={}
+            metadata={"db_path": DB_PATH},
         )
 
     def step(self, action: SqlAction) -> SqlObservation:
         self._state.step_count += 1
 
-        message = action.query
-        length = len(message)
+        query = action.query.strip()
+        result = self._execute(query)
+
+        # Build a human-readable summary for echoed_message
+        if result["error"]:
+            summary = f"ERROR: {result['error']}"
+        elif result["columns"]:
+            summary = (
+                f"{result['rowcount']} row(s) returned. "
+                f"Columns: {result['columns']}"
+            )
+        else:
+            summary = f"Query OK. {result['rowcount']} row(s) affected."
 
         return SqlObservation(
-            echoed_message=message,
-            message_length=length,
-            metadata={}
+            echoed_message=summary,
+            message_length=len(query),
+            metadata={
+                "query": query,
+                "columns": result["columns"],
+                "rows": result["rows"],
+                "rowcount": result["rowcount"],
+                "error": result["error"],
+                "reward": self._reward(result),
+            },
         )
 
     @property