def create_image_from_socket(self, msg): """ Create an image from data received on the socket. This callback function is called when data is ready on the IPC channel. It creates the image data array from the raw data sent by the Odin Data Plugin, reshaping it to a multi dimensional array matching the image dimensions. :param msg: a multipart message containing the image header, and raw image data. """ # Message should be a list from multi part message. # First part will be the json header from the live view, second part is the raw image data header = json_decode(msg[0]) # json_decode returns dictionary encoded in unicode. Convert to normal strings if necessary. header = convert_unicode_to_string(header) logging.debug("Got image with header: %s", header) # Extract the type of the image data from the header. If the type is float, coerce to # float32 since the native float in HDF5 is 32-bit vs 64-bit in python and numpy. dtype = header['dtype'] if dtype == 'float': dtype = 'float32' # create a np array of the image data, of type specified in the frame header img_data = np.fromstring(msg[1], dtype=np.dtype(dtype)) self.img_data = img_data.reshape([int(header["shape"][0]), int(header["shape"][1])]) self.header = header self.rendered_image = self.render_image( self.selected_colormap, self.clip_min, self.clip_max)
def put(self, path, request): """Handle an HTTP PUT request. This method handles an HTTP PUT request, returning a JSON response. :param path: URI path of request :param request: HTTP request object :return: an ApiAdapterResponse object containing the appropriate response """ content_type = 'application/json' try: data = convert_unicode_to_string(decode_request_body(request)) self.qem_detector.set(path, data) response = self.qem_detector.get(path) status_code = 200 except QemDetectorError as e: response = {'error': str(e)} status_code = 400 except (TypeError, ValueError) as e: response = { 'error': 'Failed to decode PUT request body: {}'.format(str(e)) } status_code = 400 logging.debug(response) return ApiAdapterResponse(response, content_type=content_type, status_code=status_code)
def test_convert_unicode_to_string_mixed_recursion(self): u_object = {u'string': u'test string', u'list': [u'unicode string', "normal string"] } result = util.convert_unicode_to_string(u_object) expected_result = { 'string': 'test string', 'list': ['unicode string', "normal string"] } assert_equal(result, expected_result)
def test_convert_unicode_to_string_mixed_recursion(self): """Test recursion through a deeper object with mixed types.""" u_object = {u'string': u'test string', u'list': [u'unicode string', "normal string"] } result = util.convert_unicode_to_string(u_object) expected_result = { 'string': 'test string', 'list': ['unicode string', "normal string"] } assert result == expected_result
def put(self, path, request): """ Handle an HTTP PUT request. This method handles an HTTP PUT request, returning a JSON response. :param path: URI path of request :param request: HTTP request object :return: an ApiAdapterResponse object with the appropriate response """ content_type = 'application/json' status_code = 200 response = {} checkAdapters = True if len(path) > 0 else False requestSent = False try: if checkAdapters: for name, adapter in self.adapters.items(): if path.startswith(name): relative_path = path.split(name + '/') reply = adapter.put(path=relative_path[1], request=request) requestSent = True if reply.status_code != 200: status_code = reply.status_code response = reply.data logging.debug(response) return ApiAdapterResponse( response, content_type=content_type, status_code=status_code) # Only pass request to Hexitec member if no matching adapter found if requestSent is False: data = convert_unicode_to_string(decode_request_body(request)) self.hexitec.set(path, data) response = self.hexitec.get(path) except HexitecError as e: response = {'error': str(e)} status_code = 400 except (TypeError, ValueError) as e: response = { 'error': 'Failed to decode PUT request body: {}'.format(str(e)) } status_code = 400 logging.debug(response) return ApiAdapterResponse(response, content_type=content_type, status_code=status_code)
async def test_adapter_put_proxy_path(self, async_proxy_adapter_test): """ Test that a PUT to a sub-path without a trailing slash in the URL within a targer succeeds and returns the correct data. """ node = async_proxy_adapter_test.adapter.targets[0].name path = "more" async_proxy_adapter_test.request.body = '{"replace": "been replaced"}' response = await async_proxy_adapter_test.adapter.put( "{}/{}".format(node, path), async_proxy_adapter_test.request) assert async_proxy_adapter_test.adapter.param_tree.get('')['status'][node]['status_code'] == 200 assert convert_unicode_to_string(response.data["more"]["replace"]) == "been replaced"
def put(self, path): """Handle PUT requests to the test server.""" response_body = convert_unicode_to_string(tornado.escape.json_decode(self.request.body)) try: self.param_tree.set(path, response_body) data_ref = self.param_tree.get(path) self.write(data_ref) except ParameterTreeError: self.set_status(404) self.write_error(404) except Exception as other_e: logging.error("ProxyTestHandler PUT failed: %s", str(other_e)) self.write_error(500)
async def test_adapter_put(self, async_proxy_adapter_test): """ Test that a PUT request to the proxy adapter returns the appropriate data for all defined proxied targets. """ response = await async_proxy_adapter_test.adapter.put( async_proxy_adapter_test.path, async_proxy_adapter_test.request) assert 'status' in response.data assert len(response.data) == async_proxy_adapter_test.num_targets + 1 for tgt in range(async_proxy_adapter_test.num_targets): node_str = 'node_{}'.format(tgt) assert node_str in response.data assert convert_unicode_to_string(response.data[node_str]) == ProxyTestHandler.param_tree.get("")
def test_convert_unicode_to_string_dict(self): """Test conversion of a unicode dict to native string dict.""" u_dict = {u'key': u'value'} result = util.convert_unicode_to_string(u_dict) assert result == {"key": "value"}
def test_convert_unicode_to_string_list(self): """Test conversion of a list of unicode strings to strings.""" u_list = [u'first string', u'second string'] result = util.convert_unicode_to_string(u_list) assert result == ["first string", "second string"]
def test_convert_unicode_to_string(self): """Test conversion of unicode to string.""" u_string = u'test string' result = util.convert_unicode_to_string(u_string) assert result == "test string"
def test_convert_unicode_to_string_dict(self): u_dict = {u'key': u'value'} result = util.convert_unicode_to_string(u_dict) assert_equal(result, {"key": "value"})
def test_convert_unicode_to_string_list(self): u_list = [u'first string', u'second string'] result = util.convert_unicode_to_string(u_list) assert_equal(result, ["first string", "second string"])
def test_convert_unicode_to_string(self): u_string = u'test string' result = util.convert_unicode_to_string(u_string) assert_equal(result, "test string")