ExperimentDesigner

class ExperimentDesigner:
    """Designs ML experiments using Gemini 3.

    Key features:
    - Hypothesis-driven experiment design
    - Learns from previous experiment results
    - Respects user constraints
    - Maintains conversation context for Thought Signature continuity
    - Intelligent fallback when Gemini fails
    """

    def __init__(self, gemini_client: GeminiClient):
        """Initialize the experiment designer.

        Args:
            gemini_client: Shared GeminiClient instance for API calls.
                           Sharing preserves conversation history.
        """

def design_experiment(
    self,
    data_profile: DataProfile,
    previous_results: list[ExperimentResult],
    task_type: str,
    constraints: Optional[str] = None,
    iteration: int = 1,
) -> ExperimentSpec:
    """Design the next experiment based on data and history.

    Args:
        data_profile: Profile of the dataset from DataProfiler.
        previous_results: List of previous experiment results.
        task_type: "classification" or "regression".
        constraints: Optional user constraints as Markdown text.
        iteration: Current iteration number.

    Returns:
        ExperimentSpec ready for code generation.

    Raises:
        GeminiError: If API call fails and no fallback available.
    """

def parse_constraints(self, constraints_text: str) -> ParsedConstraints:
    """Parse Markdown constraints text into structured config.

    Args:
        constraints_text: Raw Markdown text from constraints file.

    Returns:
        ParsedConstraints with extracted values.
    """

def select_primary_metric(
    self,
    task_type: str,
    constraints: Optional[ParsedConstraints] = None,
) -> str:
    """Select the primary metric based on task and constraints.

    Args:
        task_type: "classification" or "regression".
        constraints: Parsed constraints (may contain metric preference).

    Returns:
        Primary metric name.
    """

def get_design_count(self) -> int:
    """Get the number of experiments designed so far."""

def get_parsed_constraints(self) -> Optional[ParsedConstraints]:
    """Get the parsed constraints if available."""

@dataclass
class ParsedConstraints:
    """Parsed user constraints from Markdown."""

    primary_metric: Optional[str] = None
    preferred_models: list[str] = None
    avoided_models: list[str] = None
    preprocessing_hints: list[str] = None
    termination_rules: dict = None
    raw_text: str = ""

from src.cognitive.gemini_client import GeminiClient
from src.cognitive.experiment_designer import ExperimentDesigner

# Initialize
client = GeminiClient()
designer = ExperimentDesigner(gemini_client=client)

# Design first experiment
spec = designer.design_experiment(
    data_profile=profile,
    previous_results=[],
    task_type="regression",
    iteration=1
)

print(f"Experiment: {spec.experiment_name}")
print(f"Hypothesis: {spec.hypothesis}")
print(f"Model: {spec.model_type}")
print(f"Params: {spec.model_params}")

constraints_md = """
## Metrics
Primary metric: R2

## Models
- Prefer tree-based models
- Avoid linear models

## Preprocessing
- Use median imputation for missing values
- Apply standard scaling
"""

spec = designer.design_experiment(
    data_profile=profile,
    previous_results=results,
    task_type="regression",
    constraints=constraints_md,
    iteration=2
)

from src.orchestration.state import ExperimentState

# Initialize state
state = ExperimentState(config=config)
designer = ExperimentDesigner(gemini_client=client)

# Design and execute experiments
for iteration in range(1, 11):
    # Design next experiment
    spec = designer.design_experiment(
        data_profile=state.data_profile,
        previous_results=state.experiments,
        task_type=state.config.task_type.value,
        constraints=state.config.constraints,
        iteration=iteration
    )
    
    # Execute experiment (code generation, execution, etc.)
    result = execute_experiment(spec)
    
    # Update state
    state.add_experiment(result)
    
    # Check for early stopping
    if should_stop(state):
        break

print(f"Designed {designer.get_design_count()} experiments")

constraints_text = """
## Metrics
Primary metric: F1 score

## Models
Prefer Random Forest and XGBoost
Avoid SVM models

## Termination
Stop after 5 iterations with no improvement
"""

parsed = designer.parse_constraints(constraints_text)
print(f"Primary metric: {parsed.primary_metric}")
print(f"Preferred: {parsed.preferred_models}")
print(f"Avoided: {parsed.avoided_models}")
print(f"Plateau threshold: {parsed.termination_rules.get('plateau_threshold')}")

# After first design with constraints
spec1 = designer.design_experiment(
    data_profile=profile,
    previous_results=[],
    task_type="classification",
    constraints=constraints_md,
    iteration=1
)

# Constraints are cached and reused
constraints = designer.get_parsed_constraints()
if constraints:
    metric = designer.select_primary_metric(
        task_type="classification",
        constraints=constraints
    )
    print(f"Using metric: {metric}")

try:
    spec = designer.design_experiment(
        data_profile=profile,
        previous_results=results,
        task_type="regression",
        iteration=5
    )
    
    # Check if fallback was used
    if "fallback" in spec.experiment_name.lower():
        print("Used fallback design due to Gemini error")
        print(f"Reasoning: {spec.reasoning}")
except GeminiError as e:
    print(f"Design failed: {e}")