retab 0.0.42__py3-none-any.whl → 0.0.44__py3-none-any.whl

retab/__init__.py

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

retab/client.py

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

retab/generate_types.py

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

retab/resources/consensus/client.py

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

retab/resources/consensus/responses.py

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

retab/resources/deployments/__init__.py

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

retab/resources/deployments/automations/__init__.py

@@ -0,0 +1,9 @@
+from .client import (
+    AsyncAutomations,
+    Automations,
+)
+
+__all__ = [
+    "Automations",
+    "AsyncAutomations",
+]

retab/resources/deployments/automations/client.py

@@ -0,0 +1,244 @@
+import hashlib
+import hmac
+import json
+from typing import Any, Literal, Optional, Union
+
+from ...._resource import AsyncAPIResource, SyncAPIResource
+from ....types.automations.endpoints import Endpoint, UpdateEndpointRequest
+from ....types.automations.links import Link, UpdateLinkRequest
+from ....types.automations.mailboxes import Mailbox, UpdateMailboxRequest
+from ....types.automations.outlook import Outlook, UpdateOutlookRequest
+from ....types.standards import PreparedRequest
+from .endpoints import AsyncEndpoints, Endpoints
+from .links import AsyncLinks, Links
+from .logs import AsyncLogs, Logs
+from .mailboxes import AsyncMailboxes, Mailboxes
+from .outlook import AsyncOutlooks, Outlooks
+from .tests import AsyncTests, Tests
+
+
+class SignatureVerificationError(Exception):
+    """Raised when webhook signature verification fails."""
+
+    pass
+
+
+class AutomationsMixin:
+    def _verify_event(self, event_body: bytes, event_signature: str, secret: str) -> Any:
+        """
+        Verify the signature of a webhook event.
+
+        Args:
+            body: The raw request body
+            signature: The signature header
+            secret: The secret key used for signing
+
+        Returns:
+            The parsed event payload
+
+        Raises:
+            SignatureVerificationError: If the signature verification fails
+        """
+        expected_signature = hmac.new(secret.encode(), event_body, hashlib.sha256).hexdigest()
+
+        if not hmac.compare_digest(event_signature, expected_signature):
+            raise SignatureVerificationError("Invalid signature")
+
+        return json.loads(event_body.decode("utf-8"))
+
+    def prepare_list(
+        self,
+        processor_id: str,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        limit: Optional[int] = 10,
+        order: Optional[Literal["asc", "desc"]] = "desc",
+        automation_id: Optional[str] = None,
+        webhook_url: Optional[str] = None,
+        name: Optional[str] = None,
+    ) -> PreparedRequest:
+        params = {
+            "before": before,
+            "after": after,
+            "limit": limit,
+            "order": order,
+            "id": automation_id,
+            "webhook_url": webhook_url,
+            "name": name,
+        }
+        params = {k: v for k, v in params.items() if v is not None}
+        return PreparedRequest(method="GET", url=f"/v1/processors/{processor_id}/automations", params=params)
+
+    def prepare_get(self, processor_id: str, automation_id: str) -> PreparedRequest:
+        return PreparedRequest(method="GET", url=f"/v1/processors/{processor_id}/automations/{automation_id}")
+
+    def prepare_update(
+        self,
+        processor_id: str,
+        automation_id: str,
+        automation_data: Union[UpdateLinkRequest, UpdateMailboxRequest, UpdateEndpointRequest, UpdateOutlookRequest],
+    ) -> PreparedRequest:
+        return PreparedRequest(method="PUT", url=f"/v1/processors/{processor_id}/automations/{automation_id}", data=automation_data.model_dump(mode="json"))
+
+    def prepare_delete(self, processor_id: str, automation_id: str) -> PreparedRequest:
+        return PreparedRequest(method="DELETE", url=f"/v1/processors/{processor_id}/automations/{automation_id}")
+
+
+class Automations(SyncAPIResource, AutomationsMixin):
+    """Automations API wrapper"""
+
+    def __init__(self, client: Any) -> None:
+        super().__init__(client=client)
+        self.mailboxes = Mailboxes(client=client)
+        self.links = Links(client=client)
+        self.outlook = Outlooks(client=client)
+        self.endpoints = Endpoints(client=client)
+        self.tests = Tests(client=client)
+        self.logs = Logs(client=client)
+
+    def verify_event(self, event_body: bytes, event_signature: str, secret: str) -> Any:
+        """
+        Verify the signature of a webhook event.
+        """
+        return self._verify_event(event_body, event_signature, secret)
+
+    def list_automations(
+        self,
+        processor_id: str,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        limit: Optional[int] = 10,
+        order: Optional[Literal["asc", "desc"]] = "desc",
+        automation_id: Optional[str] = None,
+        webhook_url: Optional[str] = None,
+        name: Optional[str] = None,
+    ):
+        """List automations attached to this processor."""
+        request = self.prepare_list(processor_id, before, after, limit, order, automation_id, webhook_url, name)
+        response = self._client._prepared_request(request)
+        return response
+
+    def get_automation(self, processor_id: str, automation_id: str) -> Union[Link, Mailbox, Endpoint, Outlook]:
+        """Get a specific automation attached to this processor."""
+        request = self.prepare_get(processor_id, automation_id)
+        response = self._client._prepared_request(request)
+
+        # Return the appropriate model based on the automation type
+        if response["object"] == "automation.link":
+            return Link.model_validate(response)
+        elif response["object"] == "automation.mailbox":
+            return Mailbox.model_validate(response)
+        elif response["object"] == "automation.endpoint":
+            return Endpoint.model_validate(response)
+        elif response["object"] == "automation.outlook":
+            return Outlook.model_validate(response)
+        else:
+            raise ValueError(f"Unknown automation type: {response.get('object')}")
+
+    def update_automation(
+        self,
+        processor_id: str,
+        automation_id: str,
+        automation_data: Union[UpdateLinkRequest, UpdateMailboxRequest, UpdateEndpointRequest, UpdateOutlookRequest],
+    ) -> Union[Link, Mailbox, Endpoint, Outlook]:
+        """Update an automation attached to this processor."""
+        request = self.prepare_update(processor_id, automation_id, automation_data)
+        response = self._client._prepared_request(request)
+
+        # Return the appropriate model based on the automation type
+        if response["object"] == "automation.link":
+            return Link.model_validate(response)
+        elif response["object"] == "automation.mailbox":
+            return Mailbox.model_validate(response)
+        elif response["object"] == "automation.endpoint":
+            return Endpoint.model_validate(response)
+        elif response["object"] == "automation.outlook":
+            return Outlook.model_validate(response)
+        else:
+            raise ValueError(f"Unknown automation type: {response.get('object')}")
+
+    def delete_automation(self, processor_id: str, automation_id: str) -> None:
+        """Delete an automation attached to this processor."""
+        request = self.prepare_delete(processor_id, automation_id)
+        self._client._prepared_request(request)
+        print(f"Automation {automation_id} deleted from processor {processor_id}")
+
+
+class AsyncAutomations(AsyncAPIResource, AutomationsMixin):
+    """Async Automations API wrapper"""
+
+    def __init__(self, client: Any) -> None:
+        super().__init__(client=client)
+        self.mailboxes = AsyncMailboxes(client=client)
+        self.links = AsyncLinks(client=client)
+        self.outlook = AsyncOutlooks(client=client)
+        self.endpoints = AsyncEndpoints(client=client)
+        self.tests = AsyncTests(client=client)
+        self.logs = AsyncLogs(client=client)
+
+    async def verify_event(self, event_body: bytes, event_signature: str, secret: str) -> Any:
+        """
+        Verify the signature of a webhook event.
+        """
+        return self._verify_event(event_body, event_signature, secret)
+
+    async def list(
+        self,
+        processor_id: str,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        limit: Optional[int] = 10,
+        order: Optional[Literal["asc", "desc"]] = "desc",
+        automation_id: Optional[str] = None,
+        webhook_url: Optional[str] = None,
+        name: Optional[str] = None,
+    ):
+        """List automations attached to this processor."""
+        request = self.prepare_list(processor_id, before, after, limit, order, automation_id, webhook_url, name)
+        response = await self._client._prepared_request(request)
+        return response
+
+    async def get(self, processor_id: str, automation_id: str) -> Union[Link, Mailbox, Endpoint, Outlook]:
+        """Get a specific automation attached to this processor."""
+        request = self.prepare_get(processor_id, automation_id)
+        response = await self._client._prepared_request(request)
+
+        # Return the appropriate model based on the automation type
+        if response["object"] == "automation.link":
+            return Link.model_validate(response)
+        elif response["object"] == "automation.mailbox":
+            return Mailbox.model_validate(response)
+        elif response["object"] == "automation.endpoint":
+            return Endpoint.model_validate(response)
+        elif response["object"] == "automation.outlook":
+            return Outlook.model_validate(response)
+        else:
+            raise ValueError(f"Unknown automation type: {response.get('object')}")
+
+    async def update(
+        self,
+        processor_id: str,
+        automation_id: str,
+        automation_data: Union[UpdateLinkRequest, UpdateMailboxRequest, UpdateEndpointRequest, UpdateOutlookRequest],
+    ) -> Union[Link, Mailbox, Endpoint, Outlook]:
+        """Update an automation attached to this processor."""
+        request = self.prepare_update(processor_id, automation_id, automation_data)
+        response = await self._client._prepared_request(request)
+
+        # Return the appropriate model based on the automation type
+        if response["object"] == "automation.link":
+            return Link.model_validate(response)
+        elif response["object"] == "automation.mailbox":
+            return Mailbox.model_validate(response)
+        elif response["object"] == "automation.endpoint":
+            return Endpoint.model_validate(response)
+        elif response["object"] == "automation.outlook":
+            return Outlook.model_validate(response)
+        else:
+            raise ValueError(f"Unknown automation type: {response.get('object')}")
+
+    async def delete(self, processor_id: str, automation_id: str) -> None:
+        """Delete an automation attached to this processor."""
+        request = self.prepare_delete(processor_id, automation_id)
+        await self._client._prepared_request(request)
+        print(f"Automation {automation_id} deleted from processor {processor_id}")