retab 0.0.35__py3-none-any.whl

uiform/types/automations/cron.py

@@ -0,0 +1,58 @@
+import datetime
+from typing import Any, Literal, Optional
+
+import nanoid  # type: ignore
+from openai.types.chat.chat_completion_reasoning_effort import ChatCompletionReasoningEffort
+from pydantic import BaseModel, Field, HttpUrl, field_serializer
+
+from ..modalities import Modality
+
+
+def scrapping_action(link: HttpUrl) -> dict[str, Any]:
+    raise NotImplementedError("Scrapping action not implemented")
+
+
+class CronSchedule(BaseModel):
+    second: Optional[int] = Field(0, ge=0, le=59, description="Second (0-59), defaults to 0")
+    minute: int = Field(..., ge=0, le=59, description="Minute (0-59)")
+    hour: int = Field(..., ge=0, le=23, description="Hour (0-23)")
+    day_of_month: Optional[int] = Field(None, ge=1, le=31, description="Day of the month (1-31), None means any day")
+    month: Optional[int] = Field(None, ge=1, le=12, description="Month (1-12), None means every month")
+    day_of_week: Optional[int] = Field(None, ge=0, le=6, description="Day of the week (0-6, Sunday = 0), None means any day")
+
+    def to_cron_string(self) -> str:
+        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"
+    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")
+    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_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.")
+
+    # New attributes
+    model: str = Field(..., description="Model used for chat completion")
+    json_schema: dict[str, Any] = Field(..., description="JSON schema format used to validate the output data.")
+    temperature: float = Field(default=0.0, description="Temperature for sampling. If not provided, the default temperature for the model will be used.", examples=[0.0])
+    reasoning_effort: ChatCompletionReasoningEffort = Field(
+        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)

uiform/types/automations/endpoints.py

@@ -0,0 +1,21 @@
+from typing import Literal
+
+import nanoid  # type: ignore
+from pydantic import BaseModel, Field
+
+from ..logs import AutomationConfig, UpdateAutomationRequest
+from ..pagination import ListMetadata
+
+
+class Endpoint(AutomationConfig):
+    object: Literal['automation.endpoint'] = "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
+
+
+# Inherits from the methods of UpdateAutomationRequest
+class UpdateEndpointRequest(UpdateAutomationRequest):
+    pass

uiform/types/automations/links.py

@@ -0,0 +1,28 @@
+from typing import Literal, Optional
+
+import nanoid  # type: ignore
+from pydantic import BaseModel, Field
+
+from ..logs import AutomationConfig, UpdateAutomationRequest
+from ..pagination import ListMetadata
+
+
+class Link(AutomationConfig):
+    object: Literal['automation.link'] = "automation.link"
+    id: str = Field(default_factory=lambda: "lnk_" + nanoid.generate(), description="Unique identifier for the extraction link")
+
+    # Link Specific Config
+    password: Optional[str] = Field(None, description="Password to access the link")
+
+
+class ListLinks(BaseModel):
+    data: list[Link]
+    list_metadata: ListMetadata
+
+
+# Inherits from the methods of UpdateAutomationRequest
+class UpdateLinkRequest(UpdateAutomationRequest):
+    # ------------------------------
+    # Link Config
+    # ------------------------------
+    password: Optional[str] = None

uiform/types/automations/mailboxes.py

@@ -0,0 +1,60 @@
+import os
+import re
+from typing import ClassVar, List, Literal, Optional
+
+import nanoid  # type: ignore
+from pydantic import BaseModel, EmailStr, Field, field_validator
+
+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):
+    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
+    email: str = Field(..., pattern=EMAIL_PATTERN)
+    authorized_domains: list[str] = Field(default_factory=list, description="List of authorized domains to receive the emails from")
+    authorized_emails: List[EmailStr] = Field(default_factory=list, description="List of emails to access the link")
+
+    # Normalize email fields (case-insensitive)
+    @field_validator("email", mode="before")
+    def normalize_email(cls, value: str) -> str:
+        return value.strip().lower()
+
+    @field_validator("authorized_emails", mode="before")
+    def normalize_authorized_emails(cls, emails: List[str]) -> List[str]:
+        return [email.strip().lower() for email in emails]
+
+    @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):
+                raise ValueError(f"Invalid domain: {domain}")
+        return list_domains
+
+
+class ListMailboxes(BaseModel):
+    data: list[Mailbox]
+    list_metadata: ListMetadata
+
+
+# Inherits from the methods of UpdateAutomationRequest
+class UpdateMailboxRequest(UpdateAutomationRequest):
+
+    # ------------------------------
+    # Email Specific config
+    # ------------------------------
+    authorized_domains: Optional[list[str]] = None
+    authorized_emails: Optional[List[EmailStr]] = None
+
+    @field_validator("authorized_emails", mode="before")
+    def normalize_authorized_emails(cls, emails: Optional[List[str]]) -> Optional[List[str]]:
+        return [email.strip().lower() for email in emails] if emails else None

uiform/types/automations/outlook.py

@@ -0,0 +1,68 @@
+import re
+from typing import Any, Dict, List, Literal, Optional
+
+import nanoid  # type: ignore
+from pydantic import BaseModel, EmailStr, Field, field_validator, model_validator
+
+from ..._utils.json_schema import convert_schema_to_layout
+from ..logs import AutomationConfig, UpdateAutomationRequest
+from ..pagination import ListMetadata
+
+domain_pattern = re.compile(r"^(?:[a-zA-Z0-9-]+\.)+[a-zA-Z]{2,}$")
+
+
+class AutomationLevel(BaseModel):
+    distance_threshold: float = Field(default=0.9, description="Distance threshold for the automation")
+    score_threshold: float = Field(default=0.9, description="Score threshold for the automation")
+
+
+class MatchParams(BaseModel):
+    endpoint: str = Field(..., description="Endpoint for matching parameters")
+    headers: Dict[str, str] = Field(..., description="Headers for the request")
+    path: str = Field(..., description="Path for matching parameters")
+
+
+class FetchParams(BaseModel):
+    endpoint: str = Field(..., description="Endpoint for fetching parameters")
+    headers: Dict[str, str] = Field(..., description="Headers for the request")
+    name: str = Field(..., description="Name of the fetch parameter")
+
+
+class Outlook(AutomationConfig):
+    object: Literal['automation.outlook'] = "automation.outlook"
+    id: str = Field(default_factory=lambda: "outlook_" + nanoid.generate(), description="Unique identifier for the outlook")
+
+    authorized_domains: list[str] = Field(default_factory=list, description="List of authorized domains to receive the emails from")
+    authorized_emails: List[EmailStr] = Field(default_factory=list, description="List of emails to access the link")
+
+    layout_schema: Optional[dict[str, Any]] = Field(default=None, description="Layout schema format used to display the data")
+
+    # Optional Fields for data integration
+    match_params: List[MatchParams] = Field(default_factory=list, description="List of match parameters for the outlook automation")
+    fetch_params: List[FetchParams] = Field(default_factory=list, description="List of fetch parameters for the outlook automation")
+
+    @model_validator(mode='before')
+    @classmethod
+    def compute_layout_schema(cls, values: dict[str, Any]) -> dict[str, Any]:
+        if values.get('layout_schema') is None:
+            values['layout_schema'] = convert_schema_to_layout(values['json_schema'])
+        return values
+
+class ListOutlooks(BaseModel):
+    data: list[Outlook]
+    list_metadata: ListMetadata
+
+
+# Inherits from the methods of UpdateAutomationRequest
+class UpdateOutlookRequest(UpdateAutomationRequest):
+    authorized_domains: Optional[list[str]] = None
+    authorized_emails: Optional[List[EmailStr]] = None
+
+    match_params: Optional[List[MatchParams]] = None
+    fetch_params: Optional[List[FetchParams]] = None
+
+    layout_schema: Optional[dict[str, Any]] = None
+
+    @field_validator("authorized_emails", mode="before")
+    def normalize_authorized_emails(cls, emails: Optional[List[str]]) -> Optional[List[str]]:
+        return [email.strip().lower() for email in emails] if emails else None

uiform/types/automations/webhooks.py

@@ -0,0 +1,21 @@
+from typing import Any, Optional
+
+from pydantic import BaseModel, EmailStr
+
+from uiform.types.documents.extractions import UiParsedChatCompletion
+
+from ..mime import BaseMIMEData, MIMEData
+
+
+class WebhookRequest(BaseModel):
+    completion: UiParsedChatCompletion
+    user: Optional[EmailStr] = None
+    file_payload: MIMEData
+    metadata: Optional[dict[str, Any]] = None
+
+
+class BaseWebhookRequest(BaseModel):
+    completion: UiParsedChatCompletion
+    user: Optional[EmailStr] = None
+    file_payload: BaseMIMEData
+    metadata: Optional[dict[str, Any]] = None

uiform/types/chat.py

@@ -0,0 +1,8 @@
+from typing import Iterable, Literal, TypedDict, Union
+
+from openai.types.chat.chat_completion_content_part_param import ChatCompletionContentPartParam
+
+
+class ChatCompletionUiformMessage(TypedDict):  # homemade replacement for ChatCompletionMessageParam because iterable messes the serialization with pydantic
+    role: Literal['user', 'system', 'assistant', 'developer']
+    content: Union[str, list[ChatCompletionContentPartParam]]

uiform/types/completions.py

@@ -0,0 +1,93 @@
+from typing import Any
+
+from openai.types.chat.chat_completion_reasoning_effort import ChatCompletionReasoningEffort
+from pydantic import BaseModel, ConfigDict, Field
+
+from .._utils.ai_models import find_provider_from_model
+from .ai_models import AIProvider
+from .chat import ChatCompletionUiformMessage
+
+
+from openai.types.shared_params.response_format_json_schema import ResponseFormatJSONSchema
+
+class UiChatCompletionsRequest(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+    model: str = Field(..., description="Model used for chat completion")
+    messages: list[ChatCompletionUiformMessage] = Field(..., description="Messages to be parsed")
+    response_format: ResponseFormatJSONSchema = Field(..., description="response format used to validate the output data.")
+    temperature: float = Field(default=0.0, description="Temperature for sampling. If not provided, the default temperature for the model will be used.", examples=[0.0])
+    reasoning_effort: ChatCompletionReasoningEffort = Field(
+        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."
+    )
+    # Regular fields
+    stream: bool = Field(default=False, description="If true, the extraction will be streamed to the user using the active WebSocket connection")
+    seed: int | None = Field(default=None, description="Seed for the random number generator. If not provided, a random seed will be generated.", examples=[None])
+    n_consensus: int = Field(default=1, description="Number of consensus models to use for extraction. If greater than 1 the temperature cannot be 0.")
+
+    @property
+    def provider(self) -> AIProvider:
+        """
+        Determines the AI provider based on the model specified.
+
+        Returns:
+            AIProvider: The AI provider corresponding to the given model.
+        """
+        return find_provider_from_model(self.model)
+
+
+
+
+class UiChatCompletionsParseRequest(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+    model: str = Field(..., description="Model used for chat completion")
+    messages: list[ChatCompletionUiformMessage] = Field(..., description="Messages to be parsed")
+    json_schema: dict[str, Any] = Field(..., description="JSON schema format used to validate the output data.")
+    temperature: float = Field(default=0.0, description="Temperature for sampling. If not provided, the default temperature for the model will be used.", examples=[0.0])
+    reasoning_effort: ChatCompletionReasoningEffort = Field(
+        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."
+    )
+    # Regular fields
+    stream: bool = Field(default=False, description="If true, the extraction will be streamed to the user using the active WebSocket connection")
+    seed: int | None = Field(default=None, description="Seed for the random number generator. If not provided, a random seed will be generated.", examples=[None])
+    n_consensus: int = Field(default=1, description="Number of consensus models to use for extraction. If greater than 1 the temperature cannot be 0.")
+
+    @property
+    def provider(self) -> AIProvider:
+        """
+        Determines the AI provider based on the model specified.
+
+        Returns:
+            AIProvider: The AI provider corresponding to the given model.
+        """
+        return find_provider_from_model(self.model)
+
+from typing import Optional, Union
+from openai.types.shared_params.reasoning import Reasoning
+from openai.types.responses.response_input_param import ResponseInputParam
+from openai.types.responses.response_text_config_param import ResponseTextConfigParam
+
+class UiChatResponseCreateRequest(BaseModel):
+    input: Union[str, ResponseInputParam] = Field(..., description="Input to be parsed")
+    instructions: Optional[str] = None
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+    model: str = Field(..., description="Model used for chat completion")
+    temperature: Optional[float] = Field(default=0.0, description="Temperature for sampling. If not provided, the default temperature for the model will be used.", examples=[0.0])
+    reasoning: Optional[Reasoning] = Field(default=None, 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.")
+    
+    stream: Optional[bool] = Field(default=False, description="If true, the extraction will be streamed to the user using the active WebSocket connection")
+    seed: int | None = Field(default=None, description="Seed for the random number generator. If not provided, a random seed will be generated.", examples=[None])
+    text: ResponseTextConfigParam = Field(default={"format": {"type": "text"}}, description="Format of the response")
+
+    n_consensus: int = Field(default=1, description="Number of consensus models to use for extraction. If greater than 1 the temperature cannot be 0.")
+
+    @property
+    def provider(self) -> AIProvider:
+        """
+        Determines the AI provider based on the model specified.
+
+        Returns:
+            AIProvider: The AI provider corresponding to the given model.
+        """
+        return find_provider_from_model(self.model)
+

uiform/types/consensus.py

@@ -0,0 +1,10 @@
+from pydantic import BaseModel, Field
+
+
+class ReconciliationResponse(BaseModel):
+    consensus_dict: dict = Field(
+        description="The consensus dictionary containing the reconciled values from the input dictionaries."
+    )
+    likelihoods: dict = Field(
+        description="A dictionary containing the likelihood/confidence scores for each field in the consensus dictionary."
+    )

uiform/types/db/annotations.py

@@ -0,0 +1,24 @@
+import datetime
+from typing import Any, Dict, Literal
+
+import nanoid  # type: ignore
+from pydantic import BaseModel, Field
+
+from ..modalities import Modality
+
+
+class AnnotationParameters(BaseModel):
+    model: str
+    modality: Modality | None = "native"
+    image_resolution_dpi: int = 96
+    browser_canvas: Literal['A3', 'A4', 'A5'] = 'A4'
+    temperature: float = 0.0
+
+
+class Annotation(BaseModel):
+    file_id: str = Field(description="ID of the file that the annotation belongs to")
+    parameters: AnnotationParameters = Field(description="Parameters used for the annotation")
+    data: Dict[str, Any] = Field(default_factory=dict, description="Data of the annotation")
+    schema_id: str = Field(description="ID of the schema used for the annotation")
+    organization_id: str = Field(description="ID of the organization that owns the annotation")
+    updated_at: datetime.datetime = Field(default_factory=lambda: datetime.datetime.now(datetime.timezone.utc), description="Timestamp for when the annotation was last updated")

uiform/types/db/files.py

@@ -0,0 +1,36 @@
+import mimetypes
+from typing import BinaryIO, Literal, Tuple
+
+from pydantic import BaseModel, ConfigDict, Field, HttpUrl, field_serializer
+
+
+class DBFile(BaseModel):
+    """Represents the core file object in your new spec."""
+
+    object: Literal["file"] = "file"
+    id: str = Field(..., description="The unique identifier of the file. It is generated from the content 'file_{sha256(content)}'")
+    filename: str = Field(..., description="The name of the file")
+
+    @property
+    def mime_type(self) -> str:
+        return mimetypes.guess_type(self.filename)[0] or "application/octet-stream"
+
+    @property
+    def extension(self) -> str:
+        return self.filename.split(".")[-1].lower()
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+
+FileData = Tuple[str, BinaryIO, str]
+FileTuple = Tuple[str, FileData]
+
+
+class FileLink(BaseModel):
+    download_url: HttpUrl = Field(description="The signed URL to download the file")
+    expires_in: str = Field(description="The expiration time of the signed URL")
+    filename: str = Field(description="The name of the file")
+
+    @field_serializer('download_url')
+    def url2str(self, val: HttpUrl) -> str:
+        return str(val)

uiform/types/deployments/cron.py

@@ -0,0 +1,59 @@
+import datetime
+from typing import Any, Literal, 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_core import Url
+
+from ..modalities import Modality
+
+
+def scrapping_action(link: HttpUrl) -> dict[str, Any]:
+    raise NotImplementedError("Scrapping action not implemented")
+
+
+class CronSchedule(BaseModel):
+    second: Optional[int] = Field(0, ge=0, le=59, description="Second (0-59), defaults to 0")
+    minute: int = Field(..., ge=0, le=59, description="Minute (0-59)")
+    hour: int = Field(..., ge=0, le=23, description="Hour (0-23)")
+    day_of_month: Optional[int] = Field(None, ge=1, le=31, description="Day of the month (1-31), None means any day")
+    month: Optional[int] = Field(None, ge=1, le=12, description="Month (1-12), None means every month")
+    day_of_week: Optional[int] = Field(None, ge=0, le=6, description="Day of the week (0-6, Sunday = 0), None means any day")
+
+    def to_cron_string(self) -> str:
+        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['deployment.scrapping_cron'] = "deployment.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")
+    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_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.")
+
+    # New attributes
+    model: str = Field(..., description="Model used for chat completion")
+    json_schema: dict[str, Any] = Field(..., description="JSON schema format used to validate the output data.")
+    temperature: float = Field(default=0.0, description="Temperature for sampling. If not provided, the default temperature for the model will be used.", examples=[0.0])
+    reasoning_effort: ChatCompletionReasoningEffort = Field(
+        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)

uiform/types/deployments/endpoints.py

@@ -0,0 +1,28 @@
+import copy
+import datetime
+import json
+from typing import Any, Literal, Optional
+
+import nanoid  # type: ignore
+from openai.types.chat.chat_completion_reasoning_effort import ChatCompletionReasoningEffort
+from pydantic import BaseModel, Field, HttpUrl, computed_field, field_serializer
+
+from ..._utils.json_schema import clean_schema
+from ..._utils.mime import generate_blake2b_hash_from_string
+from ..logs import AutomationConfig, UpdateAutomationRequest
+from ..modalities import Modality
+from ..pagination import ListMetadata
+
+
+class Endpoint(AutomationConfig):
+    object: Literal['deployment.endpoint'] = "deployment.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
+
+
+# Inherits from the methods of UpdateAutomationRequest
+class UpdateEndpointRequest(UpdateAutomationRequest):
+    pass

uiform/types/deployments/links.py

@@ -0,0 +1,36 @@
+import copy
+import datetime
+import json
+from typing import Any, Dict, Literal, Optional
+
+import nanoid  # type: ignore
+from openai.types.chat.chat_completion_reasoning_effort import ChatCompletionReasoningEffort
+from pydantic import BaseModel, Field, HttpUrl, computed_field, field_serializer
+from pydantic_core import Url
+
+from ..._utils.json_schema import clean_schema
+from ..._utils.mime import generate_blake2b_hash_from_string
+from ..logs import AutomationConfig, UpdateAutomationRequest
+from ..modalities import Modality
+from ..pagination import ListMetadata
+
+
+class Link(AutomationConfig):
+    object: Literal['deployment.link'] = "deployment.link"
+    id: str = Field(default_factory=lambda: "lnk_" + nanoid.generate(), description="Unique identifier for the extraction link")
+
+    # Link Specific Config
+    password: Optional[str] = Field(None, description="Password to access the link")
+
+
+class ListLinks(BaseModel):
+    data: list[Link]
+    list_metadata: ListMetadata
+
+
+# Inherits from the methods of UpdateAutomationRequest
+class UpdateLinkRequest(UpdateAutomationRequest):
+    # ------------------------------
+    # Link Config
+    # ------------------------------
+    password: Optional[str] = None

uiform/types/deployments/mailboxes.py

@@ -0,0 +1,67 @@
+import copy
+import datetime
+import json
+import os
+import re
+from typing import Any, ClassVar, Dict, List, Literal, Optional
+
+import nanoid  # type: ignore
+from pydantic import BaseModel, EmailStr, Field, HttpUrl, computed_field, field_serializer, field_validator
+from pydantic_core import Url
+
+from ..._utils.json_schema import clean_schema
+from ..._utils.mime import generate_blake2b_hash_from_string
+from ..modalities import Modality
+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):
+    EMAIL_PATTERN: ClassVar[str] = f".*@{os.getenv('EMAIL_DOMAIN', 'mailbox.uiform.com')}$"
+    object: Literal['deployment.mailbox'] = "deployment.mailbox"
+    id: str = Field(default_factory=lambda: "mb_" + nanoid.generate(), description="Unique identifier for the mailbox")
+
+    # Email Specific config
+    email: str = Field(..., pattern=EMAIL_PATTERN)
+    authorized_domains: list[str] = Field(default_factory=list, description="List of authorized domains to receive the emails from")
+    authorized_emails: List[EmailStr] = Field(default_factory=list, description="List of emails to access the link")
+
+    # Normalize email fields (case-insensitive)
+    @field_validator("email", mode="before")
+    def normalize_email(cls, value: str) -> str:
+        return value.strip().lower()
+
+    @field_validator("authorized_emails", mode="before")
+    def normalize_authorized_emails(cls, emails: List[str]) -> List[str]:
+        return [email.strip().lower() for email in emails]
+
+    @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):
+                raise ValueError(f"Invalid domain: {domain}")
+        return list_domains
+
+
+class ListMailboxes(BaseModel):
+    data: list[Mailbox]
+    list_metadata: ListMetadata
+
+
+# Inherits from the methods of UpdateAutomationRequest
+class UpdateMailboxRequest(UpdateAutomationRequest):
+
+    # ------------------------------
+    # Email Specific config
+    # ------------------------------
+    authorized_domains: Optional[list[str]] = None
+    authorized_emails: Optional[List[EmailStr]] = None
+
+    @field_validator("authorized_emails", mode="before")
+    def normalize_authorized_emails(cls, emails: Optional[List[str]]) -> Optional[List[str]]:
+        return [email.strip().lower() for email in emails] if emails else None