exa-py 1.11.0__py3-none-any.whl → 1.12.1__py3-none-any.whl

exa_py/websets/websets_one_file.txt

@@ -1,958 +0,0 @@
-################################
-# Websets Client Code (client.py)
-################################
-
-from __future__ import annotations
-
-import time
-from datetime import datetime
-from typing import List, Optional, Literal
-
-from .types import (
-    Webset,
-    ListWebsetsResponse,
-    GetWebsetResponse,
-    UpdateWebsetRequest,
-    WebsetStatus,
-    CreateWebsetParameters,
-)
-from .core.base import WebsetsBaseClient
-from .items import WebsetItemsClient
-from .searches import WebsetSearchesClient
-from .enrichments import WebsetEnrichmentsClient
-from .webhooks import WebsetWebhooksClient
-
-class WebsetsClient(WebsetsBaseClient):
-    """Client for managing Websets."""
-    
-    def __init__(self, client):
-        super().__init__(client)
-        self.items = WebsetItemsClient(client)
-        self.searches = WebsetSearchesClient(client)
-        self.enrichments = WebsetEnrichmentsClient(client)
-        self.webhooks = WebsetWebhooksClient(client)
-
-    def create(self, params: CreateWebsetParameters) -> Webset:
-        """Create a new Webset."""
-        response = self.request("/v0/websets", data=params.model_dump(by_alias=True, exclude_none=True))
-        return Webset.model_validate(response)
-
-    def get(self, id: str, *, expand: Optional[List[Literal["items"]]] = None) -> GetWebsetResponse:
-        """Get a Webset by ID."""
-        params = {"expand": expand} if expand else {}
-        response = self.request(f"/v0/websets/{id}", params=params, method="GET")
-        return GetWebsetResponse.model_validate(response)
-
-    def list(self, *, cursor: Optional[str] = None, limit: Optional[int] = None) -> ListWebsetsResponse:
-        """List all Websets."""
-        params = {k: v for k, v in {"cursor": cursor, "limit": limit}.items() if v is not None}
-        response = self.request("/v0/websets", params=params, method="GET")
-        return ListWebsetsResponse.model_validate(response)
-
-    def update(self, id: str, params: UpdateWebsetRequest) -> Webset:
-        """Update a Webset."""
-        response = self.request(f"/v0/websets/{id}", data=params.model_dump(by_alias=True, exclude_none=True), method="POST")
-        return Webset.model_validate(response)
-
-    def delete(self, id: str) -> Webset:
-        """Delete a Webset."""
-        response = self.request(f"/v0/websets/{id}", method="DELETE")
-        return Webset.model_validate(response)
-
-    def cancel(self, id: str) -> Webset:
-        """Cancel a running Webset."""
-        response = self.request(f"/v0/websets/{id}/cancel", method="POST")
-        return Webset.model_validate(response) 
-    
-    def wait_until_idle(self, id: str, *, timeout: Optional[int] = None) -> Webset:
-        """Wait until a Webset is idle."""
-        start_time = time.time()
-        while True:
-            webset = self.get(id)
-            if webset.status == WebsetStatus.idle:
-                break
-            time.sleep(1)
-            if timeout and time.time() - start_time > timeout:
-                raise Exception("Webset timed out")
-        return webset
-
-################################
-# Core Base (core/base.py)
-################################
-
-from __future__ import annotations
-
-from pydantic import ConfigDict
-from typing import Any, Dict, Optional
-from pydantic import BaseModel
-
-class ExaBaseModel(BaseModel):
-    """Base model for all Exa models with common configuration."""
-    model_config = ConfigDict(populate_by_name=True)
-
-class WebsetsBaseClient:
-    base_url: str
-
-    """Base client for Exa API resources."""
-
-    def __init__(self, client):
-        """Initialize the client."""
-        self._client = client
-        
-    def request(self, endpoint: str, data: Optional[Dict[str, Any]] = None, 
-                method: str = "POST", params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-        """Make a request to the Exa API."""
-        return self._client.request("/websets/" + endpoint, data=data, method=method, params=params) 
-
-################################
-# Types (types.py)
-################################
-
-from __future__ import annotations
-
-from datetime import datetime
-from enum import Enum
-from typing import Any, Dict, List, Literal, Optional, Union
-
-from pydantic import AnyUrl, Field, confloat, constr
-from .core.base import ExaBaseModel
-
-
-class CanceledReason(Enum):
-    """The reason the search was canceled"""
-    webset_deleted = 'webset_deleted'
-    webset_canceled = 'webset_canceled'
-
-
-class CreateCriterionParameters(ExaBaseModel):
-    description: constr(min_length=1, max_length=300)
-    """The description of the criterion"""
-
-
-class CreateEnrichmentParameters(ExaBaseModel):
-    description: constr(min_length=1, max_length=5000)
-    """Provide a description of the enrichment task you want to perform to each Webset Item."""
-    format: Optional[str] = None
-    """Format of the enrichment response."""
-    options: Optional[List[Option]] = Field(None, max_items=20, min_items=1)
-    """When the format is options, the different options for the enrichment agent to choose from."""
-    metadata: Optional[Dict[str, Any]] = None
-    """Set of key-value pairs you want to associate with this object."""
-
-
-class CreateWebhookParameters(ExaBaseModel):
-    events: List[Event] = Field(..., max_items=12, min_items=1)
-    """The events to trigger the webhook"""
-    url: AnyUrl
-    """The URL to send the webhook to"""
-    metadata: Optional[Dict[str, Any]] = None
-    """Set of key-value pairs you want to associate with this object."""
-
-
-class CreateWebsetParameters(ExaBaseModel):
-    search: Search
-    """Create initial search for the Webset."""
-    enrichments: Optional[List[CreateEnrichmentParameters]] = Field(None, max_items=10)
-    """Add Enrichments for the Webset."""
-    external_id: Optional[str] = Field(None, alias='externalId')
-    """The external identifier for the webset."""
-    metadata: Optional[Dict[str, Any]] = None
-    """Set of key-value pairs you want to associate with this object."""
-
-
-class CreateWebsetSearchParameters(ExaBaseModel):
-    count: confloat(ge=1.0)
-    """Number of Items the Search will attempt to find."""
-    query: constr(min_length=1, max_length=5000) = Field(
-        ...,
-        examples=[
-            'Marketing agencies based in the US, that focus on consumer products. Get brands worked with and city'
-        ],
-    )
-    """Query describing what you are looking for."""
-    entity: Optional[
-        Union[
-            WebsetCompanyEntity,
-            WebsetPersonEntity,
-            WebsetArticleEntity,
-            WebsetResearchPaperEntity,
-            WebsetCustomEntity,
-        ]
-    ] = None
-    """Entity the Webset will return results for."""
-    criteria: Optional[List[CreateCriterionParameters]] = Field(
-        None, max_items=5, min_items=1
-    )
-    """Criteria every item is evaluated against."""
-    behaviour: Optional[WebsetSearchBehaviour] = Field(
-        'override', title='WebsetSearchBehaviour'
-    )
-    """The behaviour of the Search when it is added to a Webset."""
-    metadata: Optional[Dict[str, Any]] = None
-    """Set of key-value pairs you want to associate with this object."""
-
-
-class Criterion(ExaBaseModel):
-    description: constr(min_length=1, max_length=300)
-    """The description of the criterion"""
-    success_rate: confloat(ge=0.0, le=100.0) = Field(..., alias='successRate')
-    """Value between 0 and 100 representing the percentage of results that meet the criterion."""
-
-
-class EnrichmentResult(ExaBaseModel):
-    object: Literal['enrichment_result']
-    format: WebsetEnrichmentFormat
-    result: List[str]
-    """The result of the enrichment."""
-    reasoning: Optional[str] = None
-    """The reasoning for the result when an Agent is used."""
-    references: List[Reference]
-    """The references used to generate the result."""
-    enrichment_id: str = Field(..., alias='enrichmentId')
-    """The id of the Enrichment that generated the result"""
-
-
-class Event(Enum):
-    webset_created = 'webset.created'
-    webset_deleted = 'webset.deleted'
-    webset_paused = 'webset.paused'
-    webset_idle = 'webset.idle'
-    webset_search_created = 'webset.search.created'
-    webset_search_canceled = 'webset.search.canceled'
-    webset_search_completed = 'webset.search.completed'
-    webset_search_updated = 'webset.search.updated'
-    webset_export_created = 'webset.export.created'
-    webset_export_completed = 'webset.export.completed'
-    webset_item_created = 'webset.item.created'
-    webset_item_enriched = 'webset.item.enriched'
-
-
-class Format(Enum):
-    """Format of the enrichment response."""
-    text = 'text'
-    date = 'date'
-    number = 'number'
-    options = 'options'
-    email = 'email'
-    phone = 'phone'
-
-
-class ListEventsResponse(ExaBaseModel):
-    data: List[
-        Union[
-            WebsetCreatedEvent,
-            WebsetDeletedEvent,
-            WebsetIdleEvent,
-            WebsetPausedEvent,
-            WebsetItemCreatedEvent,
-            WebsetItemEnrichedEvent,
-            WebsetSearchCreatedEvent,
-            WebsetSearchUpdatedEvent,
-            WebsetSearchCanceledEvent,
-            WebsetSearchCompletedEvent,
-        ]
-    ] = Field(..., discriminator='type')
-    """The list of events"""
-    has_more: bool = Field(..., alias='hasMore')
-    """Whether there are more results to paginate through"""
-    next_cursor: Optional[str] = Field(..., alias='nextCursor')
-    """The cursor to paginate through the next set of results"""
-
-
-class ListWebhooksResponse(ExaBaseModel):
-    data: List[Webhook]
-    """The list of webhooks"""
-    has_more: bool = Field(..., alias='hasMore')
-    """Whether there are more results to paginate through"""
-    next_cursor: Optional[str] = Field(..., alias='nextCursor')
-    """The cursor to paginate through the next set of results"""
-
-
-class ListWebsetItemResponse(ExaBaseModel):
-    data: List[WebsetItem]
-    """The list of webset items"""
-    has_more: bool = Field(..., alias='hasMore')
-    """Whether there are more Items to paginate through"""
-    next_cursor: Optional[str] = Field(..., alias='nextCursor')
-    """The cursor to paginate through the next set of Items"""
-
-
-class ListWebsetsResponse(ExaBaseModel):
-    data: List[Webset]
-    """The list of websets"""
-    has_more: bool = Field(..., alias='hasMore')
-    """Whether there are more results to paginate through"""
-    next_cursor: Optional[str] = Field(..., alias='nextCursor')
-    """The cursor to paginate through the next set of results"""
-
-
-class Option(ExaBaseModel):
-    label: str
-    """The label of the option"""
-
-
-class Progress(ExaBaseModel):
-    """The progress of the search"""
-    found: float
-    """The number of results found so far"""
-    completion: confloat(ge=0.0, le=100.0)
-    """The completion percentage of the search"""
-
-
-class Reference(ExaBaseModel):
-    title: Optional[str] = None
-    """The title of the reference"""
-    snippet: Optional[str] = None
-    """The relevant snippet of the reference content"""
-    url: AnyUrl
-    """The URL of the reference"""
-
-
-class Satisfied(Enum):
-    """The satisfaction of the criterion"""
-    yes = 'yes'
-    no = 'no'
-    unclear = 'unclear'
-
-
-class Search(ExaBaseModel):
-    """Create initial search for the Webset."""
-    query: constr(min_length=1, max_length=5000) = Field(
-        ...,
-        examples=[
-            'Marketing agencies based in the US, that focus on consumer products.'
-        ],
-    )
-    """Your search query."""
-    count: confloat(ge=1.0)
-    """Number of Items the Webset will attempt to find."""
-    entity: Optional[
-        Union[
-            WebsetCompanyEntity,
-            WebsetPersonEntity,
-            WebsetArticleEntity,
-            WebsetResearchPaperEntity,
-            WebsetCustomEntity,
-        ]
-    ] = Field(None, discriminator='type')
-    """Entity the Webset will return results for."""
-    criteria: Optional[List[CreateCriterionParameters]] = Field(
-        None, max_items=5, min_items=1
-    )
-    """Criteria every item is evaluated against."""
-
-
-class Source(Enum):
-    """The source of the Item"""
-    search = 'search'
-
-
-class UpdateWebhookParameters(ExaBaseModel):
-    events: Optional[List[Event]] = Field(None, max_items=12, min_items=1)
-    """The events to trigger the webhook"""
-    url: Optional[AnyUrl] = None
-    """The URL to send the webhook to"""
-    metadata: Optional[Dict[str, Any]] = None
-    """Set of key-value pairs you want to associate with this object."""
-
-
-class UpdateWebsetRequest(ExaBaseModel):
-    metadata: Optional[Dict[str, Any]] = None
-    """Set of key-value pairs you want to associate with this object."""
-
-
-class Webhook(ExaBaseModel):
-    id: str
-    """The unique identifier for the webhook"""
-    object: Literal['webhook']
-    status: WebhookStatus = Field(..., title='WebhookStatus')
-    """The status of the webhook"""
-    events: List[Event] = Field(..., min_items=1)
-    """The events to trigger the webhook"""
-    url: AnyUrl
-    """The URL to send the webhook to"""
-    metadata: Optional[Dict[str, Any]] = None
-    """The metadata of the webhook"""
-    created_at: datetime = Field(..., alias='createdAt')
-    """The date and time the webhook was created"""
-    updated_at: datetime = Field(..., alias='updatedAt')
-    """The date and time the webhook was last updated"""
-
-
-class WebhookStatus(Enum):
-    """The status of the webhook"""
-    active = 'active'
-    inactive = 'inactive'
-
-
-class Webset(ExaBaseModel):
-    id: str
-    """The unique identifier for the webset"""
-    object: Literal['webset']
-    status: WebsetStatus = Field(..., title='WebsetStatus')
-    """The status of the webset"""
-    external_id: Optional[str] = Field(..., alias='externalId')
-    """The external identifier for the webset"""
-    searches: List[WebsetSearch]
-    """The searches that have been performed on the webset."""
-    enrichments: List[WebsetEnrichment]
-    """The Enrichments to apply to the Webset Items."""
-    metadata: Optional[Dict[str, Any]] = None
-    """Set of key-value pairs you want to associate with this object."""
-    created_at: datetime = Field(..., alias='createdAt')
-    """The date and time the webset was created"""
-    updated_at: datetime = Field(..., alias='updatedAt')
-    """The date and time the webset was updated"""
-
-
-class WebsetArticleEntity(ExaBaseModel):
-    type: Literal['article']
-
-
-class WebsetCompanyEntity(ExaBaseModel):
-    type: Literal['company']
-
-
-class WebsetCreatedEvent(ExaBaseModel):
-    id: str
-    """The unique identifier for the event"""
-    object: Literal['event']
-    type: Literal['webset.created']
-    data: Webset
-    created_at: datetime = Field(..., alias='createdAt')
-    """The date and time the event was created"""
-
-
-class WebsetCustomEntity(ExaBaseModel):
-    type: Literal['custom']
-    description: constr(min_length=2, max_length=200)
-    """When you decide to use a custom entity, this is the description of the entity."""
-
-
-class WebsetDeletedEvent(ExaBaseModel):
-    id: str
-    """The unique identifier for the event"""
-    object: Literal['event']
-    type: Literal['webset.deleted']
-    data: Webset
-    created_at: datetime = Field(..., alias='createdAt')
-    """The date and time the event was created"""
-
-
-class WebsetEnrichment(ExaBaseModel):
-    id: str
-    """The unique identifier for the enrichment"""
-    object: Literal['webset_enrichment']
-    status: WebsetEnrichmentStatus = Field(..., title='WebsetEnrichmentStatus')
-    """The status of the enrichment"""
-    webset_id: str = Field(..., alias='websetId')
-    """The unique identifier for the Webset this enrichment belongs to."""
-    title: Optional[str] = None
-    """The title of the enrichment."""
-    description: str
-    """The description of the enrichment task provided during the creation of the enrichment."""
-    format: Optional[WebsetEnrichmentFormat]
-    """The format of the enrichment response."""
-    options: Optional[List[WebsetEnrichmentOption]] = Field(
-        ..., title='WebsetEnrichmentOptions'
-    )
-    """When the format is options, the different options for the enrichment agent to choose from."""
-    instructions: Optional[str] = None
-    """The instructions for the enrichment Agent."""
-    metadata: Optional[Dict[str, Any]] = None
-    """The metadata of the enrichment"""
-    created_at: datetime = Field(..., alias='createdAt')
-    """The date and time the enrichment was created"""
-    updated_at: datetime = Field(..., alias='updatedAt')
-    """The date and time the enrichment was updated"""
-
-
-class WebsetEnrichmentFormat(Enum):
-    text = 'text'
-    date = 'date'
-    number = 'number'
-    options = 'options'
-    email = 'email'
-    phone = 'phone'
-
-
-class WebsetEnrichmentOption(Option):
-    pass
-
-
-class WebsetEnrichmentStatus(Enum):
-    """The status of the enrichment"""
-    pending = 'pending'
-    canceled = 'canceled'
-    completed = 'completed'
-
-
-class WebsetExportFormat(Enum):
-    csv = 'csv'
-
-
-class WebsetIdleEvent(ExaBaseModel):
-    id: str
-    """The unique identifier for the event"""
-    object: Literal['event']
-    type: Literal['webset.idle']
-    data: Webset
-    created_at: datetime = Field(..., alias='createdAt')
-    """The date and time the event was created"""
-
-
-class WebsetItem(ExaBaseModel):
-    id: str
-    """The unique identifier for the Webset Item"""
-    object: Literal['webset_item']
-    source: Source
-    """The source of the Item"""
-    source_id: str = Field(..., alias='sourceId')
-    """The unique identifier for the source"""
-    webset_id: str = Field(..., alias='websetId')
-    """The unique identifier for the Webset this Item belongs to."""
-    properties: Union[
-        WebsetItemPersonProperties,
-        WebsetItemCompanyProperties,
-        WebsetItemArticleProperties,
-        WebsetItemResearchPaperProperties,
-        WebsetItemCustomProperties,
-    ]
-    """The properties of the Item"""
-    evaluations: List[WebsetItemEvaluation]
-    """The criteria evaluations of the item"""
-    enrichments: Optional[List[EnrichmentResult]]
-    """The enrichments results of the Webset item"""
-    created_at: datetime = Field(..., alias='createdAt')
-    """The date and time the item was created"""
-    updated_at: datetime = Field(..., alias='updatedAt')
-    """The date and time the item was last updated"""
-
-
-class WebsetItemArticleProperties(ExaBaseModel):
-    type: Literal['article']
-    url: AnyUrl
-    """The URL of the article"""
-    description: str
-    """Short description of the relevance of the article"""
-    content: Optional[str] = None
-    """The text content for the article"""
-    article: WebsetItemArticlePropertiesFields = Field(
-        ..., title='WebsetItemArticlePropertiesFields'
-    )
-
-
-class WebsetItemArticlePropertiesFields(ExaBaseModel):
-    author: Optional[str] = None
-    """The author(s) of the article"""
-    published_at: Optional[str] = Field(..., alias='publishedAt')
-    """The date and time the article was published"""
-
-
-class WebsetItemCompanyProperties(ExaBaseModel):
-    type: Literal['company']
-    url: AnyUrl
-    """The URL of the company website"""
-    description: str
-    """Short description of the relevance of the company"""
-    content: Optional[str] = None
-    """The text content of the company website"""
-    company: WebsetItemCompanyPropertiesFields = Field(
-        ..., title='WebsetItemCompanyPropertiesFields'
-    )
-
-
-class WebsetItemCompanyPropertiesFields(ExaBaseModel):
-    name: str
-    """The name of the company"""
-    location: Optional[str] = None
-    """The main location of the company"""
-    employees: Optional[float] = None
-    """The number of employees of the company"""
-    industry: Optional[str] = None
-    """The industry of the company"""
-    about: Optional[str] = None
-    """A short description of the company"""
-    logo_url: Optional[AnyUrl] = Field(..., alias='logoUrl')
-    """The logo URL of the company"""
-
-
-class WebsetItemCreatedEvent(ExaBaseModel):
-    id: str
-    """The unique identifier for the event"""
-    object: Literal['event']
-    type: Literal['webset.item.created']
-    data: WebsetItem
-    created_at: datetime = Field(..., alias='createdAt')
-    """The date and time the event was created"""
-
-
-class WebsetItemCustomProperties(ExaBaseModel):
-    type: Literal['custom']
-    url: AnyUrl
-    """The URL of the Item"""
-    description: str
-    """Short description of the Item"""
-    content: Optional[str] = None
-    """The text content of the Item"""
-    custom: WebsetItemCustomPropertiesFields = Field(
-        ..., title='WebsetItemCustomPropertiesFields'
-    )
-
-
-class WebsetItemCustomPropertiesFields(ExaBaseModel):
-    author: Optional[str] = None
-    """The author(s) of the website"""
-    published_at: Optional[str] = Field(..., alias='publishedAt')
-    """The date and time the website was published"""
-
-
-class WebsetItemEnrichedEvent(ExaBaseModel):
-    id: str
-    """The unique identifier for the event"""
-    object: Literal['event']
-    type: Literal['webset.item.enriched']
-    data: WebsetItem
-    created_at: datetime = Field(..., alias='createdAt')
-    """The date and time the event was created"""
-
-
-class WebsetItemEvaluation(ExaBaseModel):
-    criterion: str
-    """The description of the criterion"""
-    reasoning: str
-    """The reasoning for the result of the evaluation"""
-    satisfied: Satisfied
-    """The satisfaction of the criterion"""
-    references: Optional[List[Reference]]
-    """The references used to generate the result. `null` if the evaluation is not yet completed."""
-
-
-class WebsetItemPersonProperties(ExaBaseModel):
-    type: Literal['person']
-    url: AnyUrl
-    """The URL of the person profile"""
-    description: str
-    """Short description of the relevance of the person"""
-    person: WebsetItemPersonPropertiesFields = Field(
-        ..., title='WebsetItemPersonPropertiesFields'
-    )
-
-
-class WebsetItemPersonPropertiesFields(ExaBaseModel):
-    name: str
-    """The name of the person"""
-    location: Optional[str] = None
-    """The location of the person"""
-    position: Optional[str] = None
-    """The current work position of the person"""
-    picture_url: Optional[AnyUrl] = Field(..., alias='pictureUrl')
-    """The image URL of the person"""
-
-
-class WebsetItemResearchPaperProperties(ExaBaseModel):
-    type: Literal['research_paper']
-    url: AnyUrl
-    """The URL of the research paper"""
-    description: str
-    """Short description of the relevance of the research paper"""
-    content: Optional[str] = None
-    """The text content of the research paper"""
-    research_paper: WebsetItemResearchPaperPropertiesFields = Field(
-        ..., alias='researchPaper', title='WebsetItemResearchPaperPropertiesFields'
-    )
-
-
-class WebsetItemResearchPaperPropertiesFields(ExaBaseModel):
-    author: Optional[str] = None
-    """The author(s) of the research paper"""
-    published_at: Optional[str] = Field(..., alias='publishedAt')
-    """The date and time the research paper was published"""
-
-
-class WebsetPausedEvent(ExaBaseModel):
-    id: str
-    """The unique identifier for the event"""
-    object: Literal['event']
-    type: Literal['webset.paused']
-    data: Webset
-    created_at: datetime = Field(..., alias='createdAt')
-    """The date and time the event was created"""
-
-
-class WebsetPersonEntity(ExaBaseModel):
-    type: Literal['person']
-
-
-class WebsetResearchPaperEntity(ExaBaseModel):
-    type: Literal['research_paper']
-
-
-class WebsetSearch(ExaBaseModel):
-    id: str
-    """The unique identifier for the search"""
-    object: Literal['webset_search']
-    status: WebsetSearchStatus = Field(..., title='WebsetSearchStatus')
-    """The status of the search"""
-    query: constr(min_length=1, max_length=5000)
-    """The query used to create the search."""
-    entity: Optional[
-        Union[
-            WebsetCompanyEntity,
-            WebsetPersonEntity,
-            WebsetArticleEntity,
-            WebsetResearchPaperEntity,
-            WebsetCustomEntity,
-        ]
-    ]
-    """The entity the search will return results for."""
-    criteria: List[Criterion]
-    """The criteria the search will use to evaluate the results."""
-    count: confloat(ge=1.0)
-    """The number of results the search will attempt to find."""
-    progress: Progress
-    """The progress of the search"""
-    metadata: Optional[Dict[str, Any]] = None
-    """Set of key-value pairs you want to associate with this object."""
-    canceled_at: Optional[datetime] = Field(..., alias='canceledAt')
-    """The date and time the search was canceled"""
-    canceled_reason: Optional[CanceledReason] = Field(..., alias='canceledReason')
-    """The reason the search was canceled"""
-    created_at: datetime = Field(..., alias='createdAt')
-    """The date and time the search was created"""
-    updated_at: datetime = Field(..., alias='updatedAt')
-    """The date and time the search was updated"""
-
-
-class WebsetSearchBehaviour(Enum):
-    """The behaviour of the Search when it is added to a Webset."""
-    override = 'override'
-
-
-class WebsetSearchCanceledEvent(ExaBaseModel):
-    id: str
-    """The unique identifier for the event"""
-    object: Literal['event']
-    type: Literal['webset.search.canceled']
-    data: WebsetSearch
-    created_at: datetime = Field(..., alias='createdAt')
-    """The date and time the event was created"""
-
-
-class WebsetSearchCompletedEvent(ExaBaseModel):
-    id: str
-    """The unique identifier for the event"""
-    object: Literal['event']
-    type: Literal['webset.search.completed']
-    data: WebsetSearch
-    created_at: datetime = Field(..., alias='createdAt')
-    """The date and time the event was created"""
-
-
-class WebsetSearchCreatedEvent(ExaBaseModel):
-    id: str
-    """The unique identifier for the event"""
-    object: Literal['event']
-    type: Literal['webset.search.created']
-    data: WebsetSearch
-    created_at: datetime = Field(..., alias='createdAt')
-    """The date and time the event was created"""
-
-
-class WebsetSearchStatus(Enum):
-    """The status of the search"""
-    created = 'created'
-    running = 'running'
-    completed = 'completed'
-    canceled = 'canceled'
-
-
-class WebsetSearchUpdatedEvent(ExaBaseModel):
-    id: str
-    """The unique identifier for the event"""
-    object: Literal['event']
-    type: Literal['webset.search.updated']
-    data: WebsetSearch
-    created_at: datetime = Field(..., alias='createdAt')
-    """The date and time the event was created"""
-
-
-class WebsetStatus(Enum):
-    """The status of the webset"""
-    idle = 'idle'
-    running = 'running'
-    paused = 'paused'
-
-
-class GetWebsetResponse(Webset):
-    items: Optional[List[WebsetItem]] = None
-    """When expand query parameter contains `items`, this will contain the items in the webset"""
-
-################################
-# Items Client (items/client.py)
-################################
-
-from __future__ import annotations
-
-from typing import Optional, Iterator
-
-from ..types import (
-    WebsetItem,
-    ListWebsetItemResponse,
-)
-from ..core.base import WebsetsBaseClient
-
-class WebsetItemsClient(WebsetsBaseClient):
-    """Client for managing Webset Items."""
-    
-    def __init__(self, client):
-        super().__init__(client)
-
-    def list(self, webset_id: str, *, cursor: Optional[str] = None, 
-             limit: Optional[int] = None) -> ListWebsetItemResponse:
-        """List all Items for a Webset."""
-        params = {k: v for k, v in {"cursor": cursor, "limit": limit}.items() if v is not None}
-        response = self.request(f"/v0/websets/{webset_id}/items", params=params, method="GET")
-        return ListWebsetItemResponse.model_validate(response)
-
-    def list_all(self, webset_id: str, *, limit: Optional[int] = None) -> Iterator[WebsetItem]:
-        """Iterate through all Items in a Webset, handling pagination automatically."""
-        cursor = None
-        while True:
-            response = self.list(webset_id, cursor=cursor, limit=limit)
-            for item in response.data:
-                yield item
-            
-            if not response.has_more or not response.next_cursor:
-                break
-                
-            cursor = response.next_cursor
-
-    def get(self, webset_id: str, id: str) -> WebsetItem:
-        """Get an Item by ID."""
-        response = self.request(f"/v0/websets/{webset_id}/items/{id}", method="GET")
-        return WebsetItem.model_validate(response)
-
-    def delete(self, webset_id: str, id: str) -> WebsetItem:
-        """Delete an Item."""
-        response = self.request(f"/v0/websets/{webset_id}/items/{id}", method="DELETE")
-        return WebsetItem.model_validate(response)
-
-################################
-# Searches Client (searches/client.py)
-################################
-
-from __future__ import annotations
-
-from ..types import (
-    CreateWebsetSearchParameters,
-    WebsetSearch,
-)
-from ..core.base import WebsetsBaseClient
-
-class WebsetSearchesClient(WebsetsBaseClient):
-    """Client for managing Webset Searches."""
-    
-    def __init__(self, client):
-        super().__init__(client)
-
-    def create(self, webset_id: str, params: CreateWebsetSearchParameters) -> WebsetSearch:
-        """Create a new Search for the Webset."""
-        response = self.request(f"/v0/websets/{webset_id}/searches", data=params.model_dump(by_alias=True, exclude_none=True))
-        return WebsetSearch.model_validate(response)
-
-    def get(self, webset_id: str, id: str) -> WebsetSearch:
-        """Get a Search by ID."""
-        response = self.request(f"/v0/websets/{webset_id}/searches/{id}", method="GET")
-        return WebsetSearch.model_validate(response)
-
-    def cancel(self, webset_id: str, id: str) -> WebsetSearch:
-        """Cancel a running Search."""
-        response = self.request(f"/v0/websets/{webset_id}/searches/{id}/cancel", method="POST")
-        return WebsetSearch.model_validate(response)
-
-################################
-# Enrichments Client (enrichments/client.py)
-################################
-
-from __future__ import annotations
-
-from ..types import (
-    CreateEnrichmentParameters,
-    WebsetEnrichment,
-)
-from ..core.base import WebsetsBaseClient
-
-class WebsetEnrichmentsClient(WebsetsBaseClient):
-    """Client for managing Webset Enrichments."""
-    
-    def __init__(self, client):
-        super().__init__(client)
-
-    def create(self, webset_id: str, params: CreateEnrichmentParameters) -> WebsetEnrichment:
-        """Create an Enrichment for a Webset."""
-        response = self.request(f"/v0/websets/{webset_id}/enrichments", data=params.model_dump(by_alias=True, exclude_none=True))
-        return WebsetEnrichment.model_validate(response)
-
-    def get(self, webset_id: str, id: str) -> WebsetEnrichment:
-        """Get an Enrichment by ID."""
-        response = self.request(f"/v0/websets/{webset_id}/enrichments/{id}", method="GET")
-        return WebsetEnrichment.model_validate(response)
-
-    def delete(self, webset_id: str, id: str) -> WebsetEnrichment:
-        """Delete an Enrichment."""
-        response = self.request(f"/v0/websets/{webset_id}/enrichments/{id}", method="DELETE")
-        return WebsetEnrichment.model_validate(response)
-
-    def cancel(self, webset_id: str, id: str) -> WebsetEnrichment:
-        """Cancel a running Enrichment."""
-        response = self.request(f"/v0/websets/{webset_id}/enrichments/{id}/cancel", method="POST")
-        return WebsetEnrichment.model_validate(response)
-
-################################
-# Webhooks Client (webhooks/client.py)
-################################
-
-from __future__ import annotations
-
-from typing import Optional
-
-from ..types import (
-    CreateWebhookParameters,
-    Webhook,
-    ListWebhooksResponse,
-    UpdateWebhookParameters,
-)
-from ..core.base import WebsetsBaseClient
-
-class WebsetWebhooksClient(WebsetsBaseClient):
-    """Client for managing Webset Webhooks."""
-    
-    def __init__(self, client):
-        super().__init__(client)
-
-    def create(self, params: CreateWebhookParameters) -> Webhook:
-        """Create a Webhook."""
-        response = self.request("/v0/webhooks", data=params.model_dump(by_alias=True, exclude_none=True))
-        return Webhook.model_validate(response)
-
-    def get(self, id: str) -> Webhook:
-        """Get a Webhook by ID."""
-        response = self.request(f"/v0/webhooks/{id}", method="GET")
-        return Webhook.model_validate(response)
-
-    def list(self, *, cursor: Optional[str] = None, limit: Optional[int] = None) -> ListWebhooksResponse:
-        """List all Webhooks."""
-        params = {k: v for k, v in {"cursor": cursor, "limit": limit}.items() if v is not None}
-        response = self.request("/v0/webhooks", params=params, method="GET")
-        return ListWebhooksResponse.model_validate(response)
-
-    def update(self, id: str, params: UpdateWebhookParameters) -> Webhook:
-        """Update a Webhook."""
-        response = self.request(f"/v0/webhooks/{id}", data=params.model_dump(by_alias=True, exclude_none=True), method="PATCH")
-        return Webhook.model_validate(response)
-
-    def delete(self, id: str) -> Webhook:
-        """Delete a Webhook."""
-        response = self.request(f"/v0/webhooks/{id}", method="DELETE")
-        return Webhook.model_validate(response)