connect-sdk-python3 4.0.0__zip → 4.0.1__zip

connect-sdk-python3-4.0.0/connect_sdk_python3.egg-info/PKG-INFO

@@ -1,136 +0,0 @@
-Metadata-Version: 2.1
-Name: connect-sdk-python3
-Version: 4.0.0
-Summary: SDK to communicate with the Worldline Global Collect platform using the Worldline Connect Server API
-Home-page: https://github.com/Worldline-Global-Collect/connect-sdk-python3
-Author: Worldline Global Collect
-Author-email: github.connect@worldline.com
-License: MIT
-Keywords: Worldline Global Collect Connect SDK
-Platform: python 3.7
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Operating System :: POSIX :: Linux
-Classifier: Operating System :: Microsoft :: Windows
-Classifier: Intended Audience :: Developers
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Topic :: Office/Business :: Financial
-Classifier: License :: OSI Approved :: MIT License
-Requires-Python: >= 3.7
-Description-Content-Type: text/x-rst
-License-File: LICENSE.txt
-
-Worldline Connect Python SDK
-============================
-
-Introduction
-------------
-
-The Python SDK helps you to communicate with the `Worldline Connect <https://docs.connect.worldline-solutions.com/>`__ Server API. Its primary features are:
-
--  convenient Python library for the API calls and responses
-
-   -  marshalls Python request objects to HTTP requests
-   -  unmarshalls HTTP responses to Python response objects or Python exceptions
-
--  handling of all the details concerning authentication
--  handling of required metadata
-
-Its use is demonstrated by an example for each possible call. The examples execute a call using the provided API keys.
-
-See the `Worldline Connect Developer Hub <https://docs.connect.worldline-solutions.com/documentation/sdk/server/python/>`__ for more information on how to use the SDK.
-
-Structure of this repository
-----------------------------
-
-This repository consists out of four main components:
-
-#. The source code of the SDK itself: ``/worldline/connect/sdk/``
-#. The source code of the SDK unit tests: ``/tests/unit/``
-#. The source code of the SDK integration tests: ``/tests/integration/``
-#. Usage examples: ``/examples/``
-
-Note that the source code of the unit tests and integration tests and the examples can only be found on GitHub.
-
-Requirements
-------------
-
-Python 3.7 or higher is required. In addition, the following packages are required:
-
--  `requests <https://requests.readthedocs.io/>`__ 2.25.0 or higher
--  `requests-toolbelt <https://toolbelt.readthedocs.io/>`__ 0.8.0 or higher
-
-These packages will be installed automatically if the SDK is installed manually or using pip following the below instructions.
-
-Installation
-------------
-
-To install the SDK using pip, execute the following command:
-
-.. code:: bash
-
-   pip install connect-sdk-python3
-
-Alternatively, you can install the SDK from a source distribution file:
-
-#. Download the latest version of the Python SDK from GitHub. Choose the ``connect-sdk-python3-x.y.z.zip`` file from the `releases <https://github.com/Worldline-Global-Collect/connect-sdk-python3/releases>`__ page, where ``x.y.z`` is the version number.
-
-#. Execute the following command in the folder where the SDK was downloaded to:
-
-   .. code:: bash
-
-      pip install connect-sdk-python3-x.y.z.zip
-
-Uninstalling
-------------
-
-After the Python SDK has been installed, it can be uninstalled using the following command:
-
-.. code:: bash
-
-   pip uninstall connect-sdk-python3
-
-The required packages can be uninstalled in the same way.
-
-Running tests
--------------
-
-There are two types of tests: unit tests and integration tests. The unit tests will work out-of-the-box; for the integration tests some configuration is required.
-First, some environment variables need to be set:
-
--  ``connect.api.apiKeyId`` for the API key id to use. This can be retrieved from the Configuration Center.
--  ``connect.api.secretApiKey`` for the secret API key to use. This can be retrieved from the Configuration Center.
--  ``connect.api.merchantId`` for your merchant ID.
-
-In addition, to run the proxy integration tests, the proxy URI, username and password should be set in the ``tests/resources/configuration.proxy.ini`` file.
-
-In order to run the unit and integration tests, the `mock <https://pypi.python.org/pypi/mock>`__ backport and `mockito <https://pypi.python.org/pypi/mockito>`__ are required. These can be installed using the following command:
-
-.. code:: bash
-
-   pip install mock mockito
-
-The following commands can now be executed from the ``tests`` directory to execute the tests:
-
--  Unit tests:
-
-   .. code:: bash
-
-      python run_unit_tests.py
-
--  Integration tests:
-
-   .. code:: bash
-
-      python run_integration_tests.py
-
--  Both unit and integration tests:
-
-   .. code:: bash
-
-      python run_all_tests.py

connect-sdk-python3-4.0.0/setup.py

@@ -1,72 +0,0 @@
-import os
-import unittest
-
-from setuptools import setup, find_packages
-
-
-# Utility function to read the README file.
-# Used for the long_description.  It's nice, because now 1) we have a top level
-# README file and 2) it's easier to type in the README file than to put a raw
-# string in below ...
-def read(fname):
-    return open(os.path.join(os.path.dirname(__file__), fname)).read()
-
-
-def test_collector():
-    """Function to collect tests cases to run for the 'pip connect-sdk-python3 tests' command"""
-    from tests import run_unit_tests
-    loader = unittest.TestLoader()
-    return loader.discover(start_dir=run_unit_tests.__file__)
-
-
-setup(
-    name="connect-sdk-python3",
-    version="4.0.0",
-    author="Worldline Global Collect",
-    author_email="github.connect@worldline.com",
-    description="SDK to communicate with the Worldline Global Collect platform using the Worldline Connect Server API",
-    license="MIT",
-    platforms="python 3.7",
-    keywords="Worldline Global Collect Connect SDK",
-    url="https://github.com/Worldline-Global-Collect/connect-sdk-python3",
-    packages=find_packages(
-        exclude=["*.examples", "*.examples.*", "examples.*", "examples",  # exclude examples
-                 "*.tests", "*.tests.*", "tests.*", "tests"],             # and tests
-        include="worldline.*"),  # finds all source packages, recursively
-    # list non-code files used by the SDK
-    package_data={".": ["MANIFEST.in", "README.rst", "setup.py"]},
-    # data_files=[(".", ["LICENSE.txt"])],
-    # installs all files listed in the MANIFEST.in into the installation (currently does not seem to happen either way)
-    include_package_data=True,
-    # data_files=[("index.rst", "README.rst", "setup.py, MANIFEST.in")],  # list miscellaneous files to include
-    # The pypi homepage is based on the long description, standard interpretation is reStructuredText
-    long_description=read('README.rst'),
-    long_description_content_type='text/x-rst',
-    classifiers=[
-        "Development Status :: 5 - Production/Stable",
-        "Operating System :: POSIX :: Linux",
-        "Operating System :: Microsoft :: Windows",
-        "Intended Audience :: Developers",
-        "Programming Language :: Python :: 3 :: Only",
-        "Programming Language :: Python :: 3.7",
-        "Programming Language :: Python :: 3.8",
-        "Programming Language :: Python :: 3.9",
-        "Programming Language :: Python :: 3.10",
-        "Programming Language :: Python :: 3.11",
-        "Programming Language :: Python :: 3.12",
-        "Topic :: Office/Business :: Financial",
-        "License :: OSI Approved :: MIT License"
-    ],
-    scripts=[],  # executable python scripts, none since this is a library
-    python_requires=">= 3.7",
-    install_requires=[
-        "requests >= 2.25.0",
-        "requests-toolbelt >= 0.8.0"
-    ],
-    # test_suite="tests/run_unit_tests"   # enables command 'pip connect-sdk-python3 test', which runs unit tests)
-
-    # setup_requires=[               # setuptools_scm automatically reads the version from version control
-    #     'setuptools_scm'
-    # ],
-    # use_scm_version=True           # turns setuptools_scm on
-)

connect-sdk-python3-4.0.0/worldline/connect/sdk/client.py

@@ -1,98 +0,0 @@
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from base64 import b64encode
-from datetime import timedelta
-from typing import Optional
-
-from .api_resource import ApiResource
-from .communicator import Communicator
-
-from worldline.connect.sdk.log.body_obfuscator import BodyObfuscator
-from worldline.connect.sdk.log.communicator_logger import CommunicatorLogger
-from worldline.connect.sdk.log.header_obfuscator import HeaderObfuscator
-from worldline.connect.sdk.log.logging_capable import LoggingCapable
-from worldline.connect.sdk.log.obfuscation_capable import ObfuscationCapable
-from worldline.connect.sdk.v1.v1_client import V1Client
-
-
-class Client(ApiResource, LoggingCapable, ObfuscationCapable):
-    """
-    Worldline Global Collect platform client.
-    
-    This client and all its child clients are bound to one specific value for the X-GCS-ClientMetaInfo header.
-    To get a new client with a different header value, use with_client_meta_info.
-    
-    Thread-safe.
-    """
-
-    def __init__(self, communicator: Communicator, client_meta_info: Optional[str] = None):
-        """
-        :param communicator:      :class:`worldline.connect.sdk.communicator.Communicator`
-        :param client_meta_info:  str
-        """
-        super(Client, self).__init__(communicator=communicator,
-                                     client_meta_info=client_meta_info)
-
-    def with_client_meta_info(self, client_meta_info: Optional[str]) -> 'Client':
-        """
-        :param client_meta_info: JSON string containing the metadata for the client
-        :return: a new Client which uses the passed metadata for the X-GCS-ClientMetaInfo header.
-        :raise: MarshallerSyntaxException if the given clientMetaInfo is not a valid JSON string
-        """
-        if self._client_meta_info is None and client_meta_info is None:
-            return self
-        if client_meta_info is None:
-            return Client(self._communicator, None)
-        # Checking to see if this is valid JSON (no JSON parse exceptions)
-        self._communicator.marshaller.unmarshal(client_meta_info, object)
-        client_meta_info = b64encode(client_meta_info.encode('utf-8')).decode('utf-8')
-        if client_meta_info == self._client_meta_info:
-            return self
-        return Client(self._communicator, client_meta_info)
-
-    def close_idle_connections(self, idle_time: timedelta) -> None:
-        """
-        Utility method that delegates the call to this client's communicator.
-
-        :param idle_time: a datetime.timedelta object indicating the idle time
-        """
-        self._communicator.close_idle_connections(idle_time)
-
-    def close_expired_connections(self) -> None:
-        """
-        Utility method that delegates the call to this client's communicator.
-        """
-        self._communicator.close_expired_connections()
-
-    def set_body_obfuscator(self, body_obfuscator: BodyObfuscator) -> None:
-        # delegate to the communicator
-        self._communicator.set_body_obfuscator(body_obfuscator)
-
-    def set_header_obfuscator(self, header_obfuscator: HeaderObfuscator) -> None:
-        # delegate to the communicator
-        self._communicator.set_header_obfuscator(header_obfuscator)
-
-    def enable_logging(self, communicator_logger: CommunicatorLogger) -> None:
-        # delegate to the communicator
-        self._communicator.enable_logging(communicator_logger)
-
-    def disable_logging(self) -> None:
-        # delegate to the communicator
-        self._communicator.disable_logging()
-
-    def close(self) -> None:
-        """
-        Releases any system resources associated with this object.
-        """
-        self._communicator.close()
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self.close()
-
-    def v1(self) -> V1Client:
-        return V1Client(self, None)

connect-sdk-python3-4.0.0/worldline/connect/sdk/communication/connection.py

@@ -1,84 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Iterable, Mapping, Sequence, Tuple, Union
-from urllib.parse import ParseResult
-
-from .multipart_form_data_object import MultipartFormDataObject
-from .request_header import RequestHeader
-
-from worldline.connect.sdk.log.logging_capable import LoggingCapable
-from worldline.connect.sdk.log.obfuscation_capable import ObfuscationCapable
-
-
-URI = Union[str, ParseResult]
-RequestBody = Union[str, MultipartFormDataObject, None]
-Response = Tuple[int, Mapping[str, str], Iterable[bytes]]
-
-
-class Connection(LoggingCapable, ObfuscationCapable, ABC):
-    """
-    Represents a connection to the Worldline Global Collect platform server.
-    """
-
-    @abstractmethod
-    def get(self, url: URI, request_headers: Sequence[RequestHeader]) -> Response:
-        """
-        Send a GET request to the Worldline Global Collect platform and return the response.
-
-        :param url: The URI to call, including any necessary query parameters.
-        :param request_headers: An optional sequence of request headers.
-        :return: The response from the Worldline Global Collect platform as a tuple with
-         the status code, headers and a generator of body chunks
-        :raise: CommunicationException when an exception occurred communicating
-         with the Worldline Global Collect platform
-        """
-        raise NotImplementedError
-
-    @abstractmethod
-    def delete(self, url: URI, request_headers: Sequence[RequestHeader]) -> Response:
-        """
-        Send a DELETE request to the Worldline Global Collect platform and return the response.
-
-        :param url: The URI to call, including any necessary query parameters.
-        :param request_headers: An optional sequence of request headers.
-        :return: The response from the Worldline Global Collect platform as a tuple with
-         the status code, headers and a generator of body chunks
-        :raise: CommunicationException when an exception occurred communicating
-         with the Worldline Global Collect platform
-        """
-        raise NotImplementedError
-
-    @abstractmethod
-    def post(self, url: URI, request_headers: Sequence[RequestHeader], body: RequestBody) -> Response:
-        """
-        Send a POST request to the Worldline Global Collect platform and return the response.
-
-        :param url: The URI to call, including any necessary query parameters.
-        :param request_headers: An optional sequence of request headers.
-        :param body: The optional body to send.
-        :return: The response from the Worldline Global Collect platform as a tuple with
-         the status code, headers and a generator of body chunks
-        :raise: CommunicationException when an exception occurred communicating
-         with the Worldline Global Collect platform
-        """
-        raise NotImplementedError
-
-    @abstractmethod
-    def put(self, url: URI, request_headers: Sequence[RequestHeader], body: RequestBody) -> Response:
-        """
-        Send a PUT request to the Worldline Global Collect platform and return the response.
-
-        :param url: The URI to call, including any necessary query parameters.
-        :param request_headers: An optional sequence of request headers.
-        :param body: The optional body to send.
-        :return: The response from the Worldline Global Collect platform as a tuple with
-         the status code, headers and a generator of body chunks
-        :raise: CommunicationException when an exception occurred communicating
-         with the Worldline Global Collect platform
-        """
-        raise NotImplementedError
-
-    def close(self) -> None:
-        """
-        Releases any system resources associated with this object.
-        """
-        pass

connect-sdk-python3-4.0.0/worldline/connect/sdk/communication/metadata_provider.py

@@ -1,131 +0,0 @@
-import platform
-import re
-from base64 import b64encode
-from typing import Optional, Sequence
-
-from .request_header import RequestHeader
-
-from worldline.connect.sdk.domain.data_object import DataObject
-from worldline.connect.sdk.domain.shopping_cart_extension import ShoppingCartExtension
-from worldline.connect.sdk.json.default_marshaller import DefaultMarshaller
-
-
-class IterProperty(object):
-    def __init__(self, func):
-        self.func = func
-
-    def __get__(self, instance, owner):
-        return self.func(owner)
-
-
-class MetadataProvider(object):
-    """
-    Provides meta info about the server.
-    """
-    __sdk_version = "4.0.0"
-    __server_meta_info_header = "X-GCS-ServerMetaInfo"
-    __prohibited_headers = tuple(sorted([__server_meta_info_header, "X-GCS-Idempotence-Key", "Date", "Content-Type", "Authorization"],
-                                        key=str.lower))
-    __metadata_headers: Sequence[RequestHeader] = None
-
-    class ServerMetaInfo(DataObject):
-        platform_identifier = None
-        sdk_identifier = None
-        sdk_creator = None
-        integrator = None
-        shopping_cart_extension = None
-
-        def to_dictionary(self) -> dict:
-            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: dict) -> 'MetadataProvider.ServerMetaInfo':
-            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: Optional[str], shopping_cart_extension: Optional[ShoppingCartExtension] = None,
-                 additional_request_headers: Optional[Sequence[RequestHeader]] = ()):
-        if integrator is None or not integrator.strip():
-            raise ValueError("integrator is required")
-
-        MetadataProvider.__validate_additional_request_headers(additional_request_headers)
-
-        def subber(name_or_value):
-            return re.sub(r'\r?\n(?:(?![\r\n])\s)*', " ", name_or_value).strip()
-        additional_request_headers = [RequestHeader(subber(header.name), subber(header.value)) for header in additional_request_headers]
-
-        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 = "Worldline"
-        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')).decode('utf-8'))
-        if not additional_request_headers:
-            self.__metadata_headers = tuple([server_meta_info_header])
-        else:
-            request_headers = [server_meta_info_header]
-            request_headers.extend(additional_request_headers)
-            self.__metadata_headers = tuple(request_headers)
-
-    @staticmethod
-    def __validate_additional_request_headers(additional_request_headers: Optional[Sequence[RequestHeader]]) -> None:
-        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: RequestHeader) -> None:
-        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) -> Sequence[str]:
-        return self.__prohibited_headers
-
-    @property
-    def metadata_headers(self) -> Sequence[RequestHeader]:
-        """
-        :return: The server related headers containing the metadata to be
-         associated with the request (if any). This will always contain at least
-         an automatically generated header X-GCS-ServerMetaInfo.
-        """
-        return self.__metadata_headers
-
-    @property
-    def _platform_identifier(self) -> str:
-        return platform.system() + " " + platform.release() + "/" + \
-               platform.version() + " Python/" + platform.python_version() + \
-               " (" + platform.python_implementation() + "; " + \
-               str(platform.python_compiler()) + ")"
-
-    @property
-    def _sdk_identifier(self) -> str:
-        return "Python3ServerSDK/v" + self.__sdk_version