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

dslighting/__init__.py

@@ -26,7 +26,7 @@ Advanced Usage:
 For more information, see: https://github.com/usail-hkust/dslighting
 """
 
-__version__ = "1.7.1"
+__version__ = "1.7.8"
 __author__ = "DSLighting Team"
 
 # Core API classes

dslighting/core/agent.py

@@ -232,6 +232,7 @@ class Agent:
         """
         # Start timing
         start_time = time.time()
+        print(f"[DEBUG START] agent.run() called with data={type(data).__name__}, task_id={task_id}")
 
         try:
             # ========== New simplified API: task_id + data_dir ==========
@@ -278,21 +279,28 @@ class Agent:
 
             # ========== Recommended API: LoadedData with task_id ==========
             elif data is not None:
+                print(f"[DEBUG A] data is not None, type={type(data).__name__}")
                 # Load data if not already loaded
                 if not isinstance(data, LoadedData):
+                    print(f"[DEBUG B] Loading data...")
                     loader = DataLoader()
                     loaded_data = loader.load(data)
+                    print(f"[DEBUG C] Data loaded, task_id={loaded_data.task_id}")
                 else:
+                    print(f"[DEBUG B] Data is already LoadedData")
                     loaded_data = data
+                    print(f"[DEBUG C] LoadedData has task_id={loaded_data.task_id}")
 
                 # Extract task_id from loaded_data if available
                 if loaded_data.task_id:
                     # Use task_id from loaded_data for benchmark initialization
                     extracted_task_id = loaded_data.task_id
                     self.logger.info(f"Detected task_id from data: {extracted_task_id}")
+                    print(f"[DEBUG D] Extracted task_id={extracted_task_id}, overriding task_id parameter")
 
                     # Override task_id parameter for benchmark initialization
                     task_id = extracted_task_id
+                    print(f"[DEBUG E] task_id is now set to: {task_id}")
             else:
                 raise ValueError(
                     "Either 'task_id' or 'data' must be provided. "
@@ -316,10 +324,17 @@ class Agent:
             )
 
             # Initialize benchmark for MLE tasks (for grading)
+            print(f"[DEBUG 1] Checking benchmark initialization: task_id={task_id}, task_type={loaded_data.get_task_type()}")
+            self.logger.info(f"[DEBUG] Checking benchmark initialization: task_id={task_id}, task_type={loaded_data.get_task_type()}")
+
             if task_id and loaded_data.get_task_type() == "kaggle":
+                print(f"[DEBUG 2] Condition met: task_id={task_id}, task_type=kaggle")
+                self.logger.info(f"[DEBUG] Condition met: initializing benchmark")
                 try:
+                    print(f"[DEBUG 3] Attempting to import mlebench...")
                     from mlebench.grade import grade_csv
                     from mlebench.registry import Registry
+                    print(f"[DEBUG 4] mlebench imported successfully")
 
                     # Resolve data_dir - prioritize loaded_data.data_dir
                     if loaded_data.data_dir is not None:
@@ -334,84 +349,85 @@ class Agent:
                     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}")
+                    # Try to use built-in registry first
+                    import dslighting
+                    built_in_registry_dir = Path(dslighting.__file__).parent / "registry"
+                    print(f"[DEBUG 5] Built-in registry dir: {built_in_registry_dir}, exists: {built_in_registry_dir.exists()}")
+
+                    registry_dir = loaded_data.registry_dir
+                    print(f"[DEBUG 6] loaded_data.registry_dir: {registry_dir}")
+                    if not registry_dir or not Path(registry_dir).exists():
+                        print(f"[DEBUG 7] Registry dir not valid, checking built-in...")
+                        if built_in_registry_dir.exists():
+                            registry_dir = built_in_registry_dir
+                            self.logger.info(f"  Using built-in registry: {registry_dir}")
+                            print(f"[DEBUG 8] Using built-in registry: {registry_dir}")
+                        else:
+                            self.logger.warning(f"⚠️  Registry directory not found")
+                            self.logger.warning(f"  Grading will be skipped.")
+                            print(f"[DEBUG 8a] Built-in registry not found, skipping grading")
                     else:
-                        self.logger.info(f"  Registry directory: auto-detected from data directory structure")
+                        self.logger.info(f"  Registry directory (from loaded_data): {registry_dir}")
+                        print(f"[DEBUG 8b] Using loaded_data registry: {registry_dir}")
 
-                    # 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.")
+                    # Check if registry_dir exists
+                    if not registry_dir or not Path(registry_dir).exists():
+                        self.logger.warning(f"⚠️  Registry directory not available: {registry_dir}")
                         self.logger.warning(f"   Grading will be skipped.")
+                        print(f"[DEBUG 9] Registry not available, skipping grading")
                     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."""
+                        print(f"[DEBUG 10] Registry available, proceeding with initialization")
+                        # Initialize benchmark with registry
+                        registry_kwargs = {"data_dir": data_dir_path, "registry_dir": str(registry_dir)}
+
+                        try:
+                            print(f"[DEBUG 11] Creating Registry with kwargs: {registry_kwargs}")
+                            custom_registry = Registry(**registry_kwargs)
+                            print(f"[DEBUG 12] Registry created successfully")
+
+                            # Log registry configuration
+                            self.logger.info(f"  Registry config:")
+                            self.logger.info(f"    data_dir: {data_dir_path}")
+                            self.logger.info(f"    registry_dir: {registry_dir}")
+
+                            # Create simple wrapper class
+                            class SimpleMLEBenchmark:
+                                def __init__(self, registry_instance):
+                                    self.registry = registry_instance
+                                    self.problems = [{"competition_id": task_id}]
+
+                                async def grade(self, submission_path):
+                                    """Grade submission using custom registry."""
+                                    try:
                                         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}")
+                                        score = report.score if report.score is not None else 0.0
+                                        self.logger.info(f"  Grading result: {score}")
+                                        return score
+                                    except Exception as e:
+                                        self.logger.warning(f"  Grading failed: {e}")
+                                        return 0.0
+
+                            benchmark = SimpleMLEBenchmark(custom_registry)
+                            runner = self.get_runner()
+                            runner.benchmark = benchmark
+                            print(f"[DEBUG 13] ✓ Benchmark set successfully for task: {task_id}")
+                            self.logger.info(f"✓ Benchmark initialized for grading: {task_id}")
+                        except Exception as e:
+                            print(f"[DEBUG ERROR] Benchmark initialization failed: {e}")
+                            self.logger.warning(f"⚠️  Benchmark initialization failed: {e}")
+                            self.logger.warning(f"   Grading will be skipped.")
 
                 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")
+                    self.logger.warning(f"Grading will be skipped: {e}")
 
             # Execute task (async wrapper)
             result = asyncio.run(self._execute_task(task, loaded_data))

{dslighting-1.7.1.dist-info → dslighting-1.7.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dslighting
-Version: 1.7.1
+Version: 1.7.8
 Summary: Simplified API for Data Science Agent Automation
 Author: DSLighting Team
 License: AGPL-3.0
@@ -30,6 +30,8 @@ Requires-Dist: rich>=13.0.0
 Requires-Dist: transformers>=4.30.0
 Requires-Dist: torch>=2.0.0
 Requires-Dist: scikit-learn>=1.0.0
+Requires-Dist: diskcache
+Requires-Dist: tenacity
 Requires-Dist: nbformat
 Requires-Dist: nbclient
 Provides-Extra: full