Update app.py

app.py

@@ -122,6 +122,197 @@ def table_figure_reference_check(paragraphs, doc_type):
     
     return len(incorrect_table_figure_references) == 0, incorrect_table_figure_references
 
+def document_title_check(doc_path, doc_type):
+    incorrect_titles = []
+    doc = Document(doc_path)
+    
+    # Updated pattern to capture titles correctly
+    ac_pattern = re.compile(r'AC\s+\d+(?:-\d+)?(?:,|\s)+(.+?)(?=\.|,|$)')
+    
+    # Define formatting rules for different document types
+    formatting_rules = {
+        "Advisory Circular": {"italics": True, "quotes": False},
+        "Airworthiness Criteria": {"italics": False, "quotes": True},
+        "Deviation Memo": {"italics": False, "quotes": True},
+        "Exemption": {"italics": False, "quotes": True},
+        "Federal Register Notice": {"italics": False, "quotes": True},
+        "Handbook/Manual": {"italics": False, "quotes": False},
+        "Order": {"italics": False, "quotes": True},
+        "Policy Statement": {"italics": False, "quotes": False},
+        "Rule": {"italics": False, "quotes": True},
+        "Special Condition": {"italics": False, "quotes": True},
+        "Technical Standard Order": {"italics": False, "quotes": True},
+        "Other": {"italics": False, "quotes": False}
+    }
+    
+    # Get the rules for the current document type
+    if doc_type not in formatting_rules:
+        raise ValueError(f"Unsupported document type: {doc_type}")
+    
+    required_format = formatting_rules[doc_type]
+    
+    for paragraph in doc.paragraphs:
+        text = paragraph.text
+        matches = ac_pattern.finditer(text)
+        
+        for match in matches:
+            full_match = match.group(0)
+            title_text = match.group(1).strip()
+            
+            # Get the position where the title starts
+            title_start = match.start(1)
+            
+            # Check for any type of quotation marks, including smart quotes
+            title_in_quotes = any(q in title_text for q in ['"', "'", '"', '"', ''', '''])
+            
+            # Check the formatting of the title
+            title_is_italicized = False
+            current_pos = 0
+            for run in paragraph.runs:
+                run_length = len(run.text)
+                if current_pos <= title_start < current_pos + run_length:
+                    relative_pos = title_start - current_pos
+                    title_is_italicized = run.italic
+                    break
+                current_pos += run_length
+            
+            # Check if formatting matches the required format
+            formatting_incorrect = False
+            issue_message = []
+            
+            # Check italics requirement
+            if required_format["italics"] and not title_is_italicized:
+                formatting_incorrect = True
+                issue_message.append("should be italicized")
+            elif not required_format["italics"] and title_is_italicized:
+                formatting_incorrect = True
+                issue_message.append("should not be italicized")
+            
+            # Check quotes requirement
+            if required_format["quotes"] and not title_in_quotes:
+                formatting_incorrect = True
+                issue_message.append("should be in quotes")
+            elif not required_format["quotes"] and title_in_quotes:
+                formatting_incorrect = True
+                issue_message.append("should not be in quotes")
+            
+            if formatting_incorrect:
+                incorrect_titles.append({
+                    'text': full_match,
+                    'issue': ', '.join(issue_message)
+                })
+    
+    return len(incorrect_titles) == 0, incorrect_titles
+
+def get_document_checks(doc_type, template_type):
+    """Return the required headings and other checks based on document type."""
+    document_checks = {
+        "Advisory Circular": {
+            "Short AC template AC": {
+                "required_headings": [
+                    "PURPOSE.",
+                    "APPLICABILITY.",
+                    "CANCELLATION.",
+                    "RELATED MATERIAL.",
+                    "DEFINITION OF KEY TERMS."
+                ]
+            },
+            "Long AC template AC": {
+                "required_headings": [
+                    "Purpose.",
+                    "Applicability.",
+                    "Cancellation.",
+                    "Related Material.",
+                    "Definition of Key Terms."
+                ]
+            }
+        },
+        "Airworthiness Criteria": {
+            "required_headings": [
+                "TBD - Need to research"
+            ]
+        },
+        "Deviation Memo": {
+            "required_headings": [
+                "TBD - Need to research"
+            ]
+        },
+        "Exemption": {
+            "required_headings": [
+                "TBD - Need to research"
+            ]
+        },
+        "Federal Register Notice": {
+            "required_headings": [
+                "Purpose of This Notice",
+                "Audience",
+                "Where can I Find This Notice"
+            ]
+        },
+        "Handbook/Manual": {
+            "required_headings": [
+                "TBD - Need to research"
+            ]
+        },
+        "Order": {
+            "required_headings": [
+                "Purpose of This Order.",
+                "Audience.",
+                "Where to Find This Order."
+            ]
+        },
+        "Policy Statement": {
+            "required_headings": [
+                "SUMMARY",
+                "CURRENT REGULATORY AND ADVISORY MATERIAL",
+                "RELEVANT PAST PRACTICE",
+                "POLICY",
+                "EFFECT OF POLICY",
+                "CONCLUSION"
+            ]
+        },
+        "Rule": {
+            "required_headings": [
+                "TBD - Need to research"
+            ]
+        },
+        "Special Condition": {
+            "required_headings": [
+                "TBD - Need to research"
+            ]
+        },
+        "Technical Standard Order": {
+            "required_headings": [
+                "PURPOSE.",
+                "APPLICABILITY.",
+                "REQUIREMENTS.",
+                "MARKING.",
+                "APPLICATION DATA REQUIREMENTS.",
+                "MANUFACTURER DATA REQUIREMENTS.",
+                "FURNISHED DATA REQUIREMENTS.",
+                "HOW TO GET REFERENCED DOCUMENTS."
+            ]
+        },
+        "Other": {
+            "required_headings": [
+                "N/A"
+            ]
+        }
+    }
+    
+    # Add debugging logs
+    logger = logging.getLogger(__name__)
+    logger.info(f"Requested document type: {doc_type}")
+    logger.info(f"Requested template type: {template_type}")
+    
+    if doc_type == "Advisory Circular":
+        checks = document_checks.get(doc_type, {}).get(template_type, {})
+    else:
+        checks = document_checks.get(doc_type, {})
+    
+    logger.info(f"Retrieved checks: {checks}")
+    return checks
+
 def double_period_check(paragraphs):
     incorrect_sentences = []
 
@@ -222,21 +413,20 @@ def process_document(file_obj, doc_type, template_type):
         paragraphs = [para.text for para in doc.paragraphs]
         required_headings = get_document_checks(doc_type, template_type).get("required_headings", [])
         
-        # Calls to each function with `paragraphs` as input
+        # Perform each check with `paragraphs` as input
         heading_valid, headings_found = heading_title_check(paragraphs, required_headings)
         acronyms_valid, undefined_acronyms = acronym_check(paragraphs)
         legal_valid, incorrect_legal_references = legal_check(paragraphs)
         table_valid, incorrect_captions = table_caption_check(paragraphs, doc_type)
         figure_valid, incorrect_fig_captions = figure_caption_check(paragraphs, doc_type)
         references_valid, incorrect_table_figure_references = table_figure_reference_check(paragraphs, doc_type)
+        title_style_valid, incorrect_titles = document_title_check(file_obj, doc_type) if doc_type in ["Advisory Circular", "Order"] else (True, [])
         double_period_valid, incorrect_sentences = double_period_check(paragraphs)
         spacing_valid, incorrect_spacing = spacing_check(paragraphs)
-        placeholder_issues = check_prohibited_phrases(paragraphs)
-
-        # Ensure title style check is included
-        title_style_valid, incorrect_titles = document_title_check(file_obj, doc_type) if doc_type in ["Advisory Circular", "Order"] else (True, [])
+        date_issues = check_date_formats(paragraphs)  # Pass paragraphs here
+        placeholder_issues = check_placeholders(paragraphs)  # Pass paragraphs here
         
-        # Return all results
+        # Format results
         results = format_results_for_gradio(
             heading_valid=heading_valid, headings_found=headings_found,
             acronyms_valid=acronyms_valid, undefined_acronyms=undefined_acronyms,
@@ -244,10 +434,11 @@ def process_document(file_obj, doc_type, template_type):
             table_valid=table_valid, incorrect_captions=incorrect_captions,
             figure_valid=figure_valid, incorrect_fig_captions=incorrect_fig_captions,
             references_valid=references_valid, incorrect_table_figure_references=incorrect_table_figure_references,
+            title_style_valid=title_style_valid, incorrect_titles=incorrect_titles,
             double_period_valid=double_period_valid, incorrect_sentences=incorrect_sentences,
             spacing_valid=spacing_valid, incorrect_spacing=incorrect_spacing,
-            title_style_valid=title_style_valid, incorrect_titles=incorrect_titles,
-            placeholder_issues=placeholder_issues,
+            date_issues=date_issues,  # Added date_issues
+            placeholder_issues=placeholder_issues,  # Added placeholder_issues
             required_headings=required_headings, doc_type=doc_type
         )
         return results
@@ -255,22 +446,6 @@ def process_document(file_obj, doc_type, template_type):
         print(f"Error in process_document: {str(e)}")
         return f"An error occurred while processing the document: {str(e)}"
 
-def get_document_checks(doc_type, template_type):
-    """Return the required headings and other checks based on document type."""
-    if doc_type == "Advisory Circular":
-        if template_type == "Short AC template AC":
-            return {
-                "required_headings": ["Purpose", "Applicability", "Related Reading Material", 
-                                    "Background", "Discussion"]
-            }
-        else:  # Long AC template
-            return {
-                "required_headings": ["Purpose", "Applicability", "Audience", "Related Reading Material",
-                                    "Background", "Discussion", "Conclusion"]
-            }
-    # Add other document types as needed
-    return {"required_headings": []}
-
 def format_results_for_gradio(**kwargs):
     """Format the results for display in Gradio."""
     results = []
@@ -473,8 +648,7 @@ with demo:
         with gr.Column(scale=2):
             output = gr.Markdown(
                 label="Check Results",
-                value="Results will appear here after processing..."
-            )
+                ).markdown("Results will appear here after processing...")
     
     # Update template type visibility based on document type
     def update_template_visibility(doc_type):