Update app.py

app.py

@@ -1,234 +1,118 @@
-import streamlit as st
+from flask import Flask, render_template, request, jsonify, send_file
+import speech_recognition as sr
+import requests
+import smtplib
+from email.message import EmailMessage
+from transformers import pipeline
+from reportlab.pdfgen import canvas
 import os
-import google.generativeai as genai
-from google.ai.generativelanguage_v1beta.types import content
-import json
-from tempfile import NamedTemporaryFile
-
-# Initialize session state for chat history if it doesn't exist
-if 'chat_history' not in st.session_state:
-    st.session_state.chat_history = []
-
-if 'diarization_output' not in st.session_state:
-    st.session_state.diarization_output = None
-
-# Configuration for the page
-st.set_page_config(
-    page_title="Meeting Audio Analyzer",
-    layout="wide"
-)
-
-# Sidebar controls
-with st.sidebar:
-    st.title("Settings")
-    
-    # Language selection
-    language = st.selectbox(
-        "Select language",
-        ["English", "Turkish", "Spanish", "French", "German"]
-    )
-    
-    # Number of speakers
-    num_speakers = st.number_input(
-        "Enter number of speakers",
-        min_value=1,
-        max_value=10,
-        value=2
-    )
+
+app = Flask(__name__)
+
+# Google Speech-to-Text API Anahtarı (JSON dosyanızın yolu)
+os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "your-google-cloud-key.json"
+
+# Gemini API Anahtarı
+GEMINI_API_KEY = "your-gemini-api-key"
+
+# Hugging Face Özetleme Modeli
+summary_pipeline = pipeline("summarization", model="facebook/bart-large-cnn")
+
+### 📌 1️⃣ Speech-to-Text API ###
+@app.route('/speech-to-text', methods=['POST'])
+def speech_to_text():
+    if 'audio' not in request.files:
+        return jsonify({"error": "No audio file provided"}), 400
     
-    # File upload
-    uploaded_file = st.file_uploader("Upload audio file", type=['mp3', 'wav'])
+    audio_file = request.files['audio']
+    recognizer = sr.Recognizer()
+
+    with sr.AudioFile(audio_file) as source:
+        audio_data = recognizer.record(source)
+        try:
+            text = recognizer.recognize_google(audio_data, language="tr-TR")
+            return jsonify({"text": text})
+        except sr.UnknownValueError:
+            return jsonify({"error": "Could not understand audio"})
+        except sr.RequestError:
+            return jsonify({"error": "Could not request results"})
+
+### 📌 2️⃣ Metni Özetleme (Gemini API) ###
+def summarize_text(text):
+    url = "https://generativelanguage.googleapis.com/v1/models/gemini-pro:generateText"
+    headers = {"Authorization": f"Bearer {GEMINI_API_KEY}"}
+    payload = {
+        "prompt": f"Summarize this meeting transcript:\n{text}",
+        "max_tokens": 500
+    }
+    response = requests.post(url, json=payload, headers=headers)
+    return response.json()["choices"][0]["text"]
+
+@app.route('/summarize', methods=['POST'])
+def summarize():
+    data = request.get_json()
+    text = data.get("text")
+    if not text:
+        return jsonify({"error": "No text provided"}), 400
+
+    summary = summarize_text(text)
+    return jsonify({"summary": summary})
+
+### 📌 3️⃣ Kararları Çıkarma (Hugging Face NLP) ###
+def extract_decisions(text):
+    summary = summary_pipeline(text, max_length=100, min_length=30, do_sample=False)
+    return summary[0]['summary_text']
+
+@app.route('/extract-decisions', methods=['POST'])
+def extract():
+    data = request.get_json()
+    text = data.get("text")
+    if not text:
+        return jsonify({"error": "No text provided"}), 400
+
+    decisions = extract_decisions(text)
+    return jsonify({"decisions": decisions})
+
+### 📌 4️⃣ PDF Raporu Oluşturma ###
+def create_pdf(text, filename="meeting_report.pdf"):
+    c = canvas.Canvas(filename)
+    c.drawString(100, 750, "Meeting Report")
+    c.drawString(100, 730, text)
+    c.save()
+    return filename
+
+@app.route('/generate-pdf', methods=['POST'])
+def generate_pdf():
+    data = request.get_json()
+    text = data.get("text")
+    if not text:
+        return jsonify({"error": "No text provided"}), 400
+
+    pdf_file = create_pdf(text)
+    return send_file(pdf_file, as_attachment=True)
+
+### 📌 5️⃣ E-Posta Gönderme ###
+def send_email(pdf_file, recipient_email):
+    email = "[email protected]"
+    password = "your-email-password"
     
-    # Action buttons
-    if uploaded_file:
-        if st.button("Diarize"):
-            with st.spinner("Processing audio..."):
-                # Save uploaded file temporarily
-                with NamedTemporaryFile(delete=False, suffix='.mp3') as tmp_file:
-                    tmp_file.write(uploaded_file.getvalue())
-                    temp_path = tmp_file.name
-
-                try:
-                    # Configure Gemini
-                    genai.configure(api_key=os.environ["GEMINI_API_KEY"])
-                    
-                    # Upload to Gemini
-                    gemini_file = genai.upload_file(temp_path, mime_type="audio/mpeg")
-                    
-                    # Create diarization model and process
-                    diarization_config = {
-                        "temperature": 0.5,
-                        "top_p": 0.95, #0.95
-                        "top_k": 40,
-                        "max_output_tokens": 8192,
-                        "response_mime_type": "application/json",
-                    }
-
-                    diarization_model = genai.GenerativeModel(
-                        model_name="gemini-2.0-flash-exp",
-                        generation_config=diarization_config,
-                        safety_settings={
-                            'HATE': 'BLOCK_NONE',
-                            'HARASSMENT': 'BLOCK_NONE',
-                            'SEXUAL': 'BLOCK_NONE',
-                            'DANGEROUS': 'BLOCK_NONE'
-                        }
-                    )
-                    
-                    # Process diarization
-                    chat_session = diarization_model.start_chat(
-                        history=[{"role": "user", "parts": [gemini_file]}]
-                    )
-                    
-                    response = chat_session.send_message(
-                        f"Generate meeting diarization of the meeting audio record provided in the file. "
-                        f"The meeting may be in a foreign language, expect a mixture of words in local language "
-                        f"and words in english. Provided audio has {num_speakers} speakers. "
-                        f"Accurately name the speakers or use labels like SPEAKER_01, SPEAKER_02, SPEAKER_03 and so on. "
-                        f"Provide a structured JSON output. timestamp (hh:mm:ss), speaker (name only), "
-                        f"speech (transcription). Do not transcribe filler words."
-                    )
-                    
-                    json_data = json.loads(response.text)
-                    formatted_output = ""
-                    for item in json_data:
-                        formatted_output += f"{item['timestamp']} - {item['speaker']}: {item['speech']}\n\n"
-                    
-                    st.session_state.diarization_output = formatted_output
-                    
-                except Exception as e:
-                    st.error(f"Error processing audio: {str(e)}")
-                finally:
-                    # Clean up temp file
-                    os.unlink(temp_path)
-        
-        if st.button("Summarize") and st.session_state.diarization_output:
-            with st.spinner("Generating summary..."):
-                try:
-                    # Configure summarization model
-                    summarization_config = {
-                        "temperature": 0.25,
-                        "top_p": 0.95,
-                        "top_k": 40,
-                        "max_output_tokens": 8192,
-                        "response_schema": content.Schema(
-                            type=content.Type.OBJECT,
-                            enum=[],
-                            required=["summary"],
-                            properties={
-                                "summary": content.Schema(
-                                    type=content.Type.STRING,
-                                ),
-                            },
-                        ),
-                        "response_mime_type": "application/json",
-                    }
-
-                    summarization_model = genai.GenerativeModel(
-                        model_name="gemini-2.0-flash-exp",
-                        generation_config=summarization_config,
-                        safety_settings={
-                            'HATE': 'BLOCK_NONE',
-                            'HARASSMENT': 'BLOCK_NONE',
-                            'SEXUAL': 'BLOCK_NONE',
-                            'DANGEROUS': 'BLOCK_NONE'
-                        }
-                    )
-                    
-                    # Generate summary
-                    chat_session = summarization_model.start_chat(
-                        history=[{"role": "user", "parts": [st.session_state.diarization_output]}]
-                    )
-                    
-                    response = chat_session.send_message(
-                        f"Generate a detailed summarization of the meeting, provide information on "
-                        f"the topic of the meeting, agenda, things discussed and future plans if any mentioned. "
-                        f"Provide structured output with only one tag 'summary'. Generate response in {language}."
-                    )
-                    
-                    json_data = json.loads(response.text)
-                    summary = json_data.get('summary', "No summary found.")
-                    st.session_state.chat_history.append(("Summary", summary))
-                
-                except Exception as e:
-                    st.error(f"Error generating summary: {str(e)}")
-
-# Main chat interface
-st.title("Meeting Audio Analyzer")
-
-# Diarization output in collapsible section
-if st.session_state.diarization_output:
-    with st.expander("Diarization Output", expanded=False):
-        st.text_area("Transcript", st.session_state.diarization_output, height=300)
-
-# Chat history
-for role, message in st.session_state.chat_history:
-    if role == "User":
-        st.write(f"User: {message}")
-    elif role == "Bot":
-        st.write(f"Bot: {message}")
-    else:  # Summary
-        st.write("Meeting Summary:")
-        st.write(message)
-
-# Question input
-if st.session_state.diarization_output:
-    question = st.text_input("Type in your question")
-    if st.button("Send"):
-        if question:
-            # Add user question to chat history
-            st.session_state.chat_history.append(("User", question))
-            
-            with st.spinner("Generating response..."):
-                try:
-                    # Configure QnA model
-                    qna_config = {
-                        "temperature": 0.25,
-                        "top_p": 0.95,
-                        "top_k": 40,
-                        "max_output_tokens": 8192,
-                        "response_schema": content.Schema(
-                            type=content.Type.OBJECT,
-                            enum=[],
-                            required=["answer"],
-                            properties={
-                                "answer": content.Schema(
-                                    type=content.Type.STRING,
-                                ),
-                            },
-                        ),
-                        "response_mime_type": "application/json",
-                    }
-
-                    qna_model = genai.GenerativeModel(
-                        model_name="gemini-2.0-flash-exp",
-                        generation_config=qna_config,
-                        safety_settings={
-                            'HATE': 'BLOCK_NONE',
-                            'HARASSMENT': 'BLOCK_NONE',
-                            'SEXUAL': 'BLOCK_NONE',
-                            'DANGEROUS': 'BLOCK_NONE'
-                        }
-                    )
-                    
-                    # Generate answer
-                    chat_session = qna_model.start_chat(
-                        history=[{"role": "user", "parts": [st.session_state.diarization_output]}]
-                    )
-                    
-                    response = chat_session.send_message(
-                        f"Answer the following question based on the meeting: {question}. Generate response in {language}."
-                        f"Provide structured output with only one tag 'answer'."
-                    )
-                    
-                    json_data = json.loads(response.text)
-                    answer = json_data.get('answer', "No answer found.")
-                    
-                    # Add bot response to chat history
-                    st.session_state.chat_history.append(("Bot", answer))
-                    
-                    # Rerun to update the chat display
-                    st.rerun()
-                    
-                except Exception as e:
-                    st.error(f"Error generating answer: {str(e)}")
+    msg = EmailMessage()
+    msg['Subject'] = 'Meeting Report'
+    msg['From'] = email
+    msg['To'] = recipient_email
+    msg.set_content('The meeting report is attached.')
+
+    with open(pdf_file, 'rb') as f:
+        file_data = f.read()
+        msg.add_attachment(file_data, maintype='application', subtype='pdf', filename=pdf_file)
+
+    with smtplib.SMTP_SSL('smtp.gmail.com', 465) as server:
+        server.login(email, password)
+        server.send_message(msg)
+
+@app.route('/')
+def home():
+    return render_template('index.html')
+
+if __name__ == '__main__':
+    app.run(debug=True)