Format python files with YAPF (#1947)

Enabling yapf formatting of python files

Author: cssherman

geosx_mesh_tools_package/geosx_mesh_tools/abaqus_converter.py

@@ -1,4 +1,3 @@
-
 import meshio
 from meshio._mesh import CellBlock
 import numpy as np
@@ -19,8 +18,8 @@ def convert_abaqus_to_gmsh(input_mesh, output_mesh, logger=None):
     """
     # Initialize the logger if it is empty
     if not logger:
-      logging.basicConfig(level=logging.WARNING)
-      logger = logging.getLogger(__name__)
+        logging.basicConfig(level=logging.WARNING)
+        logger = logging.getLogger(__name__)
 
     # Keep track of the number of warnings
     n_warnings = 0
@@ -142,10 +141,9 @@ def main():
     logging.basicConfig(level=logging.WARNING)
     logger = logging.getLogger(__name__)
     if args.verbose:
-      logger.setLevel(logging.INFO)
+        logger.setLevel(logging.INFO)
 
     # Call the converter
     err = convert_abaqus_to_gmsh(args.input, args.output, logger)
     if err:
         sys.exit('Warnings detected: check the output file for potential errors!')
-

geosx_mesh_tools_package/setup.py

@@ -8,4 +8,3 @@
       packages=['geosx_mesh_tools'],
       entry_points={'console_scripts': ['convert_abaqus = geosx_mesh_tools.abaqus_converter:main']},
       install_requires=['meshio'])
-

geosx_xml_tools_package/geosx_xml_tools/attribute_coverage.py

@@ -1,4 +1,3 @@
-
 from lxml import etree as ElementTree
 import os
 from pathlib import Path
@@ -65,9 +64,7 @@ def collect_xml_attributes_level(local_types, node, folder):
 
     for child in node:
         if child.tag in local_types['children']:
-            collect_xml_attributes_level(local_types['children'][child.tag],
-                                         child,
-                                         folder)
+            collect_xml_attributes_level(local_types['children'][child.tag], child, folder)
 
 
 def collect_xml_attributes(xml_types, fname, folder):

geosx_xml_tools_package/geosx_xml_tools/main.py

@@ -11,10 +11,19 @@ def parse_arguments():
     # Parse the user arguments
     parser = argparse.ArgumentParser()
     parser.add_argument('-i', '--input', type=str, action='append', help='Input file name (multiple allowed)')
-    parser.add_argument('-c', '--compiled-name', type=str, help='Compiled xml file name (otherwise, it is randomly genrated)', default='')
+    parser.add_argument('-c',
+                        '--compiled-name',
+                        type=str,
+                        help='Compiled xml 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 (name value, multiple allowed)', default=[])
+    parser.add_argument('-p',
+                        '--parameters',
+                        nargs='+',
+                        action='append',
+                        help='Parameter overrides (name value, multiple allowed)',
+                        default=[])
     return parser.parse_known_args()
 
 
@@ -28,7 +37,9 @@ def check_mpi_rank():
 
 
 def wait_for_file_write_rank_0(target_file_argument=0, max_wait_time=100, max_startup_delay=1):
+
     def wait_for_file_write_rank_0_inner(writer):
+
         def wait_for_file_write_rank_0_decorator(*args, **kwargs):
             # Check the target file status
             rank = check_mpi_rank()
@@ -46,22 +57,24 @@ def wait_for_file_write_rank_0_decorator(*args, **kwargs):
                 # Variations in thread startup times may mean the file has already been processed
                 # If the last edit was done within the specified time, then allow the thread to proceed
                 if (abs(target_file_edit_time - time.time()) < max_startup_delay):
-                    target_file_edit_time = 0                    
+                    target_file_edit_time = 0
 
             # Go into the target process or wait for the expected file update
             if (rank == 0):
                 return writer(*args, **kwargs)
             else:
                 ta = time.time()
-                while(time.time() - ta < max_wait_time):
+                while (time.time() - ta < max_wait_time):
                     if target_file_exists:
                         if (os.path.getmtime(fname) > target_file_edit_time):
                             break
                     else:
                         if os.path.isfile(fname):
                             break
                     time.sleep(0.1)
+
         return wait_for_file_write_rank_0_decorator
+
     return wait_for_file_write_rank_0_inner
 
 
@@ -89,7 +102,9 @@ def preprocess_serial():
         if args.compiled_name:
             compiled_name = args.compiled_name
         else:
-            raise Exception('When applying the preprocessor in parallel (outside of pygeosx), the --compiled_name argument is required')
+            raise Exception(
+                'When applying the preprocessor in parallel (outside of pygeosx), the --compiled_name argument is required'
+            )
 
     # Note: the return value may be passed to sys.exit, and cause bash to report an error
     # return format_geosx_arguments(compiled_name, unknown_args)

geosx_xml_tools_package/geosx_xml_tools/regex_tools.py

@@ -2,7 +2,6 @@
 
 import re
 
-
 # Define regex patterns used throughout the module:
 #
 # Pattern         |  Example targets             | Notes
@@ -16,13 +15,15 @@
 # strip_trailing  | 3.0000, 5.150050             | Removes unnecessary float strings
 # strip_trailing_b| 3.0000e0, 1.23e0             | Removes unnecessary float strings
 #
-patterns = {'parameters': r"\$:?([a-zA-Z_0-9]*)\$?",
-            'units': r"([0-9]*?\.?[0-9]+(?:[eE][-+]?[0-9]*?)?)\ *?\[([-+.*/()a-zA-Z0-9]*)\]",
-            'units_b': r"([a-zA-Z]*)",
-            'symbolic': r"\`([-+.*/() 0-9eE]*)\`",
-            'sanitize': r"[a-z-[e]A-Z-[E]]",
-            'strip_trailing': r"\.?0+(?=e)",
-            'strip_trailing_b': r"e\+00|\+0?|(?<=-)0"}
+patterns = {
+    'parameters': r"\$:?([a-zA-Z_0-9]*)\$?",
+    'units': r"([0-9]*?\.?[0-9]+(?:[eE][-+]?[0-9]*?)?)\ *?\[([-+.*/()a-zA-Z0-9]*)\]",
+    'units_b': r"([a-zA-Z]*)",
+    'symbolic': r"\`([-+.*/() 0-9eE]*)\`",
+    'sanitize': r"[a-z-[e]A-Z-[E]]",
+    'strip_trailing': r"\.?0+(?=e)",
+    'strip_trailing_b': r"e\+00|\+0?|(?<=-)0"
+}
 
 # String formatting for symbolic expressions
 symbolic_format = '%1.6e'
@@ -31,7 +32,7 @@
 def SymbolicMathRegexHandler(match):
     """Evaluate symbolic expressions that are identified using the regex_tools.patterns['symbolic'].
 
-       @param match A matching string identified by the regex.
+    @param match A matching string identified by the regex.
     """
     k = match.group(1)
     if k:
@@ -52,15 +53,15 @@ class DictRegexHandler():
 
     def __init__(self):
         """Initialize the handler with an empty target list.
-           The key/value pairs of self.target indicate which values
-           to look for and the values they will replace with.
+        The key/value pairs of self.target indicate which values
+        to look for and the values they will replace with.
         """
         self.target = {}
 
     def __call__(self, match):
         """Replace the matching strings with their target.
 
-           @param match A matching string identified by the regex.
+        @param match A matching string identified by the regex.
         """
 
         k = match.group(1)

geosx_xml_tools_package/geosx_xml_tools/table_generator.py

@@ -6,10 +6,10 @@
 def write_GEOS_table(axes_values, properties, axes_names=['x', 'y', 'z', 't'], string_format='%1.5e'):
     """Write an GEOS-compatible ascii table.
 
-       @param axes_values List of arrays containing the coordinates for each axis of the table.
-       @param properties Dict of arrays with dimensionality/size defined by the axes_values
-       @param axes_names Names for each axis (default = ['x', 'y', 'z', 't'])
-       @param string_format Format for output values (default = %1.5e)
+    @param axes_values List of arrays containing the coordinates for each axis of the table.
+    @param properties Dict of arrays with dimensionality/size defined by the axes_values
+    @param axes_names Names for each axis (default = ['x', 'y', 'z', 't'])
+    @param string_format Format for output values (default = %1.5e)
     """
 
     # Check to make sure the axes/property files have the correct shape
@@ -31,9 +31,9 @@ def write_GEOS_table(axes_values, properties, axes_names=['x', 'y', 'z', 't'], s
 def read_GEOS_table(axes_files, property_files):
     """Read an GEOS-compatible ascii table.
 
-       @param axes_files List of the axes file names in order.
-       @param property_files List of property file names
-       @return List of axis definitions, dict of property values
+    @param axes_files List of the axes file names in order.
+    @param property_files List of property file names
+    @return List of axis definitions, dict of property values
     """
     axes_values = []
     for f in axes_files:
@@ -59,7 +59,7 @@ def write_read_GEOS_table_example():
 
     # Generate table values (note: the indexing argument is important)
     A, B = np.meshgrid(a, b, indexing='ij')
-    properties = {'c': A + 2.0*B}
+    properties = {'c': A + 2.0 * B}
 
     # Write, then read tables
     write_GEOS_table(axes_values, properties, axes_names=['a', 'b'])

geosx_xml_tools_package/geosx_xml_tools/tests/generate_test_xml.py

@@ -9,7 +9,7 @@ def generate_test_xml_files(root_dir):
     """Build example input/output xml files, which can be used to test the parser.
      These are derived from a GEOSX integrated test xml.
 
-     @param root_dir The folder to write the example xml files.
+    @param root_dir The folder to write the example xml files.
     """
 
     # Build segments of an xml file that can be compiled to form a test
@@ -340,35 +340,35 @@ def generate_test_xml_files(root_dir):
     # Write the files, and apply pretty_print to targets for easy matches
     # No advanced features case
     with open('%s/no_advanced_features_input.xml' % (root_dir), 'w') as f:
-        f.write(xml_header+xml_base_a+xml_base_b+field_string_base+xml_footer)
+        f.write(xml_header + xml_base_a + xml_base_b + field_string_base + xml_footer)
     with open('%s/no_advanced_features_target.xml' % (root_dir), 'w') as f:
-        f.write(xml_header+xml_base_a+xml_base_b+field_string_base+xml_footer)
+        f.write(xml_header + xml_base_a + xml_base_b + field_string_base + xml_footer)
     xml_formatter.format_file('%s/no_advanced_features_target.xml' % (root_dir))
 
     # Parameters case
     with open('%s/parameters_input.xml' % (root_dir), 'w') as f:
-        f.write(xml_header+xml_parameters+xml_base_a+xml_base_b+field_string_with_parameters+xml_footer)
+        f.write(xml_header + xml_parameters + xml_base_a + xml_base_b + field_string_with_parameters + xml_footer)
     with open('%s/parameters_target.xml' % (root_dir), 'w') as f:
-        f.write(xml_header+xml_base_a+xml_base_b+field_string_base+xml_footer)
+        f.write(xml_header + xml_base_a + xml_base_b + field_string_base + xml_footer)
     xml_formatter.format_file('%s/parameters_target.xml' % (root_dir))
 
     # Symbolic + parameters case
     with open('%s/symbolic_parameters_input.xml' % (root_dir), 'w') as f:
-        f.write(xml_header+xml_parameters+xml_base_a+xml_base_b+field_string_with_symbolic+xml_footer)
+        f.write(xml_header + xml_parameters + xml_base_a + xml_base_b + field_string_with_symbolic + xml_footer)
     with open('%s/symbolic_parameters_target.xml' % (root_dir), 'w') as f:
-        f.write(xml_header+xml_base_a+xml_base_b+field_string_alt+xml_footer)
+        f.write(xml_header + xml_base_a + xml_base_b + field_string_alt + xml_footer)
     xml_formatter.format_file('%s/symbolic_parameters_target.xml' % (root_dir))
 
     # Included case
     os.makedirs('%s/included' % (root_dir), exist_ok=True)
     with open('%s/included_input.xml' % (root_dir), 'w') as f:
-        f.write(xml_header+xml_includes+xml_footer)
+        f.write(xml_header + xml_includes + xml_footer)
     with open('%s/included/included_a.xml' % (root_dir), 'w') as f:
-        f.write(xml_header+xml_base_a+xml_footer)
+        f.write(xml_header + xml_base_a + xml_footer)
     with open('%s/included/included_b.xml' % (root_dir), 'w') as f:
-        f.write(xml_header+xml_base_b+xml_footer)
+        f.write(xml_header + xml_base_b + xml_footer)
     with open('%s/included/included_c.xml' % (root_dir), 'w') as f:
-        f.write(xml_header+field_string_base+xml_footer)
+        f.write(xml_header + field_string_base + xml_footer)
     with open('%s/included_target.xml' % (root_dir), 'w') as f:
-        f.write(xml_header+xml_base_a+xml_base_b+field_string_base+xml_footer)
+        f.write(xml_header + xml_base_a + xml_base_b + field_string_base + xml_footer)
     xml_formatter.format_file('%s/included_target.xml' % (root_dir))

geosx_xml_tools_package/geosx_xml_tools/tests/test_manager.py

@@ -7,13 +7,13 @@
 import argparse
 from parameterized import parameterized
 
-
 # Create an instance of the unit manager
 unitManager = unit_manager.UnitManager()
 
 
 # Test the unit manager definitions
 class TestUnitManager(unittest.TestCase):
+
     @classmethod
     def setUpClass(cls):
         cls.tol = 1e-6
@@ -23,30 +23,14 @@ def test_unit_dict(self):
         self.assertTrue(bool(unitManager.units))
 
     # Scale value tests
-    @parameterized.expand([['meter', '2', 2.0],
-                           ['meter', '1.234', 1.234],
-                           ['meter', '1.234e1', 12.34],
-                           ['meter', '1.234E1', 12.34],
-                           ['meter', '1.234e+1', 12.34],
-                           ['meter', '1.234e-1', 0.1234],
-                           ['mumeter', '1', 1.0e-6],
-                           ['micrometer', '1', 1.0e-6],
-                           ['kilometer', '1', 1.0e3],
-                           ['ms', '1', 1.0e-3],
-                           ['millisecond', '1', 1.0e-3],
-                           ['Ms', '1', 1.0e6],
-                           ['m/s', '1', 1.0],
-                           ['micrometer/s', '1', 1.0e-6],
-                           ['micrometer/ms', '1', 1.0e-3],
-                           ['micrometer/microsecond', '1', 1.0],
-                           ['m**2', '1', 1.0],
-                           ['km**2', '1', 1.0e6],
-                           ['kilometer**2', '1', 1.0e6],
-                           ['(km*mm)', '1', 1.0],
-                           ['(km*mm)**2', '1', 1.0],
-                           ['km^2', '1', 1.0e6, True],
-                           ['bbl/day', '1', 0.000001840130728333],
-                           ['cP', '1', 0.001]])
+    @parameterized.expand([['meter', '2', 2.0], ['meter', '1.234', 1.234], ['meter', '1.234e1', 12.34],
+                           ['meter', '1.234E1', 12.34], ['meter', '1.234e+1', 12.34], ['meter', '1.234e-1', 0.1234],
+                           ['mumeter', '1', 1.0e-6], ['micrometer', '1', 1.0e-6], ['kilometer', '1', 1.0e3],
+                           ['ms', '1', 1.0e-3], ['millisecond', '1', 1.0e-3], ['Ms', '1', 1.0e6], ['m/s', '1', 1.0],
+                           ['micrometer/s', '1', 1.0e-6], ['micrometer/ms', '1', 1.0e-3],
+                           ['micrometer/microsecond', '1', 1.0], ['m**2', '1', 1.0], ['km**2', '1', 1.0e6],
+                           ['kilometer**2', '1', 1.0e6], ['(km*mm)', '1', 1.0], ['(km*mm)**2', '1', 1.0],
+                           ['km^2', '1', 1.0e6, True], ['bbl/day', '1', 0.000001840130728333], ['cP', '1', 0.001]])
     def test_units(self, unit, scale, expected_value, expect_fail=False):
         try:
             val = float(unitManager([scale, unit]))
@@ -64,11 +48,9 @@ def setUpClass(cls):
         cls.regexHandler.target['foo'] = '1.23'
         cls.regexHandler.target['bar'] = '4.56e7'
 
-    @parameterized.expand([['$:foo*1.234', '1.23*1.234'],
-                           ['$:foo*1.234/$:bar', '1.23*1.234/4.56e7'],
+    @parameterized.expand([['$:foo*1.234', '1.23*1.234'], ['$:foo*1.234/$:bar', '1.23*1.234/4.56e7'],
                            ['$:foo*1.234/($:bar*$:foo)', '1.23*1.234/(4.56e7*1.23)'],
-                           ['$foo*1.234/$bar', '1.23*1.234/4.56e7'],
-                           ['$foo$*1.234/$bar', '1.23*1.234/4.56e7'],
+                           ['$foo*1.234/$bar', '1.23*1.234/4.56e7'], ['$foo$*1.234/$bar', '1.23*1.234/4.56e7'],
                            ['$foo$*1.234/$bar$', '1.23*1.234/4.56e7'],
                            ['$blah$*1.234/$bar$', '1.23*1.234/4.56e7', True],
                            ['$foo$*1.234/$bar$', '4.56e7*1.234/4.56e7', True]])
@@ -87,9 +69,7 @@ class TestUnitsRegex(unittest.TestCase):
     def setUpClass(cls):
         cls.tol = 1e-6
 
-    @parameterized.expand([['1.234[m**2/s]', '1.234'],
-                           ['1.234 [m**2/s]', '1.234'],
-                           ['1.234[m**2/s]*3.4', '1.234*3.4'],
+    @parameterized.expand([['1.234[m**2/s]', '1.234'], ['1.234 [m**2/s]', '1.234'], ['1.234[m**2/s]*3.4', '1.234*3.4'],
                            ['1.234[m**2/s] + 5.678[mm/s]', '1.234 + 5.678e-3'],
                            ['1.234 [m**2/s] + 5.678 [mm/s]', '1.234 + 5.678e-3'],
                            ['(1.234[m**2/s])*5.678', '(1.234)*5.678']])
@@ -108,19 +88,10 @@ class TestSymbolicRegex(unittest.TestCase):
     def setUpClass(cls):
         cls.tol = 1e-6
 
-    @parameterized.expand([['`1.234`', '1.234'],
-                           ['`1.234*2.0`', '2.468'],
-                           ['`10`', '1e1'],
-                           ['`10*2`', '2e1'],
-                           ['`1.0/2.0`', '5e-1'],
-                           ['`2.0**2`', '4'],
-                           ['`1.0 + 2.0**2`', '5'],
-                           ['`(1.0 + 2.0)**2`', '9'],
-                           ['`((1.0 + 2.0)**2)**(0.5)`', '3'],
-                           ['`(1.2e3)*2`', '2.4e3'],
-                           ['`1.2e3*2`', '2.4e3'],
-                           ['`2.0^2`', '4', True],
-                           ['`sqrt(4.0)`', '2', True]])
+    @parameterized.expand([['`1.234`', '1.234'], ['`1.234*2.0`', '2.468'], ['`10`', '1e1'], ['`10*2`', '2e1'],
+                           ['`1.0/2.0`', '5e-1'], ['`2.0**2`', '4'], ['`1.0 + 2.0**2`', '5'], ['`(1.0 + 2.0)**2`', '9'],
+                           ['`((1.0 + 2.0)**2)**(0.5)`', '3'], ['`(1.2e3)*2`', '2.4e3'], ['`1.2e3*2`', '2.4e3'],
+                           ['`2.0^2`', '4', True], ['`sqrt(4.0)`', '2', True]])
     def test_symbolic_regex(self, symbolicInput, expectedValue, expect_fail=False):
         try:
             result = re.sub(regex_tools.patterns['symbolic'], regex_tools.SymbolicMathRegexHandler, symbolicInput)
@@ -131,6 +102,7 @@ def test_symbolic_regex(self, symbolicInput, expectedValue, expect_fail=False):
 
 # Test the complete xml processor
 class TestXMLProcessor(unittest.TestCase):
+
     @classmethod
     def setUpClass(cls):
         generate_test_xml.generate_test_xml_files('.')