def deserialize(self, stream: Stream, all0_: typing.List['Referent'],
sofa: 'SourceOfAnalysis') -> None:
typ = SerializerHelper.deserialize_string(stream)
cou = SerializerHelper.deserialize_int(stream)
i = 0
while i < cou:
typ = SerializerHelper.deserialize_string(stream)
c = SerializerHelper.deserialize_int(stream)
id0_ = SerializerHelper.deserialize_int(stream)
val = None
if ((id0_ < 0) and all0_ is not None):
id1 = (-id0_) - 1
if (id1 < len(all0_)):
val = (all0_[id1])
elif (id0_ > 0):
stream.position = stream.position - (4)
val = (SerializerHelper.deserialize_string(stream))
self.add_slot(typ, val, False, c)
i += 1
cou = SerializerHelper.deserialize_int(stream)
self.__m_occurrence = list()
i = 0
while i < cou:
a = TextAnnotation._new2863(sofa, self)
self.__m_occurrence.append(a)
a.begin_char = SerializerHelper.deserialize_int(stream)
a.end_char = SerializerHelper.deserialize_int(stream)
attr = SerializerHelper.deserialize_int(stream)
if (((attr & 1)) != 0):
a.essential_for_occurence = True
i += 1
def __deserialize_item(self, stream: Stream) -> 'MorphBaseInfo':
from pullenti.ner.core.internal.SerializerHelper import SerializerHelper
ty = stream.readbyte()
res = (MorphBaseInfo() if ty == 0 else MorphWordForm())
res.class0_ = MorphClass._new53(
SerializerHelper.deserialize_short(stream))
res.case_ = MorphCase._new29(
SerializerHelper.deserialize_short(stream))
res.gender = Utils.valToEnum(
SerializerHelper.deserialize_short(stream), MorphGender)
res.number = Utils.valToEnum(
SerializerHelper.deserialize_short(stream), MorphNumber)
res.language = MorphLang._new56(
SerializerHelper.deserialize_short(stream))
if (ty == 0):
return res
wf = Utils.asObjectOrNull(res, MorphWordForm)
wf.normal_case = SerializerHelper.deserialize_string(stream)
wf.normal_full = SerializerHelper.deserialize_string(stream)
wf.undef_coef = SerializerHelper.deserialize_short(stream)
cou = SerializerHelper.deserialize_int(stream)
i = 0
while i < cou:
if (wf.misc is None):
wf.misc = MorphMiscInfo()
wf.misc.attrs.append(SerializerHelper.deserialize_string(stream))
i += 1
return res
def deserialize(self, stream : io.IOBase) -> bool:
vers = 0
b = Utils.readByteIO(stream)
if (b == (0xAA)):
b = (Utils.readByteIO(stream))
vers = (b)
else:
stream.seek(stream.tell() - (1), io.SEEK_SET)
self.__m_sofa = SourceOfAnalysis(None)
self.__m_sofa.deserialize(stream)
self.base_language = MorphLang._new5(SerializerHelper.deserializeInt(stream))
self.__m_entities = list()
cou = SerializerHelper.deserializeInt(stream)
i = 0
while i < cou:
typ = SerializerHelper.deserializeString(stream)
r = ProcessorService.createReferent(typ)
if (r is None):
r = Referent("UNDEFINED")
self.__m_entities.append(r)
i += 1
i = 0
while i < cou:
self.__m_entities[i].deserialize(stream, self.__m_entities, self.__m_sofa)
i += 1
self.first_token = SerializerHelper.deserializeTokens(stream, self, vers)
self.__createStatistics()
return True
def deserialize(self, stream: Stream) -> bool:
vers = 0
b = stream.readbyte()
if (b == (0xAA)):
b = (stream.readbyte())
vers = (b)
else:
stream.position = stream.position - (1)
self.__m_sofa = SourceOfAnalysis(None)
self.__m_sofa.deserialize(stream)
self.base_language = MorphLang._new56(
SerializerHelper.deserialize_int(stream))
self.__m_entities = list()
cou = SerializerHelper.deserialize_int(stream)
i = 0
while i < cou:
typ = SerializerHelper.deserialize_string(stream)
r = ProcessorService.create_referent(typ)
if (r is None):
r = Referent("UNDEFINED")
self.__m_entities.append(r)
i += 1
i = 0
while i < cou:
self.__m_entities[i].deserialize(stream, self.__m_entities,
self.__m_sofa)
i += 1
self.first_token = SerializerHelper.deserialize_tokens(
stream, self, vers)
self.__create_statistics()
return True
def deserialize(self, stream: io.IOBase, all0_: typing.List['Referent'],
sofa: 'SourceOfAnalysis') -> None:
typ = SerializerHelper.deserializeString(stream)
cou = SerializerHelper.deserializeInt(stream)
i = 0
while i < cou:
typ = SerializerHelper.deserializeString(stream)
c = SerializerHelper.deserializeInt(stream)
id0_ = SerializerHelper.deserializeInt(stream)
val = None
if (id0_ < 0):
val = (all0_[(-id0_) - 1])
elif (id0_ > 0):
stream.seek(stream.tell() - (4), io.SEEK_SET)
val = (SerializerHelper.deserializeString(stream))
self.addSlot(typ, val, False, c)
i += 1
cou = SerializerHelper.deserializeInt(stream)
self.__m_occurrence = list()
i = 0
while i < cou:
a = TextAnnotation._new2691(sofa, self)
self.__m_occurrence.append(a)
a.begin_char = SerializerHelper.deserializeInt(stream)
a.end_char = SerializerHelper.deserializeInt(stream)
attr = SerializerHelper.deserializeInt(stream)
if (((attr & 1)) != 0):
a.essential_for_occurence = True
i += 1
def _serialize(self, stream: Stream) -> None:
super()._serialize(stream)
id0_ = 0
if (self.referent is not None
and (isinstance(self.referent.tag, int))):
id0_ = (self.referent.tag)
SerializerHelper.serialize_int(stream, id0_)
def _deserialize(self, stream: io.IOBase, kit_: 'AnalysisKit',
vers: int) -> None:
from pullenti.ner.core.internal.SerializerHelper import SerializerHelper
super()._deserialize(stream, kit_, vers)
self.term = SerializerHelper.deserializeString(stream)
self.lemma = SerializerHelper.deserializeString(stream)
self.invariant_prefix_length = SerializerHelper.deserializeShort(
stream)
self.max_length = SerializerHelper.deserializeShort(stream)
def serialize(self, stream: Stream) -> None:
""" Сериализовать весь словарь в поток
Args:
stream(Stream): поток для сериализации
"""
SerializerHelper.serialize_string(stream, self.__m_specs)
SerializerHelper.serialize_int(stream, len(self.items))
for it in self.items:
it._serialize(stream)
def _deserialize(self, stream: io.IOBase, kit_: 'AnalysisKit',
vers: int) -> None:
from pullenti.ner.core.internal.SerializerHelper import SerializerHelper
self.kit = kit_
self.begin_char = SerializerHelper.deserializeInt(stream)
self.end_char = SerializerHelper.deserializeInt(stream)
self.__m_attrs = (SerializerHelper.deserializeInt(stream))
self.chars = CharsInfo._new2656(
SerializerHelper.deserializeInt(stream))
self.__m_morph = MorphCollection()
self.__m_morph._deserialize(stream)
def _deserialize(self, stream: Stream, kit_: 'AnalysisKit',
vers: int) -> None:
from pullenti.ner.core.internal.SerializerHelper import SerializerHelper
super()._deserialize(stream, kit_, vers)
if (vers == 0):
buf = Utils.newArrayOfBytes(8, 0)
stream.read(buf, 0, 8)
lo = int.from_bytes(buf[0:0 + 8], byteorder="little")
self.value = str(lo)
else:
self.value = SerializerHelper.deserialize_string(stream)
self.typ = (Utils.valToEnum(SerializerHelper.deserialize_int(stream),
NumberSpellingType))
def _serialize(self, stream: io.IOBase) -> None:
from pullenti.ner.core.internal.SerializerHelper import SerializerHelper
super()._serialize(stream)
SerializerHelper.serializeString(stream, self.term)
SerializerHelper.serializeString(stream, self.lemma)
SerializerHelper.serializeShort(stream, self.invariant_prefix_length)
SerializerHelper.serializeShort(stream, self.max_length)
def deserialize(self, stream: Stream) -> None:
""" Восстановить словарь из потока
Args:
stream(Stream): поток для десериализации
"""
self.__m_specs = SerializerHelper.deserialize_string(stream)
self.__init()
cou = SerializerHelper.deserialize_int(stream)
while cou > 0:
it = ExtOntologyItem()
it._deserialize(stream)
self.items.append(it)
cou -= 1
self.__init_hash()
def _deserialize(self, stream: Stream) -> None:
self.ext_id = (SerializerHelper.deserialize_string(stream))
self.__m_caption = SerializerHelper.deserialize_string(stream)
cou = SerializerHelper.deserialize_int(stream)
if (cou > 0):
self._refs = list()
while cou > 0:
typ = SerializerHelper.deserialize_string(stream)
r = ProcessorService.create_referent(typ)
r.deserialize(stream, self._refs, None)
self._refs.append(r)
cou -= 1
self.type_name = SerializerHelper.deserialize_string(stream)
self.referent = ProcessorService.create_referent(self.type_name)
self.referent.deserialize(stream, self._refs, None)
def _serialize(self, stream: Stream) -> None:
from pullenti.ner.core.internal.SerializerHelper import SerializerHelper
super()._serialize(stream)
SerializerHelper.serialize_string(stream, self.term)
SerializerHelper.serialize_string(stream, self.lemma)
SerializerHelper.serialize_short(
stream, self.invariant_prefix_length_of_morph_vars)
SerializerHelper.serialize_short(stream, self.max_length_of_morph_vars)
def _serialize(self, stream: io.IOBase) -> None:
from pullenti.ner.core.internal.SerializerHelper import SerializerHelper
SerializerHelper.serializeInt(stream, self.begin_char)
SerializerHelper.serializeInt(stream, self.end_char)
SerializerHelper.serializeInt(stream, self.__m_attrs)
SerializerHelper.serializeInt(stream, self.chars.value)
if (self.__m_morph is None):
self.__m_morph = MorphCollection()
self.__m_morph._serialize(stream)
def serialize(self, stream : io.IOBase) -> None:
Utils.writeByteIO(stream, 0xAA)
Utils.writeByteIO(stream, 1)
self.__m_sofa.serialize(stream)
SerializerHelper.serializeInt(stream, self.base_language.value)
if (len(self.__m_entities) == 0):
for d in self.__m_datas.items():
self.__m_entities.extend(d[1].referents)
SerializerHelper.serializeInt(stream, len(self.__m_entities))
i = 0
while i < len(self.__m_entities):
self.__m_entities[i].tag = i + 1
SerializerHelper.serializeString(stream, self.__m_entities[i].type_name)
i += 1
for e0_ in self.__m_entities:
e0_.serialize(stream)
SerializerHelper.serializeTokens(stream, self.first_token, 0)
def serialize(self, stream: Stream) -> None:
stream.writebyte(0xAA)
stream.writebyte(1)
self.__m_sofa.serialize(stream)
SerializerHelper.serialize_int(stream, self.base_language.value)
if (len(self.__m_entities) == 0):
for d in self.__m_datas.items():
self.__m_entities.extend(d[1].referents)
SerializerHelper.serialize_int(stream, len(self.__m_entities))
i = 0
while i < len(self.__m_entities):
self.__m_entities[i].tag = i + 1
SerializerHelper.serialize_string(stream,
self.__m_entities[i].type_name)
i += 1
for e0_ in self.__m_entities:
e0_.serialize(stream)
SerializerHelper.serialize_tokens(stream, self.first_token, 0)
def _deserialize(self, stream: Stream) -> None:
from pullenti.ner.core.internal.SerializerHelper import SerializerHelper
self.__m_class = MorphClass._new53(
SerializerHelper.deserialize_short(stream))
self.__m_case = MorphCase._new29(
SerializerHelper.deserialize_short(stream))
self.__m_gender = (Utils.valToEnum(
SerializerHelper.deserialize_short(stream), MorphGender))
self.__m_number = (Utils.valToEnum(
SerializerHelper.deserialize_short(stream), MorphNumber))
self.__m_voice = (Utils.valToEnum(
SerializerHelper.deserialize_short(stream), MorphVoice))
self.__m_language = MorphLang._new56(
SerializerHelper.deserialize_short(stream))
cou = SerializerHelper.deserialize_int(stream)
self.__m_items = list()
i = 0
while i < cou:
it = self.__deserialize_item(stream)
if (it is not None):
self.__m_items.append(it)
i += 1
self.__m_need_recalc = False
def deserialize(self, stream: Stream) -> None:
self.text = SerializerHelper.deserialize_string(stream)
def _serialize(self, stream: Stream) -> None:
SerializerHelper.serialize_string(
stream, (None if self.ext_id is None else str(self.ext_id)))
SerializerHelper.serialize_string(stream, self.__m_caption)
if (self._refs is None):
SerializerHelper.serialize_int(stream, 0)
else:
SerializerHelper.serialize_int(stream, len(self._refs))
id0_ = 1
for r in self._refs:
r.tag = id0_
id0_ += 1
for r in self._refs:
r.occurrence.clear()
SerializerHelper.serialize_string(stream, r.type_name)
r.serialize(stream)
self.referent.occurrence.clear()
SerializerHelper.serialize_string(stream, self.type_name)
self.referent.serialize(stream)
def _deserialize(self, stream: Stream, kit_: 'AnalysisKit',
vers: int) -> None:
super()._deserialize(stream, kit_, vers)
id0_ = SerializerHelper.deserialize_int(stream)
if (id0_ > 0):
self.referent = kit_.entities[id0_ - 1]
def serialize(self, stream: io.IOBase) -> None:
SerializerHelper.serializeString(stream, self.text)
def deserialize(self, stream: io.IOBase) -> None:
self.text = SerializerHelper.deserializeString(stream)
def _serialize(self, stream: Stream) -> None:
from pullenti.ner.core.internal.SerializerHelper import SerializerHelper
SerializerHelper.serialize_short(stream, self.__m_class.value)
SerializerHelper.serialize_short(stream, self.__m_case.value)
SerializerHelper.serialize_short(stream, self.__m_gender)
SerializerHelper.serialize_short(stream, self.__m_number)
SerializerHelper.serialize_short(stream, self.__m_voice)
SerializerHelper.serialize_short(stream, self.__m_language.value)
if (self.__m_items is None):
self.__m_items = list()
SerializerHelper.serialize_int(stream, len(self.__m_items))
for it in self.__m_items:
self.__serialize_item(stream, it)
def _serialize(self, stream: Stream) -> None:
from pullenti.ner.core.internal.SerializerHelper import SerializerHelper
super()._serialize(stream)
SerializerHelper.serialize_string(stream, self.__m_value)
SerializerHelper.serialize_int(stream, self.typ)
def __serialize_item(self, stream: Stream, bi: 'MorphBaseInfo') -> None:
from pullenti.ner.core.internal.SerializerHelper import SerializerHelper
ty = 0
if (isinstance(bi, MorphWordForm)):
ty = (1)
stream.writebyte(ty)
SerializerHelper.serialize_short(stream, bi.class0_.value)
SerializerHelper.serialize_short(stream, bi.case_.value)
SerializerHelper.serialize_short(stream, bi.gender)
SerializerHelper.serialize_short(stream, bi.number)
SerializerHelper.serialize_short(stream, bi.language.value)
wf = Utils.asObjectOrNull(bi, MorphWordForm)
if (wf is None):
return
SerializerHelper.serialize_string(stream, wf.normal_case)
SerializerHelper.serialize_string(stream, wf.normal_full)
SerializerHelper.serialize_short(stream, wf.undef_coef)
SerializerHelper.serialize_int(
stream, (0 if wf.misc is None else len(wf.misc.attrs)))
if (wf.misc is not None):
for a in wf.misc.attrs:
SerializerHelper.serialize_string(stream, a)
def serialize(self, stream: io.IOBase) -> None:
SerializerHelper.serializeString(stream, self.type_name)
SerializerHelper.serializeInt(stream, len(self.__m_slots))
for s in self.__m_slots:
SerializerHelper.serializeString(stream, s.type_name)
SerializerHelper.serializeInt(stream, s.count)
if ((isinstance(s.value, Referent)) and (isinstance(
(s.value).tag, int))):
SerializerHelper.serializeInt(stream, -((s.value).tag))
elif (isinstance(s.value, str)):
SerializerHelper.serializeString(
stream, Utils.asObjectOrNull(s.value, str))
elif (s.value is None):
SerializerHelper.serializeInt(stream, 0)
else:
SerializerHelper.serializeString(stream, str(s.value))
if (self.__m_occurrence is None):
SerializerHelper.serializeInt(stream, 0)
else:
SerializerHelper.serializeInt(stream, len(self.__m_occurrence))
for o in self.__m_occurrence:
SerializerHelper.serializeInt(stream, o.begin_char)
SerializerHelper.serializeInt(stream, o.end_char)
attr = 0
if (o.essential_for_occurence):
attr = 1
SerializerHelper.serializeInt(stream, attr)
def serialize(self, stream: Stream) -> None:
SerializerHelper.serialize_string(stream, self.text)
