dslighting 1.3.9__py3-none-any.whl → 1.7.1__py3-none-any.whl

dsat/runner.py

@@ -188,24 +188,32 @@ class DSATRunner:
                         sandbox_workdir = workspace_service.get_path("sandbox_workdir")
                         generated_file = sandbox_workdir / output_path.name
                         if generated_file.exists():
-                            output_path.parent.mkdir(parents=True, exist_ok=True)
-                            if generated_file.resolve() != output_path.resolve():
-                                logger.info(f"Collecting produced artifact '{output_path.name}' from the sandbox.")
-
-                                # Handle both files and directories (e.g., for open-ended tasks)
-                                if generated_file.is_dir():
-                                    # For directories (like 'artifacts'), use copytree
-                                    if output_path.exists():
-                                        if output_path.is_dir():
-                                            shutil.rmtree(output_path)
-                                        else:
-                                            output_path.unlink()
-                                    shutil.copytree(generated_file, output_path)
-                                    logger.info(f"Copied directory '{generated_file}' to '{output_path}'")
-                                else:
-                                    # For files, use regular copy
-                                    shutil.copy(generated_file, output_path)
-                                    logger.info(f"Copied file '{generated_file}' to '{output_path}'")
+                            # Only copy if output_path is an absolute path
+                            # If it's a relative path (just filename), keep it in workspace/sandbox
+                            if output_path.is_absolute():
+                                output_path.parent.mkdir(parents=True, exist_ok=True)
+                                if generated_file.resolve() != output_path.resolve():
+                                    logger.info(f"Collecting produced artifact '{output_path.name}' from the sandbox.")
+
+                                    # Handle both files and directories (e.g., for open-ended tasks)
+                                    if generated_file.is_dir():
+                                        # For directories (like 'artifacts'), use copytree
+                                        if output_path.exists():
+                                            if output_path.is_dir():
+                                                shutil.rmtree(output_path)
+                                            else:
+                                                output_path.unlink()
+                                        shutil.copytree(generated_file, output_path)
+                                        logger.info(f"Copied directory '{generated_file}' to '{output_path}'")
+                                    else:
+                                        # For files, use regular copy
+                                        shutil.copy(generated_file, output_path)
+                                        logger.info(f"Copied file '{generated_file}' to '{output_path}'")
+                            else:
+                                # Relative path - file stays in sandbox, use workspace path for result
+                                logger.info(f"Output file '{output_path.name}' remains in workspace sandbox: {generated_file}")
+                                # Update output_path to point to the actual file in workspace
+                                output_path = generated_file
                         else:
                             logger.warning(f"No output '{output_path.name}' found in sandbox '{sandbox_workdir}' after workflow execution.")
 

dslighting/__init__.py

@@ -26,13 +26,16 @@ Advanced Usage:
 For more information, see: https://github.com/usail-hkust/dslighting
 """
 
-__version__ = "1.3.9"
+__version__ = "1.7.1"
 __author__ = "DSLighting Team"
 
 # Core API classes
 from dslighting.core.agent import Agent, AgentResult
 from dslighting.core.data_loader import DataLoader, LoadedData
 
+# Example datasets
+from dslighting import datasets
+
 # Convenience functions
 def load_data(source, **kwargs):
     """
@@ -147,6 +150,9 @@ __all__ = [
     # Convenience functions
     "load_data",
     "run_agent",
+
+    # Example datasets
+    "datasets",
 ]
 
 

dslighting/core/agent.py

@@ -111,6 +111,7 @@ class Agent:
         keep_workspace: bool = False,
         keep_workspace_on_failure: bool = True,
         verbose: bool = True,
+        include_package_context: bool = True,
         **kwargs
     ):
         """
@@ -134,10 +135,12 @@ class Agent:
             keep_workspace: Keep workspace after completion (default: False)
             keep_workspace_on_failure: Keep workspace on failure (default: True)
             verbose: Enable verbose logging
+            include_package_context: Include available package info in prompts (default: True)
             **kwargs: Additional parameters passed to DSATConfig
         """
         self.verbose = verbose
         self.logger = logger
+        self.include_package_context = include_package_context
 
         # Build configuration
         self.config_builder = ConfigBuilder()
@@ -163,6 +166,19 @@ class Agent:
         # Track results
         self._results: List[AgentResult] = []
 
+        # Initialize package detector for environment context
+        self._package_detector = None
+        self._package_context: Optional[str] = None
+
+        if self.include_package_context:
+            try:
+                from dslighting.utils.package_detector import PackageDetector
+                self._package_detector = PackageDetector()
+                self.logger.info("Package context enabled: Agent will be aware of available packages")
+            except Exception as e:
+                self.logger.warning(f"Failed to initialize package detector: {e}")
+                self.include_package_context = False
+
         self.logger.info(f"Agent initialized with workflow: '{self.config.workflow.name}'")
 
     def run(
@@ -172,6 +188,7 @@ class Agent:
         data_dir: str = None,
         output_path: str = None,
         description: str = None,
+        registry_dir: str = None,
         **kwargs
     ) -> AgentResult:
         """
@@ -190,6 +207,8 @@ class Agent:
                      Default: "data/competitions"
             output_path: Custom output path for results
             description: Optional task description (overrides detected)
+            registry_dir: Path to competition registry directory for grading.
+                          Example: "/path/to/mlebench/competitions"
             **kwargs: Additional task parameters
 
         Returns:
@@ -202,8 +221,11 @@ class Agent:
             ...     data_dir="data/competitions"
             ... )
 
-            >>> # Method 2: Using data path directly
-            >>> result = agent.run("path/to/competition")
+            >>> # Method 2: With custom registry for grading
+            >>> result = agent.run(
+            ...     data="data/competitions/bike-sharing-demand",
+            ...     registry_dir="/path/to/mlebench/competitions"
+            ... )
 
             >>> # Method 3: Using DataFrame
             >>> result = agent.run(df, description="Predict price")
@@ -296,28 +318,97 @@ class Agent:
             # Initialize benchmark for MLE tasks (for grading)
             if task_id and loaded_data.get_task_type() == "kaggle":
                 try:
-                    # Import here to avoid hard dependency
-                    from dsat.benchmark.mle import MLEBenchmark
-
-                    # Resolve data_dir
-                    if data_dir is None:
-                        data_dir = "data/competitions"
-                    data_dir_path = Path(data_dir).expanduser().resolve()
-
-                    # Create benchmark instance
-                    benchmark = MLEBenchmark(
-                        data_dir=str(data_dir_path),
-                        task_ids=[task_id]
-                    )
-
-                    # Set benchmark on runner
-                    runner = self.get_runner()
-                    runner.benchmark = benchmark
-
-                    self.logger.info(f"✓ Benchmark initialized for grading: {task_id}")
-                except ImportError:
-                    self.logger.warning("MLE-Bench not installed. Grading will be skipped.")
-                    self.logger.warning("Install with: pip install mlebench")
+                    from mlebench.grade import grade_csv
+                    from mlebench.registry import Registry
+
+                    # Resolve data_dir - prioritize loaded_data.data_dir
+                    if loaded_data.data_dir is not None:
+                        # Extract parent directory from loaded_data.data_dir
+                        # e.g., /path/to/competitions/bike-sharing-demand → /path/to/competitions
+                        data_dir_path = loaded_data.data_dir.parent
+                    elif data_dir is None:
+                        data_dir_path = Path("data/competitions").expanduser().resolve()
+                    else:
+                        data_dir_path = Path(data_dir).expanduser().resolve()
+
+                    self.logger.info(f"Initializing MLE-Bench grading for: {task_id}")
+                    self.logger.info(f"  Data directory: {data_dir_path}")
+
+                    # Check if user provided registry_dir in loaded_data
+                    if loaded_data.registry_dir:
+                        self.logger.info(f"  Registry directory (from loaded_data): {loaded_data.registry_dir}")
+                    else:
+                        self.logger.info(f"  Registry directory: auto-detected from data directory structure")
+
+                    # Validate data directory exists
+                    if not data_dir_path.exists():
+                        self.logger.warning(f"⚠️  Data directory does NOT exist: {data_dir_path}")
+                        self.logger.warning(f"   Please ensure competition data is downloaded and prepared.")
+                        self.logger.warning(f"   Grading will be skipped.")
+                    else:
+                        # Check if competition directory exists
+                        competition_dir = data_dir_path / task_id
+                        if not competition_dir.exists():
+                            self.logger.warning(f"⚠️  Competition directory NOT found: {competition_dir}")
+                            self.logger.warning(f"   Task '{task_id}' data not found in {data_dir_path}")
+                            self.logger.warning(f"   Available competitions: {list([d.name for d in data_dir_path.iterdir() if d.is_dir()])}")
+                            self.logger.warning(f"   Grading will be skipped.")
+                        else:
+                            # Check if prepared data exists
+                            prepared_dir = competition_dir / "prepared"
+                            private_dir = prepared_dir / "private"
+                            public_dir = prepared_dir / "public"
+
+                            if not prepared_dir.exists():
+                                self.logger.warning(f"⚠️  Prepared data NOT found: {prepared_dir}")
+                                self.logger.warning(f"   Competition data exists but is not prepared.")
+                                self.logger.warning(f"   Expected: {prepared_dir}")
+                                self.logger.warning(f"   Grading will be skipped.")
+                            elif not private_dir.exists():
+                                self.logger.warning(f"⚠️  Private directory NOT found: {private_dir}")
+                                self.logger.warning(f"   Required for grading but does not exist.")
+                                self.logger.warning(f"   This is unusual if competition data was prepared correctly.")
+                                self.logger.warning(f"   Grading will be skipped.")
+                            else:
+                                # All checks passed - initialize benchmark
+                                # IMPORTANT: Registry needs data_dir pointing to prepared data base
+                                # If user provided registry_dir, use it for config.yaml lookup
+                                registry_kwargs = {"data_dir": data_dir_path}
+                                if loaded_data.registry_dir:
+                                    registry_kwargs["registry_dir"] = loaded_data.registry_dir
+
+                                custom_registry = Registry(**registry_kwargs)
+
+                                # Log registry configuration
+                                self.logger.info(f"  Registry config:")
+                                self.logger.info(f"    data_dir: {data_dir_path}")
+                                if loaded_data.registry_dir:
+                                    self.logger.info(f"    config_dir (auto): {loaded_data.registry_dir}")
+                                self.logger.info(f"    expected private_dir: {private_dir}")
+
+                                # Create simple wrapper class
+                                class SimpleMLEBenchmark:
+                                    def __init__(self, registry_instance):
+                                        self.registry = registry_instance
+
+                                    async def grade(self, submission_path):
+                                        """Grade submission using custom registry."""
+                                        competition = self.registry.get_competition(task_id)
+                                        report = grade_csv(
+                                            submission_path,
+                                            competition,
+                                        )
+                                        # Return the score (float), not the entire report
+                                        return report.score if report.score is not None else 0.0
+
+                                benchmark = SimpleMLEBenchmark(custom_registry)
+                                runner = self.get_runner()
+                                runner.benchmark = benchmark
+                                self.logger.info(f"✓ Benchmark initialized for grading: {task_id}")
+
+                except ImportError as e:
+                    self.logger.warning(f"MLE-Bench import failed: {e}")
+                    self.logger.warning("Grading will be skipped.")
                 except Exception as e:
                     self.logger.warning(f"Benchmark initialization failed: {e}")
                     self.logger.warning("Grading will be skipped")
@@ -455,6 +546,16 @@ class Agent:
         if description is None:
             description = loaded_data.get_description()
 
+        # Add package context to description if enabled
+        if self.include_package_context and self._package_detector:
+            try:
+                package_context = self._package_detector.format_as_context()
+                # Prepend package context to description
+                description = f"{package_context}\n\nTask Description:\n{description}"
+                self.logger.info("Package context added to task description")
+            except Exception as e:
+                self.logger.warning(f"Failed to add package context: {e}")
+
         # Get I/O instructions
         io_instructions = loaded_data.get_io_instructions()
 
@@ -539,7 +640,10 @@ class Agent:
         Get the default benchmark registry directory.
 
         This is where task registration files (grade.py, description.md, etc.) are stored.
-        Default: benchmarks/mlebench/competitions/
+        Priority:
+        1. Built-in registry in dslighting package (dslighting/registry/)
+        2. Local benchmarks/mlebench/competitions/
+        3. Config-provided benchmark_dir
 
         Returns:
             Path to benchmark registry directory
@@ -552,9 +656,21 @@ class Agent:
             if hasattr(run_config, 'parameters') and run_config.parameters:
                 benchmark_dir = run_config.parameters.get('benchmark_dir')
 
-        # Fallback to default benchmark directory
+        # Fallback 1: Try built-in registry in dslighting package
+        if benchmark_dir is None:
+            try:
+                import dslighting
+                dslighting_path = Path(dslighting.__file__).parent
+                built_in_registry = dslighting_path / "registry"
+
+                if built_in_registry.exists():
+                    self.logger.info(f"Using built-in registry: {built_in_registry}")
+                    return built_in_registry.resolve()
+            except Exception as e:
+                self.logger.debug(f"Could not access built-in registry: {e}")
+
+        # Fallback 2: Use relative path from current working directory
         if benchmark_dir is None:
-            # Use relative path from current working directory
             # Default: benchmarks/mlebench/competitions/
             benchmark_dir = "benchmarks/mlebench/competitions"
 

dslighting/core/config_builder.py

@@ -251,7 +251,7 @@ class ConfigBuilder:
             config.setdefault("run", {})["name"] = run_name
 
         if workspace_dir is not None:
-            config.setdefault("run", {}).setdefault("parameters", {})["workspace_dir"] = workspace_dir
+            config.setdefault("workflow", {}).setdefault("params", {})["workspace_base_dir"] = workspace_dir
 
         if keep_workspace is not None:
             config.setdefault("run", {})["keep_all_workspaces"] = keep_workspace

dslighting/core/data_loader.py

@@ -22,23 +22,166 @@ class LoadedData:
     """
     Container for loaded data with metadata.
 
+    This class provides a structured view of the data that matches what
+    the DSLighting Agent sees - file structure, schema, and metadata.
+
     Attributes:
         source: Original data source (path, DataFrame, etc.)
         data_dir: Data directory path (for file-based sources)
         task_detection: Detected task information
         task_id: Task/Competition ID (extracted from path)
+        registry_dir: Benchmark registry directory (for MLE-Bench grading)
         metadata: Additional metadata
     """
     source: Any
     data_dir: Optional[Path] = None
     task_detection: Optional[TaskDetection] = None
     task_id: Optional[str] = None
+    registry_dir: Optional[Path] = None
     metadata: Dict[str, Any] = None
 
     def __post_init__(self):
         if self.metadata is None:
             self.metadata = {}
 
+    def __repr__(self) -> str:
+        """Return a concise representation of loaded data."""
+        if self.task_id:
+            return f"LoadedData(task_id='{self.task_id}', task_type='{self.get_task_type()}')"
+        elif self.data_dir:
+            return f"LoadedData(data_dir='{self.data_dir.name}', task_type='{self.get_task_type()}')"
+        else:
+            return f"LoadedData(task_type='{self.get_task_type()}')"
+
+    def show(self) -> str:
+        """
+        Display detailed data structure and schema information.
+
+        This shows what the Agent sees - file structure, data schema,
+        and task information. Use this to understand your data before
+        running the Agent.
+
+        Returns:
+            Formatted string with data structure and schema
+
+        Example:
+            >>> data = dslighting.load_data("data/competitions/bike-sharing-demand")
+            >>> print(data.show())
+        """
+        lines = []
+        lines.append("=" * 80)
+        lines.append("DSLighting Data Overview")
+        lines.append("=" * 80)
+        lines.append("")
+
+        # Task Information
+        lines.append("## Task Information")
+        lines.append(f"  Task ID:          {self.task_id or 'N/A'}")
+        lines.append(f"  Task Type:        {self.get_task_type()}")
+        lines.append(f"  Task Mode:        {self.task_detection.task_mode if self.task_detection else 'N/A'}")
+        lines.append(f"  Recommended:      {self.get_recommended_workflow()} workflow")
+        lines.append("")
+
+        # Data Directory
+        if self.data_dir:
+            lines.append("## Data Directory")
+            lines.append(f"  Path: {self.data_dir}")
+
+            # Show MLE structure
+            prepared_dir = self.data_dir / "prepared"
+            if prepared_dir.exists():
+                lines.append(f"  Structure: MLE-Bench format")
+                public_dir = prepared_dir / "public"
+                private_dir = prepared_dir / "private"
+
+                if public_dir.exists():
+                    lines.append(f"  Public dir:  {public_dir}")
+                    lines.append(self._analyze_directory(public_dir, "Public Data"))
+                else:
+                    lines.append(f"  Public dir:  Not found")
+
+                if private_dir.exists():
+                    lines.append(f"  Private dir: {private_dir}")
+            else:
+                # Show raw structure
+                lines.append(f"  Structure: Standard format")
+                lines.append(self._analyze_directory(self.data_dir, "Data Files"))
+            lines.append("")
+
+        # Description
+        description = self.get_description()
+        if description:
+            lines.append("## Task Description")
+            # Truncate long descriptions
+            if len(description) > 500:
+                description = description[:500] + "...\n[Description truncated, use get_description() to see full]"
+            lines.append(f"  {description}")
+            lines.append("")
+
+        # I/O Instructions
+        io_instructions = self.get_io_instructions()
+        if io_instructions:
+            lines.append("## I/O Requirements")
+            instructions = io_instructions.strip().split("\n")
+            for line in instructions[:10]:  # Show first 10 lines
+                lines.append(f"  {line}")
+            if len(instructions) > 10:
+                lines.append(f"  [... {len(instructions) - 10} more lines, use get_io_instructions() to see full]")
+            lines.append("")
+
+        lines.append("=" * 80)
+        lines.append("Use .get_description() for full task description")
+        lines.append("Use .get_io_instructions() for full I/O instructions")
+        lines.append("Use agent.run(data) to run the agent on this data")
+        lines.append("=" * 80)
+
+        return "\n".join(lines)
+
+    def _analyze_directory(self, directory: Path, title: str) -> str:
+        """Analyze directory and return schema information."""
+        lines = []
+        lines.append(f"\n  ### {title}")
+
+        try:
+            # List files
+            files = sorted([f for f in directory.iterdir() if f.is_file()])
+
+            if not files:
+                lines.append("    No files found")
+                return "\n".join(lines)
+
+            for file_path in files:
+                if not file_path.suffix.lower() in ['.csv', '.tsv', '.parquet', '.json']:
+                    continue
+
+                lines.append(f"\n  📄 {file_path.name}")
+
+                # Analyze CSV/TSV files
+                if file_path.suffix.lower() in ['.csv', '.tsv']:
+                    try:
+                        df = pd.read_csv(file_path, nrows=0)  # Read only header
+
+                        # Show columns
+                        lines.append(f"     Columns ({len(df.columns)}): {', '.join(list(df.columns[:5]))}")
+                        if len(df.columns) > 5:
+                            lines.append(f"                ... and {len(df.columns) - 5} more")
+
+                        # Show types for first few columns
+                        lines.append(f"     Types:")
+                        for col in list(df.columns)[:5]:
+                            dtype = str(df[col].dtype)
+                            lines.append(f"       - {col}: {dtype}")
+                        if len(df.columns) > 5:
+                            lines.append(f"       ... and {len(df.columns) - 5} more")
+
+                    except Exception as e:
+                        lines.append(f"     [Error reading file: {e}]")
+
+        except Exception as e:
+            lines.append(f"  [Error analyzing directory: {e}]")
+
+        return "\n".join(lines)
+
     def get_description(self) -> str:
         """Get task description."""
         if self.task_detection:
@@ -94,6 +237,7 @@ class DataLoader:
         self,
         source: Union[str, Path, pd.DataFrame, dict],
         auto_detect: bool = None,
+        registry_dir: Union[str, Path] = None,
         **kwargs
     ) -> LoadedData:
         """
@@ -103,6 +247,9 @@ class DataLoader:
             source: Data source (path, DataFrame, dict, etc.)
             auto_detect: Override the instance's auto_detect setting.
                         If None (default), use instance setting.
+            registry_dir: Benchmark registry directory (for MLE-Bench grading).
+                        If None (default), will auto-detect from data directory structure.
+                        For DSLighting project: benchmarks/mlebench/competitions/
             **kwargs: Additional parameters
 
         Returns:
@@ -125,15 +272,25 @@ class DataLoader:
         # Extract task_id from path
         task_id = self._extract_task_id(source, data_dir)
 
+        # Auto-detect registry_dir if not provided
+        if registry_dir is None:
+            registry_dir = self._auto_detect_registry_dir(data_dir, task_id)
+        else:
+            registry_dir = Path(registry_dir)
+
         # Create LoadedData
         loaded_data = LoadedData(
             source=source,
             data_dir=data_dir,
             task_detection=task_detection,
             task_id=task_id,
+            registry_dir=registry_dir,
             metadata=kwargs
         )
 
+        if registry_dir:
+            self.logger.info(f"Registry directory: {registry_dir}")
+
         self.logger.info(
             f"Loaded data: task_type={task_detection.task_type}, "
             f"workflow={task_detection.recommended_workflow}"
@@ -420,3 +577,105 @@ class DataLoader:
 
         # No task_id found
         return None
+
+    def _auto_detect_registry_dir(
+        self,
+        data_dir: Optional[Path],
+        task_id: Optional[str]
+    ) -> Optional[Path]:
+        """
+        Auto-detect MLE-Bench registry directory from data directory structure.
+
+        The registry contains competition configs (config.yaml) with grading information.
+        This method looks for the benchmarks directory relative to the data directory.
+
+        Args:
+            data_dir: Data directory path
+            task_id: Task/competition ID
+
+        Returns:
+            Path to registry directory or None
+        """
+        if not data_dir:
+            return None
+
+        self.logger.info(f"Auto-detecting registry directory for data_dir: {data_dir}")
+
+        # Expected structure:
+        # dslighting/
+        #   ├── data/competitions/{task_id}/     <- data_dir points here
+        #   └── benchmarks/mlebench/competitions/ <- registry we need to find
+
+        # Strategy 1: Look for benchmarks/ sibling to data/
+        if data_dir.is_absolute():
+            # data_dir = /path/to/dslighting/data/competitions/bike-sharing-demand
+            # We want: /path/to/dslighting/benchmarks/mlebench/competitions
+
+            # Go up to find data/, then look for benchmarks/ sibling
+            current = data_dir
+            for _ in range(5):  # Don't go up more than 5 levels
+                if current.parent.name == "data":
+                    # Found data/ directory, look for benchmarks/ sibling
+                    benchmarks_root = current.parent.parent / "benchmarks" / "mlebench" / "competitions"
+                    if benchmarks_root.exists():
+                        self.logger.info(f"  ✓ Found benchmarks at: {benchmarks_root}")
+                        return benchmarks_root
+                    break
+                current = current.parent
+
+        # Strategy 2: Check known locations relative to current file
+        try:
+            # dslighting/dslighting/core/data_loader.py
+            # Go up to dslighting/ root, then benchmarks/
+            file_location = Path(__file__).resolve()
+            dslighting_root = file_location.parent.parent.parent  # Up 3 levels
+            benchmarks_root = dslighting_root / "benchmarks" / "mlebench" / "competitions"
+
+            if benchmarks_root.exists():
+                self.logger.info(f"  ✓ Found benchmarks from package structure: {benchmarks_root}")
+                return benchmarks_root
+        except Exception as e:
+            self.logger.debug(f"  Could not determine package structure: {e}")
+
+        # Strategy 3: If data_dir is in standard DSLighting location, infer benchmarks
+        # /Users/liufan/Applications/Github/dslighting/data/competitions/{task_id}
+        # -> /Users/liufan/Applications/Github/dslighting/benchmarks/mlebench/competitions/
+        if "Github" in str(data_dir) or "dslighting" in str(data_dir):
+            # Try to reconstruct benchmarks path
+            parts = data_dir.parts
+            try:
+                if "data" in parts:
+                    idx = parts.index("data")
+                    # Rebuild path up to "data", then replace with "benchmarks/mlebench/competitions"
+                    base_parts = parts[:idx]
+                    benchmarks_path = Path(*base_parts) / "benchmarks" / "mlebench" / "competitions"
+
+                    if benchmarks_path.exists():
+                        self.logger.info(f"  ✓ Found benchmarks from path reconstruction: {benchmarks_path}")
+                        return benchmarks_path
+            except Exception as e:
+                self.logger.debug(f"  Path reconstruction failed: {e}")
+
+        # Strategy 4: Check if this is a test_project scenario
+        # /Users/liufan/Applications/Github/dslighting_test_project/
+        # -> /Users/liufan/Applications/Github/dslighting/benchmarks/
+        try:
+            import os
+            cwd = Path.cwd()
+            if "test_project" in str(cwd) or "test" in str(cwd):
+                # Go up to Github/, then into dslighting/
+                github_root = cwd.parent
+                benchmarks_path = github_root / "dslighting" / "benchmarks" / "mlebench" / "competitions"
+
+                if benchmarks_path.exists():
+                    self.logger.info(f"  ✓ Found benchmarks from test project: {benchmarks_path}")
+                    return benchmarks_path
+        except Exception as e:
+            self.logger.debug(f"  Test project detection failed: {e}")
+
+        # Could not auto-detect
+        self.logger.warning("  ⚠️  Could not auto-detect registry directory")
+        self.logger.warning("     Pass registry_dir explicitly to load_data() or Agent.run()")
+        self.logger.warning("     Example: load_data(path, registry_dir='path/to/benchmarks/mlebench/competitions')")
+
+        return None