def _manage_response(req, returnKey, error=None):
# print(req.url)
if req.status_code < 300:
try:
data = req.json()
except Exception as error:
data = {
"success": True,
"except": True,
"data": req.text,
"error": "%r" % error
}
else:
tmp = data.get(returnKey, False)
if not tmp:
if returnKey:
data["warning"] = "returnKey %s not found" % returnKey
else:
data = tmp
if isinstance(tmp, dict):
data = filter_dic(tmp)
return data
else:
return {
"success": False,
"except": True,
"error": "status code %s returned" % req.status_code
}
class Delegate(dposlib.blockchain.Content):
wallet = property(lambda cls: Wallet(cls.address), None, None, "")
voters = property(
lambda cls: list(sorted(
[
filter_dic(dic) for dic in
loadPages(GET.api.delegates.__getattr__(cls.username).voters)
],
key=lambda e: e["balance"],
reverse=True
)),
None, None, ""
)
lastBlock = property(
lambda cls: Block(cls.blocks["last"]["id"]), None, None, ""
)
def __init__(self, username, **kw):
dposlib.blockchain.Content.__init__(
self, GET.api.delegates, username,
**dict({"returnKey": "data"}, **kw)
)
def getRecentBlocks(self, limit=50):
return loadPages(
GET.api.delegates.__getattr__(self.username).blocks,
limit=limit
)
def lastTransactions(self, limit=50):
received, sent, count = [], [], 0
while count < limit:
sent.extend(rest.GET.api.transactions(senderId=self.address, orderBy="timestamp:desc", returnKey="data", offset=len(sent)))
received.extend(rest.GET.api.transactions(recipientId=self.address, orderBy="timestamp:desc", returnKey="data", offset=len(received)))
tmpcount = len(sent)+len(received)
count = limit if count == tmpcount else tmpcount
return [filter_dic(dic) for dic in sorted(received+sent, key=lambda e:e["timestamp"].get("epoch", None), reverse=True)[:limit]]
def _call(method="GET", *args, **kwargs):
returnKey = kwargs.pop("returnKey", False)
response = req.EndPoint._open(
req.EndPoint.build_req(method, *args, **kwargs))
if returnKey and returnKey in response:
return filter_dic(response[returnKey])
else:
return response
def voters(self):
voters = misc.loadPages(
dposlib.rest.GET.api.delegates.__getattr__(
self.username).__getattr__("voters"))
return list(
sorted([filter_dic(dic) for dic in voters],
key=lambda e: e["balance"],
reverse=True))
def voters(self):
voters = [
a for a in rest.GET.api.delegates.voters(publicKey=self.publicKey,
returnKey="accounts")
if a["balance"] not in [0, "0"]
]
return list(
sorted([filter_dic(dic) for dic in voters],
key=lambda e: e["balance"],
reverse=True))
def transactions(self, limit=50):
sent = misc.loadPages(dposlib.rest.GET.api.wallets.__getattr__(
self.address).__getattr__("transactions").__getattr__("sent"),
limit=limit)
received = misc.loadPages(dposlib.rest.GET.api.wallets.__getattr__(
self.address).__getattr__("transactions").__getattr__("received"),
limit=limit)
return [
filter_dic(dic) for dic in sorted(
received + sent,
key=lambda e: e.get("timestamp", {}).get("epoch"),
reverse=True)
][:limit]
class Block(Content):
previous = property(lambda cls: Block(cls._Data__dict["previous"]), None,
None, "")
transactions = property(
lambda cls: [
filter_dic(dic) for dic in loadPages(
GET.api.blocks.__getattr__(cls.id).transactions, limit=False)
], None, None, "")
def __init__(self, blk_id, **kw):
Content.__init__(self, GET.api.blocks, blk_id,
**dict({"returnKey": "data"}, **kw))
def _GET(*args, **kwargs):
# API response contains several fields and wanted one can be extracted using
# a returnKey that match the field name
return_key = kwargs.pop('returnKey', False)
peer = kwargs.pop('peer', False)
peer = peer if peer else random.choice(cfg.peers)
try:
req = requests.get(peer + "/".join(args),
params=dict([k.replace('and_', 'AND:'), v]
for k, v in kwargs.items()),
headers=cfg.headers,
verify=cfg.verify,
timeout=cfg.timeout)
# print(req.url)
data = req.json()
except Exception as error:
data = {"success": False, "error": "%r" % error, "except": True}
else:
if return_key in data:
data = data.get(return_key, {})
if isinstance(data, dict):
data = filter_dic(data)
return data
def voters(self): voters = [a for a in rest.GET.api.delegates(self.username, "voters", returnKey="data") if a["balance"] not in [0, "0"]] return list(sorted([filter_dic(dic) for dic in voters], key=lambda e:e["balance"], reverse=True))
def forged(self):
result = filter_dic(rest.GET.api.delegates.forging.getForgedByAccount(generatorPublicKey=self.publicKey))
result.pop("success", False)
return result
def forged(self):
return filter_dic(self._Data__dict["forged"])