Numerous significant improvements Beta

ciphers/atbash.py

@@ -3,52 +3,34 @@
 import string
 
 
-def atbash_slow(sequence: str) -> str:
+def atbash(text: str) -> str:
     """
-    >>> atbash_slow("ABCDEFG")
-    'ZYXWVUT'
+    Encodes or decodes text using the Atbash cipher.
 
-    >>> atbash_slow("aW;;123BX")
-    'zD;;123YC'
-    """
-    output = ""
-    for i in sequence:
-        extract = ord(i)
-        if 65 <= extract <= 90:
-            output += chr(155 - extract)
-        elif 97 <= extract <= 122:
-            output += chr(219 - extract)
-        else:
-            output += i
-    return output
-
-
-def atbash(sequence: str) -> str:
-    """
-    >>> atbash("ABCDEFG")
-    'ZYXWVUT'
-
-    >>> atbash("aW;;123BX")
-    'zD;;123YC'
-    """
-    letters = string.ascii_letters
-    letters_reversed = string.ascii_lowercase[::-1] + string.ascii_uppercase[::-1]
-    return "".join(
-        letters_reversed[letters.index(c)] if c in letters else c for c in sequence
-    )
+    The Atbash cipher substitutes each letter with its mirror in the alphabet:
+    A -> Z, B -> Y, C -> X, ... Z -> A (case is preserved)
+    Non-alphabetic characters are left unchanged.
 
+    Args:
+        text: The input string to encode/decode
 
-def benchmark() -> None:
-    """Let's benchmark our functions side-by-side..."""
-    from timeit import timeit
+    Returns:
+        The transformed string
+    """
+    # Create translation tables for uppercase and lowercase
+    lowercase_map = str.maketrans(string.ascii_lowercase, string.ascii_lowercase[::-1])
+    uppercase_map = str.maketrans(string.ascii_uppercase, string.ascii_uppercase[::-1])
 
-    print("Running performance benchmarks...")
-    setup = "from string import printable ; from __main__ import atbash, atbash_slow"
-    print(f"> atbash_slow(): {timeit('atbash_slow(printable)', setup=setup)} seconds")
-    print(f">      atbash(): {timeit('atbash(printable)', setup=setup)} seconds")
+    # Apply both translation mappings
+    return text.translate(lowercase_map).translate(uppercase_map)
 
 
+# Example usage
 if __name__ == "__main__":
-    for example in ("ABCDEFGH", "123GGjj", "testStringtest", "with space"):
-        print(f"{example} encrypted in atbash: {atbash(example)}")
-    benchmark()
+    test_string = "Hello, World! 123"
+    encoded = atbash(test_string)
+    decoded = atbash(encoded)
+
+    print(f"Original:  {test_string}")
+    print(f"Encoded:   {encoded}")
+    print(f"Decoded:   {decoded}")

ciphers/shuffled_shift_cipher.py

@@ -42,7 +42,7 @@
         """
         :return: passcode of the cipher object
         """
-        return "".join(self.__passcode)
+        return self.__passcode
 
     def __neg_pos(self, iterlist: list[int]) -> list[int]:
         """
@@ -56,19 +56,19 @@
             iterlist[i] *= -1
         return iterlist
 
-    def __passcode_creator(self) -> list[str]:
+    def __passcode_creator(self) -> str:
         """
         Creates a random password from the selection buffer of
         1. uppercase letters of the English alphabet
         2. lowercase letters of the English alphabet
         3. digits from 0 to 9
 
-        :rtype: list
+        :rtype: str
         :return: a password of a random length between 10 to 20
         """
         choices = string.ascii_letters + string.digits
         password = [random.choice(choices) for _ in range(random.randint(10, 20))]
-        return password
+        return "".join(password)
 
     def __make_key_list(self) -> list[str]:
         """
@@ -104,15 +104,14 @@
         temp_list: list[str] = []
 
         # algorithm for creating a new shuffled list, keys_l, out of key_list_options
-        for i in key_list_options:
-            temp_list.extend(i)
+        for char in key_list_options:
+            temp_list.append(char)
 
             # checking breakpoints at which to pivot temporary sublist and add it into
             # keys_l
-            if i in breakpoints or i == key_list_options[-1]:
+            if char in breakpoints or char == key_list_options[-1]:
                 keys_l.extend(temp_list[::-1])
                 temp_list.clear()
-
         # returning a shuffled keys_l to prevent brute force guessing of shift key
         return keys_l
 
@@ -135,14 +134,13 @@
 
         """
         decoded_message = ""
+        key_len = len(self.__key_list)
 
         # decoding shift like Caesar cipher algorithm implementing negative shift or
         # reverse shift or left shift
-        for i in encoded_message:
-            position = self.__key_list.index(i)
-            decoded_message += self.__key_list[
-                (position - self.__shift_key) % -len(self.__key_list)
-            ]
+        for char in encoded_message:
+            position = self.__key_list.index(char)
+            decoded_message += self.__key_list[(position - self.__shift_key) % key_len]
 
         return decoded_message
 
@@ -157,19 +155,18 @@
 
         """
         encoded_message = ""
+        key_len = len(self.__key_list)
 
         # encoding shift like Caesar cipher algorithm implementing positive shift or
         # forward shift or right shift
-        for i in plaintext:
-            position = self.__key_list.index(i)
-            encoded_message += self.__key_list[
-                (position + self.__shift_key) % len(self.__key_list)
-            ]
+        for char in plaintext:
+            position = self.__key_list.index(char)
+            encoded_message += self.__key_list[(position + self.__shift_key) % key_len]
 
         return encoded_message
 
 
 def test_end_to_end(msg: str = "Hello, this is a modified Caesar cipher") -> str:
     """
     >>> test_end_to_end()
     'Hello, this is a modified Caesar cipher'