payi 0.1.0a30__py3-none-any.whl → 0.1.0a32__py3-none-any.whl

payi/resources/experiences/properties.py

@@ -0,0 +1,174 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, 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.experiences import property_create_params
+from ...types.experience_instance_response import ExperienceInstanceResponse
+
+__all__ = ["PropertiesResource", "AsyncPropertiesResource"]
+
+
+class PropertiesResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> PropertiesResourceWithRawResponse:
+        """
+        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 PropertiesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> PropertiesResourceWithStreamingResponse:
+        """
+        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 PropertiesResourceWithStreamingResponse(self)
+
+    def create(
+        self,
+        experience_id: str,
+        *,
+        properties: Optional[Dict[str, 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,
+    ) -> ExperienceInstanceResponse:
+        """
+        Update an Experience properties
+
+        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/experiences/instances/{experience_id}/properties",
+            body=maybe_transform({"properties": properties}, property_create_params.PropertyCreateParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ExperienceInstanceResponse,
+        )
+
+
+class AsyncPropertiesResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncPropertiesResourceWithRawResponse:
+        """
+        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 AsyncPropertiesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncPropertiesResourceWithStreamingResponse:
+        """
+        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 AsyncPropertiesResourceWithStreamingResponse(self)
+
+    async def create(
+        self,
+        experience_id: str,
+        *,
+        properties: Optional[Dict[str, 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,
+    ) -> ExperienceInstanceResponse:
+        """
+        Update an Experience properties
+
+        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/experiences/instances/{experience_id}/properties",
+            body=await async_maybe_transform({"properties": properties}, property_create_params.PropertyCreateParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ExperienceInstanceResponse,
+        )
+
+
+class PropertiesResourceWithRawResponse:
+    def __init__(self, properties: PropertiesResource) -> None:
+        self._properties = properties
+
+        self.create = to_raw_response_wrapper(
+            properties.create,
+        )
+
+
+class AsyncPropertiesResourceWithRawResponse:
+    def __init__(self, properties: AsyncPropertiesResource) -> None:
+        self._properties = properties
+
+        self.create = async_to_raw_response_wrapper(
+            properties.create,
+        )
+
+
+class PropertiesResourceWithStreamingResponse:
+    def __init__(self, properties: PropertiesResource) -> None:
+        self._properties = properties
+
+        self.create = to_streamed_response_wrapper(
+            properties.create,
+        )
+
+
+class AsyncPropertiesResourceWithStreamingResponse:
+    def __init__(self, properties: AsyncPropertiesResource) -> None:
+        self._properties = properties
+
+        self.create = async_to_streamed_response_wrapper(
+            properties.create,
+        )

payi/resources/requests/__init__.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .requests import (
+    RequestsResource,
+    AsyncRequestsResource,
+    RequestsResourceWithRawResponse,
+    AsyncRequestsResourceWithRawResponse,
+    RequestsResourceWithStreamingResponse,
+    AsyncRequestsResourceWithStreamingResponse,
+)
+from .properties import (
+    PropertiesResource,
+    AsyncPropertiesResource,
+    PropertiesResourceWithRawResponse,
+    AsyncPropertiesResourceWithRawResponse,
+    PropertiesResourceWithStreamingResponse,
+    AsyncPropertiesResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "PropertiesResource",
+    "AsyncPropertiesResource",
+    "PropertiesResourceWithRawResponse",
+    "AsyncPropertiesResourceWithRawResponse",
+    "PropertiesResourceWithStreamingResponse",
+    "AsyncPropertiesResourceWithStreamingResponse",
+    "RequestsResource",
+    "AsyncRequestsResource",
+    "RequestsResourceWithRawResponse",
+    "AsyncRequestsResourceWithRawResponse",
+    "RequestsResourceWithStreamingResponse",
+    "AsyncRequestsResourceWithStreamingResponse",
+]

payi/resources/requests/properties.py

@@ -0,0 +1,174 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, 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.requests import property_create_params
+from ...types.experiences.properties_response import PropertiesResponse
+
+__all__ = ["PropertiesResource", "AsyncPropertiesResource"]
+
+
+class PropertiesResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> PropertiesResourceWithRawResponse:
+        """
+        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 PropertiesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> PropertiesResourceWithStreamingResponse:
+        """
+        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 PropertiesResourceWithStreamingResponse(self)
+
+    def create(
+        self,
+        request_id: str,
+        *,
+        properties: Optional[Dict[str, 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,
+    ) -> PropertiesResponse:
+        """
+        Create properties for a Request
+
+        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 request_id:
+            raise ValueError(f"Expected a non-empty value for `request_id` but received {request_id!r}")
+        return self._post(
+            f"/api/v1/requests/{request_id}/properties",
+            body=maybe_transform({"properties": properties}, property_create_params.PropertyCreateParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=PropertiesResponse,
+        )
+
+
+class AsyncPropertiesResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncPropertiesResourceWithRawResponse:
+        """
+        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 AsyncPropertiesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncPropertiesResourceWithStreamingResponse:
+        """
+        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 AsyncPropertiesResourceWithStreamingResponse(self)
+
+    async def create(
+        self,
+        request_id: str,
+        *,
+        properties: Optional[Dict[str, 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,
+    ) -> PropertiesResponse:
+        """
+        Create properties for a Request
+
+        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 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/requests/{request_id}/properties",
+            body=await async_maybe_transform({"properties": properties}, property_create_params.PropertyCreateParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=PropertiesResponse,
+        )
+
+
+class PropertiesResourceWithRawResponse:
+    def __init__(self, properties: PropertiesResource) -> None:
+        self._properties = properties
+
+        self.create = to_raw_response_wrapper(
+            properties.create,
+        )
+
+
+class AsyncPropertiesResourceWithRawResponse:
+    def __init__(self, properties: AsyncPropertiesResource) -> None:
+        self._properties = properties
+
+        self.create = async_to_raw_response_wrapper(
+            properties.create,
+        )
+
+
+class PropertiesResourceWithStreamingResponse:
+    def __init__(self, properties: PropertiesResource) -> None:
+        self._properties = properties
+
+        self.create = to_streamed_response_wrapper(
+            properties.create,
+        )
+
+
+class AsyncPropertiesResourceWithStreamingResponse:
+    def __init__(self, properties: AsyncPropertiesResource) -> None:
+        self._properties = properties
+
+        self.create = async_to_streamed_response_wrapper(
+            properties.create,
+        )

payi/resources/requests/requests.py

@@ -0,0 +1,102 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from ..._compat import cached_property
+from .properties import (
+    PropertiesResource,
+    AsyncPropertiesResource,
+    PropertiesResourceWithRawResponse,
+    AsyncPropertiesResourceWithRawResponse,
+    PropertiesResourceWithStreamingResponse,
+    AsyncPropertiesResourceWithStreamingResponse,
+)
+from ..._resource import SyncAPIResource, AsyncAPIResource
+
+__all__ = ["RequestsResource", "AsyncRequestsResource"]
+
+
+class RequestsResource(SyncAPIResource):
+    @cached_property
+    def properties(self) -> PropertiesResource:
+        return PropertiesResource(self._client)
+
+    @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)
+
+
+class AsyncRequestsResource(AsyncAPIResource):
+    @cached_property
+    def properties(self) -> AsyncPropertiesResource:
+        return AsyncPropertiesResource(self._client)
+
+    @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)
+
+
+class RequestsResourceWithRawResponse:
+    def __init__(self, requests: RequestsResource) -> None:
+        self._requests = requests
+
+    @cached_property
+    def properties(self) -> PropertiesResourceWithRawResponse:
+        return PropertiesResourceWithRawResponse(self._requests.properties)
+
+
+class AsyncRequestsResourceWithRawResponse:
+    def __init__(self, requests: AsyncRequestsResource) -> None:
+        self._requests = requests
+
+    @cached_property
+    def properties(self) -> AsyncPropertiesResourceWithRawResponse:
+        return AsyncPropertiesResourceWithRawResponse(self._requests.properties)
+
+
+class RequestsResourceWithStreamingResponse:
+    def __init__(self, requests: RequestsResource) -> None:
+        self._requests = requests
+
+    @cached_property
+    def properties(self) -> PropertiesResourceWithStreamingResponse:
+        return PropertiesResourceWithStreamingResponse(self._requests.properties)
+
+
+class AsyncRequestsResourceWithStreamingResponse:
+    def __init__(self, requests: AsyncRequestsResource) -> None:
+        self._requests = requests
+
+    @cached_property
+    def properties(self) -> AsyncPropertiesResourceWithStreamingResponse:
+        return AsyncPropertiesResourceWithStreamingResponse(self._requests.properties)

payi/types/__init__.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-from .csat import Csat as Csat
 from .cost_data import CostData as CostData
 from .cost_details import CostDetails as CostDetails
 from .billing_model import BillingModel as BillingModel
@@ -15,10 +14,8 @@ from .default_response import DefaultResponse as DefaultResponse
 from .category_response import CategoryResponse as CategoryResponse
 from .paged_budget_list import PagedBudgetList as PagedBudgetList
 from .budget_list_params import BudgetListParams as BudgetListParams
-from .csat_create_params import CsatCreateParams as CsatCreateParams
 from .ingest_bulk_params import IngestBulkParams as IngestBulkParams
 from .ingest_event_param import IngestEventParam as IngestEventParam
-from .experience_instance import ExperienceInstance as ExperienceInstance
 from .ingest_units_params import IngestUnitsParams as IngestUnitsParams
 from .budget_create_params import BudgetCreateParams as BudgetCreateParams
 from .budget_update_params import BudgetUpdateParams as BudgetUpdateParams
@@ -30,6 +27,7 @@ from .category_resource_response import CategoryResourceResponse as CategoryReso
 from .billing_model_create_params import BillingModelCreateParams as BillingModelCreateParams
 from .billing_model_list_response import BillingModelListResponse as BillingModelListResponse
 from .billing_model_update_params import BillingModelUpdateParams as BillingModelUpdateParams
+from .experience_instance_response import ExperienceInstanceResponse as ExperienceInstanceResponse
 from .price_modifier_create_params import PriceModifierCreateParams as PriceModifierCreateParams
 from .price_modifier_update_params import PriceModifierUpdateParams as PriceModifierUpdateParams
 from .category_list_resources_response import CategoryListResourcesResponse as CategoryListResourcesResponse

payi/types/billing_model.py

@@ -18,7 +18,7 @@ class BillingModel(BaseModel):
 
     name: str
 
-    type: Literal["costplus"]
+    type: Literal["invalid", "costplus", "subscription", "hybrid"]
 
     updated_on: datetime
 

payi/types/billing_model_create_params.py

@@ -11,7 +11,7 @@ __all__ = ["BillingModelCreateParams"]
 class BillingModelCreateParams(TypedDict, total=False):
     name: Required[str]
 
-    type: Required[Literal["costplus"]]
+    type: Required[Literal["invalid", "costplus", "subscription", "hybrid"]]
 
     default_price_modifier: Optional[float]
 

payi/types/billing_model_update_params.py

@@ -9,7 +9,7 @@ __all__ = ["BillingModelUpdateParams"]
 
 
 class BillingModelUpdateParams(TypedDict, total=False):
-    type: Required[Literal["costplus"]]
+    type: Required[Literal["invalid", "costplus", "subscription", "hybrid"]]
 
     default_price_modifier: Optional[float]
 

payi/types/{experience_instance.py → experience_instance_response.py}

@@ -1,12 +1,15 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
+from typing import Dict
 
 from .._models import BaseModel
 
-__all__ = ["ExperienceInstance"]
+__all__ = ["ExperienceInstanceResponse"]
 
 
-class ExperienceInstance(BaseModel):
+class ExperienceInstanceResponse(BaseModel):
     experience_id: str
 
+    properties: Dict[str, str]
+
     request_id: str

payi/types/experiences/__init__.py

@@ -2,8 +2,12 @@
 
 from __future__ import annotations
 
+from .csat_response import CsatResponse as CsatResponse
 from .experience_type import ExperienceType as ExperienceType
 from .type_list_params import TypeListParams as TypeListParams
+from .csat_create_params import CsatCreateParams as CsatCreateParams
 from .type_create_params import TypeCreateParams as TypeCreateParams
 from .type_list_response import TypeListResponse as TypeListResponse
 from .type_update_params import TypeUpdateParams as TypeUpdateParams
+from .properties_response import PropertiesResponse as PropertiesResponse
+from .property_create_params import PropertyCreateParams as PropertyCreateParams

payi/types/{csat.py → experiences/csat_response.py}

@@ -1,10 +1,10 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 
-from .._models import BaseModel
+from ..._models import BaseModel
 
-__all__ = ["Csat"]
+__all__ = ["CsatResponse"]
 
 
-class Csat(BaseModel):
+class CsatResponse(BaseModel):
     request_id: str

payi/types/experiences/properties_response.py

@@ -0,0 +1,11 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from ..._models import BaseModel
+
+__all__ = ["PropertiesResponse"]
+
+
+class PropertiesResponse(BaseModel):
+    request_id: Optional[str] = None

payi/types/experiences/property_create_params.py

@@ -0,0 +1,12 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Optional
+from typing_extensions import Required, TypedDict
+
+__all__ = ["PropertyCreateParams"]
+
+
+class PropertyCreateParams(TypedDict, total=False):
+    properties: Required[Optional[Dict[str, str]]]

payi/types/requests/__init__.py

@@ -0,0 +1,5 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .property_create_params import PropertyCreateParams as PropertyCreateParams

payi/types/requests/property_create_params.py

@@ -0,0 +1,12 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Optional
+from typing_extensions import Required, TypedDict
+
+__all__ = ["PropertyCreateParams"]
+
+
+class PropertyCreateParams(TypedDict, total=False):
+    properties: Required[Optional[Dict[str, str]]]

{payi-0.1.0a30.dist-info → payi-0.1.0a32.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: payi
-Version: 0.1.0a30
+Version: 0.1.0a32
 Summary: The official Python library for the payi API
 Project-URL: Homepage, https://github.com/Pay-i/pay-i-python
 Project-URL: Repository, https://github.com/Pay-i/pay-i-python
@@ -314,18 +314,19 @@ can also get all the extra fields on the Pydantic model as a dict with
 
 You can directly override the [httpx client](https://www.python-httpx.org/api/#client) to customize it for your use case, including:
 
-- Support for proxies
-- Custom transports
+- Support for [proxies](https://www.python-httpx.org/advanced/proxies/)
+- Custom [transports](https://www.python-httpx.org/advanced/transports/)
 - Additional [advanced](https://www.python-httpx.org/advanced/clients/) functionality
 
 ```python
+import httpx
 from payi import Payi, DefaultHttpxClient
 
 client = Payi(
     # Or use the `PAYI_BASE_URL` env var
     base_url="http://my.test.server.example.com:8083",
     http_client=DefaultHttpxClient(
-        proxies="http://my.test.proxy.example.com",
+        proxy="http://my.test.proxy.example.com",
         transport=httpx.HTTPTransport(local_address="0.0.0.0"),
     ),
 )