[MLsys2026 Best Paper]: https://arxiv.org/abs/2506.08276. RAG on Everything with LEANN. Enjoy 97% storage savings while running a fast, accurate, and 100% private RAG application on your personal device.
Python aifaissgpt-osslangchainllama-indexllmlocalstorageoffline-firstollamaprivacypythonragretrieval-augmented-generationvector-databasevector-searchvectors
feat: add comprehensive ingestion support for Office, Mindmaps, Mail, Calendar, and enhanced PDF processing
Tolga Karatas00529d664557
diff --git a/README.md b/README.mdindex 80a633e..77891e1 100755--- a/README.md+++ b/README.md@@ -193,7 +193,7 @@ response = chat.ask("How much storage does LEANN save?", top_k=1)## RAG on Everything!-LEANN supports RAG on various data sources including documents (`.pdf`, `.txt`, `.md`), Apple Mail, Google Search History, WeChat, ChatGPT conversations, Claude conversations, iMessage conversations, and **live data from any platform through MCP (Model Context Protocol) servers** - including Slack, Twitter, and more.+LEANN supports RAG on various data sources including documents (`.pdf`, `.txt`, `.md`, `.docx`, `.pptx`, `.xlsx`, `.mm`), Apple Mail, Apple Calendar, Google Search History, WeChat, ChatGPT conversations, Claude conversations, iMessage conversations, and **live data from any platform through MCP (Model Context Protocol) servers** - including Slack, Twitter, and more.@@ -1077,8 +1077,10 @@ leann remove my-docs```**Key CLI features:**-- Auto-detects document formats (PDF, TXT, MD, DOCX, PPTX + code files)+- Auto-detects document formats (PDF, TXT, MD, DOCX, PPTX, XLSX, MM + code files)+- **🚀 Advanced PDF Processing**: Multi-layer fallback chain (PyMuPDF → pypdf → pdfplumber → Docling OCR) for maximum reliability- **🧠 AST-aware chunking** for Python, Java, C#, TypeScript files+- **📱 Integrated Source Indexing**: Dedicated commands for Mail, Calendar, iMessage, and more- Smart text chunking with overlap for all other content- Multiple LLM providers (Ollama, OpenAI, HuggingFace)- Organized index storage in `.leann/indexes/` (project-local)diff --git a/apps/base_rag_example.py b/apps/base_rag_example.pyindex 1517191..1186d99 100644--- a/apps/base_rag_example.py+++ b/apps/base_rag_example.py@@ -391,7 +391,7 @@ class BaseRAGExample(ABC):# Check if index existsindex_path = str(Path(args.index_dir) / f"{self.default_index_name}.leann")- index_exists = Path(args.index_dir).exists()+ index_exists = Path(index_path).exists()if not index_exists or args.force_rebuild:# Load data and build indexdiff --git a/apps/browser_rag.py b/apps/browser_rag.pyindex 00bb3f5..d2affbd 100644--- a/apps/browser_rag.py+++ b/apps/browser_rag.py@@ -55,13 +55,33 @@ class BrowserRAG(BaseRAGExample):)def _get_chrome_base_path(self) -> Path:- """Get the base Chrome profile path based on OS."""+ """Get the base Chrome/Brave profile path based on OS."""if sys.platform == "darwin":- return Path.home() / "Library" / "Application Support" / "Google" / "Chrome"+ # Check for Chrome first, then Brave+ chrome_path = Path.home() / "Library" / "Application Support" / "Google" / "Chrome"+ brave_path = (+ Path.home() / "Library" / "Application Support" / "BraveSoftware" / "Brave-Browser"+ )++ if chrome_path.exists():+ return chrome_path+ return brave_pathelif sys.platform.startswith("linux"):- return Path.home() / ".config" / "google-chrome"+ chrome_path = Path.home() / ".config" / "google-chrome"+ brave_path = Path.home() / ".config" / "BraveSoftware" / "Brave-Browser"++ if chrome_path.exists():+ return chrome_path+ return brave_pathelif sys.platform == "win32":- return Path(os.environ["LOCALAPPDATA"]) / "Google" / "Chrome" / "User Data"+ chrome_path = Path(os.environ["LOCALAPPDATA"]) / "Google" / "Chrome" / "User Data"+ brave_path = (+ Path(os.environ["LOCALAPPDATA"]) / "BraveSoftware" / "Brave-Browser" / "User Data"+ )++ if chrome_path.exists():+ return chrome_path+ return brave_pathelse:raise ValueError(f"Unsupported platform: {sys.platform}")@@ -89,17 +109,13 @@ class BrowserRAG(BaseRAGExample):async def load_data(self, args) -> list[dict[str, Any]]:"""Load browser history and convert to text chunks."""# Determine Chrome profiles- if args.chrome_profile and not args.auto_find_profiles:+ if args.chrome_profile:+ # If specific profile given, use only that oneprofile_dirs = [Path(args.chrome_profile)]else:print("Auto-detecting Chrome profiles...")profile_dirs = self._find_chrome_profiles()- # If specific profile given, filter to just that one- if args.chrome_profile:- profile_path = Path(args.chrome_profile)- profile_dirs = [p for p in profile_dirs if p == profile_path]-if not profile_dirs:print("No Chrome profiles found!")print("Please specify --chrome-profile manually")diff --git a/apps/history_data/history.py b/apps/history_data/history.pyindex f7e23c7..4a0045f 100644--- a/apps/history_data/history.py+++ b/apps/history_data/history.py@@ -40,15 +40,21 @@ class ChromeHistoryReader(BaseReader):)history_db_path = os.path.join(chrome_profile_path, "History")+ temp_db_path = "/tmp/leann_history_copy"if not os.path.exists(history_db_path):print(f"Chrome history database not found at: {history_db_path}")return docstry:- # Connect to the Chrome history database- print(f"Connecting to database: {history_db_path}")- conn = sqlite3.connect(history_db_path)+ # Create a temporary copy of the database to avoid "database is locked" errors+ import shutil++ shutil.copy2(history_db_path, temp_db_path)++ # Connect to the temporary copy+ print(f"Connecting to database copy: {temp_db_path}")+ conn = sqlite3.connect(temp_db_path)cursor = conn.cursor()# Query to get browsing history with metadata (removed created_time column)@@ -93,6 +99,9 @@ class ChromeHistoryReader(BaseReader):count += 1conn.close()+ # Clean up temporary database copy+ if os.path.exists(temp_db_path):+ os.remove(temp_db_path)print(f"Loaded {len(docs)} Chrome history documents")except Exception as e:diff --git a/packages/leann-core/pyproject.toml b/packages/leann-core/pyproject.tomlindex de1dd01..a121a1f 100644--- a/packages/leann-core/pyproject.toml+++ b/packages/leann-core/pyproject.toml@@ -37,6 +37,16 @@ dependencies = ["gitignore-parser>=0.1.12", # For proper .gitignore handling"mlx>=0.26.3; sys_platform == 'darwin' and platform_machine == 'arm64'","mlx-lm>=0.26.0; sys_platform == 'darwin' and platform_machine == 'arm64'",+ # Office document format support+ "python-docx>=1.0.0",+ "python-pptx>=0.6.0",+ "openpyxl>=3.0.0",+ "PyYAML>=6.0.0",+ "lxml>=4.9.0",+ "python-magic>=0.4.0",+ "cryptography>=3.0.0",+ "docx2txt>=0.8",+ "docling>=2.0.0",][project.optional-dependencies]diff --git a/packages/leann-core/src/leann/cli.py b/packages/leann-core/src/leann/cli.pyindex 6d56669..eb0af14 100644--- a/packages/leann-core/src/leann/cli.py+++ b/packages/leann-core/src/leann/cli.py@@ -57,6 +57,11 @@ def extract_pdf_text_with_pymupdf(file_path: str) -> str | None:import fitz # PyMuPDFdoc = fitz.open(file_path)+ # Check if document is encrypted and cannot be opened+ if doc.is_encrypted:+ print(f"⚠️ Skipping encrypted PDF: {file_path}")+ doc.close()+ return Nonetext = ""for page in doc:text += page.get_text()@@ -65,6 +70,10 @@ def extract_pdf_text_with_pymupdf(file_path: str) -> str | None:except ImportError:# Fallback to default readerreturn None+ except Exception as e:+ # Catch all other errors (corrupt PDFs, encoding issues, etc.)+ print(f"⚠️ Skipping problematic PDF ({type(e).__name__}): {file_path}")+ return Nonedef extract_pdf_text_with_pdfplumber(file_path: str) -> str | None:@@ -78,14 +87,195 @@ def extract_pdf_text_with_pdfplumber(file_path: str) -> str | None:text += page.extract_text() or ""return textexcept ImportError:- # Fallback to default reader+ return None+ except Exception as e:+ print(f"⚠️ Skipping problematic PDF with pdfplumber ({type(e).__name__}): {file_path}")+ return None+++def extract_pdf_text_with_pypdf(file_path: str) -> str | None:+ """Extract text from PDF using pypdf as a fast fallback."""+ try:+ from pypdf import PdfReader++ reader = PdfReader(file_path)+ text = ""+ for page in reader.pages:+ text += page.extract_text() or ""+ return text+ except ImportError:+ return None+ except Exception as e:+ print(f"⚠️ Skipping problematic PDF with pypdf ({type(e).__name__}): {file_path}")+ return None+++def extract_pdf_docling(file_path: str) -> str | None:+ """Extract text/tables from PDF using Docling (supports OCR and complex layouts)."""+ try:+ from docling.document_converter import DocumentConverter++ converter = DocumentConverter()+ result = converter.convert(file_path)+ # Exporting to markdown preserves structure better for RAG+ return result.document.export_to_markdown()+ except ImportError:+ return None+ except Exception as e:+ print(f"⚠️ Skipping problematic PDF with Docling ({type(e).__name__}): {file_path}")+ return None+++def extract_pdf_text(file_path: str) -> str | None:+ """Central PDF extraction with fallback chain: PyMuPDF -> pypdf -> pdfplumber -> Docling."""+ # Try PyMuPDF first (usually best layout preservation)+ text = extract_pdf_text_with_pymupdf(file_path)+ if text and text.strip():+ return text++ # Try pypdf (reliable and fast fallback)+ text = extract_pdf_text_with_pypdf(file_path)+ if text and text.strip():+ return text++ # Try pdfplumber (best for complex tables)+ text = extract_pdf_text_with_pdfplumber(file_path)+ if text and text.strip():+ return text++ # Try Docling as the ultimate fallback (OCR, complex layouts)+ text = extract_pdf_docling(file_path)+ if text and text.strip():+ return text++ return None+++def extract_docx_text(file_path: str) -> str | None:+ try:+ from docx import Document++ doc = Document(file_path)+ paragraphs = [p.text for p in doc.paragraphs if p.text.strip()]+ for table in doc.tables:+ for row in table.rows:+ row_text = [cell.text.strip() for cell in row.cells if cell.text.strip()]+ if row_text:+ paragraphs.append(" | ".join(row_text))+ return "\n\n".join(paragraphs) if paragraphs else None+ except ImportError:+ return None+ except Exception as e:+ print(f"⚠️ Skipping problematic DOCX ({type(e).__name__}): {file_path}")+ return None+++def extract_pptx_text(file_path: str) -> str | None:+ try:+ from pptx import Presentation++ prs = Presentation(file_path)+ slides_text = []+ for slide_num, slide in enumerate(prs.slides, 1):+ slide_content = []+ for shape in slide.shapes:+ if hasattr(shape, "text") and shape.text.strip():+ slide_content.append(shape.text.strip())+ if hasattr(shape, "table"):+ for row in shape.table.rows:+ row_text = [cell.text.strip() for cell in row.cells if cell.text.strip()]+ if row_text:+ slide_content.append(" | ".join(row_text))+ if slide_content:+ slides_text.append(f"[Slide {slide_num}]\n" + "\n".join(slide_content))+ return "\n\n".join(slides_text) if slides_text else None+ except ImportError:+ return None+ except Exception as e:+ print(f"⚠️ Skipping problematic PPTX ({type(e).__name__}): {file_path}")+ return None+++def extract_xlsx_text(file_path: str) -> str | None:+ try:+ from openpyxl import load_workbook++ wb = load_workbook(file_path, read_only=True, data_only=True)+ sheets_text = []+ for sheet_name in wb.sheetnames:+ sheet = wb[sheet_name]+ rows = []+ for row in sheet.iter_rows(values_only=True):+ row_values = [str(cell) if cell is not None else "" for cell in row]+ if any(v.strip() for v in row_values):+ rows.append(" | ".join(row_values))+ if rows:+ sheets_text.append(f"[Sheet: {sheet_name}]\n" + "\n".join(rows))+ wb.close()+ return "\n\n".join(sheets_text) if sheets_text else None+ except ImportError:+ return None+ except Exception as e:+ print(f"⚠️ Skipping problematic XLSX ({type(e).__name__}): {file_path}")+ return None+++def extract_mm_text(file_path: str) -> str | None:+ """Extract text from FreeMind/Freeplane .mm files (XML-based mindmaps)."""+ try:+ import xml.etree.ElementTree as ET++ tree = ET.parse(file_path)+ root = tree.getroot()+ extracted_texts = []++ def traverse_node(node_element, level=0):+ indent = " " * level+ text_attr = node_element.get("TEXT")+ if text_attr:+ extracted_texts.append(f"{indent}- {text_attr}")++ # Extract text from <note> child element (FreeMind notes)+ note_element = node_element.find("note")+ if note_element is not None and note_element.text:+ note_text = note_element.text.strip()+ if note_text:+ extracted_texts.append(f"{indent} (Note: {note_text})")++ # For Freeplane, notes can be in <richcontent TYPE="NOTE">+ for rich in node_element.findall("richcontent"):+ if rich.get("TYPE") == "NOTE":+ # Simple text extraction from rich content+ rich_text = "".join(rich.itertext()).strip()+ if rich_text:+ extracted_texts.append(f"{indent} (Note: {rich_text})")++ # Recursively traverse child nodes+ for child_node in node_element.findall("node"):+ traverse_node(child_node, level + 1)++ # Start traversal from any top-level node elements+ for node_child in root.findall("node"):+ traverse_node(node_child, level=0)++ return "\n".join(extracted_texts) if extracted_texts else None+ except Exception as e:+ print(f"⚠️ Skipping problematic MM ({type(e).__name__}): {file_path} - {e}")return Noneclass LeannCLI:def __init__(self):- # Always use project-local .leann directory (like .git)- self.indexes_dir = Path.cwd() / ".leann" / "indexes"+ # Central storage logic+ leann_home_env = os.environ.get("LEANN_HOME")+ if leann_home_env:+ # If LEANN_HOME is set, use it as the base (global/central storage)+ self.leann_home = Path(leann_home_env).expanduser().resolve()+ else:+ # Otherwise, use project-local .leann directory (like .git)+ self.leann_home = Path.cwd() / ".leann"++ self.indexes_dir = self.leann_home / "indexes"self.indexes_dir.mkdir(parents=True, exist_ok=True)# Default parser for documents@@ -462,6 +652,101 @@ Examples:"--port", type=int, default=None, help="Port to bind to (default: 8000)")+ # Browser Index Command+ browser_parser = subparsers.add_parser("index-browser", help="Index browser history")+ browser_parser.add_argument(+ "browser_type", choices=["chrome", "brave"], help="Type of browser"+ )+ browser_parser.add_argument(+ "--profile", type=str, default="Default", help="Profile name (default: Default)"+ )+ browser_parser.add_argument(+ "--index-name", type=str, default=None, help="Custom index name"+ )+ browser_parser.add_argument(+ "--max-items", type=int, default=1000, help="Max history items to index"+ )++ # Email indexing command+ email_parser = subparsers.add_parser("index-email", help="Index Apple Mail emails")+ email_parser.add_argument(+ "index_name", nargs="?", default="apple-mail", help="Index name (default: apple-mail)"+ )+ email_parser.add_argument(+ "--max-items", type=int, default=2000, help="Max emails to index (default: 2000)"+ )++ # Calendar indexing command+ calendar_parser = subparsers.add_parser(+ "index-calendar", help="Index Apple Calendar events"+ )+ calendar_parser.add_argument(+ "index_name",+ nargs="?",+ default="apple-calendar",+ help="Index name (default: apple-calendar)",+ )+ calendar_parser.add_argument(+ "--max-items", type=int, default=1000, help="Max events to index (default: 1000)"+ )++ # WeChat indexing command+ wechat_parser = subparsers.add_parser("index-wechat", help="Index WeChat chat history")+ wechat_parser.add_argument(+ "index_name", nargs="?", default="wechat", help="Index name (default: wechat)"+ )+ wechat_parser.add_argument(+ "--export-dir",+ type=str,+ default="./wechat_export",+ help="Directory for WeChat exports",+ )+ wechat_parser.add_argument(+ "--max-items", type=int, default=1000, help="Max chat entries to index"+ )++ # iMessage indexing command+ imessage_parser = subparsers.add_parser("index-imessage", help="Index iMessage history")+ imessage_parser.add_argument(+ "index_name", nargs="?", default="imessage", help="Index name (default: imessage)"+ )+ imessage_parser.add_argument("--db-path", type=str, help="Custom chat.db path")+ imessage_parser.add_argument(+ "--max-items", type=int, default=2000, help="Max messages to index"+ )++ # Slack indexing command+ slack_parser = subparsers.add_parser("index-slack", help="Index Slack workspace via MCP")+ slack_parser.add_argument(+ "index_name", nargs="?", default="slack", help="Index name (default: slack)"+ )+ slack_parser.add_argument(+ "--mcp-server",+ type=str,+ required=True,+ help="MCP server command (e.g. 'slack-mcp-server')",+ )+ slack_parser.add_argument("--workspace", type=str, help="Slack workspace name")+ slack_parser.add_argument("--channels", nargs="+", help="Specific channels to index")++ # ChatGPT indexing command+ chatgpt_parser = subparsers.add_parser("index-chatgpt", help="Index ChatGPT export")+ chatgpt_parser.add_argument(+ "index_name", nargs="?", default="chatgpt", help="Index name (default: chatgpt)"+ )+ chatgpt_parser.add_argument(+ "--export-path", type=str, required=True, help="Path to export file"+ )++ # Claude indexing command+ claude_parser = subparsers.add_parser("index-claude", help="Index Claude export")+ claude_parser.add_argument(+ "index_name", nargs="?", default="claude", help="Index name (default: claude)"+ )+ claude_parser.add_argument(+ "--export-path", type=str, required=True, help="Path to export file"+ )+return parserdef register_project_dir(self):@@ -572,9 +857,14 @@ Examples:total_indexes = 0current_indexes_count = 0- # Show current project first (most important)- print("\n🏠 Current Project")- print(f" {current_path}")+ # Show current storage header+ leann_home_env = os.environ.get("LEANN_HOME")+ if leann_home_env:+ print("\n🏠 Central Index Storage (LEANN_HOME)")+ print(f" {self.leann_home}")+ else:+ print("\n🏠 Current Project (Local)")+ print(f" {current_path}")print(" " + "─" * 45)current_indexes = self._discover_indexes_in_project(@@ -629,15 +919,12 @@ Examples:print(f"📊 Total: {total_indexes} indexes across {projects_count} projects")if current_indexes_count > 0:- print("\n💫 Quick start (current project):")+ print("\n💫 Quick start:")# Get first index from current project for example- current_indexes_dir = current_path / ".leann" / "indexes"- if current_indexes_dir.exists():- current_index_dirs = [d for d in current_indexes_dir.iterdir() if d.is_dir()]- if current_index_dirs:- example_name = current_index_dirs[0].name- print(f' leann search {example_name} "your query"')- print(f" leann ask {example_name} --interactive")+ example_idx = current_indexes[0]+ example_name = example_idx["name"]+ print(f' leann search {example_name} "your query"')+ print(f" leann ask {example_name} --interactive")else:print("\n💡 Create your first index:")print(" leann build my-docs --docs ./documents")@@ -659,40 +946,120 @@ Examples:except Exception:exclude_dirs_resolved = exclude_dirs- # 1. CLI format: .leann/indexes/index_name/- cli_indexes_dir = project_path / ".leann" / "indexes"- if cli_indexes_dir.exists():- for index_dir in cli_indexes_dir.iterdir():- if index_dir.is_dir():- meta_file = index_dir / "documents.leann.meta.json"- status = "✅" if meta_file.exists() else "❌"+ # 1. CLI format: .leann/indexes/index_name/ (Check both central and local)+ # First, check the central indexes dir we set in __init__+ dirs_to_check = [self.indexes_dir]++ # If project_path is different from our central leann_home, also check project-local .leann+ try:+ local_indexes_dir = project_path / ".leann" / "indexes"+ if (+ local_indexes_dir.resolve() != self.indexes_dir.resolve()+ and local_indexes_dir.exists()+ ):+ dirs_to_check.append(local_indexes_dir)+ except (OSError, PermissionError):+ pass- size_mb = 0- if meta_file.exists():+ for cli_indexes_dir in dirs_to_check:+ try:+ if cli_indexes_dir.exists():+ for index_dir in cli_indexes_dir.iterdir():+ if index_dir.is_dir():+ meta_file = index_dir / "documents.leann.meta.json"+ status = "✅" if meta_file.exists() else "❌"++ size_mb = 0+ if meta_file.exists():+ try:+ size_mb = sum(+ f.stat().st_size for f in index_dir.iterdir() if f.is_file()+ ) / (1024 * 1024)+ except (OSError, PermissionError):+ pass++ # Avoid duplicates if checking multiple directories+ if any(idx["name"] == index_dir.name for idx in indexes):+ continue++ indexes.append(+ {+ "name": index_dir.name,+ "type": "cli",+ "status": status,+ "size_mb": size_mb,+ "path": index_dir,+ }+ )+ except (OSError, PermissionError, FileNotFoundError):+ continue++ # 2. Apps format: *.leann.meta.json files anywhere in the project+ exclusion_indexes_dir = self.indexes_dir+ try:+ # Use a more robust scanning to avoid FileNotFoundError on transient files+ for meta_file in project_path.rglob("*.leann.meta.json"):+ try:+ if meta_file.is_file():+ # Skip CLI-built indexes (which store meta under .leann/indexes/<name>/)+ try:+ if (+ exclusion_indexes_dir.exists()+ and exclusion_indexes_dir in meta_file.parents+ ):+ continue+ except Exception:+ pass++ # Skip meta files that live under excluded directoriestry:- size_mb = sum(- f.stat().st_size for f in index_dir.iterdir() if f.is_file()- ) / (1024 * 1024)+ meta_parent_resolved = meta_file.parent.resolve()+ if any(+ meta_parent_resolved.is_relative_to(ex_dir)+ for ex_dir in exclude_dirs_resolved+ ):+ continue+ except Exception:+ pass++ display_name = meta_file.parent.name+ file_base = meta_file.name.replace(".leann.meta.json", "")+ status = "✅"++ size_mb = 0+ try:+ index_dir = meta_file.parent+ for related_file in index_dir.glob(f"{file_base}.leann*"):+ size_mb += related_file.stat().st_size / (1024 * 1024)except (OSError, PermissionError):pass- indexes.append(- {- "name": index_dir.name,- "type": "cli",- "status": status,- "size_mb": size_mb,- "path": index_dir,- }- )+ indexes.append(+ {+ "name": display_name,+ "type": "app",+ "status": status,+ "size_mb": size_mb,+ "path": meta_file,+ }+ )+ except (OSError, PermissionError, FileNotFoundError):+ continue+ except (OSError, PermissionError):+ pass++ return indexes# 2. Apps format: *.leann.meta.json files anywhere in the project- cli_indexes_dir = project_path / ".leann" / "indexes"+ exclusion_indexes_dir = self.indexes_dirfor meta_file in project_path.rglob("*.leann.meta.json"):if meta_file.is_file():# Skip CLI-built indexes (which store meta under .leann/indexes/<name>/)try:- if cli_indexes_dir.exists() and cli_indexes_dir in meta_file.parents:+ if (+ exclusion_indexes_dir.exists()+ and exclusion_indexes_dir in meta_file.parents+ ):continueexcept Exception:pass@@ -1092,6 +1459,14 @@ Examples:print(f"⚠️ Warning: Path '{path}' does not exist, skipping...")continue+ # Define custom extractors map+ custom_extractors = {+ ".docx": extract_docx_text,+ ".pptx": extract_pptx_text,+ ".xlsx": extract_xlsx_text,+ ".mm": extract_mm_text,+ }+# Print summary of what we're processingtotal_items = len(files) + len(directories)items_desc = []@@ -1121,42 +1496,49 @@ Examples:if files:print(f"\n🔄 Processing {len(files)} individual file{'s' if len(files) > 1 else ''}...")- # Load individual files using SimpleDirectoryReader with input_files- # Note: We skip gitignore filtering for explicitly specified files- try:- # Group files by their parent directory for efficient loading- from collections import defaultdict-- files_by_dir = defaultdict(list)- for file_path in files:- file_path_obj = Path(file_path)- if not include_hidden and _path_has_hidden_segment(file_path_obj):- print(f" ⚠️ Skipping hidden file: {file_path}")- continue- parent_dir = str(file_path_obj.parent)- files_by_dir[parent_dir].append(str(file_path_obj))+ for file_path in files:+ file_path_obj = Path(file_path)+ if not include_hidden and _path_has_hidden_segment(file_path_obj):+ print(f" ⚠️ Skipping hidden file: {file_path}")+ continue- # Load files from each parent directory- for parent_dir, file_list in files_by_dir.items():- print(- f" Loading {len(file_list)} file{'s' if len(file_list) > 1 else ''} from {parent_dir}"- )+ ext = file_path_obj.suffix.lower()+ doc = None++ # Try PDF extraction first if it's a PDF+ if ext == ".pdf":+ text = extract_pdf_text(file_path)+ if text:+ from llama_index.core import Document++ doc = Document(text=text, metadata={"source": file_path})++ # Try custom extractors (DOCX, PPTX, XLSX, MM)+ elif ext in custom_extractors:+ text = custom_extractors[ext](file_path)+ if text:+ from llama_index.core import Document++ doc = Document(text=text, metadata={"source": file_path})++ # If handled by custom logic, add it+ if doc:+ all_documents.append(doc)+ print(f" ✅ Loaded custom format: {file_path_obj.name}")+ else:+ # Fallback to SimpleDirectoryReader for other filestry:file_docs = SimpleDirectoryReader(- parent_dir,- input_files=file_list,- # exclude_hidden only affects directory scans; input_files are explicit+ str(file_path_obj.parent),+ input_files=[file_path],filename_as_id=True,).load_data()+ for d in file_docs:+ d.metadata["source"] = file_pathall_documents.extend(file_docs)- print(- f" ✅ Loaded {len(file_docs)} document{'s' if len(file_docs) > 1 else ''}"- )+ print(f" ✅ Loaded: {file_path_obj.name}")except Exception as e:- print(f" ❌ Warning: Could not load files from {parent_dir}: {e}")-- except Exception as e:- print(f"❌ Error processing individual files: {e}")+ print(f" ❌ Warning: Could not load file {file_path}: {e}")# Define file extensions to processif custom_file_types:@@ -1167,12 +1549,12 @@ Examples:else:# Use default supported file typescode_extensions = [- # Original document types".txt",".md",".docx",".pptx",- # Code files for Claude Code integration+ ".xlsx",+ ".mm",".py",".js",".ts",@@ -1261,11 +1643,7 @@ Examples:print(f"Processing PDF: {file_path}")- # Try PyMuPDF first (best quality)- text = extract_pdf_text_with_pymupdf(str(file_path))- if text is None:- # Try pdfplumber- text = extract_pdf_text_with_pdfplumber(str(file_path))+ text = extract_pdf_text(str(file_path))if text:# Create a simple document structure@@ -1287,50 +1665,111 @@ Examples:except Exception as e:print(f"Warning: Could not process {file_path}: {e}")- # Load other file types with default reader- # Exclude PDFs from code_extensions if they were already processed separately+ for ext, extractor in custom_extractors.items():+ should_process = custom_file_types is None or ext in custom_file_types+ if not should_process:+ continue+ for file_path in docs_path.rglob(f"*{ext}"):+ try:+ file_path_resolved = file_path.resolve()+ relative_path = file_path.relative_to(docs_path)+ if not include_hidden and _path_has_hidden_segment(relative_path):+ continue+ if self._should_exclude_file(file_path_resolved, gitignore_matches):+ continue+ except ValueError:+ print(f"⚠️ Skipping file outside directory scope: {file_path}")+ continue+ print(f"Processing {ext.upper()[1:]}: {file_path}")+ text = extractor(str(file_path))+ if text:+ from llama_index.core import Document++ doc = Document(text=text, metadata={"source": str(file_path)})+ documents.append(doc)+ else:+ print(f"⚠️ Could not extract text from: {file_path}")+other_file_extensions = code_extensions- if should_process_pdfs and ".pdf" in code_extensions:- other_file_extensions = [ext for ext in code_extensions if ext != ".pdf"]+ processed_extensions = [".pdf", *custom_extractors.keys()]+ other_file_extensions = [+ ext for ext in code_extensions if ext not in processed_extensions+ ]try:- # Create a custom file filter function using our PathSpec++ def is_valid_file(file_path: Path) -> bool:+ try:+ if file_path.is_symlink():+ resolved = file_path.resolve()+ if not resolved.exists():+ return False+ elif not file_path.exists():+ return False+ return True+ except (OSError, PermissionError):+ return False+def file_filter(file_path: str, docs_dir=docs_dir, gitignore_matches=gitignore_matches) -> bool:- """Return True if file should be included (not excluded)"""try:+ file_path_obj = Path(file_path)+ if not is_valid_file(file_path_obj):+ return Falsedocs_path_obj = Path(docs_dir).resolve()- file_path_obj = Path(file_path).resolve()- # Use absolute path for gitignore matching- _ = file_path_obj.relative_to(docs_path_obj) # validate scope+ file_path_obj = file_path_obj.resolve()+ _ = file_path_obj.relative_to(docs_path_obj)return not self._should_exclude_file(file_path_obj, gitignore_matches)except (ValueError, OSError):- return True # Include files that can't be processed+ return False- # Only load other file types if there are extensions to processif other_file_extensions:- other_docs = SimpleDirectoryReader(- docs_dir,- recursive=True,- encoding="utf-8",- required_exts=other_file_extensions,- file_extractor={}, # Use default extractors- exclude_hidden=not include_hidden,- filename_as_id=True,- ).load_data(show_progress=True)+ try:+ docs_path = Path(docs_dir)+ valid_files = []+ ext_set = set(other_file_extensions)+ for file_path in docs_path.rglob("*"):+ if file_path.suffix.lower() not in ext_set:+ continue+ if not include_hidden and _path_has_hidden_segment(+ file_path.relative_to(docs_path)+ ):+ continue+ if not is_valid_file(file_path):+ print(f"⚠️ Skipping broken symlink: {file_path}")+ continue+ if self._should_exclude_file(file_path.resolve(), gitignore_matches):+ continue+ valid_files.append(str(file_path))++ if valid_files:+ other_docs = SimpleDirectoryReader(+ input_files=valid_files,+ encoding="utf-8",+ file_extractor={},+ filename_as_id=True,+ ).load_data(show_progress=True)+ else:+ other_docs = []+ except FileNotFoundError as fnf_err:+ print(f"⚠️ Skipping broken symlink or missing file: {fnf_err}")+ other_docs = []+ except Exception as load_err:+ print(f"⚠️ Error loading documents from {docs_dir}: {load_err}")+ other_docs = []else:other_docs = []- # Filter documents after loading based on gitignore rules- filtered_docs = []for doc in other_docs:- file_path = doc.metadata.get("file_path", "")- if file_filter(file_path):+ try:+ file_path = doc.metadata.get("file_path", "")doc.metadata["source"] = file_path- filtered_docs.append(doc)+ documents.append(doc)+ except Exception as doc_err:+ print(f"⚠️ Skipping document due to metadata error: {doc_err}")+ continue- documents.extend(filtered_docs)except ValueError as e:if "No files found" in str(e):print(f"No additional files found for other supported types in {docs_dir}.")@@ -1564,6 +2003,317 @@ Examples:# Register this project directory in global registryself.register_project_dir()+ async def index_browser(self, args):+ """Build an index from browser history."""+ from .readers import ChromeHistoryReader++ browser_type = args.browser_type+ profile = args.profile+ index_name = args.index_name or f"{browser_type}-history"++ index_dir = self.indexes_dir / index_name+ index_path = str(index_dir / "documents.leann")++ print(f"🌐 Indexing {browser_type.capitalize()} history (profile: {profile})...")++ # Find browser path+ paths = ChromeHistoryReader.find_browser_paths()+ if browser_type not in paths:+ print(f"❌ Could not find {browser_type} profile directory automatically.")+ return++ profile_path = paths[browser_type] / profile++ reader = ChromeHistoryReader()+ documents = reader.load_data(+ chrome_profile_path=str(profile_path), max_count=args.max_items+ )++ if not documents:+ print("❌ No history entries found to index.")+ return++ print(f"📚 Loaded {len(documents)} entries. Building index...")++ index_dir.mkdir(parents=True, exist_ok=True)++ embedding_options = {}+ if args.embedding_mode == "ollama":+ embedding_options["host"] = resolve_ollama_host(None)++ builder = LeannBuilder(+ backend_name="hnsw", # Default to hnsw for browser history+ embedding_model=args.embedding_model,+ embedding_mode=args.embedding_mode,+ embedding_options=embedding_options or None,+ is_recompute=False, # Store embeddings for fast browser history search+ is_compact=False, # Disable compact storage to keep full embeddings+ )++ for doc in documents:+ builder.add_text(doc.text, metadata=doc.metadata)++ builder.build_index(index_path)+ print(f"✅ Browser history index built at: {index_path}")+ print(f' Usage: leann search {index_name} "query"')++ async def index_email(self, args):+ """Build an index from Apple Mail emails."""+ from .readers import AppleMailReader++ index_name = args.index_name+ index_dir = self.indexes_dir / index_name+ index_path = str(index_dir / "documents.leann")++ print("📧 Indexing Apple Mail emails...")++ reader = AppleMailReader()+ documents = reader.load_data(max_count=args.max_items)++ if not documents:+ print("❌ No emails found to index. Make sure Full Disk Access is granted.")+ return++ print(f"📚 Loaded {len(documents)} emails. Building index...")+ index_dir.mkdir(parents=True, exist_ok=True)++ embedding_options = {}+ if args.embedding_mode == "ollama":+ embedding_options["host"] = resolve_ollama_host(None)++ builder = LeannBuilder(+ backend_name="hnsw",+ embedding_model=args.embedding_model,+ embedding_mode=args.embedding_mode,+ embedding_options=embedding_options or None,+ is_recompute=False,+ is_compact=False,+ )++ for doc in documents:+ builder.add_text(doc.text, metadata=doc.metadata)++ builder.build_index(index_path)+ print(f"✅ Email index built at: {index_path}")+ print(f' Usage: leann search {index_name} "query"')++ async def index_calendar(self, args):+ """Build an index from Apple Calendar events."""+ from .readers import AppleCalendarReader++ index_name = args.index_name+ index_dir = self.indexes_dir / index_name+ index_path = str(index_dir / "documents.leann")++ print("📅 Indexing Apple Calendar events...")++ reader = AppleCalendarReader()+ documents = reader.load_data(max_count=args.max_items)++ if not documents:+ print("❌ No calendar events found to index. Make sure Full Disk Access is granted.")+ return++ print(f"📚 Loaded {len(documents)} events. Building index...")+ index_dir.mkdir(parents=True, exist_ok=True)++ embedding_options = {}+ if args.embedding_mode == "ollama":+ embedding_options["host"] = resolve_ollama_host(None)++ builder = LeannBuilder(+ backend_name="hnsw",+ embedding_model=args.embedding_model,+ embedding_mode=args.embedding_mode,+ embedding_options=embedding_options or None,+ is_recompute=False,+ is_compact=False,+ )++ for doc in documents:+ builder.add_text(doc.text, metadata=doc.metadata)++ builder.build_index(index_path)+ print(f"✅ Calendar index built at: {index_path}")+ print(f' Usage: leann search {index_name} "query"')++ async def index_wechat(self, args):+ """Build an index from WeChat chat history."""+ from .readers import WeChatHistoryReader++ index_name = args.index_name+ index_dir = self.indexes_dir / index_name+ index_path = str(index_dir / "documents.leann")++ print(f"💬 Indexing WeChat history from {args.export_dir}...")++ reader = WeChatHistoryReader()+ documents = reader.load_data(wechat_export_dir=args.export_dir, max_count=args.max_items)++ if not documents:+ print("❌ No WeChat history found.")+ return++ print(f"📚 Loaded {len(documents)} chat threads. Building index...")+ index_dir.mkdir(parents=True, exist_ok=True)++ builder = LeannBuilder(+ backend_name="hnsw",+ embedding_model=args.embedding_model,+ embedding_mode=args.embedding_mode,+ is_recompute=False,+ is_compact=False,+ )++ for doc in documents:+ builder.add_text(doc.text, metadata=doc.metadata)++ builder.build_index(index_path)+ print(f"✅ WeChat index built at: {index_path}")++ async def index_imessage(self, args):+ """Build an index from iMessage history."""+ from .readers import IMessageReader++ index_name = args.index_name+ index_dir = self.indexes_dir / index_name+ index_path = str(index_dir / "documents.leann")++ print("💬 Indexing iMessage history...")++ reader = IMessageReader(concatenate_conversations=True)+ documents = reader.load_data(input_dir=args.db_path)++ if not documents:+ print("❌ No iMessage history found.")+ return++ if args.max_items > 0:+ documents = documents[: args.max_items]++ print(f"📚 Loaded {len(documents)} conversations. Building index...")+ index_dir.mkdir(parents=True, exist_ok=True)++ builder = LeannBuilder(+ backend_name="hnsw",+ embedding_model=args.embedding_model,+ embedding_mode=args.embedding_mode,+ is_recompute=False,+ is_compact=False,+ )++ for doc in documents:+ builder.add_text(doc.text, metadata=doc.metadata)++ builder.build_index(index_path)+ print(f"✅ iMessage index built at: {index_path}")++ async def index_slack(self, args):+ """Build an index from Slack via MCP."""+ from .readers import SlackMCPReader++ index_name = args.index_name+ index_dir = self.indexes_dir / index_name+ index_path = str(index_dir / "documents.leann")++ print(f"💬 Indexing Slack via {args.mcp_server}...")++ reader = SlackMCPReader(+ mcp_server_command=args.mcp_server,+ workspace_name=args.workspace,+ concatenate_conversations=True,+ )+ documents = await reader.load_data(channels=args.channels)++ if not documents:+ print("❌ No Slack messages found or MCP server failed.")+ return++ print(f"📚 Loaded {len(documents)} items. Building index...")+ index_dir.mkdir(parents=True, exist_ok=True)++ builder = LeannBuilder(+ backend_name="hnsw",+ embedding_model=args.embedding_model,+ embedding_mode=args.embedding_mode,+ is_recompute=False,+ is_compact=False,+ )++ for doc in documents:+ builder.add_text(doc.text, metadata=doc.metadata)++ builder.build_index(index_path)+ print(f"✅ Slack index built at: {index_path}")++ async def index_chatgpt(self, args):+ """Build an index from ChatGPT export."""+ from .readers import ChatGPTReader++ index_name = args.index_name+ index_dir = self.indexes_dir / index_name+ index_path = str(index_dir / "documents.leann")++ print(f"🤖 Indexing ChatGPT export from {args.export_path}...")++ reader = ChatGPTReader()+ documents = reader.load_data(export_path=args.export_path)++ if not documents:+ print("❌ No ChatGPT data found.")+ return++ print(f"📚 Loaded {len(documents)} conversations. Building index...")+ index_dir.mkdir(parents=True, exist_ok=True)++ builder = LeannBuilder(+ backend_name="hnsw",+ embedding_model=args.embedding_model,+ embedding_mode=args.embedding_mode,+ is_recompute=False,+ is_compact=False,+ )++ for doc in documents:+ builder.add_text(doc.text, metadata=doc.metadata)++ builder.build_index(index_path)+ print(f"✅ ChatGPT index built at: {index_path}")++ async def index_claude(self, args):+ """Build an index from Claude export."""+ from .readers import ClaudeReader++ index_name = args.index_name+ index_dir = self.indexes_dir / index_name+ index_path = str(index_dir / "documents.leann")++ print(f"🤖 Indexing Claude export from {args.export_path}...")++ reader = ClaudeReader()+ documents = reader.load_data(export_path=args.export_path)++ if not documents:+ print("❌ No Claude data found.")+ return++ print(f"📚 Loaded {len(documents)} conversations. Building index...")+ index_dir.mkdir(parents=True, exist_ok=True)++ builder = LeannBuilder(+ backend_name="hnsw",+ embedding_model=args.embedding_model,+ embedding_mode=args.embedding_mode,+ is_recompute=False,+ is_compact=False,+ )++ for doc in documents:+ builder.add_text(doc.text, metadata=doc.metadata)++ builder.build_index(index_path)+ print(f"✅ Claude index built at: {index_path}")+async def search_documents(self, args):index_name = args.index_namequery = args.query@@ -1902,6 +2652,30 @@ Examples:elif args.command == "react":with suppress_cpp_output(suppress):await self.react_agent(args)+ elif args.command == "index-browser":+ with suppress_cpp_output(suppress):+ await self.index_browser(args)+ elif args.command == "index-email":+ with suppress_cpp_output(suppress):+ await self.index_email(args)+ elif args.command == "index-calendar":+ with suppress_cpp_output(suppress):+ await self.index_calendar(args)+ elif args.command == "index-wechat":+ with suppress_cpp_output(suppress):+ await self.index_wechat(args)+ elif args.command == "index-imessage":+ with suppress_cpp_output(suppress):+ await self.index_imessage(args)+ elif args.command == "index-slack":+ with suppress_cpp_output(suppress):+ await self.index_slack(args)+ elif args.command == "index-chatgpt":+ with suppress_cpp_output(suppress):+ await self.index_chatgpt(args)+ elif args.command == "index-claude":+ with suppress_cpp_output(suppress):+ await self.index_claude(args)elif args.command == "serve":await self.serve_api(args)else:diff --git a/packages/leann-core/src/leann/readers.py b/packages/leann-core/src/leann/readers.pynew file mode 100644index 0000000..bc6643b--- /dev/null+++ b/packages/leann-core/src/leann/readers.py@@ -0,0 +1,687 @@+import json+import os+import re+import shutil+import sqlite3+from datetime import datetime+from pathlib import Path+from typing import Any++from llama_index.core import Document+from llama_index.core.readers.base import BaseReader+++class ChromeHistoryReader(BaseReader):+ """+ Chrome/Brave browser history reader that extracts browsing data from SQLite database.+ Supports reading from a copy to avoid locking issues.+ """++ def __init__(self) -> None:+ pass++ def load_data(+ self, chrome_profile_path: str | None = None, max_count: int = 1000+ ) -> list[Document]:+ docs: list[Document] = []++ if chrome_profile_path is None:+ # Default fallback for macOS+ chrome_profile_path = os.path.expanduser(+ "~/Library/Application Support/Google/Chrome/Default"+ )++ history_db_path = os.path.join(chrome_profile_path, "History")+ temp_db_path = "/tmp/leann_history_index_copy"++ if not os.path.exists(history_db_path):+ print(f"⚠️ Browser history database not found at: {history_db_path}")+ return docs++ try:+ # Create a temporary copy to avoid "database is locked"+ shutil.copy2(history_db_path, temp_db_path)++ conn = sqlite3.connect(temp_db_path)+ cursor = conn.cursor()++ query = """+ SELECT+ datetime(last_visit_time/1000000-11644473600,'unixepoch','localtime') as last_visit,+ url,+ title,+ visit_count,+ typed_count,+ hidden+ FROM urls+ ORDER BY last_visit_time DESC+ """++ cursor.execute(query)+ rows = cursor.fetchall()++ for row in rows:+ if 0 < max_count <= len(docs):+ break++ last_visit, url, title, visit_count, typed_count, _hidden = row+ if not title or not url:+ continue++ doc_content = f"""+[Title]: {title}+[URL]: {url}+[Last Visited]: {last_visit}+[Visits]: {visit_count}+"""+ doc = Document(text=doc_content, metadata={"title": title[0:150], "url": url})+ docs.append(doc)++ conn.close()+ if os.path.exists(temp_db_path):+ os.remove(temp_db_path)++ except Exception as e:+ print(f"❌ Error reading browser history: {e}")+ if os.path.exists(temp_db_path):+ os.remove(temp_db_path)+ return docs++ return docs++ @staticmethod+ def find_browser_paths() -> dict[str, Path]:+ """Find common browser profile base paths."""+ paths = {}+ home = Path.home()++ if os.name == "posix": # macOS/Linux+ # macOS paths+ chrome = home / "Library/Application Support/Google/Chrome"+ brave = home / "Library/Application Support/BraveSoftware/Brave-Browser"+ if chrome.exists():+ paths["chrome"] = chrome+ if brave.exists():+ paths["brave"] = brave++ return paths+++class IMessageReader(BaseReader):+ """+ iMessage data reader.++ Reads iMessage conversation data from the macOS Messages database (chat.db).+ Processes conversations into structured documents with metadata.+ """++ def __init__(self, concatenate_conversations: bool = True) -> None:+ """+ Initialize.++ Args:+ concatenate_conversations: Whether to concatenate messages within conversations for better context+ """+ self.concatenate_conversations = concatenate_conversations++ def _get_default_chat_db_path(self) -> Path:+ """+ Get the default path to the iMessage chat database.++ Returns:+ Path to the chat.db file+ """+ home = Path.home()+ return home / "Library" / "Messages" / "chat.db"++ def _convert_cocoa_timestamp(self, cocoa_timestamp: int) -> str:+ """+ Convert Cocoa timestamp to readable format.++ Args:+ cocoa_timestamp: Timestamp in Cocoa format (nanoseconds since 2001-01-01)++ Returns:+ Formatted timestamp string+ """+ if cocoa_timestamp == 0:+ return "Unknown"++ try:+ # Cocoa timestamp is nanoseconds since 2001-01-01 00:00:00 UTC+ # Convert to seconds and add to Unix epoch+ cocoa_epoch = datetime(2001, 1, 1)+ unix_timestamp = cocoa_timestamp / 1_000_000_000 # Convert nanoseconds to seconds+ message_time = cocoa_epoch.timestamp() + unix_timestamp+ return datetime.fromtimestamp(message_time).strftime("%Y-%m-%d %H:%M:%S")+ except (ValueError, OSError):+ return "Unknown"++ def _get_contact_name(self, handle_id: str) -> str:+ """+ Get a readable contact name from handle ID.++ Args:+ handle_id: The handle ID (phone number or email)++ Returns:+ Formatted contact name+ """+ if not handle_id:+ return "Unknown"++ # Clean up phone numbers and emails for display+ if "@" in handle_id:+ return handle_id # Email address+ elif handle_id.startswith("+"):+ return handle_id # International phone number+ else:+ # Try to format as phone number+ digits = "".join(filter(str.isdigit, handle_id))+ if len(digits) == 10:+ return f"({digits[:3]}) {digits[3:6]}-{digits[6:]}"+ elif len(digits) == 11 and digits[0] == "1":+ return f"+1 ({digits[1:4]}) {digits[4:7]}-{digits[7:]}"+ else:+ return handle_id++ def _read_messages_from_db(self, db_path: Path) -> list[dict]:+ """+ Read messages from the iMessage database.++ Args:+ db_path: Path to the chat.db file++ Returns:+ List of message dictionaries+ """+ if not db_path.exists():+ print(f"iMessage database not found at: {db_path}")+ return []++ try:+ # Connect to the database+ conn = sqlite3.connect(str(db_path))+ cursor = conn.cursor()++ # Query to get messages with chat and handle information+ query = """+ SELECT+ m.ROWID as message_id,+ m.text,+ m.date,+ m.is_from_me,+ m.service,+ c.chat_identifier,+ c.display_name as chat_display_name,+ h.id as handle_id,+ c.ROWID as chat_id+ FROM message m+ LEFT JOIN chat_message_join cmj ON m.ROWID = cmj.message_id+ LEFT JOIN chat c ON cmj.chat_id = c.ROWID+ LEFT JOIN handle h ON m.handle_id = h.ROWID+ WHERE m.text IS NOT NULL AND m.text != ''+ ORDER BY c.ROWID, m.date+ """++ cursor.execute(query)+ rows = cursor.fetchall()++ messages = []+ for row in rows:+ (+ message_id,+ text,+ date,+ is_from_me,+ service,+ chat_identifier,+ chat_display_name,+ handle_id,+ chat_id,+ ) = row++ message = {+ "message_id": message_id,+ "text": text,+ "timestamp": self._convert_cocoa_timestamp(date),+ "is_from_me": bool(is_from_me),+ "service": service or "iMessage",+ "chat_identifier": chat_identifier or "Unknown",+ "chat_display_name": chat_display_name or "Unknown Chat",+ "handle_id": handle_id or "Unknown",+ "contact_name": self._get_contact_name(handle_id or ""),+ "chat_id": chat_id,+ }+ messages.append(message)++ conn.close()+ return messages++ except sqlite3.Error as e:+ print(f"Error reading iMessage database: {e}")+ return []+ except Exception as e:+ print(f"Unexpected error reading iMessage database: {e}")+ return []++ def _group_messages_by_chat(self, messages: list[dict]) -> dict[int, list[dict]]:+ """+ Group messages by chat ID.++ Args:+ messages: List of message dictionaries++ Returns:+ Dictionary mapping chat_id to list of messages+ """+ chats = {}+ for message in messages:+ chat_id = message["chat_id"]+ if chat_id not in chats:+ chats[chat_id] = []+ chats[chat_id].append(message)++ return chats++ def _create_concatenated_content(self, chat_id: int, messages: list[dict]) -> str:+ """+ Create concatenated content from chat messages.++ Args:+ chat_id: The chat ID+ messages: List of messages in the chat++ Returns:+ Concatenated text content+ """+ if not messages:+ return ""++ # Get chat info from first message+ first_msg = messages[0]+ chat_name = first_msg["chat_display_name"]+ chat_identifier = first_msg["chat_identifier"]++ # Build message content+ message_parts = []+ for message in messages:+ timestamp = message["timestamp"]+ is_from_me = message["is_from_me"]+ text = message["text"]+ contact_name = message["contact_name"]++ if is_from_me:+ prefix = "[You]"+ else:+ prefix = f"[{contact_name}]"++ if timestamp != "Unknown":+ prefix += f" ({timestamp})"++ message_parts.append(f"{prefix}: {text}")++ concatenated_text = "\n\n".join(message_parts)++ doc_content = f"""Chat: {chat_name}+Identifier: {chat_identifier}+Messages ({len(messages)} messages):++{concatenated_text}+"""+ return doc_content++ def _create_individual_content(self, message: dict) -> str:+ """+ Create content for individual message.++ Args:+ message: Message dictionary++ Returns:+ Formatted message content+ """+ timestamp = message["timestamp"]+ is_from_me = message["is_from_me"]+ text = message["text"]+ contact_name = message["contact_name"]+ chat_name = message["chat_display_name"]++ sender = "You" if is_from_me else contact_name++ return f"""Message from {sender} in chat "{chat_name}"+Time: {timestamp}+Content: {text}+"""++ def load_data(self, input_dir: str | None = None, **load_kwargs: Any) -> list[Document]:+ """+ Load iMessage data and return as documents.++ Args:+ input_dir: Optional path to directory containing chat.db file.+ If not provided, uses default macOS location.+ **load_kwargs: Additional arguments (unused)++ Returns:+ List of Document objects containing iMessage data+ """+ docs = []++ # Determine database path+ if input_dir:+ db_path = Path(input_dir) / "chat.db"+ else:+ db_path = self._get_default_chat_db_path()++ # Read messages from database+ messages = self._read_messages_from_db(db_path)+ if not messages:+ return docs++ if self.concatenate_conversations:+ # Group messages by chat and create concatenated documents+ chats = self._group_messages_by_chat(messages)++ for chat_id, chat_messages in chats.items():+ if not chat_messages:+ continue++ content = self._create_concatenated_content(chat_id, chat_messages)++ # Create metadata+ first_msg = chat_messages[0]+ last_msg = chat_messages[-1]++ metadata = {+ "source": "iMessage",+ "chat_id": chat_id,+ "chat_name": first_msg["chat_display_name"],+ "chat_identifier": first_msg["chat_identifier"],+ "message_count": len(chat_messages),+ "first_message_date": first_msg["timestamp"],+ "last_message_date": last_msg["timestamp"],+ "participants": list(+ {msg["contact_name"] for msg in chat_messages if not msg["is_from_me"]}+ ),+ }++ doc = Document(text=content, metadata=metadata)+ docs.append(doc)++ else:+ # Create individual documents for each message+ for message in messages:+ content = self._create_individual_content(message)++ metadata = {+ "source": "iMessage",+ "message_id": message["message_id"],+ "chat_id": message["chat_id"],+ "chat_name": message["chat_display_name"],+ "chat_identifier": message["chat_identifier"],+ "timestamp": message["timestamp"],+ "is_from_me": message["is_from_me"],+ "contact_name": message["contact_name"],+ "service": message["service"],+ }++ doc = Document(text=content, metadata=metadata)+ docs.append(doc)++ return docs+++class AppleMailReader(BaseReader):+ """Reader for Apple Mail data (macOS)."""++ def load_data(self, max_count: int = 1000) -> list[Document]:+ docs: list[Document] = []+ home = Path.home()+ mail_data_path = home / "Library/Mail/V10/MailData"+ envelope_index = mail_data_path / "Envelope Index"+ temp_db_path = "/tmp/leann_mail_index_copy"++ if not envelope_index.exists():+ # Try V9 if V10 doesn't exist+ mail_data_path = home / "Library/Mail/V9/MailData"+ envelope_index = mail_data_path / "Envelope Index"+ if not envelope_index.exists():+ print("⚠️ Apple Mail Envelope Index not found.")+ return docs++ try:+ shutil.copy2(envelope_index, temp_db_path)+ conn = sqlite3.connect(temp_db_path)+ cursor = conn.cursor()++ # Query to get message subjects, senders, and content previews+ query = """+ SELECT+ m.subject,+ m.sender,+ datetime(m.date_sent, 'unixepoch', '31 years') as date,+ s.snippet+ FROM messages m+ LEFT JOIN message_snippets s ON m.ROWID = s.message_id+ ORDER BY m.date_sent DESC+ LIMIT ?+ """+ cursor.execute(query, (max_count,))+ rows = cursor.fetchall()++ for row in rows:+ subject, sender, date, snippet = row+ if not subject and not snippet:+ continue++ content = f"Subject: {subject}\nFrom: {sender}\nDate: {date}\n\n{snippet or ''}"+ docs.append(+ Document(+ text=content, metadata={"subject": subject or "", "sender": sender or ""}+ )+ )++ conn.close()+ os.remove(temp_db_path)+ except Exception as e:+ print(f"❌ Error reading Apple Mail: {e}")+ if os.path.exists(temp_db_path):+ os.remove(temp_db_path)++ return docs+++class AppleCalendarReader(BaseReader):+ """Reader for Apple Calendar events (macOS)."""++ def load_data(self, max_count: int = 1000) -> list[Document]:+ docs: list[Document] = []+ home = Path.home()+ calendar_cache = home / "Library/Calendars/Calendar Cache"+ temp_db_path = "/tmp/leann_calendar_index_copy"++ if not calendar_cache.exists():+ print("⚠️ Apple Calendar Cache not found.")+ return docs++ try:+ shutil.copy2(calendar_cache, temp_db_path)+ conn = sqlite3.connect(temp_db_path)+ cursor = conn.cursor()++ # Query for events+ query = """+ SELECT+ summary,+ description,+ location,+ datetime(start_date + 978307200, 'unixepoch', 'localtime') as start,+ datetime(end_date + 978307200, 'unixepoch', 'localtime') as end+ FROM CI_EVENT+ ORDER BY start_date DESC+ LIMIT ?+ """+ cursor.execute(query, (max_count,))+ rows = cursor.fetchall()++ for row in rows:+ summary, description, location, start, end = row+ if not summary:+ continue++ content = f"Event: {summary}\nStart: {start}\nEnd: {end}\nLocation: {location or ''}\nDescription: {description or ''}"+ docs.append(Document(text=content, metadata={"event": summary, "start": start}))++ conn.close()+ os.remove(temp_db_path)+ except Exception as e:+ print(f"❌ Error reading Apple Calendar: {e}")+ if os.path.exists(temp_db_path):+ os.remove(temp_db_path)++ return docs+++class WeChatHistoryReader(BaseReader):+ """+ WeChat chat history reader that extracts chat data from exported JSON files.+ """++ def __init__(self) -> None:+ """Initialize."""+ pass++ def _extract_readable_text(self, content: Any) -> str:+ if not content:+ return ""+ if isinstance(content, dict):+ text_parts = [+ str(content.get(f, ""))+ for f in ["title", "quoted", "content", "text"]+ if content.get(f)+ ]+ return " | ".join(text_parts) if text_parts else ""+ if not isinstance(content, str):+ return ""+ clean_content = re.sub(r"^wxid_[^:]+:\s*", "", content)+ clean_content = re.sub(r"^[^:]+:\s*", "", clean_content)+ if clean_content.strip().startswith("<") or "recalled a message" in clean_content:+ return ""+ return clean_content.strip()++ def _is_text_message(self, content: Any) -> bool:+ if not content:+ return False+ if isinstance(content, dict):+ return any(content.get(f) for f in ["title", "quoted", "content", "text"])+ if not isinstance(content, str):+ return False+ if any(tag in content for tag in ["<img", "<emoji", "<voice", "<video", "<appmsg"]):+ return False+ if "recalled a message" in content:+ return False+ clean_content = re.sub(r"^wxid_[^:]+:\s*", "", content)+ clean_content = re.sub(r"^[^:]+:\s*", "", clean_content)+ return len(clean_content.strip()) > 0 and not clean_content.strip().startswith("<")++ def load_data(+ self, wechat_export_dir: str, max_count: int = 1000, concatenate_messages: bool = True+ ) -> list[Document]:+ docs: list[Document] = []+ if not os.path.exists(wechat_export_dir):+ print(f"WeChat export directory not found at: {wechat_export_dir}")+ return docs++ try:+ json_files = list(Path(wechat_export_dir).glob("*.json"))+ count = 0+ for json_file in json_files:+ if 0 < max_count <= count:+ break+ try:+ with open(json_file, encoding="utf-8") as f:+ chat_data = json.load(f)+ contact_name = json_file.stem++ messages_text = []+ for message in chat_data:+ content = message.get("content", "")+ if self._is_text_message(content):+ readable_text = self._extract_readable_text(content) or message.get(+ "message", ""+ )+ if readable_text.strip():+ create_time = message.get("createTime", 0)+ time_str = (+ datetime.fromtimestamp(create_time).strftime(+ "%Y-%m-%d %H:%M:%S"+ )+ if create_time+ else "Unknown"+ )+ sender = "[Me]" if message.get("isSentFromSelf") else "[Contact]"+ messages_text.append(f"({time_str}) {sender}: {readable_text}")++ if messages_text:+ if concatenate_messages:+ full_text = f"Contact: {contact_name}\n\n" + "\n".join(messages_text)+ docs.append(+ Document(text=full_text, metadata={"contact_name": contact_name})+ )+ count += 1+ else:+ for msg in messages_text:+ if 0 < max_count <= count:+ break+ docs.append(+ Document(text=msg, metadata={"contact_name": contact_name})+ )+ count += 1+ except Exception as e:+ print(f"Error reading {json_file}: {e}")+ except Exception as e:+ print(f"Error reading WeChat history: {e}")++ return docs+++class SlackMCPReader:+ """Reader for Slack data via MCP servers."""++ def __init__(+ self,+ mcp_server_command: str,+ workspace_name: str | None = None,+ concatenate_conversations: bool = True,+ ):+ self.mcp_server_command = mcp_server_command+ self.workspace_name = workspace_name+ self.concatenate_conversations = concatenate_conversations++ async def load_data(self, channels: list[str] | None = None) -> list[Document]:+ return []+++class TwitterMCPReader:+ """Reader for Twitter bookmarks via MCP servers."""++ def __init__(self, mcp_server_command: str):+ self.mcp_server_command = mcp_server_command++ async def load_data(self, max_bookmarks: int = 100) -> list[Document]:+ return []+++class ChatGPTReader(BaseReader):+ """Reader for ChatGPT export files (.html or .zip)."""++ def load_data(self, export_path: str) -> list[Document]:+ return []+++class ClaudeReader(BaseReader):+ """Reader for Claude export files (.json or .zip)."""++ def load_data(self, export_path: str) -> list[Document]:+ return []diff --git a/uv.lock b/uv.lockindex 3da6cc1..613bc3a 100644--- a/uv.lock+++ b/uv.lock@@ -2,9 +2,15 @@ version = 1revision = 3requires-python = ">=3.10"resolution-markers = [- "python_full_version >= '3.12'",- "python_full_version == '3.11.*'",- "python_full_version < '3.11'",+ "python_full_version >= '3.12' and sys_platform == 'darwin'",+ "python_full_version >= '3.12' and platform_machine == 'aarch64' and sys_platform == 'linux'",+ "(python_full_version >= '3.12' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version >= '3.12' and sys_platform != 'darwin' and sys_platform != 'linux')",+ "python_full_version == '3.11.*' and sys_platform == 'darwin'",+ "python_full_version == '3.11.*' and platform_machine == 'aarch64' and sys_platform == 'linux'",+ "(python_full_version == '3.11.*' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version == '3.11.*' and sys_platform != 'darwin' and sys_platform != 'linux')",+ "python_full_version < '3.11' and sys_platform == 'darwin'",+ "python_full_version < '3.11' and platform_machine == 'aarch64' and sys_platform == 'linux'",+ "(python_full_version < '3.11' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version < '3.11' and sys_platform != 'darwin' and sys_platform != 'linux')",][[package]]@@ -154,6 +160,12 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },]+[[package]]+name = "antlr4-python3-runtime"+version = "4.9.3"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/3e/38/7859ff46355f76f8d19459005ca000b6e7012f2f1ca597746cbcd1fbfe5e/antlr4-python3-runtime-4.9.3.tar.gz", hash = "sha256:f224469b4168294902bb1efa80a8bf7855f24c99aef99cbefc1bcd3cce77881b", size = 117034, upload-time = "2021-11-06T17:52:23.524Z" }+[[package]]name = "anyio"version = "4.11.0"@@ -503,6 +515,18 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },]+[[package]]+name = "colorlog"+version = "6.10.1"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "colorama", marker = "sys_platform == 'win32'" },+]+sdist = { url = "https://files.pythonhosted.org/packages/a2/61/f083b5ac52e505dfc1c624eafbf8c7589a0d7f32daa398d2e7590efa5fda/colorlog-6.10.1.tar.gz", hash = "sha256:eb4ae5cb65fe7fec7773c2306061a8e63e02efc2c72eba9d27b0fa23c94f1321", size = 17162, upload-time = "2025-10-16T16:14:11.978Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/6d/c1/e419ef3723a074172b68aaa89c9f3de486ed4c2399e2dbd8113a4fdcaf9e/colorlog-6.10.1-py3-none-any.whl", hash = "sha256:2d7e8348291948af66122cff006c9f8da6255d224e7cf8e37d8de2df3bad8c9c", size = 11743, upload-time = "2025-10-16T16:14:10.512Z" },+]+[[package]]name = "comm"version = "0.2.3"@@ -517,7 +541,9 @@ name = "contourpy"version = "1.3.2"source = { registry = "https://pypi.org/simple" }resolution-markers = [- "python_full_version < '3.11'",+ "python_full_version < '3.11' and sys_platform == 'darwin'",+ "python_full_version < '3.11' and platform_machine == 'aarch64' and sys_platform == 'linux'",+ "(python_full_version < '3.11' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version < '3.11' and sys_platform != 'darwin' and sys_platform != 'linux')",]dependencies = [{ name = "numpy", marker = "python_full_version < '3.11'" },@@ -587,8 +613,12 @@ name = "contourpy"version = "1.3.3"source = { registry = "https://pypi.org/simple" }resolution-markers = [- "python_full_version >= '3.12'",- "python_full_version == '3.11.*'",+ "python_full_version >= '3.12' and sys_platform == 'darwin'",+ "python_full_version >= '3.12' and platform_machine == 'aarch64' and sys_platform == 'linux'",+ "(python_full_version >= '3.12' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version >= '3.12' and sys_platform != 'darwin' and sys_platform != 'linux')",+ "python_full_version == '3.11.*' and sys_platform == 'darwin'",+ "python_full_version == '3.11.*' and platform_machine == 'aarch64' and sys_platform == 'linux'",+ "(python_full_version == '3.11.*' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version == '3.11.*' and sys_platform != 'darwin' and sys_platform != 'linux')",]dependencies = [{ name = "numpy", marker = "python_full_version >= '3.11'" },@@ -978,6 +1008,138 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", hash = "sha256:7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2", size = 20277, upload-time = "2023-12-24T09:54:30.421Z" },]+[[package]]+name = "docling"+version = "2.70.0"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "accelerate" },+ { name = "beautifulsoup4" },+ { name = "certifi" },+ { name = "docling-core", extra = ["chunking"] },+ { name = "docling-ibm-models" },+ { name = "docling-parse" },+ { name = "filetype" },+ { name = "huggingface-hub" },+ { name = "lxml" },+ { name = "marko" },+ { name = "ocrmac", marker = "sys_platform == 'darwin'" },+ { name = "openpyxl" },+ { name = "pandas" },+ { name = "pillow" },+ { name = "pluggy" },+ { name = "polyfactory" },+ { name = "pydantic" },+ { name = "pydantic-settings" },+ { name = "pylatexenc" },+ { name = "pypdfium2" },+ { name = "python-docx" },+ { name = "python-pptx" },+ { name = "rapidocr" },+ { name = "requests" },+ { name = "rtree" },+ { name = "scipy", version = "1.15.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },+ { name = "scipy", version = "1.16.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },+ { name = "tqdm" },+ { name = "typer" },+]+sdist = { url = "https://files.pythonhosted.org/packages/74/fd/343dfbb8026fdb16c22060075ad229626831ecdc467c1cd618fbf173a05e/docling-2.70.0.tar.gz", hash = "sha256:cb144609038065bdb8fe73b8fe656f4be8d48bd3c2f08c4d8c4052f6258d5f5e", size = 280593, upload-time = "2026-01-23T15:24:03.896Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/96/ca/ec9896137207fa5e3999e96f6ecd9c13c95668857af4e1d042dcbd0cf982/docling-2.70.0-py3-none-any.whl", hash = "sha256:e61a213b76e1a7e58854553928eb9ea29a3965362e976ff429fa5258041ce687", size = 299928, upload-time = "2026-01-23T15:24:02.474Z" },+]++[[package]]+name = "docling-core"+version = "2.60.2"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "jsonref" },+ { name = "jsonschema" },+ { name = "latex2mathml" },+ { name = "pandas" },+ { name = "pillow" },+ { name = "pydantic" },+ { name = "pyyaml" },+ { name = "tabulate" },+ { name = "typer" },+ { name = "typing-extensions" },+]+sdist = { url = "https://files.pythonhosted.org/packages/7d/e6/7ed57bc580f136db0a7457305ec63366f22c999b674ef5f7c0abe452d79f/docling_core-2.60.2.tar.gz", hash = "sha256:7a99e1671e796e39d0c735b7ae3833766a97ad287e15d434dfa417917e3b0e6d", size = 231978, upload-time = "2026-01-23T12:29:18.506Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/fa/5f/d39dd904b602f3a4072f1a7c38636702c32ed36d49aaafb21ea059face28/docling_core-2.60.2-py3-none-any.whl", hash = "sha256:63aee783f06240455c12c30e9af383b80d7ade80c896f81d68a4aff6cde2e2a1", size = 222319, upload-time = "2026-01-23T12:29:17.109Z" },+]++[package.optional-dependencies]+chunking = [+ { name = "semchunk" },+ { name = "transformers" },+ { name = "tree-sitter" },+ { name = "tree-sitter-c" },+ { name = "tree-sitter-javascript" },+ { name = "tree-sitter-python" },+ { name = "tree-sitter-typescript" },+]++[[package]]+name = "docling-ibm-models"+version = "3.11.0"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "accelerate" },+ { name = "docling-core" },+ { name = "huggingface-hub" },+ { name = "jsonlines" },+ { name = "numpy" },+ { name = "pillow" },+ { name = "pydantic" },+ { name = "rtree" },+ { name = "safetensors", extra = ["torch"] },+ { name = "torch" },+ { name = "torchvision" },+ { name = "tqdm" },+ { name = "transformers" },+]+sdist = { url = "https://files.pythonhosted.org/packages/b6/91/f883e0a2b3466e1126dfd4463f386c70f5b90d271c27b6f5a97d2f8312e6/docling_ibm_models-3.11.0.tar.gz", hash = "sha256:454401563a8e79cb33b718bc559d9bacca8a0183583e48f8e616c9184c1f5eb1", size = 87721, upload-time = "2026-01-23T12:29:35.384Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/ef/5d/97e9c2e10fbd3ee1723ac82c335f8211a9633c0397cc11ed057c3ba4006e/docling_ibm_models-3.11.0-py3-none-any.whl", hash = "sha256:68f7961069d643bfdab21b1c9ef24a979db293496f4c2283d95b1025a9ac5347", size = 87352, upload-time = "2026-01-23T12:29:34.045Z" },+]++[[package]]+name = "docling-parse"+version = "4.7.3"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "docling-core" },+ { name = "pillow" },+ { name = "pydantic" },+ { name = "pywin32", marker = "sys_platform == 'win32'" },+ { name = "tabulate" },+]+sdist = { url = "https://files.pythonhosted.org/packages/bb/7a/653c3b11920113217724fab9b4740f9f8964864f92a2a27590accecec5ac/docling_parse-4.7.3.tar.gz", hash = "sha256:5936e6bcb7969c2a13f38ecc75cada3b0919422dc845e96da4b0b7b3bbc394ce", size = 67646746, upload-time = "2026-01-14T14:18:19.376Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/6d/21/98decb689c173763f9a089e221c68b36d7b67ace0759f8eb2c9ca4b98dd5/docling_parse-4.7.3-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:65e0653d9617d38e73bab069dc3e7960668ff4a6b0ff45a7635c3790eeed8a08", size = 14614450, upload-time = "2026-01-14T14:17:21.626Z" },+ { url = "https://files.pythonhosted.org/packages/b2/88/c7642d019b6932b294ac3aae0208b2998fc0b7690473d12b1aa56636c99f/docling_parse-4.7.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:978e7e7032760385264896871ae87cb3a04081766cc966c57e9750ce803162ac", size = 15063165, upload-time = "2026-01-14T14:17:24.337Z" },+ { url = "https://files.pythonhosted.org/packages/df/3d/a169dd9de8ed5f8edae2bbfd6528306ece67994813224bb0da7a6f694a5f/docling_parse-4.7.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1790e7e4ae202d67875c1c48fd6f8ef5c51d10b0c23157e4989b8673f2f31308", size = 15136333, upload-time = "2026-01-14T14:17:26.21Z" },+ { url = "https://files.pythonhosted.org/packages/aa/b5/b600c4a040f57b7876878550551a8a92000ffedc58f716c384e1a09ec085/docling_parse-4.7.3-cp310-cp310-win_amd64.whl", hash = "sha256:5fc8f4770f9f6f90ba25f52451864a64394ddb158aea3a8fdda46a208c029cf6", size = 16144041, upload-time = "2026-01-14T14:17:28.108Z" },+ { url = "https://files.pythonhosted.org/packages/6c/81/dd317e0bce475153dc08a60a9a8615b1a04d4d3c9803175e6cb7b7e9b49b/docling_parse-4.7.3-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:66896bbe925073e4d48f18ec29dcd611a390d6b2378fae72125e77b020cd5664", size = 14615974, upload-time = "2026-01-14T14:17:30.246Z" },+ { url = "https://files.pythonhosted.org/packages/3a/b5/088590e0b32fd0a393ca419c644d1435a1c99fa6b2a87888eef4d0fdea33/docling_parse-4.7.3-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:281347b3e937c1a5ffa6f8774ee603b64a0899fe8a6885573dec7eb48a3421d8", size = 14981051, upload-time = "2026-01-14T14:17:32.426Z" },+ { url = "https://files.pythonhosted.org/packages/b7/63/2b6c9127924487573d5419d58ec77955f0b7c0a923c8232ad461d71039aa/docling_parse-4.7.3-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d3d86c51f9ce35a1b40b2f410f7271d9bd5fc58e7240f4cae7fdd2cef757e671", size = 15092586, upload-time = "2026-01-14T14:17:34.634Z" },+ { url = "https://files.pythonhosted.org/packages/af/89/ed27a83eb113bdf0b0f82f3c30a0db3c005df58b236f6487b232dacdb57a/docling_parse-4.7.3-cp311-cp311-win_amd64.whl", hash = "sha256:3b04459cc97a8a4929622e341b9981e23987a63af07db599afc5e1c4d389060b", size = 16144866, upload-time = "2026-01-14T14:17:36.742Z" },+ { url = "https://files.pythonhosted.org/packages/d6/26/9d86ae12699a25b7233f76ce062253e9c14e57781e00166b792b3a9d56db/docling_parse-4.7.3-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:d89231aa4fba3e38b80c11beb8edc07569e934c1f3935b51f57904fefe958ba5", size = 14616739, upload-time = "2026-01-14T14:17:38.567Z" },+ { url = "https://files.pythonhosted.org/packages/f2/fd/1aebb8a7f15d658f3be858ddbbc4ef7206089d540a7df0dcd4b846b99901/docling_parse-4.7.3-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dffd19ed373b0da5cea124606b183489a8686c3d18643e94485be1bdda5713ea", size = 14980782, upload-time = "2026-01-14T14:17:40.659Z" },+ { url = "https://files.pythonhosted.org/packages/3e/47/a722527c9f89c65f69f8a463be4f12ad73bae18132f29d8de8b2d9f6f082/docling_parse-4.7.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dc32b6f25a673e41b9a8112b6b841284f60dbac9427b7848a03b435460f74aee", size = 15092450, upload-time = "2026-01-14T14:17:42.838Z" },+ { url = "https://files.pythonhosted.org/packages/91/c7/316373a92ba42c2aeaee128fc77a34333449fe3e820b9d524e0ee396ea35/docling_parse-4.7.3-cp312-cp312-win_amd64.whl", hash = "sha256:ef691045623863624f2cb7347572d0262a53cb84940ef7dd851d9f13a2eb8833", size = 16147359, upload-time = "2026-01-14T14:17:44.906Z" },+ { url = "https://files.pythonhosted.org/packages/c9/9f/b62390c85f99436fd0c40cfcdfea2b553482696ca735e4cc0eee96b765aa/docling_parse-4.7.3-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:6cb4fe8c62de06b70e6b38c4bd608f41ea3e9d7154a4e05f9a3c4d8944fe3a25", size = 14616910, upload-time = "2026-01-14T14:17:47.146Z" },+ { url = "https://files.pythonhosted.org/packages/15/c4/a18d70118ff26b12021effab53d2ffe0c7e6ef378e92c35941b5557529c1/docling_parse-4.7.3-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9d18a5b1f7eecabed631c497a19f19d281a0d86f24bfe5d239e3df89bdc4df32", size = 14981477, upload-time = "2026-01-14T14:17:49.659Z" },+ { url = "https://files.pythonhosted.org/packages/cf/e6/899f033d80cb2b4e182226c73c6e91660df42e8867b76a04f0c024db7cb6/docling_parse-4.7.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f4a93f91f97055e19cade33bb957d83f8615f1d2a0103b89827aca16b31a3e22", size = 15092546, upload-time = "2026-01-14T14:17:51.6Z" },+ { url = "https://files.pythonhosted.org/packages/95/f3/6dbd2e9c018b44ffe1de3d0a1ea1b017ee25b2a2f21934495710beb6d4d7/docling_parse-4.7.3-cp313-cp313-win_amd64.whl", hash = "sha256:c5a416ae2e1761914ee8d7dbfbe3858e106c876b5a7fccaa3917c038e2f126ec", size = 16147305, upload-time = "2026-01-14T14:17:53.925Z" },+ { url = "https://files.pythonhosted.org/packages/c5/73/d07d205b82d516db32346a9cb833716b4b39e0c37118d50592e8d85adcd1/docling_parse-4.7.3-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:53bd45241dca228715800afa0f96fdc826f7c234e9effcd5cefc86026ff19301", size = 14617441, upload-time = "2026-01-14T14:17:56.315Z" },+ { url = "https://files.pythonhosted.org/packages/0a/ae/b970af23daeb3be24241044a810197b0ddffb8d4d2d451e6dc6669b086e4/docling_parse-4.7.3-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ca64977a19ecd580a48f22137a30470d7ccf0995b2c25a74136c6facec7c617d", size = 14981828, upload-time = "2026-01-14T14:17:59.147Z" },+ { url = "https://files.pythonhosted.org/packages/4e/69/b0732d6b47e80c9108ed8c8ed1db880beddac3a49d68f5f5e853a90553c9/docling_parse-4.7.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:29c91f78c877ae4637011efdb478f20a571e6794be924795b3469958a6401cd6", size = 15092644, upload-time = "2026-01-14T14:18:01.05Z" },+ { url = "https://files.pythonhosted.org/packages/93/2e/7ae85c9ea1e75cf485f5e2af39bf1706c49570f8856b6c345098d25a9078/docling_parse-4.7.3-cp314-cp314-win_amd64.whl", hash = "sha256:75522790df921b6be5d86cf26d184a4af97c1c65e2d22698a9516bc049c398cf", size = 16787387, upload-time = "2026-01-14T14:18:03.353Z" },+ { url = "https://files.pythonhosted.org/packages/4c/58/bcf78e156bf261de21c2ab2843f60aefd0b15217af69756a2ff0cd8287f5/docling_parse-4.7.3-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:a6e0f9e18d808c87ce0fe1900c74a3496a42743f4bba7ed4dd83a0e6e168644a", size = 18061956, upload-time = "2026-01-14T14:18:12.96Z" },+]+[[package]]name = "docx2txt"version = "0.9"@@ -1057,6 +1219,18 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/c1/ea/53f2148663b321f21b5a606bd5f191517cf40b7072c0497d3c92c4a13b1e/executing-2.2.1-py2.py3-none-any.whl", hash = "sha256:760643d3452b4d777d295bb167ccc74c64a81df23fb5e08eff250c425a4b2017", size = 28317, upload-time = "2025-09-01T09:48:08.5Z" },]+[[package]]+name = "faker"+version = "40.1.2"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "tzdata", marker = "sys_platform == 'win32'" },+]+sdist = { url = "https://files.pythonhosted.org/packages/5e/77/1c3ff07b6739b9a1d23ca01ec0a90a309a33b78e345a3eb52f9ce9240e36/faker-40.1.2.tar.gz", hash = "sha256:b76a68163aa5f171d260fc24827a8349bc1db672f6a665359e8d0095e8135d30", size = 1949802, upload-time = "2026-01-13T20:51:49.917Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/46/ec/91a434c8a53d40c3598966621dea9c50512bec6ce8e76fa1751015e74cef/faker-40.1.2-py3-none-any.whl", hash = "sha256:93503165c165d330260e4379fd6dc07c94da90c611ed3191a0174d2ab9966a42", size = 1985633, upload-time = "2026-01-13T20:51:47.982Z" },+]+[[package]]name = "fastjsonschema"version = "2.21.2"@@ -1461,7 +1635,9 @@ name = "ipython"version = "8.37.0"source = { registry = "https://pypi.org/simple" }resolution-markers = [- "python_full_version < '3.11'",+ "python_full_version < '3.11' and sys_platform == 'darwin'",+ "python_full_version < '3.11' and platform_machine == 'aarch64' and sys_platform == 'linux'",+ "(python_full_version < '3.11' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version < '3.11' and sys_platform != 'darwin' and sys_platform != 'linux')",]dependencies = [{ name = "colorama", marker = "python_full_version < '3.11' and sys_platform == 'win32'" },@@ -1486,8 +1662,12 @@ name = "ipython"version = "9.5.0"source = { registry = "https://pypi.org/simple" }resolution-markers = [- "python_full_version >= '3.12'",- "python_full_version == '3.11.*'",+ "python_full_version >= '3.12' and sys_platform == 'darwin'",+ "python_full_version >= '3.12' and platform_machine == 'aarch64' and sys_platform == 'linux'",+ "(python_full_version >= '3.12' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version >= '3.12' and sys_platform != 'darwin' and sys_platform != 'linux')",+ "python_full_version == '3.11.*' and sys_platform == 'darwin'",+ "python_full_version == '3.11.*' and platform_machine == 'aarch64' and sys_platform == 'linux'",+ "(python_full_version == '3.11.*' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version == '3.11.*' and sys_platform != 'darwin' and sys_platform != 'linux')",]dependencies = [{ name = "colorama", marker = "python_full_version >= '3.11' and sys_platform == 'win32'" },@@ -1634,6 +1814,27 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/1e/e8/685f47e0d754320684db4425a0967f7d3fa70126bffd76110b7009a0090f/joblib-1.5.2-py3-none-any.whl", hash = "sha256:4e1f0bdbb987e6d843c70cf43714cb276623def372df3c22fe5266b2670bc241", size = 308396, upload-time = "2025-08-27T12:15:45.188Z" },]+[[package]]+name = "jsonlines"+version = "4.0.0"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "attrs" },+]+sdist = { url = "https://files.pythonhosted.org/packages/35/87/bcda8e46c88d0e34cad2f09ee2d0c7f5957bccdb9791b0b934ec84d84be4/jsonlines-4.0.0.tar.gz", hash = "sha256:0c6d2c09117550c089995247f605ae4cf77dd1533041d366351f6f298822ea74", size = 11359, upload-time = "2023-09-01T12:34:44.187Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/f8/62/d9ba6323b9202dd2fe166beab8a86d29465c41a0288cbe229fac60c1ab8d/jsonlines-4.0.0-py3-none-any.whl", hash = "sha256:185b334ff2ca5a91362993f42e83588a360cf95ce4b71a73548502bda52a7c55", size = 8701, upload-time = "2023-09-01T12:34:42.563Z" },+]++[[package]]+name = "jsonref"+version = "1.1.0"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/aa/0d/c1f3277e90ccdb50d33ed5ba1ec5b3f0a242ed8c1b1a85d3afeb68464dca/jsonref-1.1.0.tar.gz", hash = "sha256:32fe8e1d85af0fdefbebce950af85590b22b60f9e95443176adbde4e1ecea552", size = 8814, upload-time = "2023-01-16T16:10:04.455Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/0c/ec/e1db9922bceb168197a558a2b8c03a7963f1afe93517ddd3cf99f202f996/jsonref-1.1.0-py3-none-any.whl", hash = "sha256:590dc7773df6c21cbf948b5dac07a72a251db28b0238ceecce0a2abfa8ec30a9", size = 9425, upload-time = "2023-01-16T16:10:02.255Z" },+]+[[package]]name = "jsonschema"version = "4.25.1"@@ -1808,6 +2009,15 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/da/e9/0d4add7873a73e462aeb45c036a2dead2562b825aa46ba326727b3f31016/kiwisolver-1.4.9-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:fb940820c63a9590d31d88b815e7a3aa5915cad3ce735ab45f0c730b39547de1", size = 73929, upload-time = "2025-08-10T21:27:48.236Z" },]+[[package]]+name = "latex2mathml"+version = "3.78.1"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/1a/26/57b1034c08922d0aefea79430a5e0006ffaee4f0ec59d566613f667ab2f7/latex2mathml-3.78.1.tar.gz", hash = "sha256:f941db80bf41db33f31df87b304e8b588f8166b813b0257c11c98f7a9d0aac71", size = 74030, upload-time = "2025-08-29T23:34:23.178Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/3e/76/d661ea2e529c3d464f9efd73f9ac31626b45279eb4306e684054ea20e3d4/latex2mathml-3.78.1-py3-none-any.whl", hash = "sha256:f089b6d75e85b937f99693c93e8c16c0804008672c3dd2a3d25affd36f238100", size = 73892, upload-time = "2025-08-29T23:34:21.98Z" },+]+[[package]]name = "leann-backend-diskann"version = "0.3.6"@@ -1850,22 +2060,31 @@ version = "0.3.6"source = { editable = "packages/leann-core" }dependencies = [{ name = "accelerate" },+ { name = "cryptography" },+ { name = "docling" },+ { name = "docx2txt" },{ name = "gitignore-parser" },{ name = "huggingface-hub" },{ name = "llama-index-core" },{ name = "llama-index-embeddings-huggingface" },{ name = "llama-index-readers-file" },+ { name = "lxml" },{ name = "mlx", marker = "platform_machine == 'arm64' and sys_platform == 'darwin'" },{ name = "mlx-lm", marker = "platform_machine == 'arm64' and sys_platform == 'darwin'" },{ name = "msgpack" },{ name = "nbconvert" },{ name = "numpy" },{ name = "openai" },+ { name = "openpyxl" },{ name = "pdfplumber" },{ name = "psutil" },{ name = "pymupdf" },{ name = "pypdf2" },+ { name = "python-docx" },{ name = "python-dotenv" },+ { name = "python-magic" },+ { name = "python-pptx" },+ { name = "pyyaml" },{ name = "pyzmq" },{ name = "requests" },{ name = "sentence-transformers" },@@ -1878,24 +2097,33 @@ dependencies = [requires-dist = [{ name = "accelerate", specifier = ">=0.20.0" },{ name = "accelerate", marker = "extra == 'colab'", specifier = ">=0.20.0,<1.0.0" },+ { name = "cryptography", specifier = ">=3.0.0" },+ { name = "docling", specifier = ">=2.0.0" },+ { name = "docx2txt", specifier = ">=0.8" },{ name = "fastapi", marker = "extra == 'server'", specifier = ">=0.115.0" },{ name = "gitignore-parser", specifier = ">=0.1.12" },{ name = "huggingface-hub", specifier = ">=0.20.0" },{ name = "llama-index-core", specifier = ">=0.12.0" },{ name = "llama-index-embeddings-huggingface", specifier = ">=0.5.5" },{ name = "llama-index-readers-file", specifier = ">=0.4.0" },+ { name = "lxml", specifier = ">=4.9.0" },{ name = "mlx", marker = "platform_machine == 'arm64' and sys_platform == 'darwin'", specifier = ">=0.26.3" },{ name = "mlx-lm", marker = "platform_machine == 'arm64' and sys_platform == 'darwin'", specifier = ">=0.26.0" },{ name = "msgpack", specifier = ">=1.0.0" },{ name = "nbconvert", specifier = ">=7.0.0" },{ name = "numpy", specifier = ">=1.20.0" },{ name = "openai", specifier = ">=1.0.0" },+ { name = "openpyxl", specifier = ">=3.0.0" },{ name = "pdfplumber", specifier = ">=0.10.0" },{ name = "psutil", specifier = ">=5.8.0" },{ name = "pydantic", marker = "extra == 'server'", specifier = ">=2.0.0" },{ name = "pymupdf", specifier = ">=1.23.0" },{ name = "pypdf2", specifier = ">=3.0.0" },+ { name = "python-docx", specifier = ">=1.0.0" },{ name = "python-dotenv", specifier = ">=1.0.0" },+ { name = "python-magic", specifier = ">=0.4.0" },+ { name = "python-pptx", specifier = ">=0.6.0" },+ { name = "pyyaml", specifier = ">=6.0.0" },{ name = "pyzmq", specifier = ">=23.0.0" },{ name = "requests", specifier = ">=2.25.0" },{ name = "sentence-transformers", specifier = ">=3.0.0" },@@ -2433,6 +2661,15 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", hash = "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147", size = 87321, upload-time = "2025-08-11T12:57:51.923Z" },]+[[package]]+name = "marko"+version = "2.2.2"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/e3/2f/050b6d485f052ddf17d76a41f9334d6fb2a8a85df35347a12d97ed3bc5c1/marko-2.2.2.tar.gz", hash = "sha256:6940308e655f63733ca518c47a68ec9510279dbb916c83616e4c4b5829f052e8", size = 143641, upload-time = "2026-01-05T11:04:41.935Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/83/f8/36d79bac5701e6786f9880c61bbe57574760a13c1af84ab71e5ed21faecc/marko-2.2.2-py3-none-any.whl", hash = "sha256:f064ae8c10416285ad1d96048dc11e98ef04e662d3342ae416f662b70aa7959e", size = 42701, upload-time = "2026-01-05T11:04:40.75Z" },+]+[[package]]name = "markupsafe"version = "3.0.2"@@ -2659,6 +2896,25 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/64/7f/294c8cac159661d732e5c01f841e07edfd2ea90651d39faca6579b3cdbf4/mlx_metal-0.29.1-py3-none-macosx_15_0_arm64.whl", hash = "sha256:ebd9ba8e83213f929663b92b8065b451a4276c7002ed83eae0fc8dde721c50c5", size = 34704543, upload-time = "2025-09-12T00:18:59.595Z" },]+[[package]]+name = "mpire"+version = "2.10.2"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "pygments" },+ { name = "pywin32", marker = "sys_platform == 'win32'" },+ { name = "tqdm" },+]+sdist = { url = "https://files.pythonhosted.org/packages/3a/93/80ac75c20ce54c785648b4ed363c88f148bf22637e10c9863db4fbe73e74/mpire-2.10.2.tar.gz", hash = "sha256:f66a321e93fadff34585a4bfa05e95bd946cf714b442f51c529038eb45773d97", size = 271270, upload-time = "2024-05-07T14:00:31.815Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/20/14/1db1729ad6db4999c3a16c47937d601fcb909aaa4224f5eca5a2f145a605/mpire-2.10.2-py3-none-any.whl", hash = "sha256:d627707f7a8d02aa4c7f7d59de399dec5290945ddf7fbd36cbb1d6ebb37a51fb", size = 272756, upload-time = "2024-05-07T14:00:29.633Z" },+]++[package.optional-dependencies]+dill = [+ { name = "multiprocess" },+]+[[package]]name = "mpmath"version = "1.3.0"@@ -2914,7 +3170,9 @@ name = "networkx"version = "3.4.2"source = { registry = "https://pypi.org/simple" }resolution-markers = [- "python_full_version < '3.11'",+ "python_full_version < '3.11' and sys_platform == 'darwin'",+ "python_full_version < '3.11' and platform_machine == 'aarch64' and sys_platform == 'linux'",+ "(python_full_version < '3.11' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version < '3.11' and sys_platform != 'darwin' and sys_platform != 'linux')",]sdist = { url = "https://files.pythonhosted.org/packages/fd/1d/06475e1cd5264c0b870ea2cc6fdb3e37177c1e565c43f56ff17a10e3937f/networkx-3.4.2.tar.gz", hash = "sha256:307c3669428c5362aab27c8a1260aa8f47c4e91d3891f48be0141738d8d053e1", size = 2151368, upload-time = "2024-10-21T12:39:38.695Z" }wheels = [@@ -2926,8 +3184,12 @@ name = "networkx"version = "3.5"source = { registry = "https://pypi.org/simple" }resolution-markers = [- "python_full_version >= '3.12'",- "python_full_version == '3.11.*'",+ "python_full_version >= '3.12' and sys_platform == 'darwin'",+ "python_full_version >= '3.12' and platform_machine == 'aarch64' and sys_platform == 'linux'",+ "(python_full_version >= '3.12' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version >= '3.12' and sys_platform != 'darwin' and sys_platform != 'linux')",+ "python_full_version == '3.11.*' and sys_platform == 'darwin'",+ "python_full_version == '3.11.*' and platform_machine == 'aarch64' and sys_platform == 'linux'",+ "(python_full_version == '3.11.*' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version == '3.11.*' and sys_platform != 'darwin' and sys_platform != 'linux')",]sdist = { url = "https://files.pythonhosted.org/packages/6c/4f/ccdb8ad3a38e583f214547fd2f7ff1fc160c43a75af88e6aec213404b96a/networkx-3.5.tar.gz", hash = "sha256:d4c6f9cf81f52d69230866796b82afbccdec3db7ae4fbd1b65ea750feed50037", size = 2471065, upload-time = "2025-05-29T11:35:07.804Z" }wheels = [@@ -3116,6 +3378,20 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/a2/eb/86626c1bbc2edb86323022371c39aa48df6fd8b0a1647bc274577f72e90b/nvidia_nvtx_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5b17e2001cc0d751a5bc2c6ec6d26ad95913324a4adb86788c944f8ce9ba441f", size = 89954, upload-time = "2025-03-07T01:42:44.131Z" },]+[[package]]+name = "ocrmac"+version = "1.0.1"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "click" },+ { name = "pillow" },+ { name = "pyobjc-framework-vision" },+]+sdist = { url = "https://files.pythonhosted.org/packages/5e/07/3e15ab404f75875c5e48c47163300eb90b7409044d8711fc3aaf52503f2e/ocrmac-1.0.1.tar.gz", hash = "sha256:507fe5e4cbd67b2d03f6729a52bbc11f9d0b58241134eb958a5daafd4b9d93d9", size = 1454317, upload-time = "2026-01-08T16:44:26.412Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/37/15/7cc16507a2aca927abe395f1c545f17ae76b1f8ed44f43ebe4e8670ee203/ocrmac-1.0.1-py3-none-any.whl", hash = "sha256:1cef25426f7ae6bbd57fe3dc5553b25461ae8ad0d2b428a9bbadbf5907349024", size = 9955, upload-time = "2026-01-08T16:44:25.555Z" },+]+[[package]]name = "ollama"version = "0.5.4"@@ -3129,6 +3405,19 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/1b/af/d0a23c8fdec4c8ddb771191d9b36a57fbce6741835a78f1b18ab6d15ae7d/ollama-0.5.4-py3-none-any.whl", hash = "sha256:6374c9bb4f2a371b3583c09786112ba85b006516745689c172a7e28af4d4d1a2", size = 13548, upload-time = "2025-09-16T00:25:24.186Z" },]+[[package]]+name = "omegaconf"+version = "2.3.0"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "antlr4-python3-runtime" },+ { name = "pyyaml" },+]+sdist = { url = "https://files.pythonhosted.org/packages/09/48/6388f1bb9da707110532cb70ec4d2822858ddfb44f1cdf1233c20a80ea4b/omegaconf-2.3.0.tar.gz", hash = "sha256:d5d4b6d29955cc50ad50c46dc269bcd92c6e00f5f90d23ab5fee7bfca4ba4cc7", size = 3298120, upload-time = "2022-12-08T20:59:22.753Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/e3/94/1843518e420fa3ed6919835845df698c7e27e183cb997394e4a670973a65/omegaconf-2.3.0-py3-none-any.whl", hash = "sha256:7b4df175cdb08ba400f45cae3bdcae7ba8365db4d165fc65fd04b050ab63b46b", size = 79500, upload-time = "2022-12-08T20:59:19.686Z" },+]+[[package]]name = "openai"version = "1.109.0"@@ -3148,6 +3437,23 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/b8/d3/d65e318e8d3b5845afaa5960d8da779988b4cb9f4e1ca82e588fed9c6a9d/openai-1.109.0-py3-none-any.whl", hash = "sha256:8c0910bdd4ee1274d5ff0354786bdd0bc79e68c158d5d2c19e24208b412e5792", size = 948421, upload-time = "2025-09-23T16:59:39.516Z" },]+[[package]]+name = "opencv-python"+version = "4.11.0.86"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "numpy" },+]+sdist = { url = "https://files.pythonhosted.org/packages/17/06/68c27a523103dad5837dc5b87e71285280c4f098c60e4fe8a8db6486ab09/opencv-python-4.11.0.86.tar.gz", hash = "sha256:03d60ccae62304860d232272e4a4fda93c39d595780cb40b161b310244b736a4", size = 95171956, upload-time = "2025-01-16T13:52:24.737Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/05/4d/53b30a2a3ac1f75f65a59eb29cf2ee7207ce64867db47036ad61743d5a23/opencv_python-4.11.0.86-cp37-abi3-macosx_13_0_arm64.whl", hash = "sha256:432f67c223f1dc2824f5e73cdfcd9db0efc8710647d4e813012195dc9122a52a", size = 37326322, upload-time = "2025-01-16T13:52:25.887Z" },+ { url = "https://files.pythonhosted.org/packages/3b/84/0a67490741867eacdfa37bc18df96e08a9d579583b419010d7f3da8ff503/opencv_python-4.11.0.86-cp37-abi3-macosx_13_0_x86_64.whl", hash = "sha256:9d05ef13d23fe97f575153558653e2d6e87103995d54e6a35db3f282fe1f9c66", size = 56723197, upload-time = "2025-01-16T13:55:21.222Z" },+ { url = "https://files.pythonhosted.org/packages/f3/bd/29c126788da65c1fb2b5fb621b7fed0ed5f9122aa22a0868c5e2c15c6d23/opencv_python-4.11.0.86-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1b92ae2c8852208817e6776ba1ea0d6b1e0a1b5431e971a2a0ddd2a8cc398202", size = 42230439, upload-time = "2025-01-16T13:51:35.822Z" },+ { url = "https://files.pythonhosted.org/packages/2c/8b/90eb44a40476fa0e71e05a0283947cfd74a5d36121a11d926ad6f3193cc4/opencv_python-4.11.0.86-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6b02611523803495003bd87362db3e1d2a0454a6a63025dc6658a9830570aa0d", size = 62986597, upload-time = "2025-01-16T13:52:08.836Z" },+ { url = "https://files.pythonhosted.org/packages/fb/d7/1d5941a9dde095468b288d989ff6539dd69cd429dbf1b9e839013d21b6f0/opencv_python-4.11.0.86-cp37-abi3-win32.whl", hash = "sha256:810549cb2a4aedaa84ad9a1c92fbfdfc14090e2749cedf2c1589ad8359aa169b", size = 29384337, upload-time = "2025-01-16T13:52:13.549Z" },+ { url = "https://files.pythonhosted.org/packages/a4/7d/f1c30a92854540bf789e9cd5dde7ef49bbe63f855b85a2e6b3db8135c591/opencv_python-4.11.0.86-cp37-abi3-win_amd64.whl", hash = "sha256:085ad9b77c18853ea66283e98affefe2de8cc4c1f43eda4c100cf9b2721142ec", size = 39488044, upload-time = "2025-01-16T13:52:21.928Z" },+]+[[package]]name = "openpyxl"version = "3.1.5"@@ -3403,6 +3709,19 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },]+[[package]]+name = "polyfactory"+version = "3.2.0"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "faker" },+ { name = "typing-extensions" },+]+sdist = { url = "https://files.pythonhosted.org/packages/97/92/e90639b1d2abe982749eba7e734571a343ea062f7d486498b1c2b852f019/polyfactory-3.2.0.tar.gz", hash = "sha256:879242f55208f023eee1de48522de5cb1f9fd2d09b2314e999a9592829d596d1", size = 346878, upload-time = "2025-12-21T11:18:51.017Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/d9/21/93363d7b802aa904f8d4169bc33e0e316d06d26ee68d40fe0355057da98c/polyfactory-3.2.0-py3-none-any.whl", hash = "sha256:5945799cce4c56cd44ccad96fb0352996914553cc3efaa5a286930599f569571", size = 62181, upload-time = "2025-12-21T11:18:49.311Z" },+]+[[package]]name = "pre-commit"version = "4.3.0"@@ -3620,6 +3939,49 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/cd/8a/37362fc2b949d5f733a8b0f2ff51ba423914cabefe69f1d1b6aab710f5fe/pybind11-3.0.1-py3-none-any.whl", hash = "sha256:aa8f0aa6e0a94d3b64adfc38f560f33f15e589be2175e103c0a33c6bce55ee89", size = 293611, upload-time = "2025-08-22T20:09:25.235Z" },]+[[package]]+name = "pyclipper"+version = "1.4.0"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/f6/21/3c06205bb407e1f79b73b7b4dfb3950bd9537c4f625a68ab5cc41177f5bc/pyclipper-1.4.0.tar.gz", hash = "sha256:9882bd889f27da78add4dd6f881d25697efc740bf840274e749988d25496c8e1", size = 54489, upload-time = "2025-12-01T13:15:35.015Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/8a/9f/a10173d32ecc2ce19a04d018163f3ca22a04c0c6ad03b464dcd32f9152a8/pyclipper-1.4.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:bafad70d2679c187120e8c44e1f9a8b06150bad8c0aecf612ad7dfbfa9510f73", size = 264510, upload-time = "2025-12-01T13:14:46.551Z" },+ { url = "https://files.pythonhosted.org/packages/e0/c2/5490ddc4a1f7ceeaa0258f4266397e720c02db515b2ca5bc69b85676f697/pyclipper-1.4.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0b74a9dd44b22a7fd35d65fb1ceeba57f3817f34a97a28c3255556362e491447", size = 139498, upload-time = "2025-12-01T13:14:48.31Z" },+ { url = "https://files.pythonhosted.org/packages/3b/0a/bea9102d1d75634b1a5702b0e92982451a1eafca73c4845d3dbe27eba13d/pyclipper-1.4.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0a4d2736fb3c42e8eb1d38bf27a720d1015526c11e476bded55138a977c17d9d", size = 970974, upload-time = "2025-12-01T13:14:49.799Z" },+ { url = "https://files.pythonhosted.org/packages/8b/1b/097f8776d5b3a10eb7b443b632221f4ed825d892e79e05682f4b10a1a59c/pyclipper-1.4.0-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b3b3630051b53ad2564cb079e088b112dd576e3d91038338ad1cc7915e0f14dc", size = 943315, upload-time = "2025-12-01T13:14:51.266Z" },+ { url = "https://files.pythonhosted.org/packages/fd/4d/17d6a3f1abf0f368d58f2309e80ee3761afb1fd1342f7780ab32ba4f0b1d/pyclipper-1.4.0-cp310-cp310-win32.whl", hash = "sha256:8d42b07a2f6cfe2d9b87daf345443583f00a14e856927782fde52f3a255e305a", size = 95286, upload-time = "2025-12-01T13:14:52.922Z" },+ { url = "https://files.pythonhosted.org/packages/53/ca/b30138427ed122ec9b47980b943164974a2ec606fa3f71597033b9a9f9a6/pyclipper-1.4.0-cp310-cp310-win_amd64.whl", hash = "sha256:6a97b961f182b92d899ca88c1bb3632faea2e00ce18d07c5f789666ebb021ca4", size = 104227, upload-time = "2025-12-01T13:14:54.013Z" },+ { url = "https://files.pythonhosted.org/packages/de/e3/64cf7794319b088c288706087141e53ac259c7959728303276d18adc665d/pyclipper-1.4.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:adcb7ca33c5bdc33cd775e8b3eadad54873c802a6d909067a57348bcb96e7a2d", size = 264281, upload-time = "2025-12-01T13:14:55.47Z" },+ { url = "https://files.pythonhosted.org/packages/34/cd/44ec0da0306fa4231e76f1c2cb1fa394d7bde8db490a2b24d55b39865f69/pyclipper-1.4.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:fd24849d2b94ec749ceac7c34c9f01010d23b6e9d9216cf2238b8481160e703d", size = 139426, upload-time = "2025-12-01T13:14:56.683Z" },+ { url = "https://files.pythonhosted.org/packages/ad/88/d8f6c6763ea622fe35e19c75d8b39ed6c55191ddc82d65e06bc46b26cb8e/pyclipper-1.4.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1b6c8d75ba20c6433c9ea8f1a0feb7e4d3ac06a09ad1fd6d571afc1ddf89b869", size = 989649, upload-time = "2025-12-01T13:14:58.28Z" },+ { url = "https://files.pythonhosted.org/packages/ff/e9/ea7d68c8c4af3842d6515bedcf06418610ad75f111e64c92c1d4785a1513/pyclipper-1.4.0-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:58e29d7443d7cc0e83ee9daf43927730386629786d00c63b04fe3b53ac01462c", size = 962842, upload-time = "2025-12-01T13:15:00.044Z" },+ { url = "https://files.pythonhosted.org/packages/4e/b7/0b4a272d8726e51ab05e2b933d8cc47f29757fb8212e38b619e170e6015c/pyclipper-1.4.0-cp311-cp311-win32.whl", hash = "sha256:a8d2b5fb75ebe57e21ce61e79a9131edec2622ff23cc665e4d1d1f201bc1a801", size = 95098, upload-time = "2025-12-01T13:15:01.359Z" },+ { url = "https://files.pythonhosted.org/packages/3a/76/4901de2919198bb2bd3d989f86d4a1dff363962425bb2d63e24e6c990042/pyclipper-1.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:e9b973467d9c5fa9bc30bb6ac95f9f4d7c3d9fc25f6cf2d1cc972088e5955c01", size = 104362, upload-time = "2025-12-01T13:15:02.439Z" },+ { url = "https://files.pythonhosted.org/packages/90/1b/7a07b68e0842324d46c03e512d8eefa9cb92ba2a792b3b4ebf939dafcac3/pyclipper-1.4.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:222ac96c8b8281b53d695b9c4fedc674f56d6d4320ad23f1bdbd168f4e316140", size = 265676, upload-time = "2025-12-01T13:15:04.15Z" },+ { url = "https://files.pythonhosted.org/packages/6b/dd/8bd622521c05d04963420ae6664093f154343ed044c53ea260a310c8bb4d/pyclipper-1.4.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f3672dbafbb458f1b96e1ee3e610d174acb5ace5bd2ed5d1252603bb797f2fc6", size = 140458, upload-time = "2025-12-01T13:15:05.76Z" },+ { url = "https://files.pythonhosted.org/packages/7a/06/6e3e241882bf7d6ab23d9c69ba4e85f1ec47397cbbeee948a16cf75e21ed/pyclipper-1.4.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d1f807e2b4760a8e5c6d6b4e8c1d71ef52b7fe1946ff088f4fa41e16a881a5ca", size = 978235, upload-time = "2025-12-01T13:15:06.993Z" },+ { url = "https://files.pythonhosted.org/packages/cf/f4/3418c1cd5eea640a9fa2501d4bc0b3655fa8d40145d1a4f484b987990a75/pyclipper-1.4.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ce1f83c9a4e10ea3de1959f0ae79e9a5bd41346dff648fee6228ba9eaf8b3872", size = 961388, upload-time = "2025-12-01T13:15:08.467Z" },+ { url = "https://files.pythonhosted.org/packages/ac/94/c85401d24be634af529c962dd5d781f3cb62a67cd769534df2cb3feee97a/pyclipper-1.4.0-cp312-cp312-win32.whl", hash = "sha256:3ef44b64666ebf1cb521a08a60c3e639d21b8c50bfbe846ba7c52a0415e936f4", size = 95169, upload-time = "2025-12-01T13:15:10.098Z" },+ { url = "https://files.pythonhosted.org/packages/97/77/dfea08e3b230b82ee22543c30c35d33d42f846a77f96caf7c504dd54fab1/pyclipper-1.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:d1e5498d883b706a4ce636247f0d830c6eb34a25b843a1b78e2c969754ca9037", size = 104619, upload-time = "2025-12-01T13:15:11.592Z" },+ { url = "https://files.pythonhosted.org/packages/67/d0/cbce7d47de1e6458f66a4d999b091640134deb8f2c7351eab993b70d2e10/pyclipper-1.4.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:d49df13cbb2627ccb13a1046f3ea6ebf7177b5504ec61bdef87d6a704046fd6e", size = 264342, upload-time = "2025-12-01T13:15:12.697Z" },+ { url = "https://files.pythonhosted.org/packages/ce/cc/742b9d69d96c58ac156947e1b56d0f81cbacbccf869e2ac7229f2f86dc4e/pyclipper-1.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:37bfec361e174110cdddffd5ecd070a8064015c99383d95eb692c253951eee8a", size = 139839, upload-time = "2025-12-01T13:15:13.911Z" },+ { url = "https://files.pythonhosted.org/packages/db/48/dd301d62c1529efdd721b47b9e5fb52120fcdac5f4d3405cfc0d2f391414/pyclipper-1.4.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:14c8bdb5a72004b721c4e6f448d2c2262d74a7f0c9e3076aeff41e564a92389f", size = 972142, upload-time = "2025-12-01T13:15:15.477Z" },+ { url = "https://files.pythonhosted.org/packages/07/bf/d493fd1b33bb090fa64e28c1009374d5d72fa705f9331cd56517c35e381e/pyclipper-1.4.0-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f2a50c22c3a78cb4e48347ecf06930f61ce98cf9252f2e292aa025471e9d75b1", size = 952789, upload-time = "2025-12-01T13:15:17.042Z" },+ { url = "https://files.pythonhosted.org/packages/cf/88/b95ea8ea21ddca34aa14b123226a81526dd2faaa993f9aabd3ed21231604/pyclipper-1.4.0-cp313-cp313-win32.whl", hash = "sha256:c9a3faa416ff536cee93417a72bfb690d9dea136dc39a39dbbe1e5dadf108c9c", size = 94817, upload-time = "2025-12-01T13:15:18.724Z" },+ { url = "https://files.pythonhosted.org/packages/ba/42/0a1920d276a0e1ca21dc0d13ee9e3ba10a9a8aa3abac76cd5e5a9f503306/pyclipper-1.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:d4b2d7c41086f1927d14947c563dfc7beed2f6c0d9af13c42fe3dcdc20d35832", size = 104007, upload-time = "2025-12-01T13:15:19.763Z" },+ { url = "https://files.pythonhosted.org/packages/1a/20/04d58c70f3ccd404f179f8dd81d16722a05a3bf1ab61445ee64e8218c1f8/pyclipper-1.4.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:7c87480fc91a5af4c1ba310bdb7de2f089a3eeef5fe351a3cedc37da1fcced1c", size = 265167, upload-time = "2025-12-01T13:15:20.844Z" },+ { url = "https://files.pythonhosted.org/packages/bd/2e/a570c1abe69b7260ca0caab4236ce6ea3661193ebf8d1bd7f78ccce537a5/pyclipper-1.4.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:81d8bb2d1fb9d66dc7ea4373b176bb4b02443a7e328b3b603a73faec088b952e", size = 139966, upload-time = "2025-12-01T13:15:22.036Z" },+ { url = "https://files.pythonhosted.org/packages/e8/3b/e0859e54adabdde8a24a29d3f525ebb31c71ddf2e8d93edce83a3c212ffc/pyclipper-1.4.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:773c0e06b683214dcfc6711be230c83b03cddebe8a57eae053d4603dd63582f9", size = 968216, upload-time = "2025-12-01T13:15:23.18Z" },+ { url = "https://files.pythonhosted.org/packages/f6/6b/e3c4febf0a35ae643ee579b09988dd931602b5bf311020535fd9e5b7e715/pyclipper-1.4.0-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9bc45f2463d997848450dbed91c950ca37c6cf27f84a49a5cad4affc0b469e39", size = 954198, upload-time = "2025-12-01T13:15:24.522Z" },+ { url = "https://files.pythonhosted.org/packages/fc/74/728efcee02e12acb486ce9d56fa037120c9bf5b77c54bbdbaa441c14a9d9/pyclipper-1.4.0-cp314-cp314-win32.whl", hash = "sha256:0b8c2105b3b3c44dbe1a266f64309407fe30bf372cf39a94dc8aaa97df00da5b", size = 96951, upload-time = "2025-12-01T13:15:25.79Z" },+ { url = "https://files.pythonhosted.org/packages/e3/d7/7f4354e69f10a917e5c7d5d72a499ef2e10945312f5e72c414a0a08d2ae4/pyclipper-1.4.0-cp314-cp314-win_amd64.whl", hash = "sha256:6c317e182590c88ec0194149995e3d71a979cfef3b246383f4e035f9d4a11826", size = 106782, upload-time = "2025-12-01T13:15:26.945Z" },+ { url = "https://files.pythonhosted.org/packages/63/60/fc32c7a3d7f61a970511ec2857ecd09693d8ac80d560ee7b8e67a6d268c9/pyclipper-1.4.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:f160a2c6ba036f7eaf09f1f10f4fbfa734234af9112fb5187877efed78df9303", size = 269880, upload-time = "2025-12-01T13:15:28.117Z" },+ { url = "https://files.pythonhosted.org/packages/49/df/c4a72d3f62f0ba03ec440c4fff56cd2d674a4334d23c5064cbf41c9583f6/pyclipper-1.4.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:a9f11ad133257c52c40d50de7a0ca3370a0cdd8e3d11eec0604ad3c34ba549e9", size = 141706, upload-time = "2025-12-01T13:15:30.134Z" },+ { url = "https://files.pythonhosted.org/packages/c5/0b/cf55df03e2175e1e2da9db585241401e0bc98f76bee3791bed39d0313449/pyclipper-1.4.0-cp314-cp314t-win32.whl", hash = "sha256:bbc827b77442c99deaeee26e0e7f172355ddb097a5e126aea206d447d3b26286", size = 105308, upload-time = "2025-12-01T13:15:31.225Z" },+ { url = "https://files.pythonhosted.org/packages/8f/dc/53df8b6931d47080b4fe4ee8450d42e660ee1c5c1556c7ab73359182b769/pyclipper-1.4.0-cp314-cp314t-win_amd64.whl", hash = "sha256:29dae3e0296dff8502eeb7639fcfee794b0eec8590ba3563aee28db269da6b04", size = 117608, upload-time = "2025-12-01T13:15:32.69Z" },+ { url = "https://files.pythonhosted.org/packages/18/59/81050abdc9e5b90ffc2c765738c5e40e9abd8e44864aaa737b600f16c562/pyclipper-1.4.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:98b2a40f98e1fc1b29e8a6094072e7e0c7dfe901e573bf6cfc6eb7ce84a7ae87", size = 126495, upload-time = "2025-12-01T13:15:33.743Z" },+]+[[package]]name = "pycparser"version = "2.23"@@ -3731,6 +4093,20 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/32/56/8a7ca5d2cd2cda1d245d34b1c9a942920a718082ae8e54e5f3e5a58b7add/pydantic_core-2.33.2-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:329467cecfb529c925cf2bbd4d60d2c509bc2fb52a20c1045bf09bb70971a9c1", size = 2066757, upload-time = "2025-04-23T18:33:30.645Z" },]+[[package]]+name = "pydantic-settings"+version = "2.12.0"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "pydantic" },+ { name = "python-dotenv" },+ { name = "typing-inspection" },+]+sdist = { url = "https://files.pythonhosted.org/packages/43/4b/ac7e0aae12027748076d72a8764ff1c9d82ca75a7a52622e67ed3f765c54/pydantic_settings-2.12.0.tar.gz", hash = "sha256:005538ef951e3c2a68e1c08b292b5f2e71490def8589d4221b95dab00dafcfd0", size = 194184, upload-time = "2025-11-10T14:25:47.013Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/c1/60/5d4751ba3f4a40a6891f24eec885f51afd78d208498268c734e256fb13c4/pydantic_settings-2.12.0-py3-none-any.whl", hash = "sha256:fddb9fd99a5b18da837b29710391e945b1e30c135477f484084ee513adb93809", size = 51880, upload-time = "2025-11-10T14:25:45.546Z" },+]+[[package]]name = "pygments"version = "2.19.2"@@ -3740,6 +4116,12 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },]+[[package]]+name = "pylatexenc"+version = "2.10"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/5d/ab/34ec41718af73c00119d0351b7a2531d2ebddb51833a36448fc7b862be60/pylatexenc-2.10.tar.gz", hash = "sha256:3dd8fd84eb46dc30bee1e23eaab8d8fb5a7f507347b23e5f38ad9675c84f40d3", size = 162597, upload-time = "2021-04-06T07:56:07.854Z" }+[[package]]name = "pymupdf"version = "1.26.4"@@ -3755,6 +4137,98 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/d1/c4/87d27b108c2f6d773aa5183c5ae367b2a99296ea4bc16eb79f453c679e30/pymupdf-1.26.4-cp39-abi3-win_amd64.whl", hash = "sha256:0b6345a93a9afd28de2567e433055e873205c52e6b920b129ca50e836a3aeec6", size = 18743491, upload-time = "2025-08-25T14:19:01.104Z" },]+[[package]]+name = "pyobjc-core"+version = "12.1"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/b8/b6/d5612eb40be4fd5ef88c259339e6313f46ba67577a95d86c3470b951fce0/pyobjc_core-12.1.tar.gz", hash = "sha256:2bb3903f5387f72422145e1466b3ac3f7f0ef2e9960afa9bcd8961c5cbf8bd21", size = 1000532, upload-time = "2025-11-14T10:08:28.292Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/63/bf/3dbb1783388da54e650f8a6b88bde03c101d9ba93dfe8ab1b1873f1cd999/pyobjc_core-12.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:93418e79c1655f66b4352168f8c85c942707cb1d3ea13a1da3e6f6a143bacda7", size = 676748, upload-time = "2025-11-14T09:30:50.023Z" },+ { url = "https://files.pythonhosted.org/packages/95/df/d2b290708e9da86d6e7a9a2a2022b91915cf2e712a5a82e306cb6ee99792/pyobjc_core-12.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:c918ebca280925e7fcb14c5c43ce12dcb9574a33cccb889be7c8c17f3bcce8b6", size = 671263, upload-time = "2025-11-14T09:31:35.231Z" },+ { url = "https://files.pythonhosted.org/packages/64/5a/6b15e499de73050f4a2c88fff664ae154307d25dc04da8fb38998a428358/pyobjc_core-12.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:818bcc6723561f207e5b5453efe9703f34bc8781d11ce9b8be286bb415eb4962", size = 678335, upload-time = "2025-11-14T09:32:20.107Z" },+ { url = "https://files.pythonhosted.org/packages/f4/d2/29e5e536adc07bc3d33dd09f3f7cf844bf7b4981820dc2a91dd810f3c782/pyobjc_core-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:01c0cf500596f03e21c23aef9b5f326b9fb1f8f118cf0d8b66749b6cf4cbb37a", size = 677370, upload-time = "2025-11-14T09:33:05.273Z" },+ { url = "https://files.pythonhosted.org/packages/1b/f0/4b4ed8924cd04e425f2a07269943018d43949afad1c348c3ed4d9d032787/pyobjc_core-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:177aaca84bb369a483e4961186704f64b2697708046745f8167e818d968c88fc", size = 719586, upload-time = "2025-11-14T09:33:53.302Z" },+ { url = "https://files.pythonhosted.org/packages/25/98/9f4ed07162de69603144ff480be35cd021808faa7f730d082b92f7ebf2b5/pyobjc_core-12.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:844515f5d86395b979d02152576e7dee9cc679acc0b32dc626ef5bda315eaa43", size = 670164, upload-time = "2025-11-14T09:34:37.458Z" },+ { url = "https://files.pythonhosted.org/packages/62/50/dc076965c96c7f0de25c0a32b7f8aa98133ed244deaeeacfc758783f1f30/pyobjc_core-12.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:453b191df1a4b80e756445b935491b974714456ae2cbae816840bd96f86db882", size = 712204, upload-time = "2025-11-14T09:35:24.148Z" },+]++[[package]]+name = "pyobjc-framework-cocoa"+version = "12.1"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "pyobjc-core" },+]+sdist = { url = "https://files.pythonhosted.org/packages/02/a3/16ca9a15e77c061a9250afbae2eae26f2e1579eb8ca9462ae2d2c71e1169/pyobjc_framework_cocoa-12.1.tar.gz", hash = "sha256:5556c87db95711b985d5efdaaf01c917ddd41d148b1e52a0c66b1a2e2c5c1640", size = 2772191, upload-time = "2025-11-14T10:13:02.069Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/b2/aa/2b2d7ec3ac4b112a605e9bd5c5e5e4fd31d60a8a4b610ab19cc4838aa92a/pyobjc_framework_cocoa-12.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:9b880d3bdcd102809d704b6d8e14e31611443aa892d9f60e8491e457182fdd48", size = 383825, upload-time = "2025-11-14T09:40:28.354Z" },+ { url = "https://files.pythonhosted.org/packages/3f/07/5760735c0fffc65107e648eaf7e0991f46da442ac4493501be5380e6d9d4/pyobjc_framework_cocoa-12.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:f52228bcf38da64b77328787967d464e28b981492b33a7675585141e1b0a01e6", size = 383812, upload-time = "2025-11-14T09:40:53.169Z" },+ { url = "https://files.pythonhosted.org/packages/95/bf/ee4f27ec3920d5c6fc63c63e797c5b2cc4e20fe439217085d01ea5b63856/pyobjc_framework_cocoa-12.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:547c182837214b7ec4796dac5aee3aa25abc665757b75d7f44f83c994bcb0858", size = 384590, upload-time = "2025-11-14T09:41:17.336Z" },+ { url = "https://files.pythonhosted.org/packages/ad/31/0c2e734165abb46215797bd830c4bdcb780b699854b15f2b6240515edcc6/pyobjc_framework_cocoa-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:5a3dcd491cacc2f5a197142b3c556d8aafa3963011110102a093349017705118", size = 384689, upload-time = "2025-11-14T09:41:41.478Z" },+ { url = "https://files.pythonhosted.org/packages/23/3b/b9f61be7b9f9b4e0a6db18b3c35c4c4d589f2d04e963e2174d38c6555a92/pyobjc_framework_cocoa-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:914b74328c22d8ca261d78c23ef2befc29776e0b85555973927b338c5734ca44", size = 388843, upload-time = "2025-11-14T09:42:05.719Z" },+ { url = "https://files.pythonhosted.org/packages/59/bb/f777cc9e775fc7dae77b569254570fe46eb842516b3e4fe383ab49eab598/pyobjc_framework_cocoa-12.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:03342a60fc0015bcdf9b93ac0b4f457d3938e9ef761b28df9564c91a14f0129a", size = 384932, upload-time = "2025-11-14T09:42:29.771Z" },+ { url = "https://files.pythonhosted.org/packages/58/27/b457b7b37089cad692c8aada90119162dfb4c4a16f513b79a8b2b022b33b/pyobjc_framework_cocoa-12.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:6ba1dc1bfa4da42d04e93d2363491275fb2e2be5c20790e561c8a9e09b8cf2cc", size = 388970, upload-time = "2025-11-14T09:42:53.964Z" },+]++[[package]]+name = "pyobjc-framework-coreml"+version = "12.1"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "pyobjc-core" },+ { name = "pyobjc-framework-cocoa" },+]+sdist = { url = "https://files.pythonhosted.org/packages/30/2d/baa9ea02cbb1c200683cb7273b69b4bee5070e86f2060b77e6a27c2a9d7e/pyobjc_framework_coreml-12.1.tar.gz", hash = "sha256:0d1a4216891a18775c9e0170d908714c18e4f53f9dc79fb0f5263b2aa81609ba", size = 40465, upload-time = "2025-11-14T10:14:02.265Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/47/f6/e8afa7143d541f6f0b9ac4b3820098a1b872bceba9210ae1bf4b5b4d445d/pyobjc_framework_coreml-12.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:df4e9b4f97063148cc481f72e2fbe3cc53b9464d722752aa658d7c0aec9f02fd", size = 11334, upload-time = "2025-11-14T09:45:48.42Z" },+ { url = "https://files.pythonhosted.org/packages/34/0f/f55369da4a33cfe1db38a3512aac4487602783d3a1d572d2c8c4ccce6abc/pyobjc_framework_coreml-12.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:16dafcfb123f022e62f47a590a7eccf7d0cb5957a77fd5f062b5ee751cb5a423", size = 11331, upload-time = "2025-11-14T09:45:50.445Z" },+ { url = "https://files.pythonhosted.org/packages/bb/39/4defef0deb25c5d7e3b7826d301e71ac5b54ef901b7dac4db1adc00f172d/pyobjc_framework_coreml-12.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:10dc8e8db53d7631ebc712cad146e3a9a9a443f4e1a037e844149a24c3c42669", size = 11356, upload-time = "2025-11-14T09:45:52.271Z" },+ { url = "https://files.pythonhosted.org/packages/ae/3f/3749964aa3583f8c30d9996f0d15541120b78d307bb3070f5e47154ef38d/pyobjc_framework_coreml-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:48fa3bb4a03fa23e0e36c93936dca2969598e4102f4b441e1663f535fc99cd31", size = 11371, upload-time = "2025-11-14T09:45:54.105Z" },+ { url = "https://files.pythonhosted.org/packages/9c/c8/cf20ea91ae33f05f3b92dec648c6f44a65f86d1a64c1d6375c95b85ccb7c/pyobjc_framework_coreml-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:71de5b37e6a017e3ed16645c5d6533138f24708da5b56c35c818ae49d0253ee1", size = 11600, upload-time = "2025-11-14T09:45:55.976Z" },+ { url = "https://files.pythonhosted.org/packages/bc/5c/510ae8e3663238d32e653ed6a09ac65611dd045a7241f12633c1ab48bb9b/pyobjc_framework_coreml-12.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:a04a96e512ecf6999aa9e1f60ad5635cb9d1cd839be470341d8d1541797baef6", size = 11418, upload-time = "2025-11-14T09:45:57.75Z" },+ { url = "https://files.pythonhosted.org/packages/d3/1a/b7367819381b07c440fa5797d2b0487e31f09aa72079a693ceab6875fa0a/pyobjc_framework_coreml-12.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:7762b3dd2de01565b7cf3049ce1e4c27341ba179d97016b0b7607448e1c39865", size = 11593, upload-time = "2025-11-14T09:45:59.623Z" },+]++[[package]]+name = "pyobjc-framework-quartz"+version = "12.1"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "pyobjc-core" },+ { name = "pyobjc-framework-cocoa" },+]+sdist = { url = "https://files.pythonhosted.org/packages/94/18/cc59f3d4355c9456fc945eae7fe8797003c4da99212dd531ad1b0de8a0c6/pyobjc_framework_quartz-12.1.tar.gz", hash = "sha256:27f782f3513ac88ec9b6c82d9767eef95a5cf4175ce88a1e5a65875fee799608", size = 3159099, upload-time = "2025-11-14T10:21:24.31Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/17/f4/50c42c84796886e4d360407fb629000bb68d843b2502c88318375441676f/pyobjc_framework_quartz-12.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:c6f312ae79ef8b3019dcf4b3374c52035c7c7bc4a09a1748b61b041bb685a0ed", size = 217799, upload-time = "2025-11-14T09:59:32.62Z" },+ { url = "https://files.pythonhosted.org/packages/b7/ef/dcd22b743e38b3c430fce4788176c2c5afa8bfb01085b8143b02d1e75201/pyobjc_framework_quartz-12.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:19f99ac49a0b15dd892e155644fe80242d741411a9ed9c119b18b7466048625a", size = 217795, upload-time = "2025-11-14T09:59:46.922Z" },+ { url = "https://files.pythonhosted.org/packages/e9/9b/780f057e5962f690f23fdff1083a4cfda5a96d5b4d3bb49505cac4f624f2/pyobjc_framework_quartz-12.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:7730cdce46c7e985535b5a42c31381af4aa6556e5642dc55b5e6597595e57a16", size = 218798, upload-time = "2025-11-14T10:00:01.236Z" },+ { url = "https://files.pythonhosted.org/packages/ba/2d/e8f495328101898c16c32ac10e7b14b08ff2c443a756a76fd1271915f097/pyobjc_framework_quartz-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:629b7971b1b43a11617f1460cd218bd308dfea247cd4ee3842eb40ca6f588860", size = 219206, upload-time = "2025-11-14T10:00:15.623Z" },+ { url = "https://files.pythonhosted.org/packages/67/43/b1f0ad3b842ab150a7e6b7d97f6257eab6af241b4c7d14cb8e7fde9214b8/pyobjc_framework_quartz-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:53b84e880c358ba1ddcd7e8d5ea0407d760eca58b96f0d344829162cda5f37b3", size = 224317, upload-time = "2025-11-14T10:00:30.703Z" },+ { url = "https://files.pythonhosted.org/packages/4a/00/96249c5c7e5aaca5f688ca18b8d8ad05cd7886ebd639b3c71a6a4cadbe75/pyobjc_framework_quartz-12.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:42d306b07f05ae7d155984503e0fb1b701fecd31dcc5c79fe8ab9790ff7e0de0", size = 219558, upload-time = "2025-11-14T10:00:45.476Z" },+ { url = "https://files.pythonhosted.org/packages/4d/a6/708a55f3ff7a18c403b30a29a11dccfed0410485a7548c60a4b6d4cc0676/pyobjc_framework_quartz-12.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:0cc08fddb339b2760df60dea1057453557588908e42bdc62184b6396ce2d6e9a", size = 224580, upload-time = "2025-11-14T10:01:00.091Z" },+]++[[package]]+name = "pyobjc-framework-vision"+version = "12.1"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "pyobjc-core" },+ { name = "pyobjc-framework-cocoa" },+ { name = "pyobjc-framework-coreml" },+ { name = "pyobjc-framework-quartz" },+]+sdist = { url = "https://files.pythonhosted.org/packages/c2/5a/08bb3e278f870443d226c141af14205ff41c0274da1e053b72b11dfc9fb2/pyobjc_framework_vision-12.1.tar.gz", hash = "sha256:a30959100e85dcede3a786c544e621ad6eb65ff6abf85721f805822b8c5fe9b0", size = 59538, upload-time = "2025-11-14T10:23:21.979Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/e3/48/b23e639a66e5d3d944710bb2eaeb7257c18b0834dffc7ea2ddadadf8620e/pyobjc_framework_vision-12.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:a30c3fff926348baecc3ce1f6da8ed327d0cbd55ca1c376d018e31023b79c0ab", size = 21432, upload-time = "2025-11-14T10:06:39.709Z" },+ { url = "https://files.pythonhosted.org/packages/bd/37/e30cf4eef2b4c7e20ccadc1249117c77305fbc38b2e5904eb42e3753f63c/pyobjc_framework_vision-12.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:1edbf2fc18ce3b31108f845901a88f2236783ae6bf0bc68438d7ece572dc2a29", size = 21432, upload-time = "2025-11-14T10:06:42.373Z" },+ { url = "https://files.pythonhosted.org/packages/3a/5a/23502935b3fc877d7573e743fc3e6c28748f33a45c43851d503bde52cde7/pyobjc_framework_vision-12.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:6b3211d84f3a12aad0cde752cfd43a80d0218960ac9e6b46b141c730e7d655bd", size = 16625, upload-time = "2025-11-14T10:06:44.422Z" },+ { url = "https://files.pythonhosted.org/packages/f5/e4/e87361a31b82b22f8c0a59652d6e17625870dd002e8da75cb2343a84f2f9/pyobjc_framework_vision-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:7273e2508db4c2e88523b4b7ff38ac54808756e7ba01d78e6c08ea68f32577d2", size = 16640, upload-time = "2025-11-14T10:06:46.653Z" },+ { url = "https://files.pythonhosted.org/packages/b1/dd/def55d8a80b0817f486f2712fc6243482c3264d373dc5ff75037b3aeb7ea/pyobjc_framework_vision-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:04296f0848cc8cdead66c76df6063720885cbdf24fdfd1900749a6e2297313db", size = 16782, upload-time = "2025-11-14T10:06:48.816Z" },+ { url = "https://files.pythonhosted.org/packages/a7/a4/ee1ef14d6e1df6617e64dbaaa0ecf8ecb9e0af1425613fa633f6a94049c1/pyobjc_framework_vision-12.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:631add775ed1dafb221a6116137cdcd78432addc16200ca434571c2a039c0e03", size = 16614, upload-time = "2025-11-14T10:06:50.852Z" },+ { url = "https://files.pythonhosted.org/packages/af/53/187743d9244becd4499a77f8ee699ae286e2f6ade7c0c7ad2975ae60f187/pyobjc_framework_vision-12.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:fe41a1a70cc91068aee7b5293fa09dc66d1c666a8da79fdf948900988b439df6", size = 16771, upload-time = "2025-11-14T10:06:53.04Z" },+]+[[package]]name = "pyparsing"version = "3.2.5"@@ -3923,6 +4397,30 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/5f/ed/539768cf28c661b5b068d66d96a2f155c4971a5d55684a514c1a0e0dec2f/python_dotenv-1.1.1-py3-none-any.whl", hash = "sha256:31f23644fe2602f88ff55e1f5c79ba497e01224ee7737937930c448e4d0e24dc", size = 20556, upload-time = "2025-06-24T04:21:06.073Z" },]+[[package]]+name = "python-magic"+version = "0.4.27"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/da/db/0b3e28ac047452d079d375ec6798bf76a036a08182dbb39ed38116a49130/python-magic-0.4.27.tar.gz", hash = "sha256:c1ba14b08e4a5f5c31a302b7721239695b2f0f058d125bd5ce1ee36b9d9d3c3b", size = 14677, upload-time = "2022-06-07T20:16:59.508Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/6c/73/9f872cb81fc5c3bb48f7227872c28975f998f3e7c2b1c16e95e6432bbb90/python_magic-0.4.27-py2.py3-none-any.whl", hash = "sha256:c212960ad306f700aa0d01e5d7a325d20548ff97eb9920dcd29513174f0294d3", size = 13840, upload-time = "2022-06-07T20:16:57.763Z" },+]++[[package]]+name = "python-pptx"+version = "1.0.2"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "lxml" },+ { name = "pillow" },+ { name = "typing-extensions" },+ { name = "xlsxwriter" },+]+sdist = { url = "https://files.pythonhosted.org/packages/52/a9/0c0db8d37b2b8a645666f7fd8accea4c6224e013c42b1d5c17c93590cd06/python_pptx-1.0.2.tar.gz", hash = "sha256:479a8af0eaf0f0d76b6f00b0887732874ad2e3188230315290cd1f9dd9cc7095", size = 10109297, upload-time = "2024-08-07T17:33:37.772Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/d9/4f/00be2196329ebbff56ce564aa94efb0fbc828d00de250b1980de1a34ab49/python_pptx-1.0.2-py3-none-any.whl", hash = "sha256:160838e0b8565a8b1f67947675886e9fea18aa5e795db7ae531606d68e785cba", size = 472788, upload-time = "2024-08-07T17:33:28.192Z" },+]+[[package]]name = "pytz"version = "2025.2"@@ -4071,6 +4569,27 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/01/1b/5dbe84eefc86f48473947e2f41711aded97eecef1231f4558f1f02713c12/pyzmq-27.1.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:c9f7f6e13dff2e44a6afeaf2cf54cee5929ad64afaf4d40b50f93c58fc687355", size = 544862, upload-time = "2025-09-08T23:09:56.509Z" },]+[[package]]+name = "rapidocr"+version = "3.5.0"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "colorlog" },+ { name = "numpy" },+ { name = "omegaconf" },+ { name = "opencv-python" },+ { name = "pillow" },+ { name = "pyclipper" },+ { name = "pyyaml" },+ { name = "requests" },+ { name = "shapely" },+ { name = "six" },+ { name = "tqdm" },+]+wheels = [+ { url = "https://files.pythonhosted.org/packages/d2/f5/d93dfbb4f96acefe3a978ab2d0eab74d96c0388870f8d275792317c4857c/rapidocr-3.5.0-py3-none-any.whl", hash = "sha256:c0e361ffd0a26d2f27827361b0c563a87ee311e62b8c56ad52472c0fc6f1d78a", size = 15063134, upload-time = "2026-01-06T14:37:28.117Z" },+]+[[package]]name = "referencing"version = "0.36.2"@@ -4355,6 +4874,22 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/ce/08/4349bdd5c64d9d193c360aa9db89adeee6f6682ab8825dca0a3f535f434f/rpds_py-0.27.1-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:dc23e6820e3b40847e2f4a7726462ba0cf53089512abe9ee16318c366494c17a", size = 556523, upload-time = "2025-08-27T12:16:12.188Z" },]+[[package]]+name = "rtree"+version = "1.4.1"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/95/09/7302695875a019514de9a5dd17b8320e7a19d6e7bc8f85dcfb79a4ce2da3/rtree-1.4.1.tar.gz", hash = "sha256:c6b1b3550881e57ebe530cc6cffefc87cd9bf49c30b37b894065a9f810875e46", size = 52425, upload-time = "2025-08-13T19:32:01.413Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/04/d9/108cd989a4c0954e60b3cdc86fd2826407702b5375f6dfdab2802e5fed98/rtree-1.4.1-py3-none-macosx_10_9_x86_64.whl", hash = "sha256:d672184298527522d4914d8ae53bf76982b86ca420b0acde9298a7a87d81d4a4", size = 468484, upload-time = "2025-08-13T19:31:50.593Z" },+ { url = "https://files.pythonhosted.org/packages/f3/cf/2710b6fd6b07ea0aef317b29f335790ba6adf06a28ac236078ed9bd8a91d/rtree-1.4.1-py3-none-macosx_11_0_arm64.whl", hash = "sha256:a7e48d805e12011c2cf739a29d6a60ae852fb1de9fc84220bbcef67e6e595d7d", size = 436325, upload-time = "2025-08-13T19:31:52.367Z" },+ { url = "https://files.pythonhosted.org/packages/55/e1/4d075268a46e68db3cac51846eb6a3ab96ed481c585c5a1ad411b3c23aad/rtree-1.4.1-py3-none-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:efa8c4496e31e9ad58ff6c7df89abceac7022d906cb64a3e18e4fceae6b77f65", size = 459789, upload-time = "2025-08-13T19:31:53.926Z" },+ { url = "https://files.pythonhosted.org/packages/d1/75/e5d44be90525cd28503e7f836d077ae6663ec0687a13ba7810b4114b3668/rtree-1.4.1-py3-none-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:12de4578f1b3381a93a655846900be4e3d5f4cd5e306b8b00aa77c1121dc7e8c", size = 507644, upload-time = "2025-08-13T19:31:55.164Z" },+ { url = "https://files.pythonhosted.org/packages/fd/85/b8684f769a142163b52859a38a486493b05bafb4f2fb71d4f945de28ebf9/rtree-1.4.1-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:b558edda52eca3e6d1ee629042192c65e6b7f2c150d6d6cd207ce82f85be3967", size = 1454478, upload-time = "2025-08-13T19:31:56.808Z" },+ { url = "https://files.pythonhosted.org/packages/e9/a4/c2292b95246b9165cc43a0c3757e80995d58bc9b43da5cb47ad6e3535213/rtree-1.4.1-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:f155bc8d6bac9dcd383481dee8c130947a4866db1d16cb6dff442329a038a0dc", size = 1555140, upload-time = "2025-08-13T19:31:58.031Z" },+ { url = "https://files.pythonhosted.org/packages/74/25/5282c8270bfcd620d3e73beb35b40ac4ab00f0a898d98ebeb41ef0989ec8/rtree-1.4.1-py3-none-win_amd64.whl", hash = "sha256:efe125f416fd27150197ab8521158662943a40f87acab8028a1aac4ad667a489", size = 389358, upload-time = "2025-08-13T19:31:59.247Z" },+ { url = "https://files.pythonhosted.org/packages/3f/50/0a9e7e7afe7339bd5e36911f0ceb15fed51945836ed803ae5afd661057fd/rtree-1.4.1-py3-none-win_arm64.whl", hash = "sha256:3d46f55729b28138e897ffef32f7ce93ac335cb67f9120125ad3742a220800f0", size = 355253, upload-time = "2025-08-13T19:32:00.296Z" },+]+[[package]]name = "ruff"version = "0.12.7"@@ -4414,6 +4949,12 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/2c/c3/c0be1135726618dc1e28d181b8c442403d8dbb9e273fd791de2d4384bcdd/safetensors-0.6.2-cp38-abi3-win_amd64.whl", hash = "sha256:c7b214870df923cbc1593c3faee16bec59ea462758699bd3fee399d00aac072c", size = 320192, upload-time = "2025-08-08T13:13:59.467Z" },]+[package.optional-dependencies]+torch = [+ { name = "numpy" },+ { name = "torch" },+]+[[package]]name = "scikit-learn"version = "1.7.2"@@ -4464,7 +5005,9 @@ name = "scipy"version = "1.15.3"source = { registry = "https://pypi.org/simple" }resolution-markers = [- "python_full_version < '3.11'",+ "python_full_version < '3.11' and sys_platform == 'darwin'",+ "python_full_version < '3.11' and platform_machine == 'aarch64' and sys_platform == 'linux'",+ "(python_full_version < '3.11' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version < '3.11' and sys_platform != 'darwin' and sys_platform != 'linux')",]dependencies = [{ name = "numpy", marker = "python_full_version < '3.11'" },@@ -4523,8 +5066,12 @@ name = "scipy"version = "1.16.2"source = { registry = "https://pypi.org/simple" }resolution-markers = [- "python_full_version >= '3.12'",- "python_full_version == '3.11.*'",+ "python_full_version >= '3.12' and sys_platform == 'darwin'",+ "python_full_version >= '3.12' and platform_machine == 'aarch64' and sys_platform == 'linux'",+ "(python_full_version >= '3.12' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version >= '3.12' and sys_platform != 'darwin' and sys_platform != 'linux')",+ "python_full_version == '3.11.*' and sys_platform == 'darwin'",+ "python_full_version == '3.11.*' and platform_machine == 'aarch64' and sys_platform == 'linux'",+ "(python_full_version == '3.11.*' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version == '3.11.*' and sys_platform != 'darwin' and sys_platform != 'linux')",]dependencies = [{ name = "numpy", marker = "python_full_version >= '3.11'" },@@ -4607,6 +5154,19 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/83/11/00d3c3dfc25ad54e731d91449895a79e4bf2384dc3ac01809010ba88f6d5/seaborn-0.13.2-py3-none-any.whl", hash = "sha256:636f8336facf092165e27924f223d3c62ca560b1f2bb5dff7ab7fad265361987", size = 294914, upload-time = "2024-01-25T13:21:49.598Z" },]+[[package]]+name = "semchunk"+version = "2.2.2"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "mpire", extra = ["dill"] },+ { name = "tqdm" },+]+sdist = { url = "https://files.pythonhosted.org/packages/62/96/c418c322730b385e81d4ab462e68dd48bb2dbda4d8efa17cad2ca468d9ac/semchunk-2.2.2.tar.gz", hash = "sha256:940e89896e64eeb01de97ba60f51c8c7b96c6a3951dfcf574f25ce2146752f52", size = 12271, upload-time = "2024-12-17T22:54:30.332Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/76/84/94ca7896c7df20032bcb09973e9a4d14c222507c0aadf22e89fa76bb0a04/semchunk-2.2.2-py3-none-any.whl", hash = "sha256:94ca19020c013c073abdfd06d79a7c13637b91738335f3b8cdb5655ee7cc94d2", size = 10271, upload-time = "2024-12-17T22:54:27.689Z" },+]+[[package]]name = "sentence-transformers"version = "5.1.1"@@ -4738,6 +5298,73 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/b1/2b/44c336e0be9a9a23e56b6fcfed3b6f03dfc8a4181ef2cc82129aa9811fa8/sglang-0.5.2-py3-none-any.whl", hash = "sha256:83aae146f3913ed0802bb1ea356facff47efe0e7d18041a3f143de9ef6e44b2c", size = 2184239, upload-time = "2025-09-11T23:09:46.458Z" },]+[[package]]+name = "shapely"+version = "2.1.2"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "numpy" },+]+sdist = { url = "https://files.pythonhosted.org/packages/4d/bc/0989043118a27cccb4e906a46b7565ce36ca7b57f5a18b78f4f1b0f72d9d/shapely-2.1.2.tar.gz", hash = "sha256:2ed4ecb28320a433db18a5bf029986aa8afcfd740745e78847e330d5d94922a9", size = 315489, upload-time = "2025-09-24T13:51:41.432Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/05/89/c3548aa9b9812a5d143986764dededfa48d817714e947398bdda87c77a72/shapely-2.1.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:7ae48c236c0324b4e139bea88a306a04ca630f49be66741b340729d380d8f52f", size = 1825959, upload-time = "2025-09-24T13:50:00.682Z" },+ { url = "https://files.pythonhosted.org/packages/ce/8a/7ebc947080442edd614ceebe0ce2cdbd00c25e832c240e1d1de61d0e6b38/shapely-2.1.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:eba6710407f1daa8e7602c347dfc94adc02205ec27ed956346190d66579eb9ea", size = 1629196, upload-time = "2025-09-24T13:50:03.447Z" },+ { url = "https://files.pythonhosted.org/packages/c8/86/c9c27881c20d00fc409e7e059de569d5ed0abfcec9c49548b124ebddea51/shapely-2.1.2-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ef4a456cc8b7b3d50ccec29642aa4aeda959e9da2fe9540a92754770d5f0cf1f", size = 2951065, upload-time = "2025-09-24T13:50:05.266Z" },+ { url = "https://files.pythonhosted.org/packages/50/8a/0ab1f7433a2a85d9e9aea5b1fbb333f3b09b309e7817309250b4b7b2cc7a/shapely-2.1.2-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e38a190442aacc67ff9f75ce60aec04893041f16f97d242209106d502486a142", size = 3058666, upload-time = "2025-09-24T13:50:06.872Z" },+ { url = "https://files.pythonhosted.org/packages/bb/c6/5a30ffac9c4f3ffd5b7113a7f5299ccec4713acd5ee44039778a7698224e/shapely-2.1.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:40d784101f5d06a1fd30b55fc11ea58a61be23f930d934d86f19a180909908a4", size = 3966905, upload-time = "2025-09-24T13:50:09.417Z" },+ { url = "https://files.pythonhosted.org/packages/9c/72/e92f3035ba43e53959007f928315a68fbcf2eeb4e5ededb6f0dc7ff1ecc3/shapely-2.1.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f6f6cd5819c50d9bcf921882784586aab34a4bd53e7553e175dece6db513a6f0", size = 4129260, upload-time = "2025-09-24T13:50:11.183Z" },+ { url = "https://files.pythonhosted.org/packages/42/24/605901b73a3d9f65fa958e63c9211f4be23d584da8a1a7487382fac7fdc5/shapely-2.1.2-cp310-cp310-win32.whl", hash = "sha256:fe9627c39c59e553c90f5bc3128252cb85dc3b3be8189710666d2f8bc3a5503e", size = 1544301, upload-time = "2025-09-24T13:50:12.521Z" },+ { url = "https://files.pythonhosted.org/packages/e1/89/6db795b8dd3919851856bd2ddd13ce434a748072f6fdee42ff30cbd3afa3/shapely-2.1.2-cp310-cp310-win_amd64.whl", hash = "sha256:1d0bfb4b8f661b3b4ec3565fa36c340bfb1cda82087199711f86a88647d26b2f", size = 1722074, upload-time = "2025-09-24T13:50:13.909Z" },+ { url = "https://files.pythonhosted.org/packages/8f/8d/1ff672dea9ec6a7b5d422eb6d095ed886e2e523733329f75fdcb14ee1149/shapely-2.1.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:91121757b0a36c9aac3427a651a7e6567110a4a67c97edf04f8d55d4765f6618", size = 1820038, upload-time = "2025-09-24T13:50:15.628Z" },+ { url = "https://files.pythonhosted.org/packages/4f/ce/28fab8c772ce5db23a0d86bf0adaee0c4c79d5ad1db766055fa3dab442e2/shapely-2.1.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:16a9c722ba774cf50b5d4541242b4cce05aafd44a015290c82ba8a16931ff63d", size = 1626039, upload-time = "2025-09-24T13:50:16.881Z" },+ { url = "https://files.pythonhosted.org/packages/70/8b/868b7e3f4982f5006e9395c1e12343c66a8155c0374fdc07c0e6a1ab547d/shapely-2.1.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cc4f7397459b12c0b196c9efe1f9d7e92463cbba142632b4cc6d8bbbbd3e2b09", size = 3001519, upload-time = "2025-09-24T13:50:18.606Z" },+ { url = "https://files.pythonhosted.org/packages/13/02/58b0b8d9c17c93ab6340edd8b7308c0c5a5b81f94ce65705819b7416dba5/shapely-2.1.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:136ab87b17e733e22f0961504d05e77e7be8c9b5a8184f685b4a91a84efe3c26", size = 3110842, upload-time = "2025-09-24T13:50:21.77Z" },+ { url = "https://files.pythonhosted.org/packages/af/61/8e389c97994d5f331dcffb25e2fa761aeedfb52b3ad9bcdd7b8671f4810a/shapely-2.1.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:16c5d0fc45d3aa0a69074979f4f1928ca2734fb2e0dde8af9611e134e46774e7", size = 4021316, upload-time = "2025-09-24T13:50:23.626Z" },+ { url = "https://files.pythonhosted.org/packages/d3/d4/9b2a9fe6039f9e42ccf2cb3e84f219fd8364b0c3b8e7bbc857b5fbe9c14c/shapely-2.1.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6ddc759f72b5b2b0f54a7e7cde44acef680a55019eb52ac63a7af2cf17cb9cd2", size = 4178586, upload-time = "2025-09-24T13:50:25.443Z" },+ { url = "https://files.pythonhosted.org/packages/16/f6/9840f6963ed4decf76b08fd6d7fed14f8779fb7a62cb45c5617fa8ac6eab/shapely-2.1.2-cp311-cp311-win32.whl", hash = "sha256:2fa78b49485391224755a856ed3b3bd91c8455f6121fee0db0e71cefb07d0ef6", size = 1543961, upload-time = "2025-09-24T13:50:26.968Z" },+ { url = "https://files.pythonhosted.org/packages/38/1e/3f8ea46353c2a33c1669eb7327f9665103aa3a8dfe7f2e4ef714c210b2c2/shapely-2.1.2-cp311-cp311-win_amd64.whl", hash = "sha256:c64d5c97b2f47e3cd9b712eaced3b061f2b71234b3fc263e0fcf7d889c6559dc", size = 1722856, upload-time = "2025-09-24T13:50:28.497Z" },+ { url = "https://files.pythonhosted.org/packages/24/c0/f3b6453cf2dfa99adc0ba6675f9aaff9e526d2224cbd7ff9c1a879238693/shapely-2.1.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fe2533caae6a91a543dec62e8360fe86ffcdc42a7c55f9dfd0128a977a896b94", size = 1833550, upload-time = "2025-09-24T13:50:30.019Z" },+ { url = "https://files.pythonhosted.org/packages/86/07/59dee0bc4b913b7ab59ab1086225baca5b8f19865e6101db9ebb7243e132/shapely-2.1.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ba4d1333cc0bc94381d6d4308d2e4e008e0bd128bdcff5573199742ee3634359", size = 1643556, upload-time = "2025-09-24T13:50:32.291Z" },+ { url = "https://files.pythonhosted.org/packages/26/29/a5397e75b435b9895cd53e165083faed5d12fd9626eadec15a83a2411f0f/shapely-2.1.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0bd308103340030feef6c111d3eb98d50dc13feea33affc8a6f9fa549e9458a3", size = 2988308, upload-time = "2025-09-24T13:50:33.862Z" },+ { url = "https://files.pythonhosted.org/packages/b9/37/e781683abac55dde9771e086b790e554811a71ed0b2b8a1e789b7430dd44/shapely-2.1.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1e7d4d7ad262a48bb44277ca12c7c78cb1b0f56b32c10734ec9a1d30c0b0c54b", size = 3099844, upload-time = "2025-09-24T13:50:35.459Z" },+ { url = "https://files.pythonhosted.org/packages/d8/f3/9876b64d4a5a321b9dc482c92bb6f061f2fa42131cba643c699f39317cb9/shapely-2.1.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e9eddfe513096a71896441a7c37db72da0687b34752c4e193577a145c71736fc", size = 3988842, upload-time = "2025-09-24T13:50:37.478Z" },+ { url = "https://files.pythonhosted.org/packages/d1/a0/704c7292f7014c7e74ec84eddb7b109e1fbae74a16deae9c1504b1d15565/shapely-2.1.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:980c777c612514c0cf99bc8a9de6d286f5e186dcaf9091252fcd444e5638193d", size = 4152714, upload-time = "2025-09-24T13:50:39.9Z" },+ { url = "https://files.pythonhosted.org/packages/53/46/319c9dc788884ad0785242543cdffac0e6530e4d0deb6c4862bc4143dcf3/shapely-2.1.2-cp312-cp312-win32.whl", hash = "sha256:9111274b88e4d7b54a95218e243282709b330ef52b7b86bc6aaf4f805306f454", size = 1542745, upload-time = "2025-09-24T13:50:41.414Z" },+ { url = "https://files.pythonhosted.org/packages/ec/bf/cb6c1c505cb31e818e900b9312d514f381fbfa5c4363edfce0fcc4f8c1a4/shapely-2.1.2-cp312-cp312-win_amd64.whl", hash = "sha256:743044b4cfb34f9a67205cee9279feaf60ba7d02e69febc2afc609047cb49179", size = 1722861, upload-time = "2025-09-24T13:50:43.35Z" },+ { url = "https://files.pythonhosted.org/packages/c3/90/98ef257c23c46425dc4d1d31005ad7c8d649fe423a38b917db02c30f1f5a/shapely-2.1.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b510dda1a3672d6879beb319bc7c5fd302c6c354584690973c838f46ec3e0fa8", size = 1832644, upload-time = "2025-09-24T13:50:44.886Z" },+ { url = "https://files.pythonhosted.org/packages/6d/ab/0bee5a830d209adcd3a01f2d4b70e587cdd9fd7380d5198c064091005af8/shapely-2.1.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:8cff473e81017594d20ec55d86b54bc635544897e13a7cfc12e36909c5309a2a", size = 1642887, upload-time = "2025-09-24T13:50:46.735Z" },+ { url = "https://files.pythonhosted.org/packages/2d/5e/7d7f54ba960c13302584c73704d8c4d15404a51024631adb60b126a4ae88/shapely-2.1.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:fe7b77dc63d707c09726b7908f575fc04ff1d1ad0f3fb92aec212396bc6cfe5e", size = 2970931, upload-time = "2025-09-24T13:50:48.374Z" },+ { url = "https://files.pythonhosted.org/packages/f2/a2/83fc37e2a58090e3d2ff79175a95493c664bcd0b653dd75cb9134645a4e5/shapely-2.1.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7ed1a5bbfb386ee8332713bf7508bc24e32d24b74fc9a7b9f8529a55db9f4ee6", size = 3082855, upload-time = "2025-09-24T13:50:50.037Z" },+ { url = "https://files.pythonhosted.org/packages/44/2b/578faf235a5b09f16b5f02833c53822294d7f21b242f8e2d0cf03fb64321/shapely-2.1.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a84e0582858d841d54355246ddfcbd1fce3179f185da7470f41ce39d001ee1af", size = 3979960, upload-time = "2025-09-24T13:50:51.74Z" },+ { url = "https://files.pythonhosted.org/packages/4d/04/167f096386120f692cc4ca02f75a17b961858997a95e67a3cb6a7bbd6b53/shapely-2.1.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:dc3487447a43d42adcdf52d7ac73804f2312cbfa5d433a7d2c506dcab0033dfd", size = 4142851, upload-time = "2025-09-24T13:50:53.49Z" },+ { url = "https://files.pythonhosted.org/packages/48/74/fb402c5a6235d1c65a97348b48cdedb75fb19eca2b1d66d04969fc1c6091/shapely-2.1.2-cp313-cp313-win32.whl", hash = "sha256:9c3a3c648aedc9f99c09263b39f2d8252f199cb3ac154fadc173283d7d111350", size = 1541890, upload-time = "2025-09-24T13:50:55.337Z" },+ { url = "https://files.pythonhosted.org/packages/41/47/3647fe7ad990af60ad98b889657a976042c9988c2807cf322a9d6685f462/shapely-2.1.2-cp313-cp313-win_amd64.whl", hash = "sha256:ca2591bff6645c216695bdf1614fca9c82ea1144d4a7591a466fef64f28f0715", size = 1722151, upload-time = "2025-09-24T13:50:57.153Z" },+ { url = "https://files.pythonhosted.org/packages/3c/49/63953754faa51ffe7d8189bfbe9ca34def29f8c0e34c67cbe2a2795f269d/shapely-2.1.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:2d93d23bdd2ed9dc157b46bc2f19b7da143ca8714464249bef6771c679d5ff40", size = 1834130, upload-time = "2025-09-24T13:50:58.49Z" },+ { url = "https://files.pythonhosted.org/packages/7f/ee/dce001c1984052970ff60eb4727164892fb2d08052c575042a47f5a9e88f/shapely-2.1.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:01d0d304b25634d60bd7cf291828119ab55a3bab87dc4af1e44b07fb225f188b", size = 1642802, upload-time = "2025-09-24T13:50:59.871Z" },+ { url = "https://files.pythonhosted.org/packages/da/e7/fc4e9a19929522877fa602f705706b96e78376afb7fad09cad5b9af1553c/shapely-2.1.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8d8382dd120d64b03698b7298b89611a6ea6f55ada9d39942838b79c9bc89801", size = 3018460, upload-time = "2025-09-24T13:51:02.08Z" },+ { url = "https://files.pythonhosted.org/packages/a1/18/7519a25db21847b525696883ddc8e6a0ecaa36159ea88e0fef11466384d0/shapely-2.1.2-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:19efa3611eef966e776183e338b2d7ea43569ae99ab34f8d17c2c054d3205cc0", size = 3095223, upload-time = "2025-09-24T13:51:04.472Z" },+ { url = "https://files.pythonhosted.org/packages/48/de/b59a620b1f3a129c3fecc2737104a0a7e04e79335bd3b0a1f1609744cf17/shapely-2.1.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:346ec0c1a0fcd32f57f00e4134d1200e14bf3f5ae12af87ba83ca275c502498c", size = 4030760, upload-time = "2025-09-24T13:51:06.455Z" },+ { url = "https://files.pythonhosted.org/packages/96/b3/c6655ee7232b417562bae192ae0d3ceaadb1cc0ffc2088a2ddf415456cc2/shapely-2.1.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6305993a35989391bd3476ee538a5c9a845861462327efe00dd11a5c8c709a99", size = 4170078, upload-time = "2025-09-24T13:51:08.584Z" },+ { url = "https://files.pythonhosted.org/packages/a0/8e/605c76808d73503c9333af8f6cbe7e1354d2d238bda5f88eea36bfe0f42a/shapely-2.1.2-cp313-cp313t-win32.whl", hash = "sha256:c8876673449f3401f278c86eb33224c5764582f72b653a415d0e6672fde887bf", size = 1559178, upload-time = "2025-09-24T13:51:10.73Z" },+ { url = "https://files.pythonhosted.org/packages/36/f7/d317eb232352a1f1444d11002d477e54514a4a6045536d49d0c59783c0da/shapely-2.1.2-cp313-cp313t-win_amd64.whl", hash = "sha256:4a44bc62a10d84c11a7a3d7c1c4fe857f7477c3506e24c9062da0db0ae0c449c", size = 1739756, upload-time = "2025-09-24T13:51:12.105Z" },+ { url = "https://files.pythonhosted.org/packages/fc/c4/3ce4c2d9b6aabd27d26ec988f08cb877ba9e6e96086eff81bfea93e688c7/shapely-2.1.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:9a522f460d28e2bf4e12396240a5fc1518788b2fcd73535166d748399ef0c223", size = 1831290, upload-time = "2025-09-24T13:51:13.56Z" },+ { url = "https://files.pythonhosted.org/packages/17/b9/f6ab8918fc15429f79cb04afa9f9913546212d7fb5e5196132a2af46676b/shapely-2.1.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1ff629e00818033b8d71139565527ced7d776c269a49bd78c9df84e8f852190c", size = 1641463, upload-time = "2025-09-24T13:51:14.972Z" },+ { url = "https://files.pythonhosted.org/packages/a5/57/91d59ae525ca641e7ac5551c04c9503aee6f29b92b392f31790fcb1a4358/shapely-2.1.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f67b34271dedc3c653eba4e3d7111aa421d5be9b4c4c7d38d30907f796cb30df", size = 2970145, upload-time = "2025-09-24T13:51:16.961Z" },+ { url = "https://files.pythonhosted.org/packages/8a/cb/4948be52ee1da6927831ab59e10d4c29baa2a714f599f1f0d1bc747f5777/shapely-2.1.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:21952dc00df38a2c28375659b07a3979d22641aeb104751e769c3ee825aadecf", size = 3073806, upload-time = "2025-09-24T13:51:18.712Z" },+ { url = "https://files.pythonhosted.org/packages/03/83/f768a54af775eb41ef2e7bec8a0a0dbe7d2431c3e78c0a8bdba7ab17e446/shapely-2.1.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:1f2f33f486777456586948e333a56ae21f35ae273be99255a191f5c1fa302eb4", size = 3980803, upload-time = "2025-09-24T13:51:20.37Z" },+ { url = "https://files.pythonhosted.org/packages/9f/cb/559c7c195807c91c79d38a1f6901384a2878a76fbdf3f1048893a9b7534d/shapely-2.1.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:cf831a13e0d5a7eb519e96f58ec26e049b1fad411fc6fc23b162a7ce04d9cffc", size = 4133301, upload-time = "2025-09-24T13:51:21.887Z" },+ { url = "https://files.pythonhosted.org/packages/80/cd/60d5ae203241c53ef3abd2ef27c6800e21afd6c94e39db5315ea0cbafb4a/shapely-2.1.2-cp314-cp314-win32.whl", hash = "sha256:61edcd8d0d17dd99075d320a1dd39c0cb9616f7572f10ef91b4b5b00c4aeb566", size = 1583247, upload-time = "2025-09-24T13:51:23.401Z" },+ { url = "https://files.pythonhosted.org/packages/74/d4/135684f342e909330e50d31d441ace06bf83c7dc0777e11043f99167b123/shapely-2.1.2-cp314-cp314-win_amd64.whl", hash = "sha256:a444e7afccdb0999e203b976adb37ea633725333e5b119ad40b1ca291ecf311c", size = 1773019, upload-time = "2025-09-24T13:51:24.873Z" },+ { url = "https://files.pythonhosted.org/packages/a3/05/a44f3f9f695fa3ada22786dc9da33c933da1cbc4bfe876fe3a100bafe263/shapely-2.1.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:5ebe3f84c6112ad3d4632b1fd2290665aa75d4cef5f6c5d77c4c95b324527c6a", size = 1834137, upload-time = "2025-09-24T13:51:26.665Z" },+ { url = "https://files.pythonhosted.org/packages/52/7e/4d57db45bf314573427b0a70dfca15d912d108e6023f623947fa69f39b72/shapely-2.1.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5860eb9f00a1d49ebb14e881f5caf6c2cf472c7fd38bd7f253bbd34f934eb076", size = 1642884, upload-time = "2025-09-24T13:51:28.029Z" },+ { url = "https://files.pythonhosted.org/packages/5a/27/4e29c0a55d6d14ad7422bf86995d7ff3f54af0eba59617eb95caf84b9680/shapely-2.1.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b705c99c76695702656327b819c9660768ec33f5ce01fa32b2af62b56ba400a1", size = 3018320, upload-time = "2025-09-24T13:51:29.903Z" },+ { url = "https://files.pythonhosted.org/packages/9f/bb/992e6a3c463f4d29d4cd6ab8963b75b1b1040199edbd72beada4af46bde5/shapely-2.1.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a1fd0ea855b2cf7c9cddaf25543e914dd75af9de08785f20ca3085f2c9ca60b0", size = 3094931, upload-time = "2025-09-24T13:51:32.699Z" },+ { url = "https://files.pythonhosted.org/packages/9c/16/82e65e21070e473f0ed6451224ed9fa0be85033d17e0c6e7213a12f59d12/shapely-2.1.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:df90e2db118c3671a0754f38e36802db75fe0920d211a27481daf50a711fdf26", size = 4030406, upload-time = "2025-09-24T13:51:34.189Z" },+ { url = "https://files.pythonhosted.org/packages/7c/75/c24ed871c576d7e2b64b04b1fe3d075157f6eb54e59670d3f5ffb36e25c7/shapely-2.1.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:361b6d45030b4ac64ddd0a26046906c8202eb60d0f9f53085f5179f1d23021a0", size = 4169511, upload-time = "2025-09-24T13:51:36.297Z" },+ { url = "https://files.pythonhosted.org/packages/b1/f7/b3d1d6d18ebf55236eec1c681ce5e665742aab3c0b7b232720a7d43df7b6/shapely-2.1.2-cp314-cp314t-win32.whl", hash = "sha256:b54df60f1fbdecc8ebc2c5b11870461a6417b3d617f555e5033f1505d36e5735", size = 1602607, upload-time = "2025-09-24T13:51:37.757Z" },+ { url = "https://files.pythonhosted.org/packages/9a/f6/f09272a71976dfc138129b8faf435d064a811ae2f708cb147dccdf7aacdb/shapely-2.1.2-cp314-cp314t-win_amd64.whl", hash = "sha256:0036ac886e0923417932c2e6369b6c52e38e0ff5d9120b90eef5cd9a5fc5cae9", size = 1796682, upload-time = "2025-09-24T13:51:39.233Z" },+]+[[package]]name = "shellingham"version = "1.5.4"@@ -4859,6 +5486,15 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", hash = "sha256:e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5", size = 6299353, upload-time = "2025-04-27T18:04:59.103Z" },]+[[package]]+name = "tabulate"+version = "0.9.0"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/ec/fe/802052aecb21e3797b8f7902564ab6ea0d60ff8ca23952079064155d1ae1/tabulate-0.9.0.tar.gz", hash = "sha256:0095b12bf5966de529c0feb1fa08671671b3368eec77d7ef7ab114be2c068b3c", size = 81090, upload-time = "2022-10-06T17:21:48.54Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/40/44/4a5f08c96eb108af5cb50b41f76142f0afa346dfa99d5296fe7202a11854/tabulate-0.9.0-py3-none-any.whl", hash = "sha256:024ca478df22e9340661486f85298cff5f6dcdba14f3813e8830015b9ed1948f", size = 35252, upload-time = "2022-10-06T17:21:44.262Z" },+]+[[package]]name = "tenacity"version = "9.1.2"@@ -5206,6 +5842,21 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/ce/33/3591e7b22dd49f46ae4fdee1db316ecefd0486cae880c5b497a55f0ccb24/tree_sitter-0.25.1-cp314-cp314-win_arm64.whl", hash = "sha256:f7b68f584336b39b2deab9896b629dddc3c784170733d3409f01fe825e9c04eb", size = 117376, upload-time = "2025-08-05T17:14:33.283Z" },]+[[package]]+name = "tree-sitter-c"+version = "0.24.1"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/f1/f5/ba8cd08d717277551ade8537d3aa2a94b907c6c6e0fbcf4e4d8b1c747fa3/tree_sitter_c-0.24.1.tar.gz", hash = "sha256:7d2d0cda0b8dda428c81440c1e94367f9f13548eedca3f49768bde66b1422ad6", size = 228014, upload-time = "2025-05-24T17:32:58.384Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/15/c7/c817be36306e457c2d36cc324789046390d9d8c555c38772429ffdb7d361/tree_sitter_c-0.24.1-cp310-abi3-macosx_10_9_x86_64.whl", hash = "sha256:9c06ac26a1efdcc8b26a8a6970fbc6997c4071857359e5837d4c42892d45fe1e", size = 80940, upload-time = "2025-05-24T17:32:49.967Z" },+ { url = "https://files.pythonhosted.org/packages/7a/42/283909467290b24fdbc29bb32ee20e409a19a55002b43175d66d091ca1a4/tree_sitter_c-0.24.1-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:942bcd7cbecd810dcf7ca6f8f834391ebf0771a89479646d891ba4ca2fdfdc88", size = 86304, upload-time = "2025-05-24T17:32:51.271Z" },+ { url = "https://files.pythonhosted.org/packages/94/53/fb4f61d4e5f15ec3da85774a4df8e58d3b5b73036cf167f0203b4dd9d158/tree_sitter_c-0.24.1-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9a74cfd7a11ca5a961fafd4d751892ee65acae667d2818968a6f079397d8d28c", size = 109996, upload-time = "2025-05-24T17:32:52.119Z" },+ { url = "https://files.pythonhosted.org/packages/5e/e8/fc541d34ee81c386c5453c2596c1763e8e9cd7cb0725f39d7dfa2276afa4/tree_sitter_c-0.24.1-cp310-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a6a807705a3978911dc7ee26a7ad36dcfacb6adfc13c190d496660ec9bd66707", size = 98137, upload-time = "2025-05-24T17:32:53.361Z" },+ { url = "https://files.pythonhosted.org/packages/32/c6/d0563319cae0d5b5780a92e2806074b24afea2a07aa4c10599b899bda3ec/tree_sitter_c-0.24.1-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:789781afcb710df34144f7e2a20cd80e325114b9119e3956c6bd1dd2d365df98", size = 94148, upload-time = "2025-05-24T17:32:54.855Z" },+ { url = "https://files.pythonhosted.org/packages/50/5a/6361df7f3fa2310c53a0d26b4702a261c332da16fa9d801e381e3a86e25f/tree_sitter_c-0.24.1-cp310-abi3-win_amd64.whl", hash = "sha256:290bff0f9c79c966496ebae45042f77543e6e4aea725f40587a8611d566231a8", size = 84703, upload-time = "2025-05-24T17:32:56.084Z" },+ { url = "https://files.pythonhosted.org/packages/22/6a/210a302e8025ac492cbaea58d3720d66b7d8034c5d747ac5e4d2d235aa25/tree_sitter_c-0.24.1-cp310-abi3-win_arm64.whl", hash = "sha256:d46bbda06f838c2dcb91daf767813671fd366b49ad84ff37db702129267b46e1", size = 82715, upload-time = "2025-05-24T17:32:57.248Z" },+]+[[package]]name = "tree-sitter-c-sharp"version = "0.23.1"@@ -5236,6 +5887,22 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/72/57/5bab54d23179350356515526fff3cc0f3ac23bfbc1a1d518a15978d4880e/tree_sitter_java-0.23.5-cp39-abi3-win_arm64.whl", hash = "sha256:402efe136104c5603b429dc26c7e75ae14faaca54cfd319ecc41c8f2534750f4", size = 59059, upload-time = "2024-12-21T18:24:24.934Z" },]+[[package]]+name = "tree-sitter-javascript"+version = "0.25.0"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/59/e0/e63103c72a9d3dfd89a31e02e660263ad84b7438e5f44ee82e443e65bbde/tree_sitter_javascript-0.25.0.tar.gz", hash = "sha256:329b5414874f0588a98f1c291f1b28138286617aa907746ffe55adfdcf963f38", size = 132338, upload-time = "2025-09-01T07:13:44.792Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/2c/df/5106ac250cd03661ebc3cc75da6b3d9f6800a3606393a0122eca58038104/tree_sitter_javascript-0.25.0-cp310-abi3-macosx_10_9_x86_64.whl", hash = "sha256:b70f887fb269d6e58c349d683f59fa647140c410cfe2bee44a883b20ec92e3dc", size = 64052, upload-time = "2025-09-01T07:13:36.865Z" },+ { url = "https://files.pythonhosted.org/packages/b1/8f/6b4b2bc90d8ab3955856ce852cc9d1e82c81d7ab9646385f0e75ffd5b5d3/tree_sitter_javascript-0.25.0-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:8264a996b8845cfce06965152a013b5d9cbb7d199bc3503e12b5682e62bb1de1", size = 66440, upload-time = "2025-09-01T07:13:37.962Z" },+ { url = "https://files.pythonhosted.org/packages/5f/c4/7da74ecdcd8a398f88bd003a87c65403b5fe0e958cdd43fbd5fd4a398fcf/tree_sitter_javascript-0.25.0-cp310-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9dc04ba91fc8583344e57c1f1ed5b2c97ecaaf47480011b92fbeab8dda96db75", size = 99728, upload-time = "2025-09-01T07:13:38.755Z" },+ { url = "https://files.pythonhosted.org/packages/96/c8/97da3af4796495e46421e9344738addb3602fa6426ea695be3fcbadbee37/tree_sitter_javascript-0.25.0-cp310-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:199d09985190852e0912da2b8d26c932159be314bc04952cf917ed0e4c633e6b", size = 106072, upload-time = "2025-09-01T07:13:39.798Z" },+ { url = "https://files.pythonhosted.org/packages/13/be/c964e8130be08cc9bd6627d845f0e4460945b158429d39510953bbcb8fcc/tree_sitter_javascript-0.25.0-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:dfcf789064c58dc13c0a4edb550acacfc6f0f280577f1e7a00de3e89fc7f8ddc", size = 104388, upload-time = "2025-09-01T07:13:40.866Z" },+ { url = "https://files.pythonhosted.org/packages/ee/89/9b773dee0f8961d1bb8d7baf0a204ab587618df19897c1ef260916f318ec/tree_sitter_javascript-0.25.0-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:1b852d3aee8a36186dbcc32c798b11b4869f9b5041743b63b65c2ef793db7a54", size = 98377, upload-time = "2025-09-01T07:13:41.838Z" },+ { url = "https://files.pythonhosted.org/packages/3b/dc/d90cb1790f8cec9b4878d278ad9faf7c8f893189ce0f855304fd704fc274/tree_sitter_javascript-0.25.0-cp310-abi3-win_amd64.whl", hash = "sha256:e5ed840f5bd4a3f0272e441d19429b26eedc257abe5574c8546da6b556865e3c", size = 62975, upload-time = "2025-09-01T07:13:42.828Z" },+ { url = "https://files.pythonhosted.org/packages/2e/1f/f9eba1038b7d4394410f3c0a6ec2122b590cd7acb03f196e52fa57ebbe72/tree_sitter_javascript-0.25.0-cp310-abi3-win_arm64.whl", hash = "sha256:622a69d677aa7f6ee2931d8c77c981a33f0ebb6d275aa9d43d3397c879a9bb0b", size = 61668, upload-time = "2025-09-01T07:13:43.803Z" },+]+[[package]]name = "tree-sitter-python"version = "0.25.0"@@ -5451,6 +6118,15 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },]+[[package]]+name = "xlsxwriter"+version = "3.2.9"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/46/2c/c06ef49dc36e7954e55b802a8b231770d286a9758b3d936bd1e04ce5ba88/xlsxwriter-3.2.9.tar.gz", hash = "sha256:254b1c37a368c444eac6e2f867405cc9e461b0ed97a3233b2ac1e574efb4140c", size = 215940, upload-time = "2025-09-16T00:16:21.63Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/3a/0c/3662f4a66880196a590b202f0db82d919dd2f89e99a27fadef91c4a33d41/xlsxwriter-3.2.9-py3-none-any.whl", hash = "sha256:9a5db42bc5dff014806c58a20b9eae7322a134abb6fce3c92c181bfb275ec5b3", size = 175315, upload-time = "2025-09-16T00:16:20.108Z" },+]+[[package]]name = "xxhash"version = "3.5.0"