paymentsgate 1.5.0__py3-none-any.whl → 1.5.2__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,26 +1,20 @@
 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 .types import TokenResponse
-from .tokens import (
-  AccessToken,
-  RefreshToken
-)
-from .exceptions import (
-    APIResponseError, 
-    APIAuthenticationError
-)
+from .tokens import AccessToken, RefreshToken
+from .exceptions import APIResponseError, APIAuthenticationError
 from .models import (
-    Credentials, 
-    GetQuoteModel, 
-    GetQuoteResponseModel, 
-    PayInModel, 
-    PayInResponseModel, 
-    PayOutModel, 
+    Credentials,
+    GetQuoteModel,
+    GetQuoteResponseModel,
+    PayInModel,
+    PayInResponseModel,
+    PayOutModel,
     PayOutResponseModel,
     InvoiceModel,
     GetQuoteTlv,
@@ -28,32 +22,240 @@ from .models import (
     QuoteTlvResponse,
 )
 from .enums import ApiPaths
-from .transport import (
-  Request,
-  Response
-)
+from .transport import Request, Response
 from .logger import Logger
-from .cache import (
-  AbstractCache, 
-  DefaultCache
-)
+from .cache import AbstractCache, DefaultCache
+
+import httpx
 
-import requests
 
+class BaseClient:
 
-class ApiClient:
-    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.REQUEST_DEBUG = False
-        self.RESPONSE_DEBUG = False
-        self.timeout = 180
-
+        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(
@@ -61,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.log(request, response)
         if (response.success):
             return response.cast(PayInResponseModel, APIResponseError)
         else:
@@ -80,12 +281,11 @@ 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.log(request, response)
         if (response.success):
             return response.cast(PayOutResponseModel, APIResponseError)
         else:
@@ -95,52 +295,48 @@ class ApiClient:
         request = Request(
             method="post",
             path=ApiPaths.invoices_payout_tlv,
-            content_type='application/json',
+            content_type="application/json",
             noAuth=False,
             signature=False,
-            body=request
+            body=request.model_dump(exclude_none=True),
         )
 
         # Handle response
         response = self._send_request(request)
-        self.log(request, response)
         if not response.success:
             raise APIResponseError(response)
-
         return response.cast(PayOutResponseModel, APIResponseError)
 
     def Quote(self, params: GetQuoteModel) -> GetQuoteResponseModel:
          # Prepare request
         request = Request(
-            method="post",
+            method="get",
             path=ApiPaths.fx_quote,
             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.log(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',
+            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.log(request, response)
         if not response.success:
             raise APIResponseError(response)
 
@@ -158,41 +354,37 @@ class ApiClient:
 
         # Handle response
         response = self._send_request(request)
-        self.log(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('AccessToken')
-        refresh = self.cache.get_token('RefreshToken')
-
+        token = self.cache.get_token('access')
+        refresh = self.cache.get_token('refresh')
         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 = self._refresh_token(token, refresh)
+                refreshed = self._refresh_token()
 
                 if (refreshed.success):
                     access = AccessToken(
-                        refreshed.json_body["access_token"]
+                        response.json_body["access_token"]
                     )
                     refresh = RefreshToken(
-                        refreshed.json_body["refresh_token"],
-                        int(refreshed.json_body["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(
@@ -202,7 +394,6 @@ class ApiClient:
                     response.json_body["refresh_token"],
                     int(response.json_body["expires_in"]),
                 )
-
                 self.cache.set_token(access)
                 self.cache.set_token(refresh)
 
@@ -214,60 +405,40 @@ 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
-        body = 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)
-            try:
-                r = requests.request(
-                    method=request.method,
-                    url=f"{self.baseUrl}{request.path}?{params}",
-                    headers=headers,
-                    timeout=self.timeout
-                )
-            except:
-                print('Error')
-                pass
+            r = httpx.request(
+                method=request.method,
+                url=f"{self.baseUrl}{request.path}?{params}",
+                headers=headers,
+                timeout=self.timeout
+            )
         else:
-            try:
-                r = requests.request(
-                    method=request.method,
-                    url=f"{self.baseUrl}{request.path}",
-                    headers=headers,
-                    json=body,
-                    timeout=self.timeout
-                )
-            except KeyError:
-                print('Error')
-                pass
-
-        # if r == None:
+            r = httpx.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_body={}, status_code=r.status_code)
+        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_body = r.json()
         except json.JSONDecodeError:
             pass
-
-        self.log(request, response)
         return response
 
-    def log(self, request: Request, response: Response):
-        Logger(self, request, response)
-
-    def _get_token(self) -> Response:
+    def _fetch_token(self) -> Response:
         # Prepare request
         request = Request(
             method="post",
@@ -278,27 +449,16 @@ class ApiClient:
         )
         # Handle response
         response = self._send_request(request)
-        self.log(request, response)
         return response
-    
-    def _refresh_token(self, access: AccessToken, refresh: RefreshToken) -> Response:
+
+    def _refresh_token(self) -> Response:
          # Prepare request
         request = Request(
             method="post",
             path=ApiPaths.token_refresh,
             content_type='application/json',
-            noAuth=True,
-            headers={"Authorization": f"Bearer {access.token}" },
-            body={"refresh_token": refresh.token},
+            body={"refresh_token": self.refreshToken},
         )
         # Handle response
         response = self._send_request(request)
-        self.log(request, response)
         return response
-    
-    def loadToken(self, params: TokenResponse):
-        access = AccessToken(params.access_token)
-        refresh = RefreshToken(params.refresh_token, int(params.expires_in))
-        self.cache.set_token(access)
-        self.cache.set_token(refresh)
-