remove unnecessary litellm reference

Author: asamal4

src/lightspeed_evaluation/core/llm/deepeval.py

@@ -1,4 +1,4 @@
-"""DeepEval LLM Manager - DeepEval-specific LLM wrapper that takes LiteLLM parameters."""
+"""DeepEval LLM Manager - DeepEval-specific LLM wrapper."""
 
 from typing import Any
 
@@ -11,32 +11,32 @@ class DeepEvalLLMManager:
     This manager focuses solely on DeepEval-specific LLM integration.
     """
 
-    def __init__(self, model_name: str, litellm_params: dict[str, Any]):
+    def __init__(self, model_name: str, llm_params: dict[str, Any]):
         """Initialize with LLM parameters from LLMManager."""
         self.model_name = model_name
-        self.litellm_params = litellm_params
+        self.llm_params = llm_params
 
-        # Create DeepEval's LiteLLMModel with provided parameters
+        # Create DeepEval's LLM model with provided parameters
         self.llm_model = LiteLLMModel(
             model=self.model_name,
-            temperature=litellm_params.get("temperature", 0.0),
-            max_tokens=litellm_params.get("max_tokens"),
-            timeout=litellm_params.get("timeout"),
-            num_retries=litellm_params.get("num_retries", 3),
+            temperature=llm_params.get("temperature", 0.0),
+            max_tokens=llm_params.get("max_tokens"),
+            timeout=llm_params.get("timeout"),
+            num_retries=llm_params.get("num_retries", 3),
         )
 
         print(f"✅ DeepEval LLM Manager: {self.model_name}")
 
     def get_llm(self) -> LiteLLMModel:
-        """Get the configured DeepEval LiteLLM model."""
+        """Get the configured DeepEval LLM model."""
         return self.llm_model
 
     def get_model_info(self) -> dict[str, Any]:
         """Get information about the configured model."""
         return {
             "model_name": self.model_name,
-            "temperature": self.litellm_params.get("temperature", 0.0),
-            "max_tokens": self.litellm_params.get("max_tokens"),
-            "timeout": self.litellm_params.get("timeout"),
-            "num_retries": self.litellm_params.get("num_retries", 3),
+            "temperature": self.llm_params.get("temperature", 0.0),
+            "max_tokens": self.llm_params.get("max_tokens"),
+            "timeout": self.llm_params.get("timeout"),
+            "num_retries": self.llm_params.get("num_retries", 3),
         }

src/lightspeed_evaluation/core/llm/manager.py

@@ -13,7 +13,7 @@ class LLMManager:
     Responsibilities:
     - Environment validation for multiple providers
     - Model name construction
-    - Provides LiteLLM parameters for consumption by framework-specific managers
+    - Provides LLM parameters for consumption by framework-specific managers
     """
 
     def __init__(self, config: LLMConfig):
@@ -25,7 +25,7 @@ def __init__(self, config: LLMConfig):
         )
 
     def _construct_model_name_and_validate(self) -> str:
-        """Construct model name for LiteLLM and validate required environment variables."""
+        """Construct model name and validate required environment variables."""
         provider = self.config.provider.lower()
 
         # Provider-specific validation and model name construction
@@ -89,11 +89,11 @@ def _handle_ollama_provider(self) -> str:
         return f"ollama/{self.config.model}"
 
     def get_model_name(self) -> str:
-        """Get the constructed LiteLLM model name."""
+        """Get the constructed model name."""
         return self.model_name
 
-    def get_litellm_params(self) -> dict[str, Any]:
-        """Get parameters for LiteLLM completion calls."""
+    def get_llm_params(self) -> dict[str, Any]:
+        """Get parameters for LLM completion calls."""
         return {
             "model": self.model_name,
             "temperature": self.config.temperature,

src/lightspeed_evaluation/core/llm/ragas.py

@@ -1,4 +1,4 @@
-"""Ragas LLM Manager - Ragas-specific LLM wrapper that takes LiteLLM parameters."""
+"""Ragas LLM Manager - Ragas-specific LLM wrapper."""
 
 from typing import Any, Optional
 
@@ -10,12 +10,12 @@
 
 
 class RagasCustomLLM(BaseRagasLLM, BaseCustomLLM):
-    """Custom LLM for Ragas using LiteLLM parameters."""
+    """Custom LLM for Ragas."""
 
-    def __init__(self, model_name: str, litellm_params: dict[str, Any]):
-        """Initialize Ragas custom LLM with model name and LiteLLM parameters."""
+    def __init__(self, model_name: str, llm_params: dict[str, Any]):
+        """Initialize Ragas custom LLM with model name and LLM parameters."""
         BaseRagasLLM.__init__(self)
-        BaseCustomLLM.__init__(self, model_name, litellm_params)
+        BaseCustomLLM.__init__(self, model_name, llm_params)
         print(f"✅ Ragas Custom LLM: {self.model_name}")
 
     def generate_text(  # pylint: disable=too-many-arguments,too-many-positional-arguments
@@ -26,14 +26,14 @@ def generate_text(  # pylint: disable=too-many-arguments,too-many-positional-arg
         stop: Optional[list[str]] = None,
         callbacks: Optional[Any] = None,
     ) -> LLMResult:
-        """Generate text using LiteLLM with provided parameters."""
+        """Generate text using LLM with provided parameters."""
         prompt_text = str(prompt)
 
         # Use temperature from params unless explicitly overridden
         temp = (
             temperature
             if temperature != 1e-08
-            else self.litellm_params.get("temperature", 0.0)
+            else self.llm_params.get("temperature", 0.0)
         )
 
         try:
@@ -84,11 +84,11 @@ class RagasLLMManager:
     This manager focuses solely on Ragas-specific LLM integration.
     """
 
-    def __init__(self, model_name: str, litellm_params: dict[str, Any]):
+    def __init__(self, model_name: str, llm_params: dict[str, Any]):
         """Initialize with LLM parameters from LLMManager."""
         self.model_name = model_name
-        self.litellm_params = litellm_params
-        self.custom_llm = RagasCustomLLM(model_name, litellm_params)
+        self.llm_params = llm_params
+        self.custom_llm = RagasCustomLLM(model_name, llm_params)
 
         # Configure Ragas metrics to use our custom LLM
         answer_relevancy.llm = self.custom_llm
@@ -104,5 +104,5 @@ def get_model_info(self) -> dict[str, Any]:
         """Get information about the configured model."""
         return {
             "model_name": self.model_name,
-            "temperature": self.litellm_params.get("temperature", 0.0),
+            "temperature": self.llm_params.get("temperature", 0.0),
         }

src/lightspeed_evaluation/core/metrics/custom.py

@@ -28,7 +28,7 @@ class EvaluationPromptParams(BaseModel):
 
 
 class CustomMetrics:  # pylint: disable=too-few-public-methods
-    """Handles custom metrics using LLMManager for direct LiteLLM calls."""
+    """Handles custom metrics using LLMManager for direct LLM calls."""
 
     def __init__(self, llm_manager: LLMManager):
         """Initialize with LLM Manager.
@@ -37,7 +37,7 @@ def __init__(self, llm_manager: LLMManager):
             llm_manager: Pre-configured LLMManager with validated parameters
         """
         self.llm = BaseCustomLLM(
-            llm_manager.get_model_name(), llm_manager.get_litellm_params()
+            llm_manager.get_model_name(), llm_manager.get_llm_params()
         )
 
         self.supported_metrics = {

src/lightspeed_evaluation/core/metrics/deepeval.py

@@ -26,7 +26,7 @@ def __init__(self, llm_manager: LLMManager):
         """
         # Create LLM Manager for DeepEval metrics
         self.llm_manager = DeepEvalLLMManager(
-            llm_manager.get_model_name(), llm_manager.get_litellm_params()
+            llm_manager.get_model_name(), llm_manager.get_llm_params()
         )
 
         self.supported_metrics = {

src/lightspeed_evaluation/core/metrics/ragas.py

@@ -36,7 +36,7 @@ def __init__(self, llm_manager: LLMManager, embedding_manager: EmbeddingManager)
         # Note, it's not actually used, it modifies
         # global ragas.metrics settings during instance init
         self.llm_manager = RagasLLMManager(
-            llm_manager.get_model_name(), llm_manager.get_litellm_params()
+            llm_manager.get_model_name(), llm_manager.get_llm_params()
         )
         self.embedding_manager = RagasEmbeddingManager(embedding_manager)
 

tests/unit/core/llm/test_manager.py

@@ -66,8 +66,8 @@ def test_get_model_name(self):
             manager = LLMManager(config)
             assert manager.get_model_name() == "gpt-4"
 
-    def test_get_litellm_params(self):
-        """Test get_litellm_params method."""
+    def test_get_llm_params(self):
+        """Test get_llm_params method."""
         config = LLMConfig(
             provider="openai",
             model="gpt-4",
@@ -79,7 +79,7 @@ def test_get_litellm_params(self):
 
         with patch.dict(os.environ, {"OPENAI_API_KEY": "test-key"}):
             manager = LLMManager(config)
-            params = manager.get_litellm_params()
+            params = manager.get_llm_params()
 
             expected = {
                 "model": "gpt-4",