opik-optimizer 2.2.0__py3-none-any.whl → 2.2.1__py3-none-any.whl

opik_optimizer/base_optimizer.py

@@ -637,7 +637,7 @@ class BaseOptimizer(ABC):
             base_config = self._deep_merge_dicts(base_config, additional_metadata)
 
         if experiment_config:
-            base_config = self._deep_merge_dicts(experiment_config, base_config)
+            base_config = self._deep_merge_dicts(base_config, experiment_config)
 
         return self._drop_none(base_config)
 

opik_optimizer/gepa_optimizer/gepa_optimizer.py

@@ -1,10 +1,10 @@
 import logging
-from contextlib import nullcontext
-from typing import Any, ContextManager
+from typing import Any
 from collections.abc import Callable
 
 import opik
 from opik import Dataset, opik_context
+from opik.evaluation import evaluator as opik_evaluator
 from opik.evaluation.metrics.score_result import ScoreResult
 
 from ..base_optimizer import BaseOptimizer
@@ -16,7 +16,9 @@ from ..utils import (
     create_litellm_agent_class,
     disable_experiment_reporting,
     enable_experiment_reporting,
+    unique_ordered_by_key,
 )
+from ..task_evaluator import _create_metric_class
 from ..reporting_utils import suppress_opik_logs
 from .. import task_evaluator
 from . import reporting as gepa_reporting
@@ -213,6 +215,25 @@ class GepaOptimizer(BaseOptimizer):
         # Calculate max_metric_calls from max_trials and effective samples
         effective_n_samples = len(items)
         max_metric_calls = max_trials * effective_n_samples
+        budget_limited_trials = (
+            max_metric_calls // effective_n_samples if effective_n_samples else 0
+        )
+        if reflection_minibatch_size > max_trials:
+            logger.warning(
+                "reflection_minibatch_size (%s) exceeds max_trials (%s); GEPA reflection will not run. "
+                "Increase max_trials or lower the minibatch.",
+                reflection_minibatch_size,
+                max_trials,
+            )
+        elif (
+            budget_limited_trials and reflection_minibatch_size > budget_limited_trials
+        ):
+            logger.warning(
+                "reflection_minibatch_size (%s) exceeds the number of candidates allowed by the metric budget (%s). "
+                "Consider increasing max_trials or n_samples.",
+                reflection_minibatch_size,
+                budget_limited_trials,
+            )
 
         data_insts = self._build_data_insts(items, input_key, output_key)
 
@@ -375,6 +396,23 @@ class GepaOptimizer(BaseOptimizer):
         candidates: list[dict[str, str]] = getattr(gepa_result, "candidates", []) or []
         val_scores: list[float] = list(getattr(gepa_result, "val_aggregate_scores", []))
 
+        indexed_candidates: list[tuple[int, dict[str, str]]] = list(
+            enumerate(candidates)
+        )
+        filtered_indexed_candidates = unique_ordered_by_key(
+            indexed_candidates,
+            key=lambda item: self._extract_system_text_from_candidate(
+                item[1], seed_prompt_text
+            ).strip(),
+        )
+        filtered_candidates: list[dict[str, str]] = [
+            candidate for _, candidate in filtered_indexed_candidates
+        ]
+        filtered_val_scores: list[float | None] = [
+            val_scores[idx] if idx < len(val_scores) else None
+            for idx, _ in filtered_indexed_candidates
+        ]
+
         rescored: list[float] = []
         candidate_rows: list[dict[str, Any]] = []
         history: list[dict[str, Any]] = []
@@ -385,7 +423,9 @@ class GepaOptimizer(BaseOptimizer):
         # Wrap rescoring to prevent OPIK messages and experiment link displays
         with suppress_opik_logs():
             with convert_tqdm_to_rich(verbose=0):
-                for idx, candidate in enumerate(candidates):
+                for idx, (original_idx, candidate) in enumerate(
+                    filtered_indexed_candidates
+                ):
                     candidate_prompt = self._extract_system_text_from_candidate(
                         candidate, seed_prompt_text
                     )
@@ -421,9 +461,7 @@ class GepaOptimizer(BaseOptimizer):
                         {
                             "iteration": idx + 1,
                             "system_prompt": candidate_prompt,
-                            "gepa_score": val_scores[idx]
-                            if idx < len(val_scores)
-                            else None,
+                            "gepa_score": filtered_val_scores[idx],
                             "opik_score": score,
                             "source": self.__class__.__name__,
                         }
@@ -435,9 +473,7 @@ class GepaOptimizer(BaseOptimizer):
                             "scores": [
                                 {
                                     "metric_name": f"GEPA-{metric.__name__}",
-                                    "score": val_scores[idx]
-                                    if idx < len(val_scores)
-                                    else None,
+                                    "score": filtered_val_scores[idx],
                                 },
                                 {"metric_name": metric.__name__, "score": score},
                             ],
@@ -446,14 +482,45 @@ class GepaOptimizer(BaseOptimizer):
                     )
 
         if rescored:
-            best_idx = max(range(len(rescored)), key=lambda i: rescored[i])
+
+            def _tie_break(idx: int) -> tuple[float, float, int]:
+                opik_score = rescored[idx]
+                gepa_score = filtered_val_scores[idx]
+                gepa_numeric = (
+                    float(gepa_score)
+                    if isinstance(gepa_score, (int, float))
+                    else float("-inf")
+                )
+                return opik_score, gepa_numeric, idx
+
+            best_idx = max(range(len(rescored)), key=_tie_break)
             best_score = rescored[best_idx]
         else:
-            best_idx = getattr(gepa_result, "best_idx", 0) or 0
-            best_score = float(val_scores[best_idx]) if val_scores else 0.0
+            if filtered_indexed_candidates:
+                gepa_best_idx = getattr(gepa_result, "best_idx", 0) or 0
+                best_idx = next(
+                    (
+                        i
+                        for i, (original_idx, _) in enumerate(
+                            filtered_indexed_candidates
+                        )
+                        if original_idx == gepa_best_idx
+                    ),
+                    0,
+                )
+                if filtered_val_scores and 0 <= best_idx < len(filtered_val_scores):
+                    score_value = filtered_val_scores[best_idx]
+                    best_score = float(score_value) if score_value is not None else 0.0
+                else:
+                    best_score = float(initial_score)
+            else:
+                best_idx = 0
+                best_score = float(initial_score)
 
         best_candidate = (
-            candidates[best_idx] if candidates else {"system_prompt": seed_prompt_text}
+            filtered_candidates[best_idx]
+            if filtered_candidates
+            else {"system_prompt": seed_prompt_text}
         )
         best_prompt_text = self._extract_system_text_from_candidate(
             best_candidate, seed_prompt_text
@@ -469,26 +536,62 @@ class GepaOptimizer(BaseOptimizer):
         }
         final_prompt.model_kwargs = filtered_model_kwargs
 
-        final_eval_kwargs = dict(
-            prompt=final_prompt,
-            dataset=dataset,
-            metric=metric,
-            n_samples=n_samples,
-            optimization_id=opt_id,
-            extra_metadata={"phase": "final", "selected": True},
-            verbose=0,
-        )
-        suppress_logs: ContextManager[Any] = nullcontext()
-        try:
-            from ..reporting_utils import suppress_opik_logs as _suppress_logs
-
-            suppress_logs = _suppress_logs()
-        except Exception:
-            pass
+        final_eval_result: Any | None = None
 
-        with suppress_logs:
+        with suppress_opik_logs():
             try:
-                self._evaluate_prompt_logged(**final_eval_kwargs)
+                final_agent_cls = create_litellm_agent_class(
+                    final_prompt, optimizer_ref=self
+                )
+                final_agent = final_agent_cls(final_prompt)
+
+                def final_llm_task(dataset_item: dict[str, Any]) -> dict[str, str]:
+                    messages = final_prompt.get_messages(dataset_item)
+                    raw = final_agent.invoke(messages)
+                    if self.current_optimization_id:
+                        opik_context.update_current_trace(
+                            tags=[self.current_optimization_id, "Evaluation"]
+                        )
+                    return {mappers.EVALUATED_LLM_TASK_OUTPUT: raw.strip()}
+
+                configuration_updates = self._drop_none(
+                    {"gepa": {"phase": "final", "selected": True}}
+                )
+                final_experiment_config = self._prepare_experiment_config(
+                    prompt=final_prompt,
+                    dataset=dataset,
+                    metric=metric,
+                    experiment_config=experiment_config,
+                    configuration_updates=configuration_updates,
+                )
+
+                metric_class = _create_metric_class(metric)
+
+                if opt_id:
+                    final_eval_result = opik_evaluator.evaluate_optimization_trial(
+                        optimization_id=opt_id,
+                        dataset=dataset,
+                        task=final_llm_task,
+                        project_name=final_experiment_config.get("project_name"),
+                        dataset_item_ids=None,
+                        scoring_metrics=[metric_class],
+                        task_threads=self.n_threads,
+                        nb_samples=n_samples,
+                        experiment_config=final_experiment_config,
+                        verbose=0,
+                    )
+                else:
+                    final_eval_result = opik_evaluator.evaluate(
+                        dataset=dataset,
+                        task=final_llm_task,
+                        project_name=final_experiment_config.get("project_name"),
+                        dataset_item_ids=None,
+                        scoring_metrics=[metric_class],
+                        task_threads=self.n_threads,
+                        nb_samples=n_samples,
+                        experiment_config=final_experiment_config,
+                        verbose=0,
+                    )
             except Exception:
                 logger.debug("Final evaluation failed", exc_info=True)
 
@@ -518,28 +621,55 @@ class GepaOptimizer(BaseOptimizer):
         except Exception:
             logger.debug("Per-item diagnostics failed", exc_info=True)
 
+        trial_info: dict[str, Any] | None = None
+        if final_eval_result is not None:
+            experiment_name = getattr(final_eval_result, "experiment_name", None)
+            experiment_url = getattr(final_eval_result, "experiment_url", None)
+            trial_ids = []
+            try:
+                trial_ids = sorted(
+                    {
+                        str(test_result.trial_id)
+                        for test_result in getattr(
+                            final_eval_result, "test_results", []
+                        )
+                        if getattr(test_result, "trial_id", None) is not None
+                    }
+                )
+            except Exception:
+                logger.debug("Failed to extract trial IDs", exc_info=True)
+
+            trial_info = {
+                "experiment_name": experiment_name,
+                "experiment_url": experiment_url,
+                "trial_ids": trial_ids,
+            }
+
         details: dict[str, Any] = {
             "model": self.model,
             "temperature": self.model_parameters.get("temperature"),
             "optimizer": self.__class__.__name__,
-            "num_candidates": getattr(gepa_result, "num_candidates", None),
+            "num_candidates": len(filtered_candidates),
             "total_metric_calls": getattr(gepa_result, "total_metric_calls", None),
             "parents": getattr(gepa_result, "parents", None),
-            "val_scores": val_scores,
+            "val_scores": filtered_val_scores,
             "opik_rescored_scores": rescored,
             "candidate_summary": candidate_rows,
             "best_candidate_iteration": (
                 candidate_rows[best_idx]["iteration"] if candidate_rows else 0
             ),
-            "selected_candidate_index": best_idx,
+            "selected_candidate_index": best_idx if filtered_candidates else None,
             "selected_candidate_gepa_score": (
-                val_scores[best_idx] if best_idx < len(val_scores) else None
+                filtered_val_scores[best_idx]
+                if filtered_val_scores and 0 <= best_idx < len(filtered_val_scores)
+                else None
             ),
             "selected_candidate_opik_score": best_score,
             "gepa_live_metric_used": True,
             "gepa_live_metric_call_count": self._gepa_live_metric_calls,
             "selected_candidate_item_scores": per_item_scores,
             "dataset_item_ids": [item.get("id") for item in items],
+            "selected_candidate_trial_info": trial_info,
         }
         if experiment_config:
             details["experiment"] = experiment_config
@@ -551,7 +681,10 @@ class GepaOptimizer(BaseOptimizer):
                 candidate_rows, verbose=self.verbose
             )
             gepa_reporting.display_selected_candidate(
-                best_prompt_text, best_score, verbose=self.verbose
+                best_prompt_text,
+                best_score,
+                verbose=self.verbose,
+                trial_info=trial_info,
             )
 
         if logger.isEnabledFor(logging.DEBUG):

opik_optimizer/gepa_optimizer/reporting.py

@@ -1,3 +1,5 @@
+import json
+from numbers import Number
 from contextlib import contextmanager
 from typing import Any
 
@@ -19,12 +21,70 @@ from ..reporting_utils import (  # noqa: F401
     display_result,
     get_console,
     convert_tqdm_to_rich,
+    format_prompt_snippet,
     suppress_opik_logs,
 )
 
 console = get_console()
 
 
+def _format_pareto_note(note: str) -> str:
+    try:
+        data = json.loads(note)
+    except json.JSONDecodeError:
+        return note
+
+    if isinstance(data, dict):
+        parts: list[str] = []
+        new_scores = data.get("new_scores") or data.get("scores")
+        if isinstance(new_scores, list):
+            formatted_scores = ", ".join(
+                f"{float(score) if isinstance(score, (int, float)) else float(str(score)):.3f}"
+                if isinstance(score, Number)
+                else str(score)
+                for score in new_scores
+            )
+            parts.append(f"scores=[{formatted_scores}]")
+
+        chosen = data.get("chosen")
+        if chosen is not None:
+            parts.append(f"chosen={chosen}")
+
+        train_val = data.get("pareto_front_train_val_score")
+        if isinstance(train_val, dict) and chosen is not None:
+            chosen_entry = train_val.get(str(chosen))
+            if isinstance(chosen_entry, dict):
+                score = chosen_entry.get("score")
+                if isinstance(score, Number):
+                    parts.append(
+                        f"train_val={float(score) if isinstance(score, (int, float)) else float(str(score)):.3f}"
+                    )
+
+        pareto_front = data.get("pareto_front")
+        if isinstance(pareto_front, dict):
+            parts.append(f"front_size={len(pareto_front)}")
+
+        if parts:
+            return ", ".join(parts)
+
+        return note
+
+    elif isinstance(data, list):
+        return ", ".join(
+            f"{float(item) if isinstance(item, (int, float)) else float(str(item)):.3f}"
+            if isinstance(item, Number)
+            else str(item)
+            for item in data
+        )
+
+    elif isinstance(data, Number):
+        return (
+            f"{float(data) if isinstance(data, (int, float)) else float(str(data)):.3f}"
+        )
+
+    return str(data)
+
+
 class RichGEPAOptimizerLogger:
     """Adapter for GEPA's logger that provides concise Rich output with progress tracking."""
 
@@ -58,6 +118,8 @@ class RichGEPAOptimizerLogger:
         self.task_id = task_id
         self.max_trials = max_trials
         self.current_iteration = 0
+        self._last_best_message: tuple[str, str] | None = None
+        self._last_raw_message: str | None = None
 
     def log(self, message: str) -> None:
         if self.verbose < 1:
@@ -73,6 +135,13 @@ class RichGEPAOptimizerLogger:
 
         first = lines[0]
 
+        if first == self._last_raw_message:
+            return
+
+        # Reset duplicate tracker when handling other messages
+        if not first.startswith("Best "):
+            self._last_best_message = None
+
         # Track iteration changes and add separation
         if first.startswith("Iteration "):
             colon = first.find(":")
@@ -88,6 +157,7 @@ class RichGEPAOptimizerLogger:
 
                     self.optimizer._gepa_current_iteration = iteration  # type: ignore[attr-defined]
                     self.current_iteration = iteration
+                    self._last_raw_message = first
 
                     # Update progress bar
                     if self.progress and self.task_id is not None:
@@ -120,32 +190,34 @@ class RichGEPAOptimizerLogger:
                 except Exception:
                     pass
 
-        # Check if this message should be suppressed
-        for keyword in self.SUPPRESS_KEYWORDS:
-            if keyword in first:
-                return
+        # Check if this message should be suppressed (unless verbose >= 2)
+        if self.verbose <= 1:
+            for keyword in self.SUPPRESS_KEYWORDS:
+                if keyword in first:
+                    return
 
-        for prefix in self.SUPPRESS_PREFIXES:
-            if prefix in first:
-                return
+            for prefix in self.SUPPRESS_PREFIXES:
+                if prefix in first:
+                    return
 
         # Format proposed prompts
         if "Proposed new text" in first and "system_prompt:" in first:
             _, _, rest = first.partition("system_prompt:")
-            snippet = rest.strip()
-            if len(snippet) > 100:
-                snippet = snippet[:100] + "…"
+            snippet = format_prompt_snippet(rest, max_length=100)
             console.print(f"│ │  Proposed: {snippet}", style="dim")
+            self._last_raw_message = first
             return
 
         # Format subsample evaluation results
         if "New subsample score" in first and "is not better than" in first:
             console.print("│ └─ Rejected - no improvement", style="dim yellow")
             console.print("│")  # Add spacing after rejected trials
+            self._last_raw_message = first
             return
 
-        if "New subsample score" in first and "is better than" in first:
+        elif "New subsample score" in first and "is better than" in first:
             console.print("│ ├─ Promising! Running full validation...", style="green")
+            self._last_raw_message = first
             return
 
         # Format final validation score
@@ -157,9 +229,18 @@ class RichGEPAOptimizerLogger:
                 console.print(f"│ ├─ Validation complete: {score}", style="bold green")
             else:
                 console.print("│ ├─ Validation complete", style="green")
+            self._last_raw_message = first
             return
 
         # Format best score updates
+        if "Best score on train_val" in first:
+            parts = first.split(":")
+            if len(parts) >= 2:
+                score = parts[-1].strip()
+                console.print(f"│   Best train_val score: {score}", style="cyan")
+                self._last_raw_message = first
+            return
+
         if (
             "Best valset aggregate score so far" in first
             or "Best score on valset" in first
@@ -168,10 +249,32 @@ class RichGEPAOptimizerLogger:
             parts = first.split(":")
             if len(parts) >= 2:
                 score = parts[-1].strip()
-                console.print(f"│ └─ New best: {score} ✓", style="bold green")
-                console.print("│")  # Add spacing after successful trials
+                key = ("new_best", score)
+                if self._last_best_message != key:
+                    console.print(f"│ └─ New best: {score} ✓", style="bold green")
+                    console.print("│")  # Add spacing after successful trials
+                    self._last_best_message = key
+                    self._last_raw_message = first
             return
 
+        if self.verbose >= 2:
+            if "New valset pareto front scores" in first:
+                note = first.split(":", 1)[-1].strip()
+                console.print(
+                    f"│   Pareto front scores updated: {_format_pareto_note(note)}",
+                    style="cyan",
+                )
+                self._last_raw_message = first
+                return
+            if "Updated valset pareto front programs" in first:
+                console.print("│   Pareto front programs updated", style="cyan")
+                self._last_raw_message = first
+                return
+            if "New program is on the linear pareto front" in first:
+                console.print("│   Candidate added to Pareto front", style="cyan")
+                self._last_raw_message = first
+                return
+
         # Suppress redundant "Iteration X:" prefix from detailed messages
         if first.startswith(f"Iteration {self.current_iteration}:"):
             # Remove the iteration prefix for cleaner output
@@ -184,6 +287,7 @@ class RichGEPAOptimizerLogger:
         # Default: print with standard prefix only if not already handled
         if first:
             console.print(f"│ {first}", style="dim")
+            self._last_raw_message = first
 
 
 @contextmanager
@@ -280,6 +384,7 @@ def display_selected_candidate(
     *,
     verbose: int = 1,
     title: str = "Selected Candidate",
+    trial_info: dict[str, Any] | None = None,
 ) -> None:
     """Display the final selected candidate with its Opik score."""
     if verbose < 1:
@@ -287,11 +392,33 @@ def display_selected_candidate(
 
     snippet = system_prompt.strip() or "<empty>"
     text = Text(snippet)
+    subtitle: Text | None = None
+    if trial_info:
+        trial_parts: list[str] = []
+        trial_name = trial_info.get("experiment_name")
+        trial_ids = trial_info.get("trial_ids") or []
+        if trial_name:
+            trial_parts.append(f"Trial {trial_name}")
+        elif trial_ids:
+            trial_parts.append(f"Trial {trial_ids[0]}")
+
+        compare_url = trial_info.get("compare_url")
+        experiment_url = trial_info.get("experiment_url")
+        if compare_url:
+            trial_parts.append(f"[link={compare_url}]Compare run[/link]")
+        elif experiment_url:
+            trial_parts.append(f"[link={experiment_url}]View experiment[/link]")
+
+        if trial_parts:
+            subtitle = Text.from_markup(" • ".join(trial_parts))
+
     panel = Panel(
         text,
         title=f"{title} — Opik score {score:.4f}",
         border_style="green",
         expand=True,
+        subtitle=subtitle,
+        subtitle_align="left",
     )
     console.print(panel)
 

opik_optimizer/reporting_utils.py

@@ -1,5 +1,6 @@
 import json
 import logging
+import re
 from contextlib import contextmanager
 from typing import Any
 
@@ -94,6 +95,23 @@ def suppress_opik_logs() -> Any:
         opik_logger.setLevel(original_opik_level)
 
 
+def format_prompt_snippet(text: str, max_length: int = 100) -> str:
+    """
+    Normalize whitespace in a prompt snippet and truncate it for compact display.
+
+    Args:
+        text: Raw text to summarize.
+        max_length: Maximum characters to keep before adding an ellipsis.
+
+    Returns:
+        str: Condensed snippet safe for inline logging.
+    """
+    normalized = re.sub(r"\s+", " ", text.strip())
+    if len(normalized) > max_length:
+        return normalized[:max_length] + "…"
+    return normalized
+
+
 def display_messages(messages: list[dict[str, str]], prefix: str = "") -> None:
     for i, msg in enumerate(messages):
         panel = Panel(

opik_optimizer/utils/__init__.py

@@ -3,13 +3,16 @@
 from .core import *  # noqa: F401,F403
 from .dataset_utils import *  # noqa: F401,F403
 from .prompt_segments import *  # noqa: F401,F403
+from .candidate_utils import *  # noqa: F401,F403
 
 from . import core as _core
 from . import dataset_utils as _dataset_utils
 from . import prompt_segments as _prompt_segments
+from . import candidate_utils as _candidate_utils
 
 __all__: list[str] = [
     *getattr(_core, "__all__", []),
     *getattr(_dataset_utils, "__all__", []),
     *getattr(_prompt_segments, "__all__", []),
+    *getattr(_candidate_utils, "__all__", []),
 ]

opik_optimizer/utils/candidate_utils.py

@@ -0,0 +1,52 @@
+"""
+Utilities for working with optimizer candidate collections.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable
+from typing import TypeVar
+
+__all__ = ["unique_ordered_by_key"]
+
+T = TypeVar("T")
+
+
+def unique_ordered_by_key(
+    items: Iterable[T],
+    key: Callable[[T], str],
+    *,
+    drop_keys: set[str] | None = None,
+) -> list[T]:
+    """
+    Return a list of items that preserves the original order while removing duplicates.
+
+    Args:
+        items: Sequence of items to filter.
+        key: Function that extracts the comparison key from an item.
+        drop_keys: Optional set of keys to omit entirely from the result.
+
+    Returns:
+        List[T]: Ordered list containing the first occurrence of each unique key.
+    """
+    seen: set[str] = set()
+    filtered: list[T] = []
+
+    for item in items:
+        try:
+            item_key = key(item)
+        except (TypeError, AttributeError, KeyError):
+            # If the key extractor fails, fall back to stringifying the item.
+            item_key = str(item)
+
+        if drop_keys and item_key in drop_keys:
+            seen.add(item_key)
+            continue
+
+        if item_key in seen:
+            continue
+
+        seen.add(item_key)
+        filtered.append(item)
+
+    return filtered

opik_optimizer/utils/core.py

@@ -310,6 +310,25 @@ def get_optimization_run_url_by_id(
     return urllib.parse.urljoin(ensure_ending_slash(url_override), run_path)
 
 
+def get_trial_compare_url(
+    *, dataset_id: str | None, optimization_id: str | None, trial_ids: list[str]
+) -> str:
+    if dataset_id is None or optimization_id is None:
+        raise ValueError("dataset_id and optimization_id are required")
+    if not trial_ids:
+        raise ValueError("trial_ids must be a non-empty list")
+
+    opik_config = opik.config.get_from_user_inputs()
+    url_override = opik_config.url_override
+    base = ensure_ending_slash(url_override)
+
+    trials_query = urllib.parse.quote(json.dumps(trial_ids))
+    compare_path = (
+        f"optimizations/{optimization_id}/{dataset_id}/compare?trials={trials_query}"
+    )
+    return urllib.parse.urljoin(base, compare_path)
+
+
 def create_litellm_agent_class(
     prompt: "ChatPrompt", optimizer_ref: Any = None
 ) -> type["OptimizableAgent"]:

{opik_optimizer-2.2.0.dist-info → opik_optimizer-2.2.1.dist-info}/METADATA

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

{opik_optimizer-2.2.0.dist-info → opik_optimizer-2.2.1.dist-info}/RECORD

@@ -1,13 +1,13 @@
 opik_optimizer/__init__.py,sha256=HsEIWyxeUJhzCvuML5SjBHFWtm-b5LSHyE9GRYytyeI,1592
 opik_optimizer/_throttle.py,sha256=1JXIhYlo0IaqCgwmNB0Hnh9CYhYPkwRFdVGIcE7pVNg,1362
-opik_optimizer/base_optimizer.py,sha256=VpH6JSalcoewGkIN0h77_crCAkx5ffQtjNhaD0Xtazg,28350
+opik_optimizer/base_optimizer.py,sha256=o4U9yoU-KhR7q_3KnvV3DgCeVboOQdacgleq8D2d_20,28350
 opik_optimizer/cache_config.py,sha256=Xd3NdUsL7bLQWoNe3pESqH4nHucU1iNTSGp-RqbwDog,599
 opik_optimizer/logging_config.py,sha256=TmxX0C1P20amxoXuiNQvlENOjdSNfWwvL8jFy206VWM,3837
 opik_optimizer/multi_metric_objective.py,sha256=y4jqirnhkfhB7SWonI4ldYg5fWG4JGfAxqu7ylRD1J4,1178
 opik_optimizer/optimizable_agent.py,sha256=gB1ALuVPyEmXOTVYeK2i-inBAO-6JMZSjOrmj37okgQ,6514
 opik_optimizer/optimization_result.py,sha256=sG-Yr-hOaH9zx_I5S6_W3v6j8nPUhwYdS333jVM4Gus,17218
 opik_optimizer/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-opik_optimizer/reporting_utils.py,sha256=Gx69W16FfIpavH_o0WvnGJPIpqHAjJm4GNHKcJhtoeU,9443
+opik_optimizer/reporting_utils.py,sha256=jN3_-tTy98KtsOv8Xp-DKFpePQQYZHHhT7kkG-jUrOg,9970
 opik_optimizer/task_evaluator.py,sha256=7N254DU0UkWJ5saQ5AmYEsHHSrychAJtedmmjNsCOnI,5081
 opik_optimizer/data/context7_eval.jsonl,sha256=vPR3XRfI0UbZ1hgUGaOdpraFT99RDLU1YWuPFLLQz40,1757
 opik_optimizer/data/hotpot-500.json,sha256=YXxCtuvYvxSu5u0y4559a6b1qwgAYsWzT_SUKv_21ew,76862
@@ -43,8 +43,8 @@ opik_optimizer/few_shot_bayesian_optimizer/few_shot_bayesian_optimizer.py,sha256
 opik_optimizer/few_shot_bayesian_optimizer/reporting.py,sha256=xk7gKaoTrlp1WDpW3mB5Irzty5Z5l9SJygO3PaamOvU,6283
 opik_optimizer/gepa_optimizer/__init__.py,sha256=XcPah5t4mop7UCFo69E9l45Mem49-itqkQT7_J1aWOA,71
 opik_optimizer/gepa_optimizer/adapter.py,sha256=KzPa4koq7aJhALMAOKPxAO4yWuEy_YbW7tGnqny3Hfo,5139
-opik_optimizer/gepa_optimizer/gepa_optimizer.py,sha256=rWD92KauJbnkXbsftzhTDkBjmgzlwGZcm6t7F-ceh_Q,27055
-opik_optimizer/gepa_optimizer/reporting.py,sha256=ZyD4bwiW6BxmPb-966u3iDAfBsiO56kO2VBxHtNmL-Q,11050
+opik_optimizer/gepa_optimizer/gepa_optimizer.py,sha256=RlTm71yWjRR8C1nEAuNXfAx1gkt5nsOwV6bfvu5NwbM,32849
+opik_optimizer/gepa_optimizer/reporting.py,sha256=FiIPtHE6c5p4yMfknnhZetEjehvrA8PRejeOPT9uBCo,15836
 opik_optimizer/hierarchical_reflective_optimizer/__init__.py,sha256=9qM3kvfAaFy-Y6Tg19MXHJxpnF5DJQQwzr6oNsxaRBM,133
 opik_optimizer/hierarchical_reflective_optimizer/hierarchical_reflective_optimizer.py,sha256=fhB68XrGNgaHfPwV1JDow-MiAT-jhKDT_Kf-mLLzk0o,27775
 opik_optimizer/hierarchical_reflective_optimizer/hierarchical_root_cause_analyzer.py,sha256=0D5wgx04jZvTJ0Yjqm0jtQvkjrGBB73qgcsSwLBpnv0,13814
@@ -74,13 +74,14 @@ opik_optimizer/parameter_optimizer/parameter_spec.py,sha256=HzYT_dHBTfZtx403mY-E
 opik_optimizer/parameter_optimizer/reporting.py,sha256=-kEe9sQFdkUhxayEamXLR8ukyTLJrGsTs8pbJWmimQ4,4665
 opik_optimizer/parameter_optimizer/search_space_types.py,sha256=UajTA2QKikEWazokDNO7j141gc2WxxYYiDRnFFjXi6M,512
 opik_optimizer/parameter_optimizer/sensitivity_analysis.py,sha256=8KEMVMHsmcoiK21Cq1-We6_Pw_6LX9qBX9Az4-tmj_w,2146
-opik_optimizer/utils/__init__.py,sha256=Ee0SnTPOcwRwp93M6Lh-X913lfSIwnvCiYYh5cpdRQE,486
+opik_optimizer/utils/__init__.py,sha256=_sielSJdLVeyBugtsw1iSVJr_I8YbhsU-U7p8zLe_JY,633
+opik_optimizer/utils/candidate_utils.py,sha256=PKtjREM4MFHvgDri8jCmbs6zHvxAnrfjuwwymvQNnrk,1294
 opik_optimizer/utils/colbert.py,sha256=qSrzKUUGw7P92mLy4Ofug5pBGeTsHBLMJXlXSJSfKuo,8147
-opik_optimizer/utils/core.py,sha256=sL9I9kG1Gdjj0b3rBgPpXp7NUaUisD3_ITSkE7w5QhU,16014
+opik_optimizer/utils/core.py,sha256=56lQax3mAQkVZWfie6vhaTKZfjTBcYXf-FFkXgyFYFE,16715
 opik_optimizer/utils/dataset_utils.py,sha256=dqRUGOekjeNWL0J15R8xFwLyKJDJynJXzVyQmt8rhHA,1464
 opik_optimizer/utils/prompt_segments.py,sha256=eiLYT1iiPxtB7ArriN13-LgI5tID-v7MrjniTAxK2Lo,5904
-opik_optimizer-2.2.0.dist-info/licenses/LICENSE,sha256=V-0VHJOBdcA_teT8VymvsBUQ1-CZU6yJRmMEjec_8tA,11372
-opik_optimizer-2.2.0.dist-info/METADATA,sha256=O8dgJi_lpEyd2kDMCj-AZMK4QthqAaZiR5Afo5WwCZ8,12807
-opik_optimizer-2.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-opik_optimizer-2.2.0.dist-info/top_level.txt,sha256=ondOlpq6_yFckqpxoAHSfzZS2N-JfgmA-QQhOJfz7m0,15
-opik_optimizer-2.2.0.dist-info/RECORD,,
+opik_optimizer-2.2.1.dist-info/licenses/LICENSE,sha256=V-0VHJOBdcA_teT8VymvsBUQ1-CZU6yJRmMEjec_8tA,11372
+opik_optimizer-2.2.1.dist-info/METADATA,sha256=8HayPMPvWBxuCg1H3u6-d_8MwBxVF2DzbID2VrdqjKk,12807
+opik_optimizer-2.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+opik_optimizer-2.2.1.dist-info/top_level.txt,sha256=ondOlpq6_yFckqpxoAHSfzZS2N-JfgmA-QQhOJfz7m0,15
+opik_optimizer-2.2.1.dist-info/RECORD,,