As usual, the program should show usage with no arguments or for `-h|--help`:

usage: runny_babbit.py [-h] [-w int] str

runny_babbit.py: error: the following arguments are required: str

usage: runny_babbit.py [-h] [-w int] str

positional arguments:

str Input text or file

optional arguments:

-h, --help show this help message and exit

-w int, --width int Output text width (default: 70)

It should handle text from the command line:

Or a named file:

We'll use a set of "stop" words to prevent the switching of sounds when one of the words is in the following list:

Hints:

1 #!/usr/bin/env python3

2 """Spoonerisms"""

3

4 import argparse

5 import os

6 import re

7 import string

8 import textwrap

9

10

11 # --------------------------------------------------

12 def get_args():

13 """Get command-line arguments"""

14

15 parser = argparse.ArgumentParser(

16 description='Introduce Spoonerisms',

17 formatter_class=argparse.ArgumentDefaultsHelpFormatter)

18

19 parser.add_argument('text',

20 metavar='str',

21 help='Input text or file')

22

23 parser.add_argument('-w',

24 '--width',

25 help='Output text width',

26 metavar='int',

27 type=int,

28 default=70)

29

30 args = parser.parse_args()

31

32 if os.path.isfile(args.text):

33 args.text = open(args.text).read()

34

35 return args

36

37

38 # --------------------------------------------------

39 def main():

40 """Make a jazz noise here"""

41

42 args = get_args()

43 text = args.text

44 words = text.split()

45 pairs = []

46

47 for k in range(len(words) - 1):

48 pairs.append((words[k], words[k+1]))

49

50 vowels = 'aeiouAEIOU'

51 consonants = ''.join([c for c in string.ascii_letters if c not in vowels])

52 regex = re.compile('^([' + consonants + ']+)([' + vowels + '].*)')

53 stop = set('before behind between beyond but by concerning'

54 'despite down during following for from into like near'

55 'plus since that the through throughout to towards'

56 'which with within without'.split())

57 skip = set()

58

59 for i, pair in enumerate(pairs):

60 w1, w2 = pair

61 if set([w1.lower(), w2.lower()]).intersection(stop):

62 continue

63

64 i1, i2 = i, i + 1

65 if i1 in skip or i2 in skip:

66 continue

67

68 m1 = regex.search(w1)

69 m2 = regex.search(w2)

70 if m1 and m2:

71 prefix1, suffix1 = m1.groups()

72 prefix2, suffix2 = m2.groups()

73 words[i1] = prefix2 + suffix1

74 words[i2] = prefix1 + suffix2

75 skip.add(i1)

76 skip.add(i2)

77

78 print('\n'.join(textwrap.wrap(' '.join(words), width=args.width)))

79

80 # --------------------------------------------------

81 if __name__ == '__main__':

82 main()

For this exercise, I thought I might move the logic to read an optionally named input *file* into the `get_args` function so that by the time I call `args = get_args()` the `args.text` really is just whatever "text" I need to consider, regardless if the source was the command line or a file. If I'm using `input1.txt`, then I essentially have this:

I need all the pairs of words, so that means I first need all the "words" which I'll get by naively using `str.split` (that is, I won't worry about punctation and such):

Now I need all *pairs* of words which I can get by going from the zeroth word to the second to last word:

... pairs.append((words[k], words[k+1]))

...

I need to find all the pairs where both words start with some consonant sounds and where neither of them is in my stop list, which I'll create like so:

... 'despite down during following for from into like near'

... 'plus since that the through throughout to towards'

... 'which with within without'.split())

How will I find words that start with consonants? I can easily list all the vowels:

And then create the complement from `string.ascii_lowercase`:

And then build a regular expression that looks for the start of a string `^` followed by a character class of all the `consonants` followed by the character class of `vowels` maybe followed by something else. I'll use parentheses `()` to capture both parts:

Now I can iterate over the `pairs`. First I check if the either of the words is in the `stop` set by using the `set.intersection` function. For the first pair `('The', 'bunny')` we see there is an intersection:

For the next pair, there is not:

Next I need to see if *both* words match my regular expression:

They do! So I can use their `groups` to get the parts of each word to swap:

This is the 2nd pair, so `i` would be equal to `1` in the actual code. I can use this to go mutate the `words` at positions `i` and `i + 1`:

Finally we need to `print` the `words` back out, joining them on a blank and using `textwrap.wrap` with the `--width` argument to make it pretty:

.PHONY: test

test:

pytest -xv test.py

Are you familiar with Spoonerisms where the initial consonant sounds of two words are switched? According to Wikipedia, they get their name from William Archibald Spooner who did this often. The author Shel Silverstein wrote a wonderful book called _Runny Babbit_ ("bunny rabbit") based on this. So, let's write a Python program called `runny_babbit.py` that will read some text or an input file given as a single positional argument and finds neighboring words with initial consonant sounds to swap. As we'll need to look at pairs of words and in such as way that it will make it difficult to remember the original formatting of the text, let's also take a `-w|--width` (default `70`) to format the output text to a maximum width.

As usual, the program should show usage with no arguments or for `-h|--help`:

It should handle text from the command line:

Or a named file:

We'll use a set of "stop" words to prevent the switching of sounds when one of the words is in the following list:

before behind between beyond but by concerning despite down

during following for from into like near plus since that the

through throughout to towards which with within without

Hints:

* You'll need to consider all the words in the input as pairs, like `[(0, 1), (1, 2)]` up to `n` (number of words) etc. How can you create such a list where instead of `0` and `1` you have the actual words, e.g., `[('The', 'bunny'), ('bunny', 'rabbit')]`?

* There are several exercises where we try to break words into initial consonant sounds and whatever else that follows. Can you reuse code from elsewhere? I'd recommend using regular expressions!

* Be sure you don't use a word more than once in a swap. E.g., in the phrase "the brown, wooden box", we'd skip "the" and consider the other two pairs of words `('brown', 'wooden')` and `('wooden', 'box')`. If we swap the first pair to make `('wown', 'brooden')`, we would not want to consider the next pair because 'wooden' has already been used.

* Use the `textwrap` module to handle the formatting of the ouput text to a maximum `--width`