Upload folder using huggingface_hub

tinytroupe/config.ini

@@ -3,7 +3,7 @@
 # OpenAI or Azure OpenAI Service
 #
 
-# Default options: openai, azure, helmholtz-blablador
+# Default options: openai, azure
 API_TYPE=openai
 
 # Check Azure's documentation for updates here:
@@ -15,10 +15,10 @@ AZURE_API_VERSION=2023-05-15
 #
 
 # The main text generation model, used for agent responses
-MODEL=alias-large
+MODEL=gpt-4.1-mini
 
 # Reasoning model is used when precise reasoning is required, such as when computing detailed analyses of simulation properties.
-REASONING_MODEL=alias-large
+REASONING_MODEL=o3-mini
 
 # Embedding model is used for text similarity tasks
 EMBEDDING_MODEL=text-embedding-3-small 
@@ -31,8 +31,8 @@ TEMPERATURE=1.5
 FREQ_PENALTY=0.1
 PRESENCE_PENALTY=0.1
 TIMEOUT=480
-MAX_ATTEMPTS=999
-WAITING_TIME=35
+MAX_ATTEMPTS=5
+WAITING_TIME=1
 EXPONENTIAL_BACKOFF_FACTOR=5
 
 REASONING_EFFORT=high
@@ -90,7 +90,7 @@ QUALITY_THRESHOLD = 5
 
 
 [Logging]
-LOGLEVEL=DEBUG
+LOGLEVEL=ERROR
 # ERROR
 # WARNING
 # INFO

tinytroupe/openai_utils.py

@@ -31,8 +31,6 @@ class OpenAIClient:
     def __init__(self, cache_api_calls=default["cache_api_calls"], cache_file_name=default["cache_file_name"]) -> None:
         logger.debug("Initializing OpenAIClient")
 
-        self.client = None
-
         # should we cache api calls and reuse them?
         self.set_api_cache(cache_api_calls, cache_file_name)
     
@@ -54,8 +52,7 @@ class OpenAIClient:
         """
         Sets up the OpenAI API configurations for this client.
         """
-        if self.client is None:
-            self.client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+        self.client = OpenAI(api_key=os.getenv("OPENAI_API_KEY", os.getenv("BLABLADOR_API_KEY", "dummy_token")), base_url=os.getenv("HELMHOLTZ_BLABLADOR_ENDPOINT", "https://api.helmholtz-blablador.fz-juelich.de/v1"))
 
     @config_manager.config_defaults(
         model="model",
@@ -144,6 +141,7 @@ class OpenAIClient:
             "messages": current_messages,
             "temperature": temperature,
             "max_tokens":max_tokens,
+            "top_p": top_p,
             "frequency_penalty": frequency_penalty,
             "presence_penalty": presence_penalty,
             "stop": stop,
@@ -152,40 +150,18 @@ class OpenAIClient:
             "n": n,
         }
 
-        if top_p is not None and top_p > 0:
-            chat_api_params["top_p"] = top_p
-
         if response_format is not None:
             chat_api_params["response_format"] = response_format
 
         i = 0
-        while True:
+        while i < max_attempts:
             try:
                 i += 1
 
-                #
-                # Model fallback and retry strategy requested by the user:
-                # 1. alias-fast for 3 attempts, 35s wait
-                # 2. alias-large for 2 attempts, 35s wait
-                # 3. alias-huge until success, 60s wait
-                #
-                # Model fallback strategy using config
-                if i <= 3:
-                    current_model = config["OpenAI"].get("MODEL", "alias-large")
-                    current_wait_time = 35
-                elif i <= 5:
-                    current_model = config["OpenAI"].get("FALLBACK_MODEL_LARGE", "alias-large")
-                    current_wait_time = 35
-                else:
-                    current_model = config["OpenAI"].get("FALLBACK_MODEL_HUGE", "alias-huge")
-                    current_wait_time = 60
-
-                chat_api_params["model"] = current_model
-
                 try:
-                    logger.debug(f"Sending messages to OpenAI API. Model={current_model}. Token count={self._count_tokens(current_messages, current_model)}.")
+                    logger.debug(f"Sending messages to OpenAI API. Token count={self._count_tokens(current_messages, model)}.")
                 except NotImplementedError:
-                    logger.debug(f"Token count not implemented for model {current_model}.")
+                    logger.debug(f"Token count not implemented for model {model}.")
                     
                 start_time = time.monotonic()
                 logger.debug(f"Calling model with client class {self.__class__.__name__}.")
@@ -193,11 +169,15 @@ class OpenAIClient:
                 ###############################################################
                 # call the model, either from the cache or from the API
                 ###############################################################
-                cache_key = str((current_model, chat_api_params)) # need string to be hashable
+                cache_key = str((model, chat_api_params)) # need string to be hashable
                 if self.cache_api_calls and (cache_key in self.api_cache):
                     response = self.api_cache[cache_key]
                 else:
-                    response = self._raw_model_call(current_model, chat_api_params)
+                    if waiting_time > 0:
+                        logger.info(f"Waiting {waiting_time} seconds before next API request (to avoid throttling)...")
+                        time.sleep(waiting_time)
+                    
+                    response = self._raw_model_call(model, chat_api_params)
                     if self.cache_api_calls:
                         self.api_cache[cache_key] = response
                         self._save_cache()
@@ -213,21 +193,35 @@ class OpenAIClient:
                 else:
                     return utils.sanitize_dict(self._raw_model_response_extractor(response))
 
-            except (InvalidRequestError, openai.BadRequestError) as e:
+            except InvalidRequestError as e:
                 logger.error(f"[{i}] Invalid request error, won't retry: {e}")
+
+                # there's no point in retrying if the request is invalid
+                # so we return None right away
                 return None
             
-            except (openai.RateLimitError,
-                    openai.APITimeoutError,
-                    openai.APIConnectionError,
-                    openai.InternalServerError,
-                    NonTerminalError,
-                    Exception) as e:
-                msg = f"[{i}] {type(e).__name__} Error with {current_model}: {e}. Waiting {current_wait_time} seconds before next attempt..."
-                logger.warning(msg)
-
-                time.sleep(current_wait_time)
-                continue
+            except openai.BadRequestError as e:
+                logger.error(f"[{i}] Invalid request error, won't retry: {e}")
+                
+                # there's no point in retrying if the request is invalid
+                # so we return None right away
+                return None
+            
+            except openai.RateLimitError:
+                logger.warning(
+                    f"[{i}] Rate limit error, waiting a bit and trying again.")
+                aux_exponential_backoff()
+            
+            except NonTerminalError as e:
+                logger.error(f"[{i}] Non-terminal error: {e}")
+                aux_exponential_backoff()
+                
+            except Exception as e:
+                logger.error(f"[{i}] {type(e).__name__} Error: {e}")
+                aux_exponential_backoff()
+
+        logger.error(f"Failed to get response after {max_attempts} attempts.")
+        return None
     
     def _raw_model_call(self, model, chat_api_params):
         """
@@ -250,12 +244,8 @@ class OpenAIClient:
             chat_api_params["reasoning_effort"] = default["reasoning_effort"]
 
 
-        # To make the log cleaner, we remove the messages from the logged parameters,
-        # unless we are in debug mode
-        if logger.getEffectiveLevel() <= logging.DEBUG:
-            logged_params = chat_api_params
-        else:
-            logged_params = {k: v for k, v in chat_api_params.items() if k != "messages"}
+        # To make the log cleaner, we remove the messages from the logged parameters
+        logged_params = {k: v for k, v in chat_api_params.items() if k != "messages"} 
 
         if "response_format" in chat_api_params:
             # to enforce the response format via pydantic, we need to use a different method
@@ -322,8 +312,8 @@ class OpenAIClient:
             elif "gpt-3.5-turbo" in model:
                 logger.debug("Token count: gpt-3.5-turbo may update over time. Returning num tokens assuming gpt-3.5-turbo-0613.")
                 return self._count_tokens(messages, model="gpt-3.5-turbo-0613")
-            elif ("gpt-4" in model) or ("ppo" in model) or ("alias-large" in model) or ("alias-huge" in model) or ("alias-large" in model):
-                logger.debug("Token count: gpt-4/alias-large may update over time. Returning num tokens assuming gpt-4-0613.")
+            elif ("gpt-4" in model) or ("ppo" in model) :
+                logger.debug("Token count: gpt-4 may update over time. Returning num tokens assuming gpt-4-0613.")
                 return self._count_tokens(messages, model="gpt-4-0613")
             else:
                 raise NotImplementedError(
@@ -404,40 +394,23 @@ class AzureClient(OpenAIClient):
         Sets up the Azure OpenAI Service API configurations for this client,
         including the API endpoint and key.
         """
-        if self.client is None:
-            if os.getenv("AZURE_OPENAI_KEY"):
-                logger.info("Using Azure OpenAI Service API with key.")
-                self.client = AzureOpenAI(azure_endpoint= os.getenv("AZURE_OPENAI_ENDPOINT"),
-                                        api_version = config["OpenAI"]["AZURE_API_VERSION"],
-                                        api_key = os.getenv("AZURE_OPENAI_KEY"))
-            else:  # Use Entra ID Auth
-                logger.info("Using Azure OpenAI Service API with Entra ID Auth.")
-                from azure.identity import DefaultAzureCredential, get_bearer_token_provider
-
-                credential = DefaultAzureCredential()
-                token_provider = get_bearer_token_provider(credential, "https://cognitiveservices.azure.com/.default")
-                self.client = AzureOpenAI(
-                    azure_endpoint= os.getenv("AZURE_OPENAI_ENDPOINT"),
-                    api_version = config["OpenAI"]["AZURE_API_VERSION"],
-                    azure_ad_token_provider=token_provider
-                )
-
-
-class HelmholtzBlabladorClient(OpenAIClient):
-
-    def __init__(self, cache_api_calls=default["cache_api_calls"], cache_file_name=default["cache_file_name"]) -> None:
-        logger.debug("Initializing HelmholtzBlabladorClient")
-        super().__init__(cache_api_calls, cache_file_name)
-
-    def _setup_from_config(self):
-        """
-        Sets up the Helmholtz Blablador API configurations for this client.
-        """
-        if self.client is None:
-            self.client = OpenAI(
-                base_url="https://api.helmholtz-blablador.fz-juelich.de/v1",
-                api_key=os.getenv("BLABLADOR_API_KEY", "dummy"),
+        if os.getenv("AZURE_OPENAI_KEY"):
+            logger.info("Using Azure OpenAI Service API with key.")
+            self.client = AzureOpenAI(azure_endpoint= os.getenv("AZURE_OPENAI_ENDPOINT"),
+                                    api_version = config["OpenAI"]["AZURE_API_VERSION"],
+                                    api_key = os.getenv("AZURE_OPENAI_KEY"))
+        else:  # Use Entra ID Auth
+            logger.info("Using Azure OpenAI Service API with Entra ID Auth.")
+            from azure.identity import DefaultAzureCredential, get_bearer_token_provider
+
+            credential = DefaultAzureCredential()
+            token_provider = get_bearer_token_provider(credential, "https://cognitiveservices.azure.com/.default")
+            self.client = AzureOpenAI(
+                azure_endpoint= os.getenv("AZURE_OPENAI_ENDPOINT"),
+                api_version = config["OpenAI"]["AZURE_API_VERSION"],
+                azure_ad_token_provider=token_provider
             )
+    
 
 ###########################################################################
 # Exceptions
@@ -529,7 +502,6 @@ def force_api_cache(cache_api_calls, cache_file_name=default["cache_file_name"])
 # default client
 register_client("openai", OpenAIClient())
 register_client("azure", AzureClient())
-register_client("helmholtz-blablador", HelmholtzBlabladorClient())