exa-py 1.12.1__tar.gz → 1.13.0__tar.gz

exa_py-1.12.1/README.md → exa_py-1.13.0/PKG-INFO

@@ -1,3 +1,22 @@
+Metadata-Version: 2.4
+Name: exa-py
+Version: 1.13.0
+Summary: Python SDK for Exa API.
+Home-page: https://github.com/exa-labs/exa-py
+Author: Exa
+Author-email: Exa AI <hello@exa.ai>
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.32.3
+Requires-Dist: typing-extensions>=4.12.2
+Requires-Dist: openai>=1.48
+Requires-Dist: pydantic>=2.10.6
+Requires-Dist: pytest-mock>=3.14.0
+Requires-Dist: httpx>=0.28.1
+Dynamic: author
+Dynamic: home-page
+
 # Exa
 
 Exa (formerly Metaphor) API in Python
@@ -27,9 +46,6 @@ exa = Exa(api_key="your-api-key")
   # basic search
   results = exa.search("This is a Exa query:")
 
-  # autoprompted search
-  results = exa.search("autopromptable query", use_autoprompt=True)
-
   # keyword search (non-neural)
   results = exa.search("Google-style query", type="keyword")
 
@@ -42,13 +58,9 @@ exa = Exa(api_key="your-api-key")
   # search and get text contents
   results = exa.search_and_contents("This is a Exa query:")
 
-  # search and get highlights
-  results = exa.search_and_contents("This is a Exa query:", highlights=True)
-
   # search and get contents with contents options
   results = exa.search_and_contents("This is a Exa query:", 
-                                    text={"include_html_tags": True, "max_characters": 1000}, 
-                                    highlights={"highlights_per_url": 2, "num_sentences": 1, "query": "This is the highlight query:"})
+                                    text={"include_html_tags": True, "max_characters": 1000})
                                     
   # find similar documents
   results = exa.find_similar("https://example.com")
@@ -57,18 +69,14 @@ exa = Exa(api_key="your-api-key")
   results = exa.find_similar("https://example.com", exclude_source_domain=True)
 
   # find similar with contents
-  results = exa.find_similar_and_contents("https://example.com", text=True, highlights=True)
+  results = exa.find_similar_and_contents("https://example.com", text=True)
 
   # get text contents
-  results = exa.get_contents(["urls"])
-
-  # get highlights
-  results = exa.get_contents(["urls"], highlights=True)
+  results = exa.get_contents(["tesla.com"])
 
   # get contents with contents options
   results = exa.get_contents(["urls"], 
-                             text={"include_html_tags": True, "max_characters": 1000}, 
-                             highlights={"highlights_per_url": 2, "num_sentences": 1, "query": "This is the highlight query:"})
+                             text={"include_html_tags": True, "max_characters": 1000})
 
   # basic answer
   response = exa.answer("This is a query to answer a question")

exa_py-1.13.0/README.md

@@ -0,0 +1,76 @@
+# Exa
+
+Exa (formerly Metaphor) API in Python
+
+Note: This API is basically the same as `metaphor-python` but reflects new
+features associated with Metaphor's rename to Exa. New site is https://exa.ai
+
+## Installation
+
+```bash
+pip install exa_py
+```
+
+## Usage
+
+Import the package and initialize the Exa client with your API key:
+
+```python
+from exa_py import Exa
+
+exa = Exa(api_key="your-api-key")
+```
+
+## Common requests
+```python
+
+  # basic search
+  results = exa.search("This is a Exa query:")
+
+  # keyword search (non-neural)
+  results = exa.search("Google-style query", type="keyword")
+
+  # search with date filters
+  results = exa.search("This is a Exa query:", start_published_date="2019-01-01", end_published_date="2019-01-31")
+
+  # search with domain filters
+  results = exa.search("This is a Exa query:", include_domains=["www.cnn.com", "www.nytimes.com"])
+
+  # search and get text contents
+  results = exa.search_and_contents("This is a Exa query:")
+
+  # search and get contents with contents options
+  results = exa.search_and_contents("This is a Exa query:", 
+                                    text={"include_html_tags": True, "max_characters": 1000})
+                                    
+  # find similar documents
+  results = exa.find_similar("https://example.com")
+
+  # find similar excluding source domain
+  results = exa.find_similar("https://example.com", exclude_source_domain=True)
+
+  # find similar with contents
+  results = exa.find_similar_and_contents("https://example.com", text=True)
+
+  # get text contents
+  results = exa.get_contents(["tesla.com"])
+
+  # get contents with contents options
+  results = exa.get_contents(["urls"], 
+                             text={"include_html_tags": True, "max_characters": 1000})
+
+  # basic answer
+  response = exa.answer("This is a query to answer a question")
+
+  # answer with full text, using the exa-pro model (sends 2 expanded quries to exa search)
+  response = exa.answer("This is a query to answer a question", text=True, model="exa-pro")
+
+  # answer with streaming
+  response = exa.stream_answer("This is a query to answer:")
+
+  # Print each chunk as it arrives when using the stream_answer method
+  for chunk in response:
+    print(chunk, end='', flush=True)
+
+```
+

{exa_py-1.12.1 → exa_py-1.13.0}/exa_py/api.py

@@ -834,6 +834,36 @@ def nest_fields(original_dict: Dict, fields_to_nest: List[str], new_key: str):
 
     return original_dict
 
+@dataclass
+class ResearchTaskResponse:
+    """A class representing the response for a research task.
+
+    Attributes:
+        id (str): The unique identifier for the research request.
+        status (str): Status of the research request.
+        output (Optional[Dict[str, Any]]): The answer structured as JSON, if available.
+        citations (Optional[Dict[str, List[_Result]]]): List of citations used to generate the answer, grouped by root field in the output schema.
+    """
+
+    id: str
+    status: str
+    output: Optional[Dict[str, Any]]
+    citations: Dict[str, List[_Result]]
+
+    def __str__(self):
+        output_repr = (
+            json.dumps(self.output, indent=2, ensure_ascii=False)
+            if self.output is not None
+            else "None"
+        )
+        citations_str = "\n\n".join(str(src) for src in self.citations)
+        return (
+            f"ID: {self.id}\n"
+            f"Status: {self.status}\n"
+            f"Output: {output_repr}\n\n"
+            f"Citations:\n{citations_str}"
+        )
+
 
 class Exa:
     """A client for interacting with Exa API."""
@@ -1911,6 +1941,37 @@ class Exa:
         raw_response = self.request("/answer", options)
         return StreamAnswerResponse(raw_response)
 
+    def researchTask(
+        self,
+        *,
+        input_instructions: str,
+        output_schema: Dict[str, Any],
+    ) -> ResearchTaskResponse:
+        """Submit a research request to Exa.
+
+        Args:
+            input_instructions (str): The instructions for the research task.
+            output_schema (Dict[str, Any]): JSON schema describing the desired answer structure.
+        """
+        # Build the request payload expected by the Exa API
+        options = {
+            "input": {"instructions": input_instructions},
+            "output": {"schema": output_schema},
+        }
+
+        response = self.request("/research/tasks", options)
+
+        return ResearchTaskResponse(
+            id=response["id"],
+            status=response["status"],
+            output=response.get("output"),
+            citations={
+                key: [_Result(**to_snake_case(citation)) for citation in citations_list]
+                for key, citations_list in response.get("citations", {}).items()
+            },
+        )
+
+
 class AsyncExa(Exa):
     def __init__(self, api_key: str, api_base: str = "https://api.exa.ai"):
         super().__init__(api_key, api_base)
@@ -2244,3 +2305,36 @@ class AsyncExa(Exa):
         options["stream"] = True
         raw_response = await self.async_request("/answer", options)
         return AsyncStreamAnswerResponse(raw_response)
+
+    async def researchTask(
+        self,
+        *,
+        input_instructions: str,
+        output_schema: Dict[str, Any],
+    ) -> ResearchTaskResponse:
+        """Asynchronously submit a research request to Exa.
+
+        Args:
+            input_instructions (str): The instructions for the research task.
+            output_schema (Dict[str, Any]): JSON schema describing the desired answer structure.
+
+        Returns:
+            ResearchTaskResponse: The parsed response from the Exa API.
+        """
+        # Build the request payload expected by the Exa API
+        options = {
+            "input": {"instructions": input_instructions},
+            "output": {"schema": output_schema},
+        }
+
+        response = await self.async_request("/research/tasks", options)
+
+        return ResearchTaskResponse(
+            id=response["id"],
+            status=response["status"],
+            output=response.get("output"),
+            citations={
+                key: [_Result(**to_snake_case(citation)) for citation in citations_list]
+                for key, citations_list in response.get("citations", {}).items()
+            },
+        )

{exa_py-1.12.1 → exa_py-1.13.0/exa_py.egg-info}/PKG-INFO

@@ -1,25 +1,21 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: exa-py
-Version: 1.12.1
+Version: 1.13.0
 Summary: Python SDK for Exa API.
+Home-page: https://github.com/exa-labs/exa-py
+Author: Exa
+Author-email: Exa AI <hello@exa.ai>
 License: MIT
-Author: Exa AI
-Author-email: hello@exa.ai
 Requires-Python: >=3.9
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: httpx (>=0.28.1)
-Requires-Dist: openai (>=1.48)
-Requires-Dist: pydantic (>=2.10.6)
-Requires-Dist: pytest-mock (>=3.14.0)
-Requires-Dist: requests (>=2.32.3)
-Requires-Dist: typing-extensions (>=4.12.2)
 Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.32.3
+Requires-Dist: typing-extensions>=4.12.2
+Requires-Dist: openai>=1.48
+Requires-Dist: pydantic>=2.10.6
+Requires-Dist: pytest-mock>=3.14.0
+Requires-Dist: httpx>=0.28.1
+Dynamic: author
+Dynamic: home-page
 
 # Exa
 
@@ -50,9 +46,6 @@ exa = Exa(api_key="your-api-key")
   # basic search
   results = exa.search("This is a Exa query:")
 
-  # autoprompted search
-  results = exa.search("autopromptable query", use_autoprompt=True)
-
   # keyword search (non-neural)
   results = exa.search("Google-style query", type="keyword")
 
@@ -65,13 +58,9 @@ exa = Exa(api_key="your-api-key")
   # search and get text contents
   results = exa.search_and_contents("This is a Exa query:")
 
-  # search and get highlights
-  results = exa.search_and_contents("This is a Exa query:", highlights=True)
-
   # search and get contents with contents options
   results = exa.search_and_contents("This is a Exa query:", 
-                                    text={"include_html_tags": True, "max_characters": 1000}, 
-                                    highlights={"highlights_per_url": 2, "num_sentences": 1, "query": "This is the highlight query:"})
+                                    text={"include_html_tags": True, "max_characters": 1000})
                                     
   # find similar documents
   results = exa.find_similar("https://example.com")
@@ -80,18 +69,14 @@ exa = Exa(api_key="your-api-key")
   results = exa.find_similar("https://example.com", exclude_source_domain=True)
 
   # find similar with contents
-  results = exa.find_similar_and_contents("https://example.com", text=True, highlights=True)
+  results = exa.find_similar_and_contents("https://example.com", text=True)
 
   # get text contents
-  results = exa.get_contents(["urls"])
-
-  # get highlights
-  results = exa.get_contents(["urls"], highlights=True)
+  results = exa.get_contents(["tesla.com"])
 
   # get contents with contents options
   results = exa.get_contents(["urls"], 
-                             text={"include_html_tags": True, "max_characters": 1000}, 
-                             highlights={"highlights_per_url": 2, "num_sentences": 1, "query": "This is the highlight query:"})
+                             text={"include_html_tags": True, "max_characters": 1000})
 
   # basic answer
   response = exa.answer("This is a query to answer a question")
@@ -108,4 +93,3 @@ exa = Exa(api_key="your-api-key")
 
 ```
 
-

exa_py-1.13.0/exa_py.egg-info/SOURCES.txt

@@ -0,0 +1,26 @@
+README.md
+pyproject.toml
+setup.py
+exa_py/__init__.py
+exa_py/api.py
+exa_py/py.typed
+exa_py/utils.py
+exa_py.egg-info/PKG-INFO
+exa_py.egg-info/SOURCES.txt
+exa_py.egg-info/dependency_links.txt
+exa_py.egg-info/requires.txt
+exa_py.egg-info/top_level.txt
+exa_py/websets/__init__.py
+exa_py/websets/client.py
+exa_py/websets/types.py
+exa_py/websets/core/__init__.py
+exa_py/websets/core/base.py
+exa_py/websets/enrichments/__init__.py
+exa_py/websets/enrichments/client.py
+exa_py/websets/items/__init__.py
+exa_py/websets/items/client.py
+exa_py/websets/searches/__init__.py
+exa_py/websets/searches/client.py
+exa_py/websets/webhooks/__init__.py
+exa_py/websets/webhooks/client.py
+tests/test_websets.py

exa_py-1.13.0/exa_py.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

exa_py-1.13.0/exa_py.egg-info/requires.txt

@@ -0,0 +1,6 @@
+requests>=2.32.3
+typing-extensions>=4.12.2
+openai>=1.48
+pydantic>=2.10.6
+pytest-mock>=3.14.0
+httpx>=0.28.1

exa_py-1.13.0/exa_py.egg-info/top_level.txt

@@ -0,0 +1 @@
+exa_py

{exa_py-1.12.1 → exa_py-1.13.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "exa-py"
-version = "1.12.1"
+version = "1.13.0"
 description = "Python SDK for Exa API."
 authors = ["Exa AI <hello@exa.ai>"]
 readme = "README.md"
@@ -32,7 +32,7 @@ in-project = true
 
 [project]
 name = "exa-py"
-version = "1.12.1"
+version = "1.13.0"
 description = "Python SDK for Exa API."
 readme = "README.md"
 requires-python = ">=3.9"

exa_py-1.13.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

exa_py-1.13.0/setup.py

@@ -0,0 +1,26 @@
+from setuptools import find_packages, setup
+
+setup(
+    name="exa_py",
+    version="1.13.0",
+    description="Python SDK for Exa API.",
+    long_description_content_type="text/markdown",
+    long_description=open("README.md").read(),
+    author="Exa",
+    author_email="hello@exa.ai",
+    package_data={"exa_py": ["py.typed"]},
+    url="https://github.com/exa-labs/exa-py",
+    packages=find_packages(),
+    install_requires=["requests", "typing-extensions", "openai>=1.10.0"],
+    classifiers=[
+        "Development Status :: 5 - Production/Stable",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Typing :: Typed",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+    ],
+)

exa_py-1.13.0/tests/test_websets.py

@@ -0,0 +1,415 @@
+from datetime import datetime
+import json
+from typing import Dict, Any
+
+from pydantic import AnyUrl
+import pytest
+from unittest.mock import MagicMock
+
+from exa_py.websets.client import WebsetsClient
+from exa_py.websets.core.base import WebsetsBaseClient
+from exa_py.api import snake_to_camel, camel_to_snake, to_camel_case, to_snake_case
+from exa_py.websets.types import (
+    UpdateWebsetRequest,
+    CreateWebsetParameters,
+    Search,
+    CreateEnrichmentParameters,
+    Format
+)
+
+# ============================================================================
+# Fixtures
+# ============================================================================
+
+@pytest.fixture
+def mock_response():
+    """Factory fixture to create mock responses with custom data."""
+    def _create_response(json_data: Dict[str, Any], status_code: int = 200) -> MagicMock:
+        mock = MagicMock()
+        mock.json_data = json_data
+        mock.status_code = status_code
+        mock.text = json.dumps(json_data)
+        mock.json.return_value = json_data
+        return mock
+    return _create_response
+
+@pytest.fixture
+def parent_mock():
+    """Create a mock parent client."""
+    return MagicMock()
+
+@pytest.fixture
+def base_client(parent_mock):
+    """Create a base client instance with mock parent."""
+    return WebsetsBaseClient(parent_mock)
+
+@pytest.fixture
+def websets_client(parent_mock):
+    """Create a WebsetsClient instance with mock parent."""
+    return WebsetsClient(parent_mock)
+
+@pytest.fixture
+def items_client(websets_client):
+    """Create an items client instance."""
+    return websets_client.items
+
+# ============================================================================
+# Case Conversion Tests
+# ============================================================================
+
+@pytest.mark.parametrize("input,expected", [
+    ("test_case", "testCase"),
+    ("multiple_word_test", "multipleWordTest"),
+    ("single", "single"),
+    ("schema_", "$schema"),
+    ("not_", "not"),
+])
+def test_snake_to_camel(input, expected):
+    """Test snake_case to camelCase conversion."""
+    assert snake_to_camel(input) == expected
+
+@pytest.mark.parametrize("input,expected", [
+    ("testCase", "test_case"),
+    ("multipleWordTest", "multiple_word_test"),
+    ("single", "single"),
+])
+def test_camel_to_snake(input, expected):
+    """Test camelCase to snake_case conversion."""
+    assert camel_to_snake(input) == expected
+
+def test_dict_to_camel_case():
+    """Test converting dictionary keys from snake_case to camelCase."""
+    snake_dict = {
+        "test_key": "value",
+        "nested_dict": {
+            "inner_key": 123,
+            "another_key": True
+        },
+        "normal_key": None
+    }
+    
+    expected = {
+        "testKey": "value",
+        "nestedDict": {
+            "innerKey": 123,
+            "anotherKey": True
+        }
+    }
+    
+    assert to_camel_case(snake_dict) == expected
+
+def test_dict_to_snake_case():
+    """Test converting dictionary keys from camelCase to snake_case."""
+    camel_dict = {
+        "testKey": "value",
+        "nestedDict": {
+            "innerKey": 123,
+            "anotherKey": True
+        }
+    }
+    
+    expected = {
+        "test_key": "value",
+        "nested_dict": {
+            "inner_key": 123,
+            "another_key": True
+        }
+    }
+    
+    assert to_snake_case(camel_dict) == expected
+
+def test_request_body_case_conversion(websets_client, parent_mock):
+    """Test that request body fields are converted from snake_case to camelCase."""
+    mock_response = {
+        "id": "ws_123",
+        "object": "webset",
+        "status": "idle",
+        "externalId": "test-id",
+        "createdAt": "2023-01-01T00:00:00Z",
+        "updatedAt": "2023-01-01T00:00:00Z",
+        "searches": [],
+        "enrichments": []
+    }
+    
+    parent_mock.request.return_value = mock_response
+    
+    request = CreateWebsetParameters(
+        external_id="test-id",
+        search=Search(
+            query="test query",
+            count=10
+        ),
+        metadata={"snake_case_key": "value"}
+    )
+    
+    websets_client.create(params=request)
+    
+    actual_data = parent_mock.request.call_args[1]['data']
+    assert actual_data == {
+        "search": {
+            "query": "test query",
+            "count": 10
+        },
+        "externalId": "test-id",  # This should be camelCase in the request
+        "metadata": {"snake_case_key": "value"}  # metadata preserved original case
+    }
+
+def test_response_case_conversion(websets_client, parent_mock):
+    """Test that API response fields are converted from camelCase to snake_case."""
+    mock_response = {
+        "id": "ws_123",
+        "object": "webset",
+        "status": "idle",
+        "externalId": "test-id",
+        "createdAt": "2023-01-01T00:00:00Z",
+        "updatedAt": "2023-01-01T00:00:00Z",
+        "searches": [],
+        "enrichments": []
+    }
+    
+    parent_mock.request.return_value = mock_response
+    result = websets_client.get(id="ws_123")
+    
+    assert result.external_id == "test-id"
+    assert result.created_at == datetime.fromisoformat(mock_response["createdAt"])
+
+
+def test_metadata_case_preservation(websets_client, parent_mock):
+    """Test that metadata keys preserve their original case format when sent to API."""
+    test_cases = [
+        {"snake_case_key": "value"},
+        {"camelCaseKey": "value"},
+        {"UPPER_CASE": "value"},
+        {"mixed_Case_Key": "value"},
+    ]
+    
+    for metadata in test_cases:
+        mock_response = {
+            "id": "ws_123",
+            "object": "webset",
+            "status": "idle",
+            "metadata": metadata,
+            "externalId": "test-id",
+            "searches": [],
+            "enrichments": [],
+            "createdAt": "2023-01-01T00:00:00Z",
+            "updatedAt": "2023-01-01T00:00:00Z"
+        }
+        
+        parent_mock.request.return_value = mock_response
+        
+        request = UpdateWebsetRequest(metadata=metadata)
+        result = websets_client.update(id="ws_123", params=request)
+        
+        actual_data = parent_mock.request.call_args[1]['data']
+        assert actual_data["metadata"] == metadata
+        
+        assert result.metadata == metadata
+
+def test_nested_property_case_conversion(items_client, parent_mock):
+    """Test that nested property fields follow proper case conversion rules."""
+    mock_response = {
+        "data": [{
+            "id": "item_123",
+            "object": "webset_item",
+            "source": "search",
+            "sourceId": "search_123",
+            "websetId": "ws_123",
+            "properties": {
+                "type": "company",
+                "url": "https://example.com",
+                "description": "This is a test description",
+                "company": {
+                    "name": "Example Company",
+                    "logoUrl": "https://example.com/logo.png",
+                }
+            },
+            "evaluations": [],
+            "enrichments": [],
+            "createdAt": "2023-01-01T00:00:00Z",
+            "updatedAt": "2023-01-01T00:00:00Z"
+        }],
+        "hasMore": False,
+        "nextCursor": None
+    }
+    
+    parent_mock.request.return_value = mock_response
+    result = items_client.list(webset_id="ws_123", limit=10)
+    
+    assert result.data[0].properties.company.logo_url == AnyUrl("https://example.com/logo.png")
+
+def test_request_forwards_to_parent(base_client, parent_mock):
+    """Test that BaseClient.request forwards to the parent client's request method."""
+    parent_mock.request.return_value = {"key": "value"}
+    
+    result = base_client.request(
+        "/test",
+        data={"param": "value"},
+        method="POST",
+        params={"query": "test"}
+    )
+    
+    # WebsetsBaseClient prepends '/websets/' to all endpoints
+    parent_mock.request.assert_called_once_with(
+        "/websets//test",  # Double slash is preserved
+        data={"param": "value"},
+        method="POST",
+        params={"query": "test"}
+    )
+    
+    assert result == {"key": "value"}
+
+def test_format_validation_string_and_enum():
+    """Test that the format field accepts both string and enum values."""
+    # Test with enum value
+    params1 = CreateEnrichmentParameters(
+        description="Test description",
+        format=Format.text
+    )
+    # Since use_enum_values=True in ExaBaseModel, the enum is converted to its string value
+    assert params1.format == Format.text.value
+    
+    # Test with string value
+    params2 = CreateEnrichmentParameters(
+        description="Test description",
+        format="text"
+    )
+    assert params2.format == "text"
+    
+    # Both should serialize to the same value
+    assert params1.model_dump()["format"] == params2.model_dump()["format"]
+    
+    # Test with invalid string value
+    with pytest.raises(ValueError):
+        CreateEnrichmentParameters(
+            description="Test description",
+            format="invalid_format"
+        )
+
+def test_dict_and_model_parameter_support(websets_client, parent_mock):
+    """Test that client methods accept both dictionaries and model instances."""
+    from exa_py.websets.types import CreateWebsetParameters, Format
+    
+    # Set up mock response
+    mock_response = {
+        "id": "ws_123",
+        "object": "webset",
+        "status": "idle",
+        "externalId": None,
+        "createdAt": "2023-01-01T00:00:00Z",
+        "updatedAt": "2023-01-01T00:00:00Z",
+        "searches": [],
+        "enrichments": []
+    }
+    parent_mock.request.return_value = mock_response
+    
+    # Test with a model instance
+    model_params = CreateWebsetParameters(
+        search={
+            "query": "Test query",
+            "count": 10
+        },
+        enrichments=[{
+            "description": "Test enrichment",
+            "format": Format.text
+        }]
+    )
+    model_result = websets_client.create(params=model_params)
+    
+    # Test with an equivalent dictionary
+    dict_params = {
+        "search": {
+            "query": "Test query",
+            "count": 10
+        },
+        "enrichments": [{
+            "description": "Test enrichment",
+            "format": "text"
+        }]
+    }
+    dict_result = websets_client.create(params=dict_params)
+    
+    # Verify both calls produce the same result
+    assert model_result.id == dict_result.id
+    assert model_result.status == dict_result.status
+    
+    # Verify both calls were made (we don't need to verify exact equality of serialized data)
+    assert len(parent_mock.request.call_args_list) == 2
+    
+    # Both serialization approaches should have the same functionality
+    # The differences (Enum vs string, float vs int) are still valid when sent to the API
+    model_call_data = parent_mock.request.call_args_list[0][1]['data']
+    dict_call_data = parent_mock.request.call_args_list[1][1]['data']
+    
+    # Check that fields are functionally equivalent
+    assert model_call_data['search']['query'] == dict_call_data['search']['query']
+    assert float(model_call_data['search']['count']) == float(dict_call_data['search']['count'])
+    assert model_call_data['enrichments'][0]['description'] == dict_call_data['enrichments'][0]['description']
+    
+    # For format, we should get either the enum's value or the string directly
+    format1 = model_call_data['enrichments'][0]['format']
+    format2 = dict_call_data['enrichments'][0]['format']
+    
+    # If format1 is an enum, get its value
+    format1_value = format1.value if hasattr(format1, 'value') else format1
+    # If format2 is an enum, get its value
+    format2_value = format2.value if hasattr(format2, 'value') else format2
+    
+    assert format1_value == format2_value 
+
+def test_webhook_attempts_list(websets_client, parent_mock):
+    """Test that the WebhookAttemptsClient.list method works correctly."""
+    # Mock response for webhook attempts
+    mock_response = {
+        "data": [{
+            "id": "attempt_123",
+            "object": "webhook_attempt",
+            "eventId": "event_123",
+            "eventType": "webset.created",
+            "webhookId": "webhook_123",
+            "url": "https://example.com/webhook",
+            "successful": True,
+            "responseHeaders": {"content-type": "application/json"},
+            "responseBody": '{"status": "ok"}',
+            "responseStatusCode": 200,
+            "attempt": 1,
+            "attemptedAt": "2023-01-01T00:00:00Z"
+        }],
+        "hasMore": False,
+        "nextCursor": None
+    }
+    
+    parent_mock.request.return_value = mock_response
+    
+    # Test without optional parameters
+    result = websets_client.webhooks.attempts.list(webhook_id="webhook_123")
+    
+    parent_mock.request.assert_called_with(
+        "/websets//v0/webhooks/webhook_123/attempts",
+        params={},
+        method="GET",
+        data=None
+    )
+    
+    assert len(result.data) == 1
+    assert result.data[0].id == "attempt_123"
+    assert result.data[0].event_type == "webset.created"
+    assert result.data[0].successful is True
+    
+    # Reset mock and test with all optional parameters
+    parent_mock.request.reset_mock()
+    parent_mock.request.return_value = mock_response
+    
+    result = websets_client.webhooks.attempts.list(
+        webhook_id="webhook_123",
+        cursor="cursor_value",
+        limit=10,
+        event_type="webset.created"
+    )
+    
+    parent_mock.request.assert_called_with(
+        "/websets//v0/webhooks/webhook_123/attempts",
+        params={"cursor": "cursor_value", "limit": 10, "eventType": "webset.created"},
+        method="GET",
+        data=None
+    ) 

exa_py-1.12.1/exa_py/websets/_generator/pydantic/BaseModel.jinja2

@@ -1,42 +0,0 @@
-{% 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 -%}