exa-py 1.14.2__tar.gz → 1.14.3__tar.gz

{exa_py-1.14.2 → exa_py-1.14.3}/PKG-INFO

@@ -1,25 +1,21 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: exa-py
-Version: 1.14.2
+Version: 1.14.3
 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
 
@@ -131,4 +127,3 @@ exa = Exa(api_key="your-api-key")
       output_schema=OUTPUT_SCHEMA,
   )
 ```
-

{exa_py-1.14.2 → exa_py-1.14.3}/exa_py/api.py

@@ -159,7 +159,7 @@ FIND_SIMILAR_OPTIONS_TYPES = {
 }
 
 # the livecrawl options
-LIVECRAWL_OPTIONS = Literal["always", "fallback", "never", "auto"]
+LIVECRAWL_OPTIONS = Literal["always", "fallback", "never", "auto", "preferred"]
 
 CONTENTS_OPTIONS_TYPES = {
     "urls": [list],

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

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: exa-py
+Version: 1.14.3
+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)
+
+  # research task example – answer a question with citations
+  # Example prompt & schema inspired by the TypeScript example.
+  QUESTION = (
+      "Summarize the history of San Francisco highlighting one or two major events "
+      "for each decade from 1850 to 1950"
+  )
+  OUTPUT_SCHEMA: Dict[str, Any] = {
+      "type": "object",
+      "required": ["timeline"],
+      "properties": {
+          "timeline": {
+              "type": "array",
+              "items": {
+                  "type": "object",
+                  "required": ["decade", "notableEvents"],
+                  "properties": {
+                      "decade": {
+                          "type": "string",
+                          "description": 'Decade label e.g. "1850s"',
+                      },
+                      "notableEvents": {
+                          "type": "string",
+                          "description": "A summary of notable events.",
+                      },
+                  },
+              },
+          },
+      },
+  }
+  resp = exa.research.create_task(
+      instructions=QUESTION,
+      model="exa-research",
+      output_schema=OUTPUT_SCHEMA,
+  )
+```

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

@@ -0,0 +1,34 @@
+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/research/__init__.py
+exa_py/research/client.py
+exa_py/research/models.py
+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/monitors/__init__.py
+exa_py/websets/monitors/client.py
+exa_py/websets/monitors/runs/__init__.py
+exa_py/websets/monitors/runs/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_monitors.py
+tests/test_websets.py

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

@@ -0,0 +1 @@
+

exa_py-1.14.3/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.14.3/exa_py.egg-info/top_level.txt

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

{exa_py-1.14.2 → exa_py-1.14.3}/pyproject.toml

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

exa_py-1.14.3/setup.cfg

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

exa_py-1.14.3/setup.py

@@ -0,0 +1,26 @@
+from setuptools import find_packages, setup
+
+setup(
+    name="exa_py",
+    version="1.12.4",
+    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.14.3/tests/test_monitors.py

@@ -0,0 +1,502 @@
+from datetime import datetime
+import json
+from typing import Dict, Any
+
+import pytest
+from unittest.mock import MagicMock
+
+from exa_py.websets.monitors.client import MonitorsClient
+from exa_py.websets.monitors.runs.client import MonitorRunsClient
+from exa_py.websets.types import (
+    CreateMonitorParameters,
+    UpdateMonitor,
+    MonitorBehaviorSearch,
+    MonitorBehaviorRefresh,
+    MonitorBehaviorSearchConfig,
+    MonitorRefreshBehaviorEnrichmentsConfig,
+    MonitorRefreshBehaviorContentsConfig,
+    MonitorCadence,
+    MonitorStatus,
+    WebsetCompanyEntity,
+)
+
+# ============================================================================
+# 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 monitors_client(parent_mock):
+    """Create a MonitorsClient instance with mock parent."""
+    return MonitorsClient(parent_mock)
+
+@pytest.fixture
+def runs_client(parent_mock):
+    """Create a MonitorRunsClient instance with mock parent."""
+    return MonitorRunsClient(parent_mock)
+
+@pytest.fixture
+def sample_monitor_response():
+    """Sample monitor response data."""
+    return {
+        "id": "monitor_123",
+        "object": "monitor",
+        "status": "enabled",
+        "websetId": "ws_123",
+        "cadence": {
+            "cron": "0 9 * * *",  # Daily at 9:00 AM
+            "timezone": "Etc/UTC"
+        },
+        "behavior": {
+            "type": "search",
+            "config": {
+                "query": "AI startups",
+                "criteria": [{"description": "Must be AI focused"}],
+                "entity": {"type": "company"},
+                "count": 10,
+                "behavior": "append"
+            }
+        },
+        "lastRun": {
+            "id": "run_123",
+            "object": "monitor_run",
+            "status": "completed",
+            "monitorId": "monitor_123",
+            "type": "search",
+            "completedAt": "2023-01-01T10:00:00Z",
+            "failedAt": None,
+            "canceledAt": None,
+            "createdAt": "2023-01-01T09:00:00Z",
+            "updatedAt": "2023-01-01T10:00:00Z"
+        },
+        "nextRunAt": "2023-01-02T09:00:00Z",
+        "metadata": {"key": "value"},
+        "createdAt": "2023-01-01T00:00:00Z",
+        "updatedAt": "2023-01-01T00:00:00Z"
+    }
+
+@pytest.fixture
+def sample_monitor_run_response():
+    """Sample monitor run response data."""
+    return {
+        "id": "run_123",
+        "object": "monitor_run",
+        "status": "completed",
+        "monitorId": "monitor_123",
+        "type": "search",
+        "completedAt": "2023-01-01T10:00:00Z",
+        "failedAt": None,
+        "canceledAt": None,
+        "createdAt": "2023-01-01T09:00:00Z",
+        "updatedAt": "2023-01-01T10:00:00Z"
+    }
+
+# ============================================================================
+# MonitorsClient Tests
+# ============================================================================
+
+def test_monitors_client_has_runs_client(monitors_client):
+    """Test that MonitorsClient properly initializes with a runs client."""
+    assert hasattr(monitors_client, 'runs')
+    assert isinstance(monitors_client.runs, MonitorRunsClient)
+
+def test_create_monitor_with_search_behavior(monitors_client, parent_mock, sample_monitor_response):
+    """Test creating a monitor with search behavior."""
+    parent_mock.request.return_value = sample_monitor_response
+    
+    # Create parameters with search behavior
+    params = CreateMonitorParameters(
+        webset_id="ws_123",
+        cadence=MonitorCadence(
+            cron="0 9 * * *",  # Daily at 9:00 AM
+            timezone="America/New_York"
+        ),
+        behavior=MonitorBehaviorSearch(
+            type="search",
+            config=MonitorBehaviorSearchConfig(
+                query="AI startups",
+                criteria=[{"description": "Must be AI focused"}],
+                entity=WebsetCompanyEntity(type="company"),
+                count=10
+            )
+        ),
+        metadata={"environment": "test"}
+    )
+    
+    result = monitors_client.create(params)
+    
+    # Verify the request was made correctly
+    parent_mock.request.assert_called_once_with(
+        "/websets/v0/monitors",
+        data={
+            'websetId': 'ws_123',
+            'cadence': {'cron': '0 9 * * *', 'timezone': 'America/New_York'},
+            'behavior': {
+                'type': 'search',
+                'config': {
+                    'query': 'AI startups',
+                    'criteria': [{'description': 'Must be AI focused'}],
+                    'entity': {'type': 'company'},
+                    'count': 10,
+                    'behavior': 'append'
+                }
+            },
+            'metadata': {'environment': 'test'}
+        },
+        method="POST",
+        params=None
+    )
+    
+    # Verify the response
+    assert result.id == "monitor_123"
+    assert result.webset_id == "ws_123"
+    assert result.status == "enabled"
+
+def test_create_monitor_with_refresh_behavior(monitors_client, parent_mock, sample_monitor_response):
+    """Test creating a monitor with refresh behavior."""
+    # Modify response for refresh behavior
+    refresh_response = sample_monitor_response.copy()
+    refresh_response["behavior"] = {
+        "type": "refresh",
+        "config": {
+            "target": "enrichments",
+            "enrichments": {"ids": ["enrich_123"]}
+        }
+    }
+    parent_mock.request.return_value = refresh_response
+    
+    params = CreateMonitorParameters(
+        webset_id="ws_123",
+        cadence=MonitorCadence(cron="0 9 * * 1"),  # Weekly on Monday at 9:00 AM
+        behavior=MonitorBehaviorRefresh(
+            type="refresh",
+            config=MonitorRefreshBehaviorEnrichmentsConfig(
+                target="enrichments",
+                enrichments={"ids": ["enrich_123"]}
+            )
+        )
+    )
+    
+    result = monitors_client.create(params)
+    
+    assert result.id == "monitor_123"
+    assert result.behavior.type == "refresh"
+
+def test_create_monitor_with_contents_refresh(monitors_client, parent_mock, sample_monitor_response):
+    """Test creating a monitor with contents refresh behavior."""
+    # Modify response for contents refresh
+    refresh_response = sample_monitor_response.copy()
+    refresh_response["behavior"] = {
+        "type": "refresh",
+        "config": {
+            "target": "contents"
+        }
+    }
+    parent_mock.request.return_value = refresh_response
+    
+    params = CreateMonitorParameters(
+        webset_id="ws_123",
+        cadence=MonitorCadence(cron="0 9 * * 1"),
+        behavior=MonitorBehaviorRefresh(
+            type="refresh",
+            config=MonitorRefreshBehaviorContentsConfig(target="contents")
+        )
+    )
+    
+    result = monitors_client.create(params)
+    
+    assert result.id == "monitor_123"
+    assert result.behavior.type == "refresh"
+    assert result.behavior.config.target == "contents"
+
+def test_create_monitor_with_dict_params(monitors_client, parent_mock, sample_monitor_response):
+    """Test creating a monitor with dictionary parameters."""
+    parent_mock.request.return_value = sample_monitor_response
+    
+    params = {
+        "websetId": "ws_123",
+        "cadence": {
+            "cron": "0 9 * * *",
+            "timezone": "America/New_York"
+        },
+        "behavior": {
+            "type": "search",
+            "config": {
+                "query": "AI startups",
+                "criteria": [{"description": "Must be AI focused"}],
+                "entity": {"type": "company"},
+                "count": 10
+            }
+        }
+    }
+    
+    result = monitors_client.create(params)
+    
+    assert result.id == "monitor_123"
+    assert result.webset_id == "ws_123"
+
+def test_get_monitor(monitors_client, parent_mock, sample_monitor_response):
+    """Test getting a specific monitor."""
+    parent_mock.request.return_value = sample_monitor_response
+    
+    result = monitors_client.get("monitor_123")
+    
+    parent_mock.request.assert_called_once_with(
+        "/websets/v0/monitors/monitor_123",
+        data=None,
+        method="GET",
+        params=None
+    )
+    
+    assert result.id == "monitor_123"
+    assert result.status == "enabled"
+
+def test_list_monitors(monitors_client, parent_mock):
+    """Test listing monitors with parameters."""
+    response_data = {
+        "data": [
+            {
+                "id": "monitor_123",
+                "object": "monitor",
+                "status": "enabled",
+                "websetId": "ws_123",
+                "cadence": {"cron": "0 9 * * *", "timezone": "Etc/UTC"},
+                "behavior": {
+                    "type": "search", 
+                    "config": {
+                        "query": "AI startups",
+                        "criteria": [{"description": "Must be AI focused"}],
+                        "entity": {"type": "company"},
+                        "count": 10,
+                        "behavior": "append"
+                    }
+                },
+                "metadata": {},
+                "createdAt": "2023-01-01T00:00:00Z",
+                "updatedAt": "2023-01-01T00:00:00Z"
+            }
+        ],
+        "hasMore": False,
+        "nextCursor": None
+    }
+    parent_mock.request.return_value = response_data
+    
+    result = monitors_client.list(cursor="cursor_123", limit=10, webset_id="ws_123")
+    
+    parent_mock.request.assert_called_once_with(
+        "/websets/v0/monitors",
+        data=None,
+        method="GET",
+        params={"cursor": "cursor_123", "limit": 10, "websetId": "ws_123"}
+    )
+    
+    assert len(result.data) == 1
+    assert result.data[0].id == "monitor_123"
+    assert not result.has_more
+
+def test_list_monitors_no_params(monitors_client, parent_mock):
+    """Test listing monitors without parameters."""
+    response_data = {
+        "data": [],
+        "hasMore": False,
+        "nextCursor": None
+    }
+    parent_mock.request.return_value = response_data
+    
+    result = monitors_client.list()
+    
+    parent_mock.request.assert_called_once_with(
+        "/websets/v0/monitors",
+        data=None,
+        method="GET",
+        params={}
+    )
+    
+    assert len(result.data) == 0
+
+def test_update_monitor(monitors_client, parent_mock, sample_monitor_response):
+    """Test updating a monitor."""
+    updated_response = sample_monitor_response.copy()
+    updated_response["status"] = "disabled"
+    parent_mock.request.return_value = updated_response
+    
+    params = UpdateMonitor(status=MonitorStatus.disabled, metadata={"updated": "true"})
+    
+    result = monitors_client.update("monitor_123", params)
+    
+    parent_mock.request.assert_called_once_with(
+        "/websets/v0/monitors/monitor_123",
+        data={"status": "disabled", "metadata": {"updated": "true"}},
+        method="PATCH",
+        params=None
+    )
+    
+    assert result.id == "monitor_123"
+    assert result.status == "disabled"
+
+def test_update_monitor_with_dict(monitors_client, parent_mock, sample_monitor_response):
+    """Test updating a monitor with dictionary parameters."""
+    updated_response = sample_monitor_response.copy()
+    updated_response["status"] = "disabled"
+    parent_mock.request.return_value = updated_response
+    
+    params = {"status": "disabled", "metadata": {"updated": "true"}}
+    
+    result = monitors_client.update("monitor_123", params)
+    
+    assert result.id == "monitor_123"
+    assert result.status == "disabled"
+
+def test_delete_monitor(monitors_client, parent_mock, sample_monitor_response):
+    """Test deleting a monitor."""
+    deleted_response = sample_monitor_response.copy()
+    deleted_response["status"] = "disabled"
+    parent_mock.request.return_value = deleted_response
+    
+    result = monitors_client.delete("monitor_123")
+    
+    parent_mock.request.assert_called_once_with(
+        "/websets/v0/monitors/monitor_123",
+        data=None,
+        method="DELETE",
+        params=None
+    )
+    
+    assert result.id == "monitor_123"
+
+# ============================================================================
+# MonitorRunsClient Tests
+# ============================================================================
+
+def test_list_monitor_runs(runs_client, parent_mock, sample_monitor_run_response):
+    """Test listing monitor runs."""
+    response_data = {
+        "data": [sample_monitor_run_response],
+        "hasMore": False,
+        "nextCursor": None
+    }
+    parent_mock.request.return_value = response_data
+    
+    result = runs_client.list("monitor_123")
+    
+    parent_mock.request.assert_called_once_with(
+        "/websets/v0/monitors/monitor_123/runs",
+        data=None,
+        method="GET",
+        params=None
+    )
+    
+    assert len(result.data) == 1
+    assert result.data[0].id == "run_123"
+    assert result.data[0].monitor_id == "monitor_123"
+
+def test_get_monitor_run(runs_client, parent_mock, sample_monitor_run_response):
+    """Test getting a specific monitor run."""
+    parent_mock.request.return_value = sample_monitor_run_response
+    
+    result = runs_client.get("monitor_123", "run_123")
+    
+    parent_mock.request.assert_called_once_with(
+        "/websets/v0/monitors/monitor_123/runs/run_123",
+        data=None,
+        method="GET",
+        params=None
+    )
+    
+    assert result.id == "run_123"
+    assert result.monitor_id == "monitor_123"
+    assert result.status == "completed"
+
+def test_monitors_client_runs_integration(monitors_client, parent_mock, sample_monitor_run_response):
+    """Test that monitors client properly integrates with runs client."""
+    response_data = {
+        "data": [sample_monitor_run_response],
+        "hasMore": False,
+        "nextCursor": None
+    }
+    parent_mock.request.return_value = response_data
+    
+    result = monitors_client.runs.list("monitor_123")
+    
+    assert len(result.data) == 1
+    assert result.data[0].id == "run_123"
+
+def test_case_conversion_in_monitor_params(monitors_client, parent_mock, sample_monitor_response):
+    """Test that camelCase fields are properly handled."""
+    parent_mock.request.return_value = sample_monitor_response
+    
+    params = CreateMonitorParameters(
+        webset_id="ws_123",  # This should become websetId
+        cadence=MonitorCadence(cron="0 9 * * *"),
+        behavior=MonitorBehaviorSearch(
+            type="search",
+            config=MonitorBehaviorSearchConfig(
+                query="test",
+                criteria=[],
+                entity=WebsetCompanyEntity(type="company"),
+                count=10
+            )
+        )
+    )
+    
+    result = monitors_client.create(params)
+    
+    # Verify the response properly maps camelCase back to snake_case
+    assert result.webset_id == "ws_123"  # websetId -> webset_id
+    assert result.next_run_at is not None  # nextRunAt -> next_run_at
+
+def test_cron_expression_serialization(monitors_client, parent_mock, sample_monitor_response):
+    """Test that cron expressions are properly serialized."""
+    parent_mock.request.return_value = sample_monitor_response
+    
+    params = CreateMonitorParameters(
+        webset_id="ws_123",
+        cadence=MonitorCadence(
+            cron="0 9 * * 1-5",  # Weekdays at 9 AM
+            timezone="America/New_York"
+        ),
+        behavior=MonitorBehaviorSearch(
+            type="search",
+            config=MonitorBehaviorSearchConfig(
+                query="test",
+                criteria=[],
+                entity=WebsetCompanyEntity(type="company"),
+                count=5
+            )
+        )
+    )
+    
+    result = monitors_client.create(params)
+    
+    assert result.cadence.cron == "0 9 * * *"  # From response
+    assert result.cadence.timezone == "Etc/UTC"  # From response
+
+def test_monitors_client_request_error_handling(monitors_client, parent_mock):
+    """Test that client properly handles request errors."""
+    parent_mock.request.side_effect = Exception("Network error")
+    
+    with pytest.raises(Exception, match="Network error"):
+        monitors_client.get("monitor_123")
+
+def test_invalid_monitor_id_format(runs_client, parent_mock):
+    """Test handling of invalid monitor ID format."""
+    parent_mock.request.side_effect = Exception("Invalid monitor ID")
+    
+    with pytest.raises(Exception, match="Invalid monitor ID"):
+        runs_client.list("invalid_id") 

exa_py-1.14.3/tests/test_websets.py

@@ -0,0 +1,418 @@
+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,
+    CreateWebsetParametersSearch,
+    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": [],
+        "monitors": []
+    }
+    
+    parent_mock.request.return_value = mock_response
+    
+    request = CreateWebsetParameters(
+        external_id="test-id",
+        search=CreateWebsetParametersSearch(
+            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": [],
+        "monitors": []
+    }
+    
+    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": [],
+            "monitors": [],
+            "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)
+        
+        assert result.metadata == metadata
+        
+        actual_data = parent_mock.request.call_args[1]['data']
+        assert actual_data["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"}
+    )
+    
+    parent_mock.request.assert_called_once_with(
+        "/websets/test",
+        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": [],
+        "monitors": []
+    }
+    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.14.2/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 -%}