Automate with Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Import Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "init_cell": true
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from pprint import pprint, pformat\n",
    "import numpy as np\n",
    "import os\n",
    "import requests, os, bs4, threading\n",
    "import datetime\n",
    "import time\n",
    "import subprocess\n",
    "import webbrowser\n",
    "import pyperclip\n",
    "from pprint import pprint\n",
    "import bs4\n",
    "import pyautogui\n",
    "\n",
    "appendixFolder = os.path.join(os.getcwd(), 'Automate_the_Boring_Stuff_2e_onlinematerials')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1 - Word/Letter count in a sentence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "message = 'It was a bright cold day in April, and the clocks were striking thirteen.'\n",
    "count = {}\n",
    "count_maj = {}\n",
    "for character in message:\n",
    "    count.setdefault(character, 0)\n",
    "    count[character] = count[character] + 1\n",
    "    \n",
    "    count_maj.setdefault(character.upper(), 0)\n",
    "    count_maj[character.upper()] = count_maj[character.upper()] + 1\n",
    "print(pformat(count_maj))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 - Tic tac toe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "theBoard = {'top-L': ' ', 'top-M': ' ', 'top-R': ' ',\n",
    "'mid-L': ' ', 'mid-M': ' ', 'mid-R': ' ',\n",
    "'low-L': ' ', 'low-M': ' ', 'low-R': ' '}\n",
    "def printBoard(board):\n",
    "    print(board['top-L'] + '|' + board['top-M'] + '|' + board['top-R'])\n",
    "    print('-+-+-')\n",
    "    print(board['mid-L'] + '|' + board['mid-M'] + '|' + board['mid-R'])\n",
    "    print('-+-+-')\n",
    "    print(board['low-L'] + '|' + board['low-M'] + '|' + board['low-R'])\n",
    "    \n",
    "turn = 'X'\n",
    "for i in range(9):\n",
    "    printBoard(theBoard)\n",
    "    print('Turn for ' + turn + '. Move on which space?')\n",
    "    move = input()\n",
    "    theBoard[move] = turn\n",
    "    if turn == 'X':\n",
    "        turn = 'O'\n",
    "    else:\n",
    "        turn = 'X'\n",
    "\n",
    "printBoard(theBoard)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 - Liste de courses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "allGuests = {'Alice': {'apples': 5, 'pretzels': 12},\n",
    "'Bob': {'ham sandwiches': 3, 'apples': 2},\n",
    "'Carol': {'cups': 3, 'apple pies': 1}}\n",
    "\n",
    "def totalBrought(guests, item):\n",
    "    numBrought = 0\n",
    "    for k, v in guests.items():\n",
    "        numBrought = numBrought + v.get(item, 0)\n",
    "    return numBrought\n",
    "\n",
    "print('Number of things being brought:')\n",
    "print(' - Apples ' + str(totalBrought(allGuests, 'apples')))\n",
    "print(' - Cups ' + str(totalBrought(allGuests, 'cups')))\n",
    "print(' - Cakes ' + str(totalBrought(allGuests, 'cakes')))\n",
    "print(' - Ham Sandwiches ' + str(totalBrought(allGuests, 'ham sandwiches')))\n",
    "print(' - Apple Pies ' + str(totalBrought(allGuests, 'apple pies')))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4 - Aligning text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def printPicnic(itemsDict, leftWidth, rightWidth):\n",
    "    print('PICNIC ITEMS'.center(leftWidth + rightWidth, '-'))\n",
    "    for k, v in itemsDict.items():\n",
    "        print(k.ljust(leftWidth, '.') + str(v).rjust(rightWidth))\n",
    "        \n",
    "picnicItems = {'sandwiches': 4, 'apples': 12, 'cups': 4, 'cookies': 8000}\n",
    "printPicnic(picnicItems, 12, 5)\n",
    "printPicnic(picnicItems, 20, 6)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5 - Wayfair | Surround word by 'string' for SQL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "init_cell": true
   },
   "outputs": [],
   "source": [
    "#! python3\n",
    "# bulletPointAdder.py - Adds Wikipedia bullet points to the start\n",
    "# of each line of text on the clipboard.\n",
    "import pyperclip\n",
    "def TurnSKUtoStringSQL(text = ''):\n",
    "    if text == '': text = pyperclip.paste()\n",
    "    # Separate lines and add stars.\n",
    "    lines = text.strip().split('\\r\\n')\n",
    "    for i in range(len(lines)): # loop through all indexes for \"lines\" list\n",
    "        lines[i] = f\"[{lines[i]}]\" # add star to each string in \"lines\" list\n",
    "    text = ', '.join(lines)\n",
    "    pyperclip.copy(text)\n",
    "    return text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "TurnSKUtoStringSQL()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6 - Searches in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### a - Searching a phone number in copied text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "init_cell": true
   },
   "outputs": [],
   "source": [
    "import re\n",
    "def CheckPhoneNumber( textToSearch = ''):\n",
    "    if textToSearch == '': textToSearch = pyperclip.paste()\n",
    "    pattern = re.compile(r'(\\d\\d\\d-)?(\\d\\d\\d-\\d\\d\\d\\d)')\n",
    "    ## ?=0or1; +=1orMore; *=0orMore\n",
    "    matches = pattern.findall(textToSearch)\n",
    "    if matches : resultat = matches#.group()\n",
    "    else : resultat = print('No phone number found in \\n',textToSearch)\n",
    "    return resultat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = '\"search(\\'My number is 415-555-4242. 415-555-4232.\\')\"'\n",
    "CheckPhoneNumber(text) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### b - Searching text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## ^ for not \n",
    "text = 'RoboCop eats baby food. BABY FOOD.'\n",
    "consonantRegex = re.compile(r'[^aeiouAEIOU]') \n",
    "nonAlphaRegex = re.compile(r'[A-Z]') #All maj\n",
    "consonantRegex.findall(text)\n",
    "nonAlphaRegex.findall(text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "beginsWithHello = re.compile(r'^Hello', re.I) ## Starts with, ignore case\n",
    "endsWithNumber = re.compile(r'\\d\\d$')  ## Ends with\n",
    "wholeStringIsNum = re.compile(r'^\\d+$') ## Only num string\n",
    "\n",
    "wholeStringIsNum.search('1234567890').group()\n",
    "beginsWithHello.search('Hello world!').group()\n",
    "endsWithNumber.search('Your number is 42').group()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "atRegex = re.compile(r'(.*)at')\n",
    ">>> atRegex.findall('The capaat in the hat /nat sat on the flat mat.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "newlineRegex = re.compile('.*', re.DOTALL)\n",
    "newlineRegex.search('Serve the public trust.\\\n",
    "    \\nProtect the innocent.\\nUphold the law.').group()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "newlineRegex = re.compile(r'\\w+')\n",
    "newlineRegex.findall('Ser3ve the public trust.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Changing strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The ? matches zero or one of the preceding group.\n",
    "\n",
    "The * matches zero or more of the preceding group.\n",
    "\n",
    "• The + matches one or more of the preceding group.\n",
    "\n",
    "• The {n} matches exactly n of the preceding group.\n",
    "\n",
    "• The {n,} matches n or more of the preceding group.\n",
    "\n",
    "• The {,m} matches 0 to m of the preceding group.\n",
    "\n",
    "• The {n,m} matches at least n and at most m of the preceding group.\n",
    "\n",
    "• {n,m}? or *? or +? performs a nongreedy match of the preceding group.\n",
    "\n",
    "• ^spam means the string must begin with spam.\n",
    "\n",
    "• spam$ means the string must end with spam.\n",
    "\n",
    "• The . matches any character, except newline characters.\n",
    "\n",
    "• \\d, \\w, and \\s match a digit, word, or space character, respectively.\n",
    "\n",
    "• \\D, \\W, and \\S match anything except a digit, word, or space character, respectively.\n",
    "\n",
    "• [abc] matches any character between the brackets (such as a, b, or c).\n",
    "\n",
    "• [^abc] matches any character that isn’t between the brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = 'Agent Alice gave the secret documents to Agent Bob.'\n",
    "namesRegex = re.compile(r'Agent \\w+')\n",
    "censoredList = namesRegex.findall(text)\n",
    "namesRegex.sub('Agent *****', text)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "agentNamesRegex = re.compile(r'(Agent) (\\w)(\\w)\\w*')\n",
    "agentNamesRegex.sub(r'\\1 \\2****', 'Agent Alice told Agent Carol that Agent Eve knew Agent Bob was a double agent.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "phoneRegex = re.compile(r'''(\n",
    "    (\\d{3}|\\(\\d{3}\\))? # area code\n",
    "    (\\s|-|\\.)? # separator\n",
    "    \\d{3} # first 3 digits\n",
    "    (\\s|-|\\.) # separator\n",
    "    \\d{4} # last 4 digits\n",
    "    (\\s*(ext|x|ext.)\\s*\\d{2,5})? # extension\n",
    "    )''', re.VERBOSE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7 - Phone And Email Extractor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pyperclip, re\n",
    "def PhoneAndEmail(texte = ''):\n",
    "    phoneRegex = re.compile(r'''(\n",
    "    (\\d{3}|\\(\\d{3}\\))? # area code\n",
    "    (\\s|-|\\.)? # separator\n",
    "    (\\d{3}) # first 3 digits\n",
    "    (\\s|-|\\.) # separator\n",
    "    (\\d{4}) # last 4 digits\n",
    "    (\\s*(ext|x|ext.)\\s*(\\d{2,5}))? # extension\n",
    "    )''', re.VERBOSE)\n",
    "\n",
    "    emailRegex = re.compile(r'''(\n",
    "        [a-zA-Z0-9._%+-]+ # username\n",
    "        @ # @ symbol\n",
    "        [a-zA-Z0-9.-]+ # domain name\n",
    "        (\\.[a-zA-Z]{2,4}) # dot-something\n",
    "    )''', re.VERBOSE)\n",
    "\n",
    "    if texte == '': texte = pyperclip.paste()\n",
    "    matches = []\n",
    "    for groups in phoneRegex.findall(texte):\n",
    "        phoneNum = '-'.join([groups[1], groups[3], groups[5]])\n",
    "        if groups[8] != '':\n",
    "            phoneNum += ' x' + groups[8]\n",
    "        matches.append(phoneNum)\n",
    "\n",
    "    for groups in emailRegex.findall(texte):\n",
    "        matches.append(groups[0])\n",
    "\n",
    "    # Copy results to the clipboard.\n",
    "    if len(matches) > 0:\n",
    "        pyperclip.copy('\\n'.join(matches))\n",
    "        print('Copied to clipboard:')\n",
    "        print('\\n'.join(matches))\n",
    "    else:\n",
    "        print('No phone numbers or email addresses found.')\n",
    "    return texte"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = 'Papa email: gtagny@yahoo.fr'\n",
    "PhoneAndEmail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "phoneRegex = re.compile(r'''(\n",
    "    (\\d{3}|\\(\\d{3}\\))? # area code\n",
    "    (\\s|-|\\.)? # separator\n",
    "    (\\d{3}) # first 3 digits\n",
    "    (\\s|-|\\.) # separator\n",
    "    (\\d{4}) # last 4 digits\n",
    "    (\\s*(ext|x|ext.)\\s*(\\d{2,5}))? # extension\n",
    "    )''', re.VERBOSE)\n",
    "\n",
    "text = '''800-420-7240\n",
    "415-863-9900\n",
    "415-863-9950 ext 221\n",
    "info@nostarch.com\n",
    "media@nostarch.com\n",
    "academic@nostarch.com\n",
    "help@nostarch.com\n",
    "info@nostarch.com\n",
    "media@nostarch.com\n",
    "academic@nostarch.com\n",
    "help@nostarch.com'''\n",
    "phoneRegex.findall(text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8 - Manipulating text files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "currentDir = os.getcwd()\n",
    "TextFile = 'AutoPython.txt'\n",
    "\n",
    "DocOuvert = open(TextFile, 'w')\n",
    "DocOuvert.write('Hey you ! \\n')\n",
    "DocOuvert.close()\n",
    "\n",
    "DocOuvert = open(TextFile, 'a')\n",
    "DocOuvert.write('Yes you over there ;) \\n')\n",
    "DocOuvert.close()\n",
    "\n",
    "DocOuvert = open(TextFile)\n",
    "Content = DocOuvert.read()\n",
    "DocOuvert.close()\n",
    "\n",
    "print(Content)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import shelve\n",
    "shelfFile = shelve.open('mydata')\n",
    "cats = ['Zophie', 'Pooka', 'Simon']\n",
    "shelfFile['cats'] = cats\n",
    "shelfFile.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "shelfFile = shelve.open('mydata')\n",
    "shelfFile['cats']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9 - Pop Quizz "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#! python3\n",
    "# randomQuizGenerator.py - Creates quizzes with questions and answers in\n",
    "# random order, along with the answer key.\n",
    "\n",
    "def CreateQuizzFiles(QuizzFolder = ''):\n",
    "    import random\n",
    "    if QuizzFolder == '' : QuizzFolder = r'Quizz Game'\n",
    "    if not os.path.exists(QuizzFolder): os.makedirs(QuizzFolder);\n",
    "    # The quiz data. Keys are states and values are their capitals.\n",
    "    capitals = {'Alabama': 'Montgomery', 'Alaska': 'Juneau', \n",
    "                'Arizona': 'Phoenix','Arkansas': 'Little Rock',\n",
    "                'California': 'Sacramento', 'Colorado': 'Denver',\n",
    "                'Connecticut': 'Hartford', 'Delaware': 'Dover', \n",
    "                'Florida': 'Tallahassee', 'Georgia': 'Atlanta', \n",
    "                'Hawaii': 'Honolulu', 'Idaho': 'Boise', \n",
    "                'Illinois':'Springfield', 'Indiana': 'Indianapolis', \n",
    "                'Iowa': 'Des Moines', 'Kansas': 'Topeka', \n",
    "                'Kentucky': 'Frankfort', 'Louisiana': 'Baton Rouge', \n",
    "                'Maine': 'Augusta', 'Maryland': 'Annapolis', \n",
    "                'Massachusetts': 'Boston', 'Michigan': 'Lansing', \n",
    "                'Minnesota': 'Saint Paul', 'Mississippi': 'Jackson', \n",
    "                'Missouri': 'Jefferson City', 'Montana': 'Helena', \n",
    "                'Nebraska': 'Lincoln', 'Nevada': 'Carson City', \n",
    "                'New Hampshire': 'Concord', 'New Jersey': 'Trenton', \n",
    "                'New Mexico': 'Santa Fe', 'New York': 'Albany', \n",
    "                'North Carolina': 'Raleigh', 'North Dakota': 'Bismarck',\n",
    "                'Ohio': 'Columbus', 'Oklahoma': 'Oklahoma City',\n",
    "                'Oregon': 'Salem', 'Pennsylvania': 'Harrisburg', \n",
    "                'Rhode Island': 'Providence', 'South Carolina': 'Columbia', \n",
    "                'South Dakota': 'Pierre', 'Tennessee': 'Nashville', \n",
    "                'Texas': 'Austin', 'Utah': 'Salt Lake City', \n",
    "                'Vermont': 'Montpelier', 'Virginia': 'Richmond', \n",
    "                'Washington': 'Olympia', 'West Virginia': 'Charleston', \n",
    "                'Wisconsin': 'Madison', 'Wyoming': 'Cheyenne'}\n",
    "\n",
    "    # Generate 35 quiz files.\n",
    "    for quizNum in range(35):\n",
    "        # Create the quiz and answer key files.\n",
    "        quiz = QuizzFolder + '\\capitalsquiz%s.txt' % (quizNum + 1)\n",
    "        quizFile = open(quiz, 'w')\n",
    "        answerKey = QuizzFolder +'\\capitalsquiz_answers%s.txt' % (quizNum + 1)\n",
    "        answerKeyFile = open(answerKey, 'w')\n",
    "        # Write out the header for the quiz.\n",
    "        quizFile.write('Name:\\n\\nDate:\\n\\nPeriod:\\n\\n')\n",
    "        quizFile.write((' ' * 20) + 'State Capitals Quiz (Form %s)' % (quizNum + 1))\n",
    "        quizFile.write('\\n\\n')\n",
    "        # Shuffle the order of the states.\n",
    "        states = list(capitals.keys())\n",
    "        random.shuffle(states)\n",
    "\n",
    "        # Loop through all 50 states, making a question for each.\n",
    "        for questionNum in range(50):\n",
    "            quizFile = open(quiz, 'w')\n",
    "            answerKeyFile = open(answerKey, 'w')\n",
    "            # Get right and wrong answers.\n",
    "            correctAnswer = capitals[states[questionNum]]\n",
    "            wrongAnswers = list(capitals.values())\n",
    "            del wrongAnswers[wrongAnswers.index(correctAnswer)]\n",
    "            wrongAnswers = random.sample(wrongAnswers, 3)\n",
    "            answerOptions = wrongAnswers + [correctAnswer]\n",
    "            random.shuffle(answerOptions)\n",
    "            # Write the question and the answer options to the quiz file.\n",
    "            quizFile.write('%s. What is the capital of %s?\\n' % (questionNum + 1, states[questionNum]))\n",
    "            for i in range(4):\n",
    "                quizFile.write(' %s. %s\\n' % ('ABCD'[i], answerOptions[i]))\n",
    "                quizFile.write('\\n')\n",
    "            # Write the answer key to a file.\n",
    "            answerKeyFile.write('%s. %s\\n' % (questionNum + 1, 'ABCD'[answerOptions.index(correctAnswer)]))\n",
    "            quizFile.close()\n",
    "            answerKeyFile.close()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "CreateQuizzFiles('Jeu')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 10 - Highlight in tables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(24)\n",
    "df = pd.DataFrame({'A': np.linspace(1, 10, 10)})\n",
    "df = pd.concat([df, pd.DataFrame(np.random.randn(10, 4), columns=list('BCDE'))],\n",
    "               axis=1)\n",
    "df.iloc[0, 2] = np.nan\n",
    "\n",
    "def highlight_max(s):\n",
    "    '''\n",
    "    highlight the maximum in a Series yellow.\n",
    "    '''\n",
    "    is_max = s == s.max()\n",
    "    return ['background-color: yellow' if v else '' for v in is_max]\n",
    "\n",
    "def color_negative_red(val):\n",
    "    \"\"\"\n",
    "    Takes a scalar and returns a string with\n",
    "    the css property `'color: red'` for negative\n",
    "    strings, black otherwise.\n",
    "    \"\"\"\n",
    "    color = 'red' if val < 0 else 'black'\n",
    "    return 'color: %s' % color\n",
    "\n",
    "df.style.\\\n",
    "    applymap(color_negative_red).\\\n",
    "    apply(highlight_max)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 11 - Wayfair | Stripping Text"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This query can be used to remove spaces surrounding your text. \n",
    "\n",
    "If no parameter is provided, it will strip the text in the clipboard (copied text), strip it and put the result back in the clipboard while give an overview of the result in the Python Interpreter. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def RemoveSpaceNextToText(text = ''): \n",
    "    if text == '': query =  pyperclip.paste()\n",
    "    else : query = text\n",
    "    FinalQuery = ''\n",
    "    for line in query.split('\\n'):\n",
    "        FinalQuery += line.strip()+'\\n'\n",
    "    pyperclip.copy(FinalQuery)\n",
    "    return FinalQuery"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "RemoveSpaceNextToText(text = '')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 12 - Wayfair | Turn list or str to Excel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def TurnListToExcel(Liste):\n",
    "    FinalText = ''\n",
    "    for elt in Liste:\n",
    "        FinalText += elt.strip()+'\\n'\n",
    "    pyperclip.copy(FinalText)\n",
    "    return FinalText"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def TurnStrToExcel(text = ''):\n",
    "    if text == '': query =  pyperclip.paste()\n",
    "    else : query = text\n",
    "    FinalText = ''\n",
    "    for line in query.split(','):\n",
    "        FinalText += line.strip()+'\\n'\n",
    "    pyperclip.copy(FinalText)\n",
    "    return FinalText"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys, pyperclip\n",
    "def TurnExcelToString(text=None):\n",
    "    if text == None: query =  pyperclip.paste()\n",
    "    else : query = text\n",
    "    lines = [element.strip() for element in query.split('\\r\\n')]\n",
    "    mot_final = ', '.join(lines)\n",
    "    pyperclip.copy(mot_final)\n",
    "    return mot_final"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "TurnExcelToString()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys, pyperclip\n",
    "def ExtractColumnNameFromSQL(text=None):\n",
    "    if text == None: query =  pyperclip.paste()\n",
    "    else : query = text\n",
    "    lines = [f\"[{element.strip()}]\" for element in query.split('\\t')]\n",
    "    mot_final = ', '.join(lines)\n",
    "    mot_final = mot_final.split('\\n')[0].replace('\\r', \"]\")\n",
    "    pyperclip.copy(mot_final)\n",
    "    return mot_final"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ExtractColumnNameFromSQL()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 13 - Wayfair | Comparing SQL data to Extranet Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Copy all tags in BSA, Remove dupes and copy to the matching capitalirized value to a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Tag = []\n",
    "Tags1 = TurnExcelToList()\n",
    "Tags2 = [item.upper().replace(\" \", \"\") for item in Tags1]\n",
    "for i in range(len(Tags1)):\n",
    "    Tag.append((Tags1[i],Tags2[i]))\n",
    "\n",
    "one = set(Tags2)\n",
    "two = sorted(list(one)); len(two)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Copy all the SQL data, and cap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sql = TurnExcelToList()\n",
    "# sql = ['ADACompliant','AdditionalToolsRequired','AdjustableBottleRacks','ANSIBIFMAe3FurnitureSustainabilityStandard','AssemblyRequired','AvoidPowerTools','BottleSizeCompatibilityL','CALGreenCompliant','CARBPhaseIICompliantformaldehydeemissions','Certifications','Color','CommercialORResidentialCertifications','CompositeWoodProductCWP','CPGCompliant','Design','DrawersIncluded','EstimatedTimetoAssemble','FIRACertified','FireRated','FSCCertified','GeneralCertificateofConformityGCC','GlossFinish','GSAApproved','InstallationRequired','ISO14000Certified','ISO14001Certified','ISO9000Certified','ISO9001Certified','ITTOCompliant','LevelofAssembly','Material','Mirrored','NaturalVariationType','NumberofDrawers','OverallDepth-FronttoBack','OverallHeight-ToptoBottom','OverallProductWeight','OverallWidth-SidetoSide','PEFCCertified','ProductType','ProductWarranty','PurposefulDistressingType','SCSCertified','Stackable','StemwareCapacity','StemwareStorage','TAACompliant','TSCATitleVICompliantformaldehydeemissions','ULListed','WeightCapacity','WineBottleCapacity','WoodSpecies']\n",
    "sql = [item.upper() for item in sql]\n",
    "sql.__len__()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compare the 2 lists and export the results to excel ! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 14 - Most recent file containing 'mot' word in the 'dossier' folder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import glob\n",
    "def most_recent_file(dossier, mot = ''):\n",
    "    # list_of_files = glob.glob( dossier + '/*.csv') # * means all if need specific format then *.csv\n",
    "    list_of_files = glob.glob( dossier + '/*') # * means all\n",
    "    files_list, latest_file = [], None\n",
    "    for file in list_of_files: \n",
    "        if '~$' in file: break\n",
    "        elif mot.upper() in file.upper() : files_list.append(file)\n",
    "    print(f\"All {len(files_list)} files containing '{mot}' in Folder {dossier}\\n\",\\\n",
    "          [os.path.basename(fichier) for fichier in files_list])\n",
    "    if len(files_list) != 0: \n",
    "        latest_file = max(files_list, key=os.path.getmtime)\n",
    "        print (f\"\\nLast {mot}Smartling File\\n\", os.path.basename(latest_file))\n",
    "    return latest_file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "MissingTags = []\n",
    "for elt in set(one - set(sql)):\n",
    "    for item in Tag:\n",
    "        if item[1] == elt: MissingTags.append(item[0])\n",
    "MissingTags = sorted(list(set(MissingTags)))\n",
    "MissingTags_str = str(MissingTags)\n",
    "TurnListToExcel(MissingTags)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = r\"G:\\Shared drives\\Language Solutions_Internal\\07 Reporting\\0-Inputs\"\n",
    "most_recent_file(path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Connect with admin priv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys, os, traceback, types\n",
    "\n",
    "def isUserAdmin():\n",
    "\n",
    "    if os.name == 'nt':\n",
    "        import ctypes\n",
    "        # WARNING: requires Windows XP SP2 or higher!\n",
    "        try:\n",
    "            return ctypes.windll.shell32.IsUserAnAdmin()\n",
    "        except:\n",
    "            traceback.print_exc()\n",
    "            print (\"Admin check failed, assuming not an admin.\")\n",
    "            return False\n",
    "    elif os.name == 'posix':\n",
    "        # Check for root on Posix\n",
    "        return os.getuid() == 0\n",
    "    else:\n",
    "        raise RuntimeError (\"Unsupported operating system for this module: %s\" % (os.name,))\n",
    "\n",
    "def runAsAdmin(cmdLine=None, wait=True):\n",
    "\n",
    "    if os.name != 'nt':\n",
    "        raise RuntimeError(\"This function is only implemented on Windows.\")\n",
    "\n",
    "    import win32api, win32con, win32event, win32process\n",
    "    from win32com.shell.shell import ShellExecuteEx\n",
    "    from win32com.shell import shellcon\n",
    "\n",
    "    python_exe = sys.executable\n",
    "    python_exe = chromeDriver_exe\n",
    "    \n",
    "    if cmdLine is None:\n",
    "        cmdLine = [python_exe] + sys.argv\n",
    "    elif type(cmdLine) not in (tuple,list):\n",
    "        raise ValueError(\"cmdLine is not a sequence.\")\n",
    "    cmd = '\"%s\"' % (cmdLine[0],)\n",
    "    # XXX TODO: isn't there a function or something we can call to massage command line params?\n",
    "    params = \" \".join(['\"%s\"' % (x,) for x in cmdLine[1:]])\n",
    "    cmdDir = ''\n",
    "    showCmd = win32con.SW_SHOWNORMAL\n",
    "    #showCmd = win32con.SW_HIDE\n",
    "    lpVerb = 'runas'  # causes UAC elevation prompt.\n",
    "\n",
    "    # print \"Running\", cmd, params\n",
    "\n",
    "    # ShellExecute() doesn't seem to allow us to fetch the PID or handle\n",
    "    # of the process, so we can't get anything useful from it. Therefore\n",
    "    # the more complex ShellExecuteEx() must be used.\n",
    "\n",
    "    # procHandle = win32api.ShellExecute(0, lpVerb, cmd, params, cmdDir, showCmd)\n",
    "\n",
    "    procInfo = ShellExecuteEx(nShow=showCmd,\n",
    "                              fMask=shellcon.SEE_MASK_NOCLOSEPROCESS,\n",
    "                              lpVerb=lpVerb,\n",
    "                              lpFile=cmd,\n",
    "                              lpParameters=params)\n",
    "\n",
    "    if wait:\n",
    "        procHandle = procInfo['hProcess']    \n",
    "        obj = win32event.WaitForSingleObject(procHandle, win32event.INFINITE)\n",
    "        rc = win32process.GetExitCodeProcess(procHandle)\n",
    "        #print \"Process handle %s returned code %s\" % (procHandle, rc)\n",
    "    else:\n",
    "        rc = None\n",
    "\n",
    "    return rc\n",
    "\n",
    "def test():\n",
    "    rc = 0\n",
    "    if not isUserAdmin():\n",
    "        print (\"You're not an admin.\", os.getpid(), \"params: \", sys.argv)\n",
    "        #rc = runAsAdmin([\"c:\\\\Windows\\\\notepad.exe\"])\n",
    "        rc = runAsAdmin()\n",
    "    else:\n",
    "        print (\"You are an admin!\", os.getpid(), \"params: \", sys.argv)\n",
    "        rc = 0\n",
    "    x = raw_input('Press Enter to exit.')\n",
    "    return rc\n",
    "\n",
    "\n",
    "# if __name__ == \"__main__\":\n",
    "#     sys.exit(test())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 15 - Replace NULL values in SQL by \"0\" by adding the 'ISNULL' function to columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Only 1 column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys, os, traceback, types\n",
    "\n",
    "def AddIsNullToText(text = ''): \n",
    "    if text == '': query =  pyperclip.paste()\n",
    "    else : query = text\n",
    "    FinalQuery = ''\n",
    "    for line in query.split('\\n'):\n",
    "        attribute = line.strip()\n",
    "        new_col = attribute.split('.')[-1]\n",
    "        FinalQuery += f\", COALESCE({attribute},0) AS {new_col}\\n\"\n",
    "    pyperclip.copy(FinalQuery)\n",
    "    return FinalQuery"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "AddIsNullToText()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List of Columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 16 - Creating a path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "cwd = os.getcwd()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "testing_csv = os.path.join(cwd, 'Testeur.csv'); testing_csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.makedirs('Test Dir')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Getting the doc name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.path.basename(testing_csv)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Getting all folders name "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "testing_csv.split(os.path.sep)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Did I plug in a USB key? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.exists('D:\\\\'): print(\"No USB Key connected !\")\n",
    "else : print(\"USB connected\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 17 - Saving Variables with the shelve Module\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import shelve\n",
    "# Saving to binary file\n",
    "shelfFile = shelve.open('mydata')\n",
    "cats = ['Zophie', 'Pooka', 'Simon']\n",
    "shelfFile['cats'] = cats\n",
    "shelfFile.close()\n",
    "# Loading saved data\n",
    "shelfFile = shelve.open('mydata')\n",
    "# List of all saved inputs\n",
    "keys = list(shelfFile.keys())\n",
    "# All values in that key\n",
    "content = shelfFile['cats']\n",
    "shelfFile.close()\n",
    "content, keys"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 18 - Copying files from a folder to another"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 376,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'C:\\\\Users\\\\tagny\\\\Documents\\\\Coding\\\\Automate the Boring Stuff with Python\\\\.ipynb_checkpoints'"
      ]
     },
     "execution_count": 376,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import shutil, os\n",
    "# os.chdir('C:\\\\')\n",
    "old_path = \".\\\\Automate the Boring Stuff with Python (2015).pdf\"\n",
    "new_path = \".\\\\.ipynb_checkpoints\"\n",
    "os.path.abspath(new_path)\n",
    "# shutil.copy(old_path, new_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Copy a whole folder\n",
    "shutil.copytree(new_path, '.\\\\backup')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Copy and rename file\n",
    "shutil.copy(old_path, \".\\\\backupfile.pdf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Delete file\n",
    "# os.unlink('backupfile.pdf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Delete Folder \n",
    "# shutil.rmtree('backup')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Put in the bin instead of perm deleting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from send2trash import send2trash\n",
    "send2trash('backupfile.pdf')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### All subfolders and files in current folder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "desktop = r\"C:\\Users\\tagny\\OneDrive\\Desktop\"\n",
    "cwd = os.getcwd()\n",
    "for folderName, subfolders, filenames in os.walk(cwd):\n",
    "    print('The current folder is ' + folderName)\n",
    "    for subfolder in subfolders:\n",
    "        print('SUBFOLDER OF ' + folderName.split('\\\\')[-1] + ' : ' + subfolder)\n",
    "    for filename in filenames:\n",
    "        print('FILE INSIDE ' + folderName.split('\\\\')[-1] + ' : '+ filename)\n",
    "    print('')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 19 - Compressing files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create zip file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mydata_files = []\n",
    "os.makedirs('My data')\n",
    "for folderName, subfolders, filenames in os.walk(cwd): break;\n",
    "for file in filenames:\n",
    "    if 'mydata' in file: \n",
    "        mydata_files.append(file)\n",
    "        shutil.copy(file, 'My data')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for folderName, subfolders, filenames in os.walk(cwd): break;\n",
    "subfolders"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import zipfile, os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "newZip = zipfile.ZipFile('example.zip', 'w')\n",
    "newZip.write('My data', compress_type=zipfile.ZIP_DEFLATED)\n",
    "newZip.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Extract all my ESMT classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['BE2016_20180830_1706.zip',\n",
       " 'DIGI_2016_20180830_1658.zip',\n",
       " 'DT2016_20180830_1707.zip',\n",
       " 'Econ_2016_20180830_1649.zip',\n",
       " 'FACC2016_20180830_1713.zip',\n",
       " 'HFI_2016_20180830_1703.zip',\n",
       " 'IF_2016_1_20180830_1650.zip',\n",
       " 'INPD_2016_20180830_1659.zip',\n",
       " 'MARGA_2016_20180830_1706.zip',\n",
       " 'MarR_2016_20180830_1648.zip',\n",
       " 'MM_2016_1_20180830_1650.zip',\n",
       " 'OB 2016_20180830_1714.zip',\n",
       " 'OPS-2016_20180830_1713.zip',\n",
       " 'RS_2016_20180830_1703.zip',\n",
       " 'SA_2016_20180830_1651.zip',\n",
       " 'SCM_2016_20180830_1651.zip',\n",
       " 'SustA_2016_20180830_1658.zip']"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "repo = r'C:\\Users\\tagny\\OneDrive\\Documents\\ESMT Classes'\n",
    "os.chdir(repo)\n",
    "os.listdir() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Read zip file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'BE2016_20180830_1706.zip'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "ename": "BadZipFile",
     "evalue": "File is not a zip file",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mOSError\u001b[0m                                   Traceback (most recent call last)",
      "\u001b[1;32mC:\\ProgramData\\Anaconda3\\lib\\zipfile.py\u001b[0m in \u001b[0;36m_RealGetContents\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m   1287\u001b[0m         \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1288\u001b[1;33m             \u001b[0mendrec\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0m_EndRecData\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfp\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1289\u001b[0m         \u001b[1;32mexcept\u001b[0m \u001b[0mOSError\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\ProgramData\\Anaconda3\\lib\\zipfile.py\u001b[0m in \u001b[0;36m_EndRecData\u001b[1;34m(fpin)\u001b[0m\n\u001b[0;32m    268\u001b[0m         \u001b[1;32mreturn\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 269\u001b[1;33m     \u001b[0mdata\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mfpin\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mread\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    270\u001b[0m     if (len(data) == sizeEndCentDir and\n",
      "\u001b[1;31mOSError\u001b[0m: [Errno 22] Invalid argument",
      "\nDuring handling of the above exception, another exception occurred:\n",
      "\u001b[1;31mBadZipFile\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-14-f25be4d5bd74>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mfile\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mos\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mlistdir\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m     \u001b[0mexampleZip\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mzipfile\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mZipFile\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfile\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      3\u001b[0m     \u001b[1;31m# # All docs inside\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m     \u001b[0mexampleZip\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnamelist\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\ProgramData\\Anaconda3\\lib\\zipfile.py\u001b[0m in \u001b[0;36m__init__\u001b[1;34m(self, file, mode, compression, allowZip64, compresslevel)\u001b[0m\n\u001b[0;32m   1223\u001b[0m         \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1224\u001b[0m             \u001b[1;32mif\u001b[0m \u001b[0mmode\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;34m'r'\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1225\u001b[1;33m                 \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_RealGetContents\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1226\u001b[0m             \u001b[1;32melif\u001b[0m \u001b[0mmode\u001b[0m \u001b[1;32min\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'w'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'x'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1227\u001b[0m                 \u001b[1;31m# set the modified flag so central directory gets written\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\ProgramData\\Anaconda3\\lib\\zipfile.py\u001b[0m in \u001b[0;36m_RealGetContents\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m   1288\u001b[0m             \u001b[0mendrec\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0m_EndRecData\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfp\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1289\u001b[0m         \u001b[1;32mexcept\u001b[0m \u001b[0mOSError\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1290\u001b[1;33m             \u001b[1;32mraise\u001b[0m \u001b[0mBadZipFile\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"File is not a zip file\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1291\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0mendrec\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1292\u001b[0m             \u001b[1;32mraise\u001b[0m \u001b[0mBadZipFile\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"File is not a zip file\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mBadZipFile\u001b[0m: File is not a zip file"
     ]
    }
   ],
   "source": [
    "for file in os.listdir() :\n",
    "    exampleZip = zipfile.ZipFile(file)\n",
    "    # # All docs inside\n",
    "    exampleZip.namelist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Extract all\n",
    "exampleZip.extractall()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fichier = 'My data/'\n",
    "# Only extract a file, location is optional\n",
    "exampleZip.extract(fichier, cwd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "spamInfo = exampleZip.getinfo(fichier)\n",
    "'Compressed file is %sx smaller!' % (round(spamInfo.file_size / spamInfo.compress_size, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " exampleZip.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 20 - Logging error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Have both on screen and in file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def OnScreenAndLogfileLogging():   \n",
    "    import logging\n",
    "\n",
    "    # create logger\n",
    "    log = logging.getLogger('myLogger')\n",
    "    log.setLevel(logging.DEBUG)\n",
    "\n",
    "    # create formatter\n",
    "    formatter = logging.Formatter(\"%(asctime)s - %(levelname)s - %(message)s\")\n",
    "\n",
    "    fh = logging.FileHandler('test.log', mode='a', encoding='utf-8')\n",
    "    fh.setLevel(logging.WARNING)\n",
    "    fh.setFormatter(formatter)\n",
    "    log.addHandler(fh)\n",
    "\n",
    "    ch = logging.StreamHandler()\n",
    "    ch.setLevel(logging.DEBUG)\n",
    "    ch.setFormatter(formatter)\n",
    "    log.addHandler(ch)\n",
    "    \n",
    "    return log"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "log = OnScreenAndLogfileLogging()\n",
    "\n",
    "# \"application\" code\n",
    "log.debug(\"debug message\")\n",
    "log.info(\"info message\")\n",
    "log.warning(\"warn message\")\n",
    "log.error(\"error message\")\n",
    "log.critical(\"critical message\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Only choose one of the 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import logging\n",
    "import sys\n",
    "\n",
    "def cleanRootLoggingParameters():\n",
    "    # Remove all handlers associated with the root logger object.\n",
    "    for handler in logging.root.handlers[:]:\n",
    "        logging.root.removeHandler(handler)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remove all handlers associated with the root logger object.\n",
    "cleanRootLoggingParameters()\n",
    "\n",
    "# Save the logs in text file\n",
    "# logging.basicConfig(filename='myProgramLog.txt', level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')\n",
    "\n",
    "# Display the logs\n",
    "logging.basicConfig(stream = sys.stderr, level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')\n",
    "\n",
    "logging.debug('Start of program')\n",
    "def factorial(n):\n",
    "    logging.debug(f'Start of factorial({n})')\n",
    "    total = 1\n",
    "    for i in range(n + 1):\n",
    "        total *= i\n",
    "        logging.debug('i is ' + str(i) + ', total is ' + str(total))\n",
    "    logging.info(f'End of factorial({n})')\n",
    "    if total == 0:  logging.warning(f'Null value detected for {total}')\n",
    "    return total\n",
    "\n",
    "print(factorial(5))\n",
    "logging.debug('End of program')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the Assertion to check wether an intial condition is fulfilled"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Setting Streets' addresses\n",
    "market_2nd = {'ns': 'green', 'ew': 'red'}\n",
    "mission_16th = {'ns': 'red', 'ew': 'green'}\n",
    "\n",
    "# Light function\n",
    "def switchLights(stoplight):\n",
    "    for key in stoplight.keys():\n",
    "        if stoplight[key] == 'green':\n",
    "            stoplight[key] = 'yellow'\n",
    "        elif stoplight[key] == 'yellow':\n",
    "            stoplight[key] = 'red'\n",
    "        elif stoplight[key] == 'red':\n",
    "            stoplight[key] = 'green'\n",
    "        assert 'red' in stoplight.values(), 'Neither light is red! ' + str(stoplight)\n",
    "\n",
    "        \n",
    "        \n",
    "switchLights(market_2nd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 21 - Storing variable across multiple notebooks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Saving in main Notebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "paul = 3\n",
    "%store paul # where df is the name of your data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Loading data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%store -r paul\n",
    "paul"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 22 - WebScrapping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 462,
   "metadata": {},
   "outputs": [],
   "source": [
    "import webbrowser\n",
    "import pyperclip\n",
    "import requests\n",
    "from pprint import pprint\n",
    "import bs4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Address to my place"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set my address\n",
    "addressGregory = \"Schlossplatz 1 Berlin 10178\"\n",
    "\n",
    "# Function to check address on gmaps\n",
    "def CheckAddressOnGoogleMaps(address=None):\n",
    "    # From clipboard if no address provided\n",
    "    if address == None: address =  pyperclip.paste()\n",
    "    webbrowser.open('https://www.google.com/maps/place/'+address)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "CheckAddressOnGoogleMaps(addressGregory)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Extract Linkedin and connect"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import webbrowser\n",
    "file = r\"C:\\Users\\tagny\\OneDrive\\Desktop\\Comments.txt\"\n",
    "f=open(file, \"r\")\n",
    "contents =f.read()\n",
    "f.close()\n",
    "all_linkedin_profiles = []\n",
    "contents_lines = contents.split()\n",
    "for sentence in contents_lines:\n",
    "    if (\"www.linkedin\" in sentence.lower() ): all_linkedin_profiles.append(sentence.lower())\n",
    "\n",
    "# for link in all_linkedin_profiles:\n",
    "#     webbrowser.open(link)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scrapping a website"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "webPage = 'http://www.gutenberg.org/cache/epub/1112/pg1112.txt'\n",
    "\n",
    "webbrowser.open(webPage)\n",
    "res = requests.get(webPage)\n",
    "# Check if the request was executed correctly\n",
    "res.raise_for_status()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check if postive response\n",
    "res.status_code == requests.codes.ok"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(res.text[:250])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We chunck the data to lighten the CPU in case of too much data, then save it in a txt file.  It’s to ensure that the requests module doesn’t eat up too much memory even if you download massive\n",
    "files."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myFile = 'RomeoAndJuliet.txt'\n",
    "playFile = open(myFile, 'wb')\n",
    "for chunk in res.iter_content(100000):\n",
    "    playFile.write(chunk)\n",
    "playFile.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Only read the fist 5 lines of the file. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(myFile) as myfile:\n",
    "    firstNlines=myfile.readlines()[0:5] #put here the interval you want\n",
    "# Display the 1st 5lines\n",
    "pprint(firstNlines)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How to parse html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "webPage = 'http://nostarch.com'\n",
    "webbrowser.open(webPage)\n",
    "res = requests.get('http://nostarch.com')\n",
    "res.raise_for_status()\n",
    "noStarchSoup = bs4.BeautifulSoup(res.text)\n",
    "type(noStarchSoup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get element by id\n",
    "noStarchSoup.select('#skip-link')\n",
    "# Get element by css\n",
    "noStarchSoup.select('div')\n",
    "# Get element by class\n",
    "noStarchSoup.select('.row')\n",
    "# Get element with span within div\n",
    "noStarchSoup.select('div span') \n",
    "# Get element with span exactly under div\n",
    "noStarchSoup.select('div > span')\n",
    "# Get CSS with attribute type\n",
    "noStarchSoup.select('input[type]')\n",
    "# Get CSS with the attribute's value\n",
    "noStarchSoup.select('input[type=\"text\"]')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "elem = noStarchSoup.select('p')[2]\n",
    "elem.attrs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(str(elem))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reading a premium article"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 479,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Gaël Courant vit une situation étouffante. Ce jeune étudiant ariégeois parti au Cameroun pour continuer ses études d’ingénieur est actuellement bloqué à Douala et espère rejoindre rapidement la France. Né à Foix en 1997, Gaël est passé par l’école de la Tour-du-Crieu, avant de rejoindre les bancs du collège Notre-Dame et le Castella de Pamiers. Bac SSI (sciences de l’ingénieur), en poche, il est actuellement en cinquième année à l’ICAM Toulouse, Gaël Courant est arrivé le 24 février au Cameroun à l’UCAC Icam de Douala pour préparer son projet de fin d’études.\n",
      "\n",
      "Il est également connu dans le monde sportif, puisqu’il pratiquera du hockey-roller, du tennis ainsi que du crossfite dans différents clubs à Pamiers. Contacté par Messenger, Gaël fait part de ses angoisses, et nous explique la situation et l’atmosphère pesante qu’il ressent.\n",
      "\n",
      "Gaël comment allez-vous ?Bof, je suis confiné dans un appartement à Douala capital économique du Cameroun où des cas de coronavirus ont déjà été signalés. La situation est très étrange car je suis toujours dans l’attente d’un vol de retour pour la France, avec toujours une incertitude mais une promesse de l’ambassadeur de pouvoir nous rapatrier d’ici la fin de la semaine. Malgré tout j’ai la chance d’avoir un jardin pour pouvoir m’aérer de temps en temps.Avez-vous de quoi manger ?Oui j’ai un peu de stocks de nourriture, mais aussi des masques et des gants pour me protéger lors de mes sorties pour faire des courses, ainsi qu’une solution hydroalcoolique.Avez-vous l’impression que les Camerounais respectent le confinement ?Pour le moment le confinement total n’a pas été décrété. Les mesures annoncées la semaine dernière, par le Premier ministre, comme la fermeture des bars, l’interdiction de rassemblement, n’ont pas été respectées, donc je ne vois pas pourquoi le confinement total serait respecté.Ressentez-vous une ambiance particulière ?C’est un peu particulier, car dès que l’on sort dans la rue on nous appelle coronavirus comme si l’on était responsable de l’épidémie, mais pour le moment ce n’est pas allé plus loin.Comment vous organisez-vous en attendant le rapatriement ?J’évite les sorties, je continue mes études en utilisant depuis lundi le télétravail fourni par mon école, et j’attends les consignes de l’ambassade pour pouvoir retrouver ma famille en Ariège au plus vite.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "link = 'https://www.ladepeche.fr/2020/03/28/bloque-au-cameroun-gael-souhaite-retrouver-sa-famille-au-plus-vite,8822294.php'\n",
    "\n",
    "res = requests.get(link)\n",
    "soup = bs4.BeautifulSoup(res.text)\n",
    "print(soup.find(\"div\", {\"class\": 'article-full__body-content article-paywall p402_premium'}).text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Googling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# searcging terms\n",
    "searchQuery = 'Gregory TAGNY'\n",
    "googleSearch = 'http://google.com/search?q='\n",
    "\n",
    "# Starting the search\n",
    "res = requests.get(googleSearch + searchQuery)\n",
    "res.raise_for_status()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "webbrowser.open(googleSearch + searchQuery)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Getting all links"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "soup = bs4.BeautifulSoup(res.text)\n",
    "linkElems = soup.select('.r a')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(linkElems)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Download all comics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "url = 'http://xkcd.com' # starting url\n",
    "os.makedirs('xkcd', exist_ok=True) # store comics in ./xkcd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Download all images from the page"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# while not url.endswith('#'):\n",
    "for i in range(5):\n",
    "    # Download the page.\n",
    "    print('Downloading page %s...' % url)\n",
    "    res = requests.get(url)\n",
    "    res.raise_for_status()\n",
    "    soup = bs4.BeautifulSoup(res.text)\n",
    "    # Find the URL of the comic image.\n",
    "    comicElem = soup.select('#comic img')\n",
    "    if comicElem == []:\n",
    "        print('Could not find comic image.')\n",
    "    else:\n",
    "        comicUrl = 'http:' + comicElem[0].get('src')\n",
    "        # Download the image.\n",
    "        print('Downloading image %s...' % (comicUrl))\n",
    "        res = requests.get(comicUrl)\n",
    "        res.raise_for_status()\n",
    "        # Save the image to ./xkcd.\n",
    "        imageFile = open(os.path.join('xkcd', os.path.basename(comicUrl)), 'wb')\n",
    "        ## Chunking the image in piecees \n",
    "        for chunk in res.iter_content(100000):\n",
    "            imageFile.write(chunk)\n",
    "        imageFile.close()\n",
    "        # Get the Prev button's url.\n",
    "        prevLink = soup.select('a[rel=\"prev\"]')[0]\n",
    "        url = 'http://xkcd.com' + prevLink.get('href')\n",
    "print('Done.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "webbrowser.open(url)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 23 - Working with excel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import openpyxl\n",
    "# Converting all numbers to excel columns names\n",
    "from openpyxl.utils import get_column_letter, column_index_from_string\n",
    "from openpyxl.styles import Font, Color, Alignment, Border, Side, colors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wb = openpyxl.Workbook()\n",
    "sheet = wb['Sheet']\n",
    "# Adding values\n",
    "sheet['A1'] = 'Hello world!'\n",
    "sheet['B1'] = 'Well done'\n",
    "#Adding Fonts\n",
    "italic24Font = Font(size=24, italic=True)\n",
    "sheet['A1'].font = italic24Font\n",
    "# Adding formulas\n",
    "sheet['A2'] = 1\n",
    "sheet['B2'] = 2\n",
    "sheet['C2'] = '=SUM(A2:B2)'\n",
    "# Merging cells\n",
    "sheet.merge_cells('A2:A3')\n",
    "# Freezing panes\n",
    "sheet.freeze_panes = 'A2'\n",
    "# Saving file\n",
    "wb.save('styled.xlsx')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 24 - Reading PDFs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import PyPDF2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pdfFileObj = open('Shakespeare2.pdf', 'rb')\n",
    "pdfReader = PyPDF2.PdfFileReader(pdfFileObj)\n",
    "totalPages = pdfReader.numPages; totalPages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Check if the pdf is password protected"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Is the file protected by PW\n",
    "password = pdfReader.isEncrypted\n",
    "if password : \n",
    "    # If yes introduce pw\n",
    "    pdfReader.decrypt('rosebud')\n",
    "else: \n",
    "    print (password)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Read pdf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Run pdf\n",
    "page1 = pdfReader.getPage(0)\n",
    "pageLast = pdfReader.getPage(totalPages-1)\n",
    "# Rotate 180 deg\n",
    "pageLast.rotateClockwise(180).rotateCounterClockwise(180)\n",
    "print(pageLast.extractText())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Write to pdf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Open PDF writing mode\n",
    "pdfWriter = PyPDF2.PdfFileWriter()\n",
    "# Write those pages\n",
    "pdfWriter.addPage(page1)\n",
    "pdfWriter.addPage(pageLast)\n",
    "# Output file\n",
    "pdfOutputFile = open('combinedPDF.pdf', 'wb')\n",
    "# Add a password\n",
    "pdfWriter.encrypt('cat')\n",
    "# Save as a pdf file\n",
    "pdfWriter.write(pdfOutputFile)\n",
    "# Close all files\n",
    "pdfOutputFile.close()\n",
    "pdfFileObj.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding a trademark"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "waterMark = open('watermark.pdf', 'rb')\n",
    "pdfWatermarkReader = PyPDF2.PdfFileReader(waterMark)\n",
    "# Merging 2 pdfs\n",
    "pageLast.mergePage(pdfWatermarkReader.getPage(0))\n",
    "# Adding password\n",
    "pdfWriter.encrypt('swordfish')\n",
    "# Save to pdf\n",
    "pdfOutputFile = open('combinedPDF_Trademark.pdf', 'wb')\n",
    "pdfWriter.write(pdfOutputFile)\n",
    "# Close all files\n",
    "pdfOutputFile.close()\n",
    "waterMark.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get all the PDF filenames.\n",
    "pdfFiles = []\n",
    "for filename in os.listdir('.'):\n",
    "    if filename.endswith('.pdf'):\n",
    "        pdfFiles.append(filename)\n",
    "# Alphabetical order also on cap\n",
    "pdfFiles.sort(key=str.lower)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pdfFiles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 25 - Reading Word"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import docx\n",
    "myWordDoc = appendix + 'demo.docx'\n",
    "docu = docx.Document(myWordDoc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# All paragraphs in the file\n",
    "print(doc.paragraphs[0].text)\n",
    "\n",
    "# All attributes in that paragraph\n",
    "doc.paragraphs[1].runs[0].text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getText(filename):\n",
    "    doc = docx.Document(filename)\n",
    "    fullText = []\n",
    "    for para in doc.paragraphs:\n",
    "        fullText.append(para.text)\n",
    "    return '\\n'.join(fullText)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(getText(myWordDoc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding some style to the file and Saving to new file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "docu = docx.Document()\n",
    "# Adding new paragraphs\n",
    "docu.add_paragraph('Hello world!')\n",
    "paraObj1 = docu.add_paragraph('This is a second paragraph.')\n",
    "# Add an image\n",
    "docu.add_picture(appendix + 'zophie.png', width=docx.shared.Inches(1),height=docx.shared.Cm(4))\n",
    "# Add another paragraph\n",
    "paraObj2 = docu.add_paragraph('This is a yet another paragraph.')\n",
    "\n",
    "# Adding one part of sentence with some style\n",
    "paraObj2.add_run(' This text is being added to the second paragraph. \\nThis').add_break() #Add line break\n",
    "paraObj2.runs[-1].italic = True\n",
    "paraObj2.add_run(' second ').add_break(docx.enum.text.WD_BREAK.PAGE) # Add a page break\n",
    "paraObj2.runs[-1].bold = True\n",
    "paraObj2.add_run('This last text is being deleted.')\n",
    "paraObj2.runs[-1].font.double_strike = True\n",
    "\n",
    "#Saving\n",
    "docu.save('restyled2.docx')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bruteforce cracking a pdf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def BruteforceCrackPDF(filename):\n",
    "    from datetime import datetime\n",
    "    import PyPDF2\n",
    "    # Import PDF\n",
    "    pdfFileObj = open(filename, 'rb')\n",
    "    pdfReader = PyPDF2.PdfFileReader(pdfFileObj)\n",
    "    # Is the file protected by PW\n",
    "    password = pdfReader.isEncrypted\n",
    "    start = datetime.now()\n",
    "    if password: \n",
    "        # If yes introduce pw\n",
    "        print('This file is protected by a password !! ')\n",
    "        print('Starting Bruteforce attack | ', datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\"))\n",
    "        # Import all keys\n",
    "        with open(appendix+'dictionary_short.txt') as file:\n",
    "            pw_list = [w.lower().strip() for w in file.readlines()]\n",
    "            for word in pw_list:\n",
    "                # Trying to decript whith each word\n",
    "                if (pdfReader.decrypt(word)):\n",
    "                    print(f\"Hacked !!! The password was '{word}' | \",datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\"))\n",
    "                    end = datetime.now()\n",
    "                    print(f\"Password hacked in {(end-start).seconds} sec(s)\")\n",
    "                    break\n",
    "                # Adding a condition if we can't find the password\n",
    "                elif pw_list.index(word) == (len(pw_list)-1): \n",
    "                    word = None\n",
    "                    print(\"Counldn't find the password for this file | \",datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\"))\n",
    "            file.close()\n",
    "    else: \n",
    "        # If the pdf is not encrypted\n",
    "        word = None\n",
    "        print (\"No need for a password for this file ;) \")\n",
    "    pdfFileObj.close()\n",
    "    print(\"**************** END ****************\")    \n",
    "    return word"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "BruteforceCrackPDF(\"combinedPDF.pdf\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 26 - Reading JSON and working with API"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import requests\n",
    "\n",
    "Location = \"Berlin\"\n",
    "url = f\"http://api.openweathermap.org/data/2.5/forecast/daily?q=<{Location}>&cnt=3\"\n",
    "response = requests.get(url)\n",
    "response.raise_for_status()\n",
    "weatherData = json.loads(response.text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 27 - Working with Dates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime\n",
    "dt = datetime.datetime.now()\n",
    "dt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Adding 1000 days\n",
    "thousandDays = datetime.timedelta(days=1000)\n",
    "dt + thousandDays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert datetime to str\n",
    "oct21st = datetime.datetime(2015, 10, 21, 16, 29, 0)\n",
    "oct21st.strftime('%Y/%m/%d %H:%M:%S')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert str to Datetime\n",
    "datetime.datetime.strptime('October 21, 2015', '%B %d, %Y')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 28 - Multithreading"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Run in parallel a function without arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import threading, time\n",
    "print('Start of program.')\n",
    "def takeANap():\n",
    "    time.sleep(5)\n",
    "    print('Wake up!')\n",
    "    \n",
    "threadObj = threading.Thread(target=takeANap)\n",
    "threadObj.start()\n",
    "print('End of program.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1+1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Run a function with arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Cats', 'Dogs', 'Frogs', sep=' & ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "threadObj = threading.Thread(target=print, args=['Cats', 'Dogs', 'Frogs'], kwargs={'sep': ' & '})\n",
    "threadObj.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Concurrency Issues"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These issues happen when threads read and write variables at the same time, causing the threads to trip over each other. \n",
    "\n",
    "To avoid them, it is advised to only use local variables in the target function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests, os, bs4, threading\n",
    "\n",
    "os.makedirs('xkcd2', exist_ok=True) # store comics in ./xkcd\n",
    "\n",
    "def downloadXkcd(nbFois):\n",
    "    # while not url.endswith('#'):\n",
    "    for i in range(nbFois):\n",
    "        url = 'https://c.xkcd.com/random/comic/'\n",
    "        # Download the page.\n",
    "        print('Downloading page %s...' % url)\n",
    "        res = requests.get(url)\n",
    "        res.raise_for_status()\n",
    "        soup = bs4.BeautifulSoup(res.text)\n",
    "        # Find the URL of the comic image.\n",
    "        comicElem = soup.select('#comic img')\n",
    "        if comicElem == []:\n",
    "            print('Could not find comic image.')\n",
    "        else:\n",
    "            comicUrl = 'http:' + comicElem[0].get('src')\n",
    "            # Download the image.\n",
    "            print('Downloading image %s...' % (comicUrl))\n",
    "            res = requests.get(comicUrl)\n",
    "            res.raise_for_status()\n",
    "            # Save the image to ./xkcd.\n",
    "            imageFile = open(os.path.join('xkcd2', os.path.basename(comicUrl)), 'wb')\n",
    "            ## Chunking the image in piecees \n",
    "            for chunk in res.iter_content(100000):\n",
    "                imageFile.write(chunk)\n",
    "            imageFile.close()\n",
    "    print('Done.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "start = datetime.datetime.now()\n",
    "downloadXkcd(15)\n",
    "end = datetime.datetime.now()\n",
    "print(f'Thread Done in {(end-start).seconds} sec(s)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "downloadThreads = []\n",
    "start = datetime.datetime.now()\n",
    "for i in range(3):\n",
    "    downloadThread = threading.Thread(target=downloadXkcd, args=[5])\n",
    "    downloadThreads.append(downloadThread)\n",
    "    downloadThread.start() \n",
    "# Wait for all threads to end.\n",
    "for downloadThread in downloadThreads:\n",
    "    downloadThread.join()\n",
    "end = datetime.datetime.now()    \n",
    "print(f'Multithread Done in {(end-start).seconds} sec(s)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 29 - Open an application with Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [],
   "source": [
    "myFile = r\"C:\\Users\\tagny\\Documents\\Coding\\Automate the Boring Stuff with Python\\Automate_the_Boring_Stuff_2e_onlinematerials\\allMyCats1.py\"\n",
    "myFile = r\"C:\\Users\\tagny\\Documents\\Coding\\Automate the Boring Stuff with Python\\Automate_the_Boring_Stuff_2e_onlinematerials\\automate-linux-requirements.txt\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "import subprocess\n",
    "calcProc = subprocess.Popen('C:\\\\Windows\\\\System32\\\\calc.exe')\n",
    "calcProc.wait()\n",
    "print(calcProc.poll())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Open Py file with Notepad\n",
    "pyReader = subprocess.Popen([r\"C:\\Program Files\\Notepad++\\notepad++.exe\", myFile])\n",
    "pyReader.wait()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Open witht the default app\n",
    "subprocess.Popen(['start', myFile], shell=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Countdown"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "alarmFile = os.path.join(appendixFolder, \"alarm.wav\")\n",
    "vlc = r\"C:\\Program Files\\VideoLAN\\VLC\\vlc.exe\"\n",
    "for i in reversed(range(60)):\n",
    "    #print(i)\n",
    "    time.sleep(1)\n",
    "subprocess.Popen([vlc, alarmFile])\n",
    "print ('Boom !!!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Alarm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Defining a function for ringing the bell\n",
    "def Alarm(heure):\n",
    "    while True :\n",
    "        if datetime.datetime.now().strftime(\"%H:%M\") == heure : break;\n",
    "        else : time.sleep(60)\n",
    "    alarmFile = os.path.join(appendixFolder, \"alarm.wav\")\n",
    "    vlc = r\"C:\\Program Files\\VideoLAN\\VLC\\vlc.exe\"\n",
    "    subprocess.Popen([vlc, alarmFile])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Running that scheduling function in parallel\n",
    "\n",
    "heure = '12:06'\n",
    "fonction = Alarm\n",
    "\n",
    "alarmThread = threading.Thread(target=fonction, args=[heure])\n",
    "alarmThread.start() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alarmThread.join()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 30 - Sending e-mails"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The default port for smtp is port 587 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Password: ········\n",
      "Email sent! |  2020-03-26 23:10:47\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(221, b'2.0.0 closing connection w67sm5252696wmb.41 - gsmtp')"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import smtplib, getpass \n",
    "email_g = 'elgr3g0ry0@gmail.com'\n",
    "greg = 'tagnyy@yahoo.fr'\n",
    "\n",
    "sender = email_g\n",
    "receivers = [greg]\n",
    "\n",
    "message = \"\"\"Subject: SMTP e-mail test\n",
    "Hi man,\n",
    "This is a test e-mail message.\n",
    "\n",
    "Best,\n",
    "Gregory\n",
    "\"\"\"\n",
    "\n",
    "# Connecting to an SMTP Server\n",
    "smtpObj = smtplib.SMTP('smtp.gmail.com', 587) # Using TLS\n",
    "# smtpObj = smtplib.SMTP_SSL('smtp.mail.yahoo.com', 465) # Use SSL in case of error\n",
    "smtpObj.ehlo()\n",
    "smtpObj.starttls()\n",
    "# Input Password\n",
    "pw_g = getpass.getpass(prompt='Password: ', stream=None) \n",
    "\n",
    "# Connect to email address\n",
    "smtpObj.login(email_g, pw_g)\n",
    "# Send email\n",
    "smtpObj.sendmail(sender, receivers, message)\n",
    "print('Email sent! | ', datetime.datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\"))\n",
    "smtpObj.quit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [],
   "source": [
    "import smtplib, getpass\n",
    "\n",
    "smtpobj = smtplib.SMTP('smtp.gmail.com', 587) # TSL\n",
    "smtpobj = smtplib.SMTP_SSL('smtp.gmail.com', 465) #SSL"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 31 - Receiving emails"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "import imapclient, imaplib, pyzmail, pprint\n",
    "# Change the max size of results \n",
    "imaplib._MAXLINE = 10e6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b'elgr3g0ry0@gmail.com authenticated (Success)'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imapObj = imapclient.IMAPClient('imap.gmail.com', ssl=True)\n",
    "imapObj.login(email_g, pw_g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[((b'\\\\HasNoChildren',), b'/', 'INBOX'),\n",
      " ((b'\\\\HasNoChildren',), b'/', 'Scheduled'),\n",
      " ((b'\\\\HasChildren', b'\\\\Noselect'), b'/', '[Gmail]'),\n",
      " ((b'\\\\Drafts', b'\\\\HasNoChildren'), b'/', '[Gmail]/Brouillons'),\n",
      " ((b'\\\\HasNoChildren', b'\\\\Trash'), b'/', '[Gmail]/Corbeille'),\n",
      " ((b'\\\\HasNoChildren', b'\\\\Important'), b'/', '[Gmail]/Important'),\n",
      " ((b'\\\\HasNoChildren', b'\\\\Sent'), b'/', '[Gmail]/Messages envoyés'),\n",
      " ((b'\\\\HasNoChildren', b'\\\\Junk'), b'/', '[Gmail]/Spam'),\n",
      " ((b'\\\\Flagged', b'\\\\HasNoChildren'), b'/', '[Gmail]/Suivis'),\n",
      " ((b'\\\\All', b'\\\\HasNoChildren'), b'/', '[Gmail]/Tous les messages')]\n"
     ]
    }
   ],
   "source": [
    "# All folders/labels in gmail account\n",
    "pprint.pprint(imapObj.list_folders())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{b'PERMANENTFLAGS': (),\n",
       " b'FLAGS': (b'\\\\Answered',\n",
       "  b'\\\\Flagged',\n",
       "  b'\\\\Draft',\n",
       "  b'\\\\Deleted',\n",
       "  b'\\\\Seen',\n",
       "  b'$NotPhishing',\n",
       "  b'$Phishing'),\n",
       " b'UIDVALIDITY': 1,\n",
       " b'EXISTS': 7328,\n",
       " b'RECENT': 0,\n",
       " b'UIDNEXT': 7483,\n",
       " b'HIGHESTMODSEQ': 642224,\n",
       " b'READ-ONLY': [b'']}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Readonly to prevent deleting some emails\n",
    "imapObj.select_folder('INBOX', readonly=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5022]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# All unseen msg from greg Wayfair and not replied to\n",
    "imapObj.search(['FROM', 'ytagny@wayfair.com', 'UNSEEN', 'UNANSWERED'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7454, 7457, 7460, 7467]"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# All message from facebook between 20.03.2020 and 25.03.2020\n",
    "UIDs2 = imapObj.search(['TEXT', 'facebook', 'SINCE', '20-Mar-2020', 'BEFORE', '25-Mar-2020'])\n",
    "UIDs2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7451]"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use the native gmail search bar to search emails\n",
    "UIDs = imapObj.gmail_search('pornhub')\n",
    "UIDs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Search the content of the emails, by their IDs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "ename": "error",
     "evalue": "command UID illegal in state LOGOUT, only allowed in states SELECTED",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31merror\u001b[0m                                     Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-161-b60845e02122>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mrawMessages\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mimapObj\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfetch\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mUIDs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;34m'BODY[]'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[1;31m#rawMessages = imapObj.fetch(UIDs2, ['BODY[]'])\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[0mpprint\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrawMessages\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\ProgramData\\Anaconda3\\lib\\site-packages\\imapclient\\imapclient.py\u001b[0m in \u001b[0;36mfetch\u001b[1;34m(self, messages, data, modifiers)\u001b[0m\n\u001b[0;32m   1222\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0muse_uid\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1223\u001b[0m             \u001b[0margs\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0minsert\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'UID'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1224\u001b[1;33m         \u001b[0mtag\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_imap\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_command\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1225\u001b[0m         \u001b[0mtyp\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdata\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_imap\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_command_complete\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'FETCH'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtag\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1226\u001b[0m         \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_checkok\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'fetch'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtyp\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdata\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\ProgramData\\Anaconda3\\lib\\imaplib.py\u001b[0m in \u001b[0;36m_command\u001b[1;34m(self, name, *args)\u001b[0m\n\u001b[0;32m    942\u001b[0m                              \u001b[1;34m\"only allowed in states %s\"\u001b[0m \u001b[1;33m%\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    943\u001b[0m                              (name, self.state,\n\u001b[1;32m--> 944\u001b[1;33m                               ', '.join(Commands[name])))\n\u001b[0m\u001b[0;32m    945\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    946\u001b[0m         \u001b[1;32mfor\u001b[0m \u001b[0mtyp\u001b[0m \u001b[1;32min\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'OK'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'NO'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'BAD'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31merror\u001b[0m: command UID illegal in state LOGOUT, only allowed in states SELECTED"
     ]
    }
   ],
   "source": [
    "rawMessages = imapObj.fetch(UIDs, ['BODY[]'])\n",
    "#rawMessages = imapObj.fetch(UIDs2, ['BODY[]'])\n",
    "\n",
    "pprint.pprint(rawMessages)\n",
    "\n",
    "messages = []\n",
    "for ID in UIDs:\n",
    "    # Extract message from each ID\n",
    "    messages.append(pyzmail.PyzMessage.factory(rawMessages[ID][b'BODY[]']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Subject : Activate your new Pornhub account\n",
      "Sender : [('Pornhub', 'noreply@pornhub.com')]\n",
      "Sender : [('elgr3g0ry0@gmail.com', 'elgr3g0ry0@gmail.com')]\n",
      "Cc : []\n",
      "Body of the email :\n",
      " You're nearly there!\r\n",
      "Your Pornhub account Letensai91 has been created. We just need to verify your email address to complete signup.\r\n",
      "\r\n",
      "https://www.pornhub.com/user/confirm?id=1295801441&code=1269014590&check=MTU4NTI3MTcyMsidZbv8cPxJDPyMkQMO_IVkBmEKy_X8EHbTGBSK66PoAW_w6HIt_MhHFR12BnfQQxi2ztCmFtvDbJVJqgjs8jg.\r\n",
      "If you didn't sign up for Pornhub, please ignore this email.\r\n",
      "\r\n",
      "This email sent from Pornhub.com to elgr3g0ry0@gmail.com\r\n",
      "To control emails from Pornhub adjust your Email Preferenceshttps://www.pornhub.com/user/prefs\r\n",
      "\r\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Taking the 1st element of the list\n",
    "message = messages[0]\n",
    "\n",
    "# Extracting subject\n",
    "print(\"Subject :\", message.get_subject())\n",
    "\n",
    "# Extracting email addresses\n",
    "print(\"Sender :\", message.get_addresses('from'))\n",
    "print(\"Sender :\", message.get_addresses('to'))\n",
    "print(\"Cc :\", message.get_addresses('cc'))\n",
    "\n",
    "# Text message in the email\n",
    "print(\"Body of the email :\\n\", message.text_part.get_payload().decode(message.text_part.charset))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('\\r\\n                                                    Verify Your Email Address', 'http://clk.secureprovide1.com/index.php?a=tracking.click&d=FyqPzzxhvmFGBKtiY%2F8sTPoIODUSUxWxfAT219Ztb9nVnEerIp4KUDBiQ6O0gcvZNHH7SaL2TPODtDeoBobG9V8GWlGWCGLjVokgzJcEHwhGn00CyYyUaYfS%2BWPm3Q60Qw5OUhFGTUqciHWtRwRZIVQEZMVL3%2FlgEvLkRbrAYaZDcmdhzNyGkOw46h7MDODHfabWTUW10V49zSfy1iDcNp6mOsdQKFjf9z32rcPl9fYIzY73hXSc0FgrEJ7nPZ%2Fo01CqtmWZl2UxlR9w7s58fQt%2FuJESsLgHzgA%2Bx3w%2B5hdTC96SXvVPXvifYxa5lssvzP9u1hbNm58PzZkujDAo4Iz%2FnMKgC3zRfJfrFixMfmwvhTedeMS6Kw%3D%3D')\n",
      "('https://www.pornhub.com/user/confirm?id=1295801441&code=1269014590&check=MTU4NTI3MTcyMsidZbv8cPxJDPyMkQMO_IVkBmEKy_X8EHbTGBSK66PoAW_w6HIt_MhHFR12BnfQQxi2ztCmFtvDbJVJqgjs8jg.', 'https://www.pornhub.com/user/confirm?id=1295801441&code=1269014590&check=MTU4NTI3MTcyMsidZbv8cPxJDPyMkQMO_IVkBmEKy_X8EHbTGBSK66PoAW_w6HIt_MhHFR12BnfQQxi2ztCmFtvDbJVJqgjs8jg.')\n",
      "('\\r\\n                                    English ▼', 'http://clk.secureprovide1.com/index.php?a=tracking.click&d=kS%2Bu6%2Fv12mX8rH9hnAhCwOCTY862Q%2BB4cZIEdQsdrJJrDEfmCQAj%2BWM4IWSMLgH7aHvY5qIMrVQwIZHxjU4s5uF9l7CvFtx0zdPmXCacySmwG7vIaAOAfqQjktSoRLTByXiT3XQRkAzuLkN5zQMpMQ1%2BlPQ7TEzFqC3Y%2FM%2FWMXZtfWHohzP9tqkR4C%2BRxf6Ado9l%2BNfOrCc%3D')\n",
      "('Select Email Language', 'http://clk.secureprovide1.com/index.php?a=tracking.click&d=ikThLQvPvrJbcPgoj17O1CQEXZc8yvKtFMDjDIhnAhtdV9CmpbtBUCG4OL%2BvXrsLlX6sx3smxJWKI6eAl8UXvNfqA98NKbHM3XloQLUUseMRSYv65AfFCwl9rLsW4u6ZXIF3PrC7N87AUWgFKqO7ZuAfCCnCLspFKwJ6HgBGPWjpgpIgZMoJG%2FNZDNmFpUBoXDSH8f2a%2Fyg%3D')\n",
      "('elgr3g0ry0@gmail.com', 'elgr3g0ry0@gmail.com')\n",
      "('Email Preferences', 'https://www.pornhub.com/user/prefs')\n",
      "('Pornhub Blog', 'https://www.pornhub.com/blog')\n",
      "('Pornhub Twitter', 'https://www.twitter.com/pornhub')\n",
      "('Privacy Policy', 'https://www.pornhub.com/information#privacy')\n",
      "('Contact Support', 'https://www.pornhub.com/support')\n"
     ]
    }
   ],
   "source": [
    "# Html message in the email\n",
    "html_email = bs4.BeautifulSoup(message.html_part.get_payload().decode(message.html_part.charset))\n",
    "allLinks = [(link.text, link['href']) for link in html_email.find_all(href=True)]\n",
    "for link in allLinks:\n",
    "    print(link)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Logout\n",
    "imapObj.logout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 32 - Sending messages with python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "accountSID = 'AC9f9bc23d7923697565fbefc29396ba3b'\n",
    "authToken = '3a2a141b7760e8fbdebfb65ef5f6eff8'\n",
    "myTwilioNumber = '+12034968109'\n",
    "myCellPhone = '+33752599593'\n",
    "pwt = \"#WhatsAppAPI2020\"\n",
    "from twilio.rest import Client\n",
    "\n",
    "# Send SMS to my number\n",
    "def textmyself(SMS):\n",
    "    twilioCli = Client(accountSID, authToken)\n",
    "    message = twilioCli.messages.create(body=SMS,\n",
    "                                        from_=myTwilioNumber,\n",
    "                                        to=myCellPhone)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [],
   "source": [
    "textmyself(\"Toto, tu as forget ton parapluie\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I created a local file with this function which can be imported with the following command: \n",
    "**from textmyself import textmyself**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 33 - Manipulating images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(210, 105, 30, 255)"
      ]
     },
     "execution_count": 252,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from PIL import ImageColor, Image\n",
    "\n",
    "ImageColor.getcolor('Chocolate', 'RGBA')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Open the image file\n",
    "catIm = Image.open(appendixFolder+'\\zophie.png')\n",
    "# Save dimensions\n",
    "(width, height) = catIm.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {},
   "outputs": [],
   "source": [
    "# File name\n",
    "os.path.basename(catIm.filename)\n",
    "# File Path\n",
    "catIm.filename\n",
    "# File extension\n",
    "catIm.format\n",
    "# catIm.format_description\n",
    "# Save file\n",
    "catIm.save('zophie.jpg')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "metadata": {},
   "outputs": [],
   "source": [
    "im = Image.new('RGBA', (100, 200), 'purple')\n",
    "im.save('purpleImage.png')\n",
    "im2 = Image.new('RGBA', (20, 20))\n",
    "im2.save('transparentImage.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cropping images includes the left column and top row of pixels but only goes up to and does not include the right column and bottom row of pixels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Crop img \n",
    "croppedIm = catIm.crop((335, 345, 565, 560))\n",
    "croppedIm.save('cropped.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make a copy of the image\n",
    "catCopyIm = catIm.copy()\n",
    "# Cropping\n",
    "faceIm = catIm.crop((335, 345, 565, 560))\n",
    "# Pasting the cropped img\n",
    "catCopyIm.paste(faceIm, (0, 0))\n",
    "catCopyIm.paste(faceIm, (400, 500))\n",
    "catCopyIm.save('pasted.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Paste cropped image on chocolate background"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {},
   "outputs": [],
   "source": [
    "im2 = Image.new('RGBA', (500,500), \"chocolate\")\n",
    "catCopyIm = catIm.copy()\n",
    "catCopyIm = catCopyIm.crop((335, 345, 565, 560))\n",
    "im2.paste(catCopyIm, (143,135))\n",
    "im2.save('chocolatePaste.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Redim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {},
   "outputs": [],
   "source": [
    "width, height = catIm.size\n",
    "quartersizedIm = catIm.resize((int(width / 2), int(height / 2)))\n",
    "quartersizedIm.save('quartersized.png')\n",
    "svelteIm = catIm.resize((width, height + 300))\n",
    "svelteIm.save('svelte.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Rotate the pic\n",
    "## Expand helps you to make the rotated picture to fit the whole screen\n",
    "catIm.rotate(90, expand=True).save('rotated90.png')\n",
    "# Flip picture in mirror effect\n",
    "catIm.transpose(Image.FLIP_LEFT_RIGHT).save('horizontal_flip.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0\n",
      "0 215\n",
      "0 430\n",
      "0 645\n",
      "0 860\n",
      "0 1075\n",
      "230 0\n",
      "230 215\n",
      "230 430\n",
      "230 645\n",
      "230 860\n",
      "230 1075\n",
      "460 0\n",
      "460 215\n",
      "460 430\n",
      "460 645\n",
      "460 860\n",
      "460 1075\n",
      "690 0\n",
      "690 215\n",
      "690 430\n",
      "690 645\n",
      "690 860\n",
      "690 1075\n"
     ]
    }
   ],
   "source": [
    "# Create Mozaique\n",
    "width, height = catIm.size\n",
    "faceIm = catIm.crop((335, 345, 565, 560))\n",
    "catCopyTwo = catIm.copy()\n",
    "\n",
    "# All dims\n",
    "catImWidth, catImHeight = catIm.size\n",
    "faceImWidth, faceImHeight = faceIm.size\n",
    "\n",
    "# Pasting as a mozaique\n",
    "for left in range(0, catImWidth, faceImWidth):\n",
    "    for top in range(0, catImHeight, faceImHeight):\n",
    "        print(left, top)\n",
    "        catCopyTwo.paste(faceIm, (left, top))\n",
    "catCopyTwo.save('tiled.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 0, 0, 0)\n",
      "(210, 210, 210, 255)\n"
     ]
    }
   ],
   "source": [
    "# Create Transparent background\n",
    "im = Image.new('RGBA', (100, 100))\n",
    "print(im.getpixel((0, 0)))\n",
    "\n",
    "# Fill top half with gray\n",
    "for x in range(100):\n",
    "    for y in range(50):\n",
    "        im.putpixel((x, y), (210, 210, 210))\n",
    "\n",
    "# Fill other half with dark grey\n",
    "for x in range(100):\n",
    "    for y in range(50,100):\n",
    "        im.putpixel((x,y), ImageColor.getcolor('Chocolate', 'RGBA'))\n",
    "print(im.getpixel((0, 0)))\n",
    "im.save('putPixel.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Function : Resizing a picture"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 441,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ResizeImage(ImagePath, size, TargetFolder=None):\n",
    "    os.makedirs('Resized Pictures', exist_ok=True)\n",
    "    # Import image object\n",
    "    ImageObject = Image.open(ImagePath)\n",
    "    width, height = ImageObject.size\n",
    "    print(f\"Intitial size : {ImageObject.size}\")\n",
    "    image = os.path.splitext(os.path.basename(ImagePath))\n",
    "    coef = 1\n",
    "    if width > height:\n",
    "        if width > size:\n",
    "            coef = (width/size)\n",
    "        elif height > size:\n",
    "            coef = (height/size)\n",
    "    elif height > width:\n",
    "        if height > size:\n",
    "            coef = (height/size)\n",
    "        elif width > size:\n",
    "            coef = (width/size)\n",
    "    width, height = int(width/coef), int(height/coef)\n",
    "    # Resize image\n",
    "    print(\"Resizing '%s' ...\" % (image[0]+image[1]))\n",
    "    ImageObject = ImageObject.resize((width, height))\n",
    "    print(f\"Final size : {ImageObject.size}\")\n",
    "    # Saving final image\n",
    "    try : \n",
    "        ImageObject.save(TargetFolder)\n",
    "    except: \n",
    "        print(\"Invalid output folder! Saving in folder 'Resized Pictures'\")\n",
    "        TargetFolder = os.path.join('Resized Pictures', image[0]+str(size)+image[1])\n",
    "        ImageObject.save(TargetFolder)\n",
    "    print('Resizing Completed!')\n",
    "    return TargetFolder    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 445,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Intitial size : (808, 768)\n",
      "Resizing 'catlogo.png' ...\n",
      "Final size : (100, 95)\n",
      "Invalid output folder! Saving in folder 'Resized Pictures'\n",
      "Resizing Completed!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Resized Pictures\\\\catlogo100.png'"
      ]
     },
     "execution_count": 445,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ResizeImage(os.path.join(appendixFolder,'catlogo.png'), 100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Project : Adding a logo to all images in directory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 461,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Intitial size : (808, 768)\n",
      "Resizing 'catlogo.png' ...\n",
      "Final size : (50, 47)\n",
      "Invalid output folder! Saving in folder 'Resized Pictures'\n",
      "Resizing Completed!\n",
      "Resizing zophie.png ...\n",
      "Adding logo to zophie.png...\n"
     ]
    }
   ],
   "source": [
    "# Creating an output folder\n",
    "os.makedirs('withLogo', exist_ok=True)\n",
    "SQUARE_FIT_SIZE = 300\n",
    "\n",
    "# Moving resized logo file to output folder\n",
    "original_logo = ResizeImage(os.path.join(appendixFolder,'catlogo.png'), 50)\n",
    "LOGO_FILENAME = r\"withLogo\\catlogo.png\"\n",
    "shutil.copy(original_logo, LOGO_FILENAME)\n",
    "\n",
    "# Loading LogoFile\n",
    "logoIm = Image.open(LOGO_FILENAME)\n",
    "logoWidth, logoHeight = logoIm.size\n",
    "\n",
    "# Retrieving all images in folder\n",
    "image_list = []\n",
    "for file in os.listdir(appendixFolder):\n",
    "    if file != os.path.basename(LOGO_FILENAME) and file.lower().endswith('.png' or '.jpg'): \n",
    "        image_list.append(file)\n",
    "\n",
    "# Resizing big images > 300px\n",
    "for img in image_list:\n",
    "    ImageObject = Image.open(os.path.join(appendixFolder, img))\n",
    "    width, height = ImageObject.size\n",
    "    # Croping only too big files\n",
    "    coef = 1\n",
    "    if width > height:\n",
    "        if width > SQUARE_FIT_SIZE:\n",
    "            coef = (width/SQUARE_FIT_SIZE)\n",
    "        elif height > SQUARE_FIT_SIZE:\n",
    "            coef = (height/SQUARE_FIT_SIZE)\n",
    "    elif height > width:\n",
    "        if height > SQUARE_FIT_SIZE:\n",
    "            coef = (height/SQUARE_FIT_SIZE)\n",
    "        elif width > SQUARE_FIT_SIZE:\n",
    "            coef = (width/SQUARE_FIT_SIZE)\n",
    "    width, height = int(width/coef), int(height/coef)\n",
    "    # Resize image\n",
    "    print('Resizing %s ...' % (img))\n",
    "    ImageObject = ImageObject.resize((width, height))\n",
    "    # Add logo\n",
    "    print('Adding logo to %s...' % (img))\n",
    "    ImageObject.paste(logoIm, (width - logoWidth, height - logoHeight), logoIm)\n",
    "    ImageObject.save(os.path.join('withLogo', img))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Drawing with python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 458,
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import Image, ImageDraw\n",
    "im = Image.new('RGBA', (200, 200), 'white')\n",
    "draw = ImageDraw.Draw(im)\n",
    "draw.line([(0, 0), (199, 0), (199, 199), (0, 199), (50, 50), (0, 0)], fill='black')\n",
    "draw.rectangle((20, 30, 60, 60), fill='blue')\n",
    "draw.ellipse((120, 30, 160, 60), outline='blue', fill='red')\n",
    "draw.polygon(((57, 87), (79, 62), (94, 85), (120, 90), (103, 113)),fill='brown')\n",
    "for i in range(100, 200, 10):\n",
    "    draw.line([(i, 0), (200, i - 100)], fill='green')\n",
    "im.save('drawing.png')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Writing wth Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 460,
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import ImageFont\n",
    "from PIL import Image, ImageDraw, ImageFont\n",
    "import os\n",
    "\n",
    "im = Image.new('RGBA', (200, 200), 'white')\n",
    "draw = ImageDraw.Draw(im)\n",
    "draw.text((20, 150), 'Hello', fill='purple')\n",
    "fontsFolder = r'C:\\Windows\\Fonts' # e.g. ‘/Library/Fonts’\n",
    "arialFont = ImageFont.truetype(os.path.join(fontsFolder, 'arial.ttf'), 32)\n",
    "draw.text((100, 150), 'Howdy', fill='gray', font=arialFont)\n",
    "im.save('text.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 34 - Controlling mouse"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 594,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pyautogui\n",
    "# Pause every second before excecuting GUI tasks\n",
    "pyautogui.PAUSE = 1\n",
    "# Putting the cursor on (0,0) crashes the tool\n",
    "pyautogui.FAILSAFE = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Duration** here represents how long it will take the cursor to go from point A to B. Default value is 0, meaning teleportation. \n",
    "\n",
    "We can either move the mouse by indicating the geographical coordinates or by going from the current location.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 716,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Size(width=2256, height=1504)"
      ]
     },
     "execution_count": 716,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Screen resolution\n",
    "pyautogui.size()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 487,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Move the mouse indicating the coordinates\n",
    "for i in range(4):\n",
    "    pyautogui.moveTo(100, 100, duration=0.25)\n",
    "    pyautogui.moveTo(200, 100, duration=0.25)\n",
    "    pyautogui.moveTo(200, 200, duration=0.25)\n",
    "    pyautogui.moveTo(100, 200, duration=0.25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 490,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(3):\n",
    "    # From current mouse position\n",
    "    pyautogui.moveRel(100, 0, duration=0.25)\n",
    "    pyautogui.moveRel(0, 100, duration=0.25)\n",
    "    pyautogui.moveRel(-100, 0, duration=0.25)\n",
    "    pyautogui.moveRel(0, -100, duration=0.25)\n",
    "# Get the current postion of the cursor\n",
    "pyautogui.position()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cursor Tracker"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 680,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "# timeout variable can be omitted, if you use specific value in the while condition\n",
    "def WhereIsTheCursor(timeout=10):    \n",
    "    timeout_start = time.time()\n",
    "    print('Double press \"I\" to quit.')\n",
    "    try:\n",
    "        while time.time() < timeout_start + timeout:\n",
    "            # Get and print the mouse coordinates.\n",
    "            x, y = pyautogui.position()\n",
    "            pixelColor = pyautogui.screenshot().getpixel((x, y))\n",
    "            positionStr = f\"X: {str(x).rjust(4)} | Y: {str(y).rjust(4)} | RGB {pixelColor}\"\n",
    "#             positionStr = 'X: ' + str(x).rjust(4) + ' | Y: ' + str(y).rjust(4)\n",
    "            print(positionStr, end='\\r')\n",
    "            time.sleep(0.5)\n",
    "        print('\\nTime up !!')\n",
    "    except KeyboardInterrupt:\n",
    "        print('\\Interrupted.')\n",
    "    return x, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 684,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Double press \"I\" to quit.\n",
      "X: 1016 | Y: 1104 | RGB (247, 247, 247)\n",
      "Time up !!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(1016, 1104)"
      ]
     },
     "execution_count": 684,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "WhereIsTheCursor(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Clicking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 635,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Select where you want to click and with which button\n",
    "pyautogui.click(x, y, button='right')\n",
    "pyautogui.click(x-5, y)\n",
    "\n",
    "# Hold mouse down or up\n",
    "pyautogui.mouseDown()\n",
    "pyautogui.mouseUp()\n",
    "\n",
    "# Drag to the left\n",
    "pyautogui.dragRel(-100, -100, 0.5)\n",
    "# Drag back\n",
    "pyautogui.dragTo(100, 0, 0.5)\n",
    "# Double-click\n",
    "pyautogui.doubleClick(x, y)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Painting a labyrinth"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 665,
   "metadata": {},
   "outputs": [],
   "source": [
    "x,y = (674, 247)\n",
    "# Open Paint\n",
    "subprocess.Popen(\"C:\\WINDOWS\\system32\\mspaint.exe\") \n",
    "time.sleep(2)\n",
    "pyautogui.click(x,y) # click to put drawing program in focus\n",
    "pyautogui.moveTo(650, 450)\n",
    "distance = 200\n",
    "while distance > 180:\n",
    "    pyautogui.dragRel(distance, 0, duration=0.2) # move right\n",
    "    distance = distance - 5\n",
    "    pyautogui.dragRel(0, distance, duration=0.2) # move down\n",
    "    pyautogui.dragRel(-distance, 0, duration=0.2) # move left\n",
    "    distance = distance - 5\n",
    "    pyautogui.dragRel(0, -distance, duration=0.2) # move up\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Scrolling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 662,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Scroll up\n",
    "time.sleep(2); pyautogui.scroll(200)\n",
    "# Scroll down\n",
    "time.sleep(2); pyautogui.scroll(100)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Taking a screenshot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 685,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 685,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "im = pyautogui.screenshot()\n",
    "im.save('screenshot.png')\n",
    "colour = im.getpixel((50, 200))\n",
    "# Check wether color matches What we expected\n",
    "pyautogui.pixelMatchesColor(50, 200, colour)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Find an image on the screen. We can store it in a list() in case we have multiple matches."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 689,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Box(left=1999, top=185, width=81, height=27)"
      ]
     },
     "execution_count": 689,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "buttonMatch = pyautogui.locateOnScreen('Button.png')\n",
    "buttonMatch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 692,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Point(x=2039, y=198)"
      ]
     },
     "execution_count": 692,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Find the middle of the coordinates\n",
    "buttonMatch = pyautogui.center(buttonMatch)\n",
    "buttonMatch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 694,
   "metadata": {},
   "outputs": [],
   "source": [
    "pyautogui.click(buttonMatch)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 35 - Controlling Keyboard"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some slower applications can’t process keystrokes fast enough to keep up "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 714,
   "metadata": {},
   "outputs": [],
   "source": [
    "pyautogui.click(646, 1070); \n",
    "# 0.1 secs between strikes\n",
    "## Writing strings\n",
    "pyautogui.typewrite(f\"print('Woooow !')\", 0.1)\n",
    "# Writing keywords\n",
    "pyautogui.typewrite(['Enter'])\n",
    "# Simulating keyboard holding button\n",
    "pyautogui.keyDown('shift'); pyautogui.press('4'); pyautogui.keyUp('shift')\n",
    "# Shortcut for the same \n",
    "pyautogui.hotkey('shift', '5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**moveTo(x, y)** Moves the mouse cursor to the given x and y coordinates.\n",
    "\n",
    "**moveRel(xOffset, yOffset)** Moves the mouse cursor relative to its current position.\n",
    "\n",
    "**dragTo(x, y)** Moves the mouse cursor while the left button is held down.\n",
    "\n",
    "**dragRel(xOffset, yOffset)** Moves the mouse cursor relative to its current position while the left button is held down.\n",
    "\n",
    "**click(x, y, button)** Simulates a click (left button by default).\n",
    "\n",
    "**rightClick()** Simulates a right-button click.\n",
    "\n",
    "**middleClick()** Simulates a middle-button click.\n",
    "\n",
    "**doubleClick()** Simulates a double left-button click.\n",
    "\n",
    "**mouseDown(x, y, button)** Simulates pressing down the given button at the position x, y.\n",
    "\n",
    "**mouseUp(x, y, button)** Simulates releasing the given button at the position x, y.\n",
    "\n",
    "**scroll(units)** Simulates the scroll wheel. A positive argument scrolls up; a negative argument scrolls down.\n",
    "\n",
    "**typewrite(message)** Types the characters in the given message string.\n",
    "\n",
    "**typewrite([key1, key2, key3])** Types the given keyboard key strings.\n",
    "\n",
    "**press(key)** Presses the given keyboard key string.\n",
    "\n",
    "**keyDown(key)** Simulates pressing down the given keyboard key.\n",
    "\n",
    "**keyUp(key)** Simulates releasing the given keyboard key.\n",
    "\n",
    "**hotkey([key1, key2, key3])** Simulates pressing the given keyboard key strings down in order and then releasing them in reverse order.\n",
    "\n",
    "**screenshot()** Returns a screenshot as an Image object. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Initialization Cell",
  "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.7.4"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "1253px",
    "left": "648px",
    "top": "251px",
    "width": "298.635px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}