exa-py 1.15.1__py3-none-any.whl → 1.15.2__py3-none-any.whl

exa_py/api.py

@@ -23,6 +23,7 @@ from typing import (
     overload,
 )
 
+from .websets import AsyncWebsetsClient
 import httpx
 import requests
 from openai import OpenAI
@@ -2413,6 +2414,8 @@ class AsyncExa(Exa):
         super().__init__(api_key, api_base)
         # Override the synchronous ResearchClient with its async counterpart.
         self.research = AsyncResearchClient(self)
+        # Override the synchronous WebsetsClient with its async counterpart.
+        self.websets = AsyncWebsetsClient(self)
         self._client = None
 
     @property

exa_py/websets/__init__.py

@@ -1,9 +1,10 @@
-from .client import WebsetsClient
+from .client import WebsetsClient, AsyncWebsetsClient
 from .imports import ImportsClient
 from .events import EventsClient
 
 __all__ = [
     "WebsetsClient",
+    "AsyncWebsetsClient", 
     "ImportsClient",
     "EventsClient",
 ] 

exa_py/websets/async_client.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+import asyncio
+from typing import List, Optional, Literal, Dict, Any, Union
+
+from .types import (
+    Webset,
+    ListWebsetsResponse,
+    GetWebsetResponse,
+    UpdateWebsetRequest,
+    WebsetStatus,
+    CreateWebsetParameters,
+    PreviewWebsetParameters,
+    PreviewWebsetResponse,
+)
+from .core.async_base import WebsetsAsyncBaseClient
+from .async_items.client import AsyncWebsetItemsClient
+from .async_searches.client import AsyncWebsetSearchesClient
+from .async_enrichments.client import AsyncWebsetEnrichmentsClient
+from .async_webhooks.client import AsyncWebsetWebhooksClient
+from .async_monitors.client import AsyncMonitorsClient
+from .async_imports.client import AsyncImportsClient
+from .async_events.client import AsyncEventsClient
+
+class AsyncWebsetsClient(WebsetsAsyncBaseClient):
+    """Async client for managing Websets."""
+    
+    def __init__(self, client):
+        super().__init__(client)
+        self.items = AsyncWebsetItemsClient(client)
+        self.searches = AsyncWebsetSearchesClient(client)
+        self.enrichments = AsyncWebsetEnrichmentsClient(client)
+        self.webhooks = AsyncWebsetWebhooksClient(client)
+        self.monitors = AsyncMonitorsClient(client)
+        self.imports = AsyncImportsClient(client)
+        self.events = AsyncEventsClient(client)
+
+    async def create(self, params: Union[Dict[str, Any], CreateWebsetParameters]) -> Webset:
+        """Create a new Webset.
+        
+        Args:
+            params (CreateWebsetParameters): The parameters for creating a webset.
+        
+        Returns:
+            Webset: The created webset.
+        """
+        response = await self.request("/v0/websets", data=params)
+        return Webset.model_validate(response)
+
+    async def preview(self, params: Union[Dict[str, Any], PreviewWebsetParameters]) -> PreviewWebsetResponse:
+        """Preview a Webset before creating it.
+        
+        Args:
+            params (PreviewWebsetParameters): The parameters for previewing a webset.
+        
+        Returns:
+            PreviewWebsetResponse: The preview results.
+        """
+        response = await self.request("/v0/websets/preview", data=params)
+        return PreviewWebsetResponse.model_validate(response)
+
+    async def get(self, id: str, *, expand: Optional[List[Literal["items"]]] = None) -> GetWebsetResponse:
+        """Get a Webset by ID.
+        
+        Args:
+            id (str): The id or externalId of the Webset.
+            expand (List[Literal["items"]], optional): Expand items in the response.
+        
+        Returns:
+            GetWebsetResponse: The retrieved webset.
+        """
+        params = {}
+        if expand is not None:
+            params["expand"] = expand
+
+        response = await self.request(f"/v0/websets/{id}", params=params, method="GET")
+        return GetWebsetResponse.model_validate(response)
+
+    async def list(self, *, cursor: Optional[str] = None, limit: Optional[int] = None) -> ListWebsetsResponse:
+        """List all Websets.
+        
+        Args:
+            cursor (str, optional): The cursor to paginate through the results.
+            limit (int, optional): The number of results to return (max 200).
+        
+        Returns:
+            ListWebsetsResponse: List of websets.
+        """
+        params = {k: v for k, v in {"cursor": cursor, "limit": limit}.items() if v is not None}
+        response = await self.request("/v0/websets", params=params, method="GET")
+        return ListWebsetsResponse.model_validate(response)
+
+    async def update(self, id: str, params: Union[Dict[str, Any], UpdateWebsetRequest]) -> Webset:
+        """Update a Webset.
+        
+        Args:
+            id (str): The id or externalId of the Webset.
+            params (UpdateWebsetRequest): The parameters for updating a webset.
+        
+        Returns:
+            Webset: The updated webset.
+        """
+        response = await self.request(f"/v0/websets/{id}", data=params, method="POST")
+        return Webset.model_validate(response)
+
+    async def delete(self, id: str) -> Webset:
+        """Delete a Webset.
+        
+        Args:
+            id (str): The id or externalId of the Webset.
+        
+        Returns:
+            Webset: The deleted webset.
+        """
+        response = await self.request(f"/v0/websets/{id}", method="DELETE")
+        return Webset.model_validate(response)
+
+    async def cancel(self, id: str) -> Webset:
+        """Cancel a running Webset.
+        
+        Args:
+            id (str): The id or externalId of the Webset.
+        
+        Returns:
+            Webset: The canceled webset.
+        """
+        response = await self.request(f"/v0/websets/{id}/cancel", method="POST")
+        return Webset.model_validate(response)
+
+    async def wait_until_idle(self, id: str, *, timeout: int = 3600, poll_interval: int = 5) -> Webset:
+        """Wait until a Webset is idle.
+        
+        Args:
+            id (str): The id or externalId of the Webset.
+            timeout (int, optional): Maximum time to wait in seconds. Defaults to 3600.
+            poll_interval (int, optional): Time to wait between polls in seconds. Defaults to 5.
+            
+        Returns:
+            Webset: The webset once it's idle.
+            
+        Raises:
+            TimeoutError: If the webset does not become idle within the timeout period.
+        """
+        start_time = asyncio.get_event_loop().time()
+        while True:
+            webset = await self.get(id)
+            if webset.status == WebsetStatus.idle.value:
+                return webset
+                
+            if asyncio.get_event_loop().time() - start_time > timeout:
+                raise TimeoutError(f"Webset {id} did not become idle within {timeout} seconds")
+                
+            await asyncio.sleep(poll_interval)

exa_py/websets/client.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import time
+import asyncio
 from typing import List, Optional, Literal, Dict, Any, Union
 
 from .types import (
@@ -14,13 +15,14 @@ from .types import (
     PreviewWebsetResponse,
 )
 from .core.base import WebsetsBaseClient
-from .items import WebsetItemsClient
-from .searches import WebsetSearchesClient
-from .enrichments import WebsetEnrichmentsClient
-from .webhooks import WebsetWebhooksClient
-from .monitors import MonitorsClient
-from .imports import ImportsClient
-from .events import EventsClient
+from .core.async_base import WebsetsAsyncBaseClient
+from .items import WebsetItemsClient, AsyncWebsetItemsClient
+from .searches import WebsetSearchesClient, AsyncWebsetSearchesClient
+from .enrichments import WebsetEnrichmentsClient, AsyncWebsetEnrichmentsClient
+from .webhooks import WebsetWebhooksClient, AsyncWebsetWebhooksClient
+from .monitors import MonitorsClient, AsyncMonitorsClient
+from .imports import ImportsClient, AsyncImportsClient
+from .events import EventsClient, AsyncEventsClient
 
 class WebsetsClient(WebsetsBaseClient):
     """Client for managing Websets."""
@@ -154,3 +156,134 @@ class WebsetsClient(WebsetsBaseClient):
                 raise TimeoutError(f"Webset {id} did not become idle within {timeout} seconds")
                 
             time.sleep(poll_interval)
+
+
+class AsyncWebsetsClient(WebsetsAsyncBaseClient):
+    """Async client for managing Websets."""
+    
+    def __init__(self, client):
+        super().__init__(client)
+        self.items = AsyncWebsetItemsClient(client)
+        self.searches = AsyncWebsetSearchesClient(client)
+        self.enrichments = AsyncWebsetEnrichmentsClient(client)
+        self.webhooks = AsyncWebsetWebhooksClient(client)
+        self.monitors = AsyncMonitorsClient(client)
+        self.imports = AsyncImportsClient(client)
+        self.events = AsyncEventsClient(client)
+
+    async def create(self, params: Union[Dict[str, Any], CreateWebsetParameters]) -> Webset:
+        """Create a new Webset.
+        
+        Args:
+            params (CreateWebsetParameters): The parameters for creating a webset.
+        
+        Returns:
+            Webset: The created webset.
+        """
+        response = await self.request("/v0/websets", data=params)
+        return Webset.model_validate(response)
+
+    async def preview(self, params: Union[Dict[str, Any], PreviewWebsetParameters]) -> PreviewWebsetResponse:
+        """Preview a Webset before creating it.
+        
+        Args:
+            params (PreviewWebsetParameters): The parameters for previewing a webset.
+        
+        Returns:
+            PreviewWebsetResponse: The preview results.
+        """
+        response = await self.request("/v0/websets/preview", data=params)
+        return PreviewWebsetResponse.model_validate(response)
+
+    async def get(self, id: str, *, expand: Optional[List[Literal["items"]]] = None) -> GetWebsetResponse:
+        """Get a Webset by ID.
+        
+        Args:
+            id (str): The id or externalId of the Webset.
+            expand (List[Literal["items"]], optional): Expand items in the response.
+        
+        Returns:
+            GetWebsetResponse: The retrieved webset.
+        """
+        params = {}
+        if expand is not None:
+            params["expand"] = expand
+
+        response = await self.request(f"/v0/websets/{id}", params=params, method="GET")
+        return GetWebsetResponse.model_validate(response)
+
+    async def list(self, *, cursor: Optional[str] = None, limit: Optional[int] = None) -> ListWebsetsResponse:
+        """List all Websets.
+        
+        Args:
+            cursor (str, optional): The cursor to paginate through the results.
+            limit (int, optional): The number of results to return (max 200).
+        
+        Returns:
+            ListWebsetsResponse: List of websets.
+        """
+        params = {k: v for k, v in {"cursor": cursor, "limit": limit}.items() if v is not None}
+        response = await self.request("/v0/websets", params=params, method="GET")
+        return ListWebsetsResponse.model_validate(response)
+
+    async def update(self, id: str, params: Union[Dict[str, Any], UpdateWebsetRequest]) -> Webset:
+        """Update a Webset.
+        
+        Args:
+            id (str): The id or externalId of the Webset.
+            params (UpdateWebsetRequest): The parameters for updating a webset.
+        
+        Returns:
+            Webset: The updated webset.
+        """
+        response = await self.request(f"/v0/websets/{id}", data=params, method="POST")
+        return Webset.model_validate(response)
+
+    async def delete(self, id: str) -> Webset:
+        """Delete a Webset.
+        
+        Args:
+            id (str): The id or externalId of the Webset.
+        
+        Returns:
+            Webset: The deleted webset.
+        """
+        response = await self.request(f"/v0/websets/{id}", method="DELETE")
+        return Webset.model_validate(response)
+
+    async def cancel(self, id: str) -> Webset:
+        """Cancel a running Webset.
+        
+        Args:
+            id (str): The id or externalId of the Webset.
+        
+        Returns:
+            Webset: The canceled webset.
+        """
+        response = await self.request(f"/v0/websets/{id}/cancel", method="POST")
+        return Webset.model_validate(response)
+
+    async def wait_until_idle(self, id: str, *, timeout: int = 3600, poll_interval: int = 5) -> Webset:
+        """Wait until a Webset is idle.
+        
+        Args:
+            id (str): The id or externalId of the Webset.
+            timeout (int, optional): Maximum time to wait in seconds. Defaults to 3600.
+            poll_interval (int, optional): Time to wait between polls in seconds. Defaults to 5.
+            
+        Returns:
+            Webset: The webset once it's idle.
+            
+        Raises:
+            TimeoutError: If the webset does not become idle within the timeout period.
+        """
+        start_time = asyncio.get_event_loop().time()
+        while True:
+            webset = await self.get(id)
+            if webset.status == WebsetStatus.idle.value:
+                return webset
+                
+            if asyncio.get_event_loop().time() - start_time > timeout:
+                raise TimeoutError(f"Webset {id} did not become idle within {timeout} seconds")
+                
+            await asyncio.sleep(poll_interval)

exa_py/websets/core/__init__.py

@@ -1,9 +1,11 @@
 from ..types import *
+from .base import WebsetsBaseClient
+from .async_base import WebsetsAsyncBaseClient
 import sys
 
 # Get all public names from model module that don't start with underscore
 model_module = sys.modules[__name__]
-__all__ = ['WebsetsBaseClient', 'ExaBaseModel'] + [
+__all__ = ['WebsetsBaseClient', 'WebsetsAsyncBaseClient', 'ExaBaseModel'] + [
     name for name in dir(model_module)
-    if not name.startswith('_') and name not in ('WebsetsBaseClient', 'ExaBaseModel')
+    if not name.startswith('_') and name not in ('WebsetsBaseClient', 'WebsetsAsyncBaseClient', 'ExaBaseModel')
 ]

exa_py/websets/core/async_base.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import json
+import asyncio
+from typing import Any, Dict, Optional, Type, TypeVar, Union
+
+from .base import ExaBaseModel
+
+# Generic type for any ExaBaseModel
+ModelT = TypeVar('ModelT', bound=ExaBaseModel)
+
+
+
+class WebsetsAsyncBaseClient:
+    base_url: str
+
+    """Base async client for Exa API resources."""
+
+    def __init__(self, client):
+        """Initialize the async client.
+        
+        Args:
+            client: The parent AsyncExa client.
+        """
+        self._client = client
+        
+    def _prepare_data(self, data: Union[Dict[str, Any], ExaBaseModel, str], model_class: Optional[Type[ModelT]] = None) -> Union[Dict[str, Any], str]:
+        """Prepare data for API request, converting dict to model if needed.
+        
+        Args:
+            data: Either a dictionary, model instance, or string
+            model_class: The model class to use if data is a dictionary
+            
+        Returns:
+            Dictionary prepared for API request or string if string data was provided
+        """
+        if isinstance(data, str):
+            # Return string as is
+            return data
+        elif isinstance(data, dict) and model_class:
+            # Convert dict to model instance
+            model_instance = model_class.model_validate(data)
+            return model_instance.model_dump(mode='json', by_alias=True, exclude_none=True)
+        elif isinstance(data, ExaBaseModel):
+            # Use model's dump method
+            return data.model_dump(mode='json', by_alias=True, exclude_none=True)
+        elif isinstance(data, dict):
+            # Use dict directly
+            return data
+        else:
+            raise TypeError(f"Expected dict, ExaBaseModel, or str, got {type(data)}")
+        
+    async def request(self, endpoint: str, data: Optional[Union[Dict[str, Any], ExaBaseModel, str]] = None, 
+                method: str = "POST", params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Make an async request to the Exa API.
+        
+        Args:
+            endpoint (str): The API endpoint to request.
+            data (Union[Dict[str, Any], ExaBaseModel, str], optional): The request data. Can be a dictionary, model instance, or string. Defaults to None.
+            method (str, optional): The HTTP method. Defaults to "POST".
+            params (Dict[str, Any], optional): The query parameters. Defaults to None.
+            
+        Returns:
+            Dict[str, Any]: The API response.
+        """
+        if isinstance(data, str):
+            # If data is a string, pass it as is
+            pass
+        elif data is not None and isinstance(data, ExaBaseModel):
+            # If data is a model instance, convert it to a dict
+            data = data.model_dump(mode='json', by_alias=True, exclude_none=True)
+            
+        # Ensure proper URL construction by removing leading slash from endpoint if present
+        if endpoint.startswith("/"):
+            endpoint = endpoint[1:]
+            
+        return await self._client.async_request("/websets/" + endpoint, data=data, method=method, params=params) 

exa_py/websets/enrichments/__init__.py

@@ -1,3 +1,3 @@
-from .client import WebsetEnrichmentsClient
+from .client import WebsetEnrichmentsClient, AsyncWebsetEnrichmentsClient
 
-__all__ = ["WebsetEnrichmentsClient"] 
+__all__ = ["WebsetEnrichmentsClient", "AsyncWebsetEnrichmentsClient"] 

exa_py/websets/enrichments/client.py

@@ -8,6 +8,7 @@ from ..types import (
     WebsetEnrichment,
 )
 from ..core.base import WebsetsBaseClient
+from ..core.async_base import WebsetsAsyncBaseClient
 
 class WebsetEnrichmentsClient(WebsetsBaseClient):
     """Client for managing Webset Enrichments."""
@@ -79,4 +80,77 @@ class WebsetEnrichmentsClient(WebsetsBaseClient):
             WebsetEnrichment: The canceled enrichment.
         """
         response = self.request(f"/v0/websets/{webset_id}/enrichments/{id}/cancel", method="POST")
+        return WebsetEnrichment.model_validate(response)
+
+
+class AsyncWebsetEnrichmentsClient(WebsetsAsyncBaseClient):
+    """Async client for managing Webset Enrichments."""
+    
+    def __init__(self, client):
+        super().__init__(client)
+
+    async def create(self, webset_id: str, params: Union[Dict[str, Any], CreateEnrichmentParameters]) -> WebsetEnrichment:
+        """Create an Enrichment for a Webset.
+        
+        Args:
+            webset_id (str): The id of the Webset.
+            params (CreateEnrichmentParameters): The parameters for creating an enrichment.
+        
+        Returns:
+            WebsetEnrichment: The created enrichment.
+        """
+        response = await self.request(f"/v0/websets/{webset_id}/enrichments", data=params)
+        return WebsetEnrichment.model_validate(response)
+
+    async def get(self, webset_id: str, id: str) -> WebsetEnrichment:
+        """Get an Enrichment by ID.
+        
+        Args:
+            webset_id (str): The id of the Webset.
+            id (str): The id of the Enrichment.
+        
+        Returns:
+            WebsetEnrichment: The retrieved enrichment.
+        """
+        response = await self.request(f"/v0/websets/{webset_id}/enrichments/{id}", method="GET")
+        return WebsetEnrichment.model_validate(response)
+
+    async def update(self, webset_id: str, id: str, params: Union[Dict[str, Any], UpdateEnrichmentParameters]) -> WebsetEnrichment:
+        """Update an Enrichment.
+        
+        Args:
+            webset_id (str): The id of the Webset.
+            id (str): The id of the Enrichment.
+            params (UpdateEnrichmentParameters): The parameters for updating an enrichment.
+        
+        Returns:
+            WebsetEnrichment: The updated enrichment.
+        """
+        response = await self.request(f"/v0/websets/{webset_id}/enrichments/{id}", data=params, method="PATCH")
+        return WebsetEnrichment.model_validate(response)
+
+    async def delete(self, webset_id: str, id: str) -> WebsetEnrichment:
+        """Delete an Enrichment.
+        
+        Args:
+            webset_id (str): The id of the Webset.
+            id (str): The id of the Enrichment.
+        
+        Returns:
+            WebsetEnrichment: The deleted enrichment.
+        """
+        response = await self.request(f"/v0/websets/{webset_id}/enrichments/{id}", method="DELETE")
+        return WebsetEnrichment.model_validate(response)
+
+    async def cancel(self, webset_id: str, id: str) -> WebsetEnrichment:
+        """Cancel a running Enrichment.
+        
+        Args:
+            webset_id (str): The id of the Webset.
+            id (str): The id of the Enrichment.
+        
+        Returns:
+            WebsetEnrichment: The canceled enrichment.
+        """
+        response = await self.request(f"/v0/websets/{webset_id}/enrichments/{id}/cancel", method="POST")
         return WebsetEnrichment.model_validate(response) 

exa_py/websets/events/__init__.py

@@ -1,3 +1,3 @@
-from .client import EventsClient
+from .client import EventsClient, AsyncEventsClient
 
-__all__ = ["EventsClient"]
+__all__ = ["EventsClient", "AsyncEventsClient"]

exa_py/websets/events/client.py

@@ -24,6 +24,7 @@ from ..types import (
     MonitorRunCompletedEvent,
 )
 from ..core.base import WebsetsBaseClient
+from ..core.async_base import WebsetsAsyncBaseClient
 
 # Type alias for all event types
 Event = Union[
@@ -112,6 +113,87 @@ class EventsClient(WebsetsBaseClient):
             'monitor.run.completed': MonitorRunCompletedEvent,
         }
         
+        event_class = event_type_map.get(event_type)
+        if event_class:
+            return event_class.model_validate(response)
+        else:
+            # Fallback - try each type until one validates
+            # This shouldn't happen in normal operation
+            for event_class in event_type_map.values():
+                try:
+                    return event_class.model_validate(response)
+                except Exception:
+                    continue
+            
+            raise ValueError(f"Unknown event type: {event_type}")
+
+
+class AsyncEventsClient(WebsetsAsyncBaseClient):
+    """Async client for managing Events."""
+    
+    def __init__(self, client):
+        super().__init__(client)
+
+    async def list(self, *, cursor: Optional[str] = None, limit: Optional[int] = None, 
+             types: Optional[List[EventType]] = None) -> ListEventsResponse:
+        """List all Events.
+        
+        Args:
+            cursor (str, optional): The cursor to paginate through the results.
+            limit (int, optional): The number of results to return.
+            types (List[EventType], optional): The types of events to filter by.
+        
+        Returns:
+            ListEventsResponse: List of events.
+        """
+        params = {}
+        if cursor is not None:
+            params["cursor"] = cursor
+        if limit is not None:
+            params["limit"] = limit
+        if types is not None:
+            # Convert EventType enums to their string values
+            params["types"] = [t.value if hasattr(t, 'value') else t for t in types]
+            
+        response = await self.request("/v0/events", params=params, method="GET")
+        return ListEventsResponse.model_validate(response)
+
+    async def get(self, id: str) -> Event:
+        """Get an Event by ID.
+        
+        Args:
+            id (str): The ID of the Event.
+        
+        Returns:
+            Event: The retrieved event.
+        """
+        response = await self.request(f"/v0/events/{id}", method="GET")
+        
+        # The response should contain a 'type' field that helps us determine
+        # which specific event class to use for validation
+        event_type = response.get('type')
+        
+        # Map event types to their corresponding classes
+        event_type_map = {
+            'webset.created': WebsetCreatedEvent,
+            'webset.deleted': WebsetDeletedEvent,
+            'webset.idle': WebsetIdleEvent,
+            'webset.paused': WebsetPausedEvent,
+            'webset.item.created': WebsetItemCreatedEvent,
+            'webset.item.enriched': WebsetItemEnrichedEvent,
+            'webset.search.created': WebsetSearchCreatedEvent,
+            'webset.search.updated': WebsetSearchUpdatedEvent,
+            'webset.search.canceled': WebsetSearchCanceledEvent,
+            'webset.search.completed': WebsetSearchCompletedEvent,
+            'import.created': ImportCreatedEvent,
+            'import.completed': ImportCompletedEvent,
+            'monitor.created': MonitorCreatedEvent,
+            'monitor.updated': MonitorUpdatedEvent,
+            'monitor.deleted': MonitorDeletedEvent,
+            'monitor.run.created': MonitorRunCreatedEvent,
+            'monitor.run.completed': MonitorRunCompletedEvent,
+        }
+        
         event_class = event_type_map.get(event_type)
         if event_class:
             return event_class.model_validate(response)

exa_py/websets/imports/__init__.py

@@ -1,3 +1,3 @@
-from .client import ImportsClient
- 
-__all__ = ["ImportsClient"] 
+from .client import ImportsClient, AsyncImportsClient
+
+__all__ = ["ImportsClient", "AsyncImportsClient"] 

exa_py/websets/imports/client.py

@@ -4,7 +4,9 @@ import time
 import os
 import csv
 import io
+import asyncio
 import requests
+import httpx
 from typing import Dict, Any, Union, Optional
 from pathlib import Path
 
@@ -16,6 +18,7 @@ from ..types import (
     UpdateImport,
 )
 from ..core.base import WebsetsBaseClient
+from ..core.async_base import WebsetsAsyncBaseClient
 
 class ImportsClient(WebsetsBaseClient):
     """Client for managing Imports."""
@@ -176,4 +179,169 @@ class ImportsClient(WebsetsBaseClient):
             if time.time() - start_time > timeout:
                 raise TimeoutError(f"Import {import_id} did not complete within {timeout} seconds")
                 
-            time.sleep(poll_interval) 
+            time.sleep(poll_interval)
+
+
+class AsyncImportsClient(WebsetsAsyncBaseClient):
+    """Async client for managing Imports."""
+    
+    def __init__(self, client):
+        super().__init__(client)
+
+    async def create(
+        self, 
+        params: Union[Dict[str, Any], CreateImportParameters], 
+        *,
+        csv_data: Optional[Union[str, Path]] = None
+    ) -> Union[CreateImportResponse, Import]:
+        """Create a new import to upload your data into Websets.
+        
+        Imports can be used to:
+        - Enrich: Enhance your data with additional information using our AI-powered enrichment engine
+        - Search: Query your data using Websets' agentic search with natural language filters
+        - Exclude: Prevent duplicate or already known results from appearing in your searches
+
+        Args:
+            params (CreateImportParameters): The parameters for creating an import.
+            csv_data (Union[str, Path], optional): CSV data to upload. Can be raw CSV string or file path.
+                                                   When provided, size and count will be automatically calculated 
+                                                   if not specified in params.
+        
+        Returns:
+            CreateImportResponse: If csv_data is None (traditional usage with upload URL).
+            Import: If csv_data is provided (uploaded and processing).
+        """
+        if csv_data is not None:
+            if isinstance(csv_data, (str, Path)) and os.path.isfile(csv_data):
+                # Use synchronous file reading for simplicity (file reading is typically fast)
+                with open(csv_data, 'r', encoding='utf-8') as f:
+                    csv_content = f.read()
+            else:
+                csv_content = str(csv_data)
+            
+            if isinstance(params, dict):
+                current_size = params.get('size')
+                current_count = params.get('count')
+            else:
+                current_size = getattr(params, 'size', None)
+                current_count = getattr(params, 'count', None)
+            
+            if current_size is None or current_count is None:
+                calculated_size = len(csv_content.encode('utf-8'))
+                csv_reader = csv.reader(io.StringIO(csv_content))
+                rows = list(csv_reader)
+                calculated_count = max(0, len(rows) - 1)
+                
+                if isinstance(params, dict):
+                    params = params.copy()
+                    if current_size is None:
+                        params['size'] = calculated_size
+                    if current_count is None:
+                        params['count'] = calculated_count
+                else:
+                    params_dict = params.model_dump()
+                    if current_size is None:
+                        params_dict['size'] = calculated_size
+                    if current_count is None:
+                        params_dict['count'] = calculated_count
+                    params = CreateImportParameters.model_validate(params_dict)
+        
+        response = await self.request("/v0/imports", data=params)
+        import_response = CreateImportResponse.model_validate(response)
+        
+        if csv_data is None:
+            return import_response
+        
+        # Use httpx for async HTTP requests
+        async with httpx.AsyncClient() as http_client:
+            upload_response = await http_client.put(
+                import_response.upload_url,
+                data=csv_content,
+                headers={'Content-Type': 'text/csv'}
+            )
+            upload_response.raise_for_status()
+        
+        return await self.get(import_response.id)
+
+    async def get(self, import_id: str) -> Import:
+        """Get a specific import.
+        
+        Args:
+            import_id (str): The id of the Import.
+        
+        Returns:
+            Import: The retrieved import.
+        """
+        response = await self.request(f"/v0/imports/{import_id}", method="GET")
+        return Import.model_validate(response)
+
+    async def list(self, *, cursor: Optional[str] = None, limit: Optional[int] = None) -> ListImportsResponse:
+        """List all imports.
+        
+        Args:
+            cursor (str, optional): The cursor to paginate through the results.
+            limit (int, optional): The number of results to return (1-200, default 25).
+        
+        Returns:
+            ListImportsResponse: List of imports with pagination info.
+        """
+        params = {
+            k: v 
+            for k, v in {
+                "cursor": cursor, 
+                "limit": limit
+            }.items() 
+            if v is not None
+        }
+        response = await self.request("/v0/imports", params=params, method="GET")
+        return ListImportsResponse.model_validate(response)
+
+    async def update(self, import_id: str, params: Union[Dict[str, Any], UpdateImport]) -> Import:
+        """Update an import configuration.
+        
+        Args:
+            import_id (str): The id of the Import.
+            params (UpdateImport): The parameters for updating an import.
+        
+        Returns:
+            Import: The updated import.
+        """
+        response = await self.request(f"/v0/imports/{import_id}", data=params, method="PATCH")
+        return Import.model_validate(response)
+
+    async def delete(self, import_id: str) -> Import:
+        """Delete an import.
+        
+        Args:
+            import_id (str): The id of the Import.
+        
+        Returns:
+            Import: The deleted import.
+        """
+        response = await self.request(f"/v0/imports/{import_id}", method="DELETE")
+        return Import.model_validate(response)
+
+    async def wait_until_completed(self, import_id: str, *, timeout: int = 1800, poll_interval: int = 5) -> Import:
+        """Wait until an import is completed or failed.
+        
+        Args:
+            import_id (str): The id of the Import.
+            timeout (int, optional): Maximum time to wait in seconds. Defaults to 1800 (30 minutes).
+            poll_interval (int, optional): Time to wait between polls in seconds. Defaults to 5.
+            
+        Returns:
+            Import: The import once it's completed or failed.
+            
+        Raises:
+            TimeoutError: If the import does not complete within the timeout period.
+        """
+        start_time = asyncio.get_event_loop().time()
+        while True:
+            import_obj = await self.get(import_id)
+            if import_obj.status in ['completed', 'failed']:
+                return import_obj
+                
+            if asyncio.get_event_loop().time() - start_time > timeout:
+                raise TimeoutError(f"Import {import_id} did not complete within {timeout} seconds")
+                
+            await asyncio.sleep(poll_interval) 

exa_py/websets/items/__init__.py

@@ -1,3 +1,3 @@
-from .client import WebsetItemsClient
+from .client import WebsetItemsClient, AsyncWebsetItemsClient
 
-__all__ = ["WebsetItemsClient"] 
+__all__ = ["WebsetItemsClient", "AsyncWebsetItemsClient"] 

exa_py/websets/items/client.py

@@ -1,12 +1,13 @@
 from __future__ import annotations
 
-from typing import  Optional, Iterator
+from typing import Optional, Iterator, AsyncIterator
 
 from ..types import (
     WebsetItem,
     ListWebsetItemResponse,
 )
 from ..core.base import WebsetsBaseClient
+from ..core.async_base import WebsetsAsyncBaseClient
 
 class WebsetItemsClient(WebsetsBaseClient):
     """Client for managing Webset Items."""
@@ -77,4 +78,76 @@ class WebsetItemsClient(WebsetsBaseClient):
             WebsetItem: The deleted item.
         """
         response = self.request(f"/v0/websets/{webset_id}/items/{id}", method="DELETE")
+        return WebsetItem.model_validate(response)
+
+
+class AsyncWebsetItemsClient(WebsetsAsyncBaseClient):
+    """Async client for managing Webset Items."""
+    
+    def __init__(self, client):
+        super().__init__(client)
+
+    async def list(self, webset_id: str, *, cursor: Optional[str] = None, 
+             limit: Optional[int] = None, source_id: Optional[str] = None) -> ListWebsetItemResponse:
+        """List all Items for a Webset.
+        
+        Args:
+            webset_id (str): The id or externalId of the Webset.
+            cursor (str, optional): The cursor to paginate through the results.
+            limit (int, optional): The number of results to return (max 200).
+            source_id (str, optional): Filter items by source ID.
+        
+        Returns:
+            ListWebsetItemResponse: List of webset items.
+        """
+        params = {k: v for k, v in {"cursor": cursor, "limit": limit, "sourceId": source_id}.items() if v is not None}
+        response = await self.request(f"/v0/websets/{webset_id}/items", params=params, method="GET")
+        return ListWebsetItemResponse.model_validate(response)
+
+    async def list_all(self, webset_id: str, *, limit: Optional[int] = None, source_id: Optional[str] = None) -> AsyncIterator[WebsetItem]:
+        """Iterate through all Items in a Webset, handling pagination automatically.
+        
+        Args:
+            webset_id (str): The id or externalId of the Webset.
+            limit (int, optional): The number of results to return per page (max 200).
+            source_id (str, optional): Filter items by source ID.
+            
+        Yields:
+            WebsetItem: Each item in the webset.
+        """
+        cursor = None
+        while True:
+            response = await self.list(webset_id, cursor=cursor, limit=limit, source_id=source_id)
+            for item in response.data:
+                yield item
+            
+            if not response.has_more or not response.next_cursor:
+                break
+                
+            cursor = response.next_cursor
+
+    async def get(self, webset_id: str, id: str) -> WebsetItem:
+        """Get an Item by ID.
+        
+        Args:
+            webset_id (str): The id or externalId of the Webset.
+            id (str): The id of the Webset item.
+        
+        Returns:
+            WebsetItem: The retrieved item.
+        """
+        response = await self.request(f"/v0/websets/{webset_id}/items/{id}", method="GET")
+        return WebsetItem.model_validate(response)
+
+    async def delete(self, webset_id: str, id: str) -> WebsetItem:
+        """Delete an Item.
+        
+        Args:
+            webset_id (str): The id or externalId of the Webset.
+            id (str): The id of the Webset item.
+        
+        Returns:
+            WebsetItem: The deleted item.
+        """
+        response = await self.request(f"/v0/websets/{webset_id}/items/{id}", method="DELETE")
         return WebsetItem.model_validate(response) 

exa_py/websets/monitors/__init__.py

@@ -1,4 +1,4 @@
-from .client import MonitorsClient
-from .runs import MonitorRunsClient
+from .client import MonitorsClient, AsyncMonitorsClient
+from .runs import MonitorRunsClient, AsyncMonitorRunsClient
 
-__all__ = ["MonitorsClient", "MonitorRunsClient"] 
+__all__ = ["MonitorsClient", "AsyncMonitorsClient", "MonitorRunsClient", "AsyncMonitorRunsClient"] 

exa_py/websets/monitors/client.py

@@ -9,6 +9,7 @@ from ..types import (
     ListMonitorsResponse,
 )
 from ..core.base import WebsetsBaseClient
+from ..core.async_base import WebsetsAsyncBaseClient
 from .runs import MonitorRunsClient
 
 class MonitorsClient(WebsetsBaseClient):
@@ -93,4 +94,39 @@ class MonitorsClient(WebsetsBaseClient):
             Monitor: The deleted monitor.
         """
         response = self.request(f"/v0/monitors/{monitor_id}", method="DELETE")
+        return Monitor.model_validate(response)
+
+
+class AsyncMonitorsClient(WebsetsAsyncBaseClient):
+    """Async client for managing Monitors."""
+    
+    def __init__(self, client):
+        super().__init__(client)
+        from .runs import AsyncMonitorRunsClient
+        self.runs = AsyncMonitorRunsClient(client)
+
+    async def create(self, params: Union[Dict[str, Any], CreateMonitorParameters]) -> Monitor:
+        """Create a new Monitor to continuously keep your Websets updated with fresh data."""
+        response = await self.request("/v0/monitors", data=params)
+        return Monitor.model_validate(response)
+
+    async def get(self, monitor_id: str) -> Monitor:
+        """Get a specific monitor."""
+        response = await self.request(f"/v0/monitors/{monitor_id}", method="GET")
+        return Monitor.model_validate(response)
+
+    async def list(self, *, cursor: Optional[str] = None, limit: Optional[int] = None, webset_id: Optional[str] = None) -> ListMonitorsResponse:
+        """List all monitors."""
+        params = {k: v for k, v in {"cursor": cursor, "limit": limit, "websetId": webset_id}.items() if v is not None}
+        response = await self.request("/v0/monitors", params=params, method="GET")
+        return ListMonitorsResponse.model_validate(response)
+
+    async def update(self, monitor_id: str, params: Union[Dict[str, Any], UpdateMonitor]) -> Monitor:
+        """Update a monitor configuration."""
+        response = await self.request(f"/v0/monitors/{monitor_id}", data=params, method="PATCH")
+        return Monitor.model_validate(response)
+
+    async def delete(self, monitor_id: str) -> Monitor:
+        """Delete a monitor."""
+        response = await self.request(f"/v0/monitors/{monitor_id}", method="DELETE")
         return Monitor.model_validate(response) 

exa_py/websets/monitors/runs/__init__.py

@@ -1,3 +1,3 @@
-from .client import MonitorRunsClient
+from .client import MonitorRunsClient, AsyncMonitorRunsClient
 
-__all__ = ["MonitorRunsClient"] 
+__all__ = ["MonitorRunsClient", "AsyncMonitorRunsClient"] 

exa_py/websets/monitors/runs/client.py

@@ -5,6 +5,7 @@ from ...types import (
     ListMonitorRunsResponse,
 )
 from ...core.base import WebsetsBaseClient
+from ...core.async_base import WebsetsAsyncBaseClient
 
 class MonitorRunsClient(WebsetsBaseClient):
     """Client for managing Monitor Runs."""
@@ -35,4 +36,21 @@ class MonitorRunsClient(WebsetsBaseClient):
             MonitorRun: The monitor run details.
         """
         response = self.request(f"/v0/monitors/{monitor_id}/runs/{run_id}", method="GET")
+        return MonitorRun.model_validate(response)
+
+
+class AsyncMonitorRunsClient(WebsetsAsyncBaseClient):
+    """Async client for managing Monitor Runs."""
+    
+    def __init__(self, client):
+        super().__init__(client)
+
+    async def list(self, monitor_id: str) -> ListMonitorRunsResponse:
+        """List all runs for the Monitor."""
+        response = await self.request(f"/v0/monitors/{monitor_id}/runs", method="GET")
+        return ListMonitorRunsResponse.model_validate(response)
+
+    async def get(self, monitor_id: str, run_id: str) -> MonitorRun:
+        """Get a specific monitor run."""
+        response = await self.request(f"/v0/monitors/{monitor_id}/runs/{run_id}", method="GET")
         return MonitorRun.model_validate(response) 

exa_py/websets/searches/__init__.py

@@ -1,3 +1,3 @@
-from .client import WebsetSearchesClient
+from .client import WebsetSearchesClient, AsyncWebsetSearchesClient
 
-__all__ = ["WebsetSearchesClient"] 
+__all__ = ["WebsetSearchesClient", "AsyncWebsetSearchesClient"] 

exa_py/websets/searches/client.py

@@ -7,6 +7,7 @@ from ..types import (
     WebsetSearch,
 )
 from ..core.base import WebsetsBaseClient
+from ..core.async_base import WebsetsAsyncBaseClient
 
 class WebsetSearchesClient(WebsetsBaseClient):
     """Client for managing Webset Searches."""
@@ -51,4 +52,50 @@ class WebsetSearchesClient(WebsetsBaseClient):
             WebsetSearch: The canceled search.
         """
         response = self.request(f"/v0/websets/{webset_id}/searches/{id}/cancel", method="POST")
+        return WebsetSearch.model_validate(response)
+
+
+class AsyncWebsetSearchesClient(WebsetsAsyncBaseClient):
+    """Async client for managing Webset Searches."""
+    
+    def __init__(self, client):
+        super().__init__(client)
+
+    async def create(self, webset_id: str, params: Union[Dict[str, Any], CreateWebsetSearchParameters]) -> WebsetSearch:
+        """Create a new Search for the Webset.
+        
+        Args:
+            webset_id (str): The id of the Webset.
+            params (CreateWebsetSearchParameters): The parameters for creating a search.
+        
+        Returns:
+            WebsetSearch: The created search.
+        """
+        response = await self.request(f"/v0/websets/{webset_id}/searches", data=params)
+        return WebsetSearch.model_validate(response)
+
+    async def get(self, webset_id: str, id: str) -> WebsetSearch:
+        """Get a Search by ID.
+        
+        Args:
+            webset_id (str): The id of the Webset.
+            id (str): The id of the Search.
+        
+        Returns:
+            WebsetSearch: The retrieved search.
+        """
+        response = await self.request(f"/v0/websets/{webset_id}/searches/{id}", method="GET")
+        return WebsetSearch.model_validate(response)
+
+    async def cancel(self, webset_id: str, id: str) -> WebsetSearch:
+        """Cancel a running Search.
+        
+        Args:
+            webset_id (str): The id of the Webset.
+            id (str): The id of the Search.
+        
+        Returns:
+            WebsetSearch: The canceled search.
+        """
+        response = await self.request(f"/v0/websets/{webset_id}/searches/{id}/cancel", method="POST")
         return WebsetSearch.model_validate(response) 

exa_py/websets/types.py

@@ -24,15 +24,24 @@ class WebsetSearchBehavior(Enum):
 
 
 class MonitorBehaviorSearchConfig(ExaBaseModel):
-    query: str
-    criteria: List[SearchCriterion]
-    entity: Union[
+    query: Optional[str] = None
+    """
+    The query to search for. By default, the query from the last search is used.
+    """
+    criteria: Optional[List[SearchCriterion]] = None
+    """
+    The criteria to search for. By default, the criteria from the last search is used.
+    """
+    entity: Optional[Union[
         WebsetCompanyEntity,
         WebsetPersonEntity,
         WebsetArticleEntity,
         WebsetResearchPaperEntity,
         WebsetCustomEntity,
-    ] = Field(..., title='WebsetEntity')
+    ]] = Field(None, title='WebsetEntity')
+    """
+    The entity to search for. By default, the entity from the last search/import is used.
+    """
     count: int
     """
     The maximum number of results to find

exa_py/websets/webhooks/__init__.py

@@ -1,3 +1,3 @@
-from .client import WebsetWebhooksClient
+from .client import WebsetWebhooksClient, AsyncWebsetWebhooksClient, AsyncWebhookAttemptsClient
 
-__all__ = ["WebsetWebhooksClient"] 
+__all__ = ["WebsetWebhooksClient", "AsyncWebsetWebhooksClient", "AsyncWebhookAttemptsClient"] 

exa_py/websets/webhooks/client.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Optional, Dict, Any, Union, Literal
+from typing import Optional, Dict, Any, Union
 
 from ..types import (
     CreateWebhookParameters,
@@ -11,6 +11,7 @@ from ..types import (
     EventType,
 )
 from ..core.base import WebsetsBaseClient
+from ..core.async_base import WebsetsAsyncBaseClient
 
 class WebhookAttemptsClient(WebsetsBaseClient):
     """Client for managing Webhook Attempts."""
@@ -118,4 +119,65 @@ class WebsetWebhooksClient(WebsetsBaseClient):
             Webhook: The deleted webhook.
         """
         response = self.request(f"/v0/webhooks/{id}", method="DELETE")
+        return Webhook.model_validate(response)
+
+
+class AsyncWebhookAttemptsClient(WebsetsAsyncBaseClient):
+    """Async client for managing Webhook Attempts."""
+    
+    def __init__(self, client):
+        super().__init__(client)
+    
+    async def list(self, webhook_id: str, *, cursor: Optional[str] = None, 
+             limit: Optional[int] = None, event_type: Optional[Union[EventType, str]] = None,
+             successful: Optional[bool] = None) -> ListWebhookAttemptsResponse:
+        """List all attempts made by a Webhook ordered in descending order."""
+        event_type_value = None
+        if event_type is not None:
+            if isinstance(event_type, EventType):
+                event_type_value = event_type.value
+            else:
+                event_type_value = event_type
+                
+        params = {k: v for k, v in {
+            "cursor": cursor, 
+            "limit": limit,
+            "eventType": event_type_value,
+            "successful": successful
+        }.items() if v is not None}
+        
+        response = await self.request(f"/v0/webhooks/{webhook_id}/attempts", params=params, method="GET")
+        return ListWebhookAttemptsResponse.model_validate(response)
+
+class AsyncWebsetWebhooksClient(WebsetsAsyncBaseClient):
+    """Async client for managing Webset Webhooks."""
+    
+    def __init__(self, client):
+        super().__init__(client)
+        self.attempts = AsyncWebhookAttemptsClient(client)
+
+    async def create(self, params: Union[Dict[str, Any], CreateWebhookParameters]) -> Webhook:
+        """Create a Webhook."""
+        response = await self.request("/v0/webhooks", data=params)
+        return Webhook.model_validate(response)
+
+    async def get(self, id: str) -> Webhook:
+        """Get a Webhook by ID."""
+        response = await self.request(f"/v0/webhooks/{id}", method="GET")
+        return Webhook.model_validate(response)
+
+    async 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 = await self.request("/v0/webhooks", params=params, method="GET")
+        return ListWebhooksResponse.model_validate(response)
+
+    async def update(self, id: str, params: Union[Dict[str, Any], UpdateWebhookParameters]) -> Webhook:
+        """Update a Webhook."""
+        response = await self.request(f"/v0/webhooks/{id}", data=params, method="PATCH")
+        return Webhook.model_validate(response)
+
+    async def delete(self, id: str) -> Webhook:
+        """Delete a Webhook."""
+        response = await self.request(f"/v0/webhooks/{id}", method="DELETE")
         return Webhook.model_validate(response)

{exa_py-1.15.1.dist-info → exa_py-1.15.2.dist-info}/METADATA

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

exa_py-1.15.2.dist-info/RECORD

@@ -0,0 +1,37 @@
+exa_py/__init__.py,sha256=M2GC9oSdoV6m2msboW0vMWWl8wrth4o6gmEV4MYLGG8,66
+exa_py/api.py,sha256=ftJRM7qnF-Ki4agnG4PLtCn7YcrBV1JlC_TmhH5bbG4,109112
+exa_py/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+exa_py/research/__init__.py,sha256=qbWY5c3LYBM7L4yGVtiMs9nUg_kMcAVhMhT0DvN6EI4,1014
+exa_py/research/async_client.py,sha256=jP6BF8nc29Mt4iU2ZEQGAC5dGM-Z9I4k3pzpPcCKJIs,9436
+exa_py/research/base.py,sha256=0C52XGUMRwRox1JSVBrbiHZxqPI6Cgif7EFNqYxpc40,5451
+exa_py/research/models.py,sha256=2gu4jckbLYHlTmln8BhDzovuqg1fejTCncqi4r0oDow,9822
+exa_py/research/sync_client.py,sha256=LHMkgqUZgKCQWgLP41Fj6EWLbt_YfX4aAgvWGjNgbXM,9155
+exa_py/research/utils.py,sha256=YR61UkReyK-LrvOTaX_aG_neS1DsmCkv7B6YODpwHvU,5965
+exa_py/utils.py,sha256=1jwKwcJwHSbrzwgMkprXSEZ-xssCtXxwf-GTRgaFmz8,6395
+exa_py/websets/__init__.py,sha256=8ZWndRgeTKceZ3Wcm5xCh_dykrKkoCYdZdKcK7C3aSw,226
+exa_py/websets/_generator/pydantic/BaseModel.jinja2,sha256=RUDCmPZVamoVx1WudylscYFfDhGoNNtRYlpTvKjAiuA,1276
+exa_py/websets/async_client.py,sha256=fewb7T64Ip5R67sZ2fceHv-Lv0gJPqQrsXq-v6ZuZPY,5823
+exa_py/websets/client.py,sha256=mdzZSfzgajfPQKWmjvwhUqjJSrtm3aErKcv4zcp7tWI,11137
+exa_py/websets/core/__init__.py,sha256=L8dLhlle-Y7yoo0p0s60S07UyknyrcEn64W9JxkvCjM,458
+exa_py/websets/core/async_base.py,sha256=RlJEaNR7OfZFzSy4sCk5aiPNT3cztuFZIyfP5vXMGtI,3121
+exa_py/websets/core/base.py,sha256=RldWYwBg2iVfkWmdPke7xjXdwb4JKeABIOgiZtqvz-4,4125
+exa_py/websets/enrichments/__init__.py,sha256=DA57V8s3169lfMnnLcFIOMQxhFIZ9I0uwXPYZMJzs9A,145
+exa_py/websets/enrichments/client.py,sha256=EStsgPgAggEa0FiYrIG9HNZ30akuUrXtKY27f-Fa3sI,5903
+exa_py/websets/events/__init__.py,sha256=VfJzObC3rSstdqz6q2ePnOIRW50GKJoSSH3-mpmDG0w,100
+exa_py/websets/events/client.py,sha256=_jLGUlf27W5XYa7AeUVVvJ9hffwbPZ7981Qz-Fi6U1c,7691
+exa_py/websets/imports/__init__.py,sha256=5fxYvRQdJQsVngvuq278Yw5W0Ckw17I_aPRrrtPcJ1w,105
+exa_py/websets/imports/client.py,sha256=Zr_qWO1rhYTXm62Jz5bR7orfvzDhcb7pHVfeO8uvVmQ,13700
+exa_py/websets/items/__init__.py,sha256=aJZto81Zp9eK1Dou2cFrRXgv3ZBuEvCHqb2G4KuKoao,121
+exa_py/websets/items/client.py,sha256=74vRjMrEoy6cVA8679dFtD43IU2jKDH8Zlw4hLIRs8I,6027
+exa_py/websets/monitors/__init__.py,sha256=cTRxTrsUuQmmmVEN3ewKsOq26xxiBJKTy7v0UjdOooc,216
+exa_py/websets/monitors/client.py,sha256=PmIkizecQSLnicKpIPEBJafId9rx_iJlP-LD_ApuAik,5333
+exa_py/websets/monitors/runs/__init__.py,sha256=rfE6PmQds4uPAd0fN3u992pG7INwbx1QvdyH8M-t8rs,121
+exa_py/websets/monitors/runs/client.py,sha256=_fMPqxzF0gy5g76wU6N8i7XrKTtq5vaOrrIzXkM1ZcA,1985
+exa_py/websets/searches/__init__.py,sha256=w6fJnCTKwl07GWgRVKQbYkPcoAct975YyOZog37C2q8,133
+exa_py/websets/searches/client.py,sha256=_mCuQtdLvKus5ofgs2a9MtY56Zg07JBJzqIg6YWre2A,3495
+exa_py/websets/types.py,sha256=naBzmlJ-nZK3ynDGBE15lmItD5p8-x_OfsWGFpKZRDs,50874
+exa_py/websets/webhooks/__init__.py,sha256=DMl6RFkS0c79AWzkuHOXnaU5QKHmkIHYW2PhZWUFIGc,191
+exa_py/websets/webhooks/client.py,sha256=rdYU0DZKAslw5LwGKB567j3T8L34ZF9tSnlN9jLi23A,7143
+exa_py-1.15.2.dist-info/METADATA,sha256=Izyx0YsIaj8Q8bztKKC0UD1L75KJHJrZsMjZ_CVbLv0,3826
+exa_py-1.15.2.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+exa_py-1.15.2.dist-info/RECORD,,

exa_py-1.15.1.dist-info/RECORD

@@ -1,35 +0,0 @@
-exa_py/__init__.py,sha256=M2GC9oSdoV6m2msboW0vMWWl8wrth4o6gmEV4MYLGG8,66
-exa_py/api.py,sha256=gUvQ2NXtUgBlrFrWrCIUwiq-z2lAlo_gWVFncN68Vhw,108947
-exa_py/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-exa_py/research/__init__.py,sha256=qbWY5c3LYBM7L4yGVtiMs9nUg_kMcAVhMhT0DvN6EI4,1014
-exa_py/research/async_client.py,sha256=jP6BF8nc29Mt4iU2ZEQGAC5dGM-Z9I4k3pzpPcCKJIs,9436
-exa_py/research/base.py,sha256=0C52XGUMRwRox1JSVBrbiHZxqPI6Cgif7EFNqYxpc40,5451
-exa_py/research/models.py,sha256=2gu4jckbLYHlTmln8BhDzovuqg1fejTCncqi4r0oDow,9822
-exa_py/research/sync_client.py,sha256=LHMkgqUZgKCQWgLP41Fj6EWLbt_YfX4aAgvWGjNgbXM,9155
-exa_py/research/utils.py,sha256=YR61UkReyK-LrvOTaX_aG_neS1DsmCkv7B6YODpwHvU,5965
-exa_py/utils.py,sha256=1jwKwcJwHSbrzwgMkprXSEZ-xssCtXxwf-GTRgaFmz8,6395
-exa_py/websets/__init__.py,sha256=x7Dc0MS8raRXA7Ud6alKgnsUmLi6X9GTqfB8kOwC9iQ,179
-exa_py/websets/_generator/pydantic/BaseModel.jinja2,sha256=RUDCmPZVamoVx1WudylscYFfDhGoNNtRYlpTvKjAiuA,1276
-exa_py/websets/client.py,sha256=sKkji8QaPFnGM1-J5TB6yKJcGAEd6gk7lsnIebzXNQ8,5856
-exa_py/websets/core/__init__.py,sha256=xOyrFaqtBocMUu321Jpbk7IzIQRNZufSIGJXrKoG-Bg,323
-exa_py/websets/core/base.py,sha256=RldWYwBg2iVfkWmdPke7xjXdwb4JKeABIOgiZtqvz-4,4125
-exa_py/websets/enrichments/__init__.py,sha256=5dJIEKKceUost3RnI6PpCSB3VjUCBzxseEsIXu-ZY-Y,83
-exa_py/websets/enrichments/client.py,sha256=Qn6B19Gf1z4pQ5CCeXMFeTJnVi2OiVx9Ck5XlcQBZVI,2999
-exa_py/websets/events/__init__.py,sha256=aFJ9O5UudtQQzndVmdB96IaM2l07qyM1B_8xKY7rp58,60
-exa_py/websets/events/client.py,sha256=-7sQ61P0SdHj-LuYq6G0u9a_IrtmcCljyDCzZPf330U,4370
-exa_py/websets/imports/__init__.py,sha256=iEl-fZZSdcvKaqLgjMES_0RwYn7hZDCMf6BZriCrjgw,64
-exa_py/websets/imports/client.py,sha256=nJs46hxlSkZm7qjboYHNBuJ62gLmA_Yzr9fc-NDky0Y,6795
-exa_py/websets/items/__init__.py,sha256=DCWZJVtRmUjnMEkKdb5gW1LT9cHcb-J8lENMnyyBeKU,71
-exa_py/websets/items/client.py,sha256=stAQ47AgkJdEsNb1E_YAXLe96VrtglOZsG79KVcy--M,3038
-exa_py/websets/monitors/__init__.py,sha256=jfr-gq8eKVa_gNe_DEqX9XCZPbJjpOe7QpH_D4RCFJQ,122
-exa_py/websets/monitors/client.py,sha256=fFxCSngkUPXqf9ilUMl8DaO2ihYveD-WfSoqARwf1eQ,3526
-exa_py/websets/monitors/runs/__init__.py,sha256=TmcETf3zdQouA_vAeLiosCNL1MYJnZ0yW2sbOAjTmm8,71
-exa_py/websets/monitors/runs/client.py,sha256=WnwcWCf7UKk68VCNUp8mRXBtlU8vglTSX-eoWVXzKIw,1229
-exa_py/websets/searches/__init__.py,sha256=_0Zx8ES5fFTEL3T8mhLxq_xK2t0JONx6ad6AtbvClsE,77
-exa_py/websets/searches/client.py,sha256=X3f7axWGfecmxf-2tBTX0Yf_--xToz1X8ZHbbudEzy0,1790
-exa_py/websets/types.py,sha256=iDZqvt22hjhkU8_AIczQ9iHexUw9C4PHh7C66ujfhk4,50523
-exa_py/websets/webhooks/__init__.py,sha256=iTPBCxFd73z4RifLQMX6iRECx_6pwlI5qscLNjMOUHE,77
-exa_py/websets/webhooks/client.py,sha256=zS1eoWKliuiY4AIeFJdpAlPZeOINyphn7KEWANF-zaE,4384
-exa_py-1.15.1.dist-info/METADATA,sha256=6MtMgPdsfzWgOKeQtywu4aZASbZjYpetbiirn17CzjE,3826
-exa_py-1.15.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-exa_py-1.15.1.dist-info/RECORD,,