Spaces:
Sleeping
Sleeping
| # Document Helper Functions | |
| # Contains helper functions like filter_empty_sections(), extract_business_name_from_content(), etc. | |
| import re | |
| import os | |
| import sys | |
| from typing import List, Dict, Any | |
| # Add the parent directory to sys.path to import from models.py | |
| sys.path.append(os.path.dirname(os.path.dirname(__file__))) | |
| from models import ExportSection | |
| def extract_business_name_from_content(sections: List[ExportSection]) -> str: | |
| """Extract business name from markdown content""" | |
| for section in sections: | |
| if section.content: | |
| lines = section.content.split('\n') | |
| for i, line in enumerate(lines): | |
| line = line.strip() | |
| # Look for "Business Name:" pattern | |
| if '**Business Name:**' in line or 'Business Name:' in line: | |
| # Extract the business name from the line | |
| if '**Business Name:**' in line: | |
| business_name = line.split('**Business Name:**')[1].strip() | |
| else: | |
| business_name = line.split('Business Name:')[1].strip() | |
| # Keep markdown formatting - don't strip ** symbols | |
| # business_name = re.sub(r'[*_`~]', '', business_name) | |
| business_name = business_name.strip() | |
| if business_name: | |
| return business_name | |
| # If not found on same line, check next line | |
| if i + 1 < len(lines): | |
| next_line = lines[i + 1].strip() | |
| business_name = next_line # Keep ** symbols | |
| business_name = business_name.strip() | |
| if business_name: | |
| return business_name | |
| return None | |
| def extract_subheadings(content: str) -> List[str]: | |
| """Extract subheadings from markdown content""" | |
| subheadings = [] | |
| lines = content.split('\n') | |
| for line in lines: | |
| line = line.strip() | |
| # Look for various markdown header patterns | |
| if (line.startswith('##') and not line.startswith('###')) or \ | |
| line.startswith('**') and line.endswith('**') and len(line) > 4: | |
| # Remove markdown formatting and clean up | |
| if line.startswith('##'): | |
| subheading = re.sub(r'^##+\s*', '', line) | |
| else: | |
| # Handle bold text that might be headings - keep ** symbols | |
| subheading = line # Keep ** symbols instead of stripping them | |
| # subheading = re.sub(r'[*_`~]', '', subheading) # Commented out to preserve ** symbols | |
| if subheading.strip() and len(subheading.strip()) > 3: # Avoid very short headings | |
| subheadings.append(subheading.strip()) | |
| return subheadings | |
| def filter_empty_sections(sections: List[ExportSection]) -> List[ExportSection]: | |
| """Filter out sections with no content to prevent empty pages""" | |
| filtered_sections = [] | |
| for section in sections: | |
| if section.content and section.content.strip(): | |
| # Clean the content to check if it's actually meaningful | |
| cleaned_content = section.content # No clean_text_for_pdf import, so use raw content | |
| if cleaned_content and len(cleaned_content.strip()) > 10: # At least 10 characters | |
| filtered_sections.append(section) | |
| # logging.info(f"Section '{section.title}' passed filtering with {len(cleaned_content)} characters") | |
| else: | |
| # logging.info(f"Section '{section.title}' filtered out - content too short: {len(cleaned_content) if cleaned_content else 0} chars") | |
| pass | |
| else: | |
| # logging.info(f"Section '{section.title}' filtered out - no content") | |
| pass | |
| # logging.info(f"Filtered sections: {len(filtered_sections)} out of {len(sections)} total") | |
| return filtered_sections | |
| def remove_duplicate_headings(content: str) -> str: | |
| """Remove duplicate headings from content""" | |
| if not content: | |
| return content | |
| lines = content.split('\n') | |
| cleaned_lines = [] | |
| seen_headings = set() | |
| for line in lines: | |
| line = line.strip() | |
| if not line: | |
| cleaned_lines.append('') | |
| continue | |
| # Check if this is any type of heading | |
| is_heading = False | |
| heading_text = "" | |
| # Markdown headings (# ## ### etc.) | |
| if line.startswith('#'): | |
| heading_text = re.sub(r'^#+\s*', '', line).strip() | |
| is_heading = True | |
| # Bold headings (**text**) | |
| elif line.startswith('**') and line.endswith('**') and len(line) > 4: | |
| heading_text = line[2:-2].strip() # Remove ** symbols | |
| is_heading = True | |
| # Check for numbered headings (e.g., "8.1 Management Team") | |
| elif re.match(r'^\d+\.?\d*\s+', line): | |
| heading_text = re.sub(r'^\d+\.?\d*\s+', '', line).strip() | |
| is_heading = True | |
| if is_heading and heading_text: | |
| # Normalize the heading text for comparison | |
| normalized_text = heading_text.lower().strip() | |
| # Also check for variations with "and" vs "&" | |
| variations = [ | |
| normalized_text, | |
| normalized_text.replace(' & ', ' and '), | |
| normalized_text.replace(' and ', ' & '), | |
| normalized_text.replace('&', 'and'), | |
| normalized_text.replace('and', '&') | |
| ] | |
| # Check if any variation has been seen before | |
| is_duplicate = any(var in seen_headings for var in variations) | |
| if not is_duplicate: | |
| # Add all variations to seen set | |
| for var in variations: | |
| seen_headings.add(var) | |
| cleaned_lines.append(line) | |
| # Skip duplicate headings | |
| else: | |
| cleaned_lines.append(line) | |
| return '\n'.join(cleaned_lines) |