Update app.py

app.py

@@ -55,7 +55,7 @@ HEADING_WORDS = {
 # Predefined Acronyms
 PREDEFINED_ACRONYMS = {
     'CFR', 'U.S.', 'USA', 'US', 'U.S.C', 'e.g.', 'i.e.', 'FAQ', 'No.', 'ZIP', 'PDF', 'SSN',
-    'DC', 'MA', 'WA', 'TX', 'MO'
+    'DC', 'MD', 'MA', 'WA', 'TX', 'MO', 'FAA IR-M', 'DOT'
 }
 
 # Configuration Constants
@@ -451,6 +451,16 @@ class DocumentCheckerConfig:
         """
         return {
             'terminology': [
+                PatternConfig(
+                    pattern=r'\btitle 14 of the Code of Federal Regulations \(14 CFR\)\b',
+                    description="Ignore 'title 14 of the Code of Federal Regulations (14 CFR)'",
+                    is_error=False  # Set to False to ignore this phrase
+                ),
+                PatternConfig(
+                    pattern=r'\btitle 14, Code of Federal Regulations \(14 CFR\)\b',
+                    description="Ignore 'title 14, Code of Federal Regulations (14 CFR)'",
+                    is_error=False
+                ),
                 PatternConfig(
                     pattern=r'\bUSC\b',
                     description="USC should be U.S.C.",
@@ -924,10 +934,10 @@ class FAADocumentChecker(DocumentChecker):
             return DocumentCheckResult(success=False, issues=[{'error': 'Invalid document input'}])
 
         # Common words that might appear in uppercase but aren't acronyms
-        heading_words = self.config_manager.config.get('heading_words', HEADING_WORDS)
+        heading_words = self.config_manager.config.get('heading_words', self.HEADING_WORDS)
 
         # Standard acronyms that don't need to be defined
-        predefined_acronyms = self.config_manager.config.get('predefined_acronyms', PREDEFINED_ACRONYMS)
+        predefined_acronyms = self.config_manager.config.get('predefined_acronyms', self.PREDEFINED_ACRONYMS)
 
         # Tracking structures
         defined_acronyms = {}  # Stores definition info
@@ -936,6 +946,7 @@ class FAADocumentChecker(DocumentChecker):
 
         # Patterns
         defined_pattern = re.compile(r'\b([\w\s&]+?)\s*\((\b[A-Z]{2,}\b)\)')
+        # Modified acronym pattern
         acronym_pattern = re.compile(r'(?<!\()\b[A-Z]{2,}\b(?!\s*[:.]\s*)')
 
         for paragraph in doc:
@@ -975,37 +986,69 @@ class FAADocumentChecker(DocumentChecker):
 
                 if acronym not in defined_acronyms:
                     # Undefined acronym used
-                    issues.append({
-                        'type': 'undefined_acronym',
-                        'acronym': acronym,
-                        'sentence': paragraph.strip()
-                    })
+                    issues.append(acronym)  # Add only the acronym, not the sentence
                 else:
                     # Mark as used
                     defined_acronyms[acronym]['used'] = True
                     used_acronyms.add(acronym)
 
-        # Check for defined but unused acronyms
+        # Define success based on whether there are any undefined acronyms
+        success = len(issues) == 0
+
+        # Return the result with only undefined acronyms
+        return DocumentCheckResult(success=success, issues=list(set(issues)))
+
+    @profile_performance
+    def acronym_usage_check(self, doc: List[str]) -> DocumentCheckResult:
+        if not self.validate_input(doc):
+            return DocumentCheckResult(success=False, issues=[{'error': 'Invalid document input'}])
+
+        # Pattern to find acronym definitions (e.g., "Environmental Protection Agency (EPA)")
+        defined_pattern = re.compile(r'\b([\w\s&]+?)\s*\((\b[A-Z]{2,}\b)\)')
+
+        # Pattern to find acronym usage (e.g., "FAA", "EPA")
+        acronym_pattern = re.compile(r'\b[A-Z]{2,}\b')
+
+        # Tracking structures
+        defined_acronyms = {}
+        used_acronyms = set()
+
+        # Step 1: Extract all defined acronyms
+        for paragraph in doc:
+            defined_matches = defined_pattern.findall(paragraph)
+            for full_term, acronym in defined_matches:
+                if acronym not in defined_acronyms:
+                    defined_acronyms[acronym] = {
+                        'full_term': full_term.strip(),
+                        'defined_at': paragraph.strip()
+                    }
+
+        # Step 2: Check for acronym usage, excluding definitions
+        for paragraph in doc:
+            # Remove definitions from paragraph for usage checks
+            paragraph_excluding_definitions = re.sub(defined_pattern, '', paragraph)
+
+            usage_matches = acronym_pattern.findall(paragraph_excluding_definitions)
+            for acronym in usage_matches:
+                if acronym in defined_acronyms:
+                    used_acronyms.add(acronym)
+
+        # Step 3: Identify unused acronyms
         unused_acronyms = [
             {
-                'type': 'unused_acronym',
                 'acronym': acronym,
                 'full_term': data['full_term'],
                 'defined_at': data['defined_at']
             }
             for acronym, data in defined_acronyms.items()
-            if not data['used']
+            if acronym not in used_acronyms
         ]
 
-        # Combine issues
-        if unused_acronyms:
-            issues.extend(unused_acronyms)
-
-        success = len(issues) == 0
-
-        return DocumentCheckResult(success=success, issues=issues)
-
+        # Success is true if no unused acronyms are found
+        success = len(unused_acronyms) == 0
 
+        return DocumentCheckResult(success=success, issues=unused_acronyms)
+    
     @profile_performance
     def check_terminology(self, doc: List[str]) -> DocumentCheckResult:
         """
@@ -1706,6 +1749,7 @@ class FAADocumentChecker(DocumentChecker):
             ('heading_title_check', lambda: self.heading_title_check(doc, doc_type)),
             ('heading_title_period_check', lambda: self.heading_title_period_check(doc, doc_type)),
             ('acronym_check', lambda: self.acronym_check(doc)),
+            ('acronym_usage_check', lambda: self.acronym_usage_check(doc)),
             ('terminology_check', lambda: self.check_terminology(doc)),
             ('section_symbol_usage_check', lambda: self.check_section_symbol_usage(doc)),
             ('caption_check_table', lambda: self.caption_check(doc, doc_type, 'Table')),
@@ -1777,6 +1821,15 @@ class DocumentCheckResultsFormatter:
                     'after': 'This order establishes general Federal Aviation Administration (FAA) organizational policies.'
                 }
             },
+            'acronym_usage_check': {
+                'title': 'Unused Acronym Definitions',
+                'description': 'Ensures all acronyms defined in the document are subsequently used. If a term is defined but not used, it should not be defined.',
+                'solution': 'Remove definitions for acronyms that are not used later in the document.',
+                'example_fix': {
+                    'before': 'Airworthiness Directive (AD) requirements are critical.',
+                    'after': 'Remove "Airworthiness Directive (AD)" if "AD" is not used elsewhere.'
+                }
+            },
             'terminology_check': {
                 'title': 'Incorrect Terminology',
                 'description': 'Evaluates document text against the various style manuals and orders to identify non-compliant terminology, ambiguous references, and outdated phrases. This includes checking for prohibited relative references (like "above" or "below"), proper legal terminology (like "must" instead of "shall"), and consistent formatting of regulatory citations. The check ensures precise, unambiguous communication that meets current FAA documentation requirements.',
@@ -1909,6 +1962,23 @@ class DocumentCheckResultsFormatter:
         
         return output
 
+    def _format_unused_acronym_issues(self, result: DocumentCheckResult) -> List[str]:
+        """
+        Format issues for unused acronyms to display only the acronym.
+        
+        Args:
+            result: The DocumentCheckResult object containing issues.
+
+        Returns:
+            List[str]: Formatted lines displaying unused acronyms.
+        """
+        output = []
+        for issue in result.issues:
+            if isinstance(issue, dict):
+                acronym = issue.get('acronym', 'Unknown Acronym')
+                output.append(f"    • Acronym '{acronym}' was defined but never used.")
+        return output
+    
     def _format_caption_issues(self, result: DocumentCheckResult) -> List[str]:
         """Format caption issues consistently."""
         output = []
@@ -2087,7 +2157,7 @@ class DocumentCheckResultsFormatter:
                 "italics": True, 
                 "quotes": False,
                 "description": "For Advisory Circulars, referenced document titles should be italicized but not quoted",
-                "example": "See AC 25.1309-1B, *System Design and Analysis*, for information on X."
+                "example": "See AC 25.1309-1B, <i>System Design and Analysis</i>, for information on X."
             },
             "quotes_only": {
                 "types": [
@@ -2137,6 +2207,18 @@ class DocumentCheckResultsFormatter:
         
         output = []
         
+        self.issue_categories['acronym_usage_check'] = {
+            'title': 'Unused Acronym Definitions',
+            'description': 'Ensures all acronyms defined in the document are subsequently used.',
+            'solution': 'Remove definitions for acronyms that are not used later in the document.',
+            'example_fix': {
+                'before': 'Airworthiness Directive (AD) requirements are critical.',
+                'after': 'Remove "Airworthiness Directive (AD)" if "AD" is not used elsewhere.'
+            }
+        }
+
+        output = []
+        
         # Header
         output.append(f"\n{Fore.CYAN}{'='*80}")
         output.append(f"Document Check Results Summary")
@@ -2179,6 +2261,8 @@ class DocumentCheckResultsFormatter:
                     output.extend(self._format_reference_issues(result))
                 elif check_name in ['caption_check_table', 'caption_check_figure']:
                     output.extend(self._format_caption_issues(result))
+                elif check_name == 'acronym_usage_check':
+                    output.extend(self._format_unused_acronym_issues(result))
                 else:
                     # Standard issue formatting
                     formatted_issues = [self._format_standard_issue(issue) for issue in result.issues[:7]]