paymentsgate 1.4.7__tar.gz

paymentsgate-1.4.7/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 GoPay.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

paymentsgate-1.4.7/PKG-INFO

@@ -0,0 +1,148 @@
+Metadata-Version: 2.1
+Name: paymentsgate
+Version: 1.4.7
+Summary: PaymentsGate's Python SDK for REST API
+Home-page: https://github.com/paymentsgate/python-secure-api
+License: MIT
+Keywords: paymentsgate,payments,sdk,api
+Author: PaymentsGate
+Requires-Python: >=3.9,<4.0
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: jwt (>=1.3.1,<2.0.0)
+Requires-Dist: pydantic (>=2.8.2,<3.0.0)
+Requires-Dist: requests (>=2.31.0,<3.0.0)
+Requires-Dist: tomli (>=2.0.1,<3.0.0)
+Project-URL: Documentation, https://github.com/paymentsgate/python-secure-api
+Project-URL: Repository, https://github.com/paymentsgate/python-secure-api
+Description-Content-Type: text/markdown
+
+
+# Paymentsgate Python SDK for Payments REST API
+
+
+## Requirements
+
+- Python >= 3.8.1
+- dependencies:
+  - [`requests`](https://github.com/kennethreitz/requests)
+  - [`pydantic`](https://docs.pydantic.dev/latest/)
+  - [`jwt`](https://pyjwt.readthedocs.io/en/stable/)
+  
+## Installation
+
+The simplest way to install SDK is to use [PIP](https://docs.python.org/3/installing/):
+
+```bash
+pip install paymentsgate
+```
+
+## Basic usage
+
+```python
+from paymentsgate import ApiClient, Credentials, Currencies
+
+
+# minimal configuration
+config = Credentials().fromFile('/path/to/credentials.json');
+
+# create ApiClient
+client = ApiClient(config, baseUrl='https://api.example.com');
+
+# request quote
+res = cli.Quote(
+  {
+    "amount": 10.10,
+    "currency_from": Currencies.EUR,
+    "currency_to": Currencies.AZN,
+  }
+)
+print(res);
+```
+
+The `credentials.json` file is used to connect to the client and contains all necessary data to use the API. This file can be obtained in your personal cabinet, in the service accounts section. Follow the instructions in the documentation to issue new keys. If you already have keys, but you don't feel comfortable storing them in a file, you can use client initialization via variables. In this case, the key data can be stored in external storage instead of on the file system:
+
+```python
+from paymentsgate import ApiClient, Credentials
+
+config = Credentials(
+  account_id="00000000-4000-4000-0000-00000000000a" 
+  public_key="LS0tLS1CRUdJTiBSU0EgUFJJVkFUNSUlFb3dJQk..."
+)
+
+client = ApiClient(config, baseUrl='https://api.example.com');
+
+...
+```
+*It is important to note that the data format for key transfer is base46.
+
+## Examples
+
+### create PayIn
+
+```python
+res = cli.PayIn(
+  {
+    "amount": 10.10,
+    "currency": Currencies.AZN,
+    "invoiceId": "INVOICE-112123124",
+    "clientId": "",
+    "successUrl": "https://example.com/success",
+    "failUrl": "https://example.com/fail",
+    "type": InvoiceTypes.m10
+  }
+)
+print(res);
+```
+
+### create PayOut
+
+```python
+res = cli.PayOut(
+  {
+    "amount": 5.12,
+    "currencyTo": Currencies.EUR,
+    "invoiceId": "INVOICE-112123124",
+    "clientId": "CLIENT-003010023004",
+    "baseCurrency": CurrencyTypes.fiat,
+    "feesStrategy": FeesStrategy.add,
+    "recipient": {
+      "account_number": "4000000000000012",
+      "account_owner": "CARD HOLDER",
+      "type": CredentialsTypes.card
+    }
+  }
+)
+print(res);
+```
+
+### Error handling
+
+```python
+try:
+  res = cli.PayOut(
+    {
+      "amount": 5.12,
+      "currencyTo": Currencies.EUR,
+      "invoiceId": "INVOICE-112123124",
+      "clientId": "CLIENT-003010023004",
+      "baseCurrency": CurrencyTypes.fiat,
+      "feesStrategy": FeesStrategy.add,
+      "recipient": {
+        "account_number": "4000000000000012",
+        "account_owner": "CARD HOLDER",
+        "type": CredentialsTypes.card
+      }
+    }
+  )
+  print(res);
+except APIAuthenticationError as err:
+  print(f"Authentication fail: {err.message}")
+except APIResponseError as err:
+  print(f"Exception: {err.error}; Message: {err.message}")
+```

paymentsgate-1.4.7/README.md

@@ -0,0 +1,124 @@
+
+# Paymentsgate Python SDK for Payments REST API
+
+
+## Requirements
+
+- Python >= 3.8.1
+- dependencies:
+  - [`requests`](https://github.com/kennethreitz/requests)
+  - [`pydantic`](https://docs.pydantic.dev/latest/)
+  - [`jwt`](https://pyjwt.readthedocs.io/en/stable/)
+  
+## Installation
+
+The simplest way to install SDK is to use [PIP](https://docs.python.org/3/installing/):
+
+```bash
+pip install paymentsgate
+```
+
+## Basic usage
+
+```python
+from paymentsgate import ApiClient, Credentials, Currencies
+
+
+# minimal configuration
+config = Credentials().fromFile('/path/to/credentials.json');
+
+# create ApiClient
+client = ApiClient(config, baseUrl='https://api.example.com');
+
+# request quote
+res = cli.Quote(
+  {
+    "amount": 10.10,
+    "currency_from": Currencies.EUR,
+    "currency_to": Currencies.AZN,
+  }
+)
+print(res);
+```
+
+The `credentials.json` file is used to connect to the client and contains all necessary data to use the API. This file can be obtained in your personal cabinet, in the service accounts section. Follow the instructions in the documentation to issue new keys. If you already have keys, but you don't feel comfortable storing them in a file, you can use client initialization via variables. In this case, the key data can be stored in external storage instead of on the file system:
+
+```python
+from paymentsgate import ApiClient, Credentials
+
+config = Credentials(
+  account_id="00000000-4000-4000-0000-00000000000a" 
+  public_key="LS0tLS1CRUdJTiBSU0EgUFJJVkFUNSUlFb3dJQk..."
+)
+
+client = ApiClient(config, baseUrl='https://api.example.com');
+
+...
+```
+*It is important to note that the data format for key transfer is base46.
+
+## Examples
+
+### create PayIn
+
+```python
+res = cli.PayIn(
+  {
+    "amount": 10.10,
+    "currency": Currencies.AZN,
+    "invoiceId": "INVOICE-112123124",
+    "clientId": "",
+    "successUrl": "https://example.com/success",
+    "failUrl": "https://example.com/fail",
+    "type": InvoiceTypes.m10
+  }
+)
+print(res);
+```
+
+### create PayOut
+
+```python
+res = cli.PayOut(
+  {
+    "amount": 5.12,
+    "currencyTo": Currencies.EUR,
+    "invoiceId": "INVOICE-112123124",
+    "clientId": "CLIENT-003010023004",
+    "baseCurrency": CurrencyTypes.fiat,
+    "feesStrategy": FeesStrategy.add,
+    "recipient": {
+      "account_number": "4000000000000012",
+      "account_owner": "CARD HOLDER",
+      "type": CredentialsTypes.card
+    }
+  }
+)
+print(res);
+```
+
+### Error handling
+
+```python
+try:
+  res = cli.PayOut(
+    {
+      "amount": 5.12,
+      "currencyTo": Currencies.EUR,
+      "invoiceId": "INVOICE-112123124",
+      "clientId": "CLIENT-003010023004",
+      "baseCurrency": CurrencyTypes.fiat,
+      "feesStrategy": FeesStrategy.add,
+      "recipient": {
+        "account_number": "4000000000000012",
+        "account_owner": "CARD HOLDER",
+        "type": CredentialsTypes.card
+      }
+    }
+  )
+  print(res);
+except APIAuthenticationError as err:
+  print(f"Authentication fail: {err.message}")
+except APIResponseError as err:
+  print(f"Exception: {err.error}; Message: {err.message}")
+```

paymentsgate-1.4.7/paymentsgate/__init__.py

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

paymentsgate-1.4.7/paymentsgate/cache.py

@@ -0,0 +1,35 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+
+from paymentsgate.tokens import (
+  AccessToken, 
+  RefreshToken
+)
+
+class AbstractCache(ABC):
+    """
+    Abstract class for implementing custom caches used to cache the token
+    """
+
+    @abstractmethod
+    def get_token(self, key: str) -> AccessToken | RefreshToken:
+        """
+        Fetch a token with the specified key from the cache
+        """
+        ...
+
+    @abstractmethod
+    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)
+    def get_token(self, key: str) -> AccessToken | RefreshToken | None:
+        return self.tokens.get(key)
+
+    def set_token(self, token: AccessToken | RefreshToken) -> None:
+        self.tokens[token.__class__.__name__] = token

paymentsgate-1.4.7/paymentsgate/client.py

@@ -0,0 +1,223 @@
+from __future__ import annotations
+import logging
+from dataclasses import dataclass, is_dataclass, field, asdict
+import json
+from urllib.parse import urlencode
+
+from paymentsgate.tokens import (
+  AccessToken,
+  RefreshToken
+)
+from paymentsgate.exceptions import (
+    APIResponseError, 
+    APIAuthenticationError
+)
+from paymentsgate.models import (
+    Credentials, 
+    GetQuoteModel, 
+    GetQuoteResponseModel, 
+    PayInModel, 
+    PayInResponseModel, 
+    PayOutModel, 
+    PayOutResponseModel
+)
+from paymentsgate.enums import ApiPaths
+from paymentsgate.transport import (
+  Request,
+  Response
+)
+from paymentsgate.logger import Logger
+from paymentsgate.cache import (
+  AbstractCache, 
+  DefaultCache
+)
+
+import requests
+
+
+@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
+
+    def __init__(self, config: Credentials, baseUrl: str, debug: bool=False):
+        self.config = config
+        self.cache = DefaultCache()
+        self.baseUrl = baseUrl
+        if debug:
+            logging.basicConfig(level=logging.DEBUG)
+
+    def PayIn(self, request: PayInModel) -> PayInResponseModel:
+         # Prepare request
+        request = Request(
+            method="post",
+            path=ApiPaths.invoices_payin,
+            content_type='application/json',
+            noAuth=False,
+            body=request,
+        )
+
+        # Handle response
+        response = self._send_request(request)
+        self.logger(request, response)
+        if (response.success):
+            return response.cast(PayInResponseModel, APIResponseError)
+        else:
+            raise APIResponseError(response)
+        
+    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
+        )
+
+        # Handle response
+        response = self._send_request(request)
+        self.logger(request, response)
+        if (response.success):
+            return response.cast(PayOutResponseModel, APIResponseError)
+        else:
+            raise APIResponseError(response)
+
+    def Quote(self, request: GetQuoteModel) -> GetQuoteResponseModel:
+         # Prepare request
+        request = Request(
+            method="get",
+            path=ApiPaths.fx_quote,
+            content_type='application/json',
+            noAuth=False,
+            signature=False,
+            body=request
+        )
+
+        # Handle response
+        response = self._send_request(request)
+        self.logger(request, response)
+        if not response.success:
+            raise APIResponseError(response)
+
+        return response.cast(GetQuoteResponseModel, APIResponseError)
+
+    @property
+    def token(self) -> AccessToken | None:
+        # First check if valid token is cached
+        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()
+
+                if (refreshed.success):
+                    access = AccessToken(
+                        response.json["access_token"]
+                    )
+                    refresh = RefreshToken(
+                        response.json["refresh_token"],
+                        int(response.json["expires_in"]),
+                    )
+                    self.cache.set_token(access)
+                    self.cache.set_token(refresh)
+
+                    return access
+
+            # try to issue token            
+            response = self._get_token()
+            if response.success:
+                
+                access = AccessToken(
+                    response.json["access_token"]
+                )
+                refresh = RefreshToken(
+                    response.json["refresh_token"],
+                    int(response.json["expires_in"]),
+                )
+                self.cache.set_token(access)
+                self.cache.set_token(refresh)
+
+                return access
+            else:
+                raise APIAuthenticationError(response)
+
+    def _send_request(self, request: Request) -> Response:
+        """
+        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
+            if auth is not None:
+                headers["Authorization"] = f"Bearer {auth.token}"
+
+        if (request.method == 'get'):
+            params = urlencode(body)
+            r = requests.request(
+                method=request.method,
+                url=f"{self.baseUrl}{request.path}?{params}",
+                headers=headers,
+                timeout=self.timeout
+            )
+        else:
+            r = requests.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)
+
+        if (self.REQUEST_DEBUG):
+            print(f"{request.method} => {self.baseUrl}{request.path} => {response.status_code}")
+        
+        try:
+            response.json = r.json()
+        except json.JSONDecodeError:
+            pass
+
+        self.logger(request, response)
+        return response
+
+    def _get_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 = self._send_request(request)
+        self.logger(request, response)
+        return response
+    
+    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 = self._send_request(request)
+        self.logger(request, response)
+        return response

paymentsgate-1.4.7/paymentsgate/enums.py

@@ -0,0 +1,161 @@
+from enum import Enum
+
+
+class StrEnum(str, Enum):
+    def __str__(self) -> str:
+        return self.value
+    
+class AuthenticationRealms(StrEnum):
+    production = "production"
+    sandbox = "sandbox"
+
+class ApiPaths(StrEnum):
+    token_issue = "/auth/token"
+    token_refresh = "/auth/token/refresh"
+    token_revoke = "/auth/token/revoke"
+    token_validate = "/auth/token/validate"
+    invoices_payin = "/deals/payin"
+    invoices_payout = "/deals/payout"
+    invoices_info = "/deals/:id"
+    invoices_credentials = "/deals/:id/credentials"
+    assets_list = "/wallet"
+    assets_deposit = "/wallet/deposit"
+    banks_list = "/banks/find"
+    appel_create = "/support/create"
+    appel_list = "/support/list"
+    appel_stat = "/support/statistic"
+    fx_quote = "/fx/calculatenew"
+
+class Currencies(StrEnum):
+    USDT = "USDT"
+    EUR = "EUR"
+    USD = "USD"
+    TRY = "TRY"
+    CNY = "CNY"
+    JPY = "JPY"
+    GEL = "GEL"
+    AZN = "AZN"
+    INR = "INR"
+    AED = "AED"
+    KZT = "KZT"
+    UZS = "UZS"
+    TJS = "TJS"
+    EGP = "EGP"
+    PKR = "PKR"
+    IDR = "IDR"
+    BDT = "BDT"
+    GBP = "GBP"
+    RUB = "RUB"
+    THB = "THB"
+    KGS = "KGS"
+    PHP = "PHP"
+    ZAR = "ZAR"
+    ARS = "ARS"
+    GHS = "GHS"
+    KES = "KES"
+    NGN = "NGN"
+    AMD = "AMD"
+
+class Languages(StrEnum):
+    EN = "EN"
+    IN = "IN"
+    AE = "AE"
+    TR = "TR"
+    GE = "GE"
+    RU = "RU"
+    UZ = "UZ"
+    AZ = "AZ"
+
+
+class Statuses(StrEnum):
+    queued = "queued"
+    new = "new"
+    pending = "pending"
+    paid = "paid"
+    completed = "completed"
+    disputed = "disputed"
+    canceled = "canceled"
+
+
+class CurrencyTypes(StrEnum):
+    fiat = "fiat"
+    crypto = "crypto"
+
+
+class InvoiceTypes(StrEnum):
+    p2p = "p2p"
+    ecom = "ecom"
+    c2c = "c2c"
+    m10 = "m10"
+    mpay = "mpay"
+    sbp = "sbp"
+    sbpqr = "sbpqr"
+    iban = "iban"
+    upi = "upi"
+    imps = "imps"
+    spei = "spei"
+    pix = "pix"
+    rps = "rps"
+    ibps = "ibps"
+    bizum = "bizum"
+    rkgs = "rkgs"
+    kgsphone = "kgsphone"
+    krungthainext = "krungthainext"
+    sber = "sber"
+    kztphone = "kztphone"
+    accountbdt = "accountbdt"
+    alipay = "alipay"
+    accountegp = "accountegp"
+    accountphp = "accountphp"
+    sberqr = "sberqr"
+    maya = "maya"
+    gcash = "gcash"
+    banktransferphp = "banktransferphp"
+    banktransferars = "banktransferars"
+    phonepe = "phonepe"
+    freecharge = "freecharge"
+    instapay = "instapay"
+    vodafonecash = "vodafonecash"
+    razn = "razn"
+    rtjs = "rtjs"
+
+
+class CredentialsTypes(StrEnum):
+    iban = "iban"
+    phone = "phone"
+    card = "card"
+    fps = "fps"
+    account = "account"
+    custom = "custom"
+
+
+class RiskScoreLevels(StrEnum):
+    unclassified = "unclassified"
+    hr = "hr" # highest risk
+    ftd = "ftd" # high risk
+    trusted = "trusted" # low risk
+
+
+class CancellationReason(StrEnum):
+    NO_MONEY = "NO_MONEY"
+    CREDENTIALS_INVALID = "CREDENTIALS_INVALID"
+    EXPIRED = "EXPIRED"
+    PRECHARGE_GAP_UPPER_LIMIT = "PRECHARGE_GAP_UPPER_LIMIT"
+    CROSS_BANK_TFF_LESS_THAN_3K = "CROSS_BANK_TFF_LESS_THAN_3K"
+    CROSS_BANK_UNSUPPORTED = "CROSS_BANK_UNSUPPORTED"
+
+
+class FeesStrategy(StrEnum):
+    add = "add"
+    sub = "sub"
+
+
+class InvoiceDirection(StrEnum):
+    F2C = "F2C"
+    C2F = "C2F"
+
+
+class TTLUnits(StrEnum):
+    sec = "sec"
+    min = "min"
+    hour = "hour"

paymentsgate-1.4.7/paymentsgate/exceptions.py

@@ -0,0 +1,38 @@
+
+from paymentsgate.transport import Response
+
+
+class PaymentsgateError(Exception):
+    pass
+
+
+class APIError(PaymentsgateError):
+    error: str
+    message: str
+    code: int
+    data: object | None
+    details: object | None
+    
+    def __init__(self, error: str, message: str, data: object | None, details: object | None, status: int) -> None: 
+        super().__init__(f"[{error}] {message} (status: {status})")
+        self.error = error
+        self.message = message
+        self.data = data
+        self.code = status;
+        self.details = details;
+
+        if (details is not None):
+            print('Error details:', self.details)
+        if (data is not None):
+            print(self.data)
+        # print(f"{self.error}: {self.message} code: {self.code} details: {self.details}")
+    
+
+
+class APIResponseError(APIError):
+    def __init__(self, response: Response) -> None:
+        super().__init__(response.json.get('error'), response.json.get('message'), response.json.get('data'), response.json.get('details'),  response.status_code)
+
+class APIAuthenticationError(APIError):
+    def __init__(self, response: Response) -> None:
+        super().__init__(response.json.get('error'), response.json.get('message'), response.json.get('data'), response.json.get('details'), response.status_code)

paymentsgate-1.4.7/paymentsgate/logger.py

@@ -0,0 +1,8 @@
+import logging
+from paymentsgate.transport import Request, Response
+
+
+def Logger(self, request: Request, response: Response):
+    logging.debug(f"HTTP Request: {request}")
+    logging.debug(f"HTTP Response: {response}")
+

paymentsgate-1.4.7/paymentsgate/models.py

@@ -0,0 +1,228 @@
+from __future__ import annotations
+from dataclasses import dataclass
+import datetime
+import json
+from typing import Optional, List
+
+from paymentsgate.enums import (
+  Currencies, 
+  InvoiceTypes, 
+  Languages, 
+  Statuses, 
+  TTLUnits, 
+  CurrencyTypes, 
+  FeesStrategy,
+  InvoiceDirection,
+  CredentialsTypes
+)
+
+from pydantic import BaseModel, ConfigDict
+
+@dataclass
+class Credentials:
+  def __init__(
+      self, 
+      account_id: str,
+      merchant_id: str,
+      project_id: str,
+      private_key: str,
+      public_key: str
+  ):
+     self.account_id = account_id
+     self.merchant_id = merchant_id
+     self.project_id = project_id
+     self.private_key = private_key
+     self.public_key = public_key
+  
+  @classmethod
+  def fromFile(cls, filename):
+    data = json.load(open(filename))
+    return cls(data.get('account_id'),
+               data.get('merchant_id'),
+               data.get('project_id'),
+               data.get('private_key'),
+               data.get('public_key'))
+
+
+@dataclass
+class PayInFingerprintBrowserModel:
+  acceptHeader: str
+  colorDepth: int
+  language: str
+  screenHeight: int
+  screenWidth: int
+  timezone: str
+  userAgent: str
+  javaEnabled: bool
+  windowHeight: int
+  windowWidth: int
+
+@dataclass
+class PayInFingerprintModel:
+  fingerprint: str
+  ip: str
+  country: str
+  city: str
+  state: str
+  zip: str
+  browser: Optional[PayInFingerprintBrowserModel]
+
+@dataclass
+class PayInModel:
+  amount: float
+  currency: Currencies
+  invoiceId: Optional[str] # idempotent key
+  clientId: Optional[str]
+  type: InvoiceTypes
+  bankId: Optional[str]
+  trusted: Optional[bool]
+  successUrl: Optional[str]
+  failUrl: Optional[str]
+  backUrl: Optional[str]
+  clientCard: Optional[str]
+  fingerprint: Optional[PayInFingerprintModel]
+  lang: Optional[Languages]
+   
+@dataclass
+class PayInResponseModel:
+  id: str
+  status: Statuses
+  type: InvoiceTypes
+  url: str
+
+@dataclass
+class PayOutRecipientModel:
+  account_number: str
+  account_owner: Optional[str]
+  account_iban: Optional[str]
+  account_swift: Optional[str]
+  account_phone: Optional[str]
+  account_bic: Optional[str]
+  account_ewallet_name: Optional[str]
+  account_email: Optional[str]
+  account_bank_id: Optional[str]
+  type: Optional[CredentialsTypes]
+
+@dataclass
+class PayOutModel:
+  currency: Optional[Currencies] # currency from, by default = usdt
+  currencyTo:Currencies
+  amount: float
+  invoiceId: Optional[str] # idempotent key
+  clientId: Optional[str]
+  ttl: Optional[int]
+  ttl_unit: Optional[TTLUnits]
+  finalAmount: Optional[float]
+  sender_name: Optional[str]
+  baseCurrency: Optional[CurrencyTypes]
+  feesStrategy: Optional[FeesStrategy]
+  recipient: PayOutRecipientModel
+  quoteId: Optional[str]
+   
+@dataclass
+class PayOutResponseModel:
+  id: str
+  status: Statuses
+
+@dataclass
+class GetQuoteModel:
+  currency_from: Currencies
+  currency_to: Currencies
+  amount: float
+  subtype: InvoiceTypes
+
+@dataclass
+class QuoteEntity:
+  currency_from: CurrencyModel
+  currency_to: CurrencyModel
+  pair: str
+  rate: float
+
+@dataclass
+class GetQuoteResponseModel:
+  id: Optional[str]  = None
+  finalAmount: Optional[float]  = None
+  direction: Optional[InvoiceDirection]  = None
+  fullRate: Optional[float]  = None
+  fullRateReverse: Optional[float]  = None
+  fees: Optional[float]  = None
+  fees_percent: Optional[float]  = None
+  quotes: Optional[List[QuoteEntity]]  = None
+  expiredAt: Optional[datetime.datetime] = None
+
+  #deprecated
+  currency_from: Optional[CurrencyModel] = None
+  currency_to: Optional[CurrencyModel] = None
+  currency_middle: Optional[CurrencyModel] = None
+  rate1: Optional[float] = None
+  rate2: Optional[float] = None
+  rate3: Optional[float] = None
+  net_amount: Optional[float] = None
+  metadata: Optional[object] = None
+
+@dataclass
+class DepositAddressResponseModel:
+  currency: Currencies
+  address: str
+  expiredAt: datetime
+
+@dataclass
+class CurrencyModel:
+  _id: str
+  type: CurrencyTypes
+  code: Currencies
+  symbol: str
+  label: Optional[str]
+  decimal: int
+  countryCode: Optional[str]
+  countryName: Optional[str]
+
+@dataclass
+class BankModel:
+  name: str
+  title: str
+  currency: Currencies
+  fpsId: str
+
+@dataclass
+class InvoiceStatusModel:
+  name: Statuses
+  createdAt: datetime
+  updatedAt: datetime
+
+@dataclass
+class InvoiceAmountModel:
+  crypto: float
+  fiat: float
+  fiat_net: float
+
+@dataclass
+class InvoiceMetadataModel:
+  invoiceId: Optional[str]
+  clientId: Optional[str]
+
+@dataclass
+class InvoiceModel:
+  orderId: str
+  projectId: str
+  currencyFrom: CurrencyModel
+  currencyTo: CurrencyModel
+  direction: InvoiceDirection
+  amount: float
+  status: InvoiceStatusModel
+  amounts: InvoiceAmountModel
+  metadata: InvoiceMetadataModel
+  createdAt: datetime
+  updatedAt: datetime
+  expiredAt: datetime
+
+@dataclass
+class AssetsAccountModel:
+  currency: CurrencyModel;
+  total: float
+  pending: float
+  available: float
+
+@dataclass
+class AssetsResponseModel:
+  assets: List[AssetsAccountModel]

paymentsgate-1.4.7/paymentsgate/tokens.py

@@ -0,0 +1,40 @@
+from dataclasses import dataclass
+from jwt import JWT
+import time
+
+@dataclass
+class AccessToken:
+    token: str
+    expiredAt: int
+
+    def __init__(self, token):
+        self.token = token
+        jwdInstance = JWT()
+        parsed = jwdInstance.decode(token, do_verify=False, do_time_check=False)
+        self.expiredAt = int(parsed['exp'])
+    @property
+    def is_expired(self):
+        if self.expiredAt:
+            return int(time.time()) >= self.expiredAt;
+        return True
+
+    def __str__(self) -> str:
+        return self.token
+
+@dataclass
+class RefreshToken:
+    token: str
+    expiredAt: int
+
+    def __init__(self, token, expiredAt):
+        self.token = token
+        self.expiredAt = expiredAt
+    @property
+    def is_expired(self):
+        if self.expiredAt:
+            return int(time.time()) >= self.expiredAt;
+        return True
+
+    def __str__(self) -> str:
+        return self.token
+    

paymentsgate-1.4.7/paymentsgate/transport.py

@@ -0,0 +1,31 @@
+from dataclasses import dataclass
+from pydantic import BaseModel
+
+@dataclass
+class Request:
+    method: str
+    path: str
+    content_type: str = 'application/json'
+    headers: dict[str, str] | None = None
+    body: dict | None = None
+    noAuth: bool | None = False
+    signature: bool | None = False
+
+
+@dataclass
+class Response:
+    raw_body: bytes
+    json: dict
+    status_code: int
+
+    @property
+    def success(self) -> bool:
+        return self.status_code < 400
+
+    def cast(self, model: BaseModel, error: dict):
+        if self.success:
+            return model(**self.json)
+        return error(self.json.get('error'), self.json.get('message'), self.json.get('data'), self.json.get('status'));
+    
+    def __str__(self) -> str:
+       return self.raw_body.decode("utf-8")

paymentsgate-1.4.7/pyproject.toml

@@ -0,0 +1,48 @@
+[tool.poetry]
+authors = ["PaymentsGate"]
+classifiers = [
+  "Development Status :: 5 - Production/Stable",
+  "Intended Audience :: Developers",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+]
+description = "PaymentsGate's Python SDK for REST API"
+documentation = "https://github.com/paymentsgate/python-secure-api"
+homepage = "https://github.com/paymentsgate/python-secure-api"
+keywords = ["paymentsgate", "payments", "sdk", "api"]
+license = "MIT"
+name = "paymentsgate"
+packages = [{include = "paymentsgate"}]
+readme = "README.md"
+repository = "https://github.com/paymentsgate/python-secure-api"
+version = "1.4.7"
+
+[tool.poetry.dependencies]
+pydantic = "^2.8.2"
+python = "^3.9"
+requests = "^2.31.0"
+tomli = "^2.0.1"
+jwt = "^1.3.1"
+
+[tool.poetry.group.dev.dependencies]
+black = ">=23.3,<25.0"
+flake8 = "^7.1.1"
+isort = "^5.12.0"
+pytest = "^8.3.3"
+pytest-coverage = "^0.0"
+pytest-dotenv = "^0.5.2"
+
+[tool.pytest.ini_options]
+addopts = [
+  "--log-cli-level=INFO",
+  "--cov=paymentsgate",
+]
+env_files = [
+  "tests/.sandbox.env",
+]
+
+[tool.isort]
+profile = "black"
+
+[build-system]
+build-backend = "poetry.core.masonry.api"
+requires = ["poetry-core"]

paymentsgate-1.4.7/setup.py

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+from setuptools import setup
+
+packages = \
+['paymentsgate']
+
+package_data = \
+{'': ['*']}
+
+install_requires = \
+['jwt>=1.3.1,<2.0.0',
+ 'pydantic>=2.8.2,<3.0.0',
+ 'requests>=2.31.0,<3.0.0',
+ 'tomli>=2.0.1,<3.0.0']
+
+setup_kwargs = {
+    'name': 'paymentsgate',
+    'version': '1.4.7',
+    'description': "PaymentsGate's Python SDK for REST API",
+    'long_description': '\n# Paymentsgate Python SDK for Payments REST API\n\n\n## Requirements\n\n- Python >= 3.8.1\n- dependencies:\n  - [`requests`](https://github.com/kennethreitz/requests)\n  - [`pydantic`](https://docs.pydantic.dev/latest/)\n  - [`jwt`](https://pyjwt.readthedocs.io/en/stable/)\n  \n## Installation\n\nThe simplest way to install SDK is to use [PIP](https://docs.python.org/3/installing/):\n\n```bash\npip install paymentsgate\n```\n\n## Basic usage\n\n```python\nfrom paymentsgate import ApiClient, Credentials, Currencies\n\n\n# minimal configuration\nconfig = Credentials().fromFile(\'/path/to/credentials.json\');\n\n# create ApiClient\nclient = ApiClient(config, baseUrl=\'https://api.example.com\');\n\n# request quote\nres = cli.Quote(\n  {\n    "amount": 10.10,\n    "currency_from": Currencies.EUR,\n    "currency_to": Currencies.AZN,\n  }\n)\nprint(res);\n```\n\nThe `credentials.json` file is used to connect to the client and contains all necessary data to use the API. This file can be obtained in your personal cabinet, in the service accounts section. Follow the instructions in the documentation to issue new keys. If you already have keys, but you don\'t feel comfortable storing them in a file, you can use client initialization via variables. In this case, the key data can be stored in external storage instead of on the file system:\n\n```python\nfrom paymentsgate import ApiClient, Credentials\n\nconfig = Credentials(\n  account_id="00000000-4000-4000-0000-00000000000a" \n  public_key="LS0tLS1CRUdJTiBSU0EgUFJJVkFUNSUlFb3dJQk..."\n)\n\nclient = ApiClient(config, baseUrl=\'https://api.example.com\');\n\n...\n```\n*It is important to note that the data format for key transfer is base46.\n\n## Examples\n\n### create PayIn\n\n```python\nres = cli.PayIn(\n  {\n    "amount": 10.10,\n    "currency": Currencies.AZN,\n    "invoiceId": "INVOICE-112123124",\n    "clientId": "",\n    "successUrl": "https://example.com/success",\n    "failUrl": "https://example.com/fail",\n    "type": InvoiceTypes.m10\n  }\n)\nprint(res);\n```\n\n### create PayOut\n\n```python\nres = cli.PayOut(\n  {\n    "amount": 5.12,\n    "currencyTo": Currencies.EUR,\n    "invoiceId": "INVOICE-112123124",\n    "clientId": "CLIENT-003010023004",\n    "baseCurrency": CurrencyTypes.fiat,\n    "feesStrategy": FeesStrategy.add,\n    "recipient": {\n      "account_number": "4000000000000012",\n      "account_owner": "CARD HOLDER",\n      "type": CredentialsTypes.card\n    }\n  }\n)\nprint(res);\n```\n\n### Error handling\n\n```python\ntry:\n  res = cli.PayOut(\n    {\n      "amount": 5.12,\n      "currencyTo": Currencies.EUR,\n      "invoiceId": "INVOICE-112123124",\n      "clientId": "CLIENT-003010023004",\n      "baseCurrency": CurrencyTypes.fiat,\n      "feesStrategy": FeesStrategy.add,\n      "recipient": {\n        "account_number": "4000000000000012",\n        "account_owner": "CARD HOLDER",\n        "type": CredentialsTypes.card\n      }\n    }\n  )\n  print(res);\nexcept APIAuthenticationError as err:\n  print(f"Authentication fail: {err.message}")\nexcept APIResponseError as err:\n  print(f"Exception: {err.error}; Message: {err.message}")\n```',
+    'author': 'PaymentsGate',
+    'author_email': 'None',
+    'maintainer': 'None',
+    'maintainer_email': 'None',
+    'url': 'https://github.com/paymentsgate/python-secure-api',
+    'packages': packages,
+    'package_data': package_data,
+    'install_requires': install_requires,
+    'python_requires': '>=3.9,<4.0',
+}
+
+
+setup(**setup_kwargs)