- 8.1 Package Setup
- 8.2 Initial Test Coverage
- 8.3 Red
- 8.4 Green
- 8.5 Refactor
This chapter is from the book
This chapter is from the book
This chapter is from the book
8.5 Refactor
Although the code in Listing 8.32 is now working, as evidenced by our GREEN test suite, it relies on a rather cumbersome for loop that appends to a list rather than creating it all at once. In this section, we’ll refactor our code, which is the process of changing the form of code without changing its function.
By running our test suite after any significant changes, we’ll catch any regressions quickly, thereby giving us confidence that the final form of the refactored code is still correct. Throughout this section, I suggest making changes incrementally and running the test suite after each change to confirm that the suite is still GREEN.
Per Chapter 6, a more Pythonic way of creating a list of the sort in Listing 8.32 is to use a list comprehension. In particular, the loop in Listing 8.32 bears a strong resemblance to the imperative_singles() function from Listing 6.4:
states = ["Kansas", "Nebraska", "North Dakota", "South Dakota"]
.
.
.
# singles: Imperative version
def imperative_singles(states):
singles = []
for state in states:
if len(state.split()) == 1:
singles.append(state)
return singles
As we saw in Listing 6.5, this can be replaced using a list comprehension with a condition:
# singles: Functional version
def functional_singles(states):
return [state for state in states if len(state.split()) == 1]
Let’s drop into the REPL to see how to do the same thing in the present case:
>>> content = "Madam, I'm Adam." >>> [c for c in content] ['M', 'a', 'd', 'a', 'm', ',', ' ', 'I', "'", 'm', ' ', 'A', 'd', 'a', 'm', '.'] >>> [c for c in content if re.search(r"[a-zA-Z]", c)] ['M', 'a', 'd', 'a', 'm', 'I', 'm', 'A', 'd', 'a', 'm'] >>> "".join([c for c in content if re.search(r"[a-zA-Z]", c)]) 'MadamImAdam'
We see here how combining a list comprehension with a condition and a join() lets us replicate the current functionality of letters(). In fact, inside the argument to join() we can omit the square brackets and use a generator comprehension (Section 6.4) instead:
>>> "".join(c for c in content if re.search(r"[a-zA-Z]", c)) 'MadamImAdam'
This leads to the updated method shown in Listing 8.34. As is so often the case with comprehension solutions, we have been able to condense the imperative solution down to a single line.
Listing 8.34: Refactoring letters() down to a single line. GREEN
src/palindrome/phrase.py
As noted in Chapter 6, functional programs are harder to build up incrementally, which is one reason why it’s so nice to have a test suite to check that our changes had their intended effect (that is, no effect at all):
Listing 8.35: GREEN
Huzzah! Our test suite still passes, so our new one-line letters() method works.
This is a major improvement, but in fact there’s one more refactoring that represents a great example of the power of Python. Recall from Section 4.3 that regular expressions have a findall() method that lets us select regex-matching characters directly from a string:
>>> re.findall(r"[a-zA-Z]", content) ['M', 'a', 'd', 'a', 'm', 'I', 'm', 'A', 'd', 'a', 'm'] >>> "".join(re.findall(r"[a-zA-Z]", content)) 'MadamImAdam'
By using findall() with the same regex we’ve been using throughout this section and then joining on the empty string, we can simplify the application code even further by eliminating the list comprehension, as shown in Listing 8.36.
Listing 8.36: Using re.findall. GREEN
src/palindrome/phrase.py
One more run of the test suite confirms that everything is still copacetic (Figure 8.109):
)
Figure 8.10 Still a palindrome after all our work.
Listing 8.37: GREEN
8.5.1 Publishing the Python Package
As a final step, and in line with our philosophy of shipping (Box 1.5), in this final section we’ll publish our palindrome package to the Python Package Index, also known as PyPI.
Unusually among programming languages, Python actually has a dedicated test package index called TestPyPI, which means we can publish (and use) our test package without uploading to a real package index. Before proceeding, you’ll need to register an account at TestPyPI and verify your email address.
Once you’ve set up your account, you’ll be ready to build and publish your package. To do this, we’ll be using the build and twine packages, which you should install at this time:
(venv) $ pip install build==0.8.0 (venv) $ pip install twine==4.0.1
The first step is to build the package as follows:
(venv) $ python3 -m build
This uses the information in pyproject.toml (Listing 8.3) to create a dist (“distribution”) directory with files based on the name and version number of your package. For example, on my system the dist directory looks like this:
(venv) $ ls dist palindrome\_mhartl-0.0.1.tar.gz palindrome_mhartl-0.0.1-py3-none-any.whl
These are a tarball and wheel file, respectively, but the truth is that you don’t need to know anything about these files specifically; all you need to know is that the build step is necessary to publish a package to TestPyPI. (Being comfortable with ignoring these sorts of details is a good sign of technical sophistication.)
Actually publishing the package involves using the twine command, which looks like this (and is just copied from the TestPyPI documentation):10
(venv) $ twine upload --repository testpypi dist/*
(For future uploads, you may need to remove older versions of your package using rm because TestPyPI doesn’t let you reuse filenames.)
At this point, your package is published and you can test it by installing it on your local system. Because we already have an editable and testable version of the package in our main venv (Listing 8.18), it’s a good idea to spin up a new venv in a temp directory:
$ cd $ mkdir -p tmp/test_palindrome $ cd tmp/test_palindrome $ python3 -m venv venv $ source venv/bin/activate (venv) $
Now you can install your package by using the --index-url option to tell pip to use the test index instead of the real one:
(venv) $ pip install <package> --index-url https://test.pypi.org/simple/
For example, I can install my version of the test package, which is called palindrome_mhartl, as follows:11
(venv) $ pip install palindrome_mhartl --index-url https://test.pypi.org/simple/
To test the installation, you can load the package in the REPL:
(venv) $ python3
>>> from palindrome_mhartl.phrase import Phrase
>>> Phrase("Madam, I'm Adam.").ispalindrome()
True
It works! (If it doesn’t work for you—which is a real possibility since so many things can go wrong—the only recourse is to use your technical sophistication to resolve the discrepancy.)
For a general Python package, you can continue adding features and making new releases. All you need to do is increment the version number in pyproject.toml to reflect the changes you’ve made. For more guidance on how to increment the versions, I suggest learning a bit about the rules of so-called semantic versioning, or semver (Box 8.2).
Finally, if you ever go on to develop a package that isn’t just a test like the one in this chapter, you can publish it to the real Python Package Index (PyPI). Although there is ample PyPI documentation, there is little doubt in such a case that you will also have ample opportunity to apply your technical sophistication.
8.5.2 Exercises
Let’s generalize our palindrome detector by adding the capability to detect integer palindromes like 12321. By filling in FILL_IN in Listing 8.38, write tests for integer non-palindromes and palindromes. Get both tests to GREEN using the code in Listing 8.39, which adds a call to str to ensure the content is a string and includes \d in the regex to match digits as well as letters. (Note that we have updated the name of the letters() method accordingly.)
Bump the version number in pyproject.toml, commit and push your changes, build your package with build, and upload it with twine. In your temp directory, upgrade your package using the command in Listing 8.40 and confirm in the REPL that integer-palindrome detection is working. Note: The backslash \ in Listing 8.40 is a continuation character and should be typed literally, but the right angle bracket > should be added by your shell program automatically and should not be typed.