paymentsgate 1.4.9__py3-none-any.whl → 1.5.1__py3-none-any.whl

paymentsgate/__init__.py

@@ -1,17 +1,17 @@
 from paymentsgate.client import ApiClient
 from paymentsgate.enums import (
-  AuthenticationRealms,
-  ApiPaths,
-  Currencies,
-  Languages,
-  Statuses,
-  CurrencyTypes,
-  InvoiceTypes,
-  CredentialsTypes,
-  RiskScoreLevels,
-  CancellationReason,
-  FeesStrategy,
-  InvoiceDirection,
-  TTLUnits
+    AuthenticationRealms,
+    ApiPaths,
+    Currencies,
+    Languages,
+    Statuses,
+    CurrencyTypes,
+    InvoiceTypes,
+    CredentialsTypes,
+    RiskScoreLevels,
+    CancellationReason,
+    FeesStrategy,
+    InvoiceDirection,
+    TTLUnits,
 )
-from paymentsgate.models import Credentials
+from paymentsgate.models import Credentials

paymentsgate/cache.py

@@ -1,10 +1,8 @@
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
 
-from paymentsgate.tokens import (
-  AccessToken, 
-  RefreshToken
-)
+from paymentsgate.tokens import AccessToken, RefreshToken
+
 
 class AbstractCache(ABC):
     """
@@ -19,15 +17,19 @@ class AbstractCache(ABC):
         ...
 
     @abstractmethod
-    def set_token(self,token: AccessToken | RefreshToken) -> None:
+    def set_token(self, token: AccessToken | RefreshToken) -> None:
         """
         Save the token to the cache under the specified key
         """
         ...
-    
+
+
 @dataclass
 class DefaultCache(AbstractCache):
-    tokens: dict[str, AccessToken | RefreshToken] = field(default_factory=dict, init=False)
+    tokens: dict[str, AccessToken | RefreshToken] = field(
+        default_factory=dict, init=False
+    )
+
     def get_token(self, key: str) -> AccessToken | RefreshToken | None:
         return self.tokens.get(key)
 

paymentsgate/client.py

@@ -1,58 +1,261 @@
 from __future__ import annotations
 import logging
-from dataclasses import dataclass, is_dataclass, field, asdict
+
 import json
 from urllib.parse import urlencode
+from pydantic import Field, BaseModel
 
-from paymentsgate.tokens import (
-  AccessToken,
-  RefreshToken
-)
-from paymentsgate.exceptions import (
-    APIResponseError, 
-    APIAuthenticationError
-)
-from paymentsgate.models import (
-    Credentials, 
-    GetQuoteModel, 
-    GetQuoteResponseModel, 
-    PayInModel, 
-    PayInResponseModel, 
-    PayOutModel, 
+from .types import TokenResponse
+from .tokens import AccessToken, RefreshToken
+from .exceptions import APIResponseError, APIAuthenticationError
+from .models import (
+    Credentials,
+    GetQuoteModel,
+    GetQuoteResponseModel,
+    PayInModel,
+    PayInResponseModel,
+    PayOutModel,
     PayOutResponseModel,
-    InvoiceModel
-)
-from paymentsgate.enums import ApiPaths
-from paymentsgate.transport import (
-  Request,
-  Response
-)
-from paymentsgate.logger import Logger
-from paymentsgate.cache import (
-  AbstractCache, 
-  DefaultCache
+    InvoiceModel,
+    GetQuoteTlv,
+    PayOutTlvRequest,
+    QuoteTlvResponse,
 )
+from .enums import ApiPaths
+from .transport import Request, Response
+from .logger import Logger
+from .cache import AbstractCache, DefaultCache
 
-import requests
+import httpx
 
-@dataclass
-class ApiClient:
-    baseUrl: str = field(default="", init=False)
-    timeout: int = field(default=180, init=True)
-    logger: Logger = Logger
-    cache: AbstractCache = field(default_factory=DefaultCache)
-    config: Credentials = field(default_factory=dict, init=False)
 
-    REQUEST_DEBUG: bool = False
-    RESPONSE_DEBUG: bool = False
+class BaseClient:
 
-    def __init__(self, config: Credentials, baseUrl: str, debug: bool=False):
+    def __init__(self, config: Credentials, baseUrl: str, timeout: int = 20, debug: bool=False):
         self.config = config
         self.cache = DefaultCache()
         self.baseUrl = baseUrl
+        self.timeout = timeout
         if debug:
             logging.basicConfig(level=logging.DEBUG)
 
+
+class ApiAsyncClient(BaseClient):
+    async def PayIn(self, request: PayInModel) -> PayInResponseModel:
+         # Prepare request
+        request = Request(
+            method="post",
+            path=ApiPaths.invoices_payin,
+            content_type='application/json',
+            noAuth=False,
+            body=request.model_dump(exclude_none=True),
+        )
+
+        # Handle response
+        response = await self._send_request(request)
+        if (response.success):
+            return response.cast(PayInResponseModel, APIResponseError)
+        else:
+            raise APIResponseError(response)
+
+    async def PayOut(self, request: PayOutModel) -> PayOutResponseModel:
+         # Prepare request
+        request = Request(
+            method="post",
+            path=ApiPaths.invoices_payout,
+            content_type='application/json',
+            noAuth=False,
+            signature=True,
+            body=request.model_dump(exclude_none=True)
+        )
+
+        # Handle response
+        response = await self._send_request(request)
+        if (response.success):
+            return response.cast(PayOutResponseModel, APIResponseError)
+        else:
+            raise APIResponseError(response)
+
+    async def PayOutTlv(self, request: PayOutTlvRequest) -> PayOutResponseModel:
+        request = Request(
+            method="post",
+            path=ApiPaths.invoices_payout_tlv,
+            content_type="application/json",
+            noAuth=False,
+            signature=False,
+            body=request.model_dump(exclude_none=True),
+        )
+
+        # Handle response
+        response = await self._send_request(request)
+        if not response.success:
+            raise APIResponseError(response)
+
+        return response.cast(PayOutResponseModel, APIResponseError)
+
+    async def Quote(self, params: GetQuoteModel) -> GetQuoteResponseModel:
+         # Prepare request
+        request = Request(
+            method="get",
+            path=ApiPaths.fx_quote,
+            content_type='application/json',
+            noAuth=False,
+            signature=False,
+            body=params.model_dump(exclude_none=True)
+        )
+
+        # Handle response
+        response = await self._send_request(request)
+        if not response.success:
+            raise APIResponseError(response)
+
+        return response.cast(GetQuoteResponseModel, APIResponseError)
+
+    async def QuoteQr(self, params: GetQuoteTlv) -> QuoteTlvResponse:
+        request = Request(
+            method="post",
+            path=ApiPaths.fx_quote_tlv,
+            content_type="application/json",
+            noAuth=False,
+            signature=False,
+            body=params.model_dump(exclude_none=True),
+        )
+
+        # Handle response
+        response = await self._send_request(request)
+        if not response.success:
+            raise APIResponseError(response)
+
+        return response.cast(QuoteTlvResponse, APIResponseError)
+
+    async def Status(self, id: str) -> InvoiceModel:
+         # Prepare request
+        request = Request(
+            method="get",
+            path=ApiPaths.invoices_info.replace(':id', id),
+            content_type='application/json',
+            noAuth=False,
+            signature=False,
+        )
+
+        # Handle response
+        response = await self._send_request(request)
+        if not response.success:
+            raise APIResponseError(response)
+        return response.cast(InvoiceModel, APIResponseError)
+
+    async def get_token(self) -> AccessToken | None:
+        # First check if valid token is cached
+        token = self.cache.get_token("AccessToken")
+        refresh = self.cache.get_token("RefreshToken")
+
+        if token is not None and not token.is_expired:
+            return token
+        else:
+            # try to refresh token
+            if refresh is not None and not refresh.is_expired:
+                refreshed = await self._refresh_token(token, refresh)
+
+                if refreshed.success:
+                    access = AccessToken(refreshed.json_body["access_token"])
+                    refresh = RefreshToken(
+                        refreshed.json_body["refresh_token"],
+                        int(refreshed.json_body["expires_in"]),
+                    )
+
+                    self.cache.set_token(access)
+                    self.cache.set_token(refresh)
+
+                    return access
+
+            # try to issue token
+            response = await self._fetch_token()
+            if response.success:
+                access = AccessToken(response.json_body["access_token"])
+                refresh = RefreshToken(
+                    response.json_body["refresh_token"],
+                    int(response.json_body["expires_in"]),
+                )
+
+                self.cache.set_token(access)
+                self.cache.set_token(refresh)
+
+                return access
+            else:
+                raise APIAuthenticationError(response)
+
+    async def _send_request(self, request: Request) -> Response:
+        """
+        Send a specified Request to the GoPay REST API and process the response
+        """
+        dict_factory = lambda l: {k: v for k, v in l if v is not None}
+        body = request.body
+        # Add Bearer authentication to headers if needed
+        headers = request.headers or {}
+        if not request.noAuth:
+            auth = await self.get_token()
+            if auth is not None:
+                headers["Authorization"] = f"Bearer {auth.token}"
+
+        client = httpx.AsyncClient(timeout=self.timeout)
+        if request.method == 'get':
+            url = f'{self.baseUrl}{request.path}'
+            if body:
+                params = urlencode(body)
+                url = f'{url}?{params}'
+            r = await client.request(
+		        method=request.method,
+                url=url,
+                headers=headers,
+                timeout=self.timeout
+            )
+        else:
+            r = await client.request(
+		        method=request.method,
+ 		        url=f"{self.baseUrl}{request.path}",
+                headers=headers,
+                json=body,
+                timeout=self.timeout
+            )
+
+        # Build Response instance, try to decode body as JSON
+        response = Response(raw_body=r.content, json={}, status_code=r.status_code)
+
+        try:
+            response.json_body = r.json()
+        except json.JSONDecodeError:
+            pass
+
+        return response
+
+    async def _fetch_token(self) -> Response:
+        # Prepare request
+        request = Request(
+            method="post",
+            path=ApiPaths.token_issue,
+            content_type='application/json',
+            noAuth=True,
+            body={"account_id": self.config.account_id, "public_key": self.config.public_key},
+        )
+        # Handle response
+        response = await self._send_request(request)
+        return response
+    
+    async def _refresh_token(self) -> Response:
+         # Prepare request
+        request = Request(
+            method="post",
+            path=ApiPaths.token_refresh,
+            content_type='application/json',
+            body={"refresh_token": self.refreshToken},
+        )
+        # Handle response
+        response = await self._send_request(request)
+        return response
+
+
+class ApiClient(BaseClient):
+
     def PayIn(self, request: PayInModel) -> PayInResponseModel:
          # Prepare request
         request = Request(
@@ -60,12 +263,11 @@ class ApiClient:
             path=ApiPaths.invoices_payin,
             content_type='application/json',
             noAuth=False,
-            body=request,
+            body=request.model_dump(exclude_none=True),
         )
 
         # Handle response
         response = self._send_request(request)
-        self.logger(request, response)
         if (response.success):
             return response.cast(PayInResponseModel, APIResponseError)
         else:
@@ -79,17 +281,32 @@ class ApiClient:
             content_type='application/json',
             noAuth=False,
             signature=True,
-            body=request
+            body=request.model_dump(exclude_none=True)
         )
 
         # Handle response
         response = self._send_request(request)
-        self.logger(request, response)
         if (response.success):
             return response.cast(PayOutResponseModel, APIResponseError)
         else:
             raise APIResponseError(response)
 
+    def PayOutTlv(self, request: PayOutTlvRequest) -> PayOutResponseModel:
+        request = Request(
+            method="post",
+            path=ApiPaths.invoices_payout_tlv,
+            content_type="application/json",
+            noAuth=False,
+            signature=False,
+            body=request.model_dump(exclude_none=True),
+        )
+
+        # Handle response
+        response = self._send_request(request)
+        if not response.success:
+            raise APIResponseError(response)
+        return response.cast(PayOutResponseModel, APIResponseError)
+
     def Quote(self, params: GetQuoteModel) -> GetQuoteResponseModel:
          # Prepare request
         request = Request(
@@ -98,17 +315,33 @@ class ApiClient:
             content_type='application/json',
             noAuth=False,
             signature=False,
-            body=params
+            body=params.model_dump(exclude_none=True)
         )
 
         # Handle response
         response = self._send_request(request)
-        self.logger(request, response)
         if not response.success:
             raise APIResponseError(response)
 
         return response.cast(GetQuoteResponseModel, APIResponseError)
-    
+
+    def QuoteQr(self, params: GetQuoteTlv) -> QuoteTlvResponse:
+        request = Request(
+            method="post",
+            path=ApiPaths.fx_quote_tlv,
+            content_type="application/json",
+            noAuth=False,
+            signature=False,
+            body=params.model_dump(exclude_none=True),
+        )
+
+        # Handle response
+        response = self._send_request(request)
+        if not response.success:
+            raise APIResponseError(response)
+
+        return response.cast(QuoteTlvResponse, APIResponseError)
+
     def Status(self, id: str) -> InvoiceModel:
          # Prepare request
         request = Request(
@@ -121,14 +354,12 @@ class ApiClient:
 
         # Handle response
         response = self._send_request(request)
-        self.logger(request, response)
         if not response.success:
             raise APIResponseError(response)
 
         return response.cast(InvoiceModel, APIResponseError)
 
-    @property
-    def token(self) -> AccessToken | None:
+    def get_token(self) -> AccessToken | None:
         # First check if valid token is cached
         token = self.cache.get_token('access')
         refresh = self.cache.get_token('refresh')
@@ -141,27 +372,27 @@ class ApiClient:
 
                 if (refreshed.success):
                     access = AccessToken(
-                        response.json["access_token"]
+                        response.json_body["access_token"]
                     )
                     refresh = RefreshToken(
-                        response.json["refresh_token"],
-                        int(response.json["expires_in"]),
+                        response.json_body["refresh_token"],
+                        int(response.json_body["expires_in"]),
                     )
                     self.cache.set_token(access)
                     self.cache.set_token(refresh)
 
                     return access
 
-            # try to issue token            
-            response = self._get_token()
+            # try to issue token
+            response = self._fetch_token()
             if response.success:
                 
                 access = AccessToken(
-                    response.json["access_token"]
+                    response.json_body["access_token"]
                 )
                 refresh = RefreshToken(
-                    response.json["refresh_token"],
-                    int(response.json["expires_in"]),
+                    response.json_body["refresh_token"],
+                    int(response.json_body["expires_in"]),
                 )
                 self.cache.set_token(access)
                 self.cache.set_token(refresh)
@@ -174,24 +405,23 @@ class ApiClient:
         """
         Send a specified Request to the GoPay REST API and process the response
         """
-        body = asdict(request.body) if is_dataclass(request.body) else request.body
         # Add Bearer authentication to headers if needed
         headers = request.headers or {}
         if not request.noAuth:
-            auth = self.token
+            auth = self.get_token()
             if auth is not None:
                 headers["Authorization"] = f"Bearer {auth.token}"
 
         if (request.method == 'get'):
             params = urlencode(body)
-            r = requests.request(
+            r = httpx.request(
                 method=request.method,
                 url=f"{self.baseUrl}{request.path}?{params}",
                 headers=headers,
                 timeout=self.timeout
             )
         else:
-            r = requests.request(
+            r = httpx.request(
                 method=request.method,
                 url=f"{self.baseUrl}{request.path}",
                 headers=headers,
@@ -202,18 +432,13 @@ class ApiClient:
         # Build Response instance, try to decode body as JSON
         response = Response(raw_body=r.content, json={}, status_code=r.status_code)
 
-        if (self.REQUEST_DEBUG):
-            print(f"{request.method} => {self.baseUrl}{request.path} => {response.status_code}")
-        
         try:
-            response.json = r.json()
+            response.json_body = r.json()
         except json.JSONDecodeError:
             pass
-
-        self.logger(request, response)
         return response
 
-    def _get_token(self) -> Response:
+    def _fetch_token(self) -> Response:
         # Prepare request
         request = Request(
             method="post",
@@ -224,9 +449,8 @@ class ApiClient:
         )
         # Handle response
         response = self._send_request(request)
-        self.logger(request, response)
         return response
-    
+
     def _refresh_token(self) -> Response:
          # Prepare request
         request = Request(
@@ -237,5 +461,4 @@ class ApiClient:
         )
         # Handle response
         response = self._send_request(request)
-        self.logger(request, response)
         return response