dslighting 1.3.9__py3-none-any.whl

dsat/workflows/factory.py

@@ -0,0 +1,439 @@
+# dsat/workflows/factory.py
+
+from abc import ABC, abstractmethod
+import inspect
+import logging
+from typing import Dict, Any, Optional, Type
+
+# --- Core configuration and interface imports ---
+from dsat.config import DSATConfig
+from dsat.workflows.base import DSATWorkflow
+from dsat.benchmark.benchmark import BaseBenchmark
+
+# --- Services imports ---
+from dsat.services.workspace import WorkspaceService
+from dsat.services.llm import LLMService
+from dsat.services.sandbox import SandboxService
+from dsat.services.vdb import VDBService
+
+# --- State management imports ---
+from dsat.services.states.journal import JournalState
+from dsat.services.states.dsa_log import DSAgentState
+
+# --- Operators imports ---
+# General operators
+from dsat.operators.llm_basic import GenerateCodeAndPlanOperator, ReviewOperator, PlanOperator
+from dsat.operators.code import ExecuteAndTestOperator
+# AutoMind specific operators
+from dsat.operators.automind_ops import ComplexityScorerOperator, PlanDecomposerOperator
+# DS-Agent specific operators
+from dsat.operators.dsagent_ops import DevelopPlanOperator, ExecutePlanOperator, ReviseLogOperator
+# AutoKaggle specific operators
+from dsat.operators.autokaggle_ops import *  # Import all new operators
+
+from dsat.operators.aflow_ops import ScEnsembleOperator, ReviewOperator as AFlowReviewOperator, ReviseOperator as AFlowReviseOperator
+from dsat.utils.dynamic_import import import_workflow_from_string
+from dsat.common.exceptions import DynamicImportError
+
+
+# --- Concrete workflow imports ---
+from dsat.workflows.search.automind_workflow import AutoMindWorkflow
+from dsat.workflows.search.aide_workflow import AIDEWorkflow
+from dsat.workflows.search.aflow_workflow import AFlowWorkflow
+from dsat.workflows.manual.deepanalyze_workflow import DeepAnalyzeWorkflow
+from dsat.workflows.manual.dsagent_workflow import DSAgentWorkflow
+from dsat.workflows.manual.data_interpreter_workflow import DataInterpreterWorkflow
+from dsat.workflows.manual.autokaggle_workflow import AutoKaggleWorkflow
+
+logger = logging.getLogger(__name__)
+
+
+class WorkflowFactory(ABC):
+    """
+    Abstract base class for workflow factories.
+    
+    Defines a unified interface for creating workflow instances based on configuration.
+    This follows the factory pattern, separating object creation logic from usage.
+    """
+    @abstractmethod
+    def create_workflow(self, config: DSATConfig, benchmark: Optional[BaseBenchmark] = None) -> DSATWorkflow:
+        """
+        Create and return a configured workflow instance based on the provided configuration.
+
+        Args:
+            config: Complete DSATConfig object containing all runtime parameters.
+
+        Returns:
+            A fully initialized DSATWorkflow instance ready to execute solve() method.
+        """
+        raise NotImplementedError
+
+
+# ==============================================================================
+# ==                            AIDE WORKFLOW FACTORY                           ==
+# ==============================================================================
+class AIDEWorkflowFactory(WorkflowFactory):
+    """A specialized factory for creating and assembling AIDEWorkflow."""
+    def create_workflow(self, config: DSATConfig, benchmark: Optional[BaseBenchmark] = None) -> AIDEWorkflow:
+        logger.info("AIDEWorkflowFactory: Assembling AIDE workflow...")
+
+        workspace_base = None
+        if config.workflow and config.workflow.params:
+            workspace_base = config.workflow.params.get("workspace_base_dir")
+        workspace = WorkspaceService(run_name=config.run.name, base_dir=workspace_base)
+        llm_service = LLMService(config=config.llm)
+        sandbox_service = SandboxService(workspace=workspace, timeout=config.sandbox.timeout)
+        state = JournalState()
+
+        operators = {
+            "generate": GenerateCodeAndPlanOperator(llm_service=llm_service),
+            "execute": ExecuteAndTestOperator(sandbox_service=sandbox_service),
+            "review": ReviewOperator(llm_service=llm_service),
+        }
+        
+        services = {
+            "llm": llm_service,
+            "sandbox": sandbox_service,
+            "state": state,
+            "workspace": workspace,
+        }
+
+        workflow = AIDEWorkflow(
+            operators=operators,
+            services=services,
+            agent_config=config.agent.model_dump(),
+            benchmark=benchmark
+        )
+
+        logger.info("AIDE workflow assembled successfully.")
+        return workflow
+
+
+# ==============================================================================
+# ==                          AUTOMIND WORKFLOW FACTORY                         ==
+# ==============================================================================
+class AutoMindWorkflowFactory(WorkflowFactory):
+    """
+    A specialized factory for creating and assembling AutoMindWorkflow.
+
+    This class encapsulates all the complexity required to create AutoMindWorkflow,
+    including instantiating its dependent services, state managers and operators.
+    """
+    def create_workflow(self, config: DSATConfig, benchmark: Optional[BaseBenchmark] = None) -> AutoMindWorkflow:
+        """
+        Build a fully functional AutoMindWorkflow instance.
+        """
+        logger.info("AutoMindWorkflowFactory: Assembling AutoMind workflow...")
+
+        # 1. Instantiate all base services required by this workflow
+        logger.debug("Instantiating services...")
+        workspace = WorkspaceService(run_name=config.run.name)
+        llm_service = LLMService(config=config.llm)
+        sandbox_service = SandboxService(workspace=workspace, timeout=config.sandbox.timeout)
+        case_dir = config.workflow.params.get('case_dir', 'experience_replay')
+        vdb_service = VDBService(case_dir=case_dir)
+        state = JournalState()
+        
+        # 2. Instantiate all operators required by this workflow, injecting their service dependencies
+        logger.debug("Instantiating operators...")
+        operators = {
+            "generate": GenerateCodeAndPlanOperator(llm_service=llm_service),
+            "execute": ExecuteAndTestOperator(sandbox_service=sandbox_service),
+            "review": ReviewOperator(llm_service=llm_service),
+            "complexity_scorer": ComplexityScorerOperator(llm_service=llm_service),
+            "plan_decomposer": PlanDecomposerOperator(llm_service=llm_service),
+        }
+
+        # 3. Package all services for injection
+        services = {
+            "llm": llm_service,
+            "sandbox": sandbox_service,
+            "vdb": vdb_service,
+            "state": state,
+            "workspace": workspace, # Also optionally inject workspace
+        }
+
+        logger.debug("Instantiating AutoMindWorkflow with dependencies...")
+        workflow = AutoMindWorkflow(
+            operators=operators,
+            services=services,
+            agent_config=config.agent.model_dump(),
+            benchmark=benchmark
+        )
+
+        logger.info("AutoMind workflow assembled successfully.")
+        return workflow
+
+
+# ==============================================================================
+# ==                          DS-AGENT WORKFLOW FACTORY                         ==
+# ==============================================================================
+class DSAgentWorkflowFactory(WorkflowFactory):
+    """A specialized factory for creating and assembling DSAgentWorkflow."""
+    def create_workflow(self, config: DSATConfig, benchmark: Optional[BaseBenchmark] = None) -> DSAgentWorkflow:
+        logger.info("DSAgentWorkflowFactory: Assembling DS-Agent workflow...")
+
+        workspace = WorkspaceService(run_name=config.run.name)
+        llm_service = LLMService(config=config.llm)
+        sandbox_service = SandboxService(workspace=workspace, timeout=config.sandbox.timeout)
+        case_dir = config.workflow.params.get('case_dir', 'experience_replay')
+        vdb_service = VDBService(case_dir=case_dir)
+        state = DSAgentState()
+
+        operators = {
+            "planner": DevelopPlanOperator(llm_service=llm_service, vdb_service=vdb_service),
+            "executor": ExecutePlanOperator(llm_service=llm_service, sandbox_service=sandbox_service),
+            "logger": ReviseLogOperator(llm_service=llm_service),
+        }
+        
+        services = {
+            "llm": llm_service,
+            "sandbox": sandbox_service,
+            "vdb": vdb_service,
+            "state": state,
+            "workspace": workspace,
+        }
+        
+        workflow = DSAgentWorkflow(
+            operators=operators,
+            services=services,
+            agent_config=config.agent.model_dump()
+        )
+
+        logger.info("DS-Agent workflow assembled successfully.")
+        return workflow
+
+
+# ==============================================================================
+# ==                      DATA INTERPRETER WORKFLOW FACTORY                     ==
+# ==============================================================================
+class DataInterpreterWorkflowFactory(WorkflowFactory):
+    """A specialized factory for creating and assembling DataInterpreterWorkflow."""
+    def create_workflow(self, config: DSATConfig, benchmark: Optional[BaseBenchmark] = None) -> DataInterpreterWorkflow:
+        logger.info("DataInterpreterWorkflowFactory: Assembling Data Interpreter workflow...")
+
+        workspace = WorkspaceService(run_name=config.run.name)
+        llm_service = LLMService(config=config.llm)
+        sandbox_service = SandboxService(workspace=workspace, timeout=config.sandbox.timeout)
+
+        operators = {
+            "planner": PlanOperator(llm_service=llm_service),
+            "generator": GenerateCodeAndPlanOperator(llm_service=llm_service),
+            "debugger": GenerateCodeAndPlanOperator(llm_service=llm_service),
+            "executor": ExecuteAndTestOperator(sandbox_service=sandbox_service),
+        }
+        
+        services = {
+            "llm": llm_service,
+            "sandbox": sandbox_service,
+            "workspace": workspace,
+        }
+
+        workflow = DataInterpreterWorkflow(
+            operators=operators,
+            services=services,
+            agent_config=config.agent.model_dump()
+        )
+
+        logger.info("Data Interpreter workflow assembled successfully.")
+        return workflow
+
+
+# ==============================================================================
+# ==                      AUTOKAGGLE SOP WORKFLOW FACTORY                     ==
+# ==============================================================================
+class AutoKaggleWorkflowFactory(WorkflowFactory):
+    """A specialized factory for creating and assembling the dynamic AutoKaggleWorkflow."""
+    def create_workflow(self, config: DSATConfig, benchmark: Optional[BaseBenchmark] = None) -> AutoKaggleWorkflow:
+        logger.info("AutoKaggleWorkflowFactory: Assembling AutoKaggle SOP workflow...")
+
+        workspace = WorkspaceService(run_name=config.run.name)
+        llm_service = LLMService(config=config.llm)
+        sandbox_service = SandboxService(workspace=workspace, timeout=config.sandbox.timeout)
+        
+        services = {
+            "llm": llm_service,
+            "sandbox": sandbox_service,
+            "workspace": workspace,
+        }
+
+        # The workflow now instantiates its own operators, so we pass an empty dict
+        workflow = AutoKaggleWorkflow(
+            operators={}, 
+            services=services,
+            agent_config=config.agent.model_dump()
+        )
+
+        logger.info("AutoKaggle SOP workflow assembled successfully.")
+        return workflow
+
+
+# ==============================================================================
+# ==                      DEEPANALYZE WORKFLOW FACTORY                         ==
+# ==============================================================================
+class DeepAnalyzeWorkflowFactory(WorkflowFactory):
+    """Factory for assembling DeepAnalyzeWorkflow."""
+
+    def create_workflow(
+        self,
+        config: DSATConfig,
+        benchmark: Optional[BaseBenchmark] = None,
+    ) -> DeepAnalyzeWorkflow:
+        logger.info("DeepAnalyzeWorkflowFactory: Assembling DeepAnalyze workflow...")
+
+        workspace = WorkspaceService(run_name=config.run.name)
+        llm_service = LLMService(config=config.llm)
+        sandbox_service = SandboxService(workspace=workspace, timeout=config.sandbox.timeout)
+
+        operators = {
+            "execute": ExecuteAndTestOperator(sandbox_service=sandbox_service),
+        }
+
+        services = {
+            "llm": llm_service,
+            "sandbox": sandbox_service,
+            "workspace": workspace,
+        }
+
+        workflow = DeepAnalyzeWorkflow(
+            operators=operators,
+            services=services,
+            agent_config=config.agent.model_dump(),
+            benchmark=benchmark,
+        )
+
+        logger.info("DeepAnalyze workflow assembled successfully.")
+        return workflow
+
+
+# ==============================================================================
+# ==                            AFLOW WORKFLOW FACTORY                          ==
+# ==============================================================================
+class AFlowWorkflowFactory(WorkflowFactory):
+    """A specialized factory for creating and assembling AFlowWorkflow."""
+    def create_workflow(self, config: DSATConfig, benchmark: Optional[BaseBenchmark] = None) -> AFlowWorkflow:
+        logger.info("AFlowWorkflowFactory: Assembling AFlow workflow...")
+
+        workspace_base = None
+        if config.workflow and config.workflow.params:
+            workspace_base = config.workflow.params.get("workspace_base_dir")
+        workspace = WorkspaceService(run_name=config.run.name, base_dir=workspace_base)
+        llm_service = LLMService(config=config.llm)
+        # Add SandboxService for code execution capabilities
+        sandbox_service = SandboxService(workspace=workspace, timeout=config.sandbox.timeout)
+        
+        services = {
+            "llm": llm_service,
+            "workspace": workspace,
+            "sandbox": sandbox_service,
+        }
+
+        agent_config = config.agent.model_dump()
+        if config.optimizer:
+            agent_config["optimizer"] = config.optimizer.model_dump()
+
+        workflow = AFlowWorkflow(
+            operators={},  # AFlow creates its own operators
+            services=services,
+            agent_config=agent_config,
+            benchmark=benchmark,  # Pass the benchmark instance
+        )
+
+        logger.info("AFlow workflow assembled successfully.")
+        return workflow
+
+
+class DynamicWorkflowFactory(WorkflowFactory):
+    """
+    A factory that creates a workflow instance from a Python code string at runtime.
+    This is used by the AFLOW paradigm to evaluate its discovered "best" workflow.
+    """
+    def __init__(
+        self,
+        code_string: str,
+        operator_classes: Optional[Dict[str, Type["Operator"]]] = None,
+    ):
+        self.code_string = code_string
+        self.operator_classes = operator_classes
+        try:
+            self.workflow_class = import_workflow_from_string(self.code_string)
+        except DynamicImportError as e:
+            raise ValueError("Failed to dynamically import 'Workflow' class from the provided code string.") from e
+
+    def create_workflow(self, config: DSATConfig, benchmark: Optional[BaseBenchmark] = None) -> DSATWorkflow:
+        logger.info(f"DynamicWorkflowFactory: Instantiating workflow from code string...")
+        
+        workspace = WorkspaceService(run_name=config.run.name)
+        llm_service = LLMService(config=config.llm)
+        sandbox_service = SandboxService(workspace=workspace, timeout=config.sandbox.timeout)
+
+        services = {
+            "llm": llm_service,
+            "sandbox": sandbox_service,
+            "workspace": workspace,
+        }
+
+        operators = self._build_operator_instances(
+            llm_service=llm_service,
+            sandbox_service=sandbox_service,
+            workspace=workspace,
+        )
+        
+        # Instantiate the dynamically imported class
+        workflow_instance = self.workflow_class(
+            operators=operators,
+            services=services,
+            agent_config=config.agent.model_dump()
+        )
+        logger.info("Dynamically-loaded workflow instantiated successfully.")
+        return workflow_instance
+
+    def _build_operator_instances(
+        self,
+        llm_service: LLMService,
+        sandbox_service: SandboxService,
+        workspace: WorkspaceService,
+    ) -> Dict[str, Any]:
+        """
+        Build operator instances for a dynamically imported workflow.
+
+        - Default: provide AFLOW operators (backwards compatible).
+        - Override: callers may pass `operator_classes` to inject a custom toolbox.
+        """
+        if not self.operator_classes:
+            return {
+                "ScEnsemble": ScEnsembleOperator(llm_service=llm_service),
+                "Review": AFlowReviewOperator(llm_service=llm_service),
+                "Revise": AFlowReviseOperator(llm_service=llm_service),
+            }
+
+        operators: Dict[str, Any] = {}
+        for name, cls in self.operator_classes.items():
+            operators[name] = self._instantiate_operator(
+                cls=cls,
+                llm_service=llm_service,
+                sandbox_service=sandbox_service,
+                workspace=workspace,
+                operators=operators,
+            )
+        return operators
+
+    @staticmethod
+    def _instantiate_operator(
+        cls: Type["Operator"],
+        llm_service: LLMService,
+        sandbox_service: SandboxService,
+        workspace: WorkspaceService,
+        operators: Dict[str, Any],
+    ) -> Any:
+        params = inspect.signature(cls.__init__).parameters
+        kwargs: Dict[str, Any] = {}
+        if "llm_service" in params:
+            kwargs["llm_service"] = llm_service
+        if "sandbox_service" in params:
+            kwargs["sandbox_service"] = sandbox_service
+        if "workspace" in params:
+            kwargs["workspace"] = workspace
+        if "operators" in params:
+            kwargs["operators"] = operators
+        return cls(**kwargs)  # type: ignore[arg-type]

dsat/workflows/manual/autokaggle_workflow.py

@@ -0,0 +1,148 @@
+# dsat/workflows/manual/autokaggle_workflow.py
+import logging
+from pathlib import Path
+from typing import Dict, Any
+import shutil # <-- ADD THIS IMPORT
+
+from dsat.workflows.base import DSATWorkflow
+from dsat.services.llm import LLMService
+from dsat.services.sandbox import SandboxService
+from dsat.services.workspace import WorkspaceService
+from dsat.services.states.autokaggle_state import AutoKaggleState, PhaseMemory, AttemptMemory
+from dsat.operators.autokaggle_ops import (
+    TaskDeconstructionOperator,
+    AutoKagglePlannerOperator,
+    AutoKaggleDeveloperOperator,
+    DynamicValidationOperator,
+    AutoKaggleReviewerOperator,
+    AutoKaggleSummarizerOperator,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class AutoKaggleWorkflow(DSATWorkflow):
+    """
+    Implements the Contract-Driven Dynamic AutoKaggle Standard Operating Procedure.
+    """
+
+    def __init__(self, operators: Dict[str, Any], services: Dict[str, Any], agent_config: Dict[str, Any]):
+        super().__init__(operators, services, agent_config)
+        self.workspace: WorkspaceService = services["workspace"]
+        self.llm_service: LLMService = services["llm"]
+        self.sandbox: SandboxService = services["sandbox"]
+        
+        # Operator Initialization with Dependency Injection
+        validator = DynamicValidationOperator(llm_service=self.llm_service)
+        self.operators = {
+            "deconstructor": TaskDeconstructionOperator(llm_service=self.llm_service),
+            "planner": AutoKagglePlannerOperator(llm_service=self.llm_service),
+            "developer": AutoKaggleDeveloperOperator(llm_service=self.llm_service, sandbox_service=self.sandbox, validator=validator),
+            "reviewer": AutoKaggleReviewerOperator(llm_service=self.llm_service),
+            "summarizer": AutoKaggleSummarizerOperator(llm_service=self.llm_service),
+        }
+        sop_config = agent_config.get("autokaggle", {})
+        self.config = {
+            "max_attempts_per_phase": sop_config.get("max_attempts_per_phase", 5), # Give it a few more tries
+            "success_threshold": sop_config.get("success_threshold", 3.0)
+        }
+
+    async def solve(self, description: str, io_instructions: str, data_dir: Path, output_path: Path) -> None:
+        logger.info("Starting Stateful Contract-Driven Dynamic SOP Workflow...")
+
+        full_context_for_deconstructor = f"{description}\n\n{io_instructions}"
+        
+        task_contract = await self.operators["deconstructor"](full_context_for_deconstructor)
+        dynamic_phases = await self.operators["planner"].plan_phases(task_contract)
+        
+        state = AutoKaggleState(
+            contract=task_contract,
+            dynamic_phases=dynamic_phases,
+            io_instructions=io_instructions,
+            full_task_description=description
+        )
+
+        for i, phase_goal in enumerate(state.dynamic_phases):
+            logger.info(f"--- Starting Dynamic Phase {i+1}/{len(state.dynamic_phases)}: '{phase_goal}' ---")
+            
+            current_phase_memory = PhaseMemory(phase_goal=phase_goal)
+            phase_succeeded = False
+            
+            for attempt in range(self.config["max_attempts_per_phase"]):
+                logger.info(f"--- Phase '{phase_goal}', Attempt {attempt + 1} ---")
+
+                step_plan = await self.operators["planner"].plan_step_details(state, phase_goal)
+                dev_result = await self.operators["developer"](state, phase_goal, step_plan.plan, current_phase_memory.attempts)
+                review_result = await self.operators["reviewer"](state, phase_goal, dev_result, plan=step_plan.plan)
+                
+                ## --- MODIFIED: Stricter Artifact-based Validation --- ##
+                all_artifacts_produced = True
+                sandbox_workdir = self.sandbox.workspace.get_path("sandbox_workdir")
+                if dev_result['status']: # Only check for artifacts if code ran successfully
+                    if not step_plan.output_files:
+                        logger.warning(f"Phase '{phase_goal}' has no planned output files. Relying on reviewer score alone.")
+                    for filename in step_plan.output_files:
+                        if not (sandbox_workdir / filename).exists():
+                            logger.error(f"Attempt failed: Planned artifact '{filename}' was NOT created.")
+                            all_artifacts_produced = False
+                            break # No need to check other files
+                else:
+                    all_artifacts_produced = False
+
+                attempt_memory = AttemptMemory(
+                    attempt_number=attempt,
+                    plan=step_plan.plan,
+                    code=dev_result['code'],
+                    execution_output=dev_result['output'],
+                    execution_error=dev_result['error'],
+                    validation_result=dev_result.get('validation_result', {}),
+                    review_score=review_result.get('score', 1.0),
+                    review_suggestion=review_result.get('suggestion', 'No suggestion provided.')
+                )
+                current_phase_memory.attempts.append(attempt_memory)
+
+                if dev_result['status'] and all_artifacts_produced and review_result.get('score', 1.0) >= self.config["success_threshold"]:
+                    logger.info(f"--- Phase '{phase_goal}' Succeeded ---")
+                    phase_succeeded = True
+                    
+                    # Register newly created artifacts in the global state
+                    for filename in step_plan.output_files:
+                        description = f"Generated during phase: {phase_goal}"
+                        state.global_artifacts[filename] = description
+                        current_phase_memory.output_artifacts[filename] = description
+                        logger.info(f"Registered new artifact: {filename}")
+                    
+                    break # Exit attempt loop on success
+                else:
+                    logger.warning(f"Attempt failed. Code Success: {dev_result['status']}. Artifacts Produced: {all_artifacts_produced}. Score: {review_result.get('score', 1.0)}. Retrying...")
+
+            if phase_succeeded:
+                summary_report = await self.operators["summarizer"](state, current_phase_memory)
+                current_phase_memory.final_report = summary_report
+                current_phase_memory.is_successful = True
+                state.phase_history.append(current_phase_memory)
+            else:
+                logger.error(f"--- Phase '{phase_goal}' FAILED after all attempts. Aborting workflow. ---")
+                return # Abort entire workflow if a phase fails
+
+        logger.info("All dynamic phases completed successfully.")
+        
+        ## --- ADDED: Final Artifact Collection --- ##
+        final_submission_filename = None
+        if state.contract.output_files:
+            # Assume the first output file in the contract is the required one.
+            final_submission_filename = state.contract.output_files[0].filename
+        
+        if final_submission_filename and final_submission_filename in state.global_artifacts:
+            source_file = sandbox_workdir / final_submission_filename
+            destination_file = output_path
+            
+            logger.info(f"Collecting final submission artifact '{source_file}' to '{destination_file}'.")
+            try:
+                destination_file.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copy(source_file, destination_file)
+                logger.info("Final artifact collected successfully.")
+            except Exception as e:
+                logger.error(f"Failed to collect final artifact: {e}")
+        else:
+            logger.error(f"Workflow finished, but required output file '{final_submission_filename}' was not found in the global artifact registry.")