#!/usr/bin/env python import sys import re import pathlib import textwrap import pandas as pd import numpy as np import math import io from bs4 import BeautifulSoup, NavigableString, UnicodeDammit, Tag import traceback import datetime from typing import Any, Dict, List, Optional, Tuple import argparse from urllib.parse import quote, unquote, urljoin import html import itertools import unicodedata import binascii import logging import hashlib import fcntl try: from .hardcodes import apply_markdown_hardcodes except ImportError: from hardcodes import apply_markdown_hardcodes from collections import defaultdict from statistics import median import os, io, json, time, traceback, requests from dotenv import load_dotenv SEC_PARSER_DOTENV_PATH = pathlib.Path(__file__).resolve().parent / ".env" def _load_sec_parser_env() -> None: load_dotenv() if SEC_PARSER_DOTENV_PATH.exists(): load_dotenv(SEC_PARSER_DOTENV_PATH, override=False) _load_sec_parser_env() from pydantic import BaseModel, Field, ConfigDict, ValidationError from PyPDF2 import PdfReader, PdfWriter from PyPDF2.errors import PdfReadError from mistralai import Mistral, DocumentURLChunk from mistralai.extra import response_format_from_pydantic_model try: from .special_chars import WINGDINGS_MAP except ImportError: from special_chars import WINGDINGS_MAP import random from mistralai.models.sdkerror import SDKError import fitz import base64 import imgkit from playwright.sync_api import sync_playwright try: from .config import Config except ImportError: from config import Config log_file_path = pathlib.Path(__file__).parent / 'sec_parser_errors.log' ocr_log_file_path = pathlib.Path(__file__).resolve().parent.parent / 'pdf_files.log' parse_stats_log_file_path = pathlib.Path(__file__).parent / 'sec_parser_parse_stats.jsonl' parse_stats_summary_file_path = pathlib.Path(__file__).parent / 'sec_parser_parse_stats_summary.json' logger = logging.getLogger() logger.setLevel(logging.ERROR) handler = logging.FileHandler(log_file_path, mode='a', encoding='utf-8') formatter = logging.Formatter('%(asctime)s\n%(message)s\n' + '-'*80, datefmt='%Y-%m-%d %H:%M:%S') handler.setFormatter(formatter) logger.addHandler(handler) ocr_logger = logging.getLogger("ocr_tracker") ocr_logger.setLevel(logging.INFO) ocr_logger.propagate = False ocr_handler = logging.FileHandler(ocr_log_file_path, mode='a', encoding='utf-8') ocr_handler.setFormatter(formatter) ocr_logger.addHandler(ocr_handler) DEFAULT_FONT = 16.0 CURRENT_PROCESSING_FILE = "Unknown" CURRENT_OCR_LOGGED_FILINGS = set() CURRENT_SOURCE_DOCUMENT_URL = None LAST_PARSE_STATS = None LAST_POSITIONED_HTML_OCR_PAGE_COUNT = 0 _TIKTOKEN_ENCODING = None def _is_debug_enabled() -> bool: return os.getenv("SEC_PARSER_DEBUG", "0").strip().lower() in {"1", "true", "yes", "on"} def _debug_print(*args, **kwargs) -> None: if _is_debug_enabled(): print(*args, **kwargs) def estimate_parser_tokens(text: str) -> int: """Count output tokens with tiktoken when available, falling back to a stable approximation.""" global _TIKTOKEN_ENCODING text = text or "" if not text: return 0 if _TIKTOKEN_ENCODING is None: try: import tiktoken _TIKTOKEN_ENCODING = tiktoken.get_encoding("cl100k_base") except Exception: _TIKTOKEN_ENCODING = False if _TIKTOKEN_ENCODING: try: return len(_TIKTOKEN_ENCODING.encode(text)) except Exception: pass return max(1, len(re.findall(r"\w+|[^\w\s]", text, flags=re.UNICODE))) def normalize_form_type_for_stats(form_type: str) -> str: form = (form_type or "unknown").strip().upper() if not form: return "unknown" base = form[:-2] if form.endswith("/A") else form compact = re.sub(r"[^A-Z0-9]", "", base) if compact in {"8K", "10K", "10Q"}: return compact.lower() if compact.startswith("NPORT"): return "nport" if compact.startswith("NCEN"): return "ncen" if compact.startswith("NPX"): return "npx" if compact.startswith("NMFP"): return "nmfp" if compact.startswith("13F"): return "13f" if compact in {"3", "4", "5"}: return compact return compact.lower() or "unknown" def _pct(value: int, total: int) -> float: if total <= 0: return 0.0 return round((float(value) / float(total)) * 100.0, 4) def _new_parse_stats(filepath: pathlib.Path) -> Dict[str, Any]: return { "input_path": str(filepath), "source_document_url": CURRENT_SOURCE_DOCUMENT_URL, "accession_number": _current_filing_accession_number(), "form_type": "", "form_category": "unknown", "format_token_counts": {bucket: 0 for bucket in ("sgml", "html", "xml", "pdf", "text", "other")}, "format_char_counts": {bucket: 0 for bucket in ("sgml", "html", "xml", "pdf", "text", "other")}, "format_section_counts": {bucket: 0 for bucket in ("sgml", "html", "xml", "pdf", "text", "other")}, "pdf_page_count": 0, "parts": [], } def _record_parse_stats_part(stats: Optional[Dict[str, Any]], source_format: str, text: str, label: str = "") -> None: if not stats or not text or not str(text).strip(): return bucket = (source_format or "other").strip().lower() if bucket not in stats["format_token_counts"]: bucket = "other" token_count = estimate_parser_tokens(text) char_count = len(text) stats["format_token_counts"][bucket] += token_count stats["format_char_counts"][bucket] += char_count stats["format_section_counts"][bucket] += 1 stats["parts"].append( { "source_format": bucket, "label": label or bucket, "token_count": token_count, "char_count": char_count, } ) def _record_parse_stats_pdf_pages(stats: Optional[Dict[str, Any]], page_count: int) -> None: if not stats: return stats["pdf_page_count"] = int(stats.get("pdf_page_count") or 0) + max(0, int(page_count or 0)) def _finalize_parse_stats(stats: Optional[Dict[str, Any]], document_text: str, form_type: str) -> Dict[str, Any]: stats = stats or _new_parse_stats(pathlib.Path(CURRENT_PROCESSING_FILE or "unknown")) form_type = (form_type or stats.get("form_type") or "unknown").strip().upper() or "unknown" stats["form_type"] = form_type stats["form_category"] = normalize_form_type_for_stats(form_type) source_total = sum(int(v) for v in stats.get("format_token_counts", {}).values()) stats["source_token_count"] = source_total stats["source_char_count"] = sum(int(v) for v in stats.get("format_char_counts", {}).values()) stats["format_token_percentages"] = { key: _pct(int(value), source_total) for key, value in sorted(stats.get("format_token_counts", {}).items()) } pdf_page_count = int(stats.get("pdf_page_count") or 0) pdf_output_token_count = int((stats.get("format_token_counts") or {}).get("pdf") or 0) stats["pdf_page_count"] = pdf_page_count stats["pdf_output_token_count"] = pdf_output_token_count stats["pdf_output_tokens_per_page"] = ( round(float(pdf_output_token_count) / float(pdf_page_count), 4) if pdf_page_count > 0 else None ) stats["initial_document_token_count"] = estimate_parser_tokens(document_text or "") stats["initial_document_char_count"] = len(document_text or "") return stats def _complete_parse_stats_for_output( stats: Optional[Dict[str, Any]], *, output_path: pathlib.Path, final_markdown: str, to_mmd: bool, ) -> Dict[str, Any]: stats = dict(stats or _new_parse_stats(pathlib.Path(CURRENT_PROCESSING_FILE or "unknown"))) stats["output_path"] = str(output_path) stats["to_mmd"] = bool(to_mmd) stats["final_token_count"] = estimate_parser_tokens(final_markdown or "") stats["final_char_count"] = len(final_markdown or "") return stats def _write_parse_stats_outputs(stats: Dict[str, Any], output_path: pathlib.Path) -> None: sidecar_path = output_path.with_suffix(".parse_stats.json") sidecar_path.write_text(json.dumps(stats, indent=2, sort_keys=True), encoding="utf-8") if os.getenv("SEC_PARSER_DISABLE_GLOBAL_STATS", "").strip().lower() in {"1", "true", "yes", "on"}: return with parse_stats_log_file_path.open("a", encoding="utf-8") as handle: handle.write(json.dumps(stats, sort_keys=True) + "\n") _refresh_parse_stats_summary() _PARSE_STATS_SUMMARY_CACHE: Dict[str, Any] = { "path": "", "size": 0, "latest_by_input": {}, } def _refresh_parse_stats_summary() -> None: latest_by_input: Dict[str, Dict[str, Any]] log_path = parse_stats_log_file_path cache_path = str(log_path) current_size = log_path.stat().st_size if log_path.exists() else 0 cached_path = str(_PARSE_STATS_SUMMARY_CACHE.get("path") or "") cached_size = int(_PARSE_STATS_SUMMARY_CACHE.get("size") or 0) if cache_path == cached_path and current_size >= cached_size: latest_by_input = dict(_PARSE_STATS_SUMMARY_CACHE.get("latest_by_input") or {}) read_from = cached_size else: latest_by_input = {} read_from = 0 if log_path.exists(): with log_path.open("r", encoding="utf-8", errors="replace") as handle: if read_from: handle.seek(read_from) for line in handle: if not line.strip(): continue try: record = json.loads(line) except Exception: continue key = str(record.get("input_path") or record.get("accession_number") or record.get("output_path") or "") if key: latest_by_input[key] = record _PARSE_STATS_SUMMARY_CACHE["path"] = cache_path _PARSE_STATS_SUMMARY_CACHE["size"] = current_size _PARSE_STATS_SUMMARY_CACHE["latest_by_input"] = dict(latest_by_input) else: _PARSE_STATS_SUMMARY_CACHE["path"] = cache_path _PARSE_STATS_SUMMARY_CACHE["size"] = 0 _PARSE_STATS_SUMMARY_CACHE["latest_by_input"] = {} records = list(latest_by_input.values()) total_filings = len(records) form_counts: Dict[str, int] = defaultdict(int) form_token_counts: Dict[str, int] = defaultdict(int) format_token_counts: Dict[str, int] = defaultdict(int) total_pdf_page_count = 0 total_pdf_output_token_count = 0 total_tokens = 0 pdf_output_tokens_per_page_values: List[float] = [] for record in records: form = str(record.get("form_category") or normalize_form_type_for_stats(str(record.get("form_type") or ""))) tokens = int(record.get("final_token_count") or record.get("initial_document_token_count") or 0) form_counts[form] += 1 form_token_counts[form] += tokens total_tokens += tokens pdf_page_count = int(record.get("pdf_page_count") or 0) pdf_output_token_count = int( record.get("pdf_output_token_count") or (record.get("format_token_counts") or {}).get("pdf") or 0 ) total_pdf_page_count += pdf_page_count total_pdf_output_token_count += pdf_output_token_count pdf_output_tokens_per_page = record.get("pdf_output_tokens_per_page") if pdf_output_tokens_per_page is None and pdf_page_count > 0: pdf_output_tokens_per_page = round( float(pdf_output_token_count) / float(pdf_page_count), 4, ) if pdf_output_tokens_per_page is not None: pdf_output_tokens_per_page_values.append(float(pdf_output_tokens_per_page)) for bucket, value in (record.get("format_token_counts") or {}).items(): format_token_counts[str(bucket)] += int(value or 0) median_pdf_output_tokens_per_page = None if pdf_output_tokens_per_page_values: sorted_values = sorted(pdf_output_tokens_per_page_values) midpoint = len(sorted_values) // 2 median_pdf_output_tokens_per_page = ( sorted_values[midpoint] if len(sorted_values) % 2 == 1 else round((sorted_values[midpoint - 1] + sorted_values[midpoint]) / 2.0, 4) ) summary = { "deduped_filing_count": total_filings, "total_final_token_count": total_tokens, "total_pdf_page_count": total_pdf_page_count, "total_pdf_output_token_count": total_pdf_output_token_count, "pdf_output_tokens_per_page": ( round(float(total_pdf_output_token_count) / float(total_pdf_page_count), 4) if total_pdf_page_count > 0 else None ), "median_pdf_output_tokens_per_page": median_pdf_output_tokens_per_page, "form_type_counts": dict(sorted(form_counts.items())), "form_type_count_percentages": { key: _pct(value, total_filings) for key, value in sorted(form_counts.items()) }, "form_type_token_percentages": { key: _pct(value, total_tokens) for key, value in sorted(form_token_counts.items()) }, "format_token_counts": dict(sorted(format_token_counts.items())), "format_token_percentages": { key: _pct(value, sum(format_token_counts.values())) for key, value in sorted(format_token_counts.items()) }, } parse_stats_summary_file_path.write_text(json.dumps(summary, indent=2, sort_keys=True), encoding="utf-8") def _print_parse_stats_summary(stats: Dict[str, Any]) -> None: final_tokens = int(stats.get("final_token_count") or stats.get("initial_document_token_count") or 0) form = stats.get("form_category") or stats.get("form_type") or "unknown" percentages = stats.get("format_token_percentages") or {} format_text = ", ".join( f"{bucket}={percentages.get(bucket, 0):.1f}%" for bucket in ("html", "xml", "sgml", "pdf", "text", "other") if percentages.get(bucket, 0) > 0 ) or "none" print(f"[parse-stats] tokens={final_tokens:,} | form={form} | formats: {format_text}") def _current_filing_accession_number() -> Optional[str]: current_path = CURRENT_PROCESSING_FILE if not current_path or current_path == "Unknown": return None current_name = pathlib.Path(current_path).name match = re.search(r"\b\d{10}-\d{2}-\d{6}\b", current_name) if match: return match.group(0) stem = pathlib.Path(current_path).stem.strip() return stem or None def _log_current_filing_ocr(ocr_reason: str) -> None: accession_number = _current_filing_accession_number() if not accession_number or accession_number in CURRENT_OCR_LOGGED_FILINGS: return filing_name = pathlib.Path(CURRENT_PROCESSING_FILE).name CURRENT_OCR_LOGGED_FILINGS.add(accession_number) ocr_logger.info( f"ACCESSION: {accession_number}\n" f"FILING: {filing_name}\n" f"OCR_REASON: {ocr_reason}" ) CP1252_CTRL_TO_UNICODE = str.maketrans({ "\x80": "\u20AC", "\x82": "\u201A", "\x83": "\u0192", "\x84": "\u201E", "\x85": "\u2026", "\x86": "\u2020", "\x87": "\u2021", "\x88": "\u02C6", "\x89": "\u2030", "\x8A": "\u0160", "\x8B": "\u2039", "\x8C": "\u0152", "\x8E": "\u017D", "\x91": "\u2018", "\x92": "\u2019", "\x93": "\u201C", "\x94": "\u201D", "\x95": "\u2022", "\x96": "\u2013", "\x97": "\u2014", "\x98": "\u02DC", "\x99": "\u2122", "\x9A": "\u0161", "\x9B": "\u203A", "\x9C": "\u0153", "\x9E": "\u017E", "\x9F": "\u0178", }) PUNCT_CANON = str.maketrans({ "\u2018": "'", "\u2019": "'", "\uFF07": "'", "\u2032": "'", "\u2010": "-", "\u2011": "-", "\u2212": "-", }) OCR_API_URL = "https://api.mistral.ai/v1/ocr" MISTRAL_KEY_STATUS_PATH = pathlib.Path( os.getenv("SEC_PARSER_MISTRAL_KEY_STATUS_PATH", "").strip() or (pathlib.Path(__file__).parent / "mistral_key_status.json") ) MISTRAL_KEY_LOCK_PATH = MISTRAL_KEY_STATUS_PATH.with_suffix(MISTRAL_KEY_STATUS_PATH.suffix + ".lock") MISTRAL_KEY_ENV_LIMIT = 20 MISTRAL_KEY_STATE_VERSION = 1 MISTRAL_MONTHLY_TOKEN_BUDGET_ESTIMATE = 1_000_000_000 MISTRAL_QUOTA_ERROR_HINTS = ( "quota", "credit", "credits", "billing", "monthly", "free tier", "experiment plan", "token limit", "tokens per month", "out of tokens", "usage limit", "insufficient", ) MISTRAL_INVALID_KEY_HINTS = ( "invalid api key", "incorrect api key", "authentication", "unauthorized", "forbidden", "revoked", ) def _utc_now_iso() -> str: return datetime.datetime.now(datetime.timezone.utc).isoformat() def _current_usage_month_label() -> str: return datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m") def _parse_iso_timestamp(value: Optional[str]) -> Optional[float]: if not value: return None try: return datetime.datetime.fromisoformat(value).timestamp() except Exception: return None def _mistral_key_fingerprint(api_key: str) -> str: digest = hashlib.sha256((api_key or "").encode("utf-8")).hexdigest() return digest[:12] def _mistral_env_name_for_index(index: int) -> str: return "MISTRAL_API_KEY" if index == 1 else f"MISTRAL_API_KEY{index}" def _configured_mistral_key_specs(explicit_api_key: Optional[str] = None) -> List[Dict[str, Any]]: specs: List[Dict[str, Any]] = [] seen_keys = set() for idx in range(1, MISTRAL_KEY_ENV_LIMIT + 1): env_name = _mistral_env_name_for_index(idx) api_key = (os.getenv(env_name) or "").strip() if not api_key or api_key in seen_keys: continue seen_keys.add(api_key) specs.append( { "env_name": env_name, "ordinal": idx, "api_key": api_key, "fingerprint": _mistral_key_fingerprint(api_key), } ) explicit_api_key = (explicit_api_key or "").strip() if explicit_api_key and explicit_api_key not in seen_keys: specs.insert( 0, { "env_name": "MISTRAL_API_KEY", "ordinal": 1, "api_key": explicit_api_key, "fingerprint": _mistral_key_fingerprint(explicit_api_key), }, ) return specs def _has_mistral_api_keys(explicit_api_key: Optional[str] = None) -> bool: return bool(_configured_mistral_key_specs(explicit_api_key=explicit_api_key)) def _mistral_no_keys_message() -> str: return "No Mistral API keys found in environment variables MISTRAL_API_KEY through MISTRAL_API_KEY20." def _default_mistral_key_record(spec: Dict[str, Any]) -> Dict[str, Any]: return { "env_name": spec["env_name"], "ordinal": int(spec["ordinal"]), "fingerprint": spec["fingerprint"], "status": "available", "request_count": 0, "success_count": 0, "pages_processed": 0, "doc_size_bytes": 0, "estimated_output_tokens": 0, "last_selected_at": None, "last_success_at": None, "last_error_at": None, "last_error": None, "last_error_status_code": None, "last_rate_limit_headers": {}, "cooldown_until": None, "exhausted_at": None, } def _normalize_mistral_key_state(raw_state: Optional[Dict[str, Any]], key_specs: List[Dict[str, Any]]) -> Dict[str, Any]: state = dict(raw_state or {}) state_usage_month = str(state.get("usage_month") or "").strip() current_usage_month = _current_usage_month_label() monthly_reset = state_usage_month != current_usage_month keys_state = {} if monthly_reset else dict(state.get("keys") or {}) normalized_keys: Dict[str, Dict[str, Any]] = {} for spec in key_specs: record = dict(keys_state.get(spec["env_name"]) or {}) default_record = _default_mistral_key_record(spec) default_record.update(record) default_record["env_name"] = spec["env_name"] default_record["ordinal"] = int(spec["ordinal"]) default_record["fingerprint"] = spec["fingerprint"] normalized_keys[spec["env_name"]] = default_record state = { "version": MISTRAL_KEY_STATE_VERSION, "usage_month": current_usage_month, "updated_at": _utc_now_iso(), "active_env_name": state.get("active_env_name"), "keys": normalized_keys, } if state["active_env_name"] not in normalized_keys: state["active_env_name"] = None return state def _read_mistral_key_state_unlocked(key_specs: List[Dict[str, Any]]) -> Dict[str, Any]: if MISTRAL_KEY_STATUS_PATH.exists(): try: raw_state = json.loads(MISTRAL_KEY_STATUS_PATH.read_text(encoding="utf-8")) except Exception: raw_state = {} else: raw_state = {} return _normalize_mistral_key_state(raw_state, key_specs) def _write_mistral_key_state_unlocked(state: Dict[str, Any]) -> None: MISTRAL_KEY_STATUS_PATH.parent.mkdir(parents=True, exist_ok=True) tmp_path = MISTRAL_KEY_STATUS_PATH.with_suffix(MISTRAL_KEY_STATUS_PATH.suffix + ".tmp") tmp_path.write_text(json.dumps(state, indent=2, sort_keys=True), encoding="utf-8") tmp_path.replace(MISTRAL_KEY_STATUS_PATH) class _LockedMistralKeyState: def __init__(self, key_specs: List[Dict[str, Any]]): self.key_specs = key_specs self.handle = None self.state = None def __enter__(self) -> Dict[str, Any]: MISTRAL_KEY_LOCK_PATH.parent.mkdir(parents=True, exist_ok=True) self.handle = open(MISTRAL_KEY_LOCK_PATH, "a+", encoding="utf-8") fcntl.flock(self.handle.fileno(), fcntl.LOCK_EX) self.state = _read_mistral_key_state_unlocked(self.key_specs) return self.state def __exit__(self, exc_type, exc, tb) -> None: try: if self.state is not None: self.state["updated_at"] = _utc_now_iso() _write_mistral_key_state_unlocked(self.state) finally: if self.handle is not None: fcntl.flock(self.handle.fileno(), fcntl.LOCK_UN) self.handle.close() def _locked_mistral_key_state(key_specs: List[Dict[str, Any]]) -> _LockedMistralKeyState: return _LockedMistralKeyState(key_specs) def _select_mistral_key_spec(explicit_api_key: Optional[str] = None) -> Dict[str, Any]: key_specs = _configured_mistral_key_specs(explicit_api_key=explicit_api_key) if not key_specs: raise RuntimeError(_mistral_no_keys_message()) lookup = {spec["env_name"]: spec for spec in key_specs} now_ts = time.time() with _locked_mistral_key_state(key_specs) as state: available: List[Tuple[int, Dict[str, Any]]] = [] cooling: List[Tuple[float, int, Dict[str, Any]]] = [] for spec in key_specs: record = state["keys"][spec["env_name"]] if record.get("status") in {"exhausted", "invalid"}: continue cooldown_until_ts = _parse_iso_timestamp(record.get("cooldown_until")) if cooldown_until_ts and cooldown_until_ts > now_ts: cooling.append((cooldown_until_ts, spec["ordinal"], record)) else: available.append((spec["ordinal"], record)) chosen_record: Optional[Dict[str, Any]] = None if available: chosen_record = sorted(available, key=lambda item: item[0])[0][1] elif cooling: chosen_record = sorted(cooling, key=lambda item: (item[0], item[1]))[0][2] if not chosen_record: raise RuntimeError( "All configured Mistral API keys are exhausted or unavailable; stopping after MISTRAL_API_KEY20." ) chosen_record["last_selected_at"] = _utc_now_iso() chosen_record["request_count"] = int(chosen_record.get("request_count") or 0) + 1 state["active_env_name"] = chosen_record["env_name"] spec = dict(lookup[chosen_record["env_name"]]) spec["status"] = chosen_record.get("status") or "available" return spec def _record_mistral_key_success(env_name: str, usage: Optional[Dict[str, Any]] = None, explicit_api_key: Optional[str] = None) -> None: key_specs = _configured_mistral_key_specs(explicit_api_key=explicit_api_key) if not key_specs: return usage = dict(usage or {}) with _locked_mistral_key_state(key_specs) as state: record = state["keys"].get(env_name) if not record: return record["status"] = "available" record["cooldown_until"] = None record["success_count"] = int(record.get("success_count") or 0) + 1 record["pages_processed"] = int(record.get("pages_processed") or 0) + int(usage.get("pages_processed") or 0) record["doc_size_bytes"] = int(record.get("doc_size_bytes") or 0) + int(usage.get("doc_size_bytes") or 0) record["estimated_output_tokens"] = int(record.get("estimated_output_tokens") or 0) + int(usage.get("estimated_output_tokens") or 0) if usage.get("rate_limit_headers"): record["last_rate_limit_headers"] = dict(usage["rate_limit_headers"]) record["last_success_at"] = _utc_now_iso() def _record_mistral_key_terminal_error( env_name: str, *, status: str, message: str, status_code: Optional[int], explicit_api_key: Optional[str] = None, ) -> None: key_specs = _configured_mistral_key_specs(explicit_api_key=explicit_api_key) if not key_specs: return now_iso = _utc_now_iso() with _locked_mistral_key_state(key_specs) as state: record = state["keys"].get(env_name) if not record: return record["status"] = status record["last_error"] = (message or "")[:1000] record["last_error_status_code"] = status_code record["last_error_at"] = now_iso record["cooldown_until"] = None if status == "exhausted": record["exhausted_at"] = now_iso def _record_mistral_key_cooldown( env_name: str, *, message: str, status_code: Optional[int], cooldown_seconds: float, explicit_api_key: Optional[str] = None, ) -> None: key_specs = _configured_mistral_key_specs(explicit_api_key=explicit_api_key) if not key_specs: return cooldown_until = datetime.datetime.now(datetime.timezone.utc) + datetime.timedelta(seconds=max(1.0, float(cooldown_seconds))) with _locked_mistral_key_state(key_specs) as state: record = state["keys"].get(env_name) if not record: return record["status"] = "available" record["cooldown_until"] = cooldown_until.isoformat() record["last_error"] = (message or "")[:1000] record["last_error_status_code"] = status_code record["last_error_at"] = _utc_now_iso() def _extract_rate_limit_headers(headers: Optional[Dict[str, Any]]) -> Dict[str, Any]: out: Dict[str, Any] = {} for key, value in dict(headers or {}).items(): key_str = str(key) if key_str.lower().startswith("x-ratelimit") or key_str.lower() == "retry-after": out[key_str] = value return out def _extract_retry_after_seconds(headers: Optional[Dict[str, Any]], default_seconds: float = 60.0) -> float: headers = dict(headers or {}) raw = headers.get("Retry-After") or headers.get("retry-after") if raw is None: return default_seconds try: return max(1.0, float(raw)) except Exception: return default_seconds def _extract_mistral_error_details(exc: Exception) -> Dict[str, Any]: status_code = getattr(exc, "status_code", None) response = getattr(exc, "response", None) headers: Dict[str, Any] = {} message_parts = [str(exc)] if response is not None: status_code = getattr(response, "status_code", status_code) headers = dict(getattr(response, "headers", {}) or {}) try: response_text = response.text except Exception: response_text = "" if response_text: message_parts.append(response_text) try: response_json = response.json() except Exception: response_json = None if response_json: message_parts.append(json.dumps(response_json, ensure_ascii=False)) for attr_name in ("body", "response_body", "message"): attr_value = getattr(exc, attr_name, None) if attr_value: if not isinstance(attr_value, str): try: attr_value = json.dumps(attr_value, ensure_ascii=False) except Exception: attr_value = str(attr_value) message_parts.append(attr_value) message = " ".join(part.strip() for part in message_parts if str(part).strip()) message = re.sub(r"\s+", " ", message).strip() return { "status_code": status_code, "message": message[:2000], "rate_limit_headers": _extract_rate_limit_headers(headers), "retry_after_seconds": _extract_retry_after_seconds(headers), } def _classify_mistral_exception(exc: Exception) -> Dict[str, Any]: details = _extract_mistral_error_details(exc) status_code = details["status_code"] message = (details["message"] or "").lower() if status_code == 429 and any(hint in message for hint in MISTRAL_QUOTA_ERROR_HINTS): details["action"] = "exhausted" elif status_code in {402, 403} and any(hint in message for hint in MISTRAL_QUOTA_ERROR_HINTS): details["action"] = "exhausted" elif status_code == 401 or any(hint in message for hint in MISTRAL_INVALID_KEY_HINTS): details["action"] = "invalid" elif status_code == 403: details["action"] = "invalid" elif status_code == 429: details["action"] = "cooldown" else: details["action"] = "raise" return details def _summarize_ocr_usage(ocr_data: Optional[Dict[str, Any]], response_headers: Optional[Dict[str, Any]] = None) -> Dict[str, Any]: ocr_data = dict(ocr_data or {}) usage_info = dict(ocr_data.get("usage_info") or {}) pages = list(ocr_data.get("pages") or []) estimated_output_tokens = 0 for page_obj in pages: estimated_output_tokens += estimate_parser_tokens( _normalize_ocr_text((page_obj.get("markdown") or page_obj.get("text") or "").strip()) ) pages_processed = usage_info.get("pages_processed") if pages_processed is None: pages_processed = len(pages) return { "pages_processed": int(pages_processed or 0), "doc_size_bytes": int(usage_info.get("doc_size_bytes") or 0), "estimated_output_tokens": int(estimated_output_tokens), "rate_limit_headers": _extract_rate_limit_headers(response_headers), } def _run_with_mistral_key_rotation( operation_label: str, func, *, explicit_api_key: Optional[str] = None, ): key_specs = _configured_mistral_key_specs(explicit_api_key=explicit_api_key) if not key_specs: raise RuntimeError(_mistral_no_keys_message()) max_attempts = max(1, len(key_specs) * 2) last_exc: Optional[Exception] = None for _ in range(max_attempts): key_spec = _select_mistral_key_spec(explicit_api_key=explicit_api_key) key_label = f"{key_spec['env_name']}[{key_spec['fingerprint']}]" try: client = Mistral(api_key=key_spec["api_key"]) return func(client=client, api_key=key_spec["api_key"], key_spec=key_spec) except Exception as exc: decision = _classify_mistral_exception(exc) last_exc = exc if decision["action"] == "exhausted": print(f"[mistral] {key_label} exhausted during {operation_label}; switching to the next configured key.") _record_mistral_key_terminal_error( key_spec["env_name"], status="exhausted", message=decision["message"], status_code=decision["status_code"], explicit_api_key=explicit_api_key, ) continue if decision["action"] == "invalid": print(f"[mistral] {key_label} was rejected during {operation_label}; switching to the next configured key.") _record_mistral_key_terminal_error( key_spec["env_name"], status="invalid", message=decision["message"], status_code=decision["status_code"], explicit_api_key=explicit_api_key, ) continue if decision["action"] == "cooldown" and len(key_specs) > 1: cooldown_seconds = float(decision.get("retry_after_seconds") or 60.0) print( f"[mistral] {key_label} hit a rate limit during {operation_label}; cooling it down for " f"{cooldown_seconds:.0f}s and trying the next key." ) _record_mistral_key_cooldown( key_spec["env_name"], message=decision["message"], status_code=decision["status_code"], cooldown_seconds=cooldown_seconds, explicit_api_key=explicit_api_key, ) continue raise raise RuntimeError( "All configured Mistral API keys are exhausted or unavailable; stopping after MISTRAL_API_KEY20." ) from last_exc def get_mistral_key_status_snapshot(explicit_api_key: Optional[str] = None) -> Dict[str, Any]: key_specs = _configured_mistral_key_specs(explicit_api_key=explicit_api_key) with _locked_mistral_key_state(key_specs) as state: snapshot = json.loads(json.dumps(state)) now_ts = time.time() snapshot["status_path"] = str(MISTRAL_KEY_STATUS_PATH) snapshot["configured_key_count"] = len(key_specs) snapshot["available_key_count"] = 0 snapshot["exhausted_key_count"] = 0 for record in snapshot.get("keys", {}).values(): cooldown_until_ts = _parse_iso_timestamp(record.get("cooldown_until")) record["cooldown_remaining_s"] = ( max(0.0, round(cooldown_until_ts - now_ts, 3)) if cooldown_until_ts and cooldown_until_ts > now_ts else 0.0 ) if record.get("status") == "exhausted": snapshot["exhausted_key_count"] += 1 elif record.get("status") != "invalid": snapshot["available_key_count"] += 1 return snapshot def reset_mistral_key_status(explicit_api_key: Optional[str] = None) -> Dict[str, Any]: key_specs = _configured_mistral_key_specs(explicit_api_key=explicit_api_key) with _locked_mistral_key_state(key_specs) as state: fresh_state = _normalize_mistral_key_state({}, key_specs) state.clear() state.update(fresh_state) snapshot = json.loads(json.dumps(state)) snapshot["status_path"] = str(MISTRAL_KEY_STATUS_PATH) return snapshot def _estimate_monthly_mistral_tokens_used(explicit_api_key: Optional[str] = None) -> int: snapshot = get_mistral_key_status_snapshot(explicit_api_key=explicit_api_key) total = 0 for record in (snapshot.get("keys") or {}).values(): total += int(record.get("estimated_output_tokens") or 0) return total def _print_mistral_monthly_usage( phase: str, file_name: str, *, explicit_api_key: Optional[str] = None, ) -> None: used_tokens = _estimate_monthly_mistral_tokens_used(explicit_api_key=explicit_api_key) print( f"[mistral-usage] {phase} PDF '{file_name}': " f"{used_tokens:,}/{MISTRAL_MONTHLY_TOKEN_BUDGET_ESTIMATE:,} estimated output tokens used this month" ) OCR_MODEL = Config.OCR_MODEL MISTRAL_OCR_HTML_TABLE_PROMPT = ( "Extract the document content. Return prose and non-table text as Markdown. " "For every table, return real HTML table markup instead of Markdown tables. " "Use only plain table structure tags such as , ,
, and , " "with colspan and rowspan when needed to preserve merged cells. " "Do not wrap HTML tables in markdown code fences. Preserve visible table text, " "row order, column order, punctuation, signs, and numeric formatting." ) def _mistral_ocr_table_format() -> str: value = os.getenv("MISTRAL_OCR_TABLE_FORMAT", "html").strip().lower() if value in {"html", "markdown"}: return value return "html" def _build_mistral_ocr_payload(signed_url: str) -> dict: table_format = _mistral_ocr_table_format() payload = { "model": OCR_MODEL, "document": {"document_url": signed_url}, "table_format": table_format, } if table_format == "html": payload["document_annotation_format"] = { "type": "json_schema", "json_schema": { "name": "ocr_markdown_with_html_tables", "strict": True, "schema": { "type": "object", "properties": { "content": {"type": "string"}, }, "required": ["content"], "additionalProperties": False, }, }, } payload["document_annotation_prompt"] = MISTRAL_OCR_HTML_TABLE_PROMPT return payload def _post_mistral_ocr_with_retry( *, headers: Dict[str, str], payload: Dict[str, Any], operation_label: str, timeout_s: int = 600, ): max_retries = max(1, int(getattr(Config, "API_MAX_RETRIES", 4) or 4)) delay = max(0.1, float(getattr(Config, "API_INITIAL_DELAY_SECONDS", 2.0) or 2.0)) transient_statuses = {408, 409, 425, 429, 500, 502, 503, 504} last_exc: Optional[Exception] = None for attempt in range(1, max_retries + 1): response = None try: response = requests.post(OCR_API_URL, headers=headers, json=payload, timeout=timeout_s) if response.status_code not in transient_statuses: response.raise_for_status() return response response.raise_for_status() except Exception as exc: last_exc = exc status_code = getattr(response, "status_code", None) is_transient = status_code in transient_statuses or isinstance( exc, ( requests.Timeout, requests.ConnectionError, ), ) if not is_transient or attempt >= max_retries: raise retry_after = None if response is not None: retry_after_raw = response.headers.get("Retry-After") try: retry_after = float(retry_after_raw) if retry_after_raw else None except (TypeError, ValueError): retry_after = None sleep_s = max(delay, retry_after or 0.0) + random.uniform(0, 0.5) print( f"OCR API transient error during {operation_label}: {exc}. " f"Retrying in {sleep_s:.2f}s... (Attempt {attempt}/{max_retries})" ) time.sleep(sleep_s) delay = min(delay * 2, 60.0) if last_exc is not None: raise last_exc raise RuntimeError(f"OCR API request failed during {operation_label}") def _decode_uu_block_bytes(text: str) -> bytes: lines = text.splitlines() begin_idx = next((i for i, line in enumerate(lines) if re.match(r"^begin\s+\d{3}\s+[^\n]+$", line.strip())), None) if begin_idx is None: raise ValueError("Could not find a valid 'begin' line in the uuencoded block.") decoded = bytearray() found_end = False for line in lines[begin_idx + 1:]: uu_line = line.rstrip("\r\n") if uu_line == "end": found_end = True break if uu_line == "": continue try: decoded.extend(binascii.a2b_uu(uu_line.encode("latin-1"))) except binascii.Error as e: if "Trailing garbage" not in str(e): raise ValueError(f"Failed to decode uuencoded block: {e}") from e recovered = None for end in range(len(uu_line) - 1, 0, -1): try: candidate = binascii.a2b_uu(uu_line[:end].encode("latin-1")) recovered = candidate break except binascii.Error: continue if recovered is None: raise ValueError(f"Failed to decode uuencoded block: {e}") from e decoded.extend(recovered) if not found_end: raise ValueError("Could not find the terminating 'end' line in the uuencoded block.") return bytes(decoded) def _extract_uu_block(text: str) -> Tuple[bytes, str]: """Finds and decodes the first uuencoded block.""" fname_match = re.search(r"begin\s+\d{3}\s+([^\n]+)", text) if not fname_match: raise ValueError("Could not find a valid 'begin' line in the uuencoded block.") filename = fname_match.group(1).strip() decoded_bytes = _decode_uu_block_bytes(text) if not decoded_bytes: raise ValueError("UU decoding produced no data.") if decoded_bytes.startswith(b"%PDF-") and b"%%EOF" not in decoded_bytes[-1024:]: decoded_bytes += b"\n%%EOF\n" return decoded_bytes, filename def _slice_pdf_bytes(pdf_bytes: bytes, first_page: int, last_page: Optional[int] = None) -> bytes: """Extracts a page range from a PDF bytes object.""" reader = PdfReader(io.BytesIO(pdf_bytes)) writer = PdfWriter() num_pages = len(reader.pages) start_idx = first_page - 1 end_idx = num_pages if last_page is None else min(last_page, num_pages) for i in range(start_idx, end_idx): writer.add_page(reader.pages[i]) with io.BytesIO() as buf: writer.write(buf) return buf.getvalue() def is_page_nearly_blank(page: fitz.Page, threshold: float = 3.5) -> bool: """Checks if a page is visually blank by analyzing pixel standard deviation.""" pix = page.get_pixmap(matrix=fitz.Matrix(0.5, 0.5), colorspace=fitz.csGRAY, alpha=False) img_data = np.frombuffer(pix.samples, dtype=np.uint8) if img_data.size < 100: return True std_dev = np.std(img_data) return std_dev < threshold def realign_fixed_width_table(text: str) -> str: """Parses and perfectly reformats a poorly-aligned fixed-width table.""" lines = text.strip().split('\n') if len(lines) < 2: return text separator_index = next((i for i, line in enumerate(lines) if '--' in line and len(line.replace('-', '').replace(' ', '')) < 5), -1) if separator_index == -1: return text separator_line = lines[separator_index] boundaries = [] in_dash = False for i, char in enumerate(separator_line): if char == '-' and not in_dash: in_dash = True start = i elif char == ' ' and in_dash: in_dash = False boundaries.append((start, i)) if in_dash: boundaries.append((start, len(separator_line))) if not boundaries: return text rows = [[line[s:e].strip() for s, e in boundaries] for line in lines if line.strip() != separator_line.strip() and any(line[s:e].strip() for s, e in boundaries)] if not rows: return text widths = [max(len(cell) for cell in col) for col in zip(*rows)] realigned = [] header, body = rows[0], rows[1:] realigned.append(' '.join(h.ljust(w) for h, w in zip(header, widths))) realigned.append(' '.join('-' * w for w in widths)) for row in body: full_row = row + [''] * (len(widths) - len(row)) realigned.append(' '.join([full_row[0].ljust(widths[0])] + [c.rjust(w) for c, w in zip(full_row[1:], widths[1:])])) return '\n'.join(realigned) def _ascii_text(s: str) -> str: s = _normalize_ocr_text(s or "") s = s.translate(PUNCT_CANON) s = s.replace("\u201c", '"').replace("\u201d", '"') s = s.replace("\u2022", "*").replace("\u00b7", "*") s = unicodedata.normalize("NFKD", s).encode("ascii", "ignore").decode("ascii") return re.sub(r"\s+", " ", s).strip() def is_numeric_like(s: str) -> bool: s = _ascii_text(s) if s in {"", "-"}: return False s = s.replace(",", "").replace("$", "").replace("%", "") if s.startswith("(") and s.endswith(")"): s = "-" + s[1:-1] try: float(s) return True except ValueError: return False def table_to_fixed_width(table) -> str: rows = [] for tr in table.find_all("tr"): cells = [_ascii_text(c.get_text(" ", strip=True)) for c in tr.find_all(["th", "td"])] if cells: rows.append(cells) if not rows: return "" col_count = max(len(r) for r in rows) rows = [r + [""] * (col_count - len(r)) for r in rows] aligns = [] for j in range(col_count): if j == 0: aligns.append("left") continue col_vals = [r[j] for r in rows[1:] if r[j].strip()] numeric_count = sum(is_numeric_like(v) for v in col_vals) aligns.append("right" if col_vals and numeric_count >= len(col_vals) / 2 else "left") widths = [max(len(r[j]) for r in rows) for j in range(col_count)] def fmt(row): out = [] for j, cell in enumerate(row): if aligns[j] == "right": out.append(cell.rjust(widths[j])) else: out.append(cell.ljust(widths[j])) return " ".join(out).rstrip() lines = [] for i, row in enumerate(rows): lines.append(fmt(row)) if i == 0: lines.append(" ".join("-" * w for w in widths).rstrip()) return "\n".join(lines) def _html_to_fixed_width_ascii(html_fragment: str) -> str: html_fragment = (html_fragment or "").strip() if html_fragment.startswith("```"): html_fragment = re.sub(r"^```(?:html)?\s*", "", html_fragment, flags=re.I) html_fragment = re.sub(r"\s*```$", "", html_fragment) soup = BeautifulSoup(html_fragment, "html.parser") root = soup.body if soup.body else soup output_parts: List[str] = [] def append_text(text: str): text = _ascii_text(text) if not text: return m = re.match(r"^\*\*(.+?)\*\*$", text) if m: output_parts.append(m.group(1).strip().upper()) else: output_parts.append(text) def walk(nodes): for node in nodes: if isinstance(node, NavigableString): append_text(str(node)) continue node_name = getattr(node, "name", None) if node_name == "table": fixed = table_to_fixed_width(node) if fixed.strip(): output_parts.append(fixed) continue if node_name == "br": continue if getattr(node, "contents", None): walk(node.contents) else: append_text(node.get_text(" ", strip=True)) walk(root.contents) return "\n\n".join(part for part in output_parts if part.strip()) _DASH_TRANSLATE = str.maketrans({ "\u2010": "-", "\u2011": "-", "\u2012": "-", "\u2013": "-", "\u2014": "-", "\u2015": "-", "\u2212": "-", "\uFE58": "-", "\uFE63": "-", "\uFF0D": "-" }) def _normalize_ocr_text(s: str) -> str: s = unicodedata.normalize("NFKC", s or "") s = s.replace("\u00A0", " ").replace("\ufeff", "").replace("\u200b", "").replace("\u200d", "") s = s.translate(_DASH_TRANSLATE) if "\\n" in s: s = s.replace(r"\n", "\n") return s _CELL_SEP_RE = re.compile(r'^\s*:?\s*-{2,}\s*:?\s*$') _MISTRAL_HTML_TABLE_FRAGMENT_RE = re.compile(r"", re.I) def _is_separator_line(line: str) -> bool: line = _normalize_ocr_text(line) if '|' not in line: return False core = line.strip() if not core.startswith('|'): return False parts = [p.strip() for p in core.strip('|').split('|')] if not parts or any(p == '' for p in parts): return False return all(_CELL_SEP_RE.match(p or '') for p in parts) def find_md_table_blocks(text: str) -> List[Tuple[int,int]]: text = _normalize_ocr_text(text) lines = text.splitlines() blocks: List[Tuple[int,int]] = [] i, n = 0, len(lines) while i < n - 1: if '|' in lines[i].lstrip() and i + 1 < n and _is_separator_line(lines[i+1]): j, has_body = i + 2, False while j < n and '|' in lines[j].lstrip() and lines[j].strip() != '': has_body = True j += 1 if has_body: blocks.append((i, j-1)) i = j continue i += 1 return blocks def slice_text_by_blocks(text: str, blocks: List[Tuple[int,int]]) -> List[str]: text = _normalize_ocr_text(text) lines = text.splitlines() return ["\n".join(lines[s:e+1]) for s, e in blocks] def replace_blocks_with(text: str, blocks: List[Tuple[int,int]], repl_texts: List[str]) -> str: text = _normalize_ocr_text(text) lines = text.splitlines() out, cur, k = [], 0, 0 for s, e in blocks: out.extend(lines[cur:s]) out.extend(repl_texts[k].splitlines()) cur = e + 1 k += 1 out.extend(lines[cur:]) return "\n".join(out) def _inline_mistral_table_placeholders(page_obj, text_content: str) -> str: rendered = str(text_content or "") tables = page_obj.get("tables") if isinstance(page_obj, dict) else None if not isinstance(tables, list) or not tables: return rendered inlined_count = 0 fallback_contents = [] for table in tables: if not isinstance(table, dict): continue table_id = _normalize_ocr_text(str(table.get("id") or "")).strip() table_content = _normalize_ocr_text( str(table.get("content") or table.get("html") or table.get("markdown") or "") ).strip() if not table_content: continue if table_id: placeholder = f"[{table_id}]({table_id})" if placeholder in rendered: rendered = rendered.replace(placeholder, table_content) inlined_count += 1 continue fallback_contents.append(table_content) if inlined_count == 0 and fallback_contents: missing_contents = [ content for content in fallback_contents if content not in rendered ] if missing_contents: if rendered.strip(): rendered = rendered.rstrip() + "\n\n" + "\n\n".join(missing_contents) else: rendered = "\n\n".join(missing_contents) return rendered def _mistral_table_cell_text(cell) -> str: text = _normalize_ocr_text(cell.get_text(" ", strip=True)) text = re.sub(r"\s+", " ", text).strip() text = text.replace("|", r"\|") return text def _html_table_fragment_to_mmd(table_html: str) -> str: try: soup = BeautifulSoup(table_html, "html.parser") except Exception: return table_html table = soup.find("table") if table is None: return table_html rows = [] pending_rowspans = {} for tr in table.find_all("tr"): row = [] col = 0 for cell in tr.find_all(["th", "td"], recursive=False): while pending_rowspans.get(col, 0) > 0: row.append("") pending_rowspans[col] -= 1 col += 1 try: colspan = max(1, int(cell.get("colspan", 1))) except (TypeError, ValueError): colspan = 1 try: rowspan = max(1, int(cell.get("rowspan", 1))) except (TypeError, ValueError): rowspan = 1 row.append(_mistral_table_cell_text(cell)) for _ in range(1, colspan): row.append("") if rowspan > 1: for offset in range(colspan): pending_rowspans[col + offset] = max(pending_rowspans.get(col + offset, 0), rowspan - 1) col += colspan while pending_rowspans.get(col, 0) > 0: row.append("") pending_rowspans[col] -= 1 col += 1 if any(cell.strip() for cell in row): rows.append(row) if not rows: return table_html width = max(len(row) for row in rows) padded_rows = [row + [""] * (width - len(row)) for row in rows] def render_row(row) -> str: return "| " + " | ".join(cell or " " for cell in row) + " |" separator = "| " + " | ".join("---" for _ in range(width)) + " |" return "\n".join([render_row(padded_rows[0]), separator, *[render_row(row) for row in padded_rows[1:]]]) def _convert_mistral_html_tables_to_mmd(text: str) -> str: if not text or " str: rendered = _html_table_fragment_to_mmd(match.group(0)) return f"\n\n{rendered}\n\n" converted = _MISTRAL_HTML_TABLE_FRAGMENT_RE.sub(replace_table, text) return re.sub(r"\n{3,}", "\n\n", converted).strip() def _pick_text(page_obj) -> str: text_content = _normalize_ocr_text((page_obj.get("markdown") or page_obj.get("text") or "").strip()) inlined_text = _inline_mistral_table_placeholders(page_obj, text_content) return _normalize_ocr_text(_convert_mistral_html_tables_to_mmd(inlined_text).strip()) def _full_page_data_uri(doc: fitz.Document, page_index0: int, zoom: float = Config.IMAGE_RENDER_ZOOM) -> str: page = doc.load_page(page_index0) pix = page.get_pixmap(matrix=fitz.Matrix(zoom, zoom), alpha=False) return f"data:image/png;base64,{base64.b64encode(pix.tobytes('png')).decode('utf-8')}" def get_signed_url_with_retry(client, file_id, max_retries=Config.API_MAX_RETRIES, initial_delay=Config.API_INITIAL_DELAY_SECONDS): """ Attempts to get a signed URL, retrying with exponential backoff if a 404 error occurs. """ delay = initial_delay for attempt in range(max_retries): try: signed_url = client.files.get_signed_url(file_id=file_id).url return signed_url except SDKError as e: if e.status_code == 404 and attempt < max_retries - 1: print(f"File ID {file_id} not found yet. Retrying in {delay:.2f}s... (Attempt {attempt + 1}/{max_retries})") time.sleep(delay) delay *= 2 delay += random.uniform(0, 0.1) else: raise e raise Exception(f"Failed to get signed URL for file {file_id} after {max_retries} attempts.") def _process_pdf_bytes_with_fallback( pdf_bytes: bytes, file_name: str, *, batch_size: int, mistral_api_key: Optional[str], per_table_sleep_s: float, start_time: float, time_limit_s: int, ): """ Main PDF processing workflow that takes bytes and returns processed content and a boolean indicating if a timeout occurred, plus the number of PDF pages successfully parsed through OCR. """ _log_current_filing_ocr("pdf_or_rendered_html") _print_mistral_monthly_usage("before", file_name, explicit_api_key=mistral_api_key) doc = fitz.open(stream=pdf_bytes, filetype="pdf") n_total = doc.page_count results = [] parsed_page_count = 0 timed_out = False print(f"[init] processing '{file_name}' ({n_total} pages) in batches of {batch_size}…") p = 1 while p <= n_total: if time.time() - start_time > time_limit_s: print(f"\n[timeout] Time limit of {time_limit_s // 60} minutes reached. Stopping processing for this document.") timed_out = True break q = min(p + batch_size - 1, n_total) print(f"[basic] pages {p}–{q} …") pages = [] try: chunk_bytes = _slice_pdf_bytes(pdf_bytes, first_page=p, last_page=q) def _run_batch_ocr(*, client: Mistral, api_key: str, key_spec: Dict[str, Any]): up = client.files.upload(file={"file_name": f"chunk_{p}-{q}_{file_name}", "content": chunk_bytes}, purpose="ocr") if not up or not up.id: raise Exception("File upload failed to return a valid ID.") signed_url = get_signed_url_with_retry(client, file_id=up.id) headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"} payload = _build_mistral_ocr_payload(signed_url) response = _post_mistral_ocr_with_retry( headers=headers, payload=payload, operation_label=f"pdf batch {p}-{q} for {file_name}", timeout_s=600, ) ocr_data = response.json() usage = _summarize_ocr_usage(ocr_data, response.headers) return ocr_data.get("pages", []), usage, key_spec["env_name"] pages, usage, used_env_name = _run_with_mistral_key_rotation( f"pdf batch {p}-{q} for {file_name}", _run_batch_ocr, explicit_api_key=mistral_api_key, ) _record_mistral_key_success(used_env_name, usage=usage, explicit_api_key=mistral_api_key) except Exception as e: print(f"API processing for pages {p}-{q} failed and was skipped. Error: {e}") error_message = f"Could not repair '{file_name}'. The file may be severely corrupted. Error: {e}" logging.error( f"FILE: {file_name}\nERROR: {error_message}\nTRACEBACK:\n{traceback.format_exc()}" ) if not pages: p = q + 1 continue parsed_page_count += len(pages) for i, page_obj in enumerate(pages): page_no = p + i doc_page = doc.load_page(page_no - 1) if is_page_nearly_blank(doc_page): print(f"[page {page_no}] is nearly blank -> skipping.") continue text_basic = _pick_text(page_obj) results.append({"page": page_no, "content": text_basic, "source": "mistral-ocr"}) p = q + 1 _print_mistral_monthly_usage("after", file_name, explicit_api_key=mistral_api_key) return results, timed_out, parsed_page_count def _try_repair_pdf_bytes(pdf_bytes: bytes, file_name: str) -> bytes: """ Attempts to repair a potentially truncated or corrupted PDF byte stream. """ if not pdf_bytes.startswith(b"%PDF-"): print(f"[warning] Data for '{file_name}' does not appear to be a PDF. Skipping repair.") return pdf_bytes if b"%%EOF" not in pdf_bytes[-1024:]: print(f"[info] PDF '{file_name}' appears truncated. Appending EOF marker for recovery.") pdf_bytes += b"\n%%EOF\n" try: with fitz.open(stream=pdf_bytes, filetype="pdf") as doc: if doc.needs_pass: print(f"[warning] PDF '{file_name}' is password protected and cannot be repaired or processed.") return None with io.BytesIO() as output_buffer: doc.save(output_buffer, garbage=4, clean=True, deflate=True) print(f"[success] Successfully repaired and rebuilt '{file_name}'.") return output_buffer.getvalue() except Exception as e: print(f"[error] Could not repair '{file_name}'. The file may be severely corrupted. Error: {e}") logging.error( f"FILE: {file_name}\n" f"ERROR: Could not process PDF attachment: {e}\n" f"TRACEBACK:\n{traceback.format_exc()}" ) return None return pdf_bytes def parse_pdf_attachments(pdf_blobs) -> tuple[str, int]: """ Parses uu-encoded PDF attachments using a high-quality, in-memory workflow. This version includes an attempt to repair corrupted PDFs. """ _load_sec_parser_env() if not _has_mistral_api_keys(): print(f"{_mistral_no_keys_message()} Skipping PDF processing.") return "", 0 TIME_LIMIT_SECONDS = Config.PDF_TIMEOUT_LIMIT * 60 start_time = time.time() timed_out = False total_parsed_page_count = 0 md_parts = ["\n### Attached PDF Documents\n"] for i, pdf_data in enumerate(pdf_blobs, 1): if timed_out: break filename = "unknown.pdf" try: pdf_bytes, filename = _extract_uu_block(pdf_data) repaired_pdf_bytes = _try_repair_pdf_bytes(pdf_bytes, filename) if not repaired_pdf_bytes: md_parts.append(f"**Attachment {i}:** `{filename}` – Corrupted and could not be repaired.") continue if not repaired_pdf_bytes.startswith(b"%PDF-"): md_parts.append(f"**Attachment {i}:** `{filename}` – not a PDF.") continue md_parts.append(f"**Attachment {i}:** `{filename}`") page_results, timed_out_during_processing, parsed_page_count = _process_pdf_bytes_with_fallback( pdf_bytes=repaired_pdf_bytes, file_name=filename, batch_size=Config.PDF_BATCH_SIZE, mistral_api_key=None, per_table_sleep_s=Config.PER_TABLE_SLEEP_SECONDS, start_time=start_time, time_limit_s=TIME_LIMIT_SECONDS ) total_parsed_page_count += int(parsed_page_count or 0) if timed_out_during_processing: timed_out = True attachment_content_parts = [res.get('content', '') for res in page_results if res.get('content')] if attachment_content_parts: md_parts.append("\n\n".join(attachment_content_parts)) else: if not timed_out: md_parts.append("_No text found in this document._") except Exception as e: md_parts.append(f"Could not process `{filename}`: {e}") logging.error( f"FILE: {filename}\n" f"ERROR: Could not process PDF attachment: {e}\n" f"TRACEBACK:\n{traceback.format_exc()}" ) traceback.print_exc() if timed_out: md_parts.append("\n\n**Time limit hit – remaining pages or documents were skipped.**") return "\n\n".join(md_parts), total_parsed_page_count _CP1252_CTRL_RE = re.compile(r'[\x80-\x9F]') def _has_cp1252_ctrls(s: str) -> bool: return bool(_CP1252_CTRL_RE.search(s)) def normalize_text_markup(markup): if isinstance(markup, bytes): utf8_text = None try: utf8_text = markup.decode('utf-8') except UnicodeDecodeError: utf8_text = None if utf8_text is not None and not _has_cp1252_ctrls(utf8_text): text = utf8_text else: markup = UnicodeDammit.detwingle(markup) utf8_text = None try: utf8_text = markup.decode('utf-8') except UnicodeDecodeError: utf8_text = None ud = UnicodeDammit(markup, is_html=True, smart_quotes_to='unicode') text = ud.unicode_markup detected_encoding = (ud.original_encoding or '').lower() if utf8_text is not None and detected_encoding.startswith('mac_'): text = utf8_text elif (not text) or ('\uFFFD' in text) or _has_cp1252_ctrls(text): text = markup.decode('latin-1', errors='strict') else: text = str(markup) text = text.translate(CP1252_CTRL_TO_UNICODE) mojibake_map = { 'â�”': '—', 'â�“': '–', 'â�™': "'", 'â�œ': '"', 'â�d': '"', 'â�‰': ' ', } for bad, good in mojibake_map.items(): text = text.replace(bad, good) text = text.replace("<", "<").replace(">", ">").replace("    ", "##INDENT##") text = html.unescape(text) text = (text .replace('\u00AD', '') .replace('\u00A0', ' ') .replace('\u2007', ' ') .replace('\u202F', ' ') .replace('\u2009', ' ') .replace('\u2014', '—') .replace('\u2013', '–')) text = text.translate(PUNCT_CANON) return unicodedata.normalize('NFC', text) ORDER_I = [ "1. Title of Security##ROWSPAN_1##
1. Title of Security##ROWSPAN_1##", "2. Transaction Date##ROWSPAN_2##
2. Transaction Date##ROWSPAN_2##", "2A. Deemed Execution Date##ROWSPAN_3##
2A. Deemed Execution Date##ROWSPAN_3##", "3. Transaction Code (V)##COLSPAN_1##
Code", "3. Transaction Code (V)##COLSPAN_1##
V", "4. Securities Acquired (A) or Disposed of (D)##COLSPAN_2##
Amount", "4. Securities Acquired (A) or Disposed of (D)##COLSPAN_2##
(A) or (D)", "4. Securities Acquired (A) or Disposed of (D)##COLSPAN_2##
Price", "5. Amount of Securities Beneficially Owned##ROWSPAN_4##
5. Amount of Securities Beneficially Owned##ROWSPAN_4##", "6. Ownership Form##ROWSPAN_5##
6. Ownership Form##ROWSPAN_5##", "7. Nature of Indirect Beneficial Ownership##ROWSPAN_6##
7. Nature of Indirect Beneficial Ownership##ROWSPAN_6##", ] ORDER_II = [ "1. Title of Derivative Security##ROWSPAN_7##
1. Title of Derivative Security##ROWSPAN_7##", "2. Conversion or Exercise Price##ROWSPAN_8##
2. Conversion or Exercise Price##ROWSPAN_8##", "3. Transaction Date##ROWSPAN_9##
3. Transaction Date##ROWSPAN_9##", "3A. Deemed Execution Date##ROWSPAN_10##
3A. Deemed Execution Date##ROWSPAN_10##", "4. Transaction Code (V)##COLSPAN_3##
Code", "4. Transaction Code (V)##COLSPAN_3##
V", "5. Number of Derivative Securities Acquired (A) or Disposed of (D)##COLSPAN_4##
(A)", "5. Number of Derivative Securities Acquired (A) or Disposed of (D)##COLSPAN_4##
(D)", "6. Date Exercisable and Expiration Date##COLSPAN_5##
Date Exercisable", "6. Date Exercisable and Expiration Date##COLSPAN_5##
Expiration Date", "7. Title and Amount of Underlying Securities##COLSPAN_6##
Title", "7. Title and Amount of Underlying Securities##COLSPAN_6##
Amount or Number of Shares", "8. Price of Derivative Security##ROWSPAN_11##
8. Price of Derivative Security##ROWSPAN_11##", "9. Number of Derivative Securities Beneficially Owned##ROWSPAN_12##
9. Number of Derivative Securities Beneficially Owned##ROWSPAN_12##", "10. Ownership Form##ROWSPAN_13##
10. Ownership Form##ROWSPAN_13##", "11. Nature of Indirect Beneficial Ownership##ROWSPAN_14##
11. Nature of Indirect Beneficial Ownership##ROWSPAN_14##", ] ORDER_I_FORM3 = [ "1. Title of Security", "2. Amount of Securities Beneficially Owned", "3. Ownership Form", "4. Nature of Indirect Beneficial Ownership", ] ORDER_II_FORM3 = [ "1. Title of Derivative Security##ROWSPAN_1##
1. Title of Derivative Security##ROWSPAN_1##", "2. Date Exercisable and Expiration Date (Month/Day/Year)##COLSPAN_1##
Date Exercisable", "2. Date Exercisable and Expiration Date (Month/Day/Year)##COLSPAN_1##
Expiration Date", "3. Title and Amount of Underlying Securities##COLSPAN_2##
Title", "3. Title and Amount of Underlying Securities##COLSPAN_2##
Amount or Number of Shares", "4. Conversion or Exercise Price##ROWSPAN_2##
4. Conversion or Exercise Price##ROWSPAN_2##", "5. Ownership Form##ROWSPAN_3##
5. Ownership Form##ROWSPAN_3##", "6. Nature of Indirect Beneficial Ownership##ROWSPAN_4##
6. Nature of Indirect Beneficial Ownership##ROWSPAN_4##", ] SEC_COUNTRY_CODES = { 'B9': 'ANTIGUA AND BARBUDA', 'E9': 'CAYMAN ISLANDS', 'F4': 'CHINA', 'K3': 'HONG KONG', 'AL': 'ALABAMA', 'AK': 'ALASKA', 'AZ': 'ARIZONA', 'AR': 'ARKANSAS', 'CA': 'CALIFORNIA', 'CO': 'COLORADO', 'CT': 'CONNECTICUT', 'DE': 'DELAWARE', 'DC': 'DISTRICT OF COLUMBIA', 'FL': 'FLORIDA', 'GA': 'GEORGIA', 'HI': 'HAWAII', 'ID': 'IDAHO', 'IL': 'ILLINOIS', 'IN': 'INDIANA', 'IA': 'IOWA', 'KS': 'KANSAS', 'KY': 'KENTUCKY', 'LA': 'LOUISIANA', 'ME': 'MAINE', 'MD': 'MARYLAND', 'MA': 'MASSACHUSETTS', 'MI': 'MICHIGAN', 'MN': 'MINNESOTA', 'MS': 'MISSISSIPPI', 'MO': 'MISSOURI', 'MT': 'MONTANA', 'NE': 'NEBRASKA', 'NV': 'NEVADA', 'NH': 'NEW HAMPSHIRE', 'NJ': 'NEW JERSEY', 'NM': 'NEW MEXICO', 'NY': 'NEW YORK', 'NC': 'NORTH CAROLINA', 'ND': 'NORTH DAKOTA', 'OH': 'OHIO', 'OK': 'OKLAHOMA', 'OR': 'OREGON', 'PA': 'PENNSYLVANIA', 'RI': 'RHODE ISLAND', 'SC': 'SOUTH CAROLINA', 'SD': 'SOUTH DAKOTA', 'TN': 'TENNESSEE', 'TX': 'TEXAS', 'UT': 'UTAH', 'VT': 'VERMONT', 'VA': 'VIRGINIA', 'WA': 'WASHINGTON', 'WV': 'WEST VIRGINIA', 'WI': 'WISCONSIN', 'WY': 'WYOMING', 'A0': 'ALBERTA', 'A1': 'BRITISH COLUMBIA', 'A2': 'MANITOBA', 'A3': 'NEW BRUNSWICK', 'A4': 'NEWFOUNDLAND', 'A5': 'NOVA SCOTIA', 'A6': 'ONTARIO', 'A7': 'PRINCE EDWARD ISLAND', 'A8': 'QUEBEC', 'A9': 'SASKATCHEWAN', 'B0': 'YUKON TERRITORY', 'D4': 'GERMANY', 'G6': 'NETHERLANDS', 'H2': 'SWITZERLAND', 'L8': 'UNITED KINGDOM', 'Z4': 'ISRAEL' } ITEM_HEADING = re.compile( r'^\s*Item[\s\u00A0]+\d+[A-Za-z]?\.[^.]*\s*$', re.I ) SUBITEM_HEAD = re.compile(r'^\s*\([A-Za-z0-9]+\)\s+.+$') _sup_re = re.compile(r'(.*?)', re.I | re.S) PART_HEADING = re.compile(r'^\s*PART\s+[IVXLC]+\b.*\s*$', re.I) DOT_ROW = re.compile( r"""^\s* (?P		, parses it to a Markdown table, replaces all pipes '|' with '' and all newlines '\n' with '##MD_NEWLINE##', and then replaces the original div with this new single-line string. """ for div_table in soup.select('td > div[style*="display: table"]'): try: div_html = str(div_table) temp_soup = BeautifulSoup(div_html, 'lxml') if (table_tag := temp_soup.find('div', style=re.compile(r'display:\s*table'))): table_tag.name = 'table' for row in temp_soup.find_all('div', style=re.compile(r'display:\s*table-row')): row.name = 'tr' for cell in temp_soup.find_all('div', style=re.compile(r'display:\s*table-cell')): cell.name = 'td' df_list = pd.read_html(io.StringIO(str(temp_soup)), flavor="lxml", keep_default_na=False, header=0) if not df_list: continue df = df_list[0] df.dropna(how='all', axis=1, inplace=True) df.dropna(how='all', axis=0, inplace=True) df = df.reset_index(drop=True) if df.empty: continue md_table_string = to_compact_markdown(df, index=False) placeholder_string = md_table_string.replace('\n', '##MD_NEWLINE##').replace('|', '') div_table.replace_with(NavigableString(placeholder_string)) except Exception as e: print(f"[Warning] Could not process nested div-table. Removing it. Error: {e}") div_table.decompose() def parse_html_filing(html_content: str, form_type: str = "", file_path: Optional[pathlib.Path] = None) -> str: """ Parses HTML content into Markdown using an intelligent text assembly method. """ global LAST_POSITIONED_HTML_OCR_PAGE_COUNT LAST_POSITIONED_HTML_OCR_PAGE_COUNT = 0 start_time = time.time() time_limit_s = Config.HTML_TIMEOUT_LIMIT * 60 timed_out = False count = 0 r_tag_pattern = re.compile( r'(?:<|\\>)\s*/?\s*\bR\b\s*(?:>|\\<|<)', re.IGNORECASE ) html_content = r_tag_pattern.sub('', html_content) html_content = re.sub(r'', '', html_content, flags=re.IGNORECASE) indent_preservation_pattern = re.compile( r'((?: |\s)+)(<(?:b|strong|i|em|u)\b[^>]*>)', re.IGNORECASE ) html_content = indent_preservation_pattern.sub(r'\2\1', html_content) html_content = re.sub(r']*>', '##SUP##', html_content, flags=re.IGNORECASE) html_content = re.sub(r'', '##/SUP##', html_content, flags=re.IGNORECASE) html_content = re.sub(r']*>', '##SUB##', html_content, flags=re.IGNORECASE) html_content = re.sub(r'', '##/SUB##', html_content, flags=re.IGNORECASE) html_content = html_content.replace("|", r"\|").replace("
", "##NEWLINE##").replace("
", "##NEWLINE##") html_content = re.sub(r'', '', html_content, flags=re.DOTALL) html_content = fix_malformed_inline_paragraphs(html_content) u_tag_whitespace_pattern = re.compile( r'(]*>)(\s* \s*)()', re.IGNORECASE ) html_content = u_tag_whitespace_pattern.sub(r'\1##SPACE##\3', html_content) i_tag_whitespace_pattern = re.compile( r'(]*>)(\s* \s*)()', re.IGNORECASE ) html_content = i_tag_whitespace_pattern.sub(r'\1##I_SPACE##\3', html_content) try: soup = BeautifulSoup(html_content, "lxml") except ValueError as e: if "not enough values to unpack" in str(e): print(f"[Warning] lxml parser crashed on malformed attributes. Falling back to html.parser.") soup = BeautifulSoup(html_content, "html.parser") else: raise convert_nested_div_table_to_placeholders(soup) _flatten_redundant_nesting(soup) convert_margin_layout_to_table(soup) fix_inverted_bold_paragraphs(soup) if is_document_layout_positioned(soup): file_name = file_path.name if file_path else "unknown_file.html" print(f"--> Detected positioned layout for '{file_name}'. Routing to OCR-based parser.") return parse_html_via_pdf_render(html_content, file_name) final_markdown_from_ocr, is_fully_processed = parse_positioned_html_islands_via_ocr(soup) if is_fully_processed: print("--> Document fully processed by island parser. Bypassing standard HTML parsing.") return final_markdown_from_ocr, True convert_wingdings_boxes(soup) convert_vertical_align_superscripts(soup) convert_styled_inline_divs_to_spans(soup) soup = pre_fix_document_structure(soup) unwrap_fragmenting_tags(soup) for block_tag in soup.find_all(['div', 'p']): first_text_node = block_tag.find(string=True) if first_text_node and block_tag.get_text(strip=True).startswith(first_text_node.strip()): text = str(first_text_node) leading_ws_match = re.match(r'^([\s\u00A0\u2003]+)', text) if leading_ws_match: ws_string = leading_ws_match.group(1) indent_level = 0 for char in ws_string: if char in ['\u00A0', ' ']: indent_level += 0.5 elif char == '\u2003': indent_level += 2 final_indent_level = int(indent_level) if final_indent_level > 0: indent_prefix = '##INDENT##' * final_indent_level block_tag.insert(0, NavigableString(indent_prefix)) first_text_node.replace_with(text.lstrip(' \u00A0\u2003')) _normalize_list_indentation(soup) convert_styled_superscripts_to_placeholders(soup) promote_styled_headings(soup) _debug_print("→ stage 0 (raw):", len(soup.find_all("table"))) timeout_check = check_timeout(start_time, time_limit_s, "HTML pre-processing Stage 0-1") if timeout_check is not None: return timeout_check, True for text_node in soup.find_all(string=True): s = str(text_node) s = s.replace('\u00A0', ' ') for z in ['\u200B', '\u200C', '\u200D', '\u2060', '\u2063', '\uFEFF']: s = s.replace(z, '') text_node.replace_with(s) title_tag = soup.find('title') title_text = title_tag.text if title_tag else '' is_form4 = 'Form 4' in title_text or 'form 4' in html_content[:1000].lower() is_legacy = bool(soup.find(string=re.compile(r'statement of changes in beneficial ownership', re.I))) is_modern_xml = bool(soup.find('ownershipDocument')) def _style_declares_bold(style: str) -> bool: if not style: return False style_lc = style.lower() style_compact = style_lc.replace(' ', '') if any(token in style_compact for token in ( 'font-weight:bold', 'font-weight:700', 'font-weight:800', 'font-weight:900', )): return True font_decl_match = re.search(r'font\s*:\s*([^;]+)', style_lc) if font_decl_match and re.search(r'(^|[\s/])(?:bold|700|800|900)(?=$|[\s/])', font_decl_match.group(1)): return True return False for tr in soup.find_all('tr', style=True): row_style = tr.get('style', '') row_style_lc = row_style.lower().replace(' ', '') inherited_bits = [] if _style_declares_bold(row_style): inherited_bits.append('font-weight:bold') if 'font-style:italic' in row_style_lc: inherited_bits.append('font-style:italic') if 'text-decoration:underline' in row_style_lc: inherited_bits.append('text-decoration:underline') if not inherited_bits: continue for cell in tr.find_all(['td', 'th'], recursive=False): cell_style = cell.get('style', '') cell_style_lc = cell_style.lower().replace(' ', '') additions = [] for bit in inherited_bits: if bit.startswith('font-weight:'): if 'font-weight:' not in cell_style_lc: additions.append(bit) elif bit.startswith('font-style:'): if 'font-style:' not in cell_style_lc: additions.append(bit) elif bit.startswith('text-decoration:'): if 'text-decoration:' not in cell_style_lc: additions.append(bit) if additions: merged_style = cell_style.rstrip().rstrip(';') if merged_style: merged_style += '; ' merged_style += '; '.join(additions) cell['style'] = merged_style styled_tags = soup.find_all(['span', 'font', 'p', 'div', 'td', 'th'], style=True) for tag in styled_tags: raw_style_str = tag.get('style', '') style_str = raw_style_str.lower().replace(' ', '') is_bold = _style_declares_bold(raw_style_str) is_italic = 'font-style:italic' in style_str is_underline = 'text-decoration:underline' in style_str if not (is_bold or is_italic or is_underline): continue if is_bold and tag.find_parent(['b', 'strong']): is_bold = False if not (is_bold or is_italic or is_underline): if tag.name in ['span', 'font']: tag.unwrap() continue inner_content_holder = soup.new_tag('div') for child in list(tag.contents): inner_content_holder.append(child.extract()) if is_underline: new_u_tag = soup.new_tag('u') new_u_tag.extend(inner_content_holder.contents) inner_content_holder.clear() inner_content_holder.append(new_u_tag) if is_italic: new_i_tag = soup.new_tag('i') new_i_tag.extend(inner_content_holder.contents) inner_content_holder.clear() inner_content_holder.append(new_i_tag) if is_bold: new_b_tag = soup.new_tag('b') new_b_tag.extend(inner_content_holder.contents) inner_content_holder.clear() inner_content_holder.append(new_b_tag) tag.clear() tag.extend(inner_content_holder.contents) if tag.name in ['span', 'font']: tag.unwrap() merge_whitespace_tags(soup) remove_empty_bold_tags(soup) defragment_adjacent_tags(soup, ['b', 'strong']) defragment_adjacent_tags(soup, ['i', 'em']) defragment_adjacent_tags(soup, ['font']) process_inline_tags(soup, ['b', 'strong'], "BOLD") process_inline_tags(soup, ['i', 'em'], "ITALIC") process_inline_tags(soup, ['u'], "U") process_anchor_tags(soup) colspan_rowspan_tag(soup) _debug_print("→ stage 1 (after bold cleanup):", len(soup.find_all("table"))) timeout_check = check_timeout(start_time, time_limit_s, "HTML pre-processing Stage 1-2") if timeout_check is not None: return timeout_check, True xml_tags = soup.find_all(re.compile(r'^xml$', re.I)) if xml_tags: if soup.body is None or not soup.body.get_text(strip=True): return parse_any_xml([t.decode_contents() for t in xml_tags]) _debug_print("→ stage 2 (after wingdings):", len(soup.find_all("table"))) timeout_check = check_timeout(start_time, time_limit_s, "HTML pre-processing Stage 2-3") if timeout_check is not None: return timeout_check, True normalize_dl_lists(soup) protect_special_chars_in_tables(soup) _debug_print("→ stage 3 (after list-table→li):", len(soup.find_all("table"))) timeout_check = check_timeout(start_time, time_limit_s, "HTML pre-processing Stage 3-4") if timeout_check is not None: return timeout_check, True for tag in soup.find_all(["xml", "script", "style", "ix:header", "ix:resources"]): tag.decompose() _debug_print("→ stage 4 (after xml/script/style/ix):", len(soup.find_all("table"))) timeout_check = check_timeout(start_time, time_limit_s, "HTML pre-processing Stage 4-5") if timeout_check is not None: return timeout_check, True for tag in soup.find_all(attrs={"style": re.compile(r'display:\s*none', re.I)}): tag.decompose() _debug_print("→ stage 5 (after display:none):", len(soup.find_all("table"))) timeout_check = check_timeout(start_time, time_limit_s, "HTML pre-processing Stage (final)") if timeout_check is not None: return timeout_check, True total_tables = len(soup.find_all("table")) next_milestone_pct = 10 for img in soup.find_all("img"): src = img.get("src", "").strip() if not src: img.decompose() continue alt = img.get("alt", "").strip() img.replace_with(NavigableString(f"![{alt}]({src})")) sections_md, text_buf = [], [] BLOCK_TAGS = {"p", "div"} HEADING_TAGS = {"h1", "h2", "h3", "h4", "h5", "h6"} pending: List[str] = [] last_emitted = None def _emit_pending(): nonlocal last_emitted if pending: unique_pending = [p for p in pending if p.lstrip().rstrip() != last_emitted] sections_md.extend(unique_pending) if unique_pending: last_emitted = unique_pending[-1].lstrip().rstrip() pending.clear() def flush(prefix: str = ""): raw_text = "".join(text_buf) txt = re.sub(r'\s+', ' ', raw_text).strip() if txt: _emit_pending() final_text = re.sub(r'##SUP##(.*?)##/SUP##', r'\1', txt) if final_text.startswith(('http://', 'https://')): sections_md.append(prefix + final_text + "\n\n") else: sections_md.append(prefix + final_text + "\n\n") text_buf.clear() def queue(level: int, cand: str, el): tag = f"\n{'#' * level} {cand}\n" if not pending or pending[-1] != tag: pending.append(tag) el.clear() body_tag = soup.body body = body_tag if body_tag and body_tag.find(True): body = body_tag else: body = soup is_13f_filing = "13F" in form_type.upper() for elem in body.descendants: if time.time() - start_time > time_limit_s: print(f"[timeout] HTML parsing exceeded {time_limit_s // 60} minutes. Stopping.") timed_out = True break if elem.name == 'p' and elem.has_attr('style'): style = elem.get('style', '').lower() if 'border-bottom' in style and not elem.get_text(strip=True): flush() sections_md.append("\n\n------\n\n") elem.clear() continue if elem.name == 'div': style = elem.get('style', '').lower() if 'page-break-after: always' in style and not elem.get_text(strip=True): flush() sections_md.append("\n\n------\n\n") elem.clear() continue if elem.name in HEADING_TAGS: flush() raw_cand = elem.get_text(separator=' ', strip=True) cand = re.sub(r'\s+', ' ', raw_cand).strip() if cand and cand != last_emitted: lvl = int(elem.name[1]) tag = f"\n{'#' * lvl} {cand}\n" sections_md.append(tag) last_emitted = cand elem.clear() continue if elem.name == "li": flush() li_text = elem.get_text() if li_text: if li_text.lstrip().startswith(tuple(BULLET_CHARS)): sections_md.append("\n" + li_text) else: sections_md.append("* " + li_text) sections_md.append("\n\n") elem.clear() continue if elem.name in BLOCK_TAGS or elem.name == "br": flush() continue if elem.name == "hr": flush() sections_md.append("\n\n------\n\n") elem.clear() continue if elem.name == "pre": flush() pre_text = elem.get_text() if pre_text: sections_md.append(pre_text) elem.clear() continue if elem.name == "table": count += 1 current_pct = (count / total_tables) * 100 if current_pct >= next_milestone_pct and total_tables > 10: milestone_to_print = int(next_milestone_pct) print(f"-> Processing tables... {milestone_to_print}% complete ({count} of {total_tables})") next_milestone_pct += 10.0 flush() if handle_width_indented_list_table(elem, sections_md): elem.clear() continue if handle_list_like_table_with_indentation(elem, sections_md): elem.clear() continue if handle_sentence_fragment_table(elem, sections_md): elem.clear() continue tag_border_cells(elem, soup) DEFAULT_FONT_SIZE_PT = 10.0 STANDARD_INDENT_EM = 1.2 for cell in elem.find_all(['td', 'th']): elements_to_check = [cell] + cell.find_all(['p', 'div', 'font']) max_indent_pt = 0.0 font_size_pt = None for el in elements_to_check: indent_info = _calculate_effective_indent(el) if indent_info['indent'] > max_indent_pt: max_indent_pt = indent_info['indent'] if indent_info['font_size']: font_size_pt = indent_info['font_size'] if font_size_pt is None: for el in elements_to_check: indent_info = _calculate_effective_indent(el) if indent_info['font_size']: font_size_pt = indent_info['font_size'] break effective_font_size = font_size_pt or DEFAULT_FONT_SIZE_PT if max_indent_pt > 0 and effective_font_size > 0: indent_em = max_indent_pt / effective_font_size ratio = indent_em / STANDARD_INDENT_EM quantized_level = round(ratio * 4) / 4 full_indents = int(quantized_level) remainder = quantized_level - full_indents indent_prefix = "" if full_indents > 0: indent_prefix += '##INDENT##' * full_indents if remainder >= 0.75: indent_prefix += '   ' elif remainder >= 0.5: indent_prefix += '  ' if indent_prefix: cell.insert(0, NavigableString(indent_prefix)) table_text = elem.get_text(separator=' ', strip=True) if ITEM_HEADING.match(table_text): queue(3, table_text, elem) continue for cell in elem.find_all(['td', 'th']): indent_level = 0 text_indent_level = 0 elements_to_check = [cell] + cell.find_all(['div', 'p'], recursive=False) for el in elements_to_check: style = el.get('style', '') if not style: continue pad_match = re.search(r'padding-left\s*:\s*([\d\.]+)(pt|px|em)', style) margin_match = re.search(r'margin-left\s*:\s*([\d\.]+)(pt|px|em)', style) total_offset_pt = 0.0 if pad_match: val, unit = float(pad_match.group(1)), pad_match.group(2) if unit == 'em': total_offset_pt += val * 10.0 elif unit == 'px': total_offset_pt += val * 0.75 else: total_offset_pt += val if margin_match: val, unit = float(margin_match.group(1)), margin_match.group(2) if unit == 'em': total_offset_pt += val * 10.0 elif unit == 'px': total_offset_pt += val * 0.75 else: total_offset_pt += val if total_offset_pt > 0: level = int(round(total_offset_pt / 5.0)) if level > 0: indent_level = level break first_visible_text = None for descendant in cell.descendants: if not isinstance(descendant, NavigableString): continue descendant_text = str(descendant) if descendant_text.strip(' \t\r\n\u00A0\u2003'): first_visible_text = descendant_text break if first_visible_text: leading_ws_match = re.match(r'^([\s\u00A0\u2003]+)', first_visible_text) if leading_ws_match: ws_string = leading_ws_match.group(1) ws_string = re.sub(r'[\r\n]+[ \t\f\v]*', '', ws_string) indent_units = 0.0 for char in ws_string: if char in ['\u00A0', ' ']: indent_units += 0.5 elif char == '\u2003': indent_units += 2.0 text_indent_level = int(indent_units) indent_level = max(indent_level, text_indent_level) for br in cell.find_all('br'): br.replace_with('##NEWLINE##') for p in cell.find_all(['p', 'div']): p.append('##NEWLINE##') cell_text = re.sub(r'(?<=[A-Za-z0-9])-\s+', '- ', cell.get_text(strip=False).replace("**", "").replace("** ", "")) if text_indent_level > 0: cell_text = re.sub(r'^[\s\u00A0\u2003]+', '', cell_text) if cell_text.strip() == "##NEWLINE##": cell_text = "" IND = "\u2063" if text_indent_level > 0 and not re.match(r'^(?:##INDENT##| )+', cell_text): cell_text = ('##INDENT##' * text_indent_level) + cell_text elif indent_level > 0: cell_text = IND * indent_level + cell_text cell.clear() cell.string = cell_text for cell in elem.find_all(['td', 'th']): if cell.get('colspan'): try: if int(cell['colspan']) > 500: del cell['colspan'] except (ValueError, TypeError): del cell['colspan'] for tr in elem.find_all('tr'): if not tr.find(['td', 'th']): tr.decompose() table_html = str(elem) table_html = protect_numeric_list_items(table_html) table_html = _fix_escaped_malformed_font_tag(table_html) try: df_from_html = pd.read_html(io.StringIO(table_html), flavor="lxml", keep_default_na=False, na_values=[""])[0] df_from_html.replace(to_replace=r'##PROTECT_(.*?)##', value=r'\1', regex=True, inplace=True) df_from_html = df_from_html.replace({'##VISUAL_BORDER##': ''}, regex=False) first_real_row_idx = 0 for i, row in df_from_html.iterrows(): is_junk = all( str(cell).strip() in ('', 'nan', '', '', 'NaN') or 'spacer.gif' in str(cell) for cell in row ) if not is_junk: first_real_row_idx = i break raw_df = df_from_html.iloc[first_real_row_idx:].reset_index(drop=True) raw_df = raw_df.replace(r'^\s*(?: )?\s*$', np.nan, regex=True) raw_df = (raw_df .dropna(how='all') .dropna(how='all', axis=1) .reset_index(drop=True)) if not raw_df.empty: for r in range(1, len(raw_df)): for c in range(len(raw_df.columns)): if isinstance(raw_df.iat[r, c], str) and '' in raw_df.iat[r, c]: above_cell = raw_df.iat[r - 1, c] if pd.isna(above_cell): raw_df.iat[r - 1, c] = '' else: raw_df.iat[r - 1, c] = str(above_cell) + '' raw_df = raw_df.replace({r'': '', r'': ''}, regex=True) sup_replacer = lambda x: re.sub(r'##SUP##(.*?)##/SUP##', r'\1', str(x)) if '##SUP##' in str(x) else x raw_df = raw_df.applymap(sup_replacer) raw_df = drop_tag_only_rows_cols(raw_df).reset_index(drop=True) raw_df = ( raw_df .replace(r' -(?=[A-Za-z])', ' - ', regex=True) .replace(r'\s{2,}', ' ', regex=True) ) def normalize_for_comparison(val): if isinstance(val, str): text = val.replace('\u2063', '').replace('\u00A0', '') return re.sub(r'\s+', ' ', text).strip() return val if not raw_df.empty and raw_df.shape[1] > 1: cols_to_clean = raw_df.columns[1:] raw_df[cols_to_clean] = raw_df[cols_to_clean].applymap(normalize_for_comparison) table_text = re.sub(r'##(BOLD_START_\d+|BOLD_END_\d+|U_START_\d+|U_END_\d+|ITALIC_START_\d+|ITALIC_END_\d+|ROWSPAN_\d+|COLSPAN_\d+|LINK_START_\d+__[^#]+|LINK_END_\d+)##', '', table_text) table_text = table_text.replace('##NEWLINE##', '').replace('
', '').strip() positives = ( (('$' in table_text or '£' in table_text or '�' in table_text or " ) " in table_text) and re.search(r'\d', table_text)) or ('%' in table_text or re.search(r'\([\d,]+\)', table_text)) or (len(table_text) > 300 and re.search(r'\d', table_text) and "Part I" not in table_text and "Name of each exchange on which registered" not in table_text and "ITEM 1" not in table_text) or any(k in table_text for k in ["Common stock", "Total", "By:", "Earnings", "##SUP", "##SUB", "marketing", "Period Ended", "Months Ended", "For Against"]) or ((raw_df == ')').any().any()) ) exclusions = any(k in table_text for k in ["Emerging growth company", "Smaller reporting company", "[One-month LIBOR +] __%", "⌧"]) is_financial_table = positives and not exclusions if is_financial_table and not is_13f_filing and not (is_form4 and is_legacy): df_to_render = clean_financial_df(raw_df) else: df_to_render = raw_df if "OO" in table_text and "CHECK" in table_text: df_to_render = drop_active_colspan_empty_cols(df_to_render) md = df_to_markdown(df_to_render, disable_numparse=True, is_legacy_form4_table1=((is_form4 and is_legacy and "Table I" in df_to_render.to_string())), is_legacy_form4_table2=(is_form4 and is_legacy and "Table II" in df_to_render.to_string())) if md and not md.isspace(): _emit_pending() if "|:-" in md: sections_md.append(f"\n---\n\n{md}\n\n---\n") else: sections_md.append(f"{md}\n\n") except (ValueError, IndexError): fallback_text = elem.get_text(separator=' ', strip=False) if fallback_text: _emit_pending() sections_md.append(textwrap.fill(fallback_text) + "\n") elem.clear() continue if isinstance(elem, NavigableString): if not elem.find_parent(HEADING_TAGS.union({"li", "table", "script", "style"})): text_buf.append(str(elem)) flush() pending.clear() md = "".join(sections_md) md = re.sub( r"EX-[\d\.]+\s+\d+\s+[\w\.]+\.htm\s+EX-[\d\.]+\s+Document\s+" r"created\s+using\s+Wdesk.*?Document", "", md, flags=re.I, ) md = re.sub(r'\n{3,}', '\n\n', md).strip() if timed_out: return md + "\n\n", False else: return md, False def clean_phone_numbers(text: str) -> str: """ Removes newlines from within phone numbers and unifies formatting by removing any Markdown bold tags from the number components. """ if not isinstance(text, str): return text phone_pattern = re.compile(r""" \*{0,2} ( \(\s*\d{3}\s*\) ) \*{0,2} \s*\n\s* \*{0,2} ( \d{3}\s*[-]?\s*\d{4} ) \*{0,2} """, re.VERBOSE) return phone_pattern.sub(r"\1 \2", text) BULLETS = "○•●·◦➢▪" BOLD_SPLIT_RE = re.compile(r'\*\* +') def _fix_paragraph_bold_runs(txt: str) -> str: out, last = [], 0 for m in BOLD_SPLIT_RE.finditer(txt): i = m.start() window = txt[max(0, i-150):i] if window.count("**") >= 2: continue if re.search(rf"[{BULLETS}]\s*\*\*\s*$", window): continue out.append(txt[last:i].rstrip()) out.append("\n\n**") last = m.end() out.append(txt[last:]) return "".join(out) def _convert_bullet_tables_to_lists(markdown_content: str) -> str: """ Finds and converts two-column Markdown tables that are used to format bulleted lists into proper list items. e.g., | • | Some text... | -> • Some text... """ table_pattern = re.compile(r'\n---\n\n(.*?)\n\n---\n', re.S) bullet_chars = {'○', '•', '●', '*', '·', '◦', '➢', '▪'} def replacer(match): md_table_str = match.group(1) lines = md_table_str.strip().split('\n') if len(lines) < 3: return match.group(0) header_cells = [cell.strip() for cell in lines[0].strip('|').split('|')] if any(header_cells): return match.group(0) separator_cells = [cell.strip() for cell in lines[1].strip('|').split('|')] if len(separator_cells) != 2: return match.group(0) list_items = [] is_bullet_table = True for line in lines[2:]: data_cells = [cell.strip() for cell in line.strip('|').split('|')] if len(data_cells) != 2: is_bullet_table = False break bullet_part = data_cells[0] text_part = data_cells[1] if bullet_part not in bullet_chars: is_bullet_table = False break list_items.append(f"{bullet_part} {text_part}") if is_bullet_table and list_items: return "\n".join(list_items) return match.group(0) return table_pattern.sub(replacer, markdown_content) def _format_footnote_lists(markdown_content: str) -> str: """ Finds and formats footnotes that appear either as two-column tables or as simple numbered lines, converting the number into a superscript. """ table_pattern = re.compile(r'\n---\n\n(.*?)\n\n---\n', re.S) def table_replacer(match): md_table_str = match.group(1) lines = md_table_str.strip().split('\n') if len(lines) != 3: return match.group(0) if any(cell.strip() for cell in lines[0].strip('|').split('|')): return match.group(0) if len(lines[1].strip('|').split('|')) != 2: return match.group(0) data_cells = [cell.strip() for cell in lines[2].strip('|').split('|')] if len(data_cells) != 2: return match.group(0) number_part, text_part = data_cells num_match = re.fullmatch(r'(?:)?\s*(\d{1,2})\s*(?:)?', number_part) if num_match and text_part: num_str = num_match.group(1) return f"{num_str} {text_part}" return match.group(0) content = table_pattern.sub(table_replacer, markdown_content) footnote_line_pattern = re.compile(r'^(\d{1,2})\.\s+(?=[A-Z])', re.MULTILINE) content = footnote_line_pattern.sub(r'\1 ', content) return content def _remove_page_numbers(markdown_content: str) -> str: """ Removes page numbers from the document by targeting three patterns: 1. Standalone integers on a line by themselves (e.g., "1", "A-1"). 2. Standalone integers surrounded by hyphens (e.g., "-1-"). 3. The above patterns when they are the sole content of a single-cell Markdown table. The number must be less than 500 to be considered a page number. This version also collapses the extra newlines left by the removal. """ pattern_standalone = re.compile( r"(\n{2,}|^)" r"(?:)?" r"[ \t]*" r"(?:" r"(?:[A-Z]+-)?(\d{1,3})(?:\.)?" r"|" r"-\s*(\d{1,3})\s*-" r"|" r"page\s+(\d{1,3})(?:\.)?" r")" r"[ \t]*" r"(\n{2,}|$)", re.MULTILINE | re.IGNORECASE ) def replacer_standalone(m): try: num_str = m.group(2) or m.group(3) or m.group(4) page_num = int(num_str) if page_num < 500: return "\n\n" except (ValueError, TypeError, IndexError): pass return m.group(0) content = pattern_standalone.sub(replacer_standalone, markdown_content) pattern_table = re.compile(r'\n---\n\n(.*?)\n\n---\n', re.S) def replacer_table(match): """Callback to check if a table block is just a page number.""" table_content = match.group(1).strip() lines = table_content.split('\n') if len(lines) == 3: data_row = lines[2].strip() cell_match = re.fullmatch( r'\|\s*(?:(?:[A-Z]+-)?(\d{1,3})(?:\.)?|-\s*(\d{1,3})\s*-)\s*\|', data_row ) if cell_match: try: num_str = cell_match.group(1) or cell_match.group(2) page_num = int(num_str) if page_num < 500: return "\n\n" except (ValueError, TypeError, IndexError): pass return match.group(0) content = pattern_table.sub(replacer_table, content) return re.sub(r'\n{3,}', '\n\n', content) BULLET_BOLD_SPLIT_RE = re.compile( rf"""(?x) (^[^\n]{{0,150}}) # 1) a look-back window ≤150 chars, captured \n+ # 2) the offending newline(s) (\*\*[A-Za-z]) # 3) "**S" (opening bold + letter) """, re.M, ) def merge_adjacent_italics(s: str) -> str: pair = re.compile(r"##ITALIC_END_(\d+)####ITALIC_START_(\d+)##") while True: m = pair.search(s) if not m: break a, b = m.group(1), m.group(2) start_tag = f"##ITALIC_START_{a}##" idx = s.rfind(start_tag, 0, m.start()) before, after = s[:m.start()], s[m.end():] if idx != -1: before = before[:idx] + f"##ITALIC_START_{b}##" + before[idx + len(start_tag):] if before and after and not before[-1].isspace() and not after[0].isspace(): s = before + " " + after else: s = before + after return s def merge_bracket_fragmented_underlines(s: str) -> str: """ Repairs underline placeholder runs that split bracketed text into adjacent fragments, e.g.: ##U_START_a##[##U_END_a####U_START_b##Reserved##U_END_b## -> ##U_START_b##[Reserved##U_END_b## and the symmetric closing-bracket case. """ while True: updated = s updated = re.sub( r'##U_START_(\d+)##\[\s*##U_END_\1##\s*##U_START_(\d+)##(.*?)##U_END_\2##', r'##U_START_\2##[\3##U_END_\2##', updated, ) updated = re.sub( r'##U_START_(\d+)##(.*?)##U_END_\1##\s*##U_START_(\d+)##\]\s*##U_END_\3##', r'##U_START_\1##\2]##U_END_\1##', updated, ) if updated == s: break s = updated return s def collapse_redundant_bold_placeholders(s: str) -> str: """ Collapses duplicated bold placeholder wrappers before they are restored to literal markdown asterisks. This is intentionally done at the placeholder stage so escaped literal asterisks in the source document are not touched. """ while True: updated = s updated = re.sub( r"##BOLD_START_\d+##" r"((?:##(?:BOLD|ITALIC|U)_(?:START|END)_\d+##|\s)*)" r"(##BOLD_START_(\d+)##.*?##BOLD_END_\3##)" r"((?:##(?:BOLD|ITALIC|U)_(?:START|END)_\d+##|\s)*)" r"##BOLD_END_\d+##", r"\1\2\4", updated, flags=re.DOTALL, ) updated = re.sub( r"##BOLD_START_\d+##(?=(?:\s|##NEWLINE##)*##BOLD_START_\d+##)", "", updated, ) updated = re.sub( r"(##BOLD_END_\d+##)(?:\s|##NEWLINE##)*##BOLD_END_\d+##", r"\1", updated, ) if updated == s: break s = updated return s def _post_process_text_cleanup(markdown_text: str, legacy_form4 = False) -> str: """ Final-stage clean-up for Markdown pulled from iXBRL/EDGAR filings. Returns a tidy Markdown string with: • mojibake fixed • hidden metadata lines removed • common word-splits repaired • normalised spacing & punctuation """ if not markdown_text: return "" pattern = re.compile(r'(##BOLD_START_\d+##)(\s+)##BOLD_START_(\d+)##\((##BOLD_END_\3##)') replacement = r'\2\1(' markdown_text = pattern.sub(replacement, markdown_text) pattern = re.compile( r'(##BOLD_START_(\d+)##)' r'##BOLD_START_(\d+)##' r'(\)?%|\))' r'##BOLD_END_\3##' r'##BOLD_END_\2##' ) replacement = r'\1\4##BOLD_END_\2##' markdown_text = pattern.sub(replacement, markdown_text) markdown_text = markdown_text.replace("", "").replace("##SUP####/SUP##", "").replace("syste m,", "system,") pattern = r"(##BOLD_START_\d+##)\n\n" replacement = r"\n\n\1" markdown_text = re.sub(pattern, replacement, markdown_text) pattern = re.compile(r'\s+(##(?:BOLD|ITALIC|U)_END_\d+##)\s+([,.:;!?])') markdown_text = pattern.sub(r'\1\2', markdown_text) markdown_text = re.sub( r"##BOLD_START_\d+##(?:##(?:BOLD|ITALIC)_(?:START|END)_\d+##)*(##BOLD_START_(\d+)##.*?##BOLD_END_\2##)(?:##(?:BOLD|ITALIC)_(?:START|END)_\d+##)*##BOLD_END_\d+##", r"\1", markdown_text, flags=re.DOTALL) markdown_text = re.sub( r"##ITALIC_START_\d+##(?:##(?:BOLD|ITALIC)_(?:START|END)_\d+##)*(##ITALIC_START_(\d+)##.*?##ITALIC_END_\2##)(?:##(?:BOLD|ITALIC)_(?:START|END)_\d+##)*##ITALIC_END_\d+##", r"\1", markdown_text, flags=re.DOTALL) markdown_text = re.sub(r"##BOLD_START_\d+##(##BOLD_START_\d+##)", r"\1", markdown_text) markdown_text = re.sub(r"(##BOLD_END_\d+##)##BOLD_END_\d+##", r"\1", markdown_text) markdown_text = re.sub(r"##ITALIC_START_\d+##(##ITALIC_START_\d+##)", r"\1", markdown_text) markdown_text = re.sub(r"(##ITALIC_END_\d+##)##ITALIC_END_\d+##", r"\1", markdown_text) markdown_text = markdown_text.replace(" ", " ").replace(" ", " ").replace(" ", " ") markdown_text = re.sub( r'##NEWLINE##(?=(##BOLD_START_\d+##\)##BOLD_END_\d+##))', r'', markdown_text ) markdown_text = merge_adjacent_italics(markdown_text) markdown_text = re.sub(r"##ITALIC_START_\d+##([○•●·◦➢])##ITALIC_END_\d+####ITALIC_START_(\d+)##", r"##ITALIC_START_\2##\1", markdown_text) pattern = r"(##BOLD_START_(\d+)####NEWLINE##)" replacement = r"##NEWLINE####BOLD_START_\2##" markdown_text = markdown_text.replace("##NEWLINE##", "").replace("##NEWLINE##", "") _SWAP = re.compile(r'##NEWLINE##\s*((?:##(?:ITALIC|BOLD|U)_END_\d+##\s*)+)') markdown_text = _SWAP.sub(r'\1##NEWLINE## ', markdown_text) wrap_start = r'(?:##(?:ITALIC|BOLD)_START_\d+##)*' wrap_end = r'(?:##(?:ITALIC|BOLD)_END_\d+##)*' roman_dot = r'(?i:[ivxlcdm]+)\.' indent = r'(?:##INDENT##)*' pair_paren = r'\([a-zA-Z]\)\([a-zA-Z]\)' marker_core = rf'(?:{pair_paren}|\*|\•|\d+\.\d[\d\.]*|\d+\.(?!\d)|\([a-zA-Z]\)|\((?i:[ivxlcdm]+)\)|\(\d+\)|{roman_dot}|[a-zA-Z]\.)' marker = rf'{indent}{marker_core}' pattern = re.compile( rf'(?m)^({wrap_start}{marker}{wrap_end})[ \t]*\r?\n(?:[ \t]*\r?\n)*(?=\S)' ) markdown_text = pattern.sub(r'\1 ', markdown_text) pattern = re.compile( r'##BOLD_END_(\d+)##(?: )?' r'##BOLD_START_\d+##' r'(.*?)' r'##BOLD_END_\d+##', re.DOTALL ) markdown_text = pattern.sub(r'\2##BOLD_END_\1##', markdown_text) pattern = re.compile( r'##BOLD_END_(\d+)##(?: )?' r'##SUB####BOLD_START_\d+##' r'(.*?)' r'##BOLD_END_\d+####/SUB##', re.DOTALL ) markdown_text = pattern.sub(r'##SUB##\2##/SUB####BOLD_END_\1##', markdown_text) markdown_text = re.sub(r'(##BOLD_START_\d+##•##BOLD_END_\d+##) (##BOLD_START_\d+##•##BOLD_END_\d+##)(\s?)', r'\1\n\n\2\3', markdown_text) markdown_text = re.sub( r'##BOLD_START_(\d+)##\s*\(\s*##BOLD_END_\1##\s*##BOLD_START_(\d+)##(.*?)##BOLD_END_\2##', r'##BOLD_START_\2##(\3##BOLD_END_\2##', markdown_text ) markdown_text = re.sub( r'##BOLD_END_(\d+)##(?:##NEWLINE##\s*)?\s*##BOLD_START_\d+##(\s?(?:\)%|\)|%|,))(\s*)##BOLD_END_\d+##', r'\2\3##BOLD_END_\1##', markdown_text, ) markdown_text = re.sub(r' (##(?:BOLD|U|ITALIC)_END_\d+##)', r'\1 ', markdown_text) markdown_text = re.sub(r'(?m)^•(?=\S)', '• ', markdown_text) markdown_text = re.sub( r'\.##BOLD_END_(\d+)####U_START', r'.##BOLD_END_\1## ##U_START', markdown_text ) markdown_text = re.sub(r'##ITALIC_START_(\d+)####I_SPACE####ITALIC_END_\1##', ' ', markdown_text) markdown_text = re.sub(r'(##ITALIC_START_\d+##)(##I_SPACE##)', r'\2\1', markdown_text) markdown_text = re.sub(r'(##I_SPACE##)(##ITALIC_END_\d+##)', r'\2\1', markdown_text) markdown_text = re.sub(r'(\d{1,2}\.\d+[A-Z]?\.?)(##ITALIC_START_\d+##)', r'\1 \2', markdown_text) markdown_text = re.sub( r'((?:##(?:BOLD|ITALIC|U)_END_\d+##[^\S\r\n]*)+)(?=\S)', lambda m: re.sub(r'[^\S\r\n]+', '', m.group(1)) + (' ' if re.search(r'[^\S\r\n]', m.group(1)) else ''), markdown_text ) markdown_text = re.sub( r'(##(?:BOLD|ITALIC|U)_START_\d+##)\s', r' \1', markdown_text ) markdown_text = markdown_text.replace("\u00a0", " ") mojibake = { "â\x80\x94": "—", "â\x80\x93": "–", "â\x80\x99": "'", "â\x80\x98": "'", "â\x80\x9c": '"', "â\x80\x9d": '"', "â\x80¦": "...", "â�™": "'", "â�œ": '"', "â�d": '"', "â� ": '"', "â�”": "—", "â�“": "–", "â�‰": " ", "â�¦": "...", "”": '"', "“": '"', "’": "'", "‘": "'", } for bad, good in mojibake.items(): markdown_text = markdown_text.replace(bad, good) markdown_text = clean_phone_numbers(markdown_text) junk_patterns = [ re.compile(r'^\s*(?:<\??\s*)?xml\s+version\s*=\s*[\'"]\s*1\.0\s*[\'"].*$', re.IGNORECASE | re.MULTILINE), re.compile( r"^\s*\*{0,2}000\d{7}[^\n]*(?:Q[1-4]|FY|10-K|10-Q)[^\n]*false\*{0,2}\s*$", re.IGNORECASE | re.MULTILINE, ), re.compile(r"^.*XBRL Document Created with.*$", re.MULTILINE), re.compile(r'^.*(?:Created by|Powered by|Unique Code|Generated At).*$', re.IGNORECASE | re.MULTILINE), re.compile(r"^false\d{4}FY\d+.*http://fasb\.org.*$", re.IGNORECASE | re.MULTILINE), re.compile( r"^(?!\s*\|).*\[(?:Member|Axis|Domain|Line Items|Abstract|Table|Text Block|" r"Policy Text Block|Extensible Enumeration|Flag|Roll Forward)\].*$", re.IGNORECASE | re.MULTILINE, ), ] for pat in junk_patterns: markdown_text = pat.sub("", markdown_text) split_fixes = { r"##NEWLINE##": "
" } for bad_re, good in split_fixes.items(): markdown_text = re.sub(bad_re, good, markdown_text, flags=re.IGNORECASE) markdown_text = re.sub(r'(
[ \t]*){2,}', '
', markdown_text, flags=re.IGNORECASE) table_pattern = re.compile(r'\n---\n\n(.*?)\n\n---\n', re.S) def remove_empty_tables_replacer(match): table_content = match.group(1) content_check = re.sub(r'[|\-:\s—–]', '', table_content) if not content_check: return '' return match.group(0) markdown_text = table_pattern.sub(remove_empty_tables_replacer, markdown_text) markdown_text = re.sub( r'(##BOLD_END_\d+##)' r'((?:
|##NEWLINE##|##COLSPAN_\d+##|\s)*)' r'(##BOLD_START_\d+##)' r'(\)?%|\))' r'(##BOLD_END_\d+##)', r' \4\1\2', markdown_text ) markdown_text = re.sub(r"[ \t]+", " ", markdown_text) markdown_text = re.sub(r"\n{3,}", "\n\n", markdown_text) markdown_text = re.sub(r"(?)", ")").replace("
%", "%").replace("$
", "$").replace("##BOL
D", "##BOLD") link_pattern = re.compile(r'^\s*link\d+\s+".*?"\s*\n?', re.MULTILINE) markdown_text = link_pattern.sub("", markdown_text) markdown_text = markdown_text.replace("•
", "• ").replace("●
", "● ").replace("·
", "· ").replace("◦
", "◦ ").replace("➢
", "➢ ") BULLET_RUN_RE = re.compile( r'((?:^|(?:##INDENT##)+)\s*[○•●·◦➢▪])' r'(?:\s*(?:
\s*|\n\s*)){2,}', re.MULTILINE ) markdown_text = BULLET_RUN_RE.sub(r'\1 ', markdown_text) markdown_text = _fix_paragraph_bold_runs(markdown_text) CHECK_RUN_RE = re.compile( r'([✓✔✘])' r'(?:\s*
\s*|\s*\n\s*)+' ) markdown_text = CHECK_RUN_RE.sub(r'\1 ', markdown_text) markdown_text = re.sub( r'(##BOLD_START_\d+##TABLE OF CONTENTS##BOLD_END_\d+##)|\bTABLE OF CONTENTS\b', lambda m: m.group(1) or '**TABLE OF CONTENTS**', markdown_text, ) markdown_text = markdown_text.replace("##SUP##", "").replace("##/SUP##", "").replace("##SUP##", "").replace("##/SUP##", "") markdown_text = markdown_text.replace("##SUB##", "").replace("##/SUB##", "").replace("##SUB##", "").replace("##/SUB##", "") markdown_text = re.sub(r'##BOLD_START_\d+##(?=\s*
##BOLD_START)', '', markdown_text) markdown_text = re.sub(r'(##BOLD_END_\d+##)(##BOLD_START_\d+##)', r'\1 \2', markdown_text) markdown_text = re.sub(r'(\d+)\s+(%##BOLD_END_)', r'\1\2', markdown_text) markdown_text = re.sub(r'(##BOLD_START_\d+##)\s+', r' \1', markdown_text) markdown_text = re.sub(r'\s+(##BOLD_END_\d+##)', r'\1', markdown_text) markdown_text = collapse_redundant_bold_placeholders(markdown_text) markdown_text = re.sub(r'(?<=\S)##BOLD_START_\d+##', r'**', markdown_text) markdown_text = re.sub(r'##BOLD_START_\d+##', r'**', markdown_text) markdown_text = re.sub(r'##BOLD_END_\d+##(?=\S)', r'**', markdown_text) markdown_text = re.sub(r'##BOLD_END_\d+##', r'**', markdown_text) markdown_text = re.sub(r'(##ITALIC_START_\d+##)\s+', r'\1', markdown_text) markdown_text = re.sub(r'\s+(##ITALIC_END_\d+##)', r'\1', markdown_text) markdown_text = re.sub(r'(?<=\S)##ITALIC_START_\d+##', r'*', markdown_text) markdown_text = re.sub(r'##ITALIC_START_\d+##', r'*', markdown_text) markdown_text = re.sub(r'##ITALIC_END_\d+##(?=\S)', r'*', markdown_text) markdown_text = re.sub(r'##ITALIC_END_\d+##', r'*', markdown_text) markdown_text = merge_bracket_fragmented_underlines(markdown_text) markdown_text = re.sub(r'(##U_START_\d+##)\s+', r'\1', markdown_text) markdown_text = re.sub(r'\s+(##U_END_\d+##)', r'\1', markdown_text) markdown_text = re.sub(r'(?<=\S)##U_START_\d+##', r'', markdown_text) markdown_text = re.sub(r'##U_START_\d+##', r'', markdown_text) markdown_text = re.sub(r'##U_END_\d+##(?=\S)', r'', markdown_text) markdown_text = re.sub(r'##U_END_\d+##', r'', markdown_text) markdown_text = _restore_markdown_links(markdown_text) markdown_text = markdown_text.replace("$ **", "**$").replace("**
**)**", ")**") pattern = r'^(Table of Contents)\s*•\s*(.+)$' replacement = r'\1\n\n• \2' markdown_text = re.sub(pattern, replacement, markdown_text, flags=re.IGNORECASE | re.MULTILINE) markdown_text = re.sub(r'(?", "_").replace(" _", "_") pattern = r'Unnamed:\s*\d+(?:_level_\d+)?\s' markdown_text = re.sub(pattern, '', markdown_text) markdown_text = re.sub(r"\.\d+", "", markdown_text) markdown_text = re.sub(r"
\.\d+(?![%\d])", "", markdown_text) markdown_text = markdown_text.replace("", "") if legacy_form4: bad_table2_row2 = "| 1. Title of Derivative Security
(Instr. 3)
| 2. Conver-
sion or
Exercise
Price of
Deri-
vative
Security
| 3. Transaction Date
(Month/
Day/
Year)
| 3A. Deemed Execution Date, if any
(Month/
Day/
Year)
| Code
| V
A
D DE
ED
Title
Amount or Number of Shares
| 8. Price
of
Derivative
Security
(Instr.5)
| 9. Number of
Derivative
Securities
Beneficially
Owned
Following
Reported
Transaction(s)
(Instr.4) | 10. Owner-
ship
Form of
Deriv-
ative
Securities:
Direct (D)
or
Indirect (I)
(Instr.4) | 11. Nature of
Indirect
Beneficial
Ownership
(Instr.4) | | | | | |" fixed_table2_row2 = "| 1. Title of Derivative Security
(Instr. 3)
| 2. Conver-
sion or
Exercise
Price of
Deri-
vative
Security
| 3. Transaction Date
(Month/
Day/
Year)
| 3A. Deemed Execution Date, if any
(Month/
Day/
Year)
| Code
| V | A | D | DE | ED | Title | Amount or Number of Shares | 8. Price
of
Derivative
Security
(Instr.5)
| 9. Number of
Derivative
Securities
Beneficially
Owned
Following
Reported
Transaction(s)
(Instr.4) | 10. Owner-
ship
Form of
Deriv-
ative
Securities:
Direct (D)
or
Indirect (I)
(Instr.4) | 11. Nature of
Indirect
Beneficial
Ownership
(Instr.4) |" markdown_text = markdown_text.replace(bad_table2_row2, fixed_table2_row2) markdown_text = _convert_bullet_tables_to_lists(markdown_text) footnote_spacing_pattern = re.compile( r'(?<=[^\n])' r'\n' r'(\d+.*)', re.MULTILINE ) markdown_text = footnote_spacing_pattern.sub(r'\n\n\1', markdown_text) markdown_text = markdown_text.replace("**\n•", "**\n\n•").replace("** 1. ", "**\n\n1. ") markdown_text = markdown_text.replace(" ##COLSPAN", "##COLSPAN").replace(" ##ROWSPAN", "##ROWSPAN") markdown_text = markdown_text.replace("p>", "
").replace(" ", "").replace(" ", "").replace("0.%", "0.0%").replace("ER>", "") markdown_text = re.sub(r'SPAN##[1-9](?!\d)', 'SPAN##', markdown_text) markdown_text = re.sub( r'(?m)^QuickLinks(?: -- Click here to rapidly navigate through this document)?\r?\n\n', '', markdown_text ) markdown_text = _remove_page_numbers(markdown_text) markdown_text = re.sub(r'(?m)^[ \t]*(?:100|[1-9]?\d)\s+QuickLinks[ \t]*\r?$', '', markdown_text) markdown_text = markdown_text.replace(' " *', ' "*').replace('* " ', '*" ').replace(' (" *', ' ()"*').replace('* ") ', '*") ').replace("**(** ", "**(**") markdown_text = markdown_text.replace("##TRIPLE_ASTERISK##", "\\*\\*\\*") markdown_text = markdown_text.replace("##DOUBLE_ASTERISK##", "\\*\\*") markdown_text = markdown_text.replace("##SINGLE_ASTERISK##", "\\*") markdown_text = re.sub(r'(?m)^((?:[A-Za-z]\))|(?:[1-9]\d?\.))([A-Za-z])', r'\1 \2', markdown_text) markdown_text = re.sub(r'(\s*\d+\s*)\s*\s+(?=[A-Za-z0-9])', r'\1 ', markdown_text, flags=re.I) markdown_text = re.sub( r'\s*(\((?:\d+|[A-Za-z]+))\s*\s*\s*\s*(\))\s*', r'\1\2', markdown_text, flags=re.I, ) pattern = r'(?m)(^[○•●·◦➢])(?=\S)' markdown_text = re.sub(pattern, r'\1 ', markdown_text) markdown_text = re.sub(r'(?:\n\n------){2,}', '\n\n------', markdown_text) pattern = r'([○•●·◦➢])\s*\s*' markdown_text = re.sub(pattern, r'\1 ', markdown_text) markdown_text = markdown_text.replace(" ", " ").replace("", "") markdown_text = re.sub(r"##COLSPAN_\d+##", "", markdown_text) pattern = r'(?m)^(\(\d+\))(?!\s)(\S)' markdown_text = re.sub(pattern, r'\1 \2', markdown_text) markdown_text = apply_markdown_hardcodes(markdown_text) return markdown_text.strip() _pre_tag_re = re.compile(r'(?is).*?') def _extract_pre_blocks(text: str, stash, ph_fmt="__PRE_BLOCK_{:03d}__") -> str: """Replace every 
…
with a unique placeholder and store the block.""" def _sub(m): idx = len(stash) stash.append(m.group(0)) return ph_fmt.format(idx) return _pre_tag_re.sub(_sub, text) def parse_legacy_13f_hr_txt(raw_text: str) -> str: """ Router function to detect the 13F-HR text format and call the correct parser. """ if ("----------------" in raw_text and "NAME OF ISSUER" in raw_text) or "x x" not in raw_text: print("--> Detected fixed-width format.") return parse_plaintext_filing(raw_text) else: print("--> Detected free-form (OCR-style) format.") return _parse_free_form_13f_hr(raw_text) def _parse_free_form_13f_hr(raw_text: str) -> str: """ Parses legacy 13F-HR filings that are in a free-form, OCR-like text format. """ import re, pandas as pd CUSIP_RE = re.compile(r'\b([0-9A-Za-z]{8}[0-9])\b') NUM_RE = re.compile(r'(\d{1,3}(?:,\d{3})*)') TITLE_CANDIDATES = [ "Common Stock","Common","ADR","SPON ADR","Spon ADR","Spons ADR", "Preferred","PRFD","Convertible","Convert","Convert Bond","ConvertBond", "Debenture","Notes" ] HEADERS = [ 'NAME OF ISSUER','TITLE OF CLASS','CUSIP','VALUE (x$1000)', 'SHRS OR PRN AMT','SH/PRN','PUT/CALL','INVESTMENT DISCRETION','OTHER MANAGER', 'VOTING AUTHORITY (SOLE)','VOTING AUTHORITY (SHARED)','VOTING AUTHORITY (NONE)' ] def smart_title_case(text: str) -> str: words = text.split() title_cased_words = [] for word in words: if word.isupper() and len(word) > 1: title_cased_words.append(word) else: title_cased_words.append(word.capitalize()) return ' '.join(title_cased_words) def _normalize_number_token(s: str) -> str: return s.replace(',', '') def _pick_title(text: str) -> str: up = text.upper() best = None for t in TITLE_CANDIDATES: if t.upper() in up: if not best or up.rfind(t.upper()) > up.rfind(best.upper()): best = t return best or "Common" table_start = re.search(r'Form 13F Information Table', raw_text, re.I | re.S) if not table_start: return "" cover = raw_text[:table_start.start()] cover = "\n".join(l.strip() for l in cover.splitlines() if l.strip()) cover = re.sub(r'FORM 13F\s+FORM 13F', '## FORM 13F (Some records may not parsed due to OCR errors in the original filing)', cover, flags=re.I) cover = re.sub(r'COVER PAGE', '\n\n### COVER PAGE', cover, flags=re.I) cover = re.sub(r'SUMMARY PAGE', '\n\n### SUMMARY PAGE', cover, flags=re.I) cover = re.sub(r'Name:', '\n\n**Name:**', cover, flags=re.I) cover = re.sub(r'Address:', '\n\n**Address:**', cover, flags=re.I) cover = re.sub(r'Person signing this report on behalf of Reporting Manager:', '\n\n**Person signing this report on behalf of Reporting Manager:**', cover, flags=re.I) blob = raw_text[table_start.end():] blob = re.sub(r'|', ' ', blob, flags=re.I) blob = re.sub(r'\s+', ' ', blob).strip() blob = re.sub(r'(\d),\s+(\d{3})', r'\1,\2', blob) blob = re.sub(r'(\d{1,3}),\s+(\d)\s+(\d{3}\b)', r'\1 \2,\3', blob) matches = list(CUSIP_RE.finditer(blob)) holdings = [] for i, m in enumerate(matches): start = m.start() end = matches[i+1].start() if i+1 < len(matches) else len(blob) rec = blob[start:end].strip() cusip = m.group(1).upper() rest = rec[len(m.group(1)):].strip() nums = NUM_RE.findall(rest) value_tok = nums[0] if len(nums) >= 1 else '0' shares_tok = nums[1] if len(nums) >= 2 else '0' first_num_pos = rest.find(value_tok) if nums else -1 issuer_title_text = rest if first_num_pos != -1: issuer_title_text = rest[:first_num_pos].strip() else: if ' x' in rest.lower(): issuer_title_text = rest.lower().split(' x')[0].strip() value_raw = _normalize_number_token(value_tok) shares_raw = _normalize_number_token(shares_tok) title = _pick_title(issuer_title_text) issuer_text = re.sub(re.escape(title) + r'$', '', issuer_title_text, flags=re.I).strip() issuer_text = re.sub(r'\bSpons?\b\s*A(?:DR)?\b$', '', issuer_text, flags=re.I).strip() issuer_text = re.sub(r'\s{2,}', ' ', issuer_text) issuer = smart_title_case(issuer_text) x_count = len(re.findall(r'\bx\b', rec, flags=re.I)) inv_disc = "SOLE" if x_count >= 1 else "—" voting_sole = int(shares_raw) if (x_count >= 1 and shares_raw.isdigit() and int(shares_raw) > 0) else 0 is_prn = any(k in title.upper() for k in ("CONVERT", "DEBENT", "NOTES")) row = { 'NAME OF ISSUER': issuer or '—', 'TITLE OF CLASS': 'ConvertBond' if 'CONVERT' in title.upper() else (title or 'Common'), 'CUSIP': cusip, 'VALUE (x$1000)': f"{int(value_raw):}" if value_raw.isdigit() and int(value_raw) > 0 else '—', 'SHRS OR PRN AMT': f"{int(shares_raw):}" if shares_raw.isdigit() and int(shares_raw) > 0 else '—', 'SH/PRN': 'PRN' if is_prn else 'SH', 'PUT/CALL': '—', 'INVESTMENT DISCRETION': inv_disc, 'OTHER MANAGER': '—', 'VOTING AUTHORITY (SOLE)': f"{voting_sole:,}" if voting_sole > 0 else '—', 'VOTING AUTHORITY (SHARED)': '—', 'VOTING AUTHORITY (NONE)': '—', } holdings.append(row) if not holdings: return f"{cover}\n\n" df = pd.DataFrame(holdings).reindex(columns=HEADERS).fillna('—') return f"{cover}\n\n{to_compact_markdown(df, index=False)}" def _process_image_bytes_with_mistral( image_bytes: bytes, file_name: str, page_no: int, *, per_table_sleep_s: float, mistral_api_key: Optional[str] = None, ): """ Processes a single rendered page image using Mistral OCR. This is an adaptation of your PDF processing logic for a single image. """ try: def _run_page_ocr(*, client: Mistral, api_key: str, key_spec: Dict[str, Any]): up = client.files.upload(file={"file_name": f"page_{page_no}_{file_name}", "content": image_bytes}, purpose="ocr") if not up or not up.id: raise Exception("Image upload failed to return a valid ID.") signed_url = get_signed_url_with_retry(client, file_id=up.id) headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"} payload = _build_mistral_ocr_payload(signed_url) max_ocr_retries = 4 ocr_delay = 2.0 for attempt in range(max_ocr_retries): response = requests.post(OCR_API_URL, headers=headers, json=payload, timeout=600) if response.status_code in [429, 500, 502, 503, 504]: if attempt < max_ocr_retries - 1: print(f"OCR API error {response.status_code}. Retrying in {ocr_delay:.2f}s... (Attempt {attempt + 1}/{max_ocr_retries})") time.sleep(ocr_delay) ocr_delay *= 2 ocr_delay += random.uniform(0, 0.5) continue response.raise_for_status() break ocr_data = response.json() usage = _summarize_ocr_usage(ocr_data, response.headers) if not ocr_data.get("pages"): print(f"[page {page_no}] OCR returned no content.") return "", usage, key_spec["env_name"] page_obj = ocr_data["pages"][0] return _pick_text(page_obj), usage, key_spec["env_name"] page_text, usage, used_env_name = _run_with_mistral_key_rotation( f"rendered page {page_no} for {file_name}", _run_page_ocr, explicit_api_key=mistral_api_key, ) _record_mistral_key_success(used_env_name, usage=usage, explicit_api_key=mistral_api_key) return page_text except Exception as e: print(f"API processing for page {page_no} failed and was skipped. Error: {e}") return f"" def parse_html_via_ocr(filepath: pathlib.Path) -> str: """ High-quality OCR-based parser for positioned HTML. Renders each page to an image and uses Mistral OCR to extract text and tables. """ _load_sec_parser_env() if not _has_mistral_api_keys(): print(f"{_mistral_no_keys_message()} Skipping OCR processing.") return "" _log_current_filing_ocr("html_image_ocr") html_content = filepath.read_text(encoding='utf-8', errors='replace') try: soup = BeautifulSoup(html_content, "lxml") except ValueError as e: if "not enough values to unpack" in str(e): print(f"[Warning] lxml parser crashed on malformed attributes. Falling back to html.parser.") soup = BeautifulSoup(html_content, "html.parser") else: raise pages = soup.find_all('div', id=re.compile(r'^pf\w+$')) if not pages: print("Could not find page containers (e.g.,
). Treating document as a single page.") pages = [soup] md_parts = [] options = { 'format': 'png', 'quality': '100', 'width': '1224', 'disable-smart-width': '' } print(f"Found {len(pages)} pages to process via OCR.") for i, page_soup in enumerate(pages, 1): print(f"--> Rendering and processing page {i}...") try: image_bytes = imgkit.from_string(str(page_soup), False, options=options) page_content = _process_image_bytes_with_mistral( image_bytes=image_bytes, file_name=filepath.name, page_no=i, per_table_sleep_s=Config.PER_TABLE_SLEEP_SECONDS, mistral_api_key=None, ) md_parts.append(page_content) except Exception as e: error_msg = f"Failed to render or process page {i}: {e}" print(error_msg) md_parts.append(f"") return "\n\n------\n\n".join(md_parts) def parse_series_and_classes_sgml(header_content: str) -> str: """ Parses the SGML block from a filing header into a structured Markdown output. """ sgml_match = re.search( r"(.*?)", header_content, re.S | re.I ) if not sgml_match: return "" sgml_content = sgml_match.group(1) md_parts = ["## Series and Classes Contracts Data"] series_blocks = re.split(r'', sgml_content, flags=re.I)[1:] if not series_blocks: return "" for series_block in series_blocks: series_name_match = re.search(r'\s*([^\n<]+)', series_block, re.I) series_id_match = re.search(r'\s*([^\n<]+)', series_block, re.I) series_name = series_name_match.group(1).strip() if series_name_match else "—" series_id = series_id_match.group(1).strip() if series_id_match else "—" md_parts.append(f"\n### {series_name} (Series ID: {series_id})") class_records = [] class_contract_blocks = re.findall( r'(.*?)(?=||$)', series_block, re.S | re.I ) for class_block in class_contract_blocks: id_match = re.search(r'\s*([^\n<]+)', class_block, re.I) name_match = re.search(r'\s*([^\n<]+)', class_block, re.I) ticker_match = re.search(r'\s*([^\n<]+)', class_block, re.I) record = { 'Class ID': id_match.group(1).strip() if id_match else "—", 'Class Name': name_match.group(1).strip() if name_match else "—", 'Ticker Symbol': ticker_match.group(1).strip() if ticker_match else "—", } class_records.append(record) if class_records: df = pd.DataFrame(class_records) md_parts.append(to_compact_markdown(df, index=False)) return "\n\n".join(md_parts) def parse_legacy_paper_filing(raw_text: str, form_type: str) -> str: """ Parses various legacy plain-text paper filings (ADV series, MSDW, etc.). All data is contained within the or block, and it also captures any text from the block. """ form_titles = { "ADV": "FORM ADV: Uniform Application for Investment Adviser Registration", "ADV/A": "FORM ADV/A: Amendment to Form ADV", "ADV-E": "FORM ADV-E: Certificate of Accounting of Client Securities and Funds", "ADV-H-T": "FORM ADV-H-T: Application for a Temporary Hardship Exemption", "ADV-H-C": "FORM ADV-H-C: Application for a Continuing Hardship Exemption", "ADV-NR": "FORM ADV-NR: Appointment of Agent for Service of Process by Non-Resident Adviser", "ADVW": "FORM ADVW: Notice of Withdrawal from Registration as Investment Adviser", "ADVCO": "FORM ADVCO: Correction to an ADV Filing", "MSDW": "FORM MSDW: Notice of Withdrawal from Registration as a Municipal Securities Dealer" } title = form_titles.get(form_type, f"Form {form_type}") md_parts = [ "### UNITED STATES SECURITIES AND EXCHANGE COMMISSION\n" "**Washington, D.C. 20549**\n\n" f"## {title}\n" ] header_match = re.search(r"<(?:SEC|IMS)-HEADER>(.*?)", raw_text, re.S | re.I) if not header_match: md_parts.append(f"") else: header_content = header_match.group(1).strip() for line in header_content.splitlines(): line = line.strip() if not line: continue if not line.startswith('\t') and line.endswith(':'): section_name = line.rstrip(':').strip() if section_name in ["FILER", "COMPANY DATA", "FILING VALUES", "BUSINESS ADDRESS", "MAIL ADDRESS", "FORMER COMPANY"]: md_parts.append(f"\n### {section_name.title()}") continue if ':' in line: key, value = line.split(':', 1) key = key.strip() value = value.strip() if key and value: md_parts.append(f"**{key}:** {value}") doc_match = re.search(r"(.*?)", raw_text, re.S | re.I) if doc_match: doc_content = doc_match.group(1) text_match = re.search(r"(.*?)", doc_content, re.S | re.I) if text_match: doc_text = text_match.group(1).strip() if doc_text: md_parts.append("\n### Document Note") blockquote_lines = [f"> {line.strip()}" for line in doc_text.splitlines() if line.strip()] md_parts.append("\n".join(blockquote_lines)) return "\n".join(md_parts) def _extract_class_name_map_from_header_content(header_content: str) -> dict: if not header_content: return {} try: header_soup = BeautifulSoup(header_content, 'lxml') except ValueError as e: if "not enough values to unpack" in str(e): print("[Warning] lxml crashed while parsing header contract data. Falling back to html.parser.") header_soup = BeautifulSoup(header_content, 'html.parser') else: raise class_name_map = {} if (scd := header_soup.find('series-and-classes-contracts-data')): for series in scd.find_all('series'): for class_contract in series.find_all('class-contract'): class_id_tag = class_contract.find('class-contract-id') class_name_tag = class_contract.find('class-contract-name') if class_id_tag and class_name_tag: id_text_node = class_id_tag.find(string=True, recursive=False) name_text_node = class_name_tag.find(string=True, recursive=False) if id_text_node and name_text_node: class_id = id_text_node.strip() class_name = name_text_node.strip() if class_id: class_name_map[class_id] = class_name return class_name_map def _iter_document_blocks(raw_bytes: bytes): for match in re.finditer(rb"(.*?)", raw_bytes, re.S | re.I): yield match.group(1) def _iter_document_blocks_from_file(filepath: pathlib.Path, chunk_size: int = 8 * 1024 * 1024): start_re = re.compile(rb"", re.I) end_re = re.compile(rb"", re.I) overlap = 64 buffer = b"" in_document = False doc_parts: List[bytes] = [] with filepath.open("rb") as handle: while True: chunk = handle.read(chunk_size) if not chunk: break buffer += chunk while True: if not in_document: start_match = start_re.search(buffer) if not start_match: buffer = buffer[-overlap:] break buffer = buffer[start_match.end():] doc_parts = [] in_document = True end_match = end_re.search(buffer) if end_match: doc_parts.append(buffer[:end_match.start()]) yield b"".join(doc_parts) buffer = buffer[end_match.end():] doc_parts = [] in_document = False continue if len(buffer) > overlap: doc_parts.append(buffer[:-overlap]) buffer = buffer[-overlap:] break def _first_document_block_from_file(filepath: pathlib.Path) -> Optional[bytes]: return next(_iter_document_blocks_from_file(filepath), None) def _read_prefix_until_any( filepath: pathlib.Path, markers: List[bytes], chunk_size: int = 1024 * 1024, max_bytes: int = 64 * 1024 * 1024, ) -> bytes: buffer = b"" marker_res = [re.compile(re.escape(marker), re.I) for marker in markers if marker] with filepath.open("rb") as handle: while True: chunk = handle.read(chunk_size) if not chunk: return buffer buffer += chunk earliest_end: Optional[int] = None for marker_re in marker_res: match = marker_re.search(buffer) if match and (earliest_end is None or match.end() < earliest_end): earliest_end = match.end() if earliest_end is not None: return buffer[:earliest_end] if len(buffer) >= max_bytes: return buffer def _file_contains_bytes(filepath: pathlib.Path, needle: bytes, chunk_size: int = 4 * 1024 * 1024) -> bool: if not needle: return False needle_lower = needle.lower() overlap = max(0, len(needle) - 1) tail = b"" with filepath.open("rb") as handle: while True: chunk = handle.read(chunk_size) if not chunk: return False haystack = tail + chunk if needle_lower in haystack.lower(): return True tail = haystack[-overlap:] if overlap else b"" def _extract_xml_blobs_from_body_bytes(body_bytes: bytes) -> List[str]: return [ normalize_text_markup(match.group(1)) for match in re.finditer(rb"(.*?)", body_bytes, re.S | re.I) ] def _body_bytes_without_xml(body_bytes: bytes) -> bytes: if not re.search(rb".*?", b"", body_bytes, flags=re.S | re.I) def _iter_pdf_attachment_texts_from_file( filepath: pathlib.Path, skip_types: set[bytes], xbrl_ex_re: re.Pattern, ): for doc_bytes in _iter_document_blocks_from_file(filepath): m = re.search(rb"\s*([^\s<]+)", doc_bytes, re.I) doc_type_bytes = m.group(1).upper() if m else b"" if doc_type_bytes in skip_types or xbrl_ex_re.match(doc_type_bytes): continue text_match = re.search(rb"(.*?)", doc_bytes, re.S | re.I) body_bytes = text_match.group(1) if text_match else doc_bytes if not body_bytes.strip(): desc_match = re.search(rb"\s*(.*?)\s*<", doc_bytes, re.S | re.I) if desc_match: body_bytes = desc_match.group(1) if re.search(rb"", body_bytes, re.I): yield body_bytes.decode('latin-1', errors='replace') def process_local_xbrl(filepath: pathlib.Path) -> str: """ Read an EDGAR filing (HTML/HTM/TXT) and return a clean Markdown version. This version processes documents sequentially to preserve the original filing order. """ global LAST_PARSE_STATS parse_stats = _new_parse_stats(filepath) def record(source_format: str, text: str, label: str = "") -> None: _record_parse_stats_part(parse_stats, source_format, text, label) def record_pdf(text: str, label: str, page_count: int) -> None: _record_parse_stats_part(parse_stats, "pdf", text, label) _record_parse_stats_pdf_pages(parse_stats, page_count) def finish(markdown_text: str, form_type: str = "") -> str: global LAST_PARSE_STATS final_text = (markdown_text or "").strip() LAST_PARSE_STATS = _finalize_parse_stats(parse_stats, final_text, form_type or main_form_type) return final_text prefix_bytes = _read_prefix_until_any( filepath, [b"", b"", b""], ) first_doc_bytes = _first_document_block_from_file(filepath) main_form_type = "" legacy_paper_forms = {"MSDW", "MSDCO", "MSD", "MSD/A", "8-M", "9-M"} class_name_map = {} def is_html_content(content_str): return re.search(r"<\s*(html|div|p)\b", content_str, re.I) header_match_bytes = re.search(rb"(.*?)", prefix_bytes, re.S | re.I) ims_header_match_bytes = re.search(rb"(.*?)", prefix_bytes, re.S | re.I) header_part = "" sgml_header_part = "" if header_match_bytes: header_bytes = header_match_bytes.group(1) header_content = normalize_text_markup(header_bytes) class_name_map = _extract_class_name_map_from_header_content(header_content) sgml_header_part = parse_series_and_classes_sgml(header_content) if (m := re.search(r"CONFORMED SUBMISSION TYPE:\s*([^\s]+)", header_content, re.I)): main_form_type = m.group(1).strip().upper() if (main_form_type.startswith("ADV") or main_form_type in legacy_paper_forms) and _file_contains_bytes(filepath, b""): print(f"--> Detected legacy paper filing: {main_form_type}. Routing to dedicated paper parser.") full_text_decoded = filepath.read_bytes().decode('latin-1', 'replace') legacy_md = parse_legacy_paper_filing(full_text_decoded, main_form_type) record("text", legacy_md, "legacy_paper") return finish(legacy_md, main_form_type) if main_form_type in ("497", "24F-2NT"): header_part = parse_form497_file(header_content) else: header_part = parse_sec_header(header_content) record("sgml", header_part, "sec_header") record("sgml", sgml_header_part, "series_classes_sgml") elif ims_header_match_bytes: full_text_decoded = filepath.read_bytes().decode('latin-1', 'replace') header_part = parse_ims_header(full_text_decoded) if (m := re.search(r"CONFORMED SUBMISSION TYPE:\s*([^\s]+)", full_text_decoded, re.I)): main_form_type = m.group(1).strip().upper() if (main_form_type.startswith("ADV") or main_form_type in legacy_paper_forms) and _file_contains_bytes(filepath, b""): print(f"--> Detected legacy paper filing: {main_form_type}. Routing to dedicated paper parser.") legacy_md = parse_legacy_paper_filing(full_text_decoded, main_form_type) record("text", legacy_md, "legacy_paper") return finish(legacy_md, main_form_type) record("sgml", header_part, "ims_header") else: header_part = "" record("sgml", header_part, "missing_header_placeholder") if first_doc_bytes is None: raw_bytes = filepath.read_bytes() body_content_bytes_match = re.search(rb"(.*)", raw_bytes, re.S | re.I) if not body_content_bytes_match: header_end = header_match_bytes.end() if header_match_bytes else 0 body_content_bytes_match = raw_bytes[header_end:] else: body_content_bytes_match = body_content_bytes_match.group(1) if re.search(rb"", body_content_bytes_match, re.I): pdf_md, pdf_page_count = parse_pdf_attachments([body_content_bytes_match.decode('latin-1', 'replace')]) record_pdf(pdf_md, "embedded_pdf", pdf_page_count) return finish(f"{header_part}\n\n{pdf_md}", main_form_type) body_content = normalize_text_markup(body_content_bytes_match) if is_html_content(body_content): md, positioned = parse_html_filing(body_content, form_type="", file_path=filepath) if positioned: body_md = md record_pdf(body_md, "positioned_html_ocr", LAST_POSITIONED_HTML_OCR_PAGE_COUNT) else: body_md = _post_process_text_cleanup(md) record("html", body_md, "body_html") else: body_md = parse_plaintext_filing(body_content) record("text", body_md, "body_text") return finish(f"{header_part}\n\n{body_md}", main_form_type) parts: List[str] = [header_part] if header_part else [] if sgml_header_part: parts.append(sgml_header_part) pre_stash: List[str] = [] xml_blobs: List[str] = [] pdf_blobs: List[str] = [] if main_form_type.startswith(('13F-', 'N-PX')): all_xml_contents = [] legacy_text_content = "" for doc_bytes in _iter_document_blocks_from_file(filepath): text_match = re.search(rb"(.*?)", doc_bytes, re.S | re.I) body_bytes = text_match.group(1) if text_match else doc_bytes if not body_bytes.strip(): continue xmls_in_doc = _extract_xml_blobs_from_body_bytes(body_bytes) if xmls_in_doc: all_xml_contents.extend(xmls_in_doc) else: doc_content = normalize_text_markup(body_bytes) if doc_content.strip() and "13F" in main_form_type: legacy_text_content = doc_content break if all_xml_contents: parts = [header_part] if header_part else [] xml_md = parse_any_xml(all_xml_contents) record("xml", xml_md, "13f_npx_xml") parts.append(xml_md) final_md = "\n\n".join(p for p in parts if p.strip()) return finish(final_md, main_form_type) elif legacy_text_content: legacy_md = parse_legacy_13f_hr_txt(legacy_text_content) record("text", legacy_md, "legacy_13f_text") return finish(f"{header_part}\n\n{legacy_md}", main_form_type) skip_types = {b"EXCEL", b"XML", b"XBRLSUMMARY", b"JSON", b"ZIP", b"PAPER", b"GRAPHIC"} xbrl_ex_re = re.compile(rb"^EX-101\.(INS|SCH|CAL|DEF|LAB|PRE)$", re.I) if not main_form_type and first_doc_bytes is not None: if (m := re.search(rb"\s*([^\s<]+)", first_doc_bytes, re.I)): main_form_type = m.group(1).upper().decode('ascii', 'ignore') saw_pdf_blobs = False for idx, doc_bytes in enumerate(_iter_document_blocks_from_file(filepath), start=1): _debug_print(f"Document {idx} is being processed") m = re.search(rb"\s*([^\s<]+)", doc_bytes, re.I) doc_type_bytes = m.group(1).upper() if m else b"" doc_type = doc_type_bytes.decode('ascii', 'ignore') if doc_type_bytes in skip_types or xbrl_ex_re.match(doc_type_bytes): continue text_match = re.search(rb"(.*?)", doc_bytes, re.S | re.I) body_bytes = text_match.group(1) if text_match else doc_bytes if not body_bytes.strip(): desc_match = re.search(rb"\s*(.*?)\s*<", doc_bytes, re.S | re.I) if desc_match: body_bytes = desc_match.group(1) if re.search(rb"", body_bytes, re.I): saw_pdf_blobs = True continue xmls_in_doc = _extract_xml_blobs_from_body_bytes(body_bytes) if xmls_in_doc: xml_blobs.extend(xmls_in_doc) doc_content = normalize_text_markup(_body_bytes_without_xml(body_bytes)) else: doc_content = normalize_text_markup(body_bytes) body_wo_xml = doc_content body_wo_xml = _extract_pre_blocks(body_wo_xml, pre_stash) is_legacy_form4_doc = (not xmls_in_doc) and (doc_type == "4") parsed_part = "" if doc_type.startswith("NSAR-B") and not is_html_content(body_wo_xml): parsed_part = parse_nsar_b_txt(body_wo_xml) parsed_source_format = "text" elif is_html_content(body_wo_xml) or xmls_in_doc: html_part, positioned = parse_html_filing(body_wo_xml, form_type=main_form_type, file_path=filepath) if positioned: parsed_part = html_part parsed_source_format = "pdf" else: parsed_part = _post_process_text_cleanup(html_part, legacy_form4=is_legacy_form4_doc) parsed_source_format = "html" else: parsed_part = parse_plaintext_filing(body_wo_xml) parsed_source_format = "text" if parsed_part.strip(): if parsed_source_format == "pdf": record_pdf(parsed_part, doc_type or "positioned_html_ocr", LAST_POSITIONED_HTML_OCR_PAGE_COUNT) else: record(parsed_source_format, parsed_part, doc_type or parsed_source_format) if (ex := re.match(r"EX[-\s]?(\d+\.\d+)", doc_type, re.I)) and not xmls_in_doc: parts.append(f"\n## Exhibit {ex.group(1)}\n") elif doc_type and doc_type not in {main_form_type, ""} and not xmls_in_doc: desc_match = re.search(r"\s*(.*?)\s*<", doc_content, re.I) parts.append(f"\n## {(desc_match.group(1) if desc_match else doc_type).title()}\n") parts.append(parsed_part) if saw_pdf_blobs: pdf_md, pdf_page_count = parse_pdf_attachments( _iter_pdf_attachment_texts_from_file(filepath, skip_types, xbrl_ex_re) ) record_pdf(pdf_md, "pdf_attachments", pdf_page_count) parts.append(pdf_md) if xml_blobs: xml_md = parse_any_xml(xml_blobs, pdf_docs=None, class_name_map=class_name_map) record("xml", xml_md, "xml_documents") parts.append(xml_md) final_md = "\n\n".join(p for p in parts if p.strip()) rendered_pre = [parse_plaintext_filing(b) for b in pre_stash] if rendered_pre: record("text", "\n\n".join(rendered_pre), "pre_blocks") for i, block in enumerate(rendered_pre): final_md = final_md.replace(f"__PRE_BLOCK_{i:03d}__", block) return finish(final_md, main_form_type) def conditional_delete(match_object): """ This function is called for every match. It checks the length of the content after 'begin 644 '. """ captured_content = match_object.group(1) if len(captured_content) > 50: return match_object.group(0) else: return "" def main_one(path: pathlib.Path, to_mmd: bool = False, source_document_url: Optional[str] = None) -> None: global CURRENT_PROCESSING_FILE, CURRENT_SOURCE_DOCUMENT_URL CURRENT_PROCESSING_FILE = str(path.resolve()) CURRENT_SOURCE_DOCUMENT_URL = (source_document_url or '').strip() or None try: doc = process_local_xbrl(path) if not doc: raise ValueError("empty output") doc = doc.replace('| — |', '| |').replace('| — |', '| |').replace('|
— |', '| |').replace('|
— |', '| |').replace('|
- |', '| |').replace('|
- |', '| |') before_pattern = re.compile(r'(?---\n", "\n---\n") delimiter_fix_pattern = re.compile(r'(^---)([ \t]*[^-].*)', re.MULTILINE) doc = delimiter_fix_pattern.sub(r'\1\n\n\2', doc) if to_mmd == False: doc = re.sub(r'(?<=[^\s-])', ' ', doc) doc = doc.replace('', r'\|') doc = doc.replace('##MD_NEWLINE##', '
') if to_mmd: doc = convert_all_tables_to_mmd(doc) doc = apply_markdown_hardcodes(doc) doc = doc.replace("", "^").replace("", "^") doc = doc.replace("", "~").replace("", "~") doc = doc.replace(r"\ |", r"\|") doc = re.sub(r'(?<=[^\s-])', ' ', doc) doc = doc.replace('', r'\|') doc = doc.replace('##MD_NEWLINE##', '
') if (r"\>/R\<" in doc and r"\>R\<" in doc and r"\>PAGE\<" in doc): doc = doc.replace(r"\>/R\<", "").replace(r"\>R\<", "").replace(r"\>R\/R\<", "").replace(r"\>R\<", "").replace(r"\>R\\", "").replace(r"#### \>PAGE\<", "") doc = re.sub(r"\n\\>PAGE\\< ?\r?\n", "\n", doc) MARKERS = re.compile( r'(?m)^[ \t]*(?:\*\*\\?>R\\?\*\*|\d+[ \t]+\\?>PAGE\\?<)[ \t]*(?:\r?\n|$)' ) doc = MARKERS.sub('', doc) doc = re.sub(r'##(ROWSPAN_\d+|COLSPAN_\d+)##', '', doc) doc = doc.replace("
)", ")").replace("
]", "]").replace("
%", "%").replace("
)%", ")%") doc = re.sub(r'
\.[1-9](?!\d)', '', doc, flags=re.I) doc = re.sub(r'(?<=\| )—(?= +\|)', ' ', doc) doc = re.sub(r'\$ (?=[0-9(])', '$', doc) doc = doc.replace('##SINGLE_ASTERISK##', '').replace('##DOUBLE_ASTERISK##', '').replace('##TRIPLE_ASTERISK##', '') doc = re.sub(r'(?m)^\| o (?=.)', r'| ##INDENT##o ', doc) doc = doc.replace('\u2063', '').replace('##INDENT##', '    ') doc = doc.replace("\n\n\n\n", "") doc = doc.replace("| **%****%** |", "| **%** |") doc = re.sub(r'(\*{3,})(\.\*\*|\)?%\*\*)', r'*\2', doc) m = re.search(r'^begin 644.*(?:\r?\n|$)', doc, flags=re.M) doc = doc.replace("| nan |", "| |").replace("| nan |", "| |") doc = doc[:m.start()] if m else doc doc = doc.replace("\n## Excel\n\n\n", "") doc = doc.replace('##SPACE##', ' ').replace('##I_SPACE##', ' ') doc = doc.replace("
|", " |") doc = re.sub(r"\n *
*\n", "\n", doc) doc = re.sub(r"(\d+)\s%( \|)", r"\1%\2", doc) doc = doc.replace("| %** |", "| **%** |") doc = re.sub(r"\*\*(\d+(?:\.\d+)?)\*\*\s*%?\s*\*\*(?=\s|$)", r"**\1%**", doc) doc = re.sub(r"(^|\n)
(?=#+)", r"\1", doc) doc = re.sub(r"
(?=#+)", r"\n\n", doc) doc = doc.replace("
------", "------").replace("

", "
").replace("
**)**", "**)**") doc = doc.replace("\n# # #\n", "\n\\# \\# \\#\n") doc = doc.replace("\n
---\n\n|", "\n---\n\n|") pattern = r'(?<=[^\s-])------(?=\r?\n)' replacement = r'\n\n------' doc = re.sub(pattern, replacement, doc) doc = doc.replace("
% |", "% |").replace("*
*%* |", "%* |").replace("***
*%***", "%***").replace("*
*%* |", "%* |") item_heading_pattern = re.compile( r'(^\s*(?:\*\*)?\s*(?:item\s+)?\d+[A-Z]?\.)' r'(?=[A-Z])', re.IGNORECASE | re.MULTILINE ) doc = item_heading_pattern.sub(r'\1 ', doc) pattern = r"\|\s\**(?: | )+\**\s\|" doc = doc.replace(") ** |", ")** |") doc = re.sub( r"\*\*\(\s*(\$?[+-]?\d[\d,]*(?:\.\d+)?)\s*\*\*\s*(?:\s*)?\s*\*\*\)\s*\*\*", r"**(\1)**", doc, flags=re.IGNORECASE, ) doc = re.sub( r"\*\*([+-]?\d[\d,]*(?:\.\d+)?)\*\*(\s*(?:)?\s*(%?)\s*)\*\*(?=\s|$)", lambda m: f"**{m.group(1)}{'%' if not m.group(3) else m.group(2)}**", doc, flags=re.IGNORECASE, ) doc = re.sub(pattern, "| |", doc) doc = re.sub(pattern, "| |", doc) doc = re.sub(r'(?m)^\*\*2\*\*\s+\*\*nd\b', r'**2nd', doc) doc = doc.replace("** ---\n\n|", "**\n\n---\n\n|") doc = doc.replace("| $**$** | $%** |", "| **$** | **%** |").replace('| — |', '| |').replace('| — |', '| |').replace("| **$Change** |", "| **$ Change** |").replace("| **%Change** |", "| **% Change** |").replace("     months |", " months |") pattern = r"(\n\n\*\*\d+)\. \*\*" replacement = r"\1.**" doc = re.sub(pattern, replacement, doc) doc = doc.replace("**• ** ", "**•** ") pattern = re.compile(r"^(begin 644 (.*)(\r?\n|$))", re.MULTILINE) doc = pattern.sub(conditional_delete, doc) doc = re.sub(r'\^\((\d+)\)((?: )+)\^', r'^(\1)^\2', doc) doc = doc.replace("**6** **.** **ACCOUNTS RECEIVABLE**", "**6.** **ACCOUNTS RECEIVABLE**").replace("**1** **2.** **Long-term debt**", "**12.** **Long-term debt**").replace("**1** **3.** **Employee future benefits**", "**13.** **Employee future benefits**") out = path.with_suffix(".md") out.write_text(doc, encoding="utf-8") parse_stats = _complete_parse_stats_for_output( LAST_PARSE_STATS, output_path=out, final_markdown=doc, to_mmd=to_mmd, ) try: _write_parse_stats_outputs(parse_stats, out) _print_parse_stats_summary(parse_stats) except Exception as stats_exc: print(f"[parse-stats warning] Could not write parse stats: {stats_exc}") print(f"Successful! Output written to {out}") except Exception as e: logging.error( f"FILE: {path.name}\n" f"ERROR: {e}\n" f"TRACEBACK:\n{traceback.format_exc()}" ) print(f"[ERROR] {path}: {e}. Details logged to {log_file_path.name}", file=sys.stderr) if __name__ == "__main__": parser = argparse.ArgumentParser( description="A command-line tool to parse an SEC filing in HTML, HTM, or TXT format and convert it to Markdown.", formatter_class=argparse.RawTextHelpFormatter ) parser.add_argument("path", nargs="?", help="Path to the SEC filing (e.g., your_file.html).") parser.add_argument( "--to_mmd", action="store_true", help="Convert all tables in the final output to MultiMarkdown format." ) parser.add_argument( "--source-document-url", help="Optional absolute source document URL used to resolve fragment links like #a_001." ) parser.add_argument( "--mistral-key-status", action="store_true", help="Print the shared Mistral key rotation/usage monitor JSON and exit." ) parser.add_argument( "--reset-mistral-key-status", action="store_true", help="Reset the shared Mistral key rotation/usage monitor JSON and exit." ) args = parser.parse_args() if args.reset_mistral_key_status: print(json.dumps(reset_mistral_key_status(), indent=2, sort_keys=True)) sys.exit(0) if args.mistral_key_status: print(json.dumps(get_mistral_key_status_snapshot(), indent=2, sort_keys=True)) sys.exit(0) if not args.path: parser.error("the following arguments are required: path") file_path = pathlib.Path(args.path) if not file_path.is_file() and file_path.parts and file_path.parts[0] == "sec_parser": alt_path = pathlib.Path(*file_path.parts[1:]) if alt_path.is_file(): print(f"[info] Using '{alt_path}' instead of '{args.path}'.") file_path = alt_path if not file_path.is_file(): print(f"Error: File not found at {args.path}", file=sys.stderr) sys.exit(1) main_one(file_path, to_mmd=args.to_mmd, source_document_url=args.source_document_url)