Update app.py

app.py

@@ -10,6 +10,7 @@ from docx import Document
 import io
 import os
 import traceback
+from datetime import datetime
 
 @dataclass
 class DocumentCheckResult:
@@ -934,42 +935,171 @@ class FAADocumentChecker(DocumentChecker):
 
         return results
 
-def process_document(file_obj, doc_type, template_type):
-    """Process the document and run all checks."""
+@dataclass
+class DocumentCheckResult:
+    """Structured result for document checks."""
+    success: bool
+    issues: List[Dict[str, Any]]
+    details: Optional[Dict[str, Any]] = None
+
+def format_check_results(results: Dict[str, DocumentCheckResult], doc_type: str) -> str:
+    """Format check results into a Markdown string for display."""
+    output = []
+    
+    # Add header with timestamp
+    current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    output.extend([
+        f"# Document Check Results - {current_time}",
+        f"## Document Type: {doc_type}",
+        "---\n"
+    ])
+
+    # Count issues
+    total_issues = sum(1 for r in results.values() if not r.success)
+    
+    if total_issues == 0:
+        output.append("✅ **All checks passed successfully!**\n")
+        return "\n".join(output)
+    
+    output.append(f"❗ Found issues in {total_issues} check categories\n")
+
+    # Define check categories and their display names
+    check_categories = {
+        'heading_title_check': {
+            'title': '📋 Required Headings',
+            'priority': 1
+        },
+        'heading_title_period_check': {
+            'title': '🔍 Heading Period Usage',
+            'priority': 1
+        },
+        'acronym_check': {
+            'title': '📝 Acronym Definitions',
+            'priority': 2
+        },
+        'terminology_check': {
+            'title': '📖 Terminology Usage',
+            'priority': 2
+        },
+        'section_symbol_usage_check': {
+            'title': '§ Section Symbol Usage',
+            'priority': 2
+        },
+        'caption_check_table': {
+            'title': '📊 Table Captions',
+            'priority': 3
+        },
+        'caption_check_figure': {
+            'title': '🖼️ Figure Captions',
+            'priority': 3
+        },
+        'table_figure_reference_check': {
+            'title': '🔗 Table/Figure References',
+            'priority': 3
+        },
+        'document_title_check': {
+            'title': '📑 Document Title Format',
+            'priority': 1
+        },
+        'double_period_check': {
+            'title': '⚡ Double Periods',
+            'priority': 4
+        },
+        'spacing_check': {
+            'title': '⌨️ Spacing Issues',
+            'priority': 4
+        },
+        'abbreviation_usage_check': {
+            'title': '📎 Abbreviation Usage',
+            'priority': 3
+        },
+        'date_formats_check': {
+            'title': '📅 Date Formats',
+            'priority': 3
+        },
+        'placeholders_check': {
+            'title': '🚩 Placeholder Content',
+            'priority': 1
+        }
+    }
+
+    # Sort checks by priority
+    sorted_checks = sorted(
+        [(name, result) for name, result in results.items()],
+        key=lambda x: check_categories.get(x[0], {'priority': 999})['priority']
+    )
+
+    # Process each check result
+    for check_name, result in sorted_checks:
+        if not result.success:
+            category = check_categories.get(check_name, {'title': check_name.replace('_', ' ').title()})
+            
+            output.append(f"### {category['title']}")
+            
+            if isinstance(result.issues, list):
+                for issue in result.issues[:5]:  # Show first 5 issues
+                    if isinstance(issue, dict):
+                        # Format dictionary issues
+                        for key, value in issue.items():
+                            if isinstance(value, list):
+                                output.extend([f"- {item}" for item in value])
+                            else:
+                                output.append(f"- {key}: {value}")
+                    else:
+                        output.append(f"- {issue}")
+                
+                # Show count of remaining issues
+                if len(result.issues) > 5:
+                    output.append(f"\n*...and {len(result.issues) - 5} more similar issues*")
+            
+            output.append("")  # Add spacing between sections
+
+    # Add summary and recommendations
+    output.extend([
+        "## 📋 Summary and Recommendations",
+        "",
+        "### Priority Order for Fixes:",
+        "1. 🔴 Critical: Heading formats, required content, and document structure",
+        "2. 🟡 Important: Terminology, acronyms, and references",
+        "3. 🟢 Standard: Formatting, spacing, and style consistency",
+        "",
+        "### Next Steps:",
+        "1. Address issues in priority order",
+        "2. Use search/replace for consistent fixes",
+        "3. Re-run checker after making changes",
+        "4. Update your document template if needed",
+        ""
+    ])
+
+    return "\n".join(output)
+
+def process_document(file_obj, doc_type: str, template_type: Optional[str] = None) -> str:
+    """Process document and run all checks."""
     try:
-        # Convert file object to BytesIO
+        # Initialize checker
+        checker = FAADocumentChecker()
+        
+        # Convert file object to BytesIO if needed
         if isinstance(file_obj, bytes):
             file_obj = io.BytesIO(file_obj)
-        
-        checker = FAADocumentChecker()
+            
+        # Extract paragraphs
         doc = Document(file_obj)
         paragraphs = [para.text for para in doc.paragraphs if para.text.strip()]
-
-        # Rewind the file object for additional processing
+        
+        # Rewind file object
         file_obj.seek(0)
-
+        
         # Run all checks
-        results = {}
-        results['heading_check'] = checker.heading_title_check(paragraphs, doc_type)
-        results['heading_period_check'] = checker.heading_title_period_check(paragraphs, doc_type)
-        results['acronym_check'] = checker.acronym_check(paragraphs)
-        results['terminology_check'] = checker.check_terminology(paragraphs)
-        results['section_symbol_check'] = checker.check_section_symbol_usage(paragraphs)
-        results['table_caption_check'] = checker.caption_check(paragraphs, doc_type, 'Table')
-        results['figure_caption_check'] = checker.caption_check(paragraphs, doc_type, 'Figure')
-        results['references_check'] = checker.table_figure_reference_check(paragraphs, doc_type)
-        results['title_check'] = checker.document_title_check(file_obj, doc_type)
-        results['double_period_check'] = checker.double_period_check(paragraphs)
-        results['spacing_check'] = checker.spacing_check(paragraphs)
-        results['abbreviation_check'] = checker.check_abbreviation_usage(paragraphs)
-        results['date_check'] = checker.check_date_formats(paragraphs)
-        results['placeholder_check'] = checker.check_placeholders(paragraphs)
-
-        return format_results_for_gradio(results, doc_type)
+        results = checker.run_all_checks(file_obj, doc_type, template_type)
+        
+        # Format results for display
+        return format_check_results(results, doc_type)
+        
     except Exception as e:
-        print(f"Error in process_document: {str(e)}")
-        traceback.print_exc()  # This will print the full traceback
-        return f"An error occurred while processing the document: {str(e)}"
+        logging.error(f"Error processing document: {str(e)}")
+        traceback.print_exc()
+        return f"❌ Error processing document: {str(e)}\n\nPlease ensure the file is a valid .docx document and try again."
 
 def format_results_for_gradio(results: Dict[str, DocumentCheckResult], doc_type: str) -> str:
     """Format the results for display in Gradio."""
@@ -1026,67 +1156,123 @@ def format_results_for_gradio(results: Dict[str, DocumentCheckResult], doc_type:
 
     return "\n".join(output)
 
-# Create the Gradio interface
-demo = gr.Blocks(theme='JohnSmith9982/small_and_pretty')
-
-with demo:
-    gr.Markdown("# Document Checker Tool")
-    gr.Markdown("Upload a Word (docx) document to check for compliance with U.S. federal documentation standards.")
-    gr.Markdown("*This tool is still in development and you might get false positives in your results*")
-    gr.Markdown("Contact Eric Putnam if you have questions and comments.")
-    gr.Markdown("""
-    1. Upload a clean (no track changes or comments) Word file.
-    2. Choose **Check Document**.""")
+def create_interface():
+    """Create and configure the Gradio interface."""
     
     document_types = [
-        "Advisory Circular", "Airworthiness Criteria", "Deviation Memo", "Exemption", 
-        "Federal Register Notice", "Order", "Policy Statement", 
-        "Rule", "Special Condition", "Technical Standard Order", "Other"
+        "Advisory Circular",
+        "Airworthiness Criteria",
+        "Deviation Memo",
+        "Exemption",
+        "Federal Register Notice",
+        "Order",
+        "Policy Statement",
+        "Rule",
+        "Special Condition",
+        "Technical Standard Order",
+        "Other"
     ]
     
     template_types = ["Short AC template AC", "Long AC template AC"]
     
-    with gr.Row():
-        with gr.Column(scale=1):
-            file_input = gr.File(
-                label="Upload Word Document (.docx)",
-                file_types=[".docx"],
-                type="binary"
-            )
-            doc_type = gr.Dropdown(
-                choices=document_types,
-                label="Document Type",
-                value="Advisory Circular"
-            )
-            template_type = gr.Radio(
-                choices=template_types,
-                label="Template Type (Only for Advisory Circular)",
-                visible=True,
-                value="Short AC template AC"
-            )
-            submit_btn = gr.Button("Check Document", variant="primary")
-        
-        with gr.Column(scale=2):
-            output = gr.Markdown(
-                label="Check Results",
-                value="Results will appear here after processing..."
-            )
-    
-    def update_template_visibility(doc_type):
-        return gr.update(visible=doc_type == "Advisory Circular")
+    # Custom CSS for better styling
+    custom_css = """
+    .gradio-container {
+        font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+    }
+    .container {
+        max-width: 900px;
+        margin: auto;
+    }
+    .alert {
+        padding: 1rem;
+        margin-bottom: 1rem;
+        border-radius: 0.5rem;
+        background-color: #f8f9fa;
+        border: 1px solid #dee2e6;
+    }
+    """
     
-    doc_type.change(
-        fn=update_template_visibility,
-        inputs=[doc_type],
-        outputs=[template_type]
-    )
+    with gr.Blocks(theme=gr.themes.Soft(), css=custom_css) as demo:
+        gr.Markdown(
+            """
+            # 📑 Document Checker Tool
+            
+            ### Purpose
+            This tool checks Word documents for compliance with U.S. federal documentation standards.
+            
+            ### How to Use
+            1. Upload your Word document (.docx format)
+            2. Select the document type
+            3. Click "Check Document"
+            
+            > **Note:** Please ensure your document is clean (no track changes or comments)
+            """
+        )
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                file_input = gr.File(
+                    label="📎 Upload Word Document (.docx)",
+                    file_types=[".docx"],
+                    type="binary"
+                )
+                
+                doc_type = gr.Dropdown(
+                    choices=document_types,
+                    label="📋 Document Type",
+                    value="Advisory Circular",
+                    info="Select the type of document you're checking"
+                )
+                
+                template_type = gr.Radio(
+                    choices=template_types,
+                    label="📑 Template Type",
+                    visible=False,
+                    info="Only applicable for Advisory Circulars"
+                )
+                
+                submit_btn = gr.Button(
+                    "🔍 Check Document",
+                    variant="primary"
+                )
+            
+            with gr.Column(scale=2):
+                results = gr.Markdown(
+                    label="Check Results",
+                    value="Results will appear here after processing...",
+                    elem_classes=["results-panel"]
+                )
+        
+        # Update template type visibility based on document type
+        def update_template_visibility(doc_type):
+            return gr.update(visible=doc_type == "Advisory Circular")
+        
+        doc_type.change(
+            fn=update_template_visibility,
+            inputs=[doc_type],
+            outputs=[template_type]
+        )
+        
+        # Handle document processing
+        submit_btn.click(
+            fn=process_document,
+            inputs=[file_input, doc_type, template_type],
+            outputs=[results]
+        )
+        
+        gr.Markdown(
+            """
+            ### 📌 Important Notes
+            - This tool is in development; you may encounter false positives
+            - For questions or feedback, contact Eric Putnam
+            - Results are not stored or saved
+            """
+        )
     
-    submit_btn.click(
-        fn=process_document,
-        inputs=[file_input, doc_type, template_type],
-        outputs=[output]
-    )
+    return demo
 
-# Launch the demo
+# Initialize and launch the interface
 if __name__ == "__main__":
+    demo = create_interface()
     demo.launch()