gr4vy 1.10.12__py3-none-any.whl → 1.10.14__py3-none-any.whl

gr4vy/models/shippingdetailsupdate.py

@@ -38,42 +38,29 @@ class ShippingDetailsUpdate(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = [
-            "first_name",
-            "last_name",
-            "email_address",
-            "phone_number",
-            "address",
-        ]
-        nullable_fields = [
-            "first_name",
-            "last_name",
-            "email_address",
-            "phone_number",
-            "address",
-        ]
-        null_default_fields = []
-
+        optional_fields = set(
+            ["first_name", "last_name", "email_address", "phone_number", "address"]
+        )
+        nullable_fields = set(
+            ["first_name", "last_name", "email_address", "phone_number", "address"]
+        )
         serialized = handler(self)
-
         m = {}
 
         for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
-            serialized.pop(k, None)
-
-            optional_nullable = k in optional_fields and k in nullable_fields
-            is_set = (
-                self.__pydantic_fields_set__.intersection({n})
-                or k in null_default_fields
-            )  # pylint: disable=no-member
-
-            if val is not None and val != UNSET_SENTINEL:
-                m[k] = val
-            elif val != UNSET_SENTINEL and (
-                not k in optional_fields or (optional_nullable and is_set)
-            ):
-                m[k] = val
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
 
         return m

gr4vy/models/statementdescriptor.py

@@ -51,46 +51,45 @@ class StatementDescriptor(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = [
-            "name",
-            "description",
-            "city",
-            "country",
-            "phone_number",
-            "url",
-            "postal_code",
-        ]
-        nullable_fields = [
-            "name",
-            "description",
-            "city",
-            "country",
-            "phone_number",
-            "url",
-            "postal_code",
-        ]
-        null_default_fields = []
-
+        optional_fields = set(
+            [
+                "name",
+                "description",
+                "city",
+                "country",
+                "phone_number",
+                "url",
+                "postal_code",
+            ]
+        )
+        nullable_fields = set(
+            [
+                "name",
+                "description",
+                "city",
+                "country",
+                "phone_number",
+                "url",
+                "postal_code",
+            ]
+        )
         serialized = handler(self)
-
         m = {}
 
         for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
-            serialized.pop(k, None)
-
-            optional_nullable = k in optional_fields and k in nullable_fields
-            is_set = (
-                self.__pydantic_fields_set__.intersection({n})
-                or k in null_default_fields
-            )  # pylint: disable=no-member
-
-            if val is not None and val != UNSET_SENTINEL:
-                m[k] = val
-            elif val != UNSET_SENTINEL and (
-                not k in optional_fields or (optional_nullable and is_set)
-            ):
-                m[k] = val
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
 
         return m

gr4vy/models/stripeconnectoptions.py

@@ -37,42 +37,41 @@ class StripeConnectOptions(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = [
-            "stripe_account",
-            "application_fee_amount",
-            "on_behalf_of",
-            "transfer_data_destination",
-            "transfer_group",
-        ]
-        nullable_fields = [
-            "stripe_account",
-            "application_fee_amount",
-            "on_behalf_of",
-            "transfer_data_destination",
-            "transfer_group",
-        ]
-        null_default_fields = []
-
+        optional_fields = set(
+            [
+                "stripe_account",
+                "application_fee_amount",
+                "on_behalf_of",
+                "transfer_data_destination",
+                "transfer_group",
+            ]
+        )
+        nullable_fields = set(
+            [
+                "stripe_account",
+                "application_fee_amount",
+                "on_behalf_of",
+                "transfer_data_destination",
+                "transfer_group",
+            ]
+        )
         serialized = handler(self)
-
         m = {}
 
         for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
-            serialized.pop(k, None)
-
-            optional_nullable = k in optional_fields and k in nullable_fields
-            is_set = (
-                self.__pydantic_fields_set__.intersection({n})
-                or k in null_default_fields
-            )  # pylint: disable=no-member
-
-            if val is not None and val != UNSET_SENTINEL:
-                m[k] = val
-            elif val != UNSET_SENTINEL and (
-                not k in optional_fields or (optional_nullable and is_set)
-            ):
-                m[k] = val
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
 
         return m

gr4vy/models/stripeoptions.py

@@ -23,30 +23,25 @@ class StripeOptions(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["error_on_requires_action", "stripe_connect"]
-        nullable_fields = ["error_on_requires_action", "stripe_connect"]
-        null_default_fields = []
-
+        optional_fields = set(["error_on_requires_action", "stripe_connect"])
+        nullable_fields = set(["error_on_requires_action", "stripe_connect"])
         serialized = handler(self)
-
         m = {}
 
         for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
-            serialized.pop(k, None)
-
-            optional_nullable = k in optional_fields and k in nullable_fields
-            is_set = (
-                self.__pydantic_fields_set__.intersection({n})
-                or k in null_default_fields
-            )  # pylint: disable=no-member
-
-            if val is not None and val != UNSET_SENTINEL:
-                m[k] = val
-            elif val != UNSET_SENTINEL and (
-                not k in optional_fields or (optional_nullable and is_set)
-            ):
-                m[k] = val
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
 
         return m

gr4vy/models/suspend_payment_method_network_tokenop.py

@@ -1,9 +1,10 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from gr4vy.types import BaseModel
+from gr4vy.types import BaseModel, UNSET_SENTINEL
 from gr4vy.utils import FieldMetadata, HeaderMetadata, PathParamMetadata
 import pydantic
+from pydantic import model_serializer
 from typing import Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
@@ -21,6 +22,22 @@ class SuspendPaymentMethodNetworkTokenGlobals(BaseModel):
     ] = None
     r"""The ID of the merchant account to use for this request."""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["merchant_account_id"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 class SuspendPaymentMethodNetworkTokenRequestTypedDict(TypedDict):
     payment_method_id: str
@@ -48,3 +65,19 @@ class SuspendPaymentMethodNetworkTokenRequest(BaseModel):
         FieldMetadata(header=HeaderMetadata(style="simple", explode=False)),
     ] = None
     r"""The ID of the merchant account to use for this request."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["merchant_account_id"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m

gr4vy/models/sync_transactionop.py

@@ -1,9 +1,10 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from gr4vy.types import BaseModel
+from gr4vy.types import BaseModel, UNSET_SENTINEL
 from gr4vy.utils import FieldMetadata, HeaderMetadata, PathParamMetadata
 import pydantic
+from pydantic import model_serializer
 from typing import Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
@@ -21,6 +22,22 @@ class SyncTransactionGlobals(BaseModel):
     ] = None
     r"""The ID of the merchant account to use for this request."""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["merchant_account_id"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 class SyncTransactionRequestTypedDict(TypedDict):
     transaction_id: str
@@ -39,3 +56,19 @@ class SyncTransactionRequest(BaseModel):
         FieldMetadata(header=HeaderMetadata(style="simple", explode=False)),
     ] = None
     r"""The ID of the merchant account to use for this request."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["merchant_account_id"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m

gr4vy/models/threedsecure.py

@@ -17,30 +17,25 @@ class ThreeDSecure(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["amount"]
-        nullable_fields = ["amount"]
-        null_default_fields = []
-
+        optional_fields = set(["amount"])
+        nullable_fields = set(["amount"])
         serialized = handler(self)
-
         m = {}
 
         for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
-            serialized.pop(k, None)
-
-            optional_nullable = k in optional_fields and k in nullable_fields
-            is_set = (
-                self.__pydantic_fields_set__.intersection({n})
-                or k in null_default_fields
-            )  # pylint: disable=no-member
-
-            if val is not None and val != UNSET_SENTINEL:
-                m[k] = val
-            elif val != UNSET_SENTINEL and (
-                not k in optional_fields or (optional_nullable and is_set)
-            ):
-                m[k] = val
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
 
         return m

gr4vy/models/threedsecuredatav1.py

@@ -53,30 +53,25 @@ class ThreeDSecureDataV1(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["scheme"]
-        nullable_fields = ["scheme"]
-        null_default_fields = []
-
+        optional_fields = set(["scheme"])
+        nullable_fields = set(["scheme"])
         serialized = handler(self)
-
         m = {}
 
         for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
-            serialized.pop(k, None)
-
-            optional_nullable = k in optional_fields and k in nullable_fields
-            is_set = (
-                self.__pydantic_fields_set__.intersection({n})
-                or k in null_default_fields
-            )  # pylint: disable=no-member
-
-            if val is not None and val != UNSET_SENTINEL:
-                m[k] = val
-            elif val != UNSET_SENTINEL and (
-                not k in optional_fields or (optional_nullable and is_set)
-            ):
-                m[k] = val
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
 
         return m

gr4vy/models/threedsecuredatav2.py

@@ -48,30 +48,25 @@ class ThreeDSecureDataV2(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["scheme", "authentication_response"]
-        nullable_fields = ["scheme", "authentication_response"]
-        null_default_fields = []
-
+        optional_fields = set(["scheme", "authentication_response"])
+        nullable_fields = set(["scheme", "authentication_response"])
         serialized = handler(self)
-
         m = {}
 
         for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
-            serialized.pop(k, None)
-
-            optional_nullable = k in optional_fields and k in nullable_fields
-            is_set = (
-                self.__pydantic_fields_set__.intersection({n})
-                or k in null_default_fields
-            )  # pylint: disable=no-member
-
-            if val is not None and val != UNSET_SENTINEL:
-                m[k] = val
-            elif val != UNSET_SENTINEL and (
-                not k in optional_fields or (optional_nullable and is_set)
-            ):
-                m[k] = val
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
 
         return m

gr4vy/models/threedsecureerror.py

@@ -32,30 +32,25 @@ class ThreeDSecureError(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["code", "description", "detail", "component"]
-        nullable_fields = ["code", "description", "detail", "component"]
-        null_default_fields = []
-
+        optional_fields = set(["code", "description", "detail", "component"])
+        nullable_fields = set(["code", "description", "detail", "component"])
         serialized = handler(self)
-
         m = {}
 
         for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
-            serialized.pop(k, None)
-
-            optional_nullable = k in optional_fields and k in nullable_fields
-            is_set = (
-                self.__pydantic_fields_set__.intersection({n})
-                or k in null_default_fields
-            )  # pylint: disable=no-member
-
-            if val is not None and val != UNSET_SENTINEL:
-                m[k] = val
-            elif val != UNSET_SENTINEL and (
-                not k in optional_fields or (optional_nullable and is_set)
-            ):
-                m[k] = val
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
 
         return m

gr4vy/models/threedsecurescenario.py

@@ -0,0 +1,77 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .threedsecurescenarioconditions import (
+    ThreeDSecureScenarioConditions,
+    ThreeDSecureScenarioConditionsTypedDict,
+)
+from .threedsecurescenariooutcome import (
+    ThreeDSecureScenarioOutcome,
+    ThreeDSecureScenarioOutcomeTypedDict,
+)
+from datetime import datetime
+from gr4vy.types import BaseModel, UNSET_SENTINEL
+from gr4vy.utils import validate_const
+import pydantic
+from pydantic import model_serializer
+from pydantic.functional_validators import AfterValidator
+from typing import Literal, Optional
+from typing_extensions import Annotated, TypedDict
+
+
+class ThreeDSecureScenarioTypedDict(TypedDict):
+    id: str
+    r"""Unique identifier for the 3DS scenario"""
+    merchant_account_id: str
+    r"""ID of the associated merchant account"""
+    created_at: datetime
+    r"""The date and time when this 3DS scenario was first created in our system."""
+    updated_at: datetime
+    r"""The date and time when this 3DS scenario was last updated in our system."""
+    conditions: ThreeDSecureScenarioConditionsTypedDict
+    outcome: ThreeDSecureScenarioOutcomeTypedDict
+    type: Literal["three-d-secure-scenario"]
+    r"""Always `three-d-secure-scenario`."""
+
+
+class ThreeDSecureScenario(BaseModel):
+    id: str
+    r"""Unique identifier for the 3DS scenario"""
+
+    merchant_account_id: str
+    r"""ID of the associated merchant account"""
+
+    created_at: datetime
+    r"""The date and time when this 3DS scenario was first created in our system."""
+
+    updated_at: datetime
+    r"""The date and time when this 3DS scenario was last updated in our system."""
+
+    conditions: ThreeDSecureScenarioConditions
+
+    outcome: ThreeDSecureScenarioOutcome
+
+    TYPE: Annotated[
+        Annotated[
+            Optional[Literal["three-d-secure-scenario"]],
+            AfterValidator(validate_const("three-d-secure-scenario")),
+        ],
+        pydantic.Field(alias="type"),
+    ] = "three-d-secure-scenario"
+    r"""Always `three-d-secure-scenario`."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["type"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m