mt-sdk 0.0.1__py3-none-any.whl

moderntreasury/__init__.py

@@ -0,0 +1,12 @@
+# ruff: noqa: D104 | Missing docstring in public package
+# ruff: noqa: RUF022 | `__all__` is not sorted
+__all__ = [
+    "api_helper",
+    "configuration",
+    "controllers",
+    "exceptions",
+    "http",
+    "models",
+    "moderntreasury_client",
+    "utilities",
+]

moderntreasury/api_helper.py

@@ -0,0 +1,19 @@
+"""
+moderntreasury
+
+This file was automatically generated by APIMATIC v3.0 (
+ https://www.apimatic.io ).
+"""
+
+from apimatic_core.utilities.api_helper import ApiHelper as CoreApiHelper
+
+
+class APIHelper(CoreApiHelper):
+    """
+    A Helper Class for various functions associated with API Calls.
+
+    This class contains static methods for operations that need to be
+    performed during API requests. All of the methods inside this class are
+    static methods, there is no need to ever initialise an instance of this
+    class.
+    """

moderntreasury/configuration.py

@@ -0,0 +1,289 @@
+"""moderntreasury.
+
+This file was automatically generated by APIMATIC v3.0 ( https://www.apimatic.io ).
+"""
+
+# ruff: noqa: E501
+import os
+import warnings
+from enum import Enum
+
+from apimatic_core.http.configurations.http_client_configuration import (
+    HttpClientConfiguration,
+)
+from apimatic_requests_client_adapter.requests_client import (
+    RequestsClient,
+)
+from dotenv import load_dotenv
+
+from moderntreasury.http.proxy_settings import (
+    ProxySettings,
+)
+
+
+class Environment(Enum):
+    """An enum for SDK environments."""
+
+    PRODUCTION = 0
+    ENVIRONMENT2 = 1
+
+    @classmethod
+    def from_value(cls, value, default=None):
+        """Convert a value (string or int) to an Environment enum member.
+
+        Args:
+            value (Union[str, int]): The value to convert.
+            default (Environment): The fallback enum member if conversion fails.
+
+        Returns:
+            Environment: Matching enum member or fallback if invalid.
+
+        """
+        if value is None:
+            return default
+
+        # Try to match directly by enum member
+        if isinstance(value, cls):
+            return value
+
+        # Handle integer or string conversion
+        for member in cls:
+            if (str(member.value).lower() == str(value).lower()
+                or member.name.lower() == str(value).lower()):
+                return member
+
+        # Fallback to provided default
+        return default
+
+
+class Server(Enum):
+    """An enum for API servers."""
+
+    DEFAULT = 0
+
+    @classmethod
+    def from_value(cls, value, default=None):
+        """Convert a value (string or int) to a Server enum member.
+
+        Args:
+            value (Union[str, int]): The value to convert.
+            default (Server): The fallback enum member if conversion fails.
+
+        Returns:
+            Server: Matching enum member or fallback if invalid.
+
+        """
+        if value is None:
+            return default
+
+        # Try to match directly by enum member
+        if isinstance(value, cls):
+            return value
+
+        # Handle integer or string conversion
+        for member in cls:
+            if (str(member.value).lower() == str(value).lower()
+                or member.name.lower() == str(value).lower()):
+                return member
+
+        # Fallback to provided default
+        return default
+
+
+class Configuration(HttpClientConfiguration):
+    """A class used for configuring the SDK by a user."""
+
+    @property
+    def environment(self):
+        """Return current environment."""
+        return self._environment
+
+    @property
+    def basic_auth_user_name(self):
+        """Return Username from BasicAuthCredentials."""
+        return self._basic_auth_credentials.username
+
+    @property
+    def basic_auth_password(self):
+        """Return Password from BasicAuthCredentials."""
+        return self._basic_auth_credentials.password
+
+    @property
+    def basic_auth_credentials(self):
+        """Return BasicAuthCredentials."""
+        return self._basic_auth_credentials
+
+    def __init__(self, http_client_instance=None,
+                 override_http_client_configuration=False, http_call_back=None,
+                 timeout=60, max_retries=0, backoff_factor=2, retry_statuses=None,
+                 retry_methods=None, proxy_settings=None,
+                 environment=Environment.PRODUCTION, basic_auth_user_name=None,
+                 basic_auth_password=None, basic_auth_credentials=None):
+        """Initialize Configuration object."""
+        if retry_methods is None:
+            retry_methods = ["GET", "PUT"]
+
+        if retry_statuses is None:
+            retry_statuses = [408, 413, 429, 500, 502, 503, 504, 521,
+                522, 524]
+
+        super().__init__(
+            http_client_instance=http_client_instance,
+            override_http_client_configuration=override_http_client_configuration,
+            http_call_back=http_call_back, timeout=timeout,
+            max_retries=max_retries, backoff_factor=backoff_factor,
+            retry_statuses=retry_statuses, retry_methods=retry_methods,
+            proxy_settings=proxy_settings,
+        )
+
+        # Current API environment
+        self._environment = environment
+
+        self._basic_auth_credentials =\
+            self.create_auth_credentials_object(basic_auth_user_name,
+                                                basic_auth_password,
+                                                basic_auth_credentials)
+
+        # The Http Client to use for making requests.
+        self.set_http_client(self.create_http_client())
+
+    def clone_with(self, http_client_instance=None,
+                   override_http_client_configuration=None, http_call_back=None,
+                   timeout=None, max_retries=None, backoff_factor=None,
+                   retry_statuses=None, retry_methods=None, proxy_settings=None,
+                   environment=None, basic_auth_user_name=None,
+                   basic_auth_password=None, basic_auth_credentials=None):
+        """Clone configuration with overrides."""
+        http_client_instance = http_client_instance or self.http_client_instance
+        override_http_client_configuration =\
+            (override_http_client_configuration
+            or self.override_http_client_configuration)
+        http_call_back = http_call_back or self.http_callback
+        timeout = timeout or self.timeout
+        max_retries = max_retries or self.max_retries
+        backoff_factor = backoff_factor or self.backoff_factor
+        retry_statuses = retry_statuses or self.retry_statuses
+        retry_methods = retry_methods or self.retry_methods
+        proxy_settings = proxy_settings or self.proxy_settings
+        environment = environment or self.environment
+        basic_auth_credentials = self.create_auth_credentials_object(
+            basic_auth_user_name, basic_auth_password,
+            basic_auth_credentials
+            or self.basic_auth_credentials,
+            stack_level=3)
+        return Configuration(
+            http_client_instance=http_client_instance,
+            override_http_client_configuration=override_http_client_configuration,
+            http_call_back=http_call_back, timeout=timeout, max_retries=max_retries,
+            backoff_factor=backoff_factor, retry_statuses=retry_statuses,
+            retry_methods=retry_methods, proxy_settings=proxy_settings,
+            environment=environment, basic_auth_credentials=basic_auth_credentials,
+        )
+
+    def create_http_client(self):
+        """Create the HTTP client instance."""
+        return RequestsClient(
+            timeout=self.timeout, max_retries=self.max_retries,
+            backoff_factor=self.backoff_factor, retry_statuses=self.retry_statuses,
+            retry_methods=self.retry_methods,
+            http_client_instance=self.http_client_instance,
+            override_http_client_configuration=self.override_http_client_configuration,
+            response_factory=self.http_response_factory,
+            proxies=self.proxy_settings.to_proxies() if self.proxy_settings else None,
+        )
+
+    # All the environments the SDK can run in
+    environments = {
+        Environment.PRODUCTION: {
+            Server.DEFAULT: "http://localhost:3000",
+        },
+        Environment.ENVIRONMENT2: {
+            Server.DEFAULT: "https://app.moderntreasury.com",
+        },
+    }
+
+    def get_base_uri(self, server=Server.DEFAULT):
+        """Generate the appropriate base URI for the environment and the server.
+
+        Args:
+            server (Configuration.Server): The server enum for which the base
+            URI is required.
+
+        Returns:
+            String: The base URI.
+
+        """
+        return self.environments[self.environment][server]
+
+    @staticmethod
+    def create_auth_credentials_object(basic_auth_user_name,
+                                       basic_auth_password,
+                                       basic_auth_credentials, stack_level=4):
+        """Create auth credentials object."""
+        if basic_auth_user_name is None \
+                and basic_auth_password is None:
+            return basic_auth_credentials
+
+        warnings.warn(message=("The 'basic_auth_user_name', 'basic_auth_password' par"
+                               "ams are deprecated. Use 'basic_auth_credentials' para"
+                               "m instead."),
+                      category=DeprecationWarning,
+                      stacklevel=stack_level)
+
+        if basic_auth_credentials is not None:
+            return basic_auth_credentials.clone_with(basic_auth_user_name,
+                                                     basic_auth_password)
+
+        from moderntreasury.http.auth.basic_auth import (
+            BasicAuthCredentials,
+        )
+        return BasicAuthCredentials(basic_auth_user_name, basic_auth_password)
+
+    @classmethod
+    def from_environment(cls, dotenv_path=None, **overrides):
+        """Create Configuration object from .env and environment variables.
+
+        Args:
+            dotenv_path (str, optional): Path to the .env file to load.
+             If None, the default .env file is used.
+            **overrides: Optional values overriding setting from environment variables.
+
+        Returns:
+            Configuration: A configuration object populated with the resolved values.
+
+        """
+        # load .env automatically
+        load_dotenv(dotenv_path or None, override=True)
+
+        override_http_client_configuration = os.getenv(
+            "OVERRIDE_HTTP_CLIENT_CONFIGURATION", "false").lower() == "true"
+        timeout = int(os.getenv("TIMEOUT", "60"))
+        max_retries = int(os.getenv("MAX_RETRIES", "0"))
+        backoff_factor = float(os.getenv("BACKOFF_FACTOR", "2"))
+        statuses = os.getenv("RETRY_STATUSES", None)
+        retry_statuses = [int(v.strip()) for v in statuses.split(",")
+                          if v.strip().isdigit()] if statuses else None
+        methods = os.getenv("RETRY_METHODS", None)
+        retry_methods = [v.strip() for v in methods.split(",") if v.strip()]\
+            if methods else None
+        environment = Environment.from_value(
+            os.getenv("ENVIRONMENT"), Environment.PRODUCTION)
+
+        from moderntreasury.http.auth.basic_auth import (
+            BasicAuthCredentials,
+        )
+
+        # Preparing default configuration
+        default_config = cls(
+            override_http_client_configuration=override_http_client_configuration,
+            timeout=timeout,
+            max_retries=max_retries,
+            backoff_factor=backoff_factor,
+            retry_statuses=retry_statuses,
+            retry_methods=retry_methods,
+            environment=environment,
+            proxy_settings=ProxySettings.from_environment(),
+            basic_auth_credentials=BasicAuthCredentials.from_environment(),
+        )
+
+        return default_config.clone_with(**overrides)

moderntreasury/controllers/__init__.py

@@ -0,0 +1,40 @@
+# ruff: noqa: D104 | Missing docstring in public package
+# ruff: noqa: RUF022 | `__all__` is not sorted
+__all__ = [
+    "account_collection_flow_controller",
+    "account_detail_controller",
+    "balance_report_controller",
+    "base_controller",
+    "connection_controller",
+    "counterparty_controller",
+    "document_controller",
+    "event_controller",
+    "expected_payment_controller",
+    "external_account_controller",
+    "incoming_payment_detail_controller",
+    "internal_account_controller",
+    "invoice_controller",
+    "invoice_line_item_controller",
+    "ledger_account_category_controller",
+    "ledger_account_controller",
+    "ledger_account_payout_controller",
+    "ledger_account_statement_controller",
+    "ledger_controller",
+    "ledger_entry_controller",
+    "ledger_event_handler_controller",
+    "ledger_transaction_controller",
+    "ledgerable_event_controller",
+    "line_item_controller",
+    "paper_item_controller",
+    "payment_flow_controller",
+    "payment_order_controller",
+    "payment_reference_controller",
+    "ping_controller",
+    "return_controller",
+    "reversal_controller",
+    "routing_detail_controller",
+    "transaction_controller",
+    "transaction_line_item_controller",
+    "validation_controller",
+    "virtual_account_controller",
+]

moderntreasury/controllers/account_collection_flow_controller.py

@@ -0,0 +1,228 @@
+"""moderntreasury.
+
+This file was automatically generated by APIMATIC v3.0 ( https://www.apimatic.io ).
+"""
+
+# ruff: noqa: D410, E501, E101, D206
+from apimatic_core.authentication.multiple.single_auth import (
+    Single,
+)
+from apimatic_core.request_builder import RequestBuilder
+from apimatic_core.response_handler import ResponseHandler
+from apimatic_core.types.parameter import Parameter
+
+from moderntreasury.api_helper import APIHelper
+from moderntreasury.configuration import Server
+from moderntreasury.controllers.base_controller import (
+    BaseController,
+)
+from moderntreasury.exceptions.error_message_exception import (
+    ErrorMessageException,
+)
+from moderntreasury.http.http_method_enum import (
+    HttpMethodEnum,
+)
+from moderntreasury.models.account_collection_flow import (
+    AccountCollectionFlow,
+)
+
+
+class AccountCollectionFlowController(BaseController):
+    """A Controller to access Endpoints in the moderntreasury API."""
+
+    def __init__(self, config):
+        """Initialize AccountCollectionFlowController object."""
+        super(AccountCollectionFlowController, self).__init__(config)
+
+    def list_account_collection_flows(self,
+                                      after_cursor=None,
+                                      per_page=None,
+                                      client_token=None,
+                                      status=None,
+                                      counterparty_id=None,
+                                      external_account_id=None):
+        """Perform a GET request to /api/account_collection_flows.
+
+        Args:
+            after_cursor (str, optional): The request query parameter.
+            per_page (int, optional): The request query parameter.
+            client_token (str, optional): The request query parameter.
+            status (str, optional): The request query parameter.
+            counterparty_id (str, optional): The request query parameter.
+            external_account_id (str, optional): The request query parameter.
+
+        Returns:
+            List[AccountCollectionFlow]: Response from the API. successful
+
+        Raises:
+            APIException: When an error occurs while fetching the data from the
+                remote API. This exception includes the HTTP Response code, an error
+                message, and the HTTP body that was received in the request.
+
+        """
+        return super().new_api_call_builder.request(
+            RequestBuilder().server(Server.DEFAULT)
+            .path("/api/account_collection_flows")
+            .http_method(HttpMethodEnum.GET)
+            .query_param(Parameter()
+                .key("after_cursor")
+                .value(after_cursor))
+            .query_param(Parameter()
+                .key("per_page")
+                .value(per_page))
+            .query_param(Parameter()
+                .key("client_token")
+                .value(client_token))
+            .query_param(Parameter()
+                .key("status")
+                .value(status))
+            .query_param(Parameter()
+                .key("counterparty_id")
+                .value(counterparty_id))
+            .query_param(Parameter()
+                .key("external_account_id")
+                .value(external_account_id))
+            .header_param(Parameter()
+                .key("accept")
+                .value("application/json"))
+            .auth(Single("basic_auth")),
+        ).response(
+            ResponseHandler()
+            .deserializer(APIHelper.json_deserialize)
+            .deserialize_into(AccountCollectionFlow.from_dictionary),
+        ).execute()
+
+    def create_account_collection_flow(self,
+                                       idempotency_key=None,
+                                       body=None):
+        """Perform a POST request to /api/account_collection_flows.
+
+        Args:
+            idempotency_key (str, optional): This key should be something unique,
+                preferably something like an UUID.
+            body (AccountCollectionFlowCreateRequest, optional): The request body
+                parameter.
+
+        Returns:
+            AccountCollectionFlow: Response from the API. successful
+
+        Raises:
+            APIException: When an error occurs while fetching the data from the
+                remote API. This exception includes the HTTP Response code, an error
+                message, and the HTTP body that was received in the request.
+
+        """
+        return super().new_api_call_builder.request(
+            RequestBuilder().server(Server.DEFAULT)
+            .path("/api/account_collection_flows")
+            .http_method(HttpMethodEnum.POST)
+            .header_param(Parameter()
+                .key("Content-Type")
+                .value("application/json"))
+            .header_param(Parameter()
+                .key("Idempotency-Key")
+                .value(idempotency_key))
+            .body_param(Parameter()
+                .value(body))
+            .header_param(Parameter()
+                .key("accept")
+                .value("application/json"))
+            .body_serializer(APIHelper.json_serialize)
+            .auth(Single("basic_auth")),
+        ).response(
+            ResponseHandler()
+            .deserializer(APIHelper.json_deserialize)
+            .deserialize_into(AccountCollectionFlow.from_dictionary)
+            .local_error("422", "unsuccessful", ErrorMessageException),
+        ).execute()
+
+    def get_account_collection_flow(self,
+                                    id,
+                                    idempotency_key=None):
+        """Perform a GET request to /api/account_collection_flows/{id}.
+
+        Args:
+            id (str): id
+            idempotency_key (str, optional): This key should be something unique,
+                preferably something like an UUID.
+
+        Returns:
+            AccountCollectionFlow: Response from the API. successful
+
+        Raises:
+            APIException: When an error occurs while fetching the data from the
+                remote API. This exception includes the HTTP Response code, an error
+                message, and the HTTP body that was received in the request.
+
+        """
+        return super().new_api_call_builder.request(
+            RequestBuilder().server(Server.DEFAULT)
+            .path("/api/account_collection_flows/{id}")
+            .http_method(HttpMethodEnum.GET)
+            .template_param(Parameter()
+                .key("id")
+                .value(id)
+                .should_encode(True))
+            .header_param(Parameter()
+                .key("Idempotency-Key")
+                .value(idempotency_key))
+            .header_param(Parameter()
+                .key("accept")
+                .value("application/json"))
+            .auth(Single("basic_auth")),
+        ).response(
+            ResponseHandler()
+            .deserializer(APIHelper.json_deserialize)
+            .deserialize_into(AccountCollectionFlow.from_dictionary),
+        ).execute()
+
+    def update_account_collection_flow(self,
+                                       id,
+                                       idempotency_key=None,
+                                       body=None):
+        """Perform a PATCH request to /api/account_collection_flows/{id}.
+
+        Args:
+            id (str): id
+            idempotency_key (str, optional): This key should be something unique,
+                preferably something like an UUID.
+            body (AccountCollectionFlowUpdateRequest, optional): The request body
+                parameter.
+
+        Returns:
+            AccountCollectionFlow: Response from the API. successful
+
+        Raises:
+            APIException: When an error occurs while fetching the data from the
+                remote API. This exception includes the HTTP Response code, an error
+                message, and the HTTP body that was received in the request.
+
+        """
+        return super().new_api_call_builder.request(
+            RequestBuilder().server(Server.DEFAULT)
+            .path("/api/account_collection_flows/{id}")
+            .http_method(HttpMethodEnum.PATCH)
+            .template_param(Parameter()
+                .key("id")
+                .value(id)
+                .should_encode(True))
+            .header_param(Parameter()
+                .key("Content-Type")
+                .value("application/json"))
+            .header_param(Parameter()
+                .key("Idempotency-Key")
+                .value(idempotency_key))
+            .body_param(Parameter()
+                .value(body))
+            .header_param(Parameter()
+                .key("accept")
+                .value("application/json"))
+            .body_serializer(APIHelper.json_serialize)
+            .auth(Single("basic_auth")),
+        ).response(
+            ResponseHandler()
+            .deserializer(APIHelper.json_deserialize)
+            .deserialize_into(AccountCollectionFlow.from_dictionary)
+            .local_error("404", "not found", ErrorMessageException)
+            .local_error("422", "unsuccessful", ErrorMessageException),
+        ).execute()