Required_Code_Mod04.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Module 4 Required code  \n",
    "  \n",
    "\n",
    "## Note: Students of Dev330x on edX\n",
    "\n",
    "> ### It is required to submit your required code for Module 4 within the edX course   \n",
    "> The completed code must be copied from the cell below and pasted in to the edX required code page at the end of Module 4 in the course \"Introduction to Python: Creating Scalable, Robust, Interactive Code\" on edX.  \n",
    ">  \n",
    "> **REQUIREMENTS**  \n",
    "> Submit all of the code for **cipher.py** in working order but you will only be graded on the the 2 functions below:\n",
    "- ### parse_command_line()  \n",
    "  - **use the following required keywords & functions:** `argparse.ArgumentParser()`, `.add_argument()`, `.parse_args()`, `return`\n",
    "- ### read_file()\n",
    "  - **use the following required keywords & functions:** `with open`, `try`, `except`, `return`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<font size=\"6\" color=\"#B24C00\"  face=\"verdana\"> <B>Required Code Module 4</B></font>\n",
    "\n",
    "## Caesar Cipher\n",
    "\n",
    "\n",
    "\n",
    "In this project, you will implement a program to encrypt and decrypt text using Caesar Cipher. The cipher is one of the oldest and simplest known encryption techniques known. It simply relies on substituting each character in a string by another character which is shifted by a certain number of places. For example, with a shift of 1 'a' becomes 'b', 'e' becomes 'f', and 'z' becomes 'a'. In the Caesar cipher, all characters are shifted by the same number of places and we refer to the shift value as key. \n",
    "\n",
    "To decrypt a message, you simply use the same key, which was used during the encryption procedure, to shift the characters back the same number of places. For example, with a key = 1 'b' becomes 'a', 'f' becomes 'e', and 'a' becomes 'z'. \n",
    "\n",
    "Since there are 26 letters in English, there are only 25 keys available for Caesar cipher. Therefore, it is easy to decipher a message without knowing the key. Simply use all possible keys to decrypt a message then read the outputs till one of them makes sense. This process is also implemented in the project.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment Setup\n",
    "\n",
    "The following code blocks move the working directory to `command_line` and generate the necessary text file:\n",
    "* `plain_message.txt` : contains a plain message that will be encrypted\n",
    "* `encrypted_message.txt`: contains an encrypted message where the key is unknown"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Change working directory to `command_line`\n",
    "\n",
    "Necessary so all generated files are saved in this directory, the cell will generate an error message if you are already in the `command_line` directory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "%cd \"/home/nbuser/library/parent_dir/command_line\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Writing text files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile plain_message.txt\n",
    "\n",
    "Software is a great combination between artistry and engineering.\n",
    "\n",
    "--Bill Gates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile encrypted_message.txt\n",
    "\n",
    "MHI LXVKXM!\n",
    "\n",
    "Mabl fxlltzx ptl xgvkrimxw nlbgz dxr = gbgxmxxg.\n",
    "\n",
    "tuvwxyzabcdefghijklmnopqrs\n",
    "\n",
    "TUVWXYZABCDEFGHIJKLMNOPQRS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Complete the Required Code in the Jupyter Notebook Required_Code_Mod01 and then paste the code for cipher.py into edX code submission page   \n",
    "\n",
    "This is the same code assignment located as the project at the bottom of 3-1.5_Mod01_Practice.ipynb  \n",
    "\n",
    "## Program\n",
    "\n",
    "To finish this project, run the environment setup code, read the `main` function, then use the description and examples under each of the following functions to implement them:\n",
    "* `parse_command_line()`\n",
    "* `read_file(file_path)`\n",
    "* `write_file(message, file_path)`\n",
    "* `transform(message, key, decrypt)`\n",
    "\n",
    "Once you are done, use the terminal command line to:\n",
    "* Display the program's help message\n",
    "* Encrypt the text file `plain_message.txt` by key = 23 and save the result in `cipher_message.txt`\n",
    "* Find the key used to decrypt `encrypted_message.txt`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile cipher.py\n",
    "\n",
    "import argparse\n",
    "\n",
    "def parse_command_line():\n",
    "    \"\"\"\n",
    "    Parse the command line arguments and return the parse_args object.\n",
    "    \n",
    "    There should be 1 positional argument and 6 optional arguments.\n",
    "    The help message generated by the parser should look like:\n",
    "    \n",
    "    usage: cipher.py [-h] [-o outfile_path] [-k KEY] [-d] [-a] [-v] infile\n",
    "\n",
    "    positional arguments:\n",
    "      infile                input file to be encrypted or decrypted\n",
    "\n",
    "    optional arguments:\n",
    "      -h, --help            show this help message and exit\n",
    "      -o outfile_path, --outfile outfile_path\n",
    "                            output file\n",
    "      -k KEY, --key KEY     encryption/decryption key (must be positive) (default\n",
    "                            = 1)\n",
    "      -d, --decrypt         decrypt the input file\n",
    "      -a, --all             decrypt using all keys [1, 25], save outputs in\n",
    "                            different files. (useful in case the key is lost or\n",
    "                            unknown)\n",
    "      -v, --verbose         verbose mode\n",
    "\n",
    "\n",
    "    args:\n",
    "        None\n",
    "        \n",
    "    returns:\n",
    "        args: generated argparse object with all the passed command line arguments      \n",
    "    \"\"\"\n",
    "    \n",
    "    #TODO: Your code goes here\n",
    "    #HINTS: Reveiw Jupyter Notebook 3-4.1\n",
    "    pass\n",
    "\n",
    "def read_file(file_path):\n",
    "    \"\"\"\n",
    "    Read file_path and return the content as string.\n",
    "    \n",
    "    The file must be opened and closed and the function should handle exceptions when they are raised.\n",
    "    \n",
    "    args:\n",
    "        file_path: path to file\n",
    "        \n",
    "    returns:\n",
    "        message: content of file in file_path as a string\n",
    "    \"\"\"\n",
    "    \n",
    "    #TODO: Your code goes here\n",
    "    pass\n",
    "            \n",
    "def write_file(message, file_path):\n",
    "    \"\"\"\n",
    "    Write the message in file_path.\n",
    "    \n",
    "    The file must be opened and closed and the function should handle exceptions when they are raised.\n",
    "    \n",
    "    args:\n",
    "        message: string to write in file\n",
    "        file_path: path to file\n",
    "        \n",
    "    returns:\n",
    "        None\n",
    "    \"\"\"\n",
    "    \n",
    "    #TODO: Your code goes here\n",
    "    pass\n",
    "\n",
    "def transform(message, key, decrypt):\n",
    "    \"\"\"\n",
    "    Encrypt or decrypt a message using Caesar cipher.\n",
    "    \n",
    "    Encryption and decryption is determined by the Boolean value in decrypt. Key determines the number of \n",
    "    places a character is shifted. When encrypting, use the positive value of key to shift the characters forward; \n",
    "    when decrypting, use the negative key to shift the characters backward. \n",
    "    \n",
    "    The function should maintain characters that are not letters without change; for example, spaces, punctuations, \n",
    "    and numbers should not be encrypted or decrypted. Additionally, the case of the letters should be preserved, \n",
    "    small letters are transformed to other small letters and capital letters are transformed to capital letters.\n",
    "    \n",
    "    Use the function `shift` (provided later) to shift each character in message by the number in key.\n",
    "    \n",
    "    args:\n",
    "        message: string to be encrypted or decrypted\n",
    "        key: number of places to shift the characters (always positive)\n",
    "        decrypt: Boolean; when False the message is encrypted,  when True the message is decrypted\n",
    "        \n",
    "    returns:\n",
    "        transformed_message: encrypted (or decrypted) message\n",
    "        \n",
    "    examples:\n",
    "        Encryption\n",
    "        ==  transform(\"deal\", 1, False) returns:\n",
    "            \"efbm\"\n",
    "        \n",
    "        ==  transform(\"deal\", 2, False) returns:\n",
    "            \"fgcn\"\n",
    "        \n",
    "        ==  transform(\"deal\", 30, False) is equivalent to transform(message, 4, False)\n",
    "            \"hiep\"\n",
    "        \n",
    "        Decryption\n",
    "        ==  transform(\"efbm\", 1, True) returns:\n",
    "            \"deal\"\n",
    "            \n",
    "        ==  transform(\"fgcn\", 2, True) returns:\n",
    "            \"deal\"\n",
    "            \n",
    "        ==  transform(\"hiep\", 30, True) returns:\n",
    "            \"deal\"    \n",
    "        \n",
    "    \"\"\"\n",
    "    \n",
    "    #TODO: Your code goes here\n",
    "    pass\n",
    " \n",
    "def shift(char, key):    \n",
    "    \"\"\"\n",
    "    Shift char by the value in key while maintaining the case (small/capital).\n",
    "    \n",
    "    If char contains non-letters (i.e. digits, punctuations, and white spaces), it is ignored.\n",
    "    \n",
    "    args:\n",
    "        char: character to shift\n",
    "        key: number of places to shift char\n",
    "        \n",
    "    returns:\n",
    "        shifted character\n",
    "        \n",
    "    examples:\n",
    "        shfit('a', 1) ==> 'b'\n",
    "        shift('z', -1) ==> 'y'\n",
    "        shift('A', 5) ==> 'F'\n",
    "        shift('H', 7) ==> 'O'\n",
    "        shift('o', -10) ==> 'e'\n",
    "        shift('a', 30) ==> 'e'\n",
    "    \"\"\"\n",
    "    \n",
    "    # ordered lower case alphabet\n",
    "    alphabet = \"abcdefghijklmnopqrstuvwxyz\"\n",
    "    \n",
    "    # will contain shifted lower case alphabet\n",
    "    shifted_alphabet = ''\n",
    "    for i in range(len(alphabet)):\n",
    "        shifted_alphabet = shifted_alphabet + alphabet[(i + key) % 26]\n",
    " \n",
    "    if char.isalpha():\n",
    "        char_index = alphabet.index(char.lower())\n",
    "        shifted_char = shifted_alphabet[char_index]\n",
    "    \n",
    "        # keep char's case (upper or lower)\n",
    "        if char.isupper():\n",
    "            return shifted_char.upper()\n",
    "        else:\n",
    "            return shifted_char\n",
    "\n",
    "def main():\n",
    "    # parse command line arguments\n",
    "    args = parse_command_line()\n",
    "    \n",
    "    # read content of infile to a string\n",
    "    instring = read_file(args.infile)\n",
    "    \n",
    "    # verbose\n",
    "    if args.verbose:\n",
    "        print(\"Input file:\")\n",
    "        print(\"------------\")\n",
    "        print(instring)\n",
    "        print()\n",
    "    \n",
    "    # key is specified\n",
    "    if not args.all:\n",
    "        # encrypt/decrypt content of infile\n",
    "        outstring = transform(instring, args.key, args.decrypt)\n",
    "    \n",
    "        # verbose\n",
    "        if args.verbose:\n",
    "            print(\"Output file:\")\n",
    "            print(\"------------\")\n",
    "            print(outstring)\n",
    "\n",
    "        # write content of outstring to outfile\n",
    "        write_file(outstring, args.outfile)\n",
    "    \n",
    "    # key is not specified, try all keys from 1 to 25 to decrypt infile\n",
    "    else:\n",
    "        for k in range(1, 26):\n",
    "            # decrypt content of infile\n",
    "            outstring = transform(instring, k, True)\n",
    "\n",
    "            # verbose\n",
    "            if args.verbose:\n",
    "                print(\"Key =\", k)\n",
    "                print(\"------------\")\n",
    "                print(outstring)\n",
    "                print()\n",
    "\n",
    "            # write content of outstring to outfile\n",
    "            write_file(outstring, \"decrypted_by_\" + str(k) + \".txt\")\n",
    "    \n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Terminal commands\n",
    "* Display the program's help message\n",
    "* Encrypt the text file `plain_message.txt` by key = 23 and save the result in `cipher_message.txt`\n",
    "* Find the key used to decrypt `encrypted_message.txt`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Terminal commands"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Help message"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash\n",
    "\n",
    "python3 cipher.py -h"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Encrypt `plain_message.txt` by key = 23"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "\n",
    "python3 cipher.py plain_message.txt -k 23 -v -o cipher_message.txt\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Finding the key to decrypt `encrypted_message.txt`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash\n",
    "\n",
    "python3 cipher.py encrypted_message.txt -a -v"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}