Update app.py

Reverted the UI

app.py

@@ -17,25 +17,25 @@ from PyPDF2 import PdfReader  # plain text extraction
 import gradio as gr  # UI
 from dotenv import load_dotenv  # optional .env support
 
-
 # ─────────────────────────────────────────────────────────────────────────────
-# 1. PDF & TEXT PROCESSING
+# 1. PDF & TEXT PROCESSING  (LOGIC MODIFIED HERE)
 # ─────────────────────────────────────────────────────────────────────────────
 
 def extract_pdf_text(pdf_file) -> str:
     """Extracts text from a PDF file using PyPDF2."""
     reader = PdfReader(pdf_file)
-    return "\n".join(p.extract_text() or "" for p in reader.pages)
+    # MODIFICATION: Skips the first 4 pages (ToC/List of Rules)
+    return "\n".join(p.extract_text() or "" for i, p in enumerate(reader.pages) if i >= 4)
 
 
 def extract_pdf_word(pdf_file) -> str:
     """Extracts text from PDF using PyMuPDF (fitz) for better layout preservation."""
     doc = fitz.open(pdf_file)
-    text_blocks = [page.get_text("text") for page in doc]
+    # MODIFICATION: Skips the first 4 pages (ToC)
+    text_blocks = [page.get_text("text") for i, page in enumerate(doc) if i >= 4]
     return "\n".join(filter(None, text_blocks))
 
 
-# MODIFIED FUNCTION: Improved logic for re-joining wrapped lines
 def merge_pdf_wrapped_lines(raw_text: str) -> list[str]:
     """Re-join hard-wrapped lines from PDF extraction based on grammatical context."""
     merged = []
@@ -46,8 +46,8 @@ def merge_pdf_wrapped_lines(raw_text: str) -> list[str]:
         
         if merged:
             prev = merged[-1]
-            # YOUR INSIGHT: Merge if previous line ends with '—' or lacks closing punctuation,
-            # and the next line appears to be a continuation (starts with lowercase or parenthesis).
+            # Merge if previous line ends with '—' or lacks closing punctuation,
+            # and the next line appears to be a continuation.
             if prev.endswith('—') or \
                (not re.search(r'[.:;)]\s*$', prev) and re.match(r'^[a-z\(]', ln_stripped)):
                 merged[-1] = prev + ' ' + ln_stripped
@@ -57,7 +57,7 @@ def merge_pdf_wrapped_lines(raw_text: str) -> list[str]:
 
 
 # ─────────────────────────────────────────────────────────────────────────────
-# 2. RULE PARSING & CLEANING (Initial Automated Pass)
+# 2. RULE PARSING & CLEANING (LOGIC MODIFIED HERE)
 # ─────────────────────────────────────────────────────────────────────────────
 
 # --- Regex for rule structure ---
@@ -104,15 +104,15 @@ def clean_line(line: str, source: str) -> str:
     line = re.sub(r'\s{2,}', ' ', line)
     return line.strip()
 
-# NEW HELPER: Determines nesting level of a sub-rule, e.g., (1) is level 1, (a) is 2, (i) is 3
 def get_rule_level(paren_str):
+    """Determines nesting level of a sub-rule, e.g., (1) is 1, (a) is 2, (i) is 3."""
     content = paren_str.strip('()').lower()
+    if not content: return 99
     if content.isdigit(): return 1
-    if all(c in 'ivxl' for c in content): return 3 # roman numerals
+    if all(c in 'ivxlmc' for c in content): return 3 # roman numerals
     if content.isalpha(): return 2 # alphabetical
     return 4 # Unknown level, treat as deeply nested
 
-# REWRITTEN FUNCTION: Stateful, hierarchical parser to correctly handle sub-rules.
 def parse_rules(text: str, source: str) -> dict[str, str]:
     """
     Parses raw text into a dictionary of {rule_id: rule_text}.
@@ -126,7 +126,6 @@ def parse_rules(text: str, source: str) -> dict[str, str]:
         """Saves the buffered lines to the current rule ID."""
         if parent_parts and lines_buffer:
             rule_id = "".join(parent_parts)
-            # Append to existing text if rule already has a title, otherwise create it
             existing_text = rules.get(rule_id, "")
             new_text = " ".join(lines_buffer)
             rules[rule_id] = (existing_text + " " + new_text).strip()
@@ -141,17 +140,16 @@ def parse_rules(text: str, source: str) -> dict[str, str]:
         m_main = rule_pat.match(cleaned)
         m_sub = sub_rule_pat.match(cleaned)
         m_sp = subpart_pat.match(cleaned)
-
+        
         if m_sp:
             commit_buffer()
             parent_parts = [f"subpart-{m_sp.group(1).upper()}"]
             rules["".join(parent_parts)] = f"Subpart {m_sp.group(1).upper()} — {m_sp.group(2).strip()}"
-
+        
         elif m_main:
             new_base_id = m_main.group('base_rule')
             current_base_id = parent_parts[0] if parent_parts and not parent_parts[0].startswith("subpart") else None
             
-            # YOUR INSIGHT: A rule never refers to itself. If it's the same base ID, it's content.
             if new_base_id == current_base_id:
                 lines_buffer.append(cleaned)
                 continue
@@ -161,14 +159,13 @@ def parse_rules(text: str, source: str) -> dict[str, str]:
             title = m_main.group('title').strip()
             if title:
                 rules["".join(parent_parts)] = title
-
-        elif m_sub and parent_parts:
+        
+        elif m_sub and parent_parts and not parent_parts[0].startswith("subpart"):
             commit_buffer()
             paren_part = m_sub.group(1)
             text_part = m_sub.group(2).strip()
             new_level = get_rule_level(paren_part)
 
-            # Adjust hierarchy: pop parent parts until we are at the correct level
             while len(parent_parts) > 1:
                 last_part = parent_parts[-1]
                 last_level = get_rule_level(last_part)
@@ -181,7 +178,7 @@ def parse_rules(text: str, source: str) -> dict[str, str]:
             if text_part:
                 lines_buffer.append(text_part)
 
-        else: # It's continuation text
+        else:
             lines_buffer.append(cleaned)
     
     commit_buffer()
@@ -189,7 +186,7 @@ def parse_rules(text: str, source: str) -> dict[str, str]:
 
 
 # ─────────────────────────────────────────────────────────────────────────────
-# 3. COMPARISON & UI LOGIC
+# 3. COMPARISON & UI LOGIC (LOGIC MODIFIED HERE)
 # ─────────────────────────────────────────────────────────────────────────────
 
 def diff_unified(one: str, caa: str) -> str:
@@ -226,14 +223,16 @@ def combined_sort_key(key: str):
     else:
         return (4, key)
 
-    parts = re.split(r'([()])', key) # Split but keep delimiters
+    # MODIFICATION: More robust splitting for hierarchical keys like "108.51(3)(i)"
+    parts = re.split(r'(\d+\.\d+)|(\([a-zA-Z0-9]+\))', key)
     parts = [p for p in parts if p]
 
     for part in parts:
-        if part.isdigit():
-            sortable_tuple += ((1, int(part)),)
+        num_match = re.match(r'^\d+\.\d+$', part)
+        if num_match:
+             sortable_tuple += tuple( (1, int(x)) for x in part.split('.'))
         else:
-            sortable_tuple += ((2, part.lower()),)
+             sortable_tuple += ((2, part.lower()),)
     return sortable_tuple
 
 
@@ -264,24 +263,16 @@ def save_clean_and_dirty_versions(dirty_one, dirty_caa, clean_one, clean_caa, fi
     return filename
 
 
-# --- STAGE 1: Process PDFs and prepare for user review ---
-# MODIFIED FUNCTION: Skips ToC pages before parsing.
 def stage1_process_and_review(part, onereg_pdf, caa_pdf):
     if not (onereg_pdf and caa_pdf):
         raise gr.Error("Please upload both PDF files.")
     try:
-        # --- Process OneReg PDF (skipping ToC) ---
-        onereg_doc = fitz.open(onereg_pdf.name)
-        # OneReg ToC for Part 108 is pages 2-4 (index 1-3). Content starts on page 5 (index 4).
-        onereg_text_blocks = [page.get_text("text") for i, page in enumerate(onereg_doc) if i >= 4]
-        raw_one = "\n".join(filter(None, onereg_text_blocks))
+        # Process OneReg PDF
+        raw_one = extract_pdf_word(onereg_pdf.name)
         one_data = parse_rules(raw_one, "onereg")
 
-        # --- Process CAA PDF (skipping ToC) ---
-        caa_doc = PdfReader(caa_pdf.name)
-        # CAA 'List of Rules' for Part 108 is page 4 (index 3). Content starts on page 5 (index 4).
-        caa_text_blocks = [p.extract_text() or "" for i, p in enumerate(caa_doc.pages) if i >= 4]
-        raw_caa = "\n".join(caa_text_blocks)
+        # Process CAA PDF
+        raw_caa = extract_pdf_text(caa_pdf.name)
         caa_data = parse_rules(raw_caa, "caa")
 
         # Get all rule IDs and sort them
@@ -290,7 +281,6 @@ def stage1_process_and_review(part, onereg_pdf, caa_pdf):
             key=combined_sort_key
         )
 
-        # Filter for the relevant part, but always include subparts and appendices
         rules_to_review = [
             r for r in all_ids
             if r.startswith(f"{part}.") or r.startswith("subpart-") or re.match(r'^[A-Z]\.', r)
@@ -316,7 +306,6 @@ def stage1_process_and_review(part, onereg_pdf, caa_pdf):
         raise gr.Error(f"Failed during initial processing: {e}")
 
 
-# --- STAGE 2: Take user-cleaned text and perform the final comparison ---
 def stage2_finalize_and_compare(review_df, original_one, original_caa):
     if review_df is None or review_df.empty:
         raise gr.Error("No data to compare. Please process the files first.")
@@ -371,7 +360,7 @@ def stage2_finalize_and_compare(review_df, original_one, original_caa):
 
 
 # ───────────────────────────────────────���─────────────────────────────────────
-# 4. GRADIO UI LAYOUT
+# 4. GRADIO UI LAYOUT (UI IS IDENTICAL TO YOUR ORIGINAL SCRIPT)
 # ─────────────────────────────────────────────────────────────────────────────
 
 with gr.Blocks(theme=gr.themes.Soft(), title="Dual Rule Cleaning Tool") as demo:
@@ -383,7 +372,7 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Dual Rule Cleaning Tool") as demo:
 
     # --- Stage 1: Inputs and Initial Processing ---
     with gr.Row():
-        part_num = gr.Textbox(label="Part Number", value="108")
+        part_num = gr.Textbox(label="Part Number", value="139")
         onereg_pdf = gr.File(label="Upload OneReg PDF")
         caa_pdf = gr.File(label="Upload CAA PDF")