natural-pdf 0.1.30__tar.gz → 0.1.31__tar.gz

{natural_pdf-0.1.30/natural_pdf.egg-info → natural_pdf-0.1.31}/PKG-INFO

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

{natural_pdf-0.1.30 → natural_pdf-0.1.31}/natural_pdf/core/element_manager.py

@@ -7,6 +7,7 @@ characters, words, rectangles, and lines extracted from a page.
 
 import logging
 import re
+from contextlib import contextmanager
 from itertools import groupby
 from typing import Any, Dict, List, Optional, Tuple, Union
 
@@ -47,6 +48,33 @@ HIGHLIGHT_DEFAULTS = {
     "color_value_min": 0.4,        # HSV V >
 }
 
+
+@contextmanager
+def disable_text_sync():
+    """
+    Temporarily disable text synchronization for performance.
+    
+    This is used when bulk-updating text content where character-level
+    synchronization is not needed, such as during bidi processing.
+    Fixes exponential recursion issue with Arabic/RTL text processing.
+    """
+    # Save original setter
+    original_setter = TextElement.text.fset
+    
+    # Create a fast setter that skips sync
+    def fast_setter(self, value):
+        self._obj["text"] = value
+        # Skip character synchronization for performance
+    
+    # Apply fast setter
+    TextElement.text = property(TextElement.text.fget, fast_setter)
+    
+    try:
+        yield
+    finally:
+        # Restore original setter
+        TextElement.text = property(TextElement.text.fget, original_setter)
+
 class NaturalWordExtractor(WordExtractor):
     """
     Custom WordExtractor that splits words based on specified character attributes
@@ -208,8 +236,7 @@ class ElementManager:
         yt = pdf_config.get("y_tolerance", 3)
         use_flow = pdf_config.get("use_text_flow", False)
 
-        # Define which attributes to preserve on the merged word object
-        # Should include split attributes + any others needed for filtering (like color)
+        # List of attributes to preserve on word objects
         attributes_to_preserve = list(
             set(
                 self._word_split_attributes
@@ -223,7 +250,7 @@ class ElementManager:
             )
         )
 
-        # -------------------------------------------------------------
+        # ------------------------------------------------------------------
         # NEW: Detect direction (LTR vs RTL) per visual line and feed
         #       pdfplumber's WordExtractor with the correct settings.
         # -------------------------------------------------------------
@@ -271,7 +298,9 @@ class ElementManager:
             # Build a WordExtractor tailored for this line's direction
             if is_rtl_line:
                 line_dir = "ttb"  # horizontal lines stacked top→bottom
-                char_dir = "rtl"  # characters right→left within the line
+                # Feed characters in right→left x-order; extractor can then treat
+                # them as left-to-right so that resulting text stays logical.
+                char_dir = "ltr"
             else:
                 line_dir = "ttb"
                 char_dir = "ltr"
@@ -288,9 +317,8 @@ class ElementManager:
             )
 
             # Prepare character sequence for the extractor:
-            #  • For LTR lines -> left→right order (x0 ascending)
-            #  • For RTL lines -> feed **reversed** list so that neighbouring
-            #    characters appear adjacent when the extractor walks right→left.
+            # Always feed characters in spatial order (x0 ascending)
+            # PDF stores glyphs in visual order, so this gives us the visual sequence
             line_chars_for_extractor = sorted(line_chars, key=lambda c: c.get("x0", 0))
 
             try:
@@ -324,15 +352,18 @@ class ElementManager:
                 # on the whole-line heuristic.
                 rtl_in_word = any(_is_rtl_char(ch.get("text", "")) for ch in char_list)
                 if rtl_in_word:
+                    # Convert from visual order (from PDF) to logical order using bidi
                     try:
                         from bidi.algorithm import get_display  # type: ignore
                         from natural_pdf.utils.bidi_mirror import mirror_brackets
 
-                        word_element.text = mirror_brackets(
-                            get_display(word_element.text, base_dir="R")
-                        )
+                        with disable_text_sync():
+                            # word_element.text is currently in visual order (from PDF)
+                            # Convert to logical order using bidi with auto direction detection
+                            logical_text = get_display(word_element.text, base_dir='L')
+                            # Apply bracket mirroring for logical order
+                            word_element.text = mirror_brackets(logical_text)
                     except Exception:
-                        # Fallback: keep original text if python-bidi fails
                         pass
 
         # ------------------------------------------------------------------
@@ -415,19 +446,6 @@ class ElementManager:
             f"Page {self._page.number}: Generated {len(generated_words)} words using NaturalWordExtractor."
         )
 
-        # --- Post-processing pass to ensure every word containing RTL characters is
-        #     stored in logical order and with mirrored brackets.  This is a
-        #     safeguard in case the per-line loop above missed some tokens.
-        try:
-            from bidi.algorithm import get_display  # type: ignore
-            from natural_pdf.utils.bidi_mirror import mirror_brackets
-
-            for w in generated_words:
-                if any(_is_rtl_char(ch) for ch in w.text):
-                    w.text = mirror_brackets(get_display(w.text, base_dir="R"))
-        except Exception:
-            pass  # graceful degradation – keep original text
-
         # 4. Load other elements (rects, lines)
         rect_elements = [RectangleElement(r, self._page) for r in self._page._page.rects]
         line_elements = [LineElement(l, self._page) for l in self._page._page.lines]
@@ -463,6 +481,8 @@ class ElementManager:
 
         logger.debug(f"Page {self._page.number}: Element loading complete.")
 
+        # If per-word BiDi was skipped, generated_words already stay in logical order.
+
     def _prepare_char_dicts(self) -> List[Dict[str, Any]]:
         """
         Prepares a list of character dictionaries from native PDF characters,

{natural_pdf-0.1.30 → natural_pdf-0.1.31}/natural_pdf/elements/text.py

@@ -468,3 +468,32 @@ class TextElement(Element):
                 info[f"raw_{prop}"] = self._obj[prop]
 
         return info
+
+    @property
+    def visual_text(self) -> str:
+        """Return the text converted to *visual* order using the Unicode BiDi algorithm.
+
+        This helper is intentionally side-effect–free: it does **not** mutate
+        ``self.text`` or the underlying character dictionaries.  It should be
+        used by UI / rendering code that needs human-readable RTL/LTR mixing.
+        """
+        logical = self.text
+        if not logical:
+            return logical
+
+        # Quick check – bail out if no RTL chars to save import/CPU.
+        import unicodedata
+
+        if not any(unicodedata.bidirectional(ch) in ("R", "AL", "AN") for ch in logical):
+            return logical
+
+        try:
+            from bidi.algorithm import get_display  # type: ignore
+            from natural_pdf.utils.bidi_mirror import mirror_brackets
+
+            # Convert from logical order to visual order
+            visual = get_display(logical, base_dir="R")
+            return mirror_brackets(visual)
+        except Exception:
+            # If python-bidi is missing or errors, fall back to logical order
+            return logical

{natural_pdf-0.1.30 → natural_pdf-0.1.31/natural_pdf.egg-info}/PKG-INFO

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

{natural_pdf-0.1.30 → natural_pdf-0.1.31}/natural_pdf.egg-info/SOURCES.txt

@@ -806,6 +806,8 @@ pdfs/tiny.pdf
 pdfs/types-of-type.pdf
 pdfs/word-counter.pdf
 tests/conftest.py
+tests/test_arabic_performance.py
+tests/test_arabic_real_world.py
 tests/test_highlight_detection.py
 tests/test_loading_original.py
 tests/test_optional_deps.py

natural_pdf-0.1.31/tests/test_arabic_performance.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+"""Test and profile performance differences between Arabic RTL and regular PDFs."""
+
+import time
+import cProfile
+import pstats
+from io import StringIO
+import pytest
+from natural_pdf import PDF
+
+
+class TestArabicPerformance:
+    """Test performance of Arabic/RTL PDF processing."""
+    
+    def profile_pdf_extraction(self, pdf_path: str, label: str):
+        """Profile PDF text extraction and return timing info."""
+        print(f"\n{'='*60}")
+        print(f"Profiling: {label} ({pdf_path})")
+        print('='*60)
+        
+        # Time the overall operation
+        start_time = time.time()
+        
+        # Create profiler
+        profiler = cProfile.Profile()
+        
+        # Profile the operations
+        profiler.enable()
+        
+        pdf = PDF(pdf_path)
+        page = pdf.pages[0]
+        text = page.extract_text()
+        
+        profiler.disable()
+        
+        end_time = time.time()
+        elapsed = end_time - start_time
+        
+        print(f"\nTotal time: {elapsed:.2f} seconds")
+        print(f"Text length: {len(text)} characters")
+        print(f"First 100 chars: {repr(text[:100])}")
+        
+        # Print profiling stats
+        print("\nTop 20 time-consuming functions:")
+        s = StringIO()
+        ps = pstats.Stats(profiler, stream=s).sort_stats('cumulative')
+        ps.print_stats(20)
+        print(s.getvalue())
+        
+        # Also show stats by total time
+        print("\nTop 20 by total time:")
+        s2 = StringIO()
+        ps2 = pstats.Stats(profiler, stream=s2).sort_stats('tottime')
+        ps2.print_stats(20)
+        print(s2.getvalue())
+        
+        return elapsed, len(text), text
+
+    def test_arabic_vs_regular_performance(self):
+        """Compare performance between Arabic and regular PDFs."""
+        # Profile both PDFs
+        arabic_time, arabic_len, arabic_text = self.profile_pdf_extraction(
+            "pdfs/arabic.pdf", "Arabic RTL PDF"
+        )
+        regular_time, regular_len, regular_text = self.profile_pdf_extraction(
+            "pdfs/types-of-type.pdf", "Regular PDF"
+        )
+        
+        # Summary comparison
+        print(f"\n{'='*60}")
+        print("PERFORMANCE COMPARISON")
+        print('='*60)
+        print(f"Arabic PDF:  {arabic_time:.2f}s for {arabic_len} chars ({arabic_len/arabic_time:.0f} chars/sec)")
+        print(f"Regular PDF: {regular_time:.2f}s for {regular_len} chars ({regular_len/regular_time:.0f} chars/sec)")
+        slowdown = arabic_time/regular_time
+        print(f"Slowdown factor: {slowdown:.1f}x slower")
+        
+        # This test can be used to track performance regressions
+        # For now, we'll just assert that both PDFs can be processed
+        assert arabic_len > 0, "Arabic PDF should contain text"
+        assert regular_len > 0, "Regular PDF should contain text"
+        
+        # Log a warning if Arabic is significantly slower
+        if slowdown > 5:
+            print(f"\nWARNING: Arabic PDF processing is {slowdown:.1f}x slower than expected!")
+
+
+if __name__ == "__main__":
+    # Run with detailed output
+    pytest.main([__file__, "-v", "-s"])

natural_pdf-0.1.31/tests/test_arabic_real_world.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+"""Test real-world Arabic text use cases with natural-pdf."""
+
+import unittest
+import time
+from natural_pdf import PDF
+
+class TestArabicPDF(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        start = time.time()
+        cls.pdf = PDF("pdfs/arabic.pdf")
+        cls.page = cls.pdf.pages[0]
+        cls.load_time = time.time() - start
+
+    def test_load_time_under_3s(self):
+        self.assertLess(self.load_time, 3, f"PDF load time too long: {self.load_time:.2f}s")
+
+    def test_text_extraction(self):
+        text = self.page.extract_text()
+        self.assertTrue(len(text) > 1000, "Extracted text is too short")
+        self.assertIn("قانون", text, "Expected Arabic keyword not found in extracted text")
+
+    def test_arabic_keywords_found(self):
+        search_terms = [
+            ("قانون", "law"),
+            ("المنشآت الفندقية", "official gazette"),
+            ("رقم", "number"),
+            ("لسنة", "for year"),
+            ("2022", "year 2022"),
+            ("العدد", "issue"),
+        ]
+        for term, _ in search_terms:
+            print('term', term, 'translation', _)
+            with self.subTest(term=term):
+                matches = self.page.find_all(f"text:contains({term})")
+                self.assertGreater(len(matches), 0, f"No matches found for term: {term}")
+
+    def test_spatial_navigation(self):
+        headers = self.page.find_all('text[size>12]')
+        self.assertGreater(len(headers), 0, "No large text headers found")
+        below = headers[0].below().find_all('text')
+        self.assertGreater(len(below), 0, "No text found below header")
+
+    def test_mixed_content_stats(self):
+        words = self.page.find_all('word')
+        stats = {
+            "arabic_only": 0,
+            "english_only": 0,
+            "numbers_only": 0,
+            "mixed": 0,
+        }
+
+        for word in words:
+            has_ar = any('\u0600' <= c <= '\u06FF' for c in word.text)
+            has_en = any('a' <= c.lower() <= 'z' for c in word.text)
+            has_num = any(c.isdigit() for c in word.text)
+
+            if has_ar and (has_en or has_num):
+                stats["mixed"] += 1
+            elif has_ar:
+                stats["arabic_only"] += 1
+            elif has_en:
+                stats["english_only"] += 1
+            elif has_num:
+                stats["numbers_only"] += 1
+
+        self.assertGreater(stats["arabic_only"], 0, "No Arabic-only words found")
+        self.assertGreater(stats["mixed"], 0, "No mixed Arabic/English words found")
+
+    def test_line_grouping_by_y_position(self):
+        words = self.page.find_all('word')[:50]
+        lines = {}
+        for word in words:
+            y = round(word.top)
+            lines.setdefault(y, []).append(word)
+        self.assertGreater(len(lines), 0, "No lines grouped by Y position")
+
+    def test_extraction_consistency(self):
+        text1 = self.page.extract_text()
+        text2 = self.page.extract_text()
+        self.assertEqual(text1, text2, "Text extraction is not consistent")
+
+    def test_bidi_token_order(self):
+        found_2022 = self.page.find_all('text:contains(2022)')
+        found_2202 = self.page.find_all('text:contains(2202)')
+        self.assertGreater(len(found_2022), 0, "Expected to find '2022', but found none")
+        self.assertEqual(len(found_2202), 0, "Found reversed '2202', possible BiDi error")
+        for w in found_2022:
+            print(f"  '2022' sample: '{w.text}' at ({w.x0:.1f}, {w.top:.1f})")
+        for w in found_2202:
+            print(f"  '2202' sample: '{w.text}' at ({w.x0:.1f}, {w.top:.1f})")
+
+
+if __name__ == "__main__":
+    unittest.main()