natural-pdf 0.2.11__py3-none-any.whl → 0.2.12__py3-none-any.whl

natural_pdf/analyzers/guides.py

@@ -185,7 +185,9 @@ class GuidesList(UserList):
         self,
         markers: Union[str, List[str], "ElementCollection", Callable, None],
         obj: Optional[Union["Page", "Region", "FlowRegion"]] = None,
-        align: Literal["left", "right", "center", "between"] = "left",
+        align: Union[
+            Literal["left", "right", "center", "between"], Literal["top", "bottom"]
+        ] = "left",
         outer: bool = True,
         tolerance: float = 5,
         *,
@@ -203,7 +205,10 @@ class GuidesList(UserList):
                 - Callable: function that takes a page and returns markers
                 - None: no markers
             obj: Page/Region/FlowRegion to search (uses parent's context if None)
-            align: How to align guides relative to found elements
+            align: How to align guides relative to found elements:
+                - For vertical guides: 'left', 'right', 'center', 'between'
+                - For horizontal guides: 'top', 'bottom', 'center', 'between'
+                - Note: 'left'/'right' also work for horizontal (mapped to top/bottom)
             outer: Whether to add outer boundary guides
             tolerance: Tolerance for snapping to element edges
             apply_exclusions: Whether to apply exclusion zones when searching for text
@@ -224,19 +229,25 @@ class GuidesList(UserList):
             self._callable = None
             actual_markers = markers
 
+        # Normalize alignment for horizontal guides
+        if self._axis == "horizontal":
+            if align == "top":
+                align = "left"
+            elif align == "bottom":
+                align = "right"
+
         # Check if parent is in flow mode
         if self._parent.is_flow_region:
             # Create guides across all constituent regions
             all_guides = []
             for region in self._parent.context.constituent_regions:
-                # Normalize markers for this region
-                marker_texts = _normalize_markers(actual_markers, region)
+                # Pass markers directly - from_content will handle them properly
 
                 # Create guides for this region
                 region_guides = Guides.from_content(
                     obj=region,
                     axis=self._axis,
-                    markers=marker_texts,
+                    markers=actual_markers,  # Pass original markers, not normalized text
                     align=align,
                     outer=outer,
                     tolerance=tolerance,
@@ -312,14 +323,14 @@ class GuidesList(UserList):
             return self._parent
 
         # Original single-region logic
-        # Normalize markers to list of text strings
-        marker_texts = _normalize_markers(actual_markers, target_obj)
+        # Pass markers directly to from_content which will handle them properly
+        # (no need to normalize here since from_content now handles ElementCollection)
 
         # Create guides for this axis
         new_guides = Guides.from_content(
             obj=target_obj,
             axis=self._axis,
-            markers=marker_texts,
+            markers=actual_markers,  # Pass original markers, not normalized text
             align=align,
             outer=outer,
             tolerance=tolerance,
@@ -930,6 +941,82 @@ class GuidesList(UserList):
         self.data.clear()
         return self._parent
 
+    def from_stripes(
+        self,
+        stripes=None,
+        color=None,  # Explicitly specify stripe color
+    ) -> "Guides":
+        """Create guides from striped table rows or columns.
+
+        Creates guides at both edges of stripe elements (e.g., colored table rows).
+        Perfect for zebra-striped tables where you need guides at every row boundary.
+
+        Args:
+            stripes: Elements representing stripes. If None, auto-detects.
+            color: Specific color to look for (e.g., '#00ffff'). If None, finds most common.
+
+        Examples:
+            # Auto-detect zebra stripes
+            guides.horizontal.from_stripes()
+
+            # Specific color
+            guides.horizontal.from_stripes(color='#00ffff')
+
+            # Manual selection
+            stripes = page.find_all('rect[fill=#00ffff]')
+            guides.horizontal.from_stripes(stripes)
+
+            # Vertical stripes
+            guides.vertical.from_stripes(color='#e0e0e0')
+
+        Returns:
+            Parent Guides object for chaining
+        """
+        from collections import defaultdict
+
+        target_obj = self._parent.context
+        if target_obj is None:
+            raise ValueError("No context available for stripe detection")
+
+        if stripes is None:
+            if color:
+                # User specified color
+                stripes = target_obj.find_all(f"rect[fill={color}]")
+            else:
+                # Auto-detect most common non-white fill
+                all_rects = target_obj.find_all("rect[fill]")
+
+                # Group by fill color
+                fill_counts = defaultdict(list)
+                for rect in all_rects:
+                    if rect.fill and rect.fill not in ["#ffffff", "white", "none", "transparent"]:
+                        fill_counts[rect.fill].append(rect)
+
+                if not fill_counts:
+                    return self._parent  # No stripes found
+
+                # Find most common fill color
+                stripes = max(fill_counts.values(), key=len)
+
+        if not stripes:
+            return self._parent
+
+        # Get both edges of each stripe
+        edges = []
+        if self._axis == "horizontal":
+            for stripe in stripes:
+                edges.extend([stripe.top, stripe.bottom])
+        else:
+            for stripe in stripes:
+                edges.extend([stripe.x0, stripe.x1])
+
+        # Remove duplicates and sort
+        edges = sorted(set(edges))
+
+        # Add guides
+        self.extend(edges)
+        return self._parent
+
     def __add__(self, other):
         """Handle addition of GuidesList objects by returning combined data."""
         if isinstance(other, GuidesList):
@@ -1459,7 +1546,9 @@ class Guides:
         obj: Union["Page", "Region", "FlowRegion"],
         axis: Literal["vertical", "horizontal"] = "vertical",
         markers: Union[str, List[str], "ElementCollection", None] = None,
-        align: Literal["left", "right", "center", "between"] = "left",
+        align: Union[
+            Literal["left", "right", "center", "between"], Literal["top", "bottom"]
+        ] = "left",
         outer: bool = True,
         tolerance: float = 5,
         apply_exclusions: bool = True,
@@ -1475,7 +1564,9 @@ class Guides:
                 - List[str]: list of selectors or literal text strings
                 - ElementCollection: collection of elements to extract text from
                 - None: no markers
-            align: Where to place guides relative to found text
+            align: Where to place guides relative to found text:
+                - For vertical guides: 'left', 'right', 'center', 'between'
+                - For horizontal guides: 'top', 'bottom', 'center', 'between'
             outer: Whether to add guides at the boundaries
             tolerance: Maximum distance to search for text
             apply_exclusions: Whether to apply exclusion zones when searching for text
@@ -1483,6 +1574,13 @@ class Guides:
         Returns:
             New Guides object aligned to text content
         """
+        # Normalize alignment for horizontal guides
+        if axis == "horizontal":
+            if align == "top":
+                align = "left"
+            elif align == "bottom":
+                align = "right"
+
         # Handle FlowRegion
         if hasattr(obj, "constituent_regions"):
             guides = cls(context=obj)
@@ -1530,39 +1628,51 @@ class Guides:
         elif hasattr(obj, "width"):
             bounds = (0, 0, obj.width, obj.height)
 
-        # Normalize markers to list of text strings
-        marker_texts = _normalize_markers(markers, obj)
+        # Handle different marker types
+        elements_to_process = []
 
-        # Find each marker and determine guide position
-        for marker in marker_texts:
-            if hasattr(obj, "find"):
-                element = obj.find(f'text:contains("{marker}")', apply_exclusions=apply_exclusions)
-                if element:
-                    if axis == "vertical":
-                        if align == "left":
-                            guides_coords.append(element.x0)
-                        elif align == "right":
-                            guides_coords.append(element.x1)
-                        elif align == "center":
-                            guides_coords.append((element.x0 + element.x1) / 2)
-                        elif align == "between":
-                            # For between, collect left edges for processing later
-                            guides_coords.append(element.x0)
-                    else:  # horizontal
-                        if align == "left":  # top for horizontal
-                            guides_coords.append(element.top)
-                        elif align == "right":  # bottom for horizontal
-                            guides_coords.append(element.bottom)
-                        elif align == "center":
-                            guides_coords.append((element.top + element.bottom) / 2)
-                        elif align == "between":
-                            # For between, collect top edges for processing later
-                            guides_coords.append(element.top)
+        # Check if markers is an ElementCollection or has elements attribute
+        if hasattr(markers, "elements") or hasattr(markers, "_elements"):
+            # It's an ElementCollection - use elements directly
+            elements_to_process = getattr(markers, "elements", getattr(markers, "_elements", []))
+        elif hasattr(markers, "__iter__") and not isinstance(markers, str):
+            # Check if it's an iterable of elements (not strings)
+            try:
+                markers_list = list(markers)
+                if markers_list and hasattr(markers_list[0], "x0"):
+                    # It's a list of elements
+                    elements_to_process = markers_list
+            except:
+                pass
 
-        # Handle 'between' alignment - find midpoints between adjacent markers
-        if align == "between" and len(guides_coords) >= 2:
-            # We need to get the right and left edges of each marker
-            marker_bounds = []
+        if elements_to_process:
+            # Process elements directly without text search
+            for element in elements_to_process:
+                if axis == "vertical":
+                    if align == "left":
+                        guides_coords.append(element.x0)
+                    elif align == "right":
+                        guides_coords.append(element.x1)
+                    elif align == "center":
+                        guides_coords.append((element.x0 + element.x1) / 2)
+                    elif align == "between":
+                        # For between, collect left edges for processing later
+                        guides_coords.append(element.x0)
+                else:  # horizontal
+                    if align == "left":  # top for horizontal
+                        guides_coords.append(element.top)
+                    elif align == "right":  # bottom for horizontal
+                        guides_coords.append(element.bottom)
+                    elif align == "center":
+                        guides_coords.append((element.top + element.bottom) / 2)
+                    elif align == "between":
+                        # For between, collect top edges for processing later
+                        guides_coords.append(element.top)
+        else:
+            # Fall back to text-based search
+            marker_texts = _normalize_markers(markers, obj)
+
+            # Find each marker and determine guide position
             for marker in marker_texts:
                 if hasattr(obj, "find"):
                     element = obj.find(
@@ -1570,9 +1680,52 @@ class Guides:
                     )
                     if element:
                         if axis == "vertical":
-                            marker_bounds.append((element.x0, element.x1))
+                            if align == "left":
+                                guides_coords.append(element.x0)
+                            elif align == "right":
+                                guides_coords.append(element.x1)
+                            elif align == "center":
+                                guides_coords.append((element.x0 + element.x1) / 2)
+                            elif align == "between":
+                                # For between, collect left edges for processing later
+                                guides_coords.append(element.x0)
                         else:  # horizontal
-                            marker_bounds.append((element.top, element.bottom))
+                            if align == "left":  # top for horizontal
+                                guides_coords.append(element.top)
+                            elif align == "right":  # bottom for horizontal
+                                guides_coords.append(element.bottom)
+                            elif align == "center":
+                                guides_coords.append((element.top + element.bottom) / 2)
+                            elif align == "between":
+                                # For between, collect top edges for processing later
+                                guides_coords.append(element.top)
+
+        # Handle 'between' alignment - find midpoints between adjacent markers
+        if align == "between" and len(guides_coords) >= 2:
+            # We need to get the right and left edges of each marker
+            marker_bounds = []
+
+            if elements_to_process:
+                # Use elements directly
+                for element in elements_to_process:
+                    if axis == "vertical":
+                        marker_bounds.append((element.x0, element.x1))
+                    else:  # horizontal
+                        marker_bounds.append((element.top, element.bottom))
+            else:
+                # Fall back to text search
+                if "marker_texts" not in locals():
+                    marker_texts = _normalize_markers(markers, obj)
+                for marker in marker_texts:
+                    if hasattr(obj, "find"):
+                        element = obj.find(
+                            f'text:contains("{marker}")', apply_exclusions=apply_exclusions
+                        )
+                        if element:
+                            if axis == "vertical":
+                                marker_bounds.append((element.x0, element.x1))
+                            else:  # horizontal
+                                marker_bounds.append((element.top, element.bottom))
 
             # Sort markers by their left edge (or top edge for horizontal)
             marker_bounds.sort(key=lambda x: x[0])

natural_pdf/core/page.py

@@ -815,11 +815,38 @@ class Page(
                             if debug:
                                 print(f"    ✗ Empty iterable returned from callable '{label}'")
                     elif region_result:
-                        logger.warning(
-                            f"Callable exclusion '{exclusion_label}' returned non-Region object: {type(region_result)}. Skipping."
-                        )
-                        if debug:
-                            print(f"    ✗ Callable returned non-Region/None: {type(region_result)}")
+                        # Check if it's a single Element that can be converted to a Region
+                        from natural_pdf.elements.base import Element
+
+                        if isinstance(region_result, Element) or (
+                            hasattr(region_result, "bbox") and hasattr(region_result, "expand")
+                        ):
+                            try:
+                                # Convert Element to Region using expand()
+                                expanded_region = region_result.expand()
+                                if isinstance(expanded_region, Region):
+                                    expanded_region.label = label
+                                    regions.append(expanded_region)
+                                    if debug:
+                                        print(
+                                            f"    ✓ Converted Element to Region from callable '{label}': {expanded_region}"
+                                        )
+                                else:
+                                    if debug:
+                                        print(
+                                            f"    ✗ Element.expand() did not return a Region: {type(expanded_region)}"
+                                        )
+                            except Exception as e:
+                                if debug:
+                                    print(f"    ✗ Failed to convert Element to Region: {e}")
+                        else:
+                            logger.warning(
+                                f"Callable exclusion '{exclusion_label}' returned non-Region object: {type(region_result)}. Skipping."
+                            )
+                            if debug:
+                                print(
+                                    f"    ✗ Callable returned non-Region/None: {type(region_result)}"
+                                )
                     else:
                         if debug:
                             print(
@@ -839,6 +866,27 @@ class Page(
                 if debug:
                     print(f"  - Added direct region '{label}': {exclusion_item}")
 
+            # Process direct Element objects - convert to Region
+            elif hasattr(exclusion_item, "bbox") and hasattr(exclusion_item, "expand"):
+                try:
+                    # Convert Element to Region using expand()
+                    expanded_region = exclusion_item.expand()
+                    if isinstance(expanded_region, Region):
+                        expanded_region.label = label
+                        regions.append(expanded_region)
+                        if debug:
+                            print(
+                                f"  - Converted direct Element to Region '{label}': {expanded_region}"
+                            )
+                    else:
+                        if debug:
+                            print(
+                                f"  - Element.expand() did not return a Region: {type(expanded_region)}"
+                            )
+                except Exception as e:
+                    if debug:
+                        print(f"  - Failed to convert Element to Region: {e}")
+
             # Process string selectors (from PDF-level exclusions)
             elif isinstance(exclusion_item, str):
                 selector_str = exclusion_item
@@ -1081,7 +1129,7 @@ class Page(
         )  # _apply_selector doesn't filter
 
         # Filter the results based on exclusions if requested
-        if apply_exclusions and self._exclusions and results_collection:
+        if apply_exclusions and results_collection:
             filtered_elements = self._filter_elements_by_exclusions(results_collection.elements)
             # Return the first element from the filtered list
             return filtered_elements[0] if filtered_elements else None
@@ -1176,7 +1224,7 @@ class Page(
         )  # _apply_selector doesn't filter
 
         # Filter the results based on exclusions if requested
-        if apply_exclusions and self._exclusions and results_collection:
+        if apply_exclusions and results_collection:
             filtered_elements = self._filter_elements_by_exclusions(results_collection.elements)
             return ElementCollection(filtered_elements)
         else:
@@ -1548,7 +1596,7 @@ class Page(
         all_elements = self._element_mgr.get_all_elements()
 
         # Apply exclusions if requested
-        if apply_exclusions and self._exclusions:
+        if apply_exclusions:
             return self._filter_elements_by_exclusions(
                 all_elements, debug_exclusions=debug_exclusions
             )

natural_pdf/elements/region.py

@@ -1270,7 +1270,8 @@ class Region(
         # 3. Get Relevant Exclusions (overlapping this region)
         apply_exclusions_flag = kwargs.get("apply_exclusions", apply_exclusions)
         exclusion_regions = []
-        if apply_exclusions_flag and self._page._exclusions:
+        if apply_exclusions_flag:
+            # Always call _get_exclusion_regions to get both page and PDF level exclusions
             all_page_exclusions = self._page._get_exclusion_regions(
                 include_callable=True, debug=debug
             )
@@ -1281,10 +1282,11 @@ class Region(
             exclusion_regions = overlapping_exclusions
             if debug:
                 logger.debug(
-                    f"Region {self.bbox}: Applying {len(exclusion_regions)} overlapping exclusions."
+                    f"Region {self.bbox}: Found {len(all_page_exclusions)} total exclusions, "
+                    f"{len(exclusion_regions)} overlapping this region."
                 )
         elif debug:
-            logger.debug(f"Region {self.bbox}: Not applying exclusions.")
+            logger.debug(f"Region {self.bbox}: Not applying exclusions (apply_exclusions=False).")
 
         # 4. Spatially Filter Characters using Utility
         # Pass self as the target_region for precise polygon checks etc.

{natural_pdf-0.2.11.dist-info → natural_pdf-0.2.12.dist-info}/METADATA

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

{natural_pdf-0.2.11.dist-info → natural_pdf-0.2.12.dist-info}/RECORD

@@ -2,7 +2,7 @@ natural_pdf/__init__.py,sha256=N4pR0LbuPEnUYFZqbdVqc_FGKldgwPQc1wjJhYKTBBM,3417
 natural_pdf/cli.py,sha256=0zO9ZoRiP8JmyGBaVavrMATnvbARWTl7WD2PEefu9BM,4061
 natural_pdf/text_mixin.py,sha256=eFCiHj6Okcw3aum4955BepcI2NPRalkf9UFFVTc_H30,4012
 natural_pdf/analyzers/__init__.py,sha256=3XGoNq3OgiVkZP7tOdeP5XVUl7fDgyztdA8DlOcMLXg,1138
-natural_pdf/analyzers/guides.py,sha256=GQZHjl7wUpaxAKRpv4cyQf1SJuccMSjpngBKFCKNHK4,181795
+natural_pdf/analyzers/guides.py,sha256=B2_Etb0o-lOku-FQw-T1Fo1qxbcAXT4FB0hdp-5kXRs,188171
 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,7 +27,7 @@ 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=XmXii652iM-JVKgzpbKQ8f59U0TvDLD5iAfdtx92gis,152675
+natural_pdf/core/page.py,sha256=Pid5hqVjcyX-gcCzxCJ62k6AQhNbUMNM_5QmEcylIjM,155264
 natural_pdf/core/page_collection.py,sha256=IjdFq9q0D0P6ZKWInf0H25rLzxfMb7RsUXucogkhNkU,63169
 natural_pdf/core/page_groupby.py,sha256=V2e_RNlHaasUzYm2h2vNJI7_aV_fl3_pg7kU3F2j0z8,8218
 natural_pdf/core/pdf.py,sha256=ovdeu9TRPnVYyMltD7QpcdcFYBLZFXh3LlfC5ifj6RY,104227
@@ -44,7 +44,7 @@ natural_pdf/elements/element_collection.py,sha256=idM_BUWEfbCJ5Sq0Ae_KfbVHy8TdkN
 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=hCpbKg0R5TGfWEskZ6P-o_ZXPKhU4keaYjWIVX0Y7F4,165244
+natural_pdf/elements/region.py,sha256=HF6KzeuudO9upVLIrPsp3omcziLcILE3nnzl1a-LvK0,165400
 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
@@ -107,12 +107,32 @@ 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.11.dist-info/licenses/LICENSE,sha256=9zfwINwJlarbDmdh6iJV4QUG54QSJlSAUcnC1YiC_Ns,1074
+natural_pdf-0.2.12.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
 optimization/test_cleanup_methods.py,sha256=PmLOL4MRgvV0j_DW9W1TS8MsGGgu57QCuq6_5y7zK3s,6209
 optimization/test_memory_fix.py,sha256=A3knK74fNhvHknDbLhbTmA276x1ifl-3ivJ_7BhVSTI,6170
+temp/debug_cell_extraction.py,sha256=nE0Z470P40v8xZfWO1V3qgNaejs_pernEQaUOFeOJ1U,1527
+temp/debug_exclusion_overlap.py,sha256=RptJXwqBXy5gsvMF037KEx1o2QgjwEDkMB6TD5aJdqA,1644
+temp/debug_exclusions_guides.py,sha256=s8siep9te1KRJ2j0vH1tvDQnBlz7PKbHeCiYMrZL8jE,2096
+temp/debug_extra_guide.py,sha256=95Tim-YnmAR4kICw2XDKVDvlW5WsjK_51cv5-EV11rc,1236
+temp/debug_outer_boundaries.py,sha256=uJUJwojTxOU4VtbGUouuhV65IYzS6NDIVKxnS7o64nU,1456
+temp/debug_st_search.py,sha256=F4c_mUVi_d5AKaKIpQ0AnW1amDqAwALoQQj7wZj--J0,1021
+temp/fix_page_exclusions.py,sha256=YIj62zF38TdoBARAuSIvEbetl_JfXG-mp4v9p355qmo,1358
+temp/test_exclusion_with_debug.py,sha256=CScxHvb43KrB5dzXuTOhuzjcBXZBdfYB5ygiKkEW26g,1393
+temp/test_find_exclusions_fix.py,sha256=1l5aEqnElcl3kiykdtmJFlVxQ1xMKGm1UckGYEQg--c,2103
+temp/test_find_exclusions_fix_no_recursion.py,sha256=qZspTBwxunRM93N_-fZ2fR5Lodj0ArQX3h10HlTXhfc,3592
+temp/test_fix_real_pdf.py,sha256=uuylxmpeAEbIix9wjl0Gri1sZlN61dBWTq6ZCyfvzF8,1454
+temp/test_fix_working.py,sha256=-Ryre1rXYA2EG_lmPZGYEGi8yz0slhHEXPJMYexZW84,1750
+temp/test_fixed_pdf_exclusions.py,sha256=Q5zxooKDvtTXo-dDsx3nsQw1ZVHX3TW47iZ_dXpFdrY,2168
+temp/test_horizontal_top_bottom.py,sha256=Mb3tjt9Z3wOTpzFOgK7i0K-j-_ynNh4vDu2x1L3nu-s,2163
+temp/test_marker_order.py,sha256=TFZkMxRiNoZGVcdDivYnkIDNvwHaiyKUdYoy2rTTIiI,1417
+temp/test_original_exclusions_now_work.py,sha256=G6LmaF-P9Qhj0j4lT_4ncfCddllfP6L8F_x2prUBr9w,1904
+temp/test_pdf_exclusions_with_guides.py,sha256=QaMl0frgKC8kCPQ2BUI8kqyvqsIjQPXKV_St1rK3zxg,2754
+temp/test_region_exclusions_detailed.py,sha256=EftdW3JY3JH_LX5QlWKt-4drM-joPggK2fKUZRXVTMA,814
+temp/test_stripes_real_pdf.py,sha256=FIvDoJrnuioOMw1A0aTCCfZLeg99lusfe0Fb0MiqnhQ,2618
+temp/test_vertical_stripes.py,sha256=Yf3TJfb_faqAFzlgb7i5u6dDHjF4UMSHIGM99vangRk,1877
 tools/bad_pdf_eval/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tools/bad_pdf_eval/analyser.py,sha256=oqSTo3NLyignp_XdCO9_SRCUUXMU8lfgDavKYZYNxws,13690
 tools/bad_pdf_eval/collate_summaries.py,sha256=L_YsdiqmwGIHYWTVJqo6gyazyn3GIQgpfGGKk8uwckk,5159
@@ -124,8 +144,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.11.dist-info/METADATA,sha256=RBk1DrwdyTY0cJvFdWqfvM2hMd4OY30Lc0BlXopknD4,6960
-natural_pdf-0.2.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-natural_pdf-0.2.11.dist-info/entry_points.txt,sha256=1R_KMv7g60UBBpRqGfw7bppsMNGdayR-iJlb9ohEk_8,81
-natural_pdf-0.2.11.dist-info/top_level.txt,sha256=80t0F2ZeX4vN4Ke5iTflcOk_PN_0USn33ha3X6X86Ik,36
-natural_pdf-0.2.11.dist-info/RECORD,,
+natural_pdf-0.2.12.dist-info/METADATA,sha256=jRNM0JxYvPDuqzD63earjbaUwQgXCjPYPLC5pLl49Uk,6960
+natural_pdf-0.2.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+natural_pdf-0.2.12.dist-info/entry_points.txt,sha256=1R_KMv7g60UBBpRqGfw7bppsMNGdayR-iJlb9ohEk_8,81
+natural_pdf-0.2.12.dist-info/top_level.txt,sha256=ZDKhxE_tg508o9BpagsjCGcI8GY4cF_8bg0e0IaLsPI,41
+natural_pdf-0.2.12.dist-info/RECORD,,

{natural_pdf-0.2.11.dist-info → natural_pdf-0.2.12.dist-info}/top_level.txt

@@ -1,4 +1,5 @@
 natural_pdf
 optimization
+temp
 todo
 tools

temp/debug_cell_extraction.py

@@ -0,0 +1,42 @@
+"""Debug cell text extraction with exclusions"""
+from natural_pdf import PDF
+from natural_pdf.analyzers.guides import Guides
+
+pdf = PDF("pdfs/m27.pdf")
+page = pdf.pages[0]
+
+# Add exclusions
+pdf.add_exclusion(lambda page: page.find(text="PREMISE").above(), label="header")
+
+# Check exclusions are registered
+print("Exclusions on page:")
+exclusions = page._get_exclusion_regions(debug=True)
+
+# Create guides and build grid
+headers = page.find(text="NUMBER").right(include_source=True).expand(top=3, bottom=3).find_all('text')
+guides = Guides(page)
+guides.vertical.from_content(headers, align='left')
+guides.horizontal.from_stripes()
+
+# Build grid and get cells
+grid_result = guides.build_grid(include_outer_boundaries=True)
+cells = grid_result["regions"]["cells"]
+
+print(f"\nTotal cells: {len(cells)}")
+
+# Check first row cells (these should be in excluded area)
+first_row_cells = [c for c in cells if c.bbox[1] < 90]  # y < 90
+print(f"\nFirst row cells: {len(first_row_cells)}")
+
+for i, cell in enumerate(first_row_cells[:3]):
+    print(f"\nCell {i}:")
+    print(f"  Bbox: {cell.bbox}")
+    print(f"  Raw text: {repr(cell.extract_text(apply_exclusions=False))}")
+    print(f"  With exclusions: {repr(cell.extract_text(apply_exclusions=True))}")
+
+# Now test the full table extraction
+print("\n\nFull table extraction:")
+result = guides.extract_table(include_outer_boundaries=True, apply_exclusions=True, header=False)
+df = result.to_df()
+print("\nFirst row of dataframe:")
+print(df.iloc[0].to_dict() if not df.empty else "Empty")

temp/debug_exclusion_overlap.py

@@ -0,0 +1,43 @@
+"""Debug how exclusions work with overlapping regions"""
+from natural_pdf import PDF
+from natural_pdf.analyzers.guides import Guides
+
+pdf = PDF("pdfs/m27.pdf")
+page = pdf.pages[0]
+
+# Add exclusion
+pdf.add_exclusion(lambda page: page.find(text="PREMISE").above(), label="header")
+
+# Get the exclusion region
+exclusions = page._get_exclusion_regions()
+excl_region = exclusions[0]
+print(f"Exclusion region: {excl_region.bbox}")
+print(f"Exclusion bottom: {excl_region.bbox[3]}")
+
+# Create a test cell that overlaps the exclusion
+# Cell 1 from before: (32.06, 0.5, 73.18288, 79.53999999999996)
+test_cell = page.region(32.06, 0.5, 73.18288, 79.53999999999996)
+
+print(f"\nTest cell: {test_cell.bbox}")
+print(f"Cell overlaps exclusion: top={test_cell.bbox[1]} < excl_bottom={excl_region.bbox[3]}")
+
+# Extract text from different y-ranges
+print("\nText in different parts of the cell:")
+
+# Part above exclusion line (should be empty)
+upper_part = page.region(32.06, 0.5, 73.18288, 59.12)
+print(f"Upper part (0.5 to 59.12): '{upper_part.extract_text(apply_exclusions=True)}'")
+
+# Part below exclusion line (should have text)  
+lower_part = page.region(32.06, 59.12, 73.18288, 79.54)
+print(f"Lower part (59.12 to 79.54): '{lower_part.extract_text()}'")
+
+# The whole cell
+print(f"Whole cell with exclusions: '{test_cell.extract_text(apply_exclusions=True)}'")
+print(f"Whole cell without exclusions: '{test_cell.extract_text(apply_exclusions=False)}'")
+
+# Check what text elements are in this region
+print("\nText elements in cell:")
+cell_texts = test_cell.find_all('text')
+for t in cell_texts[:5]:
+    print(f"  '{t.text}' at y={t.top:.2f}-{t.bottom:.2f}")