paid-python 0.6.0__py3-none-any.whl → 1.0.0a1__py3-none-any.whl

paid/signals/client.py

@@ -0,0 +1,130 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+from ..core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
+from ..core.request_options import RequestOptions
+from ..types.bulk_signals_response import BulkSignalsResponse
+from ..types.signal import Signal
+from .raw_client import AsyncRawSignalsClient, RawSignalsClient
+
+# this is used as the default value for optional parameters
+OMIT = typing.cast(typing.Any, ...)
+
+
+class SignalsClient:
+    def __init__(self, *, client_wrapper: SyncClientWrapper):
+        self._raw_client = RawSignalsClient(client_wrapper=client_wrapper)
+
+    @property
+    def with_raw_response(self) -> RawSignalsClient:
+        """
+        Retrieves a raw implementation of this client that returns raw responses.
+
+        Returns
+        -------
+        RawSignalsClient
+        """
+        return self._raw_client
+
+    def create_signals_in_bulk(
+        self, *, signals: typing.Sequence[Signal], request_options: typing.Optional[RequestOptions] = None
+    ) -> BulkSignalsResponse:
+        """
+        Create multiple signals (usage events) in a single request. Each signal must include a customer attribution (either customerId or externalCustomerId) and a product attribution (either productId or externalProductId).
+
+        Parameters
+        ----------
+        signals : typing.Sequence[Signal]
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        BulkSignalsResponse
+            200
+
+        Examples
+        --------
+        from paid import CustomerById, Paid, Signal
+
+        client = Paid(
+            token="YOUR_TOKEN",
+        )
+        client.signals.create_signals_in_bulk(
+            signals=[
+                Signal(
+                    event_name="eventName",
+                    customer=CustomerById(
+                        customer_id="customerId",
+                    ),
+                )
+            ],
+        )
+        """
+        _response = self._raw_client.create_signals_in_bulk(signals=signals, request_options=request_options)
+        return _response.data
+
+
+class AsyncSignalsClient:
+    def __init__(self, *, client_wrapper: AsyncClientWrapper):
+        self._raw_client = AsyncRawSignalsClient(client_wrapper=client_wrapper)
+
+    @property
+    def with_raw_response(self) -> AsyncRawSignalsClient:
+        """
+        Retrieves a raw implementation of this client that returns raw responses.
+
+        Returns
+        -------
+        AsyncRawSignalsClient
+        """
+        return self._raw_client
+
+    async def create_signals_in_bulk(
+        self, *, signals: typing.Sequence[Signal], request_options: typing.Optional[RequestOptions] = None
+    ) -> BulkSignalsResponse:
+        """
+        Create multiple signals (usage events) in a single request. Each signal must include a customer attribution (either customerId or externalCustomerId) and a product attribution (either productId or externalProductId).
+
+        Parameters
+        ----------
+        signals : typing.Sequence[Signal]
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        BulkSignalsResponse
+            200
+
+        Examples
+        --------
+        import asyncio
+
+        from paid import AsyncPaid, CustomerById, Signal
+
+        client = AsyncPaid(
+            token="YOUR_TOKEN",
+        )
+
+
+        async def main() -> None:
+            await client.signals.create_signals_in_bulk(
+                signals=[
+                    Signal(
+                        event_name="eventName",
+                        customer=CustomerById(
+                            customer_id="customerId",
+                        ),
+                    )
+                ],
+            )
+
+
+        asyncio.run(main())
+        """
+        _response = await self._raw_client.create_signals_in_bulk(signals=signals, request_options=request_options)
+        return _response.data

paid/signals/raw_client.py

@@ -0,0 +1,190 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+from json.decoder import JSONDecodeError
+
+from ..core.api_error import ApiError
+from ..core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
+from ..core.http_response import AsyncHttpResponse, HttpResponse
+from ..core.pydantic_utilities import parse_obj_as
+from ..core.request_options import RequestOptions
+from ..core.serialization import convert_and_respect_annotation_metadata
+from ..errors.bad_request_error import BadRequestError
+from ..errors.forbidden_error import ForbiddenError
+from ..errors.internal_server_error import InternalServerError
+from ..types.bulk_signals_response import BulkSignalsResponse
+from ..types.error_response import ErrorResponse
+from ..types.signal import Signal
+
+# this is used as the default value for optional parameters
+OMIT = typing.cast(typing.Any, ...)
+
+
+class RawSignalsClient:
+    def __init__(self, *, client_wrapper: SyncClientWrapper):
+        self._client_wrapper = client_wrapper
+
+    def create_signals_in_bulk(
+        self, *, signals: typing.Sequence[Signal], request_options: typing.Optional[RequestOptions] = None
+    ) -> HttpResponse[BulkSignalsResponse]:
+        """
+        Create multiple signals (usage events) in a single request. Each signal must include a customer attribution (either customerId or externalCustomerId) and a product attribution (either productId or externalProductId).
+
+        Parameters
+        ----------
+        signals : typing.Sequence[Signal]
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        HttpResponse[BulkSignalsResponse]
+            200
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "signals/bulk",
+            method="POST",
+            json={
+                "signals": convert_and_respect_annotation_metadata(
+                    object_=signals, annotation=typing.Sequence[Signal], direction="write"
+                ),
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    BulkSignalsResponse,
+                    parse_obj_as(
+                        type_=BulkSignalsResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return HttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ErrorResponse,
+                        parse_obj_as(
+                            type_=ErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 403:
+                raise ForbiddenError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ErrorResponse,
+                        parse_obj_as(
+                            type_=ErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 500:
+                raise InternalServerError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ErrorResponse,
+                        parse_obj_as(
+                            type_=ErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+
+class AsyncRawSignalsClient:
+    def __init__(self, *, client_wrapper: AsyncClientWrapper):
+        self._client_wrapper = client_wrapper
+
+    async def create_signals_in_bulk(
+        self, *, signals: typing.Sequence[Signal], request_options: typing.Optional[RequestOptions] = None
+    ) -> AsyncHttpResponse[BulkSignalsResponse]:
+        """
+        Create multiple signals (usage events) in a single request. Each signal must include a customer attribution (either customerId or externalCustomerId) and a product attribution (either productId or externalProductId).
+
+        Parameters
+        ----------
+        signals : typing.Sequence[Signal]
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[BulkSignalsResponse]
+            200
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "signals/bulk",
+            method="POST",
+            json={
+                "signals": convert_and_respect_annotation_metadata(
+                    object_=signals, annotation=typing.Sequence[Signal], direction="write"
+                ),
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    BulkSignalsResponse,
+                    parse_obj_as(
+                        type_=BulkSignalsResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return AsyncHttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ErrorResponse,
+                        parse_obj_as(
+                            type_=ErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 403:
+                raise ForbiddenError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ErrorResponse,
+                        parse_obj_as(
+                            type_=ErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 500:
+                raise InternalServerError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ErrorResponse,
+                        parse_obj_as(
+                            type_=ErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)

paid/tracing/autoinstrumentation.py

@@ -18,42 +18,48 @@ try:
     from opentelemetry.instrumentation.anthropic import AnthropicInstrumentor
 
     ANTHROPIC_AVAILABLE = True
-except ImportError:
+except Exception:
+    logger.debug("Anthropic instrumentation library not available, skipping instrumentation")
     ANTHROPIC_AVAILABLE = False
 
 try:
     from opentelemetry.instrumentation.openai import OpenAIInstrumentor
 
     OPENAI_AVAILABLE = True
-except ImportError:
+except Exception:
+    logger.debug("OpenAI instrumentation library not available, skipping instrumentation")
     OPENAI_AVAILABLE = False
 
 try:
     from openinference.instrumentation.openai_agents import OpenAIAgentsInstrumentor
 
     OPENAI_AGENTS_AVAILABLE = True
-except ImportError:
+except Exception:
+    logger.debug("OpenAI Agents instrumentation library not available, skipping instrumentation")
     OPENAI_AGENTS_AVAILABLE = False
 
 try:
     from openinference.instrumentation.bedrock import BedrockInstrumentor
 
     BEDROCK_AVAILABLE = True
-except ImportError:
+except Exception:
+    logger.debug("Bedrock instrumentation library not available, skipping instrumentation")
     BEDROCK_AVAILABLE = False
 
 try:
     from openinference.instrumentation.langchain import LangChainInstrumentor
 
     LANGCHAIN_AVAILABLE = True
-except ImportError:
+except Exception:
+    logger.debug("LangChain instrumentation library not available, skipping instrumentation")
     LANGCHAIN_AVAILABLE = False
 
 try:
     from openinference.instrumentation.google_genai import GoogleGenAIInstrumentor
 
     GOOGLE_GENAI_AVAILABLE = True
-except ImportError:
+except Exception:
+    logger.debug("Google GenAI instrumentation library not available, skipping instrumentation")
     GOOGLE_GENAI_AVAILABLE = False
 
 

paid/tracing/context_manager.py

@@ -25,9 +25,6 @@ class paid_tracing:
         The external customer ID to associate with the trace.
     external_product_id : Optional[str], optional
         The external product ID to associate with the trace, by default None.
-    external_agent_id : Optional[str], optional
-        **Deprecated.** Use external_product_id instead. The external agent ID to associate
-        with the trace, by default None.
     tracing_token : Optional[int], optional
         Optional tracing token for distributed tracing, by default None.
     store_prompt : bool, optional
@@ -68,15 +65,14 @@ class paid_tracing:
         external_customer_id: Optional[str] = None,
         *,
         external_product_id: Optional[str] = None,
-        external_agent_id: Optional[str] = None,
         tracing_token: Optional[int] = None,
         store_prompt: bool = False,
         collector_endpoint: Optional[str] = tracing.DEFAULT_COLLECTOR_ENDPOINT,
         metadata: Optional[Dict[str, Any]] = None,
     ):
         self.external_customer_id = external_customer_id
-        # external_product_id overrides external_agent_id for backwards compatibility
-        self.external_agent_id = external_product_id if external_product_id else external_agent_id
+        # Map external_product_id to external_agent_id for internal context
+        self.external_agent_id = external_product_id
         self.tracing_token = tracing_token
         self.store_prompt = store_prompt
         self.collector_endpoint = collector_endpoint

paid/tracing/distributed_tracing.py

@@ -35,7 +35,7 @@ def generate_tracing_token() -> int:
             token = load_from_database("task_123")
             set_tracing_token(token)
 
-            @paid_tracing(external_customer_id="cust_123", external_agent_id="agent_456")
+            @paid_tracing(external_customer_id="cust_123", external_product_id="product_456")
             def process_task():
                 # This trace is now linked to the same token
                 pass
@@ -56,7 +56,7 @@ def set_tracing_token(token: int):
     Instead of:
         token = load_from_storage("workflow_123")
         set_tracing_token(token)
-        @paid_tracing(external_customer_id="cust_123", external_agent_id="agent_456")
+        @paid_tracing(external_customer_id="cust_123", external_product_id="product_456")
         def process_workflow():
             ...
         unset_tracing_token()
@@ -66,7 +66,7 @@ def set_tracing_token(token: int):
 
         @paid_tracing(
             external_customer_id="cust_123",
-            external_agent_id="agent_456",
+            external_product_id="product_456",
             tracing_token=token
         )
         def process_workflow():

paid/tracing/signal.py

@@ -37,21 +37,21 @@ def signal(event_name: str, enable_cost_tracing: bool = False, data: typing.Opti
 
         from paid.tracing import paid_tracing, signal
 
-        @paid_tracing(external_customer_id="cust_123", external_agent_id="agent_456")
+        @paid_tracing(external_customer_id="cust_123", external_product_id="product_456")
         def process_order(order_id):
             # ... do work ...
             signal("order_processed", data={"order_id": order_id})
 
     Signal with cost tracking:
 
-        @paid_tracing(external_customer_id="cust_123", external_agent_id="agent_456")
+        @paid_tracing(external_customer_id="cust_123", external_product_id="product_456")
         def call_ai_api():
             # ... call AI provider ...
             signal("ai_api_call_complete", enable_cost_tracing=True)
 
     Using context manager:
 
-        with paid_tracing(external_customer_id="cust_123", external_agent_id="agent_456"):
+        with paid_tracing(external_customer_id="cust_123", external_product_id="product_456"):
             # ... do work ...
             signal("milestone_reached", data={"step": "validation_complete"})
     """

paid/tracing/wrappers/openai_agents/openaiAgentsHook.py

@@ -36,7 +36,7 @@ class PaidOpenAIAgentsHook(RunHooks[Any]):
             user_hooks: Optional user-provided RunHooks to combine with Paid tracking
 
         Usage:
-            @paid_tracing("<ext_customer_id>", "<ext_agent_id>")
+            @paid_tracing("<ext_customer_id>", external_product_id="<ext_product_id>")
             def run_agent():
                 hook = PaidAgentsHook()
                 return Runner.run_streamed(agent, input, hooks=hook)

paid/types/__init__.py

@@ -2,104 +2,80 @@
 
 # isort: skip_file
 
-from .address import Address
-from .agent import Agent
-from .agent_attribute import AgentAttribute
-from .agent_price_point import AgentPricePoint
-from .agent_price_point_tiers import AgentPricePointTiers
-from .agent_update import AgentUpdate
-from .api_error import ApiError
-from .billing_frequency import BillingFrequency
-from .charge_type import ChargeType
+from .attribution import Attribution
+from .bulk_signals_response import BulkSignalsResponse
 from .contact import Contact
-from .cost_amount import CostAmount
-from .cost_trace import CostTrace
-from .cost_traces_response import CostTracesResponse
-from .creation_source import CreationSource
-from .creation_state import CreationState
+from .contact_billing_address import ContactBillingAddress
+from .contact_list_response import ContactListResponse
 from .customer import Customer
-from .customer_update import CustomerUpdate
-from .entitlement_usage import EntitlementUsage
-from .error import Error
+from .customer_attribution import CustomerAttribution
+from .customer_billing_address import CustomerBillingAddress
+from .customer_by_external_id import CustomerByExternalId
+from .customer_by_id import CustomerById
+from .customer_creation_state import CustomerCreationState
+from .customer_list_response import CustomerListResponse
+from .empty_response import EmptyResponse
+from .error_response import ErrorResponse
+from .invoice import Invoice
+from .invoice_line import InvoiceLine
+from .invoice_line_payment_status import InvoiceLinePaymentStatus
+from .invoice_lines_response import InvoiceLinesResponse
+from .invoice_list_response import InvoiceListResponse
+from .invoice_payment_status import InvoicePaymentStatus
+from .invoice_source import InvoiceSource
+from .invoice_status import InvoiceStatus
+from .invoice_tax_status import InvoiceTaxStatus
 from .order import Order
+from .order_creation_state import OrderCreationState
 from .order_line import OrderLine
-from .order_line_attribute import OrderLineAttribute
-from .order_line_attribute_create_one import OrderLineAttributeCreateOne
-from .order_line_attribute_pricing import OrderLineAttributePricing
-from .order_line_create import OrderLineCreate
-from .pagination_meta import PaginationMeta
-from .plan import Plan
-from .plan_group import PlanGroup
-from .plan_plan_products_item import PlanPlanProductsItem
-from .plan_plan_products_item_plan_product_attribute_item import PlanPlanProductsItemPlanProductAttributeItem
-from .price_point import PricePoint
-from .pricing import Pricing
-from .pricing_model_type import PricingModelType
+from .order_lines_response import OrderLinesResponse
+from .order_list_response import OrderListResponse
+from .pagination import Pagination
 from .product import Product
-from .product_type import ProductType
-from .product_update import ProductUpdate
-from .product_update_type import ProductUpdateType
-from .salutation import Salutation
+from .product_by_external_id import ProductByExternalId
+from .product_by_id import ProductById
+from .product_list_response import ProductListResponse
 from .signal import Signal
-from .signal_v_2 import SignalV2
-from .tax_exempt_status import TaxExemptStatus
-from .tier import Tier
-from .trace import Trace
-from .traces_response import TracesResponse
-from .usage_pagination_meta import UsagePaginationMeta
-from .usage_summaries_response import UsageSummariesResponse
-from .usage_summary import UsageSummary
-from .usage_summary_order import UsageSummaryOrder
-from .usage_summary_order_line import UsageSummaryOrderLine
+from .update_contact_request import UpdateContactRequest
+from .update_customer_request import UpdateCustomerRequest
+from .update_product_request import UpdateProductRequest
 
 __all__ = [
-    "Address",
-    "Agent",
-    "AgentAttribute",
-    "AgentPricePoint",
-    "AgentPricePointTiers",
-    "AgentUpdate",
-    "ApiError",
-    "BillingFrequency",
-    "ChargeType",
+    "Attribution",
+    "BulkSignalsResponse",
     "Contact",
-    "CostAmount",
-    "CostTrace",
-    "CostTracesResponse",
-    "CreationSource",
-    "CreationState",
+    "ContactBillingAddress",
+    "ContactListResponse",
     "Customer",
-    "CustomerUpdate",
-    "EntitlementUsage",
-    "Error",
+    "CustomerAttribution",
+    "CustomerBillingAddress",
+    "CustomerByExternalId",
+    "CustomerById",
+    "CustomerCreationState",
+    "CustomerListResponse",
+    "EmptyResponse",
+    "ErrorResponse",
+    "Invoice",
+    "InvoiceLine",
+    "InvoiceLinePaymentStatus",
+    "InvoiceLinesResponse",
+    "InvoiceListResponse",
+    "InvoicePaymentStatus",
+    "InvoiceSource",
+    "InvoiceStatus",
+    "InvoiceTaxStatus",
     "Order",
+    "OrderCreationState",
     "OrderLine",
-    "OrderLineAttribute",
-    "OrderLineAttributeCreateOne",
-    "OrderLineAttributePricing",
-    "OrderLineCreate",
-    "PaginationMeta",
-    "Plan",
-    "PlanGroup",
-    "PlanPlanProductsItem",
-    "PlanPlanProductsItemPlanProductAttributeItem",
-    "PricePoint",
-    "Pricing",
-    "PricingModelType",
+    "OrderLinesResponse",
+    "OrderListResponse",
+    "Pagination",
     "Product",
-    "ProductType",
-    "ProductUpdate",
-    "ProductUpdateType",
-    "Salutation",
+    "ProductByExternalId",
+    "ProductById",
+    "ProductListResponse",
     "Signal",
-    "SignalV2",
-    "TaxExemptStatus",
-    "Tier",
-    "Trace",
-    "TracesResponse",
-    "UsagePaginationMeta",
-    "UsageSummariesResponse",
-    "UsageSummary",
-    "UsageSummaryOrder",
-    "UsageSummaryOrderLine",
+    "UpdateContactRequest",
+    "UpdateCustomerRequest",
+    "UpdateProductRequest",
 ]

paid/types/attribution.py

@@ -0,0 +1,8 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+from .product_by_external_id import ProductByExternalId
+from .product_by_id import ProductById
+
+Attribution = typing.Union[ProductById, ProductByExternalId]

paid/types/{agent_attribute.py → bulk_signals_response.py}

@@ -4,13 +4,12 @@ import typing
 
 import pydantic
 from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
-from .pricing import Pricing
 
 
-class AgentAttribute(UniversalBaseModel):
-    name: str
-    active: bool
-    pricing: Pricing
+class BulkSignalsResponse(UniversalBaseModel):
+    ingested: int
+    duplicates: int
+    failed: int
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2