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

{uiform → retab}/resources/schemas.py

@@ -1,22 +1,23 @@
 from io import IOBase
 from pathlib import Path
-from typing import Any, List, Optional, Sequence
+from typing import Any, Sequence
 
 import PIL.Image
+from openai.types.chat.chat_completion_reasoning_effort import ChatCompletionReasoningEffort
 from pydantic import BaseModel
 
 from .._resource import AsyncAPIResource, SyncAPIResource
 from .._utils.ai_models import assert_valid_model_schema_generation
 from .._utils.json_schema import load_json_schema
 from .._utils.mime import prepare_mime_document_list
-from ..types.modalities import Modality
 from ..types.mime import MIMEData
-from ..types.schemas.generate import GenerateSchemaRequest
+from ..types.modalities import Modality
 from ..types.schemas.enhance import EnhanceSchemaConfig, EnhanceSchemaConfigDict, EnhanceSchemaRequest
 from ..types.schemas.evaluate import EvaluateSchemaRequest, EvaluateSchemaResponse
+from ..types.schemas.generate import GenerateSchemaRequest
 from ..types.schemas.object import Schema
 from ..types.standards import PreparedRequest
-from openai.types.chat.chat_completion_reasoning_effort import ChatCompletionReasoningEffort
+from ..types.browser_canvas import BrowserCanvas
 
 
 class SchemasMixin:
@@ -27,18 +28,19 @@ class SchemasMixin:
         model: str = "gpt-4o-2024-11-20",
         temperature: float = 0,
         modality: Modality = "native",
+        reasoning_effort: ChatCompletionReasoningEffort = "medium",
     ) -> PreparedRequest:
         assert_valid_model_schema_generation(model)
         mime_documents = prepare_mime_document_list(documents)
-        data = {
-            "documents": [doc.model_dump() for doc in mime_documents],
-            "instructions": instructions if instructions else None,
-            "model": model,
-            "temperature": temperature,
-            "modality": modality,
-        }
-        GenerateSchemaRequest.model_validate(data)
-        return PreparedRequest(method="POST", url="/v1/schemas/generate", data=data)
+        request = GenerateSchemaRequest(
+            documents=mime_documents,
+            instructions=instructions if instructions else None,
+            model=model,
+            temperature=temperature,
+            modality=modality,
+            reasoning_effort=reasoning_effort,
+        )
+        return PreparedRequest(method="POST", url="/v1/schemas/generate", data=request.model_dump())
 
     def prepare_evaluate(
         self,
@@ -46,61 +48,53 @@ class SchemasMixin:
         json_schema: dict[str, Any],
         ground_truths: list[dict[str, Any]] | None = None,
         model: str = "gpt-4o-mini",
-        temperature: float = 0.0,
         reasoning_effort: ChatCompletionReasoningEffort = "medium",
         modality: Modality = "native",
         image_resolution_dpi: int = 96,
-        browser_canvas: str = "A4",
+        browser_canvas: BrowserCanvas = "A4",
         n_consensus: int = 1,
     ) -> PreparedRequest:
-        # Assert that if ground_truths is not None, it has the same length as documents
-        if ground_truths is not None and len(documents) != len(ground_truths):
-            raise ValueError("Number of documents must match number of ground truths")
-
         mime_documents = prepare_mime_document_list(documents)
-        data = {
-            "documents": [doc.model_dump() for doc in mime_documents],
-            "ground_truths": ground_truths,
-            "model": model,
-            "temperature": temperature,
-            "reasoning_effort": reasoning_effort,
-            "modality": modality,
-            "image_resolution_dpi": image_resolution_dpi,
-            "browser_canvas": browser_canvas,
-            "n_consensus": n_consensus,
-            "json_schema": json_schema,
-        }
-        EvaluateSchemaRequest.model_validate(data)
-        return PreparedRequest(method="POST", url="/v1/schemas/evaluate", data=data)
+        request = EvaluateSchemaRequest(
+            documents=mime_documents,
+            json_schema=json_schema,
+            ground_truths=ground_truths,
+            model=model,
+            reasoning_effort=reasoning_effort,
+            modality=modality,
+            image_resolution_dpi=image_resolution_dpi,
+            browser_canvas=browser_canvas,
+            n_consensus=n_consensus,
+        )
+        return PreparedRequest(method="POST", url="/v1/schemas/evaluate", data=request.model_dump())
 
     def prepare_enhance(
         self,
         json_schema: dict[str, Any] | Path | str,
         documents: Sequence[Path | str | bytes | MIMEData | IOBase | PIL.Image.Image],
-        ground_truths: list[dict[str, Any]] | None,
-        instructions: str | None,
-        model: str,
-        temperature: float,
-        modality: Modality,
-        flat_likelihoods: list[dict[str, float]] | dict[str, float] | None,
-        tools_config: EnhanceSchemaConfig,
+        ground_truths: list[dict[str, Any]] | None = None,
+        instructions: str | None = None,
+        model: str = "gpt-4o-mini",
+        temperature: float = 0.0,
+        modality: Modality = "native",
+        flat_likelihoods: list[dict[str, float]] | dict[str, float] | None = None,
+        tools_config: EnhanceSchemaConfig = EnhanceSchemaConfig(),
     ) -> PreparedRequest:
         assert_valid_model_schema_generation(model)
         mime_documents = prepare_mime_document_list(documents)
         loaded_json_schema = load_json_schema(json_schema)
-        data = {
-            "json_schema": loaded_json_schema,
-            "documents": [doc.model_dump() for doc in mime_documents],
-            "ground_truths": ground_truths,
-            "instructions": instructions if instructions else None,
-            "model": model,
-            "temperature": temperature,
-            "modality": modality,
-            "flat_likelihoods": flat_likelihoods,
-            "tools_config": tools_config.model_dump(),
-        }
-        EnhanceSchemaRequest.model_validate(data)
-        return PreparedRequest(method="POST", url="/v1/schemas/enhance", data=data)
+        request = EnhanceSchemaRequest(
+            json_schema=loaded_json_schema,
+            documents=mime_documents,
+            ground_truths=ground_truths,
+            instructions=instructions if instructions else None,
+            model=model,
+            temperature=temperature,
+            modality=modality,
+            flat_likelihoods=flat_likelihoods,
+            tools_config=tools_config,
+        )
+        return PreparedRequest(method="POST", url="/v1/schemas/enhance", data=request.model_dump())
 
     def prepare_get(self, schema_id: str) -> PreparedRequest:
         return PreparedRequest(method="GET", url=f"/v1/schemas/{schema_id}")
@@ -155,11 +149,10 @@ class Schemas(SyncAPIResource, SchemasMixin):
         json_schema: dict[str, Any],
         ground_truths: list[dict[str, Any]] | None = None,
         model: str = "gpt-4o-mini",
-        temperature: float = 0.0,
         reasoning_effort: ChatCompletionReasoningEffort = "medium",
         modality: Modality = "native",
         image_resolution_dpi: int = 96,
-        browser_canvas: str = "A4",
+        browser_canvas: BrowserCanvas = "A4",
         n_consensus: int = 1,
     ) -> EvaluateSchemaResponse:
         """
@@ -172,13 +165,12 @@ class Schemas(SyncAPIResource, SchemasMixin):
             json_schema: The JSON schema to evaluate
             ground_truths: Optional list of ground truth dictionaries to compare against
             model: The model to use for extraction
-            temperature: The temperature to use for extraction
             reasoning_effort: The reasoning effort to use for extraction
             modality: The modality to use for extraction
             image_resolution_dpi: The DPI of the image. Defaults to 96.
             browser_canvas: The canvas size of the browser. Must be one of:
                 - "A3" (11.7in x 16.54in)
-                - "A4" (8.27in x 11.7in) 
+                - "A4" (8.27in x 11.7in)
                 - "A5" (5.83in x 8.27in)
                 Defaults to "A4".
             n_consensus: Number of consensus rounds to perform
@@ -200,7 +192,6 @@ class Schemas(SyncAPIResource, SchemasMixin):
             json_schema=json_schema,
             ground_truths=ground_truths,
             model=model,
-            temperature=temperature,
             reasoning_effort=reasoning_effort,
             modality=modality,
             image_resolution_dpi=image_resolution_dpi,
@@ -222,8 +213,17 @@ class Schemas(SyncAPIResource, SchemasMixin):
         flat_likelihoods: list[dict[str, float]] | dict[str, float] | None = None,
         tools_config: EnhanceSchemaConfigDict | None = None,
     ) -> Schema:
+        _tools_config = EnhanceSchemaConfig(**(tools_config or {}))
         prepared_request = self.prepare_enhance(
-            json_schema, documents, ground_truths, instructions, model, temperature, modality, flat_likelihoods, EnhanceSchemaConfig.model_validate(tools_config or {})
+            json_schema=json_schema,
+            documents=documents,
+            ground_truths=ground_truths,
+            instructions=instructions,
+            model=model,
+            temperature=temperature,
+            modality=modality,
+            flat_likelihoods=flat_likelihoods,
+            tools_config=_tools_config,
         )
         response = self._client._prepared_request(prepared_request)
         return Schema(json_schema=response["json_schema"])
@@ -285,7 +285,13 @@ class AsyncSchemas(AsyncAPIResource, SchemasMixin):
         Raises
             HTTPException if the request fails
         """
-        prepared_request = self.prepare_generate(documents, instructions, model, temperature, modality)
+        prepared_request = self.prepare_generate(
+            documents=documents,
+            instructions=instructions,
+            model=model,
+            temperature=temperature,
+            modality=modality,
+        )
         response = await self._client._prepared_request(prepared_request)
         return Schema.model_validate(response)
 
@@ -295,11 +301,10 @@ class AsyncSchemas(AsyncAPIResource, SchemasMixin):
         json_schema: dict[str, Any],
         ground_truths: list[dict[str, Any]] | None = None,
         model: str = "gpt-4o-mini",
-        temperature: float = 0.0,
         reasoning_effort: ChatCompletionReasoningEffort = "medium",
         modality: Modality = "native",
         image_resolution_dpi: int = 96,
-        browser_canvas: str = "A4",
+        browser_canvas: BrowserCanvas = "A4",
         n_consensus: int = 1,
     ) -> EvaluateSchemaResponse:
         """
@@ -312,13 +317,12 @@ class AsyncSchemas(AsyncAPIResource, SchemasMixin):
             json_schema: The JSON schema to evaluate
             ground_truths: Optional list of ground truth dictionaries to compare against
             model: The model to use for extraction
-            temperature: The temperature to use for extraction
             reasoning_effort: The reasoning effort to use for extraction
             modality: The modality to use for extraction
             image_resolution_dpi: The DPI of the image. Defaults to 96.
             browser_canvas: The canvas size of the browser. Must be one of:
                 - "A3" (11.7in x 16.54in)
-                - "A4" (8.27in x 11.7in) 
+                - "A4" (8.27in x 11.7in)
                 - "A5" (5.83in x 8.27in)
                 Defaults to "A4".
             n_consensus: Number of consensus rounds to perform
@@ -340,7 +344,6 @@ class AsyncSchemas(AsyncAPIResource, SchemasMixin):
             json_schema=json_schema,
             ground_truths=ground_truths,
             model=model,
-            temperature=temperature,
             reasoning_effort=reasoning_effort,
             modality=modality,
             image_resolution_dpi=image_resolution_dpi,
@@ -362,8 +365,17 @@ class AsyncSchemas(AsyncAPIResource, SchemasMixin):
         flat_likelihoods: list[dict[str, float]] | dict[str, float] | None = None,
         tools_config: EnhanceSchemaConfigDict | None = None,
     ) -> Schema:
+        _tools_config = EnhanceSchemaConfig(**(tools_config or {}))
         prepared_request = self.prepare_enhance(
-            json_schema, documents, ground_truths, instructions, model, temperature, modality, flat_likelihoods, EnhanceSchemaConfig.model_validate(tools_config or {})
+            json_schema=json_schema,
+            documents=documents,
+            ground_truths=ground_truths,
+            instructions=instructions,
+            model=model,
+            temperature=temperature,
+            modality=modality,
+            flat_likelihoods=flat_likelihoods,
+            tools_config=_tools_config,
         )
         response = await self._client._prepared_request(prepared_request)
         return Schema(json_schema=response["json_schema"])

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

@@ -1,4 +1,3 @@
-import os
 from typing import List
 
 from ..._resource import AsyncAPIResource, SyncAPIResource
@@ -9,8 +8,7 @@ from ...types.standards import PreparedRequest
 
 class ExternalAPIKeysMixin:
     def prepare_create(self, provider: AIProvider, api_key: str) -> PreparedRequest:
-        data = {"provider": provider, "api_key": api_key}
-        request = ExternalAPIKeyRequest.model_validate(data)
+        request = ExternalAPIKeyRequest(provider=provider, api_key=api_key)
         return PreparedRequest(method="POST", url="/v1/secrets/external_api_keys", data=request.model_dump(mode="json"))
 
     def prepare_get(self, provider: AIProvider) -> PreparedRequest:
@@ -55,8 +53,6 @@ class ExternalAPIKeys(SyncAPIResource, ExternalAPIKeysMixin):
         """
         request = self.prepare_get(provider)
         response = self._client._prepared_request(request)
-        return response
-
         return ExternalAPIKey.model_validate(response)
 
     def list(self) -> List[ExternalAPIKey]:

retab/resources/secrets/webhook.py

@@ -0,0 +1,64 @@
+# TODO: Implement webhook secret management
+
+# from ..._resource import AsyncAPIResource, SyncAPIResource
+# from ...types.standards import PreparedRequest
+
+
+# class WebhookMixin:
+#     def prepare_create(self) -> PreparedRequest:
+#         return PreparedRequest(method="POST", url="/v1/secrets/webhook")
+
+#     def prepare_delete(self) -> PreparedRequest:
+#         return PreparedRequest(method="DELETE", url="/v1/secrets/webhook")
+
+
+# class Webhook(SyncAPIResource, WebhookMixin):
+#     """Webhook secret management wrapper"""
+
+#     def create(
+#         self,
+#     ) -> dict:
+#         """Create a webhook secret.
+
+#         Returns:
+#             dict: Response indicating success
+#         """
+#         request = self.prepare_create()
+#         response = self._client._prepared_request(request)
+
+#         return response
+
+#     def delete(self) -> dict:
+#         """Delete a webhook secret.
+
+#         Returns:
+#             dict: Response indicating success
+#         """
+#         request = self.prepare_delete()
+#         response = self._client._prepared_request(request)
+
+#         return response
+
+
+# class AsyncWebhook(AsyncAPIResource, WebhookMixin):
+#     """Webhook secret management wrapper"""
+
+#     async def create(self) -> dict:
+#         """Create a webhook secret.
+
+#         Returns:
+#             dict: Response indicating success
+#         """
+#         request = self.prepare_create()
+#         response = await self._client._prepared_request(request)
+#         return response
+
+#     async def delete(self) -> dict:
+#         """Delete a webhook secret.
+
+#         Returns:
+#             dict: Response indicating success
+#         """
+#         request = self.prepare_delete()
+#         response = await self._client._prepared_request(request)
+#         return response

{uiform → retab}/resources/usage.py

@@ -6,7 +6,7 @@ from openai.types.chat.chat_completion import ChatCompletion
 from pydantic import BaseModel
 
 from .._resource import AsyncAPIResource, SyncAPIResource
-from ..types.ai_models import Amount
+from ..types.ai_models import Amount, MonthlyUsageResponse
 from ..types.logs import AutomationLog, LogCompletionRequest
 from ..types.standards import PreparedRequest
 
@@ -14,8 +14,17 @@ total_cost = 0.0
 
 
 class UsageMixin:
+    def prepare_monthly_credits_usage(self) -> PreparedRequest:
+        return PreparedRequest(method="GET", url="/v1/usage/monthly_credits")
+
     def prepare_total(self, start_date: Optional[datetime.datetime] = None, end_date: Optional[datetime.datetime] = None) -> PreparedRequest:
-        raise NotImplementedError("prepare_total is not implemented")
+        params = {}
+        if start_date:
+            params["start_date"] = start_date.isoformat()
+        if end_date:
+            params["end_date"] = end_date.isoformat()
+
+        return PreparedRequest(method="GET", url="/v1/usage/total", params=params)
 
     def prepare_mailbox(self, email: str, start_date: Optional[datetime.datetime] = None, end_date: Optional[datetime.datetime] = None) -> PreparedRequest:
         params = {}
@@ -72,6 +81,20 @@ class UsageMixin:
 
 
 class Usage(SyncAPIResource, UsageMixin):
+    def monthly_credits_usage(self) -> MonthlyUsageResponse:
+        """
+        Get monthly credits usage information.
+
+        Returns:
+            dict: Monthly usage data including credits consumed and limits
+
+        Raises:
+            UiformAPIError: If the API request fails
+        """
+        request = self.prepare_monthly_credits_usage()
+        response = self._client._request(request.method, request.url, request.data, request.params)
+        return MonthlyUsageResponse.model_validate(response)
+
     def total(self, start_date: Optional[datetime.datetime] = None, end_date: Optional[datetime.datetime] = None) -> Amount:
         """Get the total usage cost for a mailbox within an optional date range.
 
@@ -172,6 +195,20 @@ class Usage(SyncAPIResource, UsageMixin):
 
 
 class AsyncUsage(AsyncAPIResource, UsageMixin):
+    async def monthly_credits_usage(self) -> MonthlyUsageResponse:
+        """
+        Get monthly credits usage information.
+
+        Returns:
+            dict: Monthly usage data including credits consumed and limits
+
+        Raises:
+            UiformAPIError: If the API request fails
+        """
+        request = self.prepare_monthly_credits_usage()
+        response = await self._client._request(request.method, request.url, request.data, request.params)
+        return MonthlyUsageResponse.model_validate(response)
+
     async def total(self, start_date: Optional[datetime.datetime] = None, end_date: Optional[datetime.datetime] = None) -> Amount:
         """Get the total usage cost for a mailbox within an optional date range.
 

{uiform → retab}/types/ai_models.py

@@ -1,8 +1,14 @@
-from typing import Literal
+import datetime
+from typing import List, Literal, Optional
+
+from pydantic import BaseModel, Field
+
+from .inference_settings import InferenceSettings
 
 AIProvider = Literal["OpenAI", "Gemini", "xAI", "UiForm"]  # , "Anthropic", "xAI"]
 OpenAICompatibleProvider = Literal["OpenAI", "xAI"]  # , "xAI"]
 GeminiModel = Literal[
+    "gemini-2.5-pro-preview-06-05",
     "gemini-2.5-pro-preview-05-06",
     "gemini-2.5-flash-preview-05-20",
     "gemini-2.5-flash-preview-04-17",
@@ -49,12 +55,6 @@ xAI_Model = Literal["grok-3-beta", "grok-3-mini-beta"]
 UiFormModel = Literal["auto", "auto-small"]
 LLMModel = Literal[OpenAIModel, "human", AnthropicModel, xAI_Model, GeminiModel, UiFormModel]
 
-import datetime
-
-from pydantic import BaseModel, Field
-
-from uiform.types.jobs.base import InferenceSettings
-
 
 class FinetunedModel(BaseModel):
     object: Literal["finetuned_model"] = "finetuned_model"
@@ -67,11 +67,6 @@ class FinetunedModel(BaseModel):
     created_at: datetime.datetime = Field(default_factory=lambda: datetime.datetime.now(datetime.timezone.utc))
 
 
-from typing import Dict, List, Literal, Optional
-
-from pydantic import BaseModel
-
-
 # Monthly Usage
 class MonthlyUsageResponseContent(BaseModel):
     request_count: int
@@ -542,6 +537,11 @@ gemini_model_cards = [
         capabilities=ModelCapabilities(modalities=["text", "image"], endpoints=["chat_completions"], features=["streaming", "function_calling", "structured_outputs"]),
         temperature_support=True,
     ),
+    ModelCard(
+        model="gemini-2.5-pro-preview-06-05",
+        pricing=Pricing(text=TokenPrice(prompt=1.25, cached_discount=0.25, completion=10.00), audio=None),
+        capabilities=ModelCapabilities(modalities=["text", "image"], endpoints=["chat_completions"], features=["streaming", "function_calling", "structured_outputs"]),
+    ),
     ModelCard(
         model="gemini-2.5-pro-preview-05-06",
         pricing=Pricing(text=TokenPrice(prompt=1.25, cached_discount=0.25, completion=10.00), audio=None),
@@ -556,7 +556,7 @@ gemini_model_cards = [
     ModelCard(
         model="gemini-2.5-flash-preview-04-17",
         pricing=Pricing(text=TokenPrice(prompt=0.15, cached_discount=0.25, completion=0.60), audio=None),
-        capabilities=ModelCapabilities(modalities=["text", "image"], endpoints=["chat_completions"], features=["streaming", "function_calling", "structured_outputs"]), 
+        capabilities=ModelCapabilities(modalities=["text", "image"], endpoints=["chat_completions"], features=["streaming", "function_calling", "structured_outputs"]),
         temperature_support=True,
     ),
     ModelCard(

{uiform → retab}/types/automations/cron.py

@@ -1,11 +1,13 @@
 import datetime
-from typing import Any, Literal, Optional
+from typing import Any, Optional
 
 import nanoid  # type: ignore
 from openai.types.chat.chat_completion_reasoning_effort import ChatCompletionReasoningEffort
-from pydantic import BaseModel, Field, HttpUrl, field_serializer
+from pydantic import BaseModel, Field, HttpUrl, computed_field, field_validator
 
+from ..logs import AutomationConfig
 from ..modalities import Modality
+from ..browser_canvas import BrowserCanvas
 
 
 def scrapping_action(link: HttpUrl) -> dict[str, Any]:
@@ -24,26 +26,29 @@ class CronSchedule(BaseModel):
         return f"{self.second or '*'} {self.minute} {self.hour} {self.day_of_month or '*'} {self.month or '*'} {self.day_of_week or '*'}"
 
 
-from ..logs import AutomationConfig
-
-
 class ScrappingConfig(AutomationConfig):
-    object: Literal['automation.scrapping_cron'] = "automation.scrapping_cron"
+    @computed_field
+    @property
+    def object(self) -> str:
+        return "automation.scrapping_cron"
+
     id: str = Field(default_factory=lambda: "scrapping_" + nanoid.generate(), description="Unique identifier for the scrapping job")
 
     # Scrapping Specific Config
-    link: HttpUrl = Field(..., description="Link to be scrapped")
+    link: str = Field(..., description="Link to be scrapped")
     schedule: CronSchedule
 
     updated_at: datetime.datetime = Field(default_factory=lambda: datetime.datetime.now(datetime.timezone.utc))
 
     # HTTP Config
-    webhook_url: HttpUrl = Field(..., description="Url of the webhook to send the data to")
+    webhook_url: str = Field(..., description="Url of the webhook to send the data to")
     webhook_headers: dict[str, str] = Field(default_factory=dict, description="Headers to send with the request")
 
     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(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."
+    )
 
     # New attributes
     model: str = Field(..., description="Model used for chat completion")
@@ -53,6 +58,8 @@ class ScrappingConfig(AutomationConfig):
         default="medium", description="The effort level for the model to reason about the input data. If not provided, the default reasoning effort for the model will be used."
     )
 
-    @field_serializer('webhook_url', 'link')
-    def url2str(self, val: HttpUrl) -> str:
-        return str(val)
+    @field_validator("webhook_url", "link", mode="after")
+    def validate_httpurl(cls, val: Any) -> Any:
+        if isinstance(val, str):
+            HttpUrl(val)
+        return val

{uiform → retab}/types/automations/endpoints.py

@@ -1,16 +1,19 @@
-from typing import Literal
-
 import nanoid  # type: ignore
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, computed_field
 
 from ..logs import AutomationConfig, UpdateAutomationRequest
 from ..pagination import ListMetadata
 
 
 class Endpoint(AutomationConfig):
-    object: Literal['automation.endpoint'] = "automation.endpoint"
+    @computed_field
+    @property
+    def object(self) -> str:
+        return "automation.endpoint"
+
     id: str = Field(default_factory=lambda: "endp_" + nanoid.generate(), description="Unique identifier for the extraction endpoint")
 
+
 class ListEndpoints(BaseModel):
     data: list[Endpoint]
     list_metadata: ListMetadata

{uiform → retab}/types/automations/links.py

@@ -1,14 +1,18 @@
-from typing import Literal, Optional
+from typing import Optional
 
 import nanoid  # type: ignore
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, computed_field
 
 from ..logs import AutomationConfig, UpdateAutomationRequest
 from ..pagination import ListMetadata
 
 
 class Link(AutomationConfig):
-    object: Literal['automation.link'] = "automation.link"
+    @computed_field
+    @property
+    def object(self) -> str:
+        return "automation.link"
+
     id: str = Field(default_factory=lambda: "lnk_" + nanoid.generate(), description="Unique identifier for the extraction link")
 
     # Link Specific Config

{uiform → retab}/types/automations/mailboxes.py

@@ -1,22 +1,23 @@
 import os
 import re
-from typing import ClassVar, List, Literal, Optional
+from typing import ClassVar, List, Optional
 
 import nanoid  # type: ignore
-from pydantic import BaseModel, EmailStr, Field, field_validator
+from pydantic import BaseModel, EmailStr, Field, computed_field, field_validator
 
+from ..logs import AutomationConfig, UpdateAutomationRequest
 from ..pagination import ListMetadata
 
 domain_pattern = re.compile(r"^(?:[a-zA-Z0-9-]+\.)+[a-zA-Z]{2,}$")
 
-from openai.types.chat.chat_completion_reasoning_effort import ChatCompletionReasoningEffort
-
-from ..logs import AutomationConfig, UpdateAutomationRequest
-
 
 class Mailbox(AutomationConfig):
+    @computed_field
+    @property
+    def object(self) -> str:
+        return "automation.mailbox"
+
     EMAIL_PATTERN: ClassVar[str] = f".*@{os.getenv('EMAIL_DOMAIN', 'mailbox.uiform.com')}$"
-    object: Literal['automation.mailbox'] = "automation.mailbox"
     id: str = Field(default_factory=lambda: "mb_" + nanoid.generate(), description="Unique identifier for the mailbox")
 
     # Email Specific config
@@ -33,7 +34,7 @@ class Mailbox(AutomationConfig):
     def normalize_authorized_emails(cls, emails: List[str]) -> List[str]:
         return [email.strip().lower() for email in emails]
 
-    @field_validator('authorized_domains', mode='before')
+    @field_validator("authorized_domains", mode="before")
     def validate_domain(cls, list_domains: list[str]) -> list[str]:
         for domain in list_domains:
             if not domain_pattern.match(domain):
@@ -48,7 +49,6 @@ class ListMailboxes(BaseModel):
 
 # Inherits from the methods of UpdateAutomationRequest
 class UpdateMailboxRequest(UpdateAutomationRequest):
-
     # ------------------------------
     # Email Specific config
     # ------------------------------