natural-pdf 0.1.37__py3-none-any.whl → 0.1.38__py3-none-any.whl

natural_pdf/core/page.py

@@ -1655,7 +1655,27 @@ class Page(ClassificationMixin, ExtractionMixin, ShapeDetectionMixin, DescribeMi
                     table_settings.setdefault("join_x_tolerance", join)
                     table_settings.setdefault("join_y_tolerance", join)
 
-            return self._page.extract_tables(table_settings)
+            raw_tables = self._page.extract_tables(table_settings)
+            
+            # Apply RTL text processing to all extracted tables
+            if raw_tables:
+                processed_tables = []
+                for table in raw_tables:
+                    processed_table = []
+                    for row in table:
+                        processed_row = []
+                        for cell in row:
+                            if cell is not None:
+                                # Apply RTL text processing to each cell
+                                rtl_processed_cell = self._apply_rtl_processing_to_text(cell)
+                                processed_row.append(rtl_processed_cell)
+                            else:
+                                processed_row.append(cell)
+                        processed_table.append(processed_row)
+                    processed_tables.append(processed_table)
+                return processed_tables
+            
+            return raw_tables
         else:
             raise ValueError(
                 f"Unknown tables extraction method: '{method}'. Choose from 'pdfplumber', 'stream', 'lattice'."
@@ -3280,6 +3300,54 @@ class Page(ClassificationMixin, ExtractionMixin, ShapeDetectionMixin, DescribeMi
         )
         return self
 
+    def _apply_rtl_processing_to_text(self, text: str) -> str:
+        """
+        Apply RTL (Right-to-Left) text processing to a string.
+        
+        This converts visual order text (as stored in PDFs) to logical order
+        for proper display of Arabic, Hebrew, and other RTL scripts.
+        
+        Args:
+            text: Input text string in visual order
+            
+        Returns:
+            Text string in logical order
+        """
+        if not text or not text.strip():
+            return text
+            
+        # Quick check for RTL characters - if none found, return as-is
+        import unicodedata
+        
+        def _contains_rtl(s):
+            return any(unicodedata.bidirectional(ch) in ("R", "AL", "AN") for ch in s)
+        
+        if not _contains_rtl(text):
+            return text
+            
+        try:
+            from bidi.algorithm import get_display  # type: ignore
+            from natural_pdf.utils.bidi_mirror import mirror_brackets
+            
+            # Apply BiDi algorithm to convert from visual to logical order
+            # Process line by line to handle mixed content properly
+            processed_lines = []
+            for line in text.split("\n"):
+                if line.strip():
+                    # Determine base direction for this line
+                    base_dir = "R" if _contains_rtl(line) else "L"
+                    logical_line = get_display(line, base_dir=base_dir)
+                    # Apply bracket mirroring for correct logical order
+                    processed_lines.append(mirror_brackets(logical_line))
+                else:
+                    processed_lines.append(line)
+            
+            return "\n".join(processed_lines)
+            
+        except (ImportError, Exception):
+            # If bidi library is not available or fails, return original text
+            return text
+
     @property
     def lines(self) -> List[Any]:
         """Get all line elements on this page."""

natural_pdf/core/pdf.py

@@ -103,6 +103,7 @@ except ImportError:
 from collections.abc import Sequence
 
 
+
 class _LazyPageList(Sequence):
     """A lightweight, list-like object that lazily instantiates natural-pdf Page objects.
 
@@ -121,6 +122,7 @@ class _LazyPageList(Sequence):
         _font_attrs: Font attributes to use when creating pages.
         _cache: List of cached Page objects (None until accessed).
         _load_text: Whether to load text layer when creating pages.
+        _indices: Optional range of indices this list represents (for slices).
 
     Example:
         ```python
@@ -130,7 +132,7 @@ class _LazyPageList(Sequence):
         last_page = pdf.pages[-1]  # Creates another Page object
 
         # Slicing works too
-        first_three = pdf.pages[0:3]  # Creates 3 Page objects
+        first_three = pdf.pages[0:3]  # Returns another lazy list
 
         # Iteration creates all pages
         for page in pdf.pages:  # Each page created as needed
@@ -139,30 +141,71 @@ class _LazyPageList(Sequence):
     """
 
     def __init__(
-        self, parent_pdf: "PDF", plumber_pdf: "pdfplumber.PDF", font_attrs=None, load_text=True
+        self, 
+        parent_pdf: "PDF", 
+        plumber_pdf: "pdfplumber.PDF", 
+        font_attrs=None, 
+        load_text=True,
+        indices: Optional[List[int]] = None
     ):
         self._parent_pdf = parent_pdf
         self._plumber_pdf = plumber_pdf
         self._font_attrs = font_attrs
-        # One slot per pdfplumber page – initially all None
-        self._cache: List[Optional["Page"]] = [None] * len(self._plumber_pdf.pages)
         self._load_text = load_text
+        
+        # If indices is provided, this is a sliced view
+        if indices is not None:
+            self._indices = indices
+            self._cache = [None] * len(indices)
+        else:
+            # Full PDF - one slot per pdfplumber page
+            self._indices = list(range(len(plumber_pdf.pages)))
+            self._cache = [None] * len(plumber_pdf.pages)
 
     # Internal helper -----------------------------------------------------
     def _create_page(self, index: int) -> "Page":
+        """Create and cache a page at the given index within this list."""
         cached = self._cache[index]
         if cached is None:
             # Import here to avoid circular import problems
             from natural_pdf.core.page import Page
 
-            plumber_page = self._plumber_pdf.pages[index]
+            # Get the actual page index in the full PDF
+            actual_page_index = self._indices[index]
+            plumber_page = self._plumber_pdf.pages[actual_page_index]
             cached = Page(
                 plumber_page,
                 parent=self._parent_pdf,
-                index=index,
+                index=actual_page_index,
                 font_attrs=self._font_attrs,
                 load_text=self._load_text,
             )
+            
+            # Apply any stored exclusions to the newly created page
+            if hasattr(self._parent_pdf, '_exclusions'):
+                for exclusion_data in self._parent_pdf._exclusions:
+                    exclusion_func, label = exclusion_data
+                    try:
+                        cached.add_exclusion(exclusion_func, label=label)
+                    except Exception as e:
+                        logger.warning(f"Failed to apply exclusion to page {cached.number}: {e}")
+            
+            # Apply any stored regions to the newly created page
+            if hasattr(self._parent_pdf, '_regions'):
+                for region_data in self._parent_pdf._regions:
+                    region_func, name = region_data
+                    try:
+                        region_instance = region_func(cached)
+                        if region_instance and hasattr(region_instance, '__class__'):
+                            # Check if it's a Region-like object (avoid importing Region here)
+                            cached.add_region(region_instance, name=name, source="named")
+                        elif region_instance is not None:
+                            logger.warning(
+                                f"Region function did not return a valid Region for page {cached.number}"
+                            )
+                    except Exception as e:
+                        logger.warning(f"Failed to apply region to page {cached.number}: {e}")
+            
             self._cache[index] = cached
         return cached
 
@@ -172,9 +215,18 @@ class _LazyPageList(Sequence):
 
     def __getitem__(self, key):
         if isinstance(key, slice):
-            # Materialise pages for slice lazily as well
-            indices = range(*key.indices(len(self)))
-            return [self._create_page(i) for i in indices]
+            # Get the slice of our current indices  
+            slice_indices = range(*key.indices(len(self)))
+            # Extract the actual page indices for this slice
+            actual_indices = [self._indices[i] for i in slice_indices]
+            # Return a new lazy list for the slice
+            return _LazyPageList(
+                self._parent_pdf,
+                self._plumber_pdf,
+                font_attrs=self._font_attrs,
+                load_text=self._load_text,
+                indices=actual_indices
+            )
         elif isinstance(key, int):
             if key < 0:
                 key += len(self)
@@ -556,8 +608,14 @@ class PDF(ExtractionMixin, ExportMixin, ClassificationMixin):
             raise AttributeError("PDF pages not yet initialized.")
 
         self._exclusions = []
-        for page in self._pages:
-            page.clear_exclusions()
+        
+        # Clear exclusions only from already-created (cached) pages to avoid forcing page creation
+        for i in range(len(self._pages)):
+            if self._pages._cache[i] is not None:  # Only clear from existing pages
+                try:
+                    self._pages._cache[i].clear_exclusions()
+                except Exception as e:
+                    logger.warning(f"Failed to clear exclusions from existing page {i}: {e}")
         return self
 
     def add_exclusion(
@@ -608,25 +666,35 @@ class PDF(ExtractionMixin, ExportMixin, ClassificationMixin):
             raise AttributeError("PDF pages not yet initialized.")
 
         # ------------------------------------------------------------------
-        # NEW: Support selector strings and ElementCollection objects directly.
-        # We simply forward the same object to each page's add_exclusion which
-        # now knows how to interpret these inputs.
+        # Support selector strings and ElementCollection objects directly.
+        # Store exclusion and apply only to already-created pages.
         # ------------------------------------------------------------------
         from natural_pdf.elements.collections import ElementCollection  # local import
 
         if isinstance(exclusion_func, str) or isinstance(exclusion_func, ElementCollection):
-            # Store for bookkeeping
+            # Store for bookkeeping and lazy application
             self._exclusions.append((exclusion_func, label))
-            for page in self._pages:
-                page.add_exclusion(exclusion_func, label=label)
+            
+            # Apply only to already-created (cached) pages to avoid forcing page creation
+            for i in range(len(self._pages)):
+                if self._pages._cache[i] is not None:  # Only apply to existing pages
+                    try:
+                        self._pages._cache[i].add_exclusion(exclusion_func, label=label)
+                    except Exception as e:
+                        logger.warning(f"Failed to apply exclusion to existing page {i}: {e}")
             return self
 
         # Fallback to original callable / Region behaviour ------------------
         exclusion_data = (exclusion_func, label)
         self._exclusions.append(exclusion_data)
 
-        for page in self._pages:
-            page.add_exclusion(exclusion_func, label=label)
+        # Apply only to already-created (cached) pages to avoid forcing page creation
+        for i in range(len(self._pages)):
+            if self._pages._cache[i] is not None:  # Only apply to existing pages
+                try:
+                    self._pages._cache[i].add_exclusion(exclusion_func, label=label)
+                except Exception as e:
+                    logger.warning(f"Failed to apply exclusion to existing page {i}: {e}")
 
         return self
 
@@ -868,7 +936,6 @@ class PDF(ExtractionMixin, ExportMixin, ClassificationMixin):
         Add a region function to the PDF.
 
         Args:
-            region_func: A function that takes a Page and returns a Region, or None
             region_func: A function that takes a Page and returns a Region, or None
             name: Optional name for the region
 
@@ -881,17 +948,20 @@ class PDF(ExtractionMixin, ExportMixin, ClassificationMixin):
         region_data = (region_func, name)
         self._regions.append(region_data)
 
-        for page in self._pages:
-            try:
-                region_instance = region_func(page)
-                if region_instance and isinstance(region_instance, Region):
-                    page.add_region(region_instance, name=name, source="named")
-                elif region_instance is not None:
-                    logger.warning(
-                        f"Region function did not return a valid Region for page {page.number}"
-                    )
-            except Exception as e:
-                logger.error(f"Error adding region for page {page.number}: {e}")
+        # Apply only to already-created (cached) pages to avoid forcing page creation
+        for i in range(len(self._pages)):
+            if self._pages._cache[i] is not None:  # Only apply to existing pages
+                page = self._pages._cache[i]
+                try:
+                    region_instance = region_func(page)
+                    if region_instance and isinstance(region_instance, Region):
+                        page.add_region(region_instance, name=name, source="named")
+                    elif region_instance is not None:
+                        logger.warning(
+                            f"Region function did not return a valid Region for page {page.number}"
+                        )
+                except Exception as e:
+                    logger.error(f"Error adding region for page {page.number}: {e}")
 
         return self
 
@@ -1712,10 +1782,11 @@ class PDF(ExtractionMixin, ExportMixin, ClassificationMixin):
 
         if isinstance(key, slice):
             from natural_pdf.elements.collections import PageCollection
-
-            return PageCollection(self._pages[key])
-
-        if isinstance(key, int):
+            # Use the lazy page list's slicing which returns another _LazyPageList
+            lazy_slice = self._pages[key]  
+            # Wrap in PageCollection for compatibility
+            return PageCollection(lazy_slice)
+        elif isinstance(key, int):
             if 0 <= key < len(self._pages):
                 return self._pages[key]
             else:

natural_pdf/elements/collections.py

@@ -1,6 +1,6 @@
 import hashlib
 import logging
-from collections.abc import MutableSequence
+from collections.abc import MutableSequence, Sequence
 from pathlib import Path
 from typing import (
     TYPE_CHECKING,
@@ -2051,14 +2051,20 @@ class PageCollection(Generic[P], ApplyMixin, ShapeDetectionMixin):
     Provides methods for batch operations on these pages.
     """
 
-    def __init__(self, pages: List[P]):
+    def __init__(self, pages: Union[List[P], Sequence[P]]):
         """
         Initialize a page collection.
 
         Args:
-            pages: List of Page objects
+            pages: List or sequence of Page objects (can be lazy)
         """
-        self.pages = pages
+        # Store the sequence as-is to preserve lazy behavior
+        # Only convert to list if we need list-specific operations
+        if hasattr(pages, '__iter__') and hasattr(pages, '__len__'):
+            self.pages = pages
+        else:
+            # Fallback for non-sequence types
+            self.pages = list(pages)
 
     def __len__(self) -> int:
         """Return the number of pages in the collection."""
@@ -2078,6 +2084,31 @@ class PageCollection(Generic[P], ApplyMixin, ShapeDetectionMixin):
         """Return a string representation showing the page count."""
         return f"<PageCollection(count={len(self)})>"
 
+    def _get_items_for_apply(self) -> Iterator[P]:
+        """
+        Override ApplyMixin's _get_items_for_apply to preserve lazy behavior.
+        
+        Returns an iterator that yields pages on-demand rather than materializing
+        all pages at once, maintaining the lazy loading behavior.
+        """
+        return iter(self.pages)
+
+    def _get_page_indices(self) -> List[int]:
+        """
+        Get page indices without forcing materialization of pages.
+        
+        Returns:
+            List of page indices for the pages in this collection.
+        """
+        # Handle different types of page sequences efficiently
+        if hasattr(self.pages, '_indices'):
+            # If it's a _LazyPageList (or slice), get indices directly
+            return list(self.pages._indices)
+        else:
+            # Fallback: if pages are already materialized, get indices normally
+            # This will force materialization but only if pages aren't lazy
+            return [p.index for p in self.pages]
+
     def extract_text(
         self,
         keep_blank_chars: bool = True,
@@ -2172,7 +2203,7 @@ class PageCollection(Generic[P], ApplyMixin, ShapeDetectionMixin):
             raise RuntimeError("Parent PDF object does not have the required 'apply_ocr' method.")
 
         # Get the 0-based indices of the pages in this collection
-        page_indices = [p.index for p in self.pages]
+        page_indices = self._get_page_indices()
 
         logger.info(f"Applying OCR via parent PDF to page indices: {page_indices} in collection.")
 
@@ -2374,7 +2405,7 @@ class PageCollection(Generic[P], ApplyMixin, ShapeDetectionMixin):
                 "Parent PDF reference not found or parent PDF lacks the required 'correct_ocr' method."
             )
 
-        page_indices = [p.index for p in self.pages]
+        page_indices = self._get_page_indices()
         logger.info(
             f"PageCollection: Delegating correct_ocr to parent PDF for page indices: {page_indices} with max_workers={max_workers}."
         )
@@ -2800,7 +2831,7 @@ class PageCollection(Generic[P], ApplyMixin, ShapeDetectionMixin):
             )
 
         # Get the 0-based indices of the pages in this collection
-        page_indices = [p.index for p in self.pages]
+        page_indices = self._get_page_indices()
         logger.info(
             f"PageCollection: Delegating deskew to parent PDF for page indices: {page_indices}"
         )

natural_pdf/elements/region.py

@@ -1616,8 +1616,26 @@ class Region(
         # Extract all tables from the cropped area
         tables = cropped.extract_tables(table_settings)
 
-        # Return the tables or an empty list if none found
-        return tables if tables else []
+        # Apply RTL text processing to all tables
+        if tables:
+            processed_tables = []
+            for table in tables:
+                processed_table = []
+                for row in table:
+                    processed_row = []
+                    for cell in row:
+                        if cell is not None:
+                            # Apply RTL text processing to each cell
+                            rtl_processed_cell = self._apply_rtl_processing_to_text(cell)
+                            processed_row.append(rtl_processed_cell)
+                        else:
+                            processed_row.append(cell)
+                    processed_table.append(processed_row)
+                processed_tables.append(processed_table)
+            return processed_tables
+
+        # Return empty list if no tables found
+        return []
 
     def _extract_table_plumber(self, table_settings: dict, content_filter=None) -> List[List[str]]:
         """
@@ -1662,21 +1680,25 @@ class Region(
 
         # Return the table or an empty list if none found
         if table:
-            # Apply content filtering if provided
-            if content_filter is not None:
-                filtered_table = []
-                for row in table:
-                    filtered_row = []
-                    for cell in row:
-                        if cell is not None:
-                            # Apply content filter to cell text
-                            filtered_cell = self._apply_content_filter_to_text(cell, content_filter)
-                            filtered_row.append(filtered_cell)
+            # Apply RTL text processing and content filtering if provided
+            processed_table = []
+            for row in table:
+                processed_row = []
+                for cell in row:
+                    if cell is not None:
+                        # Apply RTL text processing first
+                        rtl_processed_cell = self._apply_rtl_processing_to_text(cell)
+                        
+                        # Then apply content filter if provided
+                        if content_filter is not None:
+                            filtered_cell = self._apply_content_filter_to_text(rtl_processed_cell, content_filter)
+                            processed_row.append(filtered_cell)
                         else:
-                            filtered_row.append(cell)
-                    filtered_table.append(filtered_row)
-                return filtered_table
-            return table
+                            processed_row.append(rtl_processed_cell)
+                    else:
+                        processed_row.append(cell)
+                processed_table.append(processed_row)
+            return processed_table
         return []
 
     def _extract_table_tatr(self, use_ocr=False, ocr_config=None, content_filter=None) -> List[List[str]]:
@@ -3490,6 +3512,54 @@ class Region(
 
         return table_grid
 
+    def _apply_rtl_processing_to_text(self, text: str) -> str:
+        """
+        Apply RTL (Right-to-Left) text processing to a string.
+        
+        This converts visual order text (as stored in PDFs) to logical order
+        for proper display of Arabic, Hebrew, and other RTL scripts.
+        
+        Args:
+            text: Input text string in visual order
+            
+        Returns:
+            Text string in logical order
+        """
+        if not text or not text.strip():
+            return text
+            
+        # Quick check for RTL characters - if none found, return as-is
+        import unicodedata
+        
+        def _contains_rtl(s):
+            return any(unicodedata.bidirectional(ch) in ("R", "AL", "AN") for ch in s)
+        
+        if not _contains_rtl(text):
+            return text
+            
+        try:
+            from bidi.algorithm import get_display  # type: ignore
+            from natural_pdf.utils.bidi_mirror import mirror_brackets
+            
+            # Apply BiDi algorithm to convert from visual to logical order
+            # Process line by line to handle mixed content properly
+            processed_lines = []
+            for line in text.split("\n"):
+                if line.strip():
+                    # Determine base direction for this line
+                    base_dir = "R" if _contains_rtl(line) else "L"
+                    logical_line = get_display(line, base_dir=base_dir)
+                    # Apply bracket mirroring for correct logical order
+                    processed_lines.append(mirror_brackets(logical_line))
+                else:
+                    processed_lines.append(line)
+            
+            return "\n".join(processed_lines)
+            
+        except (ImportError, Exception):
+            # If bidi library is not available or fails, return original text
+            return text
+
     def _apply_content_filter_to_text(self, text: str, content_filter) -> str:
         """
         Apply content filter to a text string.

{natural_pdf-0.1.37.dist-info → natural_pdf-0.1.38.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: natural-pdf
-Version: 0.1.37
+Version: 0.1.38
 Summary: A more intuitive interface for working with PDFs
 Author-email: Jonathan Soma <jonathan.soma@gmail.com>
 License-Expression: MIT

{natural_pdf-0.1.37.dist-info → natural_pdf-0.1.38.dist-info}/RECORD

@@ -27,8 +27,8 @@ natural_pdf/collections/pdf_collection.py,sha256=sDVEbFMNME_2OaHIsCoR_W7V1cAATNw
 natural_pdf/core/__init__.py,sha256=QC8H4M3KbXwMFiQORZ0pdPlzx1Ix6oKKQSS7Ib2KEaA,38
 natural_pdf/core/element_manager.py,sha256=DRZvntd99wjXy6KeDjCq5uRhjMftZop9QklOZqlUH8M,55349
 natural_pdf/core/highlighting_service.py,sha256=2tBrrEq6d6hz5f6Yf7z5TysJdlTyuHTURBnQxokJnDM,40645
-natural_pdf/core/page.py,sha256=MwIENkMjEKStC6RlD3SBrqmyZt_MKzrIY7vLBFIvrwY,142529
-natural_pdf/core/pdf.py,sha256=2hK3yRVRxEQMVy1v4w6P26VGoDpCu_3FNkYgN-LO4hA,93221
+natural_pdf/core/page.py,sha256=iWokHLuSrQ71kxB_tTWkCp_O-i72urR4iGFUIzKoH8k,145351
+natural_pdf/core/pdf.py,sha256=5M1gB9psqwJCgE0w7PQ_G1XVa_XCmyNNmluZO7pIyZ4,97112
 natural_pdf/describe/__init__.py,sha256=kIV7ORmWWB1SAur7nK2aAwR-wHqSedhKfUsaUl4hG0A,586
 natural_pdf/describe/base.py,sha256=CLhZXYQO6SOPUVWLt6VwZ7MK48t_6wgPMyFMLtTCKRc,18166
 natural_pdf/describe/elements.py,sha256=JicXC9SJmmasqxalpCXA47-kVwv-6JnR3Xiu778aNHM,12634
@@ -36,11 +36,11 @@ natural_pdf/describe/mixin.py,sha256=rkX14aGrSz7Jvxx8Rbxv3eSfbO-_29DipwpstrV2pDQ
 natural_pdf/describe/summary.py,sha256=cfT4ZQkeatCDAOwWPwhtEVXisNgk6E57fAXAnoRysSU,7645
 natural_pdf/elements/__init__.py,sha256=S8XeiNWJ1WcgnyYKdYV1yxQlAxCCO3FfITT8MQwNbyk,41
 natural_pdf/elements/base.py,sha256=-ZAcc8lb2aSWTKcprwKTvnR6hsDGDm7T8a1Y9V38E_A,52042
-natural_pdf/elements/collections.py,sha256=_B03lJA1n147alE4xvn6qQ9uZWI8kb8VGxpchghqxqg,131834
+natural_pdf/elements/collections.py,sha256=qtHEaLPxZ6i3zPQsbSOw_KMAr9oDMWR1516ilSMSDeY,133189
 natural_pdf/elements/image.py,sha256=zu-P2Y8fRoEXf6IeZU0EYRWsgZ6I_a5vy1FA3VXTGkQ,1424
 natural_pdf/elements/line.py,sha256=mHSeV-ZABY-Cc_K_NpFL53OGtTWlexYDlMvZc8_Vrx8,3845
 natural_pdf/elements/rect.py,sha256=QuQg0Qo7XYQKBac-3Ss0n0ELV6icdPcrygWM2VWzeX8,3325
-natural_pdf/elements/region.py,sha256=ewY9HmV_VN6tN_VKtHj7dtk6nh7hrot-pW5Soz5iMg0,148150
+natural_pdf/elements/region.py,sha256=s3iFTq6QNiEgSAEV9ywt-3oQW5_swTvB6FNMgANpvmA,151055
 natural_pdf/elements/text.py,sha256=giPJQaXuOBCviQ7QKVx_ZMrKFVpgQAsaCS2-kn-8mp0,20530
 natural_pdf/export/mixin.py,sha256=L1q3MIEFWuvie4j4_EmW7GT3NerbZ1as0XMUoqTS7gM,5083
 natural_pdf/exporters/__init__.py,sha256=QffoARekR6WzXEd05oxOytly4qPdBizuIF-SUkeFpig,643
@@ -98,7 +98,7 @@ natural_pdf/utils/text_extraction.py,sha256=HYWlYGPfafwzsuMyfL5oQhvcD4NobbvC_aCp
 natural_pdf/utils/visualization.py,sha256=olDkWtuVzP0NxRg0CP0DL-eXNCY7Bs-SH-2Xn-cjbo0,9370
 natural_pdf/widgets/__init__.py,sha256=QTVaUmsw__FCweFYZebwPssQxxUFUMd0wpm_cUbGZJY,181
 natural_pdf/widgets/viewer.py,sha256=KW3JogdR2TMg2ECUMYp8hwd060hfg8EsYBWxb5IEzBY,24942
-natural_pdf-0.1.37.dist-info/licenses/LICENSE,sha256=9zfwINwJlarbDmdh6iJV4QUG54QSJlSAUcnC1YiC_Ns,1074
+natural_pdf-0.1.38.dist-info/licenses/LICENSE,sha256=9zfwINwJlarbDmdh6iJV4QUG54QSJlSAUcnC1YiC_Ns,1074
 optimization/memory_comparison.py,sha256=F90D_5WhliSGAct_lyx93xd4q4F-jeo8QpGyDr8tmNw,6543
 optimization/pdf_analyzer.py,sha256=xf6h-FNlqCpsm8NriXcs_bQZOB8eQkxgGGKVRL_jgCM,19347
 optimization/performance_analysis.py,sha256=RjAqeE3YS1r_7qTWkY6Ng5YMbb6MXJXfXX6LoVjg_xQ,13035
@@ -115,8 +115,8 @@ tools/bad_pdf_eval/llm_enrich.py,sha256=mCh4KGi1HmIkzGjj5rrHz1Osd7sEX1IZ_FW08H1t
 tools/bad_pdf_eval/llm_enrich_with_retry.py,sha256=XUtPF1hUvqd3frDXT0wDTXoonuAivhjM5vgFdZ-tm0A,9373
 tools/bad_pdf_eval/reporter.py,sha256=e1g__mkSB4q02p3mGWOwMhvFs7F2HJosNBxup0-LkyU,400
 tools/bad_pdf_eval/utils.py,sha256=hR95XQ7qf7Cu6BdyX0L7ggGVx-ah5sK0jHWblTJUUic,4896
-natural_pdf-0.1.37.dist-info/METADATA,sha256=1POawL7Edgjod2Qt1TO-2DhUkVesip-OnB0KkQCgGQ0,6739
-natural_pdf-0.1.37.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-natural_pdf-0.1.37.dist-info/entry_points.txt,sha256=1R_KMv7g60UBBpRqGfw7bppsMNGdayR-iJlb9ohEk_8,81
-natural_pdf-0.1.37.dist-info/top_level.txt,sha256=oZlRzSc3nZ9sV3L6kD_Di734Pp62ANrm46imFVa51qQ,58
-natural_pdf-0.1.37.dist-info/RECORD,,
+natural_pdf-0.1.38.dist-info/METADATA,sha256=7a2BfP1oBRbUDUm_9t-3jCsw9BGjIiGyoFwGQyDvcVo,6739
+natural_pdf-0.1.38.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+natural_pdf-0.1.38.dist-info/entry_points.txt,sha256=1R_KMv7g60UBBpRqGfw7bppsMNGdayR-iJlb9ohEk_8,81
+natural_pdf-0.1.38.dist-info/top_level.txt,sha256=oZlRzSc3nZ9sV3L6kD_Di734Pp62ANrm46imFVa51qQ,58
+natural_pdf-0.1.38.dist-info/RECORD,,