""" Enhanced Document Generation Function - Integration with improved AI model Replaces the original generate_document function to fix the missing sections issue """ import logging from typing import Tuple, Dict, List logger = logging.getLogger(__name__) def generate_document_advanced( title: str, requirements: str, lecture_notes: str, document_type: str, length_words: int, style: str, include_tables: bool, include_charts: bool, include_citations: bool, citation_style: str, formats: list, # Component instances (to be passed in from app.py) analyzer=None, advanced_generator=None, research_generator=None, humanizer=None, quality_enhancer=None, document_processor=None, table_gen=None, citation_mgr=None, detector=None, pdf_gen=None, word_gen=None, md_gen=None, html_gen=None, metrics=None, preview_manager=None, transparency=None, FileHandler=None, TextFormatter=None, format_download_instructions=None, ) -> Tuple[str, dict, dict, dict]: """ Generate complete academic document with research-driven, topic-specific content. This is an enhanced version that: 1. Uses ResearchDrivenContentGenerator for topic-specific content (NOT generic) 2. Synthesizes research data into coherent sections 3. Uses EnhancedDocumentProcessor to ensure all sections are properly assembled 4. Validates document completeness before output 4. Provides detailed logging of what was generated """ try: logger.info(f"Starting advanced document generation: {title}") logger.info(f"Document type: {document_type}, Word count target: {length_words}") # Log event if transparency: transparency.log_event("advanced_document_generation_started", { "title": title, "type": document_type, "length": length_words, "formats": formats, }) # Step 1: Analyze requirements logger.info("Step 1: Analyzing requirements...") if not analyzer: from src.ai_engine import RequirementAnalyzer analyzer = RequirementAnalyzer() reqs = analyzer.analyze_requirements(requirements, lecture_notes) logger.info(f"Identified {len(reqs.sections)} sections: {reqs.sections}") # Step 2: Generate content for ALL sections using ResearchDrivenContentGenerator logger.info("Step 2: Generating research-driven content sections...") if not research_generator: from src.ai_engine import ResearchDrivenContentGenerator research_generator = ResearchDrivenContentGenerator() # Generate content with research synthesis (NOT generic templates) content_dict = research_generator.generate_document_sections( sections=reqs.sections, title=title, context=requirements, topics=reqs.key_topics if reqs.key_topics else [title] * len(reqs.sections), style=reqs.style, total_words=length_words, ) logger.info(f"Generated {len(content_dict)} research-driven sections with content") for section, content in content_dict.items(): word_count = len(content.split()) logger.info(f" - {section}: {word_count} words (research-based)") # Step 3: Humanize content for natural language logger.info("Step 3: Humanizing content...") if not humanizer: from src.ai_engine import Humanizer humanizer = Humanizer() for section in content_dict: content_dict[section] = humanizer.humanize_content( content_dict[section], style=reqs.style ) # Step 4: Enhance quality (remove placeholders, improve readability) logger.info("Step 4: Enhancing content quality...") if not quality_enhancer: from src.ai_engine import ContentQualityEnhancer quality_enhancer = ContentQualityEnhancer() content_dict = quality_enhancer.enhance_document_content(content_dict, title) quality_report = quality_enhancer.get_quality_report(content_dict) # Step 5: Assemble complete document with proper structure # THIS IS THE CRITICAL FIX: Use EnhancedDocumentProcessor logger.info("Step 5: Assembling complete document...") if not document_processor: from src.document_engine import EnhancedDocumentProcessor document_processor = EnhancedDocumentProcessor() complete_document, assembly_messages = document_processor.assemble_complete_document( title=title, content_sections=content_dict, author="AI Academic Suite", document_type=document_type, include_toc=True, include_citations=include_citations, citations=[], # Will be added later ) logger.info("Assembly messages:") for msg in assembly_messages: logger.info(f" {msg}") # Step 6: Generate visualizations if requested logger.info("Step 6: Generating visualizations...") tables_html = "" if include_tables and table_gen: try: table_data = table_gen.generate_summary_table("\n".join(content_dict.values())) tables_html = table_gen.format_as_html(table_data) logger.info(" Tables generated successfully") except Exception as e: logger.warning(f" Table generation failed: {e}") # Step 7: Generate citations if requested logger.info("Step 7: Generating citations...") citations = [] if include_citations and citation_mgr: try: citations = [ citation_mgr.generate_citation( ["Smith, J.", "Doe, A."], f"Research on {reqs.key_topics[0] if reqs.key_topics else 'Topic'}", "Academic Journal", 2024, style=citation_style ), citation_mgr.generate_citation( ["Johnson, B."], "Contemporary Research Methods", "University Press", 2023, style=citation_style ), ] logger.info(f" Generated {len(citations)} citations") except Exception as e: logger.warning(f" Citation generation failed: {e}") # Step 8: Export to requested formats logger.info("Step 8: Exporting to requested formats...") outputs = {} status_updates = [] if not FileHandler: from utils import FileHandler if "pdf" in formats: try: if not pdf_gen: from src.document_engine import PDFGenerator pdf_gen = PDFGenerator() pdf_bytes = pdf_gen.generate_pdf( title, complete_document, include_citations=include_citations, citations=citations ) pdf_path = FileHandler.save_file(pdf_bytes, f"{title.replace(' ', '_')}.pdf") outputs["PDF"] = pdf_path status_updates.append("✓ PDF generated successfully") logger.info(" PDF export successful") except Exception as e: status_updates.append(f"✗ PDF generation failed: {str(e)[:50]}") logger.error(f" PDF export failed: {e}") if "docx" in formats: try: if not word_gen: from src.document_engine import WordGenerator word_gen = WordGenerator() docx_bytes = word_gen.generate_word_doc( title, complete_document, include_citations=include_citations, citations=citations ) docx_path = FileHandler.save_file(docx_bytes, f"{title.replace(' ', '_')}.docx") outputs["Word"] = docx_path status_updates.append("✓ Word document generated successfully") logger.info(" Word export successful") except Exception as e: status_updates.append(f"✗ Word generation failed: {str(e)[:50]}") logger.error(f" Word export failed: {e}") if "md" in formats: try: if not md_gen: from src.document_engine import MarkdownGenerator md_gen = MarkdownGenerator() md_bytes = md_gen.generate_markdown_bytes( title, complete_document, include_citations=include_citations, citations=citations ) md_path = FileHandler.save_file(md_bytes, f"{title.replace(' ', '_')}.md") outputs["Markdown"] = md_path status_updates.append("✓ Markdown generated successfully") logger.info(" Markdown export successful") except Exception as e: status_updates.append(f"✗ Markdown generation failed: {str(e)[:50]}") logger.error(f" Markdown export failed: {e}") if "html" in formats: try: if not html_gen: from src.document_engine import HTMLGenerator html_gen = HTMLGenerator() html_bytes = html_gen.generate_html_bytes( title, complete_document, include_citations=include_citations, citations=citations ) html_path = FileHandler.save_file(html_bytes, f"{title.replace(' ', '_')}.html") outputs["HTML"] = html_path status_updates.append("✓ HTML generated successfully") logger.info(" HTML export successful") except Exception as e: status_updates.append(f"✗ HTML generation failed: {str(e)[:50]}") logger.error(f" HTML export failed: {e}") # Step 9: Generate quality metrics and AI detection analysis logger.info("Step 9: Analyzing document quality...") full_content = "\n".join(complete_document.values()) if not metrics: from src.research_tools import QualityMetrics metrics = QualityMetrics() quality = metrics.get_quality_report(full_content) if not detector: from src.ai_engine import AIDetector detector = AIDetector() detection = detector.analyze_detection_risk(full_content) # Step 10: Generate result summary logger.info("Step 10: Generating result summary...") if not TextFormatter: from utils import TextFormatter result_text = ( f"✅ ADVANCED DOCUMENT GENERATION COMPLETE\n\n" f"Title: {title}\n" f"Type: {document_type}\n" f"Sections Generated: {len(complete_document)}\n" f"Word Count: {TextFormatter.word_count(full_content)}\n" f"Reading Time: ~{TextFormatter.estimate_reading_time(full_content)} minutes\n\n" f"📊 QUALITY METRICS:\n" f" Readability Score: {quality.get('readability', 0)}/100\n" f" Coherence: {quality.get('coherence', 0)}/100\n" f" Originality: {quality.get('originality', 0)}/100\n\n" f"⚠️ AI DETECTION RISK: {detection.get('risk_level', 'Unknown')}\n" f" Risk Score: {detection.get('risk_score', 0):.1%}\n" f" Recommendation: {detection.get('recommendation', 'N/A')}\n\n" f"📋 DOCUMENT STRUCTURE:\n" f" Total Sections: {len(complete_document)}\n" ) # Add section details result_text += " Section Details:\n" for section_name, content in complete_document.items(): word_count = len(content.split()) result_text += f" ✓ {section_name}: {word_count} words\n" result_text += ( f"\n📥 GENERATED FORMATS:\n" + "\n".join(f" ✓ {fmt.upper()}" for fmt in outputs.keys()) + "\n\n" + f"🔗 STATUS:\n" + "\n".join(f" {s}" for s in status_updates) ) # Register document for preview & download if preview_manager: doc_id = preview_manager.register_document( title=title, file_paths=outputs, content_preview=full_content, metadata={ "document_type": document_type, "sections_count": len(complete_document), "word_count": TextFormatter.word_count(full_content), "reading_time": TextFormatter.estimate_reading_time(full_content), "quality_score": quality.get('readability', 0), "ai_detection_risk": detection.get('risk_level', 'Unknown'), "formats_available": list(outputs.keys()) } ) # Add download information if format_download_instructions: result_text += f"\n\n{'=' * 60}\n" result_text += format_download_instructions(doc_id, list(outputs.keys())) result_text += f"{'=' * 60}\n" logger.info(f"Document registered with ID: {doc_id}") # Log completion if transparency: transparency.log_event("advanced_document_generation_completed", { "formats_generated": list(outputs.keys()), "sections_count": len(complete_document), "word_count": TextFormatter.word_count(full_content), "quality_score": quality.get('readability', 0), }) logger.info("✅ Advanced document generation completed successfully") return result_text, quality, detection, {"tables": tables_html} except Exception as e: error_msg = f"❌ Error in advanced document generation: {str(e)}" logger.error(error_msg, exc_info=True) return error_msg, {}, {}, {}