Formatting - remove trailing whitespace (#31)

* Remove trailing whitespace

* Update flake8 config

Author: jleonatti

.flake8

@@ -1,6 +1,6 @@
 [flake8]
-# To be added once code is refactored: E501, W291, W293, F401
-select = W191, W391, E115, E117, E122, E124, E125, E225, E231, E301, E303, F403
+# To be added once code is refactored: E501, W293, F401
+select = W191, W291, W391, E115, E117, E122, E124, E125, E225, E231, E301, E303, F403
 count = True
 max-complexity = 10
 max-line-length = 100

ansys/dpf/post/__init__.py

@@ -12,7 +12,7 @@
 --------
 >>> from ansys.dpf import post
 >>> solution = post.solution("file.rst")
->>> disp = solution.nodal_displacement() 
+>>> disp = solution.nodal_displacement()
 
 """
 

ansys/dpf/post/common.py

@@ -4,7 +4,7 @@
 
 
 # class ElShapes(Enum):
-#     """Class with Enum inheritance. Must be used to 
+#     """Class with Enum inheritance. Must be used to
 #     describe the element shape when API allows it.
 
 #     Example
@@ -22,7 +22,7 @@
 
 
 class Grouping():
-    """Class with Enum inheritance. Must be used to 
+    """Class with Enum inheritance. Must be used to
     describe a grouping command when the API allows it.
     
     Examples
@@ -37,8 +37,8 @@ class Grouping():
 
 
 class _AvailableKeywords():
-    """Contains all the keywords that can be used inside of 
-    a method from a post.solution(file_path) object. 
+    """Contains all the keywords that can be used inside of
+    a method from a post.solution(file_path) object.
     
     In order to view the complete list of available keywords, use:
         post.print_available_keywords()

ansys/dpf/post/dpf_solution.py

@@ -23,25 +23,25 @@
 
 from ansys.dpf.post.misc_results import Misc, MecanicMisc, ComplexMecanicMisc, ThermalMisc
 
-from ansys.dpf.post.errors import NodalLocationError        
+from ansys.dpf.post.errors import NodalLocationError
 
 class DpfSolution:
     """Main class of post result API."""
     def __init__(self, data_sources, model):
-        """Initialization of the solution using data_sources 
+        """Initialization of the solution using data_sources
         and dpf.core.Model object."""
         self._data_sources = data_sources
         self._model = model
 
     @property
     def mesh(self):
-        """Mesh representation of the model. 
+        """Mesh representation of the model.
         Based on the dpf.core.MeshedRegion class."""
         return self._model.metadata.meshed_region
 
     @property
     def time_freq_support(self):
-        """Description of the temporal/frequency 
+        """Description of the temporal/frequency
         analysis of the model."""
         return self._model.metadata.time_freq_support
 
@@ -52,7 +52,7 @@ def get_result_info(self):
         --------
         >>> from ansys.dpf import post
         >>> result = post.result("file.rst")
-        >>> print(result.get_result_info())                                     
+        >>> print(result.get_result_info())
         """
         return self._model.metadata.result_info
 
@@ -78,7 +78,7 @@ def __init__(self, data_sources, model):
         super().__init__(data_sources, model)
         self.misc = MecanicMisc(model, data_sources)
 
-    #result classes            
+    #result classes
     def stress(self, **kwargs):
         """Returns a stress object from which it is possible to get ResultData.
         

ansys/dpf/post/electric_results.py

@@ -39,4 +39,4 @@ def __str__(self):
         txt = super().__str__()
         txt += "\n"
         txt += "This is an electric potential object."
-        return txt
+        return txt

ansys/dpf/post/harmonic_analysis.py

@@ -4,4 +4,4 @@
 
 
 class HarmonicAnalysisSolution(DpfMecanicComplexSolution):
-    """Harmonic solution class, which will provide all the API for Harmonic analysis."""
+    """Harmonic solution class, which will provide all the API for Harmonic analysis."""

ansys/dpf/post/misc_results.py

@@ -18,7 +18,7 @@ def __init__(self, model, data_sources):
 
     #tools
     def _get_result_data_function_of_operator(self, name, instance, data_sources, b_elem_average: bool = False, **kwargs):
-        """This method check which are the used keywords, then retusn a ResultData instance 
+        """This method check which are the used keywords, then retusn a ResultData instance
         computed with all available keywords."""
         location = None
         element_scoping = None
@@ -55,9 +55,9 @@ def _get_result_data_function_of_operator(self, name, instance, data_sources, b_
             subresult = kwargs[_AvailableKeywords._subresult]
         if _AvailableKeywords.time_scoping in kwargs:
             time_scoping = kwargs[_AvailableKeywords.time_scoping]
-        return ResultData(name, data_sources, self._model, b_elem_average, location=location, element_scoping=element_scoping, 
+        return ResultData(name, data_sources, self._model, b_elem_average, location=location, element_scoping=element_scoping,
                  node_scoping = node_scoping, named_selection = named_selection,
-                 time = time, grouping = grouping, phase = phase, subresult=subresult, mapdl_grouping=mapdl_grouping, 
+                 time = time, grouping = grouping, phase = phase, subresult=subresult, mapdl_grouping=mapdl_grouping,
                  set=set, time_scoping=time_scoping)
 
     def _check_elemental_location(self, **kwargs):
@@ -438,9 +438,9 @@ def elemental_thermal_dissipation_energy(self, **kwargs):
 
     #special results
     def von_mises_stress(self, **kwargs):
-        """von_mises_stress output default location is Nodal. 
-        Use the location keyword with 'ElementalNodal' value to 
-        get an ElementalNodal result, and the 'Elemental' value 
+        """von_mises_stress output default location is Nodal.
+        Use the location keyword with 'ElementalNodal' value to
+        get an ElementalNodal result, and the 'Elemental' value
         to get Elemental result.
         """
         return self._get_result_data_function_of_operator("S_eqv", self, self._data_sources, **kwargs)
@@ -454,7 +454,7 @@ def _get_amplitude_evaluation(self, result_data):
         # resultData = self._get_result_data_function_of_operator(name, self, self._data_sources, **kwargs)
         resultData = result_data
         modulus_op = _Operator("modulus")
-        modulus_op.inputs.fields_container.connect(resultData._evaluator._result_operator.outputs.fields_container) 
+        modulus_op.inputs.fields_container.connect(resultData._evaluator._result_operator.outputs.fields_container)
         resultData._evaluator._chained_operators[modulus_op.name] = """This operator will compute the amplitude of the result (when result has complex values)."""
         # resultData.result_fields_container = modulus_op.get_output(0, types.fields_container)
         resultData._evaluator._result_operator = modulus_op
@@ -472,7 +472,7 @@ def elemental_stress_amplitude(self, **kwargs):
 
     def nodal_stress_amplitude(self, **kwargs):
         result_data = self.nodal_stress(**kwargs)
-        return self._get_amplitude_evaluation(result_data)  
+        return self._get_amplitude_evaluation(result_data)
 
 
 class ThermalMisc(Misc):
@@ -493,4 +493,4 @@ def nodal_temperature(self, **kwargs):
         self._check_nodal_location(**kwargs)
         return self._get_result_data_function_of_operator("TEMP", self, self._data_sources, **kwargs)
 
-    
+    

ansys/dpf/post/modal_analysis.py

@@ -4,4 +4,4 @@
 
 
 class ModalAnalysisSolution(DpfMecanicComplexSolution):
-    """Modal solution class, which will provide all the API for Modal analysis."""
+    """Modal solution class, which will provide all the API for Modal analysis."""

ansys/dpf/post/result_data.py

@@ -41,16 +41,16 @@ class ResultData:
     >>> disp_on_named_selection = solution.nodal_displacement(named_selection="SELECTION")
     """
 
-    def __init__(self, operator_name: str, data_sources, model, 
-                 elem_average: bool, 
-                 location: str = None, element_scoping = None, 
-                 node_scoping = None, named_selection = None, 
-                 time = None, 
-                 grouping = None, phase = None, subresult = None, 
+    def __init__(self, operator_name: str, data_sources, model,
+                 elem_average: bool,
+                 location: str = None, element_scoping = None,
+                 node_scoping = None, named_selection = None,
+                 time = None,
+                 grouping = None, phase = None, subresult = None,
                  mapdl_grouping = None, set = None, time_scoping = None):
 
-        self._evaluator = ResultEvaluator(operator_name, data_sources, model, elem_average, 
-                 location, element_scoping, node_scoping, named_selection, time, 
+        self._evaluator = ResultEvaluator(operator_name, data_sources, model, elem_average,
+                 location, element_scoping, node_scoping, named_selection, time,
                  grouping, phase, subresult, mapdl_grouping, set, time_scoping)
         self.result_fields_container = None
 
@@ -82,13 +82,13 @@ def _evaluate_result_forced(self):
         self.result_fields_container = self._evaluator.evaluate_result()
 
     def get_all_label_spaces(self):
-        """Returns all the label spaces contained in a result 
+        """Returns all the label spaces contained in a result
         as a string.
         Labels can be used to select fields to plot.
         
         Returns
         -------
-        list 
+        list
             List of dictionary (list of label space)
         """
         self._evaluate_result()
@@ -111,8 +111,8 @@ def get_data_at_field(self, field_index: int = 0):
         return self.result_fields_container[field_index].data
 
     def __getitem__(self, field_index: int = 0):
-        """Override of the result item getter. Implements the fields_container_result 
-        item getter. Return the field at the field_index position in the result fields 
+        """Override of the result item getter. Implements the fields_container_result
+        item getter. Return the field at the field_index position in the result fields
         container.
         """
         self._evaluate_result()
@@ -132,54 +132,54 @@ def _min_max(self, pin):
         result = max_operator.get_output(pin, types.field)
         return result
 
-    @property    
+    @property
     def max(self):
-        """Returns the maximum values field. 
-        Chains the result operator to the "min_max_fc" operator, 
+        """Returns the maximum values field.
+        Chains the result operator to the "min_max_fc" operator,
         returns its result (output from pin 1).
         """
         return self._min_max(1)
 
     @property
     def max_data(self):
-        """Returns the maximum values field data. 
-        Chains the result operator to the "min_max_fc" operator, 
+        """Returns the maximum values field data.
+        Chains the result operator to the "min_max_fc" operator,
         returns its result (output from pin 1).
         """
         return self._min_max(1).data
 
     def get_max_data_at_field(self, field_index: int = 0):
-        """Returns the maximum values field data at field_index. 
-        Chains the result operator to the "min_max_fc" operator, 
+        """Returns the maximum values field data at field_index.
+        Chains the result operator to the "min_max_fc" operator,
         returns its result (output from pin 1).
         """
         return self._min_max(1).data[field_index]
 
     @property
     def min(self):
-        """Returns the minimum values field. 
-        Chains the result operator to the "min_max_fc" operator, 
+        """Returns the minimum values field.
+        Chains the result operator to the "min_max_fc" operator,
         returns its result (output from pin 0).
         """
         return self._min_max(0)
 
     @property
     def min_data(self):
-        """Returns the minimum values field data. 
-        Chains the result operator to the "min_max_fc" operator, 
+        """Returns the minimum values field data.
+        Chains the result operator to the "min_max_fc" operator,
         returns its result (output from pin 0).
         """
         return self._min_max(0).data
 
     def get_min_data_at_field(self, field_index: int = 0):
-        """Returns the minimum values field data at field_index. 
-        Chains the result operator to the "min_max_fc" operator, 
+        """Returns the minimum values field data at field_index.
+        Chains the result operator to the "min_max_fc" operator,
         returns its result (output from pin 0).
         """
         return self._min_max(0).data[field_index]
 
     def _plot_contour_with_vtk_file(self):
-        """Plot the contour result on its mesh support. The obtained figure depends on the 
+        """Plot the contour result on its mesh support. The obtained figure depends on the
         support (can be a meshed_region or a time_freq_support).
         If transient analysis, plot the last result.
         

ansys/dpf/post/result_evaluation.py

@@ -1,8 +1,8 @@
 """Module containing the ResultEvaluation class that
-will compute the information collected in the ResultData 
+will compute the information collected in the ResultData
 class (which is a fields container wrapper).
 
-This class will only be dedicated to the fields container 
+This class will only be dedicated to the fields container
 computation."""
 
 import numpy as np
@@ -18,10 +18,10 @@ class ResultEvaluator:
     """This object will make the evaluation of the fields container
     wrapped in the ResultData object."""
     def __init__(self, operator_name: str, data_sources, model,
-                 elem_average, 
-                 location: str = None, element_scoping = None, 
-                 node_scoping = None, named_selection = None, 
-                 time = None, grouping = None, phase = None, subresult = None, 
+                 elem_average,
+                 location: str = None, element_scoping = None,
+                 node_scoping = None, named_selection = None,
+                 time = None, grouping = None, phase = None, subresult = None,
                  mapdl_grouping = None, set = None, time_scoping = None):
 
         self._model = model
@@ -41,7 +41,7 @@ def __init__(self, operator_name: str, data_sources, model,
             #     raise Exception(msg)
         # if (element_scoping is not None and node_scoping is not None):
         #     raise Exception("Impossible to use both element_scoping and node_scoping.")
-        self._check_if_several_mesh_scoping(node_scoping, element_scoping, 
+        self._check_if_several_mesh_scoping(node_scoping, element_scoping,
                                             grouping, mapdl_grouping, named_selection)
         if (set is not None and time is not None) or (set is not None and time_scoping is not None) or (time is not None and time_scoping is not None):
             raise Exception("Set, time and time_scoping keyword arguments must be used independently.")
@@ -53,7 +53,7 @@ def __init__(self, operator_name: str, data_sources, model,
             self._result_operator.inputs.mesh_scoping.connect(scoping)
         if (time_scoping is not None):
             t_scoping = self._compute_scoping(time_scoping)
-            self._result_operator.inputs.time_scoping.connect(t_scoping)  
+            self._result_operator.inputs.time_scoping.connect(t_scoping)
         #chained before the result_operator
         if (named_selection is not None):
             self._check_if_scoping(node_scoping, element_scoping)
@@ -79,7 +79,7 @@ def __init__(self, operator_name: str, data_sources, model,
             if (grouping == Grouping.by_material) or (grouping == Grouping.by_body):
                 scop_op.inputs.label1.connect("mat")
             elif(grouping == Grouping.by_el_shape):
-                scop_op.inputs.label1.connect("elshape")            
+                scop_op.inputs.label1.connect("elshape")
             else:
                 raise Exception("Grouping impossible. Use the keyword argument as: grouping = grouping.by_el_shape, grouping = grouping.by_material...")
             self._result_operator.inputs.mesh_scoping.connect(scop_op.outputs.mesh_scoping)
@@ -138,7 +138,7 @@ def __init__(self, operator_name: str, data_sources, model,
                 forward_op = Operator("forward_fc")
                 forward_op.inputs.fields.connect(centroid_op.outputs.field)
                 self._result_operator = forward_op
-        # outside post-processing instruction         
+        # outside post-processing instruction
         if elem_average:
             self._elemental_nodal_to_elemental_result()
 
@@ -169,7 +169,7 @@ def _check_if_several_grouping(self, grouping, mapdl_grouping):
         if (grouping is not None) and (mapdl_grouping is not None):
             raise Exception("Both keywords grouping and mapdl_grouping can not be used simultaneously.")
 
-    def _check_if_several_mesh_scoping(self, node_scoping, element_scoping, 
+    def _check_if_several_mesh_scoping(self, node_scoping, element_scoping,
                                        grouping, mapdl_grouping, named_selection):
         count = 0
         if (node_scoping is not None):
@@ -193,7 +193,7 @@ def _get_evaluation_with_sweeping_phase(self, phase):
         sweeping_phase_op.inputs.angle.connect(phase)
         sweeping_phase_op.inputs.unit_name.connect("deg")
         self._chained_operators[sweeping_phase_op.name] = """This operator will compute the result at a given phase (when result has complex values)."""
-        self._result_operator = sweeping_phase_op      
+        self._result_operator = sweeping_phase_op
 
     def _elemental_nodal_to_elemental_result(self):
         avg = Operator("to_elemental_fc")