dslighting 1.1.8__tar.gz → 1.3.6__tar.gz

{dslighting-1.1.8 → dslighting-1.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dslighting
-Version: 1.1.8
+Version: 1.3.6
 Summary: Simplified API for Data Science Agent Automation
 Author: DSLighting Team
 License: AGPL-3.0

{dslighting-1.1.8 → dslighting-1.3.6}/dsat/services/llm.py

@@ -43,7 +43,8 @@ def _load_custom_model_pricing():
                 config = yaml.safe_load(f)
                 return config.get('custom_model_pricing', {})
         else:
-            logger.warning(f"Config file not found at {config_yaml_path}")
+            # Changed to debug to avoid confusing warnings for pip-installed packages
+            logger.debug(f"Config file not found at {config_yaml_path} (this is expected for pip-installed packages)")
             return {}
     except Exception as e:
         logger.error(f"Failed to load cost configuration: {e}")

{dslighting-1.1.8 → dslighting-1.3.6}/dsat/services/llm_single.py

@@ -43,7 +43,8 @@ def _load_custom_model_pricing():
                 config = yaml.safe_load(f)
                 return config.get('custom_model_pricing', {})
         else:
-            logger.warning(f"Config file not found at {config_yaml_path}")
+            # Changed to debug to avoid confusing warnings for pip-installed packages
+            logger.debug(f"Config file not found at {config_yaml_path} (this is expected for pip-installed packages)")
             return {}
     except Exception as e:
         logger.error(f"Failed to load cost configuration: {e}")

{dslighting-1.1.8 → dslighting-1.3.6}/dsat/services/sandbox.py

@@ -245,17 +245,46 @@ class ProcessIsolatedNotebookExecutor:
 class SandboxService:
     """
     Provides unified access to isolated script and notebook code execution environments.
+
+    Args:
+        workspace: Workspace service for managing files
+        timeout: Default timeout for script execution (seconds)
+        auto_matplotlib: Automatically inject matplotlib backend (default: False).
+                        Set to True for Web UI environments that need visualization.
+                        Set to False for standalone package usage.
     """
-    def __init__(self, workspace: WorkspaceService, timeout: int = 600):
+    def __init__(
+        self,
+        workspace: WorkspaceService,
+        timeout: int = 600,
+        auto_matplotlib: bool = False
+    ):
         self.workspace = workspace
         self.timeout = timeout
+        self.auto_matplotlib = auto_matplotlib  # Store matplotlib injection preference
         self.execution_history: List[Dict[str, Any]] = []
 
     def run_script(self, script_code: str, timeout: Optional[int] = None) -> ExecutionResult:
-        """Runs a Python script within the sandbox workspace."""
-        # Force non-interactive backend for matplotlib to prevent blocking plt.show()
-        fixed_code = "import matplotlib\nmatplotlib.use('Agg')\n" + script_code
-        
+        """
+        Runs a Python script within the sandbox workspace.
+
+        Args:
+            script_code: Python code to execute
+            timeout: Optional timeout override (uses self.timeout if None)
+
+        Returns:
+            ExecutionResult with stdout, stderr, success status, etc.
+        """
+        # Optionally inject matplotlib non-interactive backend
+        # This is only done if auto_matplotlib=True (used by Web UI for visualization)
+        if self.auto_matplotlib:
+            # Force non-interactive backend for matplotlib to prevent blocking plt.show()
+            fixed_code = "import matplotlib\nmatplotlib.use('Agg')\n" + script_code
+            logger.debug("Auto-injected matplotlib non-interactive backend")
+        else:
+            # Use code as-is without modification (default for DSLighting package)
+            fixed_code = script_code
+
         script_name = f"_sandbox_script_{uuid.uuid4().hex}.py"
         script_path = self.workspace.run_dir / script_name
         execution_id = uuid.uuid4().hex

{dslighting-1.1.8 → dslighting-1.3.6}/dslighting/__init__.py

@@ -26,7 +26,7 @@ Advanced Usage:
 For more information, see: https://github.com/usail-hkust/dslighting
 """
 
-__version__ = "1.1.8"
+__version__ = "1.3.6"
 __author__ = "DSLighting Team"
 
 # Core API classes
@@ -60,29 +60,40 @@ def load_data(source, **kwargs):
     return loader.load(source, **kwargs)
 
 
-def run_agent(data, **kwargs):
+def run_agent(data=None, task_id=None, data_dir=None, keep_workspace=False, keep_workspace_on_failure=True, **kwargs):
     """
     Quick one-liner: load data and run with defaults.
 
     This function creates an Agent with the specified parameters and runs it on the data.
 
     Args:
-        data: Data source (path, DataFrame, dict, etc.)
+        data: Optional data source (path, DataFrame, dict, etc.)
+        task_id: Task/Competition identifier (e.g., "bike-sharing-demand")
+        data_dir: Base data directory (default: "data/competitions")
+        keep_workspace: Keep workspace after completion (default: False)
+        keep_workspace_on_failure: Keep workspace on failure (default: True)
         **kwargs: Parameters passed to Agent.__init__ and Agent.run
 
     Returns:
         AgentResult with output, metrics, and metadata
 
     Examples:
-        >>> # Simplest usage - all defaults
-        >>> result = dslighting.run_agent("data/titanic")
+        >>> # Recommended: using task_id
+        >>> result = dslighting.run_agent(
+        ...     task_id="bike-sharing-demand",
+        ...     data_dir="data/competitions"
+        ... )
         >>> print(f"Score: {result.score}, Cost: ${result.cost}")
 
+        >>> # Legacy: using data path
+        >>> result = dslighting.run_agent("data/titanic")
+
         >>> # With custom parameters
         >>> result = dslighting.run_agent(
-        ...     "data/titanic",
+        ...     task_id="bike-sharing-demand",
         ...     workflow="autokaggle",
-        ...     model="gpt-4o"
+        ...     model="gpt-4o",
+        ...     keep_workspace=True  # Keep workspace for debugging
         ... )
     """
     # Extract run-specific parameters if present
@@ -90,7 +101,7 @@ def run_agent(data, **kwargs):
     agent_params = {}
 
     # Parameters that should go to run(), not __init__
-    run_only_params = {'task_id', 'output_path', 'description'}
+    run_only_params = {'task_id', 'data_dir', 'output_path', 'description'}
 
     for key, value in kwargs.items():
         if key in run_only_params:
@@ -98,6 +109,16 @@ def run_agent(data, **kwargs):
         else:
             agent_params[key] = value
 
+    # Add explicit parameters to run_kwargs
+    if task_id is not None:
+        run_kwargs['task_id'] = task_id
+    if data_dir is not None:
+        run_kwargs['data_dir'] = data_dir
+
+    # Add workspace preservation parameters to agent
+    agent_params['keep_workspace'] = keep_workspace
+    agent_params['keep_workspace_on_failure'] = keep_workspace_on_failure
+
     # Create agent and run
     agent = Agent(**agent_params)
     return agent.run(data, **run_kwargs)

{dslighting-1.1.8 → dslighting-1.3.6}/dslighting/core/agent.py

@@ -108,6 +108,8 @@ class Agent:
         num_drafts: int = None,
         workspace_dir: str = None,
         run_name: str = None,
+        keep_workspace: bool = False,
+        keep_workspace_on_failure: bool = True,
         verbose: bool = True,
         **kwargs
     ):
@@ -129,6 +131,8 @@ class Agent:
             num_drafts: Number of drafts to generate
             workspace_dir: Custom workspace directory
             run_name: Name for this run
+            keep_workspace: Keep workspace after completion (default: False)
+            keep_workspace_on_failure: Keep workspace on failure (default: True)
             verbose: Enable verbose logging
             **kwargs: Additional parameters passed to DSATConfig
         """
@@ -148,6 +152,8 @@ class Agent:
             num_drafts=num_drafts,
             workspace_dir=workspace_dir,
             run_name=run_name,
+            keep_workspace=keep_workspace,
+            keep_workspace_on_failure=keep_workspace_on_failure,
             **kwargs
         )
 
@@ -161,8 +167,9 @@ class Agent:
 
     def run(
         self,
-        data: Union[str, Path, dict, pd.DataFrame, LoadedData],
+        data: Union[str, Path, dict, pd.DataFrame, LoadedData] = None,
         task_id: str = None,
+        data_dir: str = None,
         output_path: str = None,
         description: str = None,
         **kwargs
@@ -175,8 +182,12 @@ class Agent:
         result collection.
 
         Args:
-            data: Data source (path, DataFrame, dict, or LoadedData)
-            task_id: Optional task identifier
+            data: Optional data source (path, DataFrame, dict, or LoadedData).
+                  If not provided, use task_id + data_dir pattern.
+            task_id: Task/Competition identifier (e.g., "bike-sharing-demand").
+                     Required when using MLE benchmark format.
+            data_dir: Base data directory containing competition data.
+                     Default: "data/competitions"
             output_path: Custom output path for results
             description: Optional task description (overrides detected)
             **kwargs: Additional task parameters
@@ -185,22 +196,77 @@ class Agent:
             AgentResult with output, metrics, and metadata
 
         Examples:
-            >>> result = agent.run("data/titanic")
-            >>> print(f"Score: {result.score}, Cost: ${result.cost}")
+            >>> # Method 1: Recommended - using task_id + data_dir
+            >>> result = agent.run(
+            ...     task_id="bike-sharing-demand",
+            ...     data_dir="data/competitions"
+            ... )
+
+            >>> # Method 2: Using data path directly
+            >>> result = agent.run("path/to/competition")
 
+            >>> # Method 3: Using DataFrame
             >>> result = agent.run(df, description="Predict price")
-            >>> predictions = result.output
         """
         # Start timing
         start_time = time.time()
 
         try:
-            # Load data if not already loaded
-            if not isinstance(data, LoadedData):
+            # ========== New simplified API: task_id + data_dir ==========
+            if task_id:
+                # Set default data_dir if not provided
+                if data_dir is None:
+                    data_dir = "data/competitions"
+
+                self.logger.info(f"Using MLE benchmark format")
+                self.logger.info(f"  task_id: {task_id}")
+                self.logger.info(f"  data_dir: {data_dir}")
+
+                # Resolve paths
+                data_dir_path = Path(data_dir).resolve()
+                competition_dir = data_dir_path / task_id
+
+                # Check if task exists in benchmarks registry
+                benchmark_dir = self._get_default_benchmark_dir()
+                task_registry = benchmark_dir / task_id
+
+                if not task_registry.exists():
+                    self.logger.warning(
+                        f"Task '{task_id}' not found in benchmark registry: {benchmark_dir}"
+                    )
+                    self.logger.warning(
+                        f"This means the task cannot be auto-graded. "
+                        f"To enable grading, register the task at: {task_registry}"
+                    )
+                else:
+                    self.logger.info(f"  ✓ Task registered: {task_registry}")
+
+                # Check if data exists
+                if not competition_dir.exists():
+                    raise FileNotFoundError(
+                        f"Data directory not found: {competition_dir}\n"
+                        f"Please ensure data is prepared at: {competition_dir}/prepared/"
+                    )
+
+                self.logger.info(f"  Data directory: {competition_dir}")
+
+                # Load data
                 loader = DataLoader()
-                loaded_data = loader.load(data)
+                loaded_data = loader.load(competition_dir)
+
+            # ========== Legacy API: direct data path ==========
+            elif data is not None:
+                # Load data if not already loaded
+                if not isinstance(data, LoadedData):
+                    loader = DataLoader()
+                    loaded_data = loader.load(data)
+                else:
+                    loaded_data = data
             else:
-                loaded_data = data
+                raise ValueError(
+                    "Either 'task_id' or 'data' must be provided. "
+                    "Example: agent.run(task_id='bike-sharing-demand', data_dir='data/competitions')"
+                )
 
             # Get task information
             task_detection = loaded_data.task_detection
@@ -365,30 +431,33 @@ class Agent:
 
             if task_type == "kaggle":
                 # MLE/Kaggle format: needs public_data_dir and output_submission_path
+                # Follow MLEBenchmark pattern: {data_dir}/prepared/public
                 prepared_dir = data_dir / "prepared"
-                if prepared_dir.exists():
-                    public_dir = prepared_dir / "public"
-                    if public_dir.exists():
-                        payload["public_data_dir"] = str(public_dir)
-                    else:
-                        # Fallback: use data_dir as public_data_dir
-                        payload["public_data_dir"] = str(data_dir)
+                public_dir = prepared_dir / "public"
+
+                # Check if prepared/public exists (MLE format)
+                if public_dir.exists():
+                    payload["public_data_dir"] = str(public_dir.resolve())
+                    self.logger.info(f"Using MLE prepared data: {public_dir.resolve()}")
                 else:
-                    # No prepared dir, use data_dir directly
-                    payload["public_data_dir"] = str(data_dir)
+                    # Fallback: use data_dir directly
+                    payload["public_data_dir"] = str(data_dir.resolve())
+                    self.logger.warning(
+                        f"Prepared data not found at {public_dir}, using data_dir instead"
+                    )
 
-                # Set output path to workspace with unique ID (like MLEBenchmark does)
+                # Set output path - use simple filename, will be saved in workspace/sandbox
                 if output_path is None:
                     # Extract competition_id from data_dir path if possible
                     competition_id = data_dir.name
                     unique_id = str(uuid.uuid4())[:8]
                     output_filename = f"submission_{competition_id}_{unique_id}.csv"
 
-                    # Save to workspace directory (not sandbox, workspace is preserved)
-                    workspace_dir = self._get_workspace_dir()
-                    output_path = workspace_dir / output_filename
+                    # Use just the filename - DSAT will save it in workspace/sandbox
+                    output_path = Path(output_filename)
 
                 payload["output_submission_path"] = str(output_path)
+                self.logger.info(f"Output submission file: {output_path}")
             else:
                 # Other task types: use data_dir
                 payload["data_dir"] = str(data_dir)
@@ -427,6 +496,36 @@ class Agent:
 
         return workspace_path
 
+    def _get_default_benchmark_dir(self) -> Path:
+        """
+        Get the default benchmark registry directory.
+
+        This is where task registration files (grade.py, description.md, etc.) are stored.
+        Default: benchmarks/mlebench/competitions/
+
+        Returns:
+            Path to benchmark registry directory
+        """
+        # Try to get from config
+        benchmark_dir = None
+
+        if hasattr(self, 'config') and hasattr(self.config, 'run'):
+            run_config = self.config.run
+            if hasattr(run_config, 'parameters') and run_config.parameters:
+                benchmark_dir = run_config.parameters.get('benchmark_dir')
+
+        # Fallback to default benchmark directory
+        if benchmark_dir is None:
+            # Use relative path from current working directory
+            # Default: benchmarks/mlebench/competitions/
+            benchmark_dir = "benchmarks/mlebench/competitions"
+
+        benchmark_path = Path(benchmark_dir).resolve()
+
+        self.logger.debug(f"Benchmark registry directory: {benchmark_path}")
+
+        return benchmark_path
+
     async def _execute_task(
         self,
         task: TaskDefinition,

{dslighting-1.1.8 → dslighting-1.3.6}/dslighting/core/config_builder.py

@@ -60,6 +60,8 @@ class ConfigBuilder:
         num_drafts: int = None,
         workspace_dir: str = None,
         run_name: str = None,
+        keep_workspace: bool = None,
+        keep_workspace_on_failure: bool = None,
         **kwargs
     ) -> DSATConfig:
         """
@@ -76,6 +78,8 @@ class ConfigBuilder:
             num_drafts: Number of drafts to generate
             workspace_dir: Workspace directory
             run_name: Name for this run
+            keep_workspace: Keep workspace after completion
+            keep_workspace_on_failure: Keep workspace on failure
             **kwargs: Additional parameters
 
         Returns:
@@ -100,6 +104,8 @@ class ConfigBuilder:
             num_drafts=num_drafts,
             workspace_dir=workspace_dir,
             run_name=run_name,
+            keep_workspace=keep_workspace,
+            keep_workspace_on_failure=keep_workspace_on_failure,
             **kwargs
         )
         config = self._deep_merge(config, user_config)
@@ -180,7 +186,22 @@ class ConfigBuilder:
             logger.warning("LLM_MODEL_CONFIGS must be a JSON object")
             return {}
 
-        return {k: v for k, v in parsed.items() if isinstance(k, str) and isinstance(v, dict)}
+        # Process each model config
+        result = {}
+        for k, v in parsed.items():
+            if not isinstance(k, str) or not isinstance(v, dict):
+                continue
+
+            # Handle api_key as list (take the first one)
+            if "api_key" in v and isinstance(v["api_key"], list):
+                if len(v["api_key"]) > 0:
+                    v = v.copy()  # Shallow copy to avoid mutating original
+                    v["api_key"] = v["api_key"][0]
+                    logger.debug(f"Model '{k}': using first API key from list of {len(v['api_key'])}")
+
+            result[k] = v
+
+        return result
 
     def _build_user_config(
         self,
@@ -194,6 +215,8 @@ class ConfigBuilder:
         num_drafts: int = None,
         workspace_dir: str = None,
         run_name: str = None,
+        keep_workspace: bool = None,
+        keep_workspace_on_failure: bool = None,
         **kwargs
     ) -> Dict[str, Any]:
         """Build user configuration from parameters."""
@@ -230,6 +253,12 @@ class ConfigBuilder:
         if workspace_dir is not None:
             config.setdefault("run", {}).setdefault("parameters", {})["workspace_dir"] = workspace_dir
 
+        if keep_workspace is not None:
+            config.setdefault("run", {})["keep_all_workspaces"] = keep_workspace
+
+        if keep_workspace_on_failure is not None:
+            config.setdefault("run", {})["keep_workspace_on_failure"] = keep_workspace_on_failure
+
         # Additional kwargs are added to run.parameters
         if kwargs:
             config.setdefault("run", {}).setdefault("parameters", {}).update(kwargs)

{dslighting-1.1.8 → dslighting-1.3.6}/dslighting/core/data_loader.py

@@ -269,10 +269,13 @@ class DataLoader:
         description = "MLE competition task"
 
         if isinstance(source, (str, Path)):
-            path = Path(source)
+            path = Path(source).resolve()  # Convert to absolute path
+            self.logger.info(f"Resolved path: {path}")
+
             if path.exists():
                 if path.is_dir():
                     data_dir = path
+                    self.logger.info(f"Data directory found: {data_dir}")
                     # Try to load description
                     desc_file = path / "description.md"
                     if desc_file.exists():
@@ -283,6 +286,7 @@ class DataLoader:
                             pass
                 elif path.is_file():
                     data_dir = path.parent
+                    self.logger.info(f"Data directory (from file parent): {data_dir}")
                     # Try to load description from parent directory
                     desc_file = path.parent / "description.md"
                     if desc_file.exists():
@@ -291,6 +295,47 @@ class DataLoader:
                             self.logger.info(f"Loaded description from {desc_file}")
                         except Exception:
                             pass
+            else:
+                self.logger.warning(f"Path does not exist: {path}")
+
+                # Try to find the data in common locations
+                competition_id = path.name
+
+                # Common search locations for data
+                search_locations = [
+                    # Current project: ./data/competitions/
+                    Path.cwd() / "data" / "competitions" / competition_id,
+                    # Parent dslighting: ../dslighting/data/competitions/
+                    Path.cwd().parent / "dslighting" / "data" / "competitions" / competition_id,
+                    # Parent data: ../data/competitions/
+                    Path.cwd().parent / "data" / "competitions" / competition_id,
+                    # From package location: ../../data/competitions/
+                    Path(__file__).parent.parent.parent / "data" / "competitions" / competition_id,
+                    # Absolute path fallback
+                    Path("/Users/liufan/Applications/Github/dslighting/data/competitions") / competition_id,
+                ]
+
+                for location in search_locations:
+                    self.logger.info(f"  Trying: {location}")
+                    if location.exists() and location.is_dir():
+                        data_dir = location
+                        self.logger.info(f"  ✓ Found data at: {data_dir}")
+                        break
+
+                if data_dir is None:
+                    # Last resort: use the original resolved path
+                    self.logger.warning(f"  Could not find data, using original path: {path}")
+                    data_dir = path
+
+            # Try to load description (if data_dir was found)
+            if data_dir and data_dir.exists():
+                desc_file = data_dir / "description.md"
+                if desc_file.exists():
+                    try:
+                        description = desc_file.read_text(encoding='utf-8')
+                        self.logger.info(f"Loaded description from {desc_file}")
+                    except Exception:
+                        pass
 
         # Create MLE-style detection
         from dslighting.utils.defaults import WORKFLOW_RECOMMENDATIONS

{dslighting-1.1.8 → dslighting-1.3.6}/dslighting/utils/defaults.py

@@ -105,7 +105,7 @@ DEFAULT_CONFIG: Dict[str, Any] = {
         "params": {}
     },
     "run": {
-        "name": "dslighting",  # Fixed name without UID to avoid UUID suffix
+        "name": "dsat_run",  # Use "dsat_run" to let DSATRunner auto-generate: dsat_run_{task_id}_{uid}
         "total_steps": DEFAULT_MAX_ITERATIONS,
         "keep_all_workspaces": DEFAULT_KEEP_ALL_WORKSPACES,
         "keep_workspace_on_failure": DEFAULT_KEEP_WORKSPACE_ON_FAILURE,

{dslighting-1.1.8 → dslighting-1.3.6}/dslighting.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dslighting
-Version: 1.1.8
+Version: 1.3.6
 Summary: Simplified API for Data Science Agent Automation
 Author: DSLighting Team
 License: AGPL-3.0

{dslighting-1.1.8 → dslighting-1.3.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dslighting"
-version = "1.1.8"
+version = "1.3.6"
 description = "Simplified API for Data Science Agent Automation"
 readme = "README.md"
 requires-python = ">=3.10"