🔍 Code Extractor

Flask route handler that regenerates meeting minutes from a previous session using modified instructions, model selection, and configuration parameters.

Purpose

This endpoint allows users to regenerate meeting minutes from an existing session with different AI model settings, custom instructions, rigor levels, and detail preferences. It loads the original transcript and PowerPoint data from a saved session, applies new generation parameters, validates the output for potential truncation issues, and saves the regenerated minutes as a new session while preserving the original data.

Source Code

def regenerate_minutes():
    """Regenerate meeting minutes with modified instructions"""
    try:
        session_id = request.form.get('session_id')
        new_instructions = request.form.get('new_instructions', '')
        new_model = request.form.get('new_model', 'gpt-4o')
        
        # Get new configuration options (use defaults if not provided)
        new_rigor_level = request.form.get('new_rigor_level', 'balanced')
        new_detail_level = request.form.get('new_detail_level', 'comprehensive')
        
        # Load session data
        session_file = REPORTS_FOLDER / f"session_{session_id}.json"
        if not session_file.exists():
            return jsonify({'error': 'Session not found'}), 404
        
        with open(session_file, 'r') as f:
            session_data = json.load(f)
        
        # Initialize generator with new model
        generator = EnhancedMeetingMinutesGenerator(model=new_model)
        
        # Load original data
        with open(session_data['transcript_path'], 'r', encoding='utf-8') as f:
            transcript = f.read()
        
        # Process PowerPoint if available
        ppt_content = None
        if session_data['powerpoint_path']:
            ppt_content = generator.process_powerpoint_content(session_data['powerpoint_path'])
        
        # Extract previous reports summary if available
        previous_reports_summary = ""
        if session_data['previous_reports']:
            previous_reports_summary = extract_previous_reports_summary(session_data['previous_reports'])
        
        # Generate with new instructions and configuration
        minutes = generator.generate_meeting_minutes_with_config(
            transcript=transcript,
            ppt_content=ppt_content,
            meeting_title=session_data['meeting_title'],
            previous_reports_summary=previous_reports_summary,
            user_instructions=new_instructions,
            rigor_level=new_rigor_level,
            detail_level=new_detail_level,
            action_focus=session_data.get('action_focus', 'standard'),
            output_style=session_data.get('output_style', 'professional')
        )
        
        # Check for potential truncation issues  
        validation_notes = []
        if "## Meeting Agenda" in minutes and "## Meeting Discussion by Agenda Item" in minutes:
            agenda_section = minutes.split("## Meeting Agenda")[1].split("##")[0]
            agenda_items = [line.strip() for line in agenda_section.split('\n') if line.strip() and any(line.strip().startswith(f'{i}.') for i in range(1, 10))]
            
            discussion_section = minutes.split("## Meeting Discussion by Agenda Item")[1].split("## Action Items")[0] if "## Action Items" in minutes else minutes.split("## Meeting Discussion by Agenda Item")[1]
            discussion_items = [line.strip() for line in discussion_section.split('\n') if line.strip().startswith('###')]
            
            if len(agenda_items) > len(discussion_items):
                validation_notes.append(f"⚠️ WARNING: Agenda lists {len(agenda_items)} items but only {len(discussion_items)} discussion sections generated.")
                validation_notes.append("This may indicate output truncation due to token limits. Consider regenerating or breaking into smaller sections.")
        
        # Add validation warnings to the output if needed
        if validation_notes:
            minutes += "\n\n## Generation Validation Warnings\n"
            for note in validation_notes:
                minutes += f"- {note}\n"
        
        # Save new report
        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
        report_filename = f"meeting_minutes_{timestamp}_regenerated.md"
        report_path = REPORTS_FOLDER / report_filename
        
        with open(report_path, 'w', encoding='utf-8') as f:
            f.write(minutes)
        
        # Convert to HTML
        html_content = markdown.markdown(minutes, extensions=['tables', 'fenced_code'])
        
        # Update session data
        session_data['user_instructions'] = new_instructions
        session_data['model'] = new_model
        session_data['report_path'] = str(report_path)
        
        new_session_id = timestamp
        new_session_file = REPORTS_FOLDER / f"session_{new_session_id}.json"
        with open(new_session_file, 'w') as f:
            json.dump(session_data, f)
        
        return jsonify({
            'success': True,
            'html_content': html_content,
            'markdown_content': minutes,
            'report_path': str(report_path),
            'session_id': new_session_id
        })
    
    except Exception as e:
        logger.error(f"Error regenerating minutes: {str(e)}")
        return jsonify({'error': f'Error regenerating minutes: {str(e)}'}), 500

Return Value

Returns a Flask JSON response. On success (200): {'success': True, 'html_content': string (HTML-formatted minutes), 'markdown_content': string (raw markdown), 'report_path': string (file path to saved report), 'session_id': string (new session identifier)}. On error (404 if session not found, 500 for other errors): {'error': string (error message)}.

Dependencies

• flask
• markdown
• logging
• pathlib
• datetime
• json
• openai

Required Imports

from flask import request, jsonify
import markdown
import json
from datetime import datetime
from pathlib import Path
import logging

Conditional/Optional Imports

These imports are only needed under specific conditions:

from enhanced_meeting_minutes_generator import EnhancedMeetingMinutesGenerator

from document_extractor import DocumentExtractor

Usage Example

# Example POST request to regenerate minutes
import requests

# Assuming Flask app is running on localhost:5000
response = requests.post(
    'http://localhost:5000/regenerate',
    data={
        'session_id': '20240115_143022',
        'new_instructions': 'Focus more on action items and deadlines',
        'new_model': 'gpt-4o',
        'new_rigor_level': 'thorough',
        'new_detail_level': 'comprehensive'
    }
)

if response.status_code == 200:
    result = response.json()
    print(f"Success! New session ID: {result['session_id']}")
    print(f"Report saved to: {result['report_path']}")
    # Access HTML content: result['html_content']
    # Access markdown: result['markdown_content']
else:
    print(f"Error: {response.json()['error']}")

Best Practices

• Always validate that session_id exists before attempting regeneration to avoid 404 errors
• Monitor the validation_notes in the output for warnings about potential truncation due to token limits
• Consider breaking large meetings into smaller sections if truncation warnings appear
• Preserve original session data by creating new session files rather than overwriting
• Use appropriate error handling when calling this endpoint as it can fail due to missing files, AI API errors, or file I/O issues
• Ensure REPORTS_FOLDER has write permissions for saving new reports and session files
• Be aware that regeneration creates a new session_id and report file, so track both old and new sessions if needed
• The function validates agenda items against discussion sections to detect incomplete generation
• Use markdown extensions ['tables', 'fenced_code'] when converting to HTML to maintain formatting

Tags

Similar Components

AI-powered semantic similarity - components with related functionality:

• function generate_minutes 81.5% similar

  Flask route handler that processes uploaded meeting transcripts and optional supporting documents to generate structured meeting minutes using AI, with configurable output styles and validation.

  From: /tf/active/vicechatdev/leexi/app.py

• function handle_potential_truncation 65.0% similar

  Detects and handles truncated meeting minutes by comparing agenda items to discussion sections, then attempts regeneration with enhanced instructions to ensure completeness.

  From: /tf/active/vicechatdev/leexi/app.py

• class MeetingMinutesGenerator 64.4% similar

  A class that generates professional meeting minutes from meeting transcripts using OpenAI's GPT-4o model, with capabilities to parse metadata, extract action items, and format output.

  From: /tf/active/vicechatdev/meeting_minutes_generator.py

• class MeetingMinutesGenerator_v1 63.1% similar

  A class that generates professional meeting minutes from meeting transcripts using either OpenAI's GPT-4o or Google's Gemini AI models.

  From: /tf/active/vicechatdev/advanced_meeting_minutes_generator.py

• function test_web_ui 62.2% similar

  Integration test function that validates a Flask web UI for meeting minutes generation by testing file upload, generation, and regeneration endpoints with sample transcript and PowerPoint files.

  From: /tf/active/vicechatdev/leexi/test_ui.py