Added async OpenAI services (#1)

* added async openai services

* added async openai services

* added Deepgram service with 05 example

* modernized the 'say one thing' example

* async all the things

* cleanup and user greeting

* more cleanup

src/dailyai/services/deepgram_ai_services.py

@@ -0,0 +1,29 @@
+import aiohttp
+import asyncio
+import os
+
+import requests
+
+from collections.abc import AsyncGenerator
+from dailyai.services.ai_services import TTSService
+
+class DeepgramTTSService(TTSService):
+    def __init__(self, speech_key=None, voice=None):
+        super().__init__()
+
+        self.voice = voice or os.getenv("DEEPGRAM_VOICE") or "alpha-asteria-en-v2"
+        self.speech_key = speech_key or os.getenv("DEEPGRAM_API_KEY")
+    
+    def get_mic_sample_rate(self):
+        return 24000
+
+    async def run_tts(self, sentence) -> AsyncGenerator[bytes, None]:
+        self.logger.info(f"Running deepgram tts for {sentence}")
+        base_url = "https://api.beta.deepgram.com/v1/speak"
+        request_url = f"{base_url}?model={self.voice}&encoding=linear16&container=none&sample_rate=16000"
+        headers = {"authorization": f"token {self.speech_key}"}
+        body = { "text": sentence }
+        async with aiohttp.ClientSession() as session:
+            async with session.post(request_url, headers=headers, json=body) as r:
+                async for data in r.content:
+                    yield data

src/dailyai/services/open_ai_services.py

@@ -1,33 +1,36 @@
-from dailyai.services.ai_services import AIService, TTSService, LLMService, ImageGenService
-from typing import Generator
-
 import requests
+import aiohttp
+import asyncio
 from PIL import Image
 import io
-from openai import OpenAI
+from openai import AsyncOpenAI
 
 import os
 import json
+from collections.abc import AsyncGenerator
+
+from dailyai.services.ai_services import AIService, TTSService, LLMService, ImageGenService
+
 
 class OpenAILLMService(LLMService):
     def __init__(self, api_key=None, model=None):
         super().__init__()
         api_key = api_key or os.getenv("OPEN_AI_KEY")
-        self.model = model or os.getenv("OPEN_AI_MODEL")
-        self.client = OpenAI(api_key=api_key)
+        self.model = model or os.getenv("OPEN_AI_LLM_MODEL") or "gpt-4"
+        self.client = AsyncOpenAI(api_key=api_key)
 
-    def get_response(self, messages, stream):
-        return self.client.chat.completions.create(
+    async def get_response(self, messages, stream):
+        return await self.client.chat.completions.create(
             stream=stream,
             messages=messages,
             model=self.model
         )
 
-    def run_llm_async(self, messages) -> Generator[str, None, None]:
+    async def run_llm_async(self, messages) -> AsyncGenerator[str, None]:
         messages_for_log = json.dumps(messages)
         self.logger.debug(f"Generating chat via openai: {messages_for_log}")
 
-        response = self.get_response(messages, stream=True)
+        response = await self.get_response(messages, stream=True)
 
         for chunk in response:
             if len(chunk.choices) == 0:
@@ -36,11 +39,11 @@ class OpenAILLMService(LLMService):
             if chunk.choices[0].delta.content:
                 yield chunk.choices[0].delta.content
 
-    def run_llm(self, messages) -> str | None:
+    async def run_llm(self, messages) -> str | None:
         messages_for_log = json.dumps(messages)
-        self.logger.debug(f"Generating chat via azure: {messages_for_log}")
+        self.logger.debug(f"Generating chat via openai: {messages_for_log}")
 
-        response = self.get_response(messages, stream=False)
+        response = await self.get_response(messages, stream=False)
         if response and len(response.choices) > 0:
             return response.choices[0].message.content
         else:
@@ -50,18 +53,22 @@ class OpenAIImageGenService(ImageGenService):
     def __init__(self, api_key=None, model=None):
         super().__init__()
         api_key = api_key or os.getenv("OPEN_AI_KEY")
-        self.model = model or os.getenv("OPEN_AI_MODEL")
-        self.client = OpenAI(api_key=api_key)
+        self.model = model or os.getenv("OPEN_AI_IMAGE_MODEL") or "dall-e-3"
+        self.client = AsyncOpenAI(api_key=api_key)
 
-    def run_image_gen(self, sentence) -> tuple[str, Image.Image]:
-        image = self.client.images.generate(
+    async def run_image_gen(self, sentence, size) -> tuple[str, bytes]:
+        self.logger.info("Generating OpenAI image", sentence)
+
+        image = await self.client.images.generate(
             prompt=sentence,
+            model=self.model,
             n=1,
-            size=f"1024x1024"
+            size=size
         )
         image_url = image.data[0].url
         response = requests.get(image_url)
+
         dalle_stream = io.BytesIO(response.content)
         dalle_im = Image.open(dalle_stream)
 
-        return (image_url, dalle_im)
+        return (image_url, dalle_im.tobytes())