Formatting with black and flake8

Author: JFincher42

emacs-the-best-python-editor/PyEval/debug-example.py

@@ -1,6 +1,6 @@
-'''
+"""
 Example code for debugging PyEval
-'''
+"""
 
 from pyeval_expression import Expression
 

emacs-the-best-python-editor/PyEval/expr_test.py

@@ -38,27 +38,39 @@ def test_double_term_expression(self):
         )
         expr = Expression("-53+2")
         self.assertEqual(
-            "-53 2 + ", expr.result(), "ERROR: Negative/positive term expression"
+            "-53 2 + ",
+            expr.result(),
+            "ERROR: Negative/positive term expression",
         )
         expr = Expression("53+-2")
         self.assertEqual(
-            "53 -2 + ", expr.result(), "ERROR: Positive/negative term expression"
+            "53 -2 + ",
+            expr.result(),
+            "ERROR: Positive/negative term expression",
         )
         expr = Expression("-53+-2")
         self.assertEqual(
-            "-53 -2 + ", expr.result(), "ERROR: Double negative term expression"
+            "-53 -2 + ",
+            expr.result(),
+            "ERROR: Double negative term expression",
         )
 
     def test_double_term_operands(self):
         """
         Tests a set of operands
         """
         expr = Expression("53+2")
-        self.assertEqual("53 2 + ", expr.result(), "ERROR: Additive expression")
+        self.assertEqual(
+            "53 2 + ", expr.result(), "ERROR: Additive expression"
+        )
         expr = Expression("53-2")
-        self.assertEqual("53 2 - ", expr.result(), "ERROR: Subtrative expression")
+        self.assertEqual(
+            "53 2 - ", expr.result(), "ERROR: Subtrative expression"
+        )
         expr = Expression("53*2")
-        self.assertEqual("53 2 * ", expr.result(), "ERROR: Multiplicative expression")
+        self.assertEqual(
+            "53 2 * ", expr.result(), "ERROR: Multiplicative expression"
+        )
         expr = Expression("53/2")
         self.assertEqual("53 2 / ", expr.result(), "ERROR: Divide expression")
 
@@ -67,7 +79,9 @@ def test_triple_term_expression(self):
         Tests a set of triple term expressions
         """
         expr = Expression("53+2+37")
-        self.assertEqual("53 2 37 + + ", expr.result(), "ERROR: Add/Add expression")
+        self.assertEqual(
+            "53 2 37 + + ", expr.result(), "ERROR: Add/Add expression"
+        )
         expr = Expression("53+2*37")
         self.assertEqual(
             "53 2 37 * + ", expr.result(), "ERROR: Add/Multiply expression"
@@ -78,7 +92,9 @@ def test_triple_term_expression(self):
         )
         expr = Expression("53*2*37")
         self.assertEqual(
-            "53 2 37 * * ", expr.result(), "ERROR: Multiply/Multiply expression"
+            "53 2 37 * * ",
+            expr.result(),
+            "ERROR: Multiply/Multiply expression",
         )
 
     def test_whitespace_expression(self):
@@ -91,11 +107,15 @@ def test_whitespace_expression(self):
         )
         expr = Expression("53 + 2 + 37")
         self.assertEqual(
-            "53 2 37 + + ", expr.result(), "ERROR: Infixed whitespace expression"
+            "53 2 37 + + ",
+            expr.result(),
+            "ERROR: Infixed whitespace expression",
         )
         expr = Expression(" 53+2+37 ")
         self.assertEqual(
-            "53 2 37 + + ", expr.result(), "ERROR: Pre/post-fixed whitespace expression"
+            "53 2 37 + + ",
+            expr.result(),
+            "ERROR: Pre/post-fixed whitespace expression",
         )
         expr = Expression(" 53 + 2 + 37 ")
         self.assertEqual(
@@ -105,10 +125,13 @@ def test_whitespace_expression(self):
         )
         expr = Expression("  53  +  2  +  37  ")
         self.assertEqual(
-            "53 2 37 + + ", expr.result(), "ERROR: Multiple whitespace expression"
+            "53 2 37 + + ",
+            expr.result(),
+            "ERROR: Multiple whitespace expression",
         )
 
-        # This test should throw an exception - spaces in between operands should give an error
+        # This test should throw an exception - spaces in between operands
+        # should give an error
         with self.assertRaises(SyntaxError):
             expr = Expression("  53  +  -  2  +  37  ")
             expr.parse()

emacs-the-best-python-editor/PyEval/pyeval_expression.py

@@ -8,7 +8,8 @@
 
 from pyeval_operator import Operator
 
-class Expression():
+
+class Expression:
     """
     Defines and parses an infix expression string, returning
     an RPN expression string, or raising an exception if the input string
@@ -20,7 +21,7 @@ class Expression():
     # they are appended to the stack. As the input string is processed, the
     # grows as needed. In the end, it should be empty.
 
-    __operator_stack = []             # Holds the current stack of operators
+    __operator_stack = []  # Holds the current stack of operators
 
     # Store the string, and where we are in our parsing run.
     __expr_string = ""
@@ -54,7 +55,7 @@ def __init__(self, expression_string):
     def result(self):
         """
         Returns the result of the evaluation.
-        If the expression is not yet evaluated, we attempt to parse the expression.
+        If the expression is not yet evaluated, we try to parse the expression.
           If this is unsuccessful, we raise a ValueError exception.
         Else we return the output string.
         """
@@ -75,20 +76,23 @@ def parse(self):
         # Right now, every expression starts with an operand
         # This is not universally true for functions and parentheses, but we're
         # not supporting them yet
-        ## TODO: Add support for functions and parentheses
+        # TODO: Add support for functions and parentheses
         expecting_operand = True
 
         # Get the current character to inspect
         current_char = self.__expr_string[self.__current_position]
 
         # Loop until we're past the end of the string
-        while self.__current_position < len(self.__expr_string) and current_char != "$":
+        while (
+            self.__current_position < len(self.__expr_string)
+            and current_char != "$"
+        ):
 
             # Skip any leading whitespace characters
             while current_char.isspace():
                 self.__current_position += 1
                 current_char = self.__expr_string[self.__current_position]
-            
+
             # Store whatever is next in the current_token string
             current_token = ""
 
@@ -101,17 +105,29 @@ def parse(self):
                     current_char = self.__expr_string[self.__current_position]
 
                 # Now we loop for as long as we have numbers
-                while current_char in ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]:
+                while current_char in [
+                    "0",
+                    "1",
+                    "2",
+                    "3",
+                    "4",
+                    "5",
+                    "6",
+                    "7",
+                    "8",
+                    "9",
+                ]:
                     current_token += current_char
                     self.__current_position += 1
                     current_char = self.__expr_string[self.__current_position]
-                    
-                # We should have a number now - add it to the output string, space delimited
+
+                # We should have a number now - add it to the output string,
+                # space delimited
                 self.__output_string += current_token + " "
 
                 # And after every operand, we need to look for an operator
                 expecting_operand = False
-            
+
             else:
                 # Here, we just need a single operator, so
                 # Get that operator, validate it, then
@@ -132,12 +148,20 @@ def parse(self):
                     self.__operator_stack.append(current_operator)
 
                 else:
-                    top_operator = self.__operator_stack[len(self.__operator_stack)-1]
-                    while len(self.__operator_stack)>0 and top_operator.precedence > current_operator.precedence:
+                    top_operator = self.__operator_stack[
+                        len(self.__operator_stack) - 1
+                    ]
+                    while (
+                        len(self.__operator_stack) > 0
+                        and top_operator.precedence
+                        > current_operator.precedence
+                    ):
                         self.__output_string += top_operator.op_string + " "
                         self.__operator_stack.pop()
-                        if len(self.__operator_stack)>0:
-                            top_operator = self.__operator_stack[len(self.__operator_stack)-1]
+                        if len(self.__operator_stack) > 0:
+                            top_operator = self.__operator_stack[
+                                len(self.__operator_stack) - 1
+                            ]
 
                     self.__operator_stack.append(current_operator)
 
@@ -162,4 +186,3 @@ def parse(self):
 
         self.__evaluated = True
         return self.__output_string
-        

emacs-the-best-python-editor/PyEval/pyeval_operand.py

@@ -4,13 +4,14 @@
 AUTHOR: Jon Fincher
 """
 
+
 class Operand:
     """
     Common operator class used by the evaluator.
     """
 
-    op_string = ""      # String to hold the operand literal
-    op_value = 0        # Integer value of the operand
+    op_string = ""  # String to hold the operand literal
+    op_value = 0  # Integer value of the operand
 
     def __init__(self, operand_string):
         """ Create a new operator object. """

emacs-the-best-python-editor/PyEval/pyeval_operator.py

@@ -7,32 +7,33 @@
 # Dictionary lookup for precedence
 # Currently four levels of precedence
 PRECEDENCE = {
-    '+' : 2,            # Addition
-    '-' : 2,            # Subtraction
-    '*' : 3,            # Multiplication
-    '/' : 3,            # Division
-    '%' : 3,            # Modulo
-    '^' : 4             # Power
+    "+": 2,  # Addition
+    "-": 2,  # Subtraction
+    "*": 3,  # Multiplication
+    "/": 3,  # Division
+    "%": 3,  # Modulo
+    "^": 4,  # Power
 }
 
 # Dictionary lookup for number of operands to use
 OPERAND_COUNT = {
-    '+' : 2,            # Addition
-    '-' : 2,            # Subtraction
-    '*' : 2,            # Multiplication
-    '/' : 2,            # Division
-    '%' : 2,            # Modulo
-    '^' : 2             # Power
+    "+": 2,  # Addition
+    "-": 2,  # Subtraction
+    "*": 2,  # Multiplication
+    "/": 2,  # Division
+    "%": 2,  # Modulo
+    "^": 2,  # Power
 }
 
+
 class Operator:
     """
     Common operator class used by the evaluator.
     """
 
-    _op_string = ""      # String to hold the operator
-    _op_prec = 0         # Integer to hold the precedence
-    _op_cnt = 0          # Integer to hold the number of operands to use
+    _op_string = ""  # String to hold the operator
+    _op_prec = 0  # Integer to hold the precedence
+    _op_cnt = 0  # Integer to hold the number of operands to use
 
     def __init__(self, operator_string):
         """ Create a new operator object. """