feat: Refactor logging to use a dedicated logger across providers and enhance model retrieval with httpx

src/rotator_library/client.py

@@ -1,10 +1,21 @@
 import asyncio
 import json
+import httpx
 import litellm
 from litellm.litellm_core_utils.token_counter import token_counter
 import logging
 from typing import List, Dict, Any, AsyncGenerator
 
+# Set up a dedicated logger for the library
+lib_logger = logging.getLogger('rotator_library')
+lib_logger.propagate = False
+
+# You might want to add a handler if you want to see these logs specifically
+# For example, a NullHandler to avoid "No handler found" warnings if the
+# main app doesn't configure this logger.
+if not lib_logger.handlers:
+    lib_logger.addHandler(logging.NullHandler())
+
 from .usage_manager import UsageManager
 from .failure_logger import log_failure
 from .error_handler import is_server_error, is_unrecoverable_error
@@ -26,6 +37,7 @@ class RotatingClient:
         self._provider_instances = {
             name: plugin() for name, plugin in PROVIDER_PLUGINS.items()
         }
+        self.http_client = httpx.AsyncClient()
 
     async def _streaming_wrapper(self, stream: Any, key: str, model: str) -> AsyncGenerator[Any, None]:
         """
@@ -34,7 +46,7 @@ class RotatingClient:
         """
         try:
             async for chunk in stream:
-                #logging.info(f"STREAM CHUNK: {chunk}")
+                #lib_logger.info(f"STREAM CHUNK: {chunk}")
                 # Convert the litellm chunk object to a dictionary
                 chunk_dict = chunk.dict()
                 
@@ -43,13 +55,13 @@ class RotatingClient:
 
                 # Safely check for usage data in the chunk
                 if hasattr(chunk, 'usage') and chunk.usage:
-                    logging.info(f"Usage found in chunk for key ...{key[-4:]}: {chunk.usage}")
+                    lib_logger.info(f"Usage found in chunk for key ...{key[-4:]}: {chunk.usage}")
                     self.usage_manager.record_success(key, model, chunk)
 
         finally:
             # Signal the end of the stream
             yield "data: [DONE]\n\n"
-            logging.info("STREAM FINISHED and [DONE] signal sent.")
+            lib_logger.info("STREAM FINISHED and [DONE] signal sent.")
 
 
     async def acompletion(self, **kwargs) -> Any:
@@ -139,29 +151,37 @@ class RotatingClient:
         """
         Returns a list of available models for a specific provider, with caching.
         """
+        lib_logger.info(f"Getting available models for provider: {provider}")
         if provider in self._model_list_cache:
+            lib_logger.info(f"Returning cached models for provider: {provider}")
             return self._model_list_cache[provider]
 
         api_key = self.api_keys.get(provider, [None])[0]
         if not api_key:
+            lib_logger.warning(f"No API key for provider: {provider}")
             return []
 
         if provider in self._provider_instances:
-            models = await self._provider_instances[provider].get_models(api_key)
+            lib_logger.info(f"Calling get_models for provider: {provider}")
+            models = await self._provider_instances[provider].get_models(api_key, self.http_client)
+            lib_logger.info(f"Got {len(models)} models for provider: {provider}")
             self._model_list_cache[provider] = models
             return models
         else:
-            logging.warning(f"Model list fetching not implemented for provider: {provider}")
+            lib_logger.warning(f"Model list fetching not implemented for provider: {provider}")
             return []
 
     async def get_all_available_models(self, grouped: bool = True) -> Any:
         """
         Returns a list of all available models, either grouped by provider or as a flat list.
         """
+        lib_logger.info("Getting all available models...")
         all_provider_models = {}
         for provider in self.api_keys.keys():
+            lib_logger.info(f"Getting models for provider: {provider}")
             all_provider_models[provider] = await self.get_available_models(provider)
         
+        lib_logger.info("Finished getting all available models.")
         if grouped:
             return all_provider_models
         else:

src/rotator_library/failure_logger.py

@@ -9,8 +9,9 @@ def setup_failure_logger():
     if not os.path.exists(log_dir):
         os.makedirs(log_dir)
 
-    logger = logging.getLogger('failure_logger')
-    logger.setLevel(logging.ERROR)
+    # Use the same named logger as the rest of the library
+    logger = logging.getLogger('rotator_library')
+    logger.setLevel(logging.INFO) # Set to INFO to capture all levels
     
     # Prevent logs from propagating to the root logger
     logger.propagate = False
@@ -34,12 +35,13 @@ def setup_failure_logger():
 
     handler.setFormatter(JsonFormatter())
     
-    # Add handler only if it hasn't been added before
-    if not logger.handlers:
+    # Add handler only if it hasn't been added before, and is not a NullHandler
+    if not any(isinstance(h, RotatingFileHandler) for h in logger.handlers):
         logger.addHandler(handler)
 
     return logger
 
+# Initialize the logger for failures
 failure_logger = setup_failure_logger()
 
 def log_failure(api_key: str, model: str, attempt: int, error: Exception, request_data: dict):

src/rotator_library/providers/anthropic_provider.py

@@ -1,18 +1,23 @@
-import requests
+import httpx
 import logging
 from typing import List
 from .provider_interface import ProviderInterface
 
+lib_logger = logging.getLogger('rotator_library')
+lib_logger.propagate = False # Ensure this logger doesn't propagate to root
+if not lib_logger.handlers:
+    lib_logger.addHandler(logging.NullHandler())
+
 class AnthropicProvider(ProviderInterface):
     """
     Provider implementation for the Anthropic API.
     """
-    async def get_models(self, api_key: str) -> List[str]:
+    async def get_models(self, api_key: str, client: httpx.AsyncClient) -> List[str]:
         """
         Fetches the list of available models from the Anthropic API.
         """
         try:
-            response = requests.get(
+            response = await client.get(
                 "https://api.anthropic.com/v1/models",
                 headers={
                     "x-api-key": api_key,
@@ -21,6 +26,6 @@ class AnthropicProvider(ProviderInterface):
             )
             response.raise_for_status()
             return [f"anthropic/{model['id']}" for model in response.json().get("data", [])]
-        except requests.RequestException as e:
-            logging.error(f"Failed to fetch Anthropic models: {e}")
+        except httpx.RequestError as e:
+            lib_logger.error(f"Failed to fetch Anthropic models: {e}")
             return []

src/rotator_library/providers/bedrock_provider.py

@@ -1,12 +1,18 @@
+import httpx
 import logging
 from typing import List
 from .provider_interface import ProviderInterface
 
+lib_logger = logging.getLogger('rotator_library')
+lib_logger.propagate = False # Ensure this logger doesn't propagate to root
+if not lib_logger.handlers:
+    lib_logger.addHandler(logging.NullHandler())
+
 class BedrockProvider(ProviderInterface):
     """
     Provider implementation for AWS Bedrock.
     """
-    async def get_models(self, api_key: str) -> List[str]:
+    async def get_models(self, api_key: str, client: httpx.AsyncClient) -> List[str]:
         """
         Returns a hardcoded list of common Bedrock models, as there is no
         simple, unauthenticated API endpoint to list them.
@@ -14,7 +20,7 @@ class BedrockProvider(ProviderInterface):
         # Note: Listing Bedrock models typically requires AWS credentials and boto3.
         # For a simple, key-based proxy, we'll list common models.
         # This can be expanded with full AWS authentication if needed.
-        logging.info("Returning hardcoded list for Bedrock. Full discovery requires AWS auth.")
+        lib_logger.info("Returning hardcoded list for Bedrock. Full discovery requires AWS auth.")
         return [
             "bedrock/anthropic.claude-3-sonnet-20240229-v1:0",
             "bedrock/anthropic.claude-3-haiku-20240307-v1:0",

src/rotator_library/providers/chutes_provider.py

@@ -1,23 +1,28 @@
-import requests
+import httpx
 import logging
 from typing import List
 from .provider_interface import ProviderInterface
 
+lib_logger = logging.getLogger('rotator_library')
+lib_logger.propagate = False # Ensure this logger doesn't propagate to root
+if not lib_logger.handlers:
+    lib_logger.addHandler(logging.NullHandler())
+
 class ChutesProvider(ProviderInterface):
     """
     Provider implementation for the chutes.ai API.
     """
-    async def get_models(self, api_key: str) -> List[str]:
+    async def get_models(self, api_key: str, client: httpx.AsyncClient) -> List[str]:
         """
         Fetches the list of available models from the chutes.ai API.
         """
         try:
-            response = requests.get(
+            response = await client.get(
                 "https://llm.chutes.ai/v1/models",
                 headers={"Authorization": f"Bearer {api_key}"}
             )
             response.raise_for_status()
             return [f"chutes/{model['id']}" for model in response.json().get("data", [])]
-        except requests.RequestException as e:
-            logging.error(f"Failed to fetch chutes.ai models: {e}")
-            return []
+        except httpx.RequestError as e:
+            lib_logger.error(f"Failed to fetch chutes.ai models: {e}")
+            return []

src/rotator_library/providers/cohere_provider.py

@@ -1,23 +1,28 @@
-import requests
+import httpx
 import logging
 from typing import List
 from .provider_interface import ProviderInterface
 
+lib_logger = logging.getLogger('rotator_library')
+lib_logger.propagate = False # Ensure this logger doesn't propagate to root
+if not lib_logger.handlers:
+    lib_logger.addHandler(logging.NullHandler())
+
 class CohereProvider(ProviderInterface):
     """
     Provider implementation for the Cohere API.
     """
-    async def get_models(self, api_key: str) -> List[str]:
+    async def get_models(self, api_key: str, client: httpx.AsyncClient) -> List[str]:
         """
         Fetches the list of available models from the Cohere API.
         """
         try:
-            response = requests.get(
+            response = await client.get(
                 "https://api.cohere.ai/v1/models",
                 headers={"Authorization": f"Bearer {api_key}"}
             )
             response.raise_for_status()
             return [f"cohere/{model['name']}" for model in response.json().get("models", [])]
-        except requests.RequestException as e:
-            logging.error(f"Failed to fetch Cohere models: {e}")
+        except httpx.RequestError as e:
+            lib_logger.error(f"Failed to fetch Cohere models: {e}")
             return []

src/rotator_library/providers/gemini_provider.py

@@ -1,23 +1,28 @@
-import requests
+import httpx
 import logging
 from typing import List
 from .provider_interface import ProviderInterface
 
+lib_logger = logging.getLogger('rotator_library')
+lib_logger.propagate = False # Ensure this logger doesn't propagate to root
+if not lib_logger.handlers:
+    lib_logger.addHandler(logging.NullHandler())
+
 class GeminiProvider(ProviderInterface):
     """
     Provider implementation for the Google Gemini API.
     """
-    async def get_models(self, api_key: str) -> List[str]:
+    async def get_models(self, api_key: str, client: httpx.AsyncClient) -> List[str]:
         """
         Fetches the list of available models from the Google Gemini API.
         """
         try:
-            response = requests.get(
+            response = await client.get(
                 "https://generativelanguage.googleapis.com/v1beta/models",
                 headers={"x-goog-api-key": api_key}
             )
             response.raise_for_status()
             return [f"gemini/{model['name'].replace('models/', '')}" for model in response.json().get("models", [])]
-        except requests.RequestException as e:
-            logging.error(f"Failed to fetch Gemini models: {e}")
+        except httpx.RequestError as e:
+            lib_logger.error(f"Failed to fetch Gemini models: {e}")
             return []

src/rotator_library/providers/groq_provider.py

@@ -1,23 +1,28 @@
-import requests
+import httpx
 import logging
 from typing import List
 from .provider_interface import ProviderInterface
 
+lib_logger = logging.getLogger('rotator_library')
+lib_logger.propagate = False # Ensure this logger doesn't propagate to root
+if not lib_logger.handlers:
+    lib_logger.addHandler(logging.NullHandler())
+
 class GroqProvider(ProviderInterface):
     """
     Provider implementation for the Groq API.
     """
-    async def get_models(self, api_key: str) -> List[str]:
+    async def get_models(self, api_key: str, client: httpx.AsyncClient) -> List[str]:
         """
         Fetches the list of available models from the Groq API.
         """
         try:
-            response = requests.get(
+            response = await client.get(
                 "https://api.groq.com/openai/v1/models",
                 headers={"Authorization": f"Bearer {api_key}"}
             )
             response.raise_for_status()
             return [f"groq/{model['id']}" for model in response.json().get("data", [])]
-        except requests.RequestException as e:
-            logging.error(f"Failed to fetch Groq models: {e}")
+        except httpx.RequestError as e:
+            lib_logger.error(f"Failed to fetch Groq models: {e}")
             return []

src/rotator_library/providers/mistral_provider.py

@@ -1,23 +1,28 @@
-import requests
+import httpx
 import logging
 from typing import List
 from .provider_interface import ProviderInterface
 
+lib_logger = logging.getLogger('rotator_library')
+lib_logger.propagate = False # Ensure this logger doesn't propagate to root
+if not lib_logger.handlers:
+    lib_logger.addHandler(logging.NullHandler())
+
 class MistralProvider(ProviderInterface):
     """
     Provider implementation for the Mistral API.
     """
-    async def get_models(self, api_key: str) -> List[str]:
+    async def get_models(self, api_key: str, client: httpx.AsyncClient) -> List[str]:
         """
         Fetches the list of available models from the Mistral API.
         """
         try:
-            response = requests.get(
+            response = await client.get(
                 "https://api.mistral.ai/v1/models",
                 headers={"Authorization": f"Bearer {api_key}"}
             )
             response.raise_for_status()
             return [f"mistral/{model['id']}" for model in response.json().get("data", [])]
-        except requests.RequestException as e:
-            logging.error(f"Failed to fetch Mistral models: {e}")
+        except httpx.RequestError as e:
+            lib_logger.error(f"Failed to fetch Mistral models: {e}")
             return []

src/rotator_library/providers/openai_provider.py

@@ -1,23 +1,28 @@
-import requests
+import httpx
 import logging
 from typing import List
 from .provider_interface import ProviderInterface
 
+lib_logger = logging.getLogger('rotator_library')
+lib_logger.propagate = False # Ensure this logger doesn't propagate to root
+if not lib_logger.handlers:
+    lib_logger.addHandler(logging.NullHandler())
+
 class OpenAIProvider(ProviderInterface):
     """
     Provider implementation for the OpenAI API.
     """
-    async def get_models(self, api_key: str) -> List[str]:
+    async def get_models(self, api_key: str, client: httpx.AsyncClient) -> List[str]:
         """
         Fetches the list of available models from the OpenAI API.
         """
         try:
-            response = requests.get(
+            response = await client.get(
                 "https://api.openai.com/v1/models",
                 headers={"Authorization": f"Bearer {api_key}"}
             )
             response.raise_for_status()
             return [f"openai/{model['id']}" for model in response.json().get("data", [])]
-        except requests.RequestException as e:
-            logging.error(f"Failed to fetch OpenAI models: {e}")
+        except httpx.RequestError as e:
+            lib_logger.error(f"Failed to fetch OpenAI models: {e}")
             return []

src/rotator_library/providers/openrouter_provider.py

@@ -1,23 +1,28 @@
-import requests
+import httpx
 import logging
 from typing import List
 from .provider_interface import ProviderInterface
 
+lib_logger = logging.getLogger('rotator_library')
+lib_logger.propagate = False # Ensure this logger doesn't propagate to root
+if not lib_logger.handlers:
+    lib_logger.addHandler(logging.NullHandler())
+
 class OpenRouterProvider(ProviderInterface):
     """
     Provider implementation for the OpenRouter API.
     """
-    async def get_models(self, api_key: str) -> List[str]:
+    async def get_models(self, api_key: str, client: httpx.AsyncClient) -> List[str]:
         """
         Fetches the list of available models from the OpenRouter API.
         """
         try:
-            response = requests.get(
+            response = await client.get(
                 "https://openrouter.ai/api/v1/models",
                 headers={"Authorization": f"Bearer {api_key}"}
             )
             response.raise_for_status()
             return [f"openrouter/{model['id']}" for model in response.json().get("data", [])]
-        except requests.RequestException as e:
-            logging.error(f"Failed to fetch OpenRouter models: {e}")
+        except httpx.RequestError as e:
+            lib_logger.error(f"Failed to fetch OpenRouter models: {e}")
             return []

src/rotator_library/providers/provider_interface.py

@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
-from typing import List, Any
+from typing import List
+import httpx
 
 class ProviderInterface(ABC):
     """
@@ -8,12 +9,13 @@ class ProviderInterface(ABC):
     """
 
     @abstractmethod
-    async def get_models(self, api_key: str) -> List[str]:
+    async def get_models(self, api_key: str, client: httpx.AsyncClient) -> List[str]:
         """
         Fetches the list of available model names from the provider's API.
 
         Args:
             api_key: The API key required for authentication.
+            client: An httpx.AsyncClient instance for making requests.
 
         Returns:
             A list of model name strings.

src/rotator_library/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "rotating-api-key-client"
-version = "0.5.2"
+version = "0.5.5"
 authors = [
     { name="Mirrowel", email="nuh@uh.com" },
 ]
@@ -19,7 +19,7 @@ classifiers = [
 dependencies = [
     "litellm",
     "filelock",
-    "requests",
+    "httpx"
 ]
 
 [project.urls]

src/rotator_library/usage_manager.py

@@ -1,11 +1,17 @@
 import json
 import os
 import time
+import logging
 from datetime import date, datetime
 from typing import Dict, List, Optional, Any
 from filelock import FileLock
 import litellm
 
+lib_logger = logging.getLogger('rotator_library')
+lib_logger.propagate = False # Ensure this logger doesn't propagate to root
+if not lib_logger.handlers:
+    lib_logger.addHandler(logging.NullHandler())
+
 class UsageManager:
     """
     Manages daily and global usage statistics and cooldowns for API keys.
@@ -109,7 +115,7 @@ class UsageManager:
             cost = litellm.completion_cost(completion_response=completion_response)
             daily_model_data["approx_cost"] += cost
         except Exception as e:
-            print(f"Warning: Could not calculate cost for model {model}: {e}")
+            lib_logger.warning(f"Could not calculate cost for model {model}: {e}")
 
         key_data["last_used_ts"] = time.time()
         self._save_usage()