def initialize() -> None:
if (SentimentAnalyzer.__m_inited):
return
SentimentAnalyzer.__m_inited = True
MetaSentiment.initialize()
Termin.ASSIGN_ALL_TEXTS_AS_NORMAL = True
try:
for i in range(2):
str0_ = EpNerBusinessInternalResourceHelper.getString(
("Positives.txt" if i == 0 else "Negatives.txt"))
if (str0_ is None):
continue
for line0 in Utils.splitString(str0_, '\n', False):
line = line0.strip()
if (Utils.isNullOrEmpty(line)):
continue
coef = (1 if i == 0 else -1)
SentimentAnalyzer.__m_termins.add(
Termin._new117(line, coef))
except Exception as ex:
pass
for s in ["ОЧЕНЬ", "СИЛЬНО"]:
SentimentAnalyzer.__m_termins.add(Termin._new117(s, 0))
Termin.ASSIGN_ALL_TEXTS_AS_NORMAL = False
ProcessorService.registerAnalyzer(SentimentAnalyzer())
def initialize(lang : 'MorphLang'=None) -> None:
""" Вызывать инициализацию в самом начале
Args:
lang(MorphLang): по умолчанию, русский и английский
"""
ProcessorService.initialize(lang)
MoneyAnalyzer.initialize()
UriAnalyzer.initialize()
PhoneAnalyzer.initialize()
DateAnalyzer.initialize()
KeywordAnalyzer.initialize()
DefinitionAnalyzer.initialize()
DenominationAnalyzer.initialize()
MeasureAnalyzer.initialize()
BankAnalyzer.initialize()
GeoAnalyzer.initialize()
AddressAnalyzer.initialize()
OrganizationAnalyzer.initialize()
PersonAnalyzer.initialize()
MailAnalyzer.initialize()
TransportAnalyzer.initialize()
DecreeAnalyzer.initialize()
InstrumentAnalyzer.initialize()
TitlePageAnalyzer.initialize()
BookLinkAnalyzer.initialize()
BusinessAnalyzer.initialize()
NamedEntityAnalyzer.initialize()
WeaponAnalyzer.initialize()
def initialize() -> None:
MetaTitleInfo.initialize()
try:
Termin.ASSIGN_ALL_TEXTS_AS_NORMAL = True
TitleItemToken.initialize()
Termin.ASSIGN_ALL_TEXTS_AS_NORMAL = False
except Exception as ex:
raise Utils.newException(ex.__str__(), ex)
ProcessorService.registerAnalyzer(TitlePageAnalyzer())
def initialize() -> None:
if (BankAnalyzer.__m_ontology is not None):
return
MetaBank.initialize()
BankAnalyzer.__m_ontology = TerminCollection()
t = Termin("БАНКОВСКИЕ РЕКВИЗИТЫ", None, True)
t.addVariant("ПЛАТЕЖНЫЕ РЕКВИЗИТЫ", False)
t.addVariant("РЕКВИЗИТЫ", False)
BankAnalyzer.__m_ontology.add(t)
ProcessorService.registerAnalyzer(BankAnalyzer())
def initialize() -> None:
if (BusinessAnalyzer.__m_inited):
return
BusinessAnalyzer.__m_inited = True
MetaBusinessFact.initialize()
FundsMeta.initialize()
Termin.ASSIGN_ALL_TEXTS_AS_NORMAL = True
BusinessFactItem.initialize()
Termin.ASSIGN_ALL_TEXTS_AS_NORMAL = False
ProcessorService.registerAnalyzer(BusinessAnalyzer())
def initialize() -> None:
MetaBookLink.initialize2()
MetaBookLinkRef.initialize()
try:
Termin.ASSIGN_ALL_TEXTS_AS_NORMAL = True
BookLinkToken.initialize()
Termin.ASSIGN_ALL_TEXTS_AS_NORMAL = False
except Exception as ex:
raise Utils.newException(ex.__str__(), ex)
ProcessorService.registerAnalyzer(BookLinkAnalyzer())
def initialize() -> None:
if (NamedEntityAnalyzer.__m_inited):
return
NamedEntityAnalyzer.__m_inited = True
try:
MetaNamedEntity.initialize()
Termin.ASSIGN_ALL_TEXTS_AS_NORMAL = True
NamedItemToken._initialize()
Termin.ASSIGN_ALL_TEXTS_AS_NORMAL = False
except Exception as ex:
raise Utils.newException(ex.__str__(), ex)
ProcessorService.register_analyzer(NamedEntityAnalyzer())
def initialize() -> None:
with MeasureAnalyzer.__m_lock:
if (MeasureAnalyzer.__m_initialized):
return
MeasureAnalyzer.__m_initialized = True
MeasureMeta.initialize()
UnitMeta.initialize()
Termin.ASSIGN_ALL_TEXTS_AS_NORMAL = True
UnitsHelper.initialize()
NumbersWithUnitToken._initialize()
Termin.ASSIGN_ALL_TEXTS_AS_NORMAL = False
ProcessorService.registerAnalyzer(MeasureAnalyzer())
def initialize() -> None:
if (WeaponAnalyzer.__m_inited):
return
WeaponAnalyzer.__m_inited = True
MetaWeapon.initialize()
try:
Termin.ASSIGN_ALL_TEXTS_AS_NORMAL = True
WeaponItemToken.initialize()
Termin.ASSIGN_ALL_TEXTS_AS_NORMAL = False
except Exception as ex:
raise Utils.newException(ex.__str__(), ex)
ProcessorService.registerAnalyzer(WeaponAnalyzer())
def initialize() -> None:
if (MailAnalyzer.__m_inited):
return
MailAnalyzer.__m_inited = True
try:
MetaLetter.initialize()
Termin.ASSIGN_ALL_TEXTS_AS_NORMAL = True
MailLine.initialize()
Termin.ASSIGN_ALL_TEXTS_AS_NORMAL = False
except Exception as ex:
raise Utils.newException(ex.__str__(), ex)
ProcessorService.registerAnalyzer(MailAnalyzer())
def initialize() -> None:
if (KeywordAnalyzer.M_INITIALIZED):
return
KeywordAnalyzer.M_INITIALIZED = True
try:
KeywordMeta.initialize()
Termin.ASSIGN_ALL_TEXTS_AS_NORMAL = True
DenominationAnalyzer.initialize()
Termin.ASSIGN_ALL_TEXTS_AS_NORMAL = False
ProcessorService.register_analyzer(KeywordAnalyzer())
except Exception as ex:
raise Utils.newException(ex.__str__(), ex)
def initialize() -> None:
if (PhoneAnalyzer.M_INITED):
return
PhoneAnalyzer.M_INITED = True
MetaPhone.initialize()
try:
Termin.ASSIGN_ALL_TEXTS_AS_NORMAL = True
PhoneHelper.initialize()
PhoneItemToken.initialize()
Termin.ASSIGN_ALL_TEXTS_AS_NORMAL = False
except Exception as ex:
raise Utils.newException(ex.__str__(), ex)
ProcessorService.register_analyzer(PhoneAnalyzer())
def initialize() -> None:
with GoodsAnalyzer.__m_lock:
if (GoodsAnalyzer.__m_initialized):
return
GoodsAnalyzer.__m_initialized = True
AttrMeta.initialize()
GoodMeta.initialize()
try:
Termin.ASSIGN_ALL_TEXTS_AS_NORMAL = True
GoodAttrToken.initialize()
Termin.ASSIGN_ALL_TEXTS_AS_NORMAL = False
except Exception as ex:
raise Utils.newException(ex.__str__(), ex)
ProcessorService.register_analyzer(GoodsAnalyzer())
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 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 initialize() -> None:
from pullenti.ner.instrument.internal.ParticipantToken import ParticipantToken
if (InstrumentAnalyzer.__m_inited):
return
InstrumentAnalyzer.__m_inited = True
InstrumentArtefactMeta.initialize()
MetaInstrumentBlock.initialize()
MetaInstrument.initialize()
InstrumentParticipantMeta.initialize()
try:
Termin.ASSIGN_ALL_TEXTS_AS_NORMAL = True
InstrToken.initialize()
ParticipantToken.initialize()
Termin.ASSIGN_ALL_TEXTS_AS_NORMAL = False
except Exception as ex:
raise Utils.newException(ex.__str__(), ex)
ProcessorService.registerAnalyzer(InstrumentAnalyzer())
def __init__(self, analyzers):
for analyzer in analyzers:
assert_one_of(analyzer, ANALYZERS)
self.analyzers = analyzers
langs = loaded_langs() or DEFAULT_LANGS
raw = langs_to_raw(langs)
ProcessorService.initialize(raw)
for analyzer in ANALYZERS:
if analyzer not in INITIALIZED:
TYPE_ANALYZERS[analyzer].initialize()
INITIALIZED.add(analyzer)
self.raw = RawProcessor()
for analyzer in select_analyzers(self.analyzers):
self.raw.add_analyzer(analyzer)
def initialize() -> None:
if (OrgGlobal.GLOBAL_ORGS is not None):
return
OrgGlobal.GLOBAL_ORGS = IntOntologyCollection()
org0_ = None
oi = None
with ProcessorService.create_empty_processor() as geo_proc:
geo_proc.add_analyzer(GeoAnalyzer())
geos = dict()
for k in range(3):
lang = (MorphLang.RU if k == 0 else (MorphLang.EN if k == 1 else MorphLang.UA))
name = ("Orgs_ru.dat" if k == 0 else ("Orgs_en.dat" if k == 1 else "Orgs_ua.dat"))
dat = PullentiNerOrgInternalResourceHelper.get_bytes(name)
if (dat is None):
raise Utils.newException("Can't file resource file {0} in Organization analyzer".format(name), None)
with MemoryStream(OrgItemTypeToken._deflate(dat)) as tmp:
tmp.position = 0
xml0_ = None # new XmlDocument
xml0_ = Utils.parseXmlFromStream(tmp)
for x in xml0_.getroot():
org0_ = OrganizationReferent()
abbr = None
for xx in x:
if (Utils.getXmlLocalName(xx) == "typ"):
org0_.add_slot(OrganizationReferent.ATTR_TYPE, Utils.getXmlInnerText(xx), False, 0)
elif (Utils.getXmlLocalName(xx) == "nam"):
org0_.add_slot(OrganizationReferent.ATTR_NAME, Utils.getXmlInnerText(xx), False, 0)
elif (Utils.getXmlLocalName(xx) == "epo"):
org0_.add_slot(OrganizationReferent.ATTR_EPONYM, Utils.getXmlInnerText(xx), False, 0)
elif (Utils.getXmlLocalName(xx) == "prof"):
org0_.add_slot(OrganizationReferent.ATTR_PROFILE, Utils.getXmlInnerText(xx), False, 0)
elif (Utils.getXmlLocalName(xx) == "abbr"):
abbr = Utils.getXmlInnerText(xx)
elif (Utils.getXmlLocalName(xx) == "geo"):
geo_ = None
wrapgeo1767 = RefOutArgWrapper(None)
inoutres1768 = Utils.tryGetValue(geos, Utils.getXmlInnerText(xx), wrapgeo1767)
geo_ = wrapgeo1767.value
if (not inoutres1768):
ar = geo_proc.process(SourceOfAnalysis(Utils.getXmlInnerText(xx)), None, lang)
if (ar is not None and len(ar.entities) == 1 and (isinstance(ar.entities[0], GeoReferent))):
geo_ = (Utils.asObjectOrNull(ar.entities[0], GeoReferent))
geos[Utils.getXmlInnerText(xx)] = geo_
else:
pass
if (geo_ is not None):
org0_.add_slot(OrganizationReferent.ATTR_GEO, geo_, False, 0)
oi = org0_.create_ontology_item_ex(2, True, True)
if (oi is None):
continue
if (abbr is not None):
oi.termins.append(Termin(abbr, None, True))
if (k == 2):
OrgGlobal.GLOBAL_ORGS_UA.add_item(oi)
else:
OrgGlobal.GLOBAL_ORGS.add_item(oi)
return
def __init(self) -> None:
self.__m_processor = ProcessorService.create_specific_processor(
self.__m_specs)
self.__m_anal_by_type = dict()
for a in self.__m_processor.analyzers:
a._persist_referents_regim = True
if (a.name == "DENOMINATION"):
a.ignore_this_analyzer = True
else:
for t in a.type_system:
if (not t.name in self.__m_anal_by_type):
self.__m_anal_by_type[t.name] = a
def clone(self) -> 'Referent':
from pullenti.ner.Slot import Slot
res = ProcessorService.createReferent(self.type_name)
if (res is None):
res = Referent(self.type_name)
res.occurrence.extend(self.occurrence)
res.ontology_items = self.ontology_items
for r in self.slots:
rr = Slot._new2690(r.type_name, r.value, r.count)
rr.owner = res
res.slots.append(rr)
return res
def initialize(lang: 'MorphLang' = None) -> None:
""" Инициализация SDK.
Вызывать в самом начале работы. Инициализируется морфология (MorphologyService),
служба процессоров (ProcessorService), все доступные анализаторы сущностей и
семантический анализ (SemanticService). Так что больше ничего инициализировать не нужно.
Args:
lang(MorphLang): по умолчанию, русский и английский
Инициализация конкретных языков
"""
# сначала инициализация всего сервиса
ProcessorService.initialize(lang)
# а затем конкретные анализаторы (какие нужно, в данном случае - все)
MoneyAnalyzer.initialize()
UriAnalyzer.initialize()
PhoneAnalyzer.initialize()
DateAnalyzer.initialize()
KeywordAnalyzer.initialize()
DefinitionAnalyzer.initialize()
DenominationAnalyzer.initialize()
MeasureAnalyzer.initialize()
BankAnalyzer.initialize()
GeoAnalyzer.initialize()
AddressAnalyzer.initialize()
OrganizationAnalyzer.initialize()
PersonAnalyzer.initialize()
MailAnalyzer.initialize()
TransportAnalyzer.initialize()
DecreeAnalyzer.initialize()
InstrumentAnalyzer.initialize()
TitlePageAnalyzer.initialize()
BookLinkAnalyzer.initialize()
GoodsAnalyzer.initialize()
NamedEntityAnalyzer.initialize()
WeaponAnalyzer.initialize()
# ещё инициализируем семантическую обработки (в принципе, она не используется для задачи NER)
SemanticService.initialize()
def __init__(self, spec_names : str=None) -> None:
self.items = list()
self.__m_processor = None;
self.__m_anal_by_type = None;
self.__m_hash = None
self.__m_processor = ProcessorService.createSpecificProcessor(spec_names)
self.__m_anal_by_type = dict()
for a in self.__m_processor.analyzers:
a._persist_referents_regim = True
if (a.name == "DENOMINATION"):
a.ignore_this_analyzer = True
else:
for t in a.type_system:
if (not t.name in self.__m_anal_by_type):
self.__m_anal_by_type[t.name] = a
def initialize() -> None:
if (DenominationAnalyzer.__m_inites):
return
DenominationAnalyzer.__m_inites = True
MetaDenom.initialize()
ProcessorService.register_analyzer(DenominationAnalyzer())
def get_version_date() -> str:
""" Дата выпуска версии SDK """
return ProcessorService.get_version_date()
def getVersion() -> str:
return ProcessorService.getVersion()
def main(args: typing.List[str]) -> None:
sw = Stopwatch()
# инициализация - необходимо проводить один раз до обработки текстов
print("Initializing ... ", end="", flush=True)
# инициализируются движок и все имеющиеся анализаторы
Sdk.initialize((MorphLang.RU) | MorphLang.EN)
sw.stop()
print("OK (by {0} ms), version {1}".format(
sw.elapsedMilliseconds, ProcessorService.getVersion()),
flush=True)
# анализируемый текст
txt = "Единственным конкурентом «Трансмаша» на этом сомнительном тендере было ООО «Плассер Алека Рейл Сервис», основным владельцем которого является австрийская компания «СТЦ-Холдинг ГМБХ». До конца 2011 г. эта же фирма была совладельцем «Трансмаша» вместе с «Тако» Краснова. Зато совладельцем «Плассера», также до конца 2011 г., был тот самый Карл Контрус, который имеет четверть акций «Трансмаша». "
print("Text: {0}".format(txt), flush=True)
# запускаем обработку на пустом процессоре (без анализаторов NER)
are = ProcessorService.getEmptyProcessor().process(
SourceOfAnalysis(txt), None, None)
print("Noun groups: ", end="", flush=True)
t = are.first_token
# перебираем токены
first_pass2703 = True
while True:
if first_pass2703: first_pass2703 = False
else: t = t.next0_
if (not (t is not None)): break
# выделяем именную группу с текущего токена
npt = NounPhraseHelper.tryParse(t, NounPhraseParseAttr.NO, 0)
# не получилось
if (npt is None):
continue
# получилось, выводим в нормализованном виде
print("[{0}=>{1}] ".format(
npt.getSourceText(),
npt.getNormalCaseText(None, True, MorphGender.UNDEFINED,
False)),
end="",
flush=True)
# указатель на последний токен именной группы
t = npt.end_token
with ProcessorService.createProcessor() as proc:
# анализируем текст
ar = proc.process(SourceOfAnalysis(txt), None, None)
# результирующие сущности
print(
"\r\n==========================================\r\nEntities: ",
flush=True)
for e0_ in ar.entities:
print("{0}: {1}".format(e0_.type_name, str(e0_)), flush=True)
for s in e0_.slots:
print(" {0}: {1}".format(s.type_name, s.value),
flush=True)
# пример выделения именных групп
print(
"\r\n==========================================\r\nNoun groups: ",
flush=True)
t = ar.first_token
first_pass2704 = True
while True:
if first_pass2704: first_pass2704 = False
else: t = t.next0_
if (not (t is not None)): break
# токены с сущностями игнорируем
if (t.getReferent() is not None):
continue
# пробуем создать именную группу
npt = NounPhraseHelper.tryParse(
t, NounPhraseParseAttr.ADJECTIVECANBELAST, 0)
# не получилось
if (npt is None):
continue
print(npt, flush=True)
# указатель перемещаем на последний токен группы
t = npt.end_token
with ProcessorService.createSpecificProcessor(
KeywordAnalyzer.ANALYZER_NAME) as proc:
ar = proc.process(SourceOfAnalysis(txt), None, None)
print(
"\r\n==========================================\r\nKeywords1: ",
flush=True)
for e0_ in ar.entities:
if (isinstance(e0_, KeywordReferent)):
print(e0_, flush=True)
print(
"\r\n==========================================\r\nKeywords2: ",
flush=True)
t = ar.first_token
first_pass2705 = True
while True:
if first_pass2705: first_pass2705 = False
else: t = t.next0_
if (not (t is not None)): break
if (isinstance(t, ReferentToken)):
kw = Utils.asObjectOrNull(t.getReferent(), KeywordReferent)
if (kw is None):
continue
kwstr = MiscHelper.getTextValueOfMetaToken(
Utils.asObjectOrNull(t, ReferentToken),
Utils.valToEnum(
(GetTextAttr.FIRSTNOUNGROUPTONOMINATIVESINGLE) |
(GetTextAttr.KEEPREGISTER), GetTextAttr))
print("{0} = {1}".format(kwstr, kw), flush=True)
print("Over!", flush=True)
def initialize() -> None:
if (MoneyAnalyzer.__m_inited):
return
MoneyAnalyzer.__m_inited = True
MoneyMeta.initialize()
ProcessorService.register_analyzer(MoneyAnalyzer())
def select_analyzers(selected):
for analyzer in ProcessorService.get_analyzers():
if analyzer.name in selected:
analyzer = analyzer.clone()
if analyzer is not None: # TODO why would it happen?
yield analyzer
def initialize() -> None:
if (UriAnalyzer.__m_schemes is not None):
return
Termin.ASSIGN_ALL_TEXTS_AS_NORMAL = True
MetaUri.initialize()
try:
UriAnalyzer.__m_schemes = TerminCollection()
obj = EpNerBankInternalResourceHelper.getString("UriSchemes.csv")
if (obj is None):
raise Utils.newException("Can't file resource file {0} in Organization analyzer".format("UriSchemes.csv"), None)
for line0 in Utils.splitString(obj, '\n', False):
line = line0.strip()
if (Utils.isNullOrEmpty(line)):
continue
UriAnalyzer.__m_schemes.add(Termin._new678(line, MorphLang.UNKNOWN, True, 0))
for s in ["ISBN", "УДК", "ББК", "ТНВЭД", "ОКВЭД"]:
UriAnalyzer.__m_schemes.add(Termin._new678(s, MorphLang.UNKNOWN, True, 1))
UriAnalyzer.__m_schemes.add(Termin._new2573("Общероссийский классификатор форм собственности", "ОКФС", 1, "ОКФС"))
UriAnalyzer.__m_schemes.add(Termin._new2573("Общероссийский классификатор организационно правовых форм", "ОКОПФ", 1, "ОКОПФ"))
UriAnalyzer.__m_schemes.add(Termin._new678("WWW", MorphLang.UNKNOWN, True, 2))
UriAnalyzer.__m_schemes.add(Termin._new678("HTTP", MorphLang.UNKNOWN, True, 10))
UriAnalyzer.__m_schemes.add(Termin._new678("HTTPS", MorphLang.UNKNOWN, True, 10))
UriAnalyzer.__m_schemes.add(Termin._new678("SHTTP", MorphLang.UNKNOWN, True, 10))
UriAnalyzer.__m_schemes.add(Termin._new678("FTP", MorphLang.UNKNOWN, True, 10))
t = Termin._new678("SKYPE", MorphLang.UNKNOWN, True, 3)
t.addVariant("СКАЙП", True)
t.addVariant("SKYPEID", True)
t.addVariant("SKYPE ID", True)
UriAnalyzer.__m_schemes.add(t)
t = Termin._new678("SWIFT", MorphLang.UNKNOWN, True, 3)
t.addVariant("СВИФТ", True)
UriAnalyzer.__m_schemes.add(t)
UriAnalyzer.__m_schemes.add(Termin._new678("ICQ", MorphLang.UNKNOWN, True, 4))
t = Termin._new2583("основной государственный регистрационный номер", "ОГРН", 5, "ОГРН", True)
t.addVariant("ОГРН ИП", True)
UriAnalyzer.__m_schemes.add(t)
UriAnalyzer.__m_schemes.add(Termin._new2583("Индивидуальный идентификационный номер", "ИИН", 5, "ИИН", True))
UriAnalyzer.__m_schemes.add(Termin._new2583("Индивидуальный номер налогоплательщика", "ИНН", 5, "ИНН", True))
UriAnalyzer.__m_schemes.add(Termin._new2583("Код причины постановки на учет", "КПП", 5, "КПП", True))
UriAnalyzer.__m_schemes.add(Termin._new2583("Банковский идентификационный код", "БИК", 5, "БИК", True))
UriAnalyzer.__m_schemes.add(Termin._new2583("основной государственный регистрационный номер индивидуального предпринимателя", "ОГРНИП", 5, "ОГРНИП", True))
t = Termin._new2583("Страховой номер индивидуального лицевого счёта", "СНИЛС", 5, "СНИЛС", True)
t.addVariant("Свидетельство пенсионного страхования", False)
t.addVariant("Страховое свидетельство обязательного пенсионного страхования", False)
t.addVariant("Страховое свидетельство", False)
UriAnalyzer.__m_schemes.add(t)
UriAnalyzer.__m_schemes.add(Termin._new2583("Общероссийский классификатор предприятий и организаций", "ОКПО", 5, "ОКПО", True))
UriAnalyzer.__m_schemes.add(Termin._new2583("Общероссийский классификатор объектов административно-территориального деления", "ОКАТО", 5, "ОКАТО", True))
UriAnalyzer.__m_schemes.add(Termin._new2583("Общероссийский классификатор территорий муниципальных образований", "ОКТМО", 5, "ОКТМО", True))
UriAnalyzer.__m_schemes.add(Termin._new2583("Общероссийский классификатор органов государственной власти и управления", "ОКОГУ", 5, "ОКОГУ", True))
UriAnalyzer.__m_schemes.add(Termin._new2583("Общероссийский классификатор Отрасли народного хозяйства", "ОКОНХ", 5, "ОКОНХ", True))
t = Termin._new2595("РАСЧЕТНЫЙ СЧЕТ", MorphLang.UNKNOWN, True, "Р/С", 6, 20)
t.addAbridge("Р.С.")
t.addAbridge("Р.СЧ.")
t.addAbridge("P.C.")
t.addAbridge("РАСЧ.СЧЕТ")
t.addAbridge("РАС.СЧЕТ")
t.addAbridge("РАСЧ.СЧ.")
t.addAbridge("РАС.СЧ.")
t.addAbridge("Р.СЧЕТ")
t.addVariant("СЧЕТ ПОЛУЧАТЕЛЯ", False)
t.addVariant("СЧЕТ ОТПРАВИТЕЛЯ", False)
t.addVariant("СЧЕТ", False)
UriAnalyzer.__m_schemes.add(t)
t = Termin._new2596("ЛИЦЕВОЙ СЧЕТ", "Л/С", 6, 20)
t.addAbridge("Л.С.")
t.addAbridge("Л.СЧ.")
t.addAbridge("Л/С")
t.addAbridge("ЛИЦ.СЧЕТ")
t.addAbridge("ЛИЦ.СЧ.")
t.addAbridge("Л.СЧЕТ")
UriAnalyzer.__m_schemes.add(t)
t = Termin._new2595("СПЕЦИАЛЬНЫЙ ЛИЦЕВОЙ СЧЕТ", MorphLang.UNKNOWN, True, "СПЕЦ/С", 6, 20)
t.addAbridge("СПЕЦ.С.")
t.addAbridge("СПЕЦ.СЧЕТ")
t.addAbridge("СПЕЦ.СЧ.")
t.addVariant("СПЕЦСЧЕТ", True)
t.addVariant("СПЕЦИАЛЬНЫЙ СЧЕТ", True)
UriAnalyzer.__m_schemes.add(t)
t = Termin._new2595("КОРРЕСПОНДЕНТСКИЙ СЧЕТ", MorphLang.UNKNOWN, True, "К/С", 6, 20)
t.addAbridge("КОРР.СЧЕТ")
t.addAbridge("КОР.СЧЕТ")
t.addAbridge("КОРР.СЧ.")
t.addAbridge("КОР.СЧ.")
t.addAbridge("К.СЧЕТ")
t.addAbridge("КОР.С.")
t.addAbridge("К.С.")
t.addAbridge("K.C.")
t.addAbridge("К-С")
t.addAbridge("К/С")
t.addAbridge("К.СЧ.")
t.addAbridge("К/СЧ")
UriAnalyzer.__m_schemes.add(t)
t = Termin._new2599("КОД БЮДЖЕТНОЙ КЛАССИФИКАЦИИ", "КБК", "КБК", 6, 20, True)
UriAnalyzer.__m_schemes.add(t)
UriItemToken.initialize()
except Exception as ex:
raise Utils.newException(ex.__str__(), ex)
Termin.ASSIGN_ALL_TEXTS_AS_NORMAL = False
ProcessorService.registerAnalyzer(UriAnalyzer())