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

{exa_py-1.13.0 → exa_py-1.13.1}/PKG-INFO

@@ -1,21 +1,25 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.3
 Name: exa-py
-Version: 1.13.0
+Version: 1.13.1
 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
 
@@ -93,3 +97,4 @@ exa = Exa(api_key="your-api-key")
 
 ```
 
+

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

@@ -56,7 +56,7 @@ def snake_to_camel(snake_str: str) -> str:
         return "$schema"
     if snake_str == "not_":
         return "not"
-        
+
     components = snake_str.split("_")
     return components[0] + "".join(x.title() for x in components[1:])
 
@@ -261,6 +261,7 @@ class JSONSchema(TypedDict, total=False):
     """Represents a JSON Schema definition used for structured summary output.
     To learn more visit https://json-schema.org/overview/what-is-jsonschema.
     """
+
     schema_: str  # This will be converted to "$schema" in JSON
     title: str
     description: str
@@ -288,7 +289,7 @@ class SummaryContentsOptions(TypedDict, total=False):
 
     query: str
     schema: JSONSchema
-    
+
 
 class ExtrasOptions(TypedDict, total=False):
     """A class representing additional extraction fields (e.g. links, images)"""
@@ -669,7 +670,7 @@ class AnswerResponse:
         citations (List[AnswerResult]): A list of citations used to generate the answer.
     """
 
-    answer: str
+    answer: Union[str, dict[str, Any]]
     citations: List[AnswerResult]
 
     def __str__(self):
@@ -765,9 +766,9 @@ class AsyncStreamAnswerResponse:
                         content = chunk["choices"][0]["delta"].get("content")
 
                 if (
-                        "citations" in chunk
-                        and chunk["citations"]
-                        and chunk["citations"] != "null"
+                    "citations" in chunk
+                    and chunk["citations"]
+                    and chunk["citations"] != "null"
                 ):
                     citations = [
                         AnswerResult(**to_snake_case(s)) for s in chunk["citations"]
@@ -776,6 +777,7 @@ class AsyncStreamAnswerResponse:
                 stream_chunk = StreamChunk(content=content, citations=citations)
                 if stream_chunk.has_data():
                     yield stream_chunk
+
         return generator()
 
     def close(self) -> None:
@@ -834,6 +836,7 @@ 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.
@@ -889,10 +892,20 @@ class Exa:
                     "API key must be provided as an argument or in EXA_API_KEY environment variable"
                 )
         self.base_url = base_url
-        self.headers = {"x-api-key": api_key, "User-Agent": user_agent, "Content-Type": "application/json"}
+        self.headers = {
+            "x-api-key": api_key,
+            "User-Agent": user_agent,
+            "Content-Type": "application/json",
+        }
         self.websets = WebsetsClient(self)
 
-    def request(self, endpoint: str, data: Optional[Union[Dict[str, Any], str]] = None, method: str = "POST", params: Optional[Dict[str, Any]] = None) -> Union[Dict[str, Any], requests.Response]:
+    def request(
+        self,
+        endpoint: str,
+        data: Optional[Union[Dict[str, Any], str]] = None,
+        method: str = "POST",
+        params: Optional[Dict[str, Any]] = None,
+    ) -> Union[Dict[str, Any], requests.Response]:
         """Send a request to the Exa API, optionally streaming if data['stream'] is True.
 
         Args:
@@ -915,13 +928,13 @@ class Exa:
         else:
             # Otherwise, serialize the dictionary to JSON if it exists
             json_data = json.dumps(data, cls=ExaJSONEncoder) if data else None
-            
+
         if data and data.get("stream"):
             res = requests.post(
-                self.base_url + endpoint, 
+                self.base_url + endpoint,
                 data=json_data,
-                headers=self.headers, 
-                stream=True
+                headers=self.headers,
+                stream=True,
             )
             return res
 
@@ -931,20 +944,14 @@ class Exa:
             )
         elif method.upper() == "POST":
             res = requests.post(
-                self.base_url + endpoint, 
-                data=json_data,
-                headers=self.headers
+                self.base_url + endpoint, data=json_data, headers=self.headers
             )
         elif method.upper() == "PATCH":
             res = requests.patch(
-                self.base_url + endpoint, 
-                data=json_data,
-                headers=self.headers
+                self.base_url + endpoint, data=json_data, headers=self.headers
             )
         elif method.upper() == "DELETE":
-            res = requests.delete(
-                self.base_url + endpoint, headers=self.headers
-            )
+            res = requests.delete(self.base_url + endpoint, headers=self.headers)
         else:
             raise ValueError(f"Unsupported HTTP method: {method}")
 
@@ -1875,6 +1882,7 @@ class Exa:
         text: Optional[bool] = False,
         system_prompt: Optional[str] = None,
         model: Optional[Literal["exa", "exa-pro"]] = None,
+        output_schema: Optional[dict[str, Any]] = None,
     ) -> Union[AnswerResponse, StreamAnswerResponse]: ...
 
     def answer(
@@ -1885,6 +1893,7 @@ class Exa:
         text: Optional[bool] = False,
         system_prompt: Optional[str] = None,
         model: Optional[Literal["exa", "exa-pro"]] = None,
+        output_schema: Optional[dict[str, Any]] = None,
     ) -> Union[AnswerResponse, StreamAnswerResponse]:
         """Generate an answer to a query using Exa's search and LLM capabilities.
 
@@ -1893,6 +1902,7 @@ class Exa:
             text (bool, optional): Whether to include full text in the results. Defaults to False.
             system_prompt (str, optional): A system prompt to guide the LLM's behavior when generating the answer.
             model (str, optional): The model to use for answering. Either "exa" or "exa-pro". Defaults to None.
+            output_schema (dict[str, Any], optional): JSON schema describing the desired answer structure.
 
         Returns:
             AnswerResponse: An object containing the answer and citations.
@@ -1922,6 +1932,7 @@ class Exa:
         text: bool = False,
         system_prompt: Optional[str] = None,
         model: Optional[Literal["exa", "exa-pro"]] = None,
+        output_schema: Optional[dict[str, Any]] = None,
     ) -> StreamAnswerResponse:
         """Generate a streaming answer response.
 
@@ -1930,7 +1941,7 @@ class Exa:
             text (bool): Whether to include full text in the results. Defaults to False.
             system_prompt (str, optional): A system prompt to guide the LLM's behavior when generating the answer.
             model (str, optional): The model to use for answering. Either "exa" or "exa-pro". Defaults to None.
-
+            output_schema (dict[str, Any], optional): JSON schema describing the desired answer structure.
         Returns:
             StreamAnswerResponse: An object that can be iterated over to retrieve (partial text, partial citations).
                 Each iteration yields a tuple of (Optional[str], Optional[List[AnswerResult]]).
@@ -1982,9 +1993,7 @@ class AsyncExa(Exa):
         # this may only be a
         if self._client is None:
             self._client = httpx.AsyncClient(
-                base_url=self.base_url,
-                headers=self.headers,
-                timeout=60
+                base_url=self.base_url, headers=self.headers, timeout=60
             )
         return self._client
 
@@ -2004,15 +2013,14 @@ class AsyncExa(Exa):
         """
         if data.get("stream"):
             request = httpx.Request(
-                'POST',
-                self.base_url + endpoint,
-                json=data,
-                headers=self.headers
+                "POST", self.base_url + endpoint, json=data, headers=self.headers
             )
             res = await self.client.send(request, stream=True)
             return res
 
-        res = await self.client.post(self.base_url + endpoint, json=data, headers=self.headers)
+        res = await self.client.post(
+            self.base_url + endpoint, json=data, headers=self.headers
+        )
         if res.status_code != 200:
             raise ValueError(
                 f"Request failed with status code {res.status_code}: {res.text}"
@@ -2250,6 +2258,7 @@ class AsyncExa(Exa):
         text: Optional[bool] = False,
         system_prompt: Optional[str] = None,
         model: Optional[Literal["exa", "exa-pro"]] = None,
+        output_schema: Optional[dict[str, Any]] = None,
     ) -> Union[AnswerResponse, StreamAnswerResponse]:
         """Generate an answer to a query using Exa's search and LLM capabilities.
 
@@ -2258,6 +2267,7 @@ class AsyncExa(Exa):
             text (bool, optional): Whether to include full text in the results. Defaults to False.
             system_prompt (str, optional): A system prompt to guide the LLM's behavior when generating the answer.
             model (str, optional): The model to use for answering. Either "exa" or "exa-pro". Defaults to None.
+            output_schema (dict[str, Any], optional): JSON schema describing the desired answer structure.
 
         Returns:
             AnswerResponse: An object containing the answer and citations.
@@ -2287,6 +2297,7 @@ class AsyncExa(Exa):
         text: bool = False,
         system_prompt: Optional[str] = None,
         model: Optional[Literal["exa", "exa-pro"]] = None,
+        output_schema: Optional[dict[str, Any]] = None,
     ) -> AsyncStreamAnswerResponse:
         """Generate a streaming answer response.
 
@@ -2295,7 +2306,7 @@ class AsyncExa(Exa):
             text (bool): Whether to include full text in the results. Defaults to False.
             system_prompt (str, optional): A system prompt to guide the LLM's behavior when generating the answer.
             model (str, optional): The model to use for answering. Either "exa" or "exa-pro". Defaults to None.
-
+            output_schema (dict[str, Any], optional): JSON schema describing the desired answer structure.
         Returns:
             AsyncStreamAnswerResponse: An object that can be iterated over to retrieve (partial text, partial citations).
                 Each iteration yields a tuple of (Optional[str], Optional[List[AnswerResult]]).

exa_py-1.13.1/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-1.13.0 → exa_py-1.13.1}/pyproject.toml

@@ -32,7 +32,7 @@ in-project = true
 
 [project]
 name = "exa-py"
-version = "1.13.0"
+version = "1.13.1"
 description = "Python SDK for Exa API."
 readme = "README.md"
 requires-python = ">=3.9"

exa_py-1.13.0/exa_py.egg-info/PKG-INFO

@@ -1,95 +0,0 @@
-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
-
-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.13.0/exa_py.egg-info/SOURCES.txt

@@ -1,26 +0,0 @@
-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

@@ -1 +0,0 @@
-

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

@@ -1,6 +0,0 @@
-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

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

exa_py-1.13.0/setup.cfg

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

exa_py-1.13.0/setup.py

@@ -1,26 +0,0 @@
-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

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