def test_resolve_values_from_stream(self):
assertEquals = self.assertEquals
stream = BytesIO(b'\x00\x01\x00\x02')
resolve_values = resolve_values_from_stream(stream)
bin_item = dict(type=self.BasicStruct)
events = bintype_map_events(bin_item)
events = resolve_values(events)
assertEquals((STARTEVENT, bin_item), events.next())
assertEquals(
(None, dict(name='a', type=UINT16, bin_offset=0, value=256)),
events.next())
assertEquals(
(None, dict(name='b', type=UINT16, bin_offset=2, value=512)),
events.next())
assertEquals((ENDEVENT, bin_item), events.next())
class StructWithBSTR(object):
__metaclass__ = StructType
@staticmethod
def attributes():
yield BSTR, 'name'
stream = BytesIO(b'\x02\x00\x00\x01\x00\x02')
resolve_values = resolve_values_from_stream(stream)
bin_item = dict(type=StructWithBSTR)
events = bintype_map_events(bin_item)
events = resolve_values(events)
assertEquals((STARTEVENT, bin_item), events.next())
assertEquals(
(None,
dict(name='name', type=BSTR, bin_offset=0,
value=u'\u0100\u0200')), events.next())
assertEquals((ENDEVENT, bin_item), events.next())
class StructWithParaTextChunks(object):
__metaclass__ = StructType
@staticmethod
def attributes():
yield ParaTextChunks, 'texts'
stream = BytesIO(b'\x20\x00\x21\x00\x22\x00')
resolve_values = resolve_values_from_stream(stream)
bin_item = dict(type=StructWithParaTextChunks)
events = bintype_map_events(bin_item)
events = resolve_values(events)
assertEquals((STARTEVENT, bin_item), events.next())
assertEquals((None,
dict(name='texts',
type=ParaTextChunks,
bin_offset=0,
value=[((0, 3), u'\u0020\u0021\u0022')])),
events.next())
assertEquals((ENDEVENT, bin_item), events.next())
def test_resolve_values_from_stream(self):
assertEqual = self.assertEqual
stream = BytesIO(b'\x00\x01\x00\x02')
resolve_values = resolve_values_from_stream(stream)
bin_item = dict(type=self.BasicStruct)
events = bintype_map_events(bin_item)
events = resolve_values(events)
assertEqual((STARTEVENT, bin_item), next(events))
assertEqual((None,
dict(name='a', type=UINT16, bin_offset=0, value=256)),
next(events))
assertEqual((None,
dict(name='b', type=UINT16, bin_offset=2, value=512)),
next(events))
assertEqual((ENDEVENT, bin_item), next(events))
@add_metaclass(StructType)
class StructWithBSTR(object):
@staticmethod
def attributes():
yield BSTR, 'name'
stream = BytesIO(b'\x02\x00\x00\x01\x00\x02')
resolve_values = resolve_values_from_stream(stream)
bin_item = dict(type=StructWithBSTR)
events = bintype_map_events(bin_item)
events = resolve_values(events)
assertEqual((STARTEVENT, bin_item), next(events))
assertEqual((None,
dict(name='name', type=BSTR, bin_offset=0,
value=u'\u0100\u0200')),
next(events))
assertEqual((ENDEVENT, bin_item), next(events))
@add_metaclass(StructType)
class StructWithParaTextChunks(object):
@staticmethod
def attributes():
yield ParaTextChunks, 'texts'
stream = BytesIO(b'\x20\x00\x21\x00\x22\x00')
resolve_values = resolve_values_from_stream(stream)
bin_item = dict(type=StructWithParaTextChunks)
events = bintype_map_events(bin_item)
events = resolve_values(events)
assertEqual((STARTEVENT, bin_item), next(events))
assertEqual((None,
dict(name='texts', type=ParaTextChunks,
bin_offset=0,
value=[((0, 3), u'\u0020\u0021\u0022')])),
next(events))
assertEqual((ENDEVENT, bin_item), next(events))
def parse_model_events(self):
context = dict(version=self.version)
def resolve_values_from_record(record):
stream = StringIO(record['payload'])
return resolve_values_from_stream(stream)
for group_idx, records in enumerate(self.records_treegrouped()):
context['treegroup'] = group_idx
for x in resolve_models(context, records):
event, item = x
if item['type'] is RecordModel:
if event is STARTEVENT:
record_frame = item['record']
stream = StringIO(record_frame['payload'])
resolve_values = resolve_values_from_stream(stream)
item['stream'] = stream
item['resolve_values'] = resolve_values
elif event is ENDEVENT:
stream = item['stream']
item['leftover'] = {
'offset': stream.tell(),
'bytes': stream.read()
}
yield x
def test_collect_values(self):
stream = BytesIO(b'\x01\x00\x01\x01\x02\x01\x02\x00')
resolve_values = resolve_values_from_stream(stream)
bin_item = dict(type=self.NestedStruct)
events = bintype_map_events(bin_item)
events = resolve_values(events)
events = construct_composite_values(events)
a = dict(name='a', type=UINT16, bin_offset=0, value=1)
s_a = dict(name='a', type=UINT16, bin_offset=2, value=0x101)
s_b = dict(name='b', type=UINT16, bin_offset=4, value=0x102)
b = dict(name='b', type=UINT16, bin_offset=6, value=2)
s = dict(name='s', type=self.BasicStruct, value=dict(a=0x101, b=0x102))
x = dict(type=self.NestedStruct,
value=dict(a=1, s=dict(a=0x101, b=0x102), b=2))
self.assertEquals((STARTEVENT, bin_item), events.next())
self.assertEquals((None, a), events.next())
self.assertEquals(
(STARTEVENT, dict(name='s', type=self.BasicStruct, value=dict())),
events.next())
self.assertEquals((None, s_a), events.next())
self.assertEquals((None, s_b), events.next())
self.assertEquals((ENDEVENT, s), events.next())
self.assertEquals((None, b), events.next())
self.assertEquals((ENDEVENT, x), events.next())
def parse_model_events(self):
context = dict(version=self.version)
def resolve_values_from_record(record):
stream = StringIO(record['payload'])
return resolve_values_from_stream(stream)
for group_idx, records in enumerate(self.records_treegrouped()):
context['treegroup'] = group_idx
for x in resolve_models(context, records):
event, item = x
if item['type'] is RecordModel:
if event is STARTEVENT:
record_frame = item['record']
stream = StringIO(record_frame['payload'])
resolve_values = resolve_values_from_stream(stream)
item['stream'] = stream
item['resolve_values'] = resolve_values
elif event is ENDEVENT:
stream = item['stream']
item['leftover'] = {
'offset': stream.tell(),
'bytes': stream.read()
}
yield x
def test_collect_values(self):
from hwp5.treeop import STARTEVENT, ENDEVENT
from hwp5.dataio import UINT16
from hwp5.bintype import bintype_map_events
from hwp5.bintype import resolve_values_from_stream
from hwp5.bintype import collect_values
from StringIO import StringIO
stream = StringIO('\x01\x00\x01\x01\x02\x01\x02\x00')
resolve_values = resolve_values_from_stream(stream)
bin_item = dict(type=self.NestedStruct)
events = bintype_map_events(bin_item)
events = resolve_values(events)
events = collect_values(events)
a = dict(name='a', type=UINT16, bin_offset=0, value=1)
s_a = dict(name='a', type=UINT16, bin_offset=2, value=0x101)
s_b = dict(name='b', type=UINT16, bin_offset=4, value=0x102)
b = dict(name='b', type=UINT16, bin_offset=6, value=2)
s = dict(name='s', type=self.BasicStruct,
value=dict(a=0x101, b=0x102))
x = dict(type=self.NestedStruct,
value=dict(a=1, s=dict(a=0x101, b=0x102), b=2))
self.assertEquals((STARTEVENT, bin_item), events.next())
self.assertEquals((None, a), events.next())
self.assertEquals((STARTEVENT, dict(name='s', type=self.BasicStruct,
value=dict())),
events.next())
self.assertEquals((None, s_a), events.next())
self.assertEquals((None, s_b), events.next())
self.assertEquals((ENDEVENT, s), events.next())
self.assertEquals((None, b), events.next())
self.assertEquals((ENDEVENT, x), events.next())
def xmlevents_from_hwp5file(hwp5file):
version = '%d.%d.%d.%d' % hwp5file.fileheader.version
hexversion = '%02x%02x%02x%02x' % hwp5file.fileheader.version
yield STARTEVENT, ('Hwp5Doc', {
'version': version,
'hexversion': hexversion
})
with hwp5file.fileheader.open() as f:
yield STARTEVENT, ('FileHeader', {})
resolve_values = resolve_values_from_stream(f)
from hwp5.filestructure import FileHeader
model_events = resolve_type_events(FileHeader, {}, resolve_values)
for x in xmlevents_from_modelevents(model_events):
yield x
yield ENDEVENT, 'FileHeader'
yield STARTEVENT, ('DocInfo', {})
model_events = hwp5file.docinfo.parse_model_events()
for x in xmlevents_from_modelevents(model_events):
yield x
yield ENDEVENT, 'DocInfo'
for section_name in hwp5file.bodytext:
section = hwp5file.bodytext[section_name]
yield STARTEVENT, ('Section', {'name': section_name})
model_events = section.parse_model_events()
for x in xmlevents_from_modelevents(model_events):
yield x
yield ENDEVENT, 'Section'
yield ENDEVENT, 'Hwp5Doc'
def test_collect_values(self):
stream = BytesIO(b'\x01\x00\x01\x01\x02\x01\x02\x00')
resolve_values = resolve_values_from_stream(stream)
bin_item = dict(type=self.NestedStruct)
events = bintype_map_events(bin_item)
events = resolve_values(events)
events = construct_composite_values(events)
a = dict(name='a', type=UINT16, bin_offset=0, value=1)
s_a = dict(name='a', type=UINT16, bin_offset=2, value=0x101)
s_b = dict(name='b', type=UINT16, bin_offset=4, value=0x102)
b = dict(name='b', type=UINT16, bin_offset=6, value=2)
s = dict(name='s', type=self.BasicStruct,
value=dict(a=0x101, b=0x102))
x = dict(type=self.NestedStruct,
value=dict(a=1, s=dict(a=0x101, b=0x102), b=2))
self.assertEqual((STARTEVENT, bin_item), next(events))
self.assertEqual((None, a), next(events))
self.assertEqual((STARTEVENT, dict(name='s', type=self.BasicStruct,
value=dict())),
next(events))
self.assertEqual((None, s_a), next(events))
self.assertEqual((None, s_b), next(events))
self.assertEqual((ENDEVENT, s), next(events))
self.assertEqual((None, b), next(events))
self.assertEqual((ENDEVENT, x), next(events))
def parse_model(context, model):
''' HWPTAG로 모델 결정 후 기본 파싱 '''
stream = context['stream']
context['resolve_values'] = resolve_values_from_stream(stream)
events = resolve_model_events(context, model)
events = raise_on_errorevent(context, events)
model['binevents'] = list(events)
logger.debug('model: %s', model['type'].__name__)
logger.debug('%s', model['content'])
def parse_model(context, model):
''' HWPTAG로 모델 결정 후 기본 파싱 '''
stream = context['stream']
context['resolve_values'] = resolve_values_from_stream(stream)
events = resolve_model_events(context, model)
events = raise_on_errorevent(context, events)
model['binevents'] = list(events)
logger.debug('model: %s', model['type'].__name__)
logger.debug('%s', model['content'])
def xmlevents_from_hwp5file(hwp5file):
version = '%d.%d.%d.%d' % hwp5file.fileheader.version
hexversion = '%02x%02x%02x%02x' % hwp5file.fileheader.version
yield STARTEVENT, ('Hwp5Doc', {
'version': version,
'hexversion': hexversion
})
with hwp5file.fileheader.open() as f:
yield STARTEVENT, ('FileHeader', {
})
resolve_values = resolve_values_from_stream(f)
from hwp5.filestructure import FileHeader
model_events = resolve_type_events(FileHeader, {}, resolve_values)
for x in xmlevents_from_modelevents(model_events):
yield x
yield ENDEVENT, 'FileHeader'
yield STARTEVENT, ('DocInfo', {
})
model_events = hwp5file.docinfo.parse_model_events()
for x in xmlevents_from_modelevents(model_events):
yield x
yield ENDEVENT, 'DocInfo'
for section_name in hwp5file.bodytext:
section = hwp5file.bodytext[section_name]
yield STARTEVENT, ('Section', {
'name': section_name
})
model_events = section.parse_model_events()
for x in xmlevents_from_modelevents(model_events):
yield x
yield ENDEVENT, 'Section'
yield ENDEVENT, 'Hwp5Doc'
def resolve_values_from_record(record):
stream = StringIO(record['payload'])
return resolve_values_from_stream(stream)
def resolve_values_from_record(record):
stream = StringIO(record['payload'])
return resolve_values_from_stream(stream)
def test_resolve_values_from_stream(self):
assertEquals = self.assertEquals
from hwp5.treeop import STARTEVENT, ENDEVENT
from hwp5.dataio import UINT16
from hwp5.bintype import bintype_map_events
from hwp5.bintype import resolve_values_from_stream
from StringIO import StringIO
stream = StringIO('\x00\x01\x00\x02')
resolve_values = resolve_values_from_stream(stream)
bin_item = dict(type=self.BasicStruct)
events = bintype_map_events(bin_item)
events = resolve_values(events)
assertEquals((STARTEVENT, bin_item), events.next())
assertEquals((None,
dict(name='a', type=UINT16, bin_offset=0, value=256)),
events.next())
assertEquals((None,
dict(name='b', type=UINT16, bin_offset=2, value=512)),
events.next())
assertEquals((ENDEVENT, bin_item), events.next())
from hwp5.dataio import StructType
from hwp5.dataio import BSTR
class StructWithBSTR(object):
__metaclass__ = StructType
@staticmethod
def attributes():
yield BSTR, 'name'
stream = StringIO('\x02\x00\x00\x01\x00\x02')
resolve_values = resolve_values_from_stream(stream)
bin_item = dict(type=StructWithBSTR)
events = bintype_map_events(bin_item)
events = resolve_values(events)
assertEquals((STARTEVENT, bin_item), events.next())
assertEquals((None,
dict(name='name', type=BSTR, bin_offset=0,
value=u'\u0100\u0200')),
events.next())
assertEquals((ENDEVENT, bin_item), events.next())
from hwp5.binmodel import ParaTextChunks
class StructWithParaTextChunks(object):
__metaclass__ = StructType
@staticmethod
def attributes():
yield ParaTextChunks, 'texts'
stream = StringIO('\x20\x00\x21\x00\x22\x00')
resolve_values = resolve_values_from_stream(stream)
bin_item = dict(type=StructWithParaTextChunks)
events = bintype_map_events(bin_item)
events = resolve_values(events)
assertEquals((STARTEVENT, bin_item), events.next())
assertEquals((None,
dict(name='texts', type=ParaTextChunks,
bin_offset=0,
value=[((0, 3), u'\u0020\u0021\u0022')])),
events.next())
assertEquals((ENDEVENT, bin_item), events.next())
