various cleanup and clarifications

Author: paulparkinson

python-realtimeSTT-NL2SQL-TTS/src/STTSelectAITTS.py renamed to interactive-ai-holograms/python-realtimespeech-selectai/src/variations/AIHoloPython.py

@@ -27,13 +27,21 @@
 compartment_id = os.getenv('COMPARTMENT_ID')
 print(f"compartment_id: {compartment_id}")
 
+# connection = oracledb.connect(
+#     user="user",
+#     password="userpw",
+#     dsn="yourdb_high",
+#     config_dir=r"C:\locationofyourwallet",
+#     wallet_location=r"C:\locationofyourwallet",
+#     wallet_password="walletpw"
+# )
 connection = oracledb.connect(
-    user="user",
-    password="userpw",
-    dsn="yourdb_high",
-    config_dir=r"C:\locationofyourwallet",
-    wallet_location=r"C:\locationofyourwallet",
-    wallet_password="walletpw"
+    user="moviestream",
+    password="Welcome12345",
+    dsn="selectaidb_high",
+    config_dir="/Users/pparkins/Downloads/Wallet_SelectAIDB",
+    wallet_location="/Users/pparkins/Downloads/Wallet_SelectAIDB",
+    wallet_password="Welcome12345"
 )
 print(f"Successfully connected to Oracle Database Connection: {connection}")
 

python-realtimeSTT-NL2SQL-TTS/README.md

@@ -3,6 +3,6 @@ located here: https://livelabs.oracle.com/pls/apex/r/dbpm/livelabs/view-workshop
 
 Quick notes are here...
 - setup the database side with Select AI configured, etc.
-- oci session authenticate ; oci iam region list --config-file ~/.oci/config --profile MYSPEECHAIPROFILE --auth security_token
-- $env:COMPARTMENT_ID = "ocid1.compartment.oc1..YOURCOMPARMENTID"
-- python src/RealtimeSpeechSelectAI.py
+- setup OCI config profile auth (instance or security_token)
+- export COMPARTMENT_ID 
+- python src/RealtimeSTT_NL2SQL_TTS_AudioPlay.py

python-realtimeSTT-NL2SQL-TTS/requirements.txt

@@ -1,10 +1,7 @@
-https://artifactory.oci.oraclecorp.com/ocas-service-platform-dev-pypi-local/oci.ai-speech-realtime/0.2.0/oci.ai_speech_realtime-0.2.0-py2.py3-none-any.whl
-https://artifactory.oci.oraclecorp.com/global-dev-pypi/oci-2.129.1+preview.1.1805-py3-none-any.whl
-PyAudio>=0.2.14
 websockets==11.0.3; python_version >= "3.7"
 websockets==9.1; python_version == "3.6"
-aiohttp
-oracledb
+aiohttp~=3.10.10
+oracledb~=2.4.1
 certifi==2024.8.30
 cffi==1.17.1
 circuitbreaker==2.0.0
@@ -14,4 +11,9 @@ pycparser==2.22
 pyOpenSSL==24.2.1
 python-dateutil==2.9.0.post0
 pytz==2024.2
-six==1.16.0
+six==1.16.0
+oci-ai-speech-realtime
+oci.ai_speech
+
+requests~=2.32.3
+PyAudio~=0.2.14

python-realtimeSTT-NL2SQL-TTS/src/RealtimeSpeechSelectAI.py renamed to python-realtimeSTT-NL2SQL-TTS/src/RealtimeSTT_NL2SQL_TTS_AudioPlayback.py

@@ -3,8 +3,11 @@
 import os
 import json
 import pyaudio
-import oracledb
+import requests
+import time
+import wave
 from datetime import datetime
+import oracledb
 import oci
 from oci.config import from_file
 from oci.auth.signers.security_token_signer import SecurityTokenSigner
@@ -15,57 +18,43 @@
 )
 from aiohttp import web
 
-# Global variables to store the latest data
+from oci.ai_speech import AIServiceSpeechClient
+from oci.ai_speech.models import SynthesizeSpeechDetails
+
 latest_thetime = None
 latest_question = None
 latest_answer = None
 compartment_id = os.getenv('COMPARTMENT_ID')
 print(f"compartment_id: {compartment_id}")
-pw = getpass.getpass("Enter database user password:")
 
-# Use this when making a connection with a wallet
 connection = oracledb.connect(
     user="moviestream",
-    password=pw,
+    password="Welcome12345",
     dsn="selectaidb_high",
-    config_dir=r"C:\Users\paulp\Downloads\Wallet_SelectAIDB",
-    wallet_location=r"C:\Users\paulp\Downloads\Wallet_SelectAIDB"
+    config_dir="/Users/pparkins/Downloads/Wallet_SelectAIDB",
+    wallet_location="/Users/pparkins/Downloads/Wallet_SelectAIDB",
+    wallet_password="Welcome12345"
 )
 print(f"Successfully connected to Oracle Database Connection: {connection}")
 
-# Create a FIFO queue
 queue = asyncio.Queue()
 
-# Set audio parameters
 SAMPLE_RATE = 16000
 FORMAT = pyaudio.paInt16
 CHANNELS = 1
 BUFFER_DURATION_MS = 96
-
-# Calculate the number of frames per buffer
 FRAMES_PER_BUFFER = int(SAMPLE_RATE * BUFFER_DURATION_MS / 1000)
 
-# Variables to keep track of results and state
 cummulativeResult = ""
 isSelect = False
 last_result_time = None
 
-def authenticator():
-    config = from_file("~/.oci/config", "MYSPEECHAIPROFILE")
-    with open(config["security_token_file"], "r") as f:
-        token = f.readline()
-    private_key = oci.signer.load_private_key_from_file(config["key_file"])
-    auth = SecurityTokenSigner(token=token, private_key=private_key)
-    return auth
-
 def audio_callback(in_data, frame_count, time_info, status):
-    # This function will be called by PyAudio when there's new audio data
     queue.put_nowait(in_data)
     return (None, pyaudio.paContinue)
 
 p = pyaudio.PyAudio()
 
-# Open the stream
 stream = p.open(
     format=FORMAT,
     channels=CHANNELS,
@@ -77,14 +66,36 @@ def audio_callback(in_data, frame_count, time_info, status):
 
 stream.start_stream()
 config = from_file()
-isInsertResults = True
+isInsertResults = False
 
 async def send_audio(client):
     while True:
         data = await queue.get()
-        # Send it over the websocket
         await client.send_data(data)
 
+def play_audio(file_path):
+    try:
+        wf = wave.open(file_path, 'rb')
+        p = pyaudio.PyAudio()
+        stream = p.open(
+            format=p.get_format_from_width(wf.getsampwidth()),
+            channels=wf.getnchannels(),
+            rate=wf.getframerate(),
+            output=True
+        )
+
+        data = wf.readframes(1024)
+        while data:
+            stream.write(data)
+            data = wf.readframes(1024)
+
+        stream.stop_stream()
+        stream.close()
+        p.terminate()
+        print("Audio playback finished.")
+    except Exception as e:
+        print(f"Error playing audio: {e}")
+
 class SpeechListener(RealtimeClientListener):
     def on_result(self, result):
         global cummulativeResult, isSelect, last_result_time
@@ -93,33 +104,37 @@ def on_result(self, result):
             cummulativeResult += transcription
             print(f"Received final results: {transcription}")
             print(f"Current cummulative result: {cummulativeResult}")
-            if cummulativeResult.lower().startswith("select ai"):
-                cummulativeResult = cummulativeResult[len("select ai"):].strip()
+            if cummulativeResult.lower().startswith("hey db"):
+                cummulativeResult = cummulativeResult[len("hey db"):].strip()
                 isSelect = True
-            elif cummulativeResult.lower().startswith("select the eye"):
-                cummulativeResult = cummulativeResult[len("select the eye"):].strip()
+            elif cummulativeResult.lower().startswith("adb"):
+                cummulativeResult = cummulativeResult[len("adb"):].strip()
                 isSelect = True
             else:
                 cummulativeResult = ""
             last_result_time = asyncio.get_event_loop().time()
         else:
             print(f"Received partial results: {result['transcriptions'][0]['transcription']}")
 
-
     def on_ack_message(self, ackmessage):
-        return super().on_ack_message(ackmessage)
+        """Handle acknowledgment messages (required by the abstract class)."""
+        print(f"ACK received: {ackmessage}")
 
     def on_connect(self):
-        return super().on_connect()
+        """Handle connection event (required by the abstract class)."""
+        print("Connected to Realtime Speech Service.")
 
     def on_connect_message(self, connectmessage):
-        return super().on_connect_message(connectmessage)
+        """Handle connection messages (required by the abstract class)."""
+        print(f"Connect message: {connectmessage}")
 
     def on_network_event(self, ackmessage):
-        return super().on_network_event(ackmessage)
+        """Handle network events (required by the abstract class)."""
+        print(f"Network event: {ackmessage}")
 
-    def on_error(self):
-        return super().on_error()
+    def on_error(self, exception):
+        """Handle errors (required by the abstract class)."""
+        print(f"An error occurred: {exception}")
 
 async def check_idle():
     global last_result_time, isSelect
@@ -129,93 +144,111 @@ async def check_idle():
             isSelect = False
         await asyncio.sleep(1)
 
-# Function to execute AI query and optionally insert results into the table
-# For example Select AI I am looking for the top five selling movies for the latest month please
+
+def authenticator():
+    config = from_file("~/.oci/config", "MYSPEECHAIPROFILE")
+    with open(config["security_token_file"], "r") as f:
+        token = f.readline()
+    private_key = oci.signer.load_private_key_from_file(config["key_file"])
+    auth = SecurityTokenSigner(token=token, private_key=private_key)
+    return auth
 def executeSelectAI():
     global cummulativeResult, isInsertResults, latest_thetime, latest_question, latest_answer
     print(f"executeSelectAI called cummulative result: {cummulativeResult}")
 
-    # AI query - todo use openai_gpt4o
     query = """SELECT DBMS_CLOUD_AI.GENERATE(
                 prompt       => :prompt,
                 profile_name => 'openai_gpt35', 
-                action       => 'narrate')
+                action       => 'chat')
             FROM dual"""
 
     try:
         with connection.cursor() as cursor:
-            cursor.execute(query, prompt=cummulativeResult)
+            cursor.execute(query, {'prompt': cummulativeResult})
             result = cursor.fetchone()
             if result and isinstance(result[0], oracledb.LOB):
                 text_result = result[0].read()
-                print(text_result)
+                print(f"Query result: {text_result}")
 
                 latest_thetime = datetime.now()
                 latest_question = cummulativeResult
-                latest_answer = text_result[:3000]  # Truncate if necessary
-                cummulativeResult = ""
+                latest_answer = text_result[:3000]
+
+            cummulativeResult = ""
+
+            # API key-based authentication...
+            config = oci.config.from_file("~/.oci/config", "DEFAULT")
+            speech_client = AIServiceSpeechClient(config)
+
+            text_to_speech = SynthesizeSpeechDetails(
+                text=f" {latest_answer}",
+                is_stream_enabled=False,
+                configuration=oci.ai_speech.models.TtsOracleConfiguration(
+                model_family="ORACLE",
+                # Brian Annabelle Bob Stacy Phil Cindy Brad
+                model_details=oci.ai_speech.models.TtsOracleTts2NaturalModelDetails(voice_id="Brian"),
+                speech_settings=oci.ai_speech.models.TtsOracleSpeechSettings(
+                speech_mark_types=["WORD"]
+            ),
+        )
+            )
+
+            response = speech_client.synthesize_speech(synthesize_speech_details=text_to_speech)
+
+            with open("TTSoutput.wav", "wb") as audio_file:
+                audio_file.write(response.data.content)
+
+            print("Speech synthesis completed and saved as TTSoutput.wav")
+
+            # Play the generated speech
+            play_audio("TTSoutput.wav")
 
-                if isInsertResults:
-                    insert_query = """
-                    INSERT INTO selectai_data (thetime, question, answer)
-                    VALUES (:thetime, :question, :answer)
-                    """
-                    cursor.execute(insert_query, {
-                        'thetime': latest_thetime,
-                        'question': latest_question,
-                        'answer': latest_answer
-                    })
-                    connection.commit()
-                    print("Insert successful.")
-            else:
-                print(result)
     except Exception as e:
         print(f"An error occurred: {e}")
 
-    cummulativeResult = ""
-
 async def handle_request(request):
     global latest_thetime, latest_question, latest_answer
     data = {
-        "thetime": latest_thetime.isoformat() if latest_thetime else None,  # Convert datetime to ISO format
+        "thetime": latest_thetime.isoformat() if latest_thetime else None,
         "question": latest_question,
         "answer": latest_answer
     }
     return web.json_response(data)
 
-
 if __name__ == "__main__":
-    # Run the event loop
-    def message_callback(message):
-        print(f"Received message: {message}")
+    loop = asyncio.new_event_loop()  # Fix event loop issue
+    asyncio.set_event_loop(loop)
 
     realtime_speech_parameters = RealtimeParameters()
     realtime_speech_parameters.language_code = "en-US"
     realtime_speech_parameters.model_domain = (
         realtime_speech_parameters.MODEL_DOMAIN_GENERIC
     )
-    realtime_speech_parameters.partial_silence_threshold_in_ms = 0
     realtime_speech_parameters.final_silence_threshold_in_ms = 2000
-    realtime_speech_parameters.should_ignore_invalid_customizations = False
-    realtime_speech_parameters.stabilize_partial_results = (
-        realtime_speech_parameters.STABILIZE_PARTIAL_RESULTS_NONE
-    )
 
     realtime_speech_url = "wss://realtime.aiservice.us-phoenix-1.oci.oraclecloud.com"
     client = RealtimeClient(
         config=config,
         realtime_speech_parameters=realtime_speech_parameters,
         listener=SpeechListener(),
         service_endpoint=realtime_speech_url,
-        signer=authenticator(),
+        signer=None,
         compartment_id=compartment_id,
     )
 
-    loop = asyncio.get_event_loop()
+    # Instance, resource principal, or session token-based authentication (as shown below) can also be used
+    # client = AIServiceSpeechClient(
+    #     config=config,
+    #     realtime_speech_parameters=realtime_speech_parameters,
+    #     listener=SpeechListener(),
+    #     service_endpoint=realtime_speech_url,
+    #     signer=authenticator(),
+    #     compartment_id=compartment_id,
+    # )
+
     loop.create_task(send_audio(client))
     loop.create_task(check_idle())
 
-    # Set up the HTTP server
     app = web.Application()
     app.router.add_get('/selectai_data', handle_request)
     runner = web.AppRunner(app)