LiqPay Async

Sivak Ihor — Fri, 23 Aug 2024 12:46:53 +0000

Web: https://www.liqpay.ua/
Download: https://pypi.org/project/liqpay-async/
Source: https://github.com/SpaceIgor/liqpay-async
Documentation: https://www.liqpay.ua/documentation/en/
Keywords: liqpay, privat24, privatbank, python, internet acquiring, P2P payments, two-step payments

What python version is supported?

Python 3.4+

Get Started

Sign up in https://www.liqpay.ua/en/authorization.
Create a company.
In company settings, on API tab, get Public key and Private key: https://www.liqpay.ua/doc
Done.

Installation

From pip

pip install liqpay-async

Working with LiqPay Callback locally

If you need debugging API Callback on local environment use https://localtunnel.github.io/www/

How it uses?

Example 1: Pin token card to user

Backend
Get url on SDK

Request url: https://www.liqpay.ua/api/3/checkout

from liqpay_async import LiqPay

liqpay_manager = LiqPay(public_key, private_key)
response = await liqpay_manager.post( 
        return_url=True,
        data={
            "action": "hold",
            "version": "3",
            "amount": "1",
            "currency": "UAH",  # or any currency
            "description": "Pin card",
            "language": "uk|en"     # liqpay have only ("uk", "en)
            "order_id": f"{id_user from token} {str(uuid.uuid4())}",    # id_user from token need for pin card to user
            "server_url": f"{YOUR_HOST}{URL}",  # for callback response
            "recurringbytoken": "1",    # for get token in response callback
        },
    )

    # check on bad response
    if response["status"] in (0, 1):
        # when response status 0 or 1 from response dict u can get key 'err_code' - https://www.liqpay.ua/doc/api/errors
        raise

# OK response - {"url: url, status: STATUS_MAPPING}
# return url on SDK

# When u sent card credentials in checkout SDK LiqPay. U get response on the url(server_url) from request dict
#Example:

from fastapi import Request, Body

LIQPAY_DOMAIN = "liq_pay domain"

async def pin_card(
        request: Request,
        liq_pay: YourModel = Body(...),
):
    origin = request.headers.get("origin")
    if not origin or origin != LIQPAY_DOMAIN:   # for security
        raise 

    data = liq_pay.order_id.split()

    await liqpay_manager.post(
                data={
                    "action": "refund",     # refund money
                    "version": "3",
                    "order_id": liq_pay.order_id,
                }
            )

    # and save data from callback

    # data[0] - its id user from order_id
    # card_token, sender_card_mask2, sender_card_type

Example 2: For other operation by token card

Backend

Request url: https://www.liqpay.ua/api/request

from liqpay_async import LiqPay

liqpay_manager = LiqPay(public_key, private_key)

# https://www.liqpay.ua/doc/api/internet_acquiring/checkout?tab=1
response = await liqpay_manager.post( 
        data={
            "action": "your action",
            "version": "3",
            "amount": "1",
            "currency": "UAH",  # or any currency
            "description": "Your desc",
            "language": "uk|en"     # liqpay have only ("uk", "en)
            "order_id": "str(uuid.uuid4())",
            "card_token": your_card_token
        },
    )

# OK response - {status: STATUS_MAPPING and others)

Example 3: Errors

Backend


# if response aiothhp error -> response {"status": 0}

Validation in FastApi

Sivak Ihor — Mon, 22 Jul 2024 15:23:13 +0000

Introduction
FastAPI is a modern web framework for building APIs with Python. One of its most important and convenient features is the built-in support for data validation using Pydantic. Validators in FastAPI help ensure that the data transmitted through the API meets the specified requirements, improving the security and reliability of applications.

Basics of Validation
Using Pydantic
FastAPI integrates with the Pydantic library for data validation. Pydantic allows you to define data models with clear types and validation rules. This makes it easy to check that user-provided data meets expected formats.

Key Features of Pydantic:
Data Typing:
Models in Pydantic are defined as subclasses of BaseModel, where fields are described using Python types.

from pydantic import BaseModel

class User(BaseModel):
    username: str
    email: str

Types in Pydantic
Pydantic supports a wide range of data types for validation and serialization. Here is a comprehensive list of the types you can use when defining models:

1. Basic Data Types:

int: Integer

from pydantic import BaseModel

class Item(BaseModel):
    quantity: int

float: Floating-point number

from pydantic import BaseModel

class Product(BaseModel):
    price: float

str: String

from pydantic import BaseModel

class User(BaseModel):
    username: str

bool: Boolean value (True or False)

from pydantic import BaseModel

class Settings(BaseModel):
    is_active: bool

2. Optional:

Optional[X]: Value can be of type X or None. Equivalent to Union[X, None].

from typing import Optional
from pydantic import BaseModel

class User(BaseModel):
    age: Optional[int]  # Can be int or None

3. Union:

Union[X, Y]: Value can be one of several types (X or Y).

from typing import Union
from pydantic import BaseModel

class Item(BaseModel):
    model: Union[str, int]

4. Literal:

Literal[value1, value2, ...]: Value must be one of the specified literal values.

from typing import Literal
from pydantic import BaseModel

class Car(BaseModel):
    type: Literal['sedan', 'suv', 'truck']

5. Constrained Types:

conint(gt=0): Integer that must be greater than 0.

from pydantic import BaseModel, conint

class Order(BaseModel):
    quantity: conint(gt=0)  # Only positive numbers

confloat(ge=0.0, le=100.0): Floating-point number that must be within the range of 0.0 to 100.0.

from pydantic import BaseModel, confloat

class Measurement(BaseModel):
    value: confloat(ge=0.0, le=100.0)  # Value between 0 and 100

constr(min_length=5, max_length=20): String whose length must be between 5 and 20 characters.

from pydantic import BaseModel, constr

class User(BaseModel):
    username: constr(min_length=3, max_length=50, regex='^[a-zA-Z0-9]+$')

6. Complex Types:
List[X]: List of items of type X.

from typing import List
from pydantic import BaseModel

class Items(BaseModel):
    names: List[str]

Tuple[X, Y]: Tuple where the first element is of type X and the second element is of type Y.

from typing import Tuple
from pydantic import BaseModel

class Point(BaseModel):
    coordinates: Tuple[float, float]

Dict[K, V]: Dictionary with keys of type K and values of type V.

from typing import Dict
from pydantic import BaseModel

class Scores(BaseModel):
    results: Dict[str, int]

Set[X]: Set of items of type X.

from typing import Set
from pydantic import BaseModel

class Tags(BaseModel):
    keywords: Set[str]

7. Date and Time:
date: Date (without time)

from datetime import date
from pydantic import BaseModel

class Event(BaseModel):
    event_date: date

datetime: Date and time

from datetime import datetime
from pydantic import BaseModel

class Appointment(BaseModel):
    timestamp: datetime

time: Time (without date)

from datetime import time
from pydantic import BaseModel

class Reminder(BaseModel):
    alarm_time: time

8. Special Types:

Any: Any data type
Byte: Byte string

from pydantic import BaseModel

class File(BaseModel):
    content: bytes

Custom Validators:
You can use the @validator(field_validator) and @root_validator(model_validator) decorators to create custom validators.
These types allow you to define and validate a wide range of data structures, making Pydantic a powerful tool for ensuring data integrity in your applications.

DEV Community: Sivak Ihor