gr4vy 1.10.8__py3-none-any.whl → 1.10.10__py3-none-any.whl

gr4vy/models/transactioncreate.py

@@ -69,11 +69,9 @@ from .transactionconnectionoptions import (
 from .transactionintent import TransactionIntent
 from .transactionpaymentsource import TransactionPaymentSource
 from gr4vy.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
-from gr4vy.utils import validate_open_enum
 from pydantic import model_serializer
-from pydantic.functional_validators import PlainValidator
 from typing import Dict, List, Optional, Union
-from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+from typing_extensions import NotRequired, TypeAliasType, TypedDict
 
 
 TransactionCreatePaymentMethodTypedDict = TypeAliasType(
@@ -267,9 +265,7 @@ class TransactionCreate(BaseModel):
     external_identifier: OptionalNullable[str] = UNSET
     r"""An external identifier that can be used to match the transaction against your own records."""
 
-    intent: Annotated[
-        Optional[TransactionIntent], PlainValidator(validate_open_enum(False))
-    ] = None
+    intent: Optional[TransactionIntent] = None
 
     store: Optional[bool] = False
     r"""Whether or not to also try and store the payment method with us so that it can be used again for future use. This is only supported for payment methods that support this feature. There are also a few restrictions on how the flag may be set:
@@ -301,9 +297,7 @@ class TransactionCreate(BaseModel):
     merchant_initiated: Optional[bool] = False
     r"""Indicates whether the transaction was initiated by the merchant (true) or customer (false)."""
 
-    payment_source: Annotated[
-        Optional[TransactionPaymentSource], PlainValidator(validate_open_enum(False))
-    ] = None
+    payment_source: Optional[TransactionPaymentSource] = None
     r"""The way payment method information made it to this transaction."""
 
     airline: OptionalNullable[Airline] = UNSET
@@ -378,9 +372,7 @@ class TransactionCreate(BaseModel):
     shipping_amount: OptionalNullable[int] = UNSET
     r"""Total shipping amount."""
 
-    integration_client: Annotated[
-        OptionalNullable[IntegrationClient], PlainValidator(validate_open_enum(False))
-    ] = UNSET
+    integration_client: OptionalNullable[IntegrationClient] = UNSET
     r"""Defines the client where the session for this transaction is going to be used. Please refer to the connections documentation for more guidance."""
 
     @model_serializer(mode="wrap")

gr4vy/models/transactionevent.py

@@ -3,9 +3,9 @@
 from __future__ import annotations
 from datetime import datetime
 from gr4vy.types import BaseModel, UnrecognizedStr
-from gr4vy.utils import validate_const, validate_open_enum
+from gr4vy.utils import validate_const
 import pydantic
-from pydantic.functional_validators import AfterValidator, PlainValidator
+from pydantic.functional_validators import AfterValidator
 from typing import Any, Dict, Literal, Optional, Union
 from typing_extensions import Annotated, TypedDict
 
@@ -53,6 +53,7 @@ Name = Union[
         "payment-connector-report-transaction-settled",
         "payment-connector-report-chargeback-posted",
         "payment-connector-report-chargeback-reversal-posted",
+        "payment-connector-transaction-webhook-processed",
         "digital-wallet-apple-pay-token-decrypted",
         "digital-wallet-google-pay-token-decrypted",
         "digital-wallet-click-to-pay-token-decrypted",
@@ -85,7 +86,7 @@ class TransactionEvent(BaseModel):
     id: str
     r"""The ID for the event."""
 
-    name: Annotated[Name, PlainValidator(validate_open_enum(False))]
+    name: Name
     r"""The specific event name."""
 
     created_at: datetime

gr4vy/models/transactionpaymentmethod.py

@@ -11,10 +11,10 @@ from .paymentmethoddetailscard import (
 )
 from datetime import datetime
 from gr4vy.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
-from gr4vy.utils import validate_const, validate_open_enum
+from gr4vy.utils import validate_const
 import pydantic
 from pydantic import model_serializer
-from pydantic.functional_validators import AfterValidator, PlainValidator
+from pydantic.functional_validators import AfterValidator
 from typing import Literal, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
@@ -54,7 +54,7 @@ class TransactionPaymentMethodTypedDict(TypedDict):
 
 
 class TransactionPaymentMethod(BaseModel):
-    method: Annotated[Method, PlainValidator(validate_open_enum(False))]
+    method: Method
 
     TYPE: Annotated[
         Annotated[
@@ -89,22 +89,16 @@ class TransactionPaymentMethod(BaseModel):
     last_replaced_at: OptionalNullable[datetime] = UNSET
     r"""The date and time when this card was last replaced by the account updater."""
 
-    mode: Annotated[
-        OptionalNullable[Mode], PlainValidator(validate_open_enum(False))
-    ] = UNSET
+    mode: OptionalNullable[Mode] = UNSET
     r"""The mode to use with this payment method."""
 
-    scheme: Annotated[
-        OptionalNullable[CardScheme], PlainValidator(validate_open_enum(False))
-    ] = UNSET
+    scheme: OptionalNullable[CardScheme] = UNSET
     r"""The scheme of the card. Only applies to card payments."""
 
     id: OptionalNullable[str] = UNSET
     r"""The ID of the payment method."""
 
-    approval_target: Annotated[
-        OptionalNullable[ApprovalTarget], PlainValidator(validate_open_enum(False))
-    ] = UNSET
+    approval_target: OptionalNullable[ApprovalTarget] = UNSET
     r"""The browser target that an approval URL must be opened in. If any or null, then there is no specific requirement."""
 
     external_identifier: OptionalNullable[str] = UNSET

gr4vy/models/transactionpaymentservice.py

@@ -3,9 +3,9 @@
 from __future__ import annotations
 from .method import Method
 from gr4vy.types import BaseModel
-from gr4vy.utils import validate_const, validate_open_enum
+from gr4vy.utils import validate_const
 import pydantic
-from pydantic.functional_validators import AfterValidator, PlainValidator
+from pydantic.functional_validators import AfterValidator
 from typing import Literal, Optional
 from typing_extensions import Annotated, TypedDict
 
@@ -29,7 +29,7 @@ class TransactionPaymentService(BaseModel):
     payment_service_definition_id: str
     r"""The definition ID of the service used to process this payment."""
 
-    method: Annotated[Method, PlainValidator(validate_open_enum(False))]
+    method: Method
 
     display_name: str
     r"""The display name for the payment service."""

gr4vy/models/transactionrefundcreate.py

@@ -3,11 +3,9 @@
 from __future__ import annotations
 from .refundtargettype import RefundTargetType
 from gr4vy.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
-from gr4vy.utils import validate_open_enum
 from pydantic import model_serializer
-from pydantic.functional_validators import PlainValidator
 from typing import Optional
-from typing_extensions import Annotated, NotRequired, TypedDict
+from typing_extensions import NotRequired, TypedDict
 
 
 class TransactionRefundCreateTypedDict(TypedDict):
@@ -26,9 +24,7 @@ class TransactionRefundCreate(BaseModel):
     amount: OptionalNullable[int] = UNSET
     r"""The amount to refund, in the smallest currency unit (e.g., cents). If omitted, a full refund will be requested."""
 
-    target_type: Annotated[
-        Optional[RefundTargetType], PlainValidator(validate_open_enum(False))
-    ] = None
+    target_type: Optional[RefundTargetType] = None
 
     target_id: OptionalNullable[str] = UNSET
     r"""The optional ID of the instrument to refund for. This is only required when the `target_type` is set to `gift-card-redemption`."""

gr4vy/models/transactionsummary.py

@@ -19,10 +19,10 @@ from .transactionpaymentservice import (
 from .transactionstatus import TransactionStatus
 from datetime import datetime
 from gr4vy.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
-from gr4vy.utils import validate_const, validate_open_enum
+from gr4vy.utils import validate_const
 import pydantic
 from pydantic import model_serializer
-from pydantic.functional_validators import AfterValidator, PlainValidator
+from pydantic.functional_validators import AfterValidator
 from typing import List, Literal, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
@@ -112,7 +112,7 @@ class TransactionSummary(BaseModel):
     amount: int
     r"""The total amount for this transaction across all funding sources including gift cards."""
 
-    status: Annotated[TransactionStatus, PlainValidator(validate_open_enum(False))]
+    status: TransactionStatus
 
     authorized_amount: int
     r"""The amount for this transaction that has been authorized for the `payment_method`. This can be less than the `amount` if gift cards were used."""
@@ -129,7 +129,7 @@ class TransactionSummary(BaseModel):
     settled: bool
     r"""Indicates whether this transaction has been settled."""
 
-    intent: Annotated[TransactionIntent, PlainValidator(validate_open_enum(False))]
+    intent: TransactionIntent
 
     gift_card_redemptions: List[GiftCardRedemption]
     r"""The gift cards redeemed for this transaction."""
@@ -164,14 +164,10 @@ class TransactionSummary(BaseModel):
     payment_method: OptionalNullable[TransactionPaymentMethod] = UNSET
     r"""The payment method used for this transaction."""
 
-    method: Annotated[
-        OptionalNullable[Method], PlainValidator(validate_open_enum(False))
-    ] = UNSET
+    method: OptionalNullable[Method] = UNSET
     r"""The method used for the transaction."""
 
-    instrument_type: Annotated[
-        OptionalNullable[InstrumentType], PlainValidator(validate_open_enum(False))
-    ] = UNSET
+    instrument_type: OptionalNullable[InstrumentType] = UNSET
     r"""The name of the instrument used to process the transaction."""
 
     error_code: OptionalNullable[str] = UNSET

gr4vy/models/transactionthreedsecuresummary.py

@@ -7,11 +7,9 @@ from .threedsecuremethod import ThreeDSecureMethod
 from .threedsecurestatus import ThreeDSecureStatus
 from .threedsecurev2 import ThreeDSecureV2, ThreeDSecureV2TypedDict
 from gr4vy.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
-from gr4vy.utils import validate_open_enum
 from pydantic import model_serializer
-from pydantic.functional_validators import PlainValidator
 from typing import Union
-from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+from typing_extensions import NotRequired, TypeAliasType, TypedDict
 
 
 ResponseDataTypedDict = TypeAliasType(
@@ -41,14 +39,10 @@ class TransactionThreeDSecureSummary(BaseModel):
     version: OptionalNullable[str] = UNSET
     r"""The version of 3DS used for this transaction."""
 
-    status: Annotated[
-        OptionalNullable[ThreeDSecureStatus], PlainValidator(validate_open_enum(False))
-    ] = UNSET
+    status: OptionalNullable[ThreeDSecureStatus] = UNSET
     r"""The status of the 3DS challenge for this transaction."""
 
-    method: Annotated[
-        OptionalNullable[ThreeDSecureMethod], PlainValidator(validate_open_enum(False))
-    ] = UNSET
+    method: OptionalNullable[ThreeDSecureMethod] = UNSET
     r"""The method used for 3DS authentication for this transaction."""
 
     response_data: OptionalNullable[ResponseData] = UNSET

gr4vy/models/transactionvoid.py

@@ -4,10 +4,10 @@ from __future__ import annotations
 from .transaction import Transaction, TransactionTypedDict
 from .voidstatus import VoidStatus
 from gr4vy.types import BaseModel, Nullable, UNSET_SENTINEL
-from gr4vy.utils import validate_const, validate_open_enum
+from gr4vy.utils import validate_const
 import pydantic
 from pydantic import model_serializer
-from pydantic.functional_validators import AfterValidator, PlainValidator
+from pydantic.functional_validators import AfterValidator
 from typing import Literal, Optional
 from typing_extensions import Annotated, TypedDict
 
@@ -27,7 +27,7 @@ class TransactionVoidTypedDict(TypedDict):
 
 
 class TransactionVoid(BaseModel):
-    status: Annotated[VoidStatus, PlainValidator(validate_open_enum(False))]
+    status: VoidStatus
 
     code: Nullable[str]
     r"""The standardized error code set by Gr4vy."""

gr4vy/models/void_transactionop.py

@@ -4,14 +4,9 @@ from __future__ import annotations
 from .transaction import Transaction, TransactionTypedDict
 from .transactionvoid import TransactionVoid, TransactionVoidTypedDict
 from gr4vy.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
-from gr4vy.utils import (
-    FieldMetadata,
-    HeaderMetadata,
-    PathParamMetadata,
-    get_discriminator,
-)
+from gr4vy.utils import FieldMetadata, HeaderMetadata, PathParamMetadata
 import pydantic
-from pydantic import Discriminator, Tag, model_serializer
+from pydantic import model_serializer
 from typing import List, Optional, Union
 from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
 
@@ -96,22 +91,7 @@ ResponseVoidTransactionTypedDict = TypeAliasType(
 r"""Successful Response"""
 
 
-ResponseVoidTransaction = Annotated[
-    Union[
-        Annotated[Transaction, Tag("processing")],
-        Annotated[Transaction, Tag("authorization_succeeded")],
-        Annotated[Transaction, Tag("authorization_declined")],
-        Annotated[Transaction, Tag("authorization_failed")],
-        Annotated[Transaction, Tag("authorization_voided")],
-        Annotated[Transaction, Tag("authorization_void_pending")],
-        Annotated[Transaction, Tag("capture_succeeded")],
-        Annotated[Transaction, Tag("capture_pending")],
-        Annotated[Transaction, Tag("buyer_approval_pending")],
-        Annotated[TransactionVoid, Tag("succeeded")],
-        Annotated[TransactionVoid, Tag("pending")],
-        Annotated[TransactionVoid, Tag("declined")],
-        Annotated[TransactionVoid, Tag("failed")],
-    ],
-    Discriminator(lambda m: get_discriminator(m, "status", "status")),
-]
+ResponseVoidTransaction = TypeAliasType(
+    "ResponseVoidTransaction", Union[TransactionVoid, Transaction]
+)
 r"""Successful Response"""

gr4vy/payment_links_sdk.py

@@ -50,6 +50,7 @@ class PaymentLinksSDK(BaseSDK):
         payment_source: Optional[models.TransactionPaymentSource] = None,
         store: Optional[bool] = False,
         buyer_id: OptionalNullable[str] = UNSET,
+        installment_count: OptionalNullable[int] = UNSET,
         retries: OptionalNullable[utils.RetryConfig] = UNSET,
         server_url: Optional[str] = None,
         timeout_ms: Optional[int] = None,
@@ -83,6 +84,7 @@ class PaymentLinksSDK(BaseSDK):
         :param payment_source: The way payment method information made it to this transaction.
         :param store: Whether to store the payment method for future use.
         :param buyer_id: The ID of the buyer to associate the payment method with. Note: When `buyer_id` is provided, the payment link should be treated as a secret as it will allow the user to manage payment methods for the associated buyer.
+        :param installment_count: The number of installments a buyer is required to make.
         :param retries: Override the default retry configuration for this method
         :param server_url: Override the default server URL for this method
         :param timeout_ms: Override the default request timeout configuration for this method in milliseconds
@@ -133,6 +135,7 @@ class PaymentLinksSDK(BaseSDK):
                 payment_source=payment_source,
                 store=store,
                 buyer_id=buyer_id,
+                installment_count=installment_count,
             ),
         )
 
@@ -289,6 +292,7 @@ class PaymentLinksSDK(BaseSDK):
         payment_source: Optional[models.TransactionPaymentSource] = None,
         store: Optional[bool] = False,
         buyer_id: OptionalNullable[str] = UNSET,
+        installment_count: OptionalNullable[int] = UNSET,
         retries: OptionalNullable[utils.RetryConfig] = UNSET,
         server_url: Optional[str] = None,
         timeout_ms: Optional[int] = None,
@@ -322,6 +326,7 @@ class PaymentLinksSDK(BaseSDK):
         :param payment_source: The way payment method information made it to this transaction.
         :param store: Whether to store the payment method for future use.
         :param buyer_id: The ID of the buyer to associate the payment method with. Note: When `buyer_id` is provided, the payment link should be treated as a secret as it will allow the user to manage payment methods for the associated buyer.
+        :param installment_count: The number of installments a buyer is required to make.
         :param retries: Override the default retry configuration for this method
         :param server_url: Override the default server URL for this method
         :param timeout_ms: Override the default request timeout configuration for this method in milliseconds
@@ -372,6 +377,7 @@ class PaymentLinksSDK(BaseSDK):
                 payment_source=payment_source,
                 store=store,
                 buyer_id=buyer_id,
+                installment_count=installment_count,
             ),
         )
 

gr4vy/utils/__init__.py

@@ -42,7 +42,6 @@ if TYPE_CHECKING:
         validate_decimal,
         validate_float,
         validate_int,
-        validate_open_enum,
     )
     from .url import generate_url, template_url, remove_suffix
     from .values import (
@@ -104,7 +103,6 @@ __all__ = [
     "validate_const",
     "validate_float",
     "validate_int",
-    "validate_open_enum",
     "cast_partial",
 ]
 
@@ -158,7 +156,6 @@ _dynamic_imports: dict[str, str] = {
     "validate_const": ".serializers",
     "validate_float": ".serializers",
     "validate_int": ".serializers",
-    "validate_open_enum": ".serializers",
     "cast_partial": ".values",
 }
 

gr4vy/utils/enums.py

@@ -2,6 +2,10 @@
 
 import enum
 import sys
+from typing import Any
+
+from pydantic_core import core_schema
+
 
 class OpenEnumMeta(enum.EnumMeta):
     # The __call__ method `boundary` kwarg was added in 3.11 and must be present
@@ -72,3 +76,59 @@ class OpenEnumMeta(enum.EnumMeta):
                 )
             except ValueError:
                 return value
+
+    def __new__(mcs, name, bases, namespace, **kwargs):
+        cls = super().__new__(mcs, name, bases, namespace, **kwargs)
+
+        # Add __get_pydantic_core_schema__ to make open enums work correctly
+        # in union discrimination. In strict mode (used by Pydantic for unions),
+        # only known enum values match. In lax mode, unknown values are accepted.
+        def __get_pydantic_core_schema__(
+            cls_inner: Any, _source_type: Any, _handler: Any
+        ) -> core_schema.CoreSchema:
+            # Create a validator that only accepts known enum values (for strict mode)
+            def validate_strict(v: Any) -> Any:
+                if isinstance(v, cls_inner):
+                    return v
+                # Use the parent EnumMeta's __call__ which raises ValueError for unknown values
+                return enum.EnumMeta.__call__(cls_inner, v)
+
+            # Create a lax validator that accepts unknown values
+            def validate_lax(v: Any) -> Any:
+                if isinstance(v, cls_inner):
+                    return v
+                try:
+                    return enum.EnumMeta.__call__(cls_inner, v)
+                except ValueError:
+                    # Return the raw value for unknown enum values
+                    return v
+
+            # Determine the base type schema (str or int)
+            is_int_enum = False
+            for base in cls_inner.__mro__:
+                if base is int:
+                    is_int_enum = True
+                    break
+                if base is str:
+                    break
+
+            base_schema = (
+                core_schema.int_schema()
+                if is_int_enum
+                else core_schema.str_schema()
+            )
+
+            # Use lax_or_strict_schema:
+            # - strict mode: only known enum values match (raises ValueError for unknown)
+            # - lax mode: accept any value, return enum member or raw value
+            return core_schema.lax_or_strict_schema(
+                lax_schema=core_schema.chain_schema(
+                    [base_schema, core_schema.no_info_plain_validator_function(validate_lax)]
+                ),
+                strict_schema=core_schema.chain_schema(
+                    [base_schema, core_schema.no_info_plain_validator_function(validate_strict)]
+                ),
+            )
+
+        setattr(cls, "__get_pydantic_core_schema__", classmethod(__get_pydantic_core_schema__))
+        return cls

gr4vy/utils/requestbodies.py

@@ -44,15 +44,15 @@ def serialize_request_body(
 
     serialized_request_body = SerializedRequestBody(media_type)
 
-    if re.match(r"(application|text)\/.*?\+*json.*", media_type) is not None:
+    if re.match(r"^(application|text)\/([^+]+\+)*json.*", media_type) is not None:
         serialized_request_body.content = marshal_json(request_body, request_body_type)
-    elif re.match(r"multipart\/.*", media_type) is not None:
+    elif re.match(r"^multipart\/.*", media_type) is not None:
         (
             serialized_request_body.media_type,
             serialized_request_body.data,
             serialized_request_body.files,
         ) = serialize_multipart_form(media_type, request_body)
-    elif re.match(r"application\/x-www-form-urlencoded.*", media_type) is not None:
+    elif re.match(r"^application\/x-www-form-urlencoded.*", media_type) is not None:
         serialized_request_body.data = serialize_form_data(request_body)
     elif isinstance(request_body, (bytes, bytearray, io.BytesIO, io.BufferedReader)):
         serialized_request_body.content = request_body

gr4vy/utils/serializers.py

@@ -102,26 +102,6 @@ def validate_int(b):
     return int(b)
 
 
-def validate_open_enum(is_int: bool):
-    def validate(e):
-        if e is None:
-            return None
-
-        if isinstance(e, Unset):
-            return e
-
-        if is_int:
-            if not isinstance(e, int):
-                raise ValueError("Expected int")
-        else:
-            if not isinstance(e, str):
-                raise ValueError("Expected string")
-
-        return e
-
-    return validate
-
-
 def validate_const(v):
     def validate(c):
         # Optional[T] is a Union[T, None]

{gr4vy-1.10.8.dist-info → gr4vy-1.10.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gr4vy
-Version: 1.10.8
+Version: 1.10.10
 Summary: Python Client SDK Generated by Speakeasy.
 Author: Gr4vy
 Requires-Python: >=3.9.2