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

retab/_utils/ai_models.py

@@ -1,74 +1,121 @@
+import os
+import yaml
 from typing import get_args
 
-from ..types.ai_models import AIProvider, GeminiModel, OpenAIModel, xAI_Model
+from ..types.ai_models import AIProvider, GeminiModel, OpenAIModel, xAI_Model, RetabModel, PureLLMModel, ModelCard
 
+MODEL_CARDS_DIR = os.path.join(os.path.dirname(__file__), "_model_cards")
 
-def find_provider_from_model(model: str) -> AIProvider:
-    if model in get_args(OpenAIModel):
-        return "OpenAI"
-    elif ":" in model:
-        # Handle fine-tuned models
-        ft, base_model, model_id = model.split(":", 2)
-        if base_model in get_args(OpenAIModel):
-            return "OpenAI"
-    # elif model in get_args(AnthropicModel):
-    #    return "Anthropic"
-    elif model in get_args(xAI_Model):
-        return "xAI"
-    elif model in get_args(GeminiModel):
-        return "Gemini"
-    raise ValueError(f"Could not determine AI provider for model: {model}")
+def merge_model_cards(base: dict, override: dict) -> dict:
+    result = base.copy()
+    for key, value in override.items():
+        if key == "inherits":
+            continue
+        if isinstance(value, dict) and key in result:
+            result[key] = merge_model_cards(result[key], value)
+        else:
+            result[key] = value
+    return result
 
+def load_model_cards(yaml_file: str) -> list[ModelCard]:
+    raw_cards = yaml.safe_load(open(yaml_file))
+    name_to_card = {c["model"]: c for c in raw_cards if "inherits" not in c}
 
-def assert_valid_model_extraction(model: str) -> None:
-    if model in get_args(OpenAIModel):
-        return
-    elif ":" in model:
-        # Handle fine-tuned models
-        ft, base_model, model_id = model.split(":", 2)
-        if base_model in get_args(OpenAIModel):
-            return
-    # elif model in get_args(AnthropicModel):
-    #    return
-    elif model in get_args(xAI_Model):
-        return
-    elif model in get_args(GeminiModel):
-        return
-    raise ValueError(
-        f"Invalid model for extraction: {model}.\nValid OpenAI models: {get_args(OpenAIModel)}\n"
-        # f"Valid Anthropic models: {get_args(AnthropicModel)}\n"
-        # f"Valid xAI models: {get_args(xAI_Model)}\n"
-        # f"Valid Gemini models: {get_args(GeminiModel)}"
-    )
+    final_cards = []
+    for card in raw_cards:
+        if "inherits" in card:
+            parent = name_to_card[card["inherits"]]
+            merged = merge_model_cards(parent, card)
+            final_cards.append(ModelCard(**merged))
+        else:
+            final_cards.append(ModelCard(**card))
+    return final_cards
 
+# Load all model cards
+model_cards = sum([
+    load_model_cards(os.path.join(MODEL_CARDS_DIR, "openai.yaml")),
+    load_model_cards(os.path.join(MODEL_CARDS_DIR, "anthropic.yaml")),
+    load_model_cards(os.path.join(MODEL_CARDS_DIR, "xai.yaml")),
+    load_model_cards(os.path.join(MODEL_CARDS_DIR, "gemini.yaml")),
+    load_model_cards(os.path.join(MODEL_CARDS_DIR, "auto.yaml")),
+], [])
+model_cards_dict = {card.model: card for card in model_cards}
 
-def assert_valid_model_batch_processing(model: str) -> None:
-    """Assert that the model is either a standard OpenAI model or a valid fine-tuned model.
 
-    Valid formats:
-    - Standard model: Must be in OpenAIModel
-    - Fine-tuned model: Must be {base_model}:{id} where base_model is in OpenAIModel
+# Validate that model cards
+all_model_names = set(model_cards_dict.keys())
+if all_model_names.symmetric_difference(set(get_args(PureLLMModel))):
+    raise ValueError(f"Mismatch between model cards and PureLLMModel type: {all_model_names.symmetric_difference(set(get_args(PureLLMModel)))}")
+
+
+def get_model_from_model_id(model_id: str) -> str:
+    """
+    Get the model name from the model id.
+    """
+    if model_id.startswith("ft:"):
+        parts = model_id.split(":")
+        return parts[1]
+    else:
+        return model_id
+
+
+def get_model_card(model: str) -> ModelCard:
+    """
+    Get the model card for a specific model.
+
+    Args:
+        model: The model name to look up
+
+    Returns:
+        The ModelCard for the specified model
 
     Raises:
-        ValueError: If the model format is invalid
+        ValueError: If no model card is found for the specified model
     """
-    if model in get_args(OpenAIModel):
-        return
+    model_name = get_model_from_model_id(model)
+    if model_name in model_cards_dict:
+        model_card = ModelCard(**model_cards_dict[model_name].model_dump())
+        if model_name != model:
+            # Fine-tuned model -> Change the name
+            model_card.model = model
+            # Remove the fine-tuning feature (if exists)
+            try:
+                model_card.capabilities.features.remove("fine_tuning")
+            except ValueError:
+                pass
+        return model_card
+
+    raise ValueError(f"No model card found for model: {model_name}")
 
-    try:
-        ft, base_model, model_id = model.split(":", 2)
-        if base_model not in get_args(OpenAIModel):
-            raise ValueError(f"Invalid base model in fine-tuned model '{model}'. Base model must be one of: {get_args(OpenAIModel)}")
-        if not model_id or not model_id.strip():
-            raise ValueError(f"Model ID cannot be empty in fine-tuned model '{model}'")
+
+def get_provider_for_model(model_id: str) -> AIProvider:
+    """
+    Determine the AI provider associated with the given model identifier.
+    Returns one of: "Anthropic", "xAI", "OpenAI", "Gemini", "Retab" or None if unknown.
+    """
+    model_name = get_model_from_model_id(model_id)
+    # if model_name in get_args(AnthropicModel):
+    #     return "Anthropic"
+    # if model_name in get_args(xAI_Model):
+    #     return "xAI"
+    if model_name in get_args(OpenAIModel):
+        return "OpenAI"
+    if model_name in get_args(GeminiModel):
+        return "Gemini"
+    if model_name in get_args(RetabModel):
+        return "Retab"
+    raise ValueError(f"Unknown model: {model_name}")
+
+
+def assert_valid_model_extraction(model: str) -> None:
+    try: 
+        get_provider_for_model(model)
     except ValueError:
-        if ":" not in model:
-            raise ValueError(
-                f"Invalid model format: {model}. Must be either:\n"
-                f"1. A standard model: {get_args(OpenAIModel)}\n"
-                f"2. A fine-tuned model in format 'base_model:id' where base_model is one of the standard models"
-            ) from None
-        raise
+        raise ValueError(
+            f"Invalid model for extraction: {model}.\nValid OpenAI models: {get_args(OpenAIModel)}\n"
+            f"Valid xAI models: {get_args(xAI_Model)}\n"
+            f"Valid Gemini models: {get_args(GeminiModel)}"
+        ) from None
 
 
 def assert_valid_model_schema_generation(model: str) -> None:
@@ -81,20 +128,11 @@ def assert_valid_model_schema_generation(model: str) -> None:
     Raises:
         ValueError: If the model format is invalid
     """
-    if model in get_args(OpenAIModel):
+    if get_model_from_model_id(model) in get_args(OpenAIModel):
         return
-
-    try:
-        ft, base_model, model_id = model.split(":", 2)
-        if base_model not in get_args(OpenAIModel):
-            raise ValueError(f"Invalid base model in fine-tuned model '{model}'. Base model must be one of: {get_args(OpenAIModel)}")
-        if not model_id or not model_id.strip():
-            raise ValueError(f"Model ID cannot be empty in fine-tuned model '{model}'")
-    except ValueError:
-        if ":" not in model:
-            raise ValueError(
+    else:
+        raise ValueError(
                 f"Invalid model format: {model}. Must be either:\n"
                 f"1. A standard model: {get_args(OpenAIModel)}\n"
-                f"2. A fine-tuned model in format 'base_model:id' where base_model is one of the standard models"
-            ) from None
-        raise
+                f"2. A fine-tuned model in format 'base_model:id' where base_model is one of the standard openai models"
+            ) from 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.documents.extractions import UiParsedChatCompletion, UiParsedChoice
+from ..types.chat import ChatCompletionRetabMessage
+from ..types.documents.extractions import RetabParsedChatCompletion, RetabParsedChoice
 
 
-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,23 +110,23 @@ 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
 
 
-def parse_openai_responses_response(response: Response) -> UiParsedChatCompletion:
+def parse_openai_responses_response(response: Response) -> RetabParsedChatCompletion:
     """
-    Convert an OpenAI Response (Responses API) to UiParsedChatCompletion type.
+    Convert an OpenAI Response (Responses API) to RetabParsedChatCompletion type.
 
     Args:
         response: Response from OpenAI Responses API
 
     Returns:
-        Parsed response in UiParsedChatCompletion format
+        Parsed response in RetabParsedChatCompletion format
     """
-    # Create the UiParsedChatCompletion object
+    # Create the RetabParsedChatCompletion object
     if response.usage:
         usage = CompletionUsage(
             prompt_tokens=response.usage.input_tokens,
@@ -148,7 +148,7 @@ def parse_openai_responses_response(response: Response) -> UiParsedChatCompletio
     result_object = from_json(bytes(output_text, "utf-8"), partial_mode=True)  # Attempt to parse the result even if EOF is reached
 
     choices.append(
-        UiParsedChoice(
+        RetabParsedChoice(
             index=0,
             message=ParsedChatCompletionMessage(
                 role="assistant",
@@ -158,7 +158,7 @@ def parse_openai_responses_response(response: Response) -> UiParsedChatCompletio
         )
     )
 
-    return UiParsedChatCompletion(
+    return RetabParsedChatCompletion(
         id=response.id,
         choices=choices,
         created=int(datetime.datetime.now().timestamp()),

retab/_utils/usage/usage.py

@@ -4,7 +4,8 @@ from openai.types.completion_usage import CompletionUsage
 from pydantic import BaseModel, Field
 
 # https://platform.openai.com/docs/guides/prompt-caching
-from ...types.ai_models import Amount, Pricing, get_model_card
+from ...types.ai_models import Amount, Pricing
+from ..._utils.ai_models import get_model_card
 
 # ─── PRICING MODELS ────────────────────────────────────────────────────────────
 
@@ -78,7 +79,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 +271,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 +280,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)