diff --git a/.release-please-manifest.json b/.release-please-manifest.json index ff661205..dd7ced1c 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.48.0" + ".": "0.49.0" } \ No newline at end of file diff --git a/.stats.yml b/.stats.yml index 6af66a73..3c51b7b0 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ -configured_endpoints: 59 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/profound/profound-78b11dd189b9201fa71681a122231d11c49fba4e273dfaab10301f0f9c7fbc23.yml -openapi_spec_hash: 4bfe07ba5ff595ac71ede0c0305c975a -config_hash: 722ed77ad7cd10d19ab8c20abaa9b0ff +configured_endpoints: 73 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/profound/profound-2e4776730f9ad1261f13d4f7f8f7604be69bde3b937433c4fefa2c3c9198199f.yml +openapi_spec_hash: 1c91f2db23dc5afefe433f93109c5369 +config_hash: 718a763c108eede78d67ce71ecdac365 diff --git a/CHANGELOG.md b/CHANGELOG.md index 26258fb5..1715f9e6 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,15 @@ # Changelog +## 0.49.0 (2026-06-17) + +Full Changelog: [v0.48.0...v0.49.0](https://github.com/cooper-square-technologies/profound-python-sdk/compare/v0.48.0...v0.49.0) + +### Features + +* **api:** api update ([7f09cc2](https://github.com/cooper-square-technologies/profound-python-sdk/commit/7f09cc21fffcfc50e910011658f118d1abeca21f)) +* **api:** api update ([0e0b780](https://github.com/cooper-square-technologies/profound-python-sdk/commit/0e0b78046f76107016055dd8111f830722b68f09)) +* **api:** manual updates ([0701a3f](https://github.com/cooper-square-technologies/profound-python-sdk/commit/0701a3fc3e786ed33210469d7c13a837a7cf136d)) + ## 0.48.0 (2026-06-12) Full Changelog: [v0.47.0...v0.48.0](https://github.com/cooper-square-technologies/profound-python-sdk/compare/v0.47.0...v0.48.0) diff --git a/api.md b/api.md index b35e4de5..1763987a 100644 --- a/api.md +++ b/api.md @@ -182,6 +182,44 @@ Methods: - client.reports.shopping.trigger_rate(\*\*params) -> ShoppingTriggerRateResponse - client.reports.shopping.visibility(\*\*params) -> ShoppingVisibilityResponse +## Accuracy + +Types: + +```python +from profound.types.reports import ( + AccuracyCreateBreakdownResponse, + AccuracyCreateCitationAnalysisResponse, + AccuracyCreateClaimBreakdownResponse, + AccuracyCreateClaimCitationsResponse, + AccuracyCreateClusterExampleRunsResponse, + AccuracyCreateClusterVerificationPairsResponse, + AccuracyCreateFactcheckSetupStatusResponse, + AccuracyCreateInaccuracyDriversResponse, + AccuracyCreateInaccurateClustersResponse, + AccuracyCreateInaccurateThemesResponse, + AccuracyCreateOverviewResponse, + AccuracyCreateTopInaccurateClaimsResponse, + AccuracyCreateTopicIDsResponse, +) +``` + +Methods: + +- client.reports.accuracy.create_breakdown(\*\*params) -> AccuracyCreateBreakdownResponse +- client.reports.accuracy.create_citation_analysis(\*\*params) -> AccuracyCreateCitationAnalysisResponse +- client.reports.accuracy.create_claim_breakdown(\*\*params) -> AccuracyCreateClaimBreakdownResponse +- client.reports.accuracy.create_claim_citations(\*\*params) -> AccuracyCreateClaimCitationsResponse +- client.reports.accuracy.create_cluster_example_runs(\*\*params) -> AccuracyCreateClusterExampleRunsResponse +- client.reports.accuracy.create_cluster_verification_pairs(\*\*params) -> AccuracyCreateClusterVerificationPairsResponse +- client.reports.accuracy.create_factcheck_setup_status(\*\*params) -> AccuracyCreateFactcheckSetupStatusResponse +- client.reports.accuracy.create_inaccuracy_drivers(\*\*params) -> AccuracyCreateInaccuracyDriversResponse +- client.reports.accuracy.create_inaccurate_clusters(\*\*params) -> AccuracyCreateInaccurateClustersResponse +- client.reports.accuracy.create_inaccurate_themes(\*\*params) -> AccuracyCreateInaccurateThemesResponse +- client.reports.accuracy.create_overview(\*\*params) -> AccuracyCreateOverviewResponse +- client.reports.accuracy.create_top_inaccurate_claims(\*\*params) -> AccuracyCreateTopInaccurateClaimsResponse +- client.reports.accuracy.create_topic_ids(\*\*params) -> AccuracyCreateTopicIDsResponse + # Logs ## Raw @@ -220,6 +258,7 @@ Types: from profound.types import ( AgentCreateResponse, AgentRetrieveResponse, + AgentUpdateResponse, AgentListResponse, AgentPublishResponse, ) @@ -229,6 +268,7 @@ Methods: - client.agents.create(\*\*params) -> AgentCreateResponse - client.agents.retrieve(agent_id, \*\*params) -> AgentRetrieveResponse +- client.agents.update(agent_id, \*\*params) -> AgentUpdateResponse - client.agents.list(\*\*params) -> AgentListResponse - client.agents.publish(agent_id) -> AgentPublishResponse diff --git a/pyproject.toml b/pyproject.toml index 875b1f4a..4f51b353 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "profound" -version = "0.48.0" +version = "0.49.0" description = "The official Python library for the profound API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/profound/_version.py b/src/profound/_version.py index d96d7e17..3b9e34b4 100644 --- a/src/profound/_version.py +++ b/src/profound/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "profound" -__version__ = "0.48.0" # x-release-please-version +__version__ = "0.49.0" # x-release-please-version diff --git a/src/profound/resources/agents/agents.py b/src/profound/resources/agents/agents.py index c1957726..7986c741 100644 --- a/src/profound/resources/agents/agents.py +++ b/src/profound/resources/agents/agents.py @@ -15,7 +15,7 @@ RunsResourceWithStreamingResponse, AsyncRunsResourceWithStreamingResponse, ) -from ...types import agent_list_params, agent_create_params, agent_retrieve_params +from ...types import agent_list_params, agent_create_params, agent_update_params, agent_retrieve_params from ..._types import Body, Omit, Query, Headers, NotGiven, omit, not_given from ..._utils import path_template, maybe_transform, async_maybe_transform from ..._compat import cached_property @@ -37,6 +37,7 @@ from ..._base_client import make_request_options from ...types.agent_list_response import AgentListResponse from ...types.agent_create_response import AgentCreateResponse +from ...types.agent_update_response import AgentUpdateResponse from ...types.agent_publish_response import AgentPublishResponse from ...types.agent_retrieve_response import AgentRetrieveResponse @@ -177,6 +178,54 @@ def retrieve( cast_to=AgentRetrieveResponse, ) + def update( + self, + agent_id: str, + *, + graph: Dict[str, object], + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> AgentUpdateResponse: + """ + Update an agent's draft graph in place. + + You must be a member of the agent's organization. The agent's draft is replaced + with the supplied graph and re-validated, so you can iterate one draft — create, + then update per fix — instead of creating a new agent on every change. The + response carries the updated `validation`; publish with + `POST /v1/agents/{agent_id}/publish` once `validation.valid`. + + Args: + agent_id: The ID of the agent to update. + + graph: New workflow graph for the agent's draft version. Replaces the current draft + graph; the agent is iterated in place rather than re-created, so its ID is + stable. Required — Magi rejects a null graph, so an empty update is a 422 here + rather than a relayed upstream error. + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not agent_id: + raise ValueError(f"Expected a non-empty value for `agent_id` but received {agent_id!r}") + return self._patch( + path_template("/v1/agents/{agent_id}", agent_id=agent_id), + body=maybe_transform({"graph": graph}, agent_update_params.AgentUpdateParams), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=AgentUpdateResponse, + ) + def list( self, *, @@ -403,6 +452,54 @@ async def retrieve( cast_to=AgentRetrieveResponse, ) + async def update( + self, + agent_id: str, + *, + graph: Dict[str, object], + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> AgentUpdateResponse: + """ + Update an agent's draft graph in place. + + You must be a member of the agent's organization. The agent's draft is replaced + with the supplied graph and re-validated, so you can iterate one draft — create, + then update per fix — instead of creating a new agent on every change. The + response carries the updated `validation`; publish with + `POST /v1/agents/{agent_id}/publish` once `validation.valid`. + + Args: + agent_id: The ID of the agent to update. + + graph: New workflow graph for the agent's draft version. Replaces the current draft + graph; the agent is iterated in place rather than re-created, so its ID is + stable. Required — Magi rejects a null graph, so an empty update is a 422 here + rather than a relayed upstream error. + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not agent_id: + raise ValueError(f"Expected a non-empty value for `agent_id` but received {agent_id!r}") + return await self._patch( + path_template("/v1/agents/{agent_id}", agent_id=agent_id), + body=await async_maybe_transform({"graph": graph}, agent_update_params.AgentUpdateParams), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=AgentUpdateResponse, + ) + async def list( self, *, @@ -505,6 +602,9 @@ def __init__(self, agents: AgentsResource) -> None: self.retrieve = to_raw_response_wrapper( agents.retrieve, ) + self.update = to_raw_response_wrapper( + agents.update, + ) self.list = to_raw_response_wrapper( agents.list, ) @@ -531,6 +631,9 @@ def __init__(self, agents: AsyncAgentsResource) -> None: self.retrieve = async_to_raw_response_wrapper( agents.retrieve, ) + self.update = async_to_raw_response_wrapper( + agents.update, + ) self.list = async_to_raw_response_wrapper( agents.list, ) @@ -557,6 +660,9 @@ def __init__(self, agents: AgentsResource) -> None: self.retrieve = to_streamed_response_wrapper( agents.retrieve, ) + self.update = to_streamed_response_wrapper( + agents.update, + ) self.list = to_streamed_response_wrapper( agents.list, ) @@ -583,6 +689,9 @@ def __init__(self, agents: AsyncAgentsResource) -> None: self.retrieve = async_to_streamed_response_wrapper( agents.retrieve, ) + self.update = async_to_streamed_response_wrapper( + agents.update, + ) self.list = async_to_streamed_response_wrapper( agents.list, ) diff --git a/src/profound/resources/reports/__init__.py b/src/profound/resources/reports/__init__.py index b0684579..3e1fd97a 100644 --- a/src/profound/resources/reports/__init__.py +++ b/src/profound/resources/reports/__init__.py @@ -8,6 +8,14 @@ ReportsResourceWithStreamingResponse, AsyncReportsResourceWithStreamingResponse, ) +from .accuracy import ( + AccuracyResource, + AsyncAccuracyResource, + AccuracyResourceWithRawResponse, + AsyncAccuracyResourceWithRawResponse, + AccuracyResourceWithStreamingResponse, + AsyncAccuracyResourceWithStreamingResponse, +) from .shopping import ( ShoppingResource, AsyncShoppingResource, @@ -38,6 +46,12 @@ "AsyncShoppingResourceWithRawResponse", "ShoppingResourceWithStreamingResponse", "AsyncShoppingResourceWithStreamingResponse", + "AccuracyResource", + "AsyncAccuracyResource", + "AccuracyResourceWithRawResponse", + "AsyncAccuracyResourceWithRawResponse", + "AccuracyResourceWithStreamingResponse", + "AsyncAccuracyResourceWithStreamingResponse", "ReportsResource", "AsyncReportsResource", "ReportsResourceWithRawResponse", diff --git a/src/profound/resources/reports/accuracy.py b/src/profound/resources/reports/accuracy.py new file mode 100644 index 00000000..6ec45639 --- /dev/null +++ b/src/profound/resources/reports/accuracy.py @@ -0,0 +1,1852 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Optional +from typing_extensions import Literal + +import httpx + +from ..._types import Body, Omit, Query, Headers, NotGiven, SequenceNotStr, omit, not_given +from ..._utils import maybe_transform, async_maybe_transform +from ..._compat import cached_property +from ..._resource import SyncAPIResource, AsyncAPIResource +from ..._response import ( + to_raw_response_wrapper, + to_streamed_response_wrapper, + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, +) +from ..._base_client import make_request_options +from ...types.reports import ( + accuracy_create_overview_params, + accuracy_create_breakdown_params, + accuracy_create_topic_ids_params, + accuracy_create_claim_breakdown_params, + accuracy_create_claim_citations_params, + accuracy_create_citation_analysis_params, + accuracy_create_inaccurate_themes_params, + accuracy_create_inaccuracy_drivers_params, + accuracy_create_inaccurate_clusters_params, + accuracy_create_cluster_example_runs_params, + accuracy_create_top_inaccurate_claims_params, + accuracy_create_factcheck_setup_status_params, + accuracy_create_cluster_verification_pairs_params, +) +from ...types.reports.accuracy_create_overview_response import AccuracyCreateOverviewResponse +from ...types.reports.accuracy_create_breakdown_response import AccuracyCreateBreakdownResponse +from ...types.reports.accuracy_create_topic_ids_response import AccuracyCreateTopicIDsResponse +from ...types.reports.accuracy_create_claim_breakdown_response import AccuracyCreateClaimBreakdownResponse +from ...types.reports.accuracy_create_claim_citations_response import AccuracyCreateClaimCitationsResponse +from ...types.reports.accuracy_create_citation_analysis_response import AccuracyCreateCitationAnalysisResponse +from ...types.reports.accuracy_create_inaccurate_themes_response import AccuracyCreateInaccurateThemesResponse +from ...types.reports.accuracy_create_inaccuracy_drivers_response import AccuracyCreateInaccuracyDriversResponse +from ...types.reports.accuracy_create_inaccurate_clusters_response import AccuracyCreateInaccurateClustersResponse +from ...types.reports.accuracy_create_cluster_example_runs_response import AccuracyCreateClusterExampleRunsResponse +from ...types.reports.accuracy_create_top_inaccurate_claims_response import AccuracyCreateTopInaccurateClaimsResponse +from ...types.reports.accuracy_create_factcheck_setup_status_response import AccuracyCreateFactcheckSetupStatusResponse +from ...types.reports.accuracy_create_cluster_verification_pairs_response import ( + AccuracyCreateClusterVerificationPairsResponse, +) + +__all__ = ["AccuracyResource", "AsyncAccuracyResource"] + + +class AccuracyResource(SyncAPIResource): + @cached_property + def with_raw_response(self) -> AccuracyResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/cooper-square-technologies/profound-python-sdk#accessing-raw-response-data-eg-headers + """ + return AccuracyResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AccuracyResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/cooper-square-technologies/profound-python-sdk#with_streaming_response + """ + return AccuracyResourceWithStreamingResponse(self) + + def create_breakdown( + self, + *, + category_id: str, + end_date: str, + start_date: str, + breakdown_by: Literal["citation", "platform", "topic", "prompt", "tag", "region", "persona"] | Omit = omit, + citation_categories: Optional[SequenceNotStr[str]] | Omit = omit, + comparison_end_date: Optional[str] | Omit = omit, + comparison_start_date: Optional[str] | Omit = omit, + exclude_topic_ids: bool | Omit = omit, + include_no_persona: bool | Omit = omit, + include_no_tag: bool | Omit = omit, + limit: int | Omit = omit, + offset: int | Omit = omit, + persona_ids: Optional[SequenceNotStr[str]] | Omit = omit, + platform_ids: Optional[SequenceNotStr[str]] | Omit = omit, + prompt_ids: Optional[SequenceNotStr[str]] | Omit = omit, + region_ids: Optional[SequenceNotStr[str]] | Omit = omit, + search_query: Optional[str] | Omit = omit, + sort_by: Literal["citationShare", "accuracy"] | Omit = omit, + sort_order: Literal["asc", "desc"] | Omit = omit, + tag_filter_type: Literal["all", "any"] | Omit = omit, + tag_ids: Optional[SequenceNotStr[str]] | Omit = omit, + topic_ids: Optional[SequenceNotStr[str]] | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> AccuracyCreateBreakdownResponse: + """ + Accuracy Breakdown + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + return self._post( + "/v1/reports/accuracy/breakdown", + body=maybe_transform( + { + "category_id": category_id, + "end_date": end_date, + "start_date": start_date, + "breakdown_by": breakdown_by, + "citation_categories": citation_categories, + "comparison_end_date": comparison_end_date, + "comparison_start_date": comparison_start_date, + "exclude_topic_ids": exclude_topic_ids, + "include_no_persona": include_no_persona, + "include_no_tag": include_no_tag, + "limit": limit, + "offset": offset, + "persona_ids": persona_ids, + "platform_ids": platform_ids, + "prompt_ids": prompt_ids, + "region_ids": region_ids, + "search_query": search_query, + "sort_by": sort_by, + "sort_order": sort_order, + "tag_filter_type": tag_filter_type, + "tag_ids": tag_ids, + "topic_ids": topic_ids, + }, + accuracy_create_breakdown_params.AccuracyCreateBreakdownParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=AccuracyCreateBreakdownResponse, + ) + + def create_citation_analysis( + self, + *, + category_id: str, + clean_href: str, + end_date: str, + start_date: str, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> AccuracyCreateCitationAnalysisResponse: + """ + Accuracy Citation Analysis + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + return self._post( + "/v1/reports/accuracy/citation-analysis", + body=maybe_transform( + { + "category_id": category_id, + "clean_href": clean_href, + "end_date": end_date, + "start_date": start_date, + }, + accuracy_create_citation_analysis_params.AccuracyCreateCitationAnalysisParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=AccuracyCreateCitationAnalysisResponse, + ) + + def create_claim_breakdown( + self, + *, + category_id: str, + cluster_id: str, + end_date: str, + start_date: str, + citation_categories: Optional[SequenceNotStr[str]] | Omit = omit, + comparison_end_date: Optional[str] | Omit = omit, + comparison_start_date: Optional[str] | Omit = omit, + exclude_topic_ids: bool | Omit = omit, + include_no_persona: bool | Omit = omit, + include_no_tag: bool | Omit = omit, + persona_ids: Optional[SequenceNotStr[str]] | Omit = omit, + platform_ids: Optional[SequenceNotStr[str]] | Omit = omit, + prompt_ids: Optional[SequenceNotStr[str]] | Omit = omit, + region_ids: Optional[SequenceNotStr[str]] | Omit = omit, + tag_filter_type: Literal["all", "any"] | Omit = omit, + tag_ids: Optional[SequenceNotStr[str]] | Omit = omit, + topic_ids: Optional[SequenceNotStr[str]] | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> AccuracyCreateClaimBreakdownResponse: + """ + Accuracy Claim Breakdown + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + return self._post( + "/v1/reports/accuracy/claim-breakdown", + body=maybe_transform( + { + "category_id": category_id, + "cluster_id": cluster_id, + "end_date": end_date, + "start_date": start_date, + "citation_categories": citation_categories, + "comparison_end_date": comparison_end_date, + "comparison_start_date": comparison_start_date, + "exclude_topic_ids": exclude_topic_ids, + "include_no_persona": include_no_persona, + "include_no_tag": include_no_tag, + "persona_ids": persona_ids, + "platform_ids": platform_ids, + "prompt_ids": prompt_ids, + "region_ids": region_ids, + "tag_filter_type": tag_filter_type, + "tag_ids": tag_ids, + "topic_ids": topic_ids, + }, + accuracy_create_claim_breakdown_params.AccuracyCreateClaimBreakdownParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=AccuracyCreateClaimBreakdownResponse, + ) + + def create_claim_citations( + self, + *, + category_id: str, + cluster_id: str, + end_date: str, + start_date: str, + citation_categories: Optional[SequenceNotStr[str]] | Omit = omit, + comparison_end_date: Optional[str] | Omit = omit, + comparison_start_date: Optional[str] | Omit = omit, + exclude_topic_ids: bool | Omit = omit, + include_no_persona: bool | Omit = omit, + include_no_tag: bool | Omit = omit, + limit: int | Omit = omit, + offset: int | Omit = omit, + persona_ids: Optional[SequenceNotStr[str]] | Omit = omit, + platform_ids: Optional[SequenceNotStr[str]] | Omit = omit, + prompt_ids: Optional[SequenceNotStr[str]] | Omit = omit, + region_ids: Optional[SequenceNotStr[str]] | Omit = omit, + search_query: Optional[str] | Omit = omit, + sort_order: Literal["asc", "desc"] | Omit = omit, + tag_filter_type: Literal["all", "any"] | Omit = omit, + tag_ids: Optional[SequenceNotStr[str]] | Omit = omit, + topic_ids: Optional[SequenceNotStr[str]] | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> AccuracyCreateClaimCitationsResponse: + """ + Accuracy Claim Citations + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + return self._post( + "/v1/reports/accuracy/claim-citations", + body=maybe_transform( + { + "category_id": category_id, + "cluster_id": cluster_id, + "end_date": end_date, + "start_date": start_date, + "citation_categories": citation_categories, + "comparison_end_date": comparison_end_date, + "comparison_start_date": comparison_start_date, + "exclude_topic_ids": exclude_topic_ids, + "include_no_persona": include_no_persona, + "include_no_tag": include_no_tag, + "limit": limit, + "offset": offset, + "persona_ids": persona_ids, + "platform_ids": platform_ids, + "prompt_ids": prompt_ids, + "region_ids": region_ids, + "search_query": search_query, + "sort_order": sort_order, + "tag_filter_type": tag_filter_type, + "tag_ids": tag_ids, + "topic_ids": topic_ids, + }, + accuracy_create_claim_citations_params.AccuracyCreateClaimCitationsParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=AccuracyCreateClaimCitationsResponse, + ) + + def create_cluster_example_runs( + self, + *, + category_id: str, + cluster_id: str, + end_date: str, + start_date: str, + limit: int | Omit = omit, + offset: int | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> AccuracyCreateClusterExampleRunsResponse: + """ + Accuracy Cluster Example Runs + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + return self._post( + "/v1/reports/accuracy/cluster-example-runs", + body=maybe_transform( + { + "category_id": category_id, + "cluster_id": cluster_id, + "end_date": end_date, + "start_date": start_date, + "limit": limit, + "offset": offset, + }, + accuracy_create_cluster_example_runs_params.AccuracyCreateClusterExampleRunsParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=AccuracyCreateClusterExampleRunsResponse, + ) + + def create_cluster_verification_pairs( + self, + *, + category_id: str, + cluster_id: str, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> AccuracyCreateClusterVerificationPairsResponse: + """ + Accuracy Cluster Verification Pairs + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + return self._post( + "/v1/reports/accuracy/cluster-verification-pairs", + body=maybe_transform( + { + "category_id": category_id, + "cluster_id": cluster_id, + }, + accuracy_create_cluster_verification_pairs_params.AccuracyCreateClusterVerificationPairsParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=AccuracyCreateClusterVerificationPairsResponse, + ) + + def create_factcheck_setup_status( + self, + *, + category_id: str, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> AccuracyCreateFactcheckSetupStatusResponse: + """ + Accuracy Factcheck Setup Status + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + return self._post( + "/v1/reports/accuracy/factcheck-setup-status", + body=maybe_transform( + {"category_id": category_id}, + accuracy_create_factcheck_setup_status_params.AccuracyCreateFactcheckSetupStatusParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=AccuracyCreateFactcheckSetupStatusResponse, + ) + + def create_inaccuracy_drivers( + self, + *, + category_id: str, + end_date: str, + start_date: str, + citation_categories: Optional[SequenceNotStr[str]] | Omit = omit, + comparison_end_date: Optional[str] | Omit = omit, + comparison_start_date: Optional[str] | Omit = omit, + exclude_topic_ids: bool | Omit = omit, + include_no_persona: bool | Omit = omit, + include_no_tag: bool | Omit = omit, + limit: int | Omit = omit, + persona_ids: Optional[SequenceNotStr[str]] | Omit = omit, + platform_ids: Optional[SequenceNotStr[str]] | Omit = omit, + prompt_ids: Optional[SequenceNotStr[str]] | Omit = omit, + region_ids: Optional[SequenceNotStr[str]] | Omit = omit, + tag_filter_type: Literal["all", "any"] | Omit = omit, + tag_ids: Optional[SequenceNotStr[str]] | Omit = omit, + topic_ids: Optional[SequenceNotStr[str]] | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> AccuracyCreateInaccuracyDriversResponse: + """ + Accuracy Inaccuracy Drivers + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + return self._post( + "/v1/reports/accuracy/inaccuracy-drivers", + body=maybe_transform( + { + "category_id": category_id, + "end_date": end_date, + "start_date": start_date, + "citation_categories": citation_categories, + "comparison_end_date": comparison_end_date, + "comparison_start_date": comparison_start_date, + "exclude_topic_ids": exclude_topic_ids, + "include_no_persona": include_no_persona, + "include_no_tag": include_no_tag, + "limit": limit, + "persona_ids": persona_ids, + "platform_ids": platform_ids, + "prompt_ids": prompt_ids, + "region_ids": region_ids, + "tag_filter_type": tag_filter_type, + "tag_ids": tag_ids, + "topic_ids": topic_ids, + }, + accuracy_create_inaccuracy_drivers_params.AccuracyCreateInaccuracyDriversParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=AccuracyCreateInaccuracyDriversResponse, + ) + + def create_inaccurate_clusters( + self, + *, + category_id: str, + end_date: str, + start_date: str, + theme_id: str, + citation_categories: Optional[SequenceNotStr[str]] | Omit = omit, + comparison_end_date: Optional[str] | Omit = omit, + comparison_start_date: Optional[str] | Omit = omit, + exclude_topic_ids: bool | Omit = omit, + include_no_persona: bool | Omit = omit, + include_no_tag: bool | Omit = omit, + limit: int | Omit = omit, + offset: int | Omit = omit, + persona_ids: Optional[SequenceNotStr[str]] | Omit = omit, + platform_ids: Optional[SequenceNotStr[str]] | Omit = omit, + prompt_ids: Optional[SequenceNotStr[str]] | Omit = omit, + region_ids: Optional[SequenceNotStr[str]] | Omit = omit, + search_query: Optional[str] | Omit = omit, + tag_filter_type: Literal["all", "any"] | Omit = omit, + tag_ids: Optional[SequenceNotStr[str]] | Omit = omit, + topic_ids: Optional[SequenceNotStr[str]] | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> AccuracyCreateInaccurateClustersResponse: + """ + Accuracy Inaccurate Clusters + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + return self._post( + "/v1/reports/accuracy/inaccurate-clusters", + body=maybe_transform( + { + "category_id": category_id, + "end_date": end_date, + "start_date": start_date, + "theme_id": theme_id, + "citation_categories": citation_categories, + "comparison_end_date": comparison_end_date, + "comparison_start_date": comparison_start_date, + "exclude_topic_ids": exclude_topic_ids, + "include_no_persona": include_no_persona, + "include_no_tag": include_no_tag, + "limit": limit, + "offset": offset, + "persona_ids": persona_ids, + "platform_ids": platform_ids, + "prompt_ids": prompt_ids, + "region_ids": region_ids, + "search_query": search_query, + "tag_filter_type": tag_filter_type, + "tag_ids": tag_ids, + "topic_ids": topic_ids, + }, + accuracy_create_inaccurate_clusters_params.AccuracyCreateInaccurateClustersParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=AccuracyCreateInaccurateClustersResponse, + ) + + def create_inaccurate_themes( + self, + *, + category_id: str, + end_date: str, + start_date: str, + citation_categories: Optional[SequenceNotStr[str]] | Omit = omit, + comparison_end_date: Optional[str] | Omit = omit, + comparison_start_date: Optional[str] | Omit = omit, + exclude_topic_ids: bool | Omit = omit, + include_no_persona: bool | Omit = omit, + include_no_tag: bool | Omit = omit, + limit: int | Omit = omit, + offset: int | Omit = omit, + persona_ids: Optional[SequenceNotStr[str]] | Omit = omit, + platform_ids: Optional[SequenceNotStr[str]] | Omit = omit, + prompt_ids: Optional[SequenceNotStr[str]] | Omit = omit, + region_ids: Optional[SequenceNotStr[str]] | Omit = omit, + search_query: Optional[str] | Omit = omit, + sort_by: Literal["response_share"] | Omit = omit, + sort_order: Literal["asc", "desc"] | Omit = omit, + tag_filter_type: Literal["all", "any"] | Omit = omit, + tag_ids: Optional[SequenceNotStr[str]] | Omit = omit, + topic_ids: Optional[SequenceNotStr[str]] | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> AccuracyCreateInaccurateThemesResponse: + """ + Accuracy Inaccurate Themes + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + return self._post( + "/v1/reports/accuracy/inaccurate-themes", + body=maybe_transform( + { + "category_id": category_id, + "end_date": end_date, + "start_date": start_date, + "citation_categories": citation_categories, + "comparison_end_date": comparison_end_date, + "comparison_start_date": comparison_start_date, + "exclude_topic_ids": exclude_topic_ids, + "include_no_persona": include_no_persona, + "include_no_tag": include_no_tag, + "limit": limit, + "offset": offset, + "persona_ids": persona_ids, + "platform_ids": platform_ids, + "prompt_ids": prompt_ids, + "region_ids": region_ids, + "search_query": search_query, + "sort_by": sort_by, + "sort_order": sort_order, + "tag_filter_type": tag_filter_type, + "tag_ids": tag_ids, + "topic_ids": topic_ids, + }, + accuracy_create_inaccurate_themes_params.AccuracyCreateInaccurateThemesParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=AccuracyCreateInaccurateThemesResponse, + ) + + def create_overview( + self, + *, + category_id: str, + end_date: str, + start_date: str, + citation_categories: Optional[SequenceNotStr[str]] | Omit = omit, + comparison_end_date: Optional[str] | Omit = omit, + comparison_start_date: Optional[str] | Omit = omit, + date_bucket: Optional[str] | Omit = omit, + exclude_topic_ids: bool | Omit = omit, + include_no_persona: bool | Omit = omit, + include_no_tag: bool | Omit = omit, + persona_ids: Optional[SequenceNotStr[str]] | Omit = omit, + platform_ids: Optional[SequenceNotStr[str]] | Omit = omit, + prompt_ids: Optional[SequenceNotStr[str]] | Omit = omit, + region_ids: Optional[SequenceNotStr[str]] | Omit = omit, + tag_filter_type: Literal["all", "any"] | Omit = omit, + tag_ids: Optional[SequenceNotStr[str]] | Omit = omit, + topic_ids: Optional[SequenceNotStr[str]] | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> AccuracyCreateOverviewResponse: + """ + Accuracy Overview + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + return self._post( + "/v1/reports/accuracy/overview", + body=maybe_transform( + { + "category_id": category_id, + "end_date": end_date, + "start_date": start_date, + "citation_categories": citation_categories, + "comparison_end_date": comparison_end_date, + "comparison_start_date": comparison_start_date, + "date_bucket": date_bucket, + "exclude_topic_ids": exclude_topic_ids, + "include_no_persona": include_no_persona, + "include_no_tag": include_no_tag, + "persona_ids": persona_ids, + "platform_ids": platform_ids, + "prompt_ids": prompt_ids, + "region_ids": region_ids, + "tag_filter_type": tag_filter_type, + "tag_ids": tag_ids, + "topic_ids": topic_ids, + }, + accuracy_create_overview_params.AccuracyCreateOverviewParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=AccuracyCreateOverviewResponse, + ) + + def create_top_inaccurate_claims( + self, + *, + category_id: str, + end_date: str, + start_date: str, + citation_categories: Optional[SequenceNotStr[str]] | Omit = omit, + comparison_end_date: Optional[str] | Omit = omit, + comparison_start_date: Optional[str] | Omit = omit, + exclude_topic_ids: bool | Omit = omit, + include_no_persona: bool | Omit = omit, + include_no_tag: bool | Omit = omit, + limit: int | Omit = omit, + persona_ids: Optional[SequenceNotStr[str]] | Omit = omit, + platform_ids: Optional[SequenceNotStr[str]] | Omit = omit, + prompt_ids: Optional[SequenceNotStr[str]] | Omit = omit, + region_ids: Optional[SequenceNotStr[str]] | Omit = omit, + tag_filter_type: Literal["all", "any"] | Omit = omit, + tag_ids: Optional[SequenceNotStr[str]] | Omit = omit, + topic_ids: Optional[SequenceNotStr[str]] | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> AccuracyCreateTopInaccurateClaimsResponse: + """ + Accuracy Top Inaccurate Claims + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + return self._post( + "/v1/reports/accuracy/top-inaccurate-claims", + body=maybe_transform( + { + "category_id": category_id, + "end_date": end_date, + "start_date": start_date, + "citation_categories": citation_categories, + "comparison_end_date": comparison_end_date, + "comparison_start_date": comparison_start_date, + "exclude_topic_ids": exclude_topic_ids, + "include_no_persona": include_no_persona, + "include_no_tag": include_no_tag, + "limit": limit, + "persona_ids": persona_ids, + "platform_ids": platform_ids, + "prompt_ids": prompt_ids, + "region_ids": region_ids, + "tag_filter_type": tag_filter_type, + "tag_ids": tag_ids, + "topic_ids": topic_ids, + }, + accuracy_create_top_inaccurate_claims_params.AccuracyCreateTopInaccurateClaimsParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=AccuracyCreateTopInaccurateClaimsResponse, + ) + + def create_topic_ids( + self, + *, + category_id: str, + end_date: str, + start_date: str, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> AccuracyCreateTopicIDsResponse: + """ + Accuracy Topic Ids + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + return self._post( + "/v1/reports/accuracy/topic-ids", + body=maybe_transform( + { + "category_id": category_id, + "end_date": end_date, + "start_date": start_date, + }, + accuracy_create_topic_ids_params.AccuracyCreateTopicIDsParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=AccuracyCreateTopicIDsResponse, + ) + + +class AsyncAccuracyResource(AsyncAPIResource): + @cached_property + def with_raw_response(self) -> AsyncAccuracyResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/cooper-square-technologies/profound-python-sdk#accessing-raw-response-data-eg-headers + """ + return AsyncAccuracyResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncAccuracyResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/cooper-square-technologies/profound-python-sdk#with_streaming_response + """ + return AsyncAccuracyResourceWithStreamingResponse(self) + + async def create_breakdown( + self, + *, + category_id: str, + end_date: str, + start_date: str, + breakdown_by: Literal["citation", "platform", "topic", "prompt", "tag", "region", "persona"] | Omit = omit, + citation_categories: Optional[SequenceNotStr[str]] | Omit = omit, + comparison_end_date: Optional[str] | Omit = omit, + comparison_start_date: Optional[str] | Omit = omit, + exclude_topic_ids: bool | Omit = omit, + include_no_persona: bool | Omit = omit, + include_no_tag: bool | Omit = omit, + limit: int | Omit = omit, + offset: int | Omit = omit, + persona_ids: Optional[SequenceNotStr[str]] | Omit = omit, + platform_ids: Optional[SequenceNotStr[str]] | Omit = omit, + prompt_ids: Optional[SequenceNotStr[str]] | Omit = omit, + region_ids: Optional[SequenceNotStr[str]] | Omit = omit, + search_query: Optional[str] | Omit = omit, + sort_by: Literal["citationShare", "accuracy"] | Omit = omit, + sort_order: Literal["asc", "desc"] | Omit = omit, + tag_filter_type: Literal["all", "any"] | Omit = omit, + tag_ids: Optional[SequenceNotStr[str]] | Omit = omit, + topic_ids: Optional[SequenceNotStr[str]] | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> AccuracyCreateBreakdownResponse: + """ + Accuracy Breakdown + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + return await self._post( + "/v1/reports/accuracy/breakdown", + body=await async_maybe_transform( + { + "category_id": category_id, + "end_date": end_date, + "start_date": start_date, + "breakdown_by": breakdown_by, + "citation_categories": citation_categories, + "comparison_end_date": comparison_end_date, + "comparison_start_date": comparison_start_date, + "exclude_topic_ids": exclude_topic_ids, + "include_no_persona": include_no_persona, + "include_no_tag": include_no_tag, + "limit": limit, + "offset": offset, + "persona_ids": persona_ids, + "platform_ids": platform_ids, + "prompt_ids": prompt_ids, + "region_ids": region_ids, + "search_query": search_query, + "sort_by": sort_by, + "sort_order": sort_order, + "tag_filter_type": tag_filter_type, + "tag_ids": tag_ids, + "topic_ids": topic_ids, + }, + accuracy_create_breakdown_params.AccuracyCreateBreakdownParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=AccuracyCreateBreakdownResponse, + ) + + async def create_citation_analysis( + self, + *, + category_id: str, + clean_href: str, + end_date: str, + start_date: str, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> AccuracyCreateCitationAnalysisResponse: + """ + Accuracy Citation Analysis + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + return await self._post( + "/v1/reports/accuracy/citation-analysis", + body=await async_maybe_transform( + { + "category_id": category_id, + "clean_href": clean_href, + "end_date": end_date, + "start_date": start_date, + }, + accuracy_create_citation_analysis_params.AccuracyCreateCitationAnalysisParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=AccuracyCreateCitationAnalysisResponse, + ) + + async def create_claim_breakdown( + self, + *, + category_id: str, + cluster_id: str, + end_date: str, + start_date: str, + citation_categories: Optional[SequenceNotStr[str]] | Omit = omit, + comparison_end_date: Optional[str] | Omit = omit, + comparison_start_date: Optional[str] | Omit = omit, + exclude_topic_ids: bool | Omit = omit, + include_no_persona: bool | Omit = omit, + include_no_tag: bool | Omit = omit, + persona_ids: Optional[SequenceNotStr[str]] | Omit = omit, + platform_ids: Optional[SequenceNotStr[str]] | Omit = omit, + prompt_ids: Optional[SequenceNotStr[str]] | Omit = omit, + region_ids: Optional[SequenceNotStr[str]] | Omit = omit, + tag_filter_type: Literal["all", "any"] | Omit = omit, + tag_ids: Optional[SequenceNotStr[str]] | Omit = omit, + topic_ids: Optional[SequenceNotStr[str]] | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> AccuracyCreateClaimBreakdownResponse: + """ + Accuracy Claim Breakdown + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + return await self._post( + "/v1/reports/accuracy/claim-breakdown", + body=await async_maybe_transform( + { + "category_id": category_id, + "cluster_id": cluster_id, + "end_date": end_date, + "start_date": start_date, + "citation_categories": citation_categories, + "comparison_end_date": comparison_end_date, + "comparison_start_date": comparison_start_date, + "exclude_topic_ids": exclude_topic_ids, + "include_no_persona": include_no_persona, + "include_no_tag": include_no_tag, + "persona_ids": persona_ids, + "platform_ids": platform_ids, + "prompt_ids": prompt_ids, + "region_ids": region_ids, + "tag_filter_type": tag_filter_type, + "tag_ids": tag_ids, + "topic_ids": topic_ids, + }, + accuracy_create_claim_breakdown_params.AccuracyCreateClaimBreakdownParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=AccuracyCreateClaimBreakdownResponse, + ) + + async def create_claim_citations( + self, + *, + category_id: str, + cluster_id: str, + end_date: str, + start_date: str, + citation_categories: Optional[SequenceNotStr[str]] | Omit = omit, + comparison_end_date: Optional[str] | Omit = omit, + comparison_start_date: Optional[str] | Omit = omit, + exclude_topic_ids: bool | Omit = omit, + include_no_persona: bool | Omit = omit, + include_no_tag: bool | Omit = omit, + limit: int | Omit = omit, + offset: int | Omit = omit, + persona_ids: Optional[SequenceNotStr[str]] | Omit = omit, + platform_ids: Optional[SequenceNotStr[str]] | Omit = omit, + prompt_ids: Optional[SequenceNotStr[str]] | Omit = omit, + region_ids: Optional[SequenceNotStr[str]] | Omit = omit, + search_query: Optional[str] | Omit = omit, + sort_order: Literal["asc", "desc"] | Omit = omit, + tag_filter_type: Literal["all", "any"] | Omit = omit, + tag_ids: Optional[SequenceNotStr[str]] | Omit = omit, + topic_ids: Optional[SequenceNotStr[str]] | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> AccuracyCreateClaimCitationsResponse: + """ + Accuracy Claim Citations + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + return await self._post( + "/v1/reports/accuracy/claim-citations", + body=await async_maybe_transform( + { + "category_id": category_id, + "cluster_id": cluster_id, + "end_date": end_date, + "start_date": start_date, + "citation_categories": citation_categories, + "comparison_end_date": comparison_end_date, + "comparison_start_date": comparison_start_date, + "exclude_topic_ids": exclude_topic_ids, + "include_no_persona": include_no_persona, + "include_no_tag": include_no_tag, + "limit": limit, + "offset": offset, + "persona_ids": persona_ids, + "platform_ids": platform_ids, + "prompt_ids": prompt_ids, + "region_ids": region_ids, + "search_query": search_query, + "sort_order": sort_order, + "tag_filter_type": tag_filter_type, + "tag_ids": tag_ids, + "topic_ids": topic_ids, + }, + accuracy_create_claim_citations_params.AccuracyCreateClaimCitationsParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=AccuracyCreateClaimCitationsResponse, + ) + + async def create_cluster_example_runs( + self, + *, + category_id: str, + cluster_id: str, + end_date: str, + start_date: str, + limit: int | Omit = omit, + offset: int | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> AccuracyCreateClusterExampleRunsResponse: + """ + Accuracy Cluster Example Runs + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + return await self._post( + "/v1/reports/accuracy/cluster-example-runs", + body=await async_maybe_transform( + { + "category_id": category_id, + "cluster_id": cluster_id, + "end_date": end_date, + "start_date": start_date, + "limit": limit, + "offset": offset, + }, + accuracy_create_cluster_example_runs_params.AccuracyCreateClusterExampleRunsParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=AccuracyCreateClusterExampleRunsResponse, + ) + + async def create_cluster_verification_pairs( + self, + *, + category_id: str, + cluster_id: str, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> AccuracyCreateClusterVerificationPairsResponse: + """ + Accuracy Cluster Verification Pairs + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + return await self._post( + "/v1/reports/accuracy/cluster-verification-pairs", + body=await async_maybe_transform( + { + "category_id": category_id, + "cluster_id": cluster_id, + }, + accuracy_create_cluster_verification_pairs_params.AccuracyCreateClusterVerificationPairsParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=AccuracyCreateClusterVerificationPairsResponse, + ) + + async def create_factcheck_setup_status( + self, + *, + category_id: str, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> AccuracyCreateFactcheckSetupStatusResponse: + """ + Accuracy Factcheck Setup Status + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + return await self._post( + "/v1/reports/accuracy/factcheck-setup-status", + body=await async_maybe_transform( + {"category_id": category_id}, + accuracy_create_factcheck_setup_status_params.AccuracyCreateFactcheckSetupStatusParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=AccuracyCreateFactcheckSetupStatusResponse, + ) + + async def create_inaccuracy_drivers( + self, + *, + category_id: str, + end_date: str, + start_date: str, + citation_categories: Optional[SequenceNotStr[str]] | Omit = omit, + comparison_end_date: Optional[str] | Omit = omit, + comparison_start_date: Optional[str] | Omit = omit, + exclude_topic_ids: bool | Omit = omit, + include_no_persona: bool | Omit = omit, + include_no_tag: bool | Omit = omit, + limit: int | Omit = omit, + persona_ids: Optional[SequenceNotStr[str]] | Omit = omit, + platform_ids: Optional[SequenceNotStr[str]] | Omit = omit, + prompt_ids: Optional[SequenceNotStr[str]] | Omit = omit, + region_ids: Optional[SequenceNotStr[str]] | Omit = omit, + tag_filter_type: Literal["all", "any"] | Omit = omit, + tag_ids: Optional[SequenceNotStr[str]] | Omit = omit, + topic_ids: Optional[SequenceNotStr[str]] | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> AccuracyCreateInaccuracyDriversResponse: + """ + Accuracy Inaccuracy Drivers + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + return await self._post( + "/v1/reports/accuracy/inaccuracy-drivers", + body=await async_maybe_transform( + { + "category_id": category_id, + "end_date": end_date, + "start_date": start_date, + "citation_categories": citation_categories, + "comparison_end_date": comparison_end_date, + "comparison_start_date": comparison_start_date, + "exclude_topic_ids": exclude_topic_ids, + "include_no_persona": include_no_persona, + "include_no_tag": include_no_tag, + "limit": limit, + "persona_ids": persona_ids, + "platform_ids": platform_ids, + "prompt_ids": prompt_ids, + "region_ids": region_ids, + "tag_filter_type": tag_filter_type, + "tag_ids": tag_ids, + "topic_ids": topic_ids, + }, + accuracy_create_inaccuracy_drivers_params.AccuracyCreateInaccuracyDriversParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=AccuracyCreateInaccuracyDriversResponse, + ) + + async def create_inaccurate_clusters( + self, + *, + category_id: str, + end_date: str, + start_date: str, + theme_id: str, + citation_categories: Optional[SequenceNotStr[str]] | Omit = omit, + comparison_end_date: Optional[str] | Omit = omit, + comparison_start_date: Optional[str] | Omit = omit, + exclude_topic_ids: bool | Omit = omit, + include_no_persona: bool | Omit = omit, + include_no_tag: bool | Omit = omit, + limit: int | Omit = omit, + offset: int | Omit = omit, + persona_ids: Optional[SequenceNotStr[str]] | Omit = omit, + platform_ids: Optional[SequenceNotStr[str]] | Omit = omit, + prompt_ids: Optional[SequenceNotStr[str]] | Omit = omit, + region_ids: Optional[SequenceNotStr[str]] | Omit = omit, + search_query: Optional[str] | Omit = omit, + tag_filter_type: Literal["all", "any"] | Omit = omit, + tag_ids: Optional[SequenceNotStr[str]] | Omit = omit, + topic_ids: Optional[SequenceNotStr[str]] | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> AccuracyCreateInaccurateClustersResponse: + """ + Accuracy Inaccurate Clusters + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + return await self._post( + "/v1/reports/accuracy/inaccurate-clusters", + body=await async_maybe_transform( + { + "category_id": category_id, + "end_date": end_date, + "start_date": start_date, + "theme_id": theme_id, + "citation_categories": citation_categories, + "comparison_end_date": comparison_end_date, + "comparison_start_date": comparison_start_date, + "exclude_topic_ids": exclude_topic_ids, + "include_no_persona": include_no_persona, + "include_no_tag": include_no_tag, + "limit": limit, + "offset": offset, + "persona_ids": persona_ids, + "platform_ids": platform_ids, + "prompt_ids": prompt_ids, + "region_ids": region_ids, + "search_query": search_query, + "tag_filter_type": tag_filter_type, + "tag_ids": tag_ids, + "topic_ids": topic_ids, + }, + accuracy_create_inaccurate_clusters_params.AccuracyCreateInaccurateClustersParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=AccuracyCreateInaccurateClustersResponse, + ) + + async def create_inaccurate_themes( + self, + *, + category_id: str, + end_date: str, + start_date: str, + citation_categories: Optional[SequenceNotStr[str]] | Omit = omit, + comparison_end_date: Optional[str] | Omit = omit, + comparison_start_date: Optional[str] | Omit = omit, + exclude_topic_ids: bool | Omit = omit, + include_no_persona: bool | Omit = omit, + include_no_tag: bool | Omit = omit, + limit: int | Omit = omit, + offset: int | Omit = omit, + persona_ids: Optional[SequenceNotStr[str]] | Omit = omit, + platform_ids: Optional[SequenceNotStr[str]] | Omit = omit, + prompt_ids: Optional[SequenceNotStr[str]] | Omit = omit, + region_ids: Optional[SequenceNotStr[str]] | Omit = omit, + search_query: Optional[str] | Omit = omit, + sort_by: Literal["response_share"] | Omit = omit, + sort_order: Literal["asc", "desc"] | Omit = omit, + tag_filter_type: Literal["all", "any"] | Omit = omit, + tag_ids: Optional[SequenceNotStr[str]] | Omit = omit, + topic_ids: Optional[SequenceNotStr[str]] | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> AccuracyCreateInaccurateThemesResponse: + """ + Accuracy Inaccurate Themes + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + return await self._post( + "/v1/reports/accuracy/inaccurate-themes", + body=await async_maybe_transform( + { + "category_id": category_id, + "end_date": end_date, + "start_date": start_date, + "citation_categories": citation_categories, + "comparison_end_date": comparison_end_date, + "comparison_start_date": comparison_start_date, + "exclude_topic_ids": exclude_topic_ids, + "include_no_persona": include_no_persona, + "include_no_tag": include_no_tag, + "limit": limit, + "offset": offset, + "persona_ids": persona_ids, + "platform_ids": platform_ids, + "prompt_ids": prompt_ids, + "region_ids": region_ids, + "search_query": search_query, + "sort_by": sort_by, + "sort_order": sort_order, + "tag_filter_type": tag_filter_type, + "tag_ids": tag_ids, + "topic_ids": topic_ids, + }, + accuracy_create_inaccurate_themes_params.AccuracyCreateInaccurateThemesParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=AccuracyCreateInaccurateThemesResponse, + ) + + async def create_overview( + self, + *, + category_id: str, + end_date: str, + start_date: str, + citation_categories: Optional[SequenceNotStr[str]] | Omit = omit, + comparison_end_date: Optional[str] | Omit = omit, + comparison_start_date: Optional[str] | Omit = omit, + date_bucket: Optional[str] | Omit = omit, + exclude_topic_ids: bool | Omit = omit, + include_no_persona: bool | Omit = omit, + include_no_tag: bool | Omit = omit, + persona_ids: Optional[SequenceNotStr[str]] | Omit = omit, + platform_ids: Optional[SequenceNotStr[str]] | Omit = omit, + prompt_ids: Optional[SequenceNotStr[str]] | Omit = omit, + region_ids: Optional[SequenceNotStr[str]] | Omit = omit, + tag_filter_type: Literal["all", "any"] | Omit = omit, + tag_ids: Optional[SequenceNotStr[str]] | Omit = omit, + topic_ids: Optional[SequenceNotStr[str]] | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> AccuracyCreateOverviewResponse: + """ + Accuracy Overview + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + return await self._post( + "/v1/reports/accuracy/overview", + body=await async_maybe_transform( + { + "category_id": category_id, + "end_date": end_date, + "start_date": start_date, + "citation_categories": citation_categories, + "comparison_end_date": comparison_end_date, + "comparison_start_date": comparison_start_date, + "date_bucket": date_bucket, + "exclude_topic_ids": exclude_topic_ids, + "include_no_persona": include_no_persona, + "include_no_tag": include_no_tag, + "persona_ids": persona_ids, + "platform_ids": platform_ids, + "prompt_ids": prompt_ids, + "region_ids": region_ids, + "tag_filter_type": tag_filter_type, + "tag_ids": tag_ids, + "topic_ids": topic_ids, + }, + accuracy_create_overview_params.AccuracyCreateOverviewParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=AccuracyCreateOverviewResponse, + ) + + async def create_top_inaccurate_claims( + self, + *, + category_id: str, + end_date: str, + start_date: str, + citation_categories: Optional[SequenceNotStr[str]] | Omit = omit, + comparison_end_date: Optional[str] | Omit = omit, + comparison_start_date: Optional[str] | Omit = omit, + exclude_topic_ids: bool | Omit = omit, + include_no_persona: bool | Omit = omit, + include_no_tag: bool | Omit = omit, + limit: int | Omit = omit, + persona_ids: Optional[SequenceNotStr[str]] | Omit = omit, + platform_ids: Optional[SequenceNotStr[str]] | Omit = omit, + prompt_ids: Optional[SequenceNotStr[str]] | Omit = omit, + region_ids: Optional[SequenceNotStr[str]] | Omit = omit, + tag_filter_type: Literal["all", "any"] | Omit = omit, + tag_ids: Optional[SequenceNotStr[str]] | Omit = omit, + topic_ids: Optional[SequenceNotStr[str]] | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> AccuracyCreateTopInaccurateClaimsResponse: + """ + Accuracy Top Inaccurate Claims + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + return await self._post( + "/v1/reports/accuracy/top-inaccurate-claims", + body=await async_maybe_transform( + { + "category_id": category_id, + "end_date": end_date, + "start_date": start_date, + "citation_categories": citation_categories, + "comparison_end_date": comparison_end_date, + "comparison_start_date": comparison_start_date, + "exclude_topic_ids": exclude_topic_ids, + "include_no_persona": include_no_persona, + "include_no_tag": include_no_tag, + "limit": limit, + "persona_ids": persona_ids, + "platform_ids": platform_ids, + "prompt_ids": prompt_ids, + "region_ids": region_ids, + "tag_filter_type": tag_filter_type, + "tag_ids": tag_ids, + "topic_ids": topic_ids, + }, + accuracy_create_top_inaccurate_claims_params.AccuracyCreateTopInaccurateClaimsParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=AccuracyCreateTopInaccurateClaimsResponse, + ) + + async def create_topic_ids( + self, + *, + category_id: str, + end_date: str, + start_date: str, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> AccuracyCreateTopicIDsResponse: + """ + Accuracy Topic Ids + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + return await self._post( + "/v1/reports/accuracy/topic-ids", + body=await async_maybe_transform( + { + "category_id": category_id, + "end_date": end_date, + "start_date": start_date, + }, + accuracy_create_topic_ids_params.AccuracyCreateTopicIDsParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=AccuracyCreateTopicIDsResponse, + ) + + +class AccuracyResourceWithRawResponse: + def __init__(self, accuracy: AccuracyResource) -> None: + self._accuracy = accuracy + + self.create_breakdown = to_raw_response_wrapper( + accuracy.create_breakdown, + ) + self.create_citation_analysis = to_raw_response_wrapper( + accuracy.create_citation_analysis, + ) + self.create_claim_breakdown = to_raw_response_wrapper( + accuracy.create_claim_breakdown, + ) + self.create_claim_citations = to_raw_response_wrapper( + accuracy.create_claim_citations, + ) + self.create_cluster_example_runs = to_raw_response_wrapper( + accuracy.create_cluster_example_runs, + ) + self.create_cluster_verification_pairs = to_raw_response_wrapper( + accuracy.create_cluster_verification_pairs, + ) + self.create_factcheck_setup_status = to_raw_response_wrapper( + accuracy.create_factcheck_setup_status, + ) + self.create_inaccuracy_drivers = to_raw_response_wrapper( + accuracy.create_inaccuracy_drivers, + ) + self.create_inaccurate_clusters = to_raw_response_wrapper( + accuracy.create_inaccurate_clusters, + ) + self.create_inaccurate_themes = to_raw_response_wrapper( + accuracy.create_inaccurate_themes, + ) + self.create_overview = to_raw_response_wrapper( + accuracy.create_overview, + ) + self.create_top_inaccurate_claims = to_raw_response_wrapper( + accuracy.create_top_inaccurate_claims, + ) + self.create_topic_ids = to_raw_response_wrapper( + accuracy.create_topic_ids, + ) + + +class AsyncAccuracyResourceWithRawResponse: + def __init__(self, accuracy: AsyncAccuracyResource) -> None: + self._accuracy = accuracy + + self.create_breakdown = async_to_raw_response_wrapper( + accuracy.create_breakdown, + ) + self.create_citation_analysis = async_to_raw_response_wrapper( + accuracy.create_citation_analysis, + ) + self.create_claim_breakdown = async_to_raw_response_wrapper( + accuracy.create_claim_breakdown, + ) + self.create_claim_citations = async_to_raw_response_wrapper( + accuracy.create_claim_citations, + ) + self.create_cluster_example_runs = async_to_raw_response_wrapper( + accuracy.create_cluster_example_runs, + ) + self.create_cluster_verification_pairs = async_to_raw_response_wrapper( + accuracy.create_cluster_verification_pairs, + ) + self.create_factcheck_setup_status = async_to_raw_response_wrapper( + accuracy.create_factcheck_setup_status, + ) + self.create_inaccuracy_drivers = async_to_raw_response_wrapper( + accuracy.create_inaccuracy_drivers, + ) + self.create_inaccurate_clusters = async_to_raw_response_wrapper( + accuracy.create_inaccurate_clusters, + ) + self.create_inaccurate_themes = async_to_raw_response_wrapper( + accuracy.create_inaccurate_themes, + ) + self.create_overview = async_to_raw_response_wrapper( + accuracy.create_overview, + ) + self.create_top_inaccurate_claims = async_to_raw_response_wrapper( + accuracy.create_top_inaccurate_claims, + ) + self.create_topic_ids = async_to_raw_response_wrapper( + accuracy.create_topic_ids, + ) + + +class AccuracyResourceWithStreamingResponse: + def __init__(self, accuracy: AccuracyResource) -> None: + self._accuracy = accuracy + + self.create_breakdown = to_streamed_response_wrapper( + accuracy.create_breakdown, + ) + self.create_citation_analysis = to_streamed_response_wrapper( + accuracy.create_citation_analysis, + ) + self.create_claim_breakdown = to_streamed_response_wrapper( + accuracy.create_claim_breakdown, + ) + self.create_claim_citations = to_streamed_response_wrapper( + accuracy.create_claim_citations, + ) + self.create_cluster_example_runs = to_streamed_response_wrapper( + accuracy.create_cluster_example_runs, + ) + self.create_cluster_verification_pairs = to_streamed_response_wrapper( + accuracy.create_cluster_verification_pairs, + ) + self.create_factcheck_setup_status = to_streamed_response_wrapper( + accuracy.create_factcheck_setup_status, + ) + self.create_inaccuracy_drivers = to_streamed_response_wrapper( + accuracy.create_inaccuracy_drivers, + ) + self.create_inaccurate_clusters = to_streamed_response_wrapper( + accuracy.create_inaccurate_clusters, + ) + self.create_inaccurate_themes = to_streamed_response_wrapper( + accuracy.create_inaccurate_themes, + ) + self.create_overview = to_streamed_response_wrapper( + accuracy.create_overview, + ) + self.create_top_inaccurate_claims = to_streamed_response_wrapper( + accuracy.create_top_inaccurate_claims, + ) + self.create_topic_ids = to_streamed_response_wrapper( + accuracy.create_topic_ids, + ) + + +class AsyncAccuracyResourceWithStreamingResponse: + def __init__(self, accuracy: AsyncAccuracyResource) -> None: + self._accuracy = accuracy + + self.create_breakdown = async_to_streamed_response_wrapper( + accuracy.create_breakdown, + ) + self.create_citation_analysis = async_to_streamed_response_wrapper( + accuracy.create_citation_analysis, + ) + self.create_claim_breakdown = async_to_streamed_response_wrapper( + accuracy.create_claim_breakdown, + ) + self.create_claim_citations = async_to_streamed_response_wrapper( + accuracy.create_claim_citations, + ) + self.create_cluster_example_runs = async_to_streamed_response_wrapper( + accuracy.create_cluster_example_runs, + ) + self.create_cluster_verification_pairs = async_to_streamed_response_wrapper( + accuracy.create_cluster_verification_pairs, + ) + self.create_factcheck_setup_status = async_to_streamed_response_wrapper( + accuracy.create_factcheck_setup_status, + ) + self.create_inaccuracy_drivers = async_to_streamed_response_wrapper( + accuracy.create_inaccuracy_drivers, + ) + self.create_inaccurate_clusters = async_to_streamed_response_wrapper( + accuracy.create_inaccurate_clusters, + ) + self.create_inaccurate_themes = async_to_streamed_response_wrapper( + accuracy.create_inaccurate_themes, + ) + self.create_overview = async_to_streamed_response_wrapper( + accuracy.create_overview, + ) + self.create_top_inaccurate_claims = async_to_streamed_response_wrapper( + accuracy.create_top_inaccurate_claims, + ) + self.create_topic_ids = async_to_streamed_response_wrapper( + accuracy.create_topic_ids, + ) diff --git a/src/profound/resources/reports/reports.py b/src/profound/resources/reports/reports.py index 1d056893..4bdec3f3 100644 --- a/src/profound/resources/reports/reports.py +++ b/src/profound/resources/reports/reports.py @@ -23,6 +23,14 @@ ) from ..._types import Body, Omit, Query, Headers, NotGiven, omit, not_given from ..._utils import maybe_transform, async_maybe_transform +from .accuracy import ( + AccuracyResource, + AsyncAccuracyResource, + AccuracyResourceWithRawResponse, + AsyncAccuracyResourceWithRawResponse, + AccuracyResourceWithStreamingResponse, + AsyncAccuracyResourceWithStreamingResponse, +) from .shopping import ( ShoppingResource, AsyncShoppingResource, @@ -68,6 +76,10 @@ def web_search_results(self) -> WebSearchResultsResource: def shopping(self) -> ShoppingResource: return ShoppingResource(self._client) + @cached_property + def accuracy(self) -> AccuracyResource: + return AccuracyResource(self._client) + @cached_property def with_raw_response(self) -> ReportsResourceWithRawResponse: """ @@ -92,7 +104,7 @@ def citations( *, category_id: str, end_date: Union[str, datetime], - metrics: List[Literal["count", "citation_share", "share_of_voice"]], + metrics: List[Literal["count", "citation_share", "share_of_voice", "first_cited_at"]], start_date: Union[str, datetime], date_interval: Literal["hour", "day", "week", "month", "quarter", "year", "relative_week"] | Omit = omit, dimensions: List[ @@ -731,7 +743,7 @@ def stream_citations( *, category_id: str, end_date: Union[str, datetime], - metrics: List[Literal["count", "citation_share", "share_of_voice"]], + metrics: List[Literal["count", "citation_share", "share_of_voice", "first_cited_at"]], start_date: Union[str, datetime], date_interval: Literal["hour", "day", "week", "month", "quarter", "year", "relative_week"] | Omit = omit, dimensions: List[ @@ -1136,6 +1148,10 @@ def web_search_results(self) -> AsyncWebSearchResultsResource: def shopping(self) -> AsyncShoppingResource: return AsyncShoppingResource(self._client) + @cached_property + def accuracy(self) -> AsyncAccuracyResource: + return AsyncAccuracyResource(self._client) + @cached_property def with_raw_response(self) -> AsyncReportsResourceWithRawResponse: """ @@ -1160,7 +1176,7 @@ async def citations( *, category_id: str, end_date: Union[str, datetime], - metrics: List[Literal["count", "citation_share", "share_of_voice"]], + metrics: List[Literal["count", "citation_share", "share_of_voice", "first_cited_at"]], start_date: Union[str, datetime], date_interval: Literal["hour", "day", "week", "month", "quarter", "year", "relative_week"] | Omit = omit, dimensions: List[ @@ -1799,7 +1815,7 @@ async def stream_citations( *, category_id: str, end_date: Union[str, datetime], - metrics: List[Literal["count", "citation_share", "share_of_voice"]], + metrics: List[Literal["count", "citation_share", "share_of_voice", "first_cited_at"]], start_date: Union[str, datetime], date_interval: Literal["hour", "day", "week", "month", "quarter", "year", "relative_week"] | Omit = omit, dimensions: List[ @@ -2241,6 +2257,10 @@ def web_search_results(self) -> WebSearchResultsResourceWithRawResponse: def shopping(self) -> ShoppingResourceWithRawResponse: return ShoppingResourceWithRawResponse(self._reports.shopping) + @cached_property + def accuracy(self) -> AccuracyResourceWithRawResponse: + return AccuracyResourceWithRawResponse(self._reports.accuracy) + class AsyncReportsResourceWithRawResponse: def __init__(self, reports: AsyncReportsResource) -> None: @@ -2288,6 +2308,10 @@ def web_search_results(self) -> AsyncWebSearchResultsResourceWithRawResponse: def shopping(self) -> AsyncShoppingResourceWithRawResponse: return AsyncShoppingResourceWithRawResponse(self._reports.shopping) + @cached_property + def accuracy(self) -> AsyncAccuracyResourceWithRawResponse: + return AsyncAccuracyResourceWithRawResponse(self._reports.accuracy) + class ReportsResourceWithStreamingResponse: def __init__(self, reports: ReportsResource) -> None: @@ -2335,6 +2359,10 @@ def web_search_results(self) -> WebSearchResultsResourceWithStreamingResponse: def shopping(self) -> ShoppingResourceWithStreamingResponse: return ShoppingResourceWithStreamingResponse(self._reports.shopping) + @cached_property + def accuracy(self) -> AccuracyResourceWithStreamingResponse: + return AccuracyResourceWithStreamingResponse(self._reports.accuracy) + class AsyncReportsResourceWithStreamingResponse: def __init__(self, reports: AsyncReportsResource) -> None: @@ -2381,3 +2409,7 @@ def web_search_results(self) -> AsyncWebSearchResultsResourceWithStreamingRespon @cached_property def shopping(self) -> AsyncShoppingResourceWithStreamingResponse: return AsyncShoppingResourceWithStreamingResponse(self._reports.shopping) + + @cached_property + def accuracy(self) -> AsyncAccuracyResourceWithStreamingResponse: + return AsyncAccuracyResourceWithStreamingResponse(self._reports.accuracy) diff --git a/src/profound/types/__init__.py b/src/profound/types/__init__.py index f823b24d..c6f207bb 100644 --- a/src/profound/types/__init__.py +++ b/src/profound/types/__init__.py @@ -30,8 +30,10 @@ from .agent_list_params import AgentListParams as AgentListParams from .agent_create_params import AgentCreateParams as AgentCreateParams from .agent_list_response import AgentListResponse as AgentListResponse +from .agent_update_params import AgentUpdateParams as AgentUpdateParams from .agent_create_response import AgentCreateResponse as AgentCreateResponse from .agent_retrieve_params import AgentRetrieveParams as AgentRetrieveParams +from .agent_update_response import AgentUpdateResponse as AgentUpdateResponse from .hostname_filter_param import HostnameFilterParam as HostnameFilterParam from .prompt_answers_params import PromptAnswersParams as PromptAnswersParams from .tag_name_filter_param import TagNameFilterParam as TagNameFilterParam diff --git a/src/profound/types/agent_update_params.py b/src/profound/types/agent_update_params.py new file mode 100644 index 00000000..6a2aebe7 --- /dev/null +++ b/src/profound/types/agent_update_params.py @@ -0,0 +1,18 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Dict +from typing_extensions import Required, TypedDict + +__all__ = ["AgentUpdateParams"] + + +class AgentUpdateParams(TypedDict, total=False): + graph: Required[Dict[str, object]] + """New workflow graph for the agent's draft version. + + Replaces the current draft graph; the agent is iterated in place rather than + re-created, so its ID is stable. Required — Magi rejects a null graph, so an + empty update is a 422 here rather than a relayed upstream error. + """ diff --git a/src/profound/types/agent_update_response.py b/src/profound/types/agent_update_response.py new file mode 100644 index 00000000..e0ec7648 --- /dev/null +++ b/src/profound/types/agent_update_response.py @@ -0,0 +1,98 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Dict, List, Optional +from datetime import datetime +from typing_extensions import Literal + +from pydantic import Field as FieldInfo + +from .._models import BaseModel + +__all__ = ["AgentUpdateResponse", "Schema", "Validation", "ValidationIssue"] + + +class Schema(BaseModel): + """Schema metadata for an agent.""" + + input: Dict[str, object] + """JSON Schema for the agent's `inputs` object. + + Use the top-level property keys as input field names when starting a run. + """ + + output: Dict[str, object] + """ + JSON Schema for the `outputs` object returned by + `GET /v1/agents/{agent_id}/runs/{run_id}`. + """ + + +class ValidationIssue(BaseModel): + """A single problem found while validating an agent's graph.""" + + code: str + """Stable machine-readable identifier for the kind of issue.""" + + message: str + """Human-readable description of the issue.""" + + field: Optional[str] = None + """Name of the offending field on the node, if field-specific.""" + + field_title: Optional[str] = None + """Display title of the affected field, if available.""" + + node_id: Optional[str] = None + """ID of the node the issue applies to, if node-specific.""" + + node_title: Optional[str] = None + """Display title of the affected node, if available.""" + + violation: Optional[str] = None + """The specific constraint that was violated, if available.""" + + +class Validation(BaseModel): + """Result of validating an agent's graph. + + Mirrors the report computed on every read, so callers can confirm a draft + is publishable before calling publish. + """ + + valid: bool + """Whether the agent's graph is valid and ready to publish.""" + + issues: Optional[List[ValidationIssue]] = None + """Problems found while validating the graph. Empty when `valid` is true.""" + + +class AgentUpdateResponse(BaseModel): + """Detailed information for an agent.""" + + id: str + """Unique ID for the agent.""" + + created_at: datetime + """When the agent was created.""" + + name: str + """Display name of the agent.""" + + organization_id: str + """Unique ID of the organization that owns the agent.""" + + status: Literal["draft", "published", "unknown"] + """Current status of the agent.""" + + description: Optional[str] = None + """Short description of the agent, if provided.""" + + schema_: Optional[Schema] = FieldInfo(alias="schema", default=None) + """Schema metadata for an agent.""" + + validation: Optional[Validation] = None + """Result of validating an agent's graph. + + Mirrors the report computed on every read, so callers can confirm a draft is + publishable before calling publish. + """ diff --git a/src/profound/types/organizations/category_tags_response.py b/src/profound/types/organizations/category_tags_response.py index e11c40c3..3058f73d 100644 --- a/src/profound/types/organizations/category_tags_response.py +++ b/src/profound/types/organizations/category_tags_response.py @@ -3,8 +3,15 @@ from typing import List from typing_extensions import TypeAlias -from ..named_resource import NamedResource +from ..._models import BaseModel -__all__ = ["CategoryTagsResponse"] +__all__ = ["CategoryTagsResponse", "CategoryTagsResponseItem"] -CategoryTagsResponse: TypeAlias = List[NamedResource] + +class CategoryTagsResponseItem(BaseModel): + id: str + + name: str + + +CategoryTagsResponse: TypeAlias = List[CategoryTagsResponseItem] diff --git a/src/profound/types/prompt_answers_response.py b/src/profound/types/prompt_answers_response.py index dd098d7a..1e29c68e 100644 --- a/src/profound/types/prompt_answers_response.py +++ b/src/profound/types/prompt_answers_response.py @@ -37,6 +37,8 @@ class DataCitationDetail(BaseModel): citation_category: Optional[str] = None + first_cited_at: Optional[str] = None + groups: Optional[List[DataCitationDetailGroup]] = None positions: Optional[List[int]] = None diff --git a/src/profound/types/report_citations_params.py b/src/profound/types/report_citations_params.py index e1caca1f..ec17e087 100644 --- a/src/profound/types/report_citations_params.py +++ b/src/profound/types/report_citations_params.py @@ -38,7 +38,7 @@ class ReportCitationsParams(TypedDict, total=False): Accepts formats: YYYY-MM-DD, YYYY-MM-DD HH:MM, or full ISO timestamp. """ - metrics: Required[List[Literal["count", "citation_share", "share_of_voice"]]] + metrics: Required[List[Literal["count", "citation_share", "share_of_voice", "first_cited_at"]]] """Metrics to include. `share_of_voice` is deprecated, use `citation_share` instead. diff --git a/src/profound/types/report_citations_response.py b/src/profound/types/report_citations_response.py index 9976ea55..f0ec4432 100644 --- a/src/profound/types/report_citations_response.py +++ b/src/profound/types/report_citations_response.py @@ -1,16 +1,21 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -from typing import List +from typing import List, Union from .._models import BaseModel from .report_info import ReportInfo -from .report_result import ReportResult -__all__ = ["ReportCitationsResponse"] +__all__ = ["ReportCitationsResponse", "Data"] + + +class Data(BaseModel): + dimensions: List[str] + + metrics: List[Union[float, str, None]] class ReportCitationsResponse(BaseModel): - data: List[ReportResult] + data: List[Data] info: ReportInfo """Base model for report information.""" diff --git a/src/profound/types/report_stream_citations_params.py b/src/profound/types/report_stream_citations_params.py index fe9f022c..3dfceea5 100644 --- a/src/profound/types/report_stream_citations_params.py +++ b/src/profound/types/report_stream_citations_params.py @@ -38,7 +38,7 @@ class ReportStreamCitationsParams(TypedDict, total=False): Accepts formats: YYYY-MM-DD, YYYY-MM-DD HH:MM, or full ISO timestamp. """ - metrics: Required[List[Literal["count", "citation_share", "share_of_voice"]]] + metrics: Required[List[Literal["count", "citation_share", "share_of_voice", "first_cited_at"]]] """Metrics to include. `share_of_voice` is deprecated, use `citation_share` instead. diff --git a/src/profound/types/reports/__init__.py b/src/profound/types/reports/__init__.py index f32d25de..b201963b 100644 --- a/src/profound/types/reports/__init__.py +++ b/src/profound/types/reports/__init__.py @@ -13,13 +13,19 @@ from .shopping_merchant_share_params import ShoppingMerchantShareParams as ShoppingMerchantShareParams from .shopping_trigger_rate_response import ShoppingTriggerRateResponse as ShoppingTriggerRateResponse from .web_search_result_query_params import WebSearchResultQueryParams as WebSearchResultQueryParams +from .accuracy_create_overview_params import AccuracyCreateOverviewParams as AccuracyCreateOverviewParams from .shopping_item_visibility_params import ShoppingItemVisibilityParams as ShoppingItemVisibilityParams from .web_search_result_stream_params import WebSearchResultStreamParams as WebSearchResultStreamParams +from .accuracy_create_breakdown_params import AccuracyCreateBreakdownParams as AccuracyCreateBreakdownParams +from .accuracy_create_topic_ids_params import AccuracyCreateTopicIDsParams as AccuracyCreateTopicIDsParams from .shopping_merchant_share_response import ShoppingMerchantShareResponse as ShoppingMerchantShareResponse from .web_search_result_query_response import WebSearchResultQueryResponse as WebSearchResultQueryResponse +from .accuracy_create_overview_response import AccuracyCreateOverviewResponse as AccuracyCreateOverviewResponse from .shopping_item_visibility_response import ShoppingItemVisibilityResponse as ShoppingItemVisibilityResponse from .shopping_merchant_by_items_params import ShoppingMerchantByItemsParams as ShoppingMerchantByItemsParams from .web_search_result_stream_response import WebSearchResultStreamResponse as WebSearchResultStreamResponse +from .accuracy_create_breakdown_response import AccuracyCreateBreakdownResponse as AccuracyCreateBreakdownResponse +from .accuracy_create_topic_ids_response import AccuracyCreateTopicIDsResponse as AccuracyCreateTopicIDsResponse from .shopping_merchant_by_items_response import ShoppingMerchantByItemsResponse as ShoppingMerchantByItemsResponse from .shopping_merchant_distribution_params import ( ShoppingMerchantDistributionParams as ShoppingMerchantDistributionParams, @@ -27,21 +33,81 @@ from .shopping_product_merchant_urls_params import ( ShoppingProductMerchantURLsParams as ShoppingProductMerchantURLsParams, ) +from .accuracy_create_claim_breakdown_params import ( + AccuracyCreateClaimBreakdownParams as AccuracyCreateClaimBreakdownParams, +) +from .accuracy_create_claim_citations_params import ( + AccuracyCreateClaimCitationsParams as AccuracyCreateClaimCitationsParams, +) from .shopping_merchant_distribution_response import ( ShoppingMerchantDistributionResponse as ShoppingMerchantDistributionResponse, ) from .shopping_product_merchant_urls_response import ( ShoppingProductMerchantURLsResponse as ShoppingProductMerchantURLsResponse, ) +from .accuracy_create_citation_analysis_params import ( + AccuracyCreateCitationAnalysisParams as AccuracyCreateCitationAnalysisParams, +) +from .accuracy_create_claim_breakdown_response import ( + AccuracyCreateClaimBreakdownResponse as AccuracyCreateClaimBreakdownResponse, +) +from .accuracy_create_claim_citations_response import ( + AccuracyCreateClaimCitationsResponse as AccuracyCreateClaimCitationsResponse, +) +from .accuracy_create_inaccurate_themes_params import ( + AccuracyCreateInaccurateThemesParams as AccuracyCreateInaccurateThemesParams, +) from .shopping_all_items_with_merchants_params import ( ShoppingAllItemsWithMerchantsParams as ShoppingAllItemsWithMerchantsParams, ) +from .accuracy_create_inaccuracy_drivers_params import ( + AccuracyCreateInaccuracyDriversParams as AccuracyCreateInaccuracyDriversParams, +) +from .accuracy_create_citation_analysis_response import ( + AccuracyCreateCitationAnalysisResponse as AccuracyCreateCitationAnalysisResponse, +) +from .accuracy_create_inaccurate_clusters_params import ( + AccuracyCreateInaccurateClustersParams as AccuracyCreateInaccurateClustersParams, +) +from .accuracy_create_inaccurate_themes_response import ( + AccuracyCreateInaccurateThemesResponse as AccuracyCreateInaccurateThemesResponse, +) from .shopping_all_items_with_merchants_response import ( ShoppingAllItemsWithMerchantsResponse as ShoppingAllItemsWithMerchantsResponse, ) +from .accuracy_create_cluster_example_runs_params import ( + AccuracyCreateClusterExampleRunsParams as AccuracyCreateClusterExampleRunsParams, +) +from .accuracy_create_inaccuracy_drivers_response import ( + AccuracyCreateInaccuracyDriversResponse as AccuracyCreateInaccuracyDriversResponse, +) +from .accuracy_create_inaccurate_clusters_response import ( + AccuracyCreateInaccurateClustersResponse as AccuracyCreateInaccurateClustersResponse, +) +from .accuracy_create_top_inaccurate_claims_params import ( + AccuracyCreateTopInaccurateClaimsParams as AccuracyCreateTopInaccurateClaimsParams, +) from .shopping_merchant_visibility_by_brand_params import ( ShoppingMerchantVisibilityByBrandParams as ShoppingMerchantVisibilityByBrandParams, ) +from .accuracy_create_cluster_example_runs_response import ( + AccuracyCreateClusterExampleRunsResponse as AccuracyCreateClusterExampleRunsResponse, +) +from .accuracy_create_factcheck_setup_status_params import ( + AccuracyCreateFactcheckSetupStatusParams as AccuracyCreateFactcheckSetupStatusParams, +) +from .accuracy_create_top_inaccurate_claims_response import ( + AccuracyCreateTopInaccurateClaimsResponse as AccuracyCreateTopInaccurateClaimsResponse, +) from .shopping_merchant_visibility_by_brand_response import ( ShoppingMerchantVisibilityByBrandResponse as ShoppingMerchantVisibilityByBrandResponse, ) +from .accuracy_create_factcheck_setup_status_response import ( + AccuracyCreateFactcheckSetupStatusResponse as AccuracyCreateFactcheckSetupStatusResponse, +) +from .accuracy_create_cluster_verification_pairs_params import ( + AccuracyCreateClusterVerificationPairsParams as AccuracyCreateClusterVerificationPairsParams, +) +from .accuracy_create_cluster_verification_pairs_response import ( + AccuracyCreateClusterVerificationPairsResponse as AccuracyCreateClusterVerificationPairsResponse, +) diff --git a/src/profound/types/reports/accuracy_create_breakdown_params.py b/src/profound/types/reports/accuracy_create_breakdown_params.py new file mode 100644 index 00000000..2a68dc7e --- /dev/null +++ b/src/profound/types/reports/accuracy_create_breakdown_params.py @@ -0,0 +1,56 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Optional +from typing_extensions import Literal, Required, TypedDict + +from ..._types import SequenceNotStr + +__all__ = ["AccuracyCreateBreakdownParams"] + + +class AccuracyCreateBreakdownParams(TypedDict, total=False): + category_id: Required[str] + + end_date: Required[str] + + start_date: Required[str] + + breakdown_by: Literal["citation", "platform", "topic", "prompt", "tag", "region", "persona"] + + citation_categories: Optional[SequenceNotStr[str]] + + comparison_end_date: Optional[str] + + comparison_start_date: Optional[str] + + exclude_topic_ids: bool + + include_no_persona: bool + + include_no_tag: bool + + limit: int + + offset: int + + persona_ids: Optional[SequenceNotStr[str]] + + platform_ids: Optional[SequenceNotStr[str]] + + prompt_ids: Optional[SequenceNotStr[str]] + + region_ids: Optional[SequenceNotStr[str]] + + search_query: Optional[str] + + sort_by: Literal["citationShare", "accuracy"] + + sort_order: Literal["asc", "desc"] + + tag_filter_type: Literal["all", "any"] + + tag_ids: Optional[SequenceNotStr[str]] + + topic_ids: Optional[SequenceNotStr[str]] diff --git a/src/profound/types/reports/accuracy_create_breakdown_response.py b/src/profound/types/reports/accuracy_create_breakdown_response.py new file mode 100644 index 00000000..4ce60415 --- /dev/null +++ b/src/profound/types/reports/accuracy_create_breakdown_response.py @@ -0,0 +1,37 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Optional + +from pydantic import Field as FieldInfo + +from ..._models import BaseModel + +__all__ = ["AccuracyCreateBreakdownResponse", "Data"] + + +class Data(BaseModel): + id: str + + inaccurate_count: int = FieldInfo(alias="inaccurateCount") + + name: str + + response_accuracy: float = FieldInfo(alias="responseAccuracy") + + share: float + + accuracy_change: Optional[float] = FieldInfo(alias="accuracyChange", default=None) + + citation_category: Optional[str] = FieldInfo(alias="citationCategory", default=None) + + inaccurate_count_change: Optional[int] = FieldInfo(alias="inaccurateCountChange", default=None) + + prompt_count: Optional[int] = FieldInfo(alias="promptCount", default=None) + + share_change: Optional[float] = FieldInfo(alias="shareChange", default=None) + + +class AccuracyCreateBreakdownResponse(BaseModel): + data: List[Data] + + total_count: int = FieldInfo(alias="totalCount") diff --git a/src/profound/types/reports/accuracy_create_citation_analysis_params.py b/src/profound/types/reports/accuracy_create_citation_analysis_params.py new file mode 100644 index 00000000..a4d7a4e7 --- /dev/null +++ b/src/profound/types/reports/accuracy_create_citation_analysis_params.py @@ -0,0 +1,17 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import Required, TypedDict + +__all__ = ["AccuracyCreateCitationAnalysisParams"] + + +class AccuracyCreateCitationAnalysisParams(TypedDict, total=False): + category_id: Required[str] + + clean_href: Required[str] + + end_date: Required[str] + + start_date: Required[str] diff --git a/src/profound/types/reports/accuracy_create_citation_analysis_response.py b/src/profound/types/reports/accuracy_create_citation_analysis_response.py new file mode 100644 index 00000000..d72de660 --- /dev/null +++ b/src/profound/types/reports/accuracy_create_citation_analysis_response.py @@ -0,0 +1,46 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Optional +from typing_extensions import Literal + +from pydantic import Field as FieldInfo + +from ..._models import BaseModel + +__all__ = ["AccuracyCreateCitationAnalysisResponse", "Claim"] + + +class Claim(BaseModel): + """A single inaccurate claim mapped to a cluster, surfaced on a cited page. + + ``attribute`` carries the cluster's canonical claim so the drawer can group + claims the same way it groups sentiment attributes. + """ + + attribute: str + + attribute_id: str = FieldInfo(alias="attributeId") + + claim: str + + claim_id: str = FieldInfo(alias="claimId") + + neutral_theme: str = FieldInfo(alias="neutralTheme") + + neutral_theme_id: str = FieldInfo(alias="neutralThemeId") + + snippet: str + + polarity: Optional[Literal["positive", "negative"]] = None + + +class AccuracyCreateCitationAnalysisResponse(BaseModel): + domain: str + + href: str + + markdown_content: str = FieldInfo(alias="markdownContent") + + page_title: str = FieldInfo(alias="pageTitle") + + claims: Optional[List[Claim]] = None diff --git a/src/profound/types/reports/accuracy_create_claim_breakdown_params.py b/src/profound/types/reports/accuracy_create_claim_breakdown_params.py new file mode 100644 index 00000000..3e0cd8e9 --- /dev/null +++ b/src/profound/types/reports/accuracy_create_claim_breakdown_params.py @@ -0,0 +1,46 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Optional +from typing_extensions import Literal, Required, TypedDict + +from ..._types import SequenceNotStr + +__all__ = ["AccuracyCreateClaimBreakdownParams"] + + +class AccuracyCreateClaimBreakdownParams(TypedDict, total=False): + category_id: Required[str] + + cluster_id: Required[str] + + end_date: Required[str] + + start_date: Required[str] + + citation_categories: Optional[SequenceNotStr[str]] + + comparison_end_date: Optional[str] + + comparison_start_date: Optional[str] + + exclude_topic_ids: bool + + include_no_persona: bool + + include_no_tag: bool + + persona_ids: Optional[SequenceNotStr[str]] + + platform_ids: Optional[SequenceNotStr[str]] + + prompt_ids: Optional[SequenceNotStr[str]] + + region_ids: Optional[SequenceNotStr[str]] + + tag_filter_type: Literal["all", "any"] + + tag_ids: Optional[SequenceNotStr[str]] + + topic_ids: Optional[SequenceNotStr[str]] diff --git a/src/profound/types/reports/accuracy_create_claim_breakdown_response.py b/src/profound/types/reports/accuracy_create_claim_breakdown_response.py new file mode 100644 index 00000000..494117ca --- /dev/null +++ b/src/profound/types/reports/accuracy_create_claim_breakdown_response.py @@ -0,0 +1,59 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Optional + +from pydantic import Field as FieldInfo + +from ..._models import BaseModel + +__all__ = ["AccuracyCreateClaimBreakdownResponse", "Platform", "Prompt"] + + +class Platform(BaseModel): + id: str + + label: str + + prev_response_count: int = FieldInfo(alias="prevResponseCount") + + prev_total_response_count: int = FieldInfo(alias="prevTotalResponseCount") + + response_count: int = FieldInfo(alias="responseCount") + + response_share: float = FieldInfo(alias="responseShare") + + total_response_count: int = FieldInfo(alias="totalResponseCount") + + response_share_delta: Optional[float] = FieldInfo(alias="responseShareDelta", default=None) + + +class Prompt(BaseModel): + id: str + + has_current: bool = FieldInfo(alias="hasCurrent") + + label: str + + prev_response_count: int = FieldInfo(alias="prevResponseCount") + + prev_total_response_count: int = FieldInfo(alias="prevTotalResponseCount") + + prompt_id: str = FieldInfo(alias="promptId") + + prompt_text: str = FieldInfo(alias="promptText") + + response_count: int = FieldInfo(alias="responseCount") + + response_share: float = FieldInfo(alias="responseShare") + + topic_id: str = FieldInfo(alias="topicId") + + total_response_count: int = FieldInfo(alias="totalResponseCount") + + response_share_delta: Optional[float] = FieldInfo(alias="responseShareDelta", default=None) + + +class AccuracyCreateClaimBreakdownResponse(BaseModel): + platform: List[Platform] + + prompt: List[Prompt] diff --git a/src/profound/types/reports/accuracy_create_claim_citations_params.py b/src/profound/types/reports/accuracy_create_claim_citations_params.py new file mode 100644 index 00000000..95b34068 --- /dev/null +++ b/src/profound/types/reports/accuracy_create_claim_citations_params.py @@ -0,0 +1,54 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Optional +from typing_extensions import Literal, Required, TypedDict + +from ..._types import SequenceNotStr + +__all__ = ["AccuracyCreateClaimCitationsParams"] + + +class AccuracyCreateClaimCitationsParams(TypedDict, total=False): + category_id: Required[str] + + cluster_id: Required[str] + + end_date: Required[str] + + start_date: Required[str] + + citation_categories: Optional[SequenceNotStr[str]] + + comparison_end_date: Optional[str] + + comparison_start_date: Optional[str] + + exclude_topic_ids: bool + + include_no_persona: bool + + include_no_tag: bool + + limit: int + + offset: int + + persona_ids: Optional[SequenceNotStr[str]] + + platform_ids: Optional[SequenceNotStr[str]] + + prompt_ids: Optional[SequenceNotStr[str]] + + region_ids: Optional[SequenceNotStr[str]] + + search_query: Optional[str] + + sort_order: Literal["asc", "desc"] + + tag_filter_type: Literal["all", "any"] + + tag_ids: Optional[SequenceNotStr[str]] + + topic_ids: Optional[SequenceNotStr[str]] diff --git a/src/profound/types/reports/accuracy_create_claim_citations_response.py b/src/profound/types/reports/accuracy_create_claim_citations_response.py new file mode 100644 index 00000000..b3dcde3b --- /dev/null +++ b/src/profound/types/reports/accuracy_create_claim_citations_response.py @@ -0,0 +1,33 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Optional + +from pydantic import Field as FieldInfo + +from ..._models import BaseModel + +__all__ = ["AccuracyCreateClaimCitationsResponse", "Data"] + + +class Data(BaseModel): + citation_category: str = FieldInfo(alias="citationCategory") + + citation_count: float = FieldInfo(alias="citationCount") + + citation_share: float = FieldInfo(alias="citationShare") + + hostname: str + + href: str + + path: str + + snippet: str + + citation_share_delta: Optional[float] = FieldInfo(alias="citationShareDelta", default=None) + + +class AccuracyCreateClaimCitationsResponse(BaseModel): + data: List[Data] + + total_count: int = FieldInfo(alias="totalCount") diff --git a/src/profound/types/reports/accuracy_create_cluster_example_runs_params.py b/src/profound/types/reports/accuracy_create_cluster_example_runs_params.py new file mode 100644 index 00000000..1e8a59f3 --- /dev/null +++ b/src/profound/types/reports/accuracy_create_cluster_example_runs_params.py @@ -0,0 +1,21 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import Required, TypedDict + +__all__ = ["AccuracyCreateClusterExampleRunsParams"] + + +class AccuracyCreateClusterExampleRunsParams(TypedDict, total=False): + category_id: Required[str] + + cluster_id: Required[str] + + end_date: Required[str] + + start_date: Required[str] + + limit: int + + offset: int diff --git a/src/profound/types/reports/accuracy_create_cluster_example_runs_response.py b/src/profound/types/reports/accuracy_create_cluster_example_runs_response.py new file mode 100644 index 00000000..d2fc06b1 --- /dev/null +++ b/src/profound/types/reports/accuracy_create_cluster_example_runs_response.py @@ -0,0 +1,29 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List + +from pydantic import Field as FieldInfo + +from ..._models import BaseModel + +__all__ = ["AccuracyCreateClusterExampleRunsResponse", "Data"] + + +class Data(BaseModel): + claim: str + + created_at: str = FieldInfo(alias="createdAt") + + api_model_id: str = FieldInfo(alias="modelId") + + region_id: str = FieldInfo(alias="regionId") + + response_snippet: str = FieldInfo(alias="responseSnippet") + + run_id: str = FieldInfo(alias="runId") + + +class AccuracyCreateClusterExampleRunsResponse(BaseModel): + data: List[Data] + + total_count: int = FieldInfo(alias="totalCount") diff --git a/src/profound/types/reports/accuracy_create_cluster_verification_pairs_params.py b/src/profound/types/reports/accuracy_create_cluster_verification_pairs_params.py new file mode 100644 index 00000000..0bc65495 --- /dev/null +++ b/src/profound/types/reports/accuracy_create_cluster_verification_pairs_params.py @@ -0,0 +1,13 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import Required, TypedDict + +__all__ = ["AccuracyCreateClusterVerificationPairsParams"] + + +class AccuracyCreateClusterVerificationPairsParams(TypedDict, total=False): + category_id: Required[str] + + cluster_id: Required[str] diff --git a/src/profound/types/reports/accuracy_create_cluster_verification_pairs_response.py b/src/profound/types/reports/accuracy_create_cluster_verification_pairs_response.py new file mode 100644 index 00000000..e666903a --- /dev/null +++ b/src/profound/types/reports/accuracy_create_cluster_verification_pairs_response.py @@ -0,0 +1,25 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List + +from pydantic import Field as FieldInfo + +from ..._models import BaseModel + +__all__ = ["AccuracyCreateClusterVerificationPairsResponse", "Data"] + + +class Data(BaseModel): + kb_path: str = FieldInfo(alias="kbPath") + + pair_id: str = FieldInfo(alias="pairId") + + quote: str + + reasoning: str + + snippet_idx: int = FieldInfo(alias="snippetIdx") + + +class AccuracyCreateClusterVerificationPairsResponse(BaseModel): + data: List[Data] diff --git a/src/profound/types/reports/accuracy_create_factcheck_setup_status_params.py b/src/profound/types/reports/accuracy_create_factcheck_setup_status_params.py new file mode 100644 index 00000000..6480782a --- /dev/null +++ b/src/profound/types/reports/accuracy_create_factcheck_setup_status_params.py @@ -0,0 +1,11 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import Required, TypedDict + +__all__ = ["AccuracyCreateFactcheckSetupStatusParams"] + + +class AccuracyCreateFactcheckSetupStatusParams(TypedDict, total=False): + category_id: Required[str] diff --git a/src/profound/types/reports/accuracy_create_factcheck_setup_status_response.py b/src/profound/types/reports/accuracy_create_factcheck_setup_status_response.py new file mode 100644 index 00000000..ad11f16f --- /dev/null +++ b/src/profound/types/reports/accuracy_create_factcheck_setup_status_response.py @@ -0,0 +1,21 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Optional + +from pydantic import Field as FieldInfo + +from ..._models import BaseModel + +__all__ = ["AccuracyCreateFactcheckSetupStatusResponse"] + + +class AccuracyCreateFactcheckSetupStatusResponse(BaseModel): + active_accuracy_prompt_count: int = FieldInfo(alias="activeAccuracyPromptCount") + + has_verification_data: bool = FieldInfo(alias="hasVerificationData") + + is_setup_complete: bool = FieldInfo(alias="isSetupComplete") + + setup_created_at: Optional[str] = FieldInfo(alias="setupCreatedAt", default=None) + + setup_knowledge_base_id: Optional[str] = FieldInfo(alias="setupKnowledgeBaseId", default=None) diff --git a/src/profound/types/reports/accuracy_create_inaccuracy_drivers_params.py b/src/profound/types/reports/accuracy_create_inaccuracy_drivers_params.py new file mode 100644 index 00000000..d300e6b1 --- /dev/null +++ b/src/profound/types/reports/accuracy_create_inaccuracy_drivers_params.py @@ -0,0 +1,46 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Optional +from typing_extensions import Literal, Required, TypedDict + +from ..._types import SequenceNotStr + +__all__ = ["AccuracyCreateInaccuracyDriversParams"] + + +class AccuracyCreateInaccuracyDriversParams(TypedDict, total=False): + category_id: Required[str] + + end_date: Required[str] + + start_date: Required[str] + + citation_categories: Optional[SequenceNotStr[str]] + + comparison_end_date: Optional[str] + + comparison_start_date: Optional[str] + + exclude_topic_ids: bool + + include_no_persona: bool + + include_no_tag: bool + + limit: int + + persona_ids: Optional[SequenceNotStr[str]] + + platform_ids: Optional[SequenceNotStr[str]] + + prompt_ids: Optional[SequenceNotStr[str]] + + region_ids: Optional[SequenceNotStr[str]] + + tag_filter_type: Literal["all", "any"] + + tag_ids: Optional[SequenceNotStr[str]] + + topic_ids: Optional[SequenceNotStr[str]] diff --git a/src/profound/types/reports/accuracy_create_inaccuracy_drivers_response.py b/src/profound/types/reports/accuracy_create_inaccuracy_drivers_response.py new file mode 100644 index 00000000..3e92e15c --- /dev/null +++ b/src/profound/types/reports/accuracy_create_inaccuracy_drivers_response.py @@ -0,0 +1,39 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Optional + +from pydantic import Field as FieldInfo + +from ..._models import BaseModel + +__all__ = ["AccuracyCreateInaccuracyDriversResponse", "Data"] + + +class Data(BaseModel): + """A top inaccurate claim paired with one of its most-cited pages.""" + + canonical_claim: str = FieldInfo(alias="canonicalClaim") + + citation_category: str = FieldInfo(alias="citationCategory") + + citation_count: int = FieldInfo(alias="citationCount") + + claim_occurrence: float = FieldInfo(alias="claimOccurrence") + + cluster_id: str = FieldInfo(alias="clusterId") + + domain_category: str = FieldInfo(alias="domainCategory") + + href: str + + row_id: str = FieldInfo(alias="rowId") + + snippet: str + + snippet_claim_id: str = FieldInfo(alias="snippetClaimId") + + claim_occurrence_delta: Optional[float] = FieldInfo(alias="claimOccurrenceDelta", default=None) + + +class AccuracyCreateInaccuracyDriversResponse(BaseModel): + data: List[Data] diff --git a/src/profound/types/reports/accuracy_create_inaccurate_clusters_params.py b/src/profound/types/reports/accuracy_create_inaccurate_clusters_params.py new file mode 100644 index 00000000..a42a577c --- /dev/null +++ b/src/profound/types/reports/accuracy_create_inaccurate_clusters_params.py @@ -0,0 +1,52 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Optional +from typing_extensions import Literal, Required, TypedDict + +from ..._types import SequenceNotStr + +__all__ = ["AccuracyCreateInaccurateClustersParams"] + + +class AccuracyCreateInaccurateClustersParams(TypedDict, total=False): + category_id: Required[str] + + end_date: Required[str] + + start_date: Required[str] + + theme_id: Required[str] + + citation_categories: Optional[SequenceNotStr[str]] + + comparison_end_date: Optional[str] + + comparison_start_date: Optional[str] + + exclude_topic_ids: bool + + include_no_persona: bool + + include_no_tag: bool + + limit: int + + offset: int + + persona_ids: Optional[SequenceNotStr[str]] + + platform_ids: Optional[SequenceNotStr[str]] + + prompt_ids: Optional[SequenceNotStr[str]] + + region_ids: Optional[SequenceNotStr[str]] + + search_query: Optional[str] + + tag_filter_type: Literal["all", "any"] + + tag_ids: Optional[SequenceNotStr[str]] + + topic_ids: Optional[SequenceNotStr[str]] diff --git a/src/profound/types/reports/accuracy_create_inaccurate_clusters_response.py b/src/profound/types/reports/accuracy_create_inaccurate_clusters_response.py new file mode 100644 index 00000000..e0519a3d --- /dev/null +++ b/src/profound/types/reports/accuracy_create_inaccurate_clusters_response.py @@ -0,0 +1,41 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Optional + +from pydantic import Field as FieldInfo + +from ..._models import BaseModel + +__all__ = ["AccuracyCreateInaccurateClustersResponse", "Data"] + + +class Data(BaseModel): + canonical_claim: str = FieldInfo(alias="canonicalClaim") + + citation_hostnames: List[str] = FieldInfo(alias="citationHostnames") + + claim_count: int = FieldInfo(alias="claimCount") + + cluster_id: str = FieldInfo(alias="clusterId") + + description: str + + kb_path: str = FieldInfo(alias="kbPath") + + kb_snippet: str = FieldInfo(alias="kbSnippet") + + reasoning: str + + response_count: int = FieldInfo(alias="responseCount") + + response_share: float = FieldInfo(alias="responseShare") + + total_response_count: int = FieldInfo(alias="totalResponseCount") + + response_share_delta: Optional[float] = FieldInfo(alias="responseShareDelta", default=None) + + +class AccuracyCreateInaccurateClustersResponse(BaseModel): + data: List[Data] + + total_count: int = FieldInfo(alias="totalCount") diff --git a/src/profound/types/reports/accuracy_create_inaccurate_themes_params.py b/src/profound/types/reports/accuracy_create_inaccurate_themes_params.py new file mode 100644 index 00000000..4d21acc6 --- /dev/null +++ b/src/profound/types/reports/accuracy_create_inaccurate_themes_params.py @@ -0,0 +1,54 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Optional +from typing_extensions import Literal, Required, TypedDict + +from ..._types import SequenceNotStr + +__all__ = ["AccuracyCreateInaccurateThemesParams"] + + +class AccuracyCreateInaccurateThemesParams(TypedDict, total=False): + category_id: Required[str] + + end_date: Required[str] + + start_date: Required[str] + + citation_categories: Optional[SequenceNotStr[str]] + + comparison_end_date: Optional[str] + + comparison_start_date: Optional[str] + + exclude_topic_ids: bool + + include_no_persona: bool + + include_no_tag: bool + + limit: int + + offset: int + + persona_ids: Optional[SequenceNotStr[str]] + + platform_ids: Optional[SequenceNotStr[str]] + + prompt_ids: Optional[SequenceNotStr[str]] + + region_ids: Optional[SequenceNotStr[str]] + + search_query: Optional[str] + + sort_by: Literal["response_share"] + + sort_order: Literal["asc", "desc"] + + tag_filter_type: Literal["all", "any"] + + tag_ids: Optional[SequenceNotStr[str]] + + topic_ids: Optional[SequenceNotStr[str]] diff --git a/src/profound/types/reports/accuracy_create_inaccurate_themes_response.py b/src/profound/types/reports/accuracy_create_inaccurate_themes_response.py new file mode 100644 index 00000000..8b80b206 --- /dev/null +++ b/src/profound/types/reports/accuracy_create_inaccurate_themes_response.py @@ -0,0 +1,39 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Optional + +from pydantic import Field as FieldInfo + +from ..._models import BaseModel + +__all__ = ["AccuracyCreateInaccurateThemesResponse", "Data"] + + +class Data(BaseModel): + description: str + + inaccurate_claim_count: int = FieldInfo(alias="inaccurateClaimCount") + + inaccurate_cluster_count: int = FieldInfo(alias="inaccurateClusterCount") + + neutral_theme: str = FieldInfo(alias="neutralTheme") + + response_count: int = FieldInfo(alias="responseCount") + + response_share: float = FieldInfo(alias="responseShare") + + theme_id: str = FieldInfo(alias="themeId") + + total_claim_count: int = FieldInfo(alias="totalClaimCount") + + total_cluster_count: int = FieldInfo(alias="totalClusterCount") + + total_response_count: int = FieldInfo(alias="totalResponseCount") + + response_share_delta: Optional[float] = FieldInfo(alias="responseShareDelta", default=None) + + +class AccuracyCreateInaccurateThemesResponse(BaseModel): + data: List[Data] + + total_count: int = FieldInfo(alias="totalCount") diff --git a/src/profound/types/reports/accuracy_create_overview_params.py b/src/profound/types/reports/accuracy_create_overview_params.py new file mode 100644 index 00000000..b9689d06 --- /dev/null +++ b/src/profound/types/reports/accuracy_create_overview_params.py @@ -0,0 +1,46 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Optional +from typing_extensions import Literal, Required, TypedDict + +from ..._types import SequenceNotStr + +__all__ = ["AccuracyCreateOverviewParams"] + + +class AccuracyCreateOverviewParams(TypedDict, total=False): + category_id: Required[str] + + end_date: Required[str] + + start_date: Required[str] + + citation_categories: Optional[SequenceNotStr[str]] + + comparison_end_date: Optional[str] + + comparison_start_date: Optional[str] + + date_bucket: Optional[str] + + exclude_topic_ids: bool + + include_no_persona: bool + + include_no_tag: bool + + persona_ids: Optional[SequenceNotStr[str]] + + platform_ids: Optional[SequenceNotStr[str]] + + prompt_ids: Optional[SequenceNotStr[str]] + + region_ids: Optional[SequenceNotStr[str]] + + tag_filter_type: Literal["all", "any"] + + tag_ids: Optional[SequenceNotStr[str]] + + topic_ids: Optional[SequenceNotStr[str]] diff --git a/src/profound/types/reports/accuracy_create_overview_response.py b/src/profound/types/reports/accuracy_create_overview_response.py new file mode 100644 index 00000000..b4745682 --- /dev/null +++ b/src/profound/types/reports/accuracy_create_overview_response.py @@ -0,0 +1,43 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Optional + +from pydantic import Field as FieldInfo + +from ..._models import BaseModel + +__all__ = ["AccuracyCreateOverviewResponse", "ScoreBreakdown", "TrendByPeriod"] + + +class ScoreBreakdown(BaseModel): + count: int + + share: float + + status: str + + count_change: Optional[int] = FieldInfo(alias="countChange", default=None) + + share_change: Optional[float] = FieldInfo(alias="shareChange", default=None) + + +class TrendByPeriod(BaseModel): + accurate: int + + date: str + + ratio: float + + total: int + + prev_period_data: Optional[object] = FieldInfo(alias="prevPeriodData", default=None) + + +class AccuracyCreateOverviewResponse(BaseModel): + overall_accuracy: float = FieldInfo(alias="overallAccuracy") + + score_breakdown: List[ScoreBreakdown] = FieldInfo(alias="scoreBreakdown") + + trend_by_period: List[TrendByPeriod] = FieldInfo(alias="trendByPeriod") + + accuracy_change: Optional[float] = FieldInfo(alias="accuracyChange", default=None) diff --git a/src/profound/types/reports/accuracy_create_top_inaccurate_claims_params.py b/src/profound/types/reports/accuracy_create_top_inaccurate_claims_params.py new file mode 100644 index 00000000..ab32110f --- /dev/null +++ b/src/profound/types/reports/accuracy_create_top_inaccurate_claims_params.py @@ -0,0 +1,46 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Optional +from typing_extensions import Literal, Required, TypedDict + +from ..._types import SequenceNotStr + +__all__ = ["AccuracyCreateTopInaccurateClaimsParams"] + + +class AccuracyCreateTopInaccurateClaimsParams(TypedDict, total=False): + category_id: Required[str] + + end_date: Required[str] + + start_date: Required[str] + + citation_categories: Optional[SequenceNotStr[str]] + + comparison_end_date: Optional[str] + + comparison_start_date: Optional[str] + + exclude_topic_ids: bool + + include_no_persona: bool + + include_no_tag: bool + + limit: int + + persona_ids: Optional[SequenceNotStr[str]] + + platform_ids: Optional[SequenceNotStr[str]] + + prompt_ids: Optional[SequenceNotStr[str]] + + region_ids: Optional[SequenceNotStr[str]] + + tag_filter_type: Literal["all", "any"] + + tag_ids: Optional[SequenceNotStr[str]] + + topic_ids: Optional[SequenceNotStr[str]] diff --git a/src/profound/types/reports/accuracy_create_top_inaccurate_claims_response.py b/src/profound/types/reports/accuracy_create_top_inaccurate_claims_response.py new file mode 100644 index 00000000..5228de2e --- /dev/null +++ b/src/profound/types/reports/accuracy_create_top_inaccurate_claims_response.py @@ -0,0 +1,23 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Optional + +from pydantic import Field as FieldInfo + +from ..._models import BaseModel + +__all__ = ["AccuracyCreateTopInaccurateClaimsResponse", "Data"] + + +class Data(BaseModel): + canonical_claim: str = FieldInfo(alias="canonicalClaim") + + claim_occurrence: float = FieldInfo(alias="claimOccurrence") + + cluster_id: str = FieldInfo(alias="clusterId") + + claim_occurrence_delta: Optional[float] = FieldInfo(alias="claimOccurrenceDelta", default=None) + + +class AccuracyCreateTopInaccurateClaimsResponse(BaseModel): + data: List[Data] diff --git a/src/profound/types/reports/accuracy_create_topic_ids_params.py b/src/profound/types/reports/accuracy_create_topic_ids_params.py new file mode 100644 index 00000000..e7742231 --- /dev/null +++ b/src/profound/types/reports/accuracy_create_topic_ids_params.py @@ -0,0 +1,15 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import Required, TypedDict + +__all__ = ["AccuracyCreateTopicIDsParams"] + + +class AccuracyCreateTopicIDsParams(TypedDict, total=False): + category_id: Required[str] + + end_date: Required[str] + + start_date: Required[str] diff --git a/src/profound/types/reports/accuracy_create_topic_ids_response.py b/src/profound/types/reports/accuracy_create_topic_ids_response.py new file mode 100644 index 00000000..2702e6f1 --- /dev/null +++ b/src/profound/types/reports/accuracy_create_topic_ids_response.py @@ -0,0 +1,8 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List +from typing_extensions import TypeAlias + +__all__ = ["AccuracyCreateTopicIDsResponse"] + +AccuracyCreateTopicIDsResponse: TypeAlias = List[str] diff --git a/tests/api_resources/reports/test_accuracy.py b/tests/api_resources/reports/test_accuracy.py new file mode 100644 index 00000000..d59cb3ec --- /dev/null +++ b/tests/api_resources/reports/test_accuracy.py @@ -0,0 +1,1532 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import os +from typing import Any, cast + +import pytest + +from profound import Profound, AsyncProfound +from tests.utils import assert_matches_type +from profound.types.reports import ( + AccuracyCreateOverviewResponse, + AccuracyCreateTopicIDsResponse, + AccuracyCreateBreakdownResponse, + AccuracyCreateClaimBreakdownResponse, + AccuracyCreateClaimCitationsResponse, + AccuracyCreateCitationAnalysisResponse, + AccuracyCreateInaccurateThemesResponse, + AccuracyCreateInaccuracyDriversResponse, + AccuracyCreateClusterExampleRunsResponse, + AccuracyCreateInaccurateClustersResponse, + AccuracyCreateTopInaccurateClaimsResponse, + AccuracyCreateFactcheckSetupStatusResponse, + AccuracyCreateClusterVerificationPairsResponse, +) + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") + + +class TestAccuracy: + parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_create_breakdown(self, client: Profound) -> None: + accuracy = client.reports.accuracy.create_breakdown( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) + assert_matches_type(AccuracyCreateBreakdownResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_create_breakdown_with_all_params(self, client: Profound) -> None: + accuracy = client.reports.accuracy.create_breakdown( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + breakdown_by="citation", + citation_categories=["string"], + comparison_end_date="comparison_end_date", + comparison_start_date="comparison_start_date", + exclude_topic_ids=True, + include_no_persona=True, + include_no_tag=True, + limit=1, + offset=0, + persona_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + platform_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + prompt_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + region_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + search_query="search_query", + sort_by="citationShare", + sort_order="asc", + tag_filter_type="all", + tag_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + topic_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + ) + assert_matches_type(AccuracyCreateBreakdownResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_raw_response_create_breakdown(self, client: Profound) -> None: + response = client.reports.accuracy.with_raw_response.create_breakdown( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + accuracy = response.parse() + assert_matches_type(AccuracyCreateBreakdownResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_streaming_response_create_breakdown(self, client: Profound) -> None: + with client.reports.accuracy.with_streaming_response.create_breakdown( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + accuracy = response.parse() + assert_matches_type(AccuracyCreateBreakdownResponse, accuracy, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_create_citation_analysis(self, client: Profound) -> None: + accuracy = client.reports.accuracy.create_citation_analysis( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + clean_href="clean_href", + end_date="end_date", + start_date="start_date", + ) + assert_matches_type(AccuracyCreateCitationAnalysisResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_raw_response_create_citation_analysis(self, client: Profound) -> None: + response = client.reports.accuracy.with_raw_response.create_citation_analysis( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + clean_href="clean_href", + end_date="end_date", + start_date="start_date", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + accuracy = response.parse() + assert_matches_type(AccuracyCreateCitationAnalysisResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_streaming_response_create_citation_analysis(self, client: Profound) -> None: + with client.reports.accuracy.with_streaming_response.create_citation_analysis( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + clean_href="clean_href", + end_date="end_date", + start_date="start_date", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + accuracy = response.parse() + assert_matches_type(AccuracyCreateCitationAnalysisResponse, accuracy, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_create_claim_breakdown(self, client: Profound) -> None: + accuracy = client.reports.accuracy.create_claim_breakdown( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + cluster_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) + assert_matches_type(AccuracyCreateClaimBreakdownResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_create_claim_breakdown_with_all_params(self, client: Profound) -> None: + accuracy = client.reports.accuracy.create_claim_breakdown( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + cluster_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + citation_categories=["string"], + comparison_end_date="comparison_end_date", + comparison_start_date="comparison_start_date", + exclude_topic_ids=True, + include_no_persona=True, + include_no_tag=True, + persona_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + platform_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + prompt_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + region_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + tag_filter_type="all", + tag_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + topic_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + ) + assert_matches_type(AccuracyCreateClaimBreakdownResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_raw_response_create_claim_breakdown(self, client: Profound) -> None: + response = client.reports.accuracy.with_raw_response.create_claim_breakdown( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + cluster_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + accuracy = response.parse() + assert_matches_type(AccuracyCreateClaimBreakdownResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_streaming_response_create_claim_breakdown(self, client: Profound) -> None: + with client.reports.accuracy.with_streaming_response.create_claim_breakdown( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + cluster_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + accuracy = response.parse() + assert_matches_type(AccuracyCreateClaimBreakdownResponse, accuracy, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_create_claim_citations(self, client: Profound) -> None: + accuracy = client.reports.accuracy.create_claim_citations( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + cluster_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) + assert_matches_type(AccuracyCreateClaimCitationsResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_create_claim_citations_with_all_params(self, client: Profound) -> None: + accuracy = client.reports.accuracy.create_claim_citations( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + cluster_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + citation_categories=["string"], + comparison_end_date="comparison_end_date", + comparison_start_date="comparison_start_date", + exclude_topic_ids=True, + include_no_persona=True, + include_no_tag=True, + limit=1, + offset=0, + persona_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + platform_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + prompt_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + region_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + search_query="search_query", + sort_order="asc", + tag_filter_type="all", + tag_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + topic_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + ) + assert_matches_type(AccuracyCreateClaimCitationsResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_raw_response_create_claim_citations(self, client: Profound) -> None: + response = client.reports.accuracy.with_raw_response.create_claim_citations( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + cluster_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + accuracy = response.parse() + assert_matches_type(AccuracyCreateClaimCitationsResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_streaming_response_create_claim_citations(self, client: Profound) -> None: + with client.reports.accuracy.with_streaming_response.create_claim_citations( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + cluster_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + accuracy = response.parse() + assert_matches_type(AccuracyCreateClaimCitationsResponse, accuracy, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_create_cluster_example_runs(self, client: Profound) -> None: + accuracy = client.reports.accuracy.create_cluster_example_runs( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + cluster_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) + assert_matches_type(AccuracyCreateClusterExampleRunsResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_create_cluster_example_runs_with_all_params(self, client: Profound) -> None: + accuracy = client.reports.accuracy.create_cluster_example_runs( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + cluster_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + limit=1, + offset=0, + ) + assert_matches_type(AccuracyCreateClusterExampleRunsResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_raw_response_create_cluster_example_runs(self, client: Profound) -> None: + response = client.reports.accuracy.with_raw_response.create_cluster_example_runs( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + cluster_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + accuracy = response.parse() + assert_matches_type(AccuracyCreateClusterExampleRunsResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_streaming_response_create_cluster_example_runs(self, client: Profound) -> None: + with client.reports.accuracy.with_streaming_response.create_cluster_example_runs( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + cluster_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + accuracy = response.parse() + assert_matches_type(AccuracyCreateClusterExampleRunsResponse, accuracy, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_create_cluster_verification_pairs(self, client: Profound) -> None: + accuracy = client.reports.accuracy.create_cluster_verification_pairs( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + cluster_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + ) + assert_matches_type(AccuracyCreateClusterVerificationPairsResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_raw_response_create_cluster_verification_pairs(self, client: Profound) -> None: + response = client.reports.accuracy.with_raw_response.create_cluster_verification_pairs( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + cluster_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + accuracy = response.parse() + assert_matches_type(AccuracyCreateClusterVerificationPairsResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_streaming_response_create_cluster_verification_pairs(self, client: Profound) -> None: + with client.reports.accuracy.with_streaming_response.create_cluster_verification_pairs( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + cluster_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + accuracy = response.parse() + assert_matches_type(AccuracyCreateClusterVerificationPairsResponse, accuracy, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_create_factcheck_setup_status(self, client: Profound) -> None: + accuracy = client.reports.accuracy.create_factcheck_setup_status( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + ) + assert_matches_type(AccuracyCreateFactcheckSetupStatusResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_raw_response_create_factcheck_setup_status(self, client: Profound) -> None: + response = client.reports.accuracy.with_raw_response.create_factcheck_setup_status( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + accuracy = response.parse() + assert_matches_type(AccuracyCreateFactcheckSetupStatusResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_streaming_response_create_factcheck_setup_status(self, client: Profound) -> None: + with client.reports.accuracy.with_streaming_response.create_factcheck_setup_status( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + accuracy = response.parse() + assert_matches_type(AccuracyCreateFactcheckSetupStatusResponse, accuracy, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_create_inaccuracy_drivers(self, client: Profound) -> None: + accuracy = client.reports.accuracy.create_inaccuracy_drivers( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) + assert_matches_type(AccuracyCreateInaccuracyDriversResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_create_inaccuracy_drivers_with_all_params(self, client: Profound) -> None: + accuracy = client.reports.accuracy.create_inaccuracy_drivers( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + citation_categories=["string"], + comparison_end_date="comparison_end_date", + comparison_start_date="comparison_start_date", + exclude_topic_ids=True, + include_no_persona=True, + include_no_tag=True, + limit=1, + persona_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + platform_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + prompt_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + region_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + tag_filter_type="all", + tag_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + topic_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + ) + assert_matches_type(AccuracyCreateInaccuracyDriversResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_raw_response_create_inaccuracy_drivers(self, client: Profound) -> None: + response = client.reports.accuracy.with_raw_response.create_inaccuracy_drivers( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + accuracy = response.parse() + assert_matches_type(AccuracyCreateInaccuracyDriversResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_streaming_response_create_inaccuracy_drivers(self, client: Profound) -> None: + with client.reports.accuracy.with_streaming_response.create_inaccuracy_drivers( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + accuracy = response.parse() + assert_matches_type(AccuracyCreateInaccuracyDriversResponse, accuracy, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_create_inaccurate_clusters(self, client: Profound) -> None: + accuracy = client.reports.accuracy.create_inaccurate_clusters( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + theme_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + ) + assert_matches_type(AccuracyCreateInaccurateClustersResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_create_inaccurate_clusters_with_all_params(self, client: Profound) -> None: + accuracy = client.reports.accuracy.create_inaccurate_clusters( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + theme_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + citation_categories=["string"], + comparison_end_date="comparison_end_date", + comparison_start_date="comparison_start_date", + exclude_topic_ids=True, + include_no_persona=True, + include_no_tag=True, + limit=1, + offset=0, + persona_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + platform_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + prompt_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + region_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + search_query="search_query", + tag_filter_type="all", + tag_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + topic_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + ) + assert_matches_type(AccuracyCreateInaccurateClustersResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_raw_response_create_inaccurate_clusters(self, client: Profound) -> None: + response = client.reports.accuracy.with_raw_response.create_inaccurate_clusters( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + theme_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + accuracy = response.parse() + assert_matches_type(AccuracyCreateInaccurateClustersResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_streaming_response_create_inaccurate_clusters(self, client: Profound) -> None: + with client.reports.accuracy.with_streaming_response.create_inaccurate_clusters( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + theme_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + accuracy = response.parse() + assert_matches_type(AccuracyCreateInaccurateClustersResponse, accuracy, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_create_inaccurate_themes(self, client: Profound) -> None: + accuracy = client.reports.accuracy.create_inaccurate_themes( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) + assert_matches_type(AccuracyCreateInaccurateThemesResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_create_inaccurate_themes_with_all_params(self, client: Profound) -> None: + accuracy = client.reports.accuracy.create_inaccurate_themes( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + citation_categories=["string"], + comparison_end_date="comparison_end_date", + comparison_start_date="comparison_start_date", + exclude_topic_ids=True, + include_no_persona=True, + include_no_tag=True, + limit=1, + offset=0, + persona_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + platform_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + prompt_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + region_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + search_query="search_query", + sort_by="response_share", + sort_order="asc", + tag_filter_type="all", + tag_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + topic_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + ) + assert_matches_type(AccuracyCreateInaccurateThemesResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_raw_response_create_inaccurate_themes(self, client: Profound) -> None: + response = client.reports.accuracy.with_raw_response.create_inaccurate_themes( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + accuracy = response.parse() + assert_matches_type(AccuracyCreateInaccurateThemesResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_streaming_response_create_inaccurate_themes(self, client: Profound) -> None: + with client.reports.accuracy.with_streaming_response.create_inaccurate_themes( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + accuracy = response.parse() + assert_matches_type(AccuracyCreateInaccurateThemesResponse, accuracy, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_create_overview(self, client: Profound) -> None: + accuracy = client.reports.accuracy.create_overview( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) + assert_matches_type(AccuracyCreateOverviewResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_create_overview_with_all_params(self, client: Profound) -> None: + accuracy = client.reports.accuracy.create_overview( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + citation_categories=["string"], + comparison_end_date="comparison_end_date", + comparison_start_date="comparison_start_date", + date_bucket="date_bucket", + exclude_topic_ids=True, + include_no_persona=True, + include_no_tag=True, + persona_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + platform_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + prompt_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + region_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + tag_filter_type="all", + tag_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + topic_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + ) + assert_matches_type(AccuracyCreateOverviewResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_raw_response_create_overview(self, client: Profound) -> None: + response = client.reports.accuracy.with_raw_response.create_overview( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + accuracy = response.parse() + assert_matches_type(AccuracyCreateOverviewResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_streaming_response_create_overview(self, client: Profound) -> None: + with client.reports.accuracy.with_streaming_response.create_overview( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + accuracy = response.parse() + assert_matches_type(AccuracyCreateOverviewResponse, accuracy, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_create_top_inaccurate_claims(self, client: Profound) -> None: + accuracy = client.reports.accuracy.create_top_inaccurate_claims( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) + assert_matches_type(AccuracyCreateTopInaccurateClaimsResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_create_top_inaccurate_claims_with_all_params(self, client: Profound) -> None: + accuracy = client.reports.accuracy.create_top_inaccurate_claims( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + citation_categories=["string"], + comparison_end_date="comparison_end_date", + comparison_start_date="comparison_start_date", + exclude_topic_ids=True, + include_no_persona=True, + include_no_tag=True, + limit=1, + persona_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + platform_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + prompt_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + region_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + tag_filter_type="all", + tag_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + topic_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + ) + assert_matches_type(AccuracyCreateTopInaccurateClaimsResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_raw_response_create_top_inaccurate_claims(self, client: Profound) -> None: + response = client.reports.accuracy.with_raw_response.create_top_inaccurate_claims( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + accuracy = response.parse() + assert_matches_type(AccuracyCreateTopInaccurateClaimsResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_streaming_response_create_top_inaccurate_claims(self, client: Profound) -> None: + with client.reports.accuracy.with_streaming_response.create_top_inaccurate_claims( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + accuracy = response.parse() + assert_matches_type(AccuracyCreateTopInaccurateClaimsResponse, accuracy, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_create_topic_ids(self, client: Profound) -> None: + accuracy = client.reports.accuracy.create_topic_ids( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) + assert_matches_type(AccuracyCreateTopicIDsResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_raw_response_create_topic_ids(self, client: Profound) -> None: + response = client.reports.accuracy.with_raw_response.create_topic_ids( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + accuracy = response.parse() + assert_matches_type(AccuracyCreateTopicIDsResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_streaming_response_create_topic_ids(self, client: Profound) -> None: + with client.reports.accuracy.with_streaming_response.create_topic_ids( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + accuracy = response.parse() + assert_matches_type(AccuracyCreateTopicIDsResponse, accuracy, path=["response"]) + + assert cast(Any, response.is_closed) is True + + +class TestAsyncAccuracy: + parametrize = pytest.mark.parametrize( + "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] + ) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_create_breakdown(self, async_client: AsyncProfound) -> None: + accuracy = await async_client.reports.accuracy.create_breakdown( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) + assert_matches_type(AccuracyCreateBreakdownResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_create_breakdown_with_all_params(self, async_client: AsyncProfound) -> None: + accuracy = await async_client.reports.accuracy.create_breakdown( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + breakdown_by="citation", + citation_categories=["string"], + comparison_end_date="comparison_end_date", + comparison_start_date="comparison_start_date", + exclude_topic_ids=True, + include_no_persona=True, + include_no_tag=True, + limit=1, + offset=0, + persona_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + platform_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + prompt_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + region_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + search_query="search_query", + sort_by="citationShare", + sort_order="asc", + tag_filter_type="all", + tag_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + topic_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + ) + assert_matches_type(AccuracyCreateBreakdownResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_raw_response_create_breakdown(self, async_client: AsyncProfound) -> None: + response = await async_client.reports.accuracy.with_raw_response.create_breakdown( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + accuracy = await response.parse() + assert_matches_type(AccuracyCreateBreakdownResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_streaming_response_create_breakdown(self, async_client: AsyncProfound) -> None: + async with async_client.reports.accuracy.with_streaming_response.create_breakdown( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + accuracy = await response.parse() + assert_matches_type(AccuracyCreateBreakdownResponse, accuracy, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_create_citation_analysis(self, async_client: AsyncProfound) -> None: + accuracy = await async_client.reports.accuracy.create_citation_analysis( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + clean_href="clean_href", + end_date="end_date", + start_date="start_date", + ) + assert_matches_type(AccuracyCreateCitationAnalysisResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_raw_response_create_citation_analysis(self, async_client: AsyncProfound) -> None: + response = await async_client.reports.accuracy.with_raw_response.create_citation_analysis( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + clean_href="clean_href", + end_date="end_date", + start_date="start_date", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + accuracy = await response.parse() + assert_matches_type(AccuracyCreateCitationAnalysisResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_streaming_response_create_citation_analysis(self, async_client: AsyncProfound) -> None: + async with async_client.reports.accuracy.with_streaming_response.create_citation_analysis( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + clean_href="clean_href", + end_date="end_date", + start_date="start_date", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + accuracy = await response.parse() + assert_matches_type(AccuracyCreateCitationAnalysisResponse, accuracy, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_create_claim_breakdown(self, async_client: AsyncProfound) -> None: + accuracy = await async_client.reports.accuracy.create_claim_breakdown( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + cluster_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) + assert_matches_type(AccuracyCreateClaimBreakdownResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_create_claim_breakdown_with_all_params(self, async_client: AsyncProfound) -> None: + accuracy = await async_client.reports.accuracy.create_claim_breakdown( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + cluster_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + citation_categories=["string"], + comparison_end_date="comparison_end_date", + comparison_start_date="comparison_start_date", + exclude_topic_ids=True, + include_no_persona=True, + include_no_tag=True, + persona_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + platform_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + prompt_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + region_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + tag_filter_type="all", + tag_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + topic_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + ) + assert_matches_type(AccuracyCreateClaimBreakdownResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_raw_response_create_claim_breakdown(self, async_client: AsyncProfound) -> None: + response = await async_client.reports.accuracy.with_raw_response.create_claim_breakdown( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + cluster_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + accuracy = await response.parse() + assert_matches_type(AccuracyCreateClaimBreakdownResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_streaming_response_create_claim_breakdown(self, async_client: AsyncProfound) -> None: + async with async_client.reports.accuracy.with_streaming_response.create_claim_breakdown( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + cluster_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + accuracy = await response.parse() + assert_matches_type(AccuracyCreateClaimBreakdownResponse, accuracy, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_create_claim_citations(self, async_client: AsyncProfound) -> None: + accuracy = await async_client.reports.accuracy.create_claim_citations( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + cluster_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) + assert_matches_type(AccuracyCreateClaimCitationsResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_create_claim_citations_with_all_params(self, async_client: AsyncProfound) -> None: + accuracy = await async_client.reports.accuracy.create_claim_citations( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + cluster_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + citation_categories=["string"], + comparison_end_date="comparison_end_date", + comparison_start_date="comparison_start_date", + exclude_topic_ids=True, + include_no_persona=True, + include_no_tag=True, + limit=1, + offset=0, + persona_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + platform_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + prompt_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + region_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + search_query="search_query", + sort_order="asc", + tag_filter_type="all", + tag_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + topic_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + ) + assert_matches_type(AccuracyCreateClaimCitationsResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_raw_response_create_claim_citations(self, async_client: AsyncProfound) -> None: + response = await async_client.reports.accuracy.with_raw_response.create_claim_citations( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + cluster_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + accuracy = await response.parse() + assert_matches_type(AccuracyCreateClaimCitationsResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_streaming_response_create_claim_citations(self, async_client: AsyncProfound) -> None: + async with async_client.reports.accuracy.with_streaming_response.create_claim_citations( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + cluster_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + accuracy = await response.parse() + assert_matches_type(AccuracyCreateClaimCitationsResponse, accuracy, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_create_cluster_example_runs(self, async_client: AsyncProfound) -> None: + accuracy = await async_client.reports.accuracy.create_cluster_example_runs( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + cluster_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) + assert_matches_type(AccuracyCreateClusterExampleRunsResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_create_cluster_example_runs_with_all_params(self, async_client: AsyncProfound) -> None: + accuracy = await async_client.reports.accuracy.create_cluster_example_runs( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + cluster_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + limit=1, + offset=0, + ) + assert_matches_type(AccuracyCreateClusterExampleRunsResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_raw_response_create_cluster_example_runs(self, async_client: AsyncProfound) -> None: + response = await async_client.reports.accuracy.with_raw_response.create_cluster_example_runs( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + cluster_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + accuracy = await response.parse() + assert_matches_type(AccuracyCreateClusterExampleRunsResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_streaming_response_create_cluster_example_runs(self, async_client: AsyncProfound) -> None: + async with async_client.reports.accuracy.with_streaming_response.create_cluster_example_runs( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + cluster_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + accuracy = await response.parse() + assert_matches_type(AccuracyCreateClusterExampleRunsResponse, accuracy, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_create_cluster_verification_pairs(self, async_client: AsyncProfound) -> None: + accuracy = await async_client.reports.accuracy.create_cluster_verification_pairs( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + cluster_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + ) + assert_matches_type(AccuracyCreateClusterVerificationPairsResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_raw_response_create_cluster_verification_pairs(self, async_client: AsyncProfound) -> None: + response = await async_client.reports.accuracy.with_raw_response.create_cluster_verification_pairs( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + cluster_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + accuracy = await response.parse() + assert_matches_type(AccuracyCreateClusterVerificationPairsResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_streaming_response_create_cluster_verification_pairs(self, async_client: AsyncProfound) -> None: + async with async_client.reports.accuracy.with_streaming_response.create_cluster_verification_pairs( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + cluster_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + accuracy = await response.parse() + assert_matches_type(AccuracyCreateClusterVerificationPairsResponse, accuracy, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_create_factcheck_setup_status(self, async_client: AsyncProfound) -> None: + accuracy = await async_client.reports.accuracy.create_factcheck_setup_status( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + ) + assert_matches_type(AccuracyCreateFactcheckSetupStatusResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_raw_response_create_factcheck_setup_status(self, async_client: AsyncProfound) -> None: + response = await async_client.reports.accuracy.with_raw_response.create_factcheck_setup_status( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + accuracy = await response.parse() + assert_matches_type(AccuracyCreateFactcheckSetupStatusResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_streaming_response_create_factcheck_setup_status(self, async_client: AsyncProfound) -> None: + async with async_client.reports.accuracy.with_streaming_response.create_factcheck_setup_status( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + accuracy = await response.parse() + assert_matches_type(AccuracyCreateFactcheckSetupStatusResponse, accuracy, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_create_inaccuracy_drivers(self, async_client: AsyncProfound) -> None: + accuracy = await async_client.reports.accuracy.create_inaccuracy_drivers( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) + assert_matches_type(AccuracyCreateInaccuracyDriversResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_create_inaccuracy_drivers_with_all_params(self, async_client: AsyncProfound) -> None: + accuracy = await async_client.reports.accuracy.create_inaccuracy_drivers( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + citation_categories=["string"], + comparison_end_date="comparison_end_date", + comparison_start_date="comparison_start_date", + exclude_topic_ids=True, + include_no_persona=True, + include_no_tag=True, + limit=1, + persona_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + platform_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + prompt_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + region_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + tag_filter_type="all", + tag_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + topic_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + ) + assert_matches_type(AccuracyCreateInaccuracyDriversResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_raw_response_create_inaccuracy_drivers(self, async_client: AsyncProfound) -> None: + response = await async_client.reports.accuracy.with_raw_response.create_inaccuracy_drivers( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + accuracy = await response.parse() + assert_matches_type(AccuracyCreateInaccuracyDriversResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_streaming_response_create_inaccuracy_drivers(self, async_client: AsyncProfound) -> None: + async with async_client.reports.accuracy.with_streaming_response.create_inaccuracy_drivers( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + accuracy = await response.parse() + assert_matches_type(AccuracyCreateInaccuracyDriversResponse, accuracy, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_create_inaccurate_clusters(self, async_client: AsyncProfound) -> None: + accuracy = await async_client.reports.accuracy.create_inaccurate_clusters( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + theme_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + ) + assert_matches_type(AccuracyCreateInaccurateClustersResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_create_inaccurate_clusters_with_all_params(self, async_client: AsyncProfound) -> None: + accuracy = await async_client.reports.accuracy.create_inaccurate_clusters( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + theme_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + citation_categories=["string"], + comparison_end_date="comparison_end_date", + comparison_start_date="comparison_start_date", + exclude_topic_ids=True, + include_no_persona=True, + include_no_tag=True, + limit=1, + offset=0, + persona_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + platform_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + prompt_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + region_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + search_query="search_query", + tag_filter_type="all", + tag_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + topic_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + ) + assert_matches_type(AccuracyCreateInaccurateClustersResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_raw_response_create_inaccurate_clusters(self, async_client: AsyncProfound) -> None: + response = await async_client.reports.accuracy.with_raw_response.create_inaccurate_clusters( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + theme_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + accuracy = await response.parse() + assert_matches_type(AccuracyCreateInaccurateClustersResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_streaming_response_create_inaccurate_clusters(self, async_client: AsyncProfound) -> None: + async with async_client.reports.accuracy.with_streaming_response.create_inaccurate_clusters( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + theme_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + accuracy = await response.parse() + assert_matches_type(AccuracyCreateInaccurateClustersResponse, accuracy, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_create_inaccurate_themes(self, async_client: AsyncProfound) -> None: + accuracy = await async_client.reports.accuracy.create_inaccurate_themes( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) + assert_matches_type(AccuracyCreateInaccurateThemesResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_create_inaccurate_themes_with_all_params(self, async_client: AsyncProfound) -> None: + accuracy = await async_client.reports.accuracy.create_inaccurate_themes( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + citation_categories=["string"], + comparison_end_date="comparison_end_date", + comparison_start_date="comparison_start_date", + exclude_topic_ids=True, + include_no_persona=True, + include_no_tag=True, + limit=1, + offset=0, + persona_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + platform_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + prompt_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + region_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + search_query="search_query", + sort_by="response_share", + sort_order="asc", + tag_filter_type="all", + tag_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + topic_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + ) + assert_matches_type(AccuracyCreateInaccurateThemesResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_raw_response_create_inaccurate_themes(self, async_client: AsyncProfound) -> None: + response = await async_client.reports.accuracy.with_raw_response.create_inaccurate_themes( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + accuracy = await response.parse() + assert_matches_type(AccuracyCreateInaccurateThemesResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_streaming_response_create_inaccurate_themes(self, async_client: AsyncProfound) -> None: + async with async_client.reports.accuracy.with_streaming_response.create_inaccurate_themes( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + accuracy = await response.parse() + assert_matches_type(AccuracyCreateInaccurateThemesResponse, accuracy, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_create_overview(self, async_client: AsyncProfound) -> None: + accuracy = await async_client.reports.accuracy.create_overview( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) + assert_matches_type(AccuracyCreateOverviewResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_create_overview_with_all_params(self, async_client: AsyncProfound) -> None: + accuracy = await async_client.reports.accuracy.create_overview( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + citation_categories=["string"], + comparison_end_date="comparison_end_date", + comparison_start_date="comparison_start_date", + date_bucket="date_bucket", + exclude_topic_ids=True, + include_no_persona=True, + include_no_tag=True, + persona_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + platform_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + prompt_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + region_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + tag_filter_type="all", + tag_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + topic_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + ) + assert_matches_type(AccuracyCreateOverviewResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_raw_response_create_overview(self, async_client: AsyncProfound) -> None: + response = await async_client.reports.accuracy.with_raw_response.create_overview( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + accuracy = await response.parse() + assert_matches_type(AccuracyCreateOverviewResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_streaming_response_create_overview(self, async_client: AsyncProfound) -> None: + async with async_client.reports.accuracy.with_streaming_response.create_overview( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + accuracy = await response.parse() + assert_matches_type(AccuracyCreateOverviewResponse, accuracy, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_create_top_inaccurate_claims(self, async_client: AsyncProfound) -> None: + accuracy = await async_client.reports.accuracy.create_top_inaccurate_claims( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) + assert_matches_type(AccuracyCreateTopInaccurateClaimsResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_create_top_inaccurate_claims_with_all_params(self, async_client: AsyncProfound) -> None: + accuracy = await async_client.reports.accuracy.create_top_inaccurate_claims( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + citation_categories=["string"], + comparison_end_date="comparison_end_date", + comparison_start_date="comparison_start_date", + exclude_topic_ids=True, + include_no_persona=True, + include_no_tag=True, + limit=1, + persona_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + platform_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + prompt_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + region_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + tag_filter_type="all", + tag_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + topic_ids=["182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e"], + ) + assert_matches_type(AccuracyCreateTopInaccurateClaimsResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_raw_response_create_top_inaccurate_claims(self, async_client: AsyncProfound) -> None: + response = await async_client.reports.accuracy.with_raw_response.create_top_inaccurate_claims( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + accuracy = await response.parse() + assert_matches_type(AccuracyCreateTopInaccurateClaimsResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_streaming_response_create_top_inaccurate_claims(self, async_client: AsyncProfound) -> None: + async with async_client.reports.accuracy.with_streaming_response.create_top_inaccurate_claims( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + accuracy = await response.parse() + assert_matches_type(AccuracyCreateTopInaccurateClaimsResponse, accuracy, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_create_topic_ids(self, async_client: AsyncProfound) -> None: + accuracy = await async_client.reports.accuracy.create_topic_ids( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) + assert_matches_type(AccuracyCreateTopicIDsResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_raw_response_create_topic_ids(self, async_client: AsyncProfound) -> None: + response = await async_client.reports.accuracy.with_raw_response.create_topic_ids( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + accuracy = await response.parse() + assert_matches_type(AccuracyCreateTopicIDsResponse, accuracy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_streaming_response_create_topic_ids(self, async_client: AsyncProfound) -> None: + async with async_client.reports.accuracy.with_streaming_response.create_topic_ids( + category_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + end_date="end_date", + start_date="start_date", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + accuracy = await response.parse() + assert_matches_type(AccuracyCreateTopicIDsResponse, accuracy, path=["response"]) + + assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/test_agents.py b/tests/api_resources/test_agents.py index 074e47e7..9037c24b 100644 --- a/tests/api_resources/test_agents.py +++ b/tests/api_resources/test_agents.py @@ -12,6 +12,7 @@ from profound.types import ( AgentListResponse, AgentCreateResponse, + AgentUpdateResponse, AgentPublishResponse, AgentRetrieveResponse, ) @@ -121,6 +122,52 @@ def test_path_params_retrieve(self, client: Profound) -> None: agent_id="", ) + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_update(self, client: Profound) -> None: + agent = client.agents.update( + agent_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + graph={"foo": "bar"}, + ) + assert_matches_type(AgentUpdateResponse, agent, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_raw_response_update(self, client: Profound) -> None: + response = client.agents.with_raw_response.update( + agent_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + graph={"foo": "bar"}, + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + agent = response.parse() + assert_matches_type(AgentUpdateResponse, agent, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_streaming_response_update(self, client: Profound) -> None: + with client.agents.with_streaming_response.update( + agent_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + graph={"foo": "bar"}, + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + agent = response.parse() + assert_matches_type(AgentUpdateResponse, agent, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_path_params_update(self, client: Profound) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_id` but received ''"): + client.agents.with_raw_response.update( + agent_id="", + graph={"foo": "bar"}, + ) + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_list(self, client: Profound) -> None: @@ -306,6 +353,52 @@ async def test_path_params_retrieve(self, async_client: AsyncProfound) -> None: agent_id="", ) + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_update(self, async_client: AsyncProfound) -> None: + agent = await async_client.agents.update( + agent_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + graph={"foo": "bar"}, + ) + assert_matches_type(AgentUpdateResponse, agent, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_raw_response_update(self, async_client: AsyncProfound) -> None: + response = await async_client.agents.with_raw_response.update( + agent_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + graph={"foo": "bar"}, + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + agent = await response.parse() + assert_matches_type(AgentUpdateResponse, agent, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_streaming_response_update(self, async_client: AsyncProfound) -> None: + async with async_client.agents.with_streaming_response.update( + agent_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + graph={"foo": "bar"}, + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + agent = await response.parse() + assert_matches_type(AgentUpdateResponse, agent, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_path_params_update(self, async_client: AsyncProfound) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `agent_id` but received ''"): + await async_client.agents.with_raw_response.update( + agent_id="", + graph={"foo": "bar"}, + ) + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_list(self, async_client: AsyncProfound) -> None: