pytonapi 0.4.0__tar.gz → 0.4.2__tar.gz

{pytonapi-0.4.0 → pytonapi-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pytonapi
-Version: 0.4.0
+Version: 0.4.2
 Summary: Provide access to indexed TON blockchain.
 Home-page: https://github.com/tonkeeper/pytonapi/
 Author: nessshon

{pytonapi-0.4.0 → pytonapi-0.4.2}/pytonapi/async_tonapi/__init__.py

@@ -123,6 +123,10 @@ class AsyncTonapi(AsyncTonapiClientBase):
     def wallet(self) -> methods.WalletMethod:
         return methods.WalletMethod(**self.__dict__)
 
+    @property
+    def webhooks(self) -> methods.WebhooksMethod:
+        return methods.WebhooksMethod(**self.__dict__)
+
     @property
     def websocket(self) -> methods.WebSocketMethod:
         return methods.WebSocketMethod(**self.__dict__)

{pytonapi-0.4.0 → pytonapi-0.4.2}/pytonapi/async_tonapi/client.py

@@ -311,3 +311,22 @@ class AsyncTonapiClientBase:
         if self.max_retries > 0:
             request = self._request_retries
         return await request("POST", method, headers, params=params, body=body)
+
+    async def _delete(
+            self,
+            method: str,
+            params: Optional[Dict[str, Any]] = None,
+            headers: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Make a DELETE request.
+
+        :param method: The API method.
+        :param params: Optional query parameters.
+        :param headers: Optional headers to include in the request.
+        :return: The response content as a dictionary.
+        """
+        request = self._request
+        if self.max_retries > 0:
+            request = self._request_retries
+        return await request("DELETE", method, headers, params=params)

{pytonapi-0.4.0 → pytonapi-0.4.2}/pytonapi/async_tonapi/methods/__init__.py

@@ -17,6 +17,7 @@ from .tonconnect import TonconnectMethod
 from .traces import TracesMethod
 from .utilites import UtilitiesMethod
 from .wallet import WalletMethod
+from .webhooks import WebhooksMethod
 from .websocket import WebSocketMethod
 
 __all__ = [
@@ -39,5 +40,6 @@ __all__ = [
     "TracesMethod",
     "UtilitiesMethod",
     "WalletMethod",
+    "WebhooksMethod",
     "WebSocketMethod",
 ]

{pytonapi-0.4.0 → pytonapi-0.4.2}/pytonapi/async_tonapi/methods/accounts.py

@@ -57,28 +57,49 @@ class AccountsMethod(AsyncTonapiClientBase):
 
         return DomainNames(**response)
 
-    async def get_jettons_balances(self, account_id: str) -> JettonsBalances:
+    async def get_jettons_balances(
+            self,
+            account_id: str,
+            currencies: Optional[List[str]] = None,
+            supported_extensions: Optional[List[str]] = None,
+    ) -> JettonsBalances:
         """
         Get all Jettons balances by owner address.
 
         :param account_id: account ID
+        :param currencies: accept ton and all possible fiat currencies, separated by commas
+        :param supported_extensions: comma separated list supported extensions
         :return: :class:`JettonsBalances`
         """
         method = f"v2/accounts/{account_id}/jettons"
-        response = await self._get(method=method)
+        params = {"supported_extensions": ",".join(supported_extensions)} if supported_extensions else {}
+        if currencies:
+            params["currencies"] = ",".join(currencies)
+        response = await self._get(method=method, params=params)
 
         return JettonsBalances(**response)
 
-    async def get_jetton_balance(self, account_id: str, jetton_id: str) -> JettonBalance:
+    async def get_jetton_balance(
+            self,
+            account_id: str,
+            jetton_id: str,
+            currencies: Optional[List[str]] = None,
+            supported_extensions: Optional[List[str]] = None,
+    ) -> JettonBalance:
         """
         Get Jetton balance by owner address
 
         :param account_id: account ID
         :param jetton_id: jetton ID
+        :param currencies: accept ton and all possible fiat currencies, separated by commas
+        :param supported_extensions: comma separated list supported extensions
         :return: :class:`JettonBalance`
         """
         method = f"v2/accounts/{account_id}/jettons/{jetton_id}"
-        response = await self._get(method=method)
+        params = {"supported_extensions": ",".join(supported_extensions)} if supported_extensions else {}
+        if currencies:
+            params["currencies"] = ",".join(currencies)
+        response = await self._get(method=method, params=params)
 
         return JettonBalance(**response)
 

pytonapi-0.4.2/pytonapi/async_tonapi/methods/webhooks.py

@@ -0,0 +1,81 @@
+from typing import List
+
+from pytonapi.async_tonapi.client import AsyncTonapiClientBase
+from pytonapi.schema.webhooks import WebhookCreate, WebhookList, AccountSubscriptions
+
+
+class WebhooksMethod(AsyncTonapiClientBase):
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.base_url = "https://rt.tonapi.io/"
+
+    async def create_webhook(self, endpoint: str) -> WebhookCreate:
+        """
+        Create a new webhook and return its ID.
+
+        :param endpoint: The webhook endpoint URL to receive transaction events.
+        :return: An object containing the ID of the created webhook.
+        :rtype: WebhookCreate
+        """
+        method = "webhooks"
+        body = {"endpoint": endpoint}
+        response = await self._post(method=method, body=body)
+        return WebhookCreate(**response)
+
+    async def list_webhooks(self) -> WebhookList:
+        """
+        Retrieve a list of all available webhooks.
+
+        :return: A list containing all webhooks with their IDs and endpoints.
+        :rtype: WebhookList
+        """
+        method = "webhooks"
+        response = await self._get(method=method)
+        return WebhookList(**response)
+
+    async def delete_webhook(self, webhook_id: int) -> None:
+        """
+        Delete a webhook and all its subscriptions.
+
+        :param webhook_id: The ID of the webhook to delete.
+        """
+        method = f"webhooks/{webhook_id}"
+        await self._delete(method=method)
+
+    async def subscribe_to_account(self, webhook_id: int, accounts: List[str]) -> None:
+        """
+        Subscribe a webhook to specific account transactions.
+
+        :param webhook_id: The ID of the webhook to subscribe.
+        :param accounts: A list of account IDs to subscribe to.
+        """
+        method = f"webhooks/{webhook_id}/account-tx/subscribe"
+        body = {"accounts": [{"account_id": account} for account in accounts]}
+        await self._post(method=method, body=body)
+
+    async def unsubscribe_from_account(self, webhook_id: int, accounts: List[str]) -> None:
+        """
+        Unsubscribe a webhook from specific account transactions.
+
+        :param webhook_id: The ID of the webhook to unsubscribe.
+        :param accounts: A list of account IDs to unsubscribe from.
+        """
+        method = f"webhooks/{webhook_id}/account-tx/unsubscribe"
+        body = {"accounts": accounts}
+        await self._post(method=method, body=body)
+
+    async def get_subscriptions(self, webhook_id: int, offset: int = 0, limit: int = 10) -> AccountSubscriptions:
+        """
+        Retrieve the list of subscriptions for a given webhook.
+
+        :param webhook_id: The ID of the webhook.
+        :param offset: The offset for pagination. Default is 0.
+        :param limit: The maximum number of subscriptions to return. Default is 10.
+        :return: A list of account transaction subscriptions with details.
+        :rtype: AccountSubscriptions
+        """
+        method = f"webhooks/{webhook_id}/account-tx/subscriptions"
+        params = {"offset": offset, "limit": limit}
+        response = await self._get(method=method, params=params)
+        return AccountSubscriptions(**response)

{pytonapi-0.4.0 → pytonapi-0.4.2}/pytonapi/schema/rates.py

@@ -12,7 +12,7 @@ class ChartRates(BaseModel):
 
 
 class TokenRates(BaseModel):
-    prices: Optional[Dict[str, str]] = None
+    prices: Optional[Dict[str, Union[float, int]]] = None
     diff_24h: Optional[Dict[str, str]] = None
     diff_7d: Optional[Dict[str, str]] = None
     diff_30d: Optional[Dict[str, str]] = None

pytonapi-0.4.2/pytonapi/schema/webhooks.py

@@ -0,0 +1,33 @@
+from typing import List, Optional
+
+from pydantic import BaseModel
+
+
+class WebhookCreate(BaseModel):
+    webhook_id: int
+
+
+class Webhook(BaseModel):
+    id: int
+    endpoint: str
+
+
+class WebhookList(BaseModel):
+    webhooks: List[Webhook]
+
+
+class AccountSubscription(BaseModel):
+    accounts: List[dict]
+
+
+
+class AccountTxSubscription(BaseModel):
+    account_id: str
+    last_delivered_lt: int
+    failed_at: Optional[str] = None
+    failed_lt: Optional[int] = None
+    failed_attempts: Optional[int] = None
+
+
+class AccountSubscriptions(BaseModel):
+    account_tx_subscriptions: List[AccountTxSubscription]

{pytonapi-0.4.0 → pytonapi-0.4.2}/pytonapi/tonapi/__init__.py

@@ -114,3 +114,7 @@ class Tonapi(TonapiClientBase):
     @property
     def wallet(self) -> methods.WalletMethod:
         return methods.WalletMethod(**self.__dict__)
+
+    @property
+    def webhooks(self) -> methods.WebhooksMethod:
+        return methods.WebhooksMethod(**self.__dict__)

{pytonapi-0.4.0 → pytonapi-0.4.2}/pytonapi/tonapi/client.py

@@ -266,3 +266,22 @@ class TonapiClientBase:
         if self.max_retries > 0:
             request = self._request_retries
         return request("POST", method, headers, params=params, body=body)
+
+    def _delete(
+            self,
+            method: str,
+            params: Optional[Dict[str, Any]] = None,
+            headers: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Make a DELETE request.
+
+        :param method: The API method.
+        :param params: Optional query parameters.
+        :param headers: Optional headers to include in the request.
+        :return: The response content as a dictionary.
+        """
+        request = self._request
+        if self.max_retries > 0:
+            request = self._request_retries
+        return request("DELETE", method, headers, params=params)

{pytonapi-0.4.0 → pytonapi-0.4.2}/pytonapi/tonapi/methods/__init__.py

@@ -17,6 +17,7 @@ from .tonconnect import TonconnectMethod
 from .traces import TracesMethod
 from .utilites import UtilitiesMethod
 from .wallet import WalletMethod
+from .webhooks import WebhooksMethod
 
 __all__ = [
     "AccountsMethod",
@@ -38,4 +39,5 @@ __all__ = [
     "TracesMethod",
     "UtilitiesMethod",
     "WalletMethod",
+    "WebhooksMethod",
 ]

{pytonapi-0.4.0 → pytonapi-0.4.2}/pytonapi/tonapi/methods/accounts.py

@@ -57,28 +57,49 @@ class AccountsMethod(TonapiClientBase):
 
         return DomainNames(**response)
 
-    def get_jettons_balances(self, account_id: str) -> JettonsBalances:
+    def get_jettons_balances(
+            self,
+            account_id: str,
+            currencies: Optional[List[str]] = None,
+            supported_extensions: Optional[List[str]] = None,
+    ) -> JettonsBalances:
         """
         Get all Jettons balances by owner address.
 
         :param account_id: account ID
+        :param currencies: accept ton and all possible fiat currencies, separated by commas
+        :param supported_extensions: comma separated list supported extensions
         :return: :class:`JettonsBalances`
         """
         method = f"v2/accounts/{account_id}/jettons"
-        response = self._get(method=method)
+        params = {"supported_extensions": ",".join(supported_extensions)} if supported_extensions else {}
+        if currencies:
+            params["currencies"] = ",".join(currencies)
+        response = self._get(method=method, params=params)
 
         return JettonsBalances(**response)
 
-    def get_jetton_balance(self, account_id: str, jetton_id: str) -> JettonBalance:
+    def get_jetton_balance(
+            self,
+            account_id: str,
+            jetton_id: str,
+            currencies: Optional[List[str]] = None,
+            supported_extensions: Optional[List[str]] = None,
+    ) -> JettonBalance:
         """
         Get Jetton balance by owner address
 
         :param account_id: account ID
         :param jetton_id: jetton ID
+        :param currencies: accept ton and all possible fiat currencies, separated by commas
+        :param supported_extensions: comma separated list supported extensions
         :return: :class:`JettonBalance`
         """
         method = f"v2/accounts/{account_id}/jettons/{jetton_id}"
-        response = self._get(method=method)
+        params = {"supported_extensions": ",".join(supported_extensions)} if supported_extensions else {}
+        if currencies:
+            params["currencies"] = ",".join(currencies)
+        response = self._get(method=method, params=params)
 
         return JettonBalance(**response)
 

pytonapi-0.4.2/pytonapi/tonapi/methods/webhooks.py

@@ -0,0 +1,81 @@
+from typing import List
+
+from pytonapi.schema.webhooks import WebhookCreate, WebhookList, AccountSubscriptions
+from pytonapi.tonapi.client import TonapiClientBase
+
+
+class WebhooksMethod(TonapiClientBase):
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.base_url = "https://rt.tonapi.io/"
+
+    def create_webhook(self, endpoint: str) -> WebhookCreate:
+        """
+        Create a new webhook and return its ID.
+
+        :param endpoint: The webhook endpoint URL to receive transaction events.
+        :return: An object containing the ID of the created webhook.
+        :rtype: WebhookCreate
+        """
+        method = "webhooks"
+        body = {"endpoint": endpoint}
+        response = self._post(method=method, body=body)
+        return WebhookCreate(**response)
+
+    def list_webhooks(self) -> WebhookList:
+        """
+        Retrieve a list of all available webhooks.
+
+        :return: A list containing all webhooks with their IDs and endpoints.
+        :rtype: WebhookList
+        """
+        method = "webhooks"
+        response = self._get(method=method)
+        return WebhookList(**response)
+
+    def delete_webhook(self, webhook_id: int) -> None:
+        """
+        Delete a webhook and all its subscriptions.
+
+        :param webhook_id: The ID of the webhook to delete.
+        """
+        method = f"webhooks/{webhook_id}"
+        self._delete(method=method)
+
+    def subscribe_to_account(self, webhook_id: int, accounts: List[str]) -> None:
+        """
+        Subscribe a webhook to specific account transactions.
+
+        :param webhook_id: The ID of the webhook to subscribe.
+        :param accounts: A list of account IDs to subscribe to.
+        """
+        method = f"webhooks/{webhook_id}/account-tx/subscribe"
+        body = {"accounts": [{"account_id": account} for account in accounts]}
+        self._post(method=method, body=body)
+
+    def unsubscribe_from_account(self, webhook_id: int, accounts: List[str]) -> None:
+        """
+        Unsubscribe a webhook from specific account transactions.
+
+        :param webhook_id: The ID of the webhook to unsubscribe.
+        :param accounts: A list of account IDs to unsubscribe from.
+        """
+        method = f"webhooks/{webhook_id}/account-tx/unsubscribe"
+        body = {"accounts": accounts}
+        self._post(method=method, body=body)
+
+    def get_subscriptions(self, webhook_id: int, offset: int = 0, limit: int = 10) -> AccountSubscriptions:
+        """
+        Retrieve the list of subscriptions for a given webhook.
+
+        :param webhook_id: The ID of the webhook.
+        :param offset: The offset for pagination. Default is 0.
+        :param limit: The maximum number of subscriptions to return. Default is 10.
+        :return: A list of account transaction subscriptions with details.
+        :rtype: AccountSubscriptions
+        """
+        method = f"webhooks/{webhook_id}/account-tx/subscriptions"
+        params = {"offset": offset, "limit": limit}
+        response = self._get(method=method, params=params)
+        return AccountSubscriptions(**response)

{pytonapi-0.4.0 → pytonapi-0.4.2}/pytonapi.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pytonapi
-Version: 0.4.0
+Version: 0.4.2
 Summary: Provide access to indexed TON blockchain.
 Home-page: https://github.com/tonkeeper/pytonapi/
 Author: nessshon

{pytonapi-0.4.0 → pytonapi-0.4.2}/pytonapi.egg-info/SOURCES.txt

@@ -33,6 +33,7 @@ pytonapi/async_tonapi/methods/tonconnect.py
 pytonapi/async_tonapi/methods/traces.py
 pytonapi/async_tonapi/methods/utilites.py
 pytonapi/async_tonapi/methods/wallet.py
+pytonapi/async_tonapi/methods/webhooks.py
 pytonapi/async_tonapi/methods/websocket.py
 pytonapi/schema/__init__.py
 pytonapi/schema/_address.py
@@ -54,6 +55,7 @@ pytonapi/schema/storage.py
 pytonapi/schema/tonconnect.py
 pytonapi/schema/traces.py
 pytonapi/schema/utilites.py
+pytonapi/schema/webhooks.py
 pytonapi/tonapi/__init__.py
 pytonapi/tonapi/client.py
 pytonapi/tonapi/methods/__init__.py
@@ -76,6 +78,7 @@ pytonapi/tonapi/methods/tonconnect.py
 pytonapi/tonapi/methods/traces.py
 pytonapi/tonapi/methods/utilites.py
 pytonapi/tonapi/methods/wallet.py
+pytonapi/tonapi/methods/webhooks.py
 tests/async_tonapi/__init__.py
 tests/async_tonapi/test_accounts_methods.py
 tests/async_tonapi/test_blockchain_methods.py

{pytonapi-0.4.0 → pytonapi-0.4.2}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="pytonapi",
-    version="0.4.0",
+    version="0.4.2",
     author="nessshon",
     description="Provide access to indexed TON blockchain.",
     long_description=long_description,

{pytonapi-0.4.0 → pytonapi-0.4.2}/tests/async_tonapi/__init__.py

@@ -2,7 +2,7 @@ from unittest import IsolatedAsyncioTestCase
 
 from pytonapi import AsyncTonapi
 
-API_KEY = "AE33EX7DNCVC7JAAAAABVSF7O6YWCTGMYMDXSDQYUCV2UUO5AI35QXNTQAWGXEGYPJ2BD5I"
+API_KEY = ""
 
 
 class TestAsyncTonapi(IsolatedAsyncioTestCase):

{pytonapi-0.4.0 → pytonapi-0.4.2}/tests/async_tonapi/test_accounts_methods.py

@@ -9,6 +9,10 @@ JETTON_ID = "EQD0vdSA_NedR9uvbgN9EikRX-suesDxGeFg69XQMavfLqIw"  # noqa
 
 class TestAccountMethod(TestAsyncTonapi):
 
+    async def test_parse_address(self):
+        response = await self.tonapi.accounts.parse_address(ACCOUNT_ID)
+        self.assertIsInstance(response, schema.accounts.AddressForm)
+
     async def test_get_info(self):
         response = await self.tonapi.accounts.get_info(ACCOUNT_ID)
         self.assertIsInstance(response, schema.accounts.Account)

{pytonapi-0.4.0 → pytonapi-0.4.2}/tests/async_tonapi/test_jettons_methods.py

@@ -1,7 +1,7 @@
 from pytonapi import schema
 from tests.async_tonapi import TestAsyncTonapi
 
-ACCOUNT_ID = "0:0336261f4d3e8a3521b5fc38ee30d203de5ec60d8231a4b3f2e42d512bedd7cc"  # noqa
+ACCOUNT_ID = "EQBCFwW8uFUh-amdRmNY9NyeDEaeDYXd9ggJGsicpqVcHq7B"  # noqa
 EVENT_ID = "68656e74d18b10309e41e057191abcfc42f973c82bc84326985cdbf7bf89b126"
 
 

{pytonapi-0.4.0 → pytonapi-0.4.2}/tests/async_tonapi/test_nft_methods.py

@@ -25,8 +25,7 @@ class TestNftMethod(TestAsyncTonapi):
         self.assertIsInstance(response, schema.nft.NftItems)
 
     async def test_get_all_items_by_collection_address(self):
-        response = await self.tonapi.nft.get_all_items_by_collection_address("EQBcjALtmHwSBCSpDOZ1_emrSQVtJU6J0POZR-ThkZjfXkZs")
-        print(len(response.nft_items))
+        response = await self.tonapi.nft.get_all_items_by_collection_address(ACCOUNT_ID_COLLECTION)
         self.assertIsInstance(response, schema.nft.NftItems)
 
     async def test_get_item_by_address(self):

pytonapi-0.4.2/tests/async_tonapi/test_sse_methods.py

@@ -0,0 +1,25 @@
+from pprint import pprint
+
+from tests.async_tonapi import TestAsyncTonapi
+
+ACCOUNT_ID = "EQChB2eMoFG4ThuEsZ6ehlBPKJXOjNxlR5B7qKZNGIv256Da"
+ACCOUNTS_IDS = ["ALL"]
+
+
+async def handler(event) -> None:
+    pprint(event)
+
+
+class TestSSEMethod(TestAsyncTonapi):
+
+    async def test_subscribe_to_transactions(self):
+        await self.tonapi.sse.subscribe_to_transactions(handler, ACCOUNTS_IDS)
+
+    async def test_subscribe_to_traces(self):
+        await self.tonapi.sse.subscribe_to_traces(handler, ACCOUNTS_IDS)
+
+    async def test_subscribe_to_mempool(self):
+        await self.tonapi.sse.subscribe_to_mempool(handler, [ACCOUNT_ID])
+
+    async def test_subscribe_to_blocks(self):
+        await self.tonapi.sse.subscribe_to_blocks(handler)

pytonapi-0.4.2/tests/async_tonapi/test_websocket_methods.py

@@ -0,0 +1,22 @@
+from pprint import pprint
+
+from tests.async_tonapi import TestAsyncTonapi
+
+ACCOUNT_ID = "Ef8zMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzM0vF"
+ACCOUNTS_IDS = ["UQCFJEP4WZ_mpdo0_kMEmsTgvrMHG7K_tWY16pQhKHwoOtFz"]
+
+
+async def handler(event) -> None:
+    pprint(event)
+
+
+class TestSSEMethod(TestAsyncTonapi):
+
+    async def test_subscribe_to_transactions(self):
+        await self.tonapi.websocket.subscribe_to_transactions(handler, ACCOUNTS_IDS)
+
+    async def test_subscribe_to_traces(self):
+        await self.tonapi.websocket.subscribe_to_traces(handler, ACCOUNTS_IDS)
+
+    async def test_subscribe_to_mempool(self):
+        await self.tonapi.websocket.subscribe_to_mempool(handler, [ACCOUNT_ID])

{pytonapi-0.4.0 → pytonapi-0.4.2}/tests/tonapi/__init__.py

@@ -2,7 +2,7 @@ from unittest import TestCase
 
 from pytonapi import Tonapi
 
-API_KEY = "AE33EX7DNCVC7JAAAAABVSF7O6YWCTGMYMDXSDQYUCV2UUO5AI35QXNTQAWGXEGYPJ2BD5I"
+API_KEY = ""
 
 
 class TestTonapi(TestCase):

{pytonapi-0.4.0 → pytonapi-0.4.2}/tests/tonapi/test_accounts_methods.py

@@ -25,6 +25,10 @@ class TestAccountMethod(TestTonapi):
         response = self.tonapi.accounts.get_jettons_balances(ACCOUNT_ID)
         self.assertIsInstance(response, schema.jettons.JettonsBalances)
 
+    def test_get_jettons_with_currencies(self):
+        response = self.tonapi.accounts.get_jettons_balances(ACCOUNT_ID, currencies=["ton"])
+        self.assertIsInstance(response, schema.jettons.JettonsBalances)
+
     def test_get_jetton(self):
         response = self.tonapi.accounts.get_jetton_balance(ACCOUNT_ID, JETTON_ID)
         self.assertIsInstance(response, schema.jettons.JettonBalance)

pytonapi-0.4.0/tests/async_tonapi/test_sse_methods.py

@@ -1,25 +0,0 @@
-from pprint import pprint
-
-from tests.async_tonapi import TestAsyncTonapi
-
-ACCOUNT_ID = "EQChB2eMoFG4ThuEsZ6ehlBPKJXOjNxlR5B7qKZNGIv256Da"
-ACCOUNTS_IDS = ["ALL"]
-
-
-async def handler(event) -> None:
-    pprint(event)
-
-
-class TestSSEMethod(TestAsyncTonapi):
-    pass
-    # async def test_subscribe_to_transactions(self):
-    #     await self.tonapi.sse.subscribe_to_transactions(handler, ACCOUNTS_IDS)
-    #
-    # async def test_subscribe_to_traces(self):
-    #     await self.tonapi.sse.subscribe_to_traces(handler, ACCOUNTS_IDS)
-    #
-    # async def test_subscribe_to_mempool(self):
-    #     await self.tonapi.sse.subscribe_to_mempool(handler, [ACCOUNT_ID])
-    #
-    # async def test_subscribe_to_blocks(self):
-    #     await self.tonapi.sse.subscribe_to_blocks(handler)

pytonapi-0.4.0/tests/async_tonapi/test_websocket_methods.py

@@ -1,22 +0,0 @@
-from pprint import pprint
-
-from tests.async_tonapi import TestAsyncTonapi
-
-ACCOUNT_ID = "Ef8zMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzM0vF"
-ACCOUNTS_IDS = ["UQCFJEP4WZ_mpdo0_kMEmsTgvrMHG7K_tWY16pQhKHwoOtFz"]
-
-
-async def handler(event) -> None:
-    pprint(event)
-
-
-class TestSSEMethod(TestAsyncTonapi):
-    pass
-    # async def test_subscribe_to_transactions(self):
-    #     await self.tonapi.websocket.subscribe_to_transactions(handler, ACCOUNTS_IDS)
-    #
-    # async def test_subscribe_to_traces(self):
-    #     await self.tonapi.websocket.subscribe_to_traces(handler, ACCOUNTS_IDS)
-    #
-    # async def test_subscribe_to_mempool(self):
-    #     await self.tonapi.websocket.subscribe_to_mempool(handler, [ACCOUNT_ID])