diff --git a/duniterpy/api/bma/api.py b/duniterpy/api/bma/api.py
index fdedfb9f95e6a4ef9ecd685e3bbd8cdd63fe0334..808b0f1d37cf1cd36ba437d6440c0d49e4b82b8e 100644
--- a/duniterpy/api/bma/api.py
+++ b/duniterpy/api/bma/api.py
@@ -19,7 +19,7 @@
import aiohttp, json, logging, jsonschema
-
+import warnings
from ..errors import DuniterError
logger = logging.getLogger("duniter")
@@ -28,15 +28,20 @@ logger = logging.getLogger("duniter")
class ConnectionHandler(object):
"""Helper class used by other API classes to ease passing server connection information."""
- def __init__(self, server, port):
- """
- Arguments:
- - `server`: server hostname
- - `port`: port number
+ def __init__(self, server, port, session=None):
"""
+ Init instance of connection handler
+ :param str server: Server IP or domaine name
+ :param int port: Port
+ :param aiohttp.ClientSession|None session: Session AIOHTTP
+ """
self.server = server
self.port = port
+ if session is None:
+ self.session = aiohttp.ClientSession()
+ else:
+ self.session = session
def __str__(self):
return 'connection info: %s:%d' % (self.server, self.port)
@@ -45,6 +50,7 @@ class ConnectionHandler(object):
class API(object):
"""APIRequest is a class used as an interface. The intermediate derivated classes are the modules and the leaf classes are the API requests."""
+ schema = {}
error_schema = {
"type": "object",
"properties": {
@@ -62,21 +68,20 @@ class API(object):
"""
Asks a module in order to create the url used then by derivated classes.
- Arguments:
- - `module`: module name
- - `connection_handler`: connection handler
+ :param ConnectionHandler connection_handler: Connection handler
+ :param str module: Module path
"""
-
self.module = module
self.connection_handler = connection_handler
self.headers = {}
def reverse_url(self, scheme, path):
"""
- Reverses the url using self.url and path given in parameter.
+ Reverses the url using scheme and path given in parameter.
- Arguments:
- - `path`: the request path
+ :param str scheme: Scheme of the url
+ :param str path: Path of the url
+ :return: str
"""
server, port = self.connection_handler.server, self.connection_handler.port
@@ -87,30 +92,6 @@ class API(object):
module=self.module)
return url + path
- def get(self, session, **kwargs):
- """wrapper of overloaded __get__ method."""
-
- return self.__get__(session, **kwargs)
-
- def post(self, session, **kwargs):
- """wrapper of overloaded __post__ method."""
-
- logger.debug('do some work with')
-
- data = self.__post__(session, **kwargs)
-
- logger.debug('and send back')
-
- return data
-
- async def __get__(self, session, **kwargs):
- """interface purpose for GET request"""
- pass
-
- async def __post__(self, session, **kwargs):
- """interface purpose for POST request"""
- pass
-
def parse_text(self, text):
"""
Validate and parse the BMA answer from websocket
@@ -139,30 +120,31 @@ class API(object):
except (TypeError, json.decoder.JSONDecodeError):
raise jsonschema.ValidationError("Could not parse json")
- async def parse_response(self, response):
+ async def parse_response(self, response, schema=None):
"""
Validate and parse the BMA answer
- :param response:
+ :param aiohttp.ClientResponse response: Response of aiohttp request
+ :param dict schema: The expected response structure
:return: the json data
"""
try:
data = await response.json()
- jsonschema.validate(data, self.schema)
+ if schema is not None:
+ jsonschema.validate(data, schema)
return data
except (TypeError, json.decoder.JSONDecodeError):
raise jsonschema.ValidationError("Could not parse json")
- async def requests_get(self, session, path, **kwargs):
+ async def requests_get(self, path, **kwargs):
"""
Requests GET wrapper in order to use API parameters.
- :params aiohttp.ClientSession session: the client session
:params str path: the request path
"""
logging.debug("Request : {0}".format(self.reverse_url("http", path)))
with aiohttp.Timeout(15):
- response = await session.get(self.reverse_url("http", path), params=kwargs,headers=self.headers)
+ response = await self.connection_handler.session.get(self.reverse_url("http", path), params=kwargs,headers=self.headers)
if response.status != 200:
try:
error_data = self.parse_error(await response.text())
@@ -172,11 +154,10 @@ class API(object):
return response
- async def requests_post(self, session, path, **kwargs):
+ async def requests_post(self, path, **kwargs):
"""
Requests POST wrapper in order to use API parameters.
- :param aiohttp.ClientSession session: the request session
:param str path: the request path
"""
if 'self_' in kwargs:
@@ -184,7 +165,11 @@ class API(object):
logging.debug("POST : {0}".format(kwargs))
with aiohttp.Timeout(15):
- response = await session.post(self.reverse_url("http", path), data=kwargs, headers=self.headers)
+ response = await self.connection_handler.session.post(
+ self.reverse_url("http", path),
+ data=kwargs,
+ headers=self.headers
+ )
return response
def connect_ws(self, session, path):
diff --git a/duniterpy/api/bma/blockchain.py b/duniterpy/api/bma/blockchain.py
index f40a06f478be1243ccd5ade92158b34c3da749a6..b0f1c2423a873f6a82d81b470df285abf5d5bc5a 100644
--- a/duniterpy/api/bma/blockchain.py
+++ b/duniterpy/api/bma/blockchain.py
@@ -20,14 +20,166 @@ from duniterpy.api.bma import API, logging
logger = logging.getLogger("duniter/blockchain")
+URL_PATH = 'blockchain'
-class Blockchain(API):
- def __init__(self, connection_handler, module='blockchain'):
- super(Blockchain, self).__init__(connection_handler, module)
-
-
-class Parameters(Blockchain):
- """GET the blockchain parameters used by this node."""
+BLOCK_SCHEMA = {
+ "type": "object",
+ "properties": {
+ "version": {
+ "type": "number"
+ },
+ "currency": {
+ "type": "string"
+ },
+ "nonce": {
+ "type": "number"
+ },
+ "number": {
+ "type": "number"
+ },
+ "time": {
+ "type": "number"
+ },
+ "medianTime": {
+ "type": "number"
+ },
+ "dividend": {
+ "type": ["number", "null"]
+ },
+ "monetaryMass": {
+ "type": ["number", "null"]
+ },
+ "issuer": {
+ "type": "string"
+ },
+ "previousHash": {
+ "type": ["string", "null"]
+ },
+ "previousIssuer": {
+ "type": ["string", "null"]
+ },
+ "membersCount": {
+ "type": "number"
+ },
+ "hash": {
+ "type": "string"
+ },
+ "inner_hash": {
+ "type": "string"
+ },
+ "identities": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ }
+ },
+ "joiners": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ }
+ },
+ "leavers": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ }
+ },
+ "revoked": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ }
+ },
+ "excluded": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ }
+ },
+ "certifications": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ }
+ },
+ "transactions": {
+ "type": "array",
+ "items": {
+ "type": "object",
+ "properties": {
+ "signatures": {
+ "type": "array"
+ },
+ "version": {
+ "type": "number"
+ },
+ "currency": {
+ "type": "string"
+ },
+ "issuers": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ }
+ },
+ "inputs": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ }
+ },
+ "unlocks": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ }
+ },
+ "outputs": {
+ "type": "array",
+ "item": {
+ "type": "string"
+ }
+ }
+ },
+ "required": ["signatures", "version", "currency", "issuers", "inputs", "outputs"]
+ }
+ },
+ "signature": {
+ "type": "string"
+ },
+ },
+ "required": ["version", "currency", "nonce", "number", "time", "medianTime", "dividend", "monetaryMass",
+ "issuer", "previousHash", "previousIssuer", "membersCount", "hash", "inner_hash", "identities",
+ "joiners", "leavers", "excluded", "certifications", "transactions", "signature"]
+}
+
+BLOCK_NUMBERS_SCHEMA = {
+ "type": "object",
+ "properties": {
+ "result": {
+ "type": "object",
+ "properties": {
+ "blocks": {
+ "type": "array",
+ "items": {
+ "type": "number"
+ }
+ },
+ },
+ "required": ["blocks"]
+ }
+ },
+ "required": ["result"]
+}
+
+async def parameters(connection):
+ """
+ GET the blockchain parameters used by this node
+
+ :param API.ConnectionHandler connection: Connection handler instance
+ :return: dict
+ """
schema = {
"type": "object",
"properties":
@@ -89,13 +241,17 @@ class Parameters(Blockchain):
"avgGenTime", "dtDiffEval", "blocksRot", "percentRot"]
}
- async def __get__(self, session, **kwargs):
- r = await self.requests_get(session, '/parameters', **kwargs)
- return (await self.parse_response(r))
+ client = API(connection, URL_PATH)
+ r = await client.requests_get('/parameters')
+ return await client.parse_response(r, schema)
+async def membership(connection, **kwargs):
+ """
+ GET/POST a Membership document
-class Membership(Blockchain):
- """GET/POST a Membership document."""
+ :param API.ConnectionHandler connection: Connection handler instance
+ :return: dict
+ """
schema = {
"type": "object",
"properties":
@@ -137,223 +293,78 @@ class Membership(Blockchain):
"required": ["pubkey", "uid", "sigDate", "memberships"]
}
- def __init__(self, connection_handler, search=None):
- super().__init__(connection_handler)
- self.search = search
-
- async def __post__(self, session, **kwargs):
- assert 'membership' in kwargs
-
- r = await self.requests_post(session, '/membership', **kwargs)
+ client = API(connection, URL_PATH)
+ if 'membership' in kwargs:
+ r = await client.requests_post('/membership')
+ else:
+ r = await client.requests_get('/memberships/%s' % kwargs[0])
+
+ return await client.parse_response(r, schema)
+
+async def block(connection, number=0, block=None, signature=None):
+ """
+ GET/POST a block from/to the blockchain
+
+ :param API.ConnectionHandler connection: Connection handler instance
+ :param int number: Block number to get
+ :param dict block: Block document to post
+ :param str signature: Signature of the block document issuer
+ :return: dict
+ """
+
+ client = API(connection, URL_PATH)
+ # POST block
+ if block is not None and signature is not None:
+ r = await client.requests_post('/block', block=block, signature=signature)
return r
- async def __get__(self, session, **kwargs):
- assert self.search is not None
- r = await self.requests_get(session, '/memberships/%s' % self.search, **kwargs)
- return (await self.parse_response(r))
+ # GET block
+ r = await client.requests_get('/block/%d' % number)
+ return await client.parse_response(r, BLOCK_SCHEMA)
+async def current(connection):
+ """
+ GET, return last accepted block
-class Block(Blockchain):
- """GET/POST a block from/to the blockchain."""
-
- schema = {
- "type": "object",
- "properties": {
- "version": {
- "type": "number"
- },
- "currency": {
- "type": "string"
- },
- "nonce": {
- "type": "number"
- },
- "number": {
- "type": "number"
- },
- "time": {
- "type": "number"
- },
- "medianTime": {
- "type": "number"
- },
- "dividend": {
- "type": ["number", "null"]
- },
- "monetaryMass": {
- "type": ["number", "null"]
- },
- "issuer": {
- "type": "string"
- },
- "previousHash": {
- "type": ["string", "null"]
- },
- "previousIssuer": {
- "type": ["string", "null"]
- },
- "membersCount": {
- "type": "number"
- },
- "hash": {
- "type": "string"
- },
- "inner_hash": {
- "type": "string"
- },
- "identities": {
- "type": "array",
- "items": {
- "type": "string"
- }
- },
- "joiners": {
- "type": "array",
- "items": {
- "type": "string"
- }
- },
- "leavers": {
- "type": "array",
- "items": {
- "type": "string"
- }
- },
- "revoked": {
- "type": "array",
- "items": {
- "type": "string"
- }
- },
- "excluded": {
- "type": "array",
- "items": {
- "type": "string"
- }
- },
- "certifications": {
- "type": "array",
- "items": {
- "type": "string"
- }
- },
- "transactions": {
- "type": "array",
- "items": {
- "type": "object",
- "properties": {
- "signatures": {
- "type": "array"
- },
- "version": {
- "type": "number"
- },
- "currency": {
- "type": "string"
- },
- "issuers": {
- "type": "array",
- "items": {
- "type": "string"
- }
- },
- "inputs": {
- "type": "array",
- "items": {
- "type": "string"
- }
- },
- "unlocks": {
- "type": "array",
- "items": {
- "type": "string"
- }
- },
- "outputs": {
- "type": "array",
- "item": {
- "type": "string"
- }
- }
- },
- "required": ["signatures", "version", "currency", "issuers", "inputs", "outputs"]
- }
- },
- "signature": {
- "type": "string"
- },
- },
- "required": ["version", "currency", "nonce", "number", "time", "medianTime", "dividend", "monetaryMass",
- "issuer", "previousHash", "previousIssuer", "membersCount", "hash", "inner_hash", "identities",
- "joiners", "leavers", "excluded", "certifications", "transactions", "signature"]
- }
-
- def __init__(self, connection_handler, number=None):
- """
- Use the number parameter in order to select a block number.
-
- Arguments:
- - `number`: block number to select
- """
-
- super(Block, self).__init__(connection_handler)
-
- self.number = number
-
- async def __get__(self, session, **kwargs):
- assert self.number is not None
- r = await self.requests_get(session, '/block/%d' % self.number, **kwargs)
- return (await self.parse_response(r))
-
- async def __post__(self, session, **kwargs):
- assert 'block' in kwargs
- assert 'signature' in kwargs
-
- r = await self.requests_post(session, '/block', **kwargs)
- return r
+ :param API.ConnectionHandler connection: Connection handler instance
+ :return: dict
+ """
+ client = API(connection, URL_PATH)
-class Current(Blockchain):
- """GET, same as block/[number], but return last accepted block."""
+ r = await client.requests_get('/current')
+ return await client.parse_response(r, BLOCK_SCHEMA)
- schema = Block.schema
- async def __get__(self, session, **kwargs):
- r = await self.requests_get(session, '/current', **kwargs)
- return (await self.parse_response(r))
+async def blocks(connection, count, start):
+ """
+ GET list of blocks from the blockchain
-
-
-class Blocks(Blockchain):
- """GET list of blocks from the blockchain."""
+ :param API.ConnectionHandler connection: Connection handler instance
+ :param int count: Number of blocks
+ :param int start: First block number
+ :return: list
+ """
schema = {
"type": "array",
- "items": Block.schema
+ "items": BLOCK_SCHEMA
}
- def __init__(self, connection_handler, count=None, from_=None):
- """
- Use the number parameter in order to select a block number.
-
- Arguments:
- - `count`: block count to select
- - `from_`: first block to select
- """
+ client = API(connection, URL_PATH)
+ assert count is int
+ assert start is int
+ r = await client.requests_get('/blocks/%d/%d' % (count, start))
+ return await client.parse_response(r, schema)
- super(Blocks, self).__init__(connection_handler)
- self.count = count
- self.from_ = from_
+async def hardship(connection, pubkey):
+ """
+ GET hardship level for given member's public key for writing next block
- async def __get__(self, session, **kwargs):
- assert self.count is not None
- assert self.from_ is not None
- r = await self.requests_get(session, '/blocks/%d/%d' % self.count, self.from_, **kwargs)
- return (await self.parse_response(r))
-
-
-class Hardship(Blockchain):
- """GET hardship level for given member's fingerprint for writing next block."""
+ :param API.ConnectionHandler connection: Connection handler instance
+ :param str pubkey: Public key of the member
+ :return: dict
+ """
schema = {
"type": "object",
"properties": {
@@ -367,116 +378,101 @@ class Hardship(Blockchain):
"required": ["block", "level"]
}
- def __init__(self, connection_handler, fingerprint):
- """
- Use the number parameter in order to select a block number.
-
- Arguments:
- - `fingerprint`: member fingerprint
- """
-
- super(Hardship, self).__init__(connection_handler)
-
- self.fingerprint = fingerprint
-
- async def __get__(self, session, **kwargs):
- assert self.fingerprint is not None
- r = await self.requests_get(session, '/hardship/%s' % self.fingerprint.upper(), **kwargs)
- return (await self.parse_response(r))
-
-
-class Newcomers(Blockchain):
- """GET, return block numbers containing newcomers."""
-
- schema = {
- "type": "object",
- "properties": {
- "result":{
- "type": "object",
- "properties": {
- "blocks": {
- "type": "array",
- "items": {
- "type": "number"
- }
- },
- },
- "required": ["blocks"]
- }
- },
- "required": ["result"]
- }
-
- async def __get__(self, session, **kwargs):
- r = await self.requests_get(session, '/with/newcomers', **kwargs)
- return await self.parse_response(r)
-
-
-class Certifications(Blockchain):
- """GET, return block numbers containing certifications."""
-
- schema = Newcomers.schema
-
- async def __get__(self, session, **kwargs):
- r = await self.requests_get(session, '/with/certs', **kwargs)
- return await self.parse_response(r)
-
+ client = API(connection, URL_PATH)
+ r = await client.requests_get('/hardship/%s' % pubkey)
+ return await client.parse_response(r, schema)
-class Joiners(Blockchain):
- """GET, return block numbers containing joiners."""
+async def newcomers(connection):
+ """
+ GET, return block numbers containing newcomers
- schema = Newcomers.schema
+ :param API.ConnectionHandler connection: Connection handler instance
+ :return: dict
+ """
- async def __get__(self, session, **kwargs):
- r = await self.requests_get(session, '/with/joiners', **kwargs)
- return await self.parse_response(r)
+ client = API(connection, URL_PATH)
+ r = await client.requests_get('/with/newcomers')
+ return await client.parse_response(r, BLOCK_NUMBERS_SCHEMA)
+async def certifications(connection):
+ """
+ GET, return block numbers containing certifications
-class Actives(Blockchain):
- """GET, return block numbers containing actives."""
+ :param API.ConnectionHandler connection: Connection handler instance
+ :return: dict
+ """
- schema = Newcomers.schema
+ client = API(connection, URL_PATH)
+ r = await client.requests_get('/with/certs')
+ return await client.parse_response(r, BLOCK_NUMBERS_SCHEMA)
- async def __get__(self, session, **kwargs):
- r = await self.requests_get(session, '/with/actives', **kwargs)
- return await self.parse_response(r)
+async def joiners(connection):
+ """
+ GET, return block numbers containing joiners
+ :param API.ConnectionHandler connection: Connection handler instance
+ :return: dict
+ """
-class Leavers(Blockchain):
- """GET, return block numbers containing leavers."""
+ client = API(connection, URL_PATH)
+ r = await client.requests_get('/with/joiners')
+ return await client.parse_response(r, BLOCK_NUMBERS_SCHEMA)
- schema = Newcomers.schema
+async def actives(connection):
+ """
+ GET, return block numbers containing actives
- async def __get__(self, session, **kwargs):
- r = await self.requests_get(session, '/with/leavers', **kwargs)
- return await self.parse_response(r)
+ :param API.ConnectionHandler connection: Connection handler instance
+ :return: dict
+ """
+ client = API(connection, URL_PATH)
+ r = await client.requests_get('/with/actives')
+ return await client.parse_response(r, BLOCK_NUMBERS_SCHEMA)
-class Excluded(Blockchain):
- """GET, return block numbers containing excluded."""
+async def leavers(connection):
+ """
+ GET, return block numbers containing leavers
- schema = Newcomers.schema
+ :param API.ConnectionHandler connection: Connection handler instance
+ :return: dict
+ """
- async def __get__(self, session, **kwargs):
- r = await self.requests_get(session, '/with/excluded', **kwargs)
- return await self.parse_response(r)
+ client = API(connection, URL_PATH)
+ r = await client.requests_get('/with/leavers')
+ return await client.parse_response(r, BLOCK_NUMBERS_SCHEMA)
+async def excluded(connection):
+ """
+ GET, return block numbers containing excluded
-class UD(Blockchain):
- """GET, return block numbers containing universal dividend."""
+ :param API.ConnectionHandler connection: Connection handler instance
+ :return: dict
+ """
- schema = Newcomers.schema
+ client = API(connection, URL_PATH)
+ r = await client.requests_get('/with/excluded')
+ return await client.parse_response(r, BLOCK_NUMBERS_SCHEMA)
- async def __get__(self, session, **kwargs):
- r = await self.requests_get(session, '/with/ud', **kwargs)
- return await self.parse_response(r)
+async def ud(connection):
+ """
+ GET, return block numbers containing universal dividend
+ :param API.ConnectionHandler connection: Connection handler instance
+ :return: dict
+ """
+ client = API(connection, URL_PATH)
+ r = await client.requests_get('/with/ud')
+ return await client.parse_response(r, BLOCK_NUMBERS_SCHEMA)
-class TX(Blockchain):
- """GET, return block numbers containing transactions."""
+async def tx(connection):
+ """
+ GET, return block numbers containing transactions
- schema = Newcomers.schema
+ :param API.ConnectionHandler connection: Connection handler instance
+ :return: dict
+ """
- async def __get__(self, session, **kwargs):
- r = await self.requests_get(session, '/with/tx', **kwargs)
- return await self.parse_response(r)
+ client = API(connection, URL_PATH)
+ r = await client.requests_get('/with/tx')
+ return await client.parse_response(r, BLOCK_NUMBERS_SCHEMA)
diff --git a/duniterpy/api/bma/node.py b/duniterpy/api/bma/node.py
index 7d60535b884c788dc9ac526460672dc699c4d37c..c3589921d485fb824eb65c4b784517bac4f6866e 100644
--- a/duniterpy/api/bma/node.py
+++ b/duniterpy/api/bma/node.py
@@ -20,14 +20,15 @@ from duniterpy.api.bma import API, logging
logger = logging.getLogger("duniter/node")
+URL_PATH = 'node'
-class Node(API):
- def __init__(self, connection_handler, module='node'):
- super(Node, self).__init__(connection_handler, module)
+async def summary(connection):
+ """
+ GET Certification data over a member
-
-class Summary(Node):
- """GET Certification data over a member."""
+ :param API.ConnectionHandler connection: Connection handler instance
+ :return: dict
+ """
schema = {
"type": "object",
"properties": {
@@ -49,11 +50,6 @@ class Summary(Node):
},
"required": ["duniter"]
}
-
- def __init__(self, connection_handler, module='node'):
- super(Summary, self).__init__(connection_handler, module)
-
- async def __get__(self, session, **kwargs):
- r = await self.requests_get(session, '/summary', **kwargs)
- return await self.parse_response(r)
-
+ client = API(connection, URL_PATH)
+ r = await client.requests_get('/summary')
+ return await client.parse_response(r, schema)
diff --git a/duniterpy/api/bma/ws.py b/duniterpy/api/bma/ws.py
index 9eabab3d5deb6bb2f47e33aef9ecb49aa8d7d703..535b7c6611c5a7e49648b464f525331f0cfc1fcd 100644
--- a/duniterpy/api/bma/ws.py
+++ b/duniterpy/api/bma/ws.py
@@ -17,8 +17,7 @@
#
from duniterpy.api.bma import API, logging
-from duniterpy.api.bma.blockchain import Block as _Block
-from duniterpy.api.bma.network.peering import Peers as _Peers
+from duniterpy.api.bma.blockchain import BLOCK_SCHEMA
logger = logging.getLogger("duniter/ws")
@@ -30,7 +29,7 @@ class Websocket(API):
class Block(Websocket):
"""Connect to block websocket."""
- schema = _Block.schema
+ schema = BLOCK_SCHEMA
def connect(self, session):
r = self.connect_ws(session, '/block')
diff --git a/duniterpy/documents/peer.py b/duniterpy/documents/peer.py
index c806cbcbe8e15913f424d3fcf4ed8d68691ff081..595bdf35bc049f4810a971318d4f1accc3b65170 100644
--- a/duniterpy/documents/peer.py
+++ b/duniterpy/documents/peer.py
@@ -6,6 +6,7 @@ from . import BlockUID
from .. import PROTOCOL_VERSION, MANAGED_API
from .constants import block_hash_regex, pubkey_regex
+
class Peer(Document):
"""
.. note:: A peer document is specified by the following format :
@@ -177,13 +178,13 @@ class BMAEndpoint(Endpoint):
IPv6=(" {0}".format(self.ipv6) if self.ipv6 else ""),
PORT=(" {0}".format(self.port) if self.port else ""))
- def conn_handler(self):
+ def conn_handler(self, session=None):
if self.server:
- return ConnectionHandler(self.server, self.port)
+ return ConnectionHandler(self.server, self.port, session)
elif self.ipv4:
- return ConnectionHandler(self.ipv4, self.port)
+ return ConnectionHandler(self.ipv4, self.port, session)
else:
- return ConnectionHandler("[{0}]".format(self.ipv6), self.port)
+ return ConnectionHandler("[{0}]".format(self.ipv6), self.port, session)
def __str__(self):
return self.inline()
diff --git a/examples/request_data.py b/examples/request_data.py
index b658eafc6d8de7bac30c316aefe9e15b0dcc3b7b..247df20c59500cf5fed91ed313f43287810aa98e 100644
--- a/examples/request_data.py
+++ b/examples/request_data.py
@@ -21,18 +21,22 @@ async def main():
Main code
"""
# connection handler from BMA endpoint
- connection = BMAEndpoint.from_inline(BMA_ENDPOINT).conn_handler()
+ connection = BMAEndpoint.from_inline(BMA_ENDPOINT).conn_handler(AIOHTTP_SESSION)
# Get the node summary infos
- response = await bma.node.Summary(connection).get(AIOHTTP_SESSION)
+ response = await bma.node.summary(connection)
print(response)
# Get the current block data
- response = await bma.blockchain.Current(connection).get(AIOHTTP_SESSION)
+ response = await bma.blockchain.parameters(connection)
+ print(response)
+
+ # Get the current block data
+ response = await bma.blockchain.current(connection)
print(response)
# Get the block number 0
- response = await bma.blockchain.Block(connection, 0).get(AIOHTTP_SESSION)
+ response = await bma.blockchain.block(connection, number=10)
print(response)
with AIOHTTP_SESSION: