exa-py 1.13.0__py3-none-any.whl → 1.13.2__py3-none-any.whl

exa_py/websets/_generator/pydantic/BaseModel.jinja2

@@ -0,0 +1,42 @@
+{% for decorator in decorators -%}
+{{ decorator }}
+{% endfor -%}
+class {{ class_name }}({{ base_class }}):{% if comment is defined %}  # {{ comment }}{% endif %}
+{%- if description %}
+    """
+    {{ description | indent(4) }}
+    """
+{%- endif %}
+{%- if not fields and not description %}
+    pass
+{%- endif %}
+{%- if config %}
+{%- filter indent(4) %}
+{%- endfilter %}
+{%- endif %}
+{%- for field in fields -%}
+    {%- if field.name == "type" and field.field %}
+    type: Literal['{{ field.default }}']
+    {%- elif field.name == "object" and field.field %}
+    object: Literal['{{ field.default }}']
+    {%- elif not field.annotated and field.field %}
+    {{ field.name }}: {{ field.type_hint }} = {{ field.field }}
+    {%- else %}
+    {%- if field.annotated %}
+    {{ field.name }}: {{ field.annotated }}
+    {%- else %}
+    {{ field.name }}: {{ field.type_hint }}
+    {%- endif %}
+    {%- if not (field.required or (field.represented_default == 'None' and field.strip_default_none)) or field.data_type.is_optional
+            %} = {{ field.represented_default }}
+    {%- endif -%}
+    {%- endif %}
+    {%- if field.docstring %}
+    """
+    {{ field.docstring | indent(4) }}
+    """
+    {%- endif %}
+{%- for method in methods -%}
+    {{ method }}
+{%- endfor -%}
+{%- endfor -%}

exa_py/websets/client.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import time
-from datetime import datetime
 from typing import List, Optional, Literal, Dict, Any, Union
 
 from .types import (
@@ -17,6 +16,7 @@ from .items import WebsetItemsClient
 from .searches import WebsetSearchesClient
 from .enrichments import WebsetEnrichmentsClient
 from .webhooks import WebsetWebhooksClient
+from .streams import StreamsClient
 
 class WebsetsClient(WebsetsBaseClient):
     """Client for managing Websets."""
@@ -27,6 +27,7 @@ class WebsetsClient(WebsetsBaseClient):
         self.searches = WebsetSearchesClient(client)
         self.enrichments = WebsetEnrichmentsClient(client)
         self.webhooks = WebsetWebhooksClient(client)
+        self.streams = StreamsClient(client)
 
     def create(self, params: Union[Dict[str, Any], CreateWebsetParameters]) -> Webset:
         """Create a new Webset.

exa_py/websets/core/base.py

@@ -29,7 +29,7 @@ class ExaBaseModel(BaseModel):
         str_to_upper=False,  # Don't convert strings to uppercase
         from_attributes=True,  # Allow initialization from attributes
         validate_assignment=True,  # Validate on assignment
-        extra='forbid',  # Forbid extra fields
+        extra='allow',
         json_encoders={AnyUrl: str}  # Convert AnyUrl to string when serializing to JSON
     )
 
@@ -92,5 +92,9 @@ class WebsetsBaseClient:
             # If data is a model instance, convert it to a dict
             data = data.model_dump(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 self._client.request("/websets/" + endpoint, data=data, method=method, params=params) 
-    
+

exa_py/websets/streams/__init__.py

@@ -0,0 +1,4 @@
+from .client import StreamsClient
+from .runs import StreamRunsClient
+
+__all__ = ["StreamsClient", "StreamRunsClient"] 

exa_py/websets/streams/client.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+from typing import Dict, Any, Union, Optional
+
+from ..types import (
+    Stream,
+    CreateStreamParameters,
+    UpdateStream,
+    ListStreamsResponse,
+)
+from ..core.base import WebsetsBaseClient
+from .runs import StreamRunsClient
+
+class StreamsClient(WebsetsBaseClient):
+    """Client for managing Streams."""
+    
+    def __init__(self, client):
+        super().__init__(client)
+        self.runs = StreamRunsClient(client)
+
+    def create(self, params: Union[Dict[str, Any], CreateStreamParameters]) -> Stream:
+        """Create a new Stream to continuously keep your Websets updated with fresh data.
+        
+        Streams automatically run on your defined schedule to ensure your Websets stay current without manual intervention:
+        - Find new content: Execute search operations to discover fresh items matching your criteria
+        - Update existing content: Run refresh operations to update items contents and enrichments
+        - Automated scheduling: Configure frequency, timezone, and execution times
+        
+        Args:
+            params (CreateStreamParameters): The parameters for creating a stream.
+        
+        Returns:
+            Stream: The created stream.
+        """
+        response = self.request("/v0/streams", data=params)
+        return Stream.model_validate(response)
+
+    def get(self, stream_id: str) -> Stream:
+        """Get a specific stream.
+        
+        Args:
+            stream_id (str): The id of the Stream.
+        
+        Returns:
+            Stream: The retrieved stream.
+        """
+        response = self.request(f"/v0/streams/{stream_id}", method="GET")
+        return Stream.model_validate(response)
+
+    def list(self, *, cursor: Optional[str] = None, limit: Optional[int] = None, webset_id: Optional[str] = None) -> ListStreamsResponse:
+        """List all streams.
+        
+        Args:
+            cursor (str, optional): The cursor to paginate through the results.
+            limit (int, optional): The number of results to return (1-200, default 25).
+            webset_id (str, optional): The id of the Webset to list streams for.
+        
+        Returns:
+            ListStreamsResponse: List of streams with pagination info.
+        """
+        params = {
+            k: v 
+            for k, v in {
+                "cursor": cursor, 
+                "limit": limit, 
+                "websetId": webset_id
+            }.items() 
+            if v is not None
+        }
+        response = self.request("/v0/streams", params=params, method="GET")
+        return ListStreamsResponse.model_validate(response)
+
+    def update(self, stream_id: str, params: Union[Dict[str, Any], UpdateStream]) -> Stream:
+        """Update a stream configuration.
+        
+        Args:
+            stream_id (str): The id of the Stream.
+            params (UpdateStream): The parameters for updating a stream.
+        
+        Returns:
+            Stream: The updated stream.
+        """
+        response = self.request(f"/v0/streams/{stream_id}", data=params, method="PATCH")
+        return Stream.model_validate(response)
+
+    def delete(self, stream_id: str) -> Stream:
+        """Delete a stream.
+        
+        Args:
+            stream_id (str): The id of the Stream.
+        
+        Returns:
+            Stream: The deleted stream.
+        """
+        response = self.request(f"/v0/streams/{stream_id}", method="DELETE")
+        return Stream.model_validate(response) 

exa_py/websets/streams/runs/__init__.py

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

exa_py/websets/streams/runs/client.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from ...types import (
+    StreamRun,
+    ListStreamRunsResponse,
+)
+from ...core.base import WebsetsBaseClient
+
+class StreamRunsClient(WebsetsBaseClient):
+    """Client for managing Stream Runs."""
+    
+    def __init__(self, client):
+        super().__init__(client)
+
+    def list(self, stream_id: str) -> ListStreamRunsResponse:
+        """List all runs for the Stream.
+        
+        Args:
+            stream_id (str): The id of the Stream to list runs for.
+        
+        Returns:
+            ListStreamRunsResponse: List of stream runs.
+        """
+        response = self.request(f"/v0/streams/{stream_id}/runs", method="GET")
+        return ListStreamRunsResponse.model_validate(response)
+
+    def get(self, stream_id: str, run_id: str) -> StreamRun:
+        """Get a specific stream run.
+        
+        Args:
+            stream_id (str): The id of the Stream to get the run for.
+            run_id (str): The id of the stream run.
+        
+        Returns:
+            StreamRun: The stream run details.
+        """
+        response = self.request(f"/v0/streams/{stream_id}/runs/{run_id}", method="GET")
+        return StreamRun.model_validate(response)