opik-optimizer 0.9.1__py3-none-any.whl → 0.9.2__py3-none-any.whl

opik_optimizer/evolutionary_optimizer/evolutionary_optimizer.py

@@ -828,7 +828,35 @@ Return only the new prompt list object.
             auto_continue: Whether to automatically continue optimization
             **kwargs: Additional keyword arguments
         """
-        reporting.display_header(self.__class__.__name__, verbose=self.verbose)
+        if not isinstance(prompt, chat_prompt.ChatPrompt):
+            raise ValueError("Prompt must be a ChatPrompt object")
+        
+        if not isinstance(dataset, opik.Dataset):
+            raise ValueError("Dataset must be a Dataset object")
+        
+        if not isinstance(metric, Callable):
+            raise ValueError("Metric must be a function that takes `dataset_item` and `llm_output` as arguments.")
+
+        # Step 0. Start Opik optimization run
+        opik_optimization_run: Optional[optimization.Optimization] = None
+        try:
+            opik_optimization_run: optimization.Optimization = self._opik_client.create_optimization(
+                dataset_name=dataset.name,
+                objective_name=metric.__name__,
+                metadata={"optimizer": self.__class__.__name__},
+            )
+            self._current_optimization_id = opik_optimization_run.id
+        except Exception as e:
+            logger.warning(f"Opik server error: {e}. Continuing without Opik tracking.")
+            self._current_optimization_id = None
+
+        reporting.display_header(
+            algorithm=self.__class__.__name__,
+            optimization_id=self._current_optimization_id,
+            dataset_id=dataset.id,
+            verbose=self.verbose
+        )
+
         reporting.display_configuration(
             prompt.formatted_messages,
             {
@@ -841,9 +869,9 @@ Return only the new prompt list object.
             verbose=self.verbose
         )
 
+        # Step 1. Step variables and define fitness function
         self.llm_call_counter = 0
         self._history = []
-        self._current_optimization_id = None
         self._current_generation = 0
         self._best_fitness_history = []
         self._generations_without_improvement = 0
@@ -851,7 +879,6 @@ Return only the new prompt list object.
         self._current_population = []
         self._generations_without_overall_improvement = 0
         
-        # Step 0. Define fitness function
         if self.enable_moo:
             def _deap_evaluate_individual_fitness(
                     messages: List[Dict[str, str]]
@@ -884,19 +911,6 @@ Return only the new prompt list object.
                 return (fitness_score,)
         self.toolbox.register("evaluate", _deap_evaluate_individual_fitness)
 
-        # Step 1. Start Opik optimization run
-        opik_optimization_run: Optional[optimization.Optimization] = None
-        try:
-            opik_optimization_run: optimization.Optimization = self._opik_client.create_optimization(
-                dataset_name=dataset.name,
-                objective_name=metric.__name__,
-                metadata={"optimizer": self.__class__.__name__},
-            )
-            self._current_optimization_id = opik_optimization_run.id
-            logger.info(f"Created Opik Optimization run with ID: {self._current_optimization_id}")
-        except Exception as e:
-            logger.warning(f"Opik server error: {e}. Continuing without Opik tracking.")
-
         # Step 2. Compute the initial performance of the prompt
         with reporting.baseline_performance(verbose=self.verbose) as report_baseline_performance:
             initial_eval_result: Tuple[float, float] | Tuple[float, ] = _deap_evaluate_individual_fitness(prompt.formatted_messages)
@@ -976,7 +990,7 @@ Return only the new prompt list object.
                 best_prompt=best_prompt_overall,
                 best_score=best_primary_score_overall,
                 improvement=0.0
-            ).dict()
+            ).model_dump()
             self._add_to_history(initial_round_data)
 
         with reporting.start_evolutionary_algo(verbose=self.verbose) as report_evolutionary_algo:
@@ -1035,7 +1049,7 @@ Return only the new prompt list object.
                     best_prompt=best_prompt_overall,
                     best_score=best_primary_score_overall,
                     improvement=(best_primary_score_overall - initial_primary_score) / abs(initial_primary_score) if initial_primary_score and initial_primary_score != 0 else (1.0 if best_primary_score_overall > 0 else 0.0)
-                ).dict()
+                ).model_dump()
                 self._add_to_history(gen_round_data)
 
         stopped_early_flag = self._generations_without_overall_improvement >= self.DEFAULT_EARLY_STOPPING_GENERATIONS
@@ -1101,6 +1115,7 @@ Return only the new prompt list object.
         # Add final details
         final_details.update({
             "total_generations_run": generation_idx + 1,
+            "num_generations": self.num_generations,
             "population_size": self.population_size,
             "mutation_probability": self.mutation_rate,
             "crossover_probability": self.crossover_rate,
@@ -1132,7 +1147,9 @@ Return only the new prompt list object.
         return OptimizationResult(
             optimizer=self.__class__.__name__,
             prompt=final_best_prompt.formatted_messages, 
-            score=final_primary_score, 
+            score=final_primary_score,
+            initial_prompt=prompt.formatted_messages,
+            initial_score=initial_primary_score,
             metric_name=metric.__name__,
             details=final_details,
             history=self.get_history(),
@@ -1186,6 +1203,7 @@ Return only the new prompt list object.
             response = litellm.completion(
                 model=self.model, messages=messages, **final_call_params
             )
+            self.llm_call_counter += 1
 
             logger.debug(f"Response: {response}")
             return response.choices[0].message.content

opik_optimizer/evolutionary_optimizer/reporting.py

@@ -2,8 +2,6 @@ from contextlib import contextmanager
 from io import StringIO
 from typing import List
 
-import rich
-from rich.console import Console
 from rich.panel import Panel
 from rich.text import Text
 

opik_optimizer/few_shot_bayesian_optimizer/few_shot_bayesian_optimizer.py

@@ -1,3 +1,4 @@
+import copy
 import json
 import logging
 import random
@@ -194,6 +195,7 @@ class FewShotBayesianOptimizer(base_optimizer.BaseOptimizer):
 
     def _run_optimization(
         self,
+        initial_prompt: chat_prompt.ChatPrompt,
         fewshot_prompt_template: FewShotPromptTemplate,
         dataset: Dataset,
         metric: Callable,
@@ -249,13 +251,14 @@ class FewShotBayesianOptimizer(base_optimizer.BaseOptimizer):
                 for key, value in example.items():
                     processed_example[key] = str(value)
 
-                try:
-                    processed_demo_examples.append(
-                        fewshot_prompt_template.example_template.format(**processed_example)
-                    )
-                except Exception:
-                    logger.error(f"Failed to format fewshot prompt template {fewshot_prompt_template} with example: {processed_example} ")
-                    raise
+                processed_demo_example=fewshot_prompt_template.example_template
+                for key, value in processed_example.items():
+                    try:
+                        processed_demo_example=processed_demo_example.replace(f"{{{key}}}", str(value))
+                    except Exception:
+                        logger.error(f"Failed to format fewshot prompt template {fewshot_prompt_template} with example: {processed_example} ")
+                        raise
+                processed_demo_examples.append(processed_demo_example)
             few_shot_examples = "\n\n".join(processed_demo_examples)
             
             llm_task = self._build_task_from_messages(
@@ -364,6 +367,12 @@ class FewShotBayesianOptimizer(base_optimizer.BaseOptimizer):
         best_score = best_trial.value
         best_example_indices = best_trial.user_attrs.get("example_indices", [])
 
+        if best_score <= baseline_score:
+            best_score = baseline_score
+            best_prompt = initial_prompt.formatted_messages
+        else:
+            best_prompt = best_trial.user_attrs["config"]["message_list"]
+
         reporting.display_result(
             initial_score=baseline_score,
             best_score=best_score,
@@ -374,9 +383,12 @@ class FewShotBayesianOptimizer(base_optimizer.BaseOptimizer):
         return optimization_result.OptimizationResult(
             optimizer=self.__class__.__name__,
             prompt=best_trial.user_attrs["config"]["message_list"],
+            initial_prompt=initial_prompt.formatted_messages,
+            initial_score=baseline_score,
             score=best_score,
             metric_name=metric.__name__,
             details={
+                "initial_score": baseline_score,
                 "chat_messages": best_trial.user_attrs["config"]["message_list"],
                 "prompt_parameter": best_trial.user_attrs["config"],
                 #"n_examples": best_n_examples,
@@ -414,6 +426,16 @@ class FewShotBayesianOptimizer(base_optimizer.BaseOptimizer):
         Returns:
             OptimizationResult: Result of the optimization
         """
+        if not isinstance(prompt, chat_prompt.ChatPrompt):
+            raise ValueError("Prompt must be a ChatPrompt object")
+        
+        if not isinstance(dataset, Dataset):
+            raise ValueError("Dataset must be a Dataset object")
+        
+        if not isinstance(metric, Callable):
+            raise ValueError("Metric must be a function that takes `dataset_item` and `llm_output` as arguments.")
+
+
         optimization = None
         try:
             optimization = self._opik_client.create_optimization(
@@ -421,15 +443,22 @@ class FewShotBayesianOptimizer(base_optimizer.BaseOptimizer):
                 objective_name=metric.__name__,
                 metadata={"optimizer": self.__class__.__name__},
             )
+            optimization_run_id = optimization.id
         except Exception:
             logger.warning(
                 "Opik server does not support optimizations. Please upgrade opik."
             )
             optimization = None
+            optimization_run_id = None
 
         try:
             # Start experiment reporting
-            reporting.display_header("Few-Shot Bayesian Optimizer", verbose=self.verbose)
+            reporting.display_header(
+                algorithm=self.__class__.__name__,
+                optimization_id=optimization_run_id,
+                dataset_id=dataset.id,
+                verbose=self.verbose
+            )
             reporting.display_configuration(
                 prompt.formatted_messages,
                 optimizer_config={
@@ -468,6 +497,7 @@ class FewShotBayesianOptimizer(base_optimizer.BaseOptimizer):
 
             # Step 3. Start the optimization process
             result = self._run_optimization(
+                initial_prompt=prompt,
                 fewshot_prompt_template=fewshot_template,
                 dataset=dataset,
                 metric=metric,
@@ -563,18 +593,15 @@ class FewShotBayesianOptimizer(base_optimizer.BaseOptimizer):
         self, messages: List[Dict[str, str]], few_shot_examples: Optional[str] = None
     ):
         def llm_task(dataset_item: Dict[str, Any]) -> Dict[str, Any]:
+            prompt_ = copy.deepcopy(messages)
             for key, value in dataset_item.items():
-                prompt_ = [{
-                    "role": item["role"],
-                    "content": item["content"].replace("{" + key + "}", str(value))
-                } for item in messages]
+                for item in prompt_:
+                    item["content"] = item["content"].replace("{" + key + "}", str(value))
 
             if few_shot_examples:
-                prompt_ = [{
-                    "role": item["role"],
-                    "content": item["content"].replace(FEW_SHOT_EXAMPLE_PLACEHOLDER, few_shot_examples)
-                } for item in prompt_]
-                
+                for item in prompt_:
+                    item["content"] = item["content"].replace(FEW_SHOT_EXAMPLE_PLACEHOLDER, few_shot_examples)
+            
             response = self._call_model(
                 model=self.model,
                 messages=prompt_,

opik_optimizer/meta_prompt_optimizer/meta_prompt_optimizer.py

@@ -1,4 +1,5 @@
 import json
+import copy
 import logging
 import os
 from typing import Any, Callable, Dict, List, Optional, overload
@@ -255,7 +256,7 @@ class MetaPromptOptimizer(BaseOptimizer):
             **experiment_config,
             **{
                 "optimizer": self.__class__.__name__,
-                "metric": metric.__name__,
+                "metric": getattr(metric, '__name__', str(metric)),
                 "dataset": dataset.name,
                 "configuration": {
                     "prompt": prompt.formatted_messages,
@@ -300,7 +301,7 @@ class MetaPromptOptimizer(BaseOptimizer):
 
         # Use dataset's get_items with limit for sampling
         logger.debug(
-            f"Starting evaluation with {subset_size if subset_size else 'all'} samples for metric: {metric.__name__}"
+            f"Starting evaluation with {subset_size if subset_size else 'all'} samples for metric: {getattr(metric, '__name__', str(metric))}"
         )
         score = task_evaluator.evaluate(
             dataset=dataset,
@@ -341,8 +342,15 @@ class MetaPromptOptimizer(BaseOptimizer):
         Returns:
             OptimizationResult: Structured result containing optimization details
         """
-        reporting.display_header(self.__class__.__name__, verbose=self.verbose)
+        if not isinstance(prompt, chat_prompt.ChatPrompt):
+            raise ValueError("Prompt must be a ChatPrompt object")
         
+        if not isinstance(dataset, Dataset):
+            raise ValueError("Dataset must be a Dataset object")
+        
+        if not isinstance(metric, Callable):
+            raise ValueError("Metric must be a function that takes `dataset_item` and `llm_output` as arguments.")
+
         total_items = len(dataset.get_items())
         if n_samples is not None and n_samples > total_items:
             logger.warning(
@@ -350,21 +358,12 @@ class MetaPromptOptimizer(BaseOptimizer):
             )
             n_samples = None
 
-        reporting.display_configuration(
-            messages=prompt.formatted_messages,
-            optimizer_config={
-                "optimizer": self.__class__.__name__,
-                "n_samples": n_samples,
-                "auto_continue": auto_continue
-            },
-            verbose=self.verbose
-        )
-
+        
         optimization = None
         try:
             optimization = self._opik_client.create_optimization(
                 dataset_name=dataset.name,
-                objective_name=metric.__name__,
+                objective_name=getattr(metric, '__name__', str(metric)),
                 metadata={"optimizer": self.__class__.__name__},
             )
             logger.debug(f"Created optimization with ID: {optimization.id}")
@@ -374,6 +373,22 @@ class MetaPromptOptimizer(BaseOptimizer):
             )
             optimization = None
 
+        reporting.display_header(
+            algorithm=self.__class__.__name__,
+            optimization_id=optimization.id if optimization is not None else None,
+            dataset_id=dataset.id,
+            verbose=self.verbose
+        )
+        reporting.display_configuration(
+            messages=prompt.formatted_messages,
+            optimizer_config={
+                "optimizer": self.__class__.__name__,
+                "n_samples": n_samples,
+                "auto_continue": auto_continue
+            },
+            verbose=self.verbose
+        )
+
         try:
             result = self._optimize_prompt(
                 optimization_id=optimization.id if optimization is not None else None,
@@ -411,6 +426,7 @@ class MetaPromptOptimizer(BaseOptimizer):
         self.dataset = dataset
         self.prompt = prompt
         self.llm_call_counter = 0 # Reset counter for run
+        initial_prompt: List[Dict[str, str]] = prompt.formatted_messages
 
         current_prompt = prompt.formatted_messages
         experiment_config = experiment_config or {}
@@ -418,7 +434,7 @@ class MetaPromptOptimizer(BaseOptimizer):
             **experiment_config,
             **{
                 "optimizer": self.__class__.__name__,
-                "metric": metric.__name__,
+                "metric": getattr(metric, '__name__', str(metric)),
                 "dataset": self.dataset.name,
                 "configuration": {
                     "prompt": current_prompt,
@@ -527,11 +543,11 @@ class MetaPromptOptimizer(BaseOptimizer):
 
         return self._create_result(
             metric,
-            prompt,
-            best_prompt,
-            best_score,
-            initial_score,
-            rounds,
+            initial_prompt=initial_prompt,
+            best_prompt=best_prompt,
+            best_score=best_score,
+            initial_score=initial_score,
+            rounds=rounds,
         )
 
     def _calculate_improvement(
@@ -581,21 +597,19 @@ class MetaPromptOptimizer(BaseOptimizer):
     def _create_result(
         self,
         metric: Callable,
-        prompt: chat_prompt.ChatPrompt,
-        best_prompt: str,
+        initial_prompt: List[Dict[str, str]],
+        best_prompt: List[Dict[str, str]],
         best_score: float,
         initial_score: float,
         rounds: List[OptimizationRound],
     ) -> OptimizationResult:
         """Create the final OptimizationResult object."""
         details = {
-            "initial_prompt": prompt,
-            "initial_score": initial_score,
             "final_prompt": best_prompt,
             "final_score": best_score,
             "rounds": rounds,
             "total_rounds": len(rounds),
-            "metric_name": metric.__name__,
+            "metric_name": getattr(metric, '__name__', str(metric)),
             "model": self.model,
             "temperature": self.model_kwargs.get("temperature"),
         }
@@ -604,7 +618,9 @@ class MetaPromptOptimizer(BaseOptimizer):
             optimizer=self.__class__.__name__,
             prompt=best_prompt,
             score=best_score,
-            metric_name=metric.__name__,
+            initial_prompt=initial_prompt,
+            initial_score=initial_score,
+            metric_name=getattr(metric, '__name__', str(metric)),
             details=details,
             llm_calls=self.llm_call_counter
         )

opik_optimizer/meta_prompt_optimizer/reporting.py

@@ -1,6 +1,5 @@
 from contextlib import contextmanager
 
-import rich
 from rich.text import Text
 
 from ..reporting_utils import (

opik_optimizer/mipro_optimizer/_lm.py

@@ -82,6 +82,7 @@ class LM(BaseLM):
         self.finetuning_model = finetuning_model
         self.launch_kwargs = launch_kwargs or {}
         self.train_kwargs = train_kwargs or {}
+        self.llm_call_counter = 0
 
         # Handle model-specific configuration for different model families
         model_family = model.split("/")[-1].lower() if "/" in model else model.lower()
@@ -129,6 +130,7 @@ class LM(BaseLM):
         if not getattr(results, "cache_hit", False) and dspy.settings.usage_tracker and hasattr(results, "usage"):
             settings.usage_tracker.add_usage(self.model, dict(results.usage))
 
+        self.llm_call_counter += 1
         return results
 
     def launch(self, launch_kwargs: Optional[Dict[str, Any]] = None):
@@ -323,6 +325,7 @@ def litellm_completion(request: Dict[str, Any], num_retries: int, cache={"no-cac
             **retry_kwargs,
             **request,
         )
+
         chunks = []
         async for chunk in response:
             if caller_predict_id:

opik_optimizer/mipro_optimizer/mipro_optimizer.py

@@ -42,11 +42,10 @@ class MiproOptimizer(BaseOptimizer):
         self.tools = []
         self.num_threads = self.model_kwargs.pop("num_threads", 6)
         self.model_kwargs["model"] = self.model
-        self.llm_call_counter = 0
         # FIXME: add mipro_optimizer=True - It does not count the LLM calls made internally by DSPy during MiproOptimizer.optimizer.compile().
-        lm = LM(**self.model_kwargs)
+        self.lm = LM(**self.model_kwargs)
         opik_callback = OpikCallback(project_name=self.project_name, log_graph=True)
-        dspy.configure(lm=lm, callbacks=[opik_callback])
+        dspy.configure(lm=self.lm, callbacks=[opik_callback])
         logger.debug(f"Initialized MiproOptimizer with model: {model}")
 
     def evaluate_prompt(
@@ -54,7 +53,7 @@ class MiproOptimizer(BaseOptimizer):
         dataset: Union[str, Dataset],
         metric: Callable,
         task_config: TaskConfig,
-        prompt: Union[str, dspy.Module, OptimizationResult] = None,
+        prompt: Optional[Union[str, dspy.Module, OptimizationResult]] = None,
         n_samples: int = 10,
         dataset_item_ids: Optional[List[str]] = None,
         experiment_config: Optional[Dict] = None,
@@ -463,7 +462,7 @@ class MiproOptimizer(BaseOptimizer):
                 metric_name=self.opik_metric.__name__ if hasattr(self, 'opik_metric') else "unknown_metric",
                 details={"error": "No candidate programs generated by MIPRO"},
                 history=mipro_history_processed,
-                llm_calls=self.llm_call_counter
+                llm_calls=self.lm.llm_call_counter
             )
 
         self.module = self.get_best().details["program"]
@@ -488,7 +487,7 @@ class MiproOptimizer(BaseOptimizer):
             demonstrations=best_program_details.demonstrations,
             details=best_program_details.details,
             history=mipro_history_processed,
-            llm_calls=self.llm_call_counter
+            llm_calls=self.lm.llm_call_counter
         )
 
     def get_best(self, position: int = 0) -> OptimizationResult:
@@ -501,7 +500,7 @@ class MiproOptimizer(BaseOptimizer):
                 metric_name=getattr(self, 'opik_metric', None).name if hasattr(self, 'opik_metric') and self.opik_metric else "unknown_metric",
                 details={"error": "No programs generated or compile failed"},
                 history=[],
-                llm_calls=self.llm_call_counter
+                llm_calls=self.lm.llm_call_counter
             )
             
         score = self.best_programs[position]["score"]
@@ -528,5 +527,5 @@ class MiproOptimizer(BaseOptimizer):
             metric_name=self.opik_metric.__name__,
             demonstrations=demos,
             details={"program": program_module},
-            llm_calls=self.llm_call_counter
+            llm_calls=self.lm.llm_call_counter
         )

opik_optimizer/optimization_result.py

@@ -17,6 +17,10 @@ class OptimizationResult(pydantic.BaseModel):
     score: float
     metric_name: str
     
+    # Initial score
+    initial_prompt: Optional[List[Dict[Literal["role", "content"], str]]] = None
+    initial_score: Optional[float] = None
+    
     details: Dict[str, Any] = pydantic.Field(default_factory=dict)
     history: List[Dict[str, Any]] = []
     llm_calls: Optional[int] = None
@@ -33,7 +37,7 @@ class OptimizationResult(pydantic.BaseModel):
 
     def _calculate_improvement_str(self) -> str:
         """Helper to calculate improvement percentage string."""
-        initial_s = self.details.get("initial_score")
+        initial_s = self.initial_score
         final_s = self.score
 
         # Check if initial score exists and is a number
@@ -60,7 +64,7 @@ class OptimizationResult(pydantic.BaseModel):
         """Provides a clean, well-formatted plain-text summary."""
         separator = "=" * 80
         rounds_ran = len(self.details.get("rounds", []))
-        initial_score = self.details.get("initial_score")
+        initial_score = self.initial_score
         initial_score_str = (
             f"{initial_score:.4f}" if isinstance(initial_score, (int, float)) else "N/A"
         )
@@ -74,7 +78,6 @@ class OptimizationResult(pydantic.BaseModel):
             .replace("[dim]", "")
             .replace("[/dim]", "")
         )
-        stopped_early = self.details.get("stopped_early", "N/A")
 
         model_name = self.details.get("model", "N/A")
         temp = self.details.get("temperature")
@@ -101,7 +104,6 @@ class OptimizationResult(pydantic.BaseModel):
             f"Final Best Score: {final_score_str}",
             f"Total Improvement:{improvement_str.rjust(max(0, 18 - len('Total Improvement:')))}",
             f"Rounds Completed: {rounds_ran}",
-            f"Stopped Early:    {stopped_early}",
             "\nFINAL OPTIMIZED PROMPT / STRUCTURE:",
             "--------------------------------------------------------------------------------",
             f"{final_prompt_display}",
@@ -114,7 +116,7 @@ class OptimizationResult(pydantic.BaseModel):
         """Provides a rich, formatted output for terminals supporting Rich."""
         improvement_str = self._calculate_improvement_str()
         rounds_ran = len(self.details.get("rounds", []))
-        initial_score = self.details.get("initial_score")
+        initial_score = self.initial_score
         initial_score_str = (
             f"{initial_score:.4f}"
             if isinstance(initial_score, (int, float))
@@ -124,8 +126,6 @@ class OptimizationResult(pydantic.BaseModel):
         stopped_early = self.details.get("stopped_early", "N/A")
 
         model_name = self.details.get("model", "[dim]N/A[/dim]")
-        temp = self.details.get("temperature")
-        temp_str = f"{temp:.1f}" if isinstance(temp, (int, float)) else "[dim]N/A[/dim]"
 
         table = rich.table.Table.grid(padding=(0, 1))
         table.add_column(style="dim")
@@ -135,13 +135,12 @@ class OptimizationResult(pydantic.BaseModel):
             "Optimizer:",
             f"[bold]{self.optimizer}[/bold]",
         )
-        table.add_row("Model Used:", f"{model_name} ([dim]Temp:[/dim] {temp_str})")
+        table.add_row("Model Used:", f"{model_name}")
         table.add_row("Metric Evaluated:", f"[bold]{self.metric_name}[/bold]")
         table.add_row("Initial Score:", initial_score_str)
         table.add_row("Final Best Score:", f"[bold cyan]{final_score_str}[/bold cyan]")
         table.add_row("Total Improvement:", improvement_str)
         table.add_row("Rounds Completed:", str(rounds_ran))
-        table.add_row("Stopped Early:", str(stopped_early))
 
         # Display Chat Structure if available
         panel_title = "[bold]Final Optimized Prompt[/bold]"

opik_optimizer/reporting_utils.py

@@ -2,13 +2,14 @@ import logging
 from contextlib import contextmanager
 from typing import Dict, List, Optional
 
-import rich
 from rich import box
 from rich.console import Console, Group
 from rich.panel import Panel
 from rich.progress import track
 from rich.text import Text
 
+from .utils import get_optimization_run_url_by_id
+
 PANEL_WIDTH = 70
 
 def get_console(*args, **kwargs):
@@ -21,10 +22,8 @@ def convert_tqdm_to_rich(description: Optional[str] = None, verbose: int = 1):
     """Context manager to convert tqdm to rich."""
     import opik.evaluation.engine.evaluation_tasks_executor
     
-    optimizer_logger = logging.getLogger('opik_optimizer')
-
     def _tqdm_to_track(iterable, desc, disable, total):
-        disable = verbose == 0 or optimizer_logger.level > logging.INFO
+        disable = verbose == 0
         return track(
             iterable,
             description=description or desc,
@@ -91,16 +90,36 @@ def display_messages(messages: List[Dict[str, str]], prefix: str = ""):
         for line in rendered_panel.splitlines():
             console.print(Text(prefix) + Text.from_ansi(line))
 
-def display_header(algorithm: str, verbose: int = 1):
+def display_header(
+    algorithm: str,
+    optimization_id: Optional[str]=None,
+    dataset_id: Optional[str]=None,
+    verbose: int = 1
+):
     if verbose < 1:
         return
 
+    if optimization_id is not None and dataset_id is not None:    
+        optimization_url = get_optimization_run_url_by_id(
+            optimization_id=optimization_id,
+            dataset_id=dataset_id
+        )
+        
+        # Create a visually appealing panel with an icon and ensure link doesn't wrap
+        
+        link_text = Text("-> View optimization details in your Opik dashboard")
+        link_text.stylize(f"link {optimization_url}", 28, len(link_text))
+    else:
+        link_text = Text("No optimization run link available", style="dim")
+
     content = Text.assemble(
         ("● ", "green"),  
         "Running Opik Evaluation - ",
-        (algorithm, "blue")
-    )
+        (algorithm, "blue"),
+        "\n\n"
+    ).append(link_text)
 
+    
     panel = Panel(
         content,
         box=box.ROUNDED,
@@ -126,7 +145,7 @@ def display_result(initial_score, best_score, best_prompt, verbose: int = 1):
             perc_change = (best_score - initial_score) / initial_score
             content = [Text(f"Prompt was optimized and improved from {initial_score:.4f} to {best_score:.4f} ({perc_change:.2%})", style="bold green")]
     else:
-        content = [Text("Optimization trial did not find a better prompt than the initial one.", style="bold red")]
+        content = [Text(f"Optimization run did not find a better prompt than the initial one.\nScore: {best_score:.4f}", style="dim bold red")]
     
     content.append(Text("\nOptimized prompt:"))
     for i, msg in enumerate(best_prompt):

opik_optimizer/utils.py

@@ -1,23 +1,17 @@
 """Utility functions and constants for the optimizer package."""
 
-from typing import Dict, Any, Optional, TYPE_CHECKING, Type, Literal, Final
-from types import TracebackType
-
-import opik
-from opik.api_objects.opik_client import Opik
-from opik.api_objects.optimization import Optimization
-
+import base64
 import json
 import logging
 import random
 import string
-import base64
 import urllib.parse
-from rich import console
+from types import TracebackType
+from typing import Any, Dict, Final, Literal, Optional, Type
 
-# Type hint for OptimizationResult without circular import
-if TYPE_CHECKING:
-    from .optimization_result import OptimizationResult
+import opik
+from opik.api_objects.opik_client import Opik
+from opik.api_objects.optimization import Optimization
 
 ALLOWED_URL_CHARACTERS: Final[str] = ":/&?="
 logger = logging.getLogger(__name__)
@@ -63,6 +57,7 @@ class OptimizationContextManager:
                 name=self.name,
                 metadata=self.metadata,
             )
+            
             if self.optimization:
                 return self.optimization
             else:
@@ -238,8 +233,10 @@ def ensure_ending_slash(url: str) -> str:
 
 
 def get_optimization_run_url_by_id(
-    dataset_id: str, optimization_id: str, url_override: str
+    dataset_id: str, optimization_id: str
 ) -> str:
+    opik_config = opik.config.get_from_user_inputs()
+    url_override = opik_config.url_override
     encoded_opik_url = base64.b64encode(url_override.encode("utf-8")).decode("utf-8")
 
     run_path = urllib.parse.quote(
@@ -247,18 +244,3 @@ def get_optimization_run_url_by_id(
         safe=ALLOWED_URL_CHARACTERS,
     )
     return urllib.parse.urljoin(ensure_ending_slash(url_override), run_path)
-
-
-def display_optimization_run_link(
-    optimization_id: str, dataset_id: str, url_override: str
-) -> None:
-    console_container = console.Console()
-
-    optimization_url = get_optimization_run_url_by_id(
-        optimization_id=optimization_id,
-        dataset_id=dataset_id,
-        url_override=url_override,
-    )
-    console_container.print(
-        f"View the optimization run [link={optimization_url}]in your Opik dashboard[/link]."
-    )

{opik_optimizer-0.9.1.dist-info → opik_optimizer-0.9.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opik_optimizer
-Version: 0.9.1
+Version: 0.9.2
 Summary: Agent optimization with Opik
 Home-page: https://github.com/comet-ml/opik
 Author: Comet ML

{opik_optimizer-0.9.1.dist-info → opik_optimizer-0.9.2.dist-info}/RECORD

@@ -3,10 +3,10 @@ opik_optimizer/_throttle.py,sha256=ztub8qlwz4u0GVA2TIoLig0D1Cs0hJ7_o_SnT_C7Nmk,1
 opik_optimizer/base_optimizer.py,sha256=mg5D5m2hIzq3XbVjRhx8c_HuXWZWaRE2J6QtkHnxkqE,4439
 opik_optimizer/cache_config.py,sha256=EzF4RAzxhSG8vtMJANdiUpNHQ9HzL2CrCXp0iik0f4A,580
 opik_optimizer/logging_config.py,sha256=XECPnSoh8ghbllv1F0vj6ofO8YmE2HL0coLWjLdaNTU,2780
-opik_optimizer/optimization_result.py,sha256=PeDIoNIHaJsi9WsDoKPgO6sW3CkPKZKK7RvY8tmjUN0,7508
-opik_optimizer/reporting_utils.py,sha256=pRcRhE9w1q6PVdTmqrTyqIlUmeMAknwJJFT99FG0tuk,5523
+opik_optimizer/optimization_result.py,sha256=p_vHW5NtdeJHJ9KpmbM8JMd3CqG_wd02XzClRL7mMgs,7270
+opik_optimizer/reporting_utils.py,sha256=dL1u8Wpo7S9H480FxDENsxFe301PdTqHcXbFNqqXdik,6175
 opik_optimizer/task_evaluator.py,sha256=212shzapI7GtrqrFvn_6wkvWR5_Zhm30CR5t-tW0bV8,4380
-opik_optimizer/utils.py,sha256=y7I58vESRphuMLA4cfH3sNiSuntyiqG8hwK5UuwVdt4,8239
+opik_optimizer/utils.py,sha256=mf-773TJH5Cm6cQXcsntEOQ-6WEaYUaILIonuaEErmo,7707
 opik_optimizer/data/hotpot-500.json,sha256=YXxCtuvYvxSu5u0y4559a6b1qwgAYsWzT_SUKv_21ew,76862
 opik_optimizer/datasets/__init__.py,sha256=V4LVDOaRjwzaYvhdQ3V6CAwFaeKnxyTV1lp_ES9Z31E,691
 opik_optimizer/datasets/ai2_arc.py,sha256=PMWInWVRPQ9u_nlr9N531CeVKjI6y_ZSQmNY2t1zwOI,1401
@@ -24,25 +24,25 @@ opik_optimizer/demo/__init__.py,sha256=KSpFYhzN7fTmLEsIaciRHwxcJDeAiX5NDmYLdPsfp
 opik_optimizer/demo/cache.py,sha256=5WqK8rSiijzU6s4VHIjLuL1LR5i1yHtY-x5FZTduSus,3669
 opik_optimizer/demo/datasets.py,sha256=MezQlG4Q_cgSH7zQOmJcDwkGU8JV0xKSnZwCJGaj-88,2494
 opik_optimizer/evolutionary_optimizer/__init__.py,sha256=OQ2ART5g-7EVGOISvTGY-AbmEyyDFEJJCsmJBzGJIpw,57
-opik_optimizer/evolutionary_optimizer/evolutionary_optimizer.py,sha256=cnpga8ytSjx5lNq2URLBCyV9s5r1s9_eKD4BU7rWW_g,76259
-opik_optimizer/evolutionary_optimizer/reporting.py,sha256=Gl52sH7XaU4GXUhFt_FcfjYFN3MghnDt1ISULATjbP4,9944
+opik_optimizer/evolutionary_optimizer/evolutionary_optimizer.py,sha256=tZLID_N4auZ7v7MWZesr9xbzRMudznAUQ8Q9XzhbqRY,76948
+opik_optimizer/evolutionary_optimizer/reporting.py,sha256=w5fWIA9F30a25E5BpPxKLubNitcXmU5KzeBdS86Ajao,9899
 opik_optimizer/few_shot_bayesian_optimizer/__init__.py,sha256=VuH7FOROyGcjMPryejtZC-5Y0QHlVTFLTGUDgNqRAFw,113
-opik_optimizer/few_shot_bayesian_optimizer/few_shot_bayesian_optimizer.py,sha256=trQ7lAdPyNpMrCwdQeq67FCosQuoN3uvLM6lXoJPkQQ,24457
+opik_optimizer/few_shot_bayesian_optimizer/few_shot_bayesian_optimizer.py,sha256=PwpfrZCauun0zwne4Kj1l3V9KQjX5phoz61FFZN9MHk,25660
 opik_optimizer/few_shot_bayesian_optimizer/reporting.py,sha256=j1mNEQyFT7YUVlMU1TxPZxrf5sPwiHZ2nx1fOL4ZIog,4756
 opik_optimizer/meta_prompt_optimizer/__init__.py,sha256=syiN2_fMm5iZDQezZCHYe-ZiGOIPlBkLt49Sa1kuR70,97
-opik_optimizer/meta_prompt_optimizer/meta_prompt_optimizer.py,sha256=LrN8kGoB-qm5Tvncpmcy2qd79vxkcMokei2sMXrv0jw,34404
-opik_optimizer/meta_prompt_optimizer/reporting.py,sha256=4Lju2uxSBkCVYyJ6ZSS-GjDFVnmP14R6XVtr-tEFlL0,5765
+opik_optimizer/meta_prompt_optimizer/meta_prompt_optimizer.py,sha256=X5HaT1enrwp_oYK1vuBhaDLBW7A3apP4mlElr0SDQhY,35308
+opik_optimizer/meta_prompt_optimizer/reporting.py,sha256=IXV1R3T4cdVOJBTEgACQEp5zhrRcDg0DWuebexcfN60,5753
 opik_optimizer/mipro_optimizer/__init__.py,sha256=23dqXp1lG00ZiMZvU75FzzLmzaHe_-5krchwdvMhWzE,53
-opik_optimizer/mipro_optimizer/_lm.py,sha256=bcTy2Y5HjSaFQOATIpUaA86eIp3vKHaMuDI2_RvN2ww,16376
+opik_optimizer/mipro_optimizer/_lm.py,sha256=hqSdGR0DsuiXAjxfiIFAdFxeG5cfcMtRc7jzXa74fKM,16446
 opik_optimizer/mipro_optimizer/_mipro_optimizer_v2.py,sha256=wQP3D5g3X2e0h05vJy_CvW0qDMdGqLYmuUVzdndcScE,39258
-opik_optimizer/mipro_optimizer/mipro_optimizer.py,sha256=pfD8toZVCpqSDdGwyOUvAeyORyGyYqrua71JFzVw2GA,23305
+opik_optimizer/mipro_optimizer/mipro_optimizer.py,sha256=lQcElTUwkJKKiF6eRuxcRKETq6_TvyuGXLJGw6mIIS4,23303
 opik_optimizer/mipro_optimizer/utils.py,sha256=-d9xOKxmYbKwpNM2aheKQVf3gxCh5B1ENuAvzc38xe8,2509
 opik_optimizer/optimization_config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 opik_optimizer/optimization_config/chat_prompt.py,sha256=nGSElB4CyOegYi06oFmaVeFKI6XRv6LJOWJ1axhjyyY,3500
 opik_optimizer/optimization_config/configs.py,sha256=HzpEP84bnqtDs76dtmPGecDQ-Ux2wIk0JVv7A2gsE3k,496
 opik_optimizer/optimization_config/mappers.py,sha256=RMUWwYvXNCJe6w1jYiT6EX218UYZS1PUMMe12OjNEug,1692
-opik_optimizer-0.9.1.dist-info/licenses/LICENSE,sha256=dTRSwwCHdWeSjzodvnivYqcwi8x3Qfr21yv65QUWWBE,1062
-opik_optimizer-0.9.1.dist-info/METADATA,sha256=XodSnPMwsIwJ2WF618unt3iXHoCbYfokqEM7xnN9vW4,6588
-opik_optimizer-0.9.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-opik_optimizer-0.9.1.dist-info/top_level.txt,sha256=ondOlpq6_yFckqpxoAHSfzZS2N-JfgmA-QQhOJfz7m0,15
-opik_optimizer-0.9.1.dist-info/RECORD,,
+opik_optimizer-0.9.2.dist-info/licenses/LICENSE,sha256=dTRSwwCHdWeSjzodvnivYqcwi8x3Qfr21yv65QUWWBE,1062
+opik_optimizer-0.9.2.dist-info/METADATA,sha256=e2QQWNkEFwPqHKGAnfBGrR-pQhhR-vOBrrtHaszA3lk,6588
+opik_optimizer-0.9.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+opik_optimizer-0.9.2.dist-info/top_level.txt,sha256=ondOlpq6_yFckqpxoAHSfzZS2N-JfgmA-QQhOJfz7m0,15
+opik_optimizer-0.9.2.dist-info/RECORD,,