add nanorpc as library, include requests dependency

.gitignore

@@ -14,3 +14,6 @@ venv_py/
 **/._.DS_Store
 debug
 unit_tests/testcases
+snippets/
+testcases/
+nl_config.toml

nanolab/publisher/block_asserts.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from nanolab.src.nano_rpc import NanoRpcV2
+from nanorpc.client import NanoRpcTyped
 from nanolab.publisher.block_event import BlockConfirmationEvent
 from nanolab.src.utils import get_config_parser
 import asyncio
@@ -44,8 +44,9 @@ def __init__(self, event_bus=None, node_name=None):
         self.event_bus = event_bus
         conf_p = get_config_parser()
         node_name = node_name if node_name else conf_p.get_nodes_name()[:-1]
-        self.nano_rpc_default = NanoRpcV2(conf_p.get_node_rpc(node_name))
-        self.nano_rpc_all = [NanoRpcV2(url) for url in conf_p.get_nodes_rpc()]
+        self.nano_rpc_default = NanoRpcTyped(conf_p.get_node_rpc(node_name))
+        self.nano_rpc_all = [NanoRpcTyped(url)
+                             for url in conf_p.get_nodes_rpc()]
 
     async def _fetch_block_info(self, block_hash):
         return await self.nano_rpc_default.block_info(block_hash,
@@ -101,7 +102,8 @@ async def assert_blocks_confirmed(self, block_hashes):
 
     async def _publish_block_confirmation_event(self, wait_s, block_hash,
                                                 timeout):
-        if not self.event_bus: return
+        if not self.event_bus:
+            return
         event = BlockConfirmationEvent(block_hash, timeout, wait_s)
         await self.event_bus.publish('block_confirmed', event)
 
@@ -135,4 +137,4 @@ async def assert_single_block_confirmed(self, block_hash: str):
 
     async def assert_single_block_confirmed_wait(self, block_hash, wait_s,
                                                  interval):
-        await self.assert_blocks_confirmed_wait([block_hash], wait_s, interval)
+        await self.assert_blocks_confirmed_wait([block_hash], wait_s, interval)

nanolab/publisher/block_generator.py

@@ -1,4 +1,3 @@
-#from nanolab.src.nano_rpc_v2 import NanoRpcV2
 from nanomock.modules.nl_rpc import NanoRpc, NanoLibTools
 from nanolab.src.utils import get_config_parser
 from abc import ABC, abstractmethod
@@ -67,7 +66,7 @@ def set_broadcast_blocks(self, broadcast):
     def create_send_and_open_block(self, send_amount_raw, source_seed,
                                    source_index, destination_seed,
                                    destination_index, representative):
-        #destination = self.nano_rpc_default.generate_account(destination_seed, destination_index)
+        # destination = self.nano_rpc_default.generate_account(destination_seed, destination_index)
         return self.blockgen_single_account_opener(
             representative=representative,
             source_seed=source_seed,
@@ -121,4 +120,4 @@ def blockgen_single_account_opener(
         open_block["account_data"]["source_index"] = destination_index
 
         res = [send_block, open_block]
-        return res
+        return res

nanolab/publisher/confirmation_stats.py

@@ -1,4 +1,4 @@
-from nanolab.src.nano_rpc import NanoRpcV2
+from nanorpc.client import NanoRpcTyped
 from nanolab.src.utils import get_config_parser
 from time import strftime, gmtime, time
 from math import ceil
@@ -12,16 +12,16 @@ def __init__(self, block_timeout_s):
         self.formatter = ConfirmationTableFormatter()
 
     async def initialize(self, node_name):
-        self.rpc_v2 = NanoRpcV2(get_config_parser().get_node_rpc(node_name))
-        self.rpc_v2.create_session()
-        start_block_count = await self.rpc_v2.block_count()
+        self.nanorpc = NanoRpcTyped(
+            get_config_parser().get_node_rpc(node_name))
+        start_block_count = await self.nanorpc.block_count()
         self.calculator.set_start_block_count(start_block_count)
 
     def set_end_block_count(self, end_block_count: dict) -> None:
         self.calculator.set_end_block_count(end_block_count)
 
     async def print_stats(self) -> None:
-        end_block_count = await self.rpc_v2.block_count()
+        end_block_count = await self.nanorpc.block_count()
         self.calculator.set_end_block_count(end_block_count)
         stats = self.calculator.compute_stats()
         self.printer.print_stats(stats, self.formatter)

nanolab/publisher/test_case.py

@@ -1,5 +1,4 @@
 from abc import ABC, abstractmethod
-from nanolab.src.nano_rpc import NanoRpcV2
 from nanolab.publisher.block_asserts import BlockAsserts
 from nanolab.publisher.block_generator import BlockGenerator
 from nanolab.publisher.confirmation_stats import ConfirmationStatsManager