Skip to content

Simulations Pydantic Models

In order to simplify and standardize the data that is passed between the client and the Revolut Business API, PyRevolut uses Pydantic models to define the structure of the data. Below are the Pydantic models used by the Simulations endpoint.

SimulateAccountTopup

Simulate a top-up of your account in the Sandbox environment.

This is useful during testing, when you run out of money in your test account and need to add more.

Source code in pyrevolut/api/simulations/post/simulate_account_topup.py 
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
class SimulateAccountTopup:
    """
    Simulate a top-up of your account in the Sandbox environment.

    This is useful during testing, when you run out of money in your test account
    and need to add more.
    """

    ROUTE = "/1.0/sandbox/topup"

    class Body(BaseModel):
        """
        The body of the request.
        """

        account_id: Annotated[
            UUID,
            Field(description="The ID of the account that you want to top up."),
        ]
        amount: Annotated[
            float,
            Field(
                description="The amount with which you want to top up the account. Must be <= 10000",
                gt=0,
                le=10000,
            ),
        ]
        currency: Annotated[
            Currency,
            Field(
                description="The currency of the top-up amount. Must be a valid ISO 4217 currency code.",
            ),
        ]
        reference: Annotated[
            str | None,
            Field(
                description="""
                A short description for your top up.
                Default value: 'Test Top-up' if not provided.
                """,
            ),
        ] = None
        state: Annotated[
            EnumTransactionState | None,
            Field(
                description="""
                The state to which you want to set the top-up transaction. 

                If not provided, the default value is 'completed'.

                Possible values:

                    pending:
                        The transaction is pending until it's being processed.
                        If the transfer is made between Revolut accounts,
                        this state is skipped and the transaction is executed instantly.
                    completed:
                        The transaction was successful.
                    failed:
                        The transaction was unsuccessful. This can happen for a variety of reasons,
                        for example, invalid API calls, blocked payments, etc.
                    reverted:
                        The transaction was reverted. This can happen for a variety of reasons,
                        for example, the receiver being inaccessible.
                """
            ),
        ] = None

        @model_validator(mode="after")
        def check_inputs(self) -> "SimulateAccountTopup.Body":
            """
            Check that the input is correct.
            """

            if self.state is not None:
                assert self.state in [
                    EnumTransactionState.PENDING,
                    EnumTransactionState.COMPLETED,
                    EnumTransactionState.FAILED,
                    EnumTransactionState.REVERTED,
                ], (
                    f"Invalid state: {self.state}. "
                    f"Possible values: {EnumTransactionState.PENDING}, "
                    f"{EnumTransactionState.COMPLETED}, {EnumTransactionState.FAILED}, "
                    f"{EnumTransactionState.REVERTED}."
                )
            return self

    class Response(BaseModel):
        """
        The response model.
        """

        id: Annotated[
            UUID, Field(description="The ID of the account that was topped up.")
        ]
        state: Annotated[
            EnumTransactionState,
            Field(
                description="""
                The state of the top-up transaction. Possible values:

                pending:
                    The transaction is pending until it's being processed.
                    If the transfer is made between Revolut accounts,
                    this state is skipped and the transaction is executed instantly.
                completed:
                    The transaction was successful.
                failed:
                    The transaction was unsuccessful. This can happen for a variety of reasons,
                    for example, invalid API calls, blocked payments, etc.
                reverted:
                    The transaction was reverted. This can happen for a variety of reasons,
                    for example, the receiver being inaccessible.
                """
            ),
        ]
        created_at: Annotated[
            DateTime,
            Field(
                description="The date and time the transaction was created in ISO 8601 format."
            ),
        ]
        completed_at: Annotated[
            DateTime | None,
            Field(
                description="The date and time the transaction was completed in ISO 8601 format."
            ),
        ] = None

Body

Bases: BaseModel

The body of the request.

Source code in pyrevolut/api/simulations/post/simulate_account_topup.py 
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
class Body(BaseModel):
    """
    The body of the request.
    """

    account_id: Annotated[
        UUID,
        Field(description="The ID of the account that you want to top up."),
    ]
    amount: Annotated[
        float,
        Field(
            description="The amount with which you want to top up the account. Must be <= 10000",
            gt=0,
            le=10000,
        ),
    ]
    currency: Annotated[
        Currency,
        Field(
            description="The currency of the top-up amount. Must be a valid ISO 4217 currency code.",
        ),
    ]
    reference: Annotated[
        str | None,
        Field(
            description="""
            A short description for your top up.
            Default value: 'Test Top-up' if not provided.
            """,
        ),
    ] = None
    state: Annotated[
        EnumTransactionState | None,
        Field(
            description="""
            The state to which you want to set the top-up transaction. 

            If not provided, the default value is 'completed'.

            Possible values:

                pending:
                    The transaction is pending until it's being processed.
                    If the transfer is made between Revolut accounts,
                    this state is skipped and the transaction is executed instantly.
                completed:
                    The transaction was successful.
                failed:
                    The transaction was unsuccessful. This can happen for a variety of reasons,
                    for example, invalid API calls, blocked payments, etc.
                reverted:
                    The transaction was reverted. This can happen for a variety of reasons,
                    for example, the receiver being inaccessible.
            """
        ),
    ] = None

    @model_validator(mode="after")
    def check_inputs(self) -> "SimulateAccountTopup.Body":
        """
        Check that the input is correct.
        """

        if self.state is not None:
            assert self.state in [
                EnumTransactionState.PENDING,
                EnumTransactionState.COMPLETED,
                EnumTransactionState.FAILED,
                EnumTransactionState.REVERTED,
            ], (
                f"Invalid state: {self.state}. "
                f"Possible values: {EnumTransactionState.PENDING}, "
                f"{EnumTransactionState.COMPLETED}, {EnumTransactionState.FAILED}, "
                f"{EnumTransactionState.REVERTED}."
            )
        return self

check_inputs()

Check that the input is correct.

Source code in pyrevolut/api/simulations/post/simulate_account_topup.py 
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
@model_validator(mode="after")
def check_inputs(self) -> "SimulateAccountTopup.Body":
    """
    Check that the input is correct.
    """

    if self.state is not None:
        assert self.state in [
            EnumTransactionState.PENDING,
            EnumTransactionState.COMPLETED,
            EnumTransactionState.FAILED,
            EnumTransactionState.REVERTED,
        ], (
            f"Invalid state: {self.state}. "
            f"Possible values: {EnumTransactionState.PENDING}, "
            f"{EnumTransactionState.COMPLETED}, {EnumTransactionState.FAILED}, "
            f"{EnumTransactionState.REVERTED}."
        )
    return self

Response

Bases: BaseModel

The response model.

Source code in pyrevolut/api/simulations/post/simulate_account_topup.py 
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
class Response(BaseModel):
    """
    The response model.
    """

    id: Annotated[
        UUID, Field(description="The ID of the account that was topped up.")
    ]
    state: Annotated[
        EnumTransactionState,
        Field(
            description="""
            The state of the top-up transaction. Possible values:

            pending:
                The transaction is pending until it's being processed.
                If the transfer is made between Revolut accounts,
                this state is skipped and the transaction is executed instantly.
            completed:
                The transaction was successful.
            failed:
                The transaction was unsuccessful. This can happen for a variety of reasons,
                for example, invalid API calls, blocked payments, etc.
            reverted:
                The transaction was reverted. This can happen for a variety of reasons,
                for example, the receiver being inaccessible.
            """
        ),
    ]
    created_at: Annotated[
        DateTime,
        Field(
            description="The date and time the transaction was created in ISO 8601 format."
        ),
    ]
    completed_at: Annotated[
        DateTime | None,
        Field(
            description="The date and time the transaction was completed in ISO 8601 format."
        ),
    ] = None

SimulateTransferStateUpdate

Simulate a transfer state change in the Sandbox environment.

For example, after you make a transfer in Sandbox, you can change its state to completed.

The resulting state is final and cannot be changed.

Source code in pyrevolut/api/simulations/post/simulate_transfer_state_update.py 
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
class SimulateTransferStateUpdate:
    """
    Simulate a transfer state change in the Sandbox environment.

    For example, after you make a transfer in Sandbox, you can change its
    state to completed.

    The resulting state is final and cannot be changed.
    """

    ROUTE = "/1.0/sandbox/transactions/{transfer_id}/{action}"

    class Body(BaseModel):
        """
        The body of the request.
        """

        pass

    class Response(BaseModel):
        """
        The response model.
        """

        id: Annotated[
            UUID, Field(description="The ID of the transfer whose state was updated.")
        ]
        state: Annotated[
            EnumTransactionState,
            Field(
                description="""
                Indicates the simulated transaction state. Possible values:

                completed:
                    Transaction was successfully processed.
                reverted:
                    Transaction was reverted by the system or company, but not the user. 
                    This can happen for a variety of reasons, for example, the receiver being inaccessible.
                declined:
                    Transaction was declined to the user for a good reason, such as insufficient 
                    account balance, wrong receiver information, etc.
                failed:
                    Transaction failed during initiation or completion. 
                    This can happen for a variety of reasons, for example, 
                    invalid API calls, blocked payments, etc.
                """
            ),
        ]
        created_at: Annotated[
            DateTime,
            Field(
                description="The date and time the transfer was created in ISO 8601 format."
            ),
        ]
        completed_at: Annotated[
            DateTime | None,
            Field(
                description="The date and time the transfer was completed in ISO 8601 format."
            ),
        ] = None

Body

Bases: BaseModel

The body of the request.

Source code in pyrevolut/api/simulations/post/simulate_transfer_state_update.py 
22
23
24
25
26
27
class Body(BaseModel):
    """
    The body of the request.
    """

    pass

Response

Bases: BaseModel

The response model.

Source code in pyrevolut/api/simulations/post/simulate_transfer_state_update.py 
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
class Response(BaseModel):
    """
    The response model.
    """

    id: Annotated[
        UUID, Field(description="The ID of the transfer whose state was updated.")
    ]
    state: Annotated[
        EnumTransactionState,
        Field(
            description="""
            Indicates the simulated transaction state. Possible values:

            completed:
                Transaction was successfully processed.
            reverted:
                Transaction was reverted by the system or company, but not the user. 
                This can happen for a variety of reasons, for example, the receiver being inaccessible.
            declined:
                Transaction was declined to the user for a good reason, such as insufficient 
                account balance, wrong receiver information, etc.
            failed:
                Transaction failed during initiation or completion. 
                This can happen for a variety of reasons, for example, 
                invalid API calls, blocked payments, etc.
            """
        ),
    ]
    created_at: Annotated[
        DateTime,
        Field(
            description="The date and time the transfer was created in ISO 8601 format."
        ),
    ]
    completed_at: Annotated[
        DateTime | None,
        Field(
            description="The date and time the transfer was completed in ISO 8601 format."
        ),
    ] = None