connect-sdk-python3 4.0.0__zip → 4.1.0__zip

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/value_mapping_element.py

@@ -1,85 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from typing import List, Optional
-
-from worldline.connect.sdk.domain.data_object import DataObject
-from worldline.connect.sdk.v1.domain.payment_product_field_display_element import PaymentProductFieldDisplayElement
-
-
-class ValueMappingElement(DataObject):
-
-    __display_elements: Optional[List[PaymentProductFieldDisplayElement]] = None
-    __display_name: Optional[str] = None
-    __value: Optional[str] = None
-
-    @property
-    def display_elements(self) -> Optional[List[PaymentProductFieldDisplayElement]]:
-        """
-        | List of extra data of the value.
-        
-        Type: list[:class:`worldline.connect.sdk.v1.domain.payment_product_field_display_element.PaymentProductFieldDisplayElement`]
-        """
-        return self.__display_elements
-
-    @display_elements.setter
-    def display_elements(self, value: Optional[List[PaymentProductFieldDisplayElement]]) -> None:
-        self.__display_elements = value
-
-    @property
-    def display_name(self) -> Optional[str]:
-        """
-        | Key name
-        
-        Type: str
-        
-        Deprecated; Use displayElements instead with ID 'displayName'
-        """
-        return self.__display_name
-
-    @display_name.setter
-    def display_name(self, value: Optional[str]) -> None:
-        self.__display_name = value
-
-    @property
-    def value(self) -> Optional[str]:
-        """
-        | Value corresponding to the key
-        
-        Type: str
-        """
-        return self.__value
-
-    @value.setter
-    def value(self, value: Optional[str]) -> None:
-        self.__value = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(ValueMappingElement, self).to_dictionary()
-        if self.display_elements is not None:
-            dictionary['displayElements'] = []
-            for element in self.display_elements:
-                if element is not None:
-                    dictionary['displayElements'].append(element.to_dictionary())
-        if self.display_name is not None:
-            dictionary['displayName'] = self.display_name
-        if self.value is not None:
-            dictionary['value'] = self.value
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'ValueMappingElement':
-        super(ValueMappingElement, self).from_dictionary(dictionary)
-        if 'displayElements' in dictionary:
-            if not isinstance(dictionary['displayElements'], list):
-                raise TypeError('value \'{}\' is not a list'.format(dictionary['displayElements']))
-            self.display_elements = []
-            for element in dictionary['displayElements']:
-                value = PaymentProductFieldDisplayElement()
-                self.display_elements.append(value.from_dictionary(element))
-        if 'displayName' in dictionary:
-            self.display_name = dictionary['displayName']
-        if 'value' in dictionary:
-            self.value = dictionary['value']
-        return self

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/exception_factory.py

@@ -1,72 +0,0 @@
-#
-# This file was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from typing import Any, List, Optional
-
-from .api_exception import ApiException
-from .authorization_exception import AuthorizationException
-from .declined_payment_exception import DeclinedPaymentException
-from .declined_payout_exception import DeclinedPayoutException
-from .declined_refund_exception import DeclinedRefundException
-from .idempotence_exception import IdempotenceException
-from .platform_exception import PlatformException
-from .reference_exception import ReferenceException
-from .validation_exception import ValidationException
-from worldline.connect.sdk.call_context import CallContext
-from worldline.connect.sdk.v1.domain.api_error import APIError
-from worldline.connect.sdk.v1.domain.error_response import ErrorResponse
-from worldline.connect.sdk.v1.domain.payment_error_response import PaymentErrorResponse
-from worldline.connect.sdk.v1.domain.payout_error_response import PayoutErrorResponse
-from worldline.connect.sdk.v1.domain.refund_error_response import RefundErrorResponse
-
-
-def create_exception(status_code: int, body: str, error_object: Any, context: Optional[CallContext]) -> Exception:
-    """Return a raisable api-exception based on the error object given"""
-    def create_exception_from_errors(error_id: Optional[str], errors: Optional[List[APIError]]) -> Exception:
-        if is_idempotence_error(errors):
-            return IdempotenceException(context.idempotence_key, context.idempotence_request_timestamp,
-                                        status_code, body, error_id, errors)
-        # get error based on status code, defaulting to ApiException
-        return ERROR_MAP.get(status_code, ApiException)(status_code, body, error_id, errors)
-
-    def is_idempotence_error(errors: List[APIError]) -> bool:
-        return status_code == 409 \
-            and context is not None \
-            and context.idempotence_key is not None \
-            and len(errors) == 1 \
-            and errors[0].code
-
-    if isinstance(error_object, PaymentErrorResponse):
-        if error_object.payment_result is not None:
-            return DeclinedPaymentException(status_code=status_code,
-                                            response_body=body,
-                                            errors=error_object)
-        return create_exception_from_errors(error_object.error_id, error_object.errors)
-    if isinstance(error_object, PayoutErrorResponse):
-        if error_object.payout_result is not None:
-            return DeclinedPayoutException(status_code=status_code,
-                                           response_body=body,
-                                           errors=error_object)
-        return create_exception_from_errors(error_object.error_id, error_object.errors)
-    if isinstance(error_object, RefundErrorResponse):
-        if error_object.refund_result is not None:
-            return DeclinedRefundException(status_code=status_code,
-                                           response_body=body,
-                                           errors=error_object)
-        return create_exception_from_errors(error_object.error_id, error_object.errors)
-    if not isinstance(error_object, ErrorResponse):
-        raise ValueError("Unsupported error object encountered: {}".format(error_object.__class__.__name__))
-
-    return create_exception_from_errors(error_object.error_id, error_object.errors)
-
-
-ERROR_MAP = {
-    400: ValidationException,
-    403: AuthorizationException,
-    404: ReferenceException,
-    409: ReferenceException,  # idempotence has already been tested
-    410: ReferenceException,
-    500: PlatformException,
-    502: PlatformException,
-}

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/idempotence_exception.py

@@ -1,36 +0,0 @@
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from typing import List, Optional
-
-from .api_exception import ApiException
-from worldline.connect.sdk.v1.domain.api_error import APIError
-
-
-class IdempotenceException(ApiException):
-    """
-    Represents an error response from the Worldline Global Collect platform when an
-    idempotent request failed because the first request has not finished yet.
-    """
-
-    def __init__(self, idempotence_key: str, idempotence_request_timestamp: int,
-                 status_code: int, response_body: str, error_id: Optional[str], errors: Optional[List[APIError]],
-                 message: str = "the Worldline Global Collect platform returned a duplicate request error response"):
-        super(IdempotenceException, self).__init__(status_code, response_body, error_id, errors, message)
-        self.__idempotence_key = idempotence_key
-        self.__idempotence_request_timestamp = idempotence_request_timestamp
-
-    @property
-    def idempotence_key(self) -> str:
-        """
-        :return: The key that was used for the idempotent request.
-        """
-        return self.__idempotence_key
-
-    @property
-    def idempotence_request_timestamp(self) -> int:
-        """
-        :return: The request timestamp of the first idempotent request with the same key.
-        """
-        return self.__idempotence_request_timestamp

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/merchant/captures/captures_client.py

@@ -1,101 +0,0 @@
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from typing import Mapping, Optional
-
-from worldline.connect.sdk.api_resource import ApiResource
-from worldline.connect.sdk.call_context import CallContext
-from worldline.connect.sdk.communication.response_exception import ResponseException
-from worldline.connect.sdk.v1.domain.capture_response import CaptureResponse
-from worldline.connect.sdk.v1.domain.error_response import ErrorResponse
-from worldline.connect.sdk.v1.domain.refund_error_response import RefundErrorResponse
-from worldline.connect.sdk.v1.domain.refund_request import RefundRequest
-from worldline.connect.sdk.v1.domain.refund_response import RefundResponse
-from worldline.connect.sdk.v1.exception_factory import create_exception
-
-
-class CapturesClient(ApiResource):
-    """
-    Captures client. Thread-safe.
-    """
-
-    def __init__(self, parent: ApiResource, path_context: Optional[Mapping[str, str]]):
-        """
-        :param parent:       :class:`worldline.connect.sdk.api_resource.ApiResource`
-        :param path_context: Mapping[str, str]
-        """
-        super(CapturesClient, self).__init__(parent=parent, path_context=path_context)
-
-    def get(self, capture_id: str, context: Optional[CallContext] = None) -> CaptureResponse:
-        """
-        Resource /{merchantId}/captures/{captureId} - Get capture
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/captures/get.html
-
-        :param capture_id:  str
-        :param context:     :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: :class:`worldline.connect.sdk.v1.domain.capture_response.CaptureResponse`
-        :raise: ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
-        :raise: AuthorizationException if the request was not allowed (HTTP status code 403)
-        :raise: ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
-                   or there was a conflict (HTTP status code 404, 409 or 410)
-        :raise: PlatformException if something went wrong at the Worldline Global Collect platform,
-                   the Worldline Global Collect platform was unable to process a message from a downstream partner/acquirer,
-                   or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
-        :raise: ApiException if the Worldline Global Collect platform returned any other error
-        """
-        path_context = {
-            "captureId": capture_id,
-        }
-        uri = self._instantiate_uri("/v1/{merchantId}/captures/{captureId}", path_context)
-        try:
-            return self._communicator.get(
-                    uri,
-                    self._client_headers,
-                    None,
-                    CaptureResponse,
-                    context)
-
-        except ResponseException as e:
-            error_type = ErrorResponse
-            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
-            raise create_exception(e.status_code, e.body, error_object, context)
-
-    def refund(self, capture_id: str, body: RefundRequest, context: Optional[CallContext] = None) -> RefundResponse:
-        """
-        Resource /{merchantId}/captures/{captureId}/refund - Create Refund
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/captures/refund.html
-
-        :param capture_id:  str
-        :param body:        :class:`worldline.connect.sdk.v1.domain.refund_request.RefundRequest`
-        :param context:     :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: :class:`worldline.connect.sdk.v1.domain.refund_response.RefundResponse`
-        :raise: DeclinedRefundException if the Worldline Global Collect platform declined / rejected the refund. The refund result will be available from the exception.
-        :raise: ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
-        :raise: AuthorizationException if the request was not allowed (HTTP status code 403)
-        :raise: ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
-                   or there was a conflict (HTTP status code 404, 409 or 410)
-        :raise: PlatformException if something went wrong at the Worldline Global Collect platform,
-                   the Worldline Global Collect platform was unable to process a message from a downstream partner/acquirer,
-                   or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
-        :raise: ApiException if the Worldline Global Collect platform returned any other error
-        """
-        path_context = {
-            "captureId": capture_id,
-        }
-        uri = self._instantiate_uri("/v1/{merchantId}/captures/{captureId}/refund", path_context)
-        try:
-            return self._communicator.post(
-                    uri,
-                    self._client_headers,
-                    None,
-                    body,
-                    RefundResponse,
-                    context)
-
-        except ResponseException as e:
-            error_type = RefundErrorResponse
-            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
-            raise create_exception(e.status_code, e.body, error_object, context)

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/merchant/disputes/disputes_client.py

@@ -1,171 +0,0 @@
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from typing import Mapping, Optional
-
-from worldline.connect.sdk.api_resource import ApiResource
-from worldline.connect.sdk.call_context import CallContext
-from worldline.connect.sdk.communication.response_exception import ResponseException
-from worldline.connect.sdk.v1.domain.dispute_response import DisputeResponse
-from worldline.connect.sdk.v1.domain.error_response import ErrorResponse
-from worldline.connect.sdk.v1.domain.upload_dispute_file_response import UploadDisputeFileResponse
-from worldline.connect.sdk.v1.merchant.disputes.upload_file_request import UploadFileRequest
-from worldline.connect.sdk.v1.exception_factory import create_exception
-
-
-class DisputesClient(ApiResource):
-    """
-    Disputes client. Thread-safe.
-    """
-
-    def __init__(self, parent: ApiResource, path_context: Optional[Mapping[str, str]]):
-        """
-        :param parent:       :class:`worldline.connect.sdk.api_resource.ApiResource`
-        :param path_context: Mapping[str, str]
-        """
-        super(DisputesClient, self).__init__(parent=parent, path_context=path_context)
-
-    def get(self, dispute_id: str, context: Optional[CallContext] = None) -> DisputeResponse:
-        """
-        Resource /{merchantId}/disputes/{disputeId} - Get dispute
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/disputes/get.html
-
-        :param dispute_id:  str
-        :param context:     :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: :class:`worldline.connect.sdk.v1.domain.dispute_response.DisputeResponse`
-        :raise: ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
-        :raise: AuthorizationException if the request was not allowed (HTTP status code 403)
-        :raise: ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
-                   or there was a conflict (HTTP status code 404, 409 or 410)
-        :raise: PlatformException if something went wrong at the Worldline Global Collect platform,
-                   the Worldline Global Collect platform was unable to process a message from a downstream partner/acquirer,
-                   or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
-        :raise: ApiException if the Worldline Global Collect platform returned any other error
-        """
-        path_context = {
-            "disputeId": dispute_id,
-        }
-        uri = self._instantiate_uri("/v1/{merchantId}/disputes/{disputeId}", path_context)
-        try:
-            return self._communicator.get(
-                    uri,
-                    self._client_headers,
-                    None,
-                    DisputeResponse,
-                    context)
-
-        except ResponseException as e:
-            error_type = ErrorResponse
-            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
-            raise create_exception(e.status_code, e.body, error_object, context)
-
-    def submit(self, dispute_id: str, context: Optional[CallContext] = None) -> DisputeResponse:
-        """
-        Resource /{merchantId}/disputes/{disputeId}/submit - Submit dispute
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/disputes/submit.html
-
-        :param dispute_id:  str
-        :param context:     :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: :class:`worldline.connect.sdk.v1.domain.dispute_response.DisputeResponse`
-        :raise: ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
-        :raise: AuthorizationException if the request was not allowed (HTTP status code 403)
-        :raise: ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
-                   or there was a conflict (HTTP status code 404, 409 or 410)
-        :raise: PlatformException if something went wrong at the Worldline Global Collect platform,
-                   the Worldline Global Collect platform was unable to process a message from a downstream partner/acquirer,
-                   or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
-        :raise: ApiException if the Worldline Global Collect platform returned any other error
-        """
-        path_context = {
-            "disputeId": dispute_id,
-        }
-        uri = self._instantiate_uri("/v1/{merchantId}/disputes/{disputeId}/submit", path_context)
-        try:
-            return self._communicator.post(
-                    uri,
-                    self._client_headers,
-                    None,
-                    None,
-                    DisputeResponse,
-                    context)
-
-        except ResponseException as e:
-            error_type = ErrorResponse
-            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
-            raise create_exception(e.status_code, e.body, error_object, context)
-
-    def cancel(self, dispute_id: str, context: Optional[CallContext] = None) -> DisputeResponse:
-        """
-        Resource /{merchantId}/disputes/{disputeId}/cancel - Cancel dispute
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/disputes/cancel.html
-
-        :param dispute_id:  str
-        :param context:     :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: :class:`worldline.connect.sdk.v1.domain.dispute_response.DisputeResponse`
-        :raise: ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
-        :raise: AuthorizationException if the request was not allowed (HTTP status code 403)
-        :raise: ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
-                   or there was a conflict (HTTP status code 404, 409 or 410)
-        :raise: PlatformException if something went wrong at the Worldline Global Collect platform,
-                   the Worldline Global Collect platform was unable to process a message from a downstream partner/acquirer,
-                   or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
-        :raise: ApiException if the Worldline Global Collect platform returned any other error
-        """
-        path_context = {
-            "disputeId": dispute_id,
-        }
-        uri = self._instantiate_uri("/v1/{merchantId}/disputes/{disputeId}/cancel", path_context)
-        try:
-            return self._communicator.post(
-                    uri,
-                    self._client_headers,
-                    None,
-                    None,
-                    DisputeResponse,
-                    context)
-
-        except ResponseException as e:
-            error_type = ErrorResponse
-            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
-            raise create_exception(e.status_code, e.body, error_object, context)
-
-    def upload_file(self, dispute_id: str, body: UploadFileRequest, context: Optional[CallContext] = None) -> UploadDisputeFileResponse:
-        """
-        Resource /{merchantId}/disputes/{disputeId} - Upload File
-        
-        See also https://apireference.connect.worldline-solutions.com/fileserviceapi/v1/en_US/python/disputes/uploadFile.html
-
-        :param dispute_id:  str
-        :param body:        :class:`worldline.connect.sdk.v1.merchant.disputes.upload_file_request.UploadFileRequest`
-        :param context:     :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: :class:`worldline.connect.sdk.v1.domain.upload_dispute_file_response.UploadDisputeFileResponse`
-        :raise: ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
-        :raise: AuthorizationException if the request was not allowed (HTTP status code 403)
-        :raise: ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
-                   or there was a conflict (HTTP status code 404, 409 or 410)
-        :raise: PlatformException if something went wrong at the Worldline Global Collect platform,
-                   the Worldline Global Collect platform was unable to process a message from a downstream partner/acquirer,
-                   or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
-        :raise: ApiException if the Worldline Global Collect platform returned any other error
-        """
-        path_context = {
-            "disputeId": dispute_id,
-        }
-        uri = self._instantiate_uri("/files/v1/{merchantId}/disputes/{disputeId}", path_context)
-        try:
-            return self._communicator.post(
-                    uri,
-                    self._client_headers,
-                    None,
-                    body,
-                    UploadDisputeFileResponse,
-                    context)
-
-        except ResponseException as e:
-            error_type = ErrorResponse
-            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
-            raise create_exception(e.status_code, e.body, error_object, context)

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/merchant/disputes/upload_file_request.py

@@ -1,42 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from typing import Optional
-
-from worldline.connect.sdk.domain.uploadable_file import UploadableFile
-from worldline.connect.sdk.communication.multipart_form_data_request import MultipartFormDataRequest
-from worldline.connect.sdk.communication.multipart_form_data_object import MultipartFormDataObject
-
-
-class UploadFileRequest(MultipartFormDataRequest):
-    """
-    Multipart/form-data parameters for Upload File
-    
-    See also https://apireference.connect.worldline-solutions.com/fileserviceapi/v1/en_US/python/disputes/uploadFile.html
-    """
-
-    __file: Optional[UploadableFile] = None
-
-    @property
-    def file(self) -> Optional[UploadableFile]:
-        """
-        | The file that you will upload as evidence to support a dispute.
-        
-        Type: :class:`worldline.connect.sdk.UploadableFile`
-        """
-        return self.__file
-
-    @file.setter
-    def file(self, value: Optional[UploadableFile]) -> None:
-        self.__file = value
-
-    def to_multipart_form_data_object(self) -> MultipartFormDataObject:
-        """
-        :return: :class:`worldline.connect.sdk.MultipartFormDataObject`
-        """
-        result = MultipartFormDataObject()
-        if self.file is not None:
-            result.add_file("file", self.file)
-        return result

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/merchant/files/files_client.py

@@ -1,59 +0,0 @@
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from typing import Mapping, Optional
-
-from worldline.connect.sdk.api_resource import ApiResource
-from worldline.connect.sdk.communicator import BinaryResponse
-from worldline.connect.sdk.call_context import CallContext
-from worldline.connect.sdk.communication.response_exception import ResponseException
-from worldline.connect.sdk.v1.domain.error_response import ErrorResponse
-from worldline.connect.sdk.v1.exception_factory import create_exception
-
-
-class FilesClient(ApiResource):
-    """
-    Files client. Thread-safe.
-    """
-
-    def __init__(self, parent: ApiResource, path_context: Optional[Mapping[str, str]]):
-        """
-        :param parent:       :class:`worldline.connect.sdk.api_resource.ApiResource`
-        :param path_context: Mapping[str, str]
-        """
-        super(FilesClient, self).__init__(parent=parent, path_context=path_context)
-
-    def get_file(self, file_id: str, context: Optional[CallContext] = None) -> BinaryResponse:
-        """
-        Resource /{merchantId}/files/{fileId} - Retrieve File
-        
-        See also https://apireference.connect.worldline-solutions.com/fileserviceapi/v1/en_US/python/files/getFile.html
-
-        :param file_id:  str
-        :param context:  :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: a tuple with the headers and a generator of body chunks
-        :raise: ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
-        :raise: AuthorizationException if the request was not allowed (HTTP status code 403)
-        :raise: ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
-                   or there was a conflict (HTTP status code 404, 409 or 410)
-        :raise: PlatformException if something went wrong at the Worldline Global Collect platform,
-                   the Worldline Global Collect platform was unable to process a message from a downstream partner/acquirer,
-                   or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
-        :raise: ApiException if the Worldline Global Collect platform returned any other error
-        """
-        path_context = {
-            "fileId": file_id,
-        }
-        uri = self._instantiate_uri("/files/v1/{merchantId}/files/{fileId}", path_context)
-        try:
-            return self._communicator.get_with_binary_response(
-                    uri,
-                    self._client_headers,
-                    None,
-                    context)
-
-        except ResponseException as e:
-            error_type = ErrorResponse
-            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
-            raise create_exception(e.status_code, e.body, error_object, context)