2017_10_19_answers.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Answers for Exercises due by EOD 2017.10.19"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# exercise 1: fill in midterm date availability poll\n",
    "\n",
    "go here, log in with your georgetown.edu google account, and fill in the poll:\n",
    "\n",
    "https://goo.gl/forms/rv3pnVoskIDwmUW33"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# answer 1\n",
    "\n",
    "no answer!\n",
    "\n",
    "FREE POINTS YALL"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# exercise 2: setting up `kms` encryption\n",
    "\n",
    "in the `s3` lecture, I mentioned that `s3` supports *server-side* encryption as a simple check box (that is, whenever a file is received by `s3` it will encrypt it (jumble the contents so they are unreadable to a human) with a secret key, and it will decrypt that file (reverse that jumbling) whenver someone who is approved (e.g. *you*) requests that file. I also mentioned that *client-side* encryption -- where you as a user jumble the contents before you even send them to `s3`, and decrypt the jumbled contents when they're sent back to you -- is another option, but it requires extra effort, and I didn't elaborate on that extra effort.\n",
    "\n",
    "then, in the web scraping lectures, I mentioned that it might be possible to store an *encrypted* (jumbled) version of a password in plain text on your local machine and that if you new how to *decrypt* (un-jumble) that encrypted version that this would be more secure than saving the regular password in plain text. but I didn't discuss how you might do that at all.\n",
    "\n",
    "let's walk through how *client-side encryption* can be done relatively easily using the `aws kms` service and the `python boto3` library.\n",
    "\n",
    "the end result here will be a pair of `python` functions which can encrypt and upload a secret message, and then download and decrypt that same message.\n",
    "\n",
    "\n",
    "## create a kms key\n",
    "\n",
    "go to the `aws iam` web console page. the left-hand menu has, as one of its options, [\"Encryption Keys\"](https://console.aws.amazon.com/iam/home#/encryptionKeys/us-east-1). Navigate to that place, and create a new key.\n",
    "\n",
    "+ for the administrator, select your personal `iam` user.\n",
    "+ for the usage permissions, make sure to add the role you are using for your `aws cli` use on your `ec2` server.\n",
    "    + we added this in the lecture on `aws cli`, but you can see it in the \"description\" window for your `ec2` server with a name \"IAM role\", or you can right click the `ec2` instance, select \"Instance Settings > Attach/Replace IAM Role\"\n",
    "\n",
    "\n",
    "## encrypt a message\n",
    "\n",
    "let's assume that in the previous step your named your key `mykey` (replace all occurrences of `mykey` below with whatever you actually used for your key alias name).\n",
    "\n",
    "encrypting a message is simple with the `kms` client's `encrypt` method:\n",
    "\n",
    "```python\n",
    "import boto3\n",
    "\n",
    "session = boto3.session.Session(region_name='us-east-1')\n",
    "\n",
    "message = b'evs'\n",
    "keyalias = 'mykey'\n",
    "\n",
    "# note: the kms service does not have a *resource* object yet, so we use a client\n",
    "kms = session.client('kms')\n",
    "\n",
    "response = kms.encrypt(\n",
    "    KeyId='alias/{}'.format(keyalias),\n",
    "    Plaintext=message,\n",
    ")\n",
    "\n",
    "encryptedmessage = response['CiphertextBlob']\n",
    "print(encryptedmessage)\n",
    "```\n",
    "\n",
    "if at any point you run into permissions issues, please resolve those issues using the `iam` service.\n",
    "\n",
    "\n",
    "## write encrypted message to an `s3` file\n",
    "\n",
    "using the process we demoed in a mini-exercise in the `s3` lecture where we upload a *string* (not a local text file) into a file on `s3`, create a file on `s3` with the encrypted message as its contents.\n",
    "\n",
    "\n",
    "## download that file from `s3`\n",
    "\n",
    "using the process we demoed in a mini-exercise in the `s3` lecture, download the file you just posted to `s3` into a string object (*i.e.* don't download to file).\n",
    "\n",
    "\n",
    "## decrypt the message inside the downloaded file\n",
    "\n",
    "the `kms` client object you created above has a `decrypt` method function that take an encrypted message and cycles through your encryption keys until one of them successfully decrypts the string.\n",
    "\n",
    "apply that `kms.decrypt` function to the encrypted message you just downloaded\n",
    "\n",
    "```python\n",
    "import boto3\n",
    "\n",
    "session = boto3.session.Session(region_name='us-east-1')\n",
    "\n",
    "kms = session.client('kms')\n",
    "\n",
    "response = kms.decrypt(CiphertextBlob=encryptedmessage)\n",
    "decryptedmessage = response['Plaintext']\n",
    "print(decryptedmessage)\n",
    "```\n",
    "\n",
    "## put it all together\n",
    "\n",
    "use the code you generated above to fill in the details of the `python` script `clientside.py`, available on my shared `s3` bucket here:\n",
    "\n",
    "https://s3.amazonaws.com/shared.rzl.gu511.com/clientside.py\n",
    "\n",
    "fill in the regions marked by comment boxes:\n",
    "\n",
    "```python\n",
    "# ---------------- #\n",
    "# FILL THIS IN !!! #\n",
    "# ---------------- #\n",
    "```\n",
    "\n",
    "save your filled-in version as a file named `clientside.py` on your public homework submission `s3` bucket.\n",
    "\n",
    "\n",
    "## epilogue: application to passwords\n",
    "\n",
    "*you don't have to do anything in the following: this is just an explanation of how you can use the above to work with passwords*\n",
    "\n",
    "in the \"encrypt a message\" section above, suppose the \"message\" you wanted to encrypt was a plain-text password you entered manually as\n",
    "\n",
    "```python\n",
    "import getpass\n",
    "\n",
    "message = getpass.getpass(prompt=\"Your Password: \")\n",
    "```\n",
    "\n",
    "you could now easily take that plain-text password and encrypt it. you could then quite easily write that encrypted password to a file anywhere on your computer -- say, `~/.secrets/mycredentials.json`.\n",
    "\n",
    "then, when you want to *use* that password, you could do the following with a `kms` client created the same way as above:\n",
    "\n",
    "```python\n",
    "encryptedPw = read_pw_from_file(\"/home/ubuntu/.secrets/mycredentials.json\")\n",
    "plaintextPw = kms.decrypt(CiphertextBlob=encryptedPw)['Plaintext']\n",
    "```\n",
    "\n",
    "not too much effort for a little extra security."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# answer 2\n",
    "\n",
    "the contents of `clientside.py` should be similar to\n",
    "\n",
    "```python\n",
    "#!/usr/bin/env python\n",
    "# -*- coding: utf-8 -*-\n",
    "\n",
    "\"\"\"\n",
    "Module: clientside.py\n",
    "Author: zlamberty\n",
    "Created: 2017-09-20\n",
    "\n",
    "Description:\n",
    "    client-side encryption functions for `s3`\n",
    "\n",
    "Usage:\n",
    "    python clientside.py upload -m mymessage -k mykey -b bucket -s s3keyname\n",
    "\n",
    "    or\n",
    "\n",
    "    python clientside.py download -b bucket -s s3keyname\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "import argparse\n",
    "\n",
    "import boto3\n",
    "\n",
    "\n",
    "# ----------------------------- #\n",
    "#   Main routine                #\n",
    "# ----------------------------- #\n",
    "\n",
    "def encrypt_and_upload(message, bucket, s3keyname, encrkeyalias,\n",
    "                       region_name='us-east-1'):\n",
    "    session = boto3.session.Session(region_name=region_name)\n",
    "\n",
    "    # encrypt a message\n",
    "   kms = session.client('kms')\n",
    "\n",
    "    response = kms.encrypt(\n",
    "        KeyId='alias/{}'.format(encrkeyalias),\n",
    "        Plaintext=message,\n",
    "    )\n",
    "\n",
    "    encryptedmessage = response['CiphertextBlob']\n",
    "\n",
    "    # save that encrypted message to `bucket` as `keyname`\n",
    "    s3 = session.resource('s3')\n",
    "    bucketobj = s3.Bucket(bucket)\n",
    "    s3file = bucketobj.Object(key=s3keyname)\n",
    "    s3file.put(\n",
    "        Body=encryptedmessage,\n",
    "        ContentType='text/plain'\n",
    "    )\n",
    "    return\n",
    "\n",
    "\n",
    "def download_and_decrypt(bucket, s3keyname, region_name='us-east-1'):\n",
    "    session = boto3.session.Session(region_name=region_name)\n",
    "\n",
    "    # download the contents of `bucket` file `s3keyname` to a string\n",
    "    s3 = session.resource('s3')\n",
    "    bucketobj = s3.Bucket(bucket)\n",
    "    s3file = bucketobj.Object(key=s3keyname)\n",
    "    response = s3file.get()\n",
    "    encryptedmessage = response['Body'].read()\n",
    "\n",
    "    # decrypt that string and return it below\n",
    "    kms = session.client('kms')\n",
    "\n",
    "    response = kms.decrypt(CiphertextBlob=encryptedmessage)\n",
    "    decryptedmessage = response['Plaintext']\n",
    "\n",
    "    return decryptedmessage\n",
    "\n",
    "\n",
    "# ----------------------------- #\n",
    "#   command line                #\n",
    "# ----------------------------- #\n",
    "\n",
    "def parse_args():\n",
    "    parser = argparse.ArgumentParser()\n",
    "\n",
    "    # shared flags parent parser\n",
    "    parent = argparse.ArgumentParser(add_help=False)\n",
    "\n",
    "    bucket = \"the name of the S3 bucket (no need for s3:// or any of that)\"\n",
    "    parent.add_argument(\"-b\", \"--bucket\", help=bucket, required=True)\n",
    "\n",
    "    s3keyname = \"the key name of an S3 file\"\n",
    "    parent.add_argument(\"-s\", \"--s3keyname\", help=s3keyname, required=True)\n",
    "\n",
    "    subparsers = parser.add_subparsers(\n",
    "        title='subcommands', description='valid subcommands',\n",
    "        help='additional help', dest='cmd'\n",
    "    )\n",
    "\n",
    "    # upload command\n",
    "    ul = subparsers.add_parser('upload', parents=[parent])\n",
    "\n",
    "    message = \"the message we wish to encrypt and upload to s3\"\n",
    "    ul.add_argument(\"-m\", \"--message\", help=message, required=True)\n",
    "\n",
    "    keyalias = \"the alias of the encryption key we should use\"\n",
    "    ul.add_argument(\"-k\", \"--keyalias\", help=keyalias, required=True)\n",
    "\n",
    "    dl = subparsers.add_parser('download', parents=[parent])\n",
    "\n",
    "    return parser.parse_args()\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    args = parse_args()\n",
    "\n",
    "    if args.cmd == 'upload':\n",
    "        encrypt_and_upload(\n",
    "            message=args.message, bucket=args.bucket, s3keyname=args.s3keyname,\n",
    "            encrkeyalias=args.keyalias\n",
    "        )\n",
    "    elif args.cmd == 'download':\n",
    "        decryptedmessage = download_and_decrypt(\n",
    "            bucket=args.bucket, s3keyname=args.s3keyname\n",
    "        )\n",
    "        print(decryptedmessage)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# exercise 3: `xpath` and `css` selectors in the wild\n",
    "\n",
    "let's construct several `xpath` expressions and `css` selectors to isolate elements on [the hacker news homepage](https://news.ycombinator.com/). \n",
    "\n",
    "fill in the `xpath` and `css` selector columns of the table below. [this diagram](https://drive.google.com/file/d/0ByQ4VmO-MwEEd3hZN0xNSHV2WE0/view?usp=sharing) highlights the four elements of each news article entry that we are looking to describe by enumerating and highlighting the exact elements\n",
    "\n",
    "| number | color  | description      | example                   | `xpath` | `css` selector |\n",
    "|--------|--------|------------------|---------------------------|---------|----------------|\n",
    "| 1      | red    | article title    | \"If macOS High Sierra...\" |         |                |\n",
    "| 2      | blue   | article source   | \"apple.com\"               |         |                |\n",
    "| 3      | orange | number of points | \"167 points\"              |         |                |\n",
    "| 4      | green  | age of the post  | \"55 minutes ago\"          |         |                |\n",
    "\n",
    "put the contents of the above into a `csv` file called `xpath_css_in_the_wild.csv` and upload it to your public `s3` homework submission bucket."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# answer 3\n",
    "\n",
    "the following will work\n",
    "\n",
    "\n",
    "| number | color  | description      | example                   | `xpath`                    | `css` selector |\n",
    "|--------|--------|------------------|---------------------------|----------------------------|----------------|\n",
    "| 1      | red    | article title    | \"If macOS High Sierra...\" | `//a[@class=\"storylink\"]`  | `a.storylink`  |\n",
    "| 2      | blue   | article source   | \"apple.com\"               | `//span[@class=\"sitestr\"]` | `span.sitestr` |\n",
    "| 3      | orange | number of points | \"167 points\"              | `//span[@class=\"score\"]`   | `span.score`   |\n",
    "| 4      | green  | age of the post  | \"55 minutes ago\"          | `//span[@class=\"age\"]/a`   | `span.age > a` |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# exercise 4: `POST` a `github gist`\n",
    "\n",
    "using your *personal* `github` account, create a `gist` named `GET_the_gist.txt` with whatever contents you want inside of it. make sure this `gist` is associated to your user account, not an anonymous user.\n",
    "\n",
    "place whatever commands you used to create that gist (a `curl` statement, `python requests` statements, `R httr` statements) into a file called `POST_the_gist.{sh,py,r,etc}`, where the extension is chosen based on the language of the commands you used.\n",
    "\n",
    "upload that `POST_the_gist.{extension}` file to your homework submission `s3` bucket from last week's assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# answer 4\n",
    "\n",
    "in `bash`, using `curl`:\n",
    "\n",
    "```bash\n",
    "curl -X POST \\\n",
    "     --user \"USER_NAME:PWD\" \\\n",
    "     -H \"Content-Type: application/json\" \\\n",
    "     -d '{\"description\": \"a test post of a gist\", \"public\": true, \"files\": {\"my_test_file.py\": {\"content\": \"print(''hello world'')\"}}}' \\\n",
    "     https://github.com/gitapi/gists\n",
    "```\n",
    "\n",
    "and now in `python`, using `requests`:\n",
    "\n",
    "```python\n",
    "import requests\n",
    "\n",
    "def main(username, pw):\n",
    "    data = {\n",
    "        'description': 'a test post of a gist',\n",
    "        'public': True,\n",
    "        'files': {\n",
    "            'my_test_file.py': {\n",
    "                'content': \"print('hello world')\"\n",
    "            }\n",
    "        }\n",
    "    }\n",
    "\n",
    "    resp = requests.post(\n",
    "        url=\"https://github.com/gitapi/gists\",\n",
    "        json=data,\n",
    "        auth=(username, pw)\n",
    "    )\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# exercise 5: `twitter` ~~bot~~ self-esteem engine\n",
    "\n",
    "## 5.0: setting up\n",
    "\n",
    "I've decided to put some of my thoughts out into the twitter ether. [this is a particularly good one, actually](https://twitter.com/rzl_gu511/status/916025777128427520).\n",
    "\n",
    "we all recognize it's good, so let's all go ahead and give it a big ol' like, maybe a retweet.\n",
    "\n",
    "\n",
    "### creating an account\n",
    "\n",
    "any which way we do this, we'll need a twitter account. **get a twitter account**. create a new one if you'd like, or re-use an existing one -- both are fine.\n",
    "\n",
    "in order to sign up for accounts below, you *have to associate your account with [a valid email address](https://twitter.com/settings/account) and [mobile phone](https://twitter.com/settings/add_phone)*. come back onto the grid for a little bit.\n",
    "\n",
    "\n",
    "### reading the ToS\n",
    "\n",
    "read [twitter's automation rules](https://support.twitter.com/articles/76915). we like to goof, but there are rules and you should obey them!\n",
    "\n",
    "\n",
    "### installing needed `python` packages\n",
    "\n",
    "we will do some funky authentication stuff below, so before you dive in too deep, install the `requests_oauthlib` library. **note**: this is not available via `conda`, so we *must* `pip install` it\n",
    "\n",
    "```bash\n",
    "pip install requests_oauthlib\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.1: exploring the endpoint\n",
    "\n",
    "twitter has [a very robust `api`](https://developer.twitter.com/en/docs) and you should take a look at it! via the `api`, you can do pretty much everything you could do as a real person.\n",
    "\n",
    "in particular, to \"like\" a tweet (or \"favorite\" a tweet, to use the phrase that described \"making an outline of a grey heart into a pinkish-red hued heart and thereby stimulate endorphine release in all parties\" back when the `api` was originall developed), there is [a simple `POST` endpoint](https://developer.twitter.com/en/docs/tweets/post-and-engage/api-reference/post-favorites-create). that endpoint is:\n",
    "\n",
    "```\n",
    "https://api.twitter.com/1.1/favorites/create.json\n",
    "```\n",
    "\n",
    "and the required paramater is `id`, a globally unique identifier for the tweet we want to like (look at the link of the tweet and see if you can guess what the id is!)\n",
    "\n",
    "that's right:\n",
    "\n",
    "```\n",
    "id = 916025777128427520\n",
    "```\n",
    "\n",
    "if that were all we needed to know, it'd be simple:\n",
    "\n",
    "```python\n",
    "resp = requests.post(\n",
    "    url='https:api.twitter.com/1.1./favorites/create.json',\n",
    "    params={'id': 916025777128427520}\n",
    ")\n",
    "```\n",
    "\n",
    "it's not exactly that simple, though -- twitter has *some* standards. this `api` requires *authentication* not by *username and password*, but via a process called `oauth`. let's walk through that now"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.2: `oauth` and authentication\n",
    "\n",
    "### high level: what is `oauth`\n",
    "\n",
    "[`OAuth`](https://stormpath.com/blog/what-the-heck-is-oauth) is a standard (a set of guidelines and some implementation suggestions or requirements) for \"delegating access\". basically, this is a way for you as a real human user to allow other things (applications, web apps, `api`s, etc) to act on your behalf.\n",
    "\n",
    "this is the standard that is being used when you, for example, go to \"log in\" to a site and it temporarly redirects you to Facebook or Google to either say \"yeah, that's me\" or \"sure, they can have my life's history\".\n",
    "\n",
    "one reason to do something like this is to generate a new, unique password for *every* request. this way we don't have permanent credentials sitting around in files (e.g. the `aws cli` access keys).\n",
    "\n",
    "twitter asks that we use it, so let's give that a go.\n",
    "\n",
    "\n",
    "### configuring your twitter ~~bot~~ friendliness generator to use `oauth`\n",
    "\n",
    "the following is a basic summary of instructions found [here](https://developer.twitter.com/en/docs/basics/authentication/guides/access-tokens)\n",
    "\n",
    "1. head to [the twitter application page](https://apps.twitter.com/)\n",
    "2. click \"create new app\"\n",
    "3. fill in the form\n",
    "    1. for website, use whatever you want (*e.g.* http://www.noaddress.edu/)\n",
    "    2. for callback url, leave this blank\n",
    "4. on the new application's home page (something like https://apps.twitter.com/app/********), click on the \"Keys and Access Tokens\" tab\n",
    "    1. at the bottom is a section called \"Your Access Token\"\n",
    "    2. click on the \"Create my access token\" button\n",
    "5. secrets are secrets for a reason! don't share them!!\n",
    "6. nothing more to do now, but from this page you will be using:\n",
    "    1. Consumer Key\n",
    "    2. Consumer Secret\n",
    "    3. Access Token\n",
    "    4. Access Token Secret"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.3: \"liking\" tweets using `requests_oauthlib` \n",
    "\n",
    "OAuth authentication is common enough that someone has created an extension of the `requests` library to specifically handle OAuth authentication for regular `requests` library requests.\n",
    "\n",
    "it follows a common paradigm: rather than use the `requests.post` method, we *create an OAuth-authenticated `session` object* and make our `GET` and `POST` requests with the `oauthsession.get` and `oauthsession.post` methods of that session (this is an identical workflow to the `boto3 session` objects, for example).\n",
    "\n",
    "```python\n",
    "import getpass\n",
    "import requests_oauthlib\n",
    "\n",
    "def get_oauth_credentials():\n",
    "    \"\"\"prompt a user to type in the four values on their twitter application \n",
    "    page (https://apps.twitter.com/app/********/keys). this is more secure than \n",
    "    typing them in directly, as those commands are saved to your python command \n",
    "    history file. it is *not* automation-friendly, however -- for that you would\n",
    "    want to use a separate file as discussed in the notes\n",
    "    \n",
    "    \"\"\"\n",
    "    consumerKey = getpass.getpass(prompt=\"your consumer key: \")\n",
    "    consumerSecret = getpass.getpass(prompt=\"your consumer secret: \")\n",
    "    accessToken = getpass.getpass(prompt=\"your access token: \")\n",
    "    accessTokenSecret = getpass.getpass(prompt=\"your access token secret: \")\n",
    "\n",
    "    return consumerKey, consumerSecret, accessToken, accessTokenSecret\n",
    "    \n",
    "    \n",
    "def get_tweet_history(screenname='rzl_gu511'):\n",
    "    \"\"\"build an oauth-authenticated connection and requests all statuses \n",
    "    (tweets) from the provided screen name\n",
    "    \n",
    "    \"\"\"\n",
    "    consumerKey, consumerSecret, accessToken, accessTokenSecret = get_oauth_credentials()\n",
    "    \n",
    "    # this code will create an authenticated session object\n",
    "    oauthsession = requests_oauthlib.OAuth1Session(\n",
    "        client_key=consumerKey,\n",
    "        client_secret=consumerSecret,\n",
    "        resource_owner_key=accessToken,\n",
    "        resource_owner_secret=accessTokenSecret\n",
    "    )\n",
    "    \n",
    "    # an oauth-authenticated request (didn't *need* oauth, it's just an example)\n",
    "    resp = oauthsession.get(\n",
    "        url='https://api.twitter.com/1.1/favorites/list.json',\n",
    "        params={'screen_name': 'rzl_gu511'}\n",
    "    )\n",
    "    \n",
    "    return resp.json()\n",
    "```\n",
    "\n",
    "\n",
    "### putting it all together\n",
    "\n",
    "using `requests_oauthlib`, fill in the following `python` code. make sure that the function `oh_geeze_thats_a_good_tweet` works (i.e. it \"likes\" the tweet, aka creates a favorite record for that tweet id). when you can verify that it is working correctly, save the contents to a file called `goodtweet.py`\n",
    "\n",
    "```python\n",
    "#!/usr/bin/env python\n",
    "# -*- coding: utf-8 -*-\n",
    "\n",
    "\"\"\"\n",
    "Module: goodtweet.py\n",
    "\"\"\"\n",
    "\n",
    "import getpass\n",
    "import requests_oauthlib\n",
    "\n",
    "\n",
    "def get_oauth_credentials():\n",
    "    \"\"\"prompt a user to type in the four values on their twitter application \n",
    "    page (https://apps.twitter.com/app/********/keys). this is more secure than \n",
    "    typing them in directly, as those commands are saved to your python command \n",
    "    history file. it is *not* automation-friendly, however -- for that you would\n",
    "    want to use a separate file as discussed in the notes\n",
    "    \n",
    "    \"\"\"\n",
    "    consumerKey = getpass.getpass(prompt=\"your consumer key: \")\n",
    "    consumerSecret = getpass.getpass(prompt=\"your consumer secret: \")\n",
    "    accessToken = getpass.getpass(prompt=\"your access token: \")\n",
    "    accessTokenSecret = getpass.getpass(prompt=\"your access token secret: \")\n",
    "\n",
    "    return consumerKey, consumerSecret, accessToken, accessTokenSecret\n",
    "    \n",
    "    \n",
    "def oh_geeze_thats_a_good_tweet(tweetid=916025777128427520):\n",
    "    \"\"\"build an oauth-authenticated connection and \"favorite\" (aka \"like\")\n",
    "    a tweet with a given ID\n",
    "    \n",
    "    \"\"\"\n",
    "    # load credentials with the get_oauth_credentials function\n",
    "    #---------------#\n",
    "    # FILL ME IN!!! #\n",
    "    #---------------#\n",
    "\n",
    "    # create an oauth session object using those credentials\n",
    "    #---------------#\n",
    "    # FILL ME IN!!! #\n",
    "    #---------------#\n",
    "    \n",
    "    # use the oath session you just created to make a requests to the\n",
    "    # `favorites/create` api endpoint to \"favorite\" the tweet with id `tweetid`\n",
    "    # api docs:\n",
    "    # https://developer.twitter.com/en/docs/tweets/post-and-engage/api-reference/post-favorites-create\n",
    "    #---------------#\n",
    "    # FILL ME IN!!! #\n",
    "    #---------------#\n",
    "    \n",
    "    # return the json payload of the previous request\n",
    "    return resp.json()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.4: *advanced and optional*: retweeting with `selenium`\n",
    "\n",
    "*this assignment is optional, for those of you who want experience using `selenium`.*\n",
    "\n",
    "using `selenium`, fill in the following `python` code. make sure that the function `youve_gotta_see_this_tweet` works (it fully retweets the tweet), and if it does, add it to the file `goodtweet.py` from above\n",
    "\n",
    "```python\n",
    "# add this to the import block of your `goodtweet.py` file\n",
    "import selenium\n",
    "import selenium.webdriver\n",
    "\n",
    "\n",
    "# append this to the rest of the `goodtweet.py` file\n",
    "def youve_gotta_see_this_tweet(username, password, tweeturl, driverpath=None):\n",
    "    \"\"\"use selenium to sign in to twitter (requires `username` and `password`),\n",
    "    open the tweet at `tweeturl`, click the \"retweet\" icon, and click the \n",
    "    \"retweet\" button in the popup\n",
    "    \n",
    "    \"\"\"\n",
    "    # build a driver (firefox driver, chrome, etc)\n",
    "    # *NOTE*: you have to have previously downloaded the driver executable \n",
    "    # and added the directory in which that driver resides to your PATH variable\n",
    "    #---------------#\n",
    "    # FILL ME IN!!! #\n",
    "    #---------------#\n",
    "    \n",
    "    # navigate to the twitter login page\n",
    "    #---------------#\n",
    "    # FILL ME IN!!! #\n",
    "    #---------------#\n",
    "    \n",
    "    # use xpath or css to get the html elements of the user name and password\n",
    "    # fields, and use the `sendkeys` methods of those elements to type the\n",
    "    # username and password in. then select the \"submit\" button and use the\n",
    "    # `click` method to click it\n",
    "    #---------------#\n",
    "    # FILL ME IN!!! #\n",
    "    #---------------#\n",
    "    \n",
    "    # navigate to the awesome tweet\n",
    "    #---------------#\n",
    "    # FILL ME IN!!! #\n",
    "    #---------------#\n",
    "    \n",
    "    # find the html element of the \"like\" icon, and `click` it\n",
    "    #---------------#\n",
    "    # FILL ME IN!!! #\n",
    "    #---------------#\n",
    "    \n",
    "    # in the popup, find the \"retweet\" button and `click` it\n",
    "    #---------------#\n",
    "    # FILL ME IN!!! #\n",
    "    #---------------#\n",
    "    \n",
    "    # `close` the driver\n",
    "    #---------------#\n",
    "    # FILL ME IN!!! #\n",
    "    #---------------#\n",
    "    \n",
    "    return\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.5: deliverable\n",
    "\n",
    "uplaod the contents of `goodtweet.py` to your public `s3` homework submission bucket"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# answer 5\n",
    "\n",
    "the contents of `goodtweet.py`:\n",
    "\n",
    "```python\n",
    "#!/usr/bin/env python\n",
    "# -*- coding: utf-8 -*-\n",
    "\n",
    "\"\"\"\n",
    "Module: goodtweet.py\n",
    "\"\"\"\n",
    "\n",
    "import getpass\n",
    "import requests_oauthlib\n",
    "import selenium\n",
    "import selenium.webdriver\n",
    "\n",
    "\n",
    "def get_oauth_credentials():\n",
    "    \"\"\"prompt a user to type in the four values on their twitter application \n",
    "    page (https://apps.twitter.com/app/********/keys). this is more secure than \n",
    "    typing them in directly, as those commands are saved to your python command \n",
    "    history file. it is *not* automation-friendly, however -- for that you would\n",
    "    want to use a separate file as discussed in the notes\n",
    "    \n",
    "    \"\"\"\n",
    "    consumerKey = getpass.getpass(prompt=\"your consumer key: \")\n",
    "    consumerSecret = getpass.getpass(prompt=\"your consumer secret: \")\n",
    "    accessToken = getpass.getpass(prompt=\"your access token: \")\n",
    "    accessTokenSecret = getpass.getpass(prompt=\"your access token secret: \")\n",
    "\n",
    "    return consumerKey, consumerSecret, accessToken, accessTokenSecret\n",
    "    \n",
    "    \n",
    "def oh_geeze_thats_a_good_tweet(tweetid=916025777128427520):\n",
    "    \"\"\"build an oauth-authenticated connection and \"favorite\" (aka \"like\")\n",
    "    a tweet with a given ID\n",
    "    \n",
    "    \"\"\"\n",
    "    # load credentials with the get_oauth_credentials function\n",
    "    consumerKey, consumerSecret, accessToken, accessTokenSecret = get_oauth_credentials()\n",
    "\n",
    "    # create an oauth session object using those credentials\n",
    "    oauth = OAuth1Session(\n",
    "        client_key=consumerKey,\n",
    "        client_secret=consumerSecret,\n",
    "        resource_owner_key=accessToken,\n",
    "        resource_owner_secret=accessTokenSecret\n",
    "    )\n",
    "    \n",
    "    # use the oath session you just created to make a requests to the\n",
    "    # `favorites/create` api endpoint to \"favorite\" the tweet with id `tweetid`\n",
    "    # api docs:\n",
    "    # https://developer.twitter.com/en/docs/tweets/post-and-engage/api-reference/post-favorites-create\n",
    "    resp = oauth.post(\n",
    "        url='https://api.twitter.com/1.1/favorites/create.json',\n",
    "        params={'id': 916025777128427520}\n",
    "    )\n",
    "    \n",
    "    # return the json payload of the previous request\n",
    "    return resp.json()\n",
    "    \n",
    "    \n",
    "def youve_gotta_see_this_tweet(username, password, tweeturl, driverpath=None):\n",
    "    \"\"\"use selenium to sign in to twitter (requires `username` and `password`),\n",
    "    open the tweet at `tweeturl`, click the \"retweet\" icon, and click the \n",
    "    \"retweet\" button in the popup\n",
    "    \n",
    "    \"\"\"\n",
    "    # build a driver (firefox driver, chrome, etc)\n",
    "    # *NOTE*: you have to have previously downloaded the driver executable \n",
    "    # and added the directory in which that driver resides to your PATH variable\n",
    "    driver = selenium.webdriver.Firefox(executable_path=driverpath)\n",
    "    \n",
    "    # navigate to the twitter login page\n",
    "    driver.get('https://www.twitter.com/login')\n",
    "    \n",
    "    # use xpath or css to get the html elements of the user name and password\n",
    "    # fields, and use the `sendkeys` methods of those elements to type the\n",
    "    # username and password in. then select the \"submit\" button and use the\n",
    "    # `click` method to click it\n",
    "    uname = driver.find_element_by_css_selector('input.js-username-field')\n",
    "    uname.send_keys(username)\n",
    "    \n",
    "    pw = driver.find_element_by_css_selector('input.js-password-field')\n",
    "    pw.send_keys(password)\n",
    "    \n",
    "    submit = driver.find_element_by_css_selector('button.submit')\n",
    "    submit.click()\n",
    "    \n",
    "    # navigate to the awesome tweet\n",
    "    driver.get(tweeturl)\n",
    "    \n",
    "    # find the html element of the \"like\" icon, and `click` it\n",
    "    retweet = driver.find_element_by_css_selector('button.js-actionRetweet')\n",
    "    retweet.click()\n",
    "    \n",
    "    # in the popup, find the \"retweet\" button and `click` it\n",
    "    retweetsubmit = driver.find_element_by_css_selector('button.retweet-action')\n",
    "    retweetsubmit.click()\n",
    "    \n",
    "    # `close` the driver\n",
    "    driver.close()\n",
    "```"
   ]
  }
 ],
 "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.6.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}