glQiwiApi

https://glqiwiapi.readthedocs.io/en/latest/
Admin
glQiwiApi is a fast asynchronous Python wrapper for QIWI Wallet, QIWI P2P API, QIWI Maps, and...
Tokens:81,600
Snippets:748
Trust Score:9.6
Update:5 months ago
Show doc for...
Tokens:
Raw
### Start QIWI API Polling with Startup/Shutdown Events

Source: https://glqiwiapi.readthedocs.io/en/latest/polling.html

This example shows how to start QIWI API polling while also specifying functions to be executed on startup and shutdown. The `on_startup` function can be used to perform initial setup.

```python
from glQiwiApi import QiwiWallet
from glQiwiApi.core.event_fetching import executor
from glQiwiApi.core.event_fetching.dispatcher import QiwiDispatcher
from glQiwiApi.core.event_fetching.executor import Context
from glQiwiApi.qiwi.clients.wallet.types import Transaction

qiwi_dp = QiwiDispatcher()
wallet = QiwiWallet(api_access_token='token', phone_number='+phone number')


@qiwi_dp.transaction_handler()
async def handle_transaction(t: Transaction, ctx: Context):
    """Handle transaction here"""
    ctx.wallet  # this way you can use QiwiWallet instance to avoid global variables


async def on_startup(ctx: Context):
    ctx.wallet  # do something here


async def on_shutdown(ctx: Context):
    pass


if __name__ == '__main__':
    executor.start_polling(wallet, qiwi_dp, on_startup=on_startup, on_shutdown=on_shutdown)

```

--------------------------------

### Install glQiwiApi from Source

Source: https://glqiwiapi.readthedocs.io/en/latest/installation.html

After cloning the repository, use this command to install glQiwiApi from the local source files.

```bash
python setup.py install

```

--------------------------------

### Start Polling

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/core/event_fetching/executor.html

Starts the event fetching loop by creating tasks for plugin installation and infinite polling, then runs the event loop indefinitely.

```python
def start_polling(self) -> None:
        try:
            self.loop.create_task(self._install_plugins())
            self.loop.create_task(self._run_infinite_polling())
            adapter.run_forever_safe(self.loop)
        except (SystemExit, KeyboardInterrupt):  # pragma: no cover
            # allow graceful shutdown
            pass
```

--------------------------------

### Install glQiwiApi Stable Release

Source: https://glqiwiapi.readthedocs.io/en/latest/installation.html

Use this command to install the latest stable version of glQiwiApi. This is the recommended installation method.

```bash
pip install glQiwiApi

```

--------------------------------

### BaseExecutor Plugin Installation

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/core/event_fetching/executor.html

Installs all registered plugins, passing the provided context to their install methods.

```python
async def _install_plugins(self, ctx: Optional[Dict[Any, Any]] = None) -> None:
        if ctx is None:
            ctx = {}
        incline_tasks = [plugin.install(ctx) for plugin in self._plugins]
        await asyncio.gather(*incline_tasks)
```

--------------------------------

### Start Webhook Server

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/core/event_fetching/executor.html

Starts the webhook server with the given configuration. This involves supplementing the configuration, setting up the application routes, and running the server indefinitely.

```python
def start_webhook(self, config: WebhookConfig) -> None:
        supplemented_configuration = self.loop.run_until_complete(
            self._supplement_configuration(config)
        )

        self._application = configure_app(
            dispatcher=self._dispatcher,
            app=self._application,
            webhook_config=supplemented_configuration,
        )

        self.loop.create_task(self._install_plugins())
        try:
            self.loop.run_until_complete(self.welcome())
            self.loop.create_task(
                _run_app(
                    app=self._application,
                    host=supplemented_configuration.app.host,
                    port=supplemented_configuration.app.port,
                    ssl_context=supplemented_configuration.app.ssl_context,
                    **supplemented_configuration.app.kwargs,
                )
            )
            adapter.run_forever_safe(self.loop)
        finally:
            self.loop.run_until_complete(self.goodbye())
```

--------------------------------

### BaseExecutor._install_plugins

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/core/event_fetching/executor.html

Installs all registered plugins. This method iterates through the plugins and calls their respective `install` methods, gathering any tasks created.

```APIDOC
## BaseExecutor._install_plugins

### Description
Installs all registered plugins. This method iterates through the plugins and calls their respective `install` methods, gathering any tasks created.

### Parameters
- **ctx** (Optional[Dict[Any, Any]]): Optional context dictionary to pass to plugin installation.

### Returns
- **None**
```

--------------------------------

### Install uvloop for Faster AsyncIO

Source: https://glqiwiapi.readthedocs.io/en/latest/installation.html

Install uvloop to replace the default asyncio event loop with a faster implementation. This can significantly improve API performance.

```bash
pip install uvloop

```

--------------------------------

### Start QIWI API Polling with Transaction Handler

Source: https://glqiwiapi.readthedocs.io/en/latest/polling.html

This snippet demonstrates how to initialize the QiwiDispatcher, define a transaction handler, and start polling for transactions using the executor. It includes an exception handler for QiwiAPIError.

```python
from glQiwiApi import QiwiWallet
from glQiwiApi.core.event_fetching import executor
from glQiwiApi.core.event_fetching.dispatcher import QiwiDispatcher
from glQiwiApi.core.event_fetching.executor import Context
from glQiwiApi.core.event_fetching.filters import ExceptionFilter
from glQiwiApi.qiwi.clients.wallet.types import Transaction
from glQiwiApi.qiwi.exceptions import QiwiAPIError

qiwi_dp = QiwiDispatcher()
wallet = QiwiWallet(api_access_token='token', phone_number='+phone number')


@qiwi_dp.transaction_handler()
async def handle_transaction(t: Transaction, ctx: Context):
    """Handle transaction here"""
    ctx.wallet  # this way you can use QiwiWallet instance to avoid global variables


@qiwi_dp.exception_handler(ExceptionFilter(QiwiAPIError))
async def handle_exception(err: QiwiAPIError, ctx: Context):
    pass


if __name__ == '__main__':
    executor.start_polling(wallet, qiwi_dp)

```

--------------------------------

### Aiogram and Qiwi Polling Integration

Source: https://glqiwiapi.readthedocs.io/en/latest/polling.html

This snippet shows how to initialize QiwiWrapper, Aiogram's Bot and Dispatcher, and then start polling for both Qiwi transactions and Telegram messages. It includes setup for custom handlers and startup functions.

```python
import logging
from typing import cast

from aiogram import Bot, Dispatcher, types

from glQiwiApi import QiwiWrapper
from glQiwiApi.core.event_fetching import executor
from glQiwiApi.core.event_fetching.dispatcher import QiwiDispatcher
from glQiwiApi.core.event_fetching.executor import Context
from glQiwiApi.plugins import AiogramPollingPlugin
from glQiwiApi.qiwi.clients.wallet.types import Transaction

api_access_token = 'token'
phone_number = '+phone number'

logger = logging.getLogger(__name__)


async def aiogram_message_handler(msg: types.Message):
    await msg.answer(text='Привет😇')


async def qiwi_transaction_handler(update: Transaction, ctx: Context):
    print(update)


def on_startup(ctx: Context) -> None:
    logger.info('This message logged on startup')
    register_handlers(ctx)


def register_handlers(ctx: Context):
    ctx['qiwi_dp'].transaction_handler()(qiwi_transaction_handler)
    dispatcher = cast(Dispatcher, ctx['dp'])
    dispatcher.register_message_handler(aiogram_message_handler)


def run_application() -> None:
    logging.basicConfig(level=logging.INFO)
    bot = Bot('BOT TOKEN')
    dp = Dispatcher(bot)
    wallet = QiwiWrapper(api_access_token=api_access_token, phone_number=phone_number)
    qiwi_dp = QiwiDispatcher()

    executor.start_polling(
        wallet,
        qiwi_dp,
        AiogramPollingPlugin(dp),
        on_startup=on_startup,
        skip_updates=True,
        context={'dp': dp, 'qiwi_dp': qiwi_dp},
    )


if __name__ == '__main__':
    run_application()

```

--------------------------------

### start_qiwi_api_polling

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/core/event_fetching/executor.html

Starts a polling executor for Qiwi API events. This function sets up and starts a PollingExecutor to continuously fetch updates from the Qiwi API. It can execute custom functions on startup and shutdown and supports plugins.

```APIDOC
## start_qiwi_api_polling

### Description
Starts a polling executor for Qiwi API events. This function sets up and starts a PollingExecutor to continuously fetch updates from the Qiwi API. It can execute custom functions on startup and shutdown and supports plugins.

### Parameters
- **wallet** (Union[QiwiWallet, QiwiWrapper]): The Qiwi wallet or wrapper instance.
- **dispatcher** (BaseDispatcher): The dispatcher to handle incoming events.
- **skip_updates** (bool): Whether to skip updates that occurred while the executor was not running. Defaults to False.
- **timeout_in_seconds** (float): The timeout in seconds for polling requests. Defaults to DEFAULT_TIMEOUT.
- **on_startup** (Optional[_EventHandlerType]): A function or coroutine to execute on startup.
- **on_shutdown** (Optional[_EventHandlerType]): A function or coroutine to execute on shutdown.
- **loop** (Optional[asyncio.AbstractEventLoop]): The event loop to use. Defaults to the current event loop.
- **context** (Union[Dict[str, Any], Context, None]): A dictionary or Context object for custom context data. Defaults to an empty dictionary.
```

--------------------------------

### Start Non-Blocking Polling

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/core/event_fetching/executor.html

Starts the infinite polling process without blocking the current execution flow, returning an asyncio Task.

```python
async def start_non_blocking_polling(self) -> asyncio.Task:
        return asyncio.create_task(self._run_infinite_polling())
```

--------------------------------

### Install orjson for Faster JSON Handling

Source: https://glqiwiapi.readthedocs.io/en/latest/installation.html

Install orjson as a replacement for Python's built-in json module. It offers superior performance and correctness for JSON serialization and deserialization.

```bash
pip install orjson

```

--------------------------------

### Configure glQiwiApi with SOCKS5 Proxy

Source: https://glqiwiapi.readthedocs.io/en/latest/advanced_features/proxy.html

This snippet shows how to create a RequestService with a ProxyConnector for SOCKS5 proxy authentication. Ensure the aiohttp-socks library is installed.

```python
import asyncio

from aiohttp_socks import ProxyConnector

from glQiwiApi import QiwiWallet
from glQiwiApi.core import RequestService
from glQiwiApi.core.session import AiohttpSessionHolder


def create_request_service_with_proxy(w: QiwiWallet):
    return RequestService(
        session_holder=AiohttpSessionHolder(
            connector=ProxyConnector.from_url("socks5://34.134.60.185:443"),  # some proxy
            headers={
                "Content-Type": "application/json",
                "Accept": "application/json",
                "Authorization": f"Bearer {w._api_access_token}",
                "Host": "edge.qiwi.com",
            },
        )
    )


wallet = QiwiWallet(
    api_access_token="your token",
    phone_number="+phone number",
    request_service_factory=create_request_service_with_proxy,
)


async def main():
    async with wallet:
        print(await wallet.get_balance())


asyncio.run(main())
```

--------------------------------

### start_non_blocking_qiwi_api_polling

Source: https://glqiwiapi.readthedocs.io/en/latest/polling.html

Starts the QIWI API polling in a non-blocking manner, returning an asyncio Task.

```APIDOC
## start_non_blocking_qiwi_api_polling

### Description
Starts the QIWI API polling in a non-blocking manner.

### Method Signature
```python
async start_non_blocking_qiwi_api_polling(_wallet : Union[glQiwiApi.qiwi.clients.wallet.client.QiwiWallet, glQiwiApi.qiwi.clients.wrapper.QiwiWrapper], _dispatcher : glQiwiApi.core.event_fetching.dispatcher.BaseDispatcher, _skip_updates : bool = False, _timeout_in_seconds : float = 5, _on_startup : Optional[Callable[[Context], Union[None, Awaitable[None]]]] = None, _on_shutdown : Optional[Callable[[Context], Union[None, Awaitable[None]]]] = None, _loop : Optional[asyncio.events.AbstractEventLoop] = None, _context : Optional[Union[Dict[str, Any], glQiwiApi.core.event_fetching.executor.Context]] = None) -> asyncio.Task
```

### Parameters

*   **wallet** (Union[glQiwiApi.qiwi.clients.wallet.client.QiwiWallet, glQiwiApi.qiwi.clients.wrapper.QiwiWrapper]) - Instance of QiwiWrapper.
*   **dispatcher** (glQiwiApi.core.event_fetching.dispatcher.BaseDispatcher) - The dispatcher instance.
*   **skip_updates** (bool) - If True, skips updates.
*   **timeout_in_seconds** (float) - Timeout of polling in seconds.
*   **on_startup** (Optional[Callable[[Context], Union[None, Awaitable[None]]]]) - Function or coroutine to be executed on startup.
*   **on_shutdown** (Optional[Callable[[Context], Union[None, Awaitable[None]]]]) - Function or coroutine to be executed on shutdown.
*   **loop** (Optional[asyncio.events.AbstractEventLoop]) - The asyncio event loop.
*   **context** (Optional[Union[Dict[str, Any], glQiwiApi.core.event_fetching.executor.Context]]) - Context to be transmitted to handlers.

### Returns
An asyncio.Task representing the non-blocking polling operation.
```

--------------------------------

### Clone glQiwiApi Development Repository

Source: https://glqiwiapi.readthedocs.io/en/latest/installation.html

Clone the glQiwiApi repository from GitHub to install from source files. Use the 'dev-2.x' branch for development versions.

```bash
git clone -b dev-2.x git://github.com/GLEF1X/glQiwiApi

```

--------------------------------

### Get List of Balances

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/qiwi/clients/wallet/client.html

Fetches the current account balances for the QIWI Wallet.

```APIDOC
## Get List of Balances

### Description
Retrieves a list of all current account balances associated with the QIWI Wallet.

### Method
`get_list_of_balances()`

### Response
#### Success Response (200)
- `List[Balance]` - A list of balance objects, each containing account information and balance details.
```

--------------------------------

### start_polling

Source: https://glqiwiapi.readthedocs.io/en/latest/genindex.html

Starts polling. This method can be called via the PollingExecutor or directly from the module.

```APIDOC
## start_polling()

### Description
Starts polling.

### Method
This is a method within the `glQiwiApi.core.event_fetching.executor.PollingExecutor` class.
It is also available directly within the `glQiwiApi.core.event_fetching.executor` module.
```

--------------------------------

### Fetch Operation History

Source: https://glqiwiapi.readthedocs.io/en/latest/getting-started/yoomoney/examples.html

An example of how to use the YooMoneyAPI with an access token to retrieve the operation history. Ensure you have a valid TOKEN.

```python
import asyncio

from glQiwiApi import YooMoneyAPI

TOKEN = 'your token'


async def main():
    async with YooMoneyAPI(api_access_token=TOKEN) as w:
        print(await w.operation_history(records=50))


asyncio.run(main())
```

--------------------------------

### Get Available Balances

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/qiwi/clients/wallet/client.html

Displays account aliases available for creation in the QIWI Wallet.

```APIDOC
## Get Available Balances

### Description
Retrieves a list of account aliases that are available for creation within the QIWI Wallet.

### Method
`get_available_balances()`
```

--------------------------------

### Get List of Balances

Source: https://glqiwiapi.readthedocs.io/en/latest/API/qiwi_api.html

Asynchronously retrieves a list of all available balances for the wallet. Accepts arbitrary arguments.

```python
async def _get_list_of_balances(_* args: Any, _** kw: Any) -> Any
```

--------------------------------

### Get Available Balances

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/qiwi/clients/wallet/client.html

Fetches a list of all available balances for the QIWI account.

```APIDOC
## GET /funding/accounts/default

### Description
Retrieves a list of all available balances for the QIWI account.

### Method
GET

### Endpoint
/funding/accounts/default

### Response
#### Success Response (200)
- **availableBalances** (List[AvailableBalance]) - A list of available balance objects.
```

--------------------------------

### Start Webhook Listener

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/core/event_fetching/executor.html

Initiates a blocking webhook listener for transaction and bill events. Supports custom startup and shutdown coroutines, plugins, and context.

```python
def start_webhook(
    wallet: Union[QiwiWallet, QiwiWrapper],
    dispatcher: BaseDispatcher,
    *plugins: Pluggable,
    webhook_config: WebhookConfig,
    on_startup: Optional[_EventHandlerType] = None,
    on_shutdown: Optional[_EventHandlerType] = None,
    loop: Optional[asyncio.AbstractEventLoop] = None,
    context: Union[Dict[str, Any], Context, None] = None,
) -> None:
    """
    Blocking function that listens for webhooks.
    Supports only `glQiwiApi.types.BillWebhook` and `glQiwiApi.types.TransactionWebhook`

    :param wallet: instance of QiwiWrapper
    :param dispatcher:
    :param on_startup: coroutine,which will be executed on startup
    :param on_shutdown: coroutine, which will be executed on shutdown
    :param webhook_config:
    :param plugins: List of plugins, that will be executed together with polling.
         For example  builtin TelegramWebhookPlugin or other
         class, that implement Pluggable abc interface, deal with foreign framework/application
         in the background
    :param loop:
    :param context: context, that could be transmitted to handlers
    """
    if context is None:
        context = {}
    executor = WebhookExecutor(
        wallet,
        dispatcher,
        *plugins,
        on_shutdown=on_shutdown,
        on_startup=on_startup,
        loop=loop,
        context=Context(context),
    )
    executor.start_webhook(config=webhook_config)
```

--------------------------------

### BaseExecutor.welcome

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/core/event_fetching/executor.html

Initiates the welcome sequence for the executor. This method logs a startup message and fires the on_startup callbacks.

```APIDOC
## BaseExecutor.welcome

### Description
Initiates the welcome sequence for the executor. This method logs a startup message and fires the on_startup callbacks.

### Returns
- **None**
```

--------------------------------

### Initialize QiwiWrapper

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/qiwi/clients/wrapper.html

Instantiate the QiwiWrapper with API access token, phone number, and P2P secret key. Optional shim server URL can be provided.

```python
from glQiwiApi.qiwi.clients.wrapper import QiwiWrapper

wrapper = QiwiWrapper(
    api_access_token="YOUR_API_ACCESS_TOKEN",
    phone_number="+79123456789",
    secret_p2p="YOUR_SECRET_P2P_KEY",
    shim_server_url="YOUR_SHIM_SERVER_URL"
)
```

--------------------------------

### Get Available Balances for Creation

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/qiwi/clients/wrapper.html

Retrieves a list of account aliases that are available for creation in your QIWI Wallet. No parameters are needed.

```python
return await self._qiwi_wallet.get_available_balances()
```

--------------------------------

### Start Blocking Polling

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/core/event_fetching/executor.html

Starts the polling executor and begins processing events. This function blocks until polling is stopped.

```python
def start_blocking_qiwi_api_polling(
    wallet: Union[QiwiWallet, QiwiWrapper],
    dispatcher: BaseDispatcher,
    skip_updates: bool = False,
    timeout_in_seconds: float = DEFAULT_TIMEOUT,
    on_startup: Optional[_EventHandlerType] = None,
    on_shutdown: Optional[_EventHandlerType] = None,
    loop: Optional[asyncio.AbstractEventLoop] = None,
    context: Union[Dict[str, Any], Context, None] = None,
) -> None:
    """
    Starts the blocking polling executor.

    :param wallet: QiwiWallet or QiwiWrapper instance.
    :param dispatcher: BaseDispatcher instance.
    :param skip_updates: If True, skips pending updates.
    :param timeout_in_seconds: Timeout for polling requests.
    :param on_startup: Function or coroutine to execute on startup.
    :param on_shutdown: Function or coroutine to execute on shutdown.
    :param loop: asyncio event loop.
    :param context: Context to be transmitted to handlers.
    """
    if context is None:
        context = {}
    executor = PollingExecutor(
        wallet,
        dispatcher,
        *plugins,
        timeout=timeout_in_seconds,
        skip_updates=skip_updates,
        on_startup=on_startup,
        on_shutdown=on_shutdown,
        loop=loop,
        context=Context(context),
    )
    executor.start_polling()
```

--------------------------------

### Initialize QiwiP2PClient

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/qiwi/clients/p2p/client.html

Initialize the client with your QIWI P2P secret key. An optional shim server URL can also be provided.

```python
from glQiwiApi.qiwi import QiwiP2PClient

client = QiwiP2PClient(secret_p2p='YOUR_SECRET_P2P_KEY')
# or with shim_server_url
# client = QiwiP2PClient(secret_p2p='YOUR_SECRET_P2P_KEY', shim_server_url='YOUR_SHIM_SERVER_URL')
```

--------------------------------

### Start Non-Blocking Polling

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/core/event_fetching/executor.html

Starts the polling executor in a non-blocking manner, returning an asyncio Task. This allows other operations to run concurrently.

```python
async def start_non_blocking_qiwi_api_polling(
    wallet: Union[QiwiWallet, QiwiWrapper],
    dispatcher: BaseDispatcher,
    skip_updates: bool = False,
    timeout_in_seconds: float = DEFAULT_TIMEOUT,
    on_startup: Optional[_EventHandlerType] = None,
    on_shutdown: Optional[_EventHandlerType] = None,
    loop: Optional[asyncio.AbstractEventLoop] = None,
    context: Union[Dict[str, Any], Context, None] = None,
) -> asyncio.Task:
    if context is None:
        context = {}
    executor = PollingExecutor(
        wallet,
        dispatcher,
        timeout=timeout_in_seconds,
        skip_updates=skip_updates,
        on_startup=on_startup,
        on_shutdown=on_shutdown,
        loop=loop,
        context=Context(context),
    )
    return await executor.start_non_blocking_polling()
```

--------------------------------

### Start Long-Polling Mode

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/core/event_fetching/executor.html

Sets up a long-polling mechanism to receive transaction events. Allows skipping updates, setting a polling timeout, and defining startup/shutdown handlers.

```python
def start_polling(
    wallet: Union[QiwiWallet, QiwiWrapper],
    dispatcher: BaseDispatcher,
    *plugins: Pluggable,
    skip_updates: bool = False,
    timeout_in_seconds: float = DEFAULT_TIMEOUT,
    on_startup: Optional[_EventHandlerType] = None,
    on_shutdown: Optional[_EventHandlerType] = None,
    loop: Optional[asyncio.AbstractEventLoop] = None,
    context: Union[Dict[str, Any], Context, None] = None,
) -> None:
    """
    Setup for long-polling mode. Support only `glQiwiApi.types.Transaction` as event.

    :param wallet: instance of QiwiWrapper
    :param dispatcher:
    :param skip_updates:
    :param timeout_in_seconds: timeout of polling in seconds, if the timeout is too small,

```

--------------------------------

### QiwiWallet.__init__

Source: https://glqiwiapi.readthedocs.io/en/latest/API/qiwi_api.html

Initializes the QiwiWallet client with an API access token and optional phone number.

```APIDOC
## QiwiWallet.__init__

### Description
Initializes the QiwiWallet client. This client is used for interacting with the QIWI Wallet API.

### Parameters
#### Path Parameters
- **api_access_token** (str) - Required - Your QIWI API token, obtained from https://qiwi.com/api.
- **phone_number** (Optional[str]) - Optional - Your phone number, starting with a '+' sign.
- **request_service_factory** (Optional[Callable[[...], Union[Awaitable[RequestServiceProto], RequestServiceProto]]]) - Optional - Factory for creating request services.

### Returns
- **None**
```

--------------------------------

### BaseExecutor Startup Event

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/core/event_fetching/executor.html

Fires the startup event, logging a message and executing the on_startup handler.

```python
async def welcome(self) -> None:
        logger.info('Executor has started work!')
        await self._on_startup.fire()
```

--------------------------------

### welcome()

Source: https://glqiwiapi.readthedocs.io/en/latest/genindex.html

A welcome method, likely for initialization or a basic check. This method is part of the BaseExecutor client.

```APIDOC
## welcome()

### Description
Provides a welcome message or performs an initial setup action.

### Method
(Not specified, likely a client method)

### Endpoint
(Not specified)

### Parameters
(None specified)

### Request Example
(None specified)

### Response
(None specified)
```

--------------------------------

### Run QIWI API Polling in Aiogram Startup Event

Source: https://glqiwiapi.readthedocs.io/en/latest/polling.html

This example shows an alternative way to integrate QIWI API polling with aiogram by running the QIWI polling within the aiogram `on_startup` event. This approach uses `start_non_blocking_qiwi_api_polling` to run QIWI polling concurrently.

```python
from aiogram import Bot, Dispatcher
from aiogram.types import Message
from aiogram.utils import executor

from glQiwiApi import QiwiWallet
from glQiwiApi.core.event_fetching.dispatcher import QiwiDispatcher
from glQiwiApi.core.event_fetching.executor import Context, start_non_blocking_qiwi_api_polling
from glQiwiApi.qiwi.clients.wallet.types import Transaction

qiwi_dp = QiwiDispatcher()
wallet = QiwiWallet(api_access_token='token', phone_number='+phone number')

dp = Dispatcher(Bot('BOT TOKEN'))


@qiwi_dp.transaction_handler()
async def handle_transaction(t: Transaction, ctx: Context):
    """Handle transaction here"""


@dp.message_handler()
async def handle_message(msg: Message):
    await msg.answer(text='Hello world')


async def on_startup(dp: Dispatcher):
    await start_non_blocking_qiwi_api_polling(wallet, qiwi_dp)


if __name__ == '__main__':
    executor.start_polling(dp, on_startup=on_startup)

```

--------------------------------

### Configure and Run Qiwi Bill Webhook Handler

Source: https://glqiwiapi.readthedocs.io/en/latest/webhooks.html

This example shows how to set up a webhook handler for Qiwi bills. It requires configuring the application with your bot token, wallet API token, and webhook details including encryption and host information. The handler processes incoming BillWebhook events.

```python
import logging

from aiogram import Bot, Dispatcher
from aiogram.dispatcher.webhook import configure_app
from aiohttp import web

from glQiwiApi import QiwiWallet
from glQiwiApi.core.event_fetching.dispatcher import QiwiDispatcher
from glQiwiApi.core.event_fetching.executor import Context, configure_app_for_qiwi_webhooks
from glQiwiApi.core.event_fetching.webhooks.config import (
    EncryptionConfig,
    HookRegistrationConfig,
    WebhookConfig,
)
from glQiwiApi.qiwi.clients.p2p.types import BillWebhook

qiwi_dp = QiwiDispatcher()

dp = Dispatcher(Bot('BOT TOKEN'))
wallet = QiwiWallet(api_access_token='wallet api token')


@qiwi_dp.bill_handler()
async def handle_webhook(webhook: BillWebhook, ctx: Context):
    # handle bill
    bill = webhook.bill


app = web.Application()
configure_app(
    dp,
    configure_app_for_qiwi_webhooks(
        wallet,
        qiwi_dp,
        app,
        WebhookConfig(
            encryption=EncryptionConfig(
                secret_p2p_key='secret p2p token, который был зарегистрирован с указанием айпи. '
                'Например http://айпи:8080/webhooks/qiwi/bills/'
            ),
            hook_registration=HookRegistrationConfig(host_or_ip_address='айпи:8080'),
        ),
    ),
    '/bot',
)

logging.basicConfig(level=logging.DEBUG)

if __name__ == '__main__':
    # Порт может быть любым
    web.run_app(app, port=8080)

```

--------------------------------

### Initialize QiwiMaps Client

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/qiwi/clients/maps/client.html

Instantiates the QiwiMaps client. It accepts an optional request service factory for custom request handling.

```python
import typing

from glQiwiApi.core.abc.base_api_client import BaseAPIClient, RequestServiceFactoryType
from glQiwiApi.core.request_service import RequestService, RequestServiceProto
from glQiwiApi.core.session import AiohttpSessionHolder
from glQiwiApi.qiwi.clients.maps.methods.get_partners import GetPartners
from glQiwiApi.qiwi.clients.maps.methods.get_terminals import GetTerminals
from glQiwiApi.qiwi.clients.maps.types.polygon import Polygon
from glQiwiApi.qiwi.clients.maps.types.terminal import Terminal
from glQiwiApi.qiwi.clients.wallet.types import Partner



class QiwiMaps(BaseAPIClient):
    """
    QIWI Terminal Maps API allows you to locate
    QIWI terminals on the territory of the Russian Federation

    """


    def __init__(
        self,
        request_service_factory: typing.Optional[RequestServiceFactoryType] = None,
    ) -> None:
        super().__init__(request_service_factory)


    async def _create_request_service(self) -> RequestServiceProto:
        return RequestService(
            session_holder=AiohttpSessionHolder(
                headers={
                    'Content-type': 'application/json',
                    'Accept': 'application/json',
                }
            )
        )
```

--------------------------------

### Get Receipt

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/qiwi/clients/wallet/client.html

Retrieves a receipt for a specific payment.

```APIDOC
## GET /payments/{paymentId}/receipt

### Description
Retrieves a receipt for a specific payment.

### Method
GET

### Endpoint
/payments/{paymentId}/receipt

### Parameters
#### Path Parameters
- **paymentId** (str) - Required - The ID of the payment.

### Response
#### Success Response (200)
- **receipt** (File) - The receipt file.
```

--------------------------------

### start_non_blocking_polling

Source: https://glqiwiapi.readthedocs.io/en/latest/genindex.html

Starts non-blocking polling. This method is available through the PollingExecutor.

```APIDOC
## start_non_blocking_polling()

### Description
Starts non-blocking polling.

### Method
This is a method within the `glQiwiApi.core.event_fetching.executor.PollingExecutor` class.
```

--------------------------------

### Get Nickname

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/qiwi/clients/wallet/client.html

Retrieve the nickname associated with the QIWI account.

```python
await self._request_service.execute_api_method(
            GetNickName(), phone_number=self.phone_number_without_plus_sign
        )
```

--------------------------------

### QiwiP2PClient Initialization

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/qiwi/clients/p2p/client.html

Initializes the QiwiP2PClient with a secret P2P key and optional shim server URL.

```APIDOC
## QiwiP2PClient

### Description

Provides an interface for interacting with the QIWI P2P API.

### Parameters

- **secret_p2p** (str) - Required - Your QIWI P2P secret key.
- **request_service_factory** (Optional[RequestServiceFactoryType]) - Optional - Factory for creating request services.
- **shim_server_url** (Optional[str]) - Optional - URL for the shim server.
```

--------------------------------

### Get Balance

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/qiwi/clients/wallet/client.html

Retrieves the balance for a specific account number.

```APIDOC
## Get Balance

### Description
Retrieves the balance for a specific account, identified by its account number. Defaults to the first account if not specified.

### Method
`get_balance(account_number: int = 1)`

### Parameters
#### Path Parameters
- `account_number` (int) - Optional - The number of the account for which to retrieve the balance. Defaults to 1.
```

--------------------------------

### Initialize QIWI Wallet Client

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/qiwi/clients/wallet/client.html

Initializes the QIWI Wallet client with an API access token and phone number. The request service factory can optionally be provided.

```python
async def __init__(
        self,
        api_access_token: str,
        phone_number: str,
        request_service_factory: Optional[RequestServiceFactoryType] = None,
    ) -> None:
        """
        :param api_access_token: QIWI API token received from https://qiwi.com/api
        :param phone_number: your phone number starting with +
        """
        self._api_access_token = api_access_token
        self._phone_number = phone_number

        BaseAPIClient.__init__(self, request_service_factory)
```

--------------------------------

### Initialize WebhookExecutor

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/core/event_fetching/executor.html

Initializes the WebhookExecutor with wallet, dispatcher, plugins, and optional configuration like context, event loop, and handlers.

```python
def __init__(
        self,
        wallet: Union[QiwiWallet, QiwiWrapper],
        dispatcher: BaseDispatcher,
        *plugins: Pluggable,
        context: Context,
        on_startup: Optional[_EventHandlerType] = None,
        on_shutdown: Optional[_EventHandlerType] = None,
        loop: Optional[asyncio.AbstractEventLoop] = None,
    ):
        super().__init__(
            dispatcher,
            *plugins,
            on_startup=on_startup,
            on_shutdown=on_shutdown,
            loop=loop,

```

--------------------------------

### Get History

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/qiwi/clients/wallet/client.html

Retrieves the transaction history for the QIWI account.

```APIDOC
## GET /paymentHistory

### Description
Retrieves the transaction history for the QIWI account.

### Method
GET

### Endpoint
/paymentHistory

### Query Parameters
- **startDate** (datetime) - Optional - The start date for filtering history.
- **endDate** (datetime) - Optional - The end date for filtering history.
- **operation** (str) - Optional - The type of operation to filter by.
- **sources** (List[Source]) - Optional - A list of sources to filter by.
- **limit** (int) - Optional - The maximum number of transactions to retrieve (default: MAX_HISTORY_LIMIT).

### Response
#### Success Response (200)
- **history** (List[History]) - A list of transaction history objects.
```

--------------------------------

### Get Identification

Source: https://glqiwiapi.readthedocs.io/en/latest/API/qiwi_api.html

Retrieves identification data for the QIWI wallet.

```APIDOC
## GET /identification

### Description
Retrieves identification data for the QIWI wallet. More detailed documentation: https://developer.qiwi.com/ru/qiwi-wallet-personal/?http#ident

### Method
GET

### Endpoint
/identification

### Response
#### Success Response (200)
- **Identification** (glQiwiApi.qiwi.clients.wallet.types.identification.Identification) - The identification data object.
```

--------------------------------

### Initialize QIWI Wallet Client

Source: https://glqiwiapi.readthedocs.io/en/latest/API/qiwi_api.html

Initializes the QIWI Wallet client with an API access token and an optional phone number. A request service factory can also be provided.

```python
class QiwiWallet(_api_access_token: str, _phone_number: Optional[str] = None, _request_service_factory: Optional[Callable[..., Union[Awaitable[RequestServiceProto], RequestServiceProto]]] = None)
```

```python
__init__(_api_access_token: str, _phone_number: Optional[str] = None, _request_service_factory: Optional[Callable[..., Union[Awaitable[RequestServiceProto], RequestServiceProto]]] = None) -> None
```

--------------------------------

### Configure and Add Webhook Routes

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/core/event_fetching/executor.html

Configures the application with webhook routes based on the provided configuration. Ensures the application is set up correctly before returning it.

```python
def add_routes_for_webhook(
        self, app: web.Application, config: WebhookConfig
    ) -> web.Application:
        supplemented_configuration = self.loop.run_until_complete(
            self._supplement_configuration(config)
        )
        try:
            return configure_app(
                dispatcher=self._dispatcher,
                app=app,
                webhook_config=supplemented_configuration,
            )
        finally:
            self.loop.run_until_complete(self._wallet.close())
```

--------------------------------

### Get Restrictions

Source: https://glqiwiapi.readthedocs.io/en/latest/API/qiwi_api.html

Retrieves information about any restrictions on the QIWI wallet.

```APIDOC
## GET /restrictions

### Description
Retrieves information about any restrictions on the QIWI wallet. Detailed documentation: https://developer.qiwi.com/ru/qiwi-wallet-personal/?python#restrictions

### Method
GET

### Endpoint
/restrictions

### Response
#### Success Response (200)
- **List[Restriction]** (List[glQiwiApi.qiwi.clients.wallet.types.restriction.Restriction]) - A list of restriction objects. Returns an empty list if there are no restrictions.
```

--------------------------------

### Get Transactions

Source: https://glqiwiapi.readthedocs.io/en/latest/API/qiwi_api.html

Retrieves a history of transactions for the QIWI account.

```APIDOC
## GET /transactions

### Description
Retrieves a history of transactions for the QIWI account. More detailed documentation: https://developer.qiwi.com/ru/qiwi-wallet-personal/?http#payments_list

### Method
GET

### Endpoint
/transactions

### Parameters
#### Query Parameters
- **rows** (int) - Optional - Number of transactions to retrieve. Defaults to 50.
- **operation** (TransactionType) - Optional - The type of operations to filter by. Defaults to TransactionType.ALL.
- **sources** (List[Source]) - Optional - A list of payment sources to filter by.
- **start_date** (datetime) - Optional - The starting date for filtering transactions. Used only in conjunction with end_date.
- **end_date** (datetime) - Optional - The end date for filtering transactions. Used only in conjunction with start_date.
- **next_txn_id** (int) - Optional - Used for pagination.
- **next_txn_date** (datetime) - Optional - Used for pagination.
```

--------------------------------

### QiwiWrapper Initialization

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/qiwi/clients/wrapper.html

Initializes the QiwiWrapper with optional API access token, phone number, and P2P secret key.

```APIDOC
## QiwiWrapper

### Description
Provides a unified interface for QIWI Wallet and P2P operations.

### Parameters
- **api_access_token** (Optional[str]) - Your QIWI API access token.
- **phone_number** (Optional[str]) - Your QIWI wallet phone number.
- **secret_p2p** (Optional[str]) - Your QIWI P2P secret key.
- **shim_server_url** (Optional[str]) - URL for the shim server, if applicable.
```

--------------------------------

### YooMoneyAPI Client Initialization

Source: https://glqiwiapi.readthedocs.io/en/latest/API/yoomoney_api.html

Initializes the YooMoneyAPI client with an access token. The constructor accepts an API access token and an optional request service factory.

```APIDOC
## YooMoneyAPI

### Description
Initializes the YooMoneyAPI client with an access token. The constructor accepts an API access token and an optional request service factory.

### Parameters
- **api_access_token** (str) - API token for requests.
- **request_service_factory** (Optional[Callable[[...], Union[Awaitable[RequestServiceProto], RequestServiceProto]]]) - Optional factory for creating request services.
```

--------------------------------

### Get Nickname

Source: https://glqiwiapi.readthedocs.io/en/latest/API/qiwi_api.html

Retrieves the nickname associated with the QIWI account.

```APIDOC
## GET /nickname

### Description
Retrieves the nickname associated with the QIWI account.

### Method
GET

### Endpoint
/nickname
```

--------------------------------

### Get Balance

Source: https://glqiwiapi.readthedocs.io/en/latest/API/qiwi_api.html

Retrieves the current balance of the QIWI account.

```APIDOC
## GET /balance

### Description
Retrieves the current balance of the QIWI account.

### Method
GET

### Endpoint
/balance

### Parameters
#### Query Parameters
- **account_number** (int) - Optional - The account number for which to retrieve the balance. Defaults to 1.
```

--------------------------------

### Run Referrer Proxy with Docker

Source: https://glqiwiapi.readthedocs.io/en/latest/getting-started/qiwi/examples.html

Instructions for running the referrer proxy manually using Docker. Pulls the latest image and runs it on port 80.

```bash
docker pull ghcr.io/glef1x/glqiwiapi-proxy:latest
docker run -p 80:80 ghcr.io/glef1x/glqiwiapi-proxy:latest
```

--------------------------------

### BaseExecutor Plugin Shutdown

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/core/event_fetching/executor.html

Handles the shutdown process for all installed plugins.

```python
async def _shutdown_plugins(self) -> None:
```

--------------------------------

### Interval Object

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/qiwi/clients/wallet/types/limit.html

Represents a time interval with a start and end date.

```APIDOC
## Interval Object

### Description
Represents a time interval for limits, defined by a start and end date.

### Fields
- **date_from** (datetime) - The start date of the interval.
- **date_till** (datetime) - The end date of the interval.
```

--------------------------------

### Get Webhook Secret

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/qiwi/clients/wallet/client.html

Retrieves the secret key for the registered webhook.

```APIDOC
## GET /webhooks/secret

### Description
Retrieves the secret key for the registered webhook.

### Method
GET

### Endpoint
/webhooks/secret

### Response
#### Success Response (200)
- **webhookSecret** (str) - The webhook secret key.
```

--------------------------------

### QiwiWrapper Initialization Check

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/qiwi/clients/wrapper.html

Ensures that either an API access token or a P2P secret is provided during initialization to prevent runtime errors.

```python
def __new__(
    cls: Type[_T],
    api_access_token: Optional[str] = None,
    phone_number: Optional[str] = None,
    secret_p2p: Optional[str] = None,
    cache_time_in_seconds: Union[float, int] = 0,
    *args: Any,
    **kwargs: Any,
) -> _T:
    if not isinstance(api_access_token, str) and not isinstance(secret_p2p, str):  # noqa: W503
        raise RuntimeError('Unable to initialize QiwiWrapper instance without any tokens')

    return super().__new__(cls)
```

--------------------------------

### Get Current Webhook

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/qiwi/clients/wallet/client.html

Retrieves the currently registered webhook URL.

```APIDOC
## GET /webhooks

### Description
Retrieves the currently registered webhook URL.

### Method
GET

### Endpoint
/webhooks

### Response
#### Success Response (200)
- **webhookInfo** (WebhookInfo) - Information about the registered webhook.
```

--------------------------------

### QiwiWallet Initialization

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/qiwi/clients/wallet/client.html

Initializes the QiwiWallet client with an API access token and an optional phone number.

```APIDOC
## QiwiWallet(api_access_token: str, phone_number: Optional[str] = None)

### Description
Initializes the QiwiWallet client.

### Parameters
- **api_access_token** (str) - Required - The API access token for authentication.
- **phone_number** (Optional[str]) - Optional - The phone number associated with the QIWI account.
```

--------------------------------

### buy_qiwi_master_package

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/qiwi/clients/wallet/client.html

Purchases the QIWI Master package. Requires specific API token permissions.

```APIDOC
## buy_qiwi_master_package

### Description
Method for buying QIWI Master package.
To call API methods, you need the QIWI Wallet API token with permissions to do the following:
1. Management of virtual cards,
2. Request information about the wallet profile,
3. View payment history,
4. Making payments without SMS.
You can choose these rights when creating a new api token, to use api QIWI Master

### Method
POST

### Endpoint
/universal_api/v1/proxy/ வழங்குனர்கள்/qiwi_master/package

### Request Example
{
  "phone_number": "+79161234567"
}

### Response
#### Success Response (200)
- **payment_info** (PaymentInfo) - Information about the payment for the QIWI Master package.
```

--------------------------------

### Get Balances

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/qiwi/clients/wallet/client.html

Retrieves the current balance information for the QIWI account.

```APIDOC
## GET /funding/accounts

### Description
Retrieves the current balance information for the QIWI account.

### Method
GET

### Endpoint
/funding/accounts

### Response
#### Success Response (200)
- **balances** (List[Balance]) - A list of balance objects.
```

--------------------------------

### Get Limits

Source: https://glqiwiapi.readthedocs.io/en/latest/API/qiwi_api.html

Retrieves the limits set for the QIWI wallet account.

```APIDOC
## GET /limits

### Description
Retrieves the limits set for the QIWI wallet account. Returns wallet limits as a list. Detailed documentation: https://developer.qiwi.com/ru/qiwi-wallet-personal/?http#limits

### Method
GET

### Endpoint
/limits

### Parameters
#### Query Parameters
- **limit_types** (List[str]) - Optional - A list of limit types to retrieve. Defaults to ['TURNOVER', 'REFILL', 'PAYMENTS_P2P', 'PAYMENTS_PROVIDER_INTERNATIONALS', 'PAYMENTS_PROVIDER_PAYOUT', 'WITHDRAW_CASH'].

### Response
#### Success Response (200)
- **Dict[str, Limit]** (Dict[str, glQiwiApi.qiwi.clients.wallet.types.limit.Limit]) - A dictionary containing limit information.
```

--------------------------------

### Buy QIWI Master Package

Source: https://glqiwiapi.readthedocs.io/en/latest/API/qiwi_api.html

Initiates the process for buying the QIWI Master package. Requires specific API token permissions.

```APIDOC
## POST /buy_qiwi_master

### Description
Method for buying QIWI Master package. To call API methods, you need the QIWI Wallet API token with permissions for management of virtual cards, request information about the wallet profile, view payment history, and making payments without SMS.

### Method
POST

### Endpoint
/buy_qiwi_master

### Response
#### Success Response (200)
- **payment_info** (PaymentInfo) - Information about the purchase.
```

--------------------------------

### Get Transaction Info

Source: https://glqiwiapi.readthedocs.io/en/latest/API/qiwi_api.html

Retrieves detailed information about a specific transaction.

```APIDOC
## GET /transaction_info/{transaction_id}/{transaction_type}

### Description
Retrieves detailed information about a specific transaction. Detailed documentation: https://developer.qiwi.com/ru/qiwi-wallet-personal/?python#txn_info

### Method
GET

### Endpoint
/transaction_info/{transaction_id}/{transaction_type}

### Parameters
#### Path Parameters
- **transaction_id** (Union[str, int]) - Required - The ID of the transaction.
- **transaction_type** (TransactionType) - Required - The type of the transaction (IN or OUT).

### Response
#### Success Response (200)
- **Transaction** (glQiwiApi.qiwi.clients.wallet.types.transaction.Transaction) - The transaction object.
```

--------------------------------

### BaseExecutor Initialization

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/core/event_fetching/executor.html

Initializes the BaseExecutor with a dispatcher, optional plugins, context, and event handlers for startup and shutdown.

```python
def __init__(
        self,
        dispatcher: BaseDispatcher,
        *plugins: Pluggable,
        context: Context,
        loop: Optional[asyncio.AbstractEventLoop] = None,
        on_startup: Optional[Callable[..., Any]] = None,
        on_shutdown: Optional[Callable[..., Any]] = None,
    ) -> None:
        if loop is not None:
            self._loop = loop  # pragma: no cover
        self._on_startup = ExecutorEvent(context, init_handlers=[on_startup], loop=self.loop)
        self._on_shutdown = ExecutorEvent(context, init_handlers=[on_shutdown], loop=self.loop)
        self._dispatcher = dispatcher
        self._plugins = plugins
        self._context = context
```

--------------------------------

### Get Partners

Source: https://glqiwiapi.readthedocs.io/en/latest/API/qiwi_maps.html

Retrieves information about QIWI partners. This is an asynchronous method.

```APIDOC
## Method: _partners

### Description
Retrieves information about QIWI partners.

### Method
async

### Parameters
* `*args`: Any positional arguments.
* `**kw`: Any keyword arguments.
```

--------------------------------

### Get Terminals

Source: https://glqiwiapi.readthedocs.io/en/latest/API/qiwi_maps.html

Retrieves information about QIWI terminals. This is an asynchronous method.

```APIDOC
## Method: _terminals

### Description
Retrieves information about QIWI terminals.

### Method
async

### Parameters
* `*args`: Any positional arguments.
* `**kw`: Any keyword arguments.
```

--------------------------------

### QiwiWrapper Asynchronous Context Management

Source: https://glqiwiapi.readthedocs.io/en/latest/_modules/glQiwiApi/qiwi/clients/wrapper.html

Implements asynchronous context management protocols (__aenter__ and __aexit__) for proper initialization and cleanup of underlying QIWI wallet and P2P clients.

```python
async def __aenter__(self) -> 'QiwiWrapper':
    await self._qiwi_wallet.__aenter__()  # type: ignore
    await self._p2p_client.__aenter__()  # type: ignore
    return self
```

```python
async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:  # type: ignore
    await self._qiwi_wallet.__aexit__(exc_type, exc_val, exc_tb)
    await self._p2p_client.__aexit__(exc_type, exc_val, exc_tb)
```
Tokens:
Raw