def test_datetime(self):
obj = datetime(2013, 3, 27, 23, 5)
mobj = msgpack.loads(msgpack.dumps(obj))
jobj = json.loads(json.dumps(obj))
assert obj == mobj
assert obj == jobj
eastern = pytz.timezone('US/Eastern')
obj = datetime(2013, 3, 27, 23, 5, tzinfo=eastern)
mobj = msgpack.loads(msgpack.dumps(obj))
jobj = json.loads(json.dumps(obj))
assert obj == mobj
assert obj == jobj
def test_date(self):
obj = date(2013, 3, 27)
mobj = msgpack.loads(msgpack.dumps(obj))
jobj = json.loads(json.dumps(obj))
assert obj == mobj
assert obj == jobj
def nd(image_array_or_url,
category_index=None,
get_multilabel_results=None,
get_combined_results=None,
get_layer_output=None,
get_all_graylevels=None,
threshold=None):
params = {}
if category_index:
params['categoryIndex'] = category_index
if get_multilabel_results:
params['getMultilabelResults'] = get_multilabel_results
if get_combined_results:
params['getCombinedResults'] = get_combined_results
if get_layer_output:
params['getLayerOutput'] = get_layer_output
if get_all_graylevels:
params['getAllGrayLevels'] = get_all_graylevels
if threshold:
params['threshold'] = threshold
# if get_yolo:
# params['getYolo'] = get_yolo
if params == {}:
params = None #not sure if this is necesary but the original line (below) made it happen
#params = params={"categoryIndex": category_index} if category_index else None
print('params coming into neurodoll falcon client:' + str(params))
data = msgpack.dumps({"image": image_array_or_url})
resp = requests.post(CLASSIFIER_ADDRESS, data=data, params=params)
return msgpack.loads(resp.content)
def on_post(self, req, resp):
t1 = time()
category = req.get_param('category')
col_name = req.get_param('col_name')
ret = {"success": False}
key = col_name + '.' + category
forest_handle = self.forests[key]
try:
data = msgpack.loads(req.stream.read())
fp = data.get("fingerprint")
ret['id_list'] = forest_handle.get_nns_by_vector(fp, 1000)
if ret["id_list"] is not None:
ret["success"] = True
else:
ret["error"] = "No list"
except Exception as e:
ret["error"] = str(e)
t2 = time()
duration = t2 - t1
ret['duration'] = duration
resp.data = msgpack.dumps(ret)
resp.content_type = 'application/x-msgpack'
resp.status = falcon.HTTP_200
def pd(image_arrary_or_url):
data = msgpack.dumps({"image": image_arrary_or_url})
resp = requests.post(CLASSIFIER_ADDRESS, data)
if 200 <= resp.status_code < 300:
return msgpack.loads(resp.content)
else:
raise Exception('PD FAILED', resp.content)
def on_post(self, req, resp):
category_to_look_for = req.get_param('catToLookFor')
print('category to look for:' + str(category_to_look_for))
ret = {"success": False}
try:
data = msgpack.loads(req.stream.read())
img = data.get("image")
except Exception:
ret["error"] = traceback.format_exc()
try:
mnc_mask, mnc_box, im, im_name, orig_im, boxes, scalefactor, superimpose_name = mnc.mnc_pixlevel_detect(
img)
# mnc_mask, mnc_box = mnc.mnc_pixlevel_detect(img)
if mnc_mask is not None:
ret["success"] = True
ret['mnc_output'] = {
"mask": mnc_mask,
"box": mnc_box,
"superimposed_image": im,
"image_name": im_name,
"original_image": orig_im,
"bounding_boxes": boxes,
"scale_factor": scalefactor
}
except Exception:
ret["error"] = traceback.format_exc()
resp.data = msgpack.dumps(ret)
resp.content_type = 'application/x-msgpack'
resp.status = falcon.HTTP_200
def sleeve_distance(main_vector, candidate_vector):
data = msgpack.dumps({
"function": "distance",
'main_vector': main_vector,
'candidate_vector': candidate_vector
})
resp = requests.post(CLASSIFIER_ADDRESS, data=data)
return msgpack.loads(resp.content)
def labelize(image_or_url):
try:
data = msgpack.dumps({"image": image_or_url})
resp = requests.post(LABEL_ADDRESS, data)
labels = msgpack.loads(resp.content)["labels"]
return {key: float(val) for key, val in labels.items()}
except:
return []
def test_list(self):
obj = [1, 2, 3]
mobj = msgpack.loads(msgpack.dumps(obj))
jobj = json.loads(json.dumps(obj))
assert obj == mobj
assert isinstance(mobj, list)
assert obj == jobj
assert isinstance(jobj, list)
def test_int(self):
obj = 1
mobj = msgpack.loads(msgpack.dumps(obj))
jobj = json.loads(json.dumps(obj))
assert obj == mobj
assert isinstance(mobj, int)
assert obj == jobj
assert isinstance(jobj, int)
def detect(img_arr, roi=[]):
print('using addr ' + str(CLASSIFIER_ADDRESS))
data = {"image": img_arr}
if roi:
print "Make sure roi is a list in this order [x1, y1, x2, y2]"
data["roi"] = roi
serialized_data = msgpack.dumps(data)
resp = requests.post(CLASSIFIER_ADDRESS, data=serialized_data)
return msgpack.loads(resp.content)
def test_set(self):
obj = set([1, 2, 3])
mobj = msgpack.loads(msgpack.dumps(obj))
jobj = json.loads(json.dumps(obj))
assert obj == mobj
assert isinstance(mobj, set)
assert obj == jobj
assert isinstance(jobj, set)
def test_str(self):
obj = "abc"
mobj = msgpack.loads(msgpack.dumps(obj))
jobj = json.loads(json.dumps(obj))
assert obj == mobj
assert isinstance(mobj, (str, unicode))
assert obj == jobj
assert isinstance(jobj, (str, unicode))
def test_complex(self):
obj = complex(123)
mobj = msgpack.loads(msgpack.dumps(obj))
jobj = json.loads(json.dumps(obj))
assert obj == mobj
assert isinstance(mobj, complex)
assert obj == jobj
assert isinstance(jobj, complex)
def test_dict(self):
obj = {'a': 1, 'b': 2, 'c': 3}
mobj = msgpack.loads(msgpack.dumps(obj))
jobj = json.loads(json.dumps(obj))
assert obj == mobj
assert isinstance(mobj, dict)
assert obj == jobj
assert isinstance(jobj, dict)
def test_float(self):
obj = 3.14159
mobj = msgpack.loads(msgpack.dumps(obj))
jobj = json.loads(json.dumps(obj))
assert obj == mobj
assert isinstance(mobj, float)
assert obj == jobj
assert isinstance(jobj, float)
def test_dict_int_keys(self):
obj = {1: 1, 2: 2, 3: 3}
mobj = msgpack.loads(msgpack.dumps(obj))
jobj = json.loads(json.dumps(obj))
assert obj == mobj
assert isinstance(mobj, dict)
# we cannot test this as JSON will convert int keys to strings
#assert obj == jobj
assert isinstance(jobj, dict)
def mnc(image_array_or_url, cat_to_look_for='person'):
params = {}
if cat_to_look_for:
params['catToLookFor'] = cat_to_look_for
if params == {}:
params = None #not sure if this is necesary but the original line (below) made it happen
#params = params={"categoryIndex": category_index} if category_index else None
print('params coming into mnc falcon client:' + str(params))
data = msgpack.dumps({"image": image_array_or_url})
resp = requests.post(CLASSIFIER_ADDRESS, data=data, params=params)
return msgpack.loads(resp.content)
def test_npgeneric(self):
obj = np.float32(1)
mobj = msgpack.loads(msgpack.dumps(obj))
jobj = json.loads(json.dumps(obj))
assert obj.dtype == np.float32
assert obj == mobj
assert obj.dtype == mobj.dtype
assert isinstance(mobj, np.generic)
assert obj == jobj
assert obj.dtype == jobj.dtype
assert isinstance(jobj, np.generic)
def test_serialisable(self):
class SerialisableObject(jaweson.Serialisable):
def __init__(self):
self.a = 1
obj = SerialisableObject()
mobj = msgpack.loads(msgpack.dumps(obj))
jobj = json.loads(json.dumps(obj))
assert obj.a == 1
assert obj.a == mobj.a
assert obj.a == jobj.a
def test_serialisable_constructor(self):
class SerialisableConstructorObject(jaweson.Serialisable):
def __init__(self, a):
self.a = a
obj = SerialisableConstructorObject(2)
mobj = msgpack.loads(msgpack.dumps(obj))
jobj = json.loads(json.dumps(obj))
assert obj.a == 2
assert obj.a == mobj.a
assert obj.a == jobj.a
def bring_forth_the_hydra(image_array_or_url, gpu=1):
params = {}
if gpu:
params['gpu'] = gpu
if params == {}:
params = None #not sure if this is necesary but the original line (below) made it happen
#params = params={"categoryIndex": category_index} if category_index else None
print('params coming into hydra:' + str(params))
# data = msgpack.dumps({"image": image_array_or_url})
data = {"image": image_array_or_url}
resp = requests.post(CLASSIFIER_ADDRESS, data=data, params=params)
return msgpack.loads(resp.content)
def test_ndarray(self):
obj = np.array([1, 2, 3], dtype=np.float32)
mobj = msgpack.loads(msgpack.dumps(obj))
jobj = json.loads(json.dumps(obj))
assert obj.dtype == np.float32
assert (obj == mobj).all()
assert obj.dtype == mobj.dtype
assert isinstance(mobj, np.ndarray)
assert (obj == jobj).all()
assert obj.dtype == jobj.dtype
assert isinstance(jobj, np.ndarray)
def detect_hls(img_arr, roi=[]):
print('using addr ' + str(YOLO_HLS_ADDRESS))
data = {"image": img_arr}
if roi:
print "Make sure roi is a list in this order [x1, y1, x2, y2]"
data["roi"] = roi
serialized_data = msgpack.dumps(data)
# resp = requests.post(YOLO_HLS_ADDRESS, data=data)
resp = requests.post(YOLO_HLS_ADDRESS, data=serialized_data)
print('resp from hls:' + str(resp))
# print('respcont from hls:'+str(resp.content))
return msgpack.loads(resp.content)
def on_put(self, req, resp):
ret = {"success": False}
try:
data = msgpack.loads(req.stream.read())
collection_name = data.get("collection")
category = data.get("category")
rebuild_index(collection_name, category)
ret["success"] = True
except Exception as e:
ret["error"] = str(e)
resp.data = msgpack.dumps(ret)
resp.content_type = 'application/x-msgpack'
resp.status = falcon.HTTP_200
def on_post(self, req, resp):
ret = {"success": False}
try:
data = msgpack.loads(req.stream.read())
ret["data"] = self.feature.execute(**data)
ret["success"] = True
resp.status = falcon.HTTP_200
except Exception as e:
ret["error"] = str(e)
ret["trace"] = traceback.format_exc()
resp.data = msgpack.dumps(ret)
resp.content_type = 'application/x-msgpack'
def test_class_variable(self):
class ClassVariableObject(jaweson.Serialisable):
__classname = 'TestImHere'
a = 1
obj = ClassVariableObject()
mobj = msgpack.loads(msgpack.dumps(obj))
jobj = json.loads(json.dumps(obj))
assert obj.a == 1
assert obj.a == mobj.a
assert obj.a == jobj.a
assert '_Serialisable__a' not in json.dumps(obj)
def on_post(self, req, resp):
ret = {"success": False}
try:
data = msgpack.loads(req.stream.read())
collection = data.get("collection")
category = data.get("category")
fp = data.get("fp")
port = lookup_table[collection][category]['port']
print(port)
ret = nmslib_find_top_k(fp, 1000, port, category)
print('done')
except Exception as e:
ret["error"] = str(e)
resp.data = msgpack.dumps(ret)
resp.content_type = 'application/x-msgpack'
resp.status = falcon.HTTP_200
def test_dodgy_constructor(self):
class DodgyConstructor(jaweson.Serialisable):
def __init__(self, a, b):
# flip the order
self.a = b
self.b = a
obj = DodgyConstructor(1, 2)
mobj = msgpack.loads(msgpack.dumps(obj))
jobj = json.loads(json.dumps(obj))
assert obj.a == 2
assert obj.b == 1
assert obj.a == mobj.a
assert obj.b == mobj.b
assert obj.a == jobj.a
assert obj.b == jobj.b
def test_modified_class_variable(self):
class ClassVariableOverrideObject(jaweson.Serialisable):
a = 1
def __init__(self):
self.a = 2
obj = ClassVariableOverrideObject()
mobj = msgpack.loads(msgpack.dumps(obj))
jobj = json.loads(json.dumps(obj))
assert obj.a == 2
assert obj.a == mobj.a
assert obj.a == jobj.a
assert '_Serialisable__a' not in json.dumps(obj)
assert 'a' in json.dumps(obj)
def on_post(self, req, resp):
ret = {"success": False}
try:
data = msgpack.loads(req.stream.read())
image = data.get("image_or_url")
face = data.get("face")
print('gender_app nEURALrESOURCE got face {}'.format(face))
ret["gender"] = new_genderDetector.theDetector(image, face)
if ret["gender"] is not None:
ret["success"] = True
else:
ret["error"] = "NN returned None, FACE=" + str(face)
ret["face"] = face
except Exception as e:
ret["error"] = str(e)
resp.data = msgpack.dumps(ret)
resp.content_type = 'application/x-msgpack'
resp.status = falcon.HTTP_200
def on_post(self, req, resp):
# print('got POST')
ret = {"success": False}
try:
# print(req.stream.read())
data = msgpack.loads(req.stream.read())
print(1)
fp = data.get("fp")
print(2)
k = data.get("k")
print(3)
ret["data"] = load_n_search.find_to_k(fp, k, self.nmslib_vector,
self.index)
ret["success"] = True
except Exception as e:
ret["error"] = str(e)
print(ret['success'])
# resp.data = msgpack.dumps(ret)
resp.content_type = 'application/x-msgpack'
resp.status = falcon.HTTP_200
def test_hierarchy(self):
class Node(jaweson.Serialisable):
def __init__(self, name, child=None):
self.name = name
self.child = child
obj = Node(1, Node(2, Node(3)))
mobj = msgpack.loads(msgpack.dumps(obj))
jobj = json.loads(json.dumps(obj))
assert obj.name == 1
assert obj.child.name == 2
assert obj.child.child.name == 3
assert isinstance(obj, Node)
assert obj.name == mobj.name
assert obj.child.name == mobj.child.name
assert obj.child.child.name == mobj.child.child.name
assert obj.name == jobj.name
assert obj.child.name == jobj.child.name
assert obj.child.child.name == jobj.child.child.name
def on_post(self, req, resp):
ret = {"success": False}
try:
data = msgpack.loads(req.stream.read())
img = data.get("image")
# mask_np, label_dict, pose_np, filename
ret["mask"], ret["label_dict"], ret["pose"], ret[
"filename"] = new_pd.parse(img, _eng=eng)
if ret["mask"] is not None:
ret["success"] = True
else:
ret["error"] = "No mask from PD"
except Exception as e:
ret["error"] = str(e)
resp.data = msgpack.dumps(ret)
resp.content_type = 'application/x-msgpack'
resp.status = falcon.HTTP_200
def on_post(self, req, resp):
print "Reached on_post"
gpu = req.get_param('gpu')
ret = {"success": False}
try:
data = msgpack.loads(req.stream.read())
img = data.get("image")
output = multilabel_from_binaries3.get_multiple_single_label_outputs(img)
ret["output"] = output
if ret["output"] is not None:
ret["success"] = True
else:
ret["error"] = "No output from mlb"
except Exception as e:
traceback.print_exc()
ret["error"] = traceback.format_exc()
resp.data = msgpack.dumps(ret)
resp.content_type = 'application/x-msgpack'
resp.status = falcon.HTTP_200
def test_custom_serialiser(self):
class CustomSerialiserObject(jaweson.Serialisable):
@classmethod
def to_json(cls, obj):
return {'c': obj.a, 'd': obj.b}
@classmethod
def from_json(cls, obj):
return cls(int(obj['c']), int(obj['d']))
def __init__(self, a, b):
self.a = a
self.b = b
obj = CustomSerialiserObject(1, 2)
mobj = msgpack.loads(msgpack.dumps(obj))
jobj = json.loads(json.dumps(obj))
assert obj.a == 1
assert obj.b == 2
assert obj.a == mobj.a
assert obj.b == mobj.b
assert obj.a == jobj.a
assert obj.b == jobj.b
def get_length(image_or_url):
data = msgpack.dumps({"image_or_url": image_or_url})
resp = requests.post(CLASSIFIER_ADDRESS, data=data)
return msgpack.loads(resp.content)
def genderize(image_or_url, face):
data = msgpack.dumps({"image_or_url": image_or_url, "face": face})
resp = requests.post(GENDER_ADDRESS, data)
return msgpack.loads(resp.content)
#this is doing a post, which the javascript is doing , so I don't think
#we need this file at all...
from jaweson import msgpack
import requests
#
CLASSIFIER_ADDRESS = "http://169.45.147.210:8083/pixlevel_annotator"
#thats brainim60
params = {}
if params == {}:
params = None #not sure if this is necesary but the original line (below) made it happen
#params = params={"categoryIndex": category_index} if category_index else None
print('params coming into mlb:'+str(params))
#print('image coming into mlb:'+str(image_array_or_url))
data = msgpack.dumps({"image": image_array_or_url})
resp = requests.post(CLASSIFIER_ADDRESS, data=data, params=params)
return msgpack.loads(resp.content)
def get(feature, image_or_url, **kwargs):
kwargs.update({"image_or_url": image_or_url})
data = msgpack.dumps(kwargs)
resp = requests.post(DEPLOYMENTS[feature]["url"], data=data)
return msgpack.loads(resp.content)
def on_post(self, req, resp):
print "Reached on_post"
ret = {"success": False}
# Query Params
threshold = req.get_param('threshold')
get_multilabel_results = req.get_param_as_bool('getMultilabelResults')
get_combined_results = req.get_param_as_bool('getCombinedResults')
image_url = req.get_param('imageUrl')
try:
if image_url:
img = image_url # Utils.get_cv2_img_array(image_url)
else:
data = msgpack.loads(req.stream.read())
img = data.get("image")
# multilabel alone
if get_multilabel_results:
multilabel_output = neurodoll.get_multilabel_output(img)
ret['multilabel_output'] = multilabel_output
print('multilabel output:' + str(multilabel_output))
if multilabel_output is not None:
ret["success"] = True
# ret["success"] = bool(multilabel_output)
# combined multilabel and nd
if get_combined_results:
combined_output = None
combined_output = neurodoll.combine_neurodoll_v3labels_and_multilabel(
img)
ret['combined_output'] = combined_output
ret['mask'] = combined_output
if combined_output is not None:
ret["bbs"] = imutils.mask_to_rects(ret['mask'])
ret["success"] = True
# yonti style - single category mask
ret["label_dict"] = constants.ultimate_21_dict
# regular neurodoll call
if not get_multilabel_results and not get_combined_results and not category_index:
print "No special params, inferring..."
ret["mask"], labels = neurodoll.infer_one(img)
if ret["mask"] is not None:
ret["success"] = True
ret["bbs"] = imutils.mask_to_rects(ret["mask"])
else:
ret["error"] = "No mask from ND"
except Exception as e:
traceback.print_exc()
ret["error"] = traceback.format_exc()
url = req.get_param('image')
ret['url'] = url
resp.data = msgpack.dumps(ret)
resp.content_type = 'application/x-msgpack'
resp.status = falcon.HTTP_200
return (ret)
def get_sleeve(image_or_url):
data = msgpack.dumps({"function": "execute", "image_or_url": image_or_url})
resp = requests.post(CLASSIFIER_ADDRESS, data=data)
return msgpack.loads(resp.content)
def nmslib_find_top_k(fp, k, port, category):
data = msgpack.dumps({"fp": fp, "k": k})
category_server = SERVER + str(port) + '/' + category
resp = requests.post(category_server, data=data)
return msgpack.loads(resp.content)
def pd(fp, col_name, category):
params = {"category": category,
"col_name" : col_name}
data = msgpack.dumps({"fingerprint": fp})
resp = requests.post(CLASSIFIER_ADDRESS, data=data, params=params)
return msgpack.loads(resp.content)
def deserialize(msg):
enc_np = msgpack.loads(msg)
return cv2.imdecode(enc_np, cv2.IMREAD_COLOR)
return msgpack.dumps(enc_np)
def deserialize(msg):
enc_np = msgpack.loads(msg)
return cv2.imdecode(enc_np, cv2.IMREAD_COLOR)
arr_cv2 = url_to_np_array(
"http://fazz.co/src/img/demo/gettyimages-492504614.jpg")
f, enc_jpg_np = cv2.imencode('.jpg', arr_cv2, [cv2.IMWRITE_JPEG_QUALITY, 100])
f, enc_png_np = cv2.imencode('.png', arr_cv2, [cv2.IMWRITE_PNG_COMPRESSION, 9])
start = time.time()
msg = msgpack.dumps(arr_cv2)
arr = msgpack.loads(msg)
print time.time() - start
start = time.time()
msg = msgpack.dumps(
cv2.imencode('.png', arr_cv2, [cv2.IMWRITE_PNG_COMPRESSION, 9])[1])
arr = cv2.imdecode(msgpack.loads(msg), cv2.IMREAD_COLOR)
print time.time() - start
def data_uri_to_cv2_img(uri):
encoded_data = uri.split(',')[1]
nparr = np.fromstring(encoded_data.decode('base64'), np.uint8)
img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
return img
