def write_element_not_ns_rule(self): text = 'Wherever they appear in an SBML document, elements and ' \ 'attributes from the {0} must use the ' \ '\\uri{1}http://www.sbml.org/sbml/level{2}/version{3}' \ '/{4}/version{5}{6} namespace, declaring so either explicitly ' \ 'or implicitly.'\ .format(self.full_pkg_command, self.start_b, self.level, self.version, self.package, self.pkg_version, self.end_b) ref = '{0} {1}.'\ .format(self.pkg_ref, strFunctions.wrap_section('xml-namespace', False)) sev = 'ERROR' lib_sev = '{0}_SEV_ERROR'.format(global_variables.up_full_lib) short = 'Element not in {0} namespace'.format(self.up_package) lib_ref = 'L3V1 {0} V1 Section 3.1'.format(self.up_package) tc = '{0}ElementNotInNs'.format(self.up_package) return dict({ 'number': self.number, 'text': text, 'reference': ref, 'severity': sev, 'typecode': tc, 'lib_sev': lib_sev, 'short': short, 'lib_ref': lib_ref })
def write_ns_rule(self): text = 'To conform to the {0} specification for SBML Level~{1} ' \ 'Version~{2}, an SBML document must declare ' \ '\\uri{3}http://www.sbml.org/sbml/' \ 'level{1}/version{2}/{4}/version{5}{6} as the XMLNamespace ' \ 'to use for elements of this package.'\ .format(self.full_pkg_command, self.level, self.version, self.start_b, self.package, self.pkg_version, self.end_b) ref = '{0} {1}.'\ .format(self.pkg_ref, strFunctions.wrap_section('xml-namespace', False)) sev = 'ERROR' lib_sev = '{0}_SEV_ERROR'.format(global_variables.up_full_lib) short = 'The {0} namespace is not correctly ' \ 'declared.'.format(self.up_package) lib_ref = 'L3V1 {0} V1 Section 3.1'.format(self.up_package) tc = '{0}NSUndeclared'.format(self.up_package) return dict({ 'number': self.number, 'text': text, 'reference': ref, 'severity': sev, 'typecode': tc, 'lib_sev': lib_sev, 'short': short, 'lib_ref': lib_ref })
def write_package_object_rule(self): if len(self.reqd_elem) == 0 and len(self.opt_elem) == 0: return reqd = self.parse_required_elements(self.reqd_elem) opt = self.parse_optional_elements(self.opt_elem) no_other_statement = 'No other elements from the SBML Level 3 {0} ' \ 'namespaces are permitted on {1} {2} object. '\ .format(self.fullname, self.indef, self.formatted_name) if len(opt) == 0 and len(reqd) > 0: text = '{0} {1} object must contain {2}. {3}'\ .format(self.indef_u, self.formatted_name, reqd, no_other_statement) elif len(reqd) == 0 and len(opt) > 0: text = '{0} {1} object may contain {2}. {3}'\ .format(self.indef_u, self.formatted_name, opt, no_other_statement) else: text = '{0} {1} object must contain {2}, and may contain {3}. {4}'\ .format(self.indef_u, self.formatted_name, reqd, opt, no_other_statement) ref = '{0}, {1}.'\ .format(self.pkg_ref, strFunctions.wrap_section(self.name)) sev = 'ERROR' lib_sev = '{0}_SEV_ERROR'.format(global_variables.up_full_lib) short = 'Elements allowed on <{0}>.'.format(self.lower_name) lib_ref = 'L3V1 {0} V1 Section'.format(self.up_package) tc = '{0}{1}AllowedElements'.format(self.up_package, self.name) return dict({'number': self.number, 'text': text, 'reference': ref, 'severity': sev, 'typecode': tc, 'lib_sev': lib_sev, 'short': short, 'lib_ref': lib_ref, 'plugin': False, 'object': self.name, 'reqd': self.reqd_elem, 'opt': self.opt_elem})
def write_package_attribute_rule(self): if len(self.reqd_att) == 0 and len(self.opt_att) == 0: return reqd = self.parse_required(self, self.reqd_att) opt = self.parse_optional(self, self.opt_att) no_other_statement = 'No other attributes from the SBML Level~3 {0} ' \ 'namespaces are permitted on {1} {2} object. '\ .format(self.fullname, self.indef, self.formatted_name) if len(opt) == 0 and len(reqd) > 0: text = '{0} {1} object must have {2}. {3}'\ .format(self.indef_u, self.formatted_name, reqd, no_other_statement) elif len(reqd) == 0 and len(opt) > 0: text = '{0} {1} object may have {2}. {3}'\ .format(self.indef_u, self.formatted_name, opt, no_other_statement) else: text = '{0} {1} object must have {2}, and may have {3}. {4}'\ .format(self.indef_u, self.formatted_name, reqd, opt, no_other_statement) add_extended = True if self.package == 'render': add_extended = False ref = '{0}, {1}.'\ .format(self.pkg_ref, strFunctions.wrap_section(self.name, True, add_extended)) sev = 'ERROR' lib_sev = '{0}_SEV_ERROR'.format(global_variables.up_full_lib) short = 'Attributes allowed on <{0}>.'.format(self.lower_name) lib_ref = 'L3V1 {0} V1 Section'.format(self.up_package) tc = '{0}{1}AllowedAttributes'.format(self.up_package, self.name) return dict({'number': self.number, 'text': text, 'reference': ref, 'severity': sev, 'typecode': tc, 'lib_sev': lib_sev, 'short': short, 'lib_ref': lib_ref, 'plugin': True, 'object': self.name, 'lo': False, 'reqd': self.reqd_att, 'opt': self.opt_att})
def write_core_attribute_rule(self, lo_child=None): if lo_child is None: text = '{0} {1} object may have the optional SBML Level~3 ' \ 'Core attributes {2} and {3}. No other attributes from the ' \ 'SBML Level 3 Core namespaces are permitted on {4} {1}.'\ .format(self.indef_u, self.formatted_name, strFunctions.wrap_token('metaid'), strFunctions.wrap_token('sboTerm'), self.indef) ref = 'SBML Level~3 Version~1 Core, Section~3.2.' sev = 'ERROR' tc = '{0}{1}AllowedCoreAttributes'.format(self.up_package, self.name) lo = False else: lo_name = strFunctions.plural(lo_child['name']) text = 'A {0} object may have the optional SBML Level~3 ' \ 'Core attributes {1} and {2}. No other attributes from the ' \ 'SBML Level 3 Core namespaces are permitted on a {0} object.'\ .format(strFunctions.get_element_name(lo_child), strFunctions.wrap_token('metaid'), strFunctions.wrap_token('sboTerm')) ref = '{0}, {1}.'\ .format(self.pkg_ref, strFunctions.wrap_section(self.name)) sev = 'ERROR' tc = '{0}{1}LO{2}AllowedCoreAttributes'.format(self.up_package, self.name, lo_name) lo = True lib_sev = '{0}_SEV_ERROR'.format(global_variables.up_full_lib) short = 'Core attributes allowed on <{0}>.'.format(self.lower_name) lib_ref = 'L3V1 {0} V1 Section'.format(self.up_package) return dict({'number': self.number, 'text': text, 'reference': ref, 'severity': sev, 'typecode': tc, 'lib_sev': lib_sev, 'short': short, 'lib_ref': lib_ref, 'plugin': True, 'object': self.name, 'lo': lo, 'reqd': self.reqd_elem, 'opt': self.opt_elem})
def write_reqd_lo_rule(self): number = len(self.reqd_child_lo_elem) unusual_min = False no_min = 0 # check whether have unusual minimums for i in range(0, number): if 'min_lo_children' in self.reqd_child_lo_elem[i]: min_no = self.reqd_child_lo_elem[i]['min_lo_children'] if min_no == 0: unusual_min = True no_min += 1 elif min_no > 1: unusual_min = True if no_min == number: return None if number > 1: obj = 'objects' i = 0 elements = '{0}'.format(strFunctions.get_element_name( self.reqd_child_lo_elem[i])) for i in range(1, number-1): elements += ', {0}'.format(strFunctions.get_element_name( self.reqd_child_lo_elem[i])) elements += ' and {0}'.format(strFunctions.get_element_name( self.reqd_child_lo_elem[i+1])) else: obj = 'object' elements = '{0}'.format(strFunctions.get_element_name( self.reqd_child_lo_elem[0])) text = 'The {0} sub{1} on {2} {3} object must not be empty.'\ .format(elements, obj, self.indef, self.formatted_name) if unusual_min: for i in range(0, number): num = strFunctions.replace_digits(str( self.reqd_child_lo_elem[i]['min_lo_children'])).lower() name = strFunctions.get_element_name(self.reqd_child_lo_elem[i]) text += 'The {0} must contain at least {1} instances of the ' \ '\{2} object.' \ ''.format(name, num, self.reqd_child_lo_elem[i]['name']) ref = '{0}, {1}.'\ .format(self.pkg_ref, strFunctions.wrap_section(self.name)) sev = 'ERROR' lib_sev = '{0}_SEV_ERROR'.format(global_variables.up_full_lib) lib_ref = 'L3V1 {0} V1 Section'.format(self.up_package) if unusual_min: short = 'No children in ListOf elements allowed on <{0}>.' \ ''.format(self.lower_name) tc = '{0}{1}LOReqdElementChildren'.format(self.up_package, self.name) else: short = 'No Empty ListOf elements allowed on <{0}>.' \ ''.format(self.lower_name) tc = '{0}{1}EmptyReqdLOElements'.format(self.up_package, self.name) return dict({'number': self.number, 'text': text, 'reference': ref, 'severity': sev, 'typecode': tc, 'lib_sev': lib_sev, 'short': short, 'lib_ref': lib_ref})
def write_empty_list_rule(self): text = 'No empty lists' ref = '{0} {1}.'\ .format(self.pkg_ref, strFunctions.wrap_section('primitive-types', False)) sev = 'ERROR' lib_sev = '{0}_SEV_ERROR'.format(global_variables.up_full_lib) short = 'No empty listOf'.format(self.up_package) lib_ref = 'L3V1 {0} V1 Section'.format(self.up_package) tc = '{0}EmptyListElement'.format(global_variables.prefix) return dict({'number': self.number, 'text': text, 'reference': ref, 'severity': sev, 'typecode': tc, 'lib_sev': lib_sev, 'short': short, 'lib_ref': lib_ref})
def write_allowed_attributes_rule(self): text = 'Allowed attributes' ref = '{0} {1}.'\ .format(self.pkg_ref, strFunctions.wrap_section('primitive-types', False)) sev = 'ERROR' lib_sev = '{0}_SEV_ERROR'.format(global_variables.up_full_lib) short = 'Allowed attributes'.format(self.up_package) lib_ref = 'L3V1 {0} V1 Section'.format(self.up_package) tc = 'AllowedAttributes'.format(self.up_package) return dict({'number': self.number, 'text': text, 'reference': ref, 'severity': sev, 'typecode': tc, 'lib_sev': lib_sev, 'short': short, 'lib_ref': lib_ref})
def write_valid_ns_rule(self): text = 'Invalid namespace declared.' ref = '{0} {1}.'\ .format(self.pkg_ref, strFunctions.wrap_section('primitive-types', False)) sev = 'ERROR' lib_sev = '{0}_SEV_ERROR'.format(global_variables.up_full_lib) short = 'Invalid namespace'.format(self.up_package) lib_ref = 'L3V1 {0} V1 Section'.format(self.up_package) tc = 'InvalidNamespaceOn{0}'.format(global_variables.prefix) return dict({'number': self.number, 'text': text, 'reference': ref, 'severity': sev, 'typecode': tc, 'lib_sev': lib_sev, 'short': short, 'lib_ref': lib_ref})
def write_core_subobject_rule(self, lo_child=None): if lo_child is None: text = '{0} {1} object may have the optional SBML Level~3 ' \ 'Core subobjects for notes and annotations. No other ' \ 'elements from the SBML Level~3 Core namespaces are ' \ 'permitted on {2} {1}.'\ .format(self.indef_u, self.formatted_name, self.indef) ref = 'SBML Level~3 Version~1 Core, Section~3.2.' sev = 'ERROR' lib_sev = '{0}_SEV_ERROR'.format(global_variables.up_full_lib) tc = '{0}{1}AllowedCoreElements'.format(self.up_package, self.name) short = 'Core elements allowed on <{0}>.'.format(self.lower_name) lo = False else: loname = strFunctions.get_element_name(lo_child, leave_pkg_prefix=False) temp = strFunctions.remove_prefix(lo_child['element']) lo_name = loname[7:] #strFunctions.plural(temp) text = 'Apart from the general notes and annotations subobjects ' \ 'permitted on all SBML objects, a {0} container object ' \ 'may only contain \{1} objects.'\ .format(loname, temp) sec_name = 'listof' + lo_name.lower() ref = '{0}, {1}.'\ .format(self.pkg_ref, strFunctions.wrap_section(sec_name)) sev = 'ERROR' lib_sev = '{0}_SEV_ERROR'.format(global_variables.up_full_lib) tc = '{0}{1}LO{2}AllowedCoreElements'.format( self.up_package, self.name, lo_name) lo = True short = 'Core elements allowed on <listOf{0}>.'.format(lo_name) lib_ref = 'L3V1 {0} V1 Section'.format(self.up_package) return dict({ 'number': self.number, 'text': text, 'reference': ref, 'severity': sev, 'typecode': tc, 'lib_sev': lib_sev, 'short': short, 'lib_ref': lib_ref, 'plugin': False, 'object': self.name, 'lo': lo, 'reqd': self.reqd_elem, 'opt': self.opt_elem })
def write_reqd_value_rule(self): text = 'The value of attribute {0} on the \\class{1}SBML{2} object ' \ 'must be set to \\val{1}{3}{2}.' \ .format(strFunctions.wrap_token('required', self.package), self.start_b, self.end_b, self.reqd_status) ref = '{0} {1}.'\ .format(self.pkg_ref, strFunctions.wrap_section('xml-namespace', False)) sev = 'ERROR' lib_sev = '{0}_SEV_ERROR'.format(global_variables.up_full_lib) short = 'The {0}:required attribute must be \'{1}\'' \ ''.format(self.package, self.reqd_status) lib_ref = 'L3V1 {0} V1 Section'.format(self.up_package) tc = '{0}AttributeRequiredMustHaveValue'.format(self.up_package) return dict({'number': self.number, 'text': text, 'reference': ref, 'severity': sev, 'typecode': tc, 'lib_sev': lib_sev, 'short': short, 'lib_ref': lib_ref})
def write_element_not_ns_rule(self): text = 'Wherever they appear in an SBML document, elements and ' \ 'attributes from the {0} must use the ' \ '\\uri{1}http://www.sbml.org/sbml/level{2}/version{3}' \ '/{4}/version{5}{6} namespace, declaring so either explicitly ' \ 'or implicitly.'\ .format(self.full_pkg_command, self.start_b, self.level, self.version, self.package, self.pkg_version, self.end_b) ref = '{0} {1}.'\ .format(self.pkg_ref, strFunctions.wrap_section('xml-namespace', False)) sev = 'ERROR' lib_sev = '{0}_SEV_ERROR'.format(global_variables.up_full_lib) short = 'Element not in {0} namespace'.format(self.up_package) lib_ref = 'L3V1 {0} V1 Section 3.1'.format(self.up_package) tc = '{0}ElementNotInNs'.format(self.up_package) return dict({'number': self.number, 'text': text, 'reference': ref, 'severity': sev, 'typecode': tc, 'lib_sev': lib_sev, 'short': short, 'lib_ref': lib_ref})
def write_core_subobject_rule(self, lo_child=None): if lo_child is None: text = '{0} {1} object may have the optional SBML Level~3 ' \ 'Core subobjects for notes and annotations. No other ' \ 'elements from the SBML Level~3 Core namespaces are ' \ 'permitted on {2} {1}.'\ .format(self.indef_u, self.formatted_name, self.indef) ref = 'SBML Level~3 Version~1 Core, Section~3.2.' sev = 'ERROR' tc = '{0}{1}AllowedCoreElements'.format(self.up_package, self.name) lo = False else: if 'type' in lo_child: loname = strFunctions.get_element_name(lo_child) element = lo_child['element'] lo_name = strFunctions.plural(element) else: # we are in a plugin so have different fields loname = strFunctions.cap_list_of_name(lo_child['name']) element = lo_child['name'] lo_name = strFunctions.plural(element) text = 'Apart from the general notes and annotations subobjects ' \ 'permitted on all SBML objects, a \{0} container object ' \ 'may only contain \{1} objects.'\ .format(loname, element) add_extended = True if self.package == 'render': add_extended = False ref = '{0}, {1}.'\ .format(self.pkg_ref, strFunctions.wrap_section(self.name, True, add_extended)) sev = 'ERROR' tc = '{0}{1}LO{2}AllowedCoreElements'.format(self.up_package, self.name, lo_name) lo = True lib_sev = '{0}_SEV_ERROR'.format(global_variables.up_full_lib) short = 'Core elements allowed on <{0}>.'.format(self.lower_name) lib_ref = 'L3V1 {0} V1 Section'.format(self.up_package) return dict({'number': self.number, 'text': text, 'reference': ref, 'severity': sev, 'typecode': tc, 'lib_sev': lib_sev, 'short': short, 'lib_ref': lib_ref, 'plugin': True, 'object': self.name, 'lo': lo, 'reqd': self.reqd_elem, 'opt': self.opt_elem})
def write_ns_rule(self): text = 'To conform to the {0} specification for SBML Level~{1} ' \ 'Version~{2}, an SBML document must declare ' \ '\\uri{3}http://www.sbml.org/sbml/' \ 'level{1}/version{2}/{4}/version{5}{6} as the XMLNamespace ' \ 'to use for elements of this package.'\ .format(self.full_pkg_command, self.level, self.version, self.start_b, self.package, self.pkg_version, self.end_b) ref = '{0} {1}.'\ .format(self.pkg_ref, strFunctions.wrap_section('xml-namespace', False)) sev = 'ERROR' lib_sev = '{0}_SEV_ERROR'.format(global_variables.up_full_lib) short = 'The {0} namespace is not correctly ' \ 'declared.'.format(self.up_package) lib_ref = 'L3V1 {0} V1 Section 3.1'.format(self.up_package) tc = '{0}NSUndeclared'.format(self.up_package) return dict({'number': self.number, 'text': text, 'reference': ref, 'severity': sev, 'typecode': tc, 'lib_sev': lib_sev, 'short': short, 'lib_ref': lib_ref})
def write_core_subobject_rule(self, lo_child=None): if lo_child is None: text = '{0} {1} object may have the optional SBML Level~3 ' \ 'Core subobjects for notes and annotations. No other ' \ 'elements from the SBML Level 3 Core namespaces are ' \ 'permitted on {2} {1}.'\ .format(self.indef_u, self.formatted_name, self.indef) ref = 'SBML Level~3 Version~1 Core, Section~3.2.' sev = 'ERROR' tc = '{0}{1}AllowedCoreElements'.format(self.up_package, self.name) lo = False else: if 'type' in lo_child: loname = strFunctions.get_element_name(lo_child) element = lo_child['element'] lo_name = strFunctions.plural(element) else: # we are in a plugin so have different fields loname = strFunctions.cap_list_of_name(lo_child['name']) element = lo_child['name'] lo_name = strFunctions.plural(element) text = 'Apart from the general notes and annotations subobjects ' \ 'permitted on all SBML objects, a \{0} container object ' \ 'may only contain \{1} objects.'\ .format(loname, element) ref = '{0}, {1}.'\ .format(self.pkg_ref, strFunctions.wrap_section(self.name)) sev = 'ERROR' tc = '{0}{1}LO{2}AllowedCoreElements'.format(self.up_package, self.name, lo_name) lo = True lib_sev = '{0}_SEV_ERROR'.format(global_variables.up_full_lib) short = 'Core elements allowed on <{0}>.'.format(self.lower_name) lib_ref = 'L3V1 {0} V1 Section'.format(self.up_package) return dict({'number': self.number, 'text': text, 'reference': ref, 'severity': sev, 'typecode': tc, 'lib_sev': lib_sev, 'short': short, 'lib_ref': lib_ref, 'plugin': True, 'object': self.name, 'lo': lo, 'reqd': self.reqd_elem, 'opt': self.opt_elem})
def write_file(self): BaseTexFile.BaseTexFile.write_file(self) self.write_line('\\section{Package syntax and semantics}') self.skip_line() self.write_line('In this section, we define the syntax and ' 'semantics of the {0} for ' '\\sbmlthreecore. We expound on the various data ' 'types and constructs defined in this package, ' 'then in {1}, we provide complete ' 'examples of using the constructs in example ' 'SBML models.'.format(self.full_pkg_command, strFunctions.wrap_section( 'examples', False))) self.skip_line() self.write_namespace_section() self.write_primitive_data_types() for i in range(0, len(self.plugins)): self.write_body_for_extended_class(self.plugins[i]) for i in range(0, len(self.sbml_classes)): # hack for render if self.sbml_classes[i]['name'] != 'RelAbsVector': self.write_body_for_class(self.sbml_classes[i])
def write_lochild_attribute_rule(self, child, lo_info): child_class = query.get_class(child['element'], child['root']) if not child_class or len(child_class['lo_attribs']) == 0: return # if these are all elements we dont need this num = len(child_class['lo_attribs']) count = 0 for attrib in child_class['lo_attribs']: if self.is_element(attrib['type']): count += 1 if count == num: return attributes = [] if len(child_class['lo_class_name']) == 0: child_class['lo_class_name'] = strFunctions.list_of_name(child_class['name']) formatted_name = '\\' + child_class['lo_class_name'] name = child_class['name'] child_reqd = [] child_opt = [] for attrib in child_class['lo_attribs']: attributes.append(attrib) if attrib['reqd']: child_reqd.append(attrib) else: child_opt.append(attrib) lo_info.append(dict({'formatted_name': formatted_name, 'name': child_class['lo_class_name'], 'attributes': attributes})) reqd = self.parse_required(self, child_reqd) opt = self.parse_optional(self, child_opt) no_other_statement = 'No other attributes from the SBML Level 3 {0} ' \ 'namespaces are permitted on {1} {2} object. '\ .format(self.fullname, self.indef, formatted_name) if len(opt) == 0 and len(reqd) > 0: text = '{0} {1} object must have {2}. {3}'\ .format(self.indef_u, formatted_name, reqd, no_other_statement) elif len(reqd) == 0 and len(opt) > 0: text = '{0} {1} object may have {2}. {3}'\ .format(self.indef_u, formatted_name, opt, no_other_statement) else: text = '{0} {1} object must have {2}, and may have {3}. {4}'\ .format(self.indef_u, formatted_name, reqd, opt, no_other_statement) ref = '{0}, {1}.'\ .format(self.pkg_ref, strFunctions.wrap_section(child_class['lo_class_name'])) sev = 'ERROR' lib_sev = '{0}_SEV_ERROR'.format(global_variables.up_full_lib) short = 'Attributes allowed on <{0}>.'.format(strFunctions.lower_first(child_class['lo_class_name'])) lib_ref = 'L3V1 {0} V1 Section'.format(self.up_package) tc = '{0}{1}LO{2}AllowedAttributes'.format(self.up_package, self.name, strFunctions.plural(name)) return dict({'number': self.number, 'text': text, 'reference': ref, 'severity': sev, 'typecode': tc, 'lib_sev': lib_sev, 'short': short, 'lib_ref': lib_ref, 'plugin': False, 'object': self.name, 'lo': True, 'reqd': child_reqd, 'opt': child_opt, 'lo_object': lo_info[0]['name']})
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 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' if ref_name == 'SBase': text = 'The value of the attribute {0} of {1} {2} object must be ' \ 'the identifier of an existing object derived from the \SBase class and defined in the ' \ 'enclosing \Model object.'\ .format(name, self.indef, self.formatted_name, ref_name) else: 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, self.formatted_name, ref_name) rule_type = ref_type elif att_type == 'string': text = 'The attribute {0} on {1} {2} must have a value of data ' \ 'type {3}.'\ .format(name, self.indef, self.formatted_name, strFunctions.wrap_token('string')) elif att_type == 'ID': text = 'The attribute {0} on {1} {2} must have a value of XML data ' \ 'type {3}.'\ .format(name, self.indef, self.formatted_name, strFunctions.wrap_token('ID')) elif att_type == 'IDREF': text = 'The value of the attribute {0} of {1} {2} object must be ' \ 'the \'metaid\' of an existing \SBase object defined in the ' \ 'enclosing \Model object.'\ .format(name, self.indef, formatted_name) rule_type = 'SBase' elif att_type == 'int' or att_type == 'uint': text = 'The attribute {0} on {1} {2} must have a value of data ' \ 'type {3}{4}'\ .format(name, self.indef, self.formatted_name, strFunctions.wrap_token('integer'), '.' if att_type == 'int' else ', and must be non negative.') rule_type = 'Integer' if att_type == 'int' else 'NonNegativeInteger' elif att_type == 'double': text = 'The attribute {0} on {1} {2} must have a value of data ' \ 'type {3}.'\ .format(name, self.indef, self.formatted_name, strFunctions.wrap_token('double')) rule_type = 'Double' elif att_type == 'bool' or att_type == 'boolean': text = 'The attribute {0} on {1} {2} must have a value of data ' \ 'type {3}.'\ .format(name, self.indef, self.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 = 'UnitSId' elif att_type == 'enum': enum_name = attribute['element'] enums = attribute['parent']['root']['enums'] enum_values = self.parse_enum_values(enum_name, 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, self.formatted_name, strFunctions.wrap_enum(enum_name), enum_values) rule_type = '{0}Enum'.format(attribute['element']) elif att_type == 'array': array_type = strFunctions.lower_first(attribute['element']) text = 'The value of the attribute {0} of {1} {2} object must ' \ 'be an array of values of type {3}.'\ .format(name, self.indef, self.formatted_name, strFunctions.wrap_token(array_type)) else: text = 'FIX ME: Encountered an unknown attribute type {0} in ' \ 'ValidationRulesForClass:write_attribute_type_rule'\ .format(att_type) add_extended = True if self.package == 'render': add_extended = False ref = '{0}, {1}.'\ .format(self.pkg_ref, strFunctions.wrap_section(self.name, True, add_extended)) 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, self.name, att_name, rule_type) return dict({'number': self.number, 'text': text, 'reference': ref, 'severity': sev, 'typecode': tc, 'plugin': True, 'object': self.name, 'lo': False, 'lib_sev': lib_sev, 'short': short, 'lib_ref': lib_ref, 'attrib': attribute['name'], 'attrib_type': att_type})
def write_attribute_type_rule(self, attribute): att_type = attribute['type'] att_name = strFunctions.upper_first(attribute['name']) name = strFunctions.wrap_token(attribute['name'], self.package) rule_type = 'String' if att_type == 'SId': return elif att_type == 'SIdRef': ref_name = strFunctions.upper_first(attribute['name']) # 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, self.formatted_name, ref_name) rule_type = ref_name elif att_type == 'string': text = 'The attribute {0} on {1} {2} must have a value of data ' \ 'type {3}.'\ .format(name, self.indef, self.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, self.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, self.formatted_name, strFunctions.wrap_token('double')) rule_type = 'Double' elif att_type == 'bool' or att_type == 'boolean': text = 'The attribute {0} on {1} {2} must have a value of data ' \ 'type {3}.'\ .format(name, self.indef, self.formatted_name, strFunctions.wrap_token('boolean')) rule_type = 'Boolean' elif att_type == 'enum': enum_name = attribute['element'] enums = attribute['parent']['root']['enums'] enum_values = self.parse_enum_values(enum_name, 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, self.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, self.formatted_name, strFunctions.wrap_token(attribute['element'])) else: text = 'FIX ME: Encountered an unknown attribute type {0} in ' \ 'ValidationRulesForClass:write_attribute_type_rule'\ .format(att_type) ref = '{0}, {1}.'\ .format(self.pkg_ref, strFunctions.wrap_section(self.name)) sev = 'ERROR' lib_sev = '{0}_SEV_ERROR'.format(global_variables.up_full_lib) short = 'Attribute {0} values allowed on <{1}>.' \ ''.format(attribute['name'], self.lower_name) lib_ref = 'L3V1 {0} V1 Section'.format(self.up_package) tc = '{0}{1}{2}MustBe{3}'.format(self.up_package, self.name, 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})