twitter_chatbot.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this notebook, I define a handful of functions for working with the Twitter API via Twython. These functions include `greet()`, `send_message()`, `clean_message()`, `store_messages()`, and `reply()`. I first make these functions as stand-alone entities, then combine them all into the class `Conversation`. This class is used as a chatbot that takes hard-coded inputs, and contains protocols for response when inputs are not understood.\n",
    "\n",
    "***I have removed any API keys or user ID's that were present for app testing. If you wonder why none of these variables are visibly assigned here, that's why. Same is true for some test conversation outputs that had personal info.***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "from twython import Twython\n",
    "import time\n",
    "import string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Twython Object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set API version to 1.1. Version 2 doesn't have DM support yet.\n",
    "\n",
    "t = Twython(app_key=TWITTER_APP_KEY, \n",
    "            app_secret=TWITTER_APP_KEY_SECRET, \n",
    "            oauth_token=TWITTER_ACCESS_TOKEN, \n",
    "            oauth_token_secret=TWITTER_ACCESS_TOKEN_SECRET,\n",
    "            api_version='1.1')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions For Chat Bot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Send + Receive Messages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Note that some of these cells have had their outputs deleted for privacy.*\n",
    "\n",
    "First we must establish the basic permissions of the app I'm working on. Most importantly, the app can send and receive tweets to and from an account that **isn't** the one the app is attached to. Here is an example of message sent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "t.send_direct_message(event = {\"type\" : \"message_create\",\n",
    "                               \"message_create\" : {\"target\": {\"recipient_id\" : USER_ID},\n",
    "                                                   \"message_data\" : {\"text\" : \"Hey other Steven!\"}}})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The app can also check it's direct messages, and return all items. Here are all the messages sent **and** received by the account the app is attached to:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "all_messages = t.get_direct_messages()\n",
    "all_messages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Storing Received Messages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order for \"conversation\" to eventually happen between a user and the chatbot, we must be able to **save messages and reply to them.** The function `store_messages()` is how that information above will be stored. This function (as well as all those that follow it) will be used in the Conversation class which will be defined later. The function `store_messages()` takes in a user ID and a set of messages. It then pulls out only the relevant tweets and saves their `time`, `user_id`, and `text`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def store_messages(user_id, messages):\n",
    "    \n",
    "    '''\n",
    "    Gets and saves all messages sent from a specific user to the bot.\n",
    "    Output returns a list of dictionaries, where all keys and values are\n",
    "    strings.\n",
    "    ---\n",
    "    user_id\n",
    "        The ID of the user you want to store tweets from.\n",
    "    messages\n",
    "        Must be the output from Twython.get_direct_messages().\n",
    "        This is what you get the tweets from.\n",
    "    '''\n",
    "\n",
    "    message_list = []\n",
    "    user_id = str(user_id)\n",
    "    \n",
    "    for i in range(len(messages['events'])):\n",
    "        \n",
    "        message = messages['events'][i]\n",
    "        sender_id = message['message_create']['sender_id']\n",
    "        \n",
    "        if sender_id == user_id:\n",
    "            message_dict = {}\n",
    "            message_dict['time'] = message['created_timestamp']\n",
    "            message_dict['user_id'] = message['message_create']['sender_id']\n",
    "            message_dict['text'] = message['message_create']['message_data']['text']\n",
    "            message_list.append(message_dict)\n",
    "            \n",
    "    return message_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "got_messages = store_messages(USER_ID, all_messages)\n",
    "got_messages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replying To Messages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Replying is a more complex process, and requires first cleaning any incoming messages and defining a protocol for sending replies. One function for each of these preliminary tasks is defined below, and the functions `clean_messages()` and `send_message()` are then incorporated into a final function `reply()`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cleaning Messages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function below removes all punctuation from an incoming message, changes the whole thing to lowercase, and returns a split version of the message that contains **only** the acceptable values for replying to the chatbot. These values are `['yes', 'no', 'help', 'stop']`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def clean_message(message):\n",
    "    \n",
    "    '''\n",
    "    Cleans out punctuation and capitals from a user message. Returns the\n",
    "    string as a list of strings so that replies can be parsed easily.\n",
    "    ---\n",
    "    message\n",
    "        Must be a string, ideally as seen in store_messages()[i]['text']\n",
    "    '''\n",
    "    \n",
    "    allowed_replies = ['yes', 'no', 'help', 'stop']\n",
    "    \n",
    "    for i in string.punctuation:\n",
    "        message = message.replace(i, '').lower()\n",
    "    \n",
    "    new_message = []\n",
    "    for word in message.split():\n",
    "        if word in allowed_replies:\n",
    "            new_message.append(word)\n",
    "            \n",
    "    return new_message"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['yes', 'no']"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clean_message('yeEs ,yeS No !!!hello 3456 test')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sending Messages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function below just uses the Twython function `send_direct_message()`. It is being rewritten here for **ease of use,** such that a whole JSON need not be written for each use of the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def send_message(text, user_id, t):\n",
    "    \n",
    "    '''\n",
    "    Sends a message to a specified user.\n",
    "    ---\n",
    "    text\n",
    "        String of what to send to user.\n",
    "    user_id\n",
    "        Twitter user ID. This is who gets the message.\n",
    "    t\n",
    "        Instance of Twython object. Contains authorization info and specifies\n",
    "        API v1.1 which allows DMs to be send.\n",
    "    '''\n",
    "    \n",
    "    t.send_direct_message(\n",
    "        event = {\"type\" : \"message_create\",\n",
    "                 \"message_create\" : {\"target\": {\"recipient_id\" : str(user_id)},\n",
    "                                     \"message_data\" : {\"text\" : text}}}\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "send_message(text = \"This is a test of the send_message() function\",\n",
    "             user_id = USER_ID,\n",
    "             t = t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above cell send this to my inbox:\n",
    "\n",
    "![Picture](images/reply_send_message_function.PNG)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Putting It All Together To Reply"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `reply()` function below reads the outputs from `store_messages()` and replies based on a few allowed parameters. The bot is not intended to be a fully-functioning chatbot, but rather an intermediate step to perform outreach before passing on potential clients and business partners to humans. As such, the allowed inputs form the list `['yes', 'no', 'help', 'stop']`. Each input illicits a specific reply from the bot.\n",
    "\n",
    "> *Note: The variables* `help_count` *and* `no_contact_list`*are unused here, but will come into play in the full class.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def reply(message_in, user_id, t):\n",
    "    \n",
    "    '''\n",
    "    This function allows the bot to talk back to users. It replies to four\n",
    "    possible, pre-specified inputs, and provides an alternative for when the\n",
    "    user input is not in the pre-specified list.\n",
    "    ---\n",
    "    message_in\n",
    "        Must be a string. This is what the bot replies to.\n",
    "    user_id\n",
    "        Twitter user ID. This is who gets the message.\n",
    "    t\n",
    "        Instance of Twython object. Contains authorization info and specifies\n",
    "        API v1.1 which allows DMs to be send.\n",
    "    '''\n",
    "    \n",
    "    message_in = clean_message(message_in)\n",
    "    \n",
    "    user_id = str(user_id)\n",
    "    \n",
    "    allowed_replies = ['yes', 'no', 'help', 'stop']\n",
    "    \n",
    "    if (len(message_in) > 1) or (len(message_in) == 0):\n",
    "        send_message(text = \"I'm sorry but I don't know what you want. Please reply only with YES, NO, HELP, or STOP.\",\n",
    "                     user_id = user_id,\n",
    "                     t = t)\n",
    "#         help_count += 1\n",
    "        return\n",
    "\n",
    "        \n",
    "    if message_in[0] == 'yes':\n",
    "        send_message(text = \"We're happy to hear it! A spokesperson will be in touch shortly :)\",\n",
    "                     user_id = user_id,\n",
    "                     t = t)\n",
    "        print(f'User at ID {user_id} is interested in collaborating! Get a human on this task at one!')\n",
    "        return\n",
    "    \n",
    "    if message_in[0] == 'no':\n",
    "        send_message(text = \"We're sad you won't be joining us. Have a nice day!\",\n",
    "                     user_id = user_id,\n",
    "                     t = t)\n",
    "        return\n",
    "\n",
    "    if message_in[0] == 'help':\n",
    "        send_message(text = \"Reply YES to show interest in a brand deal, NO to decline, HELP to see this message, and STOP to be put on our no-contact list.\",\n",
    "                     user_id = user_id,\n",
    "                     t = t)\n",
    "        return\n",
    "\n",
    "    if message_in[0] == 'stop':\n",
    "#         no_contact = True\n",
    "        return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "reply(message_in = \"help stop\", user_id = USER_ID, t=t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The cell above was a **functional test** that produced this result in my inbox:\n",
    "\n",
    "![Picture](images/reply_im_sorry.PNG)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "reply(message_in = \"yes i'd love to work with you\", user_id = USER_ID, t=t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And this cell produced this response:\n",
    "\n",
    "![Picture](images/reply_yes.PNG)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Greeting Users"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One last thing to do before assembling the bot is to create a simple function for greeting users. This will be run at the beginning of a conversation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "def greet(user_id, t, brand):\n",
    "    '''\n",
    "    Greets a user with the chatbot, introduces what brand the bot works for,\n",
    "    and offers four options for replying to the bot.\n",
    "    ---\n",
    "    text\n",
    "        Content of message. String.\n",
    "    user_id\n",
    "        User the message will go to. String.\n",
    "    t\n",
    "        Twython instance.\n",
    "    brand\n",
    "        What brand the bot is working for. String.\n",
    "    '''\n",
    "    text = f'Hi there! Wanna collaborate with {brand}? Please respond with YES, NO, HELP, or STOP.'\n",
    "    send_message(text = text, user_id = user_id, t=t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "greet(user_id = USER_ID, t=t, brand='Cool Steven Brand')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This produces:\n",
    "\n",
    "![Picture](images/reply_greet.PNG)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `Conversation` Class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As mentioned in the introduction, the preceding functions will now be combined into the class `Conversation`. In short, this class represents the interactions between **one** Twitter user and the chatbot. Calling the functions is made easier in the class versions since many of the inputs are defined on initialization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "class Conversation:\n",
    "    \n",
    "    '''\n",
    "    Class designed to be a representation of a unique conversation with one\n",
    "    individual. Takes in a Twython instance, the unique user ID, and a brand\n",
    "    that the bot is currently representing.\n",
    "    \n",
    "    Contains functions for storing, cleaning, and replying to messages.\n",
    "    ---\n",
    "    t\n",
    "        Twython instance.\n",
    "    user_id\n",
    "        Twitter user ID. String or int.\n",
    "    brand\n",
    "        Defaults to Amazon, but can be any string.\n",
    "    help_count\n",
    "        Number of times Twitter user has sent \"HELP\" to chatbot. If count\n",
    "        is >= 3, bot sets no_contact to True.\n",
    "    no_contact\n",
    "        Boolean. When True, bot will not reply to user.\n",
    "    passed_to_human\n",
    "        Whether or not the interaction has been passed on to a human employee.\n",
    "        Defaults to False. When a user says \"YES\" they want to work with brand,\n",
    "        this switches to True.\n",
    "    '''\n",
    "    \n",
    "    def __init__(self, t, user_id, brand = 'Amazon'):\n",
    "        self.t = t\n",
    "        self.user_id = str(user_id)\n",
    "        self.brand = brand\n",
    "        self.help_count = 0\n",
    "        self.messages = None\n",
    "        self.no_contact = False\n",
    "        self.passed_to_human = False\n",
    "    \n",
    "    \n",
    "    \n",
    "    def store_messages(self):\n",
    "\n",
    "        '''\n",
    "        Gets and saves all messages sent from Twitter user self.user_id to\n",
    "        the bot. Output returns a list of dictionaries, where all keys and\n",
    "        values are strings.\n",
    "        '''\n",
    "        \n",
    "        messages = self.t.get_direct_messages()\n",
    "        \n",
    "        message_list = []\n",
    "\n",
    "        for i in range(len(messages['events'])):\n",
    "\n",
    "            message = messages['events'][i]\n",
    "            sender_id = message['message_create']['sender_id']\n",
    "\n",
    "            if sender_id == self.user_id:\n",
    "                message_dict = {}\n",
    "                message_dict['time'] = message['created_timestamp']\n",
    "                message_dict['user_id'] = message['message_create']['sender_id']\n",
    "                message_dict['text'] = message['message_create']['message_data']['text']\n",
    "                message_list.append(message_dict)\n",
    "\n",
    "        self.messages = message_list\n",
    "        \n",
    "        \n",
    "\n",
    "    def clean_message(self, message):\n",
    "\n",
    "        '''\n",
    "        Cleans out punctuation and capitals from a user message. Returns the\n",
    "        string as a list of strings so that replies can be parsed easily.\n",
    "        ---\n",
    "        message\n",
    "            Must be a string, ideally as seen in store_messages()[i]['text']\n",
    "        '''\n",
    "\n",
    "        allowed_replies = ['yes', 'no', 'help', 'stop']\n",
    "\n",
    "        for i in string.punctuation:\n",
    "            message = message.replace(i, '').lower()\n",
    "\n",
    "        new_message = []\n",
    "        for word in message.split():\n",
    "            if word in allowed_replies:\n",
    "                new_message.append(word)\n",
    "\n",
    "        return new_message\n",
    "\n",
    "    \n",
    "\n",
    "    def send_message(self, text):\n",
    "\n",
    "        '''\n",
    "        Sends a message to a specified user.\n",
    "        ---\n",
    "        text\n",
    "            String of what to send to user.\n",
    "        '''\n",
    "\n",
    "        if self.no_contact == True:\n",
    "            return \n",
    "        \n",
    "        self.t.send_direct_message(\n",
    "            event = {\"type\" : \"message_create\",\n",
    "                     \"message_create\" : {\"target\": {\"recipient_id\" : self.user_id},\n",
    "                                         \"message_data\" : {\"text\" : text}}}\n",
    "        )\n",
    "        \n",
    "\n",
    "\n",
    "    def reply(self, message_in):\n",
    "        \n",
    "        '''\n",
    "        This function allows the bot to talk back to users. It replies to four\n",
    "        possible, pre-specified inputs, and provides an alternative for when the\n",
    "        user input is not in the pre-specified list.\n",
    "        ---\n",
    "        message_in\n",
    "            Must be a string. This is what the bot replies to.\n",
    "        '''\n",
    "\n",
    "        message_in = self.clean_message(message_in)\n",
    "        allowed_replies = ['yes', 'no', 'help', 'stop']\n",
    "        \n",
    "        if self.no_contact == True:\n",
    "            return\n",
    "        \n",
    "        if (len(message_in) > 1) or (len(message_in) == 0):\n",
    "            if self.help_count >= 3:\n",
    "                self.send_message(\"Looks like you're havin a hard' time bud. I'll leave you alone :/\")\n",
    "                self.no_contact = True\n",
    "            else:\n",
    "                self.send_message(\"I'm sorry but I don't know what you want. Please reply only with YES, NO, HELP, or STOP.\")\n",
    "            self.help_count += 1\n",
    "            return\n",
    "\n",
    "        if message_in[0] == 'yes':\n",
    "            self.send_message(\"We're happy to hear it! A spokesperson will be in touch shortly :)\")\n",
    "            print(f'User at ID {self.user_id} is interested in collaborating! Get a human on this task at once!')\n",
    "            self.passed_to_human = True\n",
    "            return\n",
    "\n",
    "        if message_in[0] == 'no':\n",
    "            self.send_message(\"We're sad you won't be joining us. Have a nice day!\")\n",
    "            return\n",
    "\n",
    "        if message_in[0] == 'help':\n",
    "            self.send_message(\"Reply YES to show interest in a brand deal, NO to decline, HELP to see this message, and STOP to be put on our no-contact list.\")\n",
    "            self.help_count += 1\n",
    "            return\n",
    "\n",
    "        if message_in[0] == 'stop':\n",
    "            self.no_contact = True\n",
    "            return\n",
    "    \n",
    "\n",
    "    \n",
    "    def greet(self):\n",
    "        \n",
    "        '''\n",
    "        Greets a user with the chatbot, introduces what brand the bot works for,\n",
    "        and offers four options for replying to the bot.\n",
    "        ---\n",
    "        All parameters pre-determined in __init__.\n",
    "        '''\n",
    "        \n",
    "        text = f'Hi there! Wanna collaborate with {self.brand}? Please respond with YES, NO, HELP, or STOP.'\n",
    "        self.send_message(text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Selected `Conversation` Class Examples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The new way to call these functions looks like this. Some examples were removed for privacy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Instantiate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = Twython(app_key=TWITTER_APP_KEY, \n",
    "            app_secret=TWITTER_APP_KEY_SECRET, \n",
    "            oauth_token=TWITTER_ACCESS_TOKEN, \n",
    "            oauth_token_secret=TWITTER_ACCESS_TOKEN_SECRET,\n",
    "            api_version='1.1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = Conversation(t = t, user_id = USER_ID)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `greet()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [],
   "source": [
    "c.greet()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Amazon Greet](images/reply_greet_amazon.PNG)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `.messages` and `store_messages()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [],
   "source": [
    "c.messages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No output on `messages` attribute, until..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "c.store_messages()\n",
    "c.messages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `reply()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "c.reply(\"Haha yes I'd love to\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `.no_contact`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c.no_contact"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [],
   "source": [
    "c.reply(\"stop I hate you stupid robot :(\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c.no_contact"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Demo\n",
    "\n",
    "This demo only makes sense as a live one with Twitter open in the other window. Feel free to ignore it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = Twython(app_key=TWITTER_APP_KEY, \n",
    "            app_secret=TWITTER_APP_KEY_SECRET, \n",
    "            oauth_token=TWITTER_ACCESS_TOKEN, \n",
    "            oauth_token_secret=TWITTER_ACCESS_TOKEN_SECRET,\n",
    "            api_version='1.1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = Conversation(t = t, user_id = USER_ID)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "c.greet()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "c.store_messages()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_message = c.messages[0]['text']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'yes if by collaborate you mean hehehehe ;)'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_message"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "c.reply(new_message)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:learn-env] *",
   "language": "python",
   "name": "conda-env-learn-env-py"
  },
  "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.9"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}