Updated to use black formating

Author: mrm9084

examples/Python/ChatApp/app.py

@@ -11,7 +11,9 @@
 # Get Azure App Configuration endpoint from environment variable
 ENDPOINT = os.environ.get("AZURE_APPCONFIG_ENDPOINT")
 if not ENDPOINT:
-    raise ValueError("The environment variable 'AZURE_APPCONFIG_ENDPOINT' is not set or is empty.")
+    raise ValueError(
+        "The environment variable 'AZURE_APPCONFIG_ENDPOINT' is not set or is empty."
+    )
 
 # Initialize Azure credentials
 credential = DefaultAzureCredential()
@@ -29,99 +31,105 @@
     trim_prefixes=["ChatApp:"],
 )
 
-T = TypeVar('T')
+T = TypeVar("T")
+
 
 # Get OpenAI configuration
 def get_openai_client():
     """Create and return an Azure OpenAI client"""
     endpoint = config.get("AzureOpenAI:Endpoint")
     # Get API key from App Configuration or fall back to environment variable
     api_key = config.get("AzureOpenAI:ApiKey", os.environ.get("AZURE_OPENAI_API_KEY"))
-    api_version = config.get("AzureOpenAI:ApiVersion", "2023-05-15")  # Read API version from config or use default
-    
+    api_version = config.get(
+        "AzureOpenAI:ApiVersion", "2023-05-15"
+    )  # Read API version from config or use default
+
     # For DefaultAzureCredential auth if no API key is available
     if not api_key:
         token_provider = get_bearer_token_provider(
             DefaultAzureCredential(), "https://cognitiveservices.azure.com/.default"
         )
         return AzureOpenAI(
-            azure_endpoint=endpoint, 
+            azure_endpoint=endpoint,
             api_version=api_version,
-            azure_ad_token_provider=token_provider
+            azure_ad_token_provider=token_provider,
         )
-    
+
     # For API key auth
     return AzureOpenAI(
-        azure_endpoint=endpoint,
-        api_key=api_key,
-        api_version=api_version
+        azure_endpoint=endpoint, api_key=api_key, api_version=api_version
     )
 
+
 def get_chat_messages(messages: List[Message]):
     """Convert from model Message objects to OpenAI messages format"""
     return [{"role": msg.role, "content": msg.content} for msg in messages]
 
+
 def main():
     """Main entry point for the console app"""
     # Get OpenAI client
     client = get_openai_client()
-    
+
     # Get deployment name
     deployment_name = config.get("AzureOpenAI:DeploymentName")
-    
+
     # Initialize conversation history with the configuration messages
     conversation_history = []
     first_run = True
-    
+
     print("Chat Application - type 'exit' to quit\n")
-    
+
     while True:
         # Refresh configuration from Azure App Configuration
         config.refresh()
-        
+
         # Get model configuration using data binding
         model_config = ModelConfiguration.from_dict(config.get("Model"))
-        
+
         # On first run, initialize conversation history with configuration messages
         # and display the initial messages
         if first_run:
             conversation_history = model_config.messages.copy()
             for msg in conversation_history:
                 print(f"{msg.role}: {msg.content}")
             first_run = False
-        
+
         # Get chat messages for the API
         messages = get_chat_messages(conversation_history)
-        
+
         # Get response from OpenAI
         response = client.chat.completions.create(
             model=deployment_name,
             messages=messages,
             max_tokens=model_config.max_tokens,
             temperature=model_config.temperature,
-            top_p=model_config.top_p
+            top_p=model_config.top_p,
         )
-        
+
         # Extract assistant message
         assistant_message = response.choices[0].message.content
-        
+
         # Display the response
         print(f"assistant: {assistant_message}")
-        
+
         # Add assistant response to conversation history
-        conversation_history.append(Message(role="assistant", content=assistant_message))
-        
+        conversation_history.append(
+            Message(role="assistant", content=assistant_message)
+        )
+
         # Get user input for the next message
         print("\nuser: ", end="")
         user_input = input().strip()
-        
+
         # Check if user wants to exit
-        if user_input.lower() == 'exit':
+        if user_input.lower() == "exit":
             print("Exiting application...")
             break
-        
+
         # Add user input to conversation history
         conversation_history.append(Message(role="user", content=user_input))
 
-if __name__ == '__main__':
-    main()
+
+if __name__ == "__main__":
+    main()

examples/Python/ChatApp/models.py

@@ -9,45 +9,46 @@ class Message:
     Represents a chat message with a role and content.
     Maps to configuration values with keys 'role' and 'content'.
     """
+
     def __init__(self, role: Optional[str] = None, content: Optional[str] = None):
         self.role = role
         self.content = content
-    
+
     @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> 'Message':
+    def from_dict(cls, data: Dict[str, Any]) -> "Message":
         """Create a Message instance from a dictionary."""
-        return cls(
-            role=data.get('role'),
-            content=data.get('content')
-        )
+        return cls(role=data.get("role"), content=data.get("content"))
 
 
 class ModelConfiguration:
     """
     Represents the configuration for an AI model including messages and parameters.
     Maps to configuration values with keys 'model', 'messages', 'max_tokens', 'temperature', and 'top_p'.
     """
-    def __init__(self, 
-                 model: Optional[str] = None, 
-                 messages: Optional[List[Message]] = None,
-                 max_tokens: int = 1024, 
-                 temperature: float = 0.7, 
-                 top_p: float = 0.95):
+
+    def __init__(
+        self,
+        model: Optional[str] = None,
+        messages: Optional[List[Message]] = None,
+        max_tokens: int = 1024,
+        temperature: float = 0.7,
+        top_p: float = 0.95,
+    ):
         self.model = model
         self.messages = messages or []
         self.max_tokens = int(max_tokens) if max_tokens is not None else 1024
         self.temperature = float(temperature) if temperature is not None else 0.7
         self.top_p = float(top_p) if top_p is not None else 0.95
-    
+
     @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> 'ModelConfiguration':
+    def from_dict(cls, data: Dict[str, Any]) -> "ModelConfiguration":
         """Create a ModelConfiguration instance from a dictionary."""
-        messages = [Message.from_dict(msg) for msg in data.get('messages', [])]
-        
+        messages = [Message.from_dict(msg) for msg in data.get("messages", [])]
+
         return cls(
-            model=data.get('model'),
+            model=data.get("model"),
             messages=messages,
-            max_tokens=data.get('max_tokens', 1024),
-            temperature=data.get('temperature', 0.7),
-            top_p=data.get('top_p', 0.95)
-        )
+            max_tokens=data.get("max_tokens", 1024),
+            temperature=data.get("temperature", 0.7),
+            top_p=data.get("top_p", 0.95),
+        )