if one_based: cipher_number += 1
plaintext_number = (
modular_division_table[multiplier]
- [(cipher_number - adder) % 26] )
+ [(cipher_number - adder) % 26])
if one_based: plaintext_number -= 1
return chr(plaintext_number % 26 + alphabet_start)
else:
return ''.join(enciphered)
-class Keyword_wrap_alphabet(Enum):
+class KeywordWrapAlphabet(Enum):
from_a = 1
from_last = 2
from_largest = 3
-def keyword_cipher_alphabet_of(keyword, wrap_alphabet=Keyword_wrap_alphabet.from_a):
+def keyword_cipher_alphabet_of(keyword, wrap_alphabet=KeywordWrapAlphabet.from_a):
"""Find the cipher alphabet given a keyword.
wrap_alphabet controls how the rest of the alphabet is added
after the keyword.
>>> keyword_cipher_alphabet_of('bayes')
'bayescdfghijklmnopqrtuvwxz'
- >>> keyword_cipher_alphabet_of('bayes', Keyword_wrap_alphabet.from_a)
+ >>> keyword_cipher_alphabet_of('bayes', KeywordWrapAlphabet.from_a)
'bayescdfghijklmnopqrtuvwxz'
- >>> keyword_cipher_alphabet_of('bayes', Keyword_wrap_alphabet.from_last)
+ >>> keyword_cipher_alphabet_of('bayes', KeywordWrapAlphabet.from_last)
'bayestuvwxzcdfghijklmnopqr'
- >>> keyword_cipher_alphabet_of('bayes', Keyword_wrap_alphabet.from_largest)
+ >>> keyword_cipher_alphabet_of('bayes', KeywordWrapAlphabet.from_largest)
'bayeszcdfghijklmnopqrtuvwx'
"""
- if wrap_alphabet == Keyword_wrap_alphabet.from_a:
+ if wrap_alphabet == KeywordWrapAlphabet.from_a:
cipher_alphabet = ''.join(deduplicate(sanitise(keyword) +
string.ascii_lowercase))
else:
- if wrap_alphabet == Keyword_wrap_alphabet.from_last:
+ if wrap_alphabet == KeywordWrapAlphabet.from_last:
last_keyword_letter = deduplicate(sanitise(keyword))[-1]
else:
last_keyword_letter = sorted(sanitise(keyword))[-1]
return cipher_alphabet
-def keyword_encipher(message, keyword, wrap_alphabet=Keyword_wrap_alphabet.from_a):
+def keyword_encipher(message, keyword, wrap_alphabet=KeywordWrapAlphabet.from_a):
"""Enciphers a message with a keyword substitution cipher.
wrap_alphabet controls how the rest of the alphabet is added
after the keyword.
>>> keyword_encipher('test message', 'bayes')
'rsqr ksqqbds'
- >>> keyword_encipher('test message', 'bayes', Keyword_wrap_alphabet.from_a)
+ >>> keyword_encipher('test message', 'bayes', KeywordWrapAlphabet.from_a)
'rsqr ksqqbds'
- >>> keyword_encipher('test message', 'bayes', Keyword_wrap_alphabet.from_last)
+ >>> keyword_encipher('test message', 'bayes', KeywordWrapAlphabet.from_last)
'lskl dskkbus'
- >>> keyword_encipher('test message', 'bayes', Keyword_wrap_alphabet.from_largest)
+ >>> keyword_encipher('test message', 'bayes', KeywordWrapAlphabet.from_largest)
'qspq jsppbcs'
"""
cipher_alphabet = keyword_cipher_alphabet_of(keyword, wrap_alphabet)
cipher_translation = ''.maketrans(string.ascii_lowercase, cipher_alphabet)
return unaccent(message).lower().translate(cipher_translation)
-def keyword_decipher(message, keyword, wrap_alphabet=Keyword_wrap_alphabet.from_a):
+def keyword_decipher(message, keyword, wrap_alphabet=KeywordWrapAlphabet.from_a):
"""Deciphers a message with a keyword substitution cipher.
wrap_alphabet controls how the rest of the alphabet is added
after the keyword.
>>> keyword_decipher('rsqr ksqqbds', 'bayes')
'test message'
- >>> keyword_decipher('rsqr ksqqbds', 'bayes', Keyword_wrap_alphabet.from_a)
+ >>> keyword_decipher('rsqr ksqqbds', 'bayes', KeywordWrapAlphabet.from_a)
'test message'
- >>> keyword_decipher('lskl dskkbus', 'bayes', Keyword_wrap_alphabet.from_last)
+ >>> keyword_decipher('lskl dskkbus', 'bayes', KeywordWrapAlphabet.from_last)
'test message'
- >>> keyword_decipher('qspq jsppbcs', 'bayes', Keyword_wrap_alphabet.from_largest)
+ >>> keyword_decipher('qspq jsppbcs', 'bayes', KeywordWrapAlphabet.from_largest)
'test message'
"""
cipher_alphabet = keyword_cipher_alphabet_of(keyword, wrap_alphabet)
else:
self.validate_wheel_spec(wheel)
self.make_wheel_map(wheel)
- self.position = ord(position) - ord('a')
+ if position in string.ascii_lowercase:
+ self.position = ord(position) - ord('a')
+ else:
+ self.position = position
def make_wheel_map(self, wheel_spec):
"""Expands a wheel specification from a list of letter-letter pairs
>>> pe.validate_wheel_spec([])
Traceback (most recent call last):
...
- ValueError: Wheel specification has 0 pairs, require 13
+ ValueError: Wheel specification has 0 pairs, requires 13
>>> pe.validate_wheel_spec([('a', 'b', 'c')]*13)
Traceback (most recent call last):
...
ValueError: Wheel specification does not contain 26 letters
"""
if len(wheel_spec) != 13:
- raise ValueError("Wheel specification has {} pairs, require 13".
+ raise ValueError("Wheel specification has {} pairs, requires 13".
format(len(wheel_spec)))
for p in wheel_spec:
if len(p) != 2:
5
>>> ''.join([pe.lookup(l) for l in string.ascii_lowercase])
'udhbfejcpgmokrliwntsayqzvx'
+ >>> pe.lookup('A')
+ ''
"""
- return chr((self.wheel_map[(ord(letter) - ord('a') - self.position) % 26] + self.position) % 26 + ord('a'))
+ if letter in string.ascii_lowercase:
+ return chr(
+ (self.wheel_map[(ord(letter) - ord('a') - self.position) % 26] +
+ self.position) % 26 +
+ ord('a'))
+ else:
+ return ''
def advance(self):
"""Advances the wheel one position.
self.position = (self.position + 1) % 26
return self.position
- def encipher(self, message):
+ def encipher(self, message, starting_position=None):
"""Enciphers a whole message.
>>> pe.set_position('f')
5
>>> pe.encipher('kjsglcjoqc')
'helloworld'
+ >>> pe.encipher('helloworld', starting_position = 'x')
+ 'egrekthnnf'
"""
+ if starting_position:
+ self.set_position(starting_position)
transformed = ''
for l in message:
transformed += self.encipher_letter(l)
projects / cipher-training.git / blobdiff