def sort_attribute_names(classes):
if classes is not None:
for i in range(0, len(classes)):
attribs = classes[i]['attribs']
for j in range(0, len(attribs)):
name = attribs[j]['name']
texname = strFunctions.texify(name)
attribs[j]['texname'] = texname
for i in range(0, len(classes)):
if 'lo_attribs' in classes[i]:
lo_attribs = classes[i]['lo_attribs']
for j in range(0, len(lo_attribs)):
name = lo_attribs[j]['name']
texname = strFunctions.texify(name)
lo_attribs[j]['texname'] = texname
def __init__(self, spec_name, number, package, pkg_ref, level, version,
pkg_version, reqd_status):
# members from object
self.fullname = spec_name
self.number = number
self.offset = number
self.package = package.lower()
self.pkg_ref = pkg_ref
self.up_package = strFunctions.upper_first(self.package)
if reqd_status:
self.reqd_status = 'true'
else:
self.reqd_status = 'false'
self.full_pkg_command = \
'\\{0}Package'.format(strFunctions.texify(self.fullname))
# useful repeated text strings
self.valid = '\\validRule{'
self.start_b = '{'
self.end_b = '}'
self.level = level
self.version = version
self.pkg_version = pkg_version
self.rules = []
self.tc = 'TBC'
def __init__(self, spec_name, number, package, pkg_ref, level, version,
pkg_version, reqd_status):
# members from object
self.fullname = spec_name
self.number = number
self.offset = number
self.package = package.lower()
self.pkg_ref = pkg_ref
self.up_package = strFunctions.upper_first(self.package)
if reqd_status:
self.reqd_status = 'true'
else:
self.reqd_status = 'false'
self.full_pkg_command = \
'\\{0}Package'.format(strFunctions.texify(self.fullname))
# useful repeated text strings
self.valid = '\\validRule{'
self.start_b = '{'
self.end_b = '}'
self.level = level
self.version = version
self.pkg_version = pkg_version
self.rules = []
self.tc = 'TBC'
def __init__(self, name, extension, object_desc):
BaseFile.BaseFile.__init__(self, name, extension)
# change the comment delimiter and line length
self.comment = '%'
self.line_length = 72
self.package = object_desc['name']
self.fullname = object_desc['fullname']
self.sbml_classes = object_desc['baseElements']
self.offset = object_desc['offset']
self.plugins = object_desc['plugins']
self.enums = object_desc['enums']
self.level = object_desc['base_level']
self.version = object_desc['base_version']
self.pkg_version = object_desc['pkg_version']
if object_desc['required']:
self.reqd_status = 'true'
else:
self.reqd_status = 'false'
self.prim_class = []
self.start_b = '{'
self.end_b = '}'
# expand the information for the classes
self.fulltexname = strFunctions.texify(self.fullname)
self.upper_package = strFunctions.upper_first(self.package)
self.sort_class_names(self.sbml_classes)
self.sort_attribute_names(self.sbml_classes)
self.sort_enum_names(self.enums)
self.full_pkg_command = '\\{0}Package'.format(self.fulltexname)
self.brief_pkg_command = '\\{0}'.format(self.upper_package)
def sort_enum_names(enums):
"""
Function to create texnames for enums
:param enums:
"""
if enums is not None:
for i in range(0, len(enums)):
name = enums[i]['name']
texname = strFunctions.texify(name)
enums[i]['texname'] = texname
def sort_class_names(self, classes):
if classes is not None:
for i in range(0, len(classes)):
name = classes[i]['name']
texname = strFunctions.texify(name)
classes[i]['texname'] = texname
# hack for render
if name == 'Ellipse' or name == 'Rectangle':
texname = 'Render' + name
classes[i]['texname'] = texname
if name == 'RelAbsVector':
self.prim_class.append(classes[i])
def update_attrib_dicts(my_list):
"""
Update a list of attribute dictionaries.
:param my_list: the list which we update.
"""
for j in range(0, len(my_list)):
if my_list[j]['type'] in [
'lo_element', 'element', 'inline_lo_element'
]:
name = my_list[j]['element']
else:
name = my_list[j]['name']
texname = strFunctions.texify(name)
my_list[j]['texname'] = texname
def sort_class_names(self, classes):
"""
Function to create texnames for classes.
:param classes: list of objects (dictionaries) representing classes.
"""
if classes is not None:
for i in range(0, len(classes)):
name = classes[i]['name']
texname = strFunctions.texify(name)
classes[i]['texname'] = texname
# hack for render
if name == 'Ellipse' or name == 'Rectangle':
texname = 'Render' + name
classes[i]['texname'] = texname
if name == 'RelAbsVector':
self.prim_class.append(classes[i])
def write_attribute_type_rule(self, attribute, lo=None):
if lo:
formatted_name = lo['formatted_name']
refname = lo['name']
abbrev = strFunctions.abbrev_lo_name(refname)
else:
formatted_name = self.formatted_name
refname = self.name
abbrev = self.name
att_type = attribute['type']
att_name = strFunctions.upper_first(attribute['name'])
name = strFunctions.wrap_token(attribute['texname'], self.package)
rule_type = 'String'
if att_type == 'SId':
return
elif att_type == 'SIdRef':
[ref_name, ref_type] = \
strFunctions.get_sid_refs(attribute['element'])
# hack for render
if ref_name == 'StartHead' or ref_name == 'EndHead':
ref_name = 'LineEnding'
text = 'The value of the attribute {0} of {1} {2} object must be ' \
'the identifier of an existing \{3} object defined in the ' \
'enclosing \Model object.'\
.format(name, self.indef, formatted_name, ref_name)
rule_type = ref_type
elif att_type == 'string' or att_type == 'IDREF':
text = 'The attribute {0} on {1} {2} must have a value of data ' \
'type {3}.'\
.format(name, self.indef, formatted_name,
strFunctions.wrap_token('string'))
elif att_type == 'int' or att_type == 'uint':
text = 'The attribute {0} on {1} {2} must have a value of data ' \
'type {3}.'\
.format(name, self.indef, formatted_name,
strFunctions.wrap_token('integer'))
rule_type = 'Integer' if att_type == 'int' else 'UnInteger'
elif att_type == 'double':
text = 'The attribute {0} on {1} {2} must have a value of data ' \
'type {3}.'\
.format(name, self.indef, formatted_name,
strFunctions.wrap_token('double'))
rule_type = 'Double'
elif att_type == 'boolean' or att_type == 'bool':
text = 'The attribute {0} on {1} {2} must have a value of data ' \
'type {3}.'\
.format(name, self.indef, formatted_name,
strFunctions.wrap_token('boolean'))
rule_type = 'Boolean'
elif att_type == 'UnitSId' or att_type == 'UnitSIdRef':
text = 'The value of the attribute {0} on {1} {2} must have a ' \
'taken from the following: the identifier of a ' \
'\\UnitDefinition object in the enclosing \Model, or one ' \
'of the base units in SBML.'.format(name,
self.indef,
formatted_name)
rule_type = 'Unit'
elif att_type == 'enum':
enum_name = strFunctions.texify(attribute['element'])
enums = attribute['parent']['root']['enums']
enum_values = self.parse_enum_values(attribute['element'], enums)
text = 'The value of the attribute {0} of {1} {2} object must ' \
'conform to the syntax of SBML data type {3} and ' \
'may only take on the allowed values of {3} defined ' \
'in SBML; that is, the value must be one of the ' \
'following: {4}.'.format(name, self.indef,
formatted_name,
strFunctions.wrap_enum(enum_name),
enum_values)
rule_type = '{0}Enum'.format(attribute['element'])
elif att_type == 'array':
text = 'The value of the attribute {0} of {1} {2} object must ' \
'be an array of values of type {3}.'\
.format(name, self.indef, formatted_name,
strFunctions.wrap_token(attribute['element']))
elif att_type == 'element' and attribute['element'] == 'RelAbsVector':
text = 'The value of the attribute {0} of {1} {2} object must ' \
'conform to the syntax of SBML data type \\RelAbsVector ' \
'i.e. a string encoding optionally an absolute number ' \
'followed by an optional relative number followed ' \
'by a \\% sign. Adding spaces between the ' \
'coordinates is encouraged, but not required.'\
.format(name, self.indef, formatted_name)
else:
text = 'FIXME: Encountered an unknown attribute type {0} in ' \
'ValidationRulesForClass'\
.format(att_type)
# global_variables.code_returned = \
# global_variables.return_codes['unknown type used']
ref = '{0}, {1}.'\
.format(self.pkg_ref, strFunctions.wrap_section(refname))
sev = 'ERROR'
lib_sev = '{0}_SEV_ERROR'.format(global_variables.up_full_lib)
short = '{0} attribute must be {1}.'.format(att_name, rule_type)
lib_ref = 'L3V1 {0} V1 Section'.format(self.up_package)
tc = '{0}{1}{2}MustBe{3}'.format(self.up_package, abbrev, att_name,
rule_type)
return dict({'number': self.number, 'text': text,
'reference': ref, 'severity': sev, 'typecode': tc,
'lib_sev': lib_sev, 'short': short, 'lib_ref': lib_ref,
'object': refname, 'attrib': att_name,
'attrib_type': att_type})
def sort_enum_names(enums):
if enums is not None:
for i in range(0, len(enums)):
name = enums[i]['name']
texname = strFunctions.texify(name)
enums[i]['texname'] = texname