natural-pdf 0.1.24__py3-none-any.whl → 0.1.26.dev0__py3-none-any.whl

natural_pdf/core/page.py

@@ -1576,8 +1576,12 @@ class Page(ClassificationMixin, ExtractionMixin, ShapeDetectionMixin, DescribeMi
             render_ocr: Whether to render OCR text on highlights.
             resolution: Resolution in DPI for base page image (default: scale * 72).
             include_highlights: Whether to render highlights.
-            exclusions: If 'mask', excluded regions will be whited out on the image.
-                        (default: None).
+            exclusions: Accepts one of the following:
+                        • None  – no masking (default)
+                        • "mask" – mask using solid white (back-compat)
+                        • CSS/HTML colour string (e.g. "red", "#ff0000", "#ff000080")
+                        • Tuple of RGB or RGBA values (ints 0-255 or floats 0-1)
+                        All excluded regions are filled with this colour.
             **kwargs: Additional parameters for pdfplumber.to_image.
 
         Returns:
@@ -1690,7 +1694,52 @@ class Page(ClassificationMixin, ExtractionMixin, ShapeDetectionMixin, DescribeMi
             # --- Apply exclusion masking if requested ---
             # This modifies 'rendered_image_component'
             image_after_masking = rendered_image_component  # Start with the rendered image
-            if exclusions == "mask" and self._exclusions:
+
+            # Determine if masking is requested and establish the fill colour
+            mask_requested = exclusions is not None and self._exclusions
+            mask_color: Union[str, Tuple[int, int, int, int]] = "white"  # default
+
+            if mask_requested:
+                if exclusions != "mask":
+                    # Attempt to parse custom colour input
+                    try:
+                        if isinstance(exclusions, tuple):
+                            # Handle RGB/RGBA tuples with ints 0-255 or floats 0-1
+                            processed = []
+                            all_float = all(isinstance(c, float) for c in exclusions)
+                            for i, c in enumerate(exclusions):
+                                if isinstance(c, float):
+                                    val = int(c * 255) if all_float or i == 3 else int(c)
+                                else:
+                                    val = int(c)
+                                processed.append(max(0, min(255, val)))
+                            if len(processed) == 3:
+                                processed.append(255)  # add full alpha
+                            mask_color = tuple(processed)  # type: ignore[assignment]
+                        elif isinstance(exclusions, str):
+                            # Try using the optional 'colour' library for rich parsing
+                            try:
+                                from colour import Color  # type: ignore
+
+                                color_obj = Color(exclusions)
+                                mask_color = (
+                                    int(color_obj.red * 255),
+                                    int(color_obj.green * 255),
+                                    int(color_obj.blue * 255),
+                                    255,
+                                )
+                            except Exception:
+                                # Fallback: if parsing fails, treat as plain string accepted by PIL
+                                mask_color = exclusions  # e.g. "red"
+                        else:
+                            logger.warning(
+                                f"Unsupported exclusions colour spec: {exclusions!r}. Using white."
+                            )
+                    except Exception as colour_parse_err:  # pragma: no cover
+                        logger.warning(
+                            f"Failed to parse exclusions colour {exclusions!r}: {colour_parse_err}. Using white."
+                        )
+
                 try:
                     # Ensure image is mutable (RGB or RGBA)
                     if image_after_masking.mode not in ("RGB", "RGBA"):
@@ -1701,17 +1750,23 @@ class Page(ClassificationMixin, ExtractionMixin, ShapeDetectionMixin, DescribeMi
                     )
                     if exclusion_regions:
                         draw = ImageDraw.Draw(image_after_masking)
-                        # Calculate the scaling factor used for the image
+                        # Scaling factor for converting PDF pts → image px
                         img_scale = render_resolution / 72.0
 
+                        # Determine fill colour compatible with current mode
+                        def _mode_compatible(colour):
+                            if isinstance(colour, tuple) and image_after_masking.mode != "RGBA":
+                                return colour[:3]  # drop alpha for RGB images
+                            return colour
+
+                        fill_colour = _mode_compatible(mask_color)
+
                         for region in exclusion_regions:
-                            # Convert PDF points (x0, top, x1, bottom) to image pixels
                             img_x0 = region.x0 * img_scale
                             img_top = region.top * img_scale
                             img_x1 = region.x1 * img_scale
                             img_bottom = region.bottom * img_scale
 
-                            # Draw a white rectangle over the excluded area
                             img_coords = (
                                 max(0, img_x0),
                                 max(0, img_top),
@@ -1719,7 +1774,7 @@ class Page(ClassificationMixin, ExtractionMixin, ShapeDetectionMixin, DescribeMi
                                 min(image_after_masking.height, img_bottom),
                             )
                             if img_coords[0] < img_coords[2] and img_coords[1] < img_coords[3]:
-                                draw.rectangle(img_coords, fill="white")
+                                draw.rectangle(img_coords, fill=fill_colour)
                             else:  # pragma: no cover
                                 logger.warning(
                                     f"Skipping invalid exclusion rect for masking: {img_coords}"
@@ -1994,6 +2049,10 @@ class Page(ClassificationMixin, ExtractionMixin, ShapeDetectionMixin, DescribeMi
             )
             return ElementCollection([])  # Return empty collection
 
+        # Clear existing detected regions if 'replace' is specified
+        if existing == "replace":
+            self.clear_detected_layout_regions()
+
         # The analyzer's analyze_layout method already adds regions to the page
         # and its element manager. We just need to retrieve them.
         analyzer.analyze_layout(

natural_pdf/describe/summary.py

@@ -56,8 +56,8 @@ class ElementSummary:
         section_title = name.replace('_', ' ').title()
         
         if isinstance(data, dict):
-            lines = [f"**{section_title}**:"]
-            lines.extend(self._format_dict(data, indent="  "))
+            lines = [f"**{section_title}**:", ""]
+            lines.extend(self._format_dict(data, indent=""))
         elif isinstance(data, list):
             lines = [f"**{section_title}**: {', '.join(str(item) for item in data)}"]
         else:

natural_pdf/elements/line.py

@@ -94,6 +94,14 @@ class LineElement(Element):
         # Vertical if x-change is within tolerance and y-change is significant
         return dx <= tolerance and dy > tolerance
 
+    @property
+    def orientation(self) -> str:
+        """Get the orientation of the line ('horizontal', 'vertical', or 'diagonal')."""
+        if self.is_horizontal:
+            return "horizontal"
+        elif self.is_vertical:
+            return "vertical"
+
     def text_above(self, distance: float = 5, **kwargs) -> Any:
         """
         Get text elements above this line.
@@ -142,7 +150,4 @@ class LineElement(Element):
 
     def __repr__(self) -> str:
         """String representation of the line element."""
-        line_type = (
-            "horizontal" if self.is_horizontal else "vertical" if self.is_vertical else "diagonal"
-        )
-        return f"<LineElement type={line_type} width={self.width:.1f} bbox={self.bbox}>"
+        return f"<LineElement type={self.orientation} width={self.width:.1f} bbox={self.bbox}>"

natural_pdf/elements/region.py

@@ -1924,18 +1924,54 @@ class Region(DirectionalMixin, ClassificationMixin, ExtractionMixin, ShapeDetect
                 f"Region {self.bbox}: Removing existing OCR elements before applying new OCR."
             )
 
-            # Remove existing OCR word elements strictly inside this region
-            ocr_selector = "text[source=ocr]"
-            ocr_elements = self.find_all(ocr_selector, apply_exclusions=False)
-            if ocr_elements:
-                removed_count = ocr_elements.remove()
-                logger.info(
-                    f"Region {self.bbox}: Removed {removed_count} existing OCR word elements in region before re-applying OCR."
-                )
-            else:
-                logger.info(
-                    f"Region {self.bbox}: No existing OCR word elements found within region to remove."
-                )
+            # --- Robust removal: iterate through all OCR elements on the page and
+            #     remove those that overlap this region. This avoids reliance on
+            #     identity‐based look-ups that can break if the ElementManager
+            #     rebuilt its internal lists.
+
+            removed_count = 0
+
+            # Helper to remove a single element safely
+            def _safe_remove(elem):
+                nonlocal removed_count
+                success = False
+                if hasattr(elem, "page") and hasattr(elem.page, "_element_mgr"):
+                    etype = getattr(elem, "object_type", "word")
+                    if etype == "word":
+                        etype_key = "words"
+                    elif etype == "char":
+                        etype_key = "chars"
+                    else:
+                        etype_key = etype + "s" if not etype.endswith("s") else etype
+                    try:
+                        success = elem.page._element_mgr.remove_element(elem, etype_key)
+                    except Exception:
+                        success = False
+                if success:
+                    removed_count += 1
+
+            # Remove OCR WORD elements overlapping region
+            for word in list(self.page._element_mgr.words):
+                if getattr(word, "source", None) == "ocr" and self.intersects(word):
+                    _safe_remove(word)
+
+            # Remove OCR CHAR dicts overlapping region
+            for char in list(self.page._element_mgr.chars):
+                # char can be dict or TextElement; normalise
+                char_src = char.get("source") if isinstance(char, dict) else getattr(char, "source", None)
+                if char_src == "ocr":
+                    # Rough bbox for dicts
+                    if isinstance(char, dict):
+                        cx0, ctop, cx1, cbottom = char.get("x0", 0), char.get("top", 0), char.get("x1", 0), char.get("bottom", 0)
+                    else:
+                        cx0, ctop, cx1, cbottom = char.x0, char.top, char.x1, char.bottom
+                    # Quick overlap check
+                    if not (cx1 < self.x0 or cx0 > self.x1 or cbottom < self.top or ctop > self.bottom):
+                        _safe_remove(char)
+
+            logger.info(
+                f"Region {self.bbox}: Removed {removed_count} existing OCR elements (words & chars) before re-applying OCR."
+            )
 
         ocr_mgr = self.page._parent._ocr_manager
 

natural_pdf/elements/text.py

@@ -43,9 +43,58 @@ class TextElement(Element):
 
     @text.setter
     def text(self, value: str):
-        """Set the text content."""
+        """Set the text content and synchronise underlying char dictionaries (if any)."""
+        # Update the primary text value stored on the object itself
         self._obj["text"] = value
 
+        # --- Keep _char_dicts in sync so downstream utilities (e.g. extract_text)
+        #     that rely on the raw character dictionaries see the corrected text.
+        #     For OCR-generated words we usually have a single representative char
+        #     dict; for native words there may be one per character.
+        # ---------------------------------------------------------------------
+        try:
+            if hasattr(self, "_char_dicts") and isinstance(self._char_dicts, list):
+                if not self._char_dicts:
+                    return  # Nothing to update
+
+                if len(self._char_dicts) == 1:
+                    # Simple case – a single char dict represents the whole text
+                    self._char_dicts[0]["text"] = value
+                else:
+                    # Update character-by-character. If new value is shorter than
+                    # existing char dicts, truncate remaining dicts by setting
+                    # their text to empty string; if longer, extend by repeating
+                    # the last char dict geometry (best-effort fallback).
+                    for idx, char_dict in enumerate(self._char_dicts):
+                        if idx < len(value):
+                            char_dict["text"] = value[idx]
+                        else:
+                            # Clear extra characters from old text
+                            char_dict["text"] = ""
+
+                    # If new text is longer, append additional char dicts based
+                    # on the last available geometry. This is an approximation
+                    # but ensures text length consistency for downstream joins.
+                    if len(value) > len(self._char_dicts):
+                        last_dict = self._char_dicts[-1]
+                        for extra_idx in range(len(self._char_dicts), len(value)):
+                            new_dict = last_dict.copy()
+                            new_dict["text"] = value[extra_idx]
+                            # Advance x0/x1 roughly by average char width if available
+                            char_width = last_dict.get("adv") or (
+                                last_dict.get("width", 0) / max(len(self.text), 1)
+                            )
+                            if isinstance(char_width, (int, float)) and char_width > 0:
+                                shift = char_width * (extra_idx - len(self._char_dicts) + 1)
+                                new_dict["x0"] = last_dict.get("x0", 0) + shift
+                                new_dict["x1"] = last_dict.get("x1", 0) + shift
+                            self._char_dicts.append(new_dict)
+        except Exception as sync_err:  # pragma: no cover
+            # Keep failures silent but logged; better to have outdated chars than crash.
+            import logging
+            logger = logging.getLogger(__name__)
+            logger.debug(f"TextElement: Failed to sync _char_dicts after text update: {sync_err}")
+
     @property
     def source(self) -> str:
         """Get the source of this text element (pdf or ocr)."""

natural_pdf/qa/document_qa.py

@@ -2,6 +2,7 @@ import json
 import logging
 import os
 import tempfile
+import warnings
 from typing import Any, Dict, List, Optional, Tuple, Union
 
 import numpy as np
@@ -310,13 +311,39 @@ class DocumentQA:
             QAResult instance with answer details
         """
         # Ensure we have text elements on the page
-        if not page.find_all("text"):
-            # Apply OCR if no text is available
-            logger.info(f"No text elements found on page {page.index}, applying OCR")
-            page.apply_ocr()
+        elements = page.find_all("text")
+        if not elements:
+            # Warn that no text was found and recommend OCR
+            warnings.warn(
+                f"No text elements found on page {page.index}. "
+                "Consider applying OCR first using page.apply_ocr() to extract text from images.",
+                UserWarning
+            )
+            
+            # Return appropriate "not found" result(s)
+            if isinstance(question, (list, tuple)):
+                return [
+                    QAResult(
+                        question=q,
+                        answer="",
+                        confidence=0.0,
+                        start=-1,
+                        end=-1,
+                        found=False,
+                    )
+                    for q in question
+                ]
+            else:
+                return QAResult(
+                    question=question,
+                    answer="",
+                    confidence=0.0,
+                    start=-1,
+                    end=-1,
+                    found=False,
+                )
 
         # Extract word boxes
-        elements = page.find_all("text")
         word_boxes = self._get_word_boxes_from_elements(elements, offset_x=0, offset_y=0)
 
         # Generate a high-resolution image of the page
@@ -393,10 +420,37 @@ class DocumentQA:
         # Get all text elements within the region
         elements = region.find_all("text")
 
-        # Apply OCR if needed
+        # Check if we have text elements
         if not elements:
-            logger.info(f"No text elements found in region, applying OCR")
-            elements = region.apply_ocr()
+            # Warn that no text was found and recommend OCR
+            warnings.warn(
+                f"No text elements found in region on page {region.page.index}. "
+                "Consider applying OCR first using region.apply_ocr() to extract text from images.",
+                UserWarning
+            )
+            
+            # Return appropriate "not found" result(s)
+            if isinstance(question, (list, tuple)):
+                return [
+                    QAResult(
+                        question=q,
+                        answer="",
+                        confidence=0.0,
+                        start=-1,
+                        end=-1,
+                        found=False,
+                    )
+                    for q in question
+                ]
+            else:
+                return QAResult(
+                    question=question,
+                    answer="",
+                    confidence=0.0,
+                    start=-1,
+                    end=-1,
+                    found=False,
+                )
 
         # Extract word boxes adjusted for the cropped region
         x0, top = int(region.x0), int(region.top)

natural_pdf/utils/packaging.py

@@ -36,7 +36,7 @@ def create_correction_task_package(
     output_zip_path: str,
     overwrite: bool = False,
     suggest=None,
-    resolution: int = 150,
+    resolution: int = 300,
 ) -> None:
     """
     Creates a zip package containing data for an OCR correction task.
@@ -160,8 +160,22 @@ def create_correction_task_package(
 
                 # 3. Prepare region data for manifest
                 page_regions_data = []
-                # Calculate scaling factor from PDF coordinates (72 DPI) to image pixels
-                coord_scale_factor = resolution / 72.0
+                # Calculate scaling factor *from PDF points* to *actual image pixels*.
+                # We prefer using the rendered image dimensions rather than the nominal
+                # resolution value, because the image might have been resized (e.g. via
+                # global `natural_pdf.options.image.width`). This guarantees that the
+                # bounding boxes we write to the manifest always align with the exact
+                # pixel grid of the exported image.
+
+                try:
+                    scale_x = img.width / float(page.width) if page.width else 1.0
+                    scale_y = img.height / float(page.height) if page.height else 1.0
+                except Exception as e:
+                    logger.warning(
+                        f"Could not compute per-axis scale factors for page {page.number}: {e}. "
+                        "Falling back to resolution-based scaling."
+                    )
+                    scale_x = scale_y = resolution / 72.0
 
                 i = -1
                 for elem in tqdm(ocr_elements):
@@ -176,12 +190,12 @@ def create_correction_task_package(
                         continue
                     region_id = f"r_{page.index}_{i}"  # ID unique within page
 
-                    # Scale coordinates to match the 300 DPI image
+                    # Scale coordinates to match the **actual** image dimensions.
                     scaled_bbox = [
-                        elem.x0 * coord_scale_factor,
-                        elem.top * coord_scale_factor,
-                        elem.x1 * coord_scale_factor,
-                        elem.bottom * coord_scale_factor,
+                        elem.x0 * scale_x,
+                        elem.top * scale_y,
+                        elem.x1 * scale_x,
+                        elem.bottom * scale_y,
                     ]
 
                     corrected = elem.text
@@ -191,7 +205,7 @@ def create_correction_task_package(
 
                     page_regions_data.append(
                         {
-                            "resolution": resolution,
+                            "resolution": scale_x * 72.0,
                             "id": region_id,
                             "bbox": scaled_bbox,
                             "ocr_text": elem.text,

{natural_pdf-0.1.24.dist-info → natural_pdf-0.1.26.dev0.dist-info}/METADATA

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

{natural_pdf-0.1.24.dist-info → natural_pdf-0.1.26.dev0.dist-info}/RECORD

@@ -26,20 +26,20 @@ natural_pdf/collections/pdf_collection.py,sha256=HLlyakM--23ZOeHDPucoM6Tw3yUyMXm
 natural_pdf/core/__init__.py,sha256=QC8H4M3KbXwMFiQORZ0pdPlzx1Ix6oKKQSS7Ib2KEaA,38
 natural_pdf/core/element_manager.py,sha256=_UdXu51sLi6STzc8Pj4k8R721G3yJixXDLuRHn3hmr8,25731
 natural_pdf/core/highlighting_service.py,sha256=DKoaxiiuQsWgtf6wSroMAIcFiqJOOF7dXhciYdQKdCw,38223
-natural_pdf/core/page.py,sha256=TOtpUp5lRhDj32wv3yvRaS8kxPX6R9904OCC6uHFi84,119512
+natural_pdf/core/page.py,sha256=GqYfYiVkuL1M_GoPTcLL0yWFXISN38BUCdQIKyF6vJ0,122721
 natural_pdf/core/pdf.py,sha256=qsSW4RxOJRmCnweLPMs0NhzkRfiAVdghTgnh4D_wuO4,74295
 natural_pdf/describe/__init__.py,sha256=B3zjuHjFI_dFuBLgXR1Q4v7c72fVDyk84d2hs0H4KV8,561
 natural_pdf/describe/base.py,sha256=mUvEydumXXPJ2FkWAYm1BbWrRWY81I0dMyQrEU32rmc,17256
 natural_pdf/describe/elements.py,sha256=xD8wwR1z5IKat7RIwoAwQRUEL6zJTEwcOKorF4F-xPg,12717
 natural_pdf/describe/mixin.py,sha256=U0x6v8r57KQb8qC3VVo64hvhfXQWsti8vdKBM7AXnMo,3116
-natural_pdf/describe/summary.py,sha256=h5zy9zG7t27wFnJ2hEguGSoURtN2IR4x6WBO3aXB4eo,7980
+natural_pdf/describe/summary.py,sha256=7FIF3zF6bzNx-gx4pCJr2XQFKiVzOEDnWsAYQ_mr9L0,7982
 natural_pdf/elements/__init__.py,sha256=S8XeiNWJ1WcgnyYKdYV1yxQlAxCCO3FfITT8MQwNbyk,41
 natural_pdf/elements/base.py,sha256=iw-Ab0o7eI69npt0gAxQvA14GPWHAAhkLrJ_JeKvIos,43309
 natural_pdf/elements/collections.py,sha256=JrM42VPRtDOJ9Q9KIR3SrcbamiiCHXI4nzTq2BBkeEk,124223
-natural_pdf/elements/line.py,sha256=300kSFBDUBIudfeQtH_tzW9gTYRgRKUDPiTABw6J-BE,4782
+natural_pdf/elements/line.py,sha256=aQm4pDdlQSDAAXqrdg4AU-oTl9JCXgYuaJN0EYls6E0,4920
 natural_pdf/elements/rect.py,sha256=kiVa3e377ZnqIOXc89d9ZSY4EcmDxtccdtUw-HOQzpw,3796
-natural_pdf/elements/region.py,sha256=CVncbiCk8ivn04CI7Ob93O7UY0ANVpCJwikBt-jVWgg,123698
-natural_pdf/elements/text.py,sha256=yshGrvdiBZSkYhQfdi6Yz6NN0kWvmqKHSSC82D829os,11470
+natural_pdf/elements/region.py,sha256=63rdyjOnbmsgTN1WMSOyQWQnvJRUYco9qTWLqBi3TBk,125498
+natural_pdf/elements/text.py,sha256=x163dnr2ZDEIE_WZXWH5hXJtoO-6cvTdA2BABcZd69U,14575
 natural_pdf/export/mixin.py,sha256=L1q3MIEFWuvie4j4_EmW7GT3NerbZ1as0XMUoqTS7gM,5083
 natural_pdf/exporters/__init__.py,sha256=g1WRPCDVzceaUUsm8dchPhzdHFSjYM0NfRyc8iN0mtE,644
 natural_pdf/exporters/base.py,sha256=XhR1xlkHOh7suOuX7mWbsj1h2o1pZNet-OAS5YCJyeI,2115
@@ -70,7 +70,7 @@ natural_pdf/ocr/ocr_manager.py,sha256=K2gpFo3e6RB1ouXOstlEAAYd14DbjBNt5RH6J7ZdDQ
 natural_pdf/ocr/ocr_options.py,sha256=l33QKu_93r-uwi3t_v8UH8pEgHo6HTVzP4tfmQFRF1w,5488
 natural_pdf/ocr/utils.py,sha256=OxuHwDbHWj6setvnC0QYwMHrAjxGkhmLzWHpMqqGupA,4397
 natural_pdf/qa/__init__.py,sha256=2u2KJcA71g1I0HnLD-j6yvDw1moAjo9kkLhhfoYRURM,166
-natural_pdf/qa/document_qa.py,sha256=6-XuIEFf5BcVA_e85FBmAeXpNZgzZhTBDkNUMPAl-tc,17803
+natural_pdf/qa/document_qa.py,sha256=cli1E9NBSVtT5Qo6n7ZRd7BpstnbpZfkljX69LGTYU8,19608
 natural_pdf/qa/qa_result.py,sha256=_q4dlSqsjtgomcI8-pqbOT69lqQKnEMkhZNydoxEkkE,2227
 natural_pdf/search/__init__.py,sha256=0Xa7tT_2q57wHObFMQLQLd4gd9AV0oyS-svV6BmmdMI,4276
 natural_pdf/search/lancedb_search_service.py,sha256=6dz2IEZUWk3hFW28C-LF_85pWohd7Sr5k44bM0pBdm4,14472
@@ -86,15 +86,15 @@ natural_pdf/utils/debug.py,sha256=RN7H3E6ph-GtxubCW6psW7TO8o2BxcNLiEzByTVR9fk,99
 natural_pdf/utils/highlighting.py,sha256=EIY6ihVGtUTS_DjWyxpnr_UXpcR4btC1KhSGQ9VUfKg,698
 natural_pdf/utils/identifiers.py,sha256=P7n6owcubnF8oAMa_UfYtENmIaJQdH_AMC9Jbs2bWXo,1117
 natural_pdf/utils/locks.py,sha256=7HJqV0VsNcOfISnbw8goCKWP5ck11uSJo6T_x9XIPKI,215
-natural_pdf/utils/packaging.py,sha256=Jshxp6S1zfcqoZmFhdd7WOpL--b6rBSz-Y9mYqELXIY,21581
+natural_pdf/utils/packaging.py,sha256=e7U2wWvpunlAWpPFexNkD_c4dYbPp5LcKo7og4bNGvk,22411
 natural_pdf/utils/reading_order.py,sha256=s3DsYq_3g_1YA07qhd4BGEjeIRTeyGtnwc_hNtSzwBY,7290
 natural_pdf/utils/text_extraction.py,sha256=mDeN1_VevNi3RwvFe48PM5vBh-A5WeBlYgP6lSjBaOk,10854
 natural_pdf/utils/visualization.py,sha256=30pRWQdsRJh2pSObh-brKVsFgC1n8tHmSrta_UDnVPw,8989
 natural_pdf/widgets/__init__.py,sha256=QTVaUmsw__FCweFYZebwPssQxxUFUMd0wpm_cUbGZJY,181
 natural_pdf/widgets/viewer.py,sha256=2VUY1TzWMDe9I-IVNOosKZ2LaqpjLB62ftMAdk-s6_8,24952
-natural_pdf-0.1.24.dist-info/licenses/LICENSE,sha256=9zfwINwJlarbDmdh6iJV4QUG54QSJlSAUcnC1YiC_Ns,1074
-natural_pdf-0.1.24.dist-info/METADATA,sha256=qcyQUXKXciLsomzdsdkQ4inSw_MJbczyj8oPq4KVGZQ,6684
-natural_pdf-0.1.24.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-natural_pdf-0.1.24.dist-info/entry_points.txt,sha256=1R_KMv7g60UBBpRqGfw7bppsMNGdayR-iJlb9ohEk_8,81
-natural_pdf-0.1.24.dist-info/top_level.txt,sha256=Cyw1zmNDlUZfb5moU-WUWGprrwH7ln_8LDGdmMHF1xI,17
-natural_pdf-0.1.24.dist-info/RECORD,,
+natural_pdf-0.1.26.dev0.dist-info/licenses/LICENSE,sha256=9zfwINwJlarbDmdh6iJV4QUG54QSJlSAUcnC1YiC_Ns,1074
+natural_pdf-0.1.26.dev0.dist-info/METADATA,sha256=Y0nVAEzmtTldA3i9iY2Gtn-WO4FzjhmC1Le6M-WJ_Ko,6689
+natural_pdf-0.1.26.dev0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+natural_pdf-0.1.26.dev0.dist-info/entry_points.txt,sha256=1R_KMv7g60UBBpRqGfw7bppsMNGdayR-iJlb9ohEk_8,81
+natural_pdf-0.1.26.dev0.dist-info/top_level.txt,sha256=Cyw1zmNDlUZfb5moU-WUWGprrwH7ln_8LDGdmMHF1xI,17
+natural_pdf-0.1.26.dev0.dist-info/RECORD,,