def test_DmapRead_DmapWrite_stream_dmap(self):
"""
Test DmapRead and DmapWrite to read in a stream and write to a stream
to be read in again and compared.
"""
with bz2.open(rawacf_stream) as fp:
dmap_stream = fp.read()
dmap = pydarnio.DmapRead(dmap_stream, True)
stream_data = dmap.read_records()
dmap_write = pydarnio.DmapWrite()
dmap_write_stream = dmap_write.write_dmap_stream(stream_data)
dmap_read = pydarnio.DmapRead(dmap_write_stream, True)
dmap_read_data = dmap_read.read_records()
self.dmap_compare(stream_data, dmap_read_data)
def test_DmapWrite_DmapRead_dmap2dict(self):
"""
Test DmapWrite writing a dmap data set to be read in by DmapRead
and convert to a dictionary by dmap2dict and compared.
"""
dmap_dict = [{
'RST.version': '4.1',
'stid': 3,
'FAC.vel': np.array([2.5, 3.5, 4.0], dtype=np.float32)
}, {
'RST.version': '4.1',
'stid': 3,
'FAC.vel': np.array([1, 0, 1], dtype=np.int8)
}, {
'RST.version': '4.1',
'stid': 3,
'FAC.vel': np.array([5.7, 2.34, -0.2], dtype=np.float32)
}]
dmap_data = copy.deepcopy(dmap_data_sets.dmap_data)
dmap_write = pydarnio.DmapWrite(dmap_data)
dmap_stream = dmap_write.write_dmap_stream()
dmap_read = pydarnio.DmapRead(dmap_stream, True)
dmap_records = dmap_read.read_records()
dmap_records = dmap_read.get_dmap_records
self.dmap_compare(dmap_records, dmap_data)
dmap_dict2 = pydarnio.dmap2dict(dmap_records)
self.dict_compare(dmap_dict, dmap_dict2)
def test_DmapWrite_DmapRead_dict2dmap_dict2dmap(self):
"""
Test Convert dictionary to dmap from dict2dmap then
write with DmapWrite to be read in with DmapRead and
converted back to a dictionary with dmap2dict.
"""
dmap_dict = [{
'stid':
56,
'channel':
0,
'software':
'RST',
'xcf':
np.array([2.5, 3.456, 34.56, -4.5], dtype=np.float32),
'gflg':
np.array([1, 0, 4, 2], np.int8)
}]
dmap_records = pydarnio.dict2dmap(dmap_dict)
dmap_write = pydarnio.DmapWrite(dmap_records, 'test_dmap.dmap')
dmap_write.write_dmap()
dmap_read = pydarnio.DmapRead("test_dmap.dmap")
records = dmap_read.read_records()
self.dmap_compare(dmap_dict, records)
dmap_dict2 = pydarnio.dict2dmap(records)
self.dmap_compare(dmap_records, dmap_dict2)
def test_dict2dmap_DmapWrite_DmapRead_stream_dmap2dict(self):
"""
Test convert dict to dmap with dict2dmap then DmapWrite to write
to a stream to be read in by
DmapRead and converted back to a dictionary
with dict2dmap
"""
dmap_dict = [{
'stid':
56,
'channel':
0,
'software':
'RST',
'xcf':
np.array([2.5, 3.456, 34.56, -4.5], dtype=np.float32),
'gflg':
np.array([1, 0, 4, 2], np.int8)
}]
dmap_records = pydarnio.dict2dmap(dmap_dict)
dmap_write = pydarnio.DmapWrite(dmap_records)
dmap_stream = dmap_write.write_dmap_stream()
dmap_read = pydarnio.DmapRead(dmap_stream, True)
records = dmap_read.read_records()
self.dmap_compare(dmap_dict, records)
dmap_dict2 = pydarnio.dict2dmap(records)
self.dmap_compare(dmap_records, dmap_dict2)
def test_DmapRead_stream_DmapWrite_file(self):
"""
Test DmapRead a stream in and DmapWrite to a file. DmapRead is
used to read the file to compare values.
"""
with bz2.open(rawacf_stream) as fp:
dmap_stream = fp.read()
dmap = pydarnio.DmapRead(dmap_stream, True)
stream_data = dmap.read_records()
dmap_stream_data = dmap.get_dmap_records
dmap_write = pydarnio.DmapWrite(stream_data)
dmap_write.write_dmap("test_rawacf.rawacf")
self.assertTrue(os.path.isfile("test_rawacf.rawacf"))
dmap = pydarnio.DmapRead("test_rawacf.rawacf")
_ = dmap.read_records()
dmap_read_data = dmap.get_dmap_records
self.dmap_compare(dmap_stream_data, dmap_read_data)
def test_read_currupt_file2(self):
"""
Test read_records on a corrupt file
Expected bahaviour: raises pydmap expection
"""
dmap = pydarnio.DmapRead(corrupt_file2)
with self.assertRaises(pydarnio.dmap_exceptions.NegativeByteError):
dmap.read_records()
def test_integrity_check_corrupt_file2(self):
"""
Test test_initial_data_integrity on a corrupt file
Expected bahaviour: raises pydmap expection
"""
dmap = pydarnio.DmapRead(corrupt_file2)
with self.assertRaises(pydarnio.dmap_exceptions.NegativeByteError):
dmap.test_initial_data_integrity()
def test_DmapWrite_DmapRead_int8_scalar(self):
"""
Test integration DmapWrite and DmapRead to write char array.
"""
scalar = pydarnio.DmapScalar('channel', 4, 1, 'c')
dmap_write = pydarnio.DmapWrite([{'channel': scalar}])
dmap_scalar_bytes = dmap_write.dmap_scalar_to_bytes(scalar)
dmap = pydarnio.DmapRead(dmap_scalar_bytes, True)
dmap_scalar = dmap.read_scalar()
self.assertEqual(scalar, dmap_scalar)
def test_DmapWrite_stream_DmapRead_dmap(self):
"""
Test DmapWrite write data to a stream, DmapRead read the stream.
"""
rawacf_data = copy.deepcopy(rawacf_data_sets.rawacf_data)
rawacf_write = pydarnio.DmapWrite()
rawacf_stream = rawacf_write.write_dmap_stream(rawacf_data)
rawacf_read = pydarnio.DmapRead(rawacf_stream, True)
rawacf_read_data = rawacf_read.read_records()
self.dmap_compare(rawacf_read_data, rawacf_data)
def test_DmapRead_dmap2dict_dict2dmap(self):
"""
Test DmapRead from a file and convert to a dictionary.
"""
dmap_read = pydarnio.DmapRead(rawacf_file)
records = dmap_read.read_records()
records = dmap_read.get_dmap_records
dict_records = pydarnio.dmap2dict(records)
records_2 = pydarnio.dict2dmap(dict_records)
self.dmap_compare(records, records_2)
def test_DmapRead_DmapWrite_dmap_file(self):
"""
Test integration between DmapRead reading a file and DmapWrite
writing the file then reading it again to ensure the data didn't
change.
"""
dmap = pydarnio.DmapRead(rawacf_file)
dmap_data = dmap.read_records()
writer = pydarnio.DmapWrite(dmap_data, "test_rawacf.rawacf")
writer.write_dmap()
self.assertTrue(os.path.isfile("test_rawacf.rawacf"))
os.remove("test_rawacf.rawacf")
dmap_write = pydarnio.DmapWrite(dmap_data)
dmap_write.write_dmap("test_rawacf.rawacf")
dmap_read = pydarnio.DmapRead("test_rawacf.rawacf")
_ = dmap_read.read_records()
_ = dmap_read.get_dmap_records
os.remove("test_rawacf.rawacf")
def test_integrity_check_dmap_file(self):
"""
Tests DmapRead test_initial_data_integrity
It should be able to read through the bytearray quickly
ensureing no curruption has occured in the file.
Behaviours: raising no exceptions
"""
file_path = rawacf_file
dm = pydarnio.DmapRead(file_path)
dm.test_initial_data_integrity()
def test_DmapRead_SDarnWrite_rawacf(self):
"""
Test DmapRead reading an rawacf and SDarnWrite writing
the rawacf file
"""
dmap = pydarnio.DmapRead(rawacf_file)
dmap_data = dmap.read_records()
dmap_write = pydarnio.SDarnWrite(dmap_data)
dmap_write.write_rawacf("test_rawacf.rawacf")
self.assertTrue(os.path.isfile("test_rawacf.rawacf"))
os.remove("test_rawacf.rawacf")
def test_DmapWrite_DmapRead_dmap_file(self):
"""
Test integration between DmapWrite and DmapRead from
a rawacf data written as file then read in and compared against.
"""
rawacf_data = copy.deepcopy(rawacf_data_sets.rawacf_data)
rawacf_write = pydarnio.DmapWrite(rawacf_data, "test_rawacf.rawacf")
rawacf_write.write_dmap()
rawacf_read = pydarnio.DmapRead("test_rawacf.rawacf")
rawacf_read_data = rawacf_read.read_records()
self.dmap_compare(rawacf_read_data, rawacf_data)
def test_write_read_int8_array(self):
"""
Test integrates DmapWrite and DmapRead to write and read an
int8 data type which is the char type for DMAP format.
"""
array = pydarnio.DmapArray('channel', np.array([1, 0, 1],
dtype=np.int8), 1, 'c',
1, [3])
dmap_write = pydarnio.DmapWrite([{'channel': array}])
dmap_array_bytes = dmap_write.dmap_array_to_bytes(array)
dmap = pydarnio.DmapRead(dmap_array_bytes, True)
dmap_array = dmap.read_array(len(dmap_array_bytes))
self.compare_dmap_array(array, dmap_array)
def test_DmapRead_SDarnWrite_SDarnRead_fitacf(self):
"""
Test DmapRead reading a fitacf file then writing it with SDarnWrite
then reading it again with SDarnRead
"""
dmap = pydarnio.DmapRead(fitacf_file)
dmap_data = dmap.read_records()
dmap_write = pydarnio.SDarnWrite(dmap_data)
dmap_write.write_fitacf("test_fitacf.fitacf")
darn_read = pydarnio.SDarnRead("test_fitacf.fitacf")
fitacf_data = darn_read.read_fitacf()
self.dmap_compare(dmap_data, fitacf_data)
os.remove("test_fitacf.fitacf")
def test_DmapRead_SDarnWrite_SDarnRead_grid(self):
"""
Test DmapRead reading a grid file then writing it with SDarnWrite
then reading it again with SDarnRead
"""
dmap = pydarnio.DmapRead(grid_file)
dmap_data = dmap.read_records()
dmap_write = pydarnio.SDarnWrite(dmap_data)
dmap_write.write_grid("test_grid.grid")
darn_read = pydarnio.SDarnRead("test_grid.grid")
grid_data = darn_read.read_grid()
self.dmap_compare(dmap_data, grid_data)
os.remove("test_grid.grid")
def test_DmapRead_SDarnWrite_SDarnRead_map(self):
"""
Test DmapRead reading a map file then writing it with SDarnWrite
then reading it again with SDarnRead
"""
dmap = pydarnio.DmapRead(map_file)
dmap_data = dmap.read_records()
dmap_write = pydarnio.SDarnWrite(dmap_data)
dmap_write.write_map("test_map.map")
darn_read = pydarnio.SDarnRead("test_map.map")
map_data = darn_read.read_map()
self.dmap_compare(dmap_data, map_data)
os.remove("test_map.map")
def test_open_dmap_file(self):
"""
Tests DmapRead's constructor on opening a rawacf.
It should be able to open the file, read it and convert to bytearray.
Checks:
- bytearray instance is created from reading in the file
- bytearray is not empty
"""
file_path = fitacf_file
dm = pydarnio.DmapRead(file_path)
self.assertIsInstance(dm.dmap_bytearr, bytearray)
self.assertGreater(dm.dmap_end_bytes, 0)
def test_DmapWrite_DmapRead_scalar(self):
"""
This test integrates DmapWrite and DmapRead for
writing a single scalar and then reading it in.
Behaviour: No change to the scalar being written then read in.
"""
scalar = pydarnio.DmapScalar('stid', 5, 3, 'i')
dmap_write = pydarnio.DmapWrite([{'stid': scalar}])
dmap_scalar_bytes = dmap_write.dmap_scalar_to_bytes(scalar)
dmap = pydarnio.DmapRead(dmap_scalar_bytes, True)
dmap = dmap.read_scalar()
self.assertEqual(scalar, dmap)
def test_DmapRead_SDarnWrite_SDarnRead_iqdat(self):
"""
Test SDarnRead reads from a stream and SDarnWrite writes
to a iqdat file
"""
dmap = pydarnio.DmapRead(iqdat_file)
dmap_data = dmap.read_records()
dmap_write = pydarnio.SDarnWrite(dmap_data)
dmap_write.write_iqdat("test_iqdat.iqdat")
darn_read = pydarnio.SDarnRead("test_iqdat.iqdat")
iqdat_data = darn_read.read_iqdat()
self.dmap_compare(dmap_data, iqdat_data)
os.remove("test_iqdat.iqdat")
def test_dict2dmap_SDarnWrite_rawacf(self):
"""
Test dict2dmap to convert a dictionary to dmap then SDarnWrite write
rawacf file
"""
rawacf_dict_data = copy.deepcopy(rawacf_dict_sets.rawacf_dict_data)
dmap_rawacf = pydarnio.dict2dmap(rawacf_dict_data)
darn_read = pydarnio.SDarnWrite(dmap_rawacf)
darn_read.write_rawacf("test_rawacf.rawacf")
dmap_read = pydarnio.DmapRead("test_rawacf.rawacf")
dmap_data = dmap_read.read_records()
dmap_data = dmap_read.get_dmap_records
self.dmap_compare(dmap_data, dmap_rawacf)
os.remove("test_rawacf.rawacf")
def test_DmapRead_stream_SDarnWrite_file_map(self):
"""
Test DmapRead to read in a stream then have SDarnWrite the
stream to file
"""
with bz2.open(map_stream) as fp:
dmap_stream = fp.read()
dmap = pydarnio.DmapRead(dmap_stream, True)
dmap_stream_data = dmap.read_records()
dmap_write = pydarnio.SDarnWrite(dmap_stream_data)
dmap_write.write_map("test_map.map")
dmap = pydarnio.SDarnRead("test_map.map")
dmap_data = dmap.read_map()
self.dmap_compare(dmap_stream_data, dmap_data)
os.remove("test_map.map")
def test_DmapWrite_DmapRead_array(self):
"""
This test integrates DmapWrite and DmapRead for
writing and reading an array.
Behaviour: No change to the array
"""
array = pydarnio.DmapArray('xcf',
np.array([4.3, 3.5, 2.3], dtype=np.float32),
4, 'f', 1, [3])
dmap_write = pydarnio.DmapWrite([{'xcf': array}])
dmap_array_bytes = dmap_write.dmap_array_to_bytes(array)
dmap = pydarnio.DmapRead(dmap_array_bytes, True)
dmap_array = dmap.read_array(len(dmap_array_bytes))
self.compare_dmap_array(array, dmap_array)
def test_DmapRead_stream_SDarnWrite_file_fitacf(self):
"""
Test DmapRead to read in a stream then have SDarnWrite the
stream to file
"""
with bz2.open(fitacf_stream) as fp:
dmap_stream = fp.read()
dmap = pydarnio.DmapRead(dmap_stream, True)
stream_data = dmap.read_records()
dmap_stream_data = dmap.get_dmap_records
dmap_write = pydarnio.SDarnWrite(stream_data)
dmap_write.write_fitacf("test_fitacf.fitacf")
dmap = pydarnio.SDarnRead("test_fitacf.fitacf")
dmap_data = dmap.read_fitacf()
dmap_data = dmap.get_dmap_records
self.dmap_compare(dmap_stream_data, dmap_data)
os.remove("test_fitacf.fitacf")
def test_read_dmap_file(self):
"""
Tests DmapRead test read_dmap.
Behaviour: raising no exceptions
"""
file_path = fitacf_file
dm = pydarnio.DmapRead(file_path)
dmap_records = dm.read_records()
dmap_records = dm.get_dmap_records
self.assertIsInstance(dmap_records, collections.deque)
self.assertIsInstance(dmap_records[0], collections.OrderedDict)
self.assertIsInstance(dmap_records[4]['bmnum'], pydarnio.DmapScalar)
self.assertIsInstance(dmap_records[1]['ptab'], pydarnio.DmapArray)
self.assertIsInstance(dmap_records[7]['channel'].value, int)
self.assertIsInstance(dmap_records[2]['ltab'].value, np.ndarray)
self.assertEqual(dmap_records[0]['ptab'].dimension, 1)
self.assertEqual(dmap_records[50]['gflg'].value[1], 0)
def test_dmap_read_corrupt_stream(self):
"""
Test read_records on a corrupt stream. Read in compressed
file which returns a byte object, then insert some random
bytes to produce a corrupt stream.
Expected bahaviour: raises pydmap expection
"""
with bz2.open(rawacf_stream) as fp:
dmap_stream = fp.read()
# need to convert to byte array for mutability
# since bytes are immutable.
corrupt_stream = bytearray(dmap_stream[0:36])
corrupt_stream[36:40] = bytearray(str(os.urandom(4)).encode('utf-8'))
corrupt_stream[40:] = dmap_stream[37:]
dmap = pydarnio.DmapRead(corrupt_stream, True)
with self.assertRaises(pydarnio.dmap_exceptions.DmapDataError):
dmap.read_records()
def test_dmap_read_stream(self):
"""
Test read_records on dmap data stream.
The dmap data stream is formed from compressed
bzip2 file that returns a bytes object.
Checks:
- returns correct data structures
- returns excpected values
"""
# bz2 opens the compressed file into a data
# stream of bytes without actually uncompressing the file
with bz2.open(rawacf_stream) as fp:
dmap_stream = fp.read()
dmap = pydarnio.DmapRead(dmap_stream, True)
dmap_data = dmap.read_records()
dmap_data = dmap.get_dmap_records
self.assertIsInstance(dmap_data, collections.deque)
self.assertIsInstance(dmap_data[0], collections.OrderedDict)
self.assertIsInstance(dmap_data[4]['channel'], pydarnio.DmapScalar)
self.assertIsInstance(dmap_data[1]['ptab'], pydarnio.DmapArray)
self.assertIsInstance(dmap_data[7]['channel'].value, int)
self.assertIsInstance(dmap_data[2]['xcfd'].value, np.ndarray)
self.assertEqual(dmap_data[0]['xcfd'].dimension, 3)
