py-near 1.1.38__py3-none-any.whl → 1.1.40__py3-none-any.whl

py_near/account.py

@@ -93,6 +93,13 @@ class Account(object):
         self._lock_by_pk = collections.defaultdict(asyncio.Lock)
         self.chain_id = (await self._provider.get_status())["chain_id"]
 
+    async def shutdown(self):
+        """
+        Close async object
+        :return:
+        """
+        await self._provider.shutdown()
+
     async def _update_last_block_hash(self):
         """
         Update last block hash& If it's older than 50 block before, transaction will fail
@@ -406,7 +413,11 @@ class Account(object):
         :return: result of view function call
         """
         result = await self._provider.view_call(
-            contract_id, method_name, json.dumps(args).encode("utf8"), block_id=block_id, threshold=threshold
+            contract_id,
+            method_name,
+            json.dumps(args).encode("utf8"),
+            block_id=block_id,
+            threshold=threshold,
         )
         if "error" in result:
             raise ViewFunctionError(result["error"])

py_near/providers.py

@@ -1,5 +1,6 @@
 import asyncio
 import base64
+import datetime
 import json
 from collections import Counter
 from typing import Optional
@@ -7,8 +8,7 @@ from typing import Optional
 import aiohttp
 from aiohttp import ClientResponseError, ClientConnectorError, ServerDisconnectedError
 from loguru import logger
-import datetime
-from py_near import constants
+
 from py_near.constants import TIMEOUT_WAIT_RPC
 from py_near.exceptions.exceptions import RpcNotAvailableError, RpcEmptyResponse
 from py_near.exceptions.provider import (
@@ -46,7 +46,7 @@ PROVIDER_CODE_TO_EXCEPTION = {
 
 
 class JsonProvider(object):
-    def __init__(self, rpc_addr, allow_broadcast=True):
+    def __init__(self, rpc_addr, allow_broadcast=True, timeout=TIMEOUT_WAIT_RPC):
         """
         :param rpc_addr: str or list of str
         :param allow_broadcast: bool - submit signed transaction to all RPCs
@@ -60,6 +60,11 @@ class JsonProvider(object):
         self._available_rpcs = self._rpc_addresses.copy()
         self._last_rpc_addr_check = 0
         self.allow_broadcast = allow_broadcast
+        self._timeout = timeout
+        self.session = aiohttp.ClientSession()
+
+    async def shutdown(self):
+        await self.session.close()
 
     async def check_available_rpcs(self):
         if (
@@ -88,115 +93,100 @@ class JsonProvider(object):
                     "params": {"finality": "final"},
                     "id": 1,
                 }
-                async with aiohttp.ClientSession() as session:
-                    async with session.post(rpc_addr, json=data) as r:
-                        if r.status == 200:
-                            data = json.loads(await r.text())["result"]
-                            if data["sync_info"]["syncing"]:
-                                last_block_ts = datetime.datetime.fromisoformat(
-                                    data["sync_info"]["latest_block_time"]
-                                )
-                                diff = (
-                                    datetime.datetime.utcnow().timestamp()
-                                    - last_block_ts.timestamp()
-                                )
-                                is_syncing = diff > 60
-                            else:
-                                is_syncing = False
-                            if is_syncing:
-                                logger.error(f"Remove async RPC : {rpc_addr} ({diff})")
-                                continue
-                            available_rpcs.append(rpc_addr)
-                        else:
-                            logger.error(
-                                f"Remove rpc because of error {r.status}: {rpc_addr}"
+                async with self.session.post(rpc_addr, json=data) as r:
+                    if r.status == 200:
+                        data = json.loads(await r.text())["result"]
+                        if data["sync_info"]["syncing"]:
+                            last_block_ts = datetime.datetime.fromisoformat(
+                                data["sync_info"]["latest_block_time"]
                             )
+                            diff = (
+                                datetime.datetime.utcnow().timestamp()
+                                - last_block_ts.timestamp()
+                            )
+                            is_syncing = diff > 60
+                        else:
+                            is_syncing = False
+                        if is_syncing:
+                            logger.error(f"Remove async RPC : {rpc_addr} ({diff})")
+                            continue
+                        available_rpcs.append(rpc_addr)
+                    else:
+                        logger.error(
+                            f"Remove rpc because of error {r.status}: {rpc_addr}"
+                        )
             except Exception as e:
                 if rpc_addr in self._available_rpcs:
                     logger.error(f"Remove rpc: {e}")
         self._available_rpcs = available_rpcs
 
+    @staticmethod
+    def most_frequent_by_hash(array):
+        counter = Counter(array)
+        most_frequent = counter.most_common(1)[0][0]
+        return most_frequent
+
     async def call_rpc_request(
-        self, method, params, timeout=TIMEOUT_WAIT_RPC, broadcast=False, threshold=None
+        self, method, params, broadcast=False, threshold: int = 0
     ):
         await self.check_available_rpcs()
         j = {"method": method, "params": params, "id": "dontcare", "jsonrpc": "2.0"}
-        res = {}
-        if broadcast or threshold:
 
-            async def f(rpc_call_addr):
-                async with aiohttp.ClientSession() as session:
-                    r = await session.post(
-                        rpc_call_addr,
-                        json=j,
-                        timeout=timeout,
-                        headers={
-                            "Referer": "https://tgapp.herewallet.app"
-                        },  # NEAR RPC requires Referer header
-                    )
-                    if r.status == 200:
-                        return json.loads(await r.text())
+        async def f(rpc_call_addr):
+            auth_key = "py-near"
+            if "@" in rpc_call_addr:
+                auth_key = rpc_call_addr.split("//")[1].split("@")[0]
+                rpc_call_addr = rpc_call_addr.replace(auth_key + "@", "")
+            r = await self.session.post(
+                rpc_call_addr,
+                json=j,
+                timeout=self._timeout,
+                headers={
+                    "Referer": "https://tgapp.herewallet.app",
+                    "Authorization": f"Bearer {auth_key}",
+                },  # NEAR RPC requires Referer header
+            )
+            if r.status == 200:
+                return json.loads(await r.text())
 
-            tasks = [
+        if broadcast or threshold:
+            pending = [
                 asyncio.create_task(f(rpc_addr)) for rpc_addr in self._available_rpcs
             ]
+
             responses = []
-            for t in tasks:
+            while len(pending):
+                done, pending = await asyncio.wait(
+                    pending, return_when=asyncio.FIRST_COMPLETED
+                )
+                for task in done:
+                    try:
+                        result = task.result()
+                        if "error" not in result and threshold <= 1:
+                            return result
+                        responses.append(result)
+                    except Exception as e:
+                        logger.warning(e)
+                if responses:
+                    array = [hash(json.dumps(x)) for x in responses]
+                    most_frequent_element = self.most_frequent_by_hash(array)
+                    correct_responses = [
+                        x for x in responses if hash(json.dumps(x)) == most_frequent_element
+                    ]
+                    if len(correct_responses) >= threshold:
+                        for task in pending:
+                            task.cancel()
+                        return most_frequent_element
+        else:
+            for rpc_addr in self._available_rpcs:
                 try:
-                    responses.append(await t)
+                    res = await f(rpc_addr)
+                    if "error" not in res:
+                        return res
                 except Exception as e:
                     logger.error(f"Rpc error: {e}")
                     continue
-
-            def most_frequent_by_hash(array):
-                counter = Counter(array)
-                most_frequent = counter.most_common(1)[0][0]
-                return most_frequent
-
-            if threshold:
-                # return first most frequent response
-                array = [hash(json.dumps(x)) for x in responses]
-                most_frequent_element = most_frequent_by_hash(array)
-                correct_responses = [
-                    x for x in responses if hash(json.dumps(x)) == most_frequent_element
-                ]
-                if len(correct_responses) >= threshold:
-                    return responses[0]
-                raise Exception(
-                    f"Threshold not reached: {len(correct_responses)}/{threshold}"
-                )
-
-            if broadcast:
-                # return first response without errors
-                for res in responses:
-                    if "error" not in res:
-                        return res
-            return responses[0]
-
-        for rpc_addr in self._available_rpcs:
-            try:
-                async with aiohttp.ClientSession() as session:
-                    r = await session.post(
-                        rpc_addr,
-                        json=j,
-                        timeout=timeout,
-                        headers={
-                            "Referer": "https://tgapp.herewallet.app/"
-                        },  # NEAR RPC requires Referer header
-                    )
-                    r.raise_for_status()
-                    res = json.loads(await r.text())
-                    return res
-            except (
-                RPCTimeoutError,
-                ClientResponseError,
-                ClientConnectorError,
-                ServerDisconnectedError,
-                ConnectionError,
-            ) as e:
-                logger.error(f"Rpc error: {e}")
-                continue
-        return res
+        raise RpcEmptyResponse("RPC returned empty response")
 
     @staticmethod
     def get_error_from_response(content: dict):
@@ -220,11 +210,9 @@ class JsonProvider(object):
                     break
             return error
 
-    async def json_rpc(
-        self, method, params, timeout=TIMEOUT_WAIT_RPC, broadcast=False, threshold=None
-    ):
+    async def json_rpc(self, method, params, broadcast=False, threshold=None):
         content = await self.call_rpc_request(
-            method, params, timeout, broadcast=broadcast, threshold=threshold
+            method, params, broadcast=broadcast, threshold=threshold
         )
         if not content:
             raise RpcEmptyResponse("RPC returned empty response")
@@ -234,7 +222,7 @@ class JsonProvider(object):
             raise error
         return content["result"]
 
-    async def send_tx(self, signed_tx: str, timeout: int = constants.TIMEOUT_WAIT_RPC):
+    async def send_tx(self, signed_tx: str):
         """
         Send a signed transaction to the network and return the hash of the transaction
         :param signed_tx: base64 encoded signed transaction, str.
@@ -244,13 +232,10 @@ class JsonProvider(object):
         return await self.json_rpc(
             "broadcast_tx_async",
             [signed_tx],
-            timeout=timeout,
             broadcast=self.allow_broadcast,
         )
 
-    async def send_tx_included(
-        self, signed_tx: str, timeout: int = constants.TIMEOUT_WAIT_RPC
-    ):
+    async def send_tx_included(self, signed_tx: str):
         """
         Send a signed transaction to the network and return the hash of the transaction
         :param signed_tx: base64 encoded signed transaction, str.
@@ -261,7 +246,6 @@ class JsonProvider(object):
             return await self.json_rpc(
                 "send_tx",
                 {"signed_tx_base64": signed_tx, "wait_until": "INCLUDED"},
-                timeout=timeout,
                 broadcast=self.allow_broadcast,
             )
         except InvalidNonce:
@@ -285,7 +269,6 @@ class JsonProvider(object):
     async def send_tx_and_wait(
         self,
         signed_tx: str,
-        timeout: int = constants.TIMEOUT_WAIT_RPC,
         trx_hash: Optional[str] = None,
         receiver_id: Optional[str] = None,
     ) -> TransactionResult:
@@ -299,7 +282,6 @@ class JsonProvider(object):
             res = await self.json_rpc(
                 "broadcast_tx_commit",
                 [signed_tx],
-                timeout=timeout,
                 broadcast=self.allow_broadcast,
             )
             return TransactionResult(**res)

{py_near-1.1.38.dist-info → py_near-1.1.40.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: py-near
-Version: 1.1.38
+Version: 1.1.40
 Summary: Pretty simple and fully asynchronous framework for working with NEAR blockchain
 Author: pvolnov
 Author-email: petr@herewallet.app

{py_near-1.1.38.dist-info → py_near-1.1.40.dist-info}/RECORD

@@ -1,5 +1,5 @@
 py_near/__init__.py,sha256=t5fAxjaU8dN8xpQR2vz0ZGhfTkdVy2RCbkhJhZFglk4,50
-py_near/account.py,sha256=CX0fYvWJj8g7QANLUr3G5eUvO347UW1jlunphN47Heg,17617
+py_near/account.py,sha256=hz-LZpGvy1cE0_iHX4_TGpOpJ5gfe0P9EAJ_0b-S8E0,17805
 py_near/constants.py,sha256=inaWIuwmF1EB5JSB0ynnZY5rKY_QsxhF9KuCOhPsM6k,164
 py_near/dapps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 py_near/dapps/core.py,sha256=LtN9aW2gw2mvEdhzQcQJIidtjv-XL1xjb0LK8DzqtqE,231
@@ -20,10 +20,10 @@ py_near/exceptions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuF
 py_near/exceptions/exceptions.py,sha256=DEFipaAHm0y7oCuN2QKzHsiQvUTUQVl-Ce36Ag7n7hs,5509
 py_near/exceptions/provider.py,sha256=K-wexgjPJ8sw42JePwaP7R5dJEIn9DoFJRvVcURsx6s,7718
 py_near/models.py,sha256=GZQD1TKGWlwqsJsKRXrVNBjCdAIpk7GQypU-QOtAPFs,11533
-py_near/providers.py,sha256=A_h587h5e-HXJeko7z2YdDw0SkC3snNJ8hk90POOge8,16190
+py_near/providers.py,sha256=0nv1pnWo0FZ6ZonUbhxVCmnq_gG8vBMiIQ3qhz6toBs,15477
 py_near/transactions.py,sha256=QAXegv2JpKISk92NaChtIH6-QPHrcWbrwdKH_lH4TsU,3186
 py_near/utils.py,sha256=FirRH93ydH1cwjn0-sNrZeIn3BRD6QHedrP2VkAdJ6g,126
-py_near-1.1.38.dist-info/LICENSE,sha256=I_GOA9xJ35FiL-KnYXZJdATkbO2KcV2dK2enRGVxzKM,1023
-py_near-1.1.38.dist-info/METADATA,sha256=YD1v8lUXSE_IgAcDNcwkEPbY16lL12k3Ri_YORwqmO0,4713
-py_near-1.1.38.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-py_near-1.1.38.dist-info/RECORD,,
+py_near-1.1.40.dist-info/LICENSE,sha256=I_GOA9xJ35FiL-KnYXZJdATkbO2KcV2dK2enRGVxzKM,1023
+py_near-1.1.40.dist-info/METADATA,sha256=MLUGiQjTbaNFCyV5qL_IGnHFwBpDlHeJe04WmY37DU4,4713
+py_near-1.1.40.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+py_near-1.1.40.dist-info/RECORD,,