pytonapi 0.3.6__tar.gz → 0.3.7__tar.gz

pytonapi-0.3.7/PKG-INFO

@@ -0,0 +1,134 @@
+Metadata-Version: 2.1
+Name: pytonapi
+Version: 0.3.7
+Summary: Provide access to indexed TON blockchain.
+Home-page: https://github.com/tonkeeper/pytonapi/
+Author: nessshon
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.26.0
+Requires-Dist: websockets>=12.0
+Requires-Dist: pydantic==2.*
+
+# 📦 PyTONAPI
+
+[![TON](https://img.shields.io/badge/TON-grey?logo=TON&logoColor=40AEF0)](https://ton.org)
+[![PyPI](https://img.shields.io/pypi/v/pytonapi.svg?color=FFE873&labelColor=3776AB)](https://pypi.python.org/pypi/pytonapi)
+![Python Versions](https://img.shields.io/badge/Python-3.7%20--%203.12-black?color=FFE873&labelColor=3776AB)
+[![License](https://img.shields.io/github/license/tonkeeper/pytonapi)](https://github.com/tonkeeper/pytonapi/blob/main/LICENSE)
+
+![Image](https://telegra.ph//file/f88bcf9051073973edbd6.jpg)
+
+![Downloads](https://pepy.tech/badge/pytonapi)
+![Downloads](https://pepy.tech/badge/pytonapi/month)
+![Downloads](https://pepy.tech/badge/pytonapi/week)
+
+Python SDK for [tonapi.io](https://tonapi.io).\
+Information about the API can be found in the  [documentation](https://docs.tonconsole.com/tonapi/api-v2).\
+To use the API **you need an API key**, you can get it here [tonconsole.com](https://tonconsole.com/).
+
+<blockquote>
+For creating wallets, transferring TON, Jetton, NFTs, and other operations, recommend using <a href="https://github.com/nessshon/tonutils">tonutils</a> in combination with <code>TonapiClient</code>. For more information, refer to the library documentation.
+</blockquote>
+
+## Usage
+
+### Installation
+
+```bash
+pip install pytonapi
+```
+
+### Examples
+
+* **Asynchronous**
+
+  ```python
+  from pytonapi import AsyncTonapi
+  
+  
+  # Declare an asynchronous function for using await
+  async def main():
+      # Create a new Tonapi object with the provided API key
+      tonapi = AsyncTonapi(api_key="Your API key")
+  
+      # Specify the account ID
+      account_id = "EQC-3ilVr-W0Uc3pLrGJElwSaFxvhXXfkiQA3EwdVBHNNess"  # noqa
+  
+      # Retrieve account information asynchronously
+      account = await tonapi.accounts.get_info(account_id=account_id)
+  
+      # Print account details
+      print(f"Account Address (raw): {account.address.to_raw()}")
+      print(f"Account Address (userfriendly): {account.address.to_userfriendly(is_bounceable=True)}")
+      print(f"Account Balance (nanoton): {account.balance.to_nano()}")
+      print(f"Account Balance (amount): {account.balance.to_amount()}")
+  
+  
+  if __name__ == '__main__':
+      import asyncio
+  
+      # Run the asynchronous function
+      asyncio.run(main())
+  
+  ```
+
+* **Synchronous**
+
+  ```python
+  from pytonapi import Tonapi
+  
+  
+  def main():
+      # Create a new Tonapi object with the provided API key
+      tonapi = Tonapi(api_key="Your API key")
+  
+      # Specify the account ID
+      account_id = "EQC-3ilVr-W0Uc3pLrGJElwSaFxvhXXfkiQA3EwdVBHNNess"  # noqa
+  
+      # Retrieve account information
+      account = tonapi.accounts.get_info(account_id=account_id)
+  
+      # Print account details
+      print(f"Account Address (raw): {account.address.to_raw()}")
+      print(f"Account Address (userfriendly): {account.address.to_userfriendly(is_bounceable=True)}")
+      print(f"Account Balance (nanoton): {account.balance.to_nano()}")
+      print(f"Account Balance (amount): {account.balance.to_amount()}")
+  
+  
+  if __name__ == '__main__':
+      main()
+  ```
+
+* **Additional examples** can be found [examples](https://github.com/tonkeeper/pytonapi/tree/main/examples) folder.
+
+## Donations
+
+**TON** - `EQC-3ilVr-W0Uc3pLrGJElwSaFxvhXXfkiQA3EwdVBHNNess`
+
+**USDT** (TRC-20) - `TJjADKFT2i7jqNJAxkgeRm5o9uarcoLUeR`
+
+## Contribution
+
+We welcome your contributions! If you have ideas for improvement or have identified a bug, please create an issue or
+submit a pull request.
+
+## Support
+
+Supported by  [TONAPI](https://tonapi.io) and [TON Society](https://github.com/ton-society/grants-and-bounties) (Grants
+and Bounties program).
+
+## License
+
+This repository is distributed under the [MIT License](https://github.com/tonkeeper/pytonapi/blob/main/LICENSE). Feel
+free to use, modify, and distribute the code in accordance
+with the terms of the license.
+

pytonapi-0.3.7/README.md

@@ -0,0 +1,114 @@
+# 📦 PyTONAPI
+
+[![TON](https://img.shields.io/badge/TON-grey?logo=TON&logoColor=40AEF0)](https://ton.org)
+[![PyPI](https://img.shields.io/pypi/v/pytonapi.svg?color=FFE873&labelColor=3776AB)](https://pypi.python.org/pypi/pytonapi)
+![Python Versions](https://img.shields.io/badge/Python-3.7%20--%203.12-black?color=FFE873&labelColor=3776AB)
+[![License](https://img.shields.io/github/license/tonkeeper/pytonapi)](https://github.com/tonkeeper/pytonapi/blob/main/LICENSE)
+
+![Image](https://telegra.ph//file/f88bcf9051073973edbd6.jpg)
+
+![Downloads](https://pepy.tech/badge/pytonapi)
+![Downloads](https://pepy.tech/badge/pytonapi/month)
+![Downloads](https://pepy.tech/badge/pytonapi/week)
+
+Python SDK for [tonapi.io](https://tonapi.io).\
+Information about the API can be found in the  [documentation](https://docs.tonconsole.com/tonapi/api-v2).\
+To use the API **you need an API key**, you can get it here [tonconsole.com](https://tonconsole.com/).
+
+<blockquote>
+For creating wallets, transferring TON, Jetton, NFTs, and other operations, recommend using <a href="https://github.com/nessshon/tonutils">tonutils</a> in combination with <code>TonapiClient</code>. For more information, refer to the library documentation.
+</blockquote>
+
+## Usage
+
+### Installation
+
+```bash
+pip install pytonapi
+```
+
+### Examples
+
+* **Asynchronous**
+
+  ```python
+  from pytonapi import AsyncTonapi
+  
+  
+  # Declare an asynchronous function for using await
+  async def main():
+      # Create a new Tonapi object with the provided API key
+      tonapi = AsyncTonapi(api_key="Your API key")
+  
+      # Specify the account ID
+      account_id = "EQC-3ilVr-W0Uc3pLrGJElwSaFxvhXXfkiQA3EwdVBHNNess"  # noqa
+  
+      # Retrieve account information asynchronously
+      account = await tonapi.accounts.get_info(account_id=account_id)
+  
+      # Print account details
+      print(f"Account Address (raw): {account.address.to_raw()}")
+      print(f"Account Address (userfriendly): {account.address.to_userfriendly(is_bounceable=True)}")
+      print(f"Account Balance (nanoton): {account.balance.to_nano()}")
+      print(f"Account Balance (amount): {account.balance.to_amount()}")
+  
+  
+  if __name__ == '__main__':
+      import asyncio
+  
+      # Run the asynchronous function
+      asyncio.run(main())
+  
+  ```
+
+* **Synchronous**
+
+  ```python
+  from pytonapi import Tonapi
+  
+  
+  def main():
+      # Create a new Tonapi object with the provided API key
+      tonapi = Tonapi(api_key="Your API key")
+  
+      # Specify the account ID
+      account_id = "EQC-3ilVr-W0Uc3pLrGJElwSaFxvhXXfkiQA3EwdVBHNNess"  # noqa
+  
+      # Retrieve account information
+      account = tonapi.accounts.get_info(account_id=account_id)
+  
+      # Print account details
+      print(f"Account Address (raw): {account.address.to_raw()}")
+      print(f"Account Address (userfriendly): {account.address.to_userfriendly(is_bounceable=True)}")
+      print(f"Account Balance (nanoton): {account.balance.to_nano()}")
+      print(f"Account Balance (amount): {account.balance.to_amount()}")
+  
+  
+  if __name__ == '__main__':
+      main()
+  ```
+
+* **Additional examples** can be found [examples](https://github.com/tonkeeper/pytonapi/tree/main/examples) folder.
+
+## Donations
+
+**TON** - `EQC-3ilVr-W0Uc3pLrGJElwSaFxvhXXfkiQA3EwdVBHNNess`
+
+**USDT** (TRC-20) - `TJjADKFT2i7jqNJAxkgeRm5o9uarcoLUeR`
+
+## Contribution
+
+We welcome your contributions! If you have ideas for improvement or have identified a bug, please create an issue or
+submit a pull request.
+
+## Support
+
+Supported by  [TONAPI](https://tonapi.io) and [TON Society](https://github.com/ton-society/grants-and-bounties) (Grants
+and Bounties program).
+
+## License
+
+This repository is distributed under the [MIT License](https://github.com/tonkeeper/pytonapi/blob/main/LICENSE). Feel
+free to use, modify, and distribute the code in accordance
+with the terms of the license.
+

{pytonapi-0.3.6 → pytonapi-0.3.7}/pytonapi/async_tonapi/__init__.py

@@ -1,36 +1,39 @@
 from typing import Any, Dict, Optional
 
 from pytonapi.async_tonapi import methods
-from pytonapi.async_tonapi.client import AsyncTonapiClient
+from pytonapi.async_tonapi.client import AsyncTonapiClientBase
 
 __all__ = [
     "AsyncTonapi",
-    "AsyncTonapiClient",
+    "AsyncTonapiClientBase",
 ]
 
 
-class AsyncTonapi(AsyncTonapiClient):
+class AsyncTonapi(AsyncTonapiClientBase):
 
     def __init__(
             self,
             api_key: str,
-            is_testnet: Optional[bool] = False,
-            max_retries: Optional[int] = None,
+            is_testnet: bool = False,
+            max_retries: int = 0,
             base_url: Optional[str] = None,
             websocket_url: Optional[str] = None,
             headers: Optional[Dict[str, Any]] = None,
             timeout: Optional[float] = None,
+            debug: bool = False,
+            **kwargs,
     ) -> None:
         """
         Initialize the AsyncTonapiClient.
 
         :param api_key: The API key.
+        :param is_testnet: Use True if using the testnet.
+        :param max_retries: Maximum number of retries per request if rate limit is reached.
         :param base_url: The base URL for the API.
         :param websocket_url: The URL for the WebSocket server.
-        :param is_testnet: Use True if using the testnet.
-        :param timeout: Request timeout in seconds.
         :param headers: Additional headers to include in requests.
-        :param max_retries: Maximum number of retries per request if rate limit is reached.
+        :param timeout: Request timeout in seconds.
+        :param debug: Enable debug mode.
         """
         super().__init__(
             api_key=api_key,
@@ -40,6 +43,8 @@ class AsyncTonapi(AsyncTonapiClient):
             websocket_url=websocket_url,
             headers=headers,
             timeout=timeout,
+            debug=debug,
+            **kwargs,
         )
 
     @property
@@ -70,6 +75,10 @@ class AsyncTonapi(AsyncTonapiClient):
     def events(self) -> methods.EventsMethod:
         return methods.EventsMethod(**self.__dict__)
 
+    @property
+    def gasless(self) -> methods.GaslessMethod:
+        return methods.GaslessMethod(**self.__dict__)
+
     @property
     def inscriptions(self) -> methods.InscriptionsMethod:
         return methods.InscriptionsMethod(**self.__dict__)
@@ -102,6 +111,10 @@ class AsyncTonapi(AsyncTonapiClient):
     def traces(self) -> methods.TracesMethod:
         return methods.TracesMethod(**self.__dict__)
 
+    @property
+    def utilities(self) -> methods.UtilitiesMethod:
+        return methods.UtilitiesMethod(**self.__dict__)
+
     @property
     def wallet(self) -> methods.WalletMethod:
         return methods.WalletMethod(**self.__dict__)

{pytonapi-0.3.6 → pytonapi-0.3.7}/pytonapi/async_tonapi/client.py

@@ -1,10 +1,10 @@
 import asyncio
 import json
-import logging
 from typing import Any, Dict, Optional, AsyncGenerator
 
 import httpx
 import websockets
+from httpx import URL, QueryParams
 
 from pytonapi.exceptions import (
     TONAPIBadRequestError,
@@ -16,9 +16,10 @@ from pytonapi.exceptions import (
     TONAPINotImplementedError,
     TONAPISSEError,
 )
+from pytonapi.logger_config import setup_logging
 
 
-class AsyncTonapiClient:
+class AsyncTonapiClientBase:
     """
     Asynchronous TON API Client.
     """
@@ -26,23 +27,26 @@ class AsyncTonapiClient:
     def __init__(
             self,
             api_key: str,
-            is_testnet: Optional[bool] = False,
-            max_retries: Optional[int] = None,
+            is_testnet: bool = False,
+            max_retries: int = 0,
             base_url: Optional[str] = None,
             websocket_url: Optional[str] = None,
             headers: Optional[Dict[str, Any]] = None,
             timeout: Optional[float] = None,
+            debug: bool = False,
+            **kwargs,
     ) -> None:
         """
         Initialize the AsyncTonapiClient.
 
         :param api_key: The API key.
+        :param is_testnet: Use True if using the testnet.
+        :param max_retries: Maximum number of retries per request if rate limit is reached.
         :param base_url: The base URL for the API.
         :param websocket_url: The URL for the WebSocket server.
-        :param is_testnet: Use True if using the testnet.
-        :param timeout: Request timeout in seconds.
         :param headers: Additional headers to include in requests.
-        :param max_retries: Maximum number of retries per request if rate limit is reached.
+        :param timeout: Request timeout in seconds.
+        :param debug: Enable debug mode.
         """
         self.api_key = api_key
         self.is_testnet = is_testnet
@@ -53,6 +57,9 @@ class AsyncTonapiClient:
         self.websocket_url = websocket_url or "wss://tonapi.io/v2/websocket"
         self.headers = headers or {"Authorization": f"Bearer {api_key}"}
 
+        self.debug = debug
+        self.logger = setup_logging(self.debug)
+
     @staticmethod
     async def __read_content(response: httpx.Response) -> Any:
         """
@@ -97,15 +104,18 @@ class AsyncTonapiClient:
                 501: TONAPINotImplementedError,
             }
             error_class = error_map.get(response.status_code, TONAPIError)
-            error_message = content.get("error") if isinstance(content, dict) else content
-            raise error_class(error_message)
+
+            if isinstance(content, dict):
+                content = content.get("error") or content.get("Error")
+            self.logger.error(f"Error response received: {content}")
+            raise error_class(content)
 
         return content
 
     async def _subscribe(
             self,
             method: str,
-            params: Optional[Dict[str, Any]],
+            params: Dict[str, Any],
     ) -> AsyncGenerator[str, None]:
         """
         Subscribe to an SSE event stream.
@@ -115,26 +125,36 @@ class AsyncTonapiClient:
         """
         url = self.base_url + method
         timeout = httpx.Timeout(timeout=self.timeout)
-        data = {"headers": self.headers, "params": params, "timeout": timeout}
 
+        self.logger.debug(f"Subscribing to SSE with URL: {url} and params: {params}")
         async with httpx.AsyncClient() as client:
             try:
-                async with client.stream("GET", url=url, **data) as response:
-                    response: httpx.Response
+                async with client.stream(
+                        method="GET",
+                        url=url,
+                        headers=self.headers,
+                        params=params or {},
+                        timeout=timeout,
+                ) as response:
                     response.raise_for_status()
 
                     async for line in response.aiter_lines():
                         try:
                             key, value = line.split(": ", 1)
                         except ValueError:
+                            self.logger.debug(f"Skipped line due to ValueError: {line}")
                             continue
                         if value == "heartbeat":
+                            self.logger.debug("Received heartbeat")
                             continue
                         if key == "data":
+                            self.logger.debug(f"Received SSE data: {value}")
                             yield value
             except httpx.LocalProtocolError:
+                self.logger.error("Local protocol error during SSE subscription.")
                 raise TONAPIUnauthorizedError
             except httpx.HTTPStatusError as e:
+                self.logger.error(f"HTTP status error during SSE subscription: {e}")
                 raise TONAPISSEError(e)
 
     async def _subscribe_websocket(
@@ -155,6 +175,7 @@ class AsyncTonapiClient:
             "method": method,
             "params": params,
         }
+        self.logger.debug("Subscribing to WebSocket with payload: {payload}")
         async with websockets.connect(self.websocket_url) as websocket:
             try:
                 await websocket.send(json.dumps(payload))
@@ -163,9 +184,11 @@ class AsyncTonapiClient:
                     message_json = json.loads(message)
                     if "params" in message_json:
                         value = message_json["params"]
+                        self.logger.debug(f"Received WebSocket message: {value}")
                         yield value
-            except websockets.exceptions.ConnectionClosed:
-                raise
+            except websockets.exceptions.ConnectionClosed as e:
+                self.logger.error(f"WebSocket connection closed unexpectedly: {e}")
+                raise TONAPIError(e)
 
     async def _request(
             self,
@@ -188,14 +211,33 @@ class AsyncTonapiClient:
         url = self.base_url + path
         self.headers.update(headers or {})
         timeout = httpx.Timeout(timeout=self.timeout)
+
+        self.logger.debug(f"Request {method}: {URL(url).copy_merge_params(QueryParams(params))}")
+        self.logger.debug(f"Request headers: {self.headers}")
+        if params:
+            self.logger.debug(f"Request params: {params}")
+        if body:
+            self.logger.debug(f"Request body: {body}")
         try:
             async with httpx.AsyncClient(headers=self.headers, timeout=timeout) as session:
-                session: httpx.AsyncClient
-                data = {"params": params or {}, "json": body or {}}
-                response = await session.request(method=method, url=url, **data)
-                return await self.__process_response(response)
+                response = await session.request(
+                    method=method,
+                    url=url,
+                    params=params or {},
+                    json=body or {},
+                )
+                response_content = await self.__process_response(response)
+                self.logger.debug(f"Response received - Status code: {response.status_code}")
+                self.logger.debug(f"Response headers: {response.headers}")
+                self.logger.debug(f"Response content: {response_content}")
+                return response_content
+
         except httpx.LocalProtocolError:
+            self.logger.error("Local protocol error occurred during request.")
             raise TONAPIUnauthorizedError
+        except httpx.HTTPStatusError as e:
+            self.logger.error(f"HTTP status error during request: {e}")
+            raise TONAPIError(e)
 
     async def _request_retries(
             self,
@@ -225,12 +267,10 @@ class AsyncTonapiClient:
                     body=body,
                 )
             except TONAPITooManyRequestsError:
-                logging.warning(
-                    f"Rate limit exceeded. "
-                    f"Retrying {i + 1}/{self.max_retries} is in progress."
-                )
+                self.logger.warning(f"Rate limit exceeded. Retrying {i + 1}/{self.max_retries} in 1 second.")
                 await asyncio.sleep(1)
 
+        self.logger.error("Max retries exceeded while making request")
         raise TONAPITooManyRequestsError
 
     async def _get(
@@ -248,7 +288,7 @@ class AsyncTonapiClient:
         :return: The response content as a dictionary.
         """
         request = self._request
-        if self.max_retries:
+        if self.max_retries > 0:
             request = self._request_retries
         return await request("GET", method, headers, params=params)
 
@@ -268,6 +308,6 @@ class AsyncTonapiClient:
         :return: The response content as a dictionary.
         """
         request = self._request
-        if self.max_retries:
+        if self.max_retries > 0:
             request = self._request_retries
         return await request("POST", method, headers, params=params, body=body)

{pytonapi-0.3.6 → pytonapi-0.3.7}/pytonapi/async_tonapi/methods/__init__.py

@@ -3,6 +3,7 @@ from .blockchain import BlockchainMethod
 from .dns import DnsMethod
 from .emulate import EmulateMethod
 from .events import EventsMethod
+from .gasless import GaslessMethod
 from .inscriptions import InscriptionsMethod
 from .jettons import JettonsMethod
 from .liteserver import LiteserverMethod
@@ -13,6 +14,7 @@ from .staking import StakingMethod
 from .storage import StorageMethod
 from .tonconnect import TonconnectMethod
 from .traces import TracesMethod
+from .utilites import UtilitiesMethod
 from .wallet import WalletMethod
 from .websocket import WebSocketMethod
 
@@ -22,6 +24,7 @@ __all__ = [
     "DnsMethod",
     "EmulateMethod",
     "EventsMethod",
+    "GaslessMethod",
     "InscriptionsMethod",
     "JettonsMethod",
     "LiteserverMethod",
@@ -32,6 +35,7 @@ __all__ = [
     "StorageMethod",
     "TonconnectMethod",
     "TracesMethod",
+    "UtilitiesMethod",
     "WalletMethod",
     "WebSocketMethod",
 ]