exa-py 1.14.14__py3-none-any.whl → 1.14.15__py3-none-any.whl

exa_py/research/client.py

@@ -11,11 +11,13 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any, Dict, Optional, Literal
 
+from exa_py.utils import JSONSchemaInput
+from ..api import _convert_schema_input
+
 if TYPE_CHECKING:  # pragma: no cover – only for static analysers
     # Import with full type info when static type-checking.  `_Result` still
     # lives in ``exa_py.api`` but the response model moved to
     # ``exa_py.research.models``.
-    from ..api import _Result  # noqa: F401
     from .models import (
         ResearchTask,
         ResearchTaskId,
@@ -41,7 +43,7 @@ class ResearchClient:
         instructions: str,
         model: Literal["exa-research", "exa-research-pro"] = "exa-research",
         output_infer_schema: bool = None,
-        output_schema: Dict[str, Any] = None,
+        output_schema: "Optional[JSONSchemaInput]" = None,
     ) -> "ResearchTaskId":
         """Submit a research request and return the *task identifier*."""
         payload = {"instructions": instructions}
@@ -50,7 +52,7 @@ class ResearchClient:
         if output_schema is not None or output_infer_schema is not None:
             payload["output"] = {}
             if output_schema is not None:
-                payload["output"]["schema"] = output_schema
+                payload["output"]["schema"] = _convert_schema_input(output_schema)
             if output_infer_schema is not None:
                 payload["output"]["inferSchema"] = output_infer_schema
 
@@ -179,14 +181,17 @@ class AsyncResearchClient:
         *,
         instructions: str,
         model: Literal["exa-research", "exa-research-pro"] = "exa-research",
-        output_schema: Dict[str, Any],
+        output_schema: "JSONSchemaInput",
     ) -> "ResearchTaskId":
         """Submit a research request and return the *task identifier* (async)."""
 
+        # Convert schema using the same conversion logic as main API
+        from ..api import _convert_schema_input  # noqa: WPS433 – runtime import
+
         payload = {
             "instructions": instructions,
             "model": model,
-            "output": {"schema": output_schema},
+            "output": {"schema": _convert_schema_input(output_schema)},
         }
 
         raw_response: Dict[str, Any] = await self._client.async_request(
@@ -327,18 +332,20 @@ def _build_research_task(raw: Dict[str, Any]):
         results = []
         for c in cites:
             snake_c = to_snake_case(c)
-            results.append(_Result(
-                url=snake_c.get("url"),
-                id=snake_c.get("id"),
-                title=snake_c.get("title"),
-                score=snake_c.get("score"),
-                published_date=snake_c.get("published_date"),
-                author=snake_c.get("author"),
-                image=snake_c.get("image"),
-                favicon=snake_c.get("favicon"),
-                subpages=snake_c.get("subpages"),
-                extras=snake_c.get("extras")
-            ))
+            results.append(
+                _Result(
+                    url=snake_c.get("url"),
+                    id=snake_c.get("id"),
+                    title=snake_c.get("title"),
+                    score=snake_c.get("score"),
+                    published_date=snake_c.get("published_date"),
+                    author=snake_c.get("author"),
+                    image=snake_c.get("image"),
+                    favicon=snake_c.get("favicon"),
+                    subpages=snake_c.get("subpages"),
+                    extras=snake_c.get("extras"),
+                )
+            )
         citations_parsed[key] = results
 
     return ResearchTask(

exa_py/utils.py

@@ -1,13 +1,17 @@
 import json
-from typing import Optional
+import os
+from typing import Any, Optional, Union
 from openai.types.chat import ChatCompletion
 
 from typing import TYPE_CHECKING
+
+from pydantic import BaseModel
+from pydantic.json_schema import GenerateJsonSchema
+
 if TYPE_CHECKING:
     from exa_py.api import ResultWithText, SearchResponse
 
 
-
 def maybe_get_query(completion) -> Optional[str]:
     """Extract query from completion if it exists."""
     if completion.choices[0].message.tool_calls:
@@ -24,25 +28,25 @@ def add_message_to_messages(completion, messages, exa_result) -> list[dict]:
     assert assistant_message.tool_calls, "Must use this with a tool call request"
     # Remove previous exa call and results to prevent blowing up history
     messages = [
-        message
-        for message in messages
-        if not (message.get("role") == "function")
+        message for message in messages if not (message.get("role") == "function")
     ]
-    
-    messages.extend([
-        assistant_message,
-        {
-            "role": "tool",
-            "name": "search",
-            "tool_call_id": assistant_message.tool_calls[0].id,
-            "content": exa_result,
-        }
-    ])
+
+    messages.extend(
+        [
+            assistant_message,
+            {
+                "role": "tool",
+                "name": "search",
+                "tool_call_id": assistant_message.tool_calls[0].id,
+                "content": exa_result,
+            },
+        ]
+    )
 
     return messages
 
 
-def format_exa_result(exa_result, max_len: int=-1):
+def format_exa_result(exa_result, max_len: int = -1):
     """Format exa result for pasting into chat."""
     str = [
         f"Url: {result.url}\nTitle: {result.title}\n{result.text[:max_len]}\n"
@@ -54,18 +58,35 @@ def format_exa_result(exa_result, max_len: int=-1):
 
 class ExaOpenAICompletion(ChatCompletion):
     """Exa wrapper for OpenAI completion."""
-    def __init__(self, exa_result: Optional["SearchResponse[ResultWithText]"], id, choices, created, model, object, system_fingerprint=None, usage=None):
-        super().__init__(id=id, choices=choices, created=created, model=model, object=object, system_fingerprint=system_fingerprint, usage=usage)
+
+    def __init__(
+        self,
+        exa_result: Optional["SearchResponse[ResultWithText]"],
+        id,
+        choices,
+        created,
+        model,
+        object,
+        system_fingerprint=None,
+        usage=None,
+    ):
+        super().__init__(
+            id=id,
+            choices=choices,
+            created=created,
+            model=model,
+            object=object,
+            system_fingerprint=system_fingerprint,
+            usage=usage,
+        )
         self.exa_result = exa_result
-    
 
     @classmethod
     def from_completion(
-        cls, 
-        exa_result: Optional["SearchResponse[ResultWithText]"], 
-        completion: ChatCompletion
+        cls,
+        exa_result: Optional["SearchResponse[ResultWithText]"],
+        completion: ChatCompletion,
     ):
-
         return cls(
             exa_result=exa_result,
             id=completion.id,
@@ -76,3 +97,98 @@ class ExaOpenAICompletion(ChatCompletion):
             system_fingerprint=completion.system_fingerprint,
             usage=completion.usage,
         )
+
+
+JSONSchemaInput = Union[type[BaseModel], dict[str, Any]]
+
+
+class InlineJsonSchemaGenerator(GenerateJsonSchema):
+    """Custom JSON schema generator that inlines all schemas without creating $defs references."""
+
+    def generate(self, schema, mode="validation"):
+        """Generate JSON schema normally, then post-process to inline all refs."""
+        # Let Pydantic do its normal thing first
+        result = super().generate(schema, mode)
+
+        # Post-process to inline all $ref references
+        if "$defs" in result:
+            definitions = result["$defs"]
+            inlined_result = self._inline_refs(result, definitions)
+            # Remove $defs since everything is now inlined
+            if "$defs" in inlined_result:
+                del inlined_result["$defs"]
+            return inlined_result
+
+        return result
+
+    def _inline_refs(self, obj, definitions):
+        """Recursively replace all $ref with actual definitions."""
+        if isinstance(obj, dict):
+            if "$ref" in obj and len(obj) == 1:  # Pure ref object
+                ref_path = obj["$ref"]
+                if ref_path.startswith("#/$defs/"):
+                    def_name = ref_path[8:]  # Remove '#/$defs/'
+                    if def_name in definitions:
+                        # Replace the ref with the actual definition (recursively processed)
+                        return self._inline_refs(definitions[def_name], definitions)
+                return obj  # Return as-is if we can't resolve
+            else:
+                # Process all values in the dict
+                return {
+                    key: self._inline_refs(value, definitions)
+                    for key, value in obj.items()
+                }
+        elif isinstance(obj, list):
+            # Process all items in the list
+            return [self._inline_refs(item, definitions) for item in obj]
+        else:
+            # Primitive value, return as-is
+            return obj
+
+
+def _convert_schema_input(schema_input: "JSONSchemaInput") -> dict[str, Any]:
+    """Convert various schema input types to JSON Schema dict.
+
+    Args:
+        schema_input: Either a Pydantic BaseModel class or a dict containing JSON Schema
+
+    Returns:
+        dict: JSON Schema representation (fully inlined without $defs)
+    """
+    # Check if it's a Pydantic model class (not instance)
+    if isinstance(schema_input, type) and issubclass(schema_input, BaseModel):
+        return schema_input.model_json_schema(
+            by_alias=False,
+            mode="serialization",
+            schema_generator=InlineJsonSchemaGenerator,
+        )
+    elif isinstance(schema_input, dict):
+        return schema_input
+    else:
+        raise ValueError(
+            f"Unsupported schema type: {type(schema_input)}. Expected BaseModel class or dict."
+        )
+
+
+def _get_package_version() -> str:
+    """Get the package version from pyproject.toml."""
+    try:
+        try:
+            import tomllib  # Python 3.11+
+        except ImportError:
+            import tomli as tomllib  # fallback for older versions
+
+        import os
+
+        current_dir = os.path.dirname(os.path.abspath(__file__))
+        project_root = os.path.dirname(current_dir)
+        pyproject_path = os.path.join(project_root, "pyproject.toml")
+
+        if os.path.exists(pyproject_path):
+            with open(pyproject_path, "rb") as f:
+                data = tomllib.load(f)
+                return data.get("project", {}).get("version", "unknown")
+    except Exception:
+        pass
+
+    return "unknown"

{exa_py-1.14.14.dist-info → exa_py-1.14.15.dist-info}/METADATA

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

{exa_py-1.14.14.dist-info → exa_py-1.14.15.dist-info}/RECORD

@@ -1,10 +1,10 @@
 exa_py/__init__.py,sha256=M2GC9oSdoV6m2msboW0vMWWl8wrth4o6gmEV4MYLGG8,66
-exa_py/api.py,sha256=IrToa0zN39SREpwwcyuFvnoE_-pIc9uWVDkEw07IN9I,99737
+exa_py/api.py,sha256=S2GfFiUSQrogwqSWqQvN2w6wb4yrbZAmgERI6NntjSQ,106657
 exa_py/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 exa_py/research/__init__.py,sha256=QeY-j6bP4QP5tF9ytX0IeQhJvd0Wn4cJCD69U8pP7kA,271
-exa_py/research/client.py,sha256=x9b299ROfbhdMrdto6jZCHGRJE5U5V2fWHsSlnnNkWo,12471
+exa_py/research/client.py,sha256=mnoTA4Qoa0TA5d8nVTR9tAU9LJElXV-MlPozgMxlUp4,12799
 exa_py/research/models.py,sha256=j7YgRoMRp2MLgnaij7775x_hJEeV5gksKpfLwmawqxY,3704
-exa_py/utils.py,sha256=sq1KOajuMWI1lygYeb9MqjXn8yqVyK0BtFZZmTwSaMY,2580
+exa_py/utils.py,sha256=eYnJRAFJonwKP_mCxzAB9TnLEqoF-88stg6wh-M-Ups,6424
 exa_py/websets/__init__.py,sha256=x7Dc0MS8raRXA7Ud6alKgnsUmLi6X9GTqfB8kOwC9iQ,179
 exa_py/websets/_generator/pydantic/BaseModel.jinja2,sha256=RUDCmPZVamoVx1WudylscYFfDhGoNNtRYlpTvKjAiuA,1276
 exa_py/websets/client.py,sha256=v8Y0p5PosjLkb7EYQ83g3nmoIIHmKaXF7JQVT8K5h2E,4967
@@ -27,6 +27,6 @@ exa_py/websets/searches/client.py,sha256=X3f7axWGfecmxf-2tBTX0Yf_--xToz1X8ZHbbud
 exa_py/websets/types.py,sha256=W0ZV_ETW-sDXNh9fK9qROmPRHU_koy1rfTGhjCG3yrA,42231
 exa_py/websets/webhooks/__init__.py,sha256=iTPBCxFd73z4RifLQMX6iRECx_6pwlI5qscLNjMOUHE,77
 exa_py/websets/webhooks/client.py,sha256=zsIRMTeJU65yj-zo7Zz-gG02Prtzgcx6utGFSoY4HQQ,4222
-exa_py-1.14.14.dist-info/METADATA,sha256=GGN6xgOdXmRExHuU7eMR4P8RC_dC6Z4eHSGnugUaoGA,3827
-exa_py-1.14.14.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-exa_py-1.14.14.dist-info/RECORD,,
+exa_py-1.14.15.dist-info/METADATA,sha256=yKrbylAzoYKm2O0JcwCsFmZaOWnQ62blvqBmvA4GK74,3827
+exa_py-1.14.15.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+exa_py-1.14.15.dist-info/RECORD,,