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

exa_py/api.py

@@ -840,7 +840,7 @@ class Exa:
         self,
         api_key: Optional[str],
         base_url: str = "https://api.exa.ai",
-        user_agent: str = "exa-py 1.10.0",
+        user_agent: str = "exa-py 1.11.0",
     ):
         """Initialize the Exa client with the provided API key and optional base URL and user agent.
 
@@ -1826,6 +1826,7 @@ class Exa:
         *,
         stream: Optional[bool] = False,
         text: Optional[bool] = False,
+        system_prompt: Optional[str] = None,
         model: Optional[Literal["exa", "exa-pro"]] = None,
     ) -> Union[AnswerResponse, StreamAnswerResponse]: ...
 
@@ -1835,6 +1836,7 @@ class Exa:
         *,
         stream: Optional[bool] = False,
         text: Optional[bool] = False,
+        system_prompt: Optional[str] = None,
         model: Optional[Literal["exa", "exa-pro"]] = None,
     ) -> Union[AnswerResponse, StreamAnswerResponse]:
         """Generate an answer to a query using Exa's search and LLM capabilities.
@@ -1842,6 +1844,7 @@ class Exa:
         Args:
             query (str): The query to answer.
             text (bool, optional): Whether to include full text in the results. Defaults to False.
+            system_prompt (str, optional): A system prompt to guide the LLM's behavior when generating the answer.
             model (str, optional): The model to use for answering. Either "exa" or "exa-pro". Defaults to None.
 
         Returns:
@@ -1870,6 +1873,7 @@ class Exa:
         query: str,
         *,
         text: bool = False,
+        system_prompt: Optional[str] = None,
         model: Optional[Literal["exa", "exa-pro"]] = None,
     ) -> StreamAnswerResponse:
         """Generate a streaming answer response.
@@ -1877,6 +1881,7 @@ class Exa:
         Args:
             query (str): The query to answer.
             text (bool): Whether to include full text in the results. Defaults to False.
+            system_prompt (str, optional): A system prompt to guide the LLM's behavior when generating the answer.
             model (str, optional): The model to use for answering. Either "exa" or "exa-pro". Defaults to None.
 
         Returns:
@@ -2165,6 +2170,7 @@ class AsyncExa(Exa):
         *,
         stream: Optional[bool] = False,
         text: Optional[bool] = False,
+        system_prompt: Optional[str] = None,
         model: Optional[Literal["exa", "exa-pro"]] = None,
     ) -> Union[AnswerResponse, StreamAnswerResponse]:
         """Generate an answer to a query using Exa's search and LLM capabilities.
@@ -2172,6 +2178,7 @@ class AsyncExa(Exa):
         Args:
             query (str): The query to answer.
             text (bool, optional): Whether to include full text in the results. Defaults to False.
+            system_prompt (str, optional): A system prompt to guide the LLM's behavior when generating the answer.
             model (str, optional): The model to use for answering. Either "exa" or "exa-pro". Defaults to None.
 
         Returns:
@@ -2200,6 +2207,7 @@ class AsyncExa(Exa):
         query: str,
         *,
         text: bool = False,
+        system_prompt: Optional[str] = None,
         model: Optional[Literal["exa", "exa-pro"]] = None,
     ) -> AsyncStreamAnswerResponse:
         """Generate a streaming answer response.
@@ -2207,6 +2215,7 @@ class AsyncExa(Exa):
         Args:
             query (str): The query to answer.
             text (bool): Whether to include full text in the results. Defaults to False.
+            system_prompt (str, optional): A system prompt to guide the LLM's behavior when generating the answer.
             model (str, optional): The model to use for answering. Either "exa" or "exa-pro". Defaults to None.
 
         Returns:

exa_py/websets/websets_one_file.txt

@@ -0,0 +1,958 @@
+################################
+# 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)

{exa_py-1.10.0.dist-info → exa_py-1.11.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: exa-py
-Version: 1.10.0
+Version: 1.11.0
 Summary: Python SDK for Exa API.
 License: MIT
 Author: Exa AI

{exa_py-1.10.0.dist-info → exa_py-1.11.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
 exa_py/__init__.py,sha256=M2GC9oSdoV6m2msboW0vMWWl8wrth4o6gmEV4MYLGG8,66
-exa_py/api.py,sha256=LZMOw4bu-h0J6wptXNHHgK2O5NvMOL5O9F2JjuK0qYU,82559
+exa_py/api.py,sha256=u9HjGGqN3yzWjXiWE79OW630zA01TzO99iprAeWHOhQ,83244
 exa_py/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 exa_py/utils.py,sha256=Rc1FJjoR9LQ7L_OJM91Sd1GNkbHjcLyEvJENhRix6gc,2405
 exa_py/websets/__init__.py,sha256=uOBAb9VrIHrPKoddGOp2ai2KgWlyUVCLMZqfbGOlboA,70
@@ -16,6 +16,7 @@ exa_py/websets/searches/client.py,sha256=elDZxycmKToOPU-F2utP2ia9x5m68vEu_5ymypc
 exa_py/websets/types.py,sha256=njlUgvZJab8hg2_6tqYa5SYvuYowDNKP9MKrmV2PSq0,26559
 exa_py/websets/webhooks/__init__.py,sha256=iTPBCxFd73z4RifLQMX6iRECx_6pwlI5qscLNjMOUHE,77
 exa_py/websets/webhooks/client.py,sha256=jNNFzUoWXW9KOswNrZ32LUO1gSbA89XBWyQkyLrUAuE,2664
-exa_py-1.10.0.dist-info/METADATA,sha256=DcDqL0AeY0uPA4mDy6JPuQ9I2EJDDzqqCYXpFYl3rCg,3565
-exa_py-1.10.0.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-exa_py-1.10.0.dist-info/RECORD,,
+exa_py/websets/websets_one_file.txt,sha256=u12CY0G5vqA3AzjQnotWfD9f0affhvtU-Tzir51v3aQ,33007
+exa_py-1.11.0.dist-info/METADATA,sha256=G46FhO3UNnF2cQj5aQkzsqrBIPhl70yFKE66uZEQ2dw,3565
+exa_py-1.11.0.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+exa_py-1.11.0.dist-info/RECORD,,