connect-sdk-python2 3.45.0__zip → 3.47.0__zip

connect-sdk-python2-3.47.0/ingenico/connect/sdk/merchant/tokens/tokens_client.py

@@ -0,0 +1,200 @@
+#
+# This class was auto-generated from the API references found at
+# https://epayments-api.developer-ingenico.com/
+#
+from ingenico.connect.sdk.api_resource import ApiResource
+from ingenico.connect.sdk.response_exception import ResponseException
+from ingenico.connect.sdk.domain.errors.error_response import ErrorResponse
+from ingenico.connect.sdk.domain.token.create_token_response import CreateTokenResponse
+from ingenico.connect.sdk.domain.token.token_response import TokenResponse
+
+
+class TokensClient(ApiResource):
+    """
+    Tokens client. Thread-safe.
+    """
+
+    def __init__(self, parent, path_context):
+        """
+        :param parent:       :class:`ingenico.connect.sdk.api_resource.ApiResource`
+        :param path_context: dict[str, str]
+        """
+        super(TokensClient, self).__init__(parent, path_context)
+
+    def create(self, body, context=None):
+        """
+        Resource /{merchantId}/tokens - Create token
+        
+        See also https://epayments-api.developer-ingenico.com/s2sapi/v1/en_US/python/tokens/create.html
+
+        :param body:     :class:`ingenico.connect.sdk.domain.token.create_token_request.CreateTokenRequest`
+        :param context:  :class:`ingenico.connect.sdk.call_context.CallContext`
+        :return: :class:`ingenico.connect.sdk.domain.token.create_token_response.CreateTokenResponse`
+        :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: GlobalCollectException if something went wrong at the Ingenico ePayments platform,
+                   the Ingenico ePayments 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 Ingenico ePayments platform returned any other error
+        """
+        uri = self._instantiate_uri("/v1/{merchantId}/tokens", None)
+        try:
+            return self._communicator.post(
+                    uri,
+                    self._client_headers,
+                    None,
+                    body,
+                    CreateTokenResponse,
+                    context)
+
+        except ResponseException as e:
+            error_type = ErrorResponse
+            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
+            raise self._create_exception(e.status_code, e.body, error_object, context)
+
+    def get(self, token_id, context=None):
+        """
+        Resource /{merchantId}/tokens/{tokenId} - Get token
+        
+        See also https://epayments-api.developer-ingenico.com/s2sapi/v1/en_US/python/tokens/get.html
+
+        :param token_id:  str
+        :param context:   :class:`ingenico.connect.sdk.call_context.CallContext`
+        :return: :class:`ingenico.connect.sdk.domain.token.token_response.TokenResponse`
+        :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: GlobalCollectException if something went wrong at the Ingenico ePayments platform,
+                   the Ingenico ePayments 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 Ingenico ePayments platform returned any other error
+        """
+        path_context = {
+            "tokenId": token_id,
+        }
+        uri = self._instantiate_uri("/v1/{merchantId}/tokens/{tokenId}", path_context)
+        try:
+            return self._communicator.get(
+                    uri,
+                    self._client_headers,
+                    None,
+                    TokenResponse,
+                    context)
+
+        except ResponseException as e:
+            error_type = ErrorResponse
+            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
+            raise self._create_exception(e.status_code, e.body, error_object, context)
+
+    def update(self, token_id, body, context=None):
+        """
+        Resource /{merchantId}/tokens/{tokenId} - Update token
+        
+        See also https://epayments-api.developer-ingenico.com/s2sapi/v1/en_US/python/tokens/update.html
+
+        :param token_id:  str
+        :param body:      :class:`ingenico.connect.sdk.domain.token.update_token_request.UpdateTokenRequest`
+        :param context:   :class:`ingenico.connect.sdk.call_context.CallContext`
+        :return: None
+        :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: GlobalCollectException if something went wrong at the Ingenico ePayments platform,
+                   the Ingenico ePayments 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 Ingenico ePayments platform returned any other error
+        """
+        path_context = {
+            "tokenId": token_id,
+        }
+        uri = self._instantiate_uri("/v1/{merchantId}/tokens/{tokenId}", path_context)
+        try:
+            return self._communicator.put(
+                    uri,
+                    self._client_headers,
+                    None,
+                    body,
+                    None,
+                    context)
+
+        except ResponseException as e:
+            error_type = ErrorResponse
+            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
+            raise self._create_exception(e.status_code, e.body, error_object, context)
+
+    def delete(self, token_id, query, context=None):
+        """
+        Resource /{merchantId}/tokens/{tokenId} - Delete token
+        
+        See also https://epayments-api.developer-ingenico.com/s2sapi/v1/en_US/python/tokens/delete.html
+
+        :param token_id:  str
+        :param query:     :class:`ingenico.connect.sdk.merchant.tokens.delete_token_params.DeleteTokenParams`
+        :param context:   :class:`ingenico.connect.sdk.call_context.CallContext`
+        :return: None
+        :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: GlobalCollectException if something went wrong at the Ingenico ePayments platform,
+                   the Ingenico ePayments 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 Ingenico ePayments platform returned any other error
+        """
+        path_context = {
+            "tokenId": token_id,
+        }
+        uri = self._instantiate_uri("/v1/{merchantId}/tokens/{tokenId}", path_context)
+        try:
+            return self._communicator.delete(
+                    uri,
+                    self._client_headers,
+                    query,
+                    None,
+                    context)
+
+        except ResponseException as e:
+            error_type = ErrorResponse
+            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
+            raise self._create_exception(e.status_code, e.body, error_object, context)
+
+    def approvesepadirectdebit(self, token_id, body, context=None):
+        """
+        Resource /{merchantId}/tokens/{tokenId}/approvesepadirectdebit - Approve SEPA DD mandate
+        
+        See also https://epayments-api.developer-ingenico.com/s2sapi/v1/en_US/python/tokens/approvesepadirectdebit.html
+
+        :param token_id:  str
+        :param body:      :class:`ingenico.connect.sdk.domain.token.approve_token_request.ApproveTokenRequest`
+        :param context:   :class:`ingenico.connect.sdk.call_context.CallContext`
+        :return: None
+        :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: GlobalCollectException if something went wrong at the Ingenico ePayments platform,
+                   the Ingenico ePayments 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 Ingenico ePayments platform returned any other error
+        """
+        path_context = {
+            "tokenId": token_id,
+        }
+        uri = self._instantiate_uri("/v1/{merchantId}/tokens/{tokenId}/approvesepadirectdebit", path_context)
+        try:
+            return self._communicator.post(
+                    uri,
+                    self._client_headers,
+                    None,
+                    body,
+                    None,
+                    context)
+
+        except ResponseException as e:
+            error_type = ErrorResponse
+            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
+            raise self._create_exception(e.status_code, e.body, error_object, context)

connect-sdk-python2-3.47.0/ingenico/connect/sdk/meta_data_provider.py

@@ -0,0 +1,127 @@
+import platform
+from base64 import b64encode
+import re
+
+from request_header import RequestHeader
+from ingenico.connect.sdk.data_object import DataObject
+from ingenico.connect.sdk.defaultimpl.default_marshaller import DefaultMarshaller
+from ingenico.connect.sdk.domain.metadata.shopping_cart_extension import ShoppingCartExtension
+
+
+class IterProperty(object):
+    def __init__(self, func):
+        self.func = func
+
+    def __get__(self, instance, owner):
+        return self.func(owner)
+
+
+class MetaDataProvider:
+    """
+    Provides meta info about the server.
+    """
+    __SDK_VERSION = "3.47.0"
+    __SERVER_META_INFO_HEADER = "X-GCS-ServerMetaInfo"
+    __prohibited_headers = [__SERVER_META_INFO_HEADER, "X-GCS-Idempotence-Key",
+                            "Date", "Content-Type", "Authorization"]
+    __PROHIBITED_HEADERS = tuple(sorted(__prohibited_headers, key=str.lower))
+    __meta_data_headers = None
+
+    class ServerMetaInfo(DataObject):
+        platform_identifier = None
+        sdk_identifier = None
+        sdk_creator = None
+        integrator = None
+        shopping_cart_extension = None
+
+        def to_dictionary(self):
+            dictionary = super(MetaDataProvider.ServerMetaInfo, self).to_dictionary()
+            if self.platform_identifier is not None:
+                dictionary['platformIdentifier'] = self.platform_identifier
+            if self.sdk_identifier is not None:
+                dictionary['sdkIdentifier'] = self.sdk_identifier
+            if self.sdk_creator is not None:
+                dictionary['sdkCreator'] = self.sdk_creator
+            if self.integrator is not None:
+                dictionary['integrator'] = self.integrator
+            if self.shopping_cart_extension is not None:
+                dictionary['shoppingCartExtension'] = self.shopping_cart_extension.to_dictionary()
+            return dictionary
+
+        def from_dictionary(self, dictionary):
+            super(MetaDataProvider.ServerMetaInfo, self).from_dictionary(dictionary)
+            if 'platformIdentifier' in dictionary:
+                self.platform_identifier = dictionary['platformIdentifier']
+            if 'sdkIdentifier' in dictionary:
+                self.sdk_identifier = dictionary['sdkIdentifier']
+            if 'sdkCreator' in dictionary:
+                self.sdk_creator = dictionary['sdkCreator']
+            if 'integrator' in dictionary:
+                self.integrator = dictionary['integrator']
+            if 'shoppingCartExtension' in dictionary:
+                if not isinstance(dictionary['shoppingCartExtension'], dict):
+                    raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['shoppingCartExtension']))
+                self.shopping_cart_extension = ShoppingCartExtension.create_from_dictionary(dictionary['shoppingCartExtension'])
+            return self
+
+    def __init__(self, integrator, shopping_cart_extension=None,
+                 additional_request_headers=()):
+        MetaDataProvider.__validate_additional_request_headers(additional_request_headers)
+        for i in additional_request_headers:
+            i.name = re.sub(r'\r?\n(?:(?![\r\n])\s)*', " ", i.name)
+            i.name = i.name.strip()
+            i.value = re.sub(r'\r?\n(?:(?![\r\n])\s)*', " ", i.value)
+            i.value = i.value.strip()
+        server_meta_info = self.ServerMetaInfo()
+        server_meta_info.platform_identifier = self._platform_identifier
+        server_meta_info.sdk_identifier = self._sdk_identifier
+        server_meta_info.sdk_creator = "Ingenico"
+        server_meta_info.integrator = integrator
+        server_meta_info.shopping_cart_extension = shopping_cart_extension
+
+        server_meta_info_string = DefaultMarshaller.INSTANCE().marshal(server_meta_info)
+        server_meta_info_header = RequestHeader(self.__SERVER_META_INFO_HEADER, b64encode(server_meta_info_string.encode('utf-8')))
+        if not additional_request_headers:
+            self.__meta_data_headers = tuple([server_meta_info_header])
+        else:
+            request_headers = [server_meta_info_header]
+            request_headers.extend(additional_request_headers)
+            self.__meta_data_headers = tuple(request_headers)
+
+    @staticmethod
+    def __validate_additional_request_headers(additional_request_headers):
+        if additional_request_headers is not None:
+            for additional_request_header in additional_request_headers:
+                MetaDataProvider.__validate_additional_request_header(additional_request_header)
+
+    @staticmethod
+    def __validate_additional_request_header(additional_request_header):
+        try:
+            if additional_request_header.name in MetaDataProvider.__PROHIBITED_HEADERS:
+                raise ValueError("request header not allowed: " + str(additional_request_header))
+        except AttributeError:
+            raise AttributeError("Each request header should have an attribute 'name' and an attribute 'value'")
+
+    @IterProperty
+    def prohibited_headers(self):
+        return self.__PROHIBITED_HEADERS
+
+    @property
+    def meta_data_headers(self):
+        """
+        :return: The server related headers containing the META data to be
+         associated with the request (if any). This will always contain at least
+         an automatically generated header X-GCS-ServerMetaInfo.
+        """
+        return self.__meta_data_headers
+
+    @property
+    def _platform_identifier(self):
+        return platform.system() + " " + platform.release() + "/" + \
+               platform.version() + " Python/" + platform.python_version() + \
+               " (" + platform.python_implementation() + "; " + \
+               str(platform.python_compiler()) + ")"
+
+    @property
+    def _sdk_identifier(self):
+        return "Python2ServerSDK/v" + self.__SDK_VERSION

connect-sdk-python2-3.47.0/ingenico/connect/sdk/not_found_exception.py

@@ -0,0 +1,10 @@
+class NotFoundException(RuntimeError):
+    """
+    Indicates an exception that occurs when the requested resource is not found.
+    In normal usage of the SDK, this exception should not occur, however it is possible.
+    For example when path parameters are set with invalid values.
+    """
+
+    def __init__(self, exception, message=None):
+        super(NotFoundException, self).__init__(message, exception)
+        self.cause = exception

connect-sdk-python2-3.47.0/ingenico/connect/sdk/proxy_configuration.py

@@ -0,0 +1,101 @@
+from urlparse import urlparse
+
+
+class ProxyConfiguration:
+    """
+    HTTP proxy configuration.
+
+    Can be initialised directly from a host and port or can be constructed from a uri using fromuri
+    """
+
+    def __init__(self, host, port, scheme="http", username=None, password=None):
+        if not host:
+            raise ValueError("host is required")
+        if not port:
+            raise ValueError("port is required")
+        if port <= 0 or port > 65535:
+            raise ValueError("""port "{}" is invalid""".format(port))
+        self.__scheme = scheme
+        self.__host = host
+        self.__port = port
+        self.__username = username
+        self.__password = password
+
+    @staticmethod
+    def from_uri(uri, username=None, password=None):
+        """
+        Constructs a ProxyConfiguration from a URI; if username and/or password
+        are given they will be used instead of corresponding data in the URI
+        """
+        parsed = urlparse(uri)
+        scheme = parsed.scheme
+        host = parsed.hostname + parsed.path
+        port = parsed.port
+        if username is None:
+            username = parsed.username
+        if password is None:
+            password = parsed.password
+        if port is None:
+            if scheme == "http":
+                port = 80
+            elif scheme == "https":
+                port = 443
+            else:
+                raise ValueError("unsupported scheme: " + scheme)
+        return ProxyConfiguration(scheme=scheme,
+                                  host=host,
+                                  port=port,
+                                  username=username,
+                                  password=password)
+
+    @property
+    def scheme(self):
+        return self.__scheme
+
+    @scheme.setter
+    def scheme(self, scheme):
+        self.__scheme = scheme
+
+    @property
+    def host(self):
+        return self.__host
+
+    @host.setter
+    def host(self, host):
+        self.__host = host
+
+    @property
+    def port(self):
+        return self.__port
+
+    @port.setter
+    def port(self, port):
+        self.__port = port
+
+    @property
+    def username(self):
+        return self.__username
+
+    @username.setter
+    def username(self, username):
+        self.__username = username
+
+    @property
+    def password(self):
+        return self.__password
+
+    @password.setter
+    def password(self, password):
+        self.__password = password
+
+    def __str__(self):
+        """
+        Return a proxy string in the form scheme://username:password@host:port
+        or scheme://host:port if authentication is absent
+
+        Supports HTTP Basic Auth
+        """
+        if self.username is None or self.password is None:
+            return r"{0}://{1}:{2}".format(self.scheme, self.host, self.port)
+        else:
+            return r"{0}://{3}:{4}@{1}:{2}".format(self.scheme, self.host, self.port, self.username, self.password)

connect-sdk-python2-3.47.0/ingenico/connect/sdk/reference_exception.py

@@ -0,0 +1,12 @@
+from api_exception import ApiException
+
+
+class ReferenceException(ApiException):
+    """
+    Represents an error response from the Ingenico ePayments platform when a
+    non-existing or removed object is trying to be accessed.
+    """
+
+    def __init__(self, status_code, response_body, error_id, errors,
+                 message="the Ingenico ePayments platform returned a reference error response"):
+        super(ReferenceException, self).__init__(status_code, response_body, error_id, errors, message)

connect-sdk-python2-3.47.0/ingenico/connect/sdk/request_header.py

@@ -0,0 +1,57 @@
+class RequestHeader:
+    """
+    A single request header. Immutable.
+    """
+
+    def __init__(self, name, value):
+        if name is None or not name.strip():
+            raise ValueError("name is required")
+        self.__name = name
+        self.__value = value
+
+    @property
+    def name(self):
+        """
+        :return: The header name.
+        """
+        return self.__name
+
+    @property
+    def value(self):
+        """
+        :return: The un-encoded value.
+        """
+        return self.__value
+
+    def __str__(self):
+        return self.__name + ":" + self.__value
+
+
+def get_header_value(headers, header_name):
+    """
+    :return: The value of the header with the given name, or None if there was no such header.
+    """
+    if isinstance(headers, dict):
+        for name, value in headers.iteritems():
+            if name.lower() == header_name.lower():
+                return value
+    elif headers is not None:
+        for header in headers:
+            if header.name.lower() == header_name.lower():
+                return header.value
+    return None
+
+
+def get_header(headers, header_name):
+    """
+    :return: The header with the given name, or None if there was no such header.
+    """
+    if isinstance(headers, dict):
+        for name, value in headers.iteritems():
+            if name.lower() == header_name.lower():
+                return RequestHeader(name, value)
+    elif headers is not None:
+        for header in headers:
+            if header.name.lower() == header_name.lower():
+                return header
+    return None

connect-sdk-python2-3.47.0/ingenico/connect/sdk/response_exception.py

@@ -0,0 +1,57 @@
+from response_header import get_header_value, get_header
+
+
+class ResponseException(RuntimeError):
+    """
+    Thrown when a response was received from the Ingenico ePayments platform which
+    indicates an error.
+    """
+
+    def __init__(self, status, body, headers):
+        super(ResponseException, self).__init__("the Ingenico ePayments platform returned an error response")
+        self.__status_code = status
+        self.__headers = headers if headers is not None else {}
+        self.__body = body
+
+    @property
+    def status_code(self):
+        """
+        :return: The HTTP status code that was returned by the Ingenico ePayments platform.
+        """
+        return self.__status_code
+
+    @property
+    def body(self):
+        """
+        :return: The raw response body that was returned by the Ingenico ePayments platform.
+        """
+        return self.__body
+
+    @property
+    def headers(self):
+        """
+        :return: The headers that were returned by the Ingenico ePayments platform. Never None.
+        """
+        return self.__headers
+
+    def get_header(self, header_name):
+        """
+        :return: The header with the given name, or None if there was no such header.
+        """
+        return get_header(self.__headers, header_name)
+
+    def get_header_value(self, header_name):
+        """
+        :return: The value header with the given name, or None if there was no such header.
+        """
+        return get_header_value(self.__headers, header_name)
+
+    def __str__(self):
+        string = super(ResponseException, self).__str__()
+        status_code = self.__status_code
+        if status_code > 0:
+            string += "; status_code=" + str(status_code)
+        response_body = self.__body
+        if response_body:
+            string += "; response_body='" + response_body + "'"
+        return str(string)

connect-sdk-python2-3.47.0/ingenico/connect/sdk/response_header.py

@@ -0,0 +1,49 @@
+import re
+
+
+def get_header_value(headers, header_name):
+    """
+    :return: The value of the header with the given name, or None if there was no such header.
+    """
+    if headers is None:
+        return None
+    for name, value in headers.iteritems():
+        if name.lower() == header_name.lower():
+            return value
+    return None
+
+
+def get_header(headers, header_name):
+    """
+    :return: The header with the given name as a tuple with the name and value, or None if there was no such header.
+    """
+    if headers is None:
+        return None
+    for name, value in headers.iteritems():
+        if name.lower() == header_name.lower():
+            return name, value
+    return None
+
+
+def get_disposition_filename(headers):
+    """
+    :return: The value of the filename parameter of the Content-Disposition header, or None if there was no such header or parameter.
+    """
+    header_value = get_header_value(headers, "Content-Disposition")
+    if header_value is None:
+        return None
+    pattern = re.compile("(?:^|;)\\s*filename\\s*=\\s*(.*?)\\s*(?:;|$)", re.IGNORECASE)
+    match = pattern.search(header_value)
+    if match is not None:
+        filename = match.group(1)
+        return __trim_quotes(filename)
+    return None
+
+
+def __trim_quotes(filename):
+    if len(filename) < 2:
+        return filename
+    if (filename.startswith("\"") and filename.endswith("\"")) or \
+       (filename.startswith("'") and filename.endswith("'")):
+        return filename[1:-1]
+    return filename

connect-sdk-python2-3.47.0/ingenico/connect/sdk/session.py

@@ -0,0 +1,58 @@
+from urlparse import urlparse
+
+
+class Session(object):
+    """
+    Contains the components needed to communicate with the Ingenico ePayments platform.
+
+    :param api_endpoint: the address of the target server as a string or ParseResult object
+    """
+    def __init__(self, api_endpoint, connection, authenticator, meta_data_provider):
+        if api_endpoint is None:
+            raise ValueError("api_endpoint is required")
+        if isinstance(api_endpoint, basestring):
+            api_endpoint = urlparse(api_endpoint)
+        if not api_endpoint.scheme.lower() in ["http", "https"] or not api_endpoint.netloc:
+            raise ValueError("invalid api_endpoint: " + str(api_endpoint))
+        if api_endpoint.path:
+            raise ValueError("api_endpoint should not contain a path")
+        if api_endpoint.username is not None or api_endpoint.query or api_endpoint.fragment:
+            raise ValueError("api_endpoint should not contain user info, query or fragment")
+        if connection is None:
+            raise ValueError("connection is required")
+        if authenticator is None:
+            raise ValueError("authenticator is required")
+        if meta_data_provider is None:
+            raise ValueError("meta_data_provider is required")
+        self.__api_endpoint = api_endpoint
+        self.__connection = connection
+        self.__authenticator = authenticator
+        self.__meta_data_provider = meta_data_provider
+
+    @property
+    def api_endpoint(self):
+        """
+        :return: The Ingenico ePayments platform API endpoint URI. This URI's path will be None or empty.
+        """
+        return self.__api_endpoint
+
+    @property
+    def connection(self):
+        """
+        :return: The Connection object associated with this session. Never None.
+        """
+        return self.__connection
+
+    @property
+    def authenticator(self):
+        """
+        :return: The Authenticator object associated with this session. Never None.
+        """
+        return self.__authenticator
+
+    @property
+    def meta_data_provider(self):
+        """
+        :return: The MetaDataProvider object associated with this session. Never None.
+        """
+        return self.__meta_data_provider