Linting.

Author: edwinokonkwo

packages/core/ldai/__init__.py

@@ -5,38 +5,21 @@
 # to extend ldai.providers.* even though ldai itself has an __init__.py
 import sys
 from pkgutil import extend_path
+
 __path__ = extend_path(__path__, __name__)
 
+# Export chat
+from ldai.chat import TrackedChat
 # Export main client
 from ldai.client import LDAIClient
-
-# Export models for convenience
-from ldai.models import (
-    AIAgentConfig,
-    AIAgentConfigDefault,
-    AIAgentConfigRequest,
-    AIAgents,
-    AICompletionConfig,
-    AICompletionConfigDefault,
-    AIJudgeConfig,
-    AIJudgeConfigDefault,
-    JudgeConfiguration,
-    LDMessage,
-    ModelConfig,
-    ProviderConfig,
-    # Deprecated aliases for backward compatibility
-    AIConfig,
-    LDAIAgent,
-    LDAIAgentConfig,
-    LDAIAgentDefaults,
-)
-
 # Export judge
 from ldai.judge import AIJudge
-
-# Export chat
-from ldai.chat import TrackedChat
-
+# Export models for convenience
+from ldai.models import (  # Deprecated aliases for backward compatibility
+    AIAgentConfig, AIAgentConfigDefault, AIAgentConfigRequest, AIAgents,
+    AICompletionConfig, AICompletionConfigDefault, AIConfig, AIJudgeConfig,
+    AIJudgeConfigDefault, JudgeConfiguration, LDAIAgent, LDAIAgentConfig,
+    LDAIAgentDefaults, LDMessage, ModelConfig, ProviderConfig)
 # Export judge types
 from ldai.providers.types import EvalScore, JudgeResponse
 

packages/core/ldai/chat/__init__.py

@@ -3,4 +3,3 @@
 from ldai.chat.tracked_chat import TrackedChat
 
 __all__ = ['TrackedChat']
-

packages/core/ldai/chat/tracked_chat.py

@@ -3,18 +3,18 @@
 import asyncio
 from typing import Any, Dict, List, Optional
 
+from ldai.judge import AIJudge
 from ldai.models import AICompletionConfig, LDMessage
 from ldai.providers.ai_provider import AIProvider
 from ldai.providers.types import ChatResponse, JudgeResponse
-from ldai.judge import AIJudge
 from ldai.tracker import LDAIConfigTracker
 
 
 class TrackedChat:
     """
     Concrete implementation of TrackedChat that provides chat functionality
     by delegating to an AIProvider implementation.
-    
+
     This class handles conversation management and tracking, while delegating
     the actual model invocation to the provider.
     """
@@ -29,7 +29,7 @@ def __init__(
     ):
         """
         Initialize the TrackedChat.
-        
+
         :param ai_config: The completion AI configuration
         :param tracker: The tracker for the completion configuration
         :param provider: The AI provider to use for chat
@@ -46,9 +46,9 @@ def __init__(
     async def invoke(self, prompt: str) -> ChatResponse:
         """
         Invoke the chat model with a prompt string.
-        
+
         This method handles conversation management and tracking, delegating to the provider's invoke_model method.
-        
+
         :param prompt: The user prompt to send to the chat model
         :return: ChatResponse containing the model's response and metrics
         """
@@ -83,9 +83,9 @@ def _start_judge_evaluations(
     ) -> List[asyncio.Task[Optional[JudgeResponse]]]:
         """
         Start judge evaluations as async tasks without awaiting them.
-        
+
         Returns a list of async tasks that can be awaited later.
-        
+
         :param messages: Array of messages representing the conversation history
         :param response: The AI response to be evaluated
         :return: List of async tasks that will return judge evaluation results
@@ -119,60 +119,60 @@ async def evaluate_judge(judge_config):
             asyncio.create_task(evaluate_judge(judge_config))
             for judge_config in judge_configs
         ]
-        
+
         return tasks
 
     def get_config(self) -> AICompletionConfig:
         """
         Get the underlying AI configuration used to initialize this TrackedChat.
-        
+
         :return: The AI completion configuration
         """
         return self._ai_config
 
     def get_tracker(self) -> LDAIConfigTracker:
         """
         Get the underlying AI configuration tracker used to initialize this TrackedChat.
-        
+
         :return: The tracker instance
         """
         return self._tracker
 
     def get_provider(self) -> AIProvider:
         """
         Get the underlying AI provider instance.
-        
+
         This provides direct access to the provider for advanced use cases.
-        
+
         :return: The AI provider instance
         """
         return self._provider
 
     def get_judges(self) -> Dict[str, AIJudge]:
         """
         Get the judges associated with this TrackedChat.
-        
+
         Returns a dictionary of judge instances keyed by their configuration keys.
-        
+
         :return: Dictionary of judge instances
         """
         return self._judges
 
     def append_messages(self, messages: List[LDMessage]) -> None:
         """
         Append messages to the conversation history.
-        
+
         Adds messages to the conversation history without invoking the model,
         which is useful for managing multi-turn conversations or injecting context.
-        
+
         :param messages: Array of messages to append to the conversation history
         """
         self._messages.extend(messages)
 
     def get_messages(self, include_config_messages: bool = False) -> List[LDMessage]:
         """
         Get all messages in the conversation history.
-        
+
         :param include_config_messages: Whether to include the config messages from the AIConfig.
                                        Defaults to False.
         :return: Array of messages. When include_config_messages is True, returns both config
@@ -183,4 +183,3 @@ def get_messages(self, include_config_messages: bool = False) -> List[LDMessage]
             config_messages = self._ai_config.messages or []
             return config_messages + self._messages
         return list(self._messages)
-

packages/core/ldai/client.py

@@ -7,21 +7,13 @@
 
 from ldai.chat import TrackedChat
 from ldai.judge import AIJudge
-from ldai.models import (
-    AIAgentConfig,
-    AIAgentConfigDefault,
-    AIAgentConfigRequest,
-    AIAgents,
-    AICompletionConfig,
-    AICompletionConfigDefault,
-    AIJudgeConfig,
-    AIJudgeConfigDefault,
-    JudgeConfiguration,
-    LDMessage,
-    ModelConfig,
-    ProviderConfig,
-)
-from ldai.providers.ai_provider_factory import AIProviderFactory, SupportedAIProvider
+from ldai.models import (AIAgentConfig, AIAgentConfigDefault,
+                         AIAgentConfigRequest, AIAgents, AICompletionConfig,
+                         AICompletionConfigDefault, AIJudgeConfig,
+                         AIJudgeConfigDefault, JudgeConfiguration, LDMessage,
+                         ModelConfig, ProviderConfig)
+from ldai.providers.ai_provider_factory import (AIProviderFactory,
+                                                SupportedAIProvider)
 from ldai.tracker import LDAIConfigTracker
 
 
@@ -204,15 +196,15 @@ async def _initialize_judges(
     ) -> Dict[str, AIJudge]:
         """
         Initialize judges from judge configurations.
-        
+
         :param judge_configs: List of judge configurations
         :param context: Standard Context used when evaluating flags
         :param variables: Dictionary of values for instruction interpolation
         :param default_ai_provider: Optional default AI provider to use
         :return: Dictionary of judge instances keyed by their configuration keys
         """
         judges: Dict[str, AIJudge] = {}
-        
+
         async def create_judge_for_config(judge_key: str):
             judge = await self.create_judge(
                 judge_key,
@@ -222,22 +214,22 @@ async def create_judge_for_config(judge_key: str):
                 default_ai_provider,
             )
             return judge_key, judge
-        
+
         judge_promises = [
             create_judge_for_config(judge_config.key)
             for judge_config in judge_configs
         ]
-        
+
         import asyncio
         results = await asyncio.gather(*judge_promises, return_exceptions=True)
-        
+
         for result in results:
             if isinstance(result, Exception):
                 continue
-            judge_key, judge = result
+            judge_key, judge = result  # type: ignore[misc]
             if judge:
                 judges[judge_key] = judge
-        
+
         return judges
 
     async def create_chat(
@@ -275,7 +267,7 @@ async def create_chat(
             if chat:
                 response = await chat.invoke("I need help with my order")
                 print(response.message.content)
-                
+
                 # Access conversation history
                 messages = chat.get_messages()
                 print(f"Conversation has {len(messages)} messages")

packages/core/ldai/judge/__init__.py

@@ -3,5 +3,3 @@
 from ldai.judge.ai_judge import AIJudge
 
 __all__ = ['AIJudge']
-
-

packages/core/ldai/judge/ai_judge.py

@@ -5,17 +5,18 @@
 
 import chevron
 
+from ldai.judge.evaluation_schema_builder import EvaluationSchemaBuilder
 from ldai.models import AIJudgeConfig, LDMessage
 from ldai.providers.ai_provider import AIProvider
-from ldai.providers.types import ChatResponse, EvalScore, JudgeResponse, StructuredResponse
+from ldai.providers.types import (ChatResponse, EvalScore, JudgeResponse,
+                                  StructuredResponse)
 from ldai.tracker import LDAIConfigTracker
-from ldai.judge.evaluation_schema_builder import EvaluationSchemaBuilder
 
 
 class AIJudge:
     """
     Judge implementation that handles evaluation functionality and conversation management.
-    
+
     According to the AIEval spec, judges are AI Configs with mode: "judge" that evaluate
     other AI Configs using structured output.
     """
@@ -29,7 +30,7 @@ def __init__(
     ):
         """
         Initialize the Judge.
-        
+
         :param ai_config: The judge AI configuration
         :param ai_config_tracker: The tracker for the judge configuration
         :param ai_provider: The AI provider to use for evaluation
@@ -51,7 +52,7 @@ async def evaluate(
     ) -> Optional[JudgeResponse]:
         """
         Evaluates an AI response using the judge's configuration.
-        
+
         :param input_text: The input prompt or question that was provided to the AI
         :param output_text: The AI-generated response to be evaluated
         :param sampling_rate: Sampling rate (0-1) to determine if evaluation should be processed (defaults to 1)
@@ -113,7 +114,7 @@ async def evaluate_messages(
     ) -> Optional[JudgeResponse]:
         """
         Evaluates an AI response from chat messages and response.
-        
+
         :param messages: Array of messages representing the conversation history
         :param response: The AI response to be evaluated
         :param sampling_ratio: Sampling ratio (0-1) to determine if evaluation should be processed (defaults to 1)
@@ -127,31 +128,31 @@ async def evaluate_messages(
     def get_ai_config(self) -> AIJudgeConfig:
         """
         Returns the AI Config used by this judge.
-        
+
         :return: The judge AI configuration
         """
         return self._ai_config
 
     def get_tracker(self) -> LDAIConfigTracker:
         """
         Returns the tracker associated with this judge.
-        
+
         :return: The tracker for the judge configuration
         """
         return self._ai_config_tracker
 
     def get_provider(self) -> AIProvider:
         """
         Returns the AI provider used by this judge.
-        
+
         :return: The AI provider
         """
         return self._ai_provider
 
     def _construct_evaluation_messages(self, input_text: str, output_text: str) -> list[LDMessage]:
         """
         Constructs evaluation messages by combining judge's config messages with input/output.
-        
+
         :param input_text: The input text
         :param output_text: The output text to evaluate
         :return: List of messages for evaluation
@@ -173,7 +174,7 @@ def _construct_evaluation_messages(self, input_text: str, output_text: str) -> l
     def _interpolate_message(self, content: str, variables: Dict[str, str]) -> str:
         """
         Interpolates message content with variables using Mustache templating.
-        
+
         :param content: The message content template
         :param variables: Variables to interpolate
         :return: Interpolated message content
@@ -184,7 +185,7 @@ def _interpolate_message(self, content: str, variables: Dict[str, str]) -> str:
     def _parse_evaluation_response(self, data: Dict[str, Any]) -> Dict[str, EvalScore]:
         """
         Parses the structured evaluation response from the AI provider.
-        
+
         :param data: The structured response data
         :return: Dictionary of evaluation scores keyed by metric key
         """
@@ -227,4 +228,3 @@ def _parse_evaluation_response(self, data: Dict[str, Any]) -> Dict[str, EvalScor
             results[metric_key] = EvalScore(score=float(score), reasoning=reasoning)
 
         return results
-