how to make a calculator 8

I can use the __getattribute__ method that comes with every Python object in the calculator tests

open the project

I change directory to the calculator folder
```
cd calculator
```
the terminal shows I am in the calculator folder
```
.../pumping_python/calculator
```

I use pytest-watcher to run the tests

uv run pytest-watcher . --now

the terminal shows

rootdir: .../pumping_python/calculator
configfile: pyproject.toml
collected 5 items

tests/test_calculator.py .....                                [100%]

======================== 5 passed in X.YZs =========================

I hold ctrl on the keyboard, then click on tests/test_calculator.py to open it in the editor

test_calculator_w_getattribute

RED: make it fail

I add a new test

    def test_calculator_functions(self):
        for operation in self.arithmetic_tests:
            with self.subTest(operation=operation):
                self.assertEqual(
                    self.arithmetic_tests[operation]['function'](
                        self.random_first_number,
                        self.random_second_number
                    ),
                    self.arithmetic_tests[operation]['expectation']
                )

    def test_calculator_w_getattribute(self):
        self.assertEqual(
            src.calculator.__getattribute__('BOOM!!!'),
            src.calculator.add
        )


# Exceptions seen

the terminal shows AttributeError

AttributeError: module 'src.calculator' has no attribute 'BOOM!!!'

__getattribute__ is a method that takes a name and checks if the name is an attribute of the object
- if the name is NOT an attribute it raises AttributeError
- if the name is an attribute it returns the object it points to
src.calculator.__getattribute__('BOOM!!!') checks if the calculator.py module in the src folder has anything named BOOM!!!

GREEN: make it pass

I change 'BOOM!!!' to 'add'

      def test_calculator_w_getattribute(self):
          self.assertEqual(
              src.calculator.__getattribute__('add'),
              src.calculator.add
          )

the test passes because the add function is an attribute of src.calculator

REFACTOR: make it better

I add a call to the add function

    def test_calculator_w_getattribute(self):
        self.assertEqual(
            src.calculator.__getattribute__('add'),
            src.calculator.add(
                self.random_first_number,
                self.random_second_number
            )
        )

the terminal shows AssertionError

AssertionError: <function numbers_only.<locals>.decorator at 0xffffa1234bc0> != DEF.GHIJKLMNOPQRS

I have to call the add function after __getattribute__ returns it

I add parentheses at the end of the line to make it a call

    def test_calculator_w_getattribute(self):
        self.assertEqual(
            src.calculator.__getattribute__('add')(
                self.random_first_number,
                self.random_second_number
            ),
            src.calculator.add(
                self.random_first_number,
                self.random_second_number
            )
        )

the test passes

I add a variables and a dictionary

    def test_calculator_w_getattribute(self):
        x = self.random_first_number
        y = self.random_second_number
        calculator_tests = {'add': x+y}

        self.assertEqual(

I use the dictionary to change the expectation of the assertion

        self.assertEqual(
            src.calculator.__getattribute__('add')(
                self.random_first_number,
                self.random_second_number
            ),
            # src.calculator.add(
            #     self.random_first_number,
            #     self.random_second_number
            # )
            calculator_tests['add']
        )

the test is still green

I use the variables for self.random_first_number and self.random_second_number in the assertion

        self.assertEqual(
            src.calculator.__getattribute__('add')(
                # self.random_first_number,
                # self.random_second_number
                x, y
            ),
            # src.calculator.add(
            #     self.random_first_number,
            #     self.random_second_number
            # )
            calculator_tests['add']
        )

still green

I remove the commented lines

    def test_calculator_w_getattribute(self):
        x = self.random_first_number
        y = self.random_second_number
        calculator_tests = {'add': x+y}

        self.assertEqual(
            src.calculator.__getattribute__('add')(x, y),
            calculator_tests['add']
        )

green

I add subtraction to the calculator_tests dictionary

    def test_calculator_w_getattribute(self):
        x = self.random_first_number
        y = self.random_second_number
        calculator_tests = {
            'add': x+y,
            'subtract': x-y,
        }

then I add an assertion

        self.assertEqual(
            src.calculator.__getattribute__('add')(x, y),
            calculator_tests['add']
        )
        self.assertEqual(
            src.calculator.__getattribute__('subtract')(x, y),
            calculator_tests['add']
        )

the terminal shows AssertionError

AssertionError: OPQ.RSTUVWXYZABCDE != FGH.IJKLMNOPQRSTUV

I change the expectation

        self.assertEqual(
            src.calculator.__getattribute__('subtract')(x, y),
            calculator_tests['subtract']
        )

the test passes

I add multiplication to the calculator_tests dictionary

    def test_calculator_w_getattribute(self):
        x = self.random_first_number
        y = self.random_second_number
        calculator_tests = {
            'add': x+y,
            'subtract': x-y,
            'multiply': x*y,
        }

then I add an assertion

        self.assertEqual(
            src.calculator.__getattribute__('subtract')(x, y),
            calculator_tests['subtract']
        )
        self.assertEqual(
            src.calculator.__getattribute__('multiply')(x, y),
            calculator_tests['subtract']
        )

the terminal shows AssertionError

AssertionError: WXYZA.BCDEFGHIJKLMNO != PQ.RSTUVWXYZABCDE

I change the expectation

        self.assertEqual(
            src.calculator.__getattribute__('multiply')(x, y),
            calculator_tests['multiply']
        )

the test passes

I add division to the calculator_tests dictionary

    def test_calculator_w_getattribute(self):
        x = self.random_first_number
        y = self.random_second_number
        calculator_tests = {
            'add': x+y,
            'subtract': x-y,
            'multiply': x*y,
            'divide': x/y,
        }

then I add an assertion

        self.assertEqual(
            src.calculator.__getattribute__('multiply')(x, y),
            calculator_tests['multiply']
        )
        self.assertEqual(
            src.calculator.__getattribute__('divide')(x, y),
            calculator_tests['multiply']
        )

the terminal shows AssertionError

AssertionError: F.GHIJKLMNOPQRST != UVWXY.ZABCDEFGH

I change the expectation

    def test_calculator_w_getattribute(self):
        x = self.random_first_number
        y = self.random_second_number
        calculator_tests = {
            'add': x+y,
            'subtract': x-y,
            'multiply': x*y,
            'divide': x/y,
        }

        self.assertEqual(
            src.calculator.__getattribute__('add')(x, y),
            calculator_tests['add']
        )
        self.assertEqual(
            src.calculator.__getattribute__('subtract')(x, y),
            calculator_tests['subtract']
        )
        self.assertEqual(
            src.calculator.__getattribute__('multiply')(x, y),
            calculator_tests['multiply']
        )
        self.assertEqual(
            src.calculator.__getattribute__('divide')(x, y),
            calculator_tests['divide']
        )


# Exceptions seen

the test passes

I add a for loop

    def test_calculator_w_getattribute(self):
        x = self.random_first_number
        y = self.random_second_number
        calculator_tests = {
            'add': x+y,
            'subtract': x-y,
            'multiply': x*y,
            'divide': x/y,
        }

        for operation in calculator_tests:
            with self.subTest(operation=operation):
                self.assertEqual(
                    src.calculator.__getattribute__(operation)(
                        x, y
                    ),
                    'BOOM!!!'
                )

        self.assertEqual(
            src.calculator.__getattribute__('add')(x, y),
            calculator_tests['add']
        )

the terminal shows AssertionError

SUBFAILED(operation='add') ...      - AssertionError: FGH.IJKLMNOPQRSTU != 'BOOM!!!'
SUBFAILED(operation='subtract') ... - AssertionError: VWX.YZABCDEFGHIJKL != 'BOOM!!!'
SUBFAILED(operation='multiply') ... - AssertionError: MNOP.QRSTUVWXYZAB != 'BOOM!!!'
SUBFAILED(operation='divide') ...   - AssertionError: CD.EFGHIJKLMNOPQR != 'BOOM!!!'

I change the expectation

                self.assertEqual(
                    src.calculator.__getattribute__(operation)(
                        x, y
                    ),
                    calculator_tests[operation]
                )

the test passes

I remove the other assertions

    def test_calculator_w_getattribute(self):
        x = self.random_first_number
        y = self.random_second_number
        calculator_tests = {
            'add': x+y,
            'subtract': x-y,
            'multiply': x*y,
            'divide': x/y,
        }

        for operation in calculator_tests:
            with self.subTest(operation=operation):
                self.assertEqual(
                    src.calculator.__getattribute__(operation)(
                        x, y
                    ),
                    calculator_tests[operation]
                )


# Exceptions seen

is this simpler than test_calculator_functions?

I add calculator_tests to the setUp method to make it a class attribute

    def setUp(self):
        self.random_first_number = a_random_number()
        self.random_second_number = a_random_number()

        x = self.random_first_number
        y = self.random_second_number

        try:
            division_result = x / y
        except ZeroDivisionError:
            division_result = 'brmph?! I cannot divide by 0. Try again...'

        self.calculator_tests = {
            'add': x+y,
            'subtract': x-y,
            'multiply': x*y,
            'divide': division_result
        }

        self.arithmetic_tests = {

I use the new class attribute in test_calculator_w_getattribute

    def test_calculator_w_getattribute(self):
        x = self.random_first_number
        y = self.random_second_number
        # calculator_tests = {
        #     'add': x+y,
        #     'subtract': x-y,
        #     'multiply': x*y,
        #     'divide': x/y,
        # }
        calculator_tests = self.calculator_tests

        for operation in calculator_tests:

the test is still green

I use self.calculator_tests in the for loop

        # for operation in calculator_tests:
        for operation in self.calculator_tests:
            with self.subTest(operation=operation):
                self.assertEqual(
                    src.calculator.__getattribute__(operation)(
                        x, y
                    ),
                    calculator_tests[operation]
                )

still green

I use it in the expectation of the assertion

                self.assertEqual(
                    src.calculator.__getattribute__(operation)(
                        x, y
                    ),
                    # calculator_tests[operation]
                    self.calculator_tests[operation]
                )

green

I use self.random_first_number for x and self.random_second_number for y in the assertion

                self.assertEqual(
                    src.calculator.__getattribute__(operation)(
                        # x, y
                        self.random_first_number,
                        self.random_second_number
                    ),
                    # calculator_tests[operation]
                    self.calculator_tests[operation]
                )

still green

I remove the commented lines and the variables because they are no longer used

    def test_calculator_w_getattribute(self):
        for operation in self.calculator_tests:
            with self.subTest(operation=operation):
                self.assertEqual(
                    src.calculator.__getattribute__(operation)(
                        self.random_first_number,
                        self.random_second_number
                    ),
                    self.calculator_tests[operation]
                )


# Exceptions seen

the test is still green

I remove test_calculator_functions because test_calculator_w_getattribute has the same tests

    def test_calculator_sends_message_when_input_is_not_a_number(self):
        for bad_input in (
            None,
            True, False,
            str(), 'text',
            tuple(), (0, 1, 2, 'n'),
            list(), [0, 1, 2, 'n'],
            set(), {0, 1, 2, 'n'},
            dict(), {'key': 'value'},
        ):
            for operation in self.arithmetic_tests:
                with self.subTest(
                    operation=operation,
                    bad_input=bad_input,
                ):
                    self.assertEqual(
                        self.arithmetic_tests[operation]['function'](
                            bad_input, a_random_number()
                        ),
                        'brmph?! Numbers only. Try again...'
                    )

    def test_calculator_w_getattribute(self):
        for operation in self.calculator_tests:
            with self.subTest(operation=operation):
                self.assertEqual(
                    src.calculator.__getattribute__(operation)(
                        self.random_first_number,
                        self.random_second_number
                    ),
                    self.calculator_tests[operation]
                )


# Exceptions seen

the tests are still green

I change the name of test_calculator_w_getattribute to test_calculator_functions

    def test_calculator_functions(self):
        for operation in self.calculator_tests:
            with self.subTest(operation=operation):
                self.assertEqual(
                    src.calculator.__getattribute__(operation)(
                        self.random_first_number,
                        self.random_second_number
                    ),
                    self.calculator_tests[operation]
                )


# Exceptions seen

I use self.calculator_tests in the for loop of test_calculator_sends_message_when_input_is_not_a_number

    def test_calculator_sends_message_when_input_is_not_a_number(self):
        for bad_input in (
            None,
            True, False,
            str(), 'text',
            tuple(), (0, 1, 2, 'n'),
            list(), [0, 1, 2, 'n'],
            set(), {0, 1, 2, 'n'},
            dict(), {'key': 'value'},
        ):
            # for operation in self.arithmetic_tests:
            for operation in self.calculator_tests:
                with self.subTest(
                    operation=operation,
                    bad_input=bad_input,
                ):

the terminal shows KeyError for all 52 sub tests

I use the __getattribute__ method in the assertion

                    self.assertEqual(
                        # self.arithmetic_tests[operation]['function'](
                        src.calculator.__getattribute__(operation)(
                            bad_input, a_random_number()
                        ),
                        'brmph?! Numbers only. Try again...'
                    )

the test passes

I remove the commented lines

    def test_calculator_sends_message_when_input_is_not_a_number(self):
        for bad_input in (
            None,
            True, False,
            str(), 'text',
            tuple(), (0, 1, 2, 'n'),
            list(), [0, 1, 2, 'n'],
            set(), {0, 1, 2, 'n'},
            dict(), {'key': 'value'},
        ):
            for operation in self.calculator_tests:
                with self.subTest(
                    operation=operation,
                    bad_input=bad_input,
                ):
                    self.assertEqual(
                        src.calculator.__getattribute__(operation)(
                            bad_input, a_random_number()
                        ),
                        'brmph?! Numbers only. Try again...'
                    )

    def test_calculator_functions(self):

I use self.calculator_tests in the for loop of test_calculator_raises_type_error_when_given_more_than_two_inputs

    def test_calculator_raises_type_error_when_given_more_than_two_inputs(self):
        # for operation in self.arithmetic_tests:
        for operation in self.calculator_tests:
            with (
                self.subTest(operation=operation),
                self.assertRaises(TypeError),
            ):
                self.arithmetic_tests[operation]['function'](
                    [0, 1, 2]
                )

    def test_calculator_sends_message_when_input_is_not_a_number(self):

the terminal shows KeyError for all 4 sub tests

I use the __getattribute__ method in the assertion

                # self.arithmetic_tests[operation]['function'](
                src.calculator.__getattribute__(operation)(
                    [0, 1, 2]
                )

the test passes

I remove the commented lines

    def test_calculator_raises_type_error_when_given_more_than_two_inputs(self):
        for operation in self.calculator_tests:
            with (
                self.subTest(operation=operation),
                self.assertRaises(TypeError),
            ):
                src.calculator.__getattribute__(operation)(
                    [0, 1, 2]
                )

    def test_calculator_sends_message_when_input_is_not_a_number(self):

the test is still green

I use self.calculator_tests in the for loop of test_calculator_w_dictionary_items

    def test_calculator_w_dictionary_items(self):
        two_numbers = {
            'first_input': self.random_first_number,
            'second_input': self.random_second_number,
        }

        # for operation in self.arithmetic_tests:
        for operation in self.calculator_tests:
            with self.subTest(operation=operation):

the terminal shows KeyError for the 4 tests

I use the __getattribute__ method in the assertion

                self.assertEqual(
                    # self.arithmetic_tests[operation]['function'](
                    src.calculator.__getattribute__(operation)(
                        **two_numbers
                    ),
                    self.arithmetic_tests[operation]['expectation']
                )

the terminal shows KeyError for the 4 sub tests

I use self.calculator_tests in the expectation of the assertion

                self.assertEqual(
                    # self.arithmetic_tests[operation]['function'](
                    src.calculator.__getattribute__(operation)(
                        **two_numbers
                    ),
                    # self.arithmetic_tests[operation]['expectation']
                    self.calculator_tests[operation]
                )

the test passes

I remove the commented lines

    def test_calculator_w_dictionary_items(self):
        two_numbers = {
            'first_input': self.random_first_number,
            'second_input': self.random_second_number,
        }

        for operation in self.calculator_tests:
            with self.subTest(operation=operation):
                self.assertEqual(
                    src.calculator.__getattribute__(operation)(
                        **two_numbers
                    ),
                    self.calculator_tests[operation]
                )

        self.assertEqual(
            src.calculator.add(
                two_numbers['first_input'],
                two_numbers['second_input']
            ),
            self.random_first_number+self.random_second_number
        )
        self.assertEqual(
            src.calculator.divide(
                two_numbers['first_input'],
                two_numbers['second_input']
            ),
            self.random_first_number/self.random_second_number
        )
        self.assertEqual(
            src.calculator.multiply(
                two_numbers['second_input'],
                two_numbers['second_input']
            ),
            self.random_second_number*self.random_second_number
        )
        self.assertEqual(
            src.calculator.subtract(
                two_numbers['first_input'],
                two_numbers['first_input']
            ),
            self.random_first_number-self.random_first_number
        )

    def test_calculator_raises_type_error_when_given_more_than_two_inputs(self):

I use self.calculator_tests in the for loop of test_calculator_w_list_items

  def test_calculator_w_list_items(self):
      # two_numbers = [
      #     self.random_first_number,
      #     self.random_second_number
      # ]
      a_dictionary = {
          'x': self.random_first_number,
          'y': self.random_second_number
      }
      two_numbers = list(a_dictionary.values())

      # for operation in self.arithmetic_tests:
      for operation in self.calculator_tests:
          with self.subTest(operation=operation):

the terminal shows KeyError for the 4 sub tests

I use the __getattribute__ method in the assertion

                self.assertEqual(
                    # self.arithmetic_tests[operation]['function'](
                    src.calculator.__getattribute__(operation)(
                        *two_numbers
                    ),
                    self.arithmetic_tests[operation]['expectation']
                )

the terminal shows KeyError for the sub tests

I use self.calculator_tests in the expectation of the assertion

                self.assertEqual(
                    # self.arithmetic_tests[operation]['function'](
                    src.calculator.__getattribute__(operation)(
                        *two_numbers
                    ),
                    # self.arithmetic_tests[operation]['expectation']
                    self.calculator_tests[operation]
                )

the test passes

I remove the new commented lines

    def test_calculator_w_list_items(self):
        # two_numbers = [
        #     self.random_first_number,
        #     self.random_second_number
        # ]
        a_dictionary = {
            'x': self.random_first_number,
            'y': self.random_second_number
        }
        two_numbers = list(a_dictionary.values())

        for operation in self.calculator_tests:
            with self.subTest(operation=operation):
                self.assertEqual(
                    src.calculator.__getattribute__(operation)(
                        *two_numbers
                    ),
                    self.calculator_tests[operation]
                )

        self.assertEqual(
            src.calculator.add(
                two_numbers[0],
                two_numbers[1]
            ),
            self.random_first_number+self.random_second_number
        )
        self.assertEqual(
            src.calculator.divide(
                two_numbers[-2],
                two_numbers[-1]
            ),
            self.random_first_number/self.random_second_number
        )
        self.assertEqual(
            src.calculator.multiply(
                two_numbers[1],
                two_numbers[-1]
            ),
            self.random_second_number*self.random_second_number
        )
        self.assertEqual(
            src.calculator.subtract(
                two_numbers[-2],
                two_numbers[0]
            ),
            self.random_first_number-self.random_first_number
        )

    def test_calculator_w_dictionary_items(self):

I comment out self.arithmetic_tests in the setUp method to see if there are any tests that still use it

    def setUp(self):
        self.random_first_number = a_random_number()
        self.random_second_number = a_random_number()

        x = self.random_first_number
        y = self.random_second_number

        try:
            division_result = x / y
        except ZeroDivisionError:
            division_result = 'brmph?! I cannot divide by 0. Try again...'

        self.calculator_tests = {
            'add': x+y,
            'subtract': x-y,
            'multiply': x*y,
            'divide': division_result
        }

        # self.arithmetic_tests = {
        #     'addition': {
        #         'function': src.calculator.add,
        #         'expectation': x+y,
        #     },
        #     'subtraction': {
        #         'function': src.calculator.subtract,
        #         'expectation': x-y,
        #     },
        #     'division': {
        #         'function': src.calculator.divide,
        #         'expectation': division_result,
        #     },
        #     'multiplication': {
        #         'function': src.calculator.multiply,
        #         'expectation': x*y,
        #     }
        # }

    def test_calculator_w_list_items(self):

the tests are still green

I remove the commented lines

    def setUp(self):
        self.random_first_number = a_random_number()
        self.random_second_number = a_random_number()

        x = self.random_first_number
        y = self.random_second_number

        try:
            division_result = x / y
        except ZeroDivisionError:
            division_result = 'brmph?! I cannot divide by 0. Try again...'

        self.calculator_tests = {
            'add': x+y,
            'subtract': x-y,
            'multiply': x*y,
            'divide': division_result
        }

    def test_calculator_w_list_items(self):

I make a function for the division result because I can

class TestCalculator(unittest.TestCase):

    def get_division_result(x, y):
        try:
            return x / y
        except ZeroDivisionError:
            return 'brmph?! I cannot divide by 0. Try again...'

    def setUp(self):

I use the new function in self.calculator_tests

the terminal shows TypeError
```
TypeError: TestCalculator.get_division_result() takes 2 positional arguments but 3 were given
```
I forgot to make get_division_result a staticmethod since it does not do anything with the rest of the class

I wrap get_division_result with the staticmethod decorator

class TestCalculator(unittest.TestCase):

    @staticmethod
    def get_division_result(x, y):
        try:
            return x / y
        except ZeroDivisionError:
            return 'brmph?! I cannot divide by 0. Try again...'

    def setUp(self):

the test passes

I remove the commented line and the exception handler from the setUp method

def setUp(self):
    self.random_first_number = a_random_number()
    self.random_second_number = a_random_number()

    x = self.random_first_number
    y = self.random_second_number

    self.calculator_tests = {
        'add': x+y,
        'subtract': x-y,
        'multiply': x*y,
        'divide': self.get_division_result(x, y)
    }

def test_calculator_w_list_items(self):

all the tests are passing and I feel like magic

test calculator tests again

I want to write the solution that will make all the tests in test_calculator.py pass without looking at them

RED: make it fail

I close test_calculator.py in the editor
I open calculator.py from the src folder in the editor
then I delete everything in calculator.py, the terminal shows 3 passing tests and AttributeError for 70 failing tests, I start with the last one
```
AttributeError: module 'src.calculator' has no attribute 'add'
```
I add the name to calculator.py
```
1add
```
the terminal shows NameError
```
NameError: name 'add' is not defined
```

GREEN: make it pass

I point add to None to define it

add = None

the terminal shows TypeError

TypeError: 'NoneType' object is not callable

I change it to a function

def add():
    return None

the terminal shows TypeError

TypeError: add() takes 0 positional arguments but 2 were given

I add a name to the parentheses

def add(x):
    return None

the terminal shows TypeError

TypeError: add() takes 1 positional argument but 2 were given

I add a second name to the parentheses

def add(x, y):
    return None

the terminal shows AssertionError

AssertionError: None != TUV.WXYZABCDEFGHIJ

I change the return statement

def add(x, y):
    return x + y

the terminal shows AttributeError

AttributeError: module 'src.calculator' has no attribute 'divide'

I add a function

def add(x, y):
    return x + y


def divide(x, y):
    return x / y

the terminal shows AttributeError

AttributeError: module 'src.calculator' has no attribute 'multiply'

I add a function

def divide(x, y):
    return x / y


def multiply(x, y):
    return x * y

the terminal shows AttributeError

AttributeError: module 'src.calculator' has no attribute 'subtract'

I add a function for it

def multiply(x, y):
    return x * y


def subtract(x, y):
    return x - y

the terminal shows TypeError

TypeError: divide() got an unexpected keyword argument 'first_input'

I add a name to the divide function

def divide(x, y, first_input):
    return x / y

the terminal shows TypeError

TypeError: divide() missing 1 required positional argument: 'first_input'

I add a default value to make it a choice

def divide(x, y, first_input=None):
    return x / y

the terminal shows TypeError

TypeError: divide() got an unexpected keyword argument 'second_input'

I add second_input with a default value to the function

def divide(x, y, first_input=None, second_input=None):
    return x / y

the terminal shows TypeError

TypeError: divide() missing 2 required positional arguments: 'x' and 'y'

the test must be calling divide with positional arguments in some cases and with keyword arguments in others. My solution does not work, I remove x and y from the parentheses
```
5def divide(first_input=None, second_input=None):
6    return x / y
```
the terminal shows NameError
```
NameError: name 'x' is not defined
```

I change the names in the return statement

def divide(first_input=None, second_input=None):
    return first_input / second_input

the terminal shows TypeError

TypeError: multiply() got an unexpected keyword argument 'first_input'

I use the Rename Symbol feature to change the names in the parentheses

def multiply(first_input, y):
    return first_input * y

the terminal shows TypeError

TypeError: divide() got an unexpected keyword argument 'second_input'

I do the same thing to y

def divide(first_input, second_input):
    return first_input / second_input

the terminal shows TypeError

TypeError: subtract() got an unexpected keyword argument 'first_input'

same problem, same solution

I change the names

def subtract(first_input, second_input):
    return first_input - second_input

the terminal shows TypeError

TypeError: add() got an unexpected keyword argument 'first_input'

I change the names in the add function

def add(first_input, second_input):
    return first_input + second_input

the terminal shows TypeError

SUBFAILED(operation='divide', bad_input={'key': 'value'}) ... - TypeError: unsupported operand type(s) for /: 'dict' and 'float'

I add an if statement to the divide function

def divide(first_input=None, second_input=None):
    if isinstance(first_input, dict):
        return None
    return first_input / second_input

the terminal shows AssertionError

AssertionError: None != 'brmph?! Numbers only. Try again...'

I change the return statement of the if statement

def add(first_input, second_input):
    if isinstance(first_input, dict):
        return 'brmph?! Numbers only. Try again...'
    return first_input + second_input

the terminal shows TypeError

SUBFAILED(operation='multiply', bad_input={'key': 'value'}) ... - TypeError: unsupported operand type(s) for *: 'dict' and 'float'

I add an if statement to the multiply function

def multiply(first_input, second_input):
    if isinstance(first_input, dict):
        return None
    return first_input * second_input

the terminal shows AssertionError

AssertionError: None != 'brmph?! Numbers only. Try again...'

I change the return statement of the if statement

def multiply(first_input, second_input):
    if isinstance(first_input, dict):
        return 'brmph?! Numbers only. Try again...'
    return first_input * second_input

the terminal shows TypeError

SUBFAILED(operation='subtract', bad_input={'key': 'value'}) ... - TypeError: unsupported operand type(s) for -: 'dict' and 'float'

same problem, same solution

I add an if statement with the same message in the subtract function

def subtract(first_input, second_input):
    if isinstance(first_input, dict):
        return 'brmph?! Numbers only. Try again...'
    return first_input - second_input

the terminal shows TypeError

SUBFAILED(operation='add', bad_input={'key': 'value'}) ... - TypeError: unsupported operand type(s) for +: 'dict' and 'float'

I add the same if statement to the add function

def add(first_input, second_input):
    if isinstance(first_input, dict):
        return 'brmph?! Numbers only. Try again...'
    return first_input + second_input

the terminal shows TypeError

SUBFAILED(operation='divide', bad_input={'n', 0, 2, 1}) ... - TypeError: unsupported operand type(s) for /: 'set' and 'float'

I add set to the if statement in the divide function

def divide(first_input=None, second_input=None):
    if isinstance(first_input, (dict, set)):
        return 'brmph?! Numbers only. Try again...'
    return first_input / second_input

the terminal shows TypeError

SUBFAILED(operation='multiply', bad_input={0, 1, 2, 'n'}) ... - TypeError: unsupported operand type(s) for *: 'set' and 'float'

I do the same thing to the if statement in the multiply function

def multiply(first_input, second_input):
    if isinstance(first_input, (dict, set)):
        return 'brmph?! Numbers only. Try again...'
    return first_input * second_input

the terminal shows TypeError

SUBFAILED(operation='subtract', bad_input={0, 1, 2, 'n'}) ... - TypeError: unsupported operand type(s) for -: 'set' and 'float'

I change the if statement in the subtract function

def subtract(first_input, second_input):
    if isinstance(first_input, (dict, set)):
        return 'brmph?! Numbers only. Try again...'
    return first_input - second_input

the terminal shows TypeError

SUBFAILED(operation='add', bad_input={0, 1, 2, 'n'}) ... - TypeError: unsupported operand type(s) for +: 'set' and 'float'

I add set to the if statement in the add function

def add(first_input, second_input):
    if isinstance(first_input, (dict, set)):
        return 'brmph?! Numbers only. Try again...'
    return first_input + second_input

the terminal shows TypeError

SUBFAILED(operation='divide', bad_input=[0, 1, 2, 'n']) ... - TypeError: unsupported operand type(s) for /: 'list' and 'float'

I add list to the if statement of the divide function

def divide(first_input=None, second_input=None):
    if isinstance(first_input, (dict, set, list)):
        return 'brmph?! Numbers only. Try again...'
    return first_input / second_input

the terminal shows TypeError

SUBFAILED(operation='multiply', bad_input=[0, 1, 2, 'n']) ... - TypeError: can't multiply sequence by non-int of type 'float'

the error message is different but the function got [0, 1, 2, 'n'] as input, it looks I will have to do this for all the other operations

I add list to the if statement in the other functions

def add(first_input, second_input):
    if isinstance(first_input, (dict, set, list)):
        return 'brmph?! Numbers only. Try again...'
    return first_input + second_input


def divide(first_input=None, second_input=None):
    if isinstance(first_input, (dict, set, list)):
        return 'brmph?! Numbers only. Try again...'
    return first_input / second_input


def multiply(first_input, second_input):
    if isinstance(first_input, (dict, set, list)):
        return 'brmph?! Numbers only. Try again...'
    return first_input * second_input


def subtract(first_input, second_input):
    if isinstance(first_input, (dict, set, list)):
        return 'brmph?! Numbers only. Try again...'
    return first_input - second_input

the terminal shows TypeError

SUBFAILED(operation='divide', bad_input=(0, 1, 2, 'n')) ... - TypeError: unsupported operand type(s) for /: 'tuple' and 'float'

another data type, there has to be a better way

I add tuple to the isinstance built-in function in the if statement of the divide function

def divide(first_input=None, second_input=None):
    if isinstance(first_input, (dict, set, list, tuple)):
        return 'brmph?! Numbers only. Try again...'
    return first_input / second_input

the terminal shows TypeError

SUBFAILED(operation='multiply', bad_input=(0, 1, 2, 'n')) ... - TypeError: can't multiply sequence by non-int of type 'float'

same problem, same solution

I add tuple to the if statement of the other functions

def add(first_input, second_input):
    if isinstance(first_input, (dict, set, list, tuple)):
        return 'brmph?! Numbers only. Try again...'
    return first_input + second_input


def divide(first_input=None, second_input=None):
    if isinstance(first_input, (dict, set, list, tuple)):
        return 'brmph?! Numbers only. Try again...'
    return first_input / second_input


def multiply(first_input, second_input):
    if isinstance(first_input, (dict, set, list, tuple)):
        return 'brmph?! Numbers only. Try again...'
    return first_input * second_input


def subtract(first_input, second_input):
    if isinstance(first_input, (dict, set, list, tuple)):
        return 'brmph?! Numbers only. Try again...'
    return first_input - second_input

the terminal shows TypeError

TypeError: can only concatenate str (not "float") to str

I add str to the if statements of the 4 functions

def add(first_input, second_input):
    if isinstance(first_input, (dict, set, list, tuple, str)):
        return 'brmph?! Numbers only. Try again...'
    return first_input + second_input


def divide(first_input=None, second_input=None):
    if isinstance(first_input, (dict, set, list, tuple, str)):
        return 'brmph?! Numbers only. Try again...'
    return first_input / second_input


def multiply(first_input, second_input):
    if isinstance(first_input, (dict, set, list, tuple, str)):
        return 'brmph?! Numbers only. Try again...'
    return first_input * second_input


def subtract(first_input, second_input):
    if isinstance(first_input, (dict, set, list, tuple, str)):
        return 'brmph?! Numbers only. Try again...'
    return first_input - second_input

the terminal shows AssertionError

SUBFAILED(operation='divide', bad_input=False) ... - AssertionError: 0.0 != 'brmph?! Numbers only. Try again...'

the input is a boolean in this case

I add bool to the if statements of the functions

def add(first_input, second_input):
    if isinstance(
        first_input,
        (dict, set, list, tuple, str, bool)
    ):
        return 'brmph?! Numbers only. Try again...'
    return first_input + second_input


def divide(first_input=None, second_input=None):
    if isinstance(
        first_input,
        (dict, set, list, tuple, str, bool)
    ):
        return 'brmph?! Numbers only. Try again...'
    return first_input / second_input


def multiply(first_input, second_input):
    if isinstance(
        first_input,
        (dict, set, list, tuple, str, bool)
    ):
        return 'brmph?! Numbers only. Try again...'
    return first_input * second_input


def subtract(first_input, second_input):
    if isinstance(
        first_input,
        (dict, set, list, tuple, str, bool)
    ):
        return 'brmph?! Numbers only. Try again...'
    return first_input - second_input

the terminal shows TypeError

SUBFAILED(operation='divide', bad_input=None) ... - TypeError: unsupported operand type(s) for /: 'NoneType' and 'float'

I add None to the call to the isinstance built-in function in the if statement of the divide function

def divide(first_input=None, second_input=None):
    if isinstance(
        first_input,
        (dict, set, list, tuple, str, bool, None)
    ):
        return 'brmph?! Numbers only. Try again...'
    return first_input / second_input

the terminal shows TypeError

TypeError: isinstance() arg 2 must be a type, a tuple of types, or a union

I cannot use None in the isinstance built-in function

I undo the change then add a new condition

def divide(first_input=None, second_input=None):
    if isinstance(
        first_input,
        (dict, set, list, tuple, str, bool)
    ) or first_input is None:
        return 'brmph?! Numbers only. Try again...'
    return first_input / second_input

the terminal shows TypeError

SUBFAILED(operation='multiply', bad_input=None) ... - TypeError: unsupported operand type(s) for *: 'NoneType' and 'float'

same problem, same …

I add the new condition to the if statement of the other functions

def add(first_input, second_input):
    if isinstance(
        first_input,
        (dict, set, list, tuple, str, bool)
    ) or first_input is None:
        return 'brmph?! Numbers only. Try again...'
    return first_input + second_input


def divide(first_input=None, second_input=None):
    if isinstance(
        first_input,
        (dict, set, list, tuple, str, bool)
    ) or first_input is None:
        return 'brmph?! Numbers only. Try again...'
    return first_input / second_input


def multiply(first_input, second_input):
    if isinstance(
        first_input,
        (dict, set, list, tuple, str, bool)
    ) or first_input is None:
        return 'brmph?! Numbers only. Try again...'
    return first_input * second_input


def subtract(first_input, second_input):
    if isinstance(
        first_input,
        (dict, set, list, tuple, str, bool)
    ) or first_input is None:
        return 'brmph?! Numbers only. Try again...'
    return first_input - second_input

the terminal shows AssertionError

AssertionError: TypeError not raised

I remove the default values from the divide function because it is the only one that is different from the others

def divide(first_input, second_input):
    if isinstance(
        first_input,
        (dict, set, list, tuple, str, bool)
    ) or first_input is None:
        return 'brmph?! Numbers only. Try again...'
    return first_input / second_input

the test passes. Time to play

REFACTOR: make it better

I add a decorator function

def check_input(function):
    def wrapper(first_input, second_input):
        if isinstance(
            first_input,
            (dict, set, list, tuple, str, bool)
        ) or first_input is None:
            return 'brmph?! Numbers only. Try again...'
        return function(first_input, second_input)
    return wrapper


def add(first_input, second_input):

I use it to wrap the add function

@check_input
def add(first_input, second_input):
    if isinstance(
        first_input,
        (dict, set, list, tuple, str, bool)
    ) or first_input is None:
        return 'brmph?! Numbers only. Try again...'
    return first_input + second_input

the test is still green

I remove the if statement

@check_input
def add(first_input, second_input):
    return first_input + second_input


def divide(first_input, second_input):

still green

I do the same thing to the divide function

@check_input
def divide(first_input, second_input):
    if isinstance(
        first_input,
        (dict, set, list, tuple, str, bool)
    ) or first_input is None:
        return 'brmph?! Numbers only. Try again...'
    return first_input / second_input

green

I remove the if statement

@check_input
def divide(first_input, second_input):
    return first_input / second_input


def multiply(first_input, second_input):

the test is still green

I make the same change to the other 2 functions

def check_input(function):
    def wrapper(first_input, second_input):
        if (
            isinstance(
                first_input,
                (dict, set, list, tuple, str, bool)
            ) or
            first_input is None
        ):
            return 'brmph?! Numbers only. Try again...'
        return function(first_input, second_input)
    return wrapper


@check_input
def add(first_input, second_input):
    return first_input + second_input


@check_input
def divide(first_input, second_input):
    return first_input / second_input


@check_input
def multiply(first_input=None, second_input=None):
    return first_input * second_input


@check_input
def subtract(first_input, second_input):
    return first_input - second_input

still green

All the tests are passing, but there are problems.

What happens when the functions receive a bad input as the second input or something that is not a dictionary, set, list, string or boolean? I need a better test
It looks like the test for how the calculator handles ZeroDivisionError never runs. I need to make that test better

I wonder what else I missed. I am still learning

close the project

I close test_calculator.py in the editor
I click in the terminal, then use q on the keyboard to leave the tests. The terminal goes back to the command line
I change directory to the parent of calculator
```
cd ..
```
the terminal shows
```
.../pumping_python
```
I am back in the pumping_python directory

review

I used the __getattribute__ built-in function to make the calculator tests simpler.
I rewrote the solution after rewriting the tests and found that
- I did not add a test for bad second inputs
- the test for handling ZeroDivisionError has a problem

code from the chapter

Do you want to see all the CODE I typed in this chapter?

what is next?

you have gone through a lot of things and know

Would you like to know what causes ModuleNotFoundError?

rate pumping python

If this has been a 7 star experience for you, please CLICK HERE to leave a 5 star review of pumping python. It helps other people get into the book too

booleans 4

what is a module?