pdfdancer-client-python 0.2.8__tar.gz → 0.2.10__tar.gz

{pdfdancer_client_python-0.2.8/src/pdfdancer_client_python.egg-info → pdfdancer_client_python-0.2.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pdfdancer-client-python
-Version: 0.2.8
+Version: 0.2.10
 Summary: Python client for PDFDancer API
 Author-email: "The Famous Cat Ltd." <hi@thefamouscat.com>
 License: MIT

{pdfdancer_client_python-0.2.8 → pdfdancer_client_python-0.2.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pdfdancer-client-python"
-version = "0.2.8"
+version = "0.2.10"
 description = "Python client for PDFDancer API"
 readme = "README.md"
 authors = [

{pdfdancer_client_python-0.2.8 → pdfdancer_client_python-0.2.10}/src/pdfdancer/__init__.py

@@ -12,7 +12,7 @@ from .exceptions import (
 )
 from .models import (
     ObjectRef, Position, ObjectType, Font, Color, Image, BoundingRect, Paragraph, FormFieldRef,
-    PositionMode, ShapeType, Point
+    PositionMode, ShapeType, Point, StandardFonts
 )
 from .paragraph_builder import ParagraphBuilder
 
@@ -32,6 +32,7 @@ __all__ = [
     "PositionMode",
     "ShapeType",
     "Point",
+    "StandardFonts",
     "PdfDancerException",
     "FontNotFoundException",
     "ValidationException",

{pdfdancer_client_python-0.2.8 → pdfdancer_client_python-0.2.10}/src/pdfdancer/models.py

@@ -8,6 +8,49 @@ from enum import Enum
 from typing import Optional, List, Any
 
 
+class StandardFonts(Enum):
+    """
+    The 14 standard PDF fonts that are guaranteed to be available in all PDF readers.
+    These fonts do not need to be embedded in the PDF document.
+
+    Serif fonts (Times family):
+    - TIMES_ROMAN: Standard Times Roman font
+    - TIMES_BOLD: Bold version of Times Roman
+    - TIMES_ITALIC: Italic version of Times Roman
+    - TIMES_BOLD_ITALIC: Bold and italic version of Times Roman
+
+    Sans-serif fonts (Helvetica family):
+    - HELVETICA: Standard Helvetica font
+    - HELVETICA_BOLD: Bold version of Helvetica
+    - HELVETICA_OBLIQUE: Oblique (italic) version of Helvetica
+    - HELVETICA_BOLD_OBLIQUE: Bold and oblique version of Helvetica
+
+    Monospace fonts (Courier family):
+    - COURIER: Standard Courier font
+    - COURIER_BOLD: Bold version of Courier
+    - COURIER_OBLIQUE: Oblique (italic) version of Courier
+    - COURIER_BOLD_OBLIQUE: Bold and oblique version of Courier
+
+    Symbol and decorative fonts:
+    - SYMBOL: Symbol font for mathematical and special characters
+    - ZAPF_DINGBATS: Zapf Dingbats font for decorative symbols
+    """
+    TIMES_ROMAN = "Times-Roman"
+    TIMES_BOLD = "Times-Bold"
+    TIMES_ITALIC = "Times-Italic"
+    TIMES_BOLD_ITALIC = "Times-BoldItalic"
+    HELVETICA = "Helvetica"
+    HELVETICA_BOLD = "Helvetica-Bold"
+    HELVETICA_OBLIQUE = "Helvetica-Oblique"
+    HELVETICA_BOLD_OBLIQUE = "Helvetica-BoldOblique"
+    COURIER = "Courier"
+    COURIER_BOLD = "Courier-Bold"
+    COURIER_OBLIQUE = "Courier-Oblique"
+    COURIER_BOLD_OBLIQUE = "Courier-BoldOblique"
+    SYMBOL = "Symbol"
+    ZAPF_DINGBATS = "ZapfDingbats"
+
+
 class ObjectType(Enum):
     """Object type enumeration matching the Java ObjectType."""
     FORM_FIELD = "FORM_FIELD"

{pdfdancer_client_python-0.2.8 → pdfdancer_client_python-0.2.10}/src/pdfdancer/paragraph_builder.py

@@ -268,3 +268,14 @@ class ParagraphBuilder:
 
     def add(self):
         self._client._add_paragraph(self.build())
+
+
+class ParagraphPageBuilder(ParagraphBuilder):
+
+    def __init__(self, client: 'PDFDancer', page_index: int):
+        super().__init__(client)
+        self._page_index: Optional[int] = page_index
+
+    # noinspection PyMethodOverriding
+    def at(self, x: float, y: float) -> 'ParagraphBuilder':
+        return super().at(self._page_index, x, y)

{pdfdancer_client_python-0.2.8 → pdfdancer_client_python-0.2.10}/src/pdfdancer/pdfdancer_v1.py

@@ -26,6 +26,7 @@ from .models import (
     FindRequest, DeleteRequest, MoveRequest, AddRequest, ModifyRequest, ModifyTextRequest, ChangeFormFieldRequest,
     ShapeType, PositionMode
 )
+from .paragraph_builder import ParagraphPageBuilder
 from .types import PathObject, ParagraphObject, TextLineObject, ImageObject, FormObject, FormFieldObject
 
 
@@ -114,6 +115,9 @@ class PageClient:
     def _ref(self):
         return ObjectRef(internal_id=self.internal_id, position=self.position, type=self.object_type)
 
+    def new_paragraph(self):
+        return ParagraphPageBuilder(self.root, self.page_index)
+
 
 class PDFDancer:
     """

{pdfdancer_client_python-0.2.8 → pdfdancer_client_python-0.2.10/src/pdfdancer_client_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pdfdancer-client-python
-Version: 0.2.8
+Version: 0.2.10
 Summary: Python client for PDFDancer API
 Author-email: "The Famous Cat Ltd." <hi@thefamouscat.com>
 License: MIT

{pdfdancer_client_python-0.2.8 → pdfdancer_client_python-0.2.10}/src/pdfdancer_client_python.egg-info/SOURCES.txt

@@ -21,9 +21,9 @@ src/pdfdancer_client_python.egg-info/requires.txt
 src/pdfdancer_client_python.egg-info/top_level.txt
 tests/__init__.py
 tests/conftest.py
-tests/test_authentication.py
 tests/test_models.py
 tests/test_openapi_compliance.py
+tests/test_standard_fonts.py
 tests/e2e/__init__.py
 tests/e2e/test_acroform.py
 tests/e2e/test_form_x_objects.py

{pdfdancer_client_python-0.2.8 → pdfdancer_client_python-0.2.10}/tests/e2e/test_paragraph.py

@@ -1,6 +1,6 @@
 import pytest
 
-from pdfdancer import Color
+from pdfdancer import Color, StandardFonts
 from pdfdancer.pdfdancer_v1 import PDFDancer
 from tests.e2e import _require_env_and_fixture
 
@@ -116,6 +116,19 @@ def test_add_paragraph_with_custom_font1_1():
         _assert_new_paragraph_exists(pdf)
 
 
+def test_add_paragraph_on_page_with_custom_font1_1():
+    base_url, token, pdf_path = _require_env_and_fixture("ObviouslyAwesome.pdf")
+
+    with PDFDancer.open(pdf_path, token=token, base_url=base_url, timeout=30.0) as pdf:
+        pdf.page(0).new_paragraph() \
+            .text("Awesomely\nObvious!") \
+            .font("Roboto-Regular", 14) \
+            .line_spacing(0.7) \
+            .at(300.1, 500) \
+            .add()
+        _assert_new_paragraph_exists(pdf)
+
+
 def test_add_paragraph_with_custom_font1_2():
     base_url, token, pdf_path = _require_env_and_fixture("ObviouslyAwesome.pdf")
 
@@ -167,3 +180,48 @@ def test_add_paragraph_with_custom_font3():
             .at(0, 300.1, 500) \
             .add()
         _assert_new_paragraph_exists(pdf)
+
+
+def test_add_paragraph_with_standard_font_helvetica():
+    base_url, token, pdf_path = _require_env_and_fixture("ObviouslyAwesome.pdf")
+
+    with PDFDancer.open(pdf_path, token=token, base_url=base_url, timeout=30.0) as pdf:
+        pdf.new_paragraph() \
+            .text("Standard Font Test\nHelvetica Bold") \
+            .font(StandardFonts.HELVETICA_BOLD.value, 16) \
+            .line_spacing(1.2) \
+            .color(Color(255, 0, 0)) \
+            .at(0, 100, 100) \
+            .add()
+
+        lines = pdf.page(0).select_text_lines_starting_with("Standard Font Test")
+        assert len(lines) >= 1
+
+
+def test_add_paragraph_with_standard_font_times():
+    base_url, token, pdf_path = _require_env_and_fixture("ObviouslyAwesome.pdf")
+
+    with PDFDancer.open(pdf_path, token=token, base_url=base_url, timeout=30.0) as pdf:
+        pdf.new_paragraph() \
+            .text("Times Roman Test") \
+            .font(StandardFonts.TIMES_ROMAN.value, 14) \
+            .at(0, 150, 150) \
+            .add()
+
+        lines = pdf.page(0).select_text_lines_starting_with("Times Roman Test")
+        assert len(lines) >= 1
+
+
+def test_add_paragraph_with_standard_font_courier():
+    base_url, token, pdf_path = _require_env_and_fixture("ObviouslyAwesome.pdf")
+
+    with PDFDancer.open(pdf_path, token=token, base_url=base_url, timeout=30.0) as pdf:
+        pdf.new_paragraph() \
+            .text("Courier Monospace\nCode Example") \
+            .font(StandardFonts.COURIER_BOLD.value, 12) \
+            .line_spacing(1.5) \
+            .at(0, 200, 200) \
+            .add()
+
+        lines = pdf.page(0).select_text_lines_starting_with("Courier Monospace")
+        assert len(lines) >= 1

{pdfdancer_client_python-0.2.8 → pdfdancer_client_python-0.2.10}/tests/e2e/test_pdfdancer.py

@@ -2,7 +2,7 @@ import os
 
 import pytest
 
-from e2e import _require_env_and_fixture
+from tests.e2e import _require_env_and_fixture
 from pdfdancer import PDFDancer, ValidationException, HttpClientException
 
 

pdfdancer_client_python-0.2.10/tests/test_standard_fonts.py

@@ -0,0 +1,164 @@
+"""
+Tests for StandardFonts enum - validates all 14 standard PDF fonts.
+"""
+
+import pytest
+
+from pdfdancer import StandardFonts
+
+
+class TestStandardFonts:
+    """Test StandardFonts enum functionality."""
+
+    def test_enum_has_14_fonts(self):
+        """Test that StandardFonts enum contains exactly 14 standard PDF fonts."""
+        assert len(StandardFonts) == 14
+
+    def test_times_family_fonts(self):
+        """Test Times family fonts (4 variants)."""
+        assert StandardFonts.TIMES_ROMAN.value == "Times-Roman"
+        assert StandardFonts.TIMES_BOLD.value == "Times-Bold"
+        assert StandardFonts.TIMES_ITALIC.value == "Times-Italic"
+        assert StandardFonts.TIMES_BOLD_ITALIC.value == "Times-BoldItalic"
+
+    def test_helvetica_family_fonts(self):
+        """Test Helvetica family fonts (4 variants)."""
+        assert StandardFonts.HELVETICA.value == "Helvetica"
+        assert StandardFonts.HELVETICA_BOLD.value == "Helvetica-Bold"
+        assert StandardFonts.HELVETICA_OBLIQUE.value == "Helvetica-Oblique"
+        assert StandardFonts.HELVETICA_BOLD_OBLIQUE.value == "Helvetica-BoldOblique"
+
+    def test_courier_family_fonts(self):
+        """Test Courier family fonts (4 variants)."""
+        assert StandardFonts.COURIER.value == "Courier"
+        assert StandardFonts.COURIER_BOLD.value == "Courier-Bold"
+        assert StandardFonts.COURIER_OBLIQUE.value == "Courier-Oblique"
+        assert StandardFonts.COURIER_BOLD_OBLIQUE.value == "Courier-BoldOblique"
+
+    def test_symbol_fonts(self):
+        """Test Symbol and ZapfDingbats fonts."""
+        assert StandardFonts.SYMBOL.value == "Symbol"
+        assert StandardFonts.ZAPF_DINGBATS.value == "ZapfDingbats"
+
+    def test_all_font_names_are_unique(self):
+        """Test that all font names are unique."""
+        font_values = [font.value for font in StandardFonts]
+        assert len(font_values) == len(set(font_values))
+
+    def test_all_font_enum_names_are_unique(self):
+        """Test that all enum names are unique."""
+        font_names = [font.name for font in StandardFonts]
+        assert len(font_names) == len(set(font_names))
+
+    def test_enum_access_by_name(self):
+        """Test accessing fonts by enum name."""
+        assert StandardFonts.TIMES_ROMAN == StandardFonts["TIMES_ROMAN"]
+        assert StandardFonts.HELVETICA == StandardFonts["HELVETICA"]
+        assert StandardFonts.COURIER == StandardFonts["COURIER"]
+
+    def test_enum_access_by_value(self):
+        """Test accessing fonts by their string value."""
+        assert StandardFonts("Times-Roman") == StandardFonts.TIMES_ROMAN
+        assert StandardFonts("Helvetica") == StandardFonts.HELVETICA
+        assert StandardFonts("Courier") == StandardFonts.COURIER
+
+    def test_font_name_format_follows_pdf_spec(self):
+        """Test that font names follow PDF specification format."""
+        # Verify specific font name formats according to PDF spec
+        assert StandardFonts.ZAPF_DINGBATS.value == "ZapfDingbats"
+        assert StandardFonts.SYMBOL.value == "Symbol"
+
+        # Base fonts (no modifiers)
+        assert StandardFonts.HELVETICA.value == "Helvetica"
+        assert StandardFonts.COURIER.value == "Courier"
+        assert StandardFonts.TIMES_ROMAN.value == "Times-Roman"
+
+        # Modified fonts should have hyphens
+        modified_fonts = [
+            f for f in StandardFonts
+            if f not in [StandardFonts.HELVETICA, StandardFonts.COURIER,
+                         StandardFonts.SYMBOL, StandardFonts.ZAPF_DINGBATS]
+        ]
+        for font in modified_fonts:
+            assert "-" in font.value
+
+    def test_iteration_over_fonts(self):
+        """Test that we can iterate over all fonts."""
+        font_list = list(StandardFonts)
+        assert len(font_list) == 14
+        assert StandardFonts.TIMES_ROMAN in font_list
+        assert StandardFonts.HELVETICA in font_list
+        assert StandardFonts.COURIER in font_list
+        assert StandardFonts.SYMBOL in font_list
+        assert StandardFonts.ZAPF_DINGBATS in font_list
+
+    def test_font_enum_is_immutable(self):
+        """Test that font enum values cannot be modified."""
+        with pytest.raises(AttributeError):
+            StandardFonts.TIMES_ROMAN = "NewValue"
+
+    def test_times_family_count(self):
+        """Test that Times family has exactly 4 variants."""
+        times_fonts = [f for f in StandardFonts if f.value.startswith("Times")]
+        assert len(times_fonts) == 4
+
+    def test_helvetica_family_count(self):
+        """Test that Helvetica family has exactly 4 variants."""
+        helvetica_fonts = [f for f in StandardFonts if f.value.startswith("Helvetica")]
+        assert len(helvetica_fonts) == 4
+
+    def test_courier_family_count(self):
+        """Test that Courier family has exactly 4 variants."""
+        courier_fonts = [f for f in StandardFonts if f.value.startswith("Courier")]
+        assert len(courier_fonts) == 4
+
+    def test_symbol_family_count(self):
+        """Test that there are exactly 2 symbol fonts."""
+        symbol_fonts = [f for f in StandardFonts if f in [StandardFonts.SYMBOL, StandardFonts.ZAPF_DINGBATS]]
+        assert len(symbol_fonts) == 2
+
+    def test_font_value_string_representation(self):
+        """Test that font values are properly formatted strings."""
+        for font in StandardFonts:
+            assert isinstance(font.value, str)
+            assert len(font.value) > 0
+            # Font names should not contain spaces
+            assert " " not in font.value
+
+    def test_all_fonts_accessible(self):
+        """Test that all 14 fonts are accessible by their enum names."""
+        fonts = [
+            StandardFonts.TIMES_ROMAN,
+            StandardFonts.TIMES_BOLD,
+            StandardFonts.TIMES_ITALIC,
+            StandardFonts.TIMES_BOLD_ITALIC,
+            StandardFonts.HELVETICA,
+            StandardFonts.HELVETICA_BOLD,
+            StandardFonts.HELVETICA_OBLIQUE,
+            StandardFonts.HELVETICA_BOLD_OBLIQUE,
+            StandardFonts.COURIER,
+            StandardFonts.COURIER_BOLD,
+            StandardFonts.COURIER_OBLIQUE,
+            StandardFonts.COURIER_BOLD_OBLIQUE,
+            StandardFonts.SYMBOL,
+            StandardFonts.ZAPF_DINGBATS,
+        ]
+        assert len(fonts) == 14
+        assert len(set(fonts)) == 14  # All unique
+
+    def test_invalid_font_value_raises_error(self):
+        """Test that accessing an invalid font value raises ValueError."""
+        with pytest.raises(ValueError):
+            StandardFonts("InvalidFont")
+
+    def test_invalid_font_name_raises_error(self):
+        """Test that accessing an invalid font name raises KeyError."""
+        with pytest.raises(KeyError):
+            StandardFonts["INVALID_FONT"]
+
+    def test_font_comparison(self):
+        """Test that font comparison works correctly."""
+        assert StandardFonts.TIMES_ROMAN == StandardFonts.TIMES_ROMAN
+        assert StandardFonts.TIMES_ROMAN != StandardFonts.TIMES_BOLD
+        assert StandardFonts.HELVETICA == StandardFonts.HELVETICA
+        assert StandardFonts.COURIER != StandardFonts.TIMES_ROMAN

pdfdancer_client_python-0.2.8/tests/test_authentication.py

@@ -1,36 +0,0 @@
-import requests
-import pytest
-
-from pdfdancer import ValidationException
-from pdfdancer.pdfdancer_v1 import PDFDancer
-
-
-def test_open_without_token_reports_actionable_message():
-    with pytest.raises(ValidationException) as exc_info:
-        PDFDancer.open(pdf_data=b"%PDF", token="")
-
-    message = str(exc_info.value)
-    assert "Missing PDFDancer API token" in message
-    assert "PDFDANCER_TOKEN" in message
-
-
-def test_create_session_unauthorized_reports_guidance(monkeypatch):
-    class FakeResponse:
-        status_code = 401
-        text = "Unauthorized"
-
-        def json(self):
-            return {"message": "Unauthorized"}
-
-    def fake_post(self, *args, **kwargs):
-        return FakeResponse()
-
-    monkeypatch.setattr(requests.Session, "post", fake_post)
-
-    with pytest.raises(ValidationException) as exc_info:
-        PDFDancer(token="bad-token", pdf_data=b"%PDF", base_url="https://api.example.com")
-
-    message = str(exc_info.value)
-    assert "Authentication with the PDFDancer API failed" in message
-    assert "Server response: Unauthorized" in message
-    assert "PDFDANCER_TOKEN" in message