def export_compare(self, o, wl=None, wxf=None, **kwargs): if wl: res = export(o, target_format="wl", **kwargs) self.assertEqual(res, wl) if wxf: res = export(o, target_format="wxf", **kwargs) self.assertEqual(res, wxf)
def test_serialization_custom(self): class MyStuff(object): def __init__(self, *stuff): self.stuff = stuff def normalizer(o): if isinstance(o, six.integer_types): return 'o' if isinstance(o, MyStuff): return wl.RandomThings(*o.stuff) return o expr = [1, 2, 'a', {1: "a"}, MyStuff(1, 2, MyStuff(1, 'a'))] normalized = [ "o", "o", "a", { "o": "a" }, wl.RandomThings("o", "o", wl.RandomThings("o", "a")) ] for export_format in available_formats: with self.assertRaises(NotImplementedError) as context: export(expr, normalizer=identity, target_format=export_format) self.assertEqual( export(expr, normalizer=normalizer, target_format=export_format), export(normalized, normalizer=identity, target_format=export_format), )
def report(self): path = tempfile.gettempdir() benchmarks = [(c, self.expression_handler(c)) for c in self.complexity] self.table_line("dumping results in %s" % path) self.table_line() # running export to do all lazy loadings binary_deserialize(export(1, target_format="wxf")) self.table_line("* Binary deserialize") self.table_line() self.table_line( "Memory", *(force_text(c).ljust(self.col_size) for c in self.complexity)) self.table_divider(len(self.complexity) + 1) for label, opts in (("wxf", dict()), ("wxf zip", dict(compress=True))): self.table_line( label, *(self.formatted_time( binary_deserialize, export(expr, target_format="wxf", **opts)) for complexity, expr in benchmarks)) self.table_line() self.table_line("* Export") self.table_line() for title, stream_generator in self.stream_generators(path): self.table_line( title, *(force_text(c).ljust(self.col_size) for c in self.complexity)) self.table_divider(len(self.complexity) + 1) for key in ("expr", "array"): for label, export_format, opts in ( ("wl", "wl", dict()), ("wxf", "wxf", dict()), ("wxf zip", "wxf", dict(compress=True)), ): if key == "expr" or (key == "array" and not label == "wl"): self.table_line( key == "expr" and label or "%s %s" % (label, key), *(self.formatted_time(export, expr[key], stream=stream_generator( complexity, export_format), target_format=export_format, **opts) for complexity, expr in benchmarks)) self.table_line()
def pth2wxf(path): pth = torch.load(path, map_location=torch.device('cpu')) npy = { key: value.numpy() for key, value in pth.items() if not re.match('.*_tracked$', key) } wxf.export(npy, path + '.wxf', target_format='wxf')
def edge_model(dataset): data = torch.load('checkpoints/' + dataset + '/EdgeModel_gen.pth', map_location='cpu') npy = {key: value.numpy() for key, value in data['generator'].items()} wxf.export(npy, 'EdgeModel_' + dataset + '.wxf', target_format='wxf') generator = EdgeGenerator() generator.load_state_dict(data['generator']) torch.save(generator, 'EdgeModel_' + dataset + '.pth')
def caffe2wxf(path): model = opencv.readNetFromCaffe(path + ".prototxt", path + ".caffemodel") layers = model.getLayerNames() npy = {} for i in layers: try: npy[i] = model.getParam(i) except Exception: pass wxf.export(npy, path + '.wxf', target_format='wxf')
def pkl2wxf(path): file = open(path, 'rb') objs = [] while True: try: objs.append(pkl.load(file)) except EOFError: break file.close() print(objs) wxf.export(objs, path + '.wxf', target_format='wxf')
def report(self): path = tempfile.gettempdir() benchmarks = [(c, self.complexity_handler(c)) for c in self.complexity] self.print("dumping results in", path) # running export to do all lazy loadings export(1) for title, stream_generator in ( ("Memory", lambda complexity: None), ( "File", lambda complexity: os.path.join( path, "benchmark-test-%s.%s" % (force_text(complexity).zfill(7), export_format), ), ), ): self.table_line( title, *(force_text(c).ljust(self.col_size) for c in self.complexity) ) self.table_divider(len(self.complexity) + 1) for label, export_format, opts in ( ("wl", "wl", dict()), ("wxf", "wxf", dict()), ("wxf zip", "wxf", dict(compress=True)), ): self.table_line( label, *( self.formatted_time( expr, stream=stream_generator(complexity), target_format=export_format, **opts ) for complexity, expr in benchmarks ) ) self.table_line() self.table_line()
def _encode_inputs_as_wxf(inputs, multipart, **kwargs): for name, value in inputs.items(): yield "%s__wxf" % name, _to_multipart(name, export(value, target_format="wxf", **kwargs), multipart=multipart)
def test_register_twice_force(self): @wolfram_encoder.dispatch(subsubfoo, replace_existing=True) def encode_subsubfoo_again(s, o): return s.serialize_symbol("subsubfooFORCE") wl = export(subsubfoo()) self.assertEqual(wl, b"subsubfooFORCE")
def _call_evaluation_api(self, expr, **kwargs): data = export(expr, target_format="wl", **kwargs) if logger.isEnabledFor(logging.DEBUG): logger.debug( "Sending expression to cloud server for evaluation: %s", data) response = self._post(self.evaluation_api_url, body=data) return WolframCloudEvaluationWXFResponse(response)
def _encode_inputs_as_wl(form_data, inputs, **kwargs): for name, value in inputs.items(): # avoid double encoding of strings '\"string\"'. if isinstance(value, six.string_types): form_data.add_field(name, value) else: form_data.add_field(name, export(value, target_format="wl", **kwargs))
async def _call_evaluation_api(self, expr, **kwargs): data = aiohttp.BytesPayload(export(expr, target_format="wl", **kwargs)) if logger.isEnabledFor(logging.DEBUG): logger.debug( "Sending expression to cloud server for evaluation: %s", data) response = await self._post(self.evaluation_api_url, data=data) return WolframEvaluationWXFResponseAsync(response)
def do_evaluate_future(self, expr, result_update_callback=None, **kwargs): future = futures.Future() wxf = export(self.normalize_input(expr), target_format="wxf", **kwargs) self.kernel_controller.evaluate_future( wxf, future, result_update_callback=result_update_callback, **kwargs ) return future
def test_png_mode_I(self): with PIL.open(path_to_file_in_data_dir('5x2.png')) as image: self.assertEqual( export(image, target_format='wl'), b'ImportByteArray[ByteArray["iVBORw0KGgoAAAANSUhEUgAAAAUAAAACEAAAAADlkZXCAAAAH0lEQVR4nGP0+P39rf6+ky9/R7Aoen2+9shDWSRCHwCO7ws73c3PRQAAAABJRU5ErkJggg=="], "PNG"]' )
def test_bad_incomplete_consumer(self): with self.assertRaises(WolframParserException) as e: binary_deserialize(export([1, 2, 3], target_format="wxf"), consumer=self.BadIncompleteConsumer()) self.assertEqual( e.msg, "Input data does not represent a valid expression in WXF format. Some expressions are imcomplete.", )
def test_bad_greedy_consumer(self): with self.assertRaises(WolframParserException) as e: binary_deserialize(export([1, 2, 3], target_format="wxf"), consumer=self.BadGreedyConsumer()) self.assertEqual( e.msg, "Input data does not represent a valid expression in WXF format. Expecting more input data.", )
def test_export(self): for value in ( 1, 2, "aaaa", 2.0, { 1: 2 }, [1, 2, 3], ["hello", decimal.Decimal("1.23")], wl.Foo, wl.Foo(2, wl.Context.Internal), ): self.serialize_compare(value, export(value, target_format="wxf")) self.assertEqual( export(Association(enumerate("abc")), target_format="wxf"), export( wl.Association(*(wl.Rule(i, v) for i, v in enumerate("abc"))), target_format="wxf", ), ) self.assertEqual( export(wlexpr("2+2"), target_format="wxf"), export(wl.ToExpression("2+2"), target_format="wxf"), ) self.assertEqual( export(wl.Foo(wlexpr("2+2"), 1, 2), target_format="wxf"), export(wl.Foo(wl.ToExpression("2+2"), 1, 2), target_format="wxf"), )
def caffe2wxf(path): data = dict() model = caffe.NetParameter() model.ParseFromString(open(path, 'rb').read()) get_array = lambda p: npy.array(p.data, dtype='float32').reshape(p.shape. dim) def add_array(node): for i in range(len(node.blobs)): data[node.name + "_" + str(i + 1)] = get_array(node.blobs[i]) def add_node(layers): for i in range(len(layers)): add_array(layers[i]) add_node(model.layer) wxf.export(data, path + '.wxf', target_format='wxf')
def handle(self, format, **opts): data = self.create_data(**opts) if format: self.print(export(dict(data), target_format=format)) else: for k, v in data: if isinstance(v, float): v = "%.4f" % v self.table_line(k, v)
def test_mode_L(self): a = numpy.arange(10).reshape((2, 5)) img = PIL.fromarray(a, mode='L') out = export(img, target_format='wl') self.assertTrue( out == b'Image[BinaryDeserialize[ByteArray["ODrCEAICBQAAAAAAAAAAAQA="]], "Byte", Rule[ColorSpace, "Grayscale"], Rule[Interleaving, True]]' or out == b'Image[BinaryDeserialize[ByteArray["ODrCEAICBQAAAAAAAAAAAQA="]], "Byte", Rule[Interleaving, True], Rule[ColorSpace, "Grayscale"]]' )
def compare_serializer(self, serializer, array, value, test_export_wxf=False): serializer.serialize(array) self.assertEqual(serializer._writer.getvalue(), value) if test_export_wxf: self.assertEqual(export(array, target_format="wxf"), value)
def _encode_inputs_as_wl(inputs, multipart, **kwargs): for name, value in inputs.items(): # avoid double encoding of strings '\"string\"'. if isinstance(value, six.string_types): yield name, _to_multipart(name, value, multipart=multipart) else: yield name, _to_multipart( name, export(value, target_format='wl', **kwargs), multipart=multipart)
def test_generators(self): array = NumericArray((i for i in range(10)), "Integer8", shape=(10, )) self.assertEqual( export(numpy.arange(10).astype(numpy.int8), target_format="wxf"), export(array, target_format="wxf"), ) self.assertEqual(len(array), 10) array = NumericArray((i for i in range(10)), "Integer8", shape=(5, 2)) self.assertEqual( export(numpy.arange(10).astype(numpy.int8).reshape(5, 2), target_format="wxf"), export(array, target_format="wxf"), ) self.assertEqual(len(array), 10)
def test_bool_img(self): a = numpy.array([[1, 0], [0, 1]], dtype='bool') img = PIL.fromarray(a) out = export(img, target_format='wl') self.assertTrue( out == b'Image[BinaryDeserialize[ByteArray["ODrCEAICAgEAAAA="]], "Bit", Rule[ColorSpace, Automatic], Rule[Interleaving, True]]' or out == b'Image[BinaryDeserialize[ByteArray["ODrCEAICAgEAAAA="]], "Bit", Rule[Interleaving, True], Rule[ColorSpace, Automatic]]' )
def process_generate_httpresponse_expression(response): if isinstance(response, dict): if not response.get("BodyByteArray", None): # empty byte array is returning a an empty list, we need an empty byte array response["BodyByteArray"] = b"" return response return { "BodyByteArray": export(response, target_format="wl"), "Headers": (wl.Rule("content-type", "text/plain;charset=utf-8"), ), "StatusCode": 500, }
def test_python_array(self): for array, numpy_type, wl_type in ( ([True, False, True, False, True, False], numpy.int8, "Integer8"), ([1, 2, 3, 4, 5, 6], numpy.int8, "Integer8"), ([1, 2, 3, 4, 5, 6], numpy.int32, "Integer32"), ([1, 2, 3, 4, 5, 6], numpy.int64, "Integer64"), ([1.2, 2.3, 3, 4, 5, 6], numpy.float32, "Real32"), ([1.2, 2.3, 3, 4, 5, 6], numpy.float64, "Real64"), ): for shape in ((3, 2), None): arr = numpy.array(array, numpy_type) if shape: arr = arr.reshape(shape) self.assertEqual( export(arr, target_format="wxf"), export(NumericArray(array, wl_type, shape=shape), target_format="wxf"), )
def test_numpy_integers(self): int8 = [numpy.int8(127), numpy.int8(-128)] self.assertEqual(export(int8), b"{127, -128}") uint8 = [numpy.uint8(0), numpy.uint8(255)] self.assertEqual(export(uint8), b"{0, 255}") int16 = [numpy.int16(32767), numpy.int16(-32768)] self.assertEqual(export(int16), b"{32767, -32768}") ints = [ numpy.uint16(65535), numpy.int32(-2147483648), numpy.uint32(4294967296), numpy.int64(-9223372036854775808), numpy.uint64(18446744073709551615), ] self.assertEqual( export(ints), b"{65535, -2147483648, 0, -9223372036854775808, 18446744073709551615}", )
def test_export_with_encoder(self): #very similar code is used by safe_wl_execute, we need to make sure that we can pass the builtin encoder and a very simple #data dump and the code keeps working self.assertEqual( export( wl.Failure("PythonFailure", {'MessageTemplate': ['baz', ('bar', 'bad')]}), target_format='wl', encoder='wolframclient.serializers.encoders.builtin.encoder'), b'Failure["PythonFailure", <|"MessageTemplate" -> {"baz", {"bar", "bad"}}|>]' )
def test_export(self): # checking that export is able to return bytes if no second argument is provided self.assertEqual(export(2), b"2") self.assertEqual(export("foo"), b'"foo"') fd, path = tempfile.mkstemp() # close the file descriptor but keep the path. Prevent error on Windows. os.close(fd) for test in ["foo", wl.Symbol, {"a": [1, 2, 3], 2: 2}]: for export_format in available_formats: expected = export(test, target_format=export_format) # checking that export is able to write to a path if a string is provided export(test, path, target_format=export_format) with open(path, "rb") as stream: self.assertEqual(stream.read(), expected) # checking that export is writing to a byteio stream = six.BytesIO() export(test, stream, target_format=export_format) stream.seek(0) self.assertEqual(stream.read(), expected) # checking that export is able to write to a filelike object with open(path, "wb") as stream: export(test, stream, target_format=export_format) with open(path, "rb") as stream: self.assertEqual(stream.read(), expected) os.remove(path)