Skip to content

Reference

Bases: BaseClient

Client.

Source code in merchant001_sdk/client/client.py 
 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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
@dataclass(kw_only=True)
class Client(BaseClient):
    """Client."""

    endpoint: str = field()
    token: str = field()
    token_prefix: str = field(default="Bearer")
    cookies: dict[str, t.Any] = field(default_factory=dict)
    is_async: bool = field(default=False)
    close_on_exit: bool = field(default=False)
    _client: httpx.AsyncClient | None = field(default=None)

    @sync_or_async()
    async def get_merchant_healthcheck(self) -> responses.healthcheck.MerchantHealthcheck | responses.ErrorResult:
        """get_merchant_healthcheck.

        Args:

        Returns:
            responses.healthcheck.MerchantHealthcheck | responses.ErrorResult
        """
        result: responses.RawResult | responses.ErrorResult = await self._request(  # type: ignore
            "POST",
            "v1/healthcheck/merchant/",
            return_raw=True,
            success_status=(http.HTTPStatus.CREATED,),
        )

        if isinstance(result, responses.ErrorResult):
            return result

        body_data = result.get_json() or {}

        return responses.healthcheck.MerchantHealthcheck(success=body_data.get("success"))

    @sync_or_async()
    async def get_payment_methods(
        self,
        raw_dict: bool = False,
        method_names_only: bool = False,
        amount: int | None = None,
    ) -> (
        dict[str, dict[str, dict[str, t.Any]]]
        | list[responses.payment_method.PaymentMethodType]
        | responses.ErrorResult
    ):
        """get_payment_methods.

        Args:
            raw_dict (bool): raw_dict
            method_names_only (bool): method_names_only
            amount (int | None): amount

        Returns:
            (
                dict[str, dict[str, dict[str, t.Any]]]
                | list[responses.payment_method.PaymentMethodType]
                | responses.ErrorResult
            ):
        """
        params = {}

        if not raw_dict:
            params["makeArray"] = 1

        if method_names_only:
            params["onlyMethod"] = 1

        if amount is not None and amount > 0:
            params["amount"] = amount

        result: responses.RawResult | responses.ErrorResult = await self._request(  # type: ignore
            "GET",
            "v1/payment-method/merchant/available",
            return_raw=True,
            params=params,
            success_status=(http.HTTPStatus.OK,),
        )

        if isinstance(result, responses.ErrorResult):
            return result

        body_data = result.get_json() or {}

        if raw_dict:
            return body_data
        else:
            return [responses.payment_method.PaymentMethodType(**mt) for mt in body_data]  # type: ignore

    @sync_or_async()
    async def create_transaction(
        self,
        pricing: dict[str, dict[str, str | float]],
        provider_type: str | None = None,
        provider_method: str | None = None,
        is_partner_fee: bool = False,
    ) -> responses.transaction.CreatedTransaction | responses.ErrorResult:
        """create_transaction.

        Args:
            pricing (dict[str, dict[str, str | float]]): pricing
            provider_type (str | None): provider_type
            provider_method (str | None): provider_method
            is_partner_fee (bool): is_partner_fee

        Returns:
            responses.transaction.CreatedTransaction | responses.ErrorResult:
        """
        data = {
            "isPartnerFee": is_partner_fee,
            "pricing": pricing,
        }

        if provider_type and provider_method:
            data["selectedProvider"] = {"type": provider_type, "method": provider_method}

        result: responses.RawResult | responses.ErrorResult = await self._request(  # type: ignore
            "POST",
            "v1/transaction/merchant",
            return_raw=True,
            data=data,
            success_status=(http.HTTPStatus.CREATED,),
        )

        if isinstance(result, responses.ErrorResult):
            return result

        body_data = result.get_json() or {}

        return responses.transaction.CreatedTransaction(**body_data)

    @sync_or_async()
    async def get_transaction(
        self,
        transaction_id: str,
    ) -> responses.transaction.GettedTransaction | responses.ErrorResult:
        """get_transaction.

        Args:
            transaction_id (str): transaction_id

        Returns:
            responses.transaction.GettedTransaction | responses.ErrorResult:
        """
        result: responses.RawResult | responses.ErrorResult = await self._request(  # type: ignore
            "GET",
            f"v1/transaction/merchant/{transaction_id}",
            return_raw=True,
            success_status=(http.HTTPStatus.OK,),
        )

        if isinstance(result, responses.ErrorResult):
            return result

        body_data = result.get_json() or {}

        return responses.transaction.GettedTransaction(**body_data)

    @sync_or_async()
    async def get_transaction_requisite(
        self,
        transaction_id: str,
    ) -> responses.transaction.GettedTransactionRequisite | responses.ErrorResult:
        """get_transaction_requisite.

        Args:
            transaction_id (str): transaction_id

        Returns:
            responses.transaction.GettedTransactionRequisite | responses.ErrorResult:
        """

        result: responses.RawResult | responses.ErrorResult = await self._request(  # type: ignore
            "GET",
            f"v1/transaction/merchant/requisite/{transaction_id}",
            return_raw=True,
            success_status=(http.HTTPStatus.OK,),
        )

        if isinstance(result, responses.ErrorResult):
            if result.status_code == 400 and (result.message or "").lower() == "bitconce order is closed":
                result.message = "Order is closed"

            return result

        body_data = result.get_json() or {}

        return responses.transaction.GettedTransactionRequisite(**body_data)

    @sync_or_async()
    async def claim_transaction_paid(
        self,
        transaction_id: str,
    ) -> responses.transaction.Transaction | responses.ErrorResult:
        """claim_transaction_paid.

        Args:
            transaction_id (str): transaction_id

        Returns:
            responses.transaction.Transaction | responses.ErrorResult:
        """

        result: responses.RawResult | responses.ErrorResult = await self._request(  # type: ignore
            "POST",
            f"v1/transaction/merchant/paid/{transaction_id}",
            return_raw=True,
            success_status=(http.HTTPStatus.CREATED,),
        )

        if isinstance(result, responses.ErrorResult):
            return result

        body_data = result.get_json() or {}

        return responses.transaction.Transaction(**body_data)

    @sync_or_async()
    async def claim_transaction_canceled(
        self,
        transaction_id: str,
    ) -> responses.transaction.Transaction | responses.ErrorResult:
        """claim_transaction_canceled.

        Args:
            transaction_id (str): transaction_id

        Returns:
            responses.transaction.Transaction | responses.ErrorResult:
        """

        result: responses.RawResult | responses.ErrorResult = await self._request(  # type: ignore
            "POST",
            f"v1/transaction/merchant/cancel/{transaction_id}",
            return_raw=True,
            success_status=(http.HTTPStatus.CREATED,),
        )

        if isinstance(result, responses.ErrorResult):
            return result

        body_data = result.get_json() or {}

        return responses.transaction.Transaction(**body_data)

    @sync_or_async()
    async def set_transaction_payment_method(
        self,
        transaction_id: str,
        provider_type: str,
        provider_method: str,
    ) -> responses.transaction.CreatedTransaction | responses.ErrorResult:
        """set_transaction_payment_method.

        Args:
            transaction_id (str): transaction_id
            provider_type (str): provider_type
            provider_method (str): provider_method

        Returns:
            responses.transaction.CreatedTransaction | responses.ErrorResult:
        """

        result: responses.RawResult | responses.ErrorResult = await self._request(  # type: ignore
            "POST",
            f"v1/transaction/merchant/provider/{transaction_id}",
            return_raw=True,
            data={"selectedProvider": {"method": provider_method, "type": provider_type}},
            success_status=(http.HTTPStatus.CREATED, http.HTTPStatus.OK),
        )

        if isinstance(result, responses.ErrorResult):
            return result

        body_data = result.get_json() or {}

        return responses.transaction.CreatedTransaction(**body_data)

    @sync_or_async()
    async def get_payment_method_rate(
        self,
        payment_method: str,
    ) -> responses.rate.PaymentMethodRate | responses.ErrorResult:
        """get_payment_method_rate.

        Args:
            payment_method (str): payment_method

        Returns:
            responses.rate.PaymentMethodRate | responses.ErrorResult:
        """

        result: responses.RawResult | responses.ErrorResult = await self._request(  # type: ignore
            "GET",
            f"v1/rate/",
            return_raw=True,
            params={"method": payment_method},
            success_status=(http.HTTPStatus.OK,),
        )

        if isinstance(result, responses.ErrorResult):
            return result

        body_data = result.get_json() or {}

        return responses.rate.PaymentMethodRate(**body_data)

    @sync_or_async()
    async def upload_payment_receipt(
        self,
        transaction_id: str,
        receipt_file: str | pathlib.Path | io.BufferedReader,
        amount: float | None = None,
    ) -> responses.StatusStub | responses.ErrorResult:
        """upload_payment_receipt.

        Args:
            transaction_id (str): transaction_id
            receipt_file (str | pathlib.Path | io.BufferedReader): receipt_file
            amount (float | None): amount

        Returns:
            responses.StatusStub | responses.ErrorResult:
        """
        form_data = {}

        if amount is not None:
            form_data["amount"] = amount

        if isinstance(receipt_file, str):
            receipt_file = pathlib.Path(receipt_file)

        if isinstance(receipt_file, pathlib.Path) and (not receipt_file.exists() or not receipt_file.is_file()):
            raise FileNotFoundError(f"Receipt file by path {receipt_file} not found!")

        elif isinstance(receipt_file, pathlib.Path):
            receipt_file = receipt_file.open(mode="rb")

        files = {"file": receipt_file}

        result: responses.RawResult | responses.ErrorResult = await self._request(  # type: ignore
            "POST",
            f"v1/transaction/merchant/receipt/{transaction_id}",
            return_raw=True,
            form=form_data,
            files=files,
            success_status=(http.HTTPStatus.OK, http.HTTPStatus.CREATED),
        )

        if isinstance(result, responses.ErrorResult):
            return result

        body_data = result.get_json() or {}

        return responses.StatusStub(**body_data)

claim_transaction_canceled(transaction_id) async

claim_transaction_canceled.

Parameters:

Name Type Description Default
transaction_id str

transaction_id

 required

Returns:

Type Description
responses.transaction.Transaction | responses.ErrorResult

responses.transaction.Transaction | responses.ErrorResult:
Source code in merchant001_sdk/client/client.py 
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
@sync_or_async()
async def claim_transaction_canceled(
    self,
    transaction_id: str,
) -> responses.transaction.Transaction | responses.ErrorResult:
    """claim_transaction_canceled.

    Args:
        transaction_id (str): transaction_id

    Returns:
        responses.transaction.Transaction | responses.ErrorResult:
    """

    result: responses.RawResult | responses.ErrorResult = await self._request(  # type: ignore
        "POST",
        f"v1/transaction/merchant/cancel/{transaction_id}",
        return_raw=True,
        success_status=(http.HTTPStatus.CREATED,),
    )

    if isinstance(result, responses.ErrorResult):
        return result

    body_data = result.get_json() or {}

    return responses.transaction.Transaction(**body_data)

claim_transaction_paid(transaction_id) async

claim_transaction_paid.

Parameters:

Name Type Description Default
transaction_id str

transaction_id

 required

Returns:

Type Description
responses.transaction.Transaction | responses.ErrorResult

responses.transaction.Transaction | responses.ErrorResult:
Source code in merchant001_sdk/client/client.py 
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
@sync_or_async()
async def claim_transaction_paid(
    self,
    transaction_id: str,
) -> responses.transaction.Transaction | responses.ErrorResult:
    """claim_transaction_paid.

    Args:
        transaction_id (str): transaction_id

    Returns:
        responses.transaction.Transaction | responses.ErrorResult:
    """

    result: responses.RawResult | responses.ErrorResult = await self._request(  # type: ignore
        "POST",
        f"v1/transaction/merchant/paid/{transaction_id}",
        return_raw=True,
        success_status=(http.HTTPStatus.CREATED,),
    )

    if isinstance(result, responses.ErrorResult):
        return result

    body_data = result.get_json() or {}

    return responses.transaction.Transaction(**body_data)

create_transaction(pricing, provider_type=None, provider_method=None, is_partner_fee=False) async

create_transaction.

Parameters:

Name Type Description Default
pricing dict[str, dict[str, str | float]]

pricing

 required
provider_type str | None

provider_type

 None
provider_method str | None

provider_method

 None
is_partner_fee bool

is_partner_fee

 False

Returns:

Type Description
responses.transaction.CreatedTransaction | responses.ErrorResult

responses.transaction.CreatedTransaction | responses.ErrorResult:
Source code in merchant001_sdk/client/client.py 
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
140
141
142
143
144
@sync_or_async()
async def create_transaction(
    self,
    pricing: dict[str, dict[str, str | float]],
    provider_type: str | None = None,
    provider_method: str | None = None,
    is_partner_fee: bool = False,
) -> responses.transaction.CreatedTransaction | responses.ErrorResult:
    """create_transaction.

    Args:
        pricing (dict[str, dict[str, str | float]]): pricing
        provider_type (str | None): provider_type
        provider_method (str | None): provider_method
        is_partner_fee (bool): is_partner_fee

    Returns:
        responses.transaction.CreatedTransaction | responses.ErrorResult:
    """
    data = {
        "isPartnerFee": is_partner_fee,
        "pricing": pricing,
    }

    if provider_type and provider_method:
        data["selectedProvider"] = {"type": provider_type, "method": provider_method}

    result: responses.RawResult | responses.ErrorResult = await self._request(  # type: ignore
        "POST",
        "v1/transaction/merchant",
        return_raw=True,
        data=data,
        success_status=(http.HTTPStatus.CREATED,),
    )

    if isinstance(result, responses.ErrorResult):
        return result

    body_data = result.get_json() or {}

    return responses.transaction.CreatedTransaction(**body_data)

get_merchant_healthcheck() async

get_merchant_healthcheck.

Returns:

Type Description
responses.healthcheck.MerchantHealthcheck | responses.ErrorResult

responses.healthcheck.MerchantHealthcheck | responses.ErrorResult
Source code in merchant001_sdk/client/client.py 
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
@sync_or_async()
async def get_merchant_healthcheck(self) -> responses.healthcheck.MerchantHealthcheck | responses.ErrorResult:
    """get_merchant_healthcheck.

    Args:

    Returns:
        responses.healthcheck.MerchantHealthcheck | responses.ErrorResult
    """
    result: responses.RawResult | responses.ErrorResult = await self._request(  # type: ignore
        "POST",
        "v1/healthcheck/merchant/",
        return_raw=True,
        success_status=(http.HTTPStatus.CREATED,),
    )

    if isinstance(result, responses.ErrorResult):
        return result

    body_data = result.get_json() or {}

    return responses.healthcheck.MerchantHealthcheck(success=body_data.get("success"))

get_payment_method_rate(payment_method) async

get_payment_method_rate.

Parameters:

Name Type Description Default
payment_method str

payment_method

 required

Returns:

Type Description
responses.rate.PaymentMethodRate | responses.ErrorResult

responses.rate.PaymentMethodRate | responses.ErrorResult:
Source code in merchant001_sdk/client/client.py 
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
@sync_or_async()
async def get_payment_method_rate(
    self,
    payment_method: str,
) -> responses.rate.PaymentMethodRate | responses.ErrorResult:
    """get_payment_method_rate.

    Args:
        payment_method (str): payment_method

    Returns:
        responses.rate.PaymentMethodRate | responses.ErrorResult:
    """

    result: responses.RawResult | responses.ErrorResult = await self._request(  # type: ignore
        "GET",
        f"v1/rate/",
        return_raw=True,
        params={"method": payment_method},
        success_status=(http.HTTPStatus.OK,),
    )

    if isinstance(result, responses.ErrorResult):
        return result

    body_data = result.get_json() or {}

    return responses.rate.PaymentMethodRate(**body_data)

get_payment_methods(raw_dict=False, method_names_only=False, amount=None) async

get_payment_methods.

Parameters:

Name Type Description Default
raw_dict bool

raw_dict

 False
method_names_only bool

method_names_only

 False
amount int | None

amount

 None

Returns:

Type Description
dict[str, dict[str, dict[str, t.Any]]] | list[responses.payment_method.PaymentMethodType] | responses.ErrorResult

( dict[str, dict[str, dict[str, t.Any]]] | list[responses.payment_method.PaymentMethodType] | responses.ErrorResult
dict[str, dict[str, dict[str, t.Any]]] | list[responses.payment_method.PaymentMethodType] | responses.ErrorResult

):
Source code in merchant001_sdk/client/client.py 
 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
@sync_or_async()
async def get_payment_methods(
    self,
    raw_dict: bool = False,
    method_names_only: bool = False,
    amount: int | None = None,
) -> (
    dict[str, dict[str, dict[str, t.Any]]]
    | list[responses.payment_method.PaymentMethodType]
    | responses.ErrorResult
):
    """get_payment_methods.

    Args:
        raw_dict (bool): raw_dict
        method_names_only (bool): method_names_only
        amount (int | None): amount

    Returns:
        (
            dict[str, dict[str, dict[str, t.Any]]]
            | list[responses.payment_method.PaymentMethodType]
            | responses.ErrorResult
        ):
    """
    params = {}

    if not raw_dict:
        params["makeArray"] = 1

    if method_names_only:
        params["onlyMethod"] = 1

    if amount is not None and amount > 0:
        params["amount"] = amount

    result: responses.RawResult | responses.ErrorResult = await self._request(  # type: ignore
        "GET",
        "v1/payment-method/merchant/available",
        return_raw=True,
        params=params,
        success_status=(http.HTTPStatus.OK,),
    )

    if isinstance(result, responses.ErrorResult):
        return result

    body_data = result.get_json() or {}

    if raw_dict:
        return body_data
    else:
        return [responses.payment_method.PaymentMethodType(**mt) for mt in body_data]  # type: ignore

get_transaction(transaction_id) async

get_transaction.

Parameters:

Name Type Description Default
transaction_id str

transaction_id

 required

Returns:

Type Description
responses.transaction.GettedTransaction | responses.ErrorResult

responses.transaction.GettedTransaction | responses.ErrorResult:
Source code in merchant001_sdk/client/client.py 
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
@sync_or_async()
async def get_transaction(
    self,
    transaction_id: str,
) -> responses.transaction.GettedTransaction | responses.ErrorResult:
    """get_transaction.

    Args:
        transaction_id (str): transaction_id

    Returns:
        responses.transaction.GettedTransaction | responses.ErrorResult:
    """
    result: responses.RawResult | responses.ErrorResult = await self._request(  # type: ignore
        "GET",
        f"v1/transaction/merchant/{transaction_id}",
        return_raw=True,
        success_status=(http.HTTPStatus.OK,),
    )

    if isinstance(result, responses.ErrorResult):
        return result

    body_data = result.get_json() or {}

    return responses.transaction.GettedTransaction(**body_data)

get_transaction_requisite(transaction_id) async

get_transaction_requisite.

Parameters:

Name Type Description Default
transaction_id str

transaction_id

 required

Returns:

Type Description
responses.transaction.GettedTransactionRequisite | responses.ErrorResult

responses.transaction.GettedTransactionRequisite | responses.ErrorResult:
Source code in merchant001_sdk/client/client.py 
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
@sync_or_async()
async def get_transaction_requisite(
    self,
    transaction_id: str,
) -> responses.transaction.GettedTransactionRequisite | responses.ErrorResult:
    """get_transaction_requisite.

    Args:
        transaction_id (str): transaction_id

    Returns:
        responses.transaction.GettedTransactionRequisite | responses.ErrorResult:
    """

    result: responses.RawResult | responses.ErrorResult = await self._request(  # type: ignore
        "GET",
        f"v1/transaction/merchant/requisite/{transaction_id}",
        return_raw=True,
        success_status=(http.HTTPStatus.OK,),
    )

    if isinstance(result, responses.ErrorResult):
        if result.status_code == 400 and (result.message or "").lower() == "bitconce order is closed":
            result.message = "Order is closed"

        return result

    body_data = result.get_json() or {}

    return responses.transaction.GettedTransactionRequisite(**body_data)

set_transaction_payment_method(transaction_id, provider_type, provider_method) async

set_transaction_payment_method.

Parameters:

Name Type Description Default
transaction_id str

transaction_id

 required
provider_type str

provider_type

 required
provider_method str

provider_method

 required

Returns:

Type Description
responses.transaction.CreatedTransaction | responses.ErrorResult

responses.transaction.CreatedTransaction | responses.ErrorResult:
Source code in merchant001_sdk/client/client.py 
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
@sync_or_async()
async def set_transaction_payment_method(
    self,
    transaction_id: str,
    provider_type: str,
    provider_method: str,
) -> responses.transaction.CreatedTransaction | responses.ErrorResult:
    """set_transaction_payment_method.

    Args:
        transaction_id (str): transaction_id
        provider_type (str): provider_type
        provider_method (str): provider_method

    Returns:
        responses.transaction.CreatedTransaction | responses.ErrorResult:
    """

    result: responses.RawResult | responses.ErrorResult = await self._request(  # type: ignore
        "POST",
        f"v1/transaction/merchant/provider/{transaction_id}",
        return_raw=True,
        data={"selectedProvider": {"method": provider_method, "type": provider_type}},
        success_status=(http.HTTPStatus.CREATED, http.HTTPStatus.OK),
    )

    if isinstance(result, responses.ErrorResult):
        return result

    body_data = result.get_json() or {}

    return responses.transaction.CreatedTransaction(**body_data)

upload_payment_receipt(transaction_id, receipt_file, amount=None) async

upload_payment_receipt.

Parameters:

Name Type Description Default
transaction_id str

transaction_id

 required
receipt_file str | pathlib.Path | io.BufferedReader

receipt_file

 required
amount float | None

amount

 None

Returns:

Type Description
responses.StatusStub | responses.ErrorResult

responses.StatusStub | responses.ErrorResult:
Source code in merchant001_sdk/client/client.py 
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
@sync_or_async()
async def upload_payment_receipt(
    self,
    transaction_id: str,
    receipt_file: str | pathlib.Path | io.BufferedReader,
    amount: float | None = None,
) -> responses.StatusStub | responses.ErrorResult:
    """upload_payment_receipt.

    Args:
        transaction_id (str): transaction_id
        receipt_file (str | pathlib.Path | io.BufferedReader): receipt_file
        amount (float | None): amount

    Returns:
        responses.StatusStub | responses.ErrorResult:
    """
    form_data = {}

    if amount is not None:
        form_data["amount"] = amount

    if isinstance(receipt_file, str):
        receipt_file = pathlib.Path(receipt_file)

    if isinstance(receipt_file, pathlib.Path) and (not receipt_file.exists() or not receipt_file.is_file()):
        raise FileNotFoundError(f"Receipt file by path {receipt_file} not found!")

    elif isinstance(receipt_file, pathlib.Path):
        receipt_file = receipt_file.open(mode="rb")

    files = {"file": receipt_file}

    result: responses.RawResult | responses.ErrorResult = await self._request(  # type: ignore
        "POST",
        f"v1/transaction/merchant/receipt/{transaction_id}",
        return_raw=True,
        form=form_data,
        files=files,
        success_status=(http.HTTPStatus.OK, http.HTTPStatus.CREATED),
    )

    if isinstance(result, responses.ErrorResult):
        return result

    body_data = result.get_json() or {}

    return responses.StatusStub(**body_data)