Upload 2 files

StarReliabilityApp_Refined.py

@@ -0,0 +1,132 @@
+
+import sys
+import sqlite3
+import requests
+from PyQt5 import QtWidgets, QtCore
+import pyttsx3  # For TTS
+import speech_recognition as sr  # For STT
+
+# Initialize the Ollama API URL and TTS Engine
+OLLAMA_API_URL = "http://127.0.0.1:11434/api/generate"
+tts_engine = pyttsx3.init()
+
+class CentralAI:
+    def __init__(self, db_path):
+        self.connection = sqlite3.connect(db_path)
+        self.short_term_memory = []
+        self.medium_term_memory = []
+        self.long_term_memory = {}
+        self.load_long_term_memory()
+
+    def load_long_term_memory(self):
+        cursor = self.connection.cursor()
+        cursor.execute("SELECT key, value FROM long_term_memory")
+        self.long_term_memory = {row[0]: row[1] for row in cursor.fetchall()}
+
+    def process_user_input(self, user_input):
+        # Step 1: Process - Use NLU to interpret the user input
+        prompt = self.fetch_prompt("Process")
+        processed_intent = self.nlp_parse(user_input, prompt)
+
+        # Step 2: Find - Reference `central_data.db` for required info
+        query_data = self.find_data(processed_intent)
+
+        # Step 3: Execute - Run functions based on user intent
+        action_response = self.execute_function(query_data)
+
+        # Send to Ollama API for final response
+        final_response = self.generate_response_via_ollama(user_input, action_response)
+        return final_response
+
+    def fetch_prompt(self, prompt_name):
+        cursor = self.connection.cursor()
+        cursor.execute("SELECT description FROM prompts WHERE title = ?", (prompt_name,))
+        result = cursor.fetchone()
+        return result[0] if result else ""
+
+    def nlp_parse(self, text, prompt):
+        # Mimic processing with the prompt and return an interpreted command.
+        return f"Interpreted Command: {text} with prompt context: {prompt}"
+
+    def find_data(self, intent):
+        # Sample code for fetching related database data
+        cursor = self.connection.cursor()
+        cursor.execute("SELECT * FROM functions WHERE function_name = ?", (intent,))
+        return cursor.fetchone()
+
+    def execute_function(self, function_data):
+        # Example execution response, this would normally invoke the function
+        return f"Executing: {function_data}"
+
+    def generate_response_via_ollama(self, user_input, action_response):
+        response = requests.post(OLLAMA_API_URL, json={"prompt": f"{user_input}\n{action_response}"})
+        return response.json().get("response", "Error generating response.")
+
+    def update_memory(self, memory_type, content):
+        # Manage short, medium, and long term memory
+        if memory_type == "short_term":
+            self.short_term_memory.append(content)
+        elif memory_type == "medium_term":
+            self.medium_term_memory.append(content)
+        elif memory_type == "long_term":
+            self.long_term_memory.update(content)
+
+class StarReliabilityApp(QtWidgets.QMainWindow):
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("StarReliability Maintenance Dashboard")
+        self.setGeometry(100, 100, 1200, 800)
+        self.central_ai = CentralAI("central_data.db")
+        self.initUI()
+
+    def initUI(self):
+        # Dashboard setup with chat and widgets for metrics, budget, etc.
+        self.chat_output = QtWidgets.QTextEdit()
+        self.chat_input = QtWidgets.QLineEdit()
+        self.chat_input.returnPressed.connect(self.process_chat_input)
+
+        self.chat_output.setReadOnly(True)
+        self.chat_input.setPlaceholderText("Type a message or speak...")
+
+        layout = QtWidgets.QVBoxLayout()
+        layout.addWidget(self.chat_output)
+        layout.addWidget(self.chat_input)
+
+        container = QtWidgets.QWidget()
+        container.setLayout(layout)
+        self.setCentralWidget(container)
+
+    def process_chat_input(self):
+        user_input = self.chat_input.text()
+        self.chat_output.append(f"User: {user_input}")
+        response = self.central_ai.process_user_input(user_input)
+        self.chat_output.append(f"AI: {response}")
+        self.chat_input.clear()
+        self.speak_response(response)
+
+    def speak_response(self, response):
+        tts_engine.say(response)
+        tts_engine.runAndWait()
+
+    def voice_input(self):
+        recognizer = sr.Recognizer()
+        with sr.Microphone() as source:
+            self.chat_output.append("Listening for command...")
+            audio = recognizer.listen(source)
+            try:
+                user_input = recognizer.recognize_google(audio)
+                self.chat_input.setText(user_input)
+                self.process_chat_input()
+            except sr.UnknownValueError:
+                self.chat_output.append("Could not understand audio.")
+            except sr.RequestError:
+                self.chat_output.append("STT service unavailable.")
+
+def run_app():
+    app = QtWidgets.QApplication(sys.argv)
+    main_window = StarReliabilityApp()
+    main_window.show()
+    sys.exit(app.exec_())
+
+if __name__ == "__main__":
+    run_app()