Add pygeosx tutorials and update advanced xml features (#1609)

Adding script to automatically apply xml preprocesser, updating advanced xml feature documentation, adding pygeosx examples

Author: cssherman

geosx_xml_tools_package/geosx_xml_tools/__main__.py

@@ -5,32 +5,33 @@
 
 
 def main():
-  """Entry point for the geosx_xml_tools console script
-
-  @arg input Input file name
-  @arg -o/--output Output filename (default = randomly generated string)
-  @arg -s/--schema GEOSX schema to use for validating the generated xml
-  @arg -v/--verbose Verbosity level
-  """
-
-  # Parse the user arguments
-  parser = argparse.ArgumentParser()
-  parser.add_argument('input', type=str, help='Input file name')
-  parser.add_argument('-o', '--output', type=str, help='Output file name (otherwise, it is randomly genrated)', default='')
-  parser.add_argument('-s', '--schema', type=str, help='GEOSX schema to use for validation', default='')
-  parser.add_argument('-v', '--verbose', type=int, help='Verbosity of outputs', default=0)
-  args = parser.parse_args()
-
-  # Process the xml file
-  output_name = xml_processor.process(args.input,
-                                      outputFile=args.output,
-                                      schema=args.schema,
-                                      verbose=args.verbose)
-
-  print(output_name)
+    """Entry point for the geosx_xml_tools console script
+
+    @arg input Input file name
+    @arg -o/--output Output filename (default = randomly generated string)
+    @arg -s/--schema GEOSX schema to use for validating the generated xml
+    @arg -v/--verbose Verbosity level
+    """
+
+    # Parse the user arguments
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-i', '--input', type=str, action='append', help='Input file name')
+    parser.add_argument('-o', '--output', type=str, help='Output file name (otherwise, it is randomly genrated)', default='')
+    parser.add_argument('-s', '--schema', type=str, help='GEOSX schema to use for validation', default='')
+    parser.add_argument('-v', '--verbose', type=int, help='Verbosity of outputs', default=0)
+    parser.add_argument('-p', '--parameters', nargs='+', action='append', help='Parameter overrides', default=[])
+    args = parser.parse_args()
+
+    # Process the xml file
+    output_name = xml_processor.process(args.input,
+                                        outputFile=args.output,
+                                        schema=args.schema,
+                                        verbose=args.verbose,
+                                        parameter_override=args.parameters)
+    print(output_name)
 
 
 if __name__ == "__main__":
-  main()
+    main()
 
 

geosx_xml_tools_package/geosx_xml_tools/attribute_coverage.py

@@ -10,165 +10,164 @@ def parse_schema_element(root,
                          xsd='{http://www.w3.org/2001/XMLSchema}',
                          recursive_types=['PeriodicEvent', 'SoloEvent', 'HaltEvent'],
                          folders=['src', 'examples']):
-  """Parse the xml schema at the current level
-
-  @arg root the root schema node
-  @arg node current schema node
-  @arg xsd the file namespace
-  @arg recursive_types node tags that allow recursive nesting
-  @arg folders folders to sort xml attribute usage into
-  """
-
-  element_type = node.get('type')
-  element_name = node.get('name')
-  element_def = root.find("%scomplexType[@name='%s']" % (xsd, element_type))
-  local_types = {'attributes': {}, 'children': {}}
-
-  # Parse attributes
-  for attribute in element_def.findall('%sattribute' % (xsd)):
-    attribute_name = attribute.get('name')
-    local_types['attributes'][attribute_name] = {ka: [] for ka in folders}
-    if ('default' in attribute.attrib):
-      local_types['attributes'][attribute_name]['default'] = attribute.get('default')
-
-  # Parse children
-  choice_node = element_def.findall('%schoice' % (xsd))
-  if choice_node:
-    for child in choice_node[0].findall('%selement' % (xsd)):
-      child_name = child.get('name')
-      if not ((child_name in recursive_types) and (element_name in recursive_types)):
-        local_types['children'][child_name] = parse_schema_element(root, child)
-
-  return local_types
+    """Parse the xml schema at the current level
+
+    @arg root the root schema node
+    @arg node current schema node
+    @arg xsd the file namespace
+    @arg recursive_types node tags that allow recursive nesting
+    @arg folders folders to sort xml attribute usage into
+    """
+
+    element_type = node.get('type')
+    element_name = node.get('name')
+    element_def = root.find("%scomplexType[@name='%s']" % (xsd, element_type))
+    local_types = {'attributes': {}, 'children': {}}
+
+    # Parse attributes
+    for attribute in element_def.findall('%sattribute' % (xsd)):
+        attribute_name = attribute.get('name')
+        local_types['attributes'][attribute_name] = {ka: [] for ka in folders}
+        if ('default' in attribute.attrib):
+            local_types['attributes'][attribute_name]['default'] = attribute.get('default')
+
+    # Parse children
+    choice_node = element_def.findall('%schoice' % (xsd))
+    if choice_node:
+        for child in choice_node[0].findall('%selement' % (xsd)):
+            child_name = child.get('name')
+            if not ((child_name in recursive_types) and (element_name in recursive_types)):
+                local_types['children'][child_name] = parse_schema_element(root, child)
+
+    return local_types
 
 
 def parse_schema(fname):
-  """Parse the schema file into the xml attribute usage dict
+    """Parse the schema file into the xml attribute usage dict
 
-  @arg fname schema name
-  """
-  xml_tree = ElementTree.parse(fname)
-  xml_root = xml_tree.getroot()
-  problem_node = xml_root.find("{http://www.w3.org/2001/XMLSchema}element")
-  return {'Problem': parse_schema_element(xml_root, problem_node)}
+    @arg fname schema name
+    """
+    xml_tree = ElementTree.parse(fname)
+    xml_root = xml_tree.getroot()
+    problem_node = xml_root.find("{http://www.w3.org/2001/XMLSchema}element")
+    return {'Problem': parse_schema_element(xml_root, problem_node)}
 
 
 def collect_xml_attributes_level(local_types, node, folder):
-  """Collect xml attribute usage at the current level
+    """Collect xml attribute usage at the current level
 
-  @arg local_types dict containing attribute usage
-  @arg node current xml node
-  @arg folder the source folder for the current file
-  """
-  for ka in node.attrib.keys():
-    local_types['attributes'][ka][folder].append(node.get(ka))
+    @arg local_types dict containing attribute usage
+    @arg node current xml node
+    @arg folder the source folder for the current file
+    """
+    for ka in node.attrib.keys():
+        local_types['attributes'][ka][folder].append(node.get(ka))
 
-  for child in node:
-    if child.tag in local_types['children']:
-      collect_xml_attributes_level(local_types['children'][child.tag],
-                                   child,
-                                   folder)
+    for child in node:
+        if child.tag in local_types['children']:
+            collect_xml_attributes_level(local_types['children'][child.tag],
+                                         child,
+                                         folder)
 
 
 def collect_xml_attributes(xml_types, fname, folder):
-  """Collect xml attribute usage in a file
+    """Collect xml attribute usage in a file
 
-  @arg xml_types dict containing attribute usage
-  @arg fname name of the target file
-  @arg folder the source folder for the current file
-  """
-  parser = ElementTree.XMLParser(remove_comments=True, remove_blank_text=True)
-  xml_tree = ElementTree.parse(fname, parser=parser)
-  xml_root = xml_tree.getroot()
+    @arg xml_types dict containing attribute usage
+    @arg fname name of the target file
+    @arg folder the source folder for the current file
+    """
+    parser = ElementTree.XMLParser(remove_comments=True, remove_blank_text=True)
+    xml_tree = ElementTree.parse(fname, parser=parser)
+    xml_root = xml_tree.getroot()
 
-  collect_xml_attributes_level(xml_types['Problem'], xml_root, folder)
+    collect_xml_attributes_level(xml_types['Problem'], xml_root, folder)
 
 
 def write_attribute_usage_xml_level(local_types, node, folders=['src', 'examples']):
-  """Write xml attribute usage file at a given level
+    """Write xml attribute usage file at a given level
 
-  @arg local_types dict containing attribute usage at the current level
-  @arg node current xml node
-  """
+    @arg local_types dict containing attribute usage at the current level
+    @arg node current xml node
+    """
 
-  # Write attributes
-  for ka in local_types['attributes'].keys():
-    attribute_node = ElementTree.Element(ka)
-    node.append(attribute_node)
+    # Write attributes
+    for ka in local_types['attributes'].keys():
+        attribute_node = ElementTree.Element(ka)
+        node.append(attribute_node)
 
-    if ('default' in local_types['attributes'][ka]):
-      attribute_node.set('default', local_types['attributes'][ka]['default'])
+        if ('default' in local_types['attributes'][ka]):
+            attribute_node.set('default', local_types['attributes'][ka]['default'])
 
-    unique_values = []
-    for f in folders:
-      sub_values = list(set(local_types['attributes'][ka][f]))
-      unique_values.extend(sub_values)
-      attribute_node.set(f, ' | '.join(sub_values))
+        unique_values = []
+        for f in folders:
+            sub_values = list(set(local_types['attributes'][ka][f]))
+            unique_values.extend(sub_values)
+            attribute_node.set(f, ' | '.join(sub_values))
 
-    unique_length = len(set(unique_values))
-    attribute_node.set('unique_values', str(unique_length))
+        unique_length = len(set(unique_values))
+        attribute_node.set('unique_values', str(unique_length))
 
-  # Write children
-  for ka in sorted(local_types['children']):
-    child = ElementTree.Element(ka)
-    node.append(child)
-    write_attribute_usage_xml_level(local_types['children'][ka], child)
+    # Write children
+    for ka in sorted(local_types['children']):
+        child = ElementTree.Element(ka)
+        node.append(child)
+        write_attribute_usage_xml_level(local_types['children'][ka], child)
 
 
 def write_attribute_usage_xml(xml_types, fname):
-  """Write xml attribute usage file
+    """Write xml attribute usage file
 
-  @arg xml_types dict containing attribute usage by xml type
-  @arg fname output file name
-  """
-  xml_root = ElementTree.Element('Problem')
-  xml_tree = ElementTree.ElementTree(xml_root)
+    @arg xml_types dict containing attribute usage by xml type
+    @arg fname output file name
+    """
+    xml_root = ElementTree.Element('Problem')
+    xml_tree = ElementTree.ElementTree(xml_root)
 
-  write_attribute_usage_xml_level(xml_types['Problem'], xml_root)
-  xml_tree.write(fname, pretty_print=True)
+    write_attribute_usage_xml_level(xml_types['Problem'], xml_root)
+    xml_tree.write(fname, pretty_print=True)
 
 
 def process_xml_files(geosx_root, output_name):
-  """Test for xml attribute usage
+    """Test for xml attribute usage
 
-  @arg geosx_root GEOSX root directory
-  @arg output_name output file name
-  """
+    @arg geosx_root GEOSX root directory
+    @arg output_name output file name
+    """
 
-  # Parse the schema
-  geosx_root = os.path.expanduser(geosx_root)
-  schema = '%ssrc/coreComponents/schema/schema.xsd' % (geosx_root)
-  xml_types = parse_schema(schema)
+    # Parse the schema
+    geosx_root = os.path.expanduser(geosx_root)
+    schema = '%ssrc/coreComponents/schema/schema.xsd' % (geosx_root)
+    xml_types = parse_schema(schema)
 
-  # Find all xml files, collect their attributes
-  for folder in ['src', 'examples']:
-    print(folder)
-    xml_files = Path(os.path.join(geosx_root, folder)).rglob('*.xml')
-    for f in xml_files:
-      print('  %s' % (str(f)))
-      collect_xml_attributes(xml_types, str(f), folder)
+    # Find all xml files, collect their attributes
+    for folder in ['src', 'examples']:
+        print(folder)
+        xml_files = Path(os.path.join(geosx_root, folder)).rglob('*.xml')
+        for f in xml_files:
+            print('  %s' % (str(f)))
+            collect_xml_attributes(xml_types, str(f), folder)
 
-  # Consolidate attributes
-  write_attribute_usage_xml(xml_types, output_name)
+    # Consolidate attributes
+    write_attribute_usage_xml(xml_types, output_name)
 
 
 def main():
-  """Entry point for the xml attribute usage test script
+    """Entry point for the xml attribute usage test script
 
-  @arg -r/--root GEOSX root directory
-  @arg -o/--output output file name
-  """
+    @arg -r/--root GEOSX root directory
+    @arg -o/--output output file name
+    """
 
-  # Parse the user arguments
-  parser = argparse.ArgumentParser()
-  parser.add_argument('-r', '--root', type=str, help='GEOSX root', default='')
-  parser.add_argument('-o', '--output', type=str, help='Output file name', default='attribute_test.xml')
-  args = parser.parse_args()
+    # Parse the user arguments
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-r', '--root', type=str, help='GEOSX root', default='')
+    parser.add_argument('-o', '--output', type=str, help='Output file name', default='attribute_test.xml')
+    args = parser.parse_args()
 
-  # Parse the xml files
-  process_xml_files(args.root, args.output)
+    # Parse the xml files
+    process_xml_files(args.root, args.output)
 
 
 if __name__ == "__main__":
-  main()
-
+    main()