retab 0.0.36__py3-none-any.whl → 0.0.38__py3-none-any.whl

{uiform → retab}/types/mime.py

@@ -58,7 +58,7 @@ class TextBox(BaseModel):
     vertices: tuple[Point, Point, Point, Point] = Field(description="(top-left, top-right, bottom-right, bottom-left)")
     text: str
 
-    @field_validator('width', 'height')
+    @field_validator("width", "height")
     @classmethod
     def check_positive_dimensions(cls, v: int) -> int:
         if not isinstance(v, int) or v <= 0:
@@ -76,7 +76,7 @@ class Page(BaseModel):
     tokens: list[TextBox]
     transforms: list[Matrix] = Field(default=[], description="Transformation matrices applied to the original document image")
 
-    @field_validator('width', 'height')
+    @field_validator("width", "height")
     @classmethod
     def check_positive_dimensions(cls, v: int) -> int:
         if not isinstance(v, int) or v <= 0:
@@ -98,21 +98,21 @@ class MIMEData(BaseModel):
 
     @property
     def extension(self) -> str:
-        return self.filename.split('.')[-1].lower()
+        return self.filename.split(".")[-1].lower()
 
     @property
     def content(self) -> str:
-        if self.url.startswith('data:'):
+        if self.url.startswith("data:"):
             # Extract base64 content from data URL
-            base64_content = self.url.split(',')[1]
+            base64_content = self.url.split(",")[1]
             return base64_content
         else:
             raise ValueError("Content is not available for this file")
 
     @property
     def mime_type(self) -> str:
-        if self.url.startswith('data:'):
-            return self.url.split(';')[0].split(':')[1]
+        if self.url.startswith("data:"):
+            return self.url.split(";")[0].split(":")[1]
         else:
             return mimetypes.guess_type(self.filename)[0] or "application/octet-stream"
 
@@ -126,7 +126,7 @@ class MIMEData(BaseModel):
         return len(base64.b64decode(self.content))
 
     def __str__(self) -> str:
-        truncated_url = self.url[:50] + '...' if len(self.url) > 50 else self.url
+        truncated_url = self.url[:50] + "..." if len(self.url) > 50 else self.url
         # truncated_content = self.content[:50] + '...' if len(self.content) > 50 else self.content
         return f"MIMEData(filename='{self.filename}', url='{truncated_url}', mime_type='{self.mime_type}', size='{self.size}', extension='{self.extension}')"
 
@@ -136,34 +136,36 @@ class MIMEData(BaseModel):
 
 class BaseMIMEData(MIMEData):
     @classmethod
-    def model_validate(cls, obj: Any, *, strict: bool | None = None, from_attributes: bool | None = None, context: Any | None = None) -> Self:
+    def model_validate(
+        cls, obj: Any, *, strict: bool | None = None, from_attributes: bool | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None
+    ) -> Self:
         if isinstance(obj, MIMEData):
             # Convert MIMEData instance to dict
             obj = obj.model_dump()
-        if isinstance(obj, dict) and 'url' in obj:
+        if isinstance(obj, dict) and "url" in obj:
             # Truncate URL to 1000 chars or less, ensuring it's a valid base64 string
-            if len(obj['url']) > 1000:
+            if len(obj["url"]) > 1000:
                 # Find the position of the base64 data
-                if ',' in obj['url']:
-                    prefix, base64_data = obj['url'].split(',', 1)
+                if "," in obj["url"]:
+                    prefix, base64_data = obj["url"].split(",", 1)
                     # Calculate how many characters we can keep (must be a multiple of 4)
                     max_base64_len = 1000 - len(prefix) - 1  # -1 for the comma
                     # Ensure the length is a multiple of 4
                     max_base64_len = max_base64_len - (max_base64_len % 4)
                     # Truncate and reassemble
-                    obj['url'] = prefix + ',' + base64_data[:max_base64_len]
+                    obj["url"] = prefix + "," + base64_data[:max_base64_len]
                 else:
                     # If there's no comma (unexpected format), truncate to 996 chars (multiple of 4)
-                    obj['url'] = obj['url'][:996]
-        return super().model_validate(obj, strict=strict, from_attributes=from_attributes, context=context)
+                    obj["url"] = obj["url"][:996]
+        return super().model_validate(obj, strict=strict, from_attributes=from_attributes, context=context, by_alias=by_alias, by_name=by_name)
 
     @property
     def id(self) -> str:
         raise NotImplementedError("id is not implemented for BaseMIMEData - id is the hash of the content, so it's not possible to generate it from the base class")
 
     def __str__(self) -> str:
-        truncated_url = self.url[:50] + '...' if len(self.url) > 50 else self.url
-        truncated_content = self.content[:50] + '...' if len(self.content) > 50 else self.content
+        truncated_url = self.url[:50] + "..." if len(self.url) > 50 else self.url
+        truncated_content = self.content[:50] + "..." if len(self.content) > 50 else self.content
         return f"BaseMIMEData(filename='{self.filename}', url='{truncated_url}', content='{truncated_content}', mime_type='{self.mime_type}', extension='{self.extension}')"
 
     def __repr__(self) -> str:
@@ -227,7 +229,7 @@ class BaseEmailData(BaseModel):
 
     @property
     def unique_filename(self) -> str:
-        cleaned_id = re.sub(r'[\s<>]', '', self.id)
+        cleaned_id = re.sub(r"[\s<>]", "", self.id)
         return f"{cleaned_id}.eml"
 
     def __repr__(self) -> str:
@@ -235,7 +237,7 @@ class BaseEmailData(BaseModel):
         attachment_count = len(self.attachments)
 
         subject_preview = self.subject
-        body_preview = self.body_plain[:5000] + '...' if self.body_plain and len(self.body_plain) > 5000 else self.body_plain
+        body_preview = self.body_plain[:5000] + "..." if self.body_plain and len(self.body_plain) > 5000 else self.body_plain
 
         return (
             f"BaseEmailData("

{uiform → retab}/types/modalities.py

@@ -4,16 +4,16 @@ BaseModality = Literal["text", "image"]  # "video" , "audio"
 Modality = Literal[BaseModality, "native", "image+text"]
 TYPE_FAMILIES = Literal["excel", "word", "powerpoint", "pdf", "image", "text", "email", "audio", "html", "web"]
 NativeModalities: dict[TYPE_FAMILIES, Modality] = {
-    'excel': 'image',
-    'word': 'image',
-    'html': 'text',
-    'powerpoint': 'image',
-    'pdf': 'image',
-    'image': 'image',
-    'web': 'image',
-    'text': 'text',
-    'email': 'native',
-    'audio': 'text',
+    "excel": "image",
+    "word": "image",
+    "html": "text",
+    "powerpoint": "image",
+    "pdf": "image",
+    "image": "image",
+    "web": "image",
+    "text": "text",
+    "email": "native",
+    "audio": "text",
 }
 
 EXCEL_TYPES = Literal[".xls", ".xlsx", ".ods"]

retab/types/predictions.py

@@ -0,0 +1,19 @@
+import datetime
+from typing import Any, Optional
+from pydantic import BaseModel, Field
+from .ai_models import Amount
+
+
+class PredictionMetadata(BaseModel):
+    extraction_id: Optional[str] = Field(default=None, description="The ID of the extraction")
+    likelihoods: Optional[dict[str, Any]] = Field(default=None, description="The likelihoods of the extraction")
+    field_locations: Optional[dict[str, Any]] = Field(default=None, description="The field locations of the extraction")
+    agentic_field_locations: Optional[dict[str, Any]] = Field(default=None, description="The field locations of the extraction extracted by an llm")
+    consensus_details: Optional[list[dict[str, Any]]] = Field(default=None, description="The consensus details of the extraction")
+    api_cost: Optional[Amount] = Field(default=None, description="The cost of the API call for this document (if any -- ground truth for example)")
+
+
+class PredictionData(BaseModel):
+    prediction: dict[str, Any] = Field(default={}, description="The result of the extraction or manual annotation")
+    metadata: Optional[PredictionMetadata] = Field(default=None, description="The metadata of the prediction")
+    updated_at: Optional[datetime.datetime] = Field(default=None, description="The creation date of the prediction")

{uiform → retab}/types/schemas/enhance.py

@@ -1,9 +1,11 @@
-from typing import Any, Self, TypedDict, Literal
+from typing import Any, Self, TypedDict
+
 from openai.types.chat.chat_completion_reasoning_effort import ChatCompletionReasoningEffort
 from pydantic import BaseModel, Field, model_validator
 
 from ..mime import MIMEData
 from ..modalities import Modality
+from ..browser_canvas import BrowserCanvas
 
 
 class EnhanceSchemaConfig(BaseModel):
@@ -40,7 +42,7 @@ class EnhanceSchemaRequest(BaseModel):
     """The modality of the document to load."""
 
     image_resolution_dpi: int = 96
-    browser_canvas: Literal['A3', 'A4', 'A5'] = 'A4'
+    browser_canvas: BrowserCanvas = "A4"
     """The image operations to apply to the document."""
 
     stream: bool = False

{uiform → retab}/types/schemas/evaluate.py

@@ -1,9 +1,12 @@
+from typing import Any, Self
+
+from openai.types.chat.chat_completion_reasoning_effort import ChatCompletionReasoningEffort
 from pydantic import BaseModel, Field, model_validator
-from typing import Any, Literal, Self
+
+from ..evals import ItemMetric
 from ..mime import MIMEData
 from ..modalities import Modality
-from openai.types.chat.chat_completion_reasoning_effort import ChatCompletionReasoningEffort
-from ..evals import ItemMetric
+from ..browser_canvas import BrowserCanvas
 
 
 class EvaluateSchemaRequest(BaseModel):
@@ -21,7 +24,7 @@ class EvaluateSchemaRequest(BaseModel):
     reasoning_effort: ChatCompletionReasoningEffort = "medium"
     modality: Modality
     image_resolution_dpi: int = Field(default=96, description="Resolution of the image sent to the LLM")
-    browser_canvas: Literal["A3", "A4", "A5"] = Field(
+    browser_canvas: BrowserCanvas = Field(
         default="A4", description="Sets the size of the browser canvas for rendering documents in browser-based processing. Choose a size that matches the document type."
     )
     n_consensus: int = 1

{uiform → retab}/types/schemas/generate.py

@@ -1,9 +1,11 @@
-from typing import Any, Literal
+from typing import Any
+
 from openai.types.chat.chat_completion_reasoning_effort import ChatCompletionReasoningEffort
 from pydantic import BaseModel, Field
 
 from ..mime import MIMEData
 from ..modalities import Modality
+from ..browser_canvas import BrowserCanvas
 
 
 class GenerateSchemaRequest(BaseModel):
@@ -15,7 +17,9 @@ class GenerateSchemaRequest(BaseModel):
     instructions: str | None = None
     """The modality of the document to load."""
     image_resolution_dpi: int = Field(default=96, description="Resolution of the image sent to the LLM")
-    browser_canvas: Literal['A3', 'A4', 'A5'] = Field(default='A4', description="Sets the size of the browser canvas for rendering documents in browser-based processing. Choose a size that matches the document type.")
+    browser_canvas: BrowserCanvas = Field(
+        default="A4", description="Sets the size of the browser canvas for rendering documents in browser-based processing. Choose a size that matches the document type."
+    )
 
     """The image operations to apply to the document."""
 
@@ -29,4 +33,3 @@ class GenerateSystemPromptRequest(GenerateSchemaRequest):
     """
 
     json_schema: dict[str, Any]
-    

{uiform → retab}/types/schemas/layout.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List, Literal, Optional, Union
+from typing import Dict, List, Literal, Optional, Union
 
 from pydantic import BaseModel
 from pydantic import Field as PydanticField

{uiform → retab}/types/schemas/object.py

@@ -2,10 +2,9 @@ import copy
 import datetime
 import json
 from pathlib import Path
-from typing import Any, Iterable, Literal, Self, cast
+from typing import Any, Literal, Self
 
 from anthropic.types.message_param import MessageParam
-
 from google.genai.types import ContentUnionDict  # type: ignore
 from openai.types.chat.chat_completion_message_param import ChatCompletionMessageParam
 from openai.types.responses.response_input_param import ResponseInputItemParam
@@ -28,7 +27,7 @@ from ..._utils.json_schema import (
 )
 from ..._utils.responses import convert_to_openai_format as convert_to_openai_responses_api_format
 from ...types.standards import StreamingBaseModel
-from ..chat import ChatCompletionUiformMessage
+from ..chat import ChatCompletionRetabMessage
 
 
 class PartialSchema(BaseModel):
@@ -220,7 +219,7 @@ class Schema(PartialSchema):
 
     @property
     def developer_system_prompt(self) -> str:
-        return '''
+        return """
 # General Instructions
 
 You are an expert in data extraction and structured data outputs.
@@ -379,7 +378,7 @@ You can easily identify the fields that require a source by the `quote___[attrib
 
 # User Defined System Prompt
 
-'''
+"""
 
     @property
     def user_system_prompt(self) -> str:
@@ -463,7 +462,7 @@ You can easily identify the fields that require a source by the `quote___[attrib
         rec_remove_required(_validation_object_schema_)
         return _validation_object_schema_
 
-    def _get_pattern_attribute(self, pattern: str, attribute: Literal['X-FieldPrompt', 'X-ReasoningPrompt', 'type']) -> str | None:
+    def _get_pattern_attribute(self, pattern: str, attribute: Literal["X-FieldPrompt", "X-ReasoningPrompt", "type"]) -> str | None:
         """
         Given a JSON Schema and a pattern (like "my_object.my_array.*.my_property"),
         navigate the schema and return the specified attribute of the identified node.
@@ -506,7 +505,7 @@ You can easily identify the fields that require a source by the `quote___[attrib
             return schema_to_ts_type(current_schema, {}, {}, 0, 0, add_field_description=False)
         return current_schema.get(attribute)
 
-    def _set_pattern_attribute(self, pattern: str, attribute: Literal['X-FieldPrompt', 'X-ReasoningPrompt', 'X-SystemPrompt', 'description'], value: str) -> None:
+    def _set_pattern_attribute(self, pattern: str, attribute: Literal["X-FieldPrompt", "X-ReasoningPrompt", "X-SystemPrompt", "description"], value: str) -> None:
         """Sets an attribute value at a specific path in the schema.
 
         Args:
@@ -551,7 +550,7 @@ You can easily identify the fields that require a source by the `quote___[attrib
                 assert ref_name in definitions, "Validation Error: The $ref is not a definition reference"
 
                 # Count how many times this ref is used in the entire schema
-                ref_count = json.dumps(self.json_schema).count(f"\"{ref}\"")
+                ref_count = json.dumps(self.json_schema).count(f'"{ref}"')
 
                 if ref_count > 1:
                     # Create a unique copy name by appending a number
@@ -589,8 +588,8 @@ You can easily identify the fields that require a source by the `quote___[attrib
     def validate_schema_and_model(cls, data: Any) -> Any:
         """Validate schema and model logic."""
         # Extract from data
-        json_schema: dict[str, Any] | None = data.get('json_schema', None)
-        pydantic_model: type[BaseModel] | None = data.get('pydantic_model', None)
+        json_schema: dict[str, Any] | None = data.get("json_schema", None)
+        pydantic_model: type[BaseModel] | None = data.get("pydantic_model", None)
 
         # Check if either json_schema or pydantic_model is provided
         if json_schema and pydantic_model:
@@ -601,17 +600,17 @@ You can easily identify the fields that require a source by the `quote___[attrib
 
         if json_schema:
             json_schema = load_json_schema(json_schema)
-            data['pydantic_model'] = convert_json_schema_to_basemodel(json_schema)
-            data['json_schema'] = json_schema
+            data["pydantic_model"] = convert_json_schema_to_basemodel(json_schema)
+            data["json_schema"] = json_schema
         if pydantic_model:
-            data['pydantic_model'] = pydantic_model
-            data['json_schema'] = pydantic_model.model_json_schema()
+            data["pydantic_model"] = pydantic_model
+            data["json_schema"] = pydantic_model.model_json_schema()
 
         return data
 
     @property
-    def messages(self) -> list[ChatCompletionUiformMessage]:
-        return [ChatCompletionUiformMessage(role="developer", content=self.system_prompt)]
+    def messages(self) -> list[ChatCompletionRetabMessage]:
+        return [ChatCompletionRetabMessage(role="developer", content=self.system_prompt)]
 
     @model_validator(mode="after")
     def model_after_validator(self) -> Self:
@@ -627,5 +626,5 @@ You can easily identify the fields that require a source by the `quote___[attrib
             json_schema: The JSON schema to save, can be a dict, Path, or string
             schema_path: Output path for the schema file
         """
-        with open(path, 'w', encoding='utf-8') as f:
+        with open(path, "w", encoding="utf-8") as f:
             json.dump(self.json_schema, f, ensure_ascii=False, indent=2)

{uiform → retab}/types/schemas/templates.py

@@ -5,6 +5,7 @@ import nanoid  # type: ignore
 from pydantic import BaseModel, Field, PrivateAttr, computed_field
 
 from ..._utils.json_schema import generate_schema_data_id, generate_schema_id
+from ...types.mime import MIMEData
 
 
 class TemplateSchema(BaseModel):
@@ -58,9 +59,6 @@ class TemplateSchema(BaseModel):
     """The Pydantic model to use for loading."""
 
 
-from ...types.mime import MIMEData
-
-
 class UpdateTemplateRequest(BaseModel):
     """Request model for updating a template."""
 

{uiform → retab}/types/secrets/external_api_keys.py

@@ -1,5 +1,4 @@
 from datetime import datetime
-from enum import Enum
 from typing import Optional
 
 from pydantic import BaseModel

{uiform → retab}/types/standards.py

@@ -1,12 +1,15 @@
-from typing import Any, Generic, List, Literal, Optional, Tuple, TypeVar
+from typing import Any, List, Literal, Optional, Tuple, TypeVar, TypedDict
 
 from pydantic import BaseModel, Field
+from pydantic.fields import _Unset
 
 # API Standards
 
 # Define a type variable to represent the content type
 T = TypeVar("T")
 
+FieldUnset = _Unset
+
 
 # Define the ErrorDetail model
 class ErrorDetail(BaseModel):
@@ -37,3 +40,17 @@ class PreparedRequest(BaseModel):
     files: dict | List[Tuple[str, Tuple[str, bytes, str]]] | None = None
     idempotency_key: str | None = None
     raise_for_status: bool = False
+
+
+class DeleteResponse(TypedDict):
+    """Response from a delete operation"""
+
+    success: bool
+    id: str
+
+
+class ExportResponse(TypedDict):
+    """Response from an export operation"""
+
+    success: bool
+    path: str