paymentsgate 1.4.8__py3-none-any.whl → 1.5.0__py3-none-any.whl

paymentsgate/client.py

@@ -1,18 +1,20 @@
 from __future__ import annotations
 import logging
-from dataclasses import dataclass, is_dataclass, field, asdict
+# from dataclasses import dataclass, is_dataclass, field, asdict
 import json
 from urllib.parse import urlencode
+from pydantic import Field, BaseModel
 
-from paymentsgate.tokens import (
+from .types import TokenResponse
+from .tokens import (
   AccessToken,
   RefreshToken
 )
-from paymentsgate.exceptions import (
+from .exceptions import (
     APIResponseError, 
     APIAuthenticationError
 )
-from paymentsgate.models import (
+from .models import (
     Credentials, 
     GetQuoteModel, 
     GetQuoteResponseModel, 
@@ -20,36 +22,35 @@ from paymentsgate.models import (
     PayInResponseModel, 
     PayOutModel, 
     PayOutResponseModel,
-    InvoiceModel
+    InvoiceModel,
+    GetQuoteTlv,
+    PayOutTlvRequest,
+    QuoteTlvResponse,
 )
-from paymentsgate.enums import ApiPaths
-from paymentsgate.transport import (
+from .enums import ApiPaths
+from .transport import (
   Request,
   Response
 )
-from paymentsgate.logger import Logger
-from paymentsgate.cache import (
+from .logger import Logger
+from .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
 
+class ApiClient:
     def __init__(self, config: Credentials, baseUrl: str, debug: bool=False):
         self.config = config
         self.cache = DefaultCache()
         self.baseUrl = baseUrl
+        
+        self.REQUEST_DEBUG = False
+        self.RESPONSE_DEBUG = False
+        self.timeout = 180
+
         if debug:
             logging.basicConfig(level=logging.DEBUG)
 
@@ -65,7 +66,7 @@ class ApiClient:
 
         # Handle response
         response = self._send_request(request)
-        self.logger(request, response)
+        self.log(request, response)
         if (response.success):
             return response.cast(PayInResponseModel, APIResponseError)
         else:
@@ -84,45 +85,80 @@ class ApiClient:
 
         # Handle response
         response = self._send_request(request)
-        self.logger(request, response)
+        self.log(request, response)
         if (response.success):
             return response.cast(PayOutResponseModel, APIResponseError)
         else:
             raise APIResponseError(response)
 
-    def Quote(self, request: GetQuoteModel) -> GetQuoteResponseModel:
+    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
+        )
+
+        # 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="get",
+            method="post",
             path=ApiPaths.fx_quote,
             content_type='application/json',
             noAuth=False,
             signature=False,
-            body=request
+            body=params
         )
 
         # Handle response
         response = self._send_request(request)
-        self.logger(request, response)
+        self.log(request, response)
         if not response.success:
             raise APIResponseError(response)
 
         return response.cast(GetQuoteResponseModel, APIResponseError)
     
-    def Status(self, query: str) -> InvoiceModel:
+    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
+        )
+
+        # Handle response
+        response = self._send_request(request)
+        self.log(request, response)
+        if not response.success:
+            raise APIResponseError(response)
+
+        return response.cast(QuoteTlvResponse, APIResponseError)
+
+    def Status(self, id: str) -> InvoiceModel:
          # Prepare request
         request = Request(
             method="get",
-            path=ApiPaths.invoices_info,
+            path=ApiPaths.invoices_info.replace(':id', id),
             content_type='application/json',
             noAuth=False,
             signature=False,
-            body=request
         )
 
         # Handle response
         response = self._send_request(request)
-        self.logger(request, response)
+        self.log(request, response)
         if not response.success:
             raise APIResponseError(response)
 
@@ -131,23 +167,25 @@ class ApiClient:
     @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')
+        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 = self._refresh_token()
+                refreshed = self._refresh_token(token, refresh)
 
                 if (refreshed.success):
                     access = AccessToken(
-                        response.json["access_token"]
+                        refreshed.json_body["access_token"]
                     )
                     refresh = RefreshToken(
-                        response.json["refresh_token"],
-                        int(response.json["expires_in"]),
+                        refreshed.json_body["refresh_token"],
+                        int(refreshed.json_body["expires_in"]),
                     )
+
                     self.cache.set_token(access)
                     self.cache.set_token(refresh)
 
@@ -158,12 +196,13 @@ class ApiClient:
             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)
 
@@ -175,7 +214,8 @@ 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 = 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:
@@ -185,35 +225,48 @@ class ApiClient:
 
         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
-            )
+            try:
+                r = requests.request(
+                    method=request.method,
+                    url=f"{self.baseUrl}{request.path}?{params}",
+                    headers=headers,
+                    timeout=self.timeout
+                )
+            except:
+                print('Error')
+                pass
         else:
-            r = requests.request(
-                method=request.method,
-                url=f"{self.baseUrl}{request.path}",
-                headers=headers,
-                json=body,
-                timeout=self.timeout
-            )
+            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:
 
         # Build Response instance, try to decode body as JSON
-        response = Response(raw_body=r.content, json={}, status_code=r.status_code)
+        response = Response(raw_body=r.content, json_body={}, 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)
+        self.log(request, response)
         return response
 
+    def log(self, request: Request, response: Response):
+        Logger(self, request, response)
+
     def _get_token(self) -> Response:
         # Prepare request
         request = Request(
@@ -225,18 +278,27 @@ class ApiClient:
         )
         # Handle response
         response = self._send_request(request)
-        self.logger(request, response)
+        self.log(request, response)
         return response
     
-    def _refresh_token(self) -> Response:
+    def _refresh_token(self, access: AccessToken, refresh: RefreshToken) -> Response:
          # Prepare request
         request = Request(
             method="post",
             path=ApiPaths.token_refresh,
             content_type='application/json',
-            body={"refresh_token": self.refreshToken},
+            noAuth=True,
+            headers={"Authorization": f"Bearer {access.token}" },
+            body={"refresh_token": refresh.token},
         )
         # Handle response
         response = self._send_request(request)
-        self.logger(request, response)
+        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)
+

paymentsgate/enums.py

@@ -16,6 +16,7 @@ class ApiPaths(StrEnum):
     token_validate = "/auth/token/validate"
     invoices_payin = "/deals/payin"
     invoices_payout = "/deals/payout"
+    invoices_payout_tlv = "/deals/tlv"
     invoices_info = "/deals/:id"
     invoices_credentials = "/deals/:id/credentials"
     assets_list = "/wallet"
@@ -25,6 +26,7 @@ class ApiPaths(StrEnum):
     appel_list = "/support/list"
     appel_stat = "/support/statistic"
     fx_quote = "/fx/calculatenew"
+    fx_quote_tlv = "/fx/tlv"
 
 class Currencies(StrEnum):
     USDT = "USDT"
@@ -57,14 +59,16 @@ class Currencies(StrEnum):
     AMD = "AMD"
 
 class Languages(StrEnum):
-    EN = "EN"
-    IN = "IN"
-    AE = "AE"
-    TR = "TR"
-    GE = "GE"
-    RU = "RU"
-    UZ = "UZ"
-    AZ = "AZ"
+    EN = "EN",
+    AZ = "AZ",
+    UZ = "UZ",
+    GE = "GE",
+    TR = "TR",
+    AE = "AE",
+    RU = "RU",
+    IN = "IN",
+    AR = "AR",
+    KG = "KG"
 
 
 class Statuses(StrEnum):
@@ -118,14 +122,42 @@ class InvoiceTypes(StrEnum):
     vodafonecash = "vodafonecash"
     razn = "razn"
     rtjs = "rtjs"
-
+    sberpay = "sberpay",
+    tpay = "tpay",
+    opay = "opay",
+    moniepoint = "moniepoint",
+    palmpay = "palmpay",
+    wave = "wave",
+    orangemoney = "orangemoney",
+    moovmoney = "moovmoney",
+    rtjscard = "rtjscard",
+    ruzs = "ruzs",
+    amobile = "amobile",
+    payid = "payid",
+    baridi = "baridi",
+    multiwidget = "multiwidget",
+    attijari = "attijari",
+    cih = "cih",
+    cashplus = "cashplus",
+    elqr = "elqr",
+    odengi = "odengi"
+
+class EELQRBankALias(StrEnum):
+    bakai = 'bakai',
+    mbank = 'mbank',
+    optima = 'optima',
+    kicb = 'kicb',
+    odengi = 'odengi',
+    demir = 'demir',
+    megapay = 'megapay',
 
 class CredentialsTypes(StrEnum):
-    iban = "iban"
-    phone = "phone"
-    card = "card"
-    fps = "fps"
-    account = "account"
+    iban = "iban",
+    phone = "phone",
+    card = "card",
+    fps = "fps",
+    qr = "qr",
+    account = "account",
     custom = "custom"
 
 
@@ -137,12 +169,13 @@ class RiskScoreLevels(StrEnum):
 
 
 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"
+    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",
+    ACCOUNT_NUMBER_BLACKLISTED = "ACCOUNT_NUMBER_BLACKLISTED"
 
 
 class FeesStrategy(StrEnum):
@@ -151,8 +184,10 @@ class FeesStrategy(StrEnum):
 
 
 class InvoiceDirection(StrEnum):
-    F2C = "F2C"
-    C2F = "C2F"
+    F2C = "F2C",
+    C2F = "C2F",
+    FIAT_IN = "FIAT_IN",
+    FIAT_OUT = "FIAT_OUT"
 
 
 class TTLUnits(StrEnum):

paymentsgate/exceptions.py

@@ -31,8 +31,8 @@ class APIError(PaymentsgateError):
 
 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)
+        super().__init__(response.json_body.get('error'), response.json_body.get('message'), response.json_body.get('data'), response.json_body.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)
+        super().__init__(response.json_body.get('error'), response.json_body.get('message'), response.json_body.get('data'), response.json_body.get('details'), response.status_code)

paymentsgate/mappers.py

@@ -0,0 +1,4 @@
+
+# def QuoteResponseMapper(self, request: , response: Response):
+#     logging.debug(f"HTTP Request: {request}")
+#     logging.debug(f"HTTP Response: {response}")

paymentsgate/models.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
-from dataclasses import dataclass
 import datetime
 import json
 from typing import Optional, List
+from pydantic import BaseModel, ConfigDict, Field
+
 
 from paymentsgate.enums import (
   Currencies, 
@@ -16,36 +17,29 @@ from paymentsgate.enums import (
   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
+class BaseRequestModel(BaseModel):
+  model_config = ConfigDict(extra='forbid')
+
+class BaseResponseModel(BaseModel):
+  model_config = ConfigDict(extra='ignore')
+
+
+class Credentials(BaseModel):
+  account_id: str
+  public_key: str
+  private_key: Optional[str] = Field(default=None)
+  merchant_id: Optional[str] = Field(default=None)
+  project_id: Optional[str] = Field(default=None)
   
   @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'))
+    return cls(**data)
+  
+  model_config = ConfigDict(extra='ignore')
 
 
-@dataclass
-class PayInFingerprintBrowserModel:
+class PayInFingerprintBrowserModel(BaseRequestModel):
   acceptHeader: str
   colorDepth: int
   language: str
@@ -57,8 +51,7 @@ class PayInFingerprintBrowserModel:
   windowHeight: int
   windowWidth: int
 
-@dataclass
-class PayInFingerprintModel:
+class PayInFingerprintModel(BaseRequestModel):
   fingerprint: str
   ip: str
   country: str
@@ -67,143 +60,146 @@ class PayInFingerprintModel:
   zip: str
   browser: Optional[PayInFingerprintBrowserModel]
 
-@dataclass
-class PayInModel:
-  amount: float
+class PayInModel(BaseRequestModel):
+  amount: float # decimals: 2
   currency: Currencies
+  country: Optional[str]  # Country iso code
   invoiceId: Optional[str] # idempotent key
-  clientId: Optional[str]
-  type: InvoiceTypes
-  bankId: Optional[str]
+  clientId: Optional[str] # uniq client ref
+  type: InvoiceTypes # Invoice subtype, see documentation 
+  bankId: Optional[str] # ID from bank list or NSPK id
   trusted: Optional[bool]
   successUrl: Optional[str]
   failUrl: Optional[str]
   backUrl: Optional[str]
   clientCard: Optional[str]
+  clientName: Optional[str]
   fingerprint: Optional[PayInFingerprintModel]
   lang: Optional[Languages]
+  sync: Optional[bool] # sync h2h scheme, see documentation
+  multiWidgetOptions: Optional[PayInMultiWidgetOptions]
+  theme: Optional[str] # personalized widget theme
    
-@dataclass
-class PayInResponseModel:
+class PayInResponseModel(BaseResponseModel):
   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:
+  url: Optional[str]
+  deeplink: Optional[str]
+  m10: Optional[str]
+  cardholder: Optional[str]
+  account: Optional[str]
+  bankId: Optional[str]
+  accountSubType: Optional[str]
+
+class PayOutRecipientModel(BaseRequestModel):
+  account_number: str #  IBAN, Phone, Card, local bank account number, wallet number, etc'
+  account_owner: Optional[str] # FirstName LastName or FirstName MiddleName LastName
+  account_iban: Optional[str] # use only cases where iban is't primary  account id  
+  account_swift: Optional[str] # for swift transfers only
+  account_phone: Optional[str] # additional recipient phone number, use only cases where phone is't primary  account id
+  account_bic: Optional[str] # recipient bank id
+  account_ewallet_name: Optional[str] # additional recipient wallet provider info
+  account_email: Optional[str] # additional recipient email, use only cases where email is't primary account id
+  account_bank_id: Optional[str] # recipient bankId (from API banks or RU NSPK id)
+  account_internal_client_number: Optional[str] # Bank internal identifier used for method banktransferphp (Philippines)
+  type: Optional[CredentialsTypes] # primary credential type
+
+class PayOutModel(BaseRequestModel):
   currency: Optional[Currencies] # currency from, by default = usdt
-  currencyTo:Currencies
-  amount: float
+  currencyTo: Optional[Currencies] # currency to, fiat only, if use quoteId - not required
+  amount: Optional[float] # decimals: 2, if use quoteId - not required
   invoiceId: Optional[str] # idempotent key
-  clientId: Optional[str]
+  clientId: Optional[str] # uniq client ref
   ttl: Optional[int]
   ttl_unit: Optional[TTLUnits]
-  finalAmount: Optional[float]
-  sender_name: Optional[str]
+  finalAmount: Optional[float] # Optional, for pre-charge rate lock
+  sender_name: Optional[str] # sender personal short data
+  sender_personal: Optional[PayOutSenderModel]
   baseCurrency: Optional[CurrencyTypes]
   feesStrategy: Optional[FeesStrategy]
   recipient: PayOutRecipientModel
   quoteId: Optional[str]
+  src_amount: Optional[str] # Optional, source amount in local currency for 2phase payout
+  type: Optional[InvoiceTypes] # payout transaction scheme hint
    
-@dataclass
-class PayOutResponseModel:
+class PayOutResponseModel(BaseResponseModel):
   id: str
   status: Statuses
 
-@dataclass
-class GetQuoteModel:
+class GetQuoteModel(BaseRequestModel):
   currency_from: Currencies
   currency_to: Currencies
   amount: float
-  subtype: InvoiceTypes
+  subtype: Optional[InvoiceTypes]
+  currency_original: Optional[Currencies]
 
-@dataclass
-class QuoteEntity:
-  currency_from: CurrencyModel
-  currency_to: CurrencyModel
+class QuoteEntity(BaseResponseModel):
+  currencyFrom: Currencies
+  currencyTo: Currencies
   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
+class GetQuoteResponseModel(BaseResponseModel):
+  id: str
+  finalAmount: float
+  direction: InvoiceDirection
+  fullRate: float
+  fullRateReverse: float
+  fees: float
+  fees_percent: float
+  quotes: List[QuoteEntity]
+  expiredAt: Optional[datetime.datetime] = Field(default=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_from: Optional[CurrencyModel] = Field(default=None)
+  currency_to: Optional[CurrencyModel] = Field(default=None)
+  currency_middle: Optional[CurrencyModel] = Field(default=None)
+  rate1: Optional[float] = Field(default=None)
+  rate2: Optional[float] = Field(default=None)
+  rate3: Optional[float] = Field(default=None)
+  net_amount: Optional[float] = Field(default=None)
+  metadata: Optional[object] = Field(default=None)
+
+
+class DepositAddressResponseModel(BaseResponseModel):
   currency: Currencies
   address: str
-  expiredAt: datetime
+  expiredAt: datetime.datetime
 
-@dataclass
-class CurrencyModel:
+
+class CurrencyModel(BaseResponseModel):
   _id: str
   type: CurrencyTypes
   code: Currencies
   symbol: str
-  label: Optional[str]
+  label: Optional[str] = Field(default=None)
   decimal: int
-  countryCode: Optional[str]
-  countryName: Optional[str]
+  countryCode: Optional[str] = Field(default=None)
+  countryName: Optional[str] = Field(default=None)
 
-@dataclass
-class BankModel:
+class BankModel(BaseResponseModel):
   name: str
   title: str
   currency: Currencies
   fpsId: str
 
-@dataclass
-class InvoiceStatusModel:
+class InvoiceStatusModel(BaseResponseModel):
   name: Statuses
-  createdAt: datetime
-  updatedAt: datetime
+  createdAt: datetime.datetime
+  updatedAt: datetime.datetime
 
-@dataclass
-class InvoiceAmountModel:
+class InvoiceAmountModel(BaseResponseModel):
   crypto: float
   fiat: float
   fiat_net: float
 
-@dataclass
-class InvoiceMetadataModel:
+class InvoiceMetadataModel(BaseResponseModel):
   invoiceId: Optional[str]
   clientId: Optional[str]
   fiatAmount: Optional[float]
 
-@dataclass
-class InvoiceModel:
+class InvoiceModel(BaseResponseModel):
   _id: str
   orderId: str
   projectId: str
@@ -216,18 +212,53 @@ class InvoiceModel:
   metadata: InvoiceMetadataModel
   receiptUrls: List[str]
   isExpired: bool
-  createdAt: datetime
-  updatedAt: datetime
-  expiredAt: datetime
+  createdAt: datetime.datetime
+  updatedAt: datetime.datetime
+  expiredAt: datetime.datetime
 
-@dataclass
-class AssetsAccountModel:
+class AssetsAccountModel(BaseResponseModel):
   currency: CurrencyModel;
   total: float
   pending: float
   available: float
 
-@dataclass
-class AssetsResponseModel:
+class AssetsResponseModel(BaseResponseModel):
   assets: List[AssetsAccountModel]
 
+class PayInMultiWidgetOptions(BaseRequestModel):
+  offerAmount: Optional[bool] # show amount select from best offers
+  elqrBanks: Optional[str] # elqr bank list
+
+class PayOutSenderModel(BaseRequestModel):
+  name: Optional[str]
+  birthday: Optional[str]
+  phone: Optional[str]
+  passport: Optional[str]
+
+class PayOutTlvRequestModel(BaseRequestModel):
+  quoteId: str # ID from /fx/tlv response
+  invoiceId: Optional[str]
+  clientId: Optional[str]
+  sender_personal: Optional[PayOutSenderModel]
+
+class GetQuoteTlv(BaseRequestModel):
+  data: str
+
+class QuoteTlvResponse(BaseResponseModel):
+  id: str
+  amount: float # fiat local amount
+  amountCrypto: float # total crypto amount inc. fees
+  currencyCode: Currencies # local currency
+  feeInCrypto: float # total fee in crypto
+  feePercent: float # fee percent
+  qrVersion: int # qr code version, 1 - nspk, 2 - tlv encoded, 3 - tlv plain
+  rate: float # exchange rate 
+  merchant: Optional[str] = Field(default=None) # merchant title
+  logo: Optional[str] = Field(default=None) # merchant logo
+
+class PayOutTlvRequest(BaseRequestModel):
+  quoteId: str # quote.id ref
+  invoiceId: Optional[str] = Field(default=None)
+  clientId: Optional[str] = Field(default=None)
+  src_amount: Optional[float] = Field(default=None)
+  sender_personal: Optional[PayOutSenderModel] = Field(default=None)

paymentsgate/transport.py

@@ -1,8 +1,7 @@
 from dataclasses import dataclass
 from pydantic import BaseModel
 
-@dataclass
-class Request:
+class Request(BaseModel):
     method: str
     path: str
     content_type: str = 'application/json'
@@ -11,11 +10,9 @@ class Request:
     noAuth: bool | None = False
     signature: bool | None = False
 
-
-@dataclass
-class Response:
+class Response(BaseModel):
     raw_body: bytes
-    json: dict
+    json_body: dict
     status_code: int
 
     @property
@@ -24,8 +21,8 @@ class Response:
 
     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'));
+            return model(**self.json_body)
+        return error(self.json_body.get('error'), self.json_body.get('message'), self.json_body.get('data'), self.json_body.get('status'));
     
     def __str__(self) -> str:
        return self.raw_body.decode("utf-8")

paymentsgate/types.py

@@ -0,0 +1,9 @@
+from pydantic import BaseModel
+
+from .tokens import AccessToken, RefreshToken
+
+class TokenResponse(BaseModel):
+  access_token: str
+  refresh_token: str
+  expires_in: int
+  

{paymentsgate-1.4.8.dist-info → paymentsgate-1.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: paymentsgate
-Version: 1.4.8
+Version: 1.5.0
 Summary: PaymentsGate's Python SDK for REST API
 Home-page: https://github.com/paymentsgate/python-secure-api
 License: MIT

paymentsgate-1.5.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+paymentsgate/__init__.py,sha256=53DrE7IRD2NFQshE2EGYQ28jLr-ro45iFei28ZMOezI,336
+paymentsgate/cache.py,sha256=w3xB3iaYPxVEZbeWxpWM1PQT-JctspoI5qC9bv6Xmts,1002
+paymentsgate/client.py,sha256=0brT3_ZTt52lBIKHoBIPzybGJ_uv_taAelxmdKLkeC0,9338
+paymentsgate/enums.py,sha256=kLK3xfw8zckTK6wbEA7RH9R98VaD2eF7asT9mzyLDBI,4201
+paymentsgate/exceptions.py,sha256=-ZzMvzyViBQCf4LsbAFXwizDHF_0Axyn705n2FBJ17I,1346
+paymentsgate/logger.py,sha256=QY6upavgb2y9dRQG05NwF_OTxP7bPspZR5QdpCjJULI,221
+paymentsgate/mappers.py,sha256=ruXJ3I5VY89wbvJP7aJY8xws2LRXFj3eOMreXkrJ7g8,163
+paymentsgate/models.py,sha256=kRTWo_velRP8pQ76-yc5vZp5OJP2pw-K8mMn3dB06Qg,8072
+paymentsgate/tokens.py,sha256=qdvCQJ9jYIRKSxlmm5gip-nMAQWH8_EHys9zwel4oaU,916
+paymentsgate/transport.py,sha256=VgVkWBCphrUtHeA79ExhlWo-FyidzHeUkxKIx8nnsh4,814
+paymentsgate/types.py,sha256=UQ6RRcTcK-TXYPjwDP6DnSSYtHsw4Fmt2f34q6O_msg,172
+paymentsgate-1.5.0.dist-info/LICENSE,sha256=4xWMZLmqNJ6602DZLEg0A9v03uT4xMq_-XSIxvXvfYM,1075
+paymentsgate-1.5.0.dist-info/WHEEL,sha256=bbU3AyvhQ312rVm7zzRQjs6axI1UYWC3nmFA2E6FFSI,88
+paymentsgate-1.5.0.dist-info/METADATA,sha256=5DVm2gm1jSZXaLNnLpDDXukEPgB7j-dI6ef97PX1dgU,4020
+paymentsgate-1.5.0.dist-info/RECORD,,

paymentsgate-1.4.8.dist-info/RECORD

@@ -1,13 +0,0 @@
-paymentsgate/__init__.py,sha256=53DrE7IRD2NFQshE2EGYQ28jLr-ro45iFei28ZMOezI,336
-paymentsgate/cache.py,sha256=w3xB3iaYPxVEZbeWxpWM1PQT-JctspoI5qC9bv6Xmts,1002
-paymentsgate/client.py,sha256=OM-kNkSKARc4_Nub9Vy0HEswQfaaYVvK7P3bbxh0Lag,7577
-paymentsgate/enums.py,sha256=wvDeVQvSO5WPPSWd1XKOh-8vgI1gsK2wyfMi7P8vay0,3311
-paymentsgate/exceptions.py,sha256=fQniUSQp8XkWXPCITHDUbVNcDwSPA8rJpwbbhJ8wfNQ,1306
-paymentsgate/logger.py,sha256=QY6upavgb2y9dRQG05NwF_OTxP7bPspZR5QdpCjJULI,221
-paymentsgate/models.py,sha256=LEwaoy2rkdA-2BLJoV85aKBlDMDu4NETZ0thCrBIV1g,5017
-paymentsgate/tokens.py,sha256=qdvCQJ9jYIRKSxlmm5gip-nMAQWH8_EHys9zwel4oaU,916
-paymentsgate/transport.py,sha256=pOmvDZh06uIGIUWTFi0vgf8pAgQT1f96ArcJNycU2Ks,785
-paymentsgate-1.4.8.dist-info/LICENSE,sha256=4xWMZLmqNJ6602DZLEg0A9v03uT4xMq_-XSIxvXvfYM,1075
-paymentsgate-1.4.8.dist-info/WHEEL,sha256=bbU3AyvhQ312rVm7zzRQjs6axI1UYWC3nmFA2E6FFSI,88
-paymentsgate-1.4.8.dist-info/METADATA,sha256=iQOvqOiCD_fnXJhEGnS3lOJId4rZJkAM1S9Tqh7qkWA,4020
-paymentsgate-1.4.8.dist-info/RECORD,,