payi 0.1.0a24__py3-none-any.whl → 0.1.0a25__py3-none-any.whl

payi/resources/evaluations/evaluations.py

@@ -0,0 +1,134 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .requests import (
+    RequestsResource,
+    AsyncRequestsResource,
+    RequestsResourceWithRawResponse,
+    AsyncRequestsResourceWithRawResponse,
+    RequestsResourceWithStreamingResponse,
+    AsyncRequestsResourceWithStreamingResponse,
+)
+from ..._compat import cached_property
+from ..._resource import SyncAPIResource, AsyncAPIResource
+from .experiences import (
+    ExperiencesResource,
+    AsyncExperiencesResource,
+    ExperiencesResourceWithRawResponse,
+    AsyncExperiencesResourceWithRawResponse,
+    ExperiencesResourceWithStreamingResponse,
+    AsyncExperiencesResourceWithStreamingResponse,
+)
+
+__all__ = ["EvaluationsResource", "AsyncEvaluationsResource"]
+
+
+class EvaluationsResource(SyncAPIResource):
+    @cached_property
+    def experiences(self) -> ExperiencesResource:
+        return ExperiencesResource(self._client)
+
+    @cached_property
+    def requests(self) -> RequestsResource:
+        return RequestsResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> EvaluationsResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return the
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/Pay-i/pay-i-python#accessing-raw-response-data-eg-headers
+        """
+        return EvaluationsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> EvaluationsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/Pay-i/pay-i-python#with_streaming_response
+        """
+        return EvaluationsResourceWithStreamingResponse(self)
+
+
+class AsyncEvaluationsResource(AsyncAPIResource):
+    @cached_property
+    def experiences(self) -> AsyncExperiencesResource:
+        return AsyncExperiencesResource(self._client)
+
+    @cached_property
+    def requests(self) -> AsyncRequestsResource:
+        return AsyncRequestsResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncEvaluationsResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return the
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/Pay-i/pay-i-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncEvaluationsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncEvaluationsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/Pay-i/pay-i-python#with_streaming_response
+        """
+        return AsyncEvaluationsResourceWithStreamingResponse(self)
+
+
+class EvaluationsResourceWithRawResponse:
+    def __init__(self, evaluations: EvaluationsResource) -> None:
+        self._evaluations = evaluations
+
+    @cached_property
+    def experiences(self) -> ExperiencesResourceWithRawResponse:
+        return ExperiencesResourceWithRawResponse(self._evaluations.experiences)
+
+    @cached_property
+    def requests(self) -> RequestsResourceWithRawResponse:
+        return RequestsResourceWithRawResponse(self._evaluations.requests)
+
+
+class AsyncEvaluationsResourceWithRawResponse:
+    def __init__(self, evaluations: AsyncEvaluationsResource) -> None:
+        self._evaluations = evaluations
+
+    @cached_property
+    def experiences(self) -> AsyncExperiencesResourceWithRawResponse:
+        return AsyncExperiencesResourceWithRawResponse(self._evaluations.experiences)
+
+    @cached_property
+    def requests(self) -> AsyncRequestsResourceWithRawResponse:
+        return AsyncRequestsResourceWithRawResponse(self._evaluations.requests)
+
+
+class EvaluationsResourceWithStreamingResponse:
+    def __init__(self, evaluations: EvaluationsResource) -> None:
+        self._evaluations = evaluations
+
+    @cached_property
+    def experiences(self) -> ExperiencesResourceWithStreamingResponse:
+        return ExperiencesResourceWithStreamingResponse(self._evaluations.experiences)
+
+    @cached_property
+    def requests(self) -> RequestsResourceWithStreamingResponse:
+        return RequestsResourceWithStreamingResponse(self._evaluations.requests)
+
+
+class AsyncEvaluationsResourceWithStreamingResponse:
+    def __init__(self, evaluations: AsyncEvaluationsResource) -> None:
+        self._evaluations = evaluations
+
+    @cached_property
+    def experiences(self) -> AsyncExperiencesResourceWithStreamingResponse:
+        return AsyncExperiencesResourceWithStreamingResponse(self._evaluations.experiences)
+
+    @cached_property
+    def requests(self) -> AsyncRequestsResourceWithStreamingResponse:
+        return AsyncRequestsResourceWithStreamingResponse(self._evaluations.requests)

payi/resources/evaluations/experiences.py

@@ -0,0 +1,188 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+
+import httpx
+
+from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+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.evaluations import experience_create_params
+from ...types.shared.evaluation_response import EvaluationResponse
+
+__all__ = ["ExperiencesResource", "AsyncExperiencesResource"]
+
+
+class ExperiencesResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> ExperiencesResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return the
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/Pay-i/pay-i-python#accessing-raw-response-data-eg-headers
+        """
+        return ExperiencesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> ExperiencesResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/Pay-i/pay-i-python#with_streaming_response
+        """
+        return ExperiencesResourceWithStreamingResponse(self)
+
+    def create(
+        self,
+        experience_id: str,
+        *,
+        evaluation: int,
+        user_id: Optional[str] | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> EvaluationResponse:
+        """
+        Create an Evaluation for an Experience
+
+        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
+        """
+        if not experience_id:
+            raise ValueError(f"Expected a non-empty value for `experience_id` but received {experience_id!r}")
+        return self._post(
+            f"/api/v1/evaluations/experiences/{experience_id}",
+            body=maybe_transform(
+                {
+                    "evaluation": evaluation,
+                    "user_id": user_id,
+                },
+                experience_create_params.ExperienceCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=EvaluationResponse,
+        )
+
+
+class AsyncExperiencesResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncExperiencesResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return the
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/Pay-i/pay-i-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncExperiencesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncExperiencesResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/Pay-i/pay-i-python#with_streaming_response
+        """
+        return AsyncExperiencesResourceWithStreamingResponse(self)
+
+    async def create(
+        self,
+        experience_id: str,
+        *,
+        evaluation: int,
+        user_id: Optional[str] | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> EvaluationResponse:
+        """
+        Create an Evaluation for an Experience
+
+        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
+        """
+        if not experience_id:
+            raise ValueError(f"Expected a non-empty value for `experience_id` but received {experience_id!r}")
+        return await self._post(
+            f"/api/v1/evaluations/experiences/{experience_id}",
+            body=await async_maybe_transform(
+                {
+                    "evaluation": evaluation,
+                    "user_id": user_id,
+                },
+                experience_create_params.ExperienceCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=EvaluationResponse,
+        )
+
+
+class ExperiencesResourceWithRawResponse:
+    def __init__(self, experiences: ExperiencesResource) -> None:
+        self._experiences = experiences
+
+        self.create = to_raw_response_wrapper(
+            experiences.create,
+        )
+
+
+class AsyncExperiencesResourceWithRawResponse:
+    def __init__(self, experiences: AsyncExperiencesResource) -> None:
+        self._experiences = experiences
+
+        self.create = async_to_raw_response_wrapper(
+            experiences.create,
+        )
+
+
+class ExperiencesResourceWithStreamingResponse:
+    def __init__(self, experiences: ExperiencesResource) -> None:
+        self._experiences = experiences
+
+        self.create = to_streamed_response_wrapper(
+            experiences.create,
+        )
+
+
+class AsyncExperiencesResourceWithStreamingResponse:
+    def __init__(self, experiences: AsyncExperiencesResource) -> None:
+        self._experiences = experiences
+
+        self.create = async_to_streamed_response_wrapper(
+            experiences.create,
+        )

payi/resources/evaluations/requests.py

@@ -0,0 +1,200 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+
+import httpx
+
+from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+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.evaluations import request_create_params
+from ...types.shared.evaluation_response import EvaluationResponse
+
+__all__ = ["RequestsResource", "AsyncRequestsResource"]
+
+
+class RequestsResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> RequestsResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return the
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/Pay-i/pay-i-python#accessing-raw-response-data-eg-headers
+        """
+        return RequestsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> RequestsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/Pay-i/pay-i-python#with_streaming_response
+        """
+        return RequestsResourceWithStreamingResponse(self)
+
+    def create(
+        self,
+        request_id: str,
+        *,
+        evaluation: int,
+        user_id: Optional[str] | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> EvaluationResponse:
+        """
+        Create an Evaluation for a Request
+
+        Args:
+          evaluation: The evaluation value
+
+          request_id: The request ID being evaluated
+
+          user_id: The user ID creating the evaluation
+
+          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 request_id:
+            raise ValueError(f"Expected a non-empty value for `request_id` but received {request_id!r}")
+        return self._post(
+            f"/api/v1/evaluations/requests/{request_id}",
+            body=maybe_transform(
+                {
+                    "evaluation": evaluation,
+                    "user_id": user_id,
+                },
+                request_create_params.RequestCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=EvaluationResponse,
+        )
+
+
+class AsyncRequestsResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncRequestsResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return the
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/Pay-i/pay-i-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncRequestsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncRequestsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/Pay-i/pay-i-python#with_streaming_response
+        """
+        return AsyncRequestsResourceWithStreamingResponse(self)
+
+    async def create(
+        self,
+        request_id: str,
+        *,
+        evaluation: int,
+        user_id: Optional[str] | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> EvaluationResponse:
+        """
+        Create an Evaluation for a Request
+
+        Args:
+          evaluation: The evaluation value
+
+          request_id: The request ID being evaluated
+
+          user_id: The user ID creating the evaluation
+
+          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 request_id:
+            raise ValueError(f"Expected a non-empty value for `request_id` but received {request_id!r}")
+        return await self._post(
+            f"/api/v1/evaluations/requests/{request_id}",
+            body=await async_maybe_transform(
+                {
+                    "evaluation": evaluation,
+                    "user_id": user_id,
+                },
+                request_create_params.RequestCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=EvaluationResponse,
+        )
+
+
+class RequestsResourceWithRawResponse:
+    def __init__(self, requests: RequestsResource) -> None:
+        self._requests = requests
+
+        self.create = to_raw_response_wrapper(
+            requests.create,
+        )
+
+
+class AsyncRequestsResourceWithRawResponse:
+    def __init__(self, requests: AsyncRequestsResource) -> None:
+        self._requests = requests
+
+        self.create = async_to_raw_response_wrapper(
+            requests.create,
+        )
+
+
+class RequestsResourceWithStreamingResponse:
+    def __init__(self, requests: RequestsResource) -> None:
+        self._requests = requests
+
+        self.create = to_streamed_response_wrapper(
+            requests.create,
+        )
+
+
+class AsyncRequestsResourceWithStreamingResponse:
+    def __init__(self, requests: AsyncRequestsResource) -> None:
+        self._requests = requests
+
+        self.create = async_to_streamed_response_wrapper(
+            requests.create,
+        )

payi/resources/experiences/experiences.py

@@ -34,10 +34,21 @@ class ExperiencesResource(SyncAPIResource):
 
     @cached_property
     def with_raw_response(self) -> ExperiencesResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return the
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/Pay-i/pay-i-python#accessing-raw-response-data-eg-headers
+        """
         return ExperiencesResourceWithRawResponse(self)
 
     @cached_property
     def with_streaming_response(self) -> ExperiencesResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/Pay-i/pay-i-python#with_streaming_response
+        """
         return ExperiencesResourceWithStreamingResponse(self)
 
     def create(
@@ -147,10 +158,21 @@ class AsyncExperiencesResource(AsyncAPIResource):
 
     @cached_property
     def with_raw_response(self) -> AsyncExperiencesResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return the
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/Pay-i/pay-i-python#accessing-raw-response-data-eg-headers
+        """
         return AsyncExperiencesResourceWithRawResponse(self)
 
     @cached_property
     def with_streaming_response(self) -> AsyncExperiencesResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/Pay-i/pay-i-python#with_streaming_response
+        """
         return AsyncExperiencesResourceWithStreamingResponse(self)
 
     async def create(

payi/resources/experiences/types.py

@@ -28,10 +28,21 @@ __all__ = ["TypesResource", "AsyncTypesResource"]
 class TypesResource(SyncAPIResource):
     @cached_property
     def with_raw_response(self) -> TypesResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return the
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/Pay-i/pay-i-python#accessing-raw-response-data-eg-headers
+        """
         return TypesResourceWithRawResponse(self)
 
     @cached_property
     def with_streaming_response(self) -> TypesResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/Pay-i/pay-i-python#with_streaming_response
+        """
         return TypesResourceWithStreamingResponse(self)
 
     def create(
@@ -215,10 +226,21 @@ class TypesResource(SyncAPIResource):
 class AsyncTypesResource(AsyncAPIResource):
     @cached_property
     def with_raw_response(self) -> AsyncTypesResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return the
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/Pay-i/pay-i-python#accessing-raw-response-data-eg-headers
+        """
         return AsyncTypesResourceWithRawResponse(self)
 
     @cached_property
     def with_streaming_response(self) -> AsyncTypesResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/Pay-i/pay-i-python#with_streaming_response
+        """
         return AsyncTypesResourceWithStreamingResponse(self)
 
     async def create(

payi/resources/ingest.py

@@ -33,10 +33,21 @@ __all__ = ["IngestResource", "AsyncIngestResource"]
 class IngestResource(SyncAPIResource):
     @cached_property
     def with_raw_response(self) -> IngestResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return the
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/Pay-i/pay-i-python#accessing-raw-response-data-eg-headers
+        """
         return IngestResourceWithRawResponse(self)
 
     @cached_property
     def with_streaming_response(self) -> IngestResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/Pay-i/pay-i-python#with_streaming_response
+        """
         return IngestResourceWithStreamingResponse(self)
 
     def bulk(
@@ -183,10 +194,21 @@ class IngestResource(SyncAPIResource):
 class AsyncIngestResource(AsyncAPIResource):
     @cached_property
     def with_raw_response(self) -> AsyncIngestResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return the
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/Pay-i/pay-i-python#accessing-raw-response-data-eg-headers
+        """
         return AsyncIngestResourceWithRawResponse(self)
 
     @cached_property
     def with_streaming_response(self) -> AsyncIngestResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/Pay-i/pay-i-python#with_streaming_response
+        """
         return AsyncIngestResourceWithStreamingResponse(self)
 
     async def bulk(

payi/types/__init__.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from .shared import EvaluationResponse as EvaluationResponse
 from .cost_data import CostData as CostData
 from .cost_details import CostDetails as CostDetails
 from .requests_data import RequestsData as RequestsData

payi/types/evaluations/__init__.py

@@ -0,0 +1,6 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .request_create_params import RequestCreateParams as RequestCreateParams
+from .experience_create_params import ExperienceCreateParams as ExperienceCreateParams

payi/types/evaluations/experience_create_params.py

@@ -0,0 +1,14 @@
+# 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 Required, TypedDict
+
+__all__ = ["ExperienceCreateParams"]
+
+
+class ExperienceCreateParams(TypedDict, total=False):
+    evaluation: Required[int]
+
+    user_id: Optional[str]