opik-optimizer 0.7.2__py3-none-any.whl → 0.7.4__py3-none-any.whl

opik_optimizer/__init__.py

@@ -27,12 +27,14 @@ from opik.evaluation.models.litellm import warning_filters
 warning_filters.add_warning_filters()
 
 from .optimization_result import OptimizationResult
+from opik_optimizer.evolutionary_optimizer.evolutionary_optimizer import EvolutionaryOptimizer
 
 __all__ = [
     "BaseOptimizer",
     "FewShotBayesianOptimizer",
     "MetaPromptOptimizer",
     "MiproOptimizer",
+    "EvolutionaryOptimizer",
     "MetricConfig",
     "OptimizationConfig",
     "TaskConfig",

opik_optimizer/_throttle.py

@@ -1,43 +1,43 @@
-import threading
+import functools
+import pyrate_limiter
 import time
-import queue
-from functools import wraps
+import opik.config
+
+from typing import Callable, Any
+
 
 class RateLimiter:
     """
-    Rate limiter that enforces a maximum number of calls across all threads.
+    Rate limiter that enforces a maximum number of calls across all threads using pyrate_limiter.
     """
-    def __init__(self, max_calls_per_second):
+    def __init__(self, max_calls_per_second: int):
         self.max_calls_per_second = max_calls_per_second
-        self.interval = 1.0 / max_calls_per_second  # Time between allowed calls
-        self.last_call_time = 0
-        self.lock = threading.Lock()
+        rate = pyrate_limiter.Rate(max_calls_per_second, pyrate_limiter.Duration.SECOND)
+
+        self.limiter = pyrate_limiter.Limiter(rate, raise_when_fail=False)
+        self.bucket_key = "global_rate_limit"
         
-    def acquire(self):
-        """
-        Wait until a call is allowed according to the global rate limit.
-        Returns immediately if the call is allowed, otherwise blocks until it's time.
-        """
-        with self.lock:
-            current_time = time.time()
-            time_since_last = current_time - self.last_call_time
-            
-            # If we haven't waited long enough since the last call
-            if time_since_last < self.interval:
-                # Calculate how much longer we need to wait
-                sleep_time = self.interval - time_since_last
-                time.sleep(sleep_time)
-                
-            # Update the last call time (after potential sleep)
-            self.last_call_time = time.time()
-
-def rate_limited(limiter):
+    def acquire(self) -> None:
+        while not self.limiter.try_acquire(self.bucket_key):
+            time.sleep(0.01)
+
+def rate_limited(limiter: RateLimiter) -> Callable[[Callable], Callable]:
     """Decorator to rate limit a function using the provided limiter"""
-    def decorator(func):
-        @wraps(func)
-        def wrapper(*args, **kwargs):
+
+    def decorator(func: Callable) -> Callable:
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs) -> Any:
             limiter.acquire()
             return func(*args, **kwargs)
         return wrapper
     return decorator
 
+
+def get_rate_limiter_for_current_opik_installation() -> RateLimiter:
+    opik_config = opik.config.OpikConfig()
+    max_calls_per_second = (
+        10
+        if opik_config.is_cloud_installation
+        else 50
+    )
+    return RateLimiter(max_calls_per_second=max_calls_per_second)

opik_optimizer/base_optimizer.py

@@ -12,7 +12,7 @@ from .cache_config import initialize_cache
 from opik.evaluation.models.litellm import opik_monitor as opik_litellm_monitor
 from .optimization_config.configs import TaskConfig, MetricConfig
 
-limiter = RateLimiter(max_calls_per_second=15)
+limiter = RateLimiter(max_calls_per_second=8)
 
 # Don't use unsupported params:
 litellm.drop_params = True
@@ -141,85 +141,6 @@ class BaseOptimizer:
         """
         self._history.append(round_data)
 
-    @rate_limited(limiter)
-    def _call_model(
-        self,
-        prompt: str,
-        system_prompt: Optional[str] = None,
-        is_reasoning: bool = False,
-    ) -> str:
-        """Call the model to get suggestions based on the meta-prompt."""
-        model = self.reasoning_model if is_reasoning else self.model
-        messages = []
-
-        if system_prompt:
-            messages.append({"role": "system", "content": system_prompt})
-            logger.debug(f"Using custom system prompt: {system_prompt[:100]}...")
-        else:
-            messages.append(
-                {"role": "system", "content": "You are a helpful assistant."}
-            )
-
-        messages.append({"role": "user", "content": prompt})
-        logger.debug(f"Calling model {model} with prompt: {prompt[:100]}...")
-
-        api_params = self.model_kwargs.copy()
-        api_params.update(
-            {
-                "model": model,
-                "messages": messages,
-                # Ensure required params like 'temperature', 'max_tokens' are present
-                # Defaults added here for safety, though usually set in __init__ kwargs
-                "temperature": api_params.get("temperature", 0.3),
-                "max_tokens": api_params.get("max_tokens", 1000),
-            }
-        )
-
-        # Attempt to add Opik monitoring if available
-        try:
-            # Assuming opik_litellm_monitor is imported and configured elsewhere
-            api_params = opik_litellm_monitor.try_add_opik_monitoring_to_params(
-                api_params
-            )
-            logger.debug("Opik monitoring hooks added to LiteLLM params.")
-        except Exception as e:
-            logger.warning(f"Could not add Opik monitoring to LiteLLM params: {e}")
-
-        logger.debug(
-            f"Final API params (excluding messages): { {k:v for k,v in api_params.items() if k != 'messages'} }"
-        )
-
-        # Increment Counter
-        self.llm_call_counter += 1
-        logger.debug(f"LLM Call Count: {self.llm_call_counter}")
-
-        try:
-            response = litellm.completion(**api_params)
-            model_output = response.choices[0].message.content.strip()
-            logger.debug(f"Model response from {model_to_use}: {model_output[:100]}...")
-            return model_output
-        except litellm.exceptions.RateLimitError as e:
-            logger.error(f"LiteLLM Rate Limit Error for model {model_to_use}: {e}")
-            # Consider adding retry logic here with tenacity
-            raise
-        except litellm.exceptions.APIConnectionError as e:
-            logger.error(f"LiteLLM API Connection Error for model {model_to_use}: {e}")
-            # Consider adding retry logic here
-            raise
-        except litellm.exceptions.ContextWindowExceededError as e:
-            logger.error(
-                f"LiteLLM Context Window Exceeded Error for model {model_to_use}. Prompt length: {len(prompt)}. Details: {e}"
-            )
-            raise
-        except litellm.exceptions.APIError as e:  # Catch broader API errors
-            logger.error(f"LiteLLM API Error for model {model_to_use}: {e}")
-            raise
-        except Exception as e:
-            # Catch any other unexpected errors
-            logger.error(
-                f"Unexpected error during model call to {model_to_use}: {type(e).__name__} - {e}"
-            )
-            raise
 
     def update_optimization(self, optimization, status: str) -> None:
         """