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

payi/resources/evaluations/__init__.py

@@ -0,0 +1,47 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .requests import (
+    RequestsResource,
+    AsyncRequestsResource,
+    RequestsResourceWithRawResponse,
+    AsyncRequestsResourceWithRawResponse,
+    RequestsResourceWithStreamingResponse,
+    AsyncRequestsResourceWithStreamingResponse,
+)
+from .evaluations import (
+    EvaluationsResource,
+    AsyncEvaluationsResource,
+    EvaluationsResourceWithRawResponse,
+    AsyncEvaluationsResourceWithRawResponse,
+    EvaluationsResourceWithStreamingResponse,
+    AsyncEvaluationsResourceWithStreamingResponse,
+)
+from .experiences import (
+    ExperiencesResource,
+    AsyncExperiencesResource,
+    ExperiencesResourceWithRawResponse,
+    AsyncExperiencesResourceWithRawResponse,
+    ExperiencesResourceWithStreamingResponse,
+    AsyncExperiencesResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "ExperiencesResource",
+    "AsyncExperiencesResource",
+    "ExperiencesResourceWithRawResponse",
+    "AsyncExperiencesResourceWithRawResponse",
+    "ExperiencesResourceWithStreamingResponse",
+    "AsyncExperiencesResourceWithStreamingResponse",
+    "RequestsResource",
+    "AsyncRequestsResource",
+    "RequestsResourceWithRawResponse",
+    "AsyncRequestsResourceWithRawResponse",
+    "RequestsResourceWithStreamingResponse",
+    "AsyncRequestsResourceWithStreamingResponse",
+    "EvaluationsResource",
+    "AsyncEvaluationsResource",
+    "EvaluationsResourceWithRawResponse",
+    "AsyncEvaluationsResourceWithRawResponse",
+    "EvaluationsResourceWithStreamingResponse",
+    "AsyncEvaluationsResourceWithStreamingResponse",
+]

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,15 +34,26 @@ 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_type_id: str,
+        experience_name: 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.
@@ -63,10 +74,10 @@ class ExperiencesResource(SyncAPIResource):
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
-        if not experience_type_id:
-            raise ValueError(f"Expected a non-empty value for `experience_type_id` but received {experience_type_id!r}")
+        if not experience_name:
+            raise ValueError(f"Expected a non-empty value for `experience_name` but received {experience_name!r}")
         return self._post(
-            f"/api/v1/experiences/instances/{experience_type_id}",
+            f"/api/v1/experiences/instances/{experience_name}",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -85,7 +96,7 @@ class ExperiencesResource(SyncAPIResource):
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
     ) -> ExperienceInstance:
         """
-        Get Experience details
+        Get an Experience details
 
         Args:
           extra_headers: Send extra headers
@@ -147,15 +158,26 @@ 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_type_id: str,
+        experience_name: 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.
@@ -176,10 +198,10 @@ class AsyncExperiencesResource(AsyncAPIResource):
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
-        if not experience_type_id:
-            raise ValueError(f"Expected a non-empty value for `experience_type_id` but received {experience_type_id!r}")
+        if not experience_name:
+            raise ValueError(f"Expected a non-empty value for `experience_name` but received {experience_name!r}")
         return await self._post(
-            f"/api/v1/experiences/instances/{experience_type_id}",
+            f"/api/v1/experiences/instances/{experience_name}",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -198,7 +220,7 @@ class AsyncExperiencesResource(AsyncAPIResource):
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
     ) -> ExperienceInstance:
         """
-        Get Experience details
+        Get an Experience details
 
         Args:
           extra_headers: Send extra headers