def to_libpressio(x):
op = None
if isinstance(value, np.ndarray):
value_lp = pressio.io_data_from_numpy(value)
op = pressio.option_new_data(value_lp)
pressio.data_free(value_lp)
elif isinstance(value, list):
if value:
# list is non-empty
if isinstance(value[0], str):
op = pressio.option_new_strings(
pressio.vector_string([i.encode() for i in value]))
elif isinstance(value[0], int) or isinstance(value[0], float):
arr = np.array(value)
lp = pressio.io_data_from_numpy(arr)
op = pressio.option_new_data(lp)
pressio.data_free(lp)
else:
raise TypeError("unexpected list type: " + value)
else:
# list is empty
op = pressio.option_new_strings(pressio.vector_string())
elif isinstance(value, float):
op = pressio.option_new_double(value)
elif isinstance(value, str):
op = pressio.option_new_string(value.encode())
elif isinstance(value, bytes):
op = pressio.option_new_string(value)
elif isinstance(value, int):
op = pressio.option_new_integer64(value)
else:
raise TypeError("Unsupported type " + str(type(value)))
return op
def decode(self, compressed, decompressed=None):
"""perform decompression
params:
compressed: bytes - the data to be decompressed
decompressed: numpy.ndarray - memory to be used to decompress data into
"""
compressed_lp = None
decompressed_lp = None
try:
compressed_lp = pressio.io_data_from_bytes(compressed)
decompressed_lp = pressio.io_data_from_numpy(decompressed)
rc = pressio.compressor_decompress(self._compressor, compressed_lp,
decompressed_lp)
if rc:
raise PressioException.from_compressor(self._compressor)
dec = pressio.io_data_to_numpy(decompressed_lp)
if decompressed is not None:
return dec
else:
return ndarray_copy(dec, decompressed)
finally:
pressio.data_free(compressed_lp)
pressio.data_free(decompressed_lp)
def _from_data_option(x):
lp = pressio.option_get_data(x)
if pressio.data_dtype(lp) == pressio.byte_dtype:
ret = pressio.io_data_to_bytes(lp)
else:
ret = pressio.io_data_to_numpy(lp)
pressio.data_free(lp)
return ret
def convert_back_and_forth(nd_array):
try:
p_data = pressio.io_data_from_numpy(nd_array)
n_data = pressio.io_data_to_numpy(p_data)
pressio.data_free(p_data)
assert np.array_equal(nd_array, n_data), f"FAILED nd_array size={nd_array.shape}, dtype={nd_array.dtype}"
except (AssertionError,TypeError) as e:
print(e)
global FAILED
FAILED += 1
else:
global PASSED
PASSED += 1
def write(self, output):
"""reads a data buffer to a file
params:
output: np.ndarray - the file to be written
"""
try:
out = pressio.io_data_from_numpy(output)
ret = pressio.io_write(self._io, out)
if ret:
raise PressioException.from_io(self._io)
return ret
finally:
pressio.data_free(out)
def read(self, template=None):
"""reads a data buffer from a file
params:
template: Optional[np.ndarray] - a input template if one is provided
"""
if template is not None:
template = pressio.io_data_from_numpy(template)
ret_lp = pressio.io_read(self._io, template)
if not ret_lp:
raise PressioException.from_io(self._io)
ret = pressio.io_data_to_numpy(ret_lp)
pressio.data_free(ret_lp)
return ret
def encode(self, uncompressed):
"""perform compression
params:
uncompressed: np.ndarray - the data to be compressed
"""
uncompressed_lp = None
compressed_lp = None
try:
uncompressed_lp = pressio.io_data_from_numpy(uncompressed)
compressed_lp = pressio.data_new_empty(pressio.byte_dtype,
pressio.vector_uint64_t())
rc = pressio.compressor_compress(self._compressor, uncompressed_lp,
compressed_lp)
if rc:
raise PressioException.from_compressor(self._compressor)
comp = pressio.io_data_to_bytes(compressed_lp)
finally:
pressio.data_free(uncompressed_lp)
pressio.data_free(compressed_lp)
return comp
def evaluate(self, input=None, compressed=None, output=None):
results_lp = None
try:
input_lp = input if input is None else pressio.io_data_from_numpy(
input)
compressed_lp = compressed if compressed is None else pressio.io_data_from_bytes(
compressed)
output_lp = output if output is None else pressio.io_data_from_numpy(
output)
results_lp = pressio.metrics_evaluate(self._metric, input_lp,
compressed_lp, output_lp)
return _pressio_to_python(results_lp)
finally:
if input_lp is not None:
pressio.data_free(input_lp)
if output_lp is not None:
pressio.data_free(output_lp)
if compressed_lp is not None:
pressio.data_free(compressed_lp)
if results_lp is not None:
pressio.options_free(results_lp)
