mollie-api-py 1.0.0__py3-none-any.whl

mollie/__init__.py

@@ -0,0 +1,18 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from ._version import (
+    __title__,
+    __version__,
+    __openapi_doc_version__,
+    __gen_version__,
+    __user_agent__,
+)
+from .sdk import *
+from .sdkconfiguration import *
+from .models import *
+
+
+VERSION: str = __version__
+OPENAPI_DOC_VERSION = __openapi_doc_version__
+SPEAKEASY_GENERATOR_VERSION = __gen_version__
+USER_AGENT = __user_agent__

mollie/_hooks/__init__.py

@@ -0,0 +1,5 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from .sdkhooks import *
+from .types import *
+from .registration import *

mollie/_hooks/mollie_hooks.py

@@ -0,0 +1,165 @@
+import uuid
+import sys
+import json
+
+from httpx import Request
+from typing import Union
+from urllib.parse import parse_qs, urlencode, urlparse, urlunparse
+
+from .types import (
+    BeforeRequestHook,
+    BeforeRequestContext,
+)
+
+def generate_idempotency_key() -> str:
+    """
+    Generates a UUID4 to be used as an idempotency key.
+    @see https://docs.mollie.com/reference/api-idempotency#using-an-idempotency-key
+
+    :return: A string representation of a UUID4.
+    """
+    return str(uuid.uuid4())
+
+
+class MollieHooks(BeforeRequestHook):
+    def before_request(self, hook_ctx: BeforeRequestContext, request: Request) -> Union[Request, Exception]:
+        """
+        Modify the request before sending.
+
+        :param hook_ctx: Context for the hook, containing request metadata.
+        :param request: The HTTP request to modify.
+        :return: The modified request or an exception.
+        """
+        # Create a copy of the headers
+        headers = dict(request.headers or {})
+
+        # Add the idempotency key if it doesn't already exist
+        headers = self._handle_idempotency_key(headers)
+
+        # Customize the User Agent header
+        headers = self._customize_user_agent(headers, hook_ctx)
+
+        # Update request with new headers first
+        request = Request(
+            method=request.method,
+            url=request.url,
+            headers=headers,
+            content=request.content,
+            extensions=request.extensions
+        )
+
+        # Then populate profile ID and testmode if OAuth (this may update headers again)
+        if self._is_oauth_request(headers, hook_ctx):
+            request = self._populate_profile_id_and_testmode(request, hook_ctx)
+
+        return request
+
+    def _is_oauth_request(self, headers: dict, hook_ctx: BeforeRequestContext) -> bool:
+        security = hook_ctx.config.security
+
+        if callable(security):
+            security = security()
+
+        if security is None:
+            return False
+
+        o_auth = getattr(security, 'o_auth', None)
+        if o_auth is None:
+            return False
+
+        return headers.get("authorization", None) == f"Bearer {o_auth}"
+
+    def _handle_idempotency_key(self, headers: dict) -> dict:
+        idempotency_key = "idempotency-key"
+        if idempotency_key not in headers or not headers[idempotency_key]:
+            headers[idempotency_key] = generate_idempotency_key()
+        return headers
+    
+    def _customize_user_agent(self, headers: dict, hook_ctx: BeforeRequestContext) -> dict:
+        user_agent_key = "user-agent"
+
+        gen_version = hook_ctx.config.gen_version
+        sdk_version = hook_ctx.config.sdk_version
+        python_version = sys.version.split(" ", maxsplit=1)[0]
+        package_name = "mollie-api-py"
+
+        new_user_agent = f"Speakeasy/{gen_version} Python/{python_version} {package_name}/{sdk_version}"
+        if hook_ctx.config.globals.custom_user_agent:
+            new_user_agent = f"{new_user_agent} {hook_ctx.config.globals.custom_user_agent}"
+
+        headers[user_agent_key] = new_user_agent
+
+        return headers
+    
+    def _populate_profile_id_and_testmode(self, request: Request, hook_ctx: BeforeRequestContext) -> Request:        
+        client_profile_id = hook_ctx.config.globals.profile_id
+        client_testmode = hook_ctx.config.globals.testmode
+
+        # Get the HTTP method
+        method = request.method
+        
+        if method == "GET":
+            # Update the query parameters. If testmode or profileId are not present, add them.
+            parsed_url = urlparse(str(request.url))
+            query_params = parse_qs(parsed_url.query, keep_blank_values=True)
+            
+            # Add profileId if not already present
+            if client_profile_id is not None and 'profileId' not in query_params:
+                query_params['profileId'] = [client_profile_id]
+            
+            # Add testmode if not already present
+            if client_testmode is not None and 'testmode' not in query_params:
+                query_params['testmode'] = [str(client_testmode).lower()]
+            
+            # Rebuild the URL with updated query parameters
+            new_query = urlencode(query_params, doseq=True)
+            new_url = urlunparse((
+                parsed_url.scheme,
+                parsed_url.netloc,
+                parsed_url.path,
+                parsed_url.params,
+                new_query,
+                parsed_url.fragment
+            ))
+            
+            return Request(
+                method=request.method,
+                url=new_url,
+                headers=request.headers,
+                content=request.content,
+                extensions=request.extensions
+            )
+
+        # It's POST, DELETE, PATCH
+        # Update the JSON body. If testmode or profileId are not present, add them.
+        if request.content:
+            try:
+                body = json.loads(request.content)
+            except (json.JSONDecodeError, TypeError):
+                # If it's not JSON, return the request unchanged
+                return request
+        else:
+            body = {}
+        
+        # Add profileId if not already present
+        if client_profile_id is not None and 'profileId' not in body:
+            body['profileId'] = client_profile_id
+        
+        # Add testmode if not already present
+        if client_testmode is not None and 'testmode' not in body:
+            body['testmode'] = client_testmode
+        
+        # Create a new request with updated body
+        new_content = json.dumps(body).encode('utf-8')
+        
+        # Update headers with correct Content-Length
+        new_headers = dict(request.headers)
+        new_headers['content-length'] = str(len(new_content))
+        
+        return Request(
+            method=request.method,
+            url=request.url,
+            headers=new_headers,
+            content=new_content,
+            extensions=request.extensions
+        )

mollie/_hooks/registration.py

@@ -0,0 +1,18 @@
+from .types import Hooks
+
+from .mollie_hooks import MollieHooks
+
+
+# This file is only ever generated once on the first generation and then is free to be modified.
+# Any hooks you wish to add should be registered in the init_hooks function. Feel free to define them
+# in this file or in separate files in the hooks folder.
+
+
+def init_hooks(hooks: Hooks):
+    # pylint: disable=unused-argument
+    """Add hooks by calling hooks.register{sdk_init/before_request/after_success/after_error}Hook
+    with an instance of a hook that implements that specific Hook interface
+    Hooks are registered per SDK instance, and are valid for the lifetime of the SDK instance"""
+
+    mollie_hook = MollieHooks()
+    hooks.register_before_request_hook(mollie_hook)

mollie/_hooks/sdkhooks.py

@@ -0,0 +1,76 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+import httpx
+from .types import (
+    SDKInitHook,
+    BeforeRequestContext,
+    BeforeRequestHook,
+    AfterSuccessContext,
+    AfterSuccessHook,
+    AfterErrorContext,
+    AfterErrorHook,
+    Hooks,
+)
+from .registration import init_hooks
+from typing import List, Optional, Tuple
+from mollie.httpclient import HttpClient
+
+
+class SDKHooks(Hooks):
+    def __init__(self) -> None:
+        self.sdk_init_hooks: List[SDKInitHook] = []
+        self.before_request_hooks: List[BeforeRequestHook] = []
+        self.after_success_hooks: List[AfterSuccessHook] = []
+        self.after_error_hooks: List[AfterErrorHook] = []
+        init_hooks(self)
+
+    def register_sdk_init_hook(self, hook: SDKInitHook) -> None:
+        self.sdk_init_hooks.append(hook)
+
+    def register_before_request_hook(self, hook: BeforeRequestHook) -> None:
+        self.before_request_hooks.append(hook)
+
+    def register_after_success_hook(self, hook: AfterSuccessHook) -> None:
+        self.after_success_hooks.append(hook)
+
+    def register_after_error_hook(self, hook: AfterErrorHook) -> None:
+        self.after_error_hooks.append(hook)
+
+    def sdk_init(self, base_url: str, client: HttpClient) -> Tuple[str, HttpClient]:
+        for hook in self.sdk_init_hooks:
+            base_url, client = hook.sdk_init(base_url, client)
+        return base_url, client
+
+    def before_request(
+        self, hook_ctx: BeforeRequestContext, request: httpx.Request
+    ) -> httpx.Request:
+        for hook in self.before_request_hooks:
+            out = hook.before_request(hook_ctx, request)
+            if isinstance(out, Exception):
+                raise out
+            request = out
+
+        return request
+
+    def after_success(
+        self, hook_ctx: AfterSuccessContext, response: httpx.Response
+    ) -> httpx.Response:
+        for hook in self.after_success_hooks:
+            out = hook.after_success(hook_ctx, response)
+            if isinstance(out, Exception):
+                raise out
+            response = out
+        return response
+
+    def after_error(
+        self,
+        hook_ctx: AfterErrorContext,
+        response: Optional[httpx.Response],
+        error: Optional[Exception],
+    ) -> Tuple[Optional[httpx.Response], Optional[Exception]]:
+        for hook in self.after_error_hooks:
+            result = hook.after_error(hook_ctx, response, error)
+            if isinstance(result, Exception):
+                raise result
+            response, error = result
+        return response, error

mollie/_hooks/types.py

@@ -0,0 +1,113 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from abc import ABC, abstractmethod
+import httpx
+from mollie.httpclient import HttpClient
+from mollie.sdkconfiguration import SDKConfiguration
+from typing import Any, Callable, List, Optional, Tuple, Union
+
+
+class HookContext:
+    config: SDKConfiguration
+    base_url: str
+    operation_id: str
+    oauth2_scopes: Optional[List[str]] = None
+    security_source: Optional[Union[Any, Callable[[], Any]]] = None
+
+    def __init__(
+        self,
+        config: SDKConfiguration,
+        base_url: str,
+        operation_id: str,
+        oauth2_scopes: Optional[List[str]],
+        security_source: Optional[Union[Any, Callable[[], Any]]],
+    ):
+        self.config = config
+        self.base_url = base_url
+        self.operation_id = operation_id
+        self.oauth2_scopes = oauth2_scopes
+        self.security_source = security_source
+
+
+class BeforeRequestContext(HookContext):
+    def __init__(self, hook_ctx: HookContext):
+        super().__init__(
+            hook_ctx.config,
+            hook_ctx.base_url,
+            hook_ctx.operation_id,
+            hook_ctx.oauth2_scopes,
+            hook_ctx.security_source,
+        )
+
+
+class AfterSuccessContext(HookContext):
+    def __init__(self, hook_ctx: HookContext):
+        super().__init__(
+            hook_ctx.config,
+            hook_ctx.base_url,
+            hook_ctx.operation_id,
+            hook_ctx.oauth2_scopes,
+            hook_ctx.security_source,
+        )
+
+
+class AfterErrorContext(HookContext):
+    def __init__(self, hook_ctx: HookContext):
+        super().__init__(
+            hook_ctx.config,
+            hook_ctx.base_url,
+            hook_ctx.operation_id,
+            hook_ctx.oauth2_scopes,
+            hook_ctx.security_source,
+        )
+
+
+class SDKInitHook(ABC):
+    @abstractmethod
+    def sdk_init(self, base_url: str, client: HttpClient) -> Tuple[str, HttpClient]:
+        pass
+
+
+class BeforeRequestHook(ABC):
+    @abstractmethod
+    def before_request(
+        self, hook_ctx: BeforeRequestContext, request: httpx.Request
+    ) -> Union[httpx.Request, Exception]:
+        pass
+
+
+class AfterSuccessHook(ABC):
+    @abstractmethod
+    def after_success(
+        self, hook_ctx: AfterSuccessContext, response: httpx.Response
+    ) -> Union[httpx.Response, Exception]:
+        pass
+
+
+class AfterErrorHook(ABC):
+    @abstractmethod
+    def after_error(
+        self,
+        hook_ctx: AfterErrorContext,
+        response: Optional[httpx.Response],
+        error: Optional[Exception],
+    ) -> Union[Tuple[Optional[httpx.Response], Optional[Exception]], Exception]:
+        pass
+
+
+class Hooks(ABC):
+    @abstractmethod
+    def register_sdk_init_hook(self, hook: SDKInitHook):
+        pass
+
+    @abstractmethod
+    def register_before_request_hook(self, hook: BeforeRequestHook):
+        pass
+
+    @abstractmethod
+    def register_after_success_hook(self, hook: AfterSuccessHook):
+        pass
+
+    @abstractmethod
+    def register_after_error_hook(self, hook: AfterErrorHook):
+        pass

mollie/_version.py

@@ -0,0 +1,15 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+import importlib.metadata
+
+__title__: str = "mollie"
+__version__: str = "1.0.0"
+__openapi_doc_version__: str = "1.0.0"
+__gen_version__: str = "2.730.5"
+__user_agent__: str = "speakeasy-sdk/python 1.0.0 2.730.5 1.0.0 mollie"
+
+try:
+    if __package__ is not None:
+        __version__ = importlib.metadata.version(__package__)
+except importlib.metadata.PackageNotFoundError:
+    pass