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

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

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

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

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

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

@@ -11,7 +11,7 @@ from .exceptions import (
     HttpClientException, SessionException
 )
 from .models import (
-    ObjectRef, Position, ObjectType, Font, Color, Image, BoundingRect, Paragraph, FormFieldRef,
+    ObjectRef, Position, ObjectType, Font, Color, Image, BoundingRect, Paragraph, FormFieldRef, TextObjectRef,
     PositionMode, ShapeType, Point, StandardFonts
 )
 from .paragraph_builder import ParagraphBuilder
@@ -29,6 +29,7 @@ __all__ = [
     "BoundingRect",
     "Paragraph",
     "FormFieldRef",
+    "TextObjectRef",
     "PositionMode",
     "ShapeType",
     "Point",

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

@@ -121,6 +121,7 @@ class Position:
     mode: Optional[PositionMode] = None
     bounding_rect: Optional[BoundingRect] = None
     text_starts_with: Optional[str] = None
+    text_pattern: Optional[str] = None
     name: Optional[str] = None
 
     @staticmethod
@@ -185,21 +186,6 @@ class Position:
         """Returns the Y coordinate of this position."""
         return self.bounding_rect.get_y() if self.bounding_rect else None
 
-    def copy(self) -> 'Position':
-        """Creates a copy of this position."""
-        # Create deep copy of bounding_rect if it exists
-        bounding_rect_copy = None
-        if self.bounding_rect:
-            bounding_rect_copy = BoundingRect(
-                self.bounding_rect.x,
-                self.bounding_rect.y,
-                self.bounding_rect.width,
-                self.bounding_rect.height
-            )
-
-        pos = Position(self.page_index, self.shape, self.mode, bounding_rect_copy, self.text_starts_with)
-        return pos
-
 
 @dataclass
 class ObjectRef:
@@ -325,7 +311,8 @@ class FindRequest:
         """Convert Position to dictionary for JSON serialization."""
         result = {
             "pageIndex": position.page_index,
-            "textStartsWith": position.text_starts_with
+            "textStartsWith": position.text_starts_with,
+            "textPattern": position.text_pattern
         }
         if position.name:
             result["name"] = position.name
@@ -419,7 +406,8 @@ class AddRequest:
                     text_element = {
                         "text": line,
                         "font": {"name": obj.font.name, "size": obj.font.size} if obj.font else None,
-                        "color": {"r": obj.color.r, "g": obj.color.g, "b": obj.color.b} if obj.color else None,
+                        "color": {"red": obj.color.r, "green": obj.color.g, "blue": obj.color.b,
+                                  "alpha": obj.color.a} if obj.color else None,
                         "position": FindRequest._position_to_dict(obj.position) if obj.position else None
                     }
                     text_line = {
@@ -427,7 +415,8 @@ class AddRequest:
                     }
                     # TextLine has color and position
                     if obj.color:
-                        text_line["color"] = {"r": obj.color.r, "g": obj.color.g, "b": obj.color.b}
+                        text_line["color"] = {"red": obj.color.r, "green": obj.color.g, "blue": obj.color.b,
+                                              "alpha": obj.color.a}
                     if obj.position:
                         text_line["position"] = FindRequest._position_to_dict(obj.position)
                     lines.append(text_line)
@@ -515,3 +504,46 @@ class FormFieldRef(ObjectRef):
     def get_value(self) -> Optional[str]:
         """Get the form field value."""
         return self.value
+
+
+class TextObjectRef(ObjectRef):
+    """
+    Represents a text object reference with additional text-specific properties.
+    Extends ObjectRef to include text content, font information, and hierarchical structure.
+    """
+
+    def __init__(self, internal_id: str, position: Position, object_type: ObjectType,
+                 text: Optional[str] = None, font_name: Optional[str] = None,
+                 font_size: Optional[float] = None, line_spacings: Optional[List[float]] = None,
+                 color: Optional[Color] = None):
+        super().__init__(internal_id, position, object_type)
+        self.text = text
+        self.font_name = font_name
+        self.font_size = font_size
+        self.line_spacings = line_spacings
+        self.color = color
+        self.children: List['TextObjectRef'] = []
+
+    def get_text(self) -> Optional[str]:
+        """Get the text content."""
+        return self.text
+
+    def get_font_name(self) -> Optional[str]:
+        """Get the font name."""
+        return self.font_name
+
+    def get_font_size(self) -> Optional[float]:
+        """Get the font size."""
+        return self.font_size
+
+    def get_line_spacings(self) -> Optional[List[float]]:
+        """Get the line spacings."""
+        return self.line_spacings
+
+    def get_color(self) -> Optional[Color]:
+        """Get the color."""
+        return self.color
+
+    def get_children(self) -> List['TextObjectRef']:
+        """Get the child text objects."""
+        return self.children

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

@@ -22,7 +22,7 @@ from .exceptions import (
 )
 from .image_builder import ImageBuilder
 from .models import (
-    ObjectRef, Position, ObjectType, Font, Image, Paragraph, FormFieldRef,
+    ObjectRef, Position, ObjectType, Font, Image, Paragraph, FormFieldRef, TextObjectRef,
     FindRequest, DeleteRequest, MoveRequest, AddRequest, ModifyRequest, ModifyTextRequest, ChangeFormFieldRequest,
     ShapeType, PositionMode
 )
@@ -52,6 +52,18 @@ class PageClient:
         # noinspection PyProtectedMember
         return self.root._to_paragraph_objects(self.root._find_paragraphs(position))
 
+    def select_paragraphs_matching(self, pattern):
+        position = Position.at_page(self.page_index)
+        position.text_pattern = pattern
+        # noinspection PyProtectedMember
+        return self.root._to_paragraph_objects(self.root._find_paragraphs(position))
+
+    def select_text_lines_matching(self, pattern: str) -> List[TextLineObject]:
+        position = Position.at_page(self.page_index)
+        position.text_pattern = pattern
+        # noinspection PyProtectedMember
+        return self.root._to_textline_objects(self.root._find_text_lines(position))
+
     def select_paragraphs_at(self, x: float, y: float) -> List[ParagraphObject]:
         position = Position.at_page_coordinates(self.page_index, x, y)
         # noinspection PyProtectedMember
@@ -68,6 +80,11 @@ class PageClient:
         # noinspection PyProtectedMember
         return self.root._to_textline_objects(self.root._find_text_lines(position))
 
+    def select_text_lines_at(self, x, y) -> List[TextLineObject]:
+        position = Position.at_page_coordinates(self.page_index, x, y)
+        # noinspection PyProtectedMember
+        return self.root._to_textline_objects(self.root._find_text_lines(position))
+
     def select_images(self) -> List[ImageObject]:
         # noinspection PyProtectedMember
         return self.root._to_image_objects(self.root._find_images(Position.at_page(self.page_index)))
@@ -149,6 +166,21 @@ class PDFDancer:
         Returns:
             A ready-to-use `PDFDancer` client instance.
         """
+        resolved_token = cls._resolve_token(token)
+        resolved_base_url = cls._resolve_base_url(base_url)
+
+        return PDFDancer(resolved_token, pdf_data, resolved_base_url, timeout)
+
+    @classmethod
+    def _resolve_base_url(cls, base_url: Optional[str]) -> Optional[str]:
+        env_base_url = os.getenv("PDFDANCER_BASE_URL")
+        resolved_base_url = base_url or (env_base_url.strip() if env_base_url and env_base_url.strip() else None)
+        if resolved_base_url is None:
+            resolved_base_url = "https://api.pdfdancer.com"
+        return resolved_base_url
+
+    @classmethod
+    def _resolve_token(cls, token: Optional[str]) -> Optional[str]:
         resolved_token = token.strip() if token and token.strip() else None
         if resolved_token is None:
             env_token = os.getenv("PDFDANCER_TOKEN")
@@ -159,13 +191,18 @@ class PDFDancer:
                 "Missing PDFDancer API token. Pass a token via the `token` argument "
                 "or set the PDFDANCER_TOKEN environment variable."
             )
+        return resolved_token
 
-        env_base_url = os.getenv("PDFDANCER_BASE_URL")
-        resolved_base_url = base_url or (env_base_url.strip() if env_base_url and env_base_url.strip() else None)
-        if resolved_base_url is None:
-            resolved_base_url = "https://api.pdfdancer.com"
+    @classmethod
+    def new(cls,
+            token: Optional[str] = None,
+            base_url: Optional[str] = None,
+            timeout: float = 30.0) -> "PDFDancer":
 
-        return PDFDancer(resolved_token, pdf_data, resolved_base_url, timeout)
+        resolved_token = cls._resolve_token(token)
+        resolved_base_url = cls._resolve_base_url(base_url)
+
+        raise Exception("Unsupported Operation Exception: TODO")
 
     def __init__(self, token: str, pdf_data: Union[bytes, Path, str, BinaryIO],
                  base_url: str, read_timeout: float = 0):
@@ -205,7 +242,8 @@ class PDFDancer:
         # Create session - equivalent to Java constructor behavior
         self._session_id = self._create_session()
 
-    def _process_pdf_data(self, pdf_data: Union[bytes, Path, str, BinaryIO]) -> bytes:
+    @staticmethod
+    def _process_pdf_data(pdf_data: Union[bytes, Path, str, BinaryIO]) -> bytes:
         """
         Process PDF data from various input types with strict validation.
         """
@@ -347,7 +385,7 @@ class PDFDancer:
                 timeout=self._read_timeout if self._read_timeout > 0 else None
             )
 
-            # Handle FontNotFoundException specifically like Java client
+            # Handle FontNotFoundException
             if response.status_code == 404:
                 try:
                     error_data = response.json()
@@ -366,8 +404,6 @@ class PDFDancer:
             raise HttpClientException(f"API request failed: {error_message}", response=getattr(e, 'response', None),
                                       cause=e) from None
 
-    # Search Operations - matching Java client exactly
-
     def _find(self, object_type: Optional[ObjectType] = None, position: Optional[Position] = None) -> List[ObjectRef]:
         """
         Searches for PDF objects matching the specified criteria.
@@ -388,17 +424,21 @@ class PDFDancer:
         objects_data = response.json()
         return [self._parse_object_ref(obj_data) for obj_data in objects_data]
 
-    def select_paragraphs(self) -> List[ParagraphObject]:
+    def select_paragraphs(self) -> List[TextObjectRef]:
         """
-        Searches for paragraph objects at the specified position.
+        Searches for paragraph objects returning TextObjectRef with hierarchical structure.
         """
-        return self._to_paragraph_objects(self._find(ObjectType.PARAGRAPH, None))
+        return self._find_paragraphs(None)
 
-    def _find_paragraphs(self, position: Optional[Position] = None) -> List[ObjectRef]:
+    def _find_paragraphs(self, position: Optional[Position] = None) -> List[TextObjectRef]:
         """
-        Searches for paragraph objects at the specified position.
+        Searches for paragraph objects returning TextObjectRef with hierarchical structure.
         """
-        return self._find(ObjectType.PARAGRAPH, position)
+        request_data = FindRequest(ObjectType.PARAGRAPH, position).to_dict()
+        response = self._make_request('POST', '/pdf/find', data=request_data)
+
+        objects_data = response.json()
+        return [self._parse_text_object_ref(obj_data) for obj_data in objects_data]
 
     def _find_images(self, position: Optional[Position] = None) -> List[ObjectRef]:
         """
@@ -471,17 +511,21 @@ class PDFDancer:
         """
         return self._find(ObjectType.PATH, position)
 
-    def _find_text_lines(self, position: Optional[Position] = None) -> List[ObjectRef]:
+    def _find_text_lines(self, position: Optional[Position] = None) -> List[TextObjectRef]:
         """
-        Searches for text line objects at the specified position.
+        Searches for text line objects returning TextObjectRef with hierarchical structure.
         """
-        return self._find(ObjectType.TEXT_LINE, position)
+        request_data = FindRequest(ObjectType.TEXT_LINE, position).to_dict()
+        response = self._make_request('POST', '/pdf/find', data=request_data)
+
+        objects_data = response.json()
+        return [self._parse_text_object_ref(obj_data) for obj_data in objects_data]
 
     def select_text_lines(self) -> List[TextLineObject]:
         """
-        Searches for text line objects at the specified position.
+        Searches for text line objects returning TextLineObject wrappers.
         """
-        return self._to_textline_objects(self._find(ObjectType.TEXT_LINE, None))
+        return self._to_textline_objects(self._find_text_lines(None))
 
     def page(self, page_index: int) -> PageClient:
         return PageClient(page_index, self)
@@ -835,7 +879,7 @@ class PDFDancer:
             type=object_type
         )
 
-    def _parse_form_field_ref(self, obj_data: dict) -> ObjectRef:
+    def _parse_form_field_ref(self, obj_data: dict) -> FormFieldRef:
         """Parse JSON object data into ObjectRef instance."""
         position_data = obj_data.get('position', {})
         position = self._parse_position(position_data) if position_data else None
@@ -874,6 +918,45 @@ class PDFDancer:
 
         return position
 
+    def _parse_text_object_ref(self, obj_data: dict, fallback_id: Optional[str] = None) -> TextObjectRef:
+        """Parse JSON object data into TextObjectRef instance with hierarchical structure."""
+        position_data = obj_data.get('position', {})
+        position = self._parse_position(position_data) if position_data else Position()
+
+        object_type = ObjectType(obj_data.get('type', 'TEXT_LINE'))
+        line_spacings = obj_data.get('lineSpacings') if isinstance(obj_data.get('lineSpacings'), list) else None
+        internal_id = obj_data.get('internalId', fallback_id or '')
+
+        color = None
+        color_data = obj_data.get('color')
+        if isinstance(color_data, dict):
+            from .models import Color
+            red = color_data.get('red')
+            green = color_data.get('green')
+            blue = color_data.get('blue')
+            alpha = color_data.get('alpha', 255)
+            if all(isinstance(v, int) for v in [red, green, blue]):
+                color = Color(red, green, blue, alpha)
+
+        text_object = TextObjectRef(
+            internal_id=internal_id,
+            position=position,
+            object_type=object_type,
+            text=obj_data.get('text') if isinstance(obj_data.get('text'), str) else None,
+            font_name=obj_data.get('fontName') if isinstance(obj_data.get('fontName'), str) else None,
+            font_size=obj_data.get('fontSize') if isinstance(obj_data.get('fontSize'), (int, float)) else None,
+            line_spacings=line_spacings,
+            color=color
+        )
+
+        if isinstance(obj_data.get('children'), list) and len(obj_data['children']) > 0:
+            text_object.children = [
+                self._parse_text_object_ref(child_data, f"{internal_id or 'child'}-{index}")
+                for index, child_data in enumerate(obj_data['children'])
+            ]
+
+        return text_object
+
     # Builder Pattern Support
 
     def _paragraph_builder(self) -> 'ParagraphBuilder':
@@ -892,30 +975,30 @@ class PDFDancer:
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         """Context manager exit - cleanup if needed."""
-        # Could add session cleanup here if API supports it
+        # TODO Could add session cleanup here if API supports it. Cleanup on the server
         pass
 
-    def _to_path_objects(self, path_refs: List[ObjectRef]) -> List[PathObject]:
-        return [PathObject(self, ref.internal_id, ref.type, ref.position) for ref in path_refs]
+    def _to_path_objects(self, refs: List[ObjectRef]) -> List[PathObject]:
+        return [PathObject(self, ref.internal_id, ref.type, ref.position) for ref in refs]
 
-    def _to_paragraph_objects(self, path_refs: List[ObjectRef]) -> List[ParagraphObject]:
-        return [ParagraphObject(self, ref.internal_id, ref.type, ref.position) for ref in path_refs]
+    def _to_paragraph_objects(self, refs: List[TextObjectRef]) -> List[ParagraphObject]:
+        return [ParagraphObject(self, ref) for ref in refs]
 
-    def _to_textline_objects(self, path_refs: List[ObjectRef]) -> List[TextLineObject]:
-        return [TextLineObject(self, ref.internal_id, ref.type, ref.position) for ref in path_refs]
+    def _to_textline_objects(self, refs: List[TextObjectRef]) -> List[TextLineObject]:
+        return [TextLineObject(self, ref) for ref in refs]
 
-    def _to_image_objects(self, path_refs: List[ObjectRef]) -> List[ImageObject]:
-        return [ImageObject(self, ref.internal_id, ref.type, ref.position) for ref in path_refs]
+    def _to_image_objects(self, refs: List[ObjectRef]) -> List[ImageObject]:
+        return [ImageObject(self, ref.internal_id, ref.type, ref.position) for ref in refs]
 
-    def _to_form_objects(self, path_refs: List[ObjectRef]) -> List[FormObject]:
-        return [FormObject(self, ref.internal_id, ref.type, ref.position) for ref in path_refs]
+    def _to_form_objects(self, refs: List[ObjectRef]) -> List[FormObject]:
+        return [FormObject(self, ref.internal_id, ref.type, ref.position) for ref in refs]
 
-    def _to_form_field_objects(self, path_refs: List[FormFieldRef]) -> List[FormFieldObject]:
+    def _to_form_field_objects(self, refs: List[FormFieldRef]) -> List[FormFieldObject]:
         return [FormFieldObject(self, ref.internal_id, ref.type, ref.position, ref.name, ref.value) for ref in
-                path_refs]
+                refs]
 
-    def _to_page_objects(self, path_refs: List[ObjectRef]) -> List[PageClient]:
-        return [PageClient.from_ref(self, ref) for ref in path_refs]
+    def _to_page_objects(self, refs: List[ObjectRef]) -> List[PageClient]:
+        return [PageClient.from_ref(self, ref) for ref in refs]
 
     def _to_page_object(self, ref: ObjectRef) -> PageClient:
         return PageClient.from_ref(self, ref)

{pdfdancer_client_python-0.2.10 → pdfdancer_client_python-0.2.12}/src/pdfdancer/types.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
+import statistics
 from dataclasses import dataclass
-from typing import Optional
+from typing import Optional, List
 
-from . import ObjectType, Position, ObjectRef, Point, Paragraph, Font, Color, FormFieldRef
+from . import ObjectType, Position, ObjectRef, Point, Paragraph, Font, Color, FormFieldRef, TextObjectRef
 
 
 @dataclass
@@ -66,16 +67,33 @@ class PathObject(PDFObjectBase):
         """Optional bounding rectangle (if available)."""
         return self.position.bounding_rect
 
+    def __eq__(self, other):
+        if not isinstance(other, PathObject):
+            return False
+        return (self.internal_id == other.internal_id and
+                self.object_type == other.object_type and
+                self.position == other.position)
+
 
 class ImageObject(PDFObjectBase):
-    pass
+    def __eq__(self, other):
+        if not isinstance(other, ImageObject):
+            return False
+        return (self.internal_id == other.internal_id and
+                self.object_type == other.object_type and
+                self.position == other.position)
 
 
 class FormObject(PDFObjectBase):
-    pass
+    def __eq__(self, other):
+        if not isinstance(other, FormObject):
+            return False
+        return (self.internal_id == other.internal_id and
+                self.object_type == other.object_type and
+                self.position == other.position)
 
 
-def _process_text_lines(text: str) -> list[str]:
+def _process_text_lines(text: str) -> List[str]:
     """
     Process text into lines for the paragraph.
     This is a simplified version - the full implementation would handle
@@ -171,21 +189,53 @@ class ParagraphEdit(BaseTextEdit):
             return self._target_obj._client._modify_paragraph(self._object_ref, self._new_text)
         else:
             new_paragraph = Paragraph(
-                position=self._position,
-                line_spacing=self._line_spacing if self._line_spacing is not None else DEFAULT_LINE_SPACING,
-                font=Font(name=self._font_name, size=self._font_size),
-                text_lines=_process_text_lines(self._new_text),
-                color=self._color if self._color is not None else DEFAULT_COLOR,
+                position=self._position if self._position is not None else self._object_ref.position,
+                line_spacing=self._get_line_spacing(),
+                font=self._get_font(),
+                text_lines=self._get_text_lines(),
+                color=self._get_color(),
             )
             # noinspection PyProtectedMember
             return self._target_obj._client._modify_paragraph(self._object_ref, new_paragraph)
 
+    def _get_line_spacing(self) -> float:
+        if self._line_spacing is not None:
+            return self._line_spacing
+        elif self._object_ref.line_spacings is not None:
+            return statistics.mean(self._object_ref.line_spacings)
+        else:
+            return DEFAULT_LINE_SPACING
+
+    def _get_font(self):
+        if self._font_name is not None and self._font_size is not None:
+            return Font(name=self._font_name, size=self._font_size)
+        elif self._object_ref.font_name is not None and self._object_ref.font_size is not None:
+            return Font(name=self._object_ref.font_name, size=self._object_ref.font_size)
+        else:
+            raise Exception("Font is none")
+
+    def _get_text_lines(self):
+        if self._new_text is not None:
+            return _process_text_lines(self._new_text)
+        elif self._object_ref.text is not None:
+            # TODO this actually messes up existing text line internals
+            return _process_text_lines(self._object_ref.text)
+        else:
+            raise Exception("Paragraph has no text")
+
+    def _get_color(self):
+        if self._color is not None:
+            return self._color
+        elif self._object_ref.color is not None:
+            return self._object_ref.color
+        else:
+            return DEFAULT_COLOR
+
 
 class TextLineEdit(BaseTextEdit):
     def apply(self) -> bool:
         if (
-                self._position is None
-                and self._line_spacing is None
+                self._line_spacing is None
                 and self._font_size is None
                 and self._font_name is None
                 and self._color is None
@@ -199,16 +249,56 @@ class TextLineEdit(BaseTextEdit):
 class ParagraphObject(PDFObjectBase):
     """Represents a paragraph text block inside a PDF page."""
 
+    def __init__(self, client: 'PDFDancer', object_ref: TextObjectRef):
+        super().__init__(client, object_ref.internal_id, object_ref.type, object_ref.position)
+        self._object_ref = object_ref
+
     def edit(self) -> ParagraphEdit:
         return ParagraphEdit(self, self.object_ref())
 
+    def object_ref(self) -> TextObjectRef:
+        return self._object_ref
+
+    def __eq__(self, other):
+        if not isinstance(other, ParagraphObject):
+            return False
+        return (self.internal_id == other.internal_id and
+                self.object_type == other.object_type and
+                self.position == other.position and
+                self._object_ref.text == other._object_ref.text and
+                self._object_ref.font_name == other._object_ref.font_name and
+                self._object_ref.font_size == other._object_ref.font_size and
+                self._object_ref.line_spacings == other._object_ref.line_spacings and
+                self._object_ref.color == other._object_ref.color and
+                self._object_ref.children == other._object_ref.children)
+
 
 class TextLineObject(PDFObjectBase):
     """Represents a single line of text inside a PDF page."""
 
+    def __init__(self, client: 'PDFDancer', object_ref: TextObjectRef):
+        super().__init__(client, object_ref.internal_id, object_ref.type, object_ref.position)
+        self._object_ref = object_ref
+
     def edit(self) -> TextLineEdit:
         return TextLineEdit(self, self.object_ref())
 
+    def object_ref(self) -> TextObjectRef:
+        return self._object_ref
+
+    def __eq__(self, other):
+        if not isinstance(other, TextLineObject):
+            return False
+        return (self.internal_id == other.internal_id and
+                self.object_type == other.object_type and
+                self.position == other.position and
+                self._object_ref.text == other._object_ref.text and
+                self._object_ref.font_name == other._object_ref.font_name and
+                self._object_ref.font_size == other._object_ref.font_size and
+                self._object_ref.line_spacings == other._object_ref.line_spacings and
+                self._object_ref.color == other._object_ref.color and
+                self._object_ref.children == other._object_ref.children)
+
 
 class FormFieldEdit:
     def __init__(self, form_field: 'FormFieldObject', object_ref: FormFieldRef):
@@ -239,3 +329,12 @@ class FormFieldObject(PDFObjectBase):
         ref.name = self.name
         ref.value = self.value
         return ref
+
+    def __eq__(self, other):
+        if not isinstance(other, FormFieldObject):
+            return False
+        return (self.internal_id == other.internal_id and
+                self.object_type == other.object_type and
+                self.position == other.position and
+                self.name == other.name and
+                self.value == other.value)

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

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

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

@@ -23,8 +23,10 @@ tests/__init__.py
 tests/conftest.py
 tests/test_models.py
 tests/test_openapi_compliance.py
+tests/test_pdf_object_equality.py
 tests/test_standard_fonts.py
 tests/e2e/__init__.py
+tests/e2e/pdf_assertions.py
 tests/e2e/test_acroform.py
 tests/e2e/test_form_x_objects.py
 tests/e2e/test_image.py
@@ -34,6 +36,7 @@ tests/e2e/test_paragraph.py
 tests/e2e/test_path.py
 tests/e2e/test_pdfdancer.py
 tests/fixtures/DancingScript-Regular.ttf
+tests/fixtures/Empty.pdf
 tests/fixtures/JetBrainsMono-Regular.ttf
 tests/fixtures/ObviouslyAwesome.pdf
 tests/fixtures/basic-paths.pdf

{pdfdancer_client_python-0.2.10 → pdfdancer_client_python-0.2.12}/tests/e2e/__init__.py

@@ -34,13 +34,18 @@ def _server_up(base_url: str) -> bool:
 
 
 def _require_env_and_fixture(pdf_filename: str) -> tuple[str, str, Path]:
+    base_url, token = _require_env()
+    pdf_path = Path(__file__).resolve().parent.parent / 'fixtures' / pdf_filename
+    if not pdf_path.exists():
+        pytest.fail(f"{pdf_filename} fixture not found")
+    return base_url, token, pdf_path
+
+
+def _require_env() -> tuple[str, str | None]:
     base_url = _get_base_url()
     token = _read_token()
     if not _server_up(base_url):
         pytest.fail(f"PDFDancer server not reachable at {base_url}; set PDFDANCER_BASE_URL or start server")
     if not token:
         pytest.fail("PDFDANCER_TOKEN not set and no token file found; set env or place jwt-token-*.txt in repo")
-    pdf_path = Path(__file__).resolve().parent.parent / 'fixtures' / pdf_filename
-    if not pdf_path.exists():
-        pytest.fail(f"{pdf_filename} fixture not found")
-    return base_url, token, pdf_path
+    return base_url, token