retab 0.0.42__tar.gz → 0.0.44__tar.gz

{retab-0.0.42 → retab-0.0.44}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: retab
-Version: 0.0.42
+Version: 0.0.44
 Summary: Retab official python library
 Home-page: https://github.com/Retab-dev/retab
 Author: Retab
@@ -61,13 +61,13 @@ Made with love by the team at [Retab](https://retab.com) 🤍.
 
 ### What is Retab?
 
-Retab solves all the major challenges in document processing with LLMs:
+Retab solves all the major challenges in document processing with Large Language Models:
 
 1. **Universal Document Preprocessing**: Convert any file type (PDFs, Excel, emails, etc.) into LLM-ready format without writing custom parsers
 2. **Structured, Schema-driven Extraction**: Get consistent, reliable outputs using schema-based prompt engineering
 3. **Processors**: Publish a live, stable, shareable document processor.
 4. **Automations**: Create document processing workflows that can be triggered by events (mailbox, upload link, endpoint, outlook plugin).
-5. **Evaluations**: Evaluate the performance of models against annotated datasets
+5. **Projects**: Evaluate the performance of models against annotated datasets
 6. **Optimizations**: Identify the most used processors and help you finetune models to reduce costs and improve performance
 
 We are offering you all the software-defined primitives to build your own document processing solutions. We see it as **Stripe** for document processing.
@@ -90,7 +90,7 @@ Many people haven't yet realized how powerful LLMs have become at document proce
 
 ## Code examples
 
-## You can check our Github repository to see code examples: [python examples](https://github.com/Retab-dev/retab/tree/main/examples) and [jupyter notebooks](https://github.com/Retab-dev/retab-nodejs/tree/main/notebooks).
+You can check our Github repository to see code examples: [python examples](https://github.com/Retab-dev/retab/tree/main/examples) and [jupyter notebooks](https://github.com/Retab-dev/retab-nodejs/tree/main/notebooks).
 
 ## Community
 
@@ -112,8 +112,6 @@ We share our roadmap publicly on [Github](https://github.com/Retab-dev/retab)
 Among the features we're working on:
 
 * [ ] Node.js SDK
-* [ ] Low-level speed optimizations for Evals Frontend
 * [ ] Schema optimization autopilot
 * [ ] Sources API
-* [ ] Parse API for RAG
 

{retab-0.0.42 → retab-0.0.44}/README.md

@@ -18,13 +18,13 @@ Made with love by the team at [Retab](https://retab.com) 🤍.
 
 ### What is Retab?
 
-Retab solves all the major challenges in document processing with LLMs:
+Retab solves all the major challenges in document processing with Large Language Models:
 
 1. **Universal Document Preprocessing**: Convert any file type (PDFs, Excel, emails, etc.) into LLM-ready format without writing custom parsers
 2. **Structured, Schema-driven Extraction**: Get consistent, reliable outputs using schema-based prompt engineering
 3. **Processors**: Publish a live, stable, shareable document processor.
 4. **Automations**: Create document processing workflows that can be triggered by events (mailbox, upload link, endpoint, outlook plugin).
-5. **Evaluations**: Evaluate the performance of models against annotated datasets
+5. **Projects**: Evaluate the performance of models against annotated datasets
 6. **Optimizations**: Identify the most used processors and help you finetune models to reduce costs and improve performance
 
 We are offering you all the software-defined primitives to build your own document processing solutions. We see it as **Stripe** for document processing.
@@ -47,7 +47,7 @@ Many people haven't yet realized how powerful LLMs have become at document proce
 
 ## Code examples
 
-## You can check our Github repository to see code examples: [python examples](https://github.com/Retab-dev/retab/tree/main/examples) and [jupyter notebooks](https://github.com/Retab-dev/retab-nodejs/tree/main/notebooks).
+You can check our Github repository to see code examples: [python examples](https://github.com/Retab-dev/retab/tree/main/examples) and [jupyter notebooks](https://github.com/Retab-dev/retab-nodejs/tree/main/notebooks).
 
 ## Community
 
@@ -69,8 +69,6 @@ We share our roadmap publicly on [Github](https://github.com/Retab-dev/retab)
 Among the features we're working on:
 
 * [ ] Node.js SDK
-* [ ] Low-level speed optimizations for Evals Frontend
 * [ ] Schema optimization autopilot
 * [ ] Sources API
-* [ ] Parse API for RAG
 

{retab-0.0.42 → retab-0.0.44}/retab/__init__.py

@@ -1,4 +1,5 @@
 from .client import AsyncRetab, Retab
 from .types.schemas.object import Schema
+from . import utils
 
-__all__ = ["Retab", "AsyncRetab", "Schema"]
+__all__ = ["Retab", "AsyncRetab", "Schema", "utils"]

{retab-0.0.42 → retab-0.0.44}/retab/client.py

@@ -7,10 +7,9 @@ import backoff
 import backoff.types
 import httpx
 import truststore
-from pydantic_core import PydanticUndefined
 
-from .resources import consensus, documents, evals, files, finetuning, models, processors, schemas, secrets, usage, evaluations
-from .types.standards import PreparedRequest
+from .resources import consensus, deployments, documents, files, finetuning, models, processors, schemas, secrets, usage, projects
+from .types.standards import PreparedRequest, FieldUnset
 
 
 class MaxRetriesExceeded(Exception):
@@ -43,20 +42,15 @@ class BaseRetab:
         ValueError: If no API key is provided through arguments or environment variables
     """
 
-    #   claude_api_key (str, optional): Claude API key. Will look for CLAUDE_API_KEY env variable if not provided
-    #   xai_api_key (str, optional): XAI API key. Will look for XAI_API_KEY env variable if not provided
-    #   gemini_api_key (str, optional): Gemini API key. Will look for GEMINI_API_KEY env variable if not provided
-
     def __init__(
         self,
         api_key: Optional[str] = None,
         base_url: Optional[str] = None,
         timeout: float = 240.0,
         max_retries: int = 3,
-        openai_api_key: Optional[str] = PydanticUndefined,  # type: ignore[assignment]
-        gemini_api_key: Optional[str] = PydanticUndefined,  # type: ignore[assignment]
-        # claude_api_key: Optional[str] = PydanticUndefined,   # type: ignore[assignment]
-        xai_api_key: Optional[str] = PydanticUndefined,  # type: ignore[assignment]
+        openai_api_key: Optional[str] = FieldUnset,
+        gemini_api_key: Optional[str] = FieldUnset,
+        xai_api_key: Optional[str] = FieldUnset,
     ) -> None:
         if api_key is None:
             api_key = os.environ.get("RETAB_API_KEY")
@@ -80,30 +74,21 @@ class BaseRetab:
             "Content-Type": "application/json",
         }
 
-        # Only check environment variables if the value is PydanticUndefined
-        if openai_api_key is PydanticUndefined:
+        # Only check environment variables if the value is FieldUnset
+        if openai_api_key is FieldUnset:
             openai_api_key = os.environ.get("OPENAI_API_KEY")
 
-        # if claude_api_key is PydanticUndefined:
-        #    claude_api_key = os.environ.get("CLAUDE_API_KEY")
-
-        # if xai_api_key is PydanticUndefined:
-        #    xai_api_key = os.environ.get("XAI_API_KEY")
-
-        if gemini_api_key is PydanticUndefined:
+        if gemini_api_key is FieldUnset:
             gemini_api_key = os.environ.get("GEMINI_API_KEY")
 
-        # Only add headers if the values are actual strings (not None or PydanticUndefined)
-        if openai_api_key and openai_api_key is not PydanticUndefined:
+        # Only add headers if the values are actual strings (not None or FieldUnset)
+        if openai_api_key and openai_api_key is not FieldUnset:
             self.headers["OpenAI-Api-Key"] = openai_api_key
 
-        # if claude_api_key and claude_api_key is not PydanticUndefined:
-        #    self.headers["Anthropic-Api-Key"] = claude_api_key
-
-        if xai_api_key and xai_api_key is not PydanticUndefined:
+        if xai_api_key and xai_api_key is not FieldUnset:
             self.headers["XAI-Api-Key"] = xai_api_key
 
-        if gemini_api_key and gemini_api_key is not PydanticUndefined:
+        if gemini_api_key and gemini_api_key is not FieldUnset:
             self.headers["Gemini-Api-Key"] = gemini_api_key
 
     def _prepare_url(self, endpoint: str) -> str:
@@ -150,7 +135,7 @@ class Retab(BaseRetab):
     """Synchronous client for interacting with the Retab API.
 
     This client provides synchronous access to all Retab API resources including files, fine-tuning,
-    prompt optimization, documents, models, datasets, and schemas.
+    prompt optimization, documents, models, processors, deployments, and schemas.
 
     Args:
         api_key (str, optional): Retab API key. If not provided, will look for RETAB_API_KEY env variable.
@@ -158,8 +143,6 @@ class Retab(BaseRetab):
         timeout (float): Request timeout in seconds. Defaults to 240.0
         max_retries (int): Maximum number of retries for failed requests. Defaults to 3
         openai_api_key (str, optional): OpenAI API key. Will look for OPENAI_API_KEY env variable if not provided
-        claude_api_key (str, optional): Claude API key. Will look for CLAUDE_API_KEY env variable if not provided
-        xai_api_key (str, optional): XAI API key. Will look for XAI_API_KEY env variable if not provided
         gemini_api_key (str, optional): Gemini API key. Will look for GEMINI_API_KEY env variable if not provided
 
     Attributes:
@@ -168,7 +151,8 @@ class Retab(BaseRetab):
         prompt_optimization: Access to prompt optimization operations
         documents: Access to document operations
         models: Access to model operations
-        datasets: Access to dataset operations
+        processors: Access to processor operations
+        deployments: Access to deployment operations
         schemas: Access to schema operations
         responses: Access to responses API (OpenAI Responses API compatible interface)
     """
@@ -179,10 +163,8 @@ class Retab(BaseRetab):
         base_url: Optional[str] = None,
         timeout: float = 240.0,
         max_retries: int = 3,
-        openai_api_key: Optional[str] = PydanticUndefined,  # type: ignore[assignment]
-        gemini_api_key: Optional[str] = PydanticUndefined,  # type: ignore[assignment]
-        # claude_api_key: Optional[str] = PydanticUndefined,   # type: ignore[assignment]
-        # xai_api_key: Optional[str] = PydanticUndefined,   # type: ignore[assignment]
+        openai_api_key: Optional[str] = FieldUnset,
+        gemini_api_key: Optional[str] = FieldUnset,
     ) -> None:
         super().__init__(
             api_key=api_key,
@@ -191,20 +173,17 @@ class Retab(BaseRetab):
             max_retries=max_retries,
             openai_api_key=openai_api_key,
             gemini_api_key=gemini_api_key,
-            # claude_api_key=claude_api_key,
-            # xai_api_key=xai_api_key,
         )
 
         self.client = httpx.Client(timeout=self.timeout)
-        self.evals = evals.Evals(client=self)
-        self.evaluations = evaluations.Evaluations(client=self)
+        self.projects = projects.Projects(client=self)
         self.files = files.Files(client=self)
         self.fine_tuning = finetuning.FineTuning(client=self)
-        # self.prompt_optimization = prompt_optimization.PromptOptimization(client=self)
         self.documents = documents.Documents(client=self)
         self.models = models.Models(client=self)
         self.schemas = schemas.Schemas(client=self)
         self.processors = processors.Processors(client=self)
+        self.deployments = deployments.Deployments(client=self)
         self.secrets = secrets.Secrets(client=self)
         self.usage = usage.Usage(client=self)
         self.consensus = consensus.Consensus(client=self)
@@ -418,7 +397,7 @@ class AsyncRetab(BaseRetab):
     """Asynchronous client for interacting with the Retab API.
 
     This client provides asynchronous access to all Retab API resources including files, fine-tuning,
-    prompt optimization, documents, models, datasets, and schemas.
+    prompt optimization, documents, models, processors, deployments, and schemas.
 
     Args:
         api_key (str, optional): Retab API key. If not provided, will look for RETAB_API_KEY env variable.
@@ -436,7 +415,8 @@ class AsyncRetab(BaseRetab):
         prompt_optimization: Access to asynchronous prompt optimization operations
         documents: Access to asynchronous document operations
         models: Access to asynchronous model operations
-        datasets: Access to asynchronous dataset operations
+        processors: Access to asynchronous processor operations
+        deployments: Access to asynchronous deployment operations
         schemas: Access to asynchronous schema operations
         responses: Access to responses API (OpenAI Responses API compatible interface)
     """
@@ -447,10 +427,8 @@ class AsyncRetab(BaseRetab):
         base_url: Optional[str] = None,
         timeout: float = 240.0,
         max_retries: int = 3,
-        openai_api_key: Optional[str] = PydanticUndefined,  # type: ignore[assignment]
-        gemini_api_key: Optional[str] = PydanticUndefined,  # type: ignore[assignment]
-        # claude_api_key: Optional[str] = PydanticUndefined,   # type: ignore[assignment]
-        # xai_api_key: Optional[str] = PydanticUndefined,   # type: ignore[assignment]
+        openai_api_key: Optional[str] = FieldUnset,
+        gemini_api_key: Optional[str] = FieldUnset,
     ) -> None:
         super().__init__(
             api_key=api_key,
@@ -459,21 +437,18 @@ class AsyncRetab(BaseRetab):
             max_retries=max_retries,
             openai_api_key=openai_api_key,
             gemini_api_key=gemini_api_key,
-            # claude_api_key=claude_api_key,
-            # xai_api_key=xai_api_key,
         )
 
         self.client = httpx.AsyncClient(timeout=self.timeout)
 
-        self.evals = evals.AsyncEvals(client=self)
-        self.evaluations = evaluations.AsyncEvaluations(client=self)
+        self.projects = projects.AsyncProjects(client=self)
         self.files = files.AsyncFiles(client=self)
         self.fine_tuning = finetuning.AsyncFineTuning(client=self)
-        # self.prompt_optimization = prompt_optimization.AsyncPromptOptimization(client=self)
         self.documents = documents.AsyncDocuments(client=self)
         self.models = models.AsyncModels(client=self)
         self.schemas = schemas.AsyncSchemas(client=self)
         self.processors = processors.AsyncProcessors(client=self)
+        self.deployments = deployments.AsyncDeployments(client=self)
         self.secrets = secrets.AsyncSecrets(client=self)
         self.usage = usage.AsyncUsage(client=self)
         self.consensus = consensus.AsyncConsensus(client=self)

retab-0.0.44/retab/generate_types.py

@@ -0,0 +1,180 @@
+import collections.abc
+import json
+import os
+import types
+import typing
+import enum
+import sys
+import inspect
+from datetime import datetime, date
+from typing import Any, Type, get_args, get_origin, Union, Literal, is_typeddict
+from typing_extensions import is_typeddict as is_typeddict_ext
+import typing_extensions
+from pydantic_core import PydanticUndefined
+from pydantic import BaseModel, EmailStr
+import PIL.Image
+
+to_compile: list[tuple[str, Type, bool]] = []
+
+def is_base_model(field_type: Type) -> bool:
+    return getattr(field_type, "__name__", None) in ["BaseModel", "GenericModel", "ConfigDict", "Generic"]
+
+def type_to_zod(field_type: Any, put_names: bool = True, ts: bool = False) -> str:
+    origin = get_origin(field_type) or field_type
+    optional = False
+
+    def make_union(args):
+        return args[0] if len(args) <= 1 else "z.union([" + ", ".join(args) + "])"
+
+    def make_ts_union(args):
+        return args[0] if len(args) <= 1 else " | ".join(args)
+
+    if isinstance(field_type, typing.ForwardRef):
+        return type_to_zod(typing._eval_type(field_type, globals(), locals(), []), ts=ts)
+    elif origin is typing.Annotated or origin is typing.Required or origin is typing_extensions.Required:
+        return type_to_zod(get_args(field_type)[0], put_names, ts=ts)
+    if origin is Union or origin is types.UnionType:
+        args = [x for x in get_args(field_type)]
+        if types.NoneType in args:
+            args.remove(types.NoneType)
+            optional = True
+        typename = make_union([type_to_zod(x) for x in args])
+        ts_typename = make_ts_union([type_to_zod(x, ts=True) for x in args])
+    elif issubclass(origin, BaseModel) or is_typeddict(origin) or is_typeddict_ext(origin):
+        if put_names:
+            typename = "Z" + origin.__name__
+            ts_typename = origin.__name__
+            to_compile.append((origin.__name__, field_type, True))
+        else:
+            excluded_fields = set()
+            typename = "z.object({\n"
+            ts_typename = "{\n"
+            props = [(n, f.annotation, f.default) for n, f in origin.model_fields.items()] if issubclass(origin, BaseModel) else \
+                    [(n, f, PydanticUndefined) for n, f in origin.__annotations__.items()]
+
+            for field_name, field, default in props:
+                if field_name in excluded_fields:
+                    continue
+                ts_compiled = type_to_zod(field, ts=True)
+                default_str = ""
+                if default is not PydanticUndefined and default is not None:
+                    if isinstance(default, BaseModel):
+                        default_str = f".default({json.dumps(default.model_dump(mode="json", exclude_unset=True))})"
+                    else:
+                        default_str = f".default({json.dumps(default)})"
+                typename += f"    {field_name}: {type_to_zod(field)}{default_str},\n"
+                ts_typename += f"    {field_name}{"?" if ts_compiled.endswith(" | undefined") or default is not PydanticUndefined else ""}: {ts_compiled},\n"
+            typename += "})"
+            ts_typename += "}"
+
+            based = origin.__bases__
+            for i in range(0, len(based)):
+                if is_base_model(based[i]) or based[i] is dict:
+                    break
+                if issubclass(based[i], BaseModel):
+                    excluded_fields.update(based[i].model_fields.keys())
+                typename += ".merge(Z" + based[i].__name__ + ".schema)"
+                ts_typename += " & " + based[i].__name__
+    elif origin is list or origin is typing.List or origin is collections.abc.Sequence or origin is collections.abc.Iterable:
+        typename = "z.array(" + type_to_zod(get_args(field_type)[0]) + ")"
+        ts_typename = "Array<" + type_to_zod(get_args(field_type)[0], ts=True) + ">"
+    elif origin is tuple:
+        args = get_args(field_type)
+        typename = "z.tuple([" + ", ".join([type_to_zod(x) for x in args]) + "])"
+        ts_typename = "[" + ", ".join([type_to_zod(x, ts=True) for x in args]) + "]"
+    elif origin is dict:
+        if len(get_args(field_type)) == 2:
+            typename = "z.record(" + type_to_zod(get_args(field_type)[0]) + ", " + type_to_zod(get_args(field_type)[1]) + ")"
+            ts_typename = "{[key: " + type_to_zod(get_args(field_type)[0], ts=True) + "]: " + type_to_zod(get_args(field_type)[1], ts=True) + "}"
+        else:
+            typename = "z.record(z.any())"
+            ts_typename = "{[key: string]: any}"
+    elif origin is Literal:
+        typename = make_union(["z.literal(" + json.dumps(x) + ")" for x in get_args(field_type)])
+        ts_typename = make_ts_union([json.dumps(x) for x in get_args(field_type)])
+    elif isinstance(field_type, typing.TypeVar):
+        typename = "z.any()"
+        ts_typename = "any"
+    elif isinstance(field_type, type) and issubclass(field_type, enum.Enum):
+        typename = "z.any()"
+        ts_typename = "any"
+    elif field_type is str or field_type is date or field_type is datetime:
+        typename = "z.string()"
+        ts_typename = "string"
+    elif field_type is int or field_type is float:
+        typename = "z.number()"
+        ts_typename = "number"
+    elif field_type is bool:
+        typename = "z.boolean()"
+        ts_typename = "boolean"
+    elif field_type is typing.Any:
+        typename = "z.any()"
+        ts_typename = "any"
+    elif field_type is bytes or field_type is PIL.Image.Image or field_type is typing.BinaryIO or origin is typing.IO or origin is typing_extensions.IO:
+        typename = "z.instanceof(Uint8Array)"
+        ts_typename = "Uint8Array"
+    elif field_type is EmailStr:
+        typename = "z.string().email()"
+        ts_typename = "string"
+    elif field_type is os.PathLike:
+        typename = "z.string()"
+        ts_typename = "string"
+    elif field_type is object:
+        typename = "z.object({}).passthrough()"
+        ts_typename = "object"
+    else:
+        raise ValueError(f"Unsupported type: {field_type} ({origin})")
+    if ts:
+        return ts_typename if not optional else ts_typename + " | null | undefined"
+    else:
+        return typename if not optional else typename + ".nullable().optional()"
+    
+
+# SET of names of python builtin types starting with a capital
+builtin_types = {
+    "Any",
+    "BaseModel",
+    "NoneType",
+    "Literal",
+    "Union",
+    "List",
+    "Sequence",
+    "ConfigDict",
+    "Optional",
+}
+
+if __name__ == "__main__":
+    modules = []
+    for root, dirs, files in os.walk("retab/types"):
+        for module in files:
+            if module[-3:] != '.py':
+                continue
+            full_name = os.path.join(root, module[:-3]).replace(os.path.sep, '.')
+            __import__(full_name, locals(), globals())
+            modules.append(full_name)
+
+
+    for module_name in modules:
+        for name, obj in inspect.getmembers(sys.modules[module_name]):
+            if name[0] != name[0].lower() and name not in builtin_types:
+                to_compile.append((name, obj, False))
+
+    print("import * as z from 'zod';\n")
+    
+    defined = {}
+    while len(to_compile) > 0:
+        name, model, necessary = to_compile.pop(0)
+        if name in defined: continue
+        defined[name] = True
+        try:
+            compiled = type_to_zod(model, False)
+            compiled_ts = type_to_zod(model, False, ts=True)
+        except Exception as e:
+            if not necessary:
+                print(f"Skipping {name} {model} due to error: {e}", file=sys.stderr)
+                continue
+            print(f"Error compiling {name} {model}", file=sys.stderr)
+            raise e
+        print("export const Z" + name + " = z.lazy(() => " + compiled + ");")
+        print("export type " + name + " = z.infer<typeof Z" + name + ">;\n")
+

{retab-0.0.42 → retab-0.0.44}/retab/resources/consensus/client.py

@@ -21,7 +21,7 @@ class BaseConsensusMixin:
             mode=mode,
         )
 
-        return PreparedRequest(method="POST", url="/v1/consensus/reconcile", data=request.model_dump(), idempotency_key=idempotency_key)
+        return PreparedRequest(method="POST", url="/v1/consensus/reconcile", data=request.model_dump(mode="json", exclude_unset=True), idempotency_key=idempotency_key)
 
 
 class Consensus(SyncAPIResource, BaseConsensusMixin):

{retab-0.0.42 → retab-0.0.44}/retab/resources/consensus/responses.py

@@ -55,7 +55,7 @@ class BaseResponsesMixin:
             instructions=instructions,
         )
 
-        return PreparedRequest(method="POST", url="/v1/responses", data=request.model_dump(), idempotency_key=idempotency_key)
+        return PreparedRequest(method="POST", url="/v1/responses", data=request.model_dump(mode="json", exclude_unset=True), idempotency_key=idempotency_key)
 
     def prepare_parse(
         self,

retab-0.0.44/retab/resources/deployments/__init__.py

@@ -0,0 +1,3 @@
+from .client import AsyncDeployments, Deployments
+
+__all__ = ["Deployments", "AsyncDeployments"]

retab-0.0.44/retab/resources/deployments/client.py

@@ -0,0 +1,148 @@
+import base64
+from io import IOBase
+from pathlib import Path
+from typing import Any, List
+
+import PIL.Image
+from pydantic import HttpUrl
+from ..._resource import AsyncAPIResource, SyncAPIResource
+from ...utils.mime import MIMEData, prepare_mime_document
+from ...types.documents.extractions import RetabParsedChatCompletion
+from ...types.standards import PreparedRequest
+
+
+class DeploymentsMixin:
+    def prepare_submit(
+        self,
+        project_id: str,
+        iteration_id: str,
+        document: Path | str | bytes | IOBase | MIMEData | PIL.Image.Image | HttpUrl | None = None,
+        documents: list[Path | str | bytes | IOBase | MIMEData | PIL.Image.Image | HttpUrl] | None = None,
+        temperature: float | None = None,
+        seed: int | None = None,
+        store: bool = True,
+    ) -> PreparedRequest:
+        """Prepare a request to submit documents to a processor.
+
+        Args:
+            project_id: ID of the project
+            iteration_id: ID of the iteration
+            document: Single document to process (mutually exclusive with documents)
+            documents: List of documents to process (mutually exclusive with document)
+            temperature: Optional temperature override
+            seed: Optional seed for reproducibility
+            store: Whether to store the results
+
+        Returns:
+            PreparedRequest: The prepared request
+        """
+        # Validate that either document or documents is provided, but not both
+        if not document and not documents:
+            raise ValueError("Either 'document' or 'documents' must be provided")
+
+        if document and documents:
+            raise ValueError("Provide either 'document' (single) or 'documents' (multiple), not both")
+
+        # Prepare form data parameters
+        form_data = {
+            "temperature": temperature,
+            "seed": seed,
+            "store": store,
+        }
+        # Remove None values
+        form_data = {k: v for k, v in form_data.items() if v is not None}
+
+        # Prepare files for upload
+        files = {}
+        if document:
+            # Convert document to MIMEData if needed
+            mime_document = prepare_mime_document(document)
+            # Single document upload
+            files["document"] = (mime_document.filename, base64.b64decode(mime_document.content), mime_document.mime_type)
+        elif documents:
+            # Multiple documents upload - httpx supports multiple files with same field name using a list
+            files_list = []
+            for doc in documents:
+                # Convert each document to MIMEData if needed
+                mime_doc = prepare_mime_document(doc)
+                files_list.append(
+                    (
+                        "documents",  # field name
+                        (mime_doc.filename, base64.b64decode(mime_doc.content), mime_doc.mime_type),
+                    )
+                )
+            files = files_list
+
+        url = f"/v1/deployments/{project_id}/{iteration_id}/submit"
+
+        return PreparedRequest(method="POST", url=url, form_data=form_data, files=files)
+
+
+class Deployments(SyncAPIResource, DeploymentsMixin):
+    """Deployments API wrapper for managing deployment configurations"""
+
+    def __init__(self, client: Any) -> None:
+        super().__init__(client=client)
+
+    def submit(
+        self,
+        project_id: str,
+        iteration_id: str,
+        document: Path | str | bytes | IOBase | MIMEData | PIL.Image.Image | HttpUrl | None = None,
+        documents: List[Path | str | bytes | IOBase | MIMEData | PIL.Image.Image | HttpUrl] | None = None,
+        temperature: float | None = None,
+        seed: int | None = None,
+        store: bool = True,
+    ) -> RetabParsedChatCompletion:
+        """Submit documents to a deployment for processing.
+
+        Args:
+            project_id: ID of the project
+            iteration_id: ID of the iteration
+            document: Single document to process (mutually exclusive with documents)
+            documents: List of documents to process (mutually exclusive with document)
+            temperature: Optional temperature override
+            seed: Optional seed for reproducibility
+            store: Whether to store the results
+
+        Returns:
+            RetabParsedChatCompletion: The processing result
+        """
+        request = self.prepare_submit(project_id=project_id, iteration_id=iteration_id, document=document, documents=documents, temperature=temperature, seed=seed, store=store)
+        response = self._client._prepared_request(request)
+        return RetabParsedChatCompletion.model_validate(response)
+
+
+class AsyncDeployments(AsyncAPIResource, DeploymentsMixin):
+    """Async Deployments API wrapper for managing deployment configurations"""
+
+    def __init__(self, client: Any) -> None:
+        super().__init__(client=client)
+
+    async def submit(
+        self,
+        project_id: str,
+        iteration_id: str,
+        document: Path | str | bytes | IOBase | MIMEData | PIL.Image.Image | HttpUrl | None = None,
+        documents: List[Path | str | bytes | IOBase | MIMEData | PIL.Image.Image | HttpUrl] | None = None,
+        temperature: float | None = None,
+        seed: int | None = None,
+        store: bool = True,
+    ) -> RetabParsedChatCompletion:
+        """Submit documents to a deployment for processing.
+
+        Args:
+            project_id: ID of the project
+            iteration_id: ID of the iteration
+            document: Single document to process (mutually exclusive with documents)
+            documents: List of documents to process (mutually exclusive with document)
+            temperature: Optional temperature override
+            seed: Optional seed for reproducibility
+            store: Whether to store the results
+
+        Returns:
+            RetabParsedChatCompletion: The processing result
+        """
+        request = self.prepare_submit(project_id=project_id, iteration_id=iteration_id, document=document, documents=documents, temperature=temperature, seed=seed, store=store)
+        response = await self._client._prepared_request(request)
+        return RetabParsedChatCompletion.model_validate(response)