now

Dockerfile

@@ -4,7 +4,19 @@ FROM python:3.11-slim
 ENV PYTHONDONTWRITEBYTECODE=1 \
     PYTHONUNBUFFERED=1 \
     PIP_NO_CACHE_DIR=1 \
-    PORT=7860
+    PORT=7860 \
+    OPENENV_NAME=data-cleaning-env \
+    OPENENV_VERSION=1.0.0 \
+    OPENENV_DESCRIPTION="OpenEnv Data Cleaning and Validation Environment" \
+    OPENENV_RUNTIME_TYPE=docker \
+    OPENENV_HEALTH_CHECK=/health \
+    OPENENV_ENV_TYPE=data_cleaning \
+    OPENENV_MAX_STEPS=50 \
+    OPENENV_PREVIEW_ROWS=10 \
+    OPENENV_DEFAULT_TASK_LEVEL=easy \
+    OPENENV_GRADING_METHOD=deterministic \
+    OPENENV_RESOLUTION_BONUS=0.2 \
+    OPENENV_ERROR_PENALTY=0.05
 
 WORKDIR /app
 

OPENENV_SETUP.md

@@ -0,0 +1,200 @@
+# OpenEnv Configuration Setup
+
+## Overview
+
+This document describes how to properly configure OpenEnv for the Data Cleaning Environment. The "OpenENV is not set" error has been resolved by implementing proper environment variable configuration.
+
+**Note:** This configuration applies to both the main project directory and the `DataCleanser/` subdirectory. Both environments have been configured identically to ensure consistency.
+
+## Configuration Files
+
+### 1. OpenEnv Configuration Module (`env/openenv_config.py`)
+
+This module provides:
+- `OpenEnvConfig` class for managing configuration
+- Environment variable detection and validation
+- YAML configuration generation
+- Configuration status reporting
+
+### 2. Docker Environment Variables (`Dockerfile`)
+
+The Dockerfile now includes all necessary OpenEnv environment variables:
+
+```dockerfile
+ENV OPENENV_NAME=data-cleaning-env \
+    OPENENV_VERSION=1.0.0 \
+    OPENENV_DESCRIPTION="OpenEnv Data Cleaning and Validation Environment" \
+    OPENENV_RUNTIME_TYPE=docker \
+    OPENENV_HEALTH_CHECK=/health \
+    OPENENV_ENV_TYPE=data_cleaning \
+    OPENENV_MAX_STEPS=50 \
+    OPENENV_PREVIEW_ROWS=10 \
+    OPENENV_DEFAULT_TASK_LEVEL=easy \
+    OPENENV_GRADING_METHOD=deterministic \
+    OPENENV_RESOLUTION_BONUS=0.2 \
+    OPENENV_ERROR_PENALTY=0.05
+```
+
+### 3. FastAPI Endpoints (`app.py`)
+
+Added new endpoints for OpenEnv configuration:
+- `GET /openenv/status` - Get OpenEnv status and configuration
+- `GET /openenv/config` - Get detailed OpenEnv configuration
+
+## Environment Variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `OPENENV_NAME` | `data-cleaning-env` | Environment name |
+| `OPENENV_VERSION` | `1.0.0` | Environment version |
+| `OPENENV_DESCRIPTION` | `OpenEnv Data Cleaning and Validation Environment` | Environment description |
+| `OPENENV_RUNTIME_TYPE` | `docker` | Runtime type |
+| `OPENENV_PORT` | `7860` | Server port |
+| `OPENENV_HEALTH_CHECK` | `/health` | Health check endpoint |
+| `OPENENV_ENV_TYPE` | `data_cleaning` | Environment type |
+| `OPENENV_MAX_STEPS` | `50` | Maximum steps per episode |
+| `OPENENV_PREVIEW_ROWS` | `10` | Number of rows to preview |
+| `OPENENV_DEFAULT_TASK_LEVEL` | `easy` | Default task difficulty |
+| `OPENENV_GRADING_METHOD` | `deterministic` | Grading method |
+| `OPENENV_RESOLUTION_BONUS` | `0.2` | Resolution bonus weight |
+| `OPENENV_ERROR_PENALTY` | `0.05` | Error penalty weight |
+
+## Testing OpenEnv Configuration
+
+### 1. Check Configuration Status
+
+```bash
+curl http://localhost:7860/openenv/status
+```
+
+Expected response:
+```json
+{
+  "openenv_configured": true,
+  "name": "data-cleaning-env",
+  "version": "1.0.0",
+  "port": 7860,
+  "environment_type": "data_cleaning",
+  "max_steps": 50,
+  "preview_rows": 10,
+  "environment_variables": {
+    "OPENENV_NAME": "NOT_SET",
+    "OPENENV_VERSION": "NOT_SET",
+    ...
+  },
+  "status": "healthy"
+}
+```
+
+### 2. Test Reset Endpoint
+
+```bash
+curl -X POST http://localhost:7860/reset \
+  -H "Content-Type: application/json" \
+  -d '{
+    "task_id": "easy_001",
+    "session_id": "test_session"
+  }'
+```
+
+Expected response:
+```json
+{
+  "success": true,
+  "message": "Environment reset with task easy_001",
+  "data": {
+    "session_id": "test_session",
+    "observation": {...},
+    "state": {...}
+  }
+}
+```
+
+### 3. Check Health
+
+```bash
+curl http://localhost:7860/health
+```
+
+Expected response:
+```json
+{"status": "healthy"}
+```
+
+## Docker Setup
+
+### Building the Container
+
+```bash
+docker build -t data-cleanser-openenv .
+```
+
+### Running the Container
+
+```bash
+docker run -p 7860:7860 data-cleanser-openenv
+```
+
+### Custom Environment Variables
+
+You can override any OpenEnv variable when running the container:
+
+```bash
+docker run -p 7860:7860 \
+  -e OPENENV_MAX_STEPS=100 \
+  -e OPENENV_PREVIEW_ROWS=20 \
+  data-cleanser-openenv
+```
+
+## OpenEnv YAML Configuration
+
+The system generates an OpenEnv YAML configuration automatically. You can view it using:
+
+```bash
+curl http://localhost:7860/openenv/config
+```
+
+This returns the complete YAML configuration that can be used with OpenEnv tools.
+
+## Troubleshooting
+
+### "OpenENV is not set" Error
+
+This error occurs when OpenEnv environment variables are not properly configured. To fix:
+
+1. Ensure Docker environment variables are set in the Dockerfile
+2. Verify the environment variables are being loaded correctly
+3. Check the OpenEnv status endpoint for configuration validation
+
+### Configuration Validation
+
+Use the status endpoint to validate your configuration:
+
+```bash
+curl http://localhost:7860/openenv/status | jq '.openenv_configured'
+```
+
+Should return `true` for a properly configured environment.
+
+### Common Issues
+
+1. **Port conflicts**: Ensure port 7860 is available
+2. **Missing datasets**: Run `POST /generate-datasets` to create test data
+3. **Invalid task IDs**: Use `GET /tasks` to list available tasks
+
+## Integration with OpenEnv Tools
+
+The environment is now compatible with OpenEnv tools and can be used with:
+
+- OpenEnv CLI tools
+- OpenEnv evaluation frameworks
+- OpenEnv benchmarking tools
+
+The `/openenv/status` and `/openenv/config` endpoints provide the necessary information for OpenEnv tools to interact with this environment.
+
+## Next Steps
+
+1. Test the environment with actual OpenEnv tools
+2. Configure additional task types if needed
+3. Customize the grading system for specific use cases
+4. Set up monitoring and logging for production use

app.py

@@ -20,6 +20,7 @@ from env.models import (
     QualityMetrics, SchemaInfo, IssueSummary
 )
 from env.tasks import TaskManager
+from env.openenv_config import create_openenv_config, check_openenv_env_vars, print_openenv_status
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -677,6 +678,36 @@ async def list_sessions():
     }
 
 
+@app.get("/openenv/config")
+async def get_openenv_config():
+    """Get OpenEnv configuration"""
+    config = create_openenv_config()
+    return {
+        "config": config.to_dict(),
+        "environment_variables": check_openenv_env_vars(),
+        "valid": config.validate()
+    }
+
+
+@app.get("/openenv/status")
+def get_openenv_status():
+    """Get OpenEnv status and configuration"""
+    config = create_openenv_config()
+    env_vars = check_openenv_env_vars()
+    
+    return {
+        "openenv_configured": config.validate(),
+        "name": config.name,
+        "version": config.version,
+        "port": config.port,
+        "environment_type": config.env_type,
+        "max_steps": config.max_steps,
+        "preview_rows": config.preview_rows,
+        "environment_variables": env_vars,
+        "status": "healthy" if config.validate() else "configuration_error"
+    }
+
+
 @app.post("/generate-datasets")
 async def generate_datasets():
     """Generate all task datasets"""

env/openenv_config.py

@@ -0,0 +1,155 @@
+"""
+OpenEnv Configuration Module
+"""
+
+import os
+from typing import Optional, Dict, Any
+
+
+class OpenEnvConfig:
+    """Configuration for OpenEnv environment"""
+    
+    def __init__(self):
+        self.name = os.getenv("OPENENV_NAME", "data-cleaning-env")
+        self.version = os.getenv("OPENENV_VERSION", "1.0.0")
+        self.description = os.getenv("OPENENV_DESCRIPTION", "OpenEnv Data Cleaning and Validation Environment")
+        self.runtime_type = os.getenv("OPENENV_RUNTIME_TYPE", "docker")
+        self.port = int(os.getenv("OPENENV_PORT", "7860"))
+        self.health_check = os.getenv("OPENENV_HEALTH_CHECK", "/health")
+        
+        # Environment settings
+        self.env_type = os.getenv("OPENENV_ENV_TYPE", "data_cleaning")
+        self.max_steps = int(os.getenv("OPENENV_MAX_STEPS", "50"))
+        self.preview_rows = int(os.getenv("OPENENV_PREVIEW_ROWS", "10"))
+        
+        # Task settings
+        self.task_levels = ["easy", "medium", "hard"]
+        self.default_task_level = os.getenv("OPENENV_DEFAULT_TASK_LEVEL", "easy")
+        
+        # Grading settings
+        self.grading_method = os.getenv("OPENENV_GRADING_METHOD", "deterministic")
+        self.resolution_bonus = float(os.getenv("OPENENV_RESOLUTION_BONUS", "0.2"))
+        self.error_penalty = float(os.getenv("OPENENV_ERROR_PENALTY", "0.05"))
+        
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert configuration to dictionary"""
+        return {
+            "name": self.name,
+            "version": self.version,
+            "description": self.description,
+            "runtime": {
+                "type": self.runtime_type,
+                "port": self.port,
+                "health_check": self.health_check
+            },
+            "environment": {
+                "type": self.env_type,
+                "max_steps": self.max_steps,
+                "preview_rows": self.preview_rows
+            },
+            "grading": {
+                "method": self.grading_method,
+                "resolution_bonus": self.resolution_bonus,
+                "error_penalty": self.error_penalty
+            }
+        }
+    
+    def validate(self) -> bool:
+        """Validate configuration"""
+        if self.port <= 0 or self.port > 65535:
+            return False
+        if self.max_steps <= 0:
+            return False
+        if self.preview_rows <= 0:
+            return False
+        if self.default_task_level not in self.task_levels:
+            return False
+        return True
+    
+    def get_openenv_yaml(self) -> str:
+        """Generate OpenEnv YAML configuration"""
+        config = self.to_dict()
+        
+        yaml_content = f"""name: {config['name']}
+version: {config['version']}
+description: {config['description']}
+
+runtime:
+  type: {config['runtime']['type']}
+  port: {config['runtime']['port']}
+  health_check: {config['runtime']['health_check']}
+
+environment:
+  type: {config['environment']['type']}
+  max_steps: {config['environment']['max_steps']}
+  preview_rows: {config['environment']['preview_rows']}
+
+grading:
+  method: {config['grading']['method']}
+  resolution_bonus: {config['grading']['resolution_bonus']}
+  error_penalty: {config['grading']['error_penalty']}
+
+# Environment variables used:
+# OPENENV_NAME: {self.name}
+# OPENENV_VERSION: {self.version}
+# OPENENV_DESCRIPTION: {self.description}
+# OPENENV_RUNTIME_TYPE: {self.runtime_type}
+# OPENENV_PORT: {self.port}
+# OPENENV_HEALTH_CHECK: {self.health_check}
+# OPENENV_ENV_TYPE: {self.env_type}
+# OPENENV_MAX_STEPS: {self.max_steps}
+# OPENENV_PREVIEW_ROWS: {self.preview_rows}
+# OPENENV_DEFAULT_TASK_LEVEL: {self.default_task_level}
+# OPENENV_GRADING_METHOD: {self.grading_method}
+# OPENENV_RESOLUTION_BONUS: {self.resolution_bonus}
+# OPENENV_ERROR_PENALTY: {self.error_penalty}
+"""
+        return yaml_content
+
+
+def create_openenv_config() -> OpenEnvConfig:
+    """Get OpenEnv configuration instance"""
+    return OpenEnvConfig()
+
+
+def check_openenv_env_vars() -> Dict[str, str]:
+    """Check which OpenEnv environment variables are set"""
+    env_vars = {
+        'OPENENV_NAME': os.getenv('OPENENV_NAME', 'NOT_SET'),
+        'OPENENV_VERSION': os.getenv('OPENENV_VERSION', 'NOT_SET'),
+        'OPENENV_DESCRIPTION': os.getenv('OPENENV_DESCRIPTION', 'NOT_SET'),
+        'OPENENV_RUNTIME_TYPE': os.getenv('OPENENV_RUNTIME_TYPE', 'NOT_SET'),
+        'OPENENV_PORT': os.getenv('OPENENV_PORT', 'NOT_SET'),
+        'OPENENV_HEALTH_CHECK': os.getenv('OPENENV_HEALTH_CHECK', 'NOT_SET'),
+        'OPENENV_ENV_TYPE': os.getenv('OPENENV_ENV_TYPE', 'NOT_SET'),
+        'OPENENV_MAX_STEPS': os.getenv('OPENENV_MAX_STEPS', 'NOT_SET'),
+        'OPENENV_PREVIEW_ROWS': os.getenv('OPENENV_PREVIEW_ROWS', 'NOT_SET'),
+        'OPENENV_DEFAULT_TASK_LEVEL': os.getenv('OPENENV_DEFAULT_TASK_LEVEL', 'NOT_SET'),
+        'OPENENV_GRADING_METHOD': os.getenv('OPENENV_GRADING_METHOD', 'NOT_SET'),
+        'OPENENV_RESOLUTION_BONUS': os.getenv('OPENENV_RESOLUTION_BONUS', 'NOT_SET'),
+        'OPENENV_ERROR_PENALTY': os.getenv('OPENENV_ERROR_PENALTY', 'NOT_SET'),
+    }
+    return env_vars
+
+
+def print_openenv_status():
+    """Print OpenEnv configuration status"""
+    config = get_openenv_config()
+    env_vars = check_openenv_env_vars()
+    
+    print("=== OpenEnv Configuration Status ===")
+    print(f"Configuration valid: {config.validate()}")
+    print(f"Name: {config.name}")
+    print(f"Version: {config.version}")
+    print(f"Port: {config.port}")
+    print(f"Environment Type: {config.env_type}")
+    print(f"Max Steps: {config.max_steps}")
+    print(f"Preview Rows: {config.preview_rows}")
+    print()
+    print("Environment Variables:")
+    for key, value in env_vars.items():
+        status = "✓" if value != "NOT_SET" else "✗"
+        print(f"  {status} {key}: {value}")
+    print()
+    print("OpenEnv YAML Configuration:")
+    print(config.get_openenv_yaml())