separate and equal functions

All the functions in the functions project were written in tests/test_functions.py. I want to move them to the functions module in the src folder so that I can keep the tests and solutions separate.

preview

I have these tests by the end of the chapter

functions/tests/test_functions.py

import src.functions

def assert_equal(input_1, input_2):
    assert input_1 == input_2

def assert_is_none(something):
    assert something is None

def test_making_a_function_w_pass():
    assert_is_none(src.functions.w_pass())

functions/tests/test_functions.py

def test_making_a_function_w_return():
    assert_is_none(src.functions.w_return())


def test_making_a_function_w_return_none():
    assert_is_none(src.functions.w_return_none())


def test_what_happens_after_functions_return():
    assert_is_none(
        src.functions.return_leaves_the_function()
    )

functions/tests/test_functions.py

def test_constant_function():
    assert_equal(
        src.functions.constant(), 'the same thing'
    )


def test_identity_function():
    assert_is_none(src.functions.identity(None))
    assert_equal(
        src.functions.identity(object), object
    )

functions/tests/test_functions.py

def test_why_use_a_function():
    def add_x(number):
        return 3 + number

    assert_equal(add_x(0), 3)
    assert_equal(add_x(1), 4)
    assert_equal(add_x(2), 5)
    assert_equal(add_x(3), 6)
    assert_equal(add_x(4), 7)
    assert_equal(add_x(5), 8)
    assert_equal(add_x(6), 9)
    assert_equal(add_x(7), 10)
    assert_equal(add_x(8), 11)
    assert_equal(add_x(9), 12)

functions/tests/test_functions.py

def test_positional_arguments():
    positional_arguments = (
        src.functions.positional_arguments
    )
    first, last = 'first', 'last'

    assert_equal(
        positional_arguments(first, last),
        (first, last)
    )
    assert_equal(
        positional_arguments(last, first),
        (last, first)
    )

    assert_equal(
        positional_arguments(0, 1), (0, 1)
    )

    a_tuple = (0, 1, 2, 'n')
    a_list = [0, 1, 2, 'n']
    assert_equal(
        positional_arguments(a_tuple, a_list),
        (a_tuple, a_list)
    )

    a_set = {0, 1, 2, 'n'}
    a_dictionary = {'key': 'value'}
    assert_equal(
        src.functions.keyword_arguments(
            a_set, a_dictionary,
        ),
        (a_set, a_dictionary)
    )

functions/tests/test_functions.py

def test_keyword_arguments():
    keyword_arguments = (
        src.functions.keyword_arguments
    )
    first, last = 'first', 'last'

    assert_equal(
        keyword_arguments(
            first_input=first, last_input=last,
        ),
        (first, last)
    )
    assert_equal(
        keyword_arguments(
            last_input=last, first_input=first,
        ),
        (first, last)
    )

    assert_equal(
        keyword_arguments(
            last_input=0, first_input=1,
        ),
        (1, 0)
    )

    a_tuple = (0, 1, 2, 'n')
    a_list = [0, 1, 2, 'n']
    assert_equal(
        keyword_arguments(
            first_input=a_tuple,
            last_input=a_list,
        ),
        (a_tuple, a_list)
    )

    a_set = {0, 1, 2, 'n'}
    a_dictionary = {'key': 'value'}
    assert_equal(
        src.functions.positional_arguments(
            last_input=a_dictionary,
            first_input=a_set,
        ),
        (a_set, a_dictionary)
    )

functions/tests/test_functions.py

def test_args_and_kwargs():
    first, last = 'first', 'last'

    assert_equal(
        src.functions.args_and_kwargs(
            first, last_input=last
        ),
        (first, last)
    )

functions/tests/test_functions.py

def test_optional_arguments():
    optional_arguments = (
        src.functions.optional_arguments
    )

    first_name, last_name = 'jane', 'doe'
    assert_equal(
        optional_arguments(
            first_name,
        ),
        (first_name, last_name)
    )

    first_name, blow = 'joe', 'blow'
    assert_equal(
        optional_arguments(
            first_name, blow
        ),
        (first_name, blow)
    )

    first_name = 'john'
    assert_equal(
        optional_arguments(
            first_input=first_name,
        ),
        (first_name, last_name)
    )

    last_name = 'smith'
    assert_equal(
        optional_arguments(
            last_input=last_name,
            first_input=first_name,
        ),
        (first_name, last_name)
    )

functions/tests/test_functions.py

def test_unknown_number_of_arguments():
    unknown_number_of_arguments = (
        src.functions.unknown_number_of_arguments
    )

    a_tuple = (0, 1)
    a_dictionary = {'a': 2, 'b': 3}
    assert_equal(
        unknown_number_of_arguments(
            *a_tuple, **a_dictionary
        ),
        (a_tuple, a_dictionary)
    )

    a_dictionary = {'a': 2, 'b': 3, 'c': 4}
    assert_equal(
        unknown_number_of_arguments(
            *a_tuple, **a_dictionary,
        ),
        (a_tuple, a_dictionary)
    )

    a_tuple = (0, 1, 2)
    a_dictionary = {'a': 3, 'b': 4, 'c': 5}
    assert_equal(
        unknown_number_of_arguments(
            *a_tuple, **a_dictionary
        ),
        (a_tuple, a_dictionary)
    )

    a_tuple = (0, 1, 2, 'n')
    assert_equal(
        unknown_number_of_arguments(*a_tuple),
        (a_tuple, {})
    )

    a_dictionary = {'a': 1, 'b': 2, 'c': 3, 'd': 'n'}
    assert_equal(
        unknown_number_of_arguments(**a_dictionary),
        ((), a_dictionary)
    )

    assert_equal(
        unknown_number_of_arguments(), ((), {})
    )


# Exceptions seen
# AssertionError
# NameError
# TypeError
# SyntaxError
# AttributeError

open the project

I open a terminal
I change directory to the project
terminal
```
cd functions
```
the terminal shows I am in the functions folder
```
.../pumping_python/functions
```
I open test_functions.py from the tests folder

I use pytest-watcher to run the tests automatically

terminal

uv run pytest-watcher . --now --patterns "**/*.py"

the terminal shows

test_functions.py ............                      [100%]

=================== 12 passed in X.YZs ===================

move w_pass to src

RED: make it fail

I change the call in the assertion of test_making_a_function_w_pass to use the result of a call to the w_pass function of the functions module in the src folder instead of a call to the w_pass function in tests/test_functions.py

def test_making_a_function_w_pass():
    def w_pass():
        pass

    # assert_is_none(w_pass())
    assert_is_none(src.functions.w_pass())


def test_making_a_function_w_return():

the terminal is my friend, and shows NameError

NameError: name 'src' is not defined

because src is not defined in tests/test_functions.py.

GREEN: make it pass

I add an import statement at the top of tests/test_functions.py
```
1import src.functions
2
3
4def test_making_a_function_w_pass():
```
the terminal is my friend, and shows AttributeError
```
AttributeError: module 'src.functions' has no attribute 'w_pass'
```
because there is nothing in the functions module in the src folder with the name w_pass.
I add AttributeError to the list of Exceptions seen, in tests/test_functions.py
I open __init__.py from the functions folder in the src folder.
I remove all the text then add a copy of the w_pass function to src/functions/__init__.py
```
1def w_pass():
2    pass
```
the test passes.

REFACTOR: make it better

I remove the commented line and the w_pass function from test_making_a_function_w_pass in tests/test_functions.py

the test is still green because the call that was made to the w_pass function that was in tests/test_functions.py is now to the w_pass function in __init__.py in the functions folder in the src folder.

Python follows this path when src.functions.w_pass is called
```
src.functions.w_pass
src/
└── functions/
    └── __init__.py
        └── def w_pass():
            └── pass
```
I add a git commit message in the other terminal
terminal
```
git commit -am 'move w_pass to src'
```

I can write solutions in a different module from the tests.

move w_return

RED: make it fail

I go back to the terminal where the tests are running
I change the call in the assertion of test_making_a_function_w_return to use the result of a call to the w_return function of the functions module in the src folder instead of a call to the w_return function in tests/test_functions.py

the terminal is my friend, and shows AttributeError
```
AttributeError: module 'src.functions'
                has no attribute 'w_return'
```
because __init__.py in the functions folder in the src folder does not have anything named w_return in it.

GREEN: make it pass

I add a copy of the w_return function to src/functions/__init__.py

def w_pass():
    pass


def w_return():
    return

the test passes.

REFACTOR: make it better

I remove the commented line and the w_return function from test_making_a_function_w_return in tests/test_functions.py

the test is still green because the call that was made to the w_return function that was in tests/test_functions.py is now to the w_return function in __init__.py in the functions folder in the src folder.

Python follows this path when src.functions.w_return is called
```
src.functions.w_return
src/
└── functions/
    └── __init__.py
        └── def w_return():
            └── return
```
I add a git commit message in the other terminal
terminal
```
git commit -am 'move w_return to src'
```

move w_return_none

RED: make it fail

I go back to the terminal where the tests are running
I change the call in the assertion of test_making_a_function_w_return_none to use the result of a call to the w_return_none function of the functions module in the src folder instead of a call to the w_return_none function in tests/test_functions.py

the terminal is my friend, and shows AttributeError
```
AttributeError: module 'src.functions'
                has no attribute 'w_return_none'
```
because __init__.py in the functions folder in the src folder does not have anything named w_return_none in it.

GREEN: make it pass

I add a copy of the w_return_none function to src/functions/__init__.py

def w_return():
    return


def w_return_none():
    return None

the test passes.

REFACTOR: make it better

I remove the commented line and the w_return_none function from test_making_a_function_w_return_none in tests/test_functions.py

the test is still green because the call that was made to the w_return_none function that was in tests/test_functions.py is now to the w_return_none function in __init__.py in the functions folder in the src folder.

Python follows this path when src.functions.w_return_none is called
```
src.functions.w_return_none
src/
└── functions/
    └── __init__.py
        └── def w_return_none():
            └── return None
```
I add a git commit message in the other terminal
terminal
```
git commit -am 'move w_return_none to src'
```

move return_leaves_the_function

RED: make it fail

I go back to the terminal where the tests are running
I change the call in the assertion of test_what_happens_after_functions_return to use the result of a call to return_leaves_the_function of the functions module in the src folder instead of a call to return_leaves_the_function in tests/test_functions.py

the terminal is my friend, and shows AttributeError
```
AttributeError: module 'src.functions'
                has no attribute 'return_leaves_the_function'
```
because I have not added return_leaves_the_function to src/functions/__init__.py.

GREEN: make it pass

I add a copy of return_leaves_the_function to src/functions/__init__.py

def w_return_none():
    return None


def return_leaves_the_function():
    return None
    return 'only one way for this line to run'

the test passes.

REFACTOR: make it better

I remove the commented line and return_leaves_the_function from test_what_happens_after_functions_return in tests/test_functions.py

the test is still green because the call that was made to return_leaves_the_function that was in tests/test_functions.py is now to return_leaves_the_function in __init__.py in the functions folder in the src folder.

Python follows this path when src.functions.return_leaves_the_function is called
```
src.functions.return_leaves_the_function
src/
└── functions/
    └── __init__.py
        └── def return_leaves_the_function():
            └── return None
```

I add a git commit message in the other terminal

terminal

git commit -am \
'move return_leaves_the_function to src'

move constant function

RED: make it fail

I go back to the terminal where the tests are running
I change the call in the assertion of test_constant_function to use the result of a call to the constant function of the functions module in the src folder instead of a call to the constant function in tests/test_functions.py

the terminal is my friend, and shows AttributeError
```
AttributeError: module 'src.functions'
                has no attribute 'constant'
```
because there is nothing named constant in __init__.py in the functions folder in the src folder.

GREEN: make it pass

I add a copy of the constant function to src/functions/__init__.py

def return_leaves_the_function():
    return None
    return 'only one way for this line to run'


def constant():
    return 'the same thing'

the test passes.

REFACTOR: make it better

I remove the commented line and the constant function from test_constant_function in tests/test_functions.py

the test is still green because the call that was made to the constant function that was in tests/test_functions.py is now to the constant function in __init__.py in the functions folder in the src folder.

Python follows this path when src.functions.constant is called
```
src.functions.constant
src/
└── functions/
    └── __init__.py
        └── def constant():
            └── return 'the same thing'
```

I add a git commit message in the other terminal

terminal

git commit -am \
'move constant function to src'

move identity function

RED: make it fail

I go back to the terminal where the tests are running
I change the calls in the assertions of test_identity_function to use the results of calls to the identity function of the functions module in the src folder instead of calls to the identity function in tests/test_functions.py

the terminal is my friend, and shows AttributeError
```
AttributeError: module 'src.functions'
                has no attribute 'identity'
```
because identity is not a name in __init__.py in the functions folder in the src folder.

GREEN: make it pass

I add a copy of the identity function to src/functions/__init__.py

def constant():
    return 'the same thing'


def identity(the_input):
    return the_input

the test passes.

REFACTOR: make it better

I remove the commented line and the identity function from test_identity_function in tests/test_functions.py

the test is still green because the call that was made to the identity function that was in tests/test_functions.py is now to the identity function in __init__.py in the functions folder in the src folder.

Python follows this path when src.functions.identity is called
```
src.functions.identity
src/
└── functions/
    └── __init__.py
        └── def identity(the_input):
            └── return the_input
```

I add a git commit message in the other terminal

terminal

git commit -am \
'move identity function to src'

move positional_arguments

RED: make it fail

I go back to the terminal where the tests are running
I comment out the positional_arguments function in tests/test_functions.py

the terminal is my friend, and shows NameError
```
NameError: name 'positional_arguments'
           is not defined
```

GREEN: make it pass

I use a variable to reroute the calls to the positional_arguments function from test_positional_arguments to the positional_arguments function of the functions module in the src folder

the terminal is my friend, and shows NameError
```
NameError: name 'positional_arguments' is not defined
```
because test_keyword_arguments also calls the positional_arguments function of tests/test_functions.py. This is a risky change.
I change the call to the positional_arguments function from test_keyword_arguments to the positional_arguments function of the functions module in the src folder

the terminal is my friend, and shows AttributeError
```
AttributeError: module 'src.functions'
                has no attribute 'positional_arguments'
```
because positional_arguments does not exist in src/functions/__init__.py.
I add a copy of the positional_arguments function to src/functions/__init__.py

the tests pass because the calls that were made to the positional_arguments function that was in tests/test_functions.py are now made to the positional_arguments function in __init__.py in the functions folder in the src folder.

Python follows this path when positional_arguments is called in test_positional_arguments and test_keyword_arguments
```
positional_arguments = src.functions.positional_arguments
src/
└── functions/
    └── __init__.py
        └── def positional_arguments(first_input, last_input):
            └── return first_input, last_input
```

REFACTOR: make it better

I remove the commented positional_arguments function from tests/test_functions.py

I add a git commit message in the other terminal

terminal

git commit -am \
'move positional_arguments to src'

move keyword_arguments

RED: make it fail

I go back to the terminal where the tests are running
I comment out the keyword_arguments function in tests/test_functions.py

the terminal is my friend, and shows NameError
```
NameError: name 'keyword_arguments' is not defined
```

GREEN: make it pass

I use a variable to reroute the calls to the keyword_arguments function from test_keyword_arguments to the keyword_arguments function of the functions module in the src folder

the terminal is my friend, and shows AttributeError
```
AttributeError: module 'src.functions'
                has no attribute 'keyword_arguments'
```
because I have not added keyword_arguments to src/functions/__init__.py, yet.
I add a copy of the keyword_arguments function to src/functions/__init__.py

the terminal is my friend, and shows NameError
```
NameError: name 'keyword_arguments' is not defined
```
because test_positional_arguments also calls the keyword_arguments function of tests/test_functions.py. More risky business.
I change the call to the keyword_arguments function from test_positional_arguments to the keyword_arguments function of the functions module in the src folder

the tests pass because the calls that were made to the keyword_arguments function that was in tests/test_functions.py are now made to the keyword_arguments function in __init__.py in the functions folder in the src folder.

Python follows this path when keyword_arguments is called in test_keyword_arguments and test_positional_arguments
```
keyword_arguments = src.functions.keyword_arguments

src/
└── functions/
    └── __init__.py
        └── def keyword_arguments(first_input, last_input):
            └── return first_input, last_input
```

REFACTOR: make it better

I remove the commented lines from test_positional_arguments and test_keyword_arguments and the commented keyword_arguments function from tests/test_functions.py

I add a git commit message in the other terminal

terminal

git commit -am \
'move keyword_arguments to src'

move args_and_kwargs

RED: make it fail

I go back to the terminal where the tests are running
I change the call in the assertion of test_args_and_kwargs to use the result of a call to the args_and_kwargs function of the functions module in the src folder instead of the result of a call to the args_and_kwargs function in tests/test_functions.py

the terminal is my friend, and shows AttributeError
```
AttributeError: module 'src.functions'
                has no attribute 'args_and_kwargs'
```
because args_and_kwargs is not a name in __init__.py in the functions folder in the src folder.

GREEN: make it pass

I add a copy of the args_and_kwargs function to src/functions/__init__.py

def keyword_arguments(first_input, last_input):
    return first_input, last_input


def args_and_kwargs(first_input, last_input):
    return first_input, last_input

the test passes.

REFACTOR: make it better

I remove the commented line and the args_and_kwargs function from test_args_and_kwargs in tests/test_functions.py

the test is still green because the call that was made to the args_and_kwargs function that was in tests/test_functions.py is now to the args_and_kwargs function in __init__.py in the functions folder in the src folder.

Python follows this path when src.functions.args_and_kwargs is called
```
src.functions.args_and_kwargs
src/
└── functions/
    └── __init__.py
        └── def args_and_kwargs(first_input, last_input):
            └── return first_input, last_input
```
I add a git commit message in the other terminal
terminal
```
git commit -am \
'move args_and_kwargs to src'
```

move optional_arguments

RED: make it fail

I go back to the terminal where the tests are running
I comment out the optional_arguments function in test_optional_arguments in tests/test_functions.py

the terminal is my friend, and shows NameError
```
NameError: name 'optional_arguments'
           is not defined
```

GREEN: make it pass

I use a variable to reroute the calls to the optional_arguments function from test_optional_arguments to the optional_arguments function of the functions module in the src folder

the terminal is my friend, and shows AttributeError
```
AttributeError: module 'src.functions'
                has no attribute 'optional_arguments'.
                Did you mean: 'positional_arguments'?
```
because optional_arguments does not exist in src/functions/__init__.py.
I add a copy of the optional_arguments function to src/functions/__init__.py

the test passes because the calls that were made to the optional_arguments function that was in tests/test_functions.py are now made to the optional_arguments function in __init__.py in the functions folder in the src folder.

Python follows this path when optional_arguments is called in test_optional_arguments
```
optional_arguments = src.functions.optional_arguments

src/
└── functions/
    └── __init__.py
        └── def optional_arguments(
                first_input, last_input='doe',
            ):
                └── return first_input, last_input
```

REFACTOR: make it better

I remove the commented optional_arguments function from test_optional_arguments in tests/test_functions.py

I add a git commit message in the other terminal

terminal

git commit -am \
'move optional_arguments to src'

move unknown_number_of_arguments function

RED: make it fail

I go back to the terminal where the tests are running
I comment out the unknown_number_of_arguments function in test_unknown_number_of_arguments in tests/test_functions.py

the terminal is my friend, and shows NameError
```
NameError: name 'unknown_number_of_arguments'
          is not defined
```

GREEN: make it pass

I use a variable to reroute the calls to the unknown_number_of_arguments function from test_unknown_number_of_arguments to the unknown_number_of_arguments function of the functions module in the src folder

the terminal is my friend, and shows AttributeError
```
AttributeError: module 'src.functions'
                has no attribute 'unknown_number_of_arguments'
```
because I have not yet added unknown_number_of_arguments to src/functions/__init__.py.
I add a copy of the unknown_number_of_arguments function to src/functions/__init__.py

the test passes because the calls that were made to the unknown_number_of_arguments function that was in tests/test_functions.py are now made to the unknown_number_of_arguments function in __init__.py in the functions folder in the src folder.

Python follows this path when unknown_number_of_arguments is called in test_unknown_number_of_arguments
```
unknown_number_of_arguments = (
    src.functions.unknown_number_of_arguments
)

src/
└── functions/
    └── __init__.py
        └── def unknown_number_of_arguments(
            *positional_arguments, **keyword_arguments
        ):
            └── return positional_arguments, keyword_arguments
```

REFACTOR: make it better

I remove the commented unknown_number_of_arguments function from test_unknown_number_of_arguments in tests/test_functions.py

I add a git commit message in the other terminal

terminal

git commit -am \
'move unknown_number_of_arguments to src'

test_functions

I can write the functions that make the tests pass (except for test_why_use_a_function which I left alone) without looking at tests/test_functions.py since the solutions are now separate from the tests.

RED: make it fail

I go back to the terminal where the tests are running
I close tests/test_functions.py

I delete all the text in src/functions/__init__.py and the terminal shows 11 failures.

FAILED ...::test_making_a_function_w_pass -
    AttributeError: module 'src.functions'
                    has no attribute 'w_pass'
FAILED ...::test_making_a_function_w_return -
    AttributeError: module 'src.functions'
                    has no attribute 'w_return'
FAILED ...::test_making_a_function_w_return_none -
    AttributeError: module 'src.functions'
                    has no attribute 'w_return_none'
FAILED ...::test_what_happens_after_functions_return -
    AttributeError: module 'src.functions'
                    has no attribute 'return_lea...
FAILED ...::test_constant_function -
    AttributeError: module 'src.functions'
                    has no attribute 'constant'
FAILED ...::test_identity_function -
    AttributeError: module 'src.functions'
                    has no attribute 'identity'
FAILED ...::test_positional_arguments -
    AttributeError: module 'src.functions'
                    has no attribute 'positional_arguments'
FAILED ...::test_keyword_arguments -
    AttributeError: module 'src.functions'
                    has no attribute 'keyword_arguments'
FAILED ...::test_args_and_kwargs -
    AttributeError: module 'src.functions'
                    has no attribute 'args_and_kwargs'
FAILED ...::test_optional_arguments -
    AttributeError: module 'src.functions'
                    has no attribute 'optional_arguments'
FAILED ...::test_unknown_number_of_arguments -
    AttributeError: module 'src.functions'
                    has no attribute 'unknown_nu...
============= 11 failed, 1 passed in A.BCs ==============

Can you make the tests pass without looking at how I solve it below? You can come back to compare solutions when you are done or if you get stuck.

GREEN: make it pass

I start with the last AttributeError and add a function definition for unknown_number_of_arguments to src/functions/__init__.py

def unknown_number_of_arguments():
    return None

the terminal is my friend, and shows TypeError

TypeError: unknown_number_of_arguments() got an
           unexpected keyword argument 'a'

I add a to the parentheses
```
1# def unknown_number_of_arguments():
2def unknown_number_of_arguments(a):
3    return None
```
the terminal is my friend, and shows TypeError
```
TypeError: unknown_number_of_arguments() got
           multiple values for argument 'a'
```
which means it got called with a as a keyword argument and since I have it as the first position, Python reads it as two values for the same argument.

I try another argument in the parentheses before a

# def unknown_number_of_arguments():
# def unknown_number_of_arguments(a):
def unknown_number_of_arguments(z, a):
    return None

the terminal still shows TypeError

I use a starred expression to make the function take any number of positional_arguments

# def unknown_number_of_arguments():
# def unknown_number_of_arguments(a):
# def unknown_number_of_arguments(z, a):
def unknown_number_of_arguments(
        *positional, a
    ):
    return None

the terminal is my friend, and shows TypeError

TypeError: unknown_number_of_arguments() got
           an unexpected keyword argument 'b'

because the call uses a name (b) that is not in the parentheses of its definition.

I add b to the parentheses

# def unknown_number_of_arguments():
# def unknown_number_of_arguments(a):
# def unknown_number_of_arguments(z, a):
def unknown_number_of_arguments(
        # *positional, a
        *positional, a, b
    ):
    return None

the terminal is my friend, and shows AssertionError

AssertionError: assert None == ((0, 1), {'a': 2, 'b': 3})

I copy (ctrl/command+c) the tuple from the right side in the terminal then paste it (ctrl/command+v) to replace the return statement

# def unknown_number_of_arguments():
# def unknown_number_of_arguments(a):
# def unknown_number_of_arguments(z, a):
def unknown_number_of_arguments(
        # *positional, a
        *positional, a, b
    ):
    # return None
    return ((0, 1), {'a': 2, 'b': 3})

the terminal is my friend, and shows TypeError

TypeError: unknown_number_of_arguments() got
           an unexpected keyword argument 'c'

because the call uses a name (c) that is not in the parentheses of its definition.

I add c to the parentheses

# def unknown_number_of_arguments():
# def unknown_number_of_arguments(a):
# def unknown_number_of_arguments(z, a):
def unknown_number_of_arguments(
        # *positional, a
        # *positional, a, b
        *positional, a, b, c
    ):
    # return None
    return ((0, 1), {'a': 2, 'b': 3})

the terminal shows TypeError

TypeError: unknown_number_of_arguments() missing
           1 required keyword-only argument: 'c'.

because something called the function without a value for c

I make c an optional argument

# def unknown_number_of_arguments():
# def unknown_number_of_arguments(a):
# def unknown_number_of_arguments(z, a):
def unknown_number_of_arguments(
        # *positional, a
        # *positional, a, b
        # *positional, a, b, c
        *positional, a, b, c=None,
    ):
    # return None
    return ((0, 1), {'a': 2, 'b': 3})

the terminal shows AssertionError

AssertionError: assert ((0, 1), {'a': 2, 'b': 3})
                    == ((0, 1), {'a'...': 3, 'c': 4})

I change the return statement to see the difference between the input and the expected output

# def unknown_number_of_arguments():
# def unknown_number_of_arguments(a):
# def unknown_number_of_arguments(z, a):
def unknown_number_of_arguments(
        # *positional, a
        # *positional, a, b
        # *positional, a, b, c
        *positional, a, b, c=None,
    ):
    # return None
    # return ((0, 1), {'a': 2, 'b': 3})
    return positional, a, b, c

the terminal is my friend, and shows AssertionError

AssertionError: assert ((0, 1), 2, 3, None)
                    == ((0, 1), {'a': 2, 'b': 3})

The test expects a tuple with a tuple and a dictionary.
The function returns a tuple with a tuple and three values.

I change the return statement back

# def unknown_number_of_arguments():
# def unknown_number_of_arguments(a):
# def unknown_number_of_arguments(z, a):
def unknown_number_of_arguments(
        # *positional, a
        # *positional, a, b
        # *positional, a, b, c
        *positional, a, b, c=None,
    ):
    # return None
    return ((0, 1), {'a': 2, 'b': 3})
    # return positional, a, b, c

the terminal is my friend, and shows AssertionError

AssertionError: assert ((0, 1), {'a': 2, 'b': 3})
                    == ((0, 1), {'a'...': 3, 'c': 4})

the dictionaries are different.

I use a double starred expression in the parentheses to make the function take any number of keyword_arguments

# def unknown_number_of_arguments():
# def unknown_number_of_arguments(a):
# def unknown_number_of_arguments(z, a):
def unknown_number_of_arguments(
        # *positional, a
        # *positional, a, b
        # *positional, a, b, c
        # *positional, a, b, c=None,
        *positional, **keyword,
    ):
    # return None
    return ((0, 1), {'a': 2, 'b': 3})
    # return positional, a, b, c

the terminal still shows AssertionError

AssertionError: assert ((0, 1), {'a': 2, 'b': 3})
                    == ((0, 1), {'a'...': 3, 'c': 4})

I return the inputs

# def unknown_number_of_arguments():
# def unknown_number_of_arguments(a):
# def unknown_number_of_arguments(z, a):
def unknown_number_of_arguments(
        # *positional, a
        # *positional, a, b
        # *positional, a, b, c
        # *positional, a, b, c=None,
        *positional, **keyword,
    ):
    # return None
    # return ((0, 1), {'a': 2, 'b': 3})
    # return positional, a, b, c
    return positional, keyword

the terminal is my friend, and shows AttributeError

AttributeError: module 'src.functions'
                has no attribute 'optional_arguments'

I add a function definition for optional_arguments

the terminal is my friend, and shows TypeError

TypeError: optional_arguments() takes
           0 positional arguments but 1 was given

I add a name to allow the function take input

the terminal is my friend, and shows AssertionError
```
AssertionError: assert None == ('jane', 'doe')
```
I copy (ctrl/command+c) the value from the terminal and paste it (ctrl/command+v) to replace the return statement

the terminal is my friend, and shows TypeError
```
TypeError: optional_arguments() takes
           1 positional argument but 2 were given
```

I add another name to the parentheses

the terminal shows TypeError

TypeError: optional_arguments() missing
           1 required positional argument: 'argument_b'

I make the argument optional

the terminal is my friend, and shows AssertionError

AssertionError: assert ('jane', 'doe')
                    == ('joe', 'blow')

I change the return statement of optional_arguments to see the difference between the input and the expected output

the terminal is my friend, and shows AssertionError
```
AssertionError: assert ('jane', None)
                    == ('jane', 'doe')
```
the function returned a tuple with the first argument and the default value of argument_b.
I change the default value to 'doe'

the terminal is my friend, and shows TypeError
```
TypeError: optional_arguments() got
           an unexpected keyword argument 'first_input'
```
because the call uses a name (first_input) that is not in the parentheses of its definition.
I add the name in parentheses

the terminal is my friend, and shows SyntaxError
```
SyntaxError: parameter without a default
     follows parameter with a default
```
because parameters without default values must come before parameters with default values.

I change the order of the arguments

the terminal is my friend, and shows TypeError

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

I make first_input the first argument to see if the problem is the position it is in

the terminal is my friend, and shows TypeError
```
TypeError: optional_arguments() missing
           1 required positional argument: 'argument'
```
I make argument optional

the terminal is my friend, and shows AssertionError
```
AssertionError: assert (None, 'doe')
                    == ('jane', 'doe')
```
the function returned a tuple with the default value of argument
I add first_input to the return statement

the terminal is my friend, and shows AssertionError
```
AssertionError: assert ('jane', None, 'doe')
                    == ('jane', 'doe')
```
it looks like I do not need the argument parameter.
I remove argument from the parentheses and return statement

the terminal is my friend, and shows TypeError
```
TypeError: optional_arguments() got
           an unexpected keyword argument 'last_input'.
           Did you mean 'first_input'?
```
because the call uses a name (last_input) that is not in the parentheses of its definition.
I add the name in the parentheses

the terminal is my friend, and shows SyntaxError
```
SyntaxError: parameter without a default
     follows parameter with a default
```
because parameters without default values must come before parameters with default values.
I give the argument a default value

the terminal is my friend, and shows AssertionError
```
AssertionError: assert ('john', 'doe')
                    == ('john', 'smith')
```
the last names are different.

I add last_input to the return statement

the terminal is my friend, and shows AssertionError

AssertionError: assert ('jane', 'doe', None)
                    == ('jane', 'doe')

I only need two inputs.

I remove argument_b from the parentheses and return statement, then change the default value of last_input to 'doe'

the terminal is my friend, and shows AttributeError
```
AttributeError: module 'src.functions'
                has no attribute 'args_and_kwargs'
```

I add a function definition for args_and_kwargs

the terminal is my friend, and shows TypeError

TypeError: args_and_kwargs() got
           an unexpected keyword argument 'last_input'

I add last_input in parentheses

the terminal is my friend, and shows TypeError
```
TypeError: args_and_kwargs() got
           multiple values for argument 'last_input'
```
which means it got called with last_input as a positional and keyword argument. Since I have it as the first position, Python reads it as two values for the same argument.
I add another name before last_input

the terminal is my friend, and shows AssertionError
```
AssertionError: assert None == ('first', 'last')
```

I return the inputs

the terminal is my friend, and shows AttributeError

AttributeError: module 'src.functions'
                has no attribute 'keyword_arguments'

I add a function definition for keyword_arguments

the terminal is my friend, and shows TypeError
```
TypeError: keyword_arguments() got
           an unexpected keyword argument 'first_input'
```
because the call uses a name (first_input) that is not in the parentheses of its definition.

I add first_input to the parentheses

the terminal is my friend, and shows TypeError

TypeError: keyword_arguments() got
           an unexpected keyword argument 'last_input'.
           Did you mean 'first_input'?

I add last_input to the parentheses

the terminal is my friend, and shows AssertionError
```
AssertionError: assert None == ('first', 'last')
```
I copy and paste the tuple from the terminal as the return statement

the terminal is my friend, and shows AssertionError
```
AssertionError: assert ('first', 'last') == (1, 0)
```

I change the return statement to see the difference between the inputs and the output

the terminal is my friend, and shows AttributeError

AttributeError: module 'src.functions'
                has no attribute 'positional_arguments'.
                Did you mean: 'optional_arguments'?

I add a function definition for positional_arguments

the terminal is my friend, and shows TypeError
```
TypeError: positional_arguments() got
           an unexpected keyword argument 'last_input'
```
because the call uses a name (last_input) that is …

I add the name to the parentheses in the definition

the terminal is my friend, and shows TypeError

TypeError: positional_arguments() got
           an unexpected keyword argument 'first_input'.
           Did you mean 'last_input'?

because …

I add first_input to the parentheses

the terminal is my friend, and shows AssertionError

AssertionError: assert None
    == ({3, 1, 2, 'n'}, {'key': 'value'})

I copy (ctrl/command+c) and paste (ctrl/command+v) the value from the terminal to change the return statement

the terminal is my friend, and shows AssertionError
```
AssertionError:
    assert ({1, 2, 3, 'n...ey': 'value'})
        == ('first', 'last')
```
I change the return statement to see the difference between the inputs and the output

the terminal is my friend, and shows AssertionError
```
AssertionError:
    assert ({'key': 'val...3, 1, 'n', 2})
        == ({3, 1, 'n', ...ey': 'value'})
```
- The order is reversed.
- I want better error messages.
I change the order of the inputs in the return statement

the terminal is my friend, and shows AssertionError
```
AssertionError: assert ('last', 'first')
                    == ('first', 'last')
```
the order is reversed.

I change the order of inputs in the parentheses

the terminal is my friend, and shows AttributeError

AttributeError: module 'src.functions'
                has no attribute 'identity'

I add a function definition for identity

the terminal is my friend, and shows TypeError

TypeError: identity() takes
           0 positional arguments but 1 was given

I add a name to the function definition to make it take input

the terminal is my friend, and shows AssertionError
```
AssertionError: assert None == object
```
I change the return statement to give the test what it wants

the terminal is my friend, and shows AssertionError
```
AssertionError: assert <class 'object'> == None
```

I return the input

the terminal is my friend, and shows AttributeError

AttributeError: module 'src.functions'
                has no attribute 'constant'

I add a function definition for constant

the terminal is my friend, and shows AssertionError
```
AssertionError: assert None == 'the same thing'
```

I copy and paste the value from the terminal as the return statement

the terminal is my friend, and shows AttributeError

AttributeError: module 'src.functions'
                has no attribute 'return_leaves_the_function'

I add a function definition for return_leaves_the_function

the terminal is my friend, and shows AttributeError

AttributeError: module 'src.functions'
                has no attribute 'w_return_none'

I add a function definition for w_return_none

the terminal is my friend, and shows AttributeError

AttributeError: module 'src.functions'
                has no attribute 'w_return'

I add a function definition for w_return

the terminal is my friend, and shows AttributeError

AttributeError: module 'src.functions'
                has no attribute 'w_pass'

I add a function definition for w_pass

all tests are passing!

REFACTOR: make it better

I remove the commented lines

def unknown_number_of_arguments(
        *positional, **keyword,
    ):
    return positional, keyword


def optional_arguments(
        first_input, last_input='doe',
    ):
    return first_input, last_input

I add a git commit message in the other terminal
terminal
```
git commit -am 'test functions'
```

close the project

I close src/functions/__init__.py
I click in the terminal where the tests are running
I use q on the keyboard to leave the tests. The terminal goes back to the command line.
I change directory to the parent of functions
terminal
```
cd ..
```
the terminal shows
```
.../pumping_python
```
I am back in the pumping_python directory.

review

I can write solutions in a different module from the tests.

code from the chapter

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

what is next?

would you like to separate the tests from the solution in the telephone project?

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.