def f1():
if not self.diff and self.other:
self.diff = RdfDiff()
try:
self.diff.CompareProc(self.document, self.other)
except:
log.exception()
other = GraphDocument()
self.diff.MakeLocalDiff(other, self.document)
other.UpdateNamespacesFromLoad()
props_source = self.other if self.other else self.document
props = {}
for k in type(self.document).doc_params:
v = getattr(props_source, k, None)
if v != None:
props[k] = v
other.UpdateProps(props)
all_subj = self.diff.deletions.ks.viewkeys() | self.diff.insertions.ks.viewkeys()
new_subj = self.diff.insertions.ks.viewkeys() - self.document.ks.viewkeys()
del_subj = self.diff.deletions.ks.viewkeys() - other.ks.viewkeys()
chn_subj = all_subj - new_subj - del_subj
self.subjects = []
if self.show_changed:
self.subjects += list(chn_subj)
if self.show_added:
self.subjects += list(new_subj)
if self.show_deleted:
self.subjects += list(del_subj)
if self.text:
res_doc = self.document._grSearchLabel(self.text)
res_other = other._grSearchLabel(self.text)
self.subjects = list((res_doc | res_other) & set([expand_uri(uri) for uri in self.subjects]))
self.subjects = [compact_uri(uri) for uri in self.subjects]
if self.filter_params:
env = appdata.environment_manager.GetWorkEnvironment(self.document, include_scanner=True)
res_doc = env['scanner']._find(**self.filter_params)
env = appdata.environment_manager.GetWorkEnvironment(other, include_scanner=True)
res_other = env['scanner']._find(**self.filter_params)
self.subjects = list((res_doc | res_other) & set([expand_uri(uri) for uri in self.subjects]))
self.subjects = [compact_uri(uri) for uri in self.subjects]
self.filter_params = None
count_all = len(all_subj)
count_filtered = len(self.subjects)
@public.mth
def f2():
self.ShowEntities()
self.pnode.treenode_loading = False
self.pnode.UpdateLabel(' [{1}/{2}]'.format(self.document.GetLabel(), count_filtered, count_all))
self.setEnabled(True)
self.seeding = False
def Do(cls):
path, wildcard = framework.dialogs.SelectFiles(cls.vis_label,
multi=False)
if not path:
return
doc_rdf = GraphDocument()
doc_rdf.NewImport([path], CatalogImporter,
**(dict(chosen_part2=kb.ns_dm_part2,
namespaces=kb.namespaces_std,
annotations=kb.annotations_pcardl_rdf_til)))
appdata.project.AddDocument(doc_rdf)
def OpenPaths(self, paths, node):
for p in paths:
if p.endswith('.15926'):
self.OpenProjectFile(p)
return
if not Document.VerifyEditablePaths(paths):
return
unresolved = []
for p in paths:
if p.endswith('.patt'):
doc = PatternsDocument()
doc.OpenFiles([p], {})
self.AddDocument(doc, node)
else:
unresolved.append(p)
if unresolved:
doc = GraphDocument()
params = dict(chosen_part2=kb.ns_dm_rds,
namespaces=kb.namespaces_std,
annotations=kb.annotations_rdfs +
kb.annotations_meta,
roles=kb.roles_std)
doc.OpenFiles(unresolved, **params)
self.AddDocument(doc, node)
def PrepareEnvironment(self):
if not bool(
appconfig.get('paths.p7tpl_tablan')
and appconfig.get('paths.rdl_tablan')
and appconfig.get('tablan.proj_ns')):
log('Import error: TabLan dependencies not set!\n')
return False
self.target_doc.UpdateProps(
{'basens': appconfig.get('tablan.proj_ns')})
self.p7tpl_doc = GraphDocument.FindDocumentByPaths(
[appconfig.get('paths.p7tpl_tablan')])
if not self.p7tpl_doc:
self.p7tpl_doc = GraphDocument()
param = dict(name="Template set (TabLan)",
chosen_part2=kb.ns_dm_part8,
module_name="p7tpl")
self.p7tpl_doc.OpenFiles([appconfig.get('paths.p7tpl_tablan')],
**param)
appdata.project.AddDocument(self.p7tpl_doc)
self.pcardl_doc = GraphDocument.FindDocumentByPaths(
[appconfig.get('paths.rdl_tablan')])
if not self.pcardl_doc:
self.pcardl_doc = GraphDocument()
param = dict(name='RDL (TabLan)',
chosen_part2=kb.ns_dm_part2,
namespaces=kb.namespaces_std,
annotations=kb.annotations_pcardl_rdf)
self.pcardl_doc.OpenFiles([appconfig.get('paths.rdl_tablan')],
**param)
appdata.project.AddDocument(self.pcardl_doc)
ready = True
if not self.p7tpl_doc.CanView():
wizard.Subscribe(self.p7tpl_doc, self)
ready = False
if not self.pcardl_doc.CanView():
wizard.Subscribe(self.pcardl_doc, self)
ready = False
return ready
def PrepareEnvironment(self):
"""Prepeares environment for import.
Here opened all files needed by import.
To check file is already opened here used FindDocumentByPaths document method.
"""
if not bool(appconfig.get('paths.p7tpl_catalog') and appconfig.get('paths.rdl_catalog') and appconfig.get('catalog.proj_ns')):
log('Import error: Catalog dependencies not set!\n')
return False
self.target_doc.UpdateProps({'basens': appconfig.get('catalog.proj_ns')})
self.p7tpl_doc = GraphDocument.FindDocumentByPaths([appconfig.get('paths.p7tpl_catalog')])
if not self.p7tpl_doc:
self.p7tpl_doc = GraphDocument()
param = dict(name="Template set (Catalog)", chosen_part2=kb.ns_dm_part8, module_name="p7tpl")
self.p7tpl_doc.OpenFiles([appconfig.get('paths.p7tpl_catalog')], **param)
appdata.project.AddDocument(self.p7tpl_doc)
self.pcardl_doc = GraphDocument.FindDocumentByPaths([appconfig.get('paths.rdl_catalog')])
if not self.pcardl_doc:
self.pcardl_doc = GraphDocument()
param = dict(name='RDL (Catalog)', chosen_part2=kb.ns_dm_part2, namespaces=kb.namespaces_std, annotations=kb.annotations_pcardl_rdf)
self.pcardl_doc.OpenFiles([appconfig.get('paths.rdl_catalog')], **param)
appdata.project.AddDocument(self.pcardl_doc)
ready = True
"""If file needed to be loaded, subscribe on it's events."""
if not self.p7tpl_doc.CanView():
wizard.Subscribe(self.p7tpl_doc, self)
ready = False
if not self.pcardl_doc.CanView():
wizard.Subscribe(self.pcardl_doc, self)
ready = False
return ready
class CatalogImporter:
def __init__(self, target_doc, import_source):
"""Constructor for importer has fixed arguments"""
self.attr_inheritance = appconfig.get('catalog.attr_inheritance')
self.source_path = import_source[0]
self.target_doc = target_doc
self.enviponment_prepeared = self.PrepareEnvironment()
self.DoImport()
def DoImport(self):
if not self.enviponment_prepeared:
return
if not self.InitEnvironment():
self.target_doc.ChangeState(self.target_doc.state_importfailed)
return
@public.wth('Importing {0}...'.format(self.target_doc.name), self.target_doc, self.p7tpl_doc, self.pcardl_doc)
def f():
try:
with open(self.source_path, 'r') as f:
self.data = json.load(f, 'windows-1251')
self.ProcessModel()
@public.mth
def f2():
self.target_doc.ChangeState(self.target_doc.state_changed)
except:
log.exception()
@public.mth
def f3():
self.target_doc.ChangeState(self.target_doc.state_importfailed)
def InitEnvironment(self):
"""Initilizes environment.
Environment is generally the same as console local variables,
so acces to them by module names and keywords like 'builder'.
'"""
environment = appdata.environment_manager.GetWorkEnvironment(self.target_doc, include_builder=True)
self.builder = environment.get('builder', None)
self.part2 = environment.get('part2', None)
self.p7tpl = environment.get(self.p7tpl_doc.module_name, None)
return self.builder and self.part2 and self.p7tpl
def PrepareEnvironment(self):
"""Prepeares environment for import.
Here opened all files needed by import.
To check file is already opened here used FindDocumentByPaths document method.
"""
if not bool(appconfig.get('paths.p7tpl_catalog') and appconfig.get('paths.rdl_catalog') and appconfig.get('catalog.proj_ns')):
log('Import error: Catalog dependencies not set!\n')
return False
self.target_doc.UpdateProps({'basens': appconfig.get('catalog.proj_ns')})
self.p7tpl_doc = GraphDocument.FindDocumentByPaths([appconfig.get('paths.p7tpl_catalog')])
if not self.p7tpl_doc:
self.p7tpl_doc = GraphDocument()
param = dict(name="Template set (Catalog)", chosen_part2=kb.ns_dm_part8, module_name="p7tpl")
self.p7tpl_doc.OpenFiles([appconfig.get('paths.p7tpl_catalog')], **param)
appdata.project.AddDocument(self.p7tpl_doc)
self.pcardl_doc = GraphDocument.FindDocumentByPaths([appconfig.get('paths.rdl_catalog')])
if not self.pcardl_doc:
self.pcardl_doc = GraphDocument()
param = dict(name='RDL (Catalog)', chosen_part2=kb.ns_dm_part2, namespaces=kb.namespaces_std, annotations=kb.annotations_pcardl_rdf)
self.pcardl_doc.OpenFiles([appconfig.get('paths.rdl_catalog')], **param)
appdata.project.AddDocument(self.pcardl_doc)
ready = True
"""If file needed to be loaded, subscribe on it's events."""
if not self.p7tpl_doc.CanView():
wizard.Subscribe(self.p7tpl_doc, self)
ready = False
if not self.pcardl_doc.CanView():
wizard.Subscribe(self.pcardl_doc, self)
ready = False
return ready
def W_DocumentStateChanged(self, doc):
"""This handler detects that necessary files were loaded succesfully."""
if doc.CanView():
wizard.Unsubscribe(doc, self)
elif doc.IsUnavailable():
log('Import error: {0} unavailable!\n', doc.name)
self.target_doc.ChangeState(self.target_doc.state_importfailed)
wizard.Unsubscribe(doc, self)
if self.p7tpl_doc.CanView() and self.pcardl_doc.CanView():
self.enviponment_prepeared = True
appdata.app.After(self.DoImport)
def GetUnitByDesc(self, attribute):
unit_type = attribute['unit']
if unit_type == '':
return None
if unit_type in self.unit_generated:
return self.unit_generated[unit_type]
else:
unit_item = self.part2.Scale()
self.builder.annotate(id = unit_item, label=unit_type)
self.unit_generated[unit_type] = unit_item
return unit_item
def GetAttributeById(self, attr_id):
if attr_id in self.attr_generated:
return self.attr_generated[attr_id]
return None
def GetAttributeByDesc(self, attribute):
attr_id = attribute['id']
if attr_id == '':
return None
if attr_id in self.attr_generated:
return self.attr_generated[attr_id]
else:
item = None
type = attribute['type']
if type == 'string':
item = self.part2.ClassOfClassOfIndividual()
self.builder.annotate(id = item, label=attr_id)
elif type == 'real':
item = self.part2.ClassOfIndirectProperty()
self.builder.annotate(id = item, label=attr_id)
elif type == 'integer':
item = self.part2.EnumeratedPropertySet()
self.builder.annotate(id = item, label=attr_id)
elif type == 'date/time':
item_a = self.part2.RoleAndDomain()
self.builder.annotate(id = item_a, label="POSSESOR_OF_"+attr_id)
self.attr_generated["POSSESOR_OF_"+attr_id] = item_a
item_b = self.part2.RoleAndDomain()
self.builder.annotate(id = item_b, label="RANGE_OF_"+attr_id)
self.attr_generated["RANGE_OF_"+attr_id] = item_b
self.p7tpl.Specialization(item_b, "http://posccaesar.org/rdl/RDS16432820")
item = self.part2.ClassOfRelationshipWithSignature(hasClassOfEnd1 = item_a, hasClassOfEnd2 = item_b)
self.builder.annotate(id = item, label=attr_id)
elif type == 'reference':
item = self.part2.ClassOfClassOfIndividual()
self.builder.annotate(id = item, label=attr_id)
else:
return None
self.part2.Classification(hasClassified=item, hasClassifier=self.attr_type)
self.RusIdent(item, attribute['name'])
self.attr_generated[attr_id] = item
return item
def ProcessAttribute(self, attribute, class_item):
attr_item = self.GetAttributeByDesc(attribute)
unit_item = self.GetUnitByDesc(attribute)
if attr_item:
type = attribute['type']
if type == 'string':
self.p7tpl.ClassOfClassification(class_item, attr_item)
elif type == 'real' and unit_item:
self.p7tpl.PropertyRangeTypeRestrictionOfClass(class_item, attr_item, unit_item)
elif type == 'integer':
self.p7tpl.ClassOfClassification(class_item, attr_item)
elif type == 'date/time':
attr_id = "POSSESOR_OF_"+attribute['id']
self.part2.Specialization(hasSubclass=class_item, hasSuperclass=self.GetAttributeById(attr_id))
elif type == 'reference':
self.p7tpl.ClassOfClassification(class_item, attr_item)
else:
pass
def ReadClass(self, classnode, parent_attributes = [], parent_class = None):
if classnode['id'] == '':
return
if self.attr_inheritance:
attributes = parent_attributes[:]
else:
attributes = []
class_item = self.part2.ClassOfIndividual()
self.builder.annotate(id = class_item, label=classnode['id'])
if parent_class:
self.part2.Specialization(hasSubclass=class_item, hasSuperclass=parent_class)
self.part2.Classification(hasClassified=class_item, hasClassifier=self.eq_class)
self.RusIdent(class_item, classnode['name'])
if 'attributes' in classnode:
class_attributes = classnode['attributes']
if type(class_attributes)==type(list()):
attributes[len(attributes):] = class_attributes
elif type(class_attributes)==type(dict()):
attributes[len(attributes):] = [class_attributes]
else:
log("err!!")
for subitem in attributes:
self.ProcessAttribute(subitem, class_item)
if 'subClasses' in classnode:
class_subclasses = classnode['subClasses']
if type(class_subclasses)==type(list()):
for subitem in class_subclasses:
self.ReadClass(subitem, attributes, class_item)
elif type(class_subclasses)==type(dict()):
self.ReadClass(class_subclasses, attributes, class_item)
else:
log("err!!")
def ProcessModel(self):
self.ru_ident = self.part2.ClassOfClassOfIdentification()
self.builder.annotate(id = self.ru_ident, label='CATALOG RUSSIAN IDENTIFICATION')
self.attr_type = self.part2.ClassOfClass()
self.builder.annotate(id = self.attr_type, label='CATALOG ATTRIBUTE TYPE')
self.eq_class = self.part2.ClassOfClassOfIndividual()
self.builder.annotate(id = self.eq_class, label='CATALOG EQUIPMENT CLASS')
data = self.data
self.attr_generated = {}
self.unit_generated = {}
self.ReadClass(data)
def RusIdent(self, item, name):
exs = self.part2.ExpressString()
self.builder.annotate(id = exs, label=name)
coi = self.part2.ClassOfIdentification(hasRepresented=item, hasPattern=exs)
self.p7tpl.Classification(coi, self.ru_ident)
def verify_patterns():
import csv
def inf(uri):
tp, label, rdl = '', '', ''
for doc in appdata.documents(GraphDocument):
if getattr(doc, 'idi', None) != None:
for t in doc.grTriplesForSubj(uri):
if t.p == kb.rdf_type:
tp = t.v
elif t.p == kb.rdfs_label:
label = t.v
elif t.p == 'http://posccaesar.org/rdl/rdsWipEquivalent':
rdl = t.v
return tp, label, rdl
with open('verify.csv', 'wb') as csvfile:
writer = csv.writer(csvfile, delimiter=";")
writer.writerow(('Pattern', ' Template', 'Role', 'Expected', 'Found', 'Found RDL', 'Found type', 'Found label', 'Error type'))
doc = appdata.active_document
fi = {doc.name: doc.patterns.keys()}
patterns_env = appdata.environment_manager.GetPatternsEnv(None, fi)
for k, v in patterns_env.patterns.iteritems():
for on, o in v.options.iteritems():
for p in o.parts:
if p.ownrole:
value = None
fixed = False
for p1 in o.parts:
role = p1.roles.get(p.ownrole)
if role and 'type_uri' in role:
value = role['type_uri']
fixed = role.get('restricted_by_value', False)
template_name = p1.typename
role_name = role['name']
break
if value:
if fixed:
if set([value]) != p.uri:
for u in p.uri:
tp, label, rdl = inf(u)
writer.writerow((k, template_name, role_name, value, u, rdl, tp, label, 'Value'))
else:
if isinstance(value, basestring):
types = [value]
else:
types = value
if p.uri:
uris = set()
for uri in p.uri:
for d in appdata.documents(GraphDocument):
for t in d.grTriplesForSubj(uri):
if t.p != 'http://posccaesar.org/rdl/rdsWipEquivalent':
uris.add(uri)
break
for u in p.uri - uris:
tp, label, rdl = inf(u)
writer.writerow((k, template_name, role_name, value, u, rdl, tp, label, 'Not found'))
unmatched = set()
for uri in uris:
for tp in types:
res = GraphDocument.infCheckClassification(uri, tp)
if res == GraphDocument.CL_OK:
break
else:
unmatched.add(uri)
for u in unmatched:
tp, label, rdl = inf(u)
writer.writerow((k, template_name, role_name, value, u, rdl, tp, label, 'URI'))
if p.types:
uris = set()
for uri in p.types:
for d in appdata.documents(GraphDocument):
for t in d.grTriplesForSubj(uri):
if t.p != 'http://posccaesar.org/rdl/rdsWipEquivalent':
uris.add(uri)
break
for u in p.types - uris:
tp, label, rdl = inf(u)
writer.writerow((k, template_name, role_name, value, u, rdl, tp, label, 'Not found'))
unmatched = set()
for uri in uris:
for tp in types:
res = GraphDocument.infCheckClassifers(tp, set([uri]))
if res == GraphDocument.CL_OK:
break
else:
unmatched.add(uri)
for u in unmatched:
tp, label, rdl = inf(u)
writer.writerow((k, template_name, role_name, value, u, rdl, tp, label, 'Type'))
def f1():
if not self.diff and self.other:
self.diff = RdfDiff()
try:
self.diff.CompareProc(self.document, self.other)
except:
log.exception()
other = GraphDocument()
self.diff.MakeLocalDiff(other, self.document)
other.UpdateNamespacesFromLoad()
props_source = self.other if self.other else self.document
props = {}
for k in type(self.document).doc_params:
v = getattr(props_source, k, None)
if v != None:
props[k] = v
other.UpdateProps(props)
all_subj = self.diff.deletions.ks.viewkeys(
) | self.diff.insertions.ks.viewkeys()
new_subj = self.diff.insertions.ks.viewkeys(
) - self.document.ks.viewkeys()
del_subj = self.diff.deletions.ks.viewkeys() - other.ks.viewkeys()
chn_subj = all_subj - new_subj - del_subj
self.subjects = []
if self.show_changed:
self.subjects += list(chn_subj)
if self.show_added:
self.subjects += list(new_subj)
if self.show_deleted:
self.subjects += list(del_subj)
if self.text:
res_doc = self.document._grSearchLabel(self.text)
res_other = other._grSearchLabel(self.text)
self.subjects = list(
(res_doc | res_other)
& set([expand_uri(uri) for uri in self.subjects]))
self.subjects = [compact_uri(uri) for uri in self.subjects]
if self.filter_params:
env = appdata.environment_manager.GetWorkEnvironment(
self.document, include_scanner=True)
res_doc = env['scanner']._find(**self.filter_params)
env = appdata.environment_manager.GetWorkEnvironment(
other, include_scanner=True)
res_other = env['scanner']._find(**self.filter_params)
self.subjects = list(
(res_doc | res_other)
& set([expand_uri(uri) for uri in self.subjects]))
self.subjects = [compact_uri(uri) for uri in self.subjects]
self.filter_params = None
count_all = len(all_subj)
count_filtered = len(self.subjects)
@public.mth
def f2():
self.ShowEntities()
self.pnode.treenode_loading = False
self.pnode.UpdateLabel(' [{1}/{2}]'.format(
self.document.GetLabel(), count_filtered, count_all))
self.setEnabled(True)
self.seeding = False
class TabLanImporter:
def __init__(self, target_doc, import_source):
self.source_path = import_source[0]
self.target_doc = target_doc
self.enviponment_prepeared = self.PrepareEnvironment()
self.part2names = {}
for (k, v) in kb.part2_itself.iteritems():
self.part2names[v['name']] = v['name']
self.cardinalities = cardinalities_cnt()
self.relations = {}
for k in dir(self):
if k.startswith('R_'):
self.relations[k[2:].replace('_', ' ')] = getattr(self, k)
self.DoImport()
def DoImport(self):
if not self.enviponment_prepeared:
return
if not self.InitEnvironment():
self.target_doc.ChangeState(self.target_doc.state_importfailed)
return
@public.wth(tm.ext.importing_doc.format(self.target_doc.name),
self.target_doc, self.p7tpl_doc, self.pcardl_doc)
def f():
try:
self.rd = excel_reader.ExcelReader(self.source_path)
self.ProcessModel()
@public.mth
def f2():
self.target_doc.ChangeState(self.target_doc.state_changed)
except:
log.exception()
@public.mth
def f3():
self.target_doc.ChangeState(
self.target_doc.state_importfailed)
def InitEnvironment(self):
environment = appdata.environment_manager.GetWorkEnvironment(
self.target_doc, include_builder=True)
self.builder = environment.get('builder', None)
self.part2 = environment.get('part2', None)
self.p7tpl = environment.get(self.p7tpl_doc.module_name, None)
return self.builder and self.part2 and self.p7tpl
def PrepareEnvironment(self):
if not bool(
appconfig.get('paths.p7tpl_tablan')
and appconfig.get('paths.rdl_tablan')
and appconfig.get('tablan.proj_ns')):
log('Import error: TabLan dependencies not set!\n')
return False
self.target_doc.UpdateProps(
{'basens': appconfig.get('tablan.proj_ns')})
self.p7tpl_doc = GraphDocument.FindDocumentByPaths(
[appconfig.get('paths.p7tpl_tablan')])
if not self.p7tpl_doc:
self.p7tpl_doc = GraphDocument()
param = dict(name="Template set (TabLan)",
chosen_part2=kb.ns_dm_part8,
module_name="p7tpl")
self.p7tpl_doc.OpenFiles([appconfig.get('paths.p7tpl_tablan')],
**param)
appdata.project.AddDocument(self.p7tpl_doc)
self.pcardl_doc = GraphDocument.FindDocumentByPaths(
[appconfig.get('paths.rdl_tablan')])
if not self.pcardl_doc:
self.pcardl_doc = GraphDocument()
param = dict(name='RDL (TabLan)',
chosen_part2=kb.ns_dm_part2,
namespaces=kb.namespaces_std,
annotations=kb.annotations_pcardl_rdf)
self.pcardl_doc.OpenFiles([appconfig.get('paths.rdl_tablan')],
**param)
appdata.project.AddDocument(self.pcardl_doc)
ready = True
if not self.p7tpl_doc.CanView():
wizard.Subscribe(self.p7tpl_doc, self)
ready = False
if not self.pcardl_doc.CanView():
wizard.Subscribe(self.pcardl_doc, self)
ready = False
return ready
def W_DocumentStateChanged(self, doc):
if doc.CanView():
wizard.Unsubscribe(doc, self)
elif doc.IsUnavailable():
log('Import error: {0} unavailable!\n', doc.name)
self.target_doc.ChangeState(self.target_doc.state_importfailed)
wizard.Unsubscribe(doc, self)
if self.p7tpl_doc.CanView() and self.pcardl_doc.CanView():
self.enviponment_prepeared = True
appdata.app.After(self.DoImport)
def ProcessModel(self):
rd = self.rd
ids = {}
ru_names = {}
en_names = {}
doc_names = {}
def is_section(r):
return r.text('Section') != ''
# classes creation
@rd.SafeRows('Class Definitions')
def f(r):
if is_section(r): return
class_id = r.text('URI')
ru_name = r.text('Russian Unique Class Name')
en_name = r.text('English Unique Class Name')
if not en_name and not ru_name:
r.row_error(
'Russian or english name is required for every class')
if class_id.startswith('rdl:'):
class_id = 'http://posccaesar.org/rdl/' + class_id[4:]
elif class_id.startswith('til:'):
class_id = 'http://techinvestlab.ru/data#' + class_id[4:]
else:
p2type = r.known('Part 2 Type', self.part2names)
class_id = getattr(self.part2, p2type)()
if en_name:
self.builder.annotate(id=class_id,
label=en_name,
label_en=en_name)
if ru_name:
if not en_name:
self.builder.annotate(id=class_id,
label=ru_name,
label_ru=ru_name)
else:
self.builder.annotate(id=class_id, label_ru=ru_name)
source = r.nonempty('Source')
self.builder.annotate(id=class_id, annSource=source)
#else:
# r.row_error('Wrong URI field')
if en_name:
en_names[class_id] = en_name
ids[en_name] = class_id
if ru_name:
ru_names[class_id] = ru_name
ids[ru_name] = class_id
# for later use
self.EmptyClass = ids['EmptyClass']
# structure model creation
@rd.SafeRows('Structure Model')
def f(r):
if is_section(r): return
item_name = r.text('Item ID')
if not item_name:
return
item = self.part2.ClassOfInformationObject()
doc_names[item] = item_name
ids[item_name] = item
self.builder.annotate(id=item, label=item_name)
self.was_item = None
# structure model specification
@rd.SafeRows('Structure Model')
def f(r):
if is_section(r): return
item = r.known_or_empty('Item ID', ids)
if not item:
item = self.was_item
classifier = r.known_or_empty('Classifier Class', ids)
if classifier:
self.part2.Classification(hasClassified=item,
hasClassifier=classifier)
subject = r.known_or_empty('Item Subject', ids)
if subject:
self.p7tpl.DescriptionByInformationObject(subject, item)
return
else:
self.was_item = item
item_class = r.known('Item Class', ids)
text = r.nonempty('Item Text')
whole = r.known_or_empty('Item of Whole', ids)
classifier = r.known_or_empty('Classifier Class', ids)
subject = r.known_or_empty('Item Subject', ids)
if text:
self.builder.annotate(id=item, annTextDefinition=text)
self.part2.Specialization(hasSubclass=item,
hasSuperclass=item_class)
if classifier:
self.part2.Classification(hasClassified=item,
hasClassifier=classifier)
if whole:
self.p7tpl.ClassOfArrangementOfIndividual(item, whole)
if subject:
self.p7tpl.DescriptionByInformationObject(subject, item)
# classes specification
@rd.SafeRows('Class Definitions')
def f(r):
if is_section(r): return
ru_name = r.text('Russian Unique Class Name')
en_name = r.text('English Unique Class Name')
if ru_name:
class_id = ids[ru_name]
else:
class_id = ids[en_name]
superclass = r.known_or_empty('Superclass', ids)
classifier = r.known_or_empty('Classifier Class', ids)
if superclass:
self.part2.Specialization(hasSubclass=class_id,
hasSuperclass=superclass)
if classifier:
self.part2.Classification(hasClassified=class_id,
hasClassifier=classifier)
# properties
@rd.SafeRows('Class Properties')
def f(r):
if is_section(r): return
# now
class_id = r.known('Class Name', ids)
prop = r.known('Property Name', ids)
ind_prop = r.known_or_empty('Indirect Property Name', ids)
vmin = r.nonempty('Property Min')
vmax = r.nonempty('Property Max')
source = r.nonempty('Source')
pr_min = ids.get(vmin)
if pr_min is None:
pr_min = self.part2.Property(label=vmin)
ids[vmin] = pr_min
pr_max = ids.get(vmax)
if pr_max is None:
pr_max = self.part2.Property(label=vmax)
ids[vmax] = pr_max
rng = self.part2.PropertyRange(annSource=source)
self.part2.Specialization(hasSubclass=rng,
hasSuperclass=prop,
annSource=source)
self.p7tpl.LowerUpperOfPropertyRange(rng,
pr_min,
pr_max,
annSource=source)
if ind_prop:
self.p7tpl.PropertyRangeRestrictionOfClass(class_id,
ind_prop,
rng,
annSource=source)
else:
self.part2.ClassOfClassification(hasClassOfClassified=class_id,
hasClassOfClassifier=rng,
annSource=source)
# classifiers
@rd.SafeRows('Classifier Definition')
def f(r):
if is_section(r): return
class_id = r.known('Class Name', ids)
superclass = r.known_or_empty('Superclass Name', ids)
rel_class = r.known_or_empty('Classifier Relationship Class', ids)
class_class = r.known_or_empty('Class of Classifier Classes', ids)
source = r.nonempty('Source')
if superclass:
rel_id = self.part2.Specialization(hasSubclass=class_id,
hasSuperclass=superclass,
annSource=source)
if rel_class:
self.part2.Classification(hasClassified=rel_id,
hasClassifier=rel_class,
annSource=source)
if class_class:
self.part2.Classification(hasClassified=class_id,
hasClassifier=class_class,
annSource=source)
# breakdown
@rd.SafeRows('Breakdown Definition')
def f(r):
if is_section(r): return
class_id = r.known('Class Name', ids)
whole_class = r.known_or_empty('Whole Class Name', ids)
rel_class = r.known_or_empty('Breakdown Relationship Class', ids)
class_class = r.known_or_empty('Class of Breakdown Classes', ids)
source = r.nonempty('Source')
if whole_class:
rel_id = self.part2.ClassOfCompositionOfIndividual(
hasClassOfPart=class_id,
hasClassOfWhole=whole_class,
annSource=source)
if rel_class:
self.part2.Classification(hasClassified=rel_id,
hasClassifier=rel_class,
annSource=source)
if class_class:
self.part2.Classification(hasClassified=class_id,
hasClassifier=class_class,
annSource=source)
# relationships
@rd.SafeRows('Other Relationships')
def f(r):
if is_section(r): return
role1 = r.known('Role 1', ids)
role1c = r.known_or_empty('Role 1 Cardinality', self.cardinalities)
rel_code = r.known('Relates to', self.relations)
role2 = r.known('Role 2', ids)
role2c = r.known_or_empty('Role 2 Cardinality', self.cardinalities)
source = r.nonempty('Source')
rel_id = rel_code(role1, role2, role1c, role2c, source)
# requirements
@rd.SafeRows('Requirements')
def f(r):
if is_section(r): return
status = r.known('Statement Classification', ids)
role1 = r.known('Role 1', ids)
role1c = r.known_or_empty('Role 1 Cardinality', self.cardinalities)
rel_code = r.known('Relates to', self.relations)
role2 = r.known('Role 2', ids)
role2c = r.known_or_empty('Role 2 Cardinality', self.cardinalities)
source = r.nonempty('Source')
rel_id = rel_code(role1, role2, role1c, role2c, source)
if rel_id:
if type(rel_id) == tuple:
rel_id = rel_id[0]
self.part2.Specialization(hasSubclass=rel_id,
hasSuperclass=status,
annSource=source)
else:
self.part2.Classification(hasClassified=rel_id,
hasClassifier=status,
annSource=source)
def R_is_described_by(self, role1, role2, role1c, role2c, source):
pi = self.part2.PossibleIndividual(annSource=source)
self.part2.Classification(hasClassified=pi,
hasClassifier=role2,
annSource=source)
rel_id = self.part2.Description(hasRepresented=role1,
hasSign=pi,
annSource=source)
return rel_id
def R_participates_in(self, role1, role2, role1c, role2c, source):
rel_id = self.part2.ClassOfCompositionOfIndividual(
hasClassOfPart=role1, hasClassOfWhole=role2, annSource=source)
if role1c is not None:
if role1c[1] == "*":
self.p7tpl.CardinalityEnd1Min(rel_id,
role1c[0],
annSource=source)
else:
self.p7tpl.CardinalityEnd1MinMax(rel_id,
role1c[0],
role1c[1],
annSource=source)
if role2c is not None:
if role2c[1] == "*":
self.p7tpl.CardinalityEnd2Min(rel_id,
role2c[0],
annSource=source)
else:
self.p7tpl.CardinalityEnd2MinMax(rel_id,
role2c[0],
role2c[1],
annSource=source)
return rel_id, 1
def R_is_a_predecessor_in_time_of(self, role1, role2, role1c, role2c,
source):
rel_id = self.part2.ClassOfTemporalSequence(
hasClassOfPredecessor=role1,
hasClassOfSuccessor=role2,
annSource=source)
if role1c is not None:
if role1c[1] == "*":
self.p7tpl.CardinalityEnd1Min(rel_id,
role1c[0],
annSource=source)
else:
self.p7tpl.CardinalityEnd1MinMax(rel_id,
role1c[0],
role1c[1],
annSource=source)
if role2c is not None:
if role2c[1] == "*":
self.p7tpl.CardinalityEnd2Min(rel_id,
role2c[0],
annSource=source)
else:
self.p7tpl.CardinalityEnd2MinMax(rel_id,
role2c[0],
role2c[1],
annSource=source)
return rel_id, 1
def R_has_as_part(self, role1, role2, role1c, role2c, source):
rel_id = self.part2.ClassOfCompositionOfIndividual(
hasClassOfPart=role2, hasClassOfWhole=role1, annSource=source)
if role1c is not None:
if role1c[1] == "*":
self.p7tpl.CardinalityEnd1Min(rel_id,
role1c[0],
annSource=source)
else:
self.p7tpl.CardinalityEnd1MinMax(rel_id,
role1c[0],
role1c[1],
annSource=source)
if role2c is not None:
if role2c[1] == "*":
self.p7tpl.CardinalityEnd2Min(rel_id,
role2c[0],
annSource=source)
else:
self.p7tpl.CardinalityEnd2MinMax(rel_id,
role2c[0],
role2c[1],
annSource=source)
return rel_id, 1
def R_is_disjoint(self, role1, role2, role1c, role2c, source):
# self.p7tpl.IntersectionOf2Classes not present in Part 8 files
eset = self.part2.EnumeratedSetOfClass(annSource=source)
self.part2.Classification(hasClassified=role1,
hasClassifier=eset,
annSource=source)
self.part2.Classification(hasClassified=role2,
hasClassifier=eset,
annSource=source)
self.p7tpl.IntersectionOfSetOfClass(eset,
self.EmptyClass,
annSource=source)
def R_is_performed_by(self, role1, role2, role1c, role2c, source):
rel_id = self.part2.ClassOfCompositionOfIndividual(
hasClassOfPart=role2, hasClassOfWhole=role1, annSource=source)
if role1c is not None:
if role1c[1] == "*":
self.p7tpl.CardinalityEnd1Min(rel_id,
role1c[0],
annSource=source)
else:
self.p7tpl.CardinalityEnd1MinMax(rel_id,
role1c[0],
role1c[1],
annSource=source)
if role2c is not None:
if role2c[1] == "*":
self.p7tpl.CardinalityEnd2Min(rel_id,
role2c[0],
annSource=source)
else:
self.p7tpl.CardinalityEnd2MinMax(rel_id,
role2c[0],
role2c[1],
annSource=source)
return rel_id, 1
def R_is_related_to(self, role1, role2, role1c, role2c, source):
rel_id = self.part2.OtherRelationship(hasEnd1=role1,
hasEnd2=role2,
annSource=source)
if role1c is not None:
if role1c[1] == "*":
self.p7tpl.CardinalityEnd1Min(rel_id,
role1c[0],
annSource=source)
else:
self.p7tpl.CardinalityEnd1MinMax(rel_id,
role1c[0],
role1c[1],
annSource=source)
if role2c is not None:
if role2c[1] == "*":
self.p7tpl.CardinalityEnd2Min(rel_id,
role2c[0],
annSource=source)
else:
self.p7tpl.CardinalityEnd2MinMax(rel_id,
role2c[0],
role2c[1],
annSource=source)
return rel_id
def R_is_classified_as(self, role1, role2, role1c, role2c, source):
rel_id = self.part2.Classification(hasClassified=role1,
hasClassifier=role2,
annSource=source)
return rel_id
def R_is_subclass_of(self, role1, role2, role1c, role2c, source):
rel_id = self.part2.Specialization(hasSubclass=role1,
hasSuperclass=role2,
annSource=source)
return rel_id
def R_complies_to_description_in(self, role1, role2, role1c, role2c,
source):
pi = self.part2.PossibleIndividual(annSource=source)
self.part2.Classification(hasClassified=pi,
hasClassifier=role2,
annSource=source)
rel_id = self.part2.Description(hasRepresented=role1,
hasSign=pi,
annSource=source)
return rel_id
