implementation 10 - corrections for pip8

Author: AntonCharnichenka

final_task/pycalc/UnitTests.py

@@ -14,7 +14,7 @@
 # Tests of 'Tokenizer' class from 'tokenizer' module
 class TokenizerTestCase(unittest.TestCase):
     """Tests for Tokenizer class"""
-        
+
     def test_extract_operators_and_pos_int_numbers(self):
         """Are operators and positive int numbers extracted properly?"""
         user_expr = '1+2-3*4/5^6**7//8%9'
@@ -23,7 +23,7 @@ def test_extract_operators_and_pos_int_numbers(self):
         self.assertEqual(tokens, ['1', '+', '2', '-', '3', '*', '4', '/',
                                   '5', '^', '6', '**', '7', '//', '8', '%', '9'])
         self.assertEqual(error_msg, None)
-        
+
     def test_extract_operators_and_neg_int_numbers(self):
         """Are operators and negative int numbers extracted properly?"""
         user_expr = '-1+-2--3*-4/-5^-6**-7//-8%-9'
@@ -32,63 +32,63 @@ def test_extract_operators_and_neg_int_numbers(self):
         self.assertEqual(tokens, ['-1.0', '-', '2', '+', '3', '*', '-4', '/', '-5',
                                   '^', '-6', '**', '-7', '//', '-8', '%', '-9'])
         self.assertEqual(error_msg, None)
-        
+
     def test_extract_pos_float_numbers(self):
         """Are positive float numbers extracted properly?"""
         user_expr = '0.1+1.55-112.12'
         tokenizer = Tokenizer(user_expr)
         tokens, error_msg = tokenizer.extract_tokens()
         self.assertEqual(tokens, ['0.1', '+', '1.55', '-', '112.12'])
         self.assertEqual(error_msg, None)
-        
+
     def test_extract_neg_float_numbers(self):
         """Are negative float numbers extracted properly?"""
         user_expr = '-0.1+-1.55--112.12'
         tokenizer = Tokenizer(user_expr)
         tokens, error_msg = tokenizer.extract_tokens()
         self.assertEqual(tokens, ['-0.1', '-', '1.55', '+', '112.12'])
         self.assertEqual(error_msg, None)
-        
+
     def test_extract_comparison_operators(self):
         """Are comparison operators extracted properly?"""
         user_expr = '><>=<=!==='
         tokenizer = Tokenizer(user_expr)
         tokens, error_msg = tokenizer.extract_tokens()
         self.assertEqual(tokens, ['>', '<', '>=', '<=', '!=', '=='])
         self.assertEqual(error_msg, None)
-        
+
     def test_extract_pos_constants(self):
         """Are positive constants extracted properly?"""
         user_expr = 'e+pi-tau/inf*nan'
         tokenizer = Tokenizer(user_expr)
         tokens, error_msg = tokenizer.extract_tokens()
         self.assertEqual(tokens, ['e', '+', 'pi', '-', 'tau', '/', 'inf', '*', 'nan'])
         self.assertEqual(error_msg, None)
-        
+
     def test_extract_neg_constants(self):
         """Are negative constants extracted properly?"""
         user_expr = '-e+-pi--tau/-inf*-nan'
         tokenizer = Tokenizer(user_expr)
         tokens, error_msg = tokenizer.extract_tokens()
         self.assertEqual(tokens, ['-e', '-', 'pi', '+', 'tau', '/', '-inf', '*', '-nan'])
         self.assertEqual(error_msg, None)
-        
+
     def test_extract_brackets(self):
         """Are brackets extracted properly?"""
         user_expr = '()'
         tokenizer = Tokenizer(user_expr)
         tokens, error_msg = tokenizer.extract_tokens()
         self.assertEqual(tokens, ['(', ')'])
         self.assertEqual(error_msg, None)
-        
+
     def test_extract_comma(self):
         """Is comma extracted?"""
         user_expr = 'pow(2,3)'
         tokenizer = Tokenizer(user_expr)
         tokens, error_msg = tokenizer.extract_tokens()
         self.assertEqual(tokens, ['pow', '(', '2', ',', '3', ')'])
         self.assertEqual(error_msg, None)
-        
+
     def test_extract_functions(self):
         """Are functions extracted properly?"""
         user_expr = "round(sin(2)-asin(1))-abs(exp(3))"
@@ -114,7 +114,7 @@ def test_is_number_method(self):
         for token in tokens:
             is_numbers.append(tokenizer.is_number(token))
         self.assertEqual(is_numbers, [True, True, True, False])
-        
+
     def test_extract_tokens_error_msg(self):
         """Is error_message created?"""
         user_expr = "2+shikaka(3)"
@@ -126,7 +126,7 @@ def test_extract_tokens_error_msg(self):
 # Tests of 'Multsignsadder' class from 'addmultsigns' module
 class MultsignsadderTestCase(unittest.TestCase):
     """Tests for Multsignsadder class"""
-        
+
     def test_is_number_method(self):
         """Does 'is_number' method distinguish tokens which are numbers from ones which are not?"""
         tokens = ['2.3', '-0.6', '5', 'sin', 'exp']
@@ -135,15 +135,15 @@ def test_is_number_method(self):
         for token in tokens:
             is_numbers.append(mult_signs_adder.is_number(token))
         self.assertEqual(is_numbers, [True, True, True, False, False])
-        
+
     def test_addmultsigns_add_mult_signs(self):
         """Are multiplication signs added to where they implicit were to be in expression?"""
         tokens = ['5', 'tau', '-', '4', 'sin', '(', '7', ')', '-', '9', '(', '1', '+', '10', ')']
         mult_signs_adder = Multsignsadder(tokens)
         extd_tokens = mult_signs_adder.addmultsigns()
         self.assertEqual(extd_tokens, ['5', '*', 'tau', '-', '4', '*', 'sin', '(', '7', ')', '-',
                                        '9', '*', '(', '1', '+', '10', ')'])
-        
+
     def test_addmultsigns_dont_add_mult_signs(self):
         """Aren't multiplication signs added if it's not needed?"""
         tokens = ['2', '+', '3', '*', '5']
@@ -169,7 +169,7 @@ def test_consider_log_args_method(self):
 # Tests of 'RPN class' from 'rpn' module
 class RPNTestCase(unittest.TestCase):
     """Tests for RPN class"""
-    
+
     def test_is_left_associative_method(self):
         """Are left associative operators recognized?"""
         tokens = ['^', '**', '+', '/']
@@ -178,7 +178,7 @@ def test_is_left_associative_method(self):
         for token in tokens:
             is_left_associative.append(rpn.is_left_associative(token))
         self.assertEqual(is_left_associative, [False, False, True, True])
-        
+
     def test_is_number_method(self):
         """Does 'is_number' method distinguish tokens which are numbers from ones which are not?"""
         tokens = ['1.3', '-0.5', '/', '%', '9']
@@ -187,15 +187,15 @@ def test_is_number_method(self):
         for token in tokens:
             is_numbers.append(rpn.is_number(token))
         self.assertEqual(is_numbers, [True, True, False, False, True])
-        
+
     def test_convert2rpn_method(self):
         """Does 'convert2rpn' method work correctly?"""
         tokens = ['-pi', '*', 'round', '(', '2.23', ')', '//', '5', '*', 'pow', '(', '2', '3', ')']
         rpn = RPN(tokens)
         result, error_msg = rpn.convert2rpn()
         self.assertEqual(result, ['-pi', '2.23', 'round', '*', '5', '//', '2', '3', 'pow', '*'])
         self.assertEqual(error_msg, None)
-        
+
     def test_convert2rpn_method_error_msg(self):
         """Is error_message created?"""
         tokens = ['(', '2', '+', '3', ')', ')']
@@ -207,7 +207,7 @@ def test_convert2rpn_method_error_msg(self):
 # Tests of 'Constsreplacer' class from 'constsreplacer' module
 class ConstsreplacerTestCase(unittest.TestCase):
     """Tests for Constsreplacer class"""
-    
+
     def test_replace_constants_method(self):
         """Are constants replaced and not constants aren't replaced?"""
         tokens = ['e', '-e', 'pi', '-pi', 'tau', '-tau', '2', 'cos', 'inf', '-nan', '+']
@@ -222,22 +222,22 @@ def test_replace_constants_method(self):
 # Tests of 'RPNcalculator' class from 'rpncalculator' module
 class RPNcalculatorTestCase(unittest.TestCase):
     """Tests for RPNcalculator class"""
-    
+
     def test_evaluate_method_result(self):
         """Does 'evaluate' method actually evaluate RPN math expression and give out correct result?"""
         rpn_tokens = ['2', 'sqrt', '3', '/', '3.14', '*', 'tan']
         rpncalculator = RPNcalculator(rpn_tokens)
         result, error_msg = rpncalculator.evaluate()
         self.assertEqual(result, 11.009005500434151)
         self.assertEqual(error_msg, None)
-        
+
     def test_evaluate_method_error_msg_zero_division(self):
         """Is 'division by zero' error message created?"""
         rpn_tokens = ['2', '0', '/']
         rpncalculator = RPNcalculator(rpn_tokens)
         result, error_msg = rpncalculator.evaluate()
         self.assertEqual(error_msg, 'ERROR: float division by zero')
-        
+
     def test_evaluate_method_error_msg_neg_num_in_fract_pow(self):
         """Is 'negative number cannot be raised to a fractional power' error message created?"""
         rpn_tokens = [['-2', '0.5', '**'], ['-2', '0.5', '^']]
@@ -247,21 +247,21 @@ def test_evaluate_method_error_msg_neg_num_in_fract_pow(self):
             error_msgs.append(rpncalculator.evaluate()[1])
         for error_msg in error_msgs:
             self.assertEqual(error_msg, 'ERROR: negative number cannot be raised to a fractional power')
-            
+
     def test_evaluate_method_error_msg_neg_num_sqrt(self):
         """Is 'root can't be extracted from a negative number' error message created?"""
         rpn_tokens = ['-2', 'sqrt']
         rpncalculator = RPNcalculator(rpn_tokens)
         result, error_msg = rpncalculator.evaluate()
         self.assertEqual(error_msg, "ERROR: a root can't be extracted from a negative number")
-        
+
     def test_evaluate_method_error_msg_invalid_syntax(self):
         """Is 'invalid syntax' error message created?"""
         rpn_tokens = ['2', '+']
         rpncalculator = RPNcalculator(rpn_tokens)
         result, error_msg = rpncalculator.evaluate()
         self.assertEqual(error_msg, "ERROR: invalid syntax")
-        
+
 
 if __name__ == '__main__':
     unittest.main()

final_task/pycalc/__main__.py

@@ -17,22 +17,17 @@ def createparser():
     parser = argparse.ArgumentParser(prog='pycalc', description='pure Python command line calculator',
                                      epilog="""Anton Charnichenka for EPAM: Introduction to Python 
                                      and Golang programming, 2018.""")
-    parser.add_argument('expression', help="""mathematical expression string to evaluate; 
-                                      implicit multiplication is supported""")
-    
+    parser.add_argument('expression', help="""mathematical expression string to evaluate;
+    implicit multiplication is supported""")
+
     return parser
 
+
 def main():
-    """calculation chain"""
+    """Calculate user's expression"""
     parser = createparser()
     namespace = parser.parse_args(sys.argv[1:])
     user_expr = namespace.expression
-    #main_input, spare_input = parser.parse_known_args(sys.argv[1:])
-    # get user's expression
-    #if main_input.expression:
-        #user_expr = main_input.expression[0]
-    #else:
-        #user_expr = spare_input[0]
 
     # calculation chain
     # tokenize user's expression string
@@ -65,7 +60,8 @@ def main():
     else:
         print(result)
         sys.exit(0)
-    
+
+
 # main
 if __name__ == "__main__":
     main()

final_task/pycalc/addmultsigns.py

@@ -6,7 +6,7 @@
 
 class Multsignsadder():
     """A model of mult_signs_adder capable of adding implicit multiplications signs in list of tokens"""
-    
+
     def __init__(self, tokens):
         """Initialize mult_signs_adder"""
         self.tokens = tokens
@@ -52,7 +52,7 @@ def addmultsigns(self):
         for index in range(len(self.tokens)-1):
             self.extended_tokens.append(self.tokens[index])
             if (self.is_number(self.tokens[index]) and ((self.tokens[index+1] in self.constants)
-                                                        or (self.tokens[index+1] in self.functions) 
+                                                        or (self.tokens[index+1] in self.functions)
                                                         or (self.tokens[index+1] == '('))):
                 self.extended_tokens.append('*')
                 continue
@@ -68,7 +68,7 @@ def addmultsigns(self):
 
 
 if __name__ == '__main__':
-    print("""This module contains class that allows to insert multiplications signs to where they where supposed 
+    print("""This module contains class that allows to insert multiplications signs to where they where supposed
     to be in a list with math tokens. For example: \n""")
     test_tokens = ['-0.1', 'tan', '+', '23', '*', '-sin', '(', '3', ')', '/', '.12', 'e']
     mult_signs_adder = Multsignsadder(test_tokens)

final_task/pycalc/constsreplacer.py

@@ -6,23 +6,23 @@
 
 class Constsreplacer():
     """A model of constants replacer capable of replacing constants (from math module) by their numeric equivalents"""
-    
+
     def __init__(self, rpn_tokens):
         """Initialize constsreplacer"""
         self.rpn_tokens = rpn_tokens
         self.constants_numeric_equivalents = constants_numeric_equivalents
-        
+
     def replace_constants(self):
         """Replaces tokens which are math module constants by their numeric equivalent"""
         for index in range(len(self.rpn_tokens)):
             if self.rpn_tokens[index] in self.constants_numeric_equivalents.keys():
                 self.rpn_tokens[index] = str(self.constants_numeric_equivalents[self.rpn_tokens[index]])
-        
+
         return self.rpn_tokens
 
 
 if __name__ == '__main__':
-    print("""This module contains class that allows to replace tokens which are math module constants by their 
+    print("""This module contains class that allows to replace tokens which are math module constants by their
     numeric equivalents. For example: \n""")
     test_tokens = ['2', '*', 'nan', '-', '-inf', '+', '-tau', '*', '-pi', '+', 'e']
     print('RPN tokens with constants: ', test_tokens)

final_task/pycalc/pycalclib.py

@@ -38,9 +38,9 @@
 # acceptable constants and functions
 constants = ['e', 'pi', 'tau', 'inf', 'nan']
 negative_constants = ['-e', '-pi', '-tau', '-inf', '-nan']
-functions = ['acosh', 'acos', 'asinh', 'asin', 'atan2', 'atanh', 'atan', 'ceil', 'copysign', 'cosh', 'cos', 
-             'degrees', 'erfc', 'erf', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 
-             'gamma', 'gcd', 'hypot', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log10', 
+functions = ['acosh', 'acos', 'asinh', 'asin', 'atan2', 'atanh', 'atan', 'ceil', 'copysign', 'cosh', 'cos',
+             'degrees', 'erfc', 'erf', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum',
+             'gamma', 'gcd', 'hypot', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log10',
              'log1p', 'log2', 'log', 'modf', 'pow', 'radians', 'sinh', 'sin', 'sqrt', 'tanh', 'tan', 'trunc',
              'round', 'abs']
 
@@ -51,7 +51,7 @@
                       '-pow', '-radians', '-sinh', '-sin', '-sqrt', '-tanh', '-tan', '-trunc', '-round', '-abs']
 
 
-# acceptable operators 
+# acceptable operators
 operators = ['+', '-', '*', '/', '//', '%', '^', '**']
 
 
@@ -65,7 +65,7 @@
 
 
 # numeric equivalents of constants
-constants_numeric_equivalents = {'e': math.e, '-e': -math.e, 'pi': math.pi, '-pi': -math.pi, 'tau': math.tau, 
+constants_numeric_equivalents = {'e': math.e, '-e': -math.e, 'pi': math.pi, '-pi': -math.pi, 'tau': math.tau,
                                  '-tau': -math.tau}
 
 
@@ -77,17 +77,17 @@
 
 # function's actions
 # first element in a tuple associated with each key is a number of arguments for corresponding function
-functions_dict = {'acos': (1, math.acos), 'acosh': (1, math.acosh), 'asin': (1, math.asin), 'asinh': (1, math.asinh), 
-                  'atan': (1, math.atan), 'atan2': (2, math.atan2), 'atanh': (1, math.atanh), 'ceil': (1, math.ceil), 
-                  'copysign': (2, math.copysign), 'cos': (1, math.cos), 'cosh': (1, math.cosh), 
-                  'degrees': (1, math.degrees), 'erf': (1, math.erf), 'erfc': (1, math.erfc), 'exp': (1, math.exp), 
+functions_dict = {'acos': (1, math.acos), 'acosh': (1, math.acosh), 'asin': (1, math.asin), 'asinh': (1, math.asinh),
+                  'atan': (1, math.atan), 'atan2': (2, math.atan2), 'atanh': (1, math.atanh), 'ceil': (1, math.ceil),
+                  'copysign': (2, math.copysign), 'cos': (1, math.cos), 'cosh': (1, math.cosh),
+                  'degrees': (1, math.degrees), 'erf': (1, math.erf), 'erfc': (1, math.erfc), 'exp': (1, math.exp),
                   'expm1': (1, math.expm1), 'fabs': (1, math.fabs), 'factorial': (1, math. factorial),
-                  'floor': (1, math.floor), 'fmod': (2, math.fmod), 'gamma': (1, math.gamma), 'gcd': (2, math.gcd), 
-                  'hypot': (2, math.hypot), 'isfinite': (1, math.isfinite), 'isinf': (1, math.isinf), 
+                  'floor': (1, math.floor), 'fmod': (2, math.fmod), 'gamma': (1, math.gamma), 'gcd': (2, math.gcd),
+                  'hypot': (2, math.hypot), 'isfinite': (1, math.isfinite), 'isinf': (1, math.isinf),
                   'isnan': (1, math.isnan), 'ldexp': (2, math.ldexp), 'lgamma': (1, math.lgamma), 'log': (2, math.log),
                   'log10': (1, math.log10), 'log1p': (1, math.log1p), 'log2': (1, math.log2), 'pow': (2, math.pow),
-                  'radians': (1, math.radians), 'sin': (1, math.sin), 'sinh': (1, math.sinh), 'sqrt': (1, math.sqrt), 
-                  'tan': (1, math.tan), 'tanh': (1, math.tanh), 'trunc': (1, math.trunc), 'abs': (1, lambda x: abs(x)), 
+                  'radians': (1, math.radians), 'sin': (1, math.sin), 'sinh': (1, math.sinh), 'sqrt': (1, math.sqrt),
+                  'tan': (1, math.tan), 'tanh': (1, math.tanh), 'trunc': (1, math.trunc), 'abs': (1, lambda x: abs(x)),
                   'round': (1, lambda x: round(x)), '-abs': (1, lambda x: -abs(x))}
 
 if __name__ == '__main__':