Caesar cipher.py

# Simple Caesar cipher functions with validations.
# This file provides:
# - caesar(text, shift, encrypt=True): core logic to shift letters.
# - encrypt(text, shift): convenience wrapper for encryption.
# - decrypt(text, shift): convenience wrapper for decryption.
# Example usage at the bottom demonstrates decryption of a sample string.

def caesar(text,shift,encrypt=True):
    """Perform Caesar cipher encryption or decryption on the input text.

    Parameters:
    - text (str): The input text to be processed.
    - shift (int): The number of positions each letter should be shifted.
    - encrypt (bool): If True, encrypt the text; if False, decrypt the text.

    Returns:
    - str: The encrypted or decrypted text.
    """
    # Validate argument types early so the rest of the function can assume valid inputs.
    # We expect 'shift' to be an integer between 1 and 25 inclusive.
    if not isinstance(shift,int):
        return "shift must be an integer Value"
    if shift<1 or shift>25:
        return "shift must be an integer between 1 and 25"
    
    # Define a lowercase alphabet for creating the shift map.
    # We will also handle uppercase by using .upper() when creating the translation table.
    alphabet="abcdefghijklmnopqrstuvwxyz"
    
    # If we're decrypting rather than encrypting, reverse the direction of the shift.
    # For example, a shift of 3 for encryption becomes -3 for decryption.
    if not encrypt:
        shift=-shift
    
    # Build the shifted version of the alphabet.
    # Example: with shift=3 -> 'defghijklmnopqrstuvwxyzabc'
    shifted_alphabet=alphabet[shift:] + alphabet[:shift]
    
    # Create a translation table for str.translate:
    # - We provide lowercase alphabet and uppercase alphabet as the 'from' set.
    # - We provide shifted lowercase and shifted uppercase as the 'to' set.
    # str.maketrans maps each character positionally from 'from' to 'to'.
    translation_table=str.maketrans(alphabet+alphabet.upper(),
                                    shifted_alphabet+shifted_alphabet.upper())
    
    # Apply the translation to the input text and return the processed string.
    # Non-alphabet characters (digits, punctuation, whitespace) are unchanged by translate.
    encrypted_text=text.translate(translation_table)
    return encrypted_text

# Helper functions to make the API clearer.
# They simply call the core 'caesar' function with the appropriate flag.
def encrypt(text,shift):
    """Encrypt the input text using Caesar cipher with the given shift.

    Parameters:
    - text (str): The input text to be encrypted.
    - shift (int): The number of positions each letter should be shifted.

    Returns:
    - str: The encrypted text.
    """
    # Default is encrypt=True, so just call caesar.
    return caesar(text,shift)

def decrypt(text,shift):
    """Decrypt the input text which was encrypted with Caesar cipher.

    Parameters:
    - text (str): The encrypted text to be decrypted.
    - shift (int): The number of positions each letter was shifted during encryption.

    Returns:
    - str: The decrypted text.
    """
    # Explicitly pass encrypt=False to reverse the shift.
    return caesar(text,shift,encrypt=False)

# Example: decrypt a sample message encrypted with a shift of 13 (ROT13).
encrypted_text="Pbhentr vf sbhaq va hayvxryl cynprf."
decrypted_text=decrypt(encrypted_text,13)
print(decrypted_text)