payi 0.1.0a13__py3-none-any.whl → 0.1.0a14__py3-none-any.whl

payi/resources/categories/resources.py

@@ -0,0 +1,450 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from datetime import datetime
+
+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.categories import resource_create_params
+from ...types.category_resource_response import CategoryResourceResponse
+from ...types.categories.resource_list_response import ResourceListResponse
+
+__all__ = ["ResourcesResource", "AsyncResourcesResource"]
+
+
+class ResourcesResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> ResourcesResourceWithRawResponse:
+        return ResourcesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> ResourcesResourceWithStreamingResponse:
+        return ResourcesResourceWithStreamingResponse(self)
+
+    def create(
+        self,
+        resource: str,
+        *,
+        category: str,
+        start_timestamp: Union[str, datetime],
+        input_price: float | NotGiven = NOT_GIVEN,
+        max_input_units: int | NotGiven = NOT_GIVEN,
+        max_output_units: int | NotGiven = NOT_GIVEN,
+        output_price: float | 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,
+    ) -> CategoryResourceResponse:
+        """
+        Create a Resource
+
+        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 category:
+            raise ValueError(f"Expected a non-empty value for `category` but received {category!r}")
+        if not resource:
+            raise ValueError(f"Expected a non-empty value for `resource` but received {resource!r}")
+        return self._post(
+            f"/api/v1/categories/{category}/resources/{resource}",
+            body=maybe_transform(
+                {
+                    "start_timestamp": start_timestamp,
+                    "input_price": input_price,
+                    "max_input_units": max_input_units,
+                    "max_output_units": max_output_units,
+                    "output_price": output_price,
+                },
+                resource_create_params.ResourceCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=CategoryResourceResponse,
+        )
+
+    def retrieve(
+        self,
+        start_timestamp: Union[str, datetime],
+        *,
+        category: str,
+        resource: 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,
+    ) -> CategoryResourceResponse:
+        """
+        Get a Resource's version details
+
+        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 category:
+            raise ValueError(f"Expected a non-empty value for `category` but received {category!r}")
+        if not resource:
+            raise ValueError(f"Expected a non-empty value for `resource` but received {resource!r}")
+        if not start_timestamp:
+            raise ValueError(f"Expected a non-empty value for `start_timestamp` but received {start_timestamp!r}")
+        return self._get(
+            f"/api/v1/categories/{category}/resources/{resource}/{start_timestamp}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=CategoryResourceResponse,
+        )
+
+    def list(
+        self,
+        resource: str,
+        *,
+        category: 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,
+    ) -> ResourceListResponse:
+        """
+        Get a list of versions of a Resource
+
+        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 category:
+            raise ValueError(f"Expected a non-empty value for `category` but received {category!r}")
+        if not resource:
+            raise ValueError(f"Expected a non-empty value for `resource` but received {resource!r}")
+        return self._get(
+            f"/api/v1/categories/{category}/resources/{resource}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ResourceListResponse,
+        )
+
+    def delete(
+        self,
+        start_timestamp: Union[str, datetime],
+        *,
+        category: str,
+        resource: 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,
+    ) -> CategoryResourceResponse:
+        """
+        Delete a version of the Resource
+
+        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 category:
+            raise ValueError(f"Expected a non-empty value for `category` but received {category!r}")
+        if not resource:
+            raise ValueError(f"Expected a non-empty value for `resource` but received {resource!r}")
+        if not start_timestamp:
+            raise ValueError(f"Expected a non-empty value for `start_timestamp` but received {start_timestamp!r}")
+        return self._delete(
+            f"/api/v1/categories/{category}/resources/{resource}/{start_timestamp}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=CategoryResourceResponse,
+        )
+
+
+class AsyncResourcesResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncResourcesResourceWithRawResponse:
+        return AsyncResourcesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncResourcesResourceWithStreamingResponse:
+        return AsyncResourcesResourceWithStreamingResponse(self)
+
+    async def create(
+        self,
+        resource: str,
+        *,
+        category: str,
+        start_timestamp: Union[str, datetime],
+        input_price: float | NotGiven = NOT_GIVEN,
+        max_input_units: int | NotGiven = NOT_GIVEN,
+        max_output_units: int | NotGiven = NOT_GIVEN,
+        output_price: float | 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,
+    ) -> CategoryResourceResponse:
+        """
+        Create a Resource
+
+        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 category:
+            raise ValueError(f"Expected a non-empty value for `category` but received {category!r}")
+        if not resource:
+            raise ValueError(f"Expected a non-empty value for `resource` but received {resource!r}")
+        return await self._post(
+            f"/api/v1/categories/{category}/resources/{resource}",
+            body=await async_maybe_transform(
+                {
+                    "start_timestamp": start_timestamp,
+                    "input_price": input_price,
+                    "max_input_units": max_input_units,
+                    "max_output_units": max_output_units,
+                    "output_price": output_price,
+                },
+                resource_create_params.ResourceCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=CategoryResourceResponse,
+        )
+
+    async def retrieve(
+        self,
+        start_timestamp: Union[str, datetime],
+        *,
+        category: str,
+        resource: 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,
+    ) -> CategoryResourceResponse:
+        """
+        Get a Resource's version details
+
+        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 category:
+            raise ValueError(f"Expected a non-empty value for `category` but received {category!r}")
+        if not resource:
+            raise ValueError(f"Expected a non-empty value for `resource` but received {resource!r}")
+        if not start_timestamp:
+            raise ValueError(f"Expected a non-empty value for `start_timestamp` but received {start_timestamp!r}")
+        return await self._get(
+            f"/api/v1/categories/{category}/resources/{resource}/{start_timestamp}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=CategoryResourceResponse,
+        )
+
+    async def list(
+        self,
+        resource: str,
+        *,
+        category: 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,
+    ) -> ResourceListResponse:
+        """
+        Get a list of versions of a Resource
+
+        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 category:
+            raise ValueError(f"Expected a non-empty value for `category` but received {category!r}")
+        if not resource:
+            raise ValueError(f"Expected a non-empty value for `resource` but received {resource!r}")
+        return await self._get(
+            f"/api/v1/categories/{category}/resources/{resource}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ResourceListResponse,
+        )
+
+    async def delete(
+        self,
+        start_timestamp: Union[str, datetime],
+        *,
+        category: str,
+        resource: 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,
+    ) -> CategoryResourceResponse:
+        """
+        Delete a version of the Resource
+
+        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 category:
+            raise ValueError(f"Expected a non-empty value for `category` but received {category!r}")
+        if not resource:
+            raise ValueError(f"Expected a non-empty value for `resource` but received {resource!r}")
+        if not start_timestamp:
+            raise ValueError(f"Expected a non-empty value for `start_timestamp` but received {start_timestamp!r}")
+        return await self._delete(
+            f"/api/v1/categories/{category}/resources/{resource}/{start_timestamp}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=CategoryResourceResponse,
+        )
+
+
+class ResourcesResourceWithRawResponse:
+    def __init__(self, resources: ResourcesResource) -> None:
+        self._resources = resources
+
+        self.create = to_raw_response_wrapper(
+            resources.create,
+        )
+        self.retrieve = to_raw_response_wrapper(
+            resources.retrieve,
+        )
+        self.list = to_raw_response_wrapper(
+            resources.list,
+        )
+        self.delete = to_raw_response_wrapper(
+            resources.delete,
+        )
+
+
+class AsyncResourcesResourceWithRawResponse:
+    def __init__(self, resources: AsyncResourcesResource) -> None:
+        self._resources = resources
+
+        self.create = async_to_raw_response_wrapper(
+            resources.create,
+        )
+        self.retrieve = async_to_raw_response_wrapper(
+            resources.retrieve,
+        )
+        self.list = async_to_raw_response_wrapper(
+            resources.list,
+        )
+        self.delete = async_to_raw_response_wrapper(
+            resources.delete,
+        )
+
+
+class ResourcesResourceWithStreamingResponse:
+    def __init__(self, resources: ResourcesResource) -> None:
+        self._resources = resources
+
+        self.create = to_streamed_response_wrapper(
+            resources.create,
+        )
+        self.retrieve = to_streamed_response_wrapper(
+            resources.retrieve,
+        )
+        self.list = to_streamed_response_wrapper(
+            resources.list,
+        )
+        self.delete = to_streamed_response_wrapper(
+            resources.delete,
+        )
+
+
+class AsyncResourcesResourceWithStreamingResponse:
+    def __init__(self, resources: AsyncResourcesResource) -> None:
+        self._resources = resources
+
+        self.create = async_to_streamed_response_wrapper(
+            resources.create,
+        )
+        self.retrieve = async_to_streamed_response_wrapper(
+            resources.retrieve,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            resources.list,
+        )
+        self.delete = async_to_streamed_response_wrapper(
+            resources.delete,
+        )

payi/resources/ingest.py

@@ -2,6 +2,9 @@
 
 from __future__ import annotations
 
+from typing import Union
+from datetime import datetime
+
 import httpx
 
 from ..types import ingest_units_params
@@ -41,8 +44,9 @@ class IngestResource(SyncAPIResource):
         input: int,
         output: int,
         resource: str,
-        budget_ids: list[str] | NotGiven = NOT_GIVEN,
-        request_tags: list[str] | NotGiven = NOT_GIVEN,
+        event_timestamp: Union[str, datetime, None] | NotGiven = NOT_GIVEN,
+        budget_ids: Union[list[str], None] | NotGiven = NOT_GIVEN,
+        request_tags: Union[list[str], None] | 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,
@@ -55,20 +59,31 @@ class IngestResource(SyncAPIResource):
 
         Args:
           category (str): The name of the category
-          resource (str): The name of the resource.
+
+          resource (str): The name of the resource
+          
           input (int): The number of input units
+
           output (int): The number of output units
+          
+          event_timestamp: (datetime, None): The timestamp of the event. Defaults to None.
+          
           budget_ids (list[str], optional): The budget IDs to associate with the request. Defaults to None.
+          
           request_tags (list[str], optional): The request tags to associate with the request. Defaults to None.
+          
           extra_headers (Dict[str, str], optional): Additional headers for the request. Defaults to None.
+          
           extra_query (Dict[str, str], optional): Additional query parameters. Defaults to None.
+          
           extra_body (Dict[str, Any], optional): Additional body parameters. Defaults to None.
+          
           timeout (Union[float, None], optional): The timeout for the request in seconds. Defaults to None.
         """
         valid_ids_str: str | NotGiven = NOT_GIVEN
         valid_tags_str: str | NotGiven = NOT_GIVEN
 
-        if isinstance(budget_ids, NotGiven):
+        if budget_ids is None or isinstance(budget_ids, NotGiven):
             valid_ids_str = NOT_GIVEN
         elif not isinstance(budget_ids, list): # type: ignore
             raise TypeError("budget_ids must be a list")
@@ -77,7 +92,7 @@ class IngestResource(SyncAPIResource):
             valid_ids = [id.strip() for id in budget_ids if id.strip()]
             valid_ids_str = ",".join(valid_ids) if valid_ids else NOT_GIVEN
 
-        if isinstance(request_tags, NotGiven):
+        if request_tags is None or isinstance(request_tags, NotGiven):
             valid_tags_str = NOT_GIVEN
         elif not isinstance(request_tags, list): # type: ignore
             raise TypeError("request_tags must be a list")
@@ -103,6 +118,7 @@ class IngestResource(SyncAPIResource):
                     "input": input,
                     "output": output,
                     "resource": resource,
+                    "event_timestamp": event_timestamp,
                 },
                 ingest_units_params.IngestUnitsParams,
             ),
@@ -129,8 +145,9 @@ class AsyncIngestResource(AsyncAPIResource):
         input: int,
         output: int,
         resource: str,
-        budget_ids: list[str] | NotGiven = NOT_GIVEN,
-        request_tags: list[str] | NotGiven = NOT_GIVEN,
+        event_timestamp: Union[str, datetime, None] | NotGiven = NOT_GIVEN,
+        budget_ids: Union[list[str], None] | NotGiven = NOT_GIVEN,
+        request_tags: Union[list[str], None] | 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,
@@ -142,25 +159,44 @@ class AsyncIngestResource(AsyncAPIResource):
         Ingest 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
+          category (str): The name of the category
 
-          timeout: Override the client-level default timeout for this request, in seconds
+          resource (str): The name of the resource
+          
+          input (int): The number of input units
+          
+          output (int): The number of output units
+          
+          event_timestamp: (datetime, None): The timestamp of the event. Defaults to None.
+          
+          budget_ids (list[str], optional): The budget IDs to associate with the request. Defaults to None.
+          
+          request_tags (list[str], optional): The request tags to associate with the request. Defaults to None.
+          
+          extra_headers (Dict[str, str], optional): Additional headers for the request. Defaults to None.
+          
+          extra_query (Dict[str, str], optional): Additional query parameters. Defaults to None.
+          
+          extra_body (Dict[str, Any], optional): Additional body parameters. Defaults to None.
+          
+          timeout (Union[float, None], optional): The timeout for the request in seconds. Defaults to None.
         """
         valid_ids_str: str | NotGiven = NOT_GIVEN
         valid_tags_str: str | NotGiven = NOT_GIVEN
 
-        if isinstance(budget_ids, NotGiven):
+        if budget_ids is None or isinstance(budget_ids, NotGiven):
             valid_ids_str = NOT_GIVEN
+        elif not isinstance(budget_ids, list): # type: ignore
+            raise TypeError("budget_ids must be a list")
         else:
             # Proceed with the list comprehension if budget_ids is not NotGiven
             valid_ids = [id.strip() for id in budget_ids if id.strip()]
             valid_ids_str = ",".join(valid_ids) if valid_ids else NOT_GIVEN
-        if isinstance(request_tags, NotGiven):
+
+        if request_tags is None or isinstance(request_tags, NotGiven):
             valid_tags_str = NOT_GIVEN
+        elif not isinstance(request_tags, list): # type: ignore
+            raise TypeError("request_tags must be a list")
         else:
             # Proceed with the list comprehension if budget_ids is not NotGiven
             valid_tags = [tag.strip() for tag in request_tags if tag.strip()]
@@ -183,6 +219,7 @@ class AsyncIngestResource(AsyncAPIResource):
                     "input": input,
                     "output": output,
                     "resource": resource,
+                    "event_timestamp": event_timestamp,
                 },
                 ingest_units_params.IngestUnitsParams,
             ),

payi/types/__init__.py

@@ -8,9 +8,15 @@ from .proxy_result import ProxyResult as ProxyResult
 from .requests_data import RequestsData as RequestsData
 from .budget_response import BudgetResponse as BudgetResponse
 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 .ingest_units_params import IngestUnitsParams as IngestUnitsParams
 from .budget_create_params import BudgetCreateParams as BudgetCreateParams
 from .budget_update_params import BudgetUpdateParams as BudgetUpdateParams
+from .category_list_response import CategoryListResponse as CategoryListResponse
 from .budget_history_response import BudgetHistoryResponse as BudgetHistoryResponse
+from .category_delete_response import CategoryDeleteResponse as CategoryDeleteResponse
+from .category_resource_response import CategoryResourceResponse as CategoryResourceResponse
+from .category_list_resources_response import CategoryListResourcesResponse as CategoryListResourcesResponse
+from .category_delete_resource_response import CategoryDeleteResourceResponse as CategoryDeleteResourceResponse

payi/types/budget_create_params.py

@@ -15,10 +15,14 @@ class BudgetCreateParams(TypedDict, total=False):
 
     base_cost_estimate: Literal["max"]
 
+    billing_model_id: Optional[int]
+
     budget_response_type: Literal["block", "allow"]
 
     budget_tags: Optional[List[str]]
 
     budget_type: Literal["conservative", "liberal"]
 
+    cost_basis: Literal["base", "billed"]
+
     currency: Literal["usd"]