|
|
import dash |
|
|
from dash import dcc, html, Input, Output, State, callback_context |
|
|
import dash_bootstrap_components as dbc |
|
|
import os |
|
|
import tempfile |
|
|
import base64 |
|
|
import openai |
|
|
import docx |
|
|
from datetime import datetime |
|
|
import threading |
|
|
import time |
|
|
import google.generativeai as genai |
|
|
from anthropic import Anthropic |
|
|
import requests |
|
|
import uuid |
|
|
import flask |
|
|
import shutil |
|
|
import logging |
|
|
from collections import defaultdict |
|
|
from moviepy import * |
|
|
|
|
|
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') |
|
|
|
|
|
openai.api_key = os.getenv("OPENAI_API_KEY") |
|
|
if not openai.api_key: |
|
|
logging.warning("OPENAI_API_KEY not set. Transcription will fail.") |
|
|
|
|
|
google_api_key = os.getenv("GOOGLE_API_KEY") |
|
|
if google_api_key: |
|
|
try: |
|
|
genai.configure(api_key=google_api_key) |
|
|
except Exception as e: |
|
|
logging.error(f"Failed to configure Google Gemini: {e}") |
|
|
genai = None |
|
|
else: |
|
|
genai = None |
|
|
logging.warning("GOOGLE_API_KEY not set. Gemini model will not be available.") |
|
|
|
|
|
anthropic_api_key = os.getenv("ANTHROPIC_API_KEY") |
|
|
if anthropic_api_key: |
|
|
try: |
|
|
anthropic = Anthropic(api_key=anthropic_api_key) |
|
|
except Exception as e: |
|
|
logging.error(f"Failed to initialize Anthropic client: {e}") |
|
|
anthropic = None |
|
|
else: |
|
|
anthropic = None |
|
|
logging.warning("ANTHROPIC_API_KEY not set. Claude model will not be available.") |
|
|
|
|
|
grok_api_key = os.getenv("GROK_API_KEY") |
|
|
if not grok_api_key: |
|
|
logging.warning("GROK_API_KEY not set. Groq model will not be available.") |
|
|
|
|
|
server = flask.Flask(__name__) |
|
|
app = dash.Dash(__name__, server=server, external_stylesheets=[dbc.themes.BOOTSTRAP], suppress_callback_exceptions=True) |
|
|
|
|
|
session_data = defaultdict(lambda: {"audio_path": None, "transcript": None, "minutes": None, "diarized": None, "temp_dir": None, "original_filename": None}) |
|
|
session_locks = defaultdict(threading.Lock) |
|
|
|
|
|
def get_session_dir(session_id): |
|
|
if session_data[session_id]["temp_dir"] is None or not os.path.exists(session_data[session_id]["temp_dir"]): |
|
|
session_specific_dir = tempfile.mkdtemp(prefix=f"session_{session_id}_") |
|
|
session_data[session_id]["temp_dir"] = session_specific_dir |
|
|
logging.info(f"Created temp directory for session {session_id}: {session_specific_dir}") |
|
|
return session_data[session_id]["temp_dir"] |
|
|
|
|
|
def cleanup_session(session_id): |
|
|
with session_locks[session_id]: |
|
|
logging.info(f"Cleaning up session: {session_id}") |
|
|
session_dir = session_data[session_id].get("temp_dir") |
|
|
if session_dir and os.path.exists(session_dir): |
|
|
try: |
|
|
shutil.rmtree(session_dir) |
|
|
logging.info(f"Removed temp directory: {session_dir}") |
|
|
except Exception as e: |
|
|
logging.error(f"Error removing directory {session_dir}: {e}") |
|
|
if session_id in session_data: |
|
|
del session_data[session_id] |
|
|
if session_id in session_locks: |
|
|
del session_locks[session_id] |
|
|
logging.info(f"Session data cleared for {session_id}") |
|
|
|
|
|
def save_base64_data(content_string, file_path): |
|
|
try: |
|
|
logging.info(f"Decoding base64 data for {file_path}") |
|
|
content_type, content_string = content_string.split(',') |
|
|
data_bytes = base64.b64decode(content_string) |
|
|
with open(file_path, 'wb') as f: |
|
|
f.write(data_bytes) |
|
|
logging.info(f"Saved uploaded data to {file_path}") |
|
|
return file_path |
|
|
except ValueError as e: |
|
|
logging.error(f"Error splitting content string: {e}. String might not be in 'type,base64_data' format.") |
|
|
return None |
|
|
except base64.binascii.Error as e: |
|
|
logging.error(f"Error decoding base64: {e}") |
|
|
return None |
|
|
except Exception as e: |
|
|
logging.error(f"Error saving base64 data: {e}") |
|
|
return None |
|
|
|
|
|
def extract_audio_from_video(video_path, audio_output_path): |
|
|
try: |
|
|
logging.info(f"Extracting audio from {video_path} to {audio_output_path}") |
|
|
video = VideoFileClip(video_path) |
|
|
video.audio.write_audiofile(audio_output_path, codec='mp3') |
|
|
video.close() |
|
|
logging.info(f"Successfully extracted audio to {audio_output_path}") |
|
|
return audio_output_path |
|
|
except Exception as e: |
|
|
logging.error(f"Error extracting audio from {video_path}: {e}") |
|
|
if os.path.exists(audio_output_path): |
|
|
os.remove(audio_output_path) |
|
|
if 'video' in locals() and hasattr(video, 'close'): |
|
|
video.close() |
|
|
return None |
|
|
|
|
|
def transcribe_audio(file_path): |
|
|
logging.info(f"Starting transcription for {file_path}") |
|
|
if not openai.api_key: |
|
|
return "Error: OpenAI API key not configured." |
|
|
if not os.path.exists(file_path): |
|
|
logging.error(f"Transcription failed: File not found at {file_path}") |
|
|
return "Error: Audio file not found for transcription." |
|
|
try: |
|
|
with open(file_path, "rb") as audio_file: |
|
|
client = openai.OpenAI() |
|
|
transcript = client.audio.transcriptions.create( |
|
|
model="whisper-1", |
|
|
file=audio_file, |
|
|
response_format="text" |
|
|
) |
|
|
logging.info(f"Transcription successful for {file_path}") |
|
|
if isinstance(transcript, str): |
|
|
return transcript |
|
|
elif hasattr(transcript, 'text'): |
|
|
return transcript.text |
|
|
else: |
|
|
logging.error(f"Unexpected transcription response format: {type(transcript)}") |
|
|
return "Error: Could not extract transcript text from OpenAI response." |
|
|
except openai.BadRequestError as e: |
|
|
logging.error(f"OpenAI API Bad Request Error (possibly file format/size issue): {e}") |
|
|
error_message = f"Error during transcription: {e}" |
|
|
if "Invalid file format" in str(e): |
|
|
error_message = "Error: Invalid audio file format. Supported formats include mp3, mp4, mpeg, mpga, m4a, wav, and webm." |
|
|
elif "maximum file size" in str(e): |
|
|
error_message = "Error: Audio file exceeds the maximum size limit (25MB) for direct upload." |
|
|
return error_message |
|
|
except openai.AuthenticationError: |
|
|
logging.error("OpenAI API Authentication Error: Check your API key.") |
|
|
return "Error: OpenAI API Authentication Failed. Check API Key." |
|
|
except Exception as e: |
|
|
logging.error(f"An unexpected error occurred during transcription: {e}") |
|
|
return f"Error during transcription: An unexpected error occurred." |
|
|
|
|
|
def generate_minutes_ai(transcript, model_name, session_id): |
|
|
logging.info(f"Generating minutes using {model_name} for session {session_id}") |
|
|
if not transcript or "Error:" in transcript: |
|
|
return "Error: Cannot generate minutes from invalid or missing transcript." |
|
|
with session_locks[session_id]: |
|
|
try: |
|
|
if model_name == 'openai': |
|
|
if not openai.api_key: return "Error: OpenAI API key not configured." |
|
|
client = openai.OpenAI() |
|
|
response = client.chat.completions.create( |
|
|
model="gpt-3.5-turbo", |
|
|
messages=[ |
|
|
{"role": "system", "content": "You are a professional assistant tasked with creating structured meeting minutes, including sections like Attendees, Agenda, Discussion Points, Action Items, and Decisions Made."}, |
|
|
{"role": "user", "content": f"Generate detailed meeting minutes from this transcript:\n\n{transcript}"} |
|
|
], |
|
|
timeout=120 |
|
|
) |
|
|
logging.info(f"OpenAI minutes generation successful for session {session_id}") |
|
|
return response.choices[0].message.content |
|
|
elif model_name == 'gemini': |
|
|
if not genai: return "Error: Google Gemini API not configured or key missing." |
|
|
model = genai.GenerativeModel('gemini-1.5-flash-latest') |
|
|
response = model.generate_content( |
|
|
f"Generate detailed meeting minutes from this transcript, including sections like Attendees, Agenda, Discussion Points, Action Items, and Decisions Made:\n\n{transcript}", |
|
|
request_options={'timeout': 120} |
|
|
) |
|
|
logging.info(f"Gemini minutes generation successful for session {session_id}") |
|
|
if response.parts: |
|
|
return response.text |
|
|
else: |
|
|
logging.warning(f"Gemini response blocked or empty for session {session_id}. Reason: {response.prompt_feedback}") |
|
|
return f"Error: Gemini response blocked or empty. Reason: {response.prompt_feedback}" |
|
|
elif model_name == 'anthropic': |
|
|
if not anthropic: return "Error: Anthropic API not configured or key missing." |
|
|
response = anthropic.messages.create( |
|
|
model="claude-3-5-haiku-20241022", |
|
|
max_tokens=2000, |
|
|
messages=[ |
|
|
{ |
|
|
"role": "user", |
|
|
"content": f"Generate detailed meeting minutes from this transcript, including sections like Attendees, Agenda, Discussion Points, Action Items, and Decisions Made:\n\n{transcript}" |
|
|
} |
|
|
], |
|
|
timeout=120 |
|
|
) |
|
|
logging.info(f"Anthropic minutes generation successful for session {session_id}") |
|
|
if response.content and isinstance(response.content, list) and hasattr(response.content[0], 'text'): |
|
|
return response.content[0].text |
|
|
else: |
|
|
logging.error(f"Could not extract content from Anthropic response: {response}") |
|
|
return "Error: Could not extract content from Anthropic response." |
|
|
elif model_name == 'grok': |
|
|
if not grok_api_key: return "Error: Grok API key (via Groq) not configured." |
|
|
groq_url = "https://api.groq.com/openai/v1/chat/completions" |
|
|
headers = { |
|
|
"Authorization": f"Bearer {grok_api_key}", |
|
|
"Content-Type": "application/json" |
|
|
} |
|
|
data = { |
|
|
"model": "grok-3-mini-fast-beta", |
|
|
"messages": [ |
|
|
{"role": "system", "content": "You are a professional assistant tasked with creating structured meeting minutes, including sections like Attendees, Agenda, Discussion Points, Action Items, and Decisions Made."}, |
|
|
{"role": "user", "content": f"Generate detailed meeting minutes from this transcript:\n\n{transcript}"} |
|
|
], |
|
|
"max_tokens": 2000, |
|
|
"temperature": 0.7 |
|
|
} |
|
|
response = requests.post(groq_url, headers=headers, json=data, timeout=120) |
|
|
response.raise_for_status() |
|
|
logging.info(f"Groq ({data['model']}) minutes generation successful for session {session_id}") |
|
|
return response.json()["choices"][0]["message"]["content"] |
|
|
else: |
|
|
logging.warning(f"Invalid model selection: {model_name}") |
|
|
return "Error: Invalid model selection" |
|
|
except requests.exceptions.Timeout: |
|
|
logging.error(f"API Request Timeout for {model_name} on session {session_id}") |
|
|
return f"Error: Request to {model_name} API timed out." |
|
|
except requests.exceptions.RequestException as e: |
|
|
logging.error(f"API Request Error for {model_name}: {e}") |
|
|
if model_name == 'grok' and e.response is not None: |
|
|
if e.response.status_code == 429: |
|
|
logging.warning(f"Groq Rate Limit hit for session {session_id}") |
|
|
return "Error: Groq API rate limit exceeded. Please try again later." |
|
|
elif e.response.status_code == 404: |
|
|
logging.error(f"Model {data['model']} not found via Groq API. Status: {e.response.status_code}. Response: {e.response.text}") |
|
|
return f"Error: Model '{data['model']}' not found or accessible via Groq API. Please check model availability." |
|
|
elif e.response.status_code >= 400: |
|
|
logging.error(f"Groq API error. Status: {e.response.status_code}. Response: {e.response.text}") |
|
|
return f"Error communicating with Groq API: {e.response.status_code}" |
|
|
return f"Error communicating with {model_name} API: {e}" |
|
|
except (genai.types.generation_types.BlockedPromptException, genai.types.generation_types.StopCandidateException) as e: |
|
|
logging.error(f"Gemini content generation issue for session {session_id}: {e}") |
|
|
return f"Error: Gemini generation failed or was blocked. {e}" |
|
|
except Exception as e: |
|
|
logging.error(f"Error generating minutes with {model_name} for session {session_id}: {e}", exc_info=True) |
|
|
if model_name == 'anthropic' and 'Could not find model' in str(e): |
|
|
return f"Error: Anthropic model '{response.model if 'response' in locals() else 'claude-3-5-haiku-20241022'}' not found or accessible. Check model name and API key permissions." |
|
|
elif model_name == 'gemini' and 'model not found' in str(e).lower(): |
|
|
return f"Error: Gemini model '{model.model_name if 'model' in locals() else 'gemini-1.5-flash-latest'}' not found or accessible. Check model name and API key permissions." |
|
|
return f"Error generating minutes using {model_name}: An unexpected error occurred." |
|
|
|
|
|
def diarize_transcript_ai(transcript, model_name, session_id): |
|
|
logging.info(f"Generating diarized transcript using {model_name} for session {session_id}") |
|
|
if not transcript or "Error:" in transcript: |
|
|
return "Error: Cannot diarize invalid or missing transcript." |
|
|
diarization_prompt = ( |
|
|
"Analyze the given transcript to identify distinct speakers without labeled identifiers. " |
|
|
"Create unique speaker embeddings based on individual speech patterns, vocabulary choices, and linguistic styles. " |
|
|
"Examine the context and content of each utterance to detect likely speaker changes. " |
|
|
"Recognize typical conversation structures and turn-taking behaviors to differentiate between speakers. " |
|
|
"Finally, use topic modeling to identify shifts in subject matter and areas of expertise, associating certain topics with specific speakers. " |
|
|
"Based on this analysis, assign speaker labels (e.g., Speaker 1, Speaker 2) to each utterance in the transcript." |
|
|
"\n\nTranscript:\n" + transcript |
|
|
) |
|
|
with session_locks[session_id]: |
|
|
try: |
|
|
if model_name == 'openai': |
|
|
if not openai.api_key: return "Error: OpenAI API key not configured." |
|
|
client = openai.OpenAI() |
|
|
response = client.chat.completions.create( |
|
|
model="gpt-3.5-turbo", |
|
|
messages=[ |
|
|
{"role": "system", "content": "You are a professional assistant skilled in speaker diarization and transcript formatting."}, |
|
|
{"role": "user", "content": diarization_prompt} |
|
|
], |
|
|
timeout=120 |
|
|
) |
|
|
logging.info(f"OpenAI diarization successful for session {session_id}") |
|
|
return response.choices[0].message.content |
|
|
elif model_name == 'gemini': |
|
|
if not genai: return "Error: Google Gemini API not configured or key missing." |
|
|
model = genai.GenerativeModel('gemini-1.5-flash-latest') |
|
|
response = model.generate_content( |
|
|
diarization_prompt, |
|
|
request_options={'timeout': 120} |
|
|
) |
|
|
logging.info(f"Gemini diarization successful for session {session_id}") |
|
|
if response.parts: |
|
|
return response.text |
|
|
else: |
|
|
logging.warning(f"Gemini diarization response blocked or empty for session {session_id}. Reason: {response.prompt_feedback}") |
|
|
return f"Error: Gemini response blocked or empty. Reason: {response.prompt_feedback}" |
|
|
elif model_name == 'anthropic': |
|
|
if not anthropic: return "Error: Anthropic API not configured or key missing." |
|
|
response = anthropic.messages.create( |
|
|
model="claude-3-5-haiku-20241022", |
|
|
max_tokens=2000, |
|
|
messages=[ |
|
|
{ |
|
|
"role": "user", |
|
|
"content": diarization_prompt |
|
|
} |
|
|
], |
|
|
timeout=120 |
|
|
) |
|
|
logging.info(f"Anthropic diarization successful for session {session_id}") |
|
|
if response.content and isinstance(response.content, list) and hasattr(response.content[0], 'text'): |
|
|
return response.content[0].text |
|
|
else: |
|
|
logging.error(f"Could not extract content from Anthropic diarization response: {response}") |
|
|
return "Error: Could not extract content from Anthropic response." |
|
|
elif model_name == 'grok': |
|
|
if not grok_api_key: return "Error: Grok API key (via Groq) not configured." |
|
|
groq_url = "https://api.groq.com/openai/v1/chat/completions" |
|
|
headers = { |
|
|
"Authorization": f"Bearer {grok_api_key}", |
|
|
"Content-Type": "application/json" |
|
|
} |
|
|
data = { |
|
|
"model": "grok-3-mini-fast-beta", |
|
|
"messages": [ |
|
|
{"role": "system", "content": "You are a professional assistant skilled in speaker diarization and transcript formatting."}, |
|
|
{"role": "user", "content": diarization_prompt} |
|
|
], |
|
|
"max_tokens": 2000, |
|
|
"temperature": 0.7 |
|
|
} |
|
|
response = requests.post(groq_url, headers=headers, json=data, timeout=120) |
|
|
response.raise_for_status() |
|
|
logging.info(f"Groq ({data['model']}) diarization successful for session {session_id}") |
|
|
return response.json()["choices"][0]["message"]["content"] |
|
|
else: |
|
|
logging.warning(f"Invalid model selection for diarization: {model_name}") |
|
|
return "Error: Invalid model selection" |
|
|
except Exception as e: |
|
|
logging.error(f"Error during diarization with {model_name} for session {session_id}: {e}", exc_info=True) |
|
|
return f"Error generating diarized transcript using {model_name}: An unexpected error occurred." |
|
|
|
|
|
def save_to_word(content, filename): |
|
|
try: |
|
|
doc = docx.Document() |
|
|
doc.add_paragraph(content) |
|
|
doc.save(filename) |
|
|
logging.info(f"Saved content to Word document: {filename}") |
|
|
return filename |
|
|
except Exception as e: |
|
|
logging.error(f"Error saving to Word document {filename}: {e}") |
|
|
return None |
|
|
|
|
|
ALLOWED_AUDIO_EXTENSIONS = ['.mp3', '.wav', '.m4a', '.webm', '.mp4', '.mpeg', '.mpga'] |
|
|
ALLOWED_VIDEO_EXTENSIONS = ['.mp4', '.mov', '.avi', '.webm', '.mkv', '.flv'] |
|
|
ALLOWED_UPLOAD_EXTENSIONS = ALLOWED_AUDIO_EXTENSIONS + ALLOWED_VIDEO_EXTENSIONS |
|
|
|
|
|
app.layout = dbc.Container([ |
|
|
dcc.Store(id='session-id', storage_type='local'), |
|
|
dcc.Store(id='session-state-trigger'), |
|
|
dcc.Download(id="download-transcript"), |
|
|
dcc.Download(id="download-audio"), |
|
|
dcc.Download(id="download-minutes"), |
|
|
dcc.Download(id="download-diarized"), |
|
|
dbc.Row([ |
|
|
dbc.Col(dbc.Card( |
|
|
dbc.CardBody([ |
|
|
html.H4("Controls", className="card-title"), |
|
|
html.Div("Upload meeting audio or video file:"), |
|
|
dcc.Upload( |
|
|
id='audio-uploader', |
|
|
children=html.Div([ |
|
|
'Drag and Drop or ', |
|
|
html.A('Select Audio/Video File') |
|
|
]), |
|
|
style={ |
|
|
'width': '100%', |
|
|
'height': '60px', |
|
|
'lineHeight': '60px', |
|
|
'borderWidth': '1px', |
|
|
'borderStyle': 'dashed', |
|
|
'borderRadius': '5px', |
|
|
'textAlign': 'center', |
|
|
'margin': '10px 0' |
|
|
}, |
|
|
multiple=False, |
|
|
accept='audio/*,video/*' |
|
|
), |
|
|
html.Div(id='upload-status', children='Status: Ready to Upload', className="mt-2"), |
|
|
html.H5("Select AI Model", className="mt-4"), |
|
|
dcc.Dropdown( |
|
|
id='model-selection', |
|
|
options=[ |
|
|
{'label': 'OpenAI GPT-3.5 Turbo', 'value': 'openai', 'disabled': not openai.api_key}, |
|
|
{'label': 'Google Gemini 1.5 Flash', 'value': 'gemini', 'disabled': not genai}, |
|
|
{'label': 'Anthropic Claude 3.5 Haiku', 'value': 'anthropic', 'disabled': not anthropic}, |
|
|
{'label': 'Grok 3 Mini', 'value': 'grok', 'disabled': not grok_api_key} |
|
|
], |
|
|
value='openai' if openai.api_key else ('gemini' if genai else ('anthropic' if anthropic else ('grok' if grok_api_key else None))), |
|
|
clearable=False, |
|
|
className="mt-2", |
|
|
disabled=not (openai.api_key or genai or anthropic or grok_api_key) |
|
|
), |
|
|
dbc.Button("Generate Minutes", id="minutes-btn", color="secondary", className="mt-4 w-100", disabled=True), |
|
|
dbc.Button("Diarize Transcript", id="diarize-btn", color="secondary", className="mt-2 w-100", disabled=True), |
|
|
html.H5("Downloads", className="mt-4"), |
|
|
dbc.Button("Download Transcript (.docx)", id="download-transcript-btn", color="info", className="w-100 mb-2", disabled=True), |
|
|
dbc.Button("Download Minutes (.docx)", id="download-minutes-btn", color="info", className="w-100 mb-2", disabled=True), |
|
|
dbc.Button("Download Processed Audio", id="download-audio-btn", color="info", className="w-100 mb-2", disabled=True), |
|
|
dbc.Button("Download Diarized Transcript (.docx)", id="download-diarized-btn", color="info", className="w-100 mb-2", disabled=True), |
|
|
dbc.Button("Delete Session Data", id="delete-btn", color="warning", className="mt-4 w-100", disabled=True), |
|
|
]), |
|
|
style={'height': '80vh', 'overflow-y': 'auto'} |
|
|
), width=12, lg=4), |
|
|
dbc.Col(dbc.Card( |
|
|
dbc.CardBody([ |
|
|
dcc.Loading( |
|
|
id="loading", |
|
|
type="default", |
|
|
parent_style={'position': 'relative', 'height': '100%'}, |
|
|
style={'position': 'absolute', 'top': '50%', 'left': '50%', 'transform': 'translate(-50%, -50%)', 'zIndex':'1000'}, |
|
|
children=[ |
|
|
html.Div([ |
|
|
html.H4("Output", className="card-title"), |
|
|
html.Div(id="status", children="Status: Idle", className="mb-2"), |
|
|
html.H5("Transcript / Minutes / Diarization"), |
|
|
html.Div(id="transcript-preview", style={ |
|
|
"height": "400px", |
|
|
"overflow-y": "scroll", |
|
|
"border": "1px solid #ccc", |
|
|
"padding": "10px", |
|
|
"white-space": "pre-wrap", |
|
|
"word-wrap": "break-word", |
|
|
"background-color": "#f9f9f9" |
|
|
}), |
|
|
]) |
|
|
] |
|
|
), |
|
|
html.Div(id="loading-output", style={"height": "0px", "visibility": "hidden"}), |
|
|
]), |
|
|
style={'height': '80vh', 'overflow-y': 'auto', 'position': 'relative'} |
|
|
), width=12, lg=8), |
|
|
]) |
|
|
], fluid=True) |
|
|
|
|
|
@app.callback( |
|
|
Output('session-id', 'data'), |
|
|
Input('session-id', 'data'), |
|
|
prevent_initial_call=False |
|
|
) |
|
|
def manage_session_id(existing_session_id): |
|
|
session_cookie = flask.request.cookies.get('dash-session-id') |
|
|
ctx = dash.callback_context |
|
|
final_session_id = None |
|
|
source = "none" |
|
|
if existing_session_id and not ctx.triggered: |
|
|
final_session_id = existing_session_id |
|
|
source = "store (initial)" |
|
|
elif existing_session_id and session_cookie == existing_session_id: |
|
|
final_session_id = existing_session_id |
|
|
source = "store/cookie match" |
|
|
elif session_cookie: |
|
|
final_session_id = session_cookie |
|
|
source = "cookie" |
|
|
else: |
|
|
final_session_id = str(uuid.uuid4()) |
|
|
source = "new generation" |
|
|
if final_session_id not in session_data: |
|
|
logging.info(f"Initializing server-side session for ID: {final_session_id} (Source: {source})") |
|
|
get_session_dir(final_session_id) |
|
|
logging.info(f"Manage Session ID - Final ID: {final_session_id}, Source: {source}, Store Input: {existing_session_id}, Cookie Input: {session_cookie}") |
|
|
response = dash.callback_context.response |
|
|
if source == "new generation" or (session_cookie != final_session_id): |
|
|
logging.info(f"Setting session cookie for ID: {final_session_id}") |
|
|
response.set_cookie('dash-session-id', final_session_id, max_age=60*60*24*7) |
|
|
return final_session_id |
|
|
|
|
|
@app.callback( |
|
|
[ |
|
|
Output("status", "children"), |
|
|
Output("transcript-preview", "children"), |
|
|
Output("minutes-btn", "disabled"), |
|
|
Output("diarize-btn", "disabled"), |
|
|
Output("download-transcript-btn", "disabled"), |
|
|
Output("download-minutes-btn", "disabled"), |
|
|
Output("download-audio-btn", "disabled"), |
|
|
Output("download-diarized-btn", "disabled"), |
|
|
Output("delete-btn", "disabled"), |
|
|
Output("loading-output", "children"), |
|
|
Output("upload-status", "children") |
|
|
], |
|
|
[ |
|
|
Input('audio-uploader', 'contents'), |
|
|
Input("minutes-btn", "n_clicks"), |
|
|
Input("diarize-btn", "n_clicks"), |
|
|
Input("delete-btn", "n_clicks") |
|
|
], |
|
|
[ |
|
|
State("session-id", "data"), |
|
|
State("model-selection", "value"), |
|
|
State("transcript-preview", "children"), |
|
|
State('audio-uploader', 'filename') |
|
|
], |
|
|
prevent_initial_call=True |
|
|
) |
|
|
def handle_actions(upload_contents, minutes_clicks, diarize_clicks, delete_clicks, session_id, selected_model, existing_preview, filename): |
|
|
if not session_id: |
|
|
logging.warning("Session ID missing in handle_actions.") |
|
|
return "Status: Error - Session ID missing", "", True, True, True, True, True, True, True, None, "Status: Error" |
|
|
ctx = dash.callback_context |
|
|
triggered_id = ctx.triggered_id if hasattr(ctx, 'triggered_id') else (ctx.triggered[0]['prop_id'].split('.')[0] if ctx.triggered else None) |
|
|
current_transcript = session_data[session_id].get("transcript", "") |
|
|
current_minutes = session_data[session_id].get("minutes", "") |
|
|
current_diarized = session_data[session_id].get("diarized", "") |
|
|
current_audio_path = session_data[session_id].get("audio_path", None) |
|
|
original_filename = session_data[session_id].get("original_filename", None) |
|
|
output_text = "" |
|
|
|
|
|
if current_diarized and "Error:" not in current_diarized: |
|
|
output_text = current_diarized |
|
|
elif current_minutes and "Error:" not in current_minutes: |
|
|
output_text = current_minutes |
|
|
elif current_transcript and "Error:" not in current_transcript: |
|
|
output_text = current_transcript |
|
|
else: |
|
|
output_text = "Upload an audio or video file to begin." |
|
|
status_msg = "Status: Idle" |
|
|
if current_diarized and "Error:" not in current_diarized: |
|
|
status_msg = "Status: Session restored. Diarized transcript loaded." |
|
|
elif current_minutes and "Error:" not in current_minutes: |
|
|
status_msg = "Status: Session restored. Minutes loaded." |
|
|
elif current_transcript and "Error:" not in current_transcript: |
|
|
status_msg = "Status: Session restored. Transcript loaded. Ready for Minutes Generation." |
|
|
elif current_audio_path and os.path.exists(current_audio_path): |
|
|
status_msg = f"Status: Session restored. Processed audio loaded ({os.path.basename(original_filename if original_filename else 'file')}). Ready for transcription/minutes." |
|
|
elif original_filename: |
|
|
status_msg = f"Status: Session restored. Previous upload ({original_filename}) might have had issues." |
|
|
minutes_disabled = not bool(current_transcript and "Error:" not in current_transcript) |
|
|
diarize_disabled = not bool(current_transcript and "Error:" not in current_transcript) |
|
|
dl_transcript_disabled = not bool(current_transcript and "Error:" not in current_transcript) |
|
|
dl_minutes_disabled = not bool(current_minutes and "Error:" not in current_minutes) |
|
|
dl_audio_disabled = not bool(current_audio_path and os.path.exists(current_audio_path)) |
|
|
dl_diarized_disabled = not bool(current_diarized and "Error:" not in current_diarized) |
|
|
delete_disabled = not bool(session_data.get(session_id, {}).get("temp_dir")) |
|
|
loading_output = None |
|
|
upload_status_msg = f"Status: {'Loaded: ' + original_filename if original_filename else 'Ready to Upload'}" |
|
|
start_time = time.time() |
|
|
if triggered_id == 'audio-uploader' and upload_contents is not None and filename is not None: |
|
|
logging.info(f"File uploaded for session {session_id}, filename: {filename}") |
|
|
session_data[session_id]["original_filename"] = filename |
|
|
upload_status_msg = f"Status: Processing Uploaded File ({filename})..." |
|
|
status_msg = "Status: Processing Upload..." |
|
|
loading_output = "Processing Upload..." |
|
|
session_dir = get_session_dir(session_id) |
|
|
_, f_ext = os.path.splitext(filename) |
|
|
f_ext_lower = f_ext.lower() |
|
|
if f_ext_lower not in ALLOWED_UPLOAD_EXTENSIONS: |
|
|
status_msg = f"Status: Error - Invalid file type ({f_ext}). Please upload audio or video." |
|
|
output_text = f"Error: Invalid file type ({f_ext}). Allowed types: {', '.join(ALLOWED_UPLOAD_EXTENSIONS)}" |
|
|
upload_status_msg = f"Status: Invalid File Type ({filename})" |
|
|
session_data[session_id]["audio_path"] = None |
|
|
session_data[session_id]["transcript"] = None |
|
|
session_data[session_id]["minutes"] = None |
|
|
session_data[session_id]["diarized"] = None |
|
|
session_data[session_id]["original_filename"] = None |
|
|
minutes_disabled = True |
|
|
diarize_disabled = True |
|
|
dl_transcript_disabled = True |
|
|
dl_minutes_disabled = True |
|
|
dl_diarized_disabled = True |
|
|
dl_audio_disabled = True |
|
|
delete_disabled = False |
|
|
return status_msg, output_text, minutes_disabled, diarize_disabled, dl_transcript_disabled, dl_minutes_disabled, dl_audio_disabled, dl_diarized_disabled, delete_disabled, None, upload_status_msg |
|
|
safe_upload_filename = f"uploaded_file{f_ext}" |
|
|
upload_file_path = os.path.join(session_dir, safe_upload_filename) |
|
|
saved_upload_path = save_base64_data(upload_contents, upload_file_path) |
|
|
if saved_upload_path: |
|
|
audio_path_for_transcription = None |
|
|
is_video = f_ext_lower in ALLOWED_VIDEO_EXTENSIONS |
|
|
if is_video: |
|
|
status_msg = "Status: Extracting audio from video..." |
|
|
upload_status_msg = "Status: Extracting Audio..." |
|
|
loading_output = "Extracting Audio..." |
|
|
extracted_audio_filename = os.path.join(session_dir, f"extracted_audio_{uuid.uuid4()}.mp3") |
|
|
extracted_audio_path = extract_audio_from_video(saved_upload_path, extracted_audio_filename) |
|
|
if extracted_audio_path: |
|
|
audio_path_for_transcription = extracted_audio_path |
|
|
session_data[session_id]["audio_path"] = extracted_audio_path |
|
|
dl_audio_disabled = False |
|
|
try: |
|
|
os.remove(saved_upload_path) |
|
|
logging.info(f"Removed original video file: {saved_upload_path}") |
|
|
except Exception as e: |
|
|
logging.warning(f"Could not remove original video file {saved_upload_path}: {e}") |
|
|
else: |
|
|
status_msg = "Status: Error - Failed to extract audio from video." |
|
|
output_text = "Error: Failed to extract audio from video file. Check if the file is valid." |
|
|
upload_status_msg = f"Status: Error Extracting Audio ({filename})" |
|
|
session_data[session_id]["audio_path"] = None |
|
|
minutes_disabled = True |
|
|
diarize_disabled = True |
|
|
dl_transcript_disabled = True |
|
|
dl_minutes_disabled = True |
|
|
dl_diarized_disabled = True |
|
|
dl_audio_disabled = True |
|
|
delete_disabled = False |
|
|
return status_msg, output_text, minutes_disabled, diarize_disabled, dl_transcript_disabled, dl_minutes_disabled, dl_audio_disabled, dl_diarized_disabled, delete_disabled, None, upload_status_msg |
|
|
else: |
|
|
audio_path_for_transcription = saved_upload_path |
|
|
session_data[session_id]["audio_path"] = saved_upload_path |
|
|
dl_audio_disabled = False |
|
|
if audio_path_for_transcription: |
|
|
logging.info(f"Audio path set for session {session_id}: {audio_path_for_transcription}. Starting transcription.") |
|
|
status_msg = "Status: Transcribing..." |
|
|
upload_status_msg = f"Status: Transcribing ({filename})..." |
|
|
loading_output = "Transcribing..." |
|
|
transcript_text = transcribe_audio(audio_path_for_transcription) |
|
|
session_data[session_id]["transcript"] = transcript_text |
|
|
session_data[session_id]["minutes"] = None |
|
|
session_data[session_id]["diarized"] = None |
|
|
if "Error:" in transcript_text: |
|
|
status_msg = f"Status: Transcription Failed - {transcript_text}" |
|
|
output_text = transcript_text |
|
|
minutes_disabled = True |
|
|
diarize_disabled = True |
|
|
dl_transcript_disabled = True |
|
|
dl_minutes_disabled = True |
|
|
dl_diarized_disabled = True |
|
|
delete_disabled = False |
|
|
upload_status_msg = f"Status: Transcription Failed. ({filename})" |
|
|
else: |
|
|
status_msg = "Status: Transcription Complete. Ready for Minutes/Diarization." |
|
|
output_text = transcript_text |
|
|
minutes_disabled = False |
|
|
diarize_disabled = False |
|
|
dl_transcript_disabled = False |
|
|
dl_minutes_disabled = True |
|
|
dl_diarized_disabled = True |
|
|
delete_disabled = False |
|
|
upload_status_msg = f"Status: Processed & Transcribed: {filename}" |
|
|
processing_time = time.time() - start_time |
|
|
logging.info(f"File processing and transcription took {processing_time:.2f} seconds for session {session_id}") |
|
|
else: |
|
|
status_msg = "Status: Error - Failed to save uploaded file data." |
|
|
output_text = "Failed to save uploaded file data." |
|
|
upload_status_msg = "Status: Error Saving Upload" |
|
|
session_data[session_id]["audio_path"] = None |
|
|
session_data[session_id]["original_filename"] = None |
|
|
minutes_disabled = True |
|
|
diarize_disabled = True |
|
|
dl_transcript_disabled = True |
|
|
dl_minutes_disabled = True |
|
|
dl_diarized_disabled = True |
|
|
dl_audio_disabled = True |
|
|
delete_disabled = False |
|
|
elif triggered_id == "minutes-btn" and minutes_clicks: |
|
|
logging.info(f"Generate Minutes button clicked for session {session_id}") |
|
|
current_transcript = session_data[session_id].get("transcript", "") |
|
|
if current_transcript and "Error:" not in current_transcript: |
|
|
status_msg = f"Status: Generating Minutes ({selected_model})..." |
|
|
loading_output = "Generating Minutes..." |
|
|
minutes_text = generate_minutes_ai(current_transcript, selected_model, session_id) |
|
|
session_data[session_id]["minutes"] = minutes_text |
|
|
|
|
|
if session_data[session_id].get("diarized") and "Error:" not in session_data[session_id]["diarized"]: |
|
|
output_text = session_data[session_id]["diarized"] |
|
|
else: |
|
|
output_text = minutes_text |
|
|
if "Error:" in minutes_text: |
|
|
status_msg = f"Status: Minutes Generation Failed - {minutes_text}" |
|
|
else: |
|
|
status_msg = "Status: Minutes Generation Complete." |
|
|
processing_time = time.time() - start_time |
|
|
logging.info(f"Minutes generation took {processing_time:.2f} seconds for session {session_id}") |
|
|
minutes_disabled = False |
|
|
diarize_disabled = False |
|
|
dl_transcript_disabled = False |
|
|
dl_audio_disabled = not bool(session_data.get(session_id, {}).get("audio_path") and os.path.exists(session_data.get(session_id, {}).get("audio_path", ""))) |
|
|
dl_minutes_disabled = not (minutes_text and "Error:" not in minutes_text) |
|
|
dl_diarized_disabled = not (session_data[session_id].get("diarized") and "Error:" not in session_data[session_id].get("diarized")) |
|
|
delete_disabled = False |
|
|
upload_status_msg = f"Status: Processed & Transcribed: {session_data[session_id].get('original_filename', 'File')}" |
|
|
else: |
|
|
status_msg = "Status: Cannot generate minutes - No valid transcript available." |
|
|
output_text = existing_preview |
|
|
minutes_disabled = True |
|
|
elif triggered_id == "diarize-btn" and diarize_clicks: |
|
|
logging.info(f"Diarize button clicked for session {session_id}") |
|
|
current_transcript = session_data[session_id].get("transcript", "") |
|
|
if current_transcript and "Error:" not in current_transcript: |
|
|
status_msg = f"Status: Diarizing Transcript ({selected_model})..." |
|
|
loading_output = "Diarizing Transcript..." |
|
|
diarized_text = diarize_transcript_ai(current_transcript, selected_model, session_id) |
|
|
session_data[session_id]["diarized"] = diarized_text |
|
|
if "Error:" in diarized_text: |
|
|
status_msg = f"Status: Diarization Failed - {diarized_text}" |
|
|
else: |
|
|
status_msg = "Status: Diarization Complete." |
|
|
output_text = diarized_text |
|
|
minutes_disabled = False |
|
|
diarize_disabled = False |
|
|
dl_transcript_disabled = False |
|
|
dl_audio_disabled = not bool(session_data.get(session_id, {}).get("audio_path") and os.path.exists(session_data.get(session_id, {}).get("audio_path", ""))) |
|
|
dl_minutes_disabled = not (session_data[session_id].get("minutes") and "Error:" not in session_data[session_id].get("minutes")) |
|
|
dl_diarized_disabled = not (diarized_text and "Error:" not in diarized_text) |
|
|
delete_disabled = False |
|
|
upload_status_msg = f"Status: Processed & Transcribed: {session_data[session_id].get('original_filename', 'File')}" |
|
|
else: |
|
|
status_msg = "Status: Cannot diarize - No valid transcript available." |
|
|
output_text = existing_preview |
|
|
diarize_disabled = True |
|
|
elif triggered_id == "delete-btn" and delete_clicks: |
|
|
logging.info(f"Delete button clicked for session {session_id}") |
|
|
cleanup_session(session_id) |
|
|
status_msg = "Status: All session data deleted." |
|
|
output_text = "Session data cleared. Upload a new file." |
|
|
minutes_disabled = True |
|
|
diarize_disabled = True |
|
|
dl_transcript_disabled = True |
|
|
dl_minutes_disabled = True |
|
|
dl_diarized_disabled = True |
|
|
dl_audio_disabled = True |
|
|
delete_disabled = True |
|
|
upload_status_msg = "Status: Ready to Upload" |
|
|
else: |
|
|
loaded_audio_path = session_data.get(session_id, {}).get("audio_path") |
|
|
loaded_transcript = session_data.get(session_id, {}).get("transcript") |
|
|
loaded_minutes = session_data.get(session_id, {}).get("minutes") |
|
|
loaded_diarized = session_data.get(session_id, {}).get("diarized") |
|
|
temp_dir_exists = bool(session_data.get(session_id, {}).get("temp_dir")) |
|
|
loaded_original_filename = session_data.get(session_id, {}).get("original_filename") |
|
|
dl_audio_disabled = not (loaded_audio_path and os.path.exists(loaded_audio_path)) |
|
|
minutes_disabled = not (loaded_transcript and "Error:" not in loaded_transcript) |
|
|
diarize_disabled = not (loaded_transcript and "Error:" not in loaded_transcript) |
|
|
dl_transcript_disabled = not (loaded_transcript and "Error:" not in loaded_transcript) |
|
|
dl_minutes_disabled = not (loaded_minutes and "Error:" not in loaded_minutes) |
|
|
dl_diarized_disabled = not (loaded_diarized and "Error:" not in loaded_diarized) |
|
|
delete_disabled = not (loaded_audio_path or loaded_transcript or loaded_minutes or loaded_diarized or temp_dir_exists or loaded_original_filename) |
|
|
|
|
|
if loaded_diarized and "Error:" not in loaded_diarized: |
|
|
output_text = loaded_diarized |
|
|
elif loaded_minutes and "Error:" not in loaded_minutes: |
|
|
output_text = loaded_minutes |
|
|
elif loaded_transcript and "Error:" not in loaded_transcript: |
|
|
output_text = loaded_transcript |
|
|
else: |
|
|
output_text = "Upload an audio or video file to begin." |
|
|
if loaded_original_filename and dl_audio_disabled and not loaded_transcript: |
|
|
upload_status_msg = f"Status: Error processing {loaded_original_filename}?" |
|
|
elif loaded_audio_path and os.path.exists(loaded_audio_path): |
|
|
upload_status_msg = f"Status: Processed audio loaded ({loaded_original_filename or 'previous file'})." |
|
|
else: |
|
|
upload_status_msg = "Status: Ready to Upload" |
|
|
return ( |
|
|
status_msg, |
|
|
output_text, |
|
|
minutes_disabled, |
|
|
diarize_disabled, |
|
|
dl_transcript_disabled, |
|
|
dl_minutes_disabled, |
|
|
dl_audio_disabled, |
|
|
dl_diarized_disabled, |
|
|
delete_disabled, |
|
|
loading_output, |
|
|
upload_status_msg |
|
|
) |
|
|
|
|
|
@app.callback( |
|
|
Output("download-transcript", "data"), |
|
|
Input("download-transcript-btn", "n_clicks"), |
|
|
State("session-id", "data"), |
|
|
prevent_initial_call=True, |
|
|
) |
|
|
def download_transcript_file(n_clicks, session_id): |
|
|
if not session_id or not session_data.get(session_id, {}).get("transcript"): |
|
|
logging.warning(f"Download transcript requested but no data found for session {session_id}.") |
|
|
return None |
|
|
transcript = session_data[session_id]["transcript"] |
|
|
if "Error:" in transcript: |
|
|
logging.warning(f"Attempted to download transcript containing an error for session {session_id}.") |
|
|
return None |
|
|
session_dir = get_session_dir(session_id) |
|
|
transcript_filename = os.path.join(session_dir, f"transcript_{uuid.uuid4()}.docx") |
|
|
saved_doc_path = save_to_word(transcript, transcript_filename) |
|
|
if saved_doc_path: |
|
|
logging.info(f"Sending transcript file: {saved_doc_path}") |
|
|
original_filename_base = os.path.splitext(session_data[session_id].get("original_filename", "meeting"))[0] |
|
|
download_filename = f"{original_filename_base}_transcript.docx" |
|
|
return dcc.send_file(saved_doc_path, filename=download_filename) |
|
|
else: |
|
|
logging.error(f"Failed to create Word document for transcript download for session {session_id}") |
|
|
return dcc.send_data_frame(lambda: transcript, "meeting_transcript.txt") |
|
|
|
|
|
@app.callback( |
|
|
Output("download-minutes", "data"), |
|
|
Input("download-minutes-btn", "n_clicks"), |
|
|
State("session-id", "data"), |
|
|
prevent_initial_call=True, |
|
|
) |
|
|
def download_minutes_file(n_clicks, session_id): |
|
|
if not session_id or not session_data.get(session_id, {}).get("minutes"): |
|
|
logging.warning(f"Download minutes requested but no data found for session {session_id}.") |
|
|
return None |
|
|
minutes = session_data[session_id]["minutes"] |
|
|
if "Error:" in minutes: |
|
|
logging.warning(f"Attempted to download minutes containing an error for session {session_id}.") |
|
|
return None |
|
|
session_dir = get_session_dir(session_id) |
|
|
minutes_filename = os.path.join(session_dir, f"meeting_minutes_{uuid.uuid4()}.docx") |
|
|
saved_doc_path = save_to_word(minutes, minutes_filename) |
|
|
if saved_doc_path: |
|
|
logging.info(f"Sending minutes file: {saved_doc_path}") |
|
|
original_filename_base = os.path.splitext(session_data[session_id].get("original_filename", "meeting"))[0] |
|
|
download_filename = f"{original_filename_base}_minutes.docx" |
|
|
return dcc.send_file(saved_doc_path, filename=download_filename) |
|
|
else: |
|
|
logging.error(f"Failed to create Word document for minutes download for session {session_id}") |
|
|
return dcc.send_data_frame(lambda: minutes, "meeting_minutes.txt") |
|
|
|
|
|
@app.callback( |
|
|
Output("download-audio", "data"), |
|
|
Input("download-audio-btn", "n_clicks"), |
|
|
State("session-id", "data"), |
|
|
prevent_initial_call=True, |
|
|
) |
|
|
def download_audio_file(n_clicks, session_id): |
|
|
if not session_id or not session_data.get(session_id, {}).get("audio_path"): |
|
|
logging.warning(f"Download audio requested but no processed audio path found for session {session_id}.") |
|
|
return None |
|
|
audio_path = session_data[session_id]["audio_path"] |
|
|
original_filename = session_data[session_id].get("original_filename", "meeting_audio") |
|
|
if os.path.exists(audio_path): |
|
|
logging.info(f"Sending processed audio file: {audio_path}") |
|
|
original_filename_base = os.path.splitext(original_filename)[0] |
|
|
_, current_ext = os.path.splitext(audio_path) |
|
|
download_filename = f"{original_filename_base}_processed_audio{current_ext}" |
|
|
return dcc.send_file(audio_path, filename=download_filename) |
|
|
else: |
|
|
logging.error(f"Processed audio file not found at path {audio_path} for session {session_id}") |
|
|
return None |
|
|
|
|
|
@app.callback( |
|
|
Output("download-diarized", "data"), |
|
|
Input("download-diarized-btn", "n_clicks"), |
|
|
State("session-id", "data"), |
|
|
prevent_initial_call=True, |
|
|
) |
|
|
def download_diarized_file(n_clicks, session_id): |
|
|
if not session_id or not session_data.get(session_id, {}).get("diarized"): |
|
|
logging.warning(f"Download diarized transcript requested but no data found for session {session_id}.") |
|
|
return None |
|
|
diarized = session_data[session_id]["diarized"] |
|
|
if "Error:" in diarized: |
|
|
logging.warning(f"Attempted to download diarized transcript containing an error for session {session_id}.") |
|
|
return None |
|
|
session_dir = get_session_dir(session_id) |
|
|
diarized_filename = os.path.join(session_dir, f"diarized_{uuid.uuid4()}.docx") |
|
|
saved_doc_path = save_to_word(diarized, diarized_filename) |
|
|
if saved_doc_path: |
|
|
logging.info(f"Sending diarized transcript file: {saved_doc_path}") |
|
|
original_filename_base = os.path.splitext(session_data[session_id].get("original_filename", "meeting"))[0] |
|
|
download_filename = f"{original_filename_base}_diarized.docx" |
|
|
return dcc.send_file(saved_doc_path, filename=download_filename) |
|
|
else: |
|
|
logging.error(f"Failed to create Word document for diarized transcript download for session {session_id}") |
|
|
return dcc.send_data_frame(lambda: diarized, "meeting_diarized.txt") |
|
|
|
|
|
if __name__ == '__main__': |
|
|
print("Starting the Dash application...") |
|
|
app.run(debug=False, host='0.0.0.0', port=7860) |
|
|
print("Dash application has finished running.") |
