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

retab/__init__.py

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

retab/_resource.py

@@ -5,13 +5,13 @@ import time
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from .client import AsyncUiForm, UiForm
+    from .client import AsyncRetab, Retab
 
 
 class SyncAPIResource:
-    _client: UiForm
+    _client: Retab
 
-    def __init__(self, client: UiForm) -> None:
+    def __init__(self, client: Retab) -> None:
         self._client = client
 
     def _sleep(self, seconds: float) -> None:
@@ -19,9 +19,9 @@ class SyncAPIResource:
 
 
 class AsyncAPIResource:
-    _client: AsyncUiForm
+    _client: AsyncRetab
 
-    def __init__(self, client: AsyncUiForm) -> None:
+    def __init__(self, client: AsyncRetab) -> None:
         self._client = client
 
     async def _sleep(self, seconds: float) -> None:

retab/_utils/chat.py

@@ -13,14 +13,14 @@ from openai.types.chat.chat_completion_content_part_param import ChatCompletionC
 from openai.types.chat.chat_completion_content_part_text_param import ChatCompletionContentPartTextParam
 from openai.types.chat.chat_completion_message_param import ChatCompletionMessageParam
 
-from ..types.chat import ChatCompletionUiformMessage
+from ..types.chat import ChatCompletionRetabMessage
 
 MediaType = Literal["image/jpeg", "image/png", "image/gif", "image/webp"]
 
 
-def convert_to_google_genai_format(messages: List[ChatCompletionUiformMessage]) -> tuple[str, list[ContentUnionDict]]:
+def convert_to_google_genai_format(messages: List[ChatCompletionRetabMessage]) -> tuple[str, list[ContentUnionDict]]:
     """
-    Converts a list of ChatCompletionUiFormMessage to a format compatible with the google.genai SDK.
+    Converts a list of ChatCompletionRetabMessage to a format compatible with the google.genai SDK.
 
 
     Example:
@@ -40,7 +40,7 @@ def convert_to_google_genai_format(messages: List[ChatCompletionUiformMessage])
         ```
 
     Args:
-        messages (List[ChatCompletionUiformMessage]): List of chat messages.
+        messages (List[ChatCompletionRetabMessage]): List of chat messages.
 
     Returns:
         List[Union[Dict[str, str], str]]: A list of formatted inputs for the google.genai SDK.
@@ -94,12 +94,12 @@ def convert_to_google_genai_format(messages: List[ChatCompletionUiformMessage])
     return system_message, formatted_content
 
 
-def convert_to_anthropic_format(messages: List[ChatCompletionUiformMessage]) -> tuple[str, List[MessageParam]]:
+def convert_to_anthropic_format(messages: List[ChatCompletionRetabMessage]) -> tuple[str, List[MessageParam]]:
     """
-    Converts a list of ChatCompletionUiformMessage to a format compatible with the Anthropic SDK.
+    Converts a list of ChatCompletionRetabMessage to a format compatible with the Anthropic SDK.
 
     Args:
-        messages (List[ChatCompletionUiformMessage]): List of chat messages.
+        messages (List[ChatCompletionRetabMessage]): List of chat messages.
 
     Returns:
         (system_message, formatted_messages):
@@ -216,11 +216,11 @@ def convert_to_anthropic_format(messages: List[ChatCompletionUiformMessage]) ->
     return system_message, formatted_messages
 
 
-def convert_from_anthropic_format(messages: list[MessageParam], system_prompt: str) -> list[ChatCompletionUiformMessage]:
+def convert_from_anthropic_format(messages: list[MessageParam], system_prompt: str) -> list[ChatCompletionRetabMessage]:
     """
-    Converts a list of Anthropic MessageParam to a list of ChatCompletionUiformMessage.
+    Converts a list of Anthropic MessageParam to a list of ChatCompletionRetabMessage.
     """
-    formatted_messages: list[ChatCompletionUiformMessage] = [ChatCompletionUiformMessage(role="developer", content=system_prompt)]
+    formatted_messages: list[ChatCompletionRetabMessage] = [ChatCompletionRetabMessage(role="developer", content=system_prompt)]
 
     for message in messages:
         role = message["role"]
@@ -229,7 +229,7 @@ def convert_from_anthropic_format(messages: list[MessageParam], system_prompt: s
         # Handle different content structures
         if isinstance(content_blocks, list) and len(content_blocks) == 1 and isinstance(content_blocks[0], dict) and content_blocks[0].get("type") == "text":
             # Simple text message
-            formatted_messages.append(cast(ChatCompletionUiformMessage, {"role": role, "content": content_blocks[0].get("text", "")}))
+            formatted_messages.append(cast(ChatCompletionRetabMessage, {"role": role, "content": content_blocks[0].get("text", "")}))
         elif isinstance(content_blocks, list):
             # Message with multiple content parts or non-text content
             formatted_content: list[ChatCompletionContentPartParam] = []
@@ -248,22 +248,22 @@ def convert_from_anthropic_format(messages: list[MessageParam], system_prompt: s
 
                             formatted_content.append(cast(ChatCompletionContentPartParam, {"type": "image_url", "image_url": {"url": image_url}}))
 
-            formatted_messages.append(cast(ChatCompletionUiformMessage, {"role": role, "content": formatted_content}))
+            formatted_messages.append(cast(ChatCompletionRetabMessage, {"role": role, "content": formatted_content}))
 
     return formatted_messages
 
 
-def convert_to_openai_format(messages: List[ChatCompletionUiformMessage]) -> List[ChatCompletionMessageParam]:
+def convert_to_openai_format(messages: List[ChatCompletionRetabMessage]) -> List[ChatCompletionMessageParam]:
     return cast(list[ChatCompletionMessageParam], messages)
 
 
-def convert_from_openai_format(messages: list[ChatCompletionMessageParam]) -> list[ChatCompletionUiformMessage]:
-    return cast(list[ChatCompletionUiformMessage], messages)
+def convert_from_openai_format(messages: list[ChatCompletionMessageParam]) -> list[ChatCompletionRetabMessage]:
+    return cast(list[ChatCompletionRetabMessage], messages)
 
 
 def separate_messages(
-    messages: list[ChatCompletionUiformMessage],
-) -> tuple[Optional[ChatCompletionUiformMessage], list[ChatCompletionUiformMessage], list[ChatCompletionUiformMessage]]:
+    messages: list[ChatCompletionRetabMessage],
+) -> tuple[Optional[ChatCompletionRetabMessage], list[ChatCompletionRetabMessage], list[ChatCompletionRetabMessage]]:
     """
     Separates messages into system, user and assistant messages.
 
@@ -291,12 +291,12 @@ def separate_messages(
     return system_message, user_messages, assistant_messages
 
 
-def str_messages(messages: list[ChatCompletionUiformMessage], max_length: int = 100) -> str:
+def str_messages(messages: list[ChatCompletionRetabMessage], max_length: int = 100) -> str:
     """
     Converts a list of chat messages into a string representation with faithfully serialized structure.
 
     Args:
-        messages (list[ChatCompletionUiformMessage]): The list of chat messages.
+        messages (list[ChatCompletionRetabMessage]): The list of chat messages.
         max_length (int): Maximum length for content before truncation.
 
     Returns:
@@ -307,7 +307,7 @@ def str_messages(messages: list[ChatCompletionUiformMessage], max_length: int =
         """Truncate text to max_len with ellipsis."""
         return text if len(text) <= max_len else f"{text[:max_len]}..."
 
-    serialized: list[ChatCompletionUiformMessage] = []
+    serialized: list[ChatCompletionRetabMessage] = []
     for message in messages:
         role = message["role"]
         content = message["content"]

retab/_utils/responses.py

@@ -16,13 +16,13 @@ from openai.types.responses.response_input_message_content_list_param import Res
 from openai.types.responses.response_input_param import ResponseInputItemParam
 from openai.types.responses.response_input_text_param import ResponseInputTextParam
 
-from ..types.chat import ChatCompletionUiformMessage
+from ..types.chat import ChatCompletionRetabMessage
 from ..types.documents.extractions import UiParsedChatCompletion, UiParsedChoice
 
 
-def convert_to_openai_format(messages: list[ChatCompletionUiformMessage]) -> list[ResponseInputItemParam]:
+def convert_to_openai_format(messages: list[ChatCompletionRetabMessage]) -> list[ResponseInputItemParam]:
     """
-    Converts a list of ChatCompletionUiformMessage to the OpenAI ResponseInputParam format.
+    Converts a list of ChatCompletionRetabMessage to the OpenAI ResponseInputParam format.
 
     Args:
         messages: List of chat messages in UIForm format
@@ -64,9 +64,9 @@ def convert_to_openai_format(messages: list[ChatCompletionUiformMessage]) -> lis
     return formatted_messages
 
 
-def convert_from_openai_format(messages: list[ResponseInputItemParam]) -> list[ChatCompletionUiformMessage]:
+def convert_from_openai_format(messages: list[ResponseInputItemParam]) -> list[ChatCompletionRetabMessage]:
     """
-    Converts messages from OpenAI ResponseInputParam format to ChatCompletionUiformMessage format.
+    Converts messages from OpenAI ResponseInputParam format to ChatCompletionRetabMessage format.
 
     Args:
         messages: Messages in OpenAI ResponseInputParam format
@@ -74,7 +74,7 @@ def convert_from_openai_format(messages: list[ResponseInputItemParam]) -> list[C
     Returns:
         List of chat messages in UIForm format
     """
-    formatted_messages: list[ChatCompletionUiformMessage] = []
+    formatted_messages: list[ChatCompletionRetabMessage] = []
 
     for message in messages:
         if "role" not in message or "content" not in message:
@@ -110,7 +110,7 @@ def convert_from_openai_format(messages: list[ResponseInputItemParam]) -> list[C
                     print(f"Not supported content type: {part['type']}... Skipping...")
 
         # Create message in UIForm format
-        formatted_message = ChatCompletionUiformMessage(role=role, content=formatted_content)
+        formatted_message = ChatCompletionRetabMessage(role=role, content=formatted_content)
         formatted_messages.append(formatted_message)
 
     return formatted_messages

retab/_utils/usage/usage.py

@@ -78,7 +78,7 @@ def compute_api_call_cost(pricing: Pricing, usage: CompletionUsage, is_ft: bool
 
 
 def compute_cost_from_model(model: str, usage: CompletionUsage) -> Amount:
-    # Extract base model name for fine-tuned models like "ft:gpt-4o:uiform:4389573"
+    # Extract base model name for fine-tuned models like "ft:gpt-4o:retab:4389573"
     is_ft = False
     if model.startswith("ft:"):
         # Split by colon and take the second part (index 1) which contains the base model
@@ -270,7 +270,7 @@ def compute_cost_from_model_with_breakdown(model: str, usage: CompletionUsage) -
     Computes a detailed cost breakdown for an API call using the specified model and usage.
 
     Args:
-        model: The model name (can be a fine-tuned model like "ft:gpt-4o:uiform:4389573")
+        model: The model name (can be a fine-tuned model like "ft:gpt-4o:retab:4389573")
         usage: Token usage statistics for the API call
 
     Returns:
@@ -279,7 +279,7 @@ def compute_cost_from_model_with_breakdown(model: str, usage: CompletionUsage) -
     Raises:
         ValueError: If no pricing information is found for the model
     """
-    # Extract base model name for fine-tuned models like "ft:gpt-4o:uiform:4389573"
+    # Extract base model name for fine-tuned models like "ft:gpt-4o:retab:4389573"
     original_model = model
     is_ft = False
 

retab/client.py

@@ -26,15 +26,15 @@ def raise_max_tries_exceeded(details: backoff.types.Details) -> None:
         raise Exception(f"Max tries exceeded after {tries} tries.")
 
 
-class BaseUiForm:
-    """Base class for UiForm clients that handles authentication and configuration.
+class BaseRetab:
+    """Base class for Retab clients that handles authentication and configuration.
 
     This class provides core functionality for API authentication, configuration, and common HTTP operations
     used by both synchronous and asynchronous clients.
 
     Args:
-        api_key (str, optional): UiForm API key. If not provided, will look for UIFORM_API_KEY env variable.
-        base_url (str, optional): Base URL for API requests. Defaults to https://api.uiform.com
+        api_key (str, optional): Retab API key. If not provided, will look for RETAB_API_KEY env variable.
+        base_url (str, optional): Base URL for API requests. Defaults to https://api.retab.dev
         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
@@ -59,16 +59,16 @@ class BaseUiForm:
         xai_api_key: Optional[str] = PydanticUndefined,  # type: ignore[assignment]
     ) -> None:
         if api_key is None:
-            api_key = os.environ.get("UIFORM_API_KEY")
+            api_key = os.environ.get("RETAB_API_KEY")
 
         if api_key is None:
             raise ValueError(
-                "No API key provided. You can create an API key at https://uiform.com\n"
-                "Then either pass it to the client (api_key='your-key') or set the UIFORM_API_KEY environment variable"
+                "No API key provided. You can create an API key at https://retab.dev\n"
+                "Then either pass it to the client (api_key='your-key') or set the RETAB_API_KEY environment variable"
             )
 
         if base_url is None:
-            base_url = os.environ.get("UIFORM_API_BASE_URL", "https://api.uiform.com")
+            base_url = os.environ.get("RETAB_API_BASE_URL", "https://api.retab.dev")
 
         truststore.inject_into_ssl()
         self.api_key = api_key
@@ -146,15 +146,15 @@ class BaseUiForm:
                 return response.text
 
 
-class UiForm(BaseUiForm):
-    """Synchronous client for interacting with the UiForm API.
+class Retab(BaseRetab):
+    """Synchronous client for interacting with the Retab API.
 
-    This client provides synchronous access to all UiForm API resources including files, fine-tuning,
+    This client provides synchronous access to all Retab API resources including files, fine-tuning,
     prompt optimization, documents, models, datasets, and schemas.
 
     Args:
-        api_key (str, optional): UiForm API key. If not provided, will look for UIFORM_API_KEY env variable.
-        base_url (str, optional): Base URL for API requests. Defaults to https://api.uiform.com
+        api_key (str, optional): Retab API key. If not provided, will look for RETAB_API_KEY env variable.
+        base_url (str, optional): Base URL for API requests. Defaults to https://api.retab.dev
         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
@@ -395,11 +395,11 @@ class UiForm(BaseUiForm):
         """Closes the HTTP client session."""
         self.client.close()
 
-    def __enter__(self) -> "UiForm":
+    def __enter__(self) -> "Retab":
         """Context manager entry point.
 
         Returns:
-            UiForm: The client instance
+            Retab: The client instance
         """
         return self
 
@@ -414,15 +414,15 @@ class UiForm(BaseUiForm):
         self.close()
 
 
-class AsyncUiForm(BaseUiForm):
-    """Asynchronous client for interacting with the UiForm API.
+class AsyncRetab(BaseRetab):
+    """Asynchronous client for interacting with the Retab API.
 
-    This client provides asynchronous access to all UiForm API resources including files, fine-tuning,
+    This client provides asynchronous access to all Retab API resources including files, fine-tuning,
     prompt optimization, documents, models, datasets, and schemas.
 
     Args:
-        api_key (str, optional): UiForm API key. If not provided, will look for UIFORM_API_KEY env variable.
-        base_url (str, optional): Base URL for API requests. Defaults to https://api.uiform.com
+        api_key (str, optional): Retab API key. If not provided, will look for RETAB_API_KEY env variable.
+        base_url (str, optional): Base URL for API requests. Defaults to https://api.retab.dev
         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
@@ -683,11 +683,11 @@ class AsyncUiForm(BaseUiForm):
         """Closes the async HTTP client session."""
         await self.client.aclose()
 
-    async def __aenter__(self) -> "AsyncUiForm":
+    async def __aenter__(self) -> "AsyncRetab":
         """Async context manager entry point.
 
         Returns:
-            AsyncUiForm: The async client instance
+            AsyncRetab: The async client instance
         """
         return self
 

retab/resources/consensus/client.py

@@ -52,7 +52,7 @@ class Consensus(SyncAPIResource, BaseConsensusMixin):
             Dict containing the consensus dictionary and consensus likelihoods
 
         Raises:
-            UiformAPIError: If the API request fails
+            RetabAPIError: If the API request fails
         """
         request = self._prepare_reconcile(list_dicts, reference_schema, mode, idempotency_key)
         response = self._client._prepared_request(request)
@@ -87,7 +87,7 @@ class AsyncConsensus(AsyncAPIResource, BaseConsensusMixin):
             Dict containing the consensus dictionary and consensus likelihoods
 
         Raises:
-            UiformAPIError: If the API request fails
+            RetabAPIError: If the API request fails
         """
         request = self._prepare_reconcile(list_dicts, reference_schema, mode, idempotency_key)
         response = await self._client._prepared_request(request)

retab/resources/consensus/completions.py

@@ -6,7 +6,7 @@ from pydantic import BaseModel as ResponseFormatT
 
 from ..._resource import AsyncAPIResource, SyncAPIResource
 from ..._utils.ai_models import assert_valid_model_extraction
-from ...types.chat import ChatCompletionUiformMessage
+from ...types.chat import ChatCompletionRetabMessage
 from ...types.completions import UiChatCompletionsRequest
 from ...types.documents.extractions import UiParsedChatCompletion
 from ...types.schemas.object import Schema
@@ -17,7 +17,7 @@ class BaseCompletionsMixin:
     def prepare_parse(
         self,
         response_format: type[ResponseFormatT],
-        messages: list[ChatCompletionUiformMessage],
+        messages: list[ChatCompletionRetabMessage],
         model: str,
         temperature: float,
         reasoning_effort: ChatCompletionReasoningEffort,
@@ -52,7 +52,7 @@ class BaseCompletionsMixin:
     def prepare_create(
         self,
         response_format: ResponseFormatJSONSchema,
-        messages: list[ChatCompletionUiformMessage],
+        messages: list[ChatCompletionRetabMessage],
         model: str,
         temperature: float,
         reasoning_effort: ChatCompletionReasoningEffort,
@@ -91,7 +91,7 @@ class Completions(SyncAPIResource, BaseCompletionsMixin):
     def create(
         self,
         response_format: ResponseFormatJSONSchema,
-        messages: list[ChatCompletionUiformMessage],
+        messages: list[ChatCompletionRetabMessage],
         model: str = "gpt-4o-2024-08-06",
         temperature: float = 0,
         reasoning_effort: ChatCompletionReasoningEffort = "medium",
@@ -100,7 +100,7 @@ class Completions(SyncAPIResource, BaseCompletionsMixin):
         stream: bool = False,
     ) -> UiParsedChatCompletion:
         """
-        Create a completion using the UiForm API.
+        Create a completion using the Retab API.
         """
 
         request = self.prepare_create(
@@ -121,7 +121,7 @@ class Completions(SyncAPIResource, BaseCompletionsMixin):
     def parse(
         self,
         response_format: type[ResponseFormatT],
-        messages: list[ChatCompletionUiformMessage],
+        messages: list[ChatCompletionRetabMessage],
         model: str = "gpt-4o-2024-08-06",
         temperature: float = 0,
         reasoning_effort: ChatCompletionReasoningEffort = "medium",
@@ -129,7 +129,7 @@ class Completions(SyncAPIResource, BaseCompletionsMixin):
         idempotency_key: str | None = None,
     ) -> UiParsedChatCompletion:
         """
-        Parse messages using the UiForm API to extract structured data according to the provided JSON schema.
+        Parse messages using the Retab API to extract structured data according to the provided JSON schema.
 
         Args:
             response_format: JSON schema defining the expected data structure
@@ -138,7 +138,7 @@ class Completions(SyncAPIResource, BaseCompletionsMixin):
             temperature: Model temperature setting (0-1)
             reasoning_effort: The effort level for the model to reason about the input data
             idempotency_key: Idempotency key for request
-            store: Whether to store the data in the UiForm database
+            store: Whether to store the data in the Retab database
 
         Returns:
             UiParsedChatCompletion: Parsed response from the API
@@ -164,7 +164,7 @@ class AsyncCompletions(AsyncAPIResource, BaseCompletionsMixin):
     async def create(
         self,
         response_format: ResponseFormatJSONSchema,
-        messages: list[ChatCompletionUiformMessage],
+        messages: list[ChatCompletionRetabMessage],
         model: str = "gpt-4o-2024-08-06",
         temperature: float = 0,
         reasoning_effort: ChatCompletionReasoningEffort = "medium",
@@ -173,7 +173,7 @@ class AsyncCompletions(AsyncAPIResource, BaseCompletionsMixin):
         stream: bool = False,
     ) -> UiParsedChatCompletion:
         """
-        Create a completion using the UiForm API.
+        Create a completion using the Retab API.
         """
 
         request = self.prepare_create(
@@ -193,7 +193,7 @@ class AsyncCompletions(AsyncAPIResource, BaseCompletionsMixin):
     async def parse(
         self,
         response_format: type[ResponseFormatT],
-        messages: list[ChatCompletionUiformMessage],
+        messages: list[ChatCompletionRetabMessage],
         model: str = "gpt-4o-2024-08-06",
         temperature: float = 0,
         reasoning_effort: ChatCompletionReasoningEffort = "medium",
@@ -201,7 +201,7 @@ class AsyncCompletions(AsyncAPIResource, BaseCompletionsMixin):
         idempotency_key: str | None = None,
     ) -> UiParsedChatCompletion:
         """
-        Parse messages using the UiForm API asynchronously.
+        Parse messages using the Retab API asynchronously.
 
         Args:
             json_schema: JSON schema defining the expected data structure

retab/resources/consensus/completions_stream.py

@@ -12,7 +12,7 @@ from ..._resource import AsyncAPIResource, SyncAPIResource
 from ..._utils.ai_models import assert_valid_model_extraction
 from ..._utils.json_schema import unflatten_dict
 from ..._utils.stream_context_managers import as_async_context_manager, as_context_manager
-from ...types.chat import ChatCompletionUiformMessage
+from ...types.chat import ChatCompletionRetabMessage
 from ...types.completions import UiChatCompletionsRequest
 from ...types.documents.extractions import UiParsedChatCompletion, UiParsedChatCompletionChunk, UiParsedChoice
 from ...types.schemas.object import Schema
@@ -23,7 +23,7 @@ class BaseCompletionsMixin:
     def prepare_parse(
         self,
         response_format: type[ResponseFormatT],
-        messages: list[ChatCompletionUiformMessage],
+        messages: list[ChatCompletionRetabMessage],
         model: str,
         temperature: float,
         reasoning_effort: ChatCompletionReasoningEffort,
@@ -58,7 +58,7 @@ class BaseCompletionsMixin:
     def prepare_create(
         self,
         response_format: ResponseFormatJSONSchema,
-        messages: list[ChatCompletionUiformMessage],
+        messages: list[ChatCompletionRetabMessage],
         model: str,
         temperature: float,
         reasoning_effort: ChatCompletionReasoningEffort,
@@ -100,7 +100,7 @@ class Completions(SyncAPIResource, BaseCompletionsMixin):
     def stream(
         self,
         response_format: type[ResponseFormatT],
-        messages: list[ChatCompletionUiformMessage],
+        messages: list[ChatCompletionRetabMessage],
         model: str = "gpt-4o-2024-08-06",
         temperature: float = 0,
         reasoning_effort: ChatCompletionReasoningEffort = "medium",
@@ -108,7 +108,7 @@ class Completions(SyncAPIResource, BaseCompletionsMixin):
         idempotency_key: str | None = None,
     ) -> Generator[UiParsedChatCompletion, None, None]:
         """
-        Process messages using the UiForm API with streaming enabled.
+        Process messages using the Retab API with streaming enabled.
 
         Args:
             response_format: JSON schema defining the expected data structure
@@ -123,7 +123,7 @@ class Completions(SyncAPIResource, BaseCompletionsMixin):
 
         Usage:
         ```python
-        with uiform.completions.stream(json_schema, messages, model, temperature, reasoning_effort) as stream:
+        with retab.devpletions.stream(json_schema, messages, model, temperature, reasoning_effort) as stream:
             for response in stream:
                 print(response)
         ```
@@ -186,7 +186,7 @@ class AsyncCompletions(AsyncAPIResource, BaseCompletionsMixin):
     async def stream(
         self,
         response_format: type[ResponseFormatT],
-        messages: list[ChatCompletionUiformMessage],
+        messages: list[ChatCompletionRetabMessage],
         model: str = "gpt-4o-2024-08-06",
         temperature: float = 0,
         reasoning_effort: ChatCompletionReasoningEffort = "medium",
@@ -194,7 +194,7 @@ class AsyncCompletions(AsyncAPIResource, BaseCompletionsMixin):
         idempotency_key: str | None = None,
     ) -> AsyncGenerator[UiParsedChatCompletion, None]:
         """
-        Parse messages using the UiForm API asynchronously with streaming.
+        Parse messages using the Retab API asynchronously with streaming.
 
         Args:
             json_schema: JSON schema defining the expected data structure
@@ -210,7 +210,7 @@ class AsyncCompletions(AsyncAPIResource, BaseCompletionsMixin):
 
         Usage:
         ```python
-        async with uiform.completions.stream(json_schema, messages, model, temperature, reasoning_effort, n_consensus) as stream:
+        async with retab.devpletions.stream(json_schema, messages, model, temperature, reasoning_effort, n_consensus) as stream:
             async for response in stream:
                 print(response)
         ```

retab/resources/consensus/responses.py

@@ -100,7 +100,7 @@ class BaseResponsesMixin:
 
 
 class Responses(SyncAPIResource, BaseResponsesMixin):
-    """UiForm Responses API compatible with OpenAI Responses API"""
+    """Retab Responses API compatible with OpenAI Responses API"""
 
     def create(
         self,
@@ -114,7 +114,7 @@ class Responses(SyncAPIResource, BaseResponsesMixin):
         idempotency_key: Optional[str] = None,
     ) -> Response:
         """
-        Create a completion using the UiForm API with OpenAI Responses API compatible interface.
+        Create a completion using the Retab API with OpenAI Responses API compatible interface.
 
         Args:
             model: The model to use
@@ -156,7 +156,7 @@ class Responses(SyncAPIResource, BaseResponsesMixin):
         idempotency_key: Optional[str] = None,
     ) -> Response:
         """
-        Parse content using the UiForm API with OpenAI Responses API compatible interface.
+        Parse content using the Retab API with OpenAI Responses API compatible interface.
 
         Args:
             model: The model to use
@@ -189,7 +189,7 @@ class Responses(SyncAPIResource, BaseResponsesMixin):
 
 
 class AsyncResponses(AsyncAPIResource, BaseResponsesMixin):
-    """UiForm Responses API compatible with OpenAI Responses API for async usage"""
+    """Retab Responses API compatible with OpenAI Responses API for async usage"""
 
     async def create(
         self,
@@ -203,7 +203,7 @@ class AsyncResponses(AsyncAPIResource, BaseResponsesMixin):
         idempotency_key: Optional[str] = None,
     ) -> UiResponse:
         """
-        Create a completion using the UiForm API asynchronously with OpenAI Responses API compatible interface.
+        Create a completion using the Retab API asynchronously with OpenAI Responses API compatible interface.
 
         Args:
             model: The model to use
@@ -245,7 +245,7 @@ class AsyncResponses(AsyncAPIResource, BaseResponsesMixin):
         idempotency_key: Optional[str] = None,
     ) -> UiResponse:
         """
-        Parse content using the UiForm API asynchronously with OpenAI Responses API compatible interface.
+        Parse content using the Retab API asynchronously with OpenAI Responses API compatible interface.
 
         Args:
             model: The model to use