Update app.py

app.py

@@ -22,7 +22,7 @@ logging.getLogger().setLevel(logging.DEBUG)  # imposta il livello di log a DEBUG
 
 class BasicAgent:
     def __init__(self):
-        print("Initializing LlamaIndex-based agent...")
+        print("coso Initializing LlamaIndex-based agent...")
 
         # Leggi la chiave OpenAI dall'ambiente
         openai_api_key = os.getenv("OPENAI_API_KEY")
@@ -49,8 +49,8 @@ class BasicAgent:
 
         # Prepara il query engine
         self.query_engine = self.index.as_query_engine()
-        print("Agent ready.")
-    
+        print("coso Agent ready.")
+    '''
     def __call__(self, question: str) -> str:
         print(f"Received question: {question[:50]}...")
         response = self.query_engine.query(question)
@@ -62,85 +62,94 @@ class BasicAgent:
         return str(response)
     '''
 
-    def __call__(self, question: str, context=None) -> str:
-        if isinstance(context, str):
-            #prompt = f"{context}\n\nDomanda: {question}"
-            response = self.query_engine.query(question)
-            # Stampa ragionamento interno
-            print("Query response object:", response)
-            print("Response text:", str(response))
-            return response.text
-
-        elif context and hasattr(context, "read"):  # file immagine o audio
-            file_bytes = context.read()
-            filename = context.name
-
-            if filename.endswith((".png", ".jpg", ".jpeg", ".webp", ".bmp", ".gif")):
-                print("coso entrato in video file:", filename)
-                image = Image.open(io.BytesIO(file_bytes))
-                response = self.query_engine.query(
-                    messages=[
-                        {"role": "user", "content": [
-                            {"type": "text", "text": question},
-                            {"type": "image_url", "image_url": image}
-                        ]}
-                    ]
-                )
-                return response.choices[0].message.content
-
-            elif filename.endswith((".mp3", ".wav", ".ogg")):
-                print("coso entrato in audio file:", filename)
-                response = self.query_engine.query(
-                    messages=[
-                        {"role": "user", "content": [
-                            {"type": "text", "text": question},
-                            {"type": "audio_url", "audio_url": file_bytes}
-                        ]}
-                    ]
-                )
-                return response.choices[0].message.content
-
-        else:
-            print("coso entrato in else")
-            response = self.llm.complete(question)
-            return response.text
 
-        
+    def __call__(self, question: str) -> str:
+        print(f"coso Received question: {question[:100]}")
 
-def answer_with_media(question, uploaded_file):
-    file_content = ""
-    file_path = None
+        # Prova a decodificare JSON
+        try:
+            q_data = json.loads(question)
+        except json.JSONDecodeError:
+            q_data = {"question": question}
+
+        text = q_data.get("question", "")
+        file_info = q_data.get("file")
+
+        # Se è presente un file, gestiscilo
+        if file_info:
+            file_name = file_info.get("name", "")
+            file_data = file_info.get("data", "")
+
+            if file_name.endswith((".png", ".jpg", ".jpeg")):
+                print("coso Image file detected, processing with GPT-4o")
+                image = self._load_image(file_data)
+                response = self._ask_gpt4o_with_image(image, text)
+                return response
+
+            elif file_name.endswith(".wav") or file_name.endswith(".mp3"):
+                print("coso Audio file detected, processing with Whisper")
+                audio_bytes = self._load_bytes(file_data)
+                transcription = self._transcribe_audio(audio_bytes)
+                return self._ask_gpt4o(transcription)
+
+            elif file_name.endswith(".txt"):
+                print("coso Text file detected")
+                text_content = self._load_text(file_data)
+                return self._ask_gpt4o(text_content)
+
+        # Altrimenti gestisci solo testo
+        return self._ask_gpt4o(text)
+
+    def _ask_gpt4o(self, text: str) -> str:
+        messages = [{"role": "user", "content": text}]
+        response = self.client.chat.completions.create(model="gpt-4o-mini", messages=messages)
+        return response.choices[0].message.content.strip()
+
+    def _ask_gpt4o_with_image(self, image: Image.Image, question: str) -> str:
+        buffered = BytesIO()
+        image.save(buffered, format="PNG")
+        buffered.seek(0)
+        image_bytes = buffered.read()
+
+        response = self.client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[{
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": question},
+                    {"type": "image_url", "image_url": {"url": "data:image/png;base64," + base64.b64encode(image_bytes).decode()}}
+                ]
+            }]
+        )
+        return response.choices[0].message.content.strip()
 
-    if uploaded_file is not None:
-        file_path = Path(uploaded_file.name)
-        suffix = file_path.suffix.lower()
+    def _transcribe_audio(self, audio_bytes: bytes) -> str:
+        audio_file = BytesIO(audio_bytes)
+        transcription = self.client.audio.transcriptions.create(model="whisper-1", file=audio_file)
+        return transcription.text.strip()
 
-        if suffix in [".txt", ".md", ".csv"]:
-            with open(file_path, "r", encoding="utf-8") as f:
-                file_content = f.read()
-        elif suffix in [".png", ".jpg", ".jpeg", ".webp", ".bmp", ".gif", ".mp3", ".wav", ".ogg"]:
-            # immagini/audio li gestiamo come path da passare al modello
-            file_content = uploaded_file
-        else:
-            return "Formato file non supportato."
+    def _load_image(self, data: str) -> Image.Image:
+        return Image.open(BytesIO(base64.b64decode(data)))
 
-    response = agent(question, context=file_content)
-    return response
+    def _load_bytes(self, data: str) -> bytes:
+        return base64.b64decode(data)
+
+    def _load_text(self, data: str) -> str:
+        return base64.b64decode(data).decode("utf-8")
 
-gr.Interface(
-    fn=answer_with_media,
-    inputs=[
-        gr.Textbox(label="Domanda"),
-        gr.File(label="Carica file (testo, immagine o audio)")
-    ],
-    outputs=gr.Textbox(label="Risposta")
-).launch()
 
 
-    '''
 
 
 
+
+
+
+
+
+    
+
+
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"