natural-pdf 0.2.5__py3-none-any.whl → 0.2.6__py3-none-any.whl

natural_pdf/elements/region.py

@@ -222,7 +222,9 @@ class Region(
         mode: Literal["show", "render"] = "show",
         color: Optional[Union[str, Tuple[int, int, int]]] = None,
         highlights: Optional[Union[List[Dict[str, Any]], bool]] = None,
-        crop: Union[bool, Literal["content"]] = True,  # Default to True for regions
+        crop: Union[
+            bool, int, str, "Region", Literal["wide"]
+        ] = True,  # Default to True for regions
         crop_bbox: Optional[Tuple[float, float, float, float]] = None,
         **kwargs,
     ) -> List[RenderSpec]:
@@ -232,7 +234,12 @@ class Region(
             mode: Rendering mode - 'show' includes highlights, 'render' is clean
             color: Color for highlighting this region in show mode
             highlights: Additional highlight groups to show, or False to disable all highlights
-            crop: Whether to crop to this region
+            crop: Cropping mode:
+                - False: No cropping
+                - True: Crop to region bounds (default for regions)
+                - int: Padding in pixels around region
+                - 'wide': Full page width, cropped vertically to region
+                - Region: Crop to the bounds of another region
             crop_bbox: Explicit crop bounds (overrides region bounds)
             **kwargs: Additional parameters
 
@@ -247,15 +254,34 @@ class Region(
         if crop_bbox:
             spec.crop_bbox = crop_bbox
         elif crop:
-            # Crop to this region's bounds
-            spec.crop_bbox = self.bbox
+            x0, y0, x1, y1 = self.bbox
+
+            if crop is True:
+                # Crop to region bounds
+                spec.crop_bbox = self.bbox
+            elif isinstance(crop, (int, float)):
+                # Add padding around region
+                padding = float(crop)
+                spec.crop_bbox = (
+                    max(0, x0 - padding),
+                    max(0, y0 - padding),
+                    min(self.page.width, x1 + padding),
+                    min(self.page.height, y1 + padding),
+                )
+            elif crop == "wide":
+                # Full page width, cropped vertically to region
+                spec.crop_bbox = (0, y0, self.page.width, y1)
+            elif hasattr(crop, "bbox"):
+                # Crop to another region's bounds
+                spec.crop_bbox = crop.bbox
 
         # Add highlights in show mode (unless explicitly disabled with highlights=False)
         if mode == "show" and highlights is not False:
             # Only highlight this region if:
             # 1. We're not cropping, OR
-            # 2. We're cropping but color was explicitly specified
-            if not crop or color is not None:
+            # 2. We're cropping but color was explicitly specified, OR
+            # 3. We're cropping to another region (not tight crop)
+            if not crop or color is not None or (crop and not isinstance(crop, bool)):
                 spec.add_highlight(
                     bbox=self.bbox,
                     polygon=self.polygon if self.has_polygon else None,
@@ -1237,6 +1263,8 @@ class Region(
             Union[str, Callable[[str], bool], List[str]]
         ] = None,  # NEW: Content filtering
         apply_exclusions: bool = True,  # Whether to apply exclusion regions during extraction
+        verticals: Optional[List] = None,  # Explicit vertical lines
+        horizontals: Optional[List] = None,  # Explicit horizontal lines
     ) -> TableResult:  # Return type allows Optional[str] for cells
         """
         Extract a table from this region.
@@ -1263,6 +1291,10 @@ class Region(
                 Works with all extraction methods by filtering cell content.
             apply_exclusions: Whether to apply exclusion regions during text extraction (default: True).
                 When True, text within excluded regions (e.g., headers/footers) will not be extracted.
+            verticals: Optional list of explicit vertical lines for table extraction. When provided,
+                       automatically sets vertical_strategy='explicit' and explicit_vertical_lines.
+            horizontals: Optional list of explicit horizontal lines for table extraction. When provided,
+                         automatically sets horizontal_strategy='explicit' and explicit_horizontal_lines.
 
         Returns:
             Table data as a list of rows, where each row is a list of cell values (str or None).
@@ -1273,6 +1305,14 @@ class Region(
         if text_options is None:
             text_options = {}  # Initialize empty dict
 
+        # Handle explicit vertical and horizontal lines
+        if verticals is not None:
+            table_settings["vertical_strategy"] = "explicit"
+            table_settings["explicit_vertical_lines"] = verticals
+        if horizontals is not None:
+            table_settings["horizontal_strategy"] = "explicit"
+            table_settings["explicit_horizontal_lines"] = horizontals
+
         # Auto-detect method if not specified
         if method is None:
             # If this is a TATR-detected region, use TATR method
@@ -2547,7 +2587,13 @@ class Region(
 
         return self
 
-    def get_section_between(self, start_element=None, end_element=None, include_boundaries="both"):
+    def get_section_between(
+        self,
+        start_element=None,
+        end_element=None,
+        include_boundaries="both",
+        orientation="vertical",
+    ):
         """
         Get a section between two elements within this region.
 
@@ -2555,6 +2601,7 @@ class Region(
             start_element: Element marking the start of the section
             end_element: Element marking the end of the section
             include_boundaries: How to include boundary elements: 'start', 'end', 'both', or 'none'
+            orientation: 'vertical' (default) or 'horizontal' - determines section direction
 
         Returns:
             Region representing the section
@@ -2599,41 +2646,67 @@ class Region(
         else:
             end_element = elements[-1]  # Default end is last element
 
-        # Adjust indexes based on boundary inclusion
-        start_element_for_bbox = start_element
-        end_element_for_bbox = end_element
-
-        if include_boundaries == "none":
-            start_idx += 1
-            end_idx -= 1
-            start_element_for_bbox = elements[start_idx] if start_idx <= end_idx else None
-            end_element_for_bbox = elements[end_idx] if start_idx <= end_idx else None
-        elif include_boundaries == "start":
-            end_idx -= 1
-            end_element_for_bbox = elements[end_idx] if start_idx <= end_idx else None
-        elif include_boundaries == "end":
-            start_idx += 1
-            start_element_for_bbox = elements[start_idx] if start_idx <= end_idx else None
-
-        # Ensure valid indexes
-        start_idx = max(0, start_idx)
-        end_idx = min(len(elements) - 1, end_idx)
-
-        # If no valid elements in range, return empty region
-        if start_idx > end_idx or start_element_for_bbox is None or end_element_for_bbox is None:
-            logger.debug("No valid elements in range for get_section_between.")
-            # Return an empty region positioned at the start element boundary
-            anchor = start_element if start_element else self
-            return Region(self.page, (anchor.x0, anchor.top, anchor.x0, anchor.top))
-
-        # Get elements in range based on adjusted indices
-        section_elements = elements[start_idx : end_idx + 1]
-
-        # Create bounding box around the ELEMENTS included based on indices
-        x0 = min(e.x0 for e in section_elements)
-        top = min(e.top for e in section_elements)
-        x1 = max(e.x1 for e in section_elements)
-        bottom = max(e.bottom for e in section_elements)
+        # Validate orientation parameter
+        if orientation not in ["vertical", "horizontal"]:
+            raise ValueError(f"orientation must be 'vertical' or 'horizontal', got '{orientation}'")
+
+        # Calculate the section boundaries based on orientation and include_boundaries
+        if orientation == "vertical":
+            # Use full width of the parent region for vertical sections
+            x0 = self.x0  # Use parent region's left boundary
+            x1 = self.x1  # Use parent region's right boundary
+
+            # Determine vertical boundaries based on include_boundaries
+            if include_boundaries == "both":
+                # Include both boundary elements
+                top = start_element.top
+                bottom = end_element.bottom
+            elif include_boundaries == "start":
+                # Include start element, exclude end element
+                top = start_element.top
+                bottom = end_element.top  # Stop at the top of end element
+            elif include_boundaries == "end":
+                # Exclude start element, include end element
+                top = start_element.bottom  # Start at the bottom of start element
+                bottom = end_element.bottom
+            else:  # "none"
+                # Exclude both boundary elements
+                top = start_element.bottom  # Start at the bottom of start element
+                bottom = end_element.top  # Stop at the top of end element
+
+            # Ensure valid boundaries
+            if top >= bottom:
+                logger.debug(f"Invalid section boundaries: top={top} >= bottom={bottom}")
+                # Return an empty region
+                return Region(self.page, (x0, top, x0, top))
+        else:  # horizontal
+            # Use full height of the parent region for horizontal sections
+            top = self.top  # Use parent region's top boundary
+            bottom = self.bottom  # Use parent region's bottom boundary
+
+            # Determine horizontal boundaries based on include_boundaries
+            if include_boundaries == "both":
+                # Include both boundary elements
+                x0 = start_element.x0
+                x1 = end_element.x1
+            elif include_boundaries == "start":
+                # Include start element, exclude end element
+                x0 = start_element.x0
+                x1 = end_element.x0  # Stop at the left of end element
+            elif include_boundaries == "end":
+                # Exclude start element, include end element
+                x0 = start_element.x1  # Start at the right of start element
+                x1 = end_element.x1
+            else:  # "none"
+                # Exclude both boundary elements
+                x0 = start_element.x1  # Start at the right of start element
+                x1 = end_element.x0  # Stop at the left of end element
+
+            # Ensure valid boundaries
+            if x0 >= x1:
+                logger.debug(f"Invalid section boundaries: x0={x0} >= x1={x1}")
+                # Return an empty region
+                return Region(self.page, (x0, top, x0, top))
 
         # Create new region
         section = Region(self.page, (x0, top, x1, bottom))
@@ -2644,7 +2717,11 @@ class Region(
         return section
 
     def get_sections(
-        self, start_elements=None, end_elements=None, include_boundaries="both"
+        self,
+        start_elements=None,
+        end_elements=None,
+        include_boundaries="both",
+        orientation="vertical",
     ) -> "ElementCollection[Region]":
         """
         Get sections within this region based on start/end elements.
@@ -2653,6 +2730,7 @@ class Region(
             start_elements: Elements or selector string that mark the start of sections
             end_elements: Elements or selector string that mark the end of sections
             include_boundaries: How to include boundary elements: 'start', 'end', 'both', or 'none'
+            orientation: 'vertical' (default) or 'horizontal' - determines section direction
 
         Returns:
             List of Region objects representing the extracted sections
@@ -2687,9 +2765,12 @@ class Region(
         if not start_elements:
             return []
 
-        # Sort all elements within the region in reading order
+        # Sort all elements within the region based on orientation
         all_elements_in_region = self.get_elements()
-        all_elements_in_region.sort(key=lambda e: (e.top, e.x0))
+        if orientation == "vertical":
+            all_elements_in_region.sort(key=lambda e: (e.top, e.x0))
+        else:  # horizontal
+            all_elements_in_region.sort(key=lambda e: (e.x0, e.top))
 
         if not all_elements_in_region:
             return []  # Cannot create sections if region is empty
@@ -2731,7 +2812,9 @@ class Region(
                 start_element = current_start_boundary["element"]
                 end_element = boundary["element"]
                 # Use the helper, ensuring elements are from within the region
-                section = self.get_section_between(start_element, end_element, include_boundaries)
+                section = self.get_section_between(
+                    start_element, end_element, include_boundaries, orientation
+                )
                 sections.append(section)
                 current_start_boundary = None  # Reset
 
@@ -2748,7 +2831,7 @@ class Region(
                 if end_idx >= 0 and end_idx >= current_start_boundary["index"]:
                     end_element = all_elements_in_region[end_idx]
                     section = self.get_section_between(
-                        start_element, end_element, include_boundaries
+                        start_element, end_element, include_boundaries, orientation
                     )
                     sections.append(section)
                 # Else: Section started and ended by consecutive start elements? Create empty?
@@ -2762,7 +2845,9 @@ class Region(
             start_element = current_start_boundary["element"]
             # End at the last element within the region
             end_element = all_elements_in_region[-1]
-            section = self.get_section_between(start_element, end_element, include_boundaries)
+            section = self.get_section_between(
+                start_element, end_element, include_boundaries, orientation
+            )
             sections.append(section)
 
         return ElementCollection(sections)
@@ -3016,6 +3101,54 @@ class Region(
 
         return all_descendants
 
+    def __add__(
+        self, other: Union["Element", "Region", "ElementCollection"]
+    ) -> "ElementCollection":
+        """Add regions/elements together to create an ElementCollection.
+
+        This allows intuitive combination of regions using the + operator:
+        ```python
+        complainant = section.find("text:contains(Complainant)").right(until='text')
+        dob = section.find("text:contains(DOB)").right(until='text')
+        combined = complainant + dob  # Creates ElementCollection with both regions
+        ```
+
+        Args:
+            other: Another Region, Element or ElementCollection to combine
+
+        Returns:
+            ElementCollection containing all elements
+        """
+        from natural_pdf.elements.base import Element
+        from natural_pdf.elements.element_collection import ElementCollection
+
+        # Create a list starting with self
+        elements = [self]
+
+        # Add the other element(s)
+        if isinstance(other, (Element, Region)):
+            elements.append(other)
+        elif isinstance(other, ElementCollection):
+            elements.extend(other)
+        elif hasattr(other, "__iter__") and not isinstance(other, (str, bytes)):
+            # Handle other iterables but exclude strings
+            elements.extend(other)
+        else:
+            raise TypeError(f"Cannot add Region with {type(other)}")
+
+        return ElementCollection(elements)
+
+    def __radd__(
+        self, other: Union["Element", "Region", "ElementCollection"]
+    ) -> "ElementCollection":
+        """Right-hand addition to support ElementCollection + Region."""
+        if other == 0:
+            # This handles sum() which starts with 0
+            from natural_pdf.elements.element_collection import ElementCollection
+
+            return ElementCollection([self])
+        return self.__add__(other)
+
     def __repr__(self) -> str:
         """String representation of the region."""
         poly_info = " (Polygon)" if self.has_polygon else ""

natural_pdf/flows/flow.py

@@ -1296,6 +1296,7 @@ class Flow(Visualizable):
         end_elements=None,
         new_section_on_page_break: bool = False,
         include_boundaries: str = "both",
+        orientation: str = "vertical",
     ) -> "ElementCollection":
         """
         Extract logical sections from the Flow based on *start* and *end* boundary
@@ -1317,6 +1318,7 @@ class Flow(Visualizable):
                 boundaries (default: False).
             include_boundaries: How to include boundary elements: 'start',
                 'end', 'both', or 'none' (default: 'both').
+            orientation: 'vertical' (default) or 'horizontal' - determines section direction.
 
         Returns:
             ElementCollection of Region/FlowRegion objects representing the
@@ -1408,6 +1410,7 @@ class Flow(Visualizable):
                 start_elements=seg_start_elems,
                 end_elements=seg_end_elems,
                 include_boundaries=include_boundaries,
+                orientation=orientation,
             )
 
             if seg_sections:

natural_pdf/selectors/parser.py

@@ -530,8 +530,8 @@ PSEUDO_CLASS_FUNCTIONS = {
     "italic": lambda el: hasattr(el, "italic") and el.italic,
     "first-child": lambda el: hasattr(el, "parent") and el.parent and el.parent.children[0] == el,
     "last-child": lambda el: hasattr(el, "parent") and el.parent and el.parent.children[-1] == el,
-    "empty": lambda el: not el.text,
-    "not-empty": lambda el: el.text,
+    "empty": lambda el: not hasattr(el, "text") or not el.text or not el.text.strip(),
+    "not-empty": lambda el: bool(hasattr(el, "text") and el.text and el.text.strip()),
     "not-bold": lambda el: hasattr(el, "bold") and not el.bold,
     "not-italic": lambda el: hasattr(el, "italic") and not el.italic,
 }

natural_pdf/utils/color_utils.py

@@ -0,0 +1,100 @@
+"""
+Utility functions for color formatting and conversion.
+"""
+
+from typing import Any, List, Optional, Tuple, Union
+
+# List of known color attribute names in natural-pdf
+COLOR_ATTRIBUTES = [
+    "color",
+    "fill",
+    "stroke",
+    "non_stroking_color",
+    "stroking_color",
+    "text_color",
+    "background_color",
+    "highlight_color",
+    "border_color",
+]
+
+
+def rgb_to_hex(color: Union[Tuple[float, ...], List[float]]) -> str:
+    """
+    Convert an RGB/RGBA color tuple to hex string.
+
+    Args:
+        color: RGB tuple with values either in [0,1] or [0,255] range
+               Can be RGB (3 values) or RGBA (4 values)
+
+    Returns:
+        Hex color string (e.g., '#ff0000' for red)
+    """
+    if not isinstance(color, (tuple, list)) or len(color) < 3:
+        raise ValueError(f"Invalid color format: {color}")
+
+    # Take first 3 values (RGB), ignore alpha if present
+    r, g, b = color[:3]
+
+    # Determine if values are in [0,1] or [0,255] range
+    # If any positive value is > 1, assume [0,255] range
+    max_val = max(abs(r), abs(g), abs(b))
+
+    if max_val > 1:
+        # Values are in 0-255 range
+        r_int = int(min(255, max(0, r)))
+        g_int = int(min(255, max(0, g)))
+        b_int = int(min(255, max(0, b)))
+    else:
+        # Values are in 0-1 range, convert to 0-255
+        r_int = int(min(255, max(0, r * 255)))
+        g_int = int(min(255, max(0, g * 255)))
+        b_int = int(min(255, max(0, b * 255)))
+
+    return f"#{r_int:02x}{g_int:02x}{b_int:02x}"
+
+
+def is_color_attribute(attr_name: str) -> bool:
+    """
+    Check if an attribute name is a known color attribute.
+
+    Args:
+        attr_name: The attribute name to check
+
+    Returns:
+        True if this is a known color attribute
+    """
+    return attr_name.lower() in [attr.lower() for attr in COLOR_ATTRIBUTES]
+
+
+def format_color_value(value: Any, attr_name: Optional[str] = None) -> str:
+    """
+    Format a color value for display, converting tuples to hex when appropriate.
+
+    Args:
+        value: The value to format
+        attr_name: Optional attribute name to help determine if this is a color
+
+    Returns:
+        Formatted string representation
+    """
+    # If attr_name is provided and it's not a color attribute, return as-is
+    if attr_name and not is_color_attribute(attr_name):
+        return str(value)
+
+    # Check if value looks like an RGB color tuple
+    if isinstance(value, (tuple, list)):
+        # Must have 3 or 4 values (RGB or RGBA)
+        if len(value) in (3, 4):
+            # Check if all values are numeric
+            if all(isinstance(v, (int, float)) for v in value):
+                # Additional validation: values should be in reasonable ranges
+                # Either all in [0,1] or all in [0,255]
+                if all(0 <= v <= 1 for v in value[:3]) or all(0 <= v <= 255 for v in value[:3]):
+                    try:
+                        return rgb_to_hex(value)
+                    except Exception:
+                        # If conversion fails, fall back to string representation
+                        pass
+
+    # Default: convert to string
+    return str(value)

{natural_pdf-0.2.5.dist-info → natural_pdf-0.2.6.dist-info}/METADATA

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

{natural_pdf-0.2.5.dist-info → natural_pdf-0.2.6.dist-info}/RECORD

@@ -2,7 +2,7 @@ natural_pdf/__init__.py,sha256=N4pR0LbuPEnUYFZqbdVqc_FGKldgwPQc1wjJhYKTBBM,3417
 natural_pdf/cli.py,sha256=SkPwhhMM-GhLsj3O1n1Agxz4KOxcZ08sj8hVQSFJB5c,4064
 natural_pdf/text_mixin.py,sha256=eFCiHj6Okcw3aum4955BepcI2NPRalkf9UFFVTc_H30,4012
 natural_pdf/analyzers/__init__.py,sha256=3XGoNq3OgiVkZP7tOdeP5XVUl7fDgyztdA8DlOcMLXg,1138
-natural_pdf/analyzers/guides.py,sha256=mLWPPEwywo_FbU3gSoegiRlzxYmkHEo2c4DLX9krH9k,157691
+natural_pdf/analyzers/guides.py,sha256=RHFTc2n6kzKrjsd2pk-1MfG1esuEpnTJr8GrsTqlF3A,160441
 natural_pdf/analyzers/shape_detection_mixin.py,sha256=mgpyJ4jIulz9l9HCqThabJIsLSrXh9BB2AmLxUoHmw0,62584
 natural_pdf/analyzers/text_options.py,sha256=qEkDaYWla0rIM_gszEOsu52q7C_dAfV81P2HLJZM2sw,3333
 natural_pdf/analyzers/text_structure.py,sha256=3WWusi-BI0krUnJxB05DD6XmKj5qRNvQBqH7zOQGm1M,28451
@@ -27,24 +27,24 @@ natural_pdf/collections/mixins.py,sha256=Se2C5AcpP9B5E0d0pIrey6-f_P32tAXTK4M7666
 natural_pdf/core/__init__.py,sha256=QC8H4M3KbXwMFiQORZ0pdPlzx1Ix6oKKQSS7Ib2KEaA,38
 natural_pdf/core/element_manager.py,sha256=KPuKM7SstfErTkRnGq4vrgE0Tv8iazN13Jp7yAXGKso,55575
 natural_pdf/core/highlighting_service.py,sha256=7on8nErhi50CEH2L4XzGIZ6tIqZtMzmmFlp-2lmwnYE,68856
-natural_pdf/core/page.py,sha256=Q3hBvB9KFB8doeXY7YVQt3G1ULdBDfA-0BQD6YPN4oo,144640
-natural_pdf/core/page_collection.py,sha256=hEeXs_fzB73XZ8ZkHz2kIuSgBYcVYydvGMMdGuB1rvw,52486
-natural_pdf/core/page_groupby.py,sha256=550ME6kd-h-2u75oUIIIqTYsmh8VvdQO1nXXioL8J6A,7378
-natural_pdf/core/pdf.py,sha256=VslSn00So6157XfiYbrB9URpx5VlWyshQOt7upi9us4,104248
+natural_pdf/core/page.py,sha256=U0wAEw6z_lFuv6BBY8DKIpD5Y4wiZCo7x7qtjPf3hcM,148300
+natural_pdf/core/page_collection.py,sha256=itVSWeY6285G7_bIP7vjrMygnGQTX2SdNbJxYW5Eypc,62196
+natural_pdf/core/page_groupby.py,sha256=V2e_RNlHaasUzYm2h2vNJI7_aV_fl3_pg7kU3F2j0z8,8218
+natural_pdf/core/pdf.py,sha256=XMEPyd6LlwAhFvnTAU5ZtE_Hr4WpkExxw16DpYsZpvQ,104410
 natural_pdf/core/pdf_collection.py,sha256=s3ogu4CEHrHMTRqQMJUKJZ-9Ii8b_B9dWbVLTFj0s7g,34992
-natural_pdf/core/render_spec.py,sha256=rLicaS9EPyojpJcjy2Lzn5DLWQwjrFyDJyRo7jbjdGU,14505
+natural_pdf/core/render_spec.py,sha256=y9QkMiIvWaKiEBlV0TjyldADIEUY3YfWLQXxStHu1S4,15480
 natural_pdf/describe/__init__.py,sha256=kIV7ORmWWB1SAur7nK2aAwR-wHqSedhKfUsaUl4hG0A,586
-natural_pdf/describe/base.py,sha256=Of9WVo9XuShXoeyJr0RN2CpLhF_CeiOjazl-or53RKU,18173
-natural_pdf/describe/elements.py,sha256=JicXC9SJmmasqxalpCXA47-kVwv-6JnR3Xiu778aNHM,12634
+natural_pdf/describe/base.py,sha256=LYbDjjQYOIZsYBbBQH3UP6XyWArJJvRc8LUugeVdJw0,18178
+natural_pdf/describe/elements.py,sha256=3Y541z5TQ2obrfZFiFi1YQMsCt3oYrhMHpD5j1tuppw,12639
 natural_pdf/describe/mixin.py,sha256=rkX14aGrSz7Jvxx8Rbxv3eSfbO-_29DipwpstrV2pDQ,3109
 natural_pdf/describe/summary.py,sha256=cfT4ZQkeatCDAOwWPwhtEVXisNgk6E57fAXAnoRysSU,7645
 natural_pdf/elements/__init__.py,sha256=ICNikmLeIEuSYypz-KnkBn8xR1hR7rge4hsa1KLkyWY,42
-natural_pdf/elements/base.py,sha256=aj-eXOQQlhKv9lYeUlUs9aKNcUebtG_dqxURZHZVZ58,55509
-natural_pdf/elements/element_collection.py,sha256=slCUnOT04sNOTjSGgmhjcCKKPVPtdDPwU7PX1ebzGMw,101342
+natural_pdf/elements/base.py,sha256=92ukTtRCQFsa5KvKflChCt4mt0ZGS4ecGYCQTNMO4zU,58907
+natural_pdf/elements/element_collection.py,sha256=42SUzjD2nYFPNEQA-4oMi2QOwwwsxBmcrY4FKgGumJ0,128700
 natural_pdf/elements/image.py,sha256=zu-P2Y8fRoEXf6IeZU0EYRWsgZ6I_a5vy1FA3VXTGkQ,1424
 natural_pdf/elements/line.py,sha256=TFn7KXjPT_jUQyQyabU0F7XYU4dC-qadwodJMZF4DCU,3844
 natural_pdf/elements/rect.py,sha256=0lNkVkPkvbRbrFED856RXoUcTcDkeeOIs5xldKGAQT8,3324
-natural_pdf/elements/region.py,sha256=_NNBewHlyUHvA4g9kApilP6it0cn2IRlcGG4r993oUI,156660
+natural_pdf/elements/region.py,sha256=XLbaMEQ-DXzbh4Xnv72ebS1ZlT5EuWpistz0O6bOSag,162583
 natural_pdf/elements/text.py,sha256=829uSJv9E-8cC6T6iR_Va7Xtv54pJoyRN78fq4NN1d4,20687
 natural_pdf/export/mixin.py,sha256=L1q3MIEFWuvie4j4_EmW7GT3NerbZ1as0XMUoqTS7gM,5083
 natural_pdf/exporters/__init__.py,sha256=QffoARekR6WzXEd05oxOytly4qPdBizuIF-SUkeFpig,643
@@ -63,7 +63,7 @@ natural_pdf/extraction/result.py,sha256=PDaCCN2LQBbHsZy0_lrQ0ROeMsnmH1WRoXWOjk9M
 natural_pdf/flows/__init__.py,sha256=cUN4A8hTDLZSRr4PO2W_lR4z6hWpbNG8Seox-IIcrLU,277
 natural_pdf/flows/collections.py,sha256=ErkHWdX6W_y1SjkcA_bGM0uUYRGPWWpRkHip6LHpej0,25740
 natural_pdf/flows/element.py,sha256=T-9uXsIBe7mIim-mQQMep6Ja5dRfWaYIj8g1ak_Bv8c,24892
-natural_pdf/flows/flow.py,sha256=If4G0feMsO3jZO5T2YXvGhb2UygMgwK3567JD42bSl0,85975
+natural_pdf/flows/flow.py,sha256=BuT3DBqNvLEqYle66-nZFO91i_1s98CAat28Dg-JjGU,86149
 natural_pdf/flows/region.py,sha256=r_cFtBlmPi7ADN3k8oYA1s_vyz8GeQLCnYcv58Zt5eM,52263
 natural_pdf/ocr/__init__.py,sha256=VY8hhvDPf7Gh2lB-d2QRmghLLyTy6ydxlgo1cS4dOSk,2482
 natural_pdf/ocr/engine.py,sha256=SwNlWydtHbrIghV5JD_j5B4-rnjCMYIWUIEARag-zHw,11839
@@ -85,12 +85,13 @@ natural_pdf/search/search_options.py,sha256=sq_e8_jSROicD94b_xtDtLnjEr_Zsy4icjzP
 natural_pdf/search/search_service_protocol.py,sha256=u8pbuWP96fnQEe6mnreY9DrdiDAHP6ZCY7phvSbFlP8,6697
 natural_pdf/search/searchable_mixin.py,sha256=hqQ_AuID5eTGRCtKYdFLZ1zF35y73uk3x1M1VW9Il8U,23514
 natural_pdf/selectors/__init__.py,sha256=oZGeqSv53EqmIZOhcnawuaGGlRg1h79vArXuZCWKm4A,123
-natural_pdf/selectors/parser.py,sha256=pw0M8ICKPMOzZPzWpLsQMG_lnl8PewGIdIG3ciukabk,38877
+natural_pdf/selectors/parser.py,sha256=yV5Eb0VyNZocoYIXi7SMKsf8o66vrGNb-MeT27aEj-M,38977
 natural_pdf/tables/__init__.py,sha256=sCvCGbGsL6BiqlNxAYfVv003bIDLI11FmjHhaWfcU6w,104
 natural_pdf/tables/result.py,sha256=-8ctA-jCJYSHtlfAoqTvhUwO5zSP2BQxxetAjqEsNyg,8665
 natural_pdf/templates/__init__.py,sha256=jYBxzfi73vew0f6yhIh1MlRxw4F_TVN2hKQR0YXOFe0,20
 natural_pdf/utils/__init__.py,sha256=s3M8FggaK1P3EBYn6R_-HgSDjNc9C73gyKe1hihtNWg,43
 natural_pdf/utils/bidi_mirror.py,sha256=jJEES0xDrMfo5Me8kHMxHv4COS51PitnYi2EvKv3HCE,1151
+natural_pdf/utils/color_utils.py,sha256=6v2hqk4WdaUR85fFbOej_T4AeASpVeze3xVRWgNKqOk,3128
 natural_pdf/utils/debug.py,sha256=Epwie_jmRgknUSaEoxEyvr1lBXpfYTFOe2UQh_zSj_0,1026
 natural_pdf/utils/highlighting.py,sha256=c9SvvPaJDI9bWXzq1A7zdh_0s3C4GCMngrJdkL2AMeM,719
 natural_pdf/utils/identifiers.py,sha256=P7n6owcubnF8oAMa_UfYtENmIaJQdH_AMC9Jbs2bWXo,1117
@@ -106,7 +107,7 @@ natural_pdf/vision/results.py,sha256=F2zXG3MVZIpOUvPkJHotOq6-9rFz68BaO_8pnSndlOs
 natural_pdf/vision/similarity.py,sha256=YH8legN-t9uf1b_XULi4JLNDaRfPNKQwU1FZ4Qu08jY,11740
 natural_pdf/widgets/__init__.py,sha256=QTVaUmsw__FCweFYZebwPssQxxUFUMd0wpm_cUbGZJY,181
 natural_pdf/widgets/viewer.py,sha256=KW3JogdR2TMg2ECUMYp8hwd060hfg8EsYBWxb5IEzBY,24942
-natural_pdf-0.2.5.dist-info/licenses/LICENSE,sha256=9zfwINwJlarbDmdh6iJV4QUG54QSJlSAUcnC1YiC_Ns,1074
+natural_pdf-0.2.6.dist-info/licenses/LICENSE,sha256=9zfwINwJlarbDmdh6iJV4QUG54QSJlSAUcnC1YiC_Ns,1074
 optimization/memory_comparison.py,sha256=0i_foFSRmppj-fY069qjwH36s_zkx-1L2ASAAlepWzA,6541
 optimization/pdf_analyzer.py,sha256=HjrmTgu2qchxPeDckc5kjgxppGwd40UESrYS9Myj7pY,19352
 optimization/performance_analysis.py,sha256=JBXnR9hc7Ix7YCnt3EJPSpsyqIUgKsc7GEffQ_TDCBk,13033
@@ -123,8 +124,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.2.5.dist-info/METADATA,sha256=H9nhjh1zRBmz2vUTe_j6FT-Zvn1sgoWT0nyoZG5GTYg,6959
-natural_pdf-0.2.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-natural_pdf-0.2.5.dist-info/entry_points.txt,sha256=1R_KMv7g60UBBpRqGfw7bppsMNGdayR-iJlb9ohEk_8,81
-natural_pdf-0.2.5.dist-info/top_level.txt,sha256=80t0F2ZeX4vN4Ke5iTflcOk_PN_0USn33ha3X6X86Ik,36
-natural_pdf-0.2.5.dist-info/RECORD,,
+natural_pdf-0.2.6.dist-info/METADATA,sha256=SJ7AqaSiRD-4NYz9Pk0Iz7IlEMiiv1aha3V8do8qvbo,6959
+natural_pdf-0.2.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+natural_pdf-0.2.6.dist-info/entry_points.txt,sha256=1R_KMv7g60UBBpRqGfw7bppsMNGdayR-iJlb9ohEk_8,81
+natural_pdf-0.2.6.dist-info/top_level.txt,sha256=80t0F2ZeX4vN4Ke5iTflcOk_PN_0USn33ha3X6X86Ik,36
+natural_pdf-0.2.6.dist-info/RECORD,,