.PHONY: test

test:

pytest -xv test.py

Perhaps you remember the game of "Telephone" where a message is secretly passed through a series of intermediaries and then the result at the end of the chain is compared with how it started? This is like that, only we're going to take some`text` (from the command line or a file) and mutate it by some percentage `-m|--mutations` (a number between 0 and 1, default `0.1` or 10%) and then print out the resulting text.

Each mutation to the text should be chosen using the `random` module, so your program will also need to accept a `-s|--seed` option to pass to the `random.seed` function for testing purposes. Print the resulting text after making the appropriate number of mutations.

````

The program should not accept a bad `--mutations` argument:

````

It can be interesting to watch the accumulation of mutations:

For what it's worth, this is how DNA changes over time. The machinery to copy DNA makes mistakes, and mutations randomly occur. Many times the change is in a part of the DNA that doesn't affect the organism or is a "synonymous" change that doesn't end up affecting the function of the DNA. Our example will only change characters to other characters, what are called "point mutations" or "single nucleotide variations" (SNV) or "single nucleotide polymorphisms" (SNP) in biology. We could write a version that would also randomly delete or insert new characters which are called them "in-dels" (insertion-deletions) in biology.

Mutations (that don't result in the demise of the organism) occur at a fairly standard rate, so counting the number of point mutations (AKA ) between a conserved region of any two organisms, we can estimate how long ago they diverged from a common ancestor!

We can revisit the output of this program later by using the Hamming distance to find how many changes we'd need to make to the output to regain the input.

To create a combined error/usage statement for the `--mutations` error, look at `parser.error` in `argparse`.

To select a character position to change, I suggest using `random.choice` and a `range` from length of the incoming text. With that, you'll need to alter the character at that position, but you'll find that strings in Python are *immutable*. For instance, if I wanted to change "candle" into "handle":

So, I need to create a *new string* that has `h` joined to the rest of the string `s` after the zeroth position. How could you do that?

For the replacement value, you should use `random.choice` from the union of the `string` class's `ascii_letters` and `punctuation`:

import argparse

import os

import random

import string

import sys

def get_args():

"""Get command-line arguments"""

parser = argparse.ArgumentParser(

description='Telephone',

formatter_class=argparse.ArgumentDefaultsHelpFormatter)

parser.add_argument('input',

metavar='str',

help='Input text or file')

parser.add_argument('-s',

'--seed',

help='Random seed',

metavar='str',

type=str,

default=None)

parser.add_argument('-m',

'--mutations',

help='Percent mutations',

metavar='float',

type=float,

default=0.1)

args = parser.parse_args()

if not 0 < args.mutations <= 1:

msg = '--mutations "{}" must be b/w 0 and 1'.format(args.mutations)

parser.error(msg)

return args

def main():

"""Make a jazz noise here"""

args = get_args()

text = args.input

random.seed(args.seed)

if os.path.isfile(text):

text = open(text).read()

len_text = len(text)

num_mutations = int(args.mutations * len_text)

alpha = string.ascii_letters + string.punctuation

for _ in range(num_mutations):

i = random.choice(range(len_text))

text = text[:i] + random.choice(alpha) + text[i+1:]

print(text.rstrip())

if __name__ == '__main__':

main()

from subprocess import getstatusoutput, getoutput

import os

import re

prg = "./telephone.py"

fox = '../inputs/fox.txt'

now = '../inputs/now.txt'

def test_exists():

"""exists"""

assert os.path.isfile(prg)

def test_usage():

"""usage"""

for flag in ['', '-h', '--help']:

out = getoutput('{} {}'.format(prg, flag))

assert re.match('usage', out, re.IGNORECASE)

def test_bad_mutation():

"""bad mutation values"""

for val in ['-1.0', '10.0']:

rv, out = getstatusoutput('{} -m {} {}'.format(prg, val, fox))

assert rv > 0

assert re.search('--mutations "{}" must be b/w 0 and 1'.format(val),

out)

def test_text01():

"""test"""

txt = open(now).read().rstrip()

rv, out = getstatusoutput('{} -s 1 "{}"'.format(prg, txt))

assert rv == 0

expected = """

""".strip()

assert out.rstrip() == expected

def test_text02():

"""test"""

txt = open(now).read().rstrip()

rv, out = getstatusoutput('{} -s 2 -m .4 "{}"'.format(prg, txt))

assert rv == 0

expected = """

""".strip()

assert out.rstrip() == expected

def test_file01():

"""test"""

rv, out = getstatusoutput('{} --seed 1 {}'.format(prg, fox))

assert rv == 0

assert out.rstrip() == 'Tho quick brown foa jumps oWer*the lazy dog.'

def test_file02():

"""test"""

rv, out = getstatusoutput('{} --seed 2 --mutations .6 {}'.format(prg, fox))

assert rv == 0

assert out.rstrip() == 'UheK+u*ckXbrPw~ fox Du*#FT{ver a~e}|Uzy (T?l'