chapter-18-sending-email-text-messages.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "8fe5b251",
   "metadata": {},
   "source": [
    "# Chapter 18: SENDING EMAIL AND TEXT MESSAGES"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7d385dc",
   "metadata": {},
   "source": [
    "## Sending and Receiving Email with the Gmail API\n",
    "\n",
    "**`! pip install ezgmail`**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1093730",
   "metadata": {},
   "source": [
    "### Enabling the Gmail API"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "7d8cb31d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "credentials.json\r\n"
     ]
    }
   ],
   "source": [
    "!ls credentials.json"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "616e1cc2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'example@gmail.com'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "import ezgmail\n",
    "\n",
    "ezgmail.init()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82eab7e2",
   "metadata": {},
   "source": [
    "### Sending Mail from a Gmail Account"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "0ccf6d9f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import ezgmail\n",
    "\n",
    "ezgmail.send('locogab166@prolug.com', 'Subject line', 'Body of the email')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15d88cb1",
   "metadata": {},
   "source": [
    "If you want to attach files to your email, you can provide an extra list argument to the `send()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "fd7c3efd",
   "metadata": {},
   "outputs": [],
   "source": [
    "ezgmail.send('locogab166@prolug.com', 'This is a subject', 'Here are the important files:',\n",
    "             ['attachment1.jpg', 'hello.txt'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2b3848d",
   "metadata": {},
   "source": [
    "You can also supply the optional keyword arguments `cc` and `bcc` to send carbon copies and blind carbon copies:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "cc2b1979",
   "metadata": {},
   "outputs": [],
   "source": [
    "ezgmail.send('locogab166@prolug.com', 'Subject line', 'Body of the email', cc='lostulartu@gufum.com',\n",
    "             bcc='caylon.alexzander@falltrack.net,yenmuflfrnge@triots.com')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9759050",
   "metadata": {},
   "source": [
    "If you need to remember which Gmail address the *token.json* file is configured for, you can examine `ezgmail.EMAIL_ADDRESS`. Note that this variable is populated only after `ezgmail.init()` or any other EZGmail function is called:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "0a969ede",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'example@gmail.com'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import ezgmail\n",
    "\n",
    "ezgmail.init()\n",
    "ezgmail.EMAIL_ADDRESS"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23ef4bd0",
   "metadata": {},
   "source": [
    "### Reading Mail from a Gmail Account"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "fef4dc7f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Javohir - Hi! How&#39;s going Python? :) - Jan 11\n",
      "JetBrains - At JetBrains, we try to better understand how companies choose collaborative data science tools. Please help us by completing a 10-minute questionnaire.͏ ͏ ͏ ͏ ͏ ͏ ͏ ͏ ͏ ͏ ͏ ͏ ͏ ͏ ͏ ͏ ͏ ͏ ͏ ͏ ͏ ͏ ͏ ͏ ͏ - Nov 30\n"
     ]
    }
   ],
   "source": [
    "import ezgmail\n",
    "\n",
    "unreadThreads = ezgmail.unread()  # List of GmailThread objects\n",
    "ezgmail.summary(unreadThreads)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "764ad63c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(unreadThreads)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "2ab63aca",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"<GmailThread numMessages=1 snippet='Hi! How&#39;s going Python? :)'>\""
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(unreadThreads[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "a842da66",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(unreadThreads[0].messages)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "6ad3483d",
   "metadata": {},
   "outputs": [],
   "source": [
    "unreadThreads[0].messages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "7278a6ef",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Automating GMail'"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "unreadThreads[0].messages[0].subject"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "081a2dfa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Hi! How's going Python? :)\\r\\n\""
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "unreadThreads[0].messages[0].body"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "1928913f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2023, 1, 11, 19, 36, 9)"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "unreadThreads[0].messages[0].timestamp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "94b4f4d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "unreadThreads[0].messages[0].sender"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "581921f0",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "unreadThreads[0].messages[0].recipient"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7fef9928",
   "metadata": {},
   "source": [
    "Similar to the `ezgmail.unread()` function, the `ezgmail.recent()` function will return 25 most recent threads in your Gmail account. You can pass an optional `maxResults` keyword argument to change this limit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "3edffa42",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recentThreads = ezgmail.recent()\n",
    "len(recentThreads)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "d4bf39c3",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "43"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recentThreads = ezgmail.recent(maxResults=100)\n",
    "len(recentThreads)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c914a55",
   "metadata": {},
   "source": [
    "### Searching Mail from a Gmail Account"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "5ec1eeff",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "resultThreads = ezgmail.search('data science')\n",
    "len(resultThreads)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "8b27d7f6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "JetBrains - choose collaborative <b>data</b> <b>science</b> tools. Please help us by completing a 10-minute questionnaire . For your time, you will - Nov 30\n"
     ]
    }
   ],
   "source": [
    "ezgmail.summary(resultThreads)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cf65c9f",
   "metadata": {},
   "source": [
    "You can also pass any of the special search operators that you can enter into the search box to the `search` function, such as the following:\n",
    "\n",
    "**'label:UNREAD'** For unread emails\n",
    "\n",
    "**'from:al\\@inventwithpython.com'** For emails from *al\\@inventwithpython.com*\n",
    "\n",
    "**'subject:hello'** For emails with “hello” in the subject\n",
    "\n",
    "**'has:attachment'** For emails with file attachments\n",
    "\n",
    "You can view a full list of search operators at https://support.google.com/mail/answer/7190?hl=en/."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07f7ecbf",
   "metadata": {},
   "source": [
    "### Downloading Attachments from a Gmail Account"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "e0914f8c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['screen-shot-2017-11-16-at-3.54.06-pm.png']"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import ezgmail\n",
    "\n",
    "threads = ezgmail.search('database design image')\n",
    "threads[0].messages[0].attachments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a8c11bd5",
   "metadata": {},
   "outputs": [],
   "source": [
    "threads[0].messages[0].downloadAttachment('individual_attachment_name')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "0a64baf6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['screen-shot-2017-11-16-at-3.54.06-pm.png']"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "threads[0].messages[0].downloadAllAttachments(downloadFolder='email_images')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3c76bca",
   "metadata": {},
   "source": [
    "## SMTP\n",
    "\n",
    "Much as HTTP is the protocol used by computers to send web pages across the internet, *Simple Mail Transfer Protocol (SMTP)* is the protocol used for sending email. SMTP dictates how email messages should be formatted, encrypted, and relayed between mail servers and all the other details that your computer handles after you click Send."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7c237cd",
   "metadata": {},
   "source": [
    "### Sending Email\n",
    "\n",
    "**This code is just an overview of the process of sending email with Python:**\n",
    "```python\n",
    "import smtplib\n",
    "\n",
    "smtpObj = smtplib.SMTP('smtp.example.com', 587)\n",
    "smtpObj.ehlo()\n",
    "\n",
    "smtpObj.starttls()\n",
    "\n",
    "smtpObj.login('bob@example.com', 'MY_SECRET_PASSWORD')\n",
    "\n",
    "smtpObj.sendmail('bob@example.com', 'alice@example.com', 'Subject: So long.\\nDear Alice, so long and thanks for all the fish. Sincerely, Bob')\n",
    "\n",
    "smtpObj.quit()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fcc4f070",
   "metadata": {},
   "source": [
    "### Connecting to an SMTP Server\n",
    "\n",
    "**Email Providers and Their SMTP Servers**\n",
    "\n",
    "| Provider | SMTP server domain name |\n",
    "| :- | :- |\n",
    "| Gmail* | *smtp.gmail.com* |\n",
    "| Outlook.com/Hotmail.com* | *smtp-mail.outlook.com* |\n",
    "| Yahoo Mail* | *smtp.mail.yahoo.com* |\n",
    "| AT&T | *smpt.mail.att.net* (port 465) |\n",
    "| Comcast | *smtp.comcast.net* |\n",
    "| Verizon | *smtp.verizon.net* (port 465) |\n",
    "\n",
    "*Additional security measures prevent Python from being able to log in to these servers with the `smtplib` module. The EZGmail module can bypass this difficulty for Gmail accounts.\n",
    "\n",
    "The port is an integer value and will almost always be 587. It’s used by the command encryption standard, TLS."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f13ab8ca",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "smtplib.SMTP_SSL"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import smtplib\n",
    "\n",
    "# smtpObj = smtplib.SMTP('smtp.gmail.com', 587)\n",
    "## OR\n",
    "smtpObj = smtplib.SMTP_SSL('smtp.gmail.com', 465)\n",
    "type(smtpObj)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c49a5bbf",
   "metadata": {},
   "source": [
    "### Sending the SMTP “Hello” Message\n",
    "\n",
    "Once you have the `SMTP` object, call its oddly named `ehlo()` method to “say hello” to the SMTP email server. This greeting is the first step in SMTP and is important for establishing a connection to the server. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "2e9ed0da",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(250,\n",
       " b'smtp.gmail.com at your service, [213.230.102.217]\\nSIZE 35882577\\n8BITMIME\\nAUTH LOGIN PLAIN XOAUTH2 PLAIN-CLIENTTOKEN OAUTHBEARER XOAUTH\\nENHANCEDSTATUSCODES\\nPIPELINING\\nCHUNKING\\nSMTPUTF8')"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "smtpObj.ehlo()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3998ece6",
   "metadata": {},
   "source": [
    "If the first item in the returned tuple is the integer `250` (the code for “success” in SMTP), then the greeting succeeded."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76f575b8",
   "metadata": {},
   "source": [
    "### Starting TLS Encryption\n",
    "\n",
    "If you are connecting to port 587 on the SMTP server (that is, you’re using TLS encryption), you’ll need to call the `starttls()` method next. This required step enables encryption for your connection. If you are connecting to port 465 (using SSL), then encryption is already set up, and you should skip this step."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "68cfba84",
   "metadata": {},
   "outputs": [],
   "source": [
    "# smtpObj.starttls()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab8aba3e",
   "metadata": {},
   "source": [
    "The `starttls()` method puts your SMTP connection in TLS mode. The `220` in the return value tells you that the server is ready."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6414a0fd",
   "metadata": {},
   "source": [
    "### Logging In to the SMTP Server"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f1e82b1a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your email: ········\n",
      "Enter your password: ········\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(235, b'2.7.0 Accepted')"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from getpass import getpass\n",
    "email = getpass(\"Enter your email: \")\n",
    "password = getpass(\"Enter your password: \")\n",
    "\n",
    "smtpObj.login(email, password)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2d509c1",
   "metadata": {},
   "source": [
    "The `235` in the return value means authentication was successful. Python raises an `smtplib.SMTPAuthenticationError` exception for incorrect passwords."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee51eabf",
   "metadata": {},
   "source": [
    "### Sending an Email\n",
    "\n",
    "Once you are logged in to your email provider’s SMTP server, you can call the `sendmail()` method to actually send the email."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "03bb17c0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "smtpObj.sendmail('my_email_address@example.com',\n",
    "                 ['recipient@example.com'],\n",
    "                 'Subject: So long.\\nDear Alice, so long and thanks for all the fish. Sincerely, Bob')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43987ed9",
   "metadata": {},
   "source": [
    "The start of the email body string *must* begin with `'Subject: \\n'` for the subject line of the email. The `'\\n'` newline character separates the subject line from the main body of the email."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa76615a",
   "metadata": {},
   "source": [
    "### Disconnecting from the SMTP Server"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "5a7fc8f8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(221,\n",
       " b'2.0.0 closing connection k42-20020a0565123daa00b004b55da01d3csm4287734lfv.191 - gsmtp')"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "smtpObj.quit()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef4d8a4b",
   "metadata": {},
   "source": [
    "The `221` in the return value means the session is ending."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c873aff",
   "metadata": {},
   "source": [
    "## IMAP\n",
    "\n",
    "Just as SMTP is the protocol for sending email, the *Internet Message Access Protocol (IMAP)* specifies how to communicate with an email provider’s server to retrieve emails sent to your email address. Python comes with an `imaplib` module, but in fact the third-party `imapclient` module is easier to use. The full documentation is at https://imapclient.readthedocs.io/."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72c4fa40",
   "metadata": {},
   "source": [
    "### Retrieving and Deleting Emails with IMAP\n",
    "\n",
    "Finding and retrieving an email in Python is a multistep process that requires both the `imapclient` and `pyzmail` third-party modules. Just to give you an overview, here’s a full example of logging in to an IMAP server, searching for emails, fetching them, and then extracting the text of the email messages from them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "29c49394",
   "metadata": {},
   "outputs": [],
   "source": [
    "import imapclient\n",
    "import pyzmail\n",
    "\n",
    "imapObj = imapclient.IMAPClient('imap.example.com', ssl=True)\n",
    "imapObj.login('my_email_address@example.com', 'MY_SECRET_PASSWORD')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ea2e4aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "imapObj.select_folder('INBOX', readonly=True)\n",
    "UIDs = imapObj.search(['SINCE 05-Jul-2019'])\n",
    "UIDs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c4b77adf",
   "metadata": {},
   "outputs": [],
   "source": [
    "rawMessages = imapObj.fetch([40041], ['BODY[]', 'FLAGS'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6233e42d",
   "metadata": {},
   "outputs": [],
   "source": [
    "message = pyzmail.PyzMessage.factory(rawMessages[40041][b'BODY[]'])\n",
    "message.get_subject()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "acc00607",
   "metadata": {},
   "outputs": [],
   "source": [
    "message.get_addresses('from')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ddfc3e67",
   "metadata": {},
   "outputs": [],
   "source": [
    "message.get_addresses('cc')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d2b1e5f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "message.get_addresses('bcc')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9b2b4d88",
   "metadata": {},
   "outputs": [],
   "source": [
    "message.text_part != None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c3b62550",
   "metadata": {},
   "outputs": [],
   "source": [
    "message.text_part.get_payload().decode(message.text_part.charset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "51fd8793",
   "metadata": {},
   "outputs": [],
   "source": [
    "message.html_part != None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dfc309ca",
   "metadata": {},
   "outputs": [],
   "source": [
    "message.html_part.get_payload().decode(message.html_part.charset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "49958a57",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b'LOGOUT Requested'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imapObj.logout()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c240f207",
   "metadata": {},
   "source": [
    "### Connecting to an IMAP Server\n",
    "\n",
    "**Email Providers and Their IMAP Servers**\n",
    "\n",
    "| Provider | IMAP server domain name |\n",
    "| - | - |\n",
    "| Gmail* | *imap.gmail.com* |\n",
    "| Outlook.com/Hotmail.com* | *imap-mail.outlook.com* |\n",
    "| Yahoo Mail* | *imap.mail.yahoo.com* |\n",
    "| AT&T | *imap.mail.att.net* |\n",
    "| Comcast | *imap.comcast.net* |\n",
    "| Verizon | *incoming.verizon.net* |\n",
    "\n",
    "\\*Additional security measures prevent Python from being able to log in to these servers with the `imapclient` module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d78b165e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting imapclient\n",
      "  Downloading IMAPClient-2.3.1-py2.py3-none-any.whl (181 kB)\n",
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m181.3/181.3 kB\u001b[0m \u001b[31m652.6 kB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0ma \u001b[36m0:00:01\u001b[0m\n",
      "\u001b[?25hRequirement already satisfied: six in /home/javohir/miniconda3/lib/python3.9/site-packages (from imapclient) (1.16.0)\n",
      "Installing collected packages: imapclient\n",
      "Successfully installed imapclient-2.3.1\n"
     ]
    }
   ],
   "source": [
    "!pip install imapclient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "4751b0b9",
   "metadata": {},
   "outputs": [],
   "source": [
    "import imapclient\n",
    "imapObj = imapclient.IMAPClient('imap.gmail.com', ssl=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f21c37b0",
   "metadata": {},
   "source": [
    "### Logging In to the IMAP Server"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "575ca905",
   "metadata": {},
   "outputs": [],
   "source": [
    "from getpass import getpass\n",
    "email = getpass(\"Enter your email: \")\n",
    "password = getpass(\"Enter your password: \")\n",
    "\n",
    "imapObj.login(email, password)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd375dfa",
   "metadata": {},
   "source": [
    "### Searching for Email\n",
    "\n",
    "Once you’re logged on, actually retrieving an email that you’re interested in is a two-step process. First, you must select a folder you want to search through. Then, you must call the `IMAPClient` object’s `search()` method, passing in a string of IMAP search keywords."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56e7d486",
   "metadata": {},
   "source": [
    "### Project: Sending Member Dues Reminder Emails\n",
    "\n",
    "Say you have been “volunteered” to track member dues for the Mandatory Volunteerism Club. This is a truly boring job, involving maintaining a spreadsheet of everyone who has paid each month and emailing reminders to those who haven’t. Instead of going through the spreadsheet yourself and copying and pasting the same email to everyone who is behind on dues, let’s—you guessed it—write a script that does this for you."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9596cd49",
   "metadata": {},
   "source": [
    "### Sending Text Messages with SMS Email Gateways"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "cdbb5982",
   "metadata": {},
   "outputs": [],
   "source": [
    "import smtplib\n",
    "\n",
    "smtpObj = smtplib.SMTP_SSL('smtp.gmail.com', 465)\n",
    "smtpObj.ehlo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "ee649001",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your email: ········\n",
      "Enter your password: ········\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(235, b'2.7.0 Accepted')"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from getpass import getpass\n",
    "email = getpass(\"Enter your email: \")\n",
    "password = getpass(\"Enter your password: \")\n",
    "\n",
    "smtpObj.login(email, password)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "afe190a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "smtpObj.sendmail('my_email_address@example.com',\n",
    "                 ['mail_address@example.com'],\n",
    "                 'PHON_NUM@uztelecom.com')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "e12389c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "smtpObj.quit()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11f8b05e",
   "metadata": {},
   "source": [
    "### Sending Text Messages with Twilio\n",
    "\n",
    "`!pip install twilio`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "511f5f19",
   "metadata": {},
   "source": [
    "**Send message to UZB phone number:**\n",
    "\n",
    "- https://github.com/kolypto/py-smsframework\n",
    "- https://github.com/smsapi/smsapi-python-client\n",
    "- https://github.com/jookies/jasmin\n",
    "- https://rapidapi.com/collection/free-sms-apis\n",
    "- https://clicksend.com - `$0.3175`\n",
    "\n",
    "- https://twilio.com - `$0.3143`\n",
    "- https://fast2sms.com - `$0.0025`\n",
    "    - https://geeksforgeeks.org/send-sms-with-rest-using-python/\n",
    "\n",
    "- https://gatewayapi.com\n",
    "- https://d7networks.com\n",
    "- https://plivo.com\n",
    "- https://textmagic.com\n",
    "- https://messagebird.com\n",
    "- https://vonage.com"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f23526c6",
   "metadata": {},
   "source": [
    "#### Sending Text Messages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c93664d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "from twilio.rest import Client\n",
    "\n",
    "with open(\"twilio.json\", 'r') as file:\n",
    "    twilio = json.load(file)\n",
    "\n",
    "account_sid = twilio['accountSID']\n",
    "auth_token = twilio['authToken']\n",
    "client = Client(account_sid, auth_token)\n",
    "twilioPhone = twilio['twilioPhone']\n",
    "myPhone = twilio['myPhone']\n",
    "\n",
    "message = client.messages.create(\n",
    "  body=\"Hello from Twilio!\",\n",
    "  from_=twilioPhone,\n",
    "  to=myPhone\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "a9a0a785",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'+48699548792'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "message.to"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e91d9587",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'+12056712307'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "message.from_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "dac9f9b3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Sent from your Twilio trial account - Hello from Twilio!'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "message.body"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "64ffc265",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'queued'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "message.status"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "5921e269",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2023, 1, 24, 10, 6, 44, tzinfo=<UTC>)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "message.date_created"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "e5dfa800",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "message.date_sent == None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "854c52b2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Twilio.Api.V2010.MessageInstance account_sid=ACd26a4cd90c204b8fce96a9a9575b72d3 sid=SMa8b280f8c54712de85c63e81a6bf9138>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "client.messages.create(\n",
    "    body=\"Messaging from pc!\",\n",
    "    from_=twilioPhone,\n",
    "    to=myPhone\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6f3da50",
   "metadata": {},
   "source": [
    "### Project: \"Just text me\" Module "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "2cb58cf2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# textMyself - Defines the textmyself() function that texts a message passed to it as a string.\n",
    "import json\n",
    "from twilio.rest import Client\n",
    "\n",
    "with open(\"twilio.json\", 'r') as file:\n",
    "    twilio = json.load(file)\n",
    "\n",
    "accountSID = twilio['accountSID']\n",
    "authToken = twilio['authToken']\n",
    "twilioNum = twilio['twilioPhone']\n",
    "myNum = twilio['myPhone']\n",
    "twilioCli = Client(accountSID, authToken)\n",
    "\n",
    "def textMyself(message):\n",
    "    twilioCli = Client(accountSID, authToken)\n",
    "    twilioCli.messages.create(body=message, from_=twilioNum, to=myNum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "fc05bbf1",
   "metadata": {},
   "outputs": [],
   "source": [
    "textMyself(\"Task finished!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f943069",
   "metadata": {},
   "source": [
    "## Practice Projects"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13123921",
   "metadata": {},
   "source": [
    "### Random Chore Assignment Emailer\n",
    "\n",
    "Write a program that takes a list of people’s email addresses and a list of chores that need to be done and randomly assigns chores to people. Email each person their assigned chores. If you’re feeling ambitious, keep a record of each person’s previously assigned chores so that you can make sure the program avoids assigning anyone the same chore they did last time. For another possible feature, schedule the program to run once a week automatically."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20c4e416",
   "metadata": {},
   "source": [
    "### Umbrella Reminder\n",
    "\n",
    "Chapter 12 showed you how to use the `requests` module to scrape data from https://weather.gov/. Write a program that runs just before you wake up in the morning and checks whether it’s raining that day. If so, have the program text you a reminder to pack an umbrella before leaving the house."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d850276b",
   "metadata": {},
   "source": [
    "### Auto Unsubscriber\n",
    "\n",
    "Write a program that scans through your email account, finds all the unsubscribe links in all your emails, and automatically opens them in a browser. This program will have to log in to your email provider’s IMAP server and download all of your emails. You can use Beautiful Soup (covered in Chapter 12) to check for any instance where the word *unsubscribe* occurs within an HTML link tag.\n",
    "\n",
    "Once you have a list of these URLs, you can use `webbrowser.open()` to automatically open all of these links in a browser. \n",
    "\n",
    "You’ll still have to manually go through and complete any additional steps to unsubscribe yourself from these lists. In most cases, this involves clicking a link to confirm.\n",
    "\n",
    "But this script saves you from having to go through all of your emails looking for unsubscribe links. You can then pass this script along to your friends so they can run it on their email accounts. (Just make sure your email password isn’t hardcoded in the source code!)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8778dc4",
   "metadata": {},
   "source": [
    "### Controlling Your Computer Through Email\n",
    "\n",
    "Write a program that checks an email account every 15 minutes for any instructions you email it and executes those instructions automatically. For example, BitTorrent is a peer-to-peer downloading system. Using free BitTorrent software such as qBittorrent, you can download large media files on your home computer. If you email the program a (completely legal, not at all piratical) BitTorrent link, the program will eventually check its email, find this message, extract the link, and then launch qBittorrent to start downloading the file. This way, you can have your home computer begin downloads while you’re away, and the (completely legal, not at all piratical) download can be finished by the time you return home.\n",
    "\n",
    "Chapter 17 covers how to launch programs on your computer using the `subprocess.Popen()` function. For example, the following call would launch the qBittorrent program, along with a torrent file:\n",
    "\n",
    "---\n",
    "`qbProcess = subprocess.Popen(['C:\\\\Program Files (x86)\\\\qBittorrent\\\\qbittorrent.exe', 'shakespeare_complete_works.torrent'])`\n",
    "\n",
    "---\n",
    "Of course, you’ll want the program to make sure the emails come from you. In particular, you might want to require that the emails contain a password, since it is fairly trivial for hackers to fake a “from” address in emails. The program should delete the emails it finds so that it doesn’t repeat instructions every time it checks the email account. As an extra feature, have the program email or text you a confirmation every time it executes a command. Since you won’t be sitting in front of the computer that is running the program, it’s a good idea to use the logging functions (see Chapter 11) to write a text file log that you can check if errors come up.\n",
    "\n",
    "qBittorrent (as well as other BitTorrent applications) has a feature where it can quit automatically after the download completes. Chapter 17 explains how you can determine when a launched application has quit with the `wait()` method for `Popen` objects. The `wait()` method call will block until qBittorrent has stopped, and then your program can email or text you a notification that the download has completed."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.15"
  },
  "vscode": {
   "interpreter": {
    "hash": "2c7666c1320a956fa05893d10993164efa76d3af81fc7470d6f4943526f3df36"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}