async def sub(**kwargs):
a = kwargs.get("a", None)
b = kwargs.get("b", None)
log.debug(f"sub({a},{b})")
if a is None:
raise InvalidParams("\"a\" is required")
if b is None:
raise InvalidParams("\"b\" is required")
if type(a) is str:
if a.isdigit():
a = int(a)
else:
raise InvalidParams("\"a\" must be a number")
if type(b) is str:
if b.isdigit():
b = int(b)
else:
raise InvalidParams("\"b\" must be a number")
result = a - b
return {"result": result}
async def find_face(**kwargs):
image = kwargs.get("image", None)
algorithm = kwargs.get("algorithm", "dlib_cnn")
if image is None:
raise InvalidParams("image is required")
face_detector = get_detector(algorithm)
if face_detector is None:
raise InvalidParams("unknown algorithm")
binary_image = base64.b64decode(image)
img_data = io.BytesIO(binary_image)
img = ioimg.imread(img_data)
# Drop alpha channel if it exists
if img.shape[-1] == 4:
img = img[:, :, :3]
log.debug("Dropping alpha channel from image")
dets = face_detect(img, face_detector, algorithm)
faces = []
for d in dets:
faces.append(dict(x=d.left(), y=d.top(), w=d.right() - d.left(), h=d.bottom() - d.top()))
return {'faces': faces}
async def blockchain_passthrough(job_address=None,
job_signature=None,
**kwargs):
job_address = self.chain.to_checksum_address(job_address)
if job_address is None:
logger.error("invalid request: job_address is required")
raise InvalidParams("invalid request: job_address is required")
if job_signature is None:
logger.error("invalid request: job_signature is required")
raise InvalidParams(
"invalid request: job_signature is required")
if await self.chain.validate_job_invocation(
job_address, job_signature):
logger.debug("dispatching request to service; job_address: %s",
job_address)
response = client.request(config.PASSTHROUGH_ENDPOINT, method,
**kwargs)
db = self.app["db"]
job_entry = db.get(job_address, {})
job_entry["job_signature"] = job_signature
job_entry["completed"] = True
logger.debug("saving job to db; job_address: %s; db entry: %s",
job_address, job_entry)
db[job_address] = job_entry
self.app.loop.create_task(
self.chain.complete_job(job_address, job_signature))
logger.debug("returning response to client; job_address: %s",
job_address)
return response
else:
logger.error("job invocation failed to validate")
raise ServerError("job invocation failed to validate")
async def sendTransaction(self, **data):
def get_data_default(key, decoder, default=None):
if key in data:
return decoder(data[key])
return default
to = get_data_default("to", recipient_decoder, b"")
startgas = get_data_default("gas", quantity_decoder, DEFAULT_STARTGAS)
gasprice = get_data_default("gasPrice", quantity_decoder,
DEFAULT_GASPRICE)
gas_token_id = get_data_default("gasTokenId", quantity_decoder, 0)
value = get_data_default("value", quantity_decoder, 0)
transfer_token_id = get_data_default("transfer_token_id",
quantity_decoder, 0)
data_ = get_data_default("data", data_decoder, b"")
v = get_data_default("v", quantity_decoder, 0)
r = get_data_default("r", quantity_decoder, 0)
s = get_data_default("s", quantity_decoder, 0)
nonce = get_data_default("nonce", quantity_decoder, None)
to_full_shard_id = get_data_default("toFullShardId",
full_shard_id_decoder, None)
from_full_shard_id = get_data_default("fromFullShardId",
full_shard_id_decoder, None)
network_id = get_data_default(
"networkId", quantity_decoder,
self.master.env.quark_chain_config.NETWORK_ID)
if nonce is None:
raise InvalidParams("Missing nonce")
if not (v and r and s):
raise InvalidParams("Missing v, r, s")
if from_full_shard_id is None:
raise InvalidParams("Missing fromFullShardId")
if to_full_shard_id is None:
to_full_shard_id = from_full_shard_id
evm_tx = EvmTransaction(
nonce,
gasprice,
startgas,
gas_token_id,
to,
value,
transfer_token_id,
data_,
v,
r,
s,
from_full_shard_id=from_full_shard_id,
to_full_shard_id=to_full_shard_id,
network_id=network_id,
)
tx = Transaction(code=Code.create_evm_code(evm_tx))
success = await self.master.add_transaction(tx)
if not success:
return None
return id_encoder(tx.get_hash(), from_full_shard_id)
def data_decoder(hex_str):
"""Decode `hexStr` representing unformatted hex_str."""
if not hex_str.startswith("0x"):
raise InvalidParams("Invalid hex_str encoding")
try:
return bytes.fromhex(hex_str[2:])
except Exception:
raise InvalidParams("Invalid hex_str hex encoding")
async def _call_or_estimate_gas(self, is_call: bool, **data):
""" Returns the result of the transaction application without putting in block chain """
if not isinstance(data, dict):
raise InvalidParams("Transaction must be an object")
def get_data_default(key, decoder, default=None):
if key in data:
return decoder(data[key])
return default
to = get_data_default("to", address_decoder, None)
if to is None:
raise InvalidParams("Missing to")
to_full_shard_key = int.from_bytes(to[20:], "big")
gas = get_data_default("gas", quantity_decoder, 0)
gas_price = get_data_default("gasPrice", quantity_decoder, 0)
value = get_data_default("value", quantity_decoder, 0)
data_ = get_data_default("data", data_decoder, b"")
sender = get_data_default("from", address_decoder,
b"\x00" * 20 + to[20:])
sender_address = Address.create_from(sender)
gas_token_id = get_data_default(
"gas_token_id", quantity_decoder,
self.env.quark_chain_config.genesis_token)
transfer_token_id = get_data_default(
"transfer_token_id",
quantity_decoder,
self.env.quark_chain_config.genesis_token,
)
network_id = self.master.env.quark_chain_config.NETWORK_ID
nonce = 0 # slave will fill in the real nonce
evm_tx = EvmTransaction(
nonce,
gas_price,
gas,
to[:20],
value,
data_,
from_full_shard_key=sender_address.full_shard_key,
to_full_shard_key=to_full_shard_key,
network_id=network_id,
gas_token_id=gas_token_id,
transfer_token_id=transfer_token_id,
)
tx = TypedTransaction(SerializedEvmTransaction.from_evm_tx(evm_tx))
if is_call:
res = await self.master.execute_transaction(
tx, sender_address, data["block_height"])
return data_encoder(res) if res is not None else None
else: # estimate gas
res = await self.master.estimate_gas(tx, sender_address)
return quantity_encoder(res) if res is not None else None
async def sendUnsigedTransaction(self, **data):
""" Returns the unsigned hash of the evm transaction """
if not isinstance(data, dict):
raise InvalidParams("Transaction must be an object")
def get_data_default(key, decoder, default=None):
if key in data:
return decoder(data[key])
return default
nonce = get_data_default("nonce", quantity_decoder, None)
to = get_data_default("to", recipient_decoder, b"")
startgas = get_data_default("gas", quantity_decoder, DEFAULT_STARTGAS)
gasprice = get_data_default("gasPrice", quantity_decoder,
DEFAULT_GASPRICE)
value = get_data_default("value", quantity_decoder, 0)
data_ = get_data_default("data", data_decoder, b"")
from_full_shard_id = get_data_default("fromFullShardId",
full_shard_id_decoder, None)
to_full_shard_id = get_data_default("toFullShardId",
full_shard_id_decoder, None)
if nonce is None:
raise InvalidParams("nonce is missing")
if from_full_shard_id is None:
raise InvalidParams("fromFullShardId is missing")
if to_full_shard_id is None:
to_full_shard_id = from_full_shard_id
evm_tx = EvmTransaction(
nonce,
gasprice,
startgas,
to,
value,
data_,
from_full_shard_id=from_full_shard_id,
to_full_shard_id=to_full_shard_id,
network_id=self.master.env.quark_chain_config.NETWORK_ID,
)
return {
"txHashUnsigned": data_encoder(evm_tx.hash_unsigned),
"nonce": quantity_encoder(evm_tx.nonce),
"to": data_encoder(evm_tx.to),
"fromFullShardId":
full_shard_id_encoder(evm_tx.from_full_shard_id),
"toFullShardId": full_shard_id_encoder(evm_tx.to_full_shard_id),
"value": quantity_encoder(evm_tx.value),
"gasPrice": quantity_encoder(evm_tx.gasprice),
"gas": quantity_encoder(evm_tx.startgas),
"data": data_encoder(evm_tx.data),
"networkId": quantity_encoder(evm_tx.network_id),
}
def quantity_decoder(hex_str):
"""Decode `hexStr` representing a quantity."""
# must start with "0x"
if not hex_str.startswith("0x") or len(hex_str) < 3:
raise InvalidParams("Invalid quantity encoding")
try:
return int(hex_str, 16)
except ValueError:
raise InvalidParams("Invalid quantity encoding")
async def classify(**kwargs):
image = kwargs.get("image", None)
image_type = kwargs.get("image_type", None)
if image is None:
raise InvalidParams("image is required")
if image_type is None:
raise InvalidParams("image_type is required")
binary_image = base64.b64decode(image)
if image_type == 'jpeg' or image_type == 'jpg':
decoder_key = 'DecodeJpeg/contents:0'
elif image_type == 'png':
decoder_key = 'DecodeJpeg/contents:0'
elif image_type == 'gif':
raise RuntimeError("TensorflowImageNet - cannot decode gif images")
elif image_type == 'bmp':
raise RuntimeError("TensorflowImageNet - cannot decode bmp images")
else:
decoder_key = 'DecodeJpeg/contents:0'
logger.warning("Missing image type {0}".format(image_type))
logger.debug("classifying '{0}' image".format(image_type))
raw_predictions = session.run(softmax_tensor, {decoder_key: binary_image})
# Pull the predicted scorces out of the raw predictions.
predicted_scores = raw_predictions[0]
# Sort and strip off the top 5 predictions.
top_predictions = predicted_scores.argsort()[-5:][::-1]
image_predictions = []
image_scores = []
for predicted_node_id in top_predictions:
# Get a text description for the top predicted node.
description = node_lookup.id_to_string(predicted_node_id)
# Cast to a float so JSON can serialize it. Normal Tensorflow float32 are not serializable.
score = float(predicted_scores[predicted_node_id])
logger.debug(" prediction = '{0}', score = {1}".format(
description, score))
# Add only those that exceed our minimum score to the predictions and scores lists.
if score > config.MINIMUM_SCORE:
image_predictions.append(description)
image_scores.append(score)
return {"predictions": image_predictions, "confidences": image_scores}
async def recognise_face(**kwargs):
image = kwargs.get("image", None)
face_bboxes = kwargs.get("faces", [])
if image is None:
raise InvalidParams("image is required")
binary_image = base64.b64decode(image)
img_data = io.BytesIO(binary_image)
img = ioimg.imread(img_data)
# Drop alpha channel if it exists
if img.shape[-1] == 4:
img = img[:, :, :3]
log.debug("Dropping alpha channel from image")
face_identities = []
for b in face_bboxes:
bbox = BoundingBox(**b)
dlib_bbox = dlib.rectangle(bbox.x, bbox.y, bbox.x + bbox.w,
bbox.y + bbox.h)
detection_object = landmark_predictor(img, dlib_bbox)
face_descriptor = facerec.compute_face_descriptor(
img, detection_object, 10)
face_identities.append([x for x in face_descriptor])
return {'face_identities': face_identities}
async def get_landmarks(**kwargs):
image = kwargs.get("image", None)
lm = kwargs.get("landmark_model", "5")
bboxes = kwargs.get("face_bboxes", [])
if image is None:
raise InvalidParams("image is required")
binary_image = base64.b64decode(image)
img_data = io.BytesIO(binary_image)
img = ioimg.imread(img_data)
# Drop alpha channel if it exists
if img.shape[-1] == 4:
img = img[:, :, :3]
log.debug("Dropping alpha channel from image")
face_landmarks = []
for bbox in bboxes:
bbox_pb = BoundingBox(**bbox)
points = landmark_finder(img, bbox_pb, lm)
face_landmarks.append({
'landmark_model': lm,
'points': [{
'x': p.x,
'y': p.y
} for p in points]
})
return {'landmarks': face_landmarks}
def _get_arguments(request):
"""Takes the 'params' part of a JSON-RPC request and converts it to either
positional or keyword arguments usable in Python. The value can be a JSON
array (python list), object (python dict), or omitted. There are no other
acceptable options. Note that a JSON-RPC request can have positional or
keyword arguments, but not both! See
http://www.jsonrpc.org/specification#parameter_structures
:param request: JSON-RPC request in dict form.
:raises InvalidParams: If 'params' was present but was not a list or dict.
:returns: A tuple containing the positionals (in a list, or None) and
keywords (in a dict, or None) extracted from the 'params' part of the
request.
"""
positionals = keywords = None
params = request.get('params')
# Params was omitted from the request. Taken as no arguments.
if 'params' not in request:
pass
# Params is a list. Taken as positional arguments.
elif isinstance(params, list):
positionals = params
# Params is a dict. Taken as keyword arguments.
elif isinstance(params, dict):
keywords = params
# Anything else is invalid. (This should never happen if the request has
# passed the schema validation.)
else:
raise InvalidParams('Params of type %s is not allowed' % \
type(params).__name__)
return (positionals, keywords)
def add_subscriber(self, sub_type, sub_id, conn, extra=None):
if sub_type not in self.subscribers:
raise InvalidParams("Invalid subscription")
self.subscribers[sub_type][sub_id] = conn
if sub_type == SUB_LOGS:
assert extra and isinstance(extra, Callable)
self.log_filter_gen[sub_id] = extra
def _call(methods, method_name, args=None, kwargs=None):
"""Find a method from a list, then validate the arguments before calling it.
:param methods: The list of methods - either a python list, or Methods obj.
:param args: Positional arguments (list)
:param kwargs: Keyword arguments (dict)
:raises MethodNotFound: If the method is not in the list.
:raises InvalidParams: If the arguments don't match the method signature.
:returns: The return value from the method called.
"""
# Get the method object from a list of rpc methods
method = _get_method(methods, method_name)
# Ensure the arguments match the method's signature
_validate_arguments_against_signature(method, args, kwargs)
# Call the method
if args and kwargs:
# Cannot have both positional and keyword arguments in JSON-RPC.
raise InvalidParams()
# No arguments
elif not args and not kwargs:
return method()
# Positional arguments
elif args:
return method(*args)
# Keyword arguments
elif kwargs:
return method(**kwargs)
def signature_decoder(hex_str):
"""Decode a block signature."""
if not hex_str:
return None
decoded = data_decoder(hex_str)
if len(decoded) != 65:
raise InvalidParams("Signature must be 65 bytes long")
return decoded
def remove_subscriber(self, sub_id):
for sub_type, subscriber_dict in self.subscribers.items():
if sub_id in subscriber_dict:
del subscriber_dict[sub_id]
if sub_type == SUB_LOGS:
del self.log_filter_gen[sub_id]
return
raise InvalidParams("subscription not found")
async def classify(**kwargs):
image = kwargs.get("image", None)
image_type = kwargs.get("image_type", None)
if image is None:
raise InvalidParams("image is required")
if image_type is None:
raise InvalidParams("image type is required")
binary_image = base64.b64decode(image)
tmp_file_name = tempfile.NamedTemporaryFile()
tmp_file_name.write(binary_image)
model.args.path = tmp_file_name.name
bounding_boxes, emotions = model.predict()
return {
"bounding boxes": str(bounding_boxes),
"predictions": str(emotions)
}
def eth_address_to_quarkchain_address_decoder(hex_str):
eth_hex = hex_str[2:]
if len(eth_hex) != 40:
raise InvalidParams("Addresses must be 40 or 0 bytes long")
full_shard_id_hex = ""
for i in range(4):
index = i * 10
full_shard_id_hex += eth_hex[index:index + 2]
return address_decoder("0x" + eth_hex + full_shard_id_hex)
async def detect(**kwargs):
model = kwargs.get("model", "yolov3")
confidence = kwargs.get("confidence", "0.7")
img_path = kwargs.get("img_path", None)
if img_path is None:
raise InvalidParams("\"img_path\" is required")
log.debug("detect({},{},{})".format(model, confidence, len(img_path)))
objd = ObjectDetector(model, confidence, map_names, img_path)
return {"result": objd.detect()}
def test_with_id(self):
response = ExceptionResponse(InvalidParams(), 1)
self.assertEqual(
{
'jsonrpc': '2.0',
'error': {
'code': -32602,
'message': 'Invalid params'
},
'id': 1
}, response)
async def dogs(**kwargs):
log.debug("dogs({})".format(kwargs))
model = kwargs.get("model", "ResNet18")
map_names = dogs_map_names
img_path = kwargs.get("img_path", None)
if img_path is None:
raise InvalidParams("\"img_path\" is required")
image_dims = (3, 224, 224)
result = img_recon.image_recognition("dogs", model, map_names, img_path, image_dims)
return {"result": result}
def test_jsonrpcservererror(self):
response = ExceptionResponse(InvalidParams(), None)
self.assertEqual(
{
'jsonrpc': '2.0',
'error': {
'code': -32602,
'message': 'Invalid params'
},
'id': None
}, response)
async def summarise(**kwargs):
text = kwargs.get("text", None)
if text is None:
raise InvalidParams("text is required")
from multiprocessing import Pool
global config
with Pool(1) as p:
result = p.apply(summarise_text, (text, ))
return {'summary': result}
async def translate(**kwargs):
text = kwargs.get("text", None)
source = kwargs.get("source", None)
target = kwargs.get("target", None)
if text is None:
raise InvalidParams("text param is required")
if source not in translations:
raise InvalidParams("source param must be one of", translations.keys())
if target not in translations[source]:
raise InvalidParams("target param must be one of",
translations[source].keys())
from multiprocessing import Pool
global config
with Pool(1) as p:
result = p.apply(translate_text, (text, source, target))
return {'summary': result}
def test_jsonrpcservererror(self):
response = ExceptionResponse(InvalidParams(), None)
self.assertEqual(
{
"jsonrpc": "2.0",
"error": {
"code": -32602,
"message": "Invalid params"
},
"id": None,
},
response,
)
def test_with_id(self):
response = ExceptionResponse(InvalidParams(), 1)
self.assertEqual(
{
"jsonrpc": "2.0",
"error": {
"code": -32602,
"message": "Invalid params"
},
"id": 1,
},
response,
)
def test_with_data(self):
config.debug = True
response = ExceptionResponse(InvalidParams('Password missing'), 1)
self.assertEqual(
{
'jsonrpc': '2.0',
'error': {
'code': -32602,
'message': 'Invalid params',
'data': 'Password missing'
},
'id': 1
}, response)
async def classify(**kwargs):
image = kwargs.get("image", None)
image_type = kwargs.get("image_type", None)
if image is None:
raise InvalidParams("image is required")
if image_type is None:
raise InvalidParams("image type is required")
binary_image = base64.b64decode(image)
# this requires that we save the file.
current_files = os.listdir('tmp')
tmp_file_name = 'tmp/tmp_' + str(random.randint(
0, 100000000000)) + '_.' + str(image_type)
while tmp_file_name in current_files:
tmp_file_name = 'tmp/tmp_' + str(random.randint(
0, 100000000000)) + '_.' + str(image_type)
with open(tmp_file_name, 'wb') as f:
f.write(binary_image)
model.args.path = tmp_file_name
bounding_boxes, emotions = model.predict()
return {
"bounding boxes": str(bounding_boxes),
"predictions": str(emotions)
}
async def classify(**kwargs):
image = kwargs.get("image", None)
image_type = kwargs.get("image_type", None)
if image is None:
raise InvalidParams("image is required")
if image_type is None:
raise InvalidParams("image type is required")
binary_image = base64.b64decode(image)
with Pool(1) as p:
bounding_boxes, emotions = p.apply(_classify, (binary_image, ))
return {
"bounding boxes": [
dict(x=d.left(),
y=d.top(),
w=d.right() - d.left(),
h=d.bottom() - d.top()) for d in bounding_boxes
],
"predictions":
emotions
}
async def getMinorBlockByHeight(
self, shard: int, height=None, include_transactions=False
):
shard_size = self.master.get_shard_size()
if height is not None:
height = quantity_decoder(height)
if shard >= shard_size:
raise InvalidParams(
"shard is larger than shard size {} > {}".format(shard, shard_size)
)
branch = Branch.create(shard_size, shard)
block = await self.master.get_minor_block_by_height(height, branch)
if not block:
return None
return minor_block_encoder(block, include_transactions)
