Update app.py

app.py

@@ -18,37 +18,24 @@ def heading_title_check(paragraphs, required_headings):
     return all_headings_present, headings_found
 
 def acronym_check(paragraphs):
-    """Check if all acronyms are defined at first use and return undefined acronyms."""
-    defined_acronyms = set()  # Set to store defined acronyms
-    undefined_acronyms = set()  # Set to store undefined acronyms
-    acronym_pattern = re.compile(r'(\b[A-Z]{2,}\b)')  # Regex to find acronyms (2 or more uppercase letters)
-    defined_pattern = re.compile(r'(\b\w+\b) \((\b[A-Z]{2,}\b)\)')  # Regex to find definitions like "Federal Aviation Administration (FAA)"
-
-    for paragraph in paragraphs:  # Use paragraphs here
-        # Check for defined acronyms
+    defined_acronyms = set()
+    undefined_acronyms = set()
+    acronym_pattern = re.compile(r'(\b[A-Z]{2,}\b)')
+    defined_pattern = re.compile(r'(\b\w+\b) \((\b[A-Z]{2,}\b)\)')
+
+    for paragraph in paragraphs:
         defined_matches = defined_pattern.findall(paragraph)
         for full_term, acronym in defined_matches:
-            defined_acronyms.add(acronym)  # Add the acronym to the defined set
+            defined_acronyms.add(acronym)
 
-        # Check for usage of acronyms
         usage_matches = acronym_pattern.findall(paragraph)
         for acronym in usage_matches:
             if acronym not in defined_acronyms:
-                undefined_acronyms.add(acronym)  # Add to undefined acronyms if not defined
+                undefined_acronyms.add(acronym)
 
     return len(undefined_acronyms) == 0, undefined_acronyms
 
-
 def legal_check(paragraphs):
-    """Check for correct legal references in the document and suggest corrections.
-    
-    Args:
-        doc (list): List of paragraphs/strings to check
-        
-    Returns:
-        tuple: (bool, list) - (True if no errors found, list of (incorrect, correct) terms)
-    """
-    # Mapping of incorrect terms to their correct versions
     incorrect_variations = {
         r"\bUSC\b": "U.S.C.",
         r"\bCFR Part\b": "CFR part",
@@ -59,28 +46,21 @@ def legal_check(paragraphs):
         r"\bshall\b": "must or will",
         r"\b&\b": "and"
     }
-    
-    # List to store tuples of incorrect terms and their correct versions
     incorrect_legal_references = []
     
     for paragraph in paragraphs:
-        # Special handling for "Title 14" / "title 14"
         title_14_pattern = r"(?P<prefix>^|[.!?\s])\s*(?P<title>title 14|Title 14)\b"
         matches = re.finditer(title_14_pattern, paragraph)
         
         for match in matches:
             prefix = match.group('prefix')
             current_title = match.group('title')
-            
-            # If it follows a sentence-ending punctuation or is at start, it should be "Title 14"
             if prefix in ('.', '!', '?', '') and current_title.lower() == "title 14":
                 if current_title != "Title 14":
                     incorrect_legal_references.append((current_title, "Title 14"))
-            # If it's within a sentence, it should be "title 14"
             elif prefix.isspace() and current_title != "title 14":
                 incorrect_legal_references.append((current_title, "title 14"))
         
-        # Check other variations
         for incorrect_pattern, correct_term in incorrect_variations.items():
             matches = re.finditer(incorrect_pattern, paragraph)
             for match in matches:
@@ -89,15 +69,9 @@ def legal_check(paragraphs):
     return len(incorrect_legal_references) == 0, incorrect_legal_references
 
 def table_caption_check(paragraphs, doc_type):
-    """
-    Check for correctly formatted table captions in the document.
-    Supports both numeric (Table 1-2) and alphanumeric (Table C-1) formats.
-    """
     if doc_type in ["Advisory Circular", "Order"]:
-        # Pattern for "Table X-Y" where X and Y can be either letters or numbers
         table_caption_pattern = re.compile(r'^Table\s+([A-Z0-9]+)-([A-Z0-9]+)[\.\s]', re.IGNORECASE)
     else:
-        # Pattern for "Table X" where X can be either letters or numbers
         table_caption_pattern = re.compile(r'^Table\s+([A-Z0-9]+)[\.\s]', re.IGNORECASE)
     
     incorrect_captions = []
@@ -111,15 +85,9 @@ def table_caption_check(paragraphs, doc_type):
     return len(incorrect_captions) == 0, incorrect_captions
 
 def figure_caption_check(paragraphs, doc_type):
-    """
-    Check for correctly formatted figure captions in the document.
-    Supports both numeric (Figure 1-2) and alphanumeric (Figure C-1) formats.
-    """
     if doc_type in ["Advisory Circular", "Order"]:
-        # Pattern for "Figure X-Y" where X and Y can be either letters or numbers
         figure_caption_pattern = re.compile(r'^Figure\s+([A-Z0-9]+)-([A-Z0-9]+)[\.\s]', re.IGNORECASE)
     else:
-        # Pattern for "Figure X" where X can be either letters or numbers
         figure_caption_pattern = re.compile(r'^Figure\s+([A-Z0-9]+)[\.\s]', re.IGNORECASE)
     
     incorrect_fig_captions = []
@@ -132,283 +100,58 @@ def figure_caption_check(paragraphs, doc_type):
     return len(incorrect_fig_captions) == 0, incorrect_fig_captions
 
 def table_figure_reference_check(paragraphs, doc_type):
-    """Check for incorrect references to tables and figures in the document."""
     incorrect_table_figure_references = []
     
     if doc_type in ["Advisory Circular", "Order"]:
-        # For Advisory Circulars and Orders, correct references are "Table X-Y" or "Figure X-Y"
         incorrect_table_ref_pattern = re.compile(r'\bTable\s+\d+(?!-\d+)\b', re.IGNORECASE)
         incorrect_figure_ref_pattern = re.compile(r'\bFigure\s+\d+(?!-\d+)\b', re.IGNORECASE)
     else:
-        # For other document types, correct references are "Table X" or "Figure X"
         incorrect_table_ref_pattern = re.compile(r'\bTable\s+\d+(-\d+)?\b', re.IGNORECASE)
         incorrect_figure_ref_pattern = re.compile(r'\bFigure\s+\d+(-\d+)?\b', re.IGNORECASE)
     
     for paragraph in paragraphs:
         paragraph_strip = paragraph.strip()
-        # Exclude captions
         starts_with_table_or_figure = paragraph_strip.lower().startswith('table') or paragraph_strip.lower().startswith('figure')
         if not starts_with_table_or_figure:
-            # Find incorrect table references
             incorrect_tables = incorrect_table_ref_pattern.findall(paragraph)
             if incorrect_tables:
                 incorrect_table_figure_references.extend(incorrect_tables)
-            # Find incorrect figure references
             incorrect_figures = incorrect_figure_ref_pattern.findall(paragraph)
             if incorrect_figures:
                 incorrect_table_figure_references.extend(incorrect_figures)
     
-    # Return False if any incorrect references are found
     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 expected outline and required headings based on document type and template 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):
-    """Check for sentences that end with two periods."""
     incorrect_sentences = []
 
     for paragraph in paragraphs:
-        # Split the paragraph into sentences based on common sentence-ending punctuation
         sentences = re.split(r'(?<=[.!?]) +', paragraph)
         for sentence in sentences:
             if sentence.endswith('..'):
-                incorrect_sentences.append(sentence.strip())  # Log the incorrectly formatted sentence
+                incorrect_sentences.append(sentence.strip())
 
-    return len(incorrect_sentences) == 0, incorrect_sentences  # Return True if no double periods are found, along with any incorrect sentences
+    return len(incorrect_sentences) == 0, incorrect_sentences
 
 def spacing_check(paragraphs):
-    """
-    Check for correct spacing in US federal regulatory documents.
-    Checks for:
-    - Spacing between document type and number (e.g., "AC 20-114")
-    - Spacing around section symbols (e.g., "§ 25.301")
-    - Spacing around part numbers (e.g., "Part 25")
-    - Spacing around paragraph indications (e.g., "(a)", "(1)")
-    - Double spaces between words
-    """
     incorrect_spacing = []
-
-    # Regex patterns to find incorrect spacing
     doc_type_pattern = re.compile(r'(?<!\s)(AC|AD|CFR|FAA|N|SFAR)(\d+[-]?\d*)', re.IGNORECASE)
     section_symbol_pattern = re.compile(r'(?<!\s)(§|§§)(\d+\.\d+)', re.IGNORECASE)
     part_number_pattern = re.compile(r'(?<!\s)Part(\d+)', re.IGNORECASE)
     paragraph_pattern = re.compile(r'(?<!\s)(\([a-z](?!\))|\([1-9](?!\)))', re.IGNORECASE)
     double_space_pattern = re.compile(r'\s{2,}')
 
-    for paragraph in doc:
-        # Check for incorrect document type spacing
-        if doc_type_pattern.search(paragraph):
-            incorrect_spacing.append(paragraph)
-
-        # Check for incorrect section symbol spacing
-        if section_symbol_pattern.search(paragraph):
-            incorrect_spacing.append(paragraph)
-
-        # Check for incorrect part number spacing
-        if part_number_pattern.search(paragraph):
-            incorrect_spacing.append(paragraph)
-
-        # Check for incorrect paragraph indication spacing
-        if paragraph_pattern.search(paragraph):
-            incorrect_spacing.append(paragraph)
-
-        # Check for double spaces
-        if double_space_pattern.search(paragraph):
+    for paragraph in paragraphs:
+        if doc_type_pattern.search(paragraph) or \
+           section_symbol_pattern.search(paragraph) or \
+           part_number_pattern.search(paragraph) or \
+           paragraph_pattern.search(paragraph) or \
+           double_space_pattern.search(paragraph):
             incorrect_spacing.append(paragraph)
 
     return len(incorrect_spacing) == 0, incorrect_spacing
 
 def check_prohibited_phrases(paragraphs):
-    """Check for prohibited words or phrases."""
     prohibited_phrases = [
         r'\babove\b',
         r'\bbelow\b',
@@ -474,64 +217,39 @@ def check_placeholders(paragraphs):
     return issues
 
 def process_document(file_obj, doc_type, template_type):
-    """Process the document and perform checks."""
     try:
-        # Read the Word document
         doc = Document(file_obj)
-        print("Document read successfully.")
-        
-        # Extract text from each paragraph to make it iterable
         paragraphs = [para.text for para in doc.paragraphs]
-        
-        # Get required headings based on document type
         required_headings = get_document_checks(doc_type, template_type).get("required_headings", [])
         
-        # Perform checks
+        # Calls to each function 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)
         double_period_valid, incorrect_sentences = double_period_check(paragraphs)
         spacing_valid, incorrect_spacing = spacing_check(paragraphs)
-        abbreviation_issues = check_abbreviation_usage(paragraphs)
-        date_issues = check_date_formats(paragraphs)
-        placeholder_issues = check_placeholders(paragraphs)
-        
-        # Format results
+        placeholder_issues = check_prohibited_phrases(paragraphs)
+
+        # Return all results
         results = format_results_for_gradio(
-            heading_valid=heading_valid,
-            headings_found=headings_found,
-            acronyms_valid=acronyms_valid,
-            undefined_acronyms=undefined_acronyms,
-            legal_valid=legal_valid,
-            incorrect_legal_references=incorrect_legal_references,
-            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,
-            required_headings=required_headings,
-            doc_type=doc_type,
-            double_period_valid=double_period_valid,
-            incorrect_sentences=incorrect_sentences,
-            spacing_valid=spacing_valid,
-            incorrect_spacing=incorrect_spacing,
-            abbreviation_issues=abbreviation_issues,
-            date_issues=date_issues,
-            placeholder_issues=placeholder_issues
+            heading_valid=heading_valid, headings_found=headings_found,
+            acronyms_valid=acronyms_valid, undefined_acronyms=undefined_acronyms,
+            legal_valid=legal_valid, incorrect_legal_references=incorrect_legal_references,
+            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,
+            double_period_valid=double_period_valid, incorrect_sentences=incorrect_sentences,
+            spacing_valid=spacing_valid, incorrect_spacing=incorrect_spacing,
+            placeholder_issues=placeholder_issues,
+            required_headings=required_headings, doc_type=doc_type
         )
-        
         return results
-    
     except Exception as e:
         print(f"Error in process_document: {str(e)}")
-        raise
+        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."""