import string

import textwrap

import re

from collections import Counter

from itertools import combinations

import numpy as np

english$\_$freq $=\{$

$\text{'}$a$\text{'}$: $0\mathrm{.}0803,$

$\text{'}$b$\text{'}$: $0\mathrm{.}014,$

$\text{'}$c$\text{'}$: $0\mathrm{.}0232,$

$\text{'}$d$\text{'}$: $0\mathrm{.}0467,$

$\text{'}$e$\text{'}$: $0\mathrm{.}1247,$

$\text{'}$f$\text{'}$: $0\mathrm{.}0226,$

$\text{'}$g$\text{'}$: $0\mathrm{.}0209,$

$\text{'}$h$\text{'}$: $0\mathrm{.}065,$

$\text{'}$i$\text{'}$: $0\mathrm{.}0683,$

$\text{'}$j$\text{'}$: $0\mathrm{.}0012,$

$\text{'}$k$\text{'}$: $0\mathrm{.}008,$

$\text{'}$l$\text{'}$: $0\mathrm{.}0367,$

$\text{'}$m$\text{'}$: $0\mathrm{.}0255,$

$\text{'}$n$\text{'}$: $0\mathrm{.}0706,$

$\text{'}$o$\text{'}$: $0\mathrm{.}0776,$

$\text{'}$p$\text{'}$: $0\mathrm{.}0166,$

$\text{'}$q$\text{'}$: $0\mathrm{.}0011,$

$\text{'}$r$\text{'}$: $0\mathrm{.}0621,$

$\text{'}$s$\text{'}$: $0\mathrm{.}0626,$

$\text{'}$t$\text{'}$: $0\mathrm{.}0902,$

$\text{'}$u$\text{'}$: $0\mathrm{.}0279,$

$\text{'}$v$\text{'}$: $0\mathrm{.}0087,$

$\text{'}$w$\text{'}$: $0\mathrm{.}0236,$

$\text{'}$x$\text{'}$: $0\mathrm{.}0012,$

$\text{'}$y$\text{'}$: $0\mathrm{.}0203,$

$\text{'}$z$\text{'}$: $0\mathrm{.}0004$

$\}$

def only$\_$letters$($X$,$ case$=$None$)$:

$\text{'}\text{'}\text{'}$Returns the string obtained from X by removing everything but the letters.

If case$=$"upper" or case$=$"lower", then the letters are all

converted to the same case.$\text{'}\text{'}\text{'}$

X $=\text{'}\text{'}.$join$($c for c in X if c in string.ascii$\_$letters$)$

if len$($X$)==0$:

return None

if case is None:

return X

elif case $==$ "lower":

return X$.$lower$()$

elif case $==$ "upper":

return X$.$upper$()$

def string$\_$for$\_$code$\_$block$($X$,$ linewidth$=60)$:

return $\text{'}$

$\text{'}.$join$($textwrap$.$wrap$($X$,$ width$=$linewidth$))$

def add$\_$spaces$($X$,$ width$=5,$ linewidth$=60)$:

one$\_$line $=\text{'}\text{'}.$join$($textwrap$.$wrap$($X$,$ width$=$width$))$

many$\_$lines $=$ string$\_$for$\_$code$\_$block$($one$\_$line, linewidth$=$linewidth$)$

return many$\_$lines

def shift$\_$char$($ch$,$ shift$\_$amt$)$:

$\text{'}\text{'}\text{'}$Shifts a specific character by shift$\_$amt.

Example:

shift$\_$char$("$Y$",3)$ returns $"$B$"$

$\text{'}\text{'}\text{'}$

if ch in string.ascii$\_$lowercase:

base $=\text{'}$a$\text{'}$

elif ch in string.ascii$\_$uppercase:

base $=\text{'}$A$\text{'}$

# It's not clear what shifting should mean in other cases

# so if the character is not upper or lower$-$case, we leave it unchanged

else:

return ch

return chr$(($ord$($ch$)-$ord$($base$)+$shift$\_$amt$)\%26+$ord$($base$))$

def shift$\_$string$($X$,$ shift$\_$amt$)$:

$\text{'}\text{'}\text{'}$Shifts all characters in X by the same amount.$\text{'}\text{'}\text{'}$

return $\text{'}\text{'}.$join$($shift$\_$char$($ch$,$ shift$\_$amt$)$ for ch in X$)$

def mut$\_$ind$\_$co$($d$1,$ d$2)$:

$\text{'}\text{'}\text{'}$For letter frequency dictionaries d$1$ and d$2,$ return the Mutual Index of Coincidence.

See Equation $(5\mathrm{.}9)$ on page $222$ in Hoffstein, Pipher, Silverman.$\text{'}\text{'}\text{'}$

s $=0$

for k in d$1.$keys$()$:

s $+=$ d$1.$get$($k$,0)*$d$2.$get$($k$,0)$

return s

def ind$\_$co$($X$)$:

X $=$ only$\_$letters$($X$,$ case$=$"upper"$)$

ctr $=$ count$\_$substrings$($X$,1)$

n $=$ sum$($ctr$.$values$())$

return $(1/($n$*($n$-1)))*$sum$($f$*($f$-1)$ for f in ctr$.$values$())$

def weave$($string$\_$list$)$:

output $=\text{'}\text{'}.$join$([\text{'}\text{'}.$join$($tup$)$ for tup in zip$(*$string$\_$list$)])$

# The rest is just to deal with the case of unequal string lengths

# We assume the only possibility is that the early strings are one character longer

last$\_$length $=$ len$($string$\_$list$[-1])$

extra $=[$s$[-1]$ for s in string$\_$list if len$($s$)>$ last$\_$length$]$

return output $+\text{'}\text{'}.$join$($extra$)$

def count$\_$substrings$($X$,$n$)$:

$\text{'}\text{'}\text{'}$Returns a Python Counter object of all n$-$grams in X$.\text{'}\text{'}\text{'}$

if not X:

return $\{\}$

X $=$ only$\_$letters$($X$)$

shifts $=[$X$[$i:$]$ for i in range$($n$)]$

grams $=[\text{'}\text{'}.$join$($chrs$)$ for chrs in zip$(*$shifts$)]$

return Counter$($grams$)$

def get$\_$freq$($X$,$ case$=$"lower"$)$:

$\text{'}\text{'}\text{'}$Returns the proportion that each letter occurs in $"$X$"\text{'}\text{'}\text{'}$

if case $==$ "lower":

letters $=$ string.ascii$\_$lowercase

elif case $==$ "upper":

letters $=$ string.ascii$\_$uppercase

else:

raise ValueError$("$case should be 'upper' or 'lower'."$)$

X $=$ only$\_$letters$($X$,$ case$=$case$)$

n $=$ len$($X$)$

ctr $=$ count$\_$substrings$($X$,1)$

output $=\{\}$

for char in letters:

output$[$char$]=$ ctr$[$char$]/$n

return output

def kasiski$\_$diffs$($Y$,$ case$=$"upper"$)$:

Y $=$ only$\_$letters$($Y$,$ case$=$case$)$

ctr $=$ count$\_$substrings$($Y$,3)$

tri$\_$reps $=[$k for k$,$v in ctr$.$items$()$ if v $>1]$

diffs $=[]$

for tri in tri$\_$reps:

starts $=[$m$.$start$()$ for m in re$.$finditer$($f$\text{'}(?=\{$tri$\})\text{'},$ Y$)]$

diffs.extend$([$abs$($x$-$y$)$ for x$,$y in combinations$($starts$,2)])$

return np$.$array$($sorted$($diffs$))$

$*$ Encrypt a piece of English text using the above $`$vigenere$`$ function with a random key of length $7,8,9,10,$ or $11.$

$*$ You can generate a random key using the following, where $`$key$\_$length$`$ is your chosen length. $($The resulting $`$key$`$ is a NumPy array rather than a list, but it should still work.$)$

$```$

rng $=$ np$.$random.default$\_$rng$()$

key $=$ rng$.$integers$(0,26,$ size$=$key$\_$length$)$

key

$```$

$*$ Your chosen text should be quite long, maybe $300$ characters. Just copy and paste from some source, and use triple quotation marks. $($Using triple quotation marks means that Python won't complain about line breaks or apostrophes or double quotation marks in your pasted text.$)$

$```$

plaintext $=\text{'}\text{'}\text{'}$ Your text here $\text{'}\text{'}\text{'}$

$*$ Encrypt your chosen plaintext using the above key and the $`$vigenere$`$ function. Store the resulting ciphertext using the variable name $`$Y$`.$

$*$ Make the ciphertext less overwhelming to look at by evaluating the following.

$```$

print$($add$\_$spaces$($Y$))$

$```$

$*$ Go to the "Lab $1$ Ciphertexts" thread on Canvas Discussion. Post the displayed ciphertext as a new response.