Update old.py

old.py

@@ -1,577 +1,577 @@
-import streamlit as st
-import os
-import json
-import re
-from pathlib import Path
-from datetime import datetime
-from typing import Dict, List, Any, Optional
-import fitz  # PyMuPDF
-from docx import Document
-from docx.shared import Inches
-import tempfile
-from groq import Groq
+# import streamlit as st
+# import os
+# import json
+# import re
+# from pathlib import Path
+# from datetime import datetime
+# from typing import Dict, List, Any, Optional
+# import fitz  # PyMuPDF
+# from docx import Document
+# from docx.shared import Inches
+# import tempfile
+# from groq import Groq
 
-# Configure Streamlit page
-st.set_page_config(
-    page_title="GLR Pipeline Automation",
-    page_icon="📋",
-    layout="wide",
-    initial_sidebar_state="expanded"
-)
+# # Configure Streamlit page
+# st.set_page_config(
+#     page_title="GLR Pipeline Automation",
+#     page_icon="📋",
+#     layout="wide",
+#     initial_sidebar_state="expanded"
+# )
 
-class GLRProcessor:
-    """Main class for processing GLR documents using Groq API"""
+# class GLRProcessor:
+#     """Main class for processing GLR documents using Groq API"""
     
-    def __init__(self):
-        self.output_dir = Path("output")
-        self.output_dir.mkdir(exist_ok=True)
-        # Get API key from Hugging Face secrets
-        self.api_key = os.getenv("Key")  # Get from HF secrets named "Key"
-        self.groq_client = None
-        self.initialize_groq()
+#     def __init__(self):
+#         self.output_dir = Path("output")
+#         self.output_dir.mkdir(exist_ok=True)
+#         # Get API key from Hugging Face secrets
+#         self.api_key = os.getenv("Key")  # Get from HF secrets named "Key"
+#         self.groq_client = None
+#         self.initialize_groq()
     
-    def initialize_groq(self):
-        """Initialize Groq client with API key from HF secrets"""
-        try:
-            if not self.api_key:
-                st.error("❌ API key not found in Hugging Face secrets. Please set the 'Key' secret in your Space settings.")
-                return
+#     def initialize_groq(self):
+#         """Initialize Groq client with API key from HF secrets"""
+#         try:
+#             if not self.api_key:
+#                 st.error("❌ API key not found in Hugging Face secrets. Please set the 'Key' secret in your Space settings.")
+#                 return
             
-            self.groq_client = Groq(api_key=self.api_key)
-            st.success("✅ Groq API initialized successfully!")
+#             self.groq_client = Groq(api_key=self.api_key)
+#             st.success("✅ Groq API initialized successfully!")
             
-        except Exception as e:
-            st.error(f"Failed to initialize Groq: {str(e)}")
-            self.groq_client = None
+#         except Exception as e:
+#             st.error(f"Failed to initialize Groq: {str(e)}")
+#             self.groq_client = None
     
-    def extract_text_from_pdf(self, pdf_file) -> str:
-        """Extract text from uploaded PDF file"""
-        try:
-            with tempfile.NamedTemporaryFile(delete=False, suffix='.pdf') as tmp_file:
-                tmp_file.write(pdf_file.read())
-                tmp_file_path = tmp_file.name
+#     def extract_text_from_pdf(self, pdf_file) -> str:
+#         """Extract text from uploaded PDF file"""
+#         try:
+#             with tempfile.NamedTemporaryFile(delete=False, suffix='.pdf') as tmp_file:
+#                 tmp_file.write(pdf_file.read())
+#                 tmp_file_path = tmp_file.name
             
-            doc = fitz.open(tmp_file_path)
-            text = ""
-            for page in doc:
-                text += page.get_text()
-            doc.close()
+#             doc = fitz.open(tmp_file_path)
+#             text = ""
+#             for page in doc:
+#                 text += page.get_text()
+#             doc.close()
             
-            os.unlink(tmp_file_path)
-            return text.strip()
-        except Exception as e:
-            st.error(f"Error extracting text from PDF: {str(e)}")
-            return ""
+#             os.unlink(tmp_file_path)
+#             return text.strip()
+#         except Exception as e:
+#             st.error(f"Error extracting text from PDF: {str(e)}")
+#             return ""
     
-    def extract_placeholders_from_docx(self, docx_file) -> List[str]:
-        """Extract placeholders from DOCX template"""
-        try:
-            with tempfile.NamedTemporaryFile(delete=False, suffix='.docx') as tmp_file:
-                tmp_file.write(docx_file.read())
-                tmp_file_path = tmp_file.name
+#     def extract_placeholders_from_docx(self, docx_file) -> List[str]:
+#         """Extract placeholders from DOCX template"""
+#         try:
+#             with tempfile.NamedTemporaryFile(delete=False, suffix='.docx') as tmp_file:
+#                 tmp_file.write(docx_file.read())
+#                 tmp_file_path = tmp_file.name
             
-            doc = Document(tmp_file_path)
-            placeholders = set()
+#             doc = Document(tmp_file_path)
+#             placeholders = set()
             
-            for paragraph in doc.paragraphs:
-                matches = re.findall(r'\[([A-Z_]+)\]', paragraph.text)
-                placeholders.update(matches)
+#             for paragraph in doc.paragraphs:
+#                 matches = re.findall(r'\[([A-Z_]+)\]', paragraph.text)
+#                 placeholders.update(matches)
             
-            for table in doc.tables:
-                for row in table.rows:
-                    for cell in row.cells:
-                        matches = re.findall(r'\[([A-Z_]+)\]', cell.text)
-                        placeholders.update(matches)
+#             for table in doc.tables:
+#                 for row in table.rows:
+#                     for cell in row.cells:
+#                         matches = re.findall(r'\[([A-Z_]+)\]', cell.text)
+#                         placeholders.update(matches)
             
-            os.unlink(tmp_file_path)
-            return list(placeholders)
-        except Exception as e:
-            st.error(f"Error extracting placeholders from DOCX: {str(e)}")
-            return []
+#             os.unlink(tmp_file_path)
+#             return list(placeholders)
+#         except Exception as e:
+#             st.error(f"Error extracting placeholders from DOCX: {str(e)}")
+#             return []
     
-    def extract_data_with_groq(self, pdf_texts: List[str], placeholders: List[str]) -> Dict[str, str]:
-        """Use Groq API to extract data from PDF texts with enhanced prompting"""
-        if self.groq_client is None:
-            st.warning("⚠️ Groq API not available. Using enhanced fallback extraction...")
-            return self._enhanced_fallback_extraction("\n\n".join(pdf_texts), placeholders)
+#     def extract_data_with_groq(self, pdf_texts: List[str], placeholders: List[str]) -> Dict[str, str]:
+#         """Use Groq API to extract data from PDF texts with enhanced prompting"""
+#         if self.groq_client is None:
+#             st.warning("⚠️ Groq API not available. Using enhanced fallback extraction...")
+#             return self._enhanced_fallback_extraction("\n\n".join(pdf_texts), placeholders)
         
-        try:
-            combined_text = "\n\n".join(pdf_texts)
+#         try:
+#             combined_text = "\n\n".join(pdf_texts)
             
-            # Truncate if too long but keep more context
-            if len(combined_text) > 12000:
-                combined_text = combined_text[:12000] + "..."
+#             # Truncate if too long but keep more context
+#             if len(combined_text) > 12000:
+#                 combined_text = combined_text[:12000] + "..."
             
-            # Create more specific field descriptions
-            field_descriptions = {
-                "DATE_LOSS": "Date when the loss/damage occurred (format: MM/DD/YYYY)",
-                "DATE_RECEIVED": "Date when the claim was received (format: MM/DD/YYYY)", 
-                "DATE_INSPECTED": "Date when the property was inspected (format: MM/DD/YYYY)",
-                "INSURED_NAME": "Full name of the insured person/entity",
-                "STREET": "Street address of the property (number + street name + suffix like St, Ave, Rd)",
-                "H_STREET": "Home street address (number + street name + suffix)",
-                "INSURED_H_STREET": "Insured's home street address (number + street name + suffix like St, Ave, Rd)",
-                "CITY": "City name",
-                "H_CITY": "Home city name",
-                "INSURED_H_CITY": "Insured's home city name",
-                "STATE": "State abbreviation (2 letters like CA, NY, TX)",
-                "H_STATE": "Home state abbreviation",
-                "INSURED_H_STATE": "Insured's home state abbreviation",
-                "ZIP": "ZIP code (5 or 9 digits)",
-                "H_ZIP": "Home ZIP code",
-                "INSURED_H_ZIP": "Insured's home ZIP code",
-                "MORTGAGEE": "Mortgage company or lender name",
-                "MORTGAGE": "Mortgage information",
-                "MORTGAGE_CO": "Mortgage company name",
-                "TOL_CODE": "Type of Loss code (alphanumeric code like F1, W2, H3, or similar insurance peril codes)",
-                "CLAIM_NUMBER": "Insurance claim number",
-                "POLICY_NUMBER": "Insurance policy number",
-                "PHONE": "Phone number",
-                "EMAIL": "Email address"
-            }
+#             # Create more specific field descriptions
+#             field_descriptions = {
+#                 "DATE_LOSS": "Date when the loss/damage occurred (format: MM/DD/YYYY)",
+#                 "DATE_RECEIVED": "Date when the claim was received (format: MM/DD/YYYY)", 
+#                 "DATE_INSPECTED": "Date when the property was inspected (format: MM/DD/YYYY)",
+#                 "INSURED_NAME": "Full name of the insured person/entity",
+#                 "STREET": "Street address of the property (number + street name + suffix like St, Ave, Rd)",
+#                 "H_STREET": "Home street address (number + street name + suffix)",
+#                 "INSURED_H_STREET": "Insured's home street address (number + street name + suffix like St, Ave, Rd)",
+#                 "CITY": "City name",
+#                 "H_CITY": "Home city name",
+#                 "INSURED_H_CITY": "Insured's home city name",
+#                 "STATE": "State abbreviation (2 letters like CA, NY, TX)",
+#                 "H_STATE": "Home state abbreviation",
+#                 "INSURED_H_STATE": "Insured's home state abbreviation",
+#                 "ZIP": "ZIP code (5 or 9 digits)",
+#                 "H_ZIP": "Home ZIP code",
+#                 "INSURED_H_ZIP": "Insured's home ZIP code",
+#                 "MORTGAGEE": "Mortgage company or lender name",
+#                 "MORTGAGE": "Mortgage information",
+#                 "MORTGAGE_CO": "Mortgage company name",
+#                 "TOL_CODE": "Type of Loss code (alphanumeric code like F1, W2, H3, or similar insurance peril codes)",
+#                 "CLAIM_NUMBER": "Insurance claim number",
+#                 "POLICY_NUMBER": "Insurance policy number",
+#                 "PHONE": "Phone number",
+#                 "EMAIL": "Email address"
+#             }
             
-            # Build detailed extraction instructions
-            extraction_instructions = []
-            for field in placeholders:
-                description = field_descriptions.get(field, f"Extract the {field.lower().replace('_', ' ')}")
-                extraction_instructions.append(f"- {field}: {description}")
+#             # Build detailed extraction instructions
+#             extraction_instructions = []
+#             for field in placeholders:
+#                 description = field_descriptions.get(field, f"Extract the {field.lower().replace('_', ' ')}")
+#                 extraction_instructions.append(f"- {field}: {description}")
             
-            prompt = f"""You are an expert insurance document analyst. Extract the following specific information from this insurance report text. Be very thorough and look for variations in how the data might be presented.
+#             prompt = f"""You are an expert insurance document analyst. Extract the following specific information from this insurance report text. Be very thorough and look for variations in how the data might be presented.
 
-REQUIRED FIELDS TO EXTRACT:
-{chr(10).join(extraction_instructions)}
+# REQUIRED FIELDS TO EXTRACT:
+# {chr(10).join(extraction_instructions)}
 
-EXTRACTION GUIDELINES:
-1. Search the ENTIRE document text carefully for each field
-2. Look for variations like "Date of Loss", "Loss Date", "DOL" for DATE_LOSS
-3. For names, extract complete full names as they appear
-4. For addresses, look for complete street addresses with numbers
-5. For dates, convert to MM/DD/YYYY format if in different format
-6. For states, use 2-letter codes (California = CA, New York = NY, etc.)
-7. Look in headers, footers, tables, and body text
-8. If a field has multiple possible values, choose the most complete/relevant one
-9. Only use "N/A" if the information is absolutely not present anywhere in the document
+# EXTRACTION GUIDELINES:
+# 1. Search the ENTIRE document text carefully for each field
+# 2. Look for variations like "Date of Loss", "Loss Date", "DOL" for DATE_LOSS
+# 3. For names, extract complete full names as they appear
+# 4. For addresses, look for complete street addresses with numbers
+# 5. For dates, convert to MM/DD/YYYY format if in different format
+# 6. For states, use 2-letter codes (California = CA, New York = NY, etc.)
+# 7. Look in headers, footers, tables, and body text
+# 8. If a field has multiple possible values, choose the most complete/relevant one
+# 9. Only use "N/A" if the information is absolutely not present anywhere in the document
 
-DOCUMENT TEXT TO ANALYZE:
-{combined_text}
+# DOCUMENT TEXT TO ANALYZE:
+# {combined_text}
 
-Return ONLY a valid JSON object with the extracted data:
-{{
-  "FIELD_NAME": "extracted_value"
-}}
+# Return ONLY a valid JSON object with the extracted data:
+# {{
+#   "FIELD_NAME": "extracted_value"
+# }}
 
-JSON:"""
+# JSON:"""
 
-            # Make API call to Groq with better parameters
-            completion = self.groq_client.chat.completions.create(
-                model="deepseek-r1-distill-llama-70b",
-                messages=[
-                    {
-                        "role": "system",
-                        "content": "You are an expert at extracting structured data from insurance documents. Always return valid JSON and be thorough in your extraction."
-                    },
-                    {
-                        "role": "user",
-                        "content": prompt
-                    }
-                ],
-                temperature=0.0,  # More deterministic
-                max_tokens=3000,
-                top_p=0.9,
-                stream=False,
-                stop=None,
-            )
+#             # Make API call to Groq with better parameters
+#             completion = self.groq_client.chat.completions.create(
+#                 model="deepseek-r1-distill-llama-70b",
+#                 messages=[
+#                     {
+#                         "role": "system",
+#                         "content": "You are an expert at extracting structured data from insurance documents. Always return valid JSON and be thorough in your extraction."
+#                     },
+#                     {
+#                         "role": "user",
+#                         "content": prompt
+#                     }
+#                 ],
+#                 temperature=0.0,  # More deterministic
+#                 max_tokens=3000,
+#                 top_p=0.9,
+#                 stream=False,
+#                 stop=None,
+#             )
             
-            response = completion.choices[0].message.content
+#             response = completion.choices[0].message.content
             
-            # Better JSON parsing
-            json_text = response.strip()
+#             # Better JSON parsing
+#             json_text = response.strip()
             
-            # Remove markdown formatting
-            if json_text.startswith("```json"):
-                json_text = json_text[7:]
-            if json_text.startswith("```"):
-                json_text = json_text[3:]
-            if json_text.endswith("```"):
-                json_text = json_text[:-3]
-            json_text = json_text.strip()
+#             # Remove markdown formatting
+#             if json_text.startswith("```json"):
+#                 json_text = json_text[7:]
+#             if json_text.startswith("```"):
+#                 json_text = json_text[3:]
+#             if json_text.endswith("```"):
+#                 json_text = json_text[:-3]
+#             json_text = json_text.strip()
             
-            # Extract JSON object more carefully
-            json_match = re.search(r'\{.*\}', json_text, re.DOTALL)
-            if json_match:
-                json_text = json_match.group()
+#             # Extract JSON object more carefully
+#             json_match = re.search(r'\{.*\}', json_text, re.DOTALL)
+#             if json_match:
+#                 json_text = json_match.group()
             
-            try:
-                extracted_data = json.loads(json_text)
-            except json.JSONDecodeError:
-                # Try to fix common JSON issues
-                json_text = json_text.replace("'", '"')  # Replace single quotes
-                json_text = re.sub(r',\s*}', '}', json_text)  # Remove trailing commas
-                extracted_data = json.loads(json_text)
+#             try:
+#                 extracted_data = json.loads(json_text)
+#             except json.JSONDecodeError:
+#                 # Try to fix common JSON issues
+#                 json_text = json_text.replace("'", '"')  # Replace single quotes
+#                 json_text = re.sub(r',\s*}', '}', json_text)  # Remove trailing commas
+#                 extracted_data = json.loads(json_text)
             
-            # Ensure all placeholders are present and post-process
-            final_data = {}
-            for placeholder in placeholders:
-                if placeholder in extracted_data:
-                    value = str(extracted_data[placeholder]).strip()
-                    # Clean up the value
-                    if value and value.lower() not in ['n/a', 'null', 'none', '', 'not found']:
-                        final_data[placeholder] = value
-                    else:
-                        # Try fallback extraction for this specific field
-                        fallback_value = self._extract_single_field(combined_text, placeholder)
-                        final_data[placeholder] = fallback_value
-                else:
-                    # Try fallback extraction for missing field
-                    fallback_value = self._extract_single_field(combined_text, placeholder)
-                    final_data[placeholder] = fallback_value
+#             # Ensure all placeholders are present and post-process
+#             final_data = {}
+#             for placeholder in placeholders:
+#                 if placeholder in extracted_data:
+#                     value = str(extracted_data[placeholder]).strip()
+#                     # Clean up the value
+#                     if value and value.lower() not in ['n/a', 'null', 'none', '', 'not found']:
+#                         final_data[placeholder] = value
+#                     else:
+#                         # Try fallback extraction for this specific field
+#                         fallback_value = self._extract_single_field(combined_text, placeholder)
+#                         final_data[placeholder] = fallback_value
+#                 else:
+#                     # Try fallback extraction for missing field
+#                     fallback_value = self._extract_single_field(combined_text, placeholder)
+#                     final_data[placeholder] = fallback_value
             
-            st.success("✅ Groq AI extraction completed successfully!")
-            return final_data
+#             st.success("✅ Groq AI extraction completed successfully!")
+#             return final_data
             
-        except Exception as e:
-            st.warning(f"Groq API extraction failed: {str(e)}")
-            return self._enhanced_fallback_extraction(combined_text, placeholders)
+#         except Exception as e:
+#             st.warning(f"Groq API extraction failed: {str(e)}")
+#             return self._enhanced_fallback_extraction(combined_text, placeholders)
     
-    def _extract_single_field(self, text: str, field: str) -> str:
-        """Extract a single field using enhanced pattern matching"""
-        text_lower = text.lower()
-        text_upper = text.upper()
+#     def _extract_single_field(self, text: str, field: str) -> str:
+#         """Extract a single field using enhanced pattern matching"""
+#         text_lower = text.lower()
+#         text_upper = text.upper()
         
-        # Date patterns
-        if "DATE" in field:
-            date_patterns = [
-                r'(?:' + field.lower().replace('_', r'[\s_]*') + r')[\s:]*(\d{1,2}[/\-]\d{1,2}[/\-]\d{2,4})',
-                r'(?:loss|received|inspect[a-z]*|claim)[\s:]+((?:\d{1,2}[/\-]\d{1,2}[/\-]\d{2,4})|(?:[A-Za-z]+ \d{1,2}, \d{4}))',
-                r'\b(\d{1,2}[/\-]\d{1,2}[/\-]\d{2,4})\b',
-                r'\b([A-Za-z]+ \d{1,2}, \d{4})\b'
-            ]
-            for pattern in date_patterns:
-                match = re.search(pattern, text, re.IGNORECASE)
-                if match:
-                    return match.group(1)
+#         # Date patterns
+#         if "DATE" in field:
+#             date_patterns = [
+#                 r'(?:' + field.lower().replace('_', r'[\s_]*') + r')[\s:]*(\d{1,2}[/\-]\d{1,2}[/\-]\d{2,4})',
+#                 r'(?:loss|received|inspect[a-z]*|claim)[\s:]+((?:\d{1,2}[/\-]\d{1,2}[/\-]\d{2,4})|(?:[A-Za-z]+ \d{1,2}, \d{4}))',
+#                 r'\b(\d{1,2}[/\-]\d{1,2}[/\-]\d{2,4})\b',
+#                 r'\b([A-Za-z]+ \d{1,2}, \d{4})\b'
+#             ]
+#             for pattern in date_patterns:
+#                 match = re.search(pattern, text, re.IGNORECASE)
+#                 if match:
+#                     return match.group(1)
         
-        # Name patterns
-        elif "NAME" in field:
-            name_patterns = [
-                r'(?:insured|name|policyholder)[\s:]+([A-Z][a-z]+ [A-Z][a-z]+(?:\s+[A-Z][a-z]+)?)',
-                r'\b([A-Z][a-z]+ [A-Z][a-z]+)\b',
-                r'name[\s:]*([A-Z][A-Za-z\s]+?)(?:\n|address|phone|email)',
-            ]
-            for pattern in name_patterns:
-                matches = re.findall(pattern, text, re.IGNORECASE)
-                for match in matches:
-                    if len(match.split()) >= 2 and len(match) > 4:
-                        return match.strip()
+#         # Name patterns
+#         elif "NAME" in field:
+#             name_patterns = [
+#                 r'(?:insured|name|policyholder)[\s:]+([A-Z][a-z]+ [A-Z][a-z]+(?:\s+[A-Z][a-z]+)?)',
+#                 r'\b([A-Z][a-z]+ [A-Z][a-z]+)\b',
+#                 r'name[\s:]*([A-Z][A-Za-z\s]+?)(?:\n|address|phone|email)',
+#             ]
+#             for pattern in name_patterns:
+#                 matches = re.findall(pattern, text, re.IGNORECASE)
+#                 for match in matches:
+#                     if len(match.split()) >= 2 and len(match) > 4:
+#                         return match.strip()
         
-        # Enhanced Address patterns for STREET
-        elif "STREET" in field:
-            street_patterns = [
-                # Standard address patterns with numbers
-                r'\b(\d+\s+[A-Z][A-Za-z\s]+(?:ST|STREET|AVE|AVENUE|RD|ROAD|DR|DRIVE|LN|LANE|CT|COURT|BLVD|BOULEVARD|PL|PLACE|WAY|CIR|CIRCLE|PKWY|PARKWAY)\.?)\b',
-                # Address after keywords
-                r'(?:address|street|location|property)[\s:]+(\d+\s+[A-Za-z][A-Za-z\s]+)',
-                # Full address patterns
-                r'\b(\d{1,5}\s+[A-Za-z][A-Za-z\s]+ (?:Street|Avenue|Road|Drive|Lane|Court|Boulevard|Place|Way|Circle|Parkway))\b',
-                # Address in format: number + name + abbreviated suffix
-                r'\b(\d{1,5}\s+[A-Za-z][A-Za-z\s]+\s+(?:St|Ave|Rd|Dr|Ln|Ct|Blvd|Pl|Way|Cir|Pkwy)\.?)\b',
-                # Property address patterns
-                r'(?:property|insured|loss)[\s\w]*address[\s:]*(\d+\s+[A-Za-z][A-Za-z\s]+)',
-                # Address before city/state
-                r'(\d+\s+[A-Za-z][A-Za-z\s]+?)(?:,\s*[A-Z][a-z]+\s*,?\s*[A-Z]{2})',
-                # General number + street name pattern
-                r'\b(\d{1,5}\s+[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*(?:\s+(?:St|Ave|Rd|Dr|Ln|Ct|Blvd|Pl|Way|Street|Avenue|Road|Drive|Lane|Court|Boulevard|Place))?)\b'
-            ]
-            for pattern in street_patterns:
-                match = re.search(pattern, text, re.IGNORECASE)
-                if match:
-                    street = match.group(1).strip()
-                    # Validate it looks like a street address
-                    if re.match(r'\d+\s+[A-Za-z]', street) and len(street) > 5:
-                        return street
+#         # Enhanced Address patterns for STREET
+#         elif "STREET" in field:
+#             street_patterns = [
+#                 # Standard address patterns with numbers
+#                 r'\b(\d+\s+[A-Z][A-Za-z\s]+(?:ST|STREET|AVE|AVENUE|RD|ROAD|DR|DRIVE|LN|LANE|CT|COURT|BLVD|BOULEVARD|PL|PLACE|WAY|CIR|CIRCLE|PKWY|PARKWAY)\.?)\b',
+#                 # Address after keywords
+#                 r'(?:address|street|location|property)[\s:]+(\d+\s+[A-Za-z][A-Za-z\s]+)',
+#                 # Full address patterns
+#                 r'\b(\d{1,5}\s+[A-Za-z][A-Za-z\s]+ (?:Street|Avenue|Road|Drive|Lane|Court|Boulevard|Place|Way|Circle|Parkway))\b',
+#                 # Address in format: number + name + abbreviated suffix
+#                 r'\b(\d{1,5}\s+[A-Za-z][A-Za-z\s]+\s+(?:St|Ave|Rd|Dr|Ln|Ct|Blvd|Pl|Way|Cir|Pkwy)\.?)\b',
+#                 # Property address patterns
+#                 r'(?:property|insured|loss)[\s\w]*address[\s:]*(\d+\s+[A-Za-z][A-Za-z\s]+)',
+#                 # Address before city/state
+#                 r'(\d+\s+[A-Za-z][A-Za-z\s]+?)(?:,\s*[A-Z][a-z]+\s*,?\s*[A-Z]{2})',
+#                 # General number + street name pattern
+#                 r'\b(\d{1,5}\s+[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*(?:\s+(?:St|Ave|Rd|Dr|Ln|Ct|Blvd|Pl|Way|Street|Avenue|Road|Drive|Lane|Court|Boulevard|Place))?)\b'
+#             ]
+#             for pattern in street_patterns:
+#                 match = re.search(pattern, text, re.IGNORECASE)
+#                 if match:
+#                     street = match.group(1).strip()
+#                     # Validate it looks like a street address
+#                     if re.match(r'\d+\s+[A-Za-z]', street) and len(street) > 5:
+#                         return street
         
-        # City patterns
-        elif "CITY" in field:
-            city_patterns = [
-                r'(?:city)[\s:]+([A-Z][a-z\s]+?)(?:,|\s+[A-Z]{2}\s|\n)',
-                r',\s*([A-Z][a-z\s]+?)\s+[A-Z]{2}\s+\d{5}',
-                r'\b([A-Z][a-z]+(?: [A-Z][a-z]+)*),\s*[A-Z]{2}\b'
-            ]
-            for pattern in city_patterns:
-                match = re.search(pattern, text)
-                if match:
-                    city = match.group(1).strip()
-                    if len(city) > 2:
-                        return city
+#         # City patterns
+#         elif "CITY" in field:
+#             city_patterns = [
+#                 r'(?:city)[\s:]+([A-Z][a-z\s]+?)(?:,|\s+[A-Z]{2}\s|\n)',
+#                 r',\s*([A-Z][a-z\s]+?)\s+[A-Z]{2}\s+\d{5}',
+#                 r'\b([A-Z][a-z]+(?: [A-Z][a-z]+)*),\s*[A-Z]{2}\b'
+#             ]
+#             for pattern in city_patterns:
+#                 match = re.search(pattern, text)
+#                 if match:
+#                     city = match.group(1).strip()
+#                     if len(city) > 2:
+#                         return city
         
-        # State patterns
-        elif "STATE" in field:
-            state_patterns = [
-                r'\b([A-Z]{2})\s+\d{5}',
-                r'(?:state)[\s:]+([A-Z]{2})\b',
-                r',\s*[A-Za-z\s]+,?\s*([A-Z]{2})\s+\d{5}'
-            ]
-            for pattern in state_patterns:
-                match = re.search(pattern, text)
-                if match:
-                    return match.group(1)
+#         # State patterns
+#         elif "STATE" in field:
+#             state_patterns = [
+#                 r'\b([A-Z]{2})\s+\d{5}',
+#                 r'(?:state)[\s:]+([A-Z]{2})\b',
+#                 r',\s*[A-Za-z\s]+,?\s*([A-Z]{2})\s+\d{5}'
+#             ]
+#             for pattern in state_patterns:
+#                 match = re.search(pattern, text)
+#                 if match:
+#                     return match.group(1)
         
-        # ZIP patterns
-        elif "ZIP" in field:
-            zip_patterns = [
-                r'\b(\d{5}-\d{4})\b',
-                r'\b(\d{5})\b(?!\d)'
-            ]
-            for pattern in zip_patterns:
-                match = re.search(pattern, text)
-                if match:
-                    return match.group(1)
+#         # ZIP patterns
+#         elif "ZIP" in field:
+#             zip_patterns = [
+#                 r'\b(\d{5}-\d{4})\b',
+#                 r'\b(\d{5})\b(?!\d)'
+#             ]
+#             for pattern in zip_patterns:
+#                 match = re.search(pattern, text)
+#                 if match:
+#                     return match.group(1)
         
-        # Phone patterns
-        elif "PHONE" in field:
-            phone_patterns = [
-                r'\b(\d{3}[-.\s]?\d{3}[-.\s]?\d{4})\b',
-                r'\((\d{3})\)\s*(\d{3})[-.\s]?(\d{4})'
-            ]
-            for pattern in phone_patterns:
-                match = re.search(pattern, text)
-                if match:
-                    if len(match.groups()) == 1:
-                        return match.group(1)
-                    else:
-                        return f"({match.group(1)}) {match.group(2)}-{match.group(3)}"
+#         # Phone patterns
+#         elif "PHONE" in field:
+#             phone_patterns = [
+#                 r'\b(\d{3}[-.\s]?\d{3}[-.\s]?\d{4})\b',
+#                 r'\((\d{3})\)\s*(\d{3})[-.\s]?(\d{4})'
+#             ]
+#             for pattern in phone_patterns:
+#                 match = re.search(pattern, text)
+#                 if match:
+#                     if len(match.groups()) == 1:
+#                         return match.group(1)
+#                     else:
+#                         return f"({match.group(1)}) {match.group(2)}-{match.group(3)}"
         
-        # Email patterns
-        elif "EMAIL" in field:
-            email_pattern = r'\b([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})\b'
-            match = re.search(email_pattern, text)
-            if match:
-                return match.group(1)
+#         # Email patterns
+#         elif "EMAIL" in field:
+#             email_pattern = r'\b([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})\b'
+#             match = re.search(email_pattern, text)
+#             if match:
+#                 return match.group(1)
         
-        # Policy/Claim number patterns
-        elif "POLICY" in field or "CLAIM" in field:
-            number_patterns = [
-                r'(?:policy|claim)[\s#:]*([A-Z0-9\-]+)',
-                r'\b([A-Z]{2,4}\d{6,})\b',
-                r'\b(\d{8,})\b'
-            ]
-            for pattern in number_patterns:
-                match = re.search(pattern, text, re.IGNORECASE)
-                if match:
-                    return match.group(1)
+#         # Policy/Claim number patterns
+#         elif "POLICY" in field or "CLAIM" in field:
+#             number_patterns = [
+#                 r'(?:policy|claim)[\s#:]*([A-Z0-9\-]+)',
+#                 r'\b([A-Z]{2,4}\d{6,})\b',
+#                 r'\b(\d{8,})\b'
+#             ]
+#             for pattern in number_patterns:
+#                 match = re.search(pattern, text, re.IGNORECASE)
+#                 if match:
+#                     return match.group(1)
         
-        # Mortgage patterns
-        elif "MORTGAGE" in field:
-            mortgage_patterns = [
-                r'(?:mortgage[e]?|lender)[\s:]+([A-Z][A-Za-z\s&]+?)(?:\n|$|address)',
-                r'\b([A-Z][a-z]+ (?:Bank|Mortgage|Financial|Credit Union|Lending))\b'
-            ]
-            for pattern in mortgage_patterns:
-                match = re.search(pattern, text, re.IGNORECASE)
-                if match:
-                    return match.group(1).strip()
+#         # Mortgage patterns
+#         elif "MORTGAGE" in field:
+#             mortgage_patterns = [
+#                 r'(?:mortgage[e]?|lender)[\s:]+([A-Z][A-Za-z\s&]+?)(?:\n|$|address)',
+#                 r'\b([A-Z][a-z]+ (?:Bank|Mortgage|Financial|Credit Union|Lending))\b'
+#             ]
+#             for pattern in mortgage_patterns:
+#                 match = re.search(pattern, text, re.IGNORECASE)
+#                 if match:
+#                     return match.group(1).strip()
         
-        # Enhanced TOL Code patterns
-        elif "TOL" in field or "CODE" in field:
-            code_patterns = [
-                # Direct TOL/code patterns
-                r'(?:tol|type\s*of\s*loss)[\s:]*code[\s:]*([A-Z0-9\-]+)',
-                r'(?:tol|code)[\s:]*([A-Z0-9\-]+)',
-                r'(?:type\s*of\s*loss)[\s:]*([A-Z0-9\-]+)',
-                # Loss type codes
-                r'(?:loss\s*type|cause\s*of\s*loss)[\s:]*([A-Z0-9\-]+)',
-                # Peril codes
-                r'(?:peril|coverage)[\s:]*code[\s:]*([A-Z0-9\-]+)',
-                # General code patterns in insurance context
-                r'(?:claim|loss|damage)[\s\w]*code[\s:]*([A-Z0-9\-]+)',
-                # Alphanumeric codes (common format)
-                r'\b([A-Z]{1,3}\d{1,4})\b',
-                r'\b([A-Z]{2,4}-?\d{2,4})\b',
-                # Fire, water, wind codes
-                r'(?:fire|water|wind|storm|hail)[\s:]*([A-Z0-9\-]+)',
-                # Coverage codes
-                r'(?:coverage|section)[\s:]*([A-Z]\d*)',
-                # Standalone codes that might be TOL
-                r'\b([A-Z]\d{2,3})\b',
-                r'\b([A-Z]{2}\d{1,2})\b'
-            ]
-            for pattern in code_patterns:
-                matches = re.findall(pattern, text, re.IGNORECASE)
-                for match in matches:
-                    # Filter out common false positives
-                    if (len(match) >= 2 and 
-                        not match.lower() in ['tx', 'ca', 'ny', 'fl'] and  # state codes
-                        not match.isdigit() and  # pure numbers
-                        not re.match(r'^\d{5}$', match)):  # zip codes
-                        return match.upper()
+#         # Enhanced TOL Code patterns
+#         elif "TOL" in field or "CODE" in field:
+#             code_patterns = [
+#                 # Direct TOL/code patterns
+#                 r'(?:tol|type\s*of\s*loss)[\s:]*code[\s:]*([A-Z0-9\-]+)',
+#                 r'(?:tol|code)[\s:]*([A-Z0-9\-]+)',
+#                 r'(?:type\s*of\s*loss)[\s:]*([A-Z0-9\-]+)',
+#                 # Loss type codes
+#                 r'(?:loss\s*type|cause\s*of\s*loss)[\s:]*([A-Z0-9\-]+)',
+#                 # Peril codes
+#                 r'(?:peril|coverage)[\s:]*code[\s:]*([A-Z0-9\-]+)',
+#                 # General code patterns in insurance context
+#                 r'(?:claim|loss|damage)[\s\w]*code[\s:]*([A-Z0-9\-]+)',
+#                 # Alphanumeric codes (common format)
+#                 r'\b([A-Z]{1,3}\d{1,4})\b',
+#                 r'\b([A-Z]{2,4}-?\d{2,4})\b',
+#                 # Fire, water, wind codes
+#                 r'(?:fire|water|wind|storm|hail)[\s:]*([A-Z0-9\-]+)',
+#                 # Coverage codes
+#                 r'(?:coverage|section)[\s:]*([A-Z]\d*)',
+#                 # Standalone codes that might be TOL
+#                 r'\b([A-Z]\d{2,3})\b',
+#                 r'\b([A-Z]{2}\d{1,2})\b'
+#             ]
+#             for pattern in code_patterns:
+#                 matches = re.findall(pattern, text, re.IGNORECASE)
+#                 for match in matches:
+#                     # Filter out common false positives
+#                     if (len(match) >= 2 and 
+#                         not match.lower() in ['tx', 'ca', 'ny', 'fl'] and  # state codes
+#                         not match.isdigit() and  # pure numbers
+#                         not re.match(r'^\d{5}$', match)):  # zip codes
+#                         return match.upper()
         
-        return "N/A"
+#         return "N/A"
     
-    def _enhanced_fallback_extraction(self, text: str, placeholders: List[str]) -> Dict[str, str]:
-        """Enhanced fallback extraction with better pattern matching"""
-        st.info("🔍 Using enhanced pattern matching extraction...")
+#     def _enhanced_fallback_extraction(self, text: str, placeholders: List[str]) -> Dict[str, str]:
+#         """Enhanced fallback extraction with better pattern matching"""
+#         st.info("🔍 Using enhanced pattern matching extraction...")
         
-        fallback_data = {}
+#         fallback_data = {}
         
-        for placeholder in placeholders:
-            value = self._extract_single_field(text, placeholder)
-            fallback_data[placeholder] = value
+#         for placeholder in placeholders:
+#             value = self._extract_single_field(text, placeholder)
+#             fallback_data[placeholder] = value
         
-        return fallback_data
+#         return fallback_data
     
-    def populate_docx_template(self, docx_file, extracted_data: Dict[str, str]) -> str:
-        """Populate DOCX template with extracted data"""
-        try:
-            with tempfile.NamedTemporaryFile(delete=False, suffix='.docx') as tmp_file:
-                tmp_file.write(docx_file.read())
-                tmp_file_path = tmp_file.name
+#     def populate_docx_template(self, docx_file, extracted_data: Dict[str, str]) -> str:
+#         """Populate DOCX template with extracted data"""
+#         try:
+#             with tempfile.NamedTemporaryFile(delete=False, suffix='.docx') as tmp_file:
+#                 tmp_file.write(docx_file.read())
+#                 tmp_file_path = tmp_file.name
             
-            doc = Document(tmp_file_path)
+#             doc = Document(tmp_file_path)
             
-            # Track replacements made
-            replacements_made = 0
+#             # Track replacements made
+#             replacements_made = 0
             
-            for paragraph in doc.paragraphs:
-                for placeholder, value in extracted_data.items():
-                    if f"[{placeholder}]" in paragraph.text:
-                        paragraph.text = paragraph.text.replace(f"[{placeholder}]", str(value))
-                        replacements_made += 1
+#             for paragraph in doc.paragraphs:
+#                 for placeholder, value in extracted_data.items():
+#                     if f"[{placeholder}]" in paragraph.text:
+#                         paragraph.text = paragraph.text.replace(f"[{placeholder}]", str(value))
+#                         replacements_made += 1
             
-            for table in doc.tables:
-                for row in table.rows:
-                    for cell in row.cells:
-                        for paragraph in cell.paragraphs:
-                            for placeholder, value in extracted_data.items():
-                                if f"[{placeholder}]" in paragraph.text:
-                                    paragraph.text = paragraph.text.replace(f"[{placeholder}]", str(value))
-                                    replacements_made += 1
+#             for table in doc.tables:
+#                 for row in table.rows:
+#                     for cell in row.cells:
+#                         for paragraph in cell.paragraphs:
+#                             for placeholder, value in extracted_data.items():
+#                                 if f"[{placeholder}]" in paragraph.text:
+#                                     paragraph.text = paragraph.text.replace(f"[{placeholder}]", str(value))
+#                                     replacements_made += 1
             
-            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-            output_filename = f"GLR_Report_{timestamp}.docx"
-            output_path = self.output_dir / output_filename
+#             timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+#             output_filename = f"GLR_Report_{timestamp}.docx"
+#             output_path = self.output_dir / output_filename
             
-            doc.save(str(output_path))
-            os.unlink(tmp_file_path)
+#             doc.save(str(output_path))
+#             os.unlink(tmp_file_path)
             
-            st.info(f"Made {replacements_made} field replacements in the template")
-            return str(output_path)
+#             st.info(f"Made {replacements_made} field replacements in the template")
+#             return str(output_path)
             
-        except Exception as e:
-            st.error(f"Error populating template: {str(e)}")
-            return None
+#         except Exception as e:
+#             st.error(f"Error populating template: {str(e)}")
+#             return None
 
-def main():
-    """Main Streamlit application"""
-    st.title("📋 GLR Pipeline Automation (Enhanced)")
-    st.markdown("**Automate General Loss Report generation with improved data extraction**")
+# def main():
+#     """Main Streamlit application"""
+#     st.title("📋 GLR Pipeline Automation (Enhanced)")
+#     st.markdown("**Automate General Loss Report generation with improved data extraction**")
     
-    # Initialize processor
-    processor = GLRProcessor()
+#     # Initialize processor
+#     processor = GLRProcessor()
     
-    col1, col2 = st.columns([1, 1])
+#     col1, col2 = st.columns([1, 1])
     
-    with col1:
-        st.header("📄 Upload Template")
-        template_file = st.file_uploader("Upload GLR Template (.docx)", type=['docx'])
+#     with col1:
+#         st.header("📄 Upload Template")
+#         template_file = st.file_uploader("Upload GLR Template (.docx)", type=['docx'])
     
-    with col2:
-        st.header("📋 Upload Reports")
-        photo_reports = st.file_uploader("Upload PDF Reports", type=['pdf'], accept_multiple_files=True)
+#     with col2:
+#         st.header("📋 Upload Reports")
+#         photo_reports = st.file_uploader("Upload PDF Reports", type=['pdf'], accept_multiple_files=True)
     
-    if template_file and photo_reports:
-        st.header("🔄 Processing")
+#     if template_file and photo_reports:
+#         st.header("🔄 Processing")
         
-        with st.spinner("Processing..."):
-            placeholders = processor.extract_placeholders_from_docx(template_file)
+#         with st.spinner("Processing..."):
+#             placeholders = processor.extract_placeholders_from_docx(template_file)
             
-            if placeholders:
-                st.success(f"Found {len(placeholders)} placeholders: {', '.join(placeholders)}")
+#             if placeholders:
+#                 st.success(f"Found {len(placeholders)} placeholders: {', '.join(placeholders)}")
                 
-                pdf_texts = []
-                for pdf_file in photo_reports:
-                    text = processor.extract_text_from_pdf(pdf_file)
-                    if text:
-                        pdf_texts.append(text)
-                        st.success(f"✅ Processed {pdf_file.name} ({len(text)} characters)")
+#                 pdf_texts = []
+#                 for pdf_file in photo_reports:
+#                     text = processor.extract_text_from_pdf(pdf_file)
+#                     if text:
+#                         pdf_texts.append(text)
+#                         st.success(f"✅ Processed {pdf_file.name} ({len(text)} characters)")
                 
-                if pdf_texts:
-                    extracted_data = processor.extract_data_with_groq(pdf_texts, placeholders)
+#                 if pdf_texts:
+#                     extracted_data = processor.extract_data_with_groq(pdf_texts, placeholders)
                     
-                    st.subheader("📊 Extracted Data")
+#                     st.subheader("📊 Extracted Data")
                     
-                    # Show extraction statistics
-                    non_na_count = sum(1 for v in extracted_data.values() if v != "N/A")
-                    extraction_rate = (non_na_count / len(extracted_data)) * 100
-                    st.metric("Extraction Success Rate", f"{extraction_rate:.1f}%", f"{non_na_count}/{len(extracted_data)} fields")
+#                     # Show extraction statistics
+#                     non_na_count = sum(1 for v in extracted_data.values() if v != "N/A")
+#                     extraction_rate = (non_na_count / len(extracted_data)) * 100
+#                     st.metric("Extraction Success Rate", f"{extraction_rate:.1f}%", f"{non_na_count}/{len(extracted_data)} fields")
                     
-                    # Create form for editing data
-                    with st.form("data_form"):
-                        edited_data = {}
-                        for placeholder, value in extracted_data.items():
-                            # Color code based on whether value was found
-                            if value != "N/A":
-                                st.markdown(f"**{placeholder}** ✅")
-                            else:
-                                st.markdown(f"**{placeholder}** ❌")
-                            edited_data[placeholder] = st.text_input(f"", value=value, key=placeholder)
+#                     # Create form for editing data
+#                     with st.form("data_form"):
+#                         edited_data = {}
+#                         for placeholder, value in extracted_data.items():
+#                             # Color code based on whether value was found
+#                             if value != "N/A":
+#                                 st.markdown(f"**{placeholder}** ✅")
+#                             else:
+#                                 st.markdown(f"**{placeholder}** ❌")
+#                             edited_data[placeholder] = st.text_input(f"", value=value, key=placeholder)
                         
-                        generate_report = st.form_submit_button("Generate Report", type="primary")
+#                         generate_report = st.form_submit_button("Generate Report", type="primary")
                     
-                    # Handle report generation outside the form
-                    if generate_report:
-                        template_file.seek(0)
-                        output_path = processor.populate_docx_template(template_file, edited_data)
+#                     # Handle report generation outside the form
+#                     if generate_report:
+#                         template_file.seek(0)
+#                         output_path = processor.populate_docx_template(template_file, edited_data)
                         
-                        if output_path:
-                            st.success("✅ Report generated successfully!")
+#                         if output_path:
+#                             st.success("✅ Report generated successfully!")
                             
-                            # Store the file data in session state for download
-                            with open(output_path, 'rb') as file:
-                                st.session_state['report_data'] = file.read()
-                                st.session_state['report_filename'] = os.path.basename(output_path)
+#                             # Store the file data in session state for download
+#                             with open(output_path, 'rb') as file:
+#                                 st.session_state['report_data'] = file.read()
+#                                 st.session_state['report_filename'] = os.path.basename(output_path)
                     
-                    # Download button outside the form
-                    if 'report_data' in st.session_state:
-                        st.download_button(
-                            label="📥 Download Generated Report",
-                            data=st.session_state['report_data'],
-                            file_name=st.session_state['report_filename'],
-                            mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-                            type="primary"
-                        )
-                else:
-                    st.error("No text extracted from PDFs")
-            else:
-                st.error("No placeholders found in template")
+#                     # Download button outside the form
+#                     if 'report_data' in st.session_state:
+#                         st.download_button(
+#                             label="📥 Download Generated Report",
+#                             data=st.session_state['report_data'],
+#                             file_name=st.session_state['report_filename'],
+#                             mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+#                             type="primary"
+#                         )
+#                 else:
+#                     st.error("No text extracted from PDFs")
+#             else:
+#                 st.error("No placeholders found in template")
     
-    # Instructions and setup for Hugging Face Spaces
-    st.header("📖 Hugging Face Spaces Setup")
-    st.markdown("""
-    **This app is configured for Hugging Face Spaces deployment:**
+#     # Instructions and setup for Hugging Face Spaces
+#     st.header("📖 Hugging Face Spaces Setup")
+#     st.markdown("""
+#     **This app is configured for Hugging Face Spaces deployment:**
     
-    **Step 1: Set up your Space**
-    - Create a new Space on Hugging Face with Streamlit SDK
-    - Upload the app files (app.py, requirements.txt, packages.txt)
+#     **Step 1: Set up your Space**
+#     - Create a new Space on Hugging Face with Streamlit SDK
+#     - Upload the app files (app.py, requirements.txt, packages.txt)
     
-    **Step 2: Configure API Key**
-    - Go to your Space Settings → Repository secrets
-    - Add a new secret named `Key` with your Groq API key value
-    - Get your free API key from [console.groq.com](https://console.groq.com/)
+#     **Step 2: Configure API Key**
+#     - Go to your Space Settings → Repository secrets
+#     - Add a new secret named `Key` with your Groq API key value
+#     - Get your free API key from [console.groq.com](https://console.groq.com/)
     
-    **Step 3: Use the App**
-    1. Upload a DOCX template with placeholders like `[DATE_LOSS]`, `[INSURED_NAME]`
-    2. Upload PDF reports containing the data to extract
-    3. Review and edit the AI-extracted data
-    4. Generate and download the completed report
-    """)
+#     **Step 3: Use the App**
+#     1. Upload a DOCX template with placeholders like `[DATE_LOSS]`, `[INSURED_NAME]`
+#     2. Upload PDF reports containing the data to extract
+#     3. Review and edit the AI-extracted data
+#     4. Generate and download the completed report
+#     """)
     
-    # Show API key status
-    if not processor.api_key:
-        st.error("⚠️ **API Key Not Found** - Please set the 'Key' secret in your Hugging Face Space settings.")
-    elif processor.groq_client:
-        st.success("✅ **API Key Configured** - Ready to process documents!")
-    else:
-        st.error("❌ **API Key Error** - Please check your API key configuration in Space secrets")
+#     # Show API key status
+#     if not processor.api_key:
+#         st.error("⚠️ **API Key Not Found** - Please set the 'Key' secret in your Hugging Face Space settings.")
+#     elif processor.groq_client:
+#         st.success("✅ **API Key Configured** - Ready to process documents!")
+#     else:
+#         st.error("❌ **API Key Error** - Please check your API key configuration in Space secrets")
 
-if __name__ == "__main__":
-    main()
+# if __name__ == "__main__":
+#     main()