diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..085c4fe --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +*.pyc +*.db diff --git a/code/misc/python/scripts/AI/.python-version b/code/misc/python/scripts/AI/.python-version new file mode 100644 index 0000000..bd28b9c --- /dev/null +++ b/code/misc/python/scripts/AI/.python-version @@ -0,0 +1 @@ +3.9 diff --git a/code/misc/python/scripts/AI/embeddings.ipynb b/code/misc/python/scripts/AI/embeddings.ipynb new file mode 100644 index 0000000..e69de29 diff --git a/code/misc/python/scripts/ANKI Card templates.ipynb b/code/misc/python/scripts/ANKI Card templates.ipynb new file mode 100644 index 0000000..c59b46d --- /dev/null +++ b/code/misc/python/scripts/ANKI Card templates.ipynb @@ -0,0 +1,132 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Latex Anki Card - Bulk Division" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "def Form1(dividend,divisor):\n", + " tmp=\"\"\"Solve [latex]\\mydiv {{{div}}}{{{divid}}} [/latex]\"\"\".format(div=divisor,divid=dividend)\n", + " return tmp\n", + "\n", + "def Form2(dividend,divisor):\n", + " tmp=\"\"\"Solve [$] {{{divid}}} \\div {{{div}}} [/$]\"\"\".format(div=divisor,divid=dividend)\n", + " return tmp\n", + "\n", + "def Form3(dividend,divisor):\n", + " tmp=\"\"\"Solve [$] \\\\frac {{{divid}}}{{{div}}} [/$]\"\"\".format(div=divisor,divid=dividend)\n", + " return tmp\n", + "\n", + "def Back(dividend,divisor):\n", + " ans=dividend/divisor\n", + " rounded1=round(ans,1)\n", + " rounded2=round(ans,2)\n", + " rounded3=round(ans,3)\n", + " temp=\"\"\" Answer(3 D.P):\\n\n", + " {ans3} \\n\\n\n", + " Working:\\n\n", + " [$]\\longdivision[stage=5] {{{divid}}}{{{div}}}[/$]\n", + "\n", + " Check Answer:\\n\n", + " [$]\\opmul{{{ans3}}}{{{div}}} \\quad \\opmul{{{ans2}}}{{{div}}} \n", + " [/$]\\n \"\"\".format(ans2=rounded2, ans3=rounded3, divid=dividend, div=divisor)\n", + " return temp\n", + "\n", + "dividends=[1023, 300, 300,300, 3520, 3932.5, 4732, 532.5,532.5,532.5,423, 4750]\n", + "divisor=[9, 2000, 2475, 400, 10, 45,9,10,15,60,3,8]\n", + "\n", + "lsf1=[]\n", + "lsf2=[]\n", + "lsf3=[]\n", + "lsb=[]\n", + "lst=[]\n", + "for divid, div in zip(dividends,divisor):\n", + " lsf1.append (Form1(divid,div))\n", + " lsf2.append (Form2(divid,div))\n", + " lsf3.append (Form3(divid,div))\n", + " lsb.append (Back(divid,div))\n", + " lst.append ('Division')\n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "location=Path('/home/dl92/SynologyDrive/Kids/Miri/FlashCards')\n", + "fname=location / 'Division.csv'\n", + "pd.DataFrame({'Form1':lsf1,'Form2':lsf2,'Form3':lsf3,'Back':lsb,'Tag':lst}).to_csv(fname,header=False, index=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.6.9 64-bit", + "language": "python", + "name": "python36964bit5aad4b8392a24ab49b91cfc5ab558ab3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.9" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/code/misc/python/scripts/Anki/workflow.ipynb b/code/misc/python/scripts/Anki/workflow.ipynb new file mode 100644 index 0000000..09cf9b7 --- /dev/null +++ b/code/misc/python/scripts/Anki/workflow.ipynb @@ -0,0 +1,212 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'result': 1725747180059, 'error': None}\n" + ] + } + ], + "source": [ + "import requests\n", + "import json\n", + "\n", + "# URL for AnkiConnect\n", + "ANKI_CONNECT_URL = 'http://localhost:8765'\n", + "\n", + "def add_note(deck_name, model_name, fields, tags=[]):\n", + " # Define the note structure\n", + " note = {\n", + " \"deckName\": deck_name,\n", + " \"modelName\": model_name,\n", + " \"fields\": fields,\n", + " \"tags\": tags,\n", + " \"options\": {\n", + " \"allowDuplicate\": False\n", + " }\n", + " }\n", + "\n", + " # Define the request payload\n", + " payload = {\n", + " \"action\": \"addNote\",\n", + " \"version\": 6,\n", + " \"params\": {\n", + " \"note\": note\n", + " }\n", + " }\n", + "\n", + " # Send the request to AnkiConnect\n", + " response = requests.post(ANKI_CONNECT_URL, json=payload)\n", + " return response.json()\n", + "\n", + "# Example usage\n", + "deck_name = \"Default\"\n", + "model_name = \"Basic\"\n", + "fields = {\n", + " \"Front\": \"What is the capital of France?\",\n", + " \"Back\": \"Paris\"\n", + "}\n", + "tags = [\"geography\"]\n", + "\n", + "result = add_note(deck_name, model_name, fields, tags)\n", + "print(result)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Python 3.9.20\n", + "asttokens==2.4.1\n", + "comm==0.2.2\n", + "debugpy==1.8.5\n", + "decorator==5.1.1\n", + "exceptiongroup==1.2.2\n", + "executing==2.1.0\n", + "importlib_metadata==8.5.0\n", + "ipykernel==6.29.5\n", + "ipython==8.18.1\n", + "jedi==0.19.1\n", + "jupyter_client==8.6.2\n", + "jupyter_core==5.7.2\n", + "matplotlib-inline==0.1.7\n", + "nest-asyncio==1.6.0\n", + "packaging==24.1\n", + "parso==0.8.4\n", + "pexpect==4.9.0\n", + "platformdirs==4.3.2\n", + "prompt_toolkit==3.0.47\n", + "psutil==6.0.0\n", + "ptyprocess==0.7.0\n", + "pure_eval==0.2.3\n", + "Pygments==2.18.0\n", + "python-dateutil==2.9.0.post0\n", + "pyzmq==26.2.0\n", + "six==1.16.0\n", + "stack-data==0.6.3\n", + "tornado==6.4.1\n", + "traitlets==5.14.3\n", + "typing_extensions==4.12.2\n", + "wcwidth==0.2.13\n", + "zipp==3.20.2\n" + ] + } + ], + "source": [ + "!python --version\n", + "!pip freeze\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "from fracdiff.sklearn import Fracdiff\n", + "import pandas_datareader as pdr\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "# Set the start and end dates for the data\n", + "start_date = '1990-01-01'\n", + "end_date= '2023-06-01'\n", + "# Fetch S&P 500 price data\n", + "data = np.array((pdr.get_data_fred('SP500', start = start_date,end = end_date)).dropna())\n", + "# Calculate the fractional differentiation\n", + "window = 100\n", + "f = Fracdiff(0.48, mode = 'valid', window = window)\n", + "frac_data = f.fit_transform(data)\n", + "# Calculate a simple differencing function for comparison\n", + "diff_data = np.reshape(np.diff(data[:, 0]), (-1, 1))\n", + "# Harmonizing time indices\n", + "data = data[window-1:, ]\n", + "diff_data = diff_data[window-2:, ]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(nrows = 3, ncols = 1)\n", + "axes[0].plot(data[5:,], label = 'S&P 500', color = 'blue', linewidth = 1)\n", + "axes[1].plot(frac_data[5:,], label =\n", + "'Fractionally Differentiated S&P 500 (0.48)',\n", + "color = 'orange', linewidth = 1)\n", + "axes[2].plot(diff_data[5:,], label =\n", + "'Differenced S&P 500', color = 'green', linewidth = 1)\n", + "axes[0].legend()\n", + "axes[1].legend()\n", + "axes[2].legend()\n", + "axes[0].grid()\n", + "axes[1].grid()\n", + "axes[2].grid()\n", + "axes[1].axhline(y = 0, color = 'black', linestyle = 'dashed')\n", + "axes[2].axhline(y = 0, color = 'black', linestyle = 'dashed')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "General", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.20" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/code/misc/python/scripts/ComputableDocs/_quarto.yml b/code/misc/python/scripts/ComputableDocs/_quarto.yml new file mode 100644 index 0000000..e023f87 --- /dev/null +++ b/code/misc/python/scripts/ComputableDocs/_quarto.yml @@ -0,0 +1,21 @@ +project: + type: website + +website: + title: "ComputableDocs" + navbar: + left: + - href: index.qmd + text: Home + - href: musicdownload.qmd + text: Music Download + - about.qmd + +format: + html: + theme: cosmo + css: styles.css + toc: true + + + diff --git a/code/misc/python/scripts/ComputableDocs/about.qmd b/code/misc/python/scripts/ComputableDocs/about.qmd new file mode 100644 index 0000000..07c5e7f --- /dev/null +++ b/code/misc/python/scripts/ComputableDocs/about.qmd @@ -0,0 +1,5 @@ +--- +title: "About" +--- + +About this site diff --git a/code/misc/python/scripts/ComputableDocs/audioconversion.ipynb b/code/misc/python/scripts/ComputableDocs/audioconversion.ipynb new file mode 100644 index 0000000..a388b90 --- /dev/null +++ b/code/misc/python/scripts/ComputableDocs/audioconversion.ipynb @@ -0,0 +1,560 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "#code\n", + "from pathlib import Path\n", + "from pytube import YouTube\n", + "from pytube import Playlist\n", + "import moviepy.editor as mp\n", + "from youtube_transcript_api import YouTubeTranscriptApi\n", + "from pathvalidate import sanitize_filepath\n", + "from pytube import cipher\n", + "import logging\n", + "import re\n", + "\n", + "logger = logging.getLogger(__name__)\n", + "\n", + "def get_throttling_function_name(js: str) -> str:\n", + " \"\"\"Extract the name of the function that computes the throttling parameter.\n", + "\n", + " :param str js:\n", + " The contents of the base.js asset file.\n", + " :rtype: str\n", + " :returns:\n", + " The name of the function used to compute the throttling parameter.\n", + " \"\"\"\n", + " function_patterns = [\n", + " # https://github.com/ytdl-org/youtube-dl/issues/29326#issuecomment-865985377\n", + " # https://github.com/yt-dlp/yt-dlp/commit/48416bc4a8f1d5ff07d5977659cb8ece7640dcd8\n", + " # var Bpa = [iha];\n", + " # ...\n", + " # a.C && (b = a.get(\"n\")) && (b = Bpa[0](b), a.set(\"n\", b),\n", + " # Bpa.length || iha(\"\")) }};\n", + " # In the above case, `iha` is the relevant function name\n", + " r'a\\.[a-zA-Z]\\s*&&\\s*\\([a-z]\\s*=\\s*a\\.get\\(\"n\"\\)\\)\\s*&&\\s*'\n", + " r'\\([a-z]\\s*=\\s*([a-zA-Z0-9$]+)(\\[\\d+\\])?\\([a-z]\\)',\n", + " r'\\([a-z]\\s*=\\s*([a-zA-Z0-9$]+)(\\[\\d+\\])\\([a-z]\\)',\n", + " ]\n", + " logger.debug('Finding throttling function name')\n", + " for pattern in function_patterns:\n", + " regex = re.compile(pattern)\n", + " function_match = regex.search(js)\n", + " if function_match:\n", + " logger.debug(\"finished regex search, matched: %s\", pattern)\n", + " if len(function_match.groups()) == 1:\n", + " return function_match.group(1)\n", + " idx = function_match.group(2)\n", + " if idx:\n", + " idx = idx.strip(\"[]\")\n", + " array = re.search(\n", + " r'var {nfunc}\\s*=\\s*(\\[.+?\\]);'.format(\n", + " nfunc=re.escape(function_match.group(1))),\n", + " js\n", + " )\n", + " if array:\n", + " array = array.group(1).strip(\"[]\").split(\",\")\n", + " array = [x.strip() for x in array]\n", + " return array[int(idx)]\n", + "\n", + " raise RegexMatchError(\n", + " caller=\"get_throttling_function_name\", pattern=\"multiple\"\n", + " )\n", + "\n", + "cipher.get_throttling_function_name = get_throttling_function_name\n", + "\n", + "def convert_mp4_to_mp3(file,oppath):\n", + " try:\n", + " # Load the video file\n", + " #video = mp.VideoFileClip(file)\n", + " audio=mp.AudioFileClip(str(file))\n", + " stem=str(file.stem)#.replace.rstrip().lstrip()\n", + "\n", + " oppath=oppath/'mp3'\n", + " oppath.mkdir(parents=True,exist_ok=True)\n", + " audio_path=sanitize_filepath(oppath/f'{stem}.mp3')\n", + " print('audio_path', stem, audio_path)\n", + "\n", + " # Extract the audio from the video and save it as an MP3 file\n", + " #video.audio.write_audiofile(audio_path, codec='pcm_s16le')\n", + " audio.write_audiofile(str(audio_path),write_logfile=True,verbose=True)#, codec='pcm_s16le')\n", + "\n", + " # Print a success message\n", + " print(f\"Audio extracted and saved as: {audio_path}\")\n", + " except Exception as e:\n", + " print(f\"Error converting MP4 to MP3: {e}\")\n", + "\n", + "def convert_mp4_to_wav(file,oppath):\n", + " try:\n", + " # Load the video file\n", + " #video = mp.VideoFileClip(file)\n", + " audio=mp.AudioFileClip(str(file))\n", + " stem=str(file.stem)#.replace.rstrip().lstrip()\n", + " oppath=oppath/'wav'\n", + " oppath.mkdir(parents=True,exist_ok=True)\n", + "\n", + " audio_path=sanitize_filepath(oppath/f'{stem}.wav')\n", + " print('audio_path', stem, audio_path)\n", + " # Extract the audio from the video and save it as an MP3 file\n", + " #video.audio.write_audiofile(audio_path, codec='pcm_s16le')\n", + " audio.write_audiofile(str(audio_path),codec='pcm_s16le',write_logfile=False,verbose=True)#, codec='pcm_s16le')\n", + "\n", + " # Print a success message\n", + " print(f\"Audio extracted and saved as: {audio_path}\")\n", + " except Exception as e:\n", + " print(f\"Error converting MP4 to MP3: {e}\")\n", + "\n", + "def download_mp4(name,video_url,oppath):\n", + " # Get the YouTube object\n", + " yt = YouTube(video_url)\n", + "\n", + " # Get video title and language\n", + " try:\n", + " title = name #yt.title\n", + " except Exception as e:\n", + " print(e)\n", + " title=name\n", + " \n", + "\n", + " video_stream = yt.streams.filter(adaptive=True).order_by('abr')\n", + " # print(video_stream)\n", + " fname=sanitize_filepath(oppath/ f'{title}.mp4')\n", + " video_stream.last().download(filename=oppath/ f'{title}.mp4')\n", + " return fname \n", + "\n", + "def download_songlist(songs,oppath):\n", + " \n", + " for name,url in songs.items():\n", + " try:\n", + " file=download_mp4(name,url,oppath)\n", + " convert_mp4_to_mp3(file,oppath)\n", + " except Exception as e:\n", + " print(f\"Error downloading file: {e}\")\n", + " continue\n", + "\n", + "def download_playlist(url_playlist,oppath):\n", + " playlist = Playlist(url_playlist)\n", + " ls=[]\n", + " for urls in playlist.video_urls:\n", + " ls.append(urls)\n", + "\n", + " download_songlist(ls,oppath)\n", + " return " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## song list 2024-06-24\n", + "\n", + "- [Sabrina Carpenter - Please Please Please (Lyric Video)](https://www.youtube.com/watch?v=Yl_thbk40A0)\n", + "- [Sabrina Carpenter - Espresso (Lyrics)](https://www.youtube.com/watch?v=kVC3BSBm2Dc)\n", + "- [Kaash Paige - Love Songs (Lyrics)](https://www.youtube.com/watch?v=7P4q7Oo67-U)\n", + "- [L’AMOUR DE MA VIE (Lyrics)](https://www.youtube.com/watch?v=RhGaivzNHps)\n", + "- [SZA Greatest Hits Full Album 2024](https://www.youtube.com/watch?v=W6kc4k4NmWQ)\n", + "- [Eminem - Just Lose It (Official Music Video)](https://www.youtube.com/watch?v=9dcVOmEQzKA)\n", + "- [Rihanna New Playlist 2023](https://www.youtube.com/watch?v=5o9AQs4GOeA)\n", + "- [Eminem - Houdini (Perfectly Clean)](https://www.youtube.com/watch?v=YMwWZXQ9xQU)\n", + "- [Tyla - Water (Lyrics)](https://www.youtube.com/watch?v=A81ZfezsLcM)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Error downloading file: HTTP Error 400: Bad Request\n", + "audio_path Sabrina Carpenter - Espresso (Lyrics) /home/ys/Music/Miri/7_playlist/mp3/Sabrina Carpenter - Espresso (Lyrics).mp3\n", + "MoviePy - Writing audio in /home/ys/Music/Miri/7_playlist/mp3/Sabrina Carpenter - Espresso (Lyrics).mp3\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " " + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MoviePy - Done.\n", + "Audio extracted and saved as: /home/ys/Music/Miri/7_playlist/mp3/Sabrina Carpenter - Espresso (Lyrics).mp3\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r" + ] + } + ], + "source": [ + "oppath=Path('/home/ys/Music/Miri/7_playlist')\n", + "\n", + "list_20240624=['https://www.youtube.com/watch?v=Yl_thbk40A0',\n", + "'https://www.youtube.com/watch?v=kVC3BSBm2Dc',\n", + "'https://www.youtube.com/watch?v=7P4q7Oo67-U',\n", + "'https://www.youtube.com/watch?v=RhGaivzNHps',\n", + "'https://www.youtube.com/watch?v=W6kc4k4NmWQ',\n", + "'https://www.youtube.com/watch?v=9dcVOmEQzKA',\n", + "'https://www.youtube.com/watch?v=5o9AQs4GOeA',\n", + "'https://www.youtube.com/watch?v=YMwWZXQ9xQU',\n", + "'https://www.youtube.com/watch?v=A81ZfezsLcM']\n", + "\n", + "\n", + "\n", + "\n", + "list_20240624\n", + "download_songlist(list_20240624,oppath)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## song list 2024-10-05\n", + "\n", + "- [sza playlist 1](https://youtu.be/455TWGwAObA?si=GZVF3c86L57d8MsF)\n", + "- [sza playlist 2](https://youtu.be/IlnxfwtCqLU?si=TjdWp9QbSG2LM2E9) #did not download\n", + "- [travis scott clean](https://youtu.be/7tcYOY50yXg?si=2zYcfSbta9WhTzGd)\n", + "- [rihanna playlist](https://youtu.be/5o9AQs4GOeA?si=I0YLFJQl0YwEx9AG) #did not download\n", + "- [weekend playlist](https://youtu.be/mPXBHFFUgzw?si=g4fhhhza2COvSnLZ) #did not download\n", + "- [travis scott clean 2](https://youtu.be/JPo3xwzupbE?si=B32de3hrHuaG283K)\n", + "- [power is power clean](https://youtu.be/iFwQcBoljoo?si=cXrK5-RDq77rvWmh)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "audio_path sza playlist 1 /home/ys/Music/Miri/8_playlist/mp3/sza playlist 1.mp3\n", + "MoviePy - Writing audio in /home/ys/Music/Miri/8_playlist/mp3/sza playlist 1.mp3\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " \r" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MoviePy - Done.\n", + "Audio extracted and saved as: /home/ys/Music/Miri/8_playlist/mp3/sza playlist 1.mp3\n", + "Error downloading file: HTTP Error 400: Bad Request\n", + "audio_path travis scott clean /home/ys/Music/Miri/8_playlist/mp3/travis scott clean.mp3\n", + "MoviePy - Writing audio in /home/ys/Music/Miri/8_playlist/mp3/travis scott clean.mp3\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " \r" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MoviePy - Done.\n", + "Audio extracted and saved as: /home/ys/Music/Miri/8_playlist/mp3/travis scott clean.mp3\n", + "audio_path rihanna playlist /home/ys/Music/Miri/8_playlist/mp3/rihanna playlist.mp3\n", + "MoviePy - Writing audio in /home/ys/Music/Miri/8_playlist/mp3/rihanna playlist.mp3\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " \r" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MoviePy - Done.\n", + "Audio extracted and saved as: /home/ys/Music/Miri/8_playlist/mp3/rihanna playlist.mp3\n", + "Error downloading file: HTTP Error 400: Bad Request\n", + "audio_path travis scott clean 2 /home/ys/Music/Miri/8_playlist/mp3/travis scott clean 2.mp3\n", + "MoviePy - Writing audio in /home/ys/Music/Miri/8_playlist/mp3/travis scott clean 2.mp3\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " \r" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MoviePy - Done.\n", + "Audio extracted and saved as: /home/ys/Music/Miri/8_playlist/mp3/travis scott clean 2.mp3\n", + "Error downloading file: HTTP Error 400: Bad Request\n" + ] + } + ], + "source": [ + "oppath=Path('/home/ys/Music/Miri/8_playlist')\n", + "oppath.mkdir(parents=True,exist_ok=True)\n", + "\n", + "\n", + "dict_20241005={\n", + "'sza playlist 1':r'https://youtu.be/455TWGwAObA?si=GZVF3c86L57d8MsF',\n", + "'sza playlist 2':r'https://youtu.be/IlnxfwtCqLU?si=TjdWp9QbSG2LM2E9',\n", + "'travis scott clean':r'https://youtu.be/7tcYOY50yXg?si=2zYcfSbta9WhTzGd',\n", + "'rihanna playlist':r'https://youtu.be/5o9AQs4GOeA?si=I0YLFJQl0YwEx9AG)',\n", + "'weekend playlist':r'https://youtu.be/mPXBHFFUgzw?si=g4fhhhza2COvSnLZ',\n", + "'travis scott clean 2':r'https://youtu.be/JPo3xwzupbE?si=B32de3hrHuaG283K',\n", + "'power is power clean':r'https://youtu.be/iFwQcBoljoo?si=cXrK5-RDq77rvWmh'\n", + "}\n", + "\n", + "\n", + "\n", + "download_songlist(dict_20241005,oppath)\n" + ] + }, + { + "attachments": { + "image.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "https://www.fatpick.com/blog?in=music-theory\n", + "\n", + "![image.png](attachment:image.png)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using preset Guitar Nylon X for guitar nylon\n" + ] + } + ], + "source": [ + "\n", + "\n", + "#for i in range(40,88,1):\n", + "# guitar.play_note(i,1,0.2)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "NOTES_FLAT = ['C', 'Db', 'D', 'Eb', 'E', 'F', 'Gb', 'G', 'Ab', 'A', 'Bb', 'B']\n", + "NOTES_SHARP = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B']\n", + "NOTES_FLAT=[str.lower(_) for _ in NOTES_FLAT]\n", + "NOTES_SHARP=[str.lower(_) for _ in NOTES_SHARP]\n", + "#def NoteToMidi_guitar(string, fret):\n", + "import pandas as pd\n", + "import numpy as np\n", + "from itertools import product\n", + "def NoteToMidi(KeyOctave): \n", + " # KeyOctave is formatted like 'C#3'\n", + " key = KeyOctave[:-1] # eg C, Db\n", + " octave = KeyOctave[-1] # eg 3, 4\n", + " answer = -1\n", + " \n", + " try:\n", + " if 'b' in key:\n", + " pos = NOTES_FLAT.index(key)\n", + " else:\n", + " pos = NOTES_SHARP.index(key)\n", + " except:\n", + " print('The key is not valid', key)\n", + " return answer\n", + "\n", + " answer += pos + 12 * (int(octave) + 1) + 1\n", + " return answer\n", + "\n", + "def guitarToMidi(string,fret):\n", + " openstr={}\n", + " openstr[6]=40\n", + " openstr[5]=45\n", + " openstr[4]=50\n", + " openstr[3]=55\n", + " openstr[2]=59\n", + " openstr[1]=64\n", + " midi=openstr[string]+fret\n", + " notes=miditoGuitarNote_sharps.loc[midi,0]\n", + " notef=miditoGuitarNote_flats.loc[midi,0]\n", + " return midi,notes,notef\n", + "\n", + "\n", + "miditoGuitarNote_sharps=(pd.concat([pd.Series({NoteToMidi(f'{k}{o}'):f'{k}{o}' for o,k in product(range(0,7,1),NOTES_SHARP)}),\n", + " ], axis=1\n", + " )\n", + " .assign(E=lambda df: np.where((df.index>=40) & (df.index<59),df[0],0),\n", + " A=lambda df: np.where((df.index>=45) & (df.index<64),df[0],0),\n", + " D=lambda df: np.where((df.index>=50) & (df.index<69),df[0],0),\n", + " G=lambda df: np.where((df.index>=55) & (df.index<74),df[0],0),\n", + " B=lambda df: np.where((df.index>=59) & (df.index<78),df[0],0),\n", + " e=lambda df: np.where((df.index>=64) & (df.index<83),df[0],0),\n", + " )\n", + ")\n", + "\n", + "miditoGuitarNote_flats=(pd.concat([pd.Series({NoteToMidi(f'{k}{o}'):f'{k}{o}' for o,k in product(range(0,7,1),NOTES_FLAT)}),\n", + " ], axis=1\n", + " )\n", + " .assign(E=lambda df: np.where((df.index>=40) & (df.index<59),df[0],0),\n", + " A=lambda df: np.where((df.index>=45) & (df.index<64),df[0],0),\n", + " D=lambda df: np.where((df.index>=50) & (df.index<69),df[0],0),\n", + " G=lambda df: np.where((df.index>=55) & (df.index<74),df[0],0),\n", + " B=lambda df: np.where((df.index>=59) & (df.index<78),df[0],0),\n", + " e=lambda df: np.where((df.index>=64) & (df.index<83),df[0],0),\n", + " )\n", + ")\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using preset Guitar Nylon X for guitar nylon\n" + ] + }, + { + "data": { + "text/plain": [ + "1.0" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#guitarToMidi(6,2)[0]\n", + "\n", + "\n", + "\n", + "from scamp import *\n", + "\n", + "s= Session() # (temp=100,)\n", + "#s.print_default_soundfont_presets()\n", + "guitar=s.new_part(\"guitar nylon\")\n", + "\n", + "#https://www.fatpick.com/blog/note-table\n", + "#http://scamp.marcevanstein.com/narrative/tutorial_videos.html\n", + "\n", + "#\n", + "count=0\n", + "vol=0\n", + "#guitar.play_note(guitarToMidi(6,0)[0],1,5,blocking=False)\n", + "for string in reversed(range(1,7,1)):\n", + " for fret in range(0,5):\n", + " \n", + " if (count%3==0):\n", + " vol=1\n", + " else:\n", + " vol=0.7\n", + " count+=1\n", + " \n", + " guitar.play_note(guitarToMidi(string,fret)[0],vol,0.1)\n", + "#guitar.play_note(40,1,2)\n", + "#guitar.play_note(83,1,2)\n", + "#guitar.play_chord([70,73,83],1,2)\n", + "#guitar.play_note(52,1,5)\n", + "s.beat_length" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "import abjad\n", + "string = \"c'16 f' g' a' d' g' a' b' e' a' b' c'' f' b' c'' d''16\"\n", + "voice_1 = abjad.Voice(string, name=\"Voice_1\")\n", + "staff_1 = abjad.Staff([voice_1], name=\"Staff_1\")\n", + "abjad.show(staff_1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "General", + "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.11.2" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/code/misc/python/scripts/ComputableDocs/index.qmd b/code/misc/python/scripts/ComputableDocs/index.qmd new file mode 100644 index 0000000..411f226 --- /dev/null +++ b/code/misc/python/scripts/ComputableDocs/index.qmd @@ -0,0 +1,7 @@ +--- +title: "ComputableDocs" +--- + +This is a Quarto website. + +To learn more about Quarto websites visit . diff --git a/code/misc/python/scripts/ComputableDocs/musicdownload.qmd b/code/misc/python/scripts/ComputableDocs/musicdownload.qmd new file mode 100644 index 0000000..7e83a21 --- /dev/null +++ b/code/misc/python/scripts/ComputableDocs/musicdownload.qmd @@ -0,0 +1,276 @@ +--- +title: "DownloadPage" +code-fold: true +execute: + enabled: true + cache: false +jupyter: python3 +format: + html: + toc: true + code-fold: true + html-math-method: katex + css: styles.css +--- + +# Miri's requests! + +```{python} +#| echo: true + +from pathlib import Path +from pytube import YouTube +from pytube import Playlist +import moviepy.editor as mp +from youtube_transcript_api import YouTubeTranscriptApi +from pathvalidate import sanitize_filepath + +def convert_mp4_to_mp3(file,oppath): + try: + # Load the video file + #video = mp.VideoFileClip(file) + audio=mp.AudioFileClip(str(file)) + stem=str(file.stem)#.replace.rstrip().lstrip() + + oppath=oppath/'mp3' + oppath.mkdir(parents=True,exist_ok=True) + audio_path=sanitize_filepath(oppath/f'{stem}.mp3') + print('audio_path', stem, audio_path) + + # Extract the audio from the video and save it as an MP3 file + #video.audio.write_audiofile(audio_path, codec='pcm_s16le') + audio.write_audiofile(str(audio_path),write_logfile=True,verbose=True)#, codec='pcm_s16le') + + # Print a success message + print(f"Audio extracted and saved as: {audio_path}") + except Exception as e: + print(f"Error converting MP4 to MP3: {e}") + +def convert_mp4_to_wav(file,oppath): + try: + # Load the video file + #video = mp.VideoFileClip(file) + audio=mp.AudioFileClip(str(file)) + stem=str(file.stem)#.replace.rstrip().lstrip() + oppath=oppath/'wav' + oppath.mkdir(parents=True,exist_ok=True) + + audio_path=sanitize_filepath(oppath/f'{stem}.wav') + print('audio_path', stem, audio_path) + # Extract the audio from the video and save it as an MP3 file + #video.audio.write_audiofile(audio_path, codec='pcm_s16le') + audio.write_audiofile(str(audio_path),codec='pcm_s16le',write_logfile=False,verbose=True)#, codec='pcm_s16le') + + # Print a success message + print(f"Audio extracted and saved as: {audio_path}") + except Exception as e: + print(f"Error converting MP4 to MP3: {e}") + +def download_mp4(video_url,oppath): + # Get the YouTube object + yt = YouTube(video_url) + + # Get video title and language + title = yt.title + # print (title) + + video_stream = yt.streams.filter(adaptive=True).order_by('abr') + # print(video_stream) + fname=sanitize_filepath(oppath/ f'{title}.mp4') + video_stream.last().download(filename=oppath/ f'{title}.mp4') + return fname + +def download_songlist(songs,oppath): + + for song in songs: + try: + file=download_mp4(song,oppath) + convert_mp4_to_mp3(file,oppath) + except Exception as e: + print(f"Error downloading file: {e}") + continue + +def download_playlist(url_playlist,oppath): + playlist = Playlist(url_playlist) + ls=[] + for urls in playlist.video_urls: + ls.append(urls) + + download_songlist(ls,oppath) + return + +``` + +fix pytube issue + +```{python} + +from pytube import cipher +import logging +import re + +logger = logging.getLogger(__name__) + +def get_throttling_function_name(js: str) -> str: + """Extract the name of the function that computes the throttling parameter. + + :param str js: + The contents of the base.js asset file. + :rtype: str + :returns: + The name of the function used to compute the throttling parameter. + """ + function_patterns = [ + # https://github.com/ytdl-org/youtube-dl/issues/29326#issuecomment-865985377 + # https://github.com/yt-dlp/yt-dlp/commit/48416bc4a8f1d5ff07d5977659cb8ece7640dcd8 + # var Bpa = [iha]; + # ... + # a.C && (b = a.get("n")) && (b = Bpa[0](b), a.set("n", b), + # Bpa.length || iha("")) }}; + # In the above case, `iha` is the relevant function name + r'a\.[a-zA-Z]\s*&&\s*\([a-z]\s*=\s*a\.get\("n"\)\)\s*&&\s*' + r'\([a-z]\s*=\s*([a-zA-Z0-9$]+)(\[\d+\])?\([a-z]\)', + r'\([a-z]\s*=\s*([a-zA-Z0-9$]+)(\[\d+\])\([a-z]\)', + ] + logger.debug('Finding throttling function name') + for pattern in function_patterns: + regex = re.compile(pattern) + function_match = regex.search(js) + if function_match: + logger.debug("finished regex search, matched: %s", pattern) + if len(function_match.groups()) == 1: + return function_match.group(1) + idx = function_match.group(2) + if idx: + idx = idx.strip("[]") + array = re.search( + r'var {nfunc}\s*=\s*(\[.+?\]);'.format( + nfunc=re.escape(function_match.group(1))), + js + ) + if array: + array = array.group(1).strip("[]").split(",") + array = [x.strip() for x in array] + return array[int(idx)] + + raise RegexMatchError( + caller="get_throttling_function_name", pattern="multiple" + ) + +cipher.get_throttling_function_name = get_throttling_function_name + +``` + +## song list 2024-06-24 + +- [Sabrina Carpenter - Please Please Please (Lyric Video)](https://www.youtube.com/watch?v=Yl_thbk40A0) +- [Sabrina Carpenter - Espresso (Lyrics)](https://www.youtube.com/watch?v=kVC3BSBm2Dc) +- [Kaash Paige - Love Songs (Lyrics)](https://www.youtube.com/watch?v=7P4q7Oo67-U) +- [L’AMOUR DE MA VIE (Lyrics)](https://www.youtube.com/watch?v=RhGaivzNHps) +- [SZA Greatest Hits Full Album 2024](https://www.youtube.com/watch?v=W6kc4k4NmWQ) +- [Eminem - Just Lose It (Official Music Video)](https://www.youtube.com/watch?v=9dcVOmEQzKA) +- [Rihanna New Playlist 2023](https://www.youtube.com/watch?v=5o9AQs4GOeA) +- [Eminem - Houdini (Perfectly Clean)](https://www.youtube.com/watch?v=YMwWZXQ9xQU) +- [Tyla - Water (Lyrics)](https://www.youtube.com/watch?v=A81ZfezsLcM) + +```{python} +p=!pwd +#p[0] +#!tree {p[0]} + +musicpath='~/Music/Miri' +!tree -d {musicpath} +``` + +```{python} + +#| echo: false +#| output: false +#| eval: false + +oppath=Path('/home/ys/Music/Miri/7_playlist') + +list_20240624=['https://www.youtube.com/watch?v=Yl_thbk40A0', +'https://www.youtube.com/watch?v=kVC3BSBm2Dc', +'https://www.youtube.com/watch?v=7P4q7Oo67-U', +'https://www.youtube.com/watch?v=RhGaivzNHps', +'https://www.youtube.com/watch?v=W6kc4k4NmWQ', +'https://www.youtube.com/watch?v=9dcVOmEQzKA', +'https://www.youtube.com/watch?v=5o9AQs4GOeA', +'https://www.youtube.com/watch?v=YMwWZXQ9xQU', +'https://www.youtube.com/watch?v=A81ZfezsLcM'] + + + +list_20240624 +download_songlist(list_20240624,oppath) + + +``` + +## song list 2024-10-05 + +- [sza playlist 1](https://youtu.be/455TWGwAObA?si=GZVF3c86L57d8MsF) +- [sza playlist 2](https://youtu.be/IlnxfwtCqLU?si=TjdWp9QbSG2LM2E9) #did not download +- [travis scott clean](https://youtu.be/7tcYOY50yXg?si=2zYcfSbta9WhTzGd) +- [rihanna playlist](https://youtu.be/5o9AQs4GOeA?si=I0YLFJQl0YwEx9AG) #did not download +- [weekend playlist](https://youtu.be/mPXBHFFUgzw?si=g4fhhhza2COvSnLZ) #did not download +- [travis scott clean 2](https://youtu.be/JPo3xwzupbE?si=B32de3hrHuaG283K) +- [power is power clean](https://youtu.be/iFwQcBoljoo?si=cXrK5-RDq77rvWmh) + +```{python} + +#| echo: false +#| output: false +#| eval: true + +oppath=Path('/home/ys/Music/Miri/8_playlist') +oppath.mkdir(parents=True,exist_ok=True) + + +list_20241005=['https://youtu.be/455TWGwAObA?si=GZVF3c86L57d8MsF', +'https://youtu.be/IlnxfwtCqLU?si=TjdWp9QbSG2LM2E9', +'https://youtu.be/7tcYOY50yXg?si=2zYcfSbta9WhTzGd', +'https://youtu.be/5o9AQs4GOeA?si=I0YLFJQl0YwEx9AG)', +'https://youtu.be/mPXBHFFUgzw?si=g4fhhhza2COvSnLZ', +'https://youtu.be/JPo3xwzupbE?si=B32de3hrHuaG283K', +'https://youtu.be/iFwQcBoljoo?si=cXrK5-RDq77rvWmh' +] + +download_songlist(list_20241005,oppath) + + +``` + +# My downloads +## song list 2024-07-13 + +- [Vicente Amigo - De Mi Corazón Al Aire](https://www.youtube.com/watch?v=6RZwLta9MHg&list=OLAK5uy_lHANtM_kWgkJVkbl8w83LuIyL8QIIBMWE&index=1) + +- [Vicente Amigo - Vivencias Imaginadas](https://www.youtube.com/watch?v=cvrg4wn7vlQ&list=OLAK5uy_nl4MMy9w40xh1g4KPGbZfB7bs9_ga6Mho&index=2) + +- [Vicente Amigo - Ciudad De Las Ideas](https://www.youtube.com/watch?v=QyBNAtr44X8&list=PLlf0nWXS9c9CRKpqe08BVKtzO7FHXW6sF) + +```{python} + +#| echo: false +#| output: false +#| eval: false + +oppath=Path('/home/ys/Music/youtube')/'Vicente Amigo'/'De Mi Corazon Al Aire' +oppath.mkdir(parents=True,exist_ok=True) +#download_playlist('https://www.youtube.com/watch?v=6RZwLta9MHg&list=OLAK5uy_lHANtM_kWgkJVkbl8w83LuIyL8QIIBMWE&index=1',oppath) + + + +oppath=Path('/home/ys/Music/youtube')/'Vicente Amigo'/'Vivencias Imaginadas' +oppath.mkdir(parents=True,exist_ok=True) +#download_playlist('https://www.youtube.com/watch?v=cvrg4wn7vlQ&list=OLAK5uy_nl4MMy9w40xh1g4KPGbZfB7bs9_ga6Mho&index=1',oppath) + +oppath=Path('/home/ys/Music/youtube')/'Vicente Amigo'/'Ciudad De Las Ideas' +oppath.mkdir(parents=True,exist_ok=True) +#download_playlist('https://www.youtube.com/watch?v=QyBNAtr44X8&list=PLlf0nWXS9c9CRKpqe08BVKtzO7FHXW6sF',oppath) + +``` + + diff --git a/code/misc/python/scripts/ComputableDocs/styles.css b/code/misc/python/scripts/ComputableDocs/styles.css new file mode 100644 index 0000000..2ddf50c --- /dev/null +++ b/code/misc/python/scripts/ComputableDocs/styles.css @@ -0,0 +1 @@ +/* css styles */ diff --git a/code/misc/python/scripts/DOTNETtesting.ipynb b/code/misc/python/scripts/DOTNETtesting.ipynb new file mode 100644 index 0000000..e69de29 diff --git a/code/misc/python/scripts/DigitalPaper Management.ipynb b/code/misc/python/scripts/DigitalPaper Management.ipynb new file mode 100644 index 0000000..466d4d2 --- /dev/null +++ b/code/misc/python/scripts/DigitalPaper Management.ipynb @@ -0,0 +1,331 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import json\n", + "import os\n", + "\n", + "from dptrp1.dptrp1 import DigitalPaper\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import getpass\n", + "import os\n", + "\n", + "password = getpass.getpass()\n", + "command = \"sudo -S sudo chmod 666 /dev/ttyACM0\" #can be any command but don't forget -S as it enables input from stdin\n", + "os.system('echo %s | %s' % (password, command))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/dev/ttyACM0\n" + ] + } + ], + "source": [ + "import serial\n", + "ser = serial.Serial('/dev/ttyACM0') # open serial port\n", + "print(ser.name) # check which port was really used\n", + "ser.write(b'\\x01\\x00\\x00\\x01\\x00\\x00\\x00\\x01\\x00\\x04') # write a string b\"\\x01\\x00\\x00\\x01\\x00\\x00\\x00\\x01\\x00\\x04\"\n", + "ser.close() # close port\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "client_id=''\n", + "key=''\n", + "SYNC_DIR = '/home/dl92/Downloads/DigitalPaper/'\n", + "def connect(address=''):\n", + " \"\"\"\n", + " Loads the key and client ID to authenticate with the DPT-RP1\n", + " \"\"\"\n", + " with open('/home/dl92/.dpt-client.txt', 'r') as f:\n", + " client_id = f.readline().strip()\n", + "\n", + " with open('/home/dl92/.dpt-key.txt', 'r') as f:\n", + " key = f.read()\n", + "\n", + " dpt = DigitalPaper(address)\n", + " dpt.authenticate(client_id, key)\n", + " return dpt\n", + "\n", + "def sync(dpt):\n", + " \"\"\"\n", + " Given an authenticated DigitalPaper instance, download all note files to a\n", + " specified directory.\n", + " \"\"\"\n", + " for doc in [f for f in dpt.list_documents() if (is_modified_note(f) and is_ReadingFolder(f)) ]:\n", + " #docpath=os.path.dirname(doc['entry_path'])\n", + " #if docpath=='Document/Reading' :\n", + " data = dpt.download(doc['entry_path'])\n", + " local_path = SYNC_DIR + os.path.basename(doc['entry_path'])\n", + " with open(local_path, 'wb') as f:\n", + " f.write(data)\n", + " print('Saved {} to {}'.format(doc['entry_path'], local_path))\n", + " \n", + "def is_modified_note(doc):\n", + " import dateparser\n", + " if doc['document_type'] == 'note' or doc['document_type'] == 'normal':\n", + " local_path = SYNC_DIR + os.path.basename(doc['entry_path'])\n", + " \n", + " if not os.path.exists(local_path):\n", + " return True\n", + " else:\n", + " #print (local_path,doc['modified_date'], os.path.getmtime(local_path), dateparser.parse(doc['modified_date']).timestamp())\n", + " return os.path.getmtime(local_path) < dateparser.parse(doc['modified_date']).timestamp()\n", + " \n", + "def is_ReadingFolder(doc):\n", + " docpath=os.path.dirname(doc['entry_path'])\n", + " if docpath=='Document/Reading':\n", + " return True\n", + " else:\n", + " return False\n", + " \n", + "\n", + "\n", + "def upload_overwrite(dpt,localpath, remotepath='Document/Reading'):\n", + " import glob, os\n", + " \n", + " files= glob.glob(localpath+'/*.pdf')\n", + " for f in files:\n", + " print (f)\n", + " dpt.upload_file(f,remotepath)\n", + " \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "dpt=connect('192.168.0.131')\n", + "\n", + "\n", + "#dpt=connect('https://192.168.0.13')\n", + "#dpt=connect('22:6f:5d:46:3f:16')" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'device_color': '#ffffff',\n", + " 'model_name': 'DPT-RP1',\n", + " 'serial_number': '5021254',\n", + " 'sku_code': 'U'}" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dpt.get_info()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "sync(dpt)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/home/dl92/Downloads/DigitalPaper/Upload/Kevin P. Murphy_Machine Learning_ A Probabilistic Perspective.pdf\n", + "/home/dl92/Downloads/DigitalPaper/Upload/John D. Kelleher_Deep Learning.pdf\n", + "/home/dl92/Downloads/DigitalPaper/Upload/Andriy Burkov_The Hundred-Page Machine Learning Book.pdf\n", + "/home/dl92/Downloads/DigitalPaper/Upload/John D. Kelleher_Fundamentals of Machine Learning for Predictive Data Analytics_ Algorithms, Worked Examples, and Case Studies.pdf\n" + ] + } + ], + "source": [ + "UPLOAD_DIR='/home/dl92/Downloads/DigitalPaper/Upload/'\n", + "upload_overwrite(dpt,UPLOAD_DIR)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'health': 'good',\n", + " 'icon_type': 'level_bar_4',\n", + " 'level': '95',\n", + " 'pen': '100',\n", + " 'plugged': 'not_plugged',\n", + " 'status': 'discharging'}" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dpt.get_battery()" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "dpt.new_folder('Document/Work')" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "ename": "ModuleNotFoundError", + "evalue": "No module named 'pypdf'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mimport\u001b[0m \u001b[0mpypdf\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'pypdf'" + ] + } + ], + "source": [ + "import pypdf" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "rate=0.33\n", + "price=394\n", + "motherboardasset=price-2*price*rate" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "rate=0.33\n", + "price=216\n", + "powersupplyasset=price-2*price*rate" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "73.44" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "powersupplyasset\n", + "#motherboardasset" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "celltoolbar": "Attachments", + "kernelspec": { + "display_name": "Python 3.8.10 ('General')", + "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.8.10" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + }, + "vscode": { + "interpreter": { + "hash": "97f3fdd28b09b8a55d08fd0c4c2cf066e1a4715931f0fa71c8f74dcb74701738" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/code/misc/python/scripts/DigitalPaper Management.py b/code/misc/python/scripts/DigitalPaper Management.py new file mode 100644 index 0000000..f6a9ef7 --- /dev/null +++ b/code/misc/python/scripts/DigitalPaper Management.py @@ -0,0 +1,71 @@ +import json +import os + +from dptrp1.dptrp1 import DigitalPaper + +client_id='' +key='' +SYNC_DIR = '/home/dl92/Documents/DigitalPaper/' +def connect(address=''): + """ + Loads the key and client ID to authenticate with the DPT-RP1 + """ + with open('/home/dl92/.dpt-client.txt', 'r') as f: + client_id = f.readline().strip() + + with open('/home/dl92/.dpt-key.txt', 'r') as f: + key = f.read() + + dpt = DigitalPaper(address) + dpt.authenticate(client_id, key) + return dpt + +def sync(dpt): + """ + Given an authenticated DigitalPaper instance, download all note files to a + specified directory. + """ + for doc in [f for f in dpt.list_documents() if (is_modified_note(f) and is_ReadingFolder(f)) ]: + #docpath=os.path.dirname(doc['entry_path']) + #if docpath=='Document/Reading' : + data = dpt.download(doc['entry_path']) + local_path = SYNC_DIR + os.path.basename(doc['entry_path']) + with open(local_path, 'wb') as f: + f.write(data) + print('Saved {} to {}'.format(doc['entry_path'], local_path)) + +def is_modified_note(doc): + import dateparser + if doc['document_type'] == 'note' or doc['document_type'] == 'normal': + local_path = SYNC_DIR + os.path.basename(doc['entry_path']) + + if not os.path.exists(local_path): + return True + else: + #print (local_path,doc['modified_date'], os.path.getmtime(local_path), dateparser.parse(doc['modified_date']).timestamp()) + return os.path.getmtime(local_path) < dateparser.parse(doc['modified_date']).timestamp() + +def is_ReadingFolder(doc): + docpath=os.path.dirname(doc['entry_path']) + if docpath=='Document/Reading': + return True + else: + return False + + +def upload_overwrite(dpt,localpath, remotepath='Document/Reading'): + import glob, os + dpt.new_folder(remotepath) + files= glob.glob(localpath+'/*.pdf') + for f in files: + print (f) + dpt.upload_file(f,remotepath) + +def delete_foldercontent(dpt,remotepath): + [dpt.delete_document(doc['entry_path']) for doc in dpt.list_objects_in_folder(remotepath)] + + +dpt=connect('192.168.0.131') +#sync(dpt) +#dpt.new_folder('Document/Miri') +#upload_overwrite(dpt,SYNC_DIR+'/Upload','Document/Miri') diff --git a/code/misc/python/scripts/FarsiWords.ipynb b/code/misc/python/scripts/FarsiWords.ipynb new file mode 100644 index 0000000..e785193 --- /dev/null +++ b/code/misc/python/scripts/FarsiWords.ipynb @@ -0,0 +1,380 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from selenium import webdriver\n", + "from selenium import webdriver\n", + "\n", + "browser = webdriver.Firefox(executable_path=\"/home/dl92/code/WebDriver/bin/geckodriver\")\n", + "browser.get('http://farsilookup.com/p2e/seek.jsp?lang=fa&word=+%D9%85%D8%AD%D9%88%D8%B1')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "x=browser.find_element_by_class_name('mean-ul')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "temp=x.text" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "temp.split('\\n')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['axis, axle, pivot']" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "temp.split('\\n')" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Unnamed: 0Unnamed: 1Unnamed: 2AudioSpellingMeaningNotesFarsiGermanAudio (f)Audio (g)Tag
0NaNNaNNaNNaNadditionNaNNaNNaNNaNNaNNaNNaN
1NaNNaNNaNNaNsubtractionNaNNaNNaNNaNNaNNaNNaN
2NaNNaNNaNNaNdivisionNaNNaNNaNNaNNaNNaNNaN
3NaNNaNNaNNaNmultiplicationNaNNaNNaNNaNNaNNaNNaN
4NaNNaNNaNNaNequationNaNNaNNaNNaNNaNNaNNaN
5NaNNaNNaNNaNequalityNaNNaNNaNNaNNaNNaNNaN
\n", + "
" + ], + "text/plain": [ + " Unnamed: 0 Unnamed: 1 Unnamed: 2 Audio Spelling Meaning Notes \\\n", + "0 NaN NaN NaN NaN addition NaN NaN \n", + "1 NaN NaN NaN NaN subtraction NaN NaN \n", + "2 NaN NaN NaN NaN division NaN NaN \n", + "3 NaN NaN NaN NaN multiplication NaN NaN \n", + "4 NaN NaN NaN NaN equation NaN NaN \n", + "5 NaN NaN NaN NaN equality NaN NaN \n", + "\n", + " Farsi German Audio (f) Audio (g) Tag \n", + "0 NaN NaN NaN NaN NaN \n", + "1 NaN NaN NaN NaN NaN \n", + "2 NaN NaN NaN NaN NaN \n", + "3 NaN NaN NaN NaN NaN \n", + "4 NaN NaN NaN NaN NaN \n", + "5 NaN NaN NaN NaN NaN " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from selenium import webdriver\n", + "from time import sleep\n", + "\n", + "import pandas as pd\n", + "from pathlib import Path\n", + "location=Path('/home/dl92/SynologyDrive/Kids/Miri/Spelling')\n", + "fname=location / 'Spelling Flashcards.ods'\n", + "df=pd.read_excel(fname,sheet_name=2 ,engine='odf')\n", + "df\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "ename": "SessionNotCreatedException", + "evalue": "Message: session not created: This version of ChromeDriver only supports Chrome version 87\nCurrent browser version is 92.0.4515.159 with binary path /usr/bin/google-chrome\n", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mSessionNotCreatedException\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mbrowser\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mwebdriver\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mChrome\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'/home/dl92/code/WebDriver/bin/chromedriver'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0mbrowser\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'http://farsilookup.com/e2p/seek.jsp?lang=en'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mtransl\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mword\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mdf\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Spelling'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Envs/ML/lib/python3.6/site-packages/selenium/webdriver/chrome/webdriver.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, executable_path, port, options, service_args, desired_capabilities, service_log_path, chrome_options, keep_alive)\u001b[0m\n\u001b[1;32m 79\u001b[0m \u001b[0mremote_server_addr\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mservice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mservice_url\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 80\u001b[0m keep_alive=keep_alive),\n\u001b[0;32m---> 81\u001b[0;31m desired_capabilities=desired_capabilities)\n\u001b[0m\u001b[1;32m 82\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 83\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mquit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Envs/ML/lib/python3.6/site-packages/selenium/webdriver/remote/webdriver.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, command_executor, desired_capabilities, browser_profile, proxy, keep_alive, file_detector, options)\u001b[0m\n\u001b[1;32m 155\u001b[0m warnings.warn(\"Please use FirefoxOptions to set browser profile\",\n\u001b[1;32m 156\u001b[0m DeprecationWarning, stacklevel=2)\n\u001b[0;32m--> 157\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstart_session\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcapabilities\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbrowser_profile\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 158\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_switch_to\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mSwitchTo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 159\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_mobile\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mMobile\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Envs/ML/lib/python3.6/site-packages/selenium/webdriver/remote/webdriver.py\u001b[0m in \u001b[0;36mstart_session\u001b[0;34m(self, capabilities, browser_profile)\u001b[0m\n\u001b[1;32m 250\u001b[0m parameters = {\"capabilities\": w3c_caps,\n\u001b[1;32m 251\u001b[0m \"desiredCapabilities\": capabilities}\n\u001b[0;32m--> 252\u001b[0;31m \u001b[0mresponse\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexecute\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mCommand\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mNEW_SESSION\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparameters\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 253\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;34m'sessionId'\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mresponse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 254\u001b[0m \u001b[0mresponse\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mresponse\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'value'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Envs/ML/lib/python3.6/site-packages/selenium/webdriver/remote/webdriver.py\u001b[0m in \u001b[0;36mexecute\u001b[0;34m(self, driver_command, params)\u001b[0m\n\u001b[1;32m 319\u001b[0m \u001b[0mresponse\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcommand_executor\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexecute\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdriver_command\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 320\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mresponse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 321\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0merror_handler\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcheck_response\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresponse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 322\u001b[0m response['value'] = self._unwrap_value(\n\u001b[1;32m 323\u001b[0m response.get('value', None))\n", + "\u001b[0;32m~/Envs/ML/lib/python3.6/site-packages/selenium/webdriver/remote/errorhandler.py\u001b[0m in \u001b[0;36mcheck_response\u001b[0;34m(self, response)\u001b[0m\n\u001b[1;32m 240\u001b[0m \u001b[0malert_text\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'alert'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'text'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 241\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mexception_class\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmessage\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mscreen\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstacktrace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0malert_text\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 242\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mexception_class\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmessage\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mscreen\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstacktrace\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 243\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 244\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_value_or_default\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdefault\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mSessionNotCreatedException\u001b[0m: Message: session not created: This version of ChromeDriver only supports Chrome version 87\nCurrent browser version is 92.0.4515.159 with binary path /usr/bin/google-chrome\n" + ] + } + ], + "source": [ + "browser=webdriver.Chrome('/home/dl92/code/WebDriver/bin/chromedriver')\n", + "browser.get('http://farsilookup.com/e2p/seek.jsp?lang=en')\n", + "\n", + "transl={}\n", + "for word in df['Spelling']:\n", + " try:\n", + " browser.find_element_by_id('word').clear()#.send_keys('abandoned')\n", + " browser.find_element_by_id('word').send_keys(word)\n", + " browser.find_element_by_class_name('button-search').click()\n", + " sleep(1)\n", + " res=browser.find_element_by_class_name('mean-ul')\n", + " restxt=res.text\n", + " transl[word]=restxt\n", + " except Exception as e:\n", + " transl[word]=''\n", + " continue\n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "df['Farsi']=pd.Series(transl).values\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [], + "source": [ + "fname=location / 'temp.xlsx'\n", + "df.to_excel(fname)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'addition': '(حساب) جمع، افزایش\\nاضافه شدن، افزودگی\\nهر چیز اضافه شده یا الحاق شده به چیز دیگر، الحاقی، اضافی\\nعنوانی که بعد از اسم فامیل می آید (مثلا : جناب آقای جان اسمیت .John Smith, Esq )',\n", + " 'subtraction': 'کاهش، تفریق، کسر سازی، کاست',\n", + " 'division': 'بخش، تقسیم، جداسازی\\nپخش، توزیع، تسهیم، حصه بری، سهم بری\\nاختلاف (عقیده یا نظر و غیره)، ناهم اندیشی\\n(به ویژه در پارلمان انگلیس) تقسیم شدن به دو یا چند دسته هنگام رای دادن\\nجدا ساز، دیواره، پاراوان، تیغه، مرز، حدفاصل،سرحد\\n(بخشی از هر چیز مثلا کشور یا اداره یا رتبه و غیره) استان، شهرستان، منطقه، دایره، فرشیم، دانگ، بخش، قسمت، دسته، طبقه،عضو، اندام (و غیره)\\n(گیاه شناسی - در برخی روش های رده بندی) شاخه (phylum هم می گویند)\\n(گل کاری و گل پروری) قلمه زنی\\n(ریاضی)تقسیم، تقسیمی، بخشی 0\\n(ارتش) لشکر، (نیروی هوایی) لشکر هوایی (متشکل از دو یا چند تیپ)، (نیروی دریایی) ناوگروه (بخشی از ناوتیپ)',\n", + " 'multiplication': '(ریاضی) عمل ضرب، بس شماری\\nزاد و ولد\\nبرافزایی، تکثیر، ازدیاد',\n", + " 'equation': 'برابر سازی، مساوی سازی، برابر پنداری\\nتساوی، برابری، توازن، تعادل، هم چندی، هم سنگی، هم پایگی، هم ترازی، هم زینگی، مشابهت\\nرجوع شود به Personal equation\\n(مجموعه ی پیچیده) پیچواره، پیچسازه\\n(ریاضی و شیمی) معادله، برابره (دوچیز که برابری آنها با نشان = مشخص می شود مثلا: H2SO4 + 2NaCl = 2HCl + Na2SO4)',\n", + " 'equality': 'برابری، مساوات\\nهم پایگی، هم چندی، هم سنگی، هم ارزی، هم زینگی\\nهمانندی، تشابه\\nهمواری، هم نواختی، همچنانی'}" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "transl" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.6.9 64-bit", + "language": "python", + "name": "python36964bit5aad4b8392a24ab49b91cfc5ab558ab3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.9" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/code/misc/python/scripts/KnighTour.ipynb b/code/misc/python/scripts/KnighTour.ipynb new file mode 100644 index 0000000..abbf4db --- /dev/null +++ b/code/misc/python/scripts/KnighTour.ipynb @@ -0,0 +1,611 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Knight Moves 6\n", + "\n", + "[![](https://www.janestreet.com/puzzles/october-2024.png)](https://www.janestreet.com/puzzles/october-2024.png)\n", + "\n", + "Pick **distinct positive integers** _A_, _B_, and _C_, and place them in the grid above. Your goal is to create two corner-to-corner trips — one from _a1_ to _f6_, and the other from _a6_ to _f1_ — both of which score **exactly 2024 points**.\n", + "\n", + "A “trip” consists of knight’s moves. Squares may **not** be revisited within a trip.\n", + "\n", + "The “score” for a trip is calculated as follows:\n", + "\n", + "- Start with _A_ points.\n", + "- Every time you make a move:\n", + " - if your move is between two _different_ integers, **multiply** your score by the value you are moving to;\n", + " - otherwise, **increment** your score by the value you are moving to.\n", + "\n", + "Can you find positive integers _A_, _B_, and _C_, as well as a pair of trips, that satisfy the criteria above? How low can you get _A_ + _B_ + _C_?\n", + "\n", + "Please format your entry by concatenating your values for _A_, _B_, and _C_, followed by your _a1_-to-_f6_ tour, followed by your _a6_-to-_f1_ tour. For example, “1,2,253,a1,b3,c5,d3,f4,d5,f6,a6,c5,a4,b2,c4,d2,f1” would be a properly formatted entry.\n", + "\n", + "To qualify for the leaderboard your value for _A_ + _B_ + _C_ must be **less than 50**." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "#code\n", + "\n", + "from IPython.core.interactiveshell import InteractiveShell\n", + "InteractiveShell.ast_node_interactivity = \"all\"\n", + "\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "\n", + "def encode_scoregrid(path:str):\n", + " return { (j,i):x+str(y) for i,x in enumerate(['a','b','c','d','e','f']) for j,y in enumerate([1,2,3,4,5,6][::-1])}\n", + "\n", + "def decode_scoregrid():\n", + " return { x+str(y):(j,i) for i,x in enumerate(['a','b','c','d','e','f']) for j,y in enumerate([1,2,3,4,5,6][::-1])}\n", + "\n", + "def calc_score_tuple(tuplepaths,scoregrid):\n", + " \n", + " prevpos=None\n", + " score=None\n", + " for i,pos in enumerate(tuplepaths):\n", + " \n", + " if i==0:\n", + " prevpos=pos\n", + " score=scoregrid[pos]\n", + " elif scoregrid[prevpos]==scoregrid[pos]:\n", + " score+=scoregrid[pos]\n", + " prevpos=pos\n", + " else:\n", + " score*=scoregrid[pos]\n", + " prevpos=pos\n", + "\n", + " return score\n", + " \n", + "def calc_score_str(path,scoregrid:str):\n", + " decode=decode_scoregrid()\n", + " path = path.split(',')\n", + "\n", + " return calc_score_tuple([decode[x] for x in path],scoregrid)\n", + " \n", + " \n", + " \n", + "\n", + "class KnightTour:\n", + "\n", + " def __init__(self,pos,prevpos,posstr,score,tours,nmoves):\n", + "\n", + " \n", + " self.currpos=pos\n", + " self.prevpos= prevpos\n", + " self.curposstr=posstr\n", + " self.currscore=score\n", + " self.tours=tours\n", + " self.nummoves=nmoves\n", + " \n", + "\n", + "\n", + " def __repr__(self):\n", + " return f'tour={self.tours}, score={self.currscore}'\n", + "\n", + "class Grid:\n", + "\n", + " def __init__(self,dims=(6,6)):\n", + " \n", + "\n", + " xlabel_i2key = {0:'a',1:'b',2:'c',3:'d',4:'e',5:'f'}\n", + " ylabel_i2key = {0:6,1:5,2:4,3:3,4:2,5:1}\n", + " xlabel_key2i ={v:k for k,v in xlabel_i2key.items()}\n", + " ylabel_key2i ={v:k for k,v in ylabel_i2key.items()}\n", + "\n", + " #construct keys for the grid\n", + " self.key_gindex={(x+str(y)):(xlabel_key2i[x],ylabel_key2i[y]) for x in ['a','b','c','d','e','f'] for y in [1,2,3,4,5,6]}\n", + " self.gindex_key ={v:k for k,v in self.key_gindex.items()}\n", + "\n", + " #kight moves on grid\n", + " self.moves = [(2,1),(1,2),(-1,2),(-2,1),(-2,-1),(-1,-2),(1,-2),(2,-1)]\n", + "\n", + " self.dims = dims\n", + " self.successfull_tours = None\n", + " self.ls_knighttours = None\n", + " self.score=np.zeros(dtype='int',shape=dims)\n", + "\n", + " def scoregrid (self, A,B,C):\n", + "\n", + " self.score[:,:]=B \n", + " self.score[:,0]=A\n", + " self.score[-4:,1]=A\n", + " self.score[-2:,2]=A\n", + " self.score[:,-1]=C\n", + " self.score[:4,-2]=C\n", + " self.score[:2,-3]=C\n", + " #return self.score\n", + " \n", + " def calcscore_at_nextpos(self,prev_score,init_pos,next_pos):\n", + " #care numpy array indexing, row first then column\n", + " #pos is x,y == (column,row) therefore reverse indexing\n", + "\n", + " if self.score[init_pos[::-1]]==self.score[next_pos[::-1]]:\n", + " return prev_score+self.score[next_pos[::-1]]\n", + " else:\n", + " return prev_score*self.score[next_pos[::-1]]\n", + "\n", + "\n", + " score = prev_score[next_pos] - prev_score[init_pos]\n", + " return score\n", + "\n", + "\n", + " def tour(self,a,b,c,init_pos:tuple,dest_pos:tuple,numsteps:int):\n", + " \n", + " self.successfull_tours = None\n", + " self.ls_knighttours = None\n", + " self.scoregrid(a,b,c)\n", + " score=a\n", + " posstr = self.gindex_key[init_pos]\n", + " ls_knighttours=KnightTour(init_pos,init_pos,posstr,score,posstr,1)\n", + " \n", + " self.run_knight_tours(numsteps,dest_pos,1,[ls_knighttours],[])\n", + " #print(self.successfull_tours)\n", + " return (pd.DataFrame([(t.tours,t.nummoves,t.currscore) for t in self.successfull_tours],\n", + " columns=['tour','nmoves','score'])\n", + " .assign(score=lambda df: df.apply(lambda r: calc_score_str(r['tour'],self.score),axis=1))\n", + " .sort_values(by='score',ascending=False)\n", + " .pipe(lambda x: x[x.score==2024])\n", + " .head(1)\n", + " )\n", + " \n", + "\n", + "\n", + "\n", + " def run_knight_tours(self,numsteps,dest:tuple,iter,ls_knighttours:list,successfull_tours:list):\n", + " #knight move in x,y coordinate system different to indexing of arrays!\n", + " \n", + " if iter == numsteps:\n", + " self.ls_knighttours=ls_knighttours\n", + " self.successfull_tours=successfull_tours\n", + " return \n", + " \n", + " newscore=0\n", + " newls_knighttours = [] \n", + " for aknighttour in ls_knighttours:\n", + "\n", + " prevpos= aknighttour.prevpos\n", + " pos= aknighttour.currpos\n", + " score= aknighttour.currscore\n", + "\n", + " #check if the tour is complete!\n", + " #if pos[0]==dest[0] and pos[1]==dest[1]: #reached f6 f1\n", + " # successfull_tours.append(aknighttour)\n", + " # continue\n", + " \n", + " for move in self.moves: #all possible moves\n", + " x_new = pos[0]+move[0]\n", + " y_new = pos[1]+move[1]\n", + "\n", + " \n", + " if (x_new >= 0 and x_new< self.dims[0] and y_new >= 0 and y_new < self.dims[1]): #check if the move is valid \n", + " \n", + " #make sure new move does not go backwards!\n", + " if (x_new == prevpos[0] and y_new == prevpos[1]):\n", + " continue\n", + " \n", + "\n", + " #newscore=self.calcscore_at_nextpos(score,(pos[0],pos[1]),(x_new,y_new))\n", + " posstr = self.gindex_key[(x_new,y_new)]\n", + "\n", + " #now for each valid move, create corresponding paths/score\n", + " updatedtour=aknighttour.tours +','+posstr\n", + "\n", + " newknighttour=KnightTour((x_new,y_new),pos,posstr,newscore,updatedtour,aknighttour.nummoves+1)\n", + " if x_new==dest[0] and y_new==dest[1]: #reached f6 f1\n", + " successfull_tours.append(newknighttour)\n", + " else: \n", + " newls_knighttours.append(newknighttour)\n", + "\n", + "\n", + " return self.run_knight_tours(numsteps,dest,iter+1,newls_knighttours,successfull_tours)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'a1,b3,d2,c4,d6,e4,f6'" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "N=7\n", + "gobj=Grid()\n", + "res_a1_f6=gobj.tour(1,2,253,(0,5),(5,0),N)\n", + "\n", + "res_a6_f1=gobj.tour(1,2,253,(0,0),(5,5),N)\n", + "\n", + "res_a1_f6.iloc[0,0]\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 2 3 6\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "gobj=Grid()\n", + "N=15\n", + "\n", + "counter=0\n", + "\n", + "outputs=[]\n", + "scores=[]\n", + "ids=[]\n", + "for i in range(1,51):\n", + " for j in range(1,51):\n", + " for k in range(1,51):\n", + " if (i !=j) and (j!=k) and (i!=k):\n", + " sum=i+j+k\n", + " if sum<=6:\n", + " #print(counter)\n", + " print(i,j,k,sum)\n", + " res_a6_f1=gobj.tour(i,j,k,(0,0),(5,5),N)\n", + " res_a1_f6=gobj.tour(i,j,k,(0,5),(5,0),N)\n", + "\n", + "\n", + " if res_a6_f1.empty==False and res_a1_f6.empty==False:\n", + " if res_a1_f6.iloc[0,2]==res_a1_f6.iloc[0,2]:\n", + " op=f'{i},{j},{k},{res_a1_f6.iloc[0,0]},{res_a6_f1.iloc[0,0]}'\n", + " ids.append(counter)\n", + " scores.append(sum)\n", + " outputs.append(op)\n", + " print(counter,sum,op) \n", + " counter+=1\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gobj.tour(40,5,6,(0,0),(5,5),4)\n", + "gobj.successfull_tours" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "#code\n", + "score=np.zeros(dtype='int',shape=(6,6))\n", + "\n", + "def encode_scoregrid(path:str):\n", + " return { (j,i):x+str(y) for i,x in enumerate(['a','b','c','d','e','f']) for j,y in enumerate([1,2,3,4,5,6][::-1])}\n", + "\n", + "def decode_scoregrid():\n", + " return { x+str(y):(j,i) for i,x in enumerate(['a','b','c','d','e','f']) for j,y in enumerate([1,2,3,4,5,6][::-1])}\n", + " \n", + "def f_scoregrid (A,B,C):\n", + "\n", + " score[:,:]=B \n", + " score[:,0]=A\n", + " score[-4:,1]=A\n", + " score[-2:,2]=A\n", + " score[:,-1]=C\n", + " score[:4,-2]=C\n", + " score[:2,-3]=C\n", + " return score\n", + "\n", + "scoregrid=f_scoregrid(1,2,253)\n", + "\n", + "def calc_score_tuple(tuplepaths,scoregrid):\n", + " \n", + " prevpos=None\n", + " score=None\n", + " for i,pos in enumerate(tuplepaths):\n", + " \n", + " if i==0:\n", + " prevpos=pos\n", + " score=scoregrid[pos]\n", + " elif scoregrid[prevpos]==scoregrid[pos]:\n", + " score+=scoregrid[pos]\n", + " prevpos=pos\n", + " else:\n", + " score*=scoregrid[pos]\n", + " prevpos=pos\n", + "\n", + " return score\n", + " \n", + "def calc_score_str(path,scoregrid:str):\n", + " decode=decode_scoregrid()\n", + " path = path.split(',')\n", + "\n", + " return calc_score_tuple([decode[x] for x in path],scoregrid)\n", + " \n", + " \n", + " \n", + " # return res " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'calc_score' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[3], line 4\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m#a6,b4,c6,d4,f3,d2,e4,f6, score=111\u001b[39;00m\n\u001b[1;32m 2\u001b[0m scoregrid\u001b[38;5;241m=\u001b[39mf_scoregrid(\u001b[38;5;241m1\u001b[39m,\u001b[38;5;241m2\u001b[39m,\u001b[38;5;241m253\u001b[39m)\n\u001b[0;32m----> 4\u001b[0m \u001b[43mcalc_score\u001b[49m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124ma6,b4,c6,d4,f3,d2,e4,f6\u001b[39m\u001b[38;5;124m'\u001b[39m,scoregrid)\n", + "\u001b[0;31mNameError\u001b[0m: name 'calc_score' is not defined" + ] + } + ], + "source": [ + "#a6,b4,c6,d4,f3,d2,e4,f6, score=111\n", + "scoregrid=f_scoregrid(1,2,253)\n", + "\n", + "calc_score('a6,b4,c6,d4,f3,d2,e4,f6',scoregrid)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[np.int64(2024),\n", + " np.int64(2024),\n", + " np.int64(2024),\n", + " np.int64(2024),\n", + " np.int64(2024),\n", + " np.int64(2024),\n", + " np.int64(2024)]" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scores=['a6,b4,a2,c3,d5,e3,f1',\n", + "'a6,c5,b3,a5,c4,d2,f1',\n", + "'a6,b4,c2,d4,f5,e3,f1',\n", + "'a6,b4,c6,d4,f5,e3,f1',\n", + "'a6,c5,a4,c3,b1,d2,f1',\n", + "'a6,c5,a4,b2,c4,d2,f1',\n", + "'a6,c5,a4,b6,c4,d2,f1'\n", + "]\n", + "\n", + "[calc_score_str(x,scoregrid) for x in scores]\n", + "\n", + "#calc_score_str('a1,b3,c5,d3,f4,d5,f6',scoregrid)\n", + "#calc_score_str('a6,c5,a4,b2,c4,d2,f1',scoregrid)\n", + "#calc_score_tuple([(5, 0), (3, 1), (1, 2), (3, 3), (2, 5), (1, 3), (0, 5)],scoregrid)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.int64(2024)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "np.int64(2024)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scoregrid=f_scoregrid(1,5,2)\n", + "calc_score_str('a1,c2,d4,f3,d2,f1,e3,d1,f2,e4,f6',scoregrid)\n", + "calc_score_str('a6,c5,d3,e5,c4,d6,e4,c3,d5,e3,f1',scoregrid)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# joojoo score" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.int64(2024)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "np.int64(2024)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "scoregrid=f_scoregrid(3,1,2)\n", + "calc_score_str('a1,c2,e3,c4,a5,c6,d4,b3,c5,d3,b2,d1,c3,b1,d2,e4,f6',scoregrid)\n", + "\n", + "calc_score_str('a6,b4,d5,c3,a4,c5,d3,c1,e2,d4,b3,d2,c4,b2,d1,e3,f1',scoregrid)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# joojoo score v2" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.int64(2024)" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "np.int64(2024)" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "scoregrid=f_scoregrid(1,3,2)\n", + "calc_score_str('a1,c2,b4,c6,e5,d3,f2,e4,d6,c4,a3,b1,c3,d5,f6',scoregrid)\n", + "\n", + "calc_score_str('a6,b4,c2,e1,f3,d4,f5,d6,e4,c3,b1,a3,c4,e3,f1',scoregrid)" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[(5, 0), (3, 1), (1, 2), (3, 3), (2, 5), (1, 3), (0, 5)]" + ] + }, + "execution_count": 74, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "[(0, 0), (1, 2), (2, 0), (4, 1), (2, 2), (4, 3), (5, 5)]" + ] + }, + "execution_count": 74, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "decode=decode_scoregrid()\n", + "[decode[k] for k in 'a1,b3,c5,d3,f4,d5,f6'.split(',')]\n", + "[decode[k] for k in 'a6,c5,a4,b2,c4,d2,f1'.split(',')]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "General", + "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.11.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/code/misc/python/scripts/MITM/.gitignore b/code/misc/python/scripts/MITM/.gitignore new file mode 100644 index 0000000..a846951 --- /dev/null +++ b/code/misc/python/scripts/MITM/.gitignore @@ -0,0 +1,14 @@ +*.pyc +*.db +*.python-version +/.quarto/ +.ipynb_checkpoints + +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# IPython +profile_default/ +ipython_config.py diff --git a/code/misc/python/scripts/MITM/Terms-to-Block.csv b/code/misc/python/scripts/MITM/Terms-to-Block.csv new file mode 100644 index 0000000..fffe8e0 --- /dev/null +++ b/code/misc/python/scripts/MITM/Terms-to-Block.csv @@ -0,0 +1,719 @@ +anal +analprobe +anilingus +anus +areola +areole +arian +aryan +ass +assbang +assbanged +assbangs +asses +assfuck +assfucker +assh0le +asshat +assho1e +ass hole +assholes +assmaster +assmunch +asswipe +asswipes +azazel +azz +b1tch +babe +babes +ballsack +bang +banger +barf +bastard +bastards +bawdy +beaner +beardedclam +beastiality +beatch +beater +beaver +beer +beeyotch +beotch +biatch +bigtits +big tits +bimbo +bitch +bitched +bitches +bitchy +blow job +blow +blowjob +blowjobs +bod +bodily +boink +bollock +bollocks +bollok +bone +boned +boner +boners +bong +boob +boobies +boobs +booby +booger +bookie +bootee +bootie +booty +booze +boozer +boozy +bosom +bosomy +bowel +bowels +bra +brassiere +breast +breasts +bugger +bukkake +bullshit +bull shit +bullshits +bullshitted +bullturds +bung +busty +butt +butt fuck +buttfuck +buttfucker +buttfucker +buttplug +c.0.c.k +c.o.c.k. +c.u.n.t +c0ck +c-0-c-k +caca +cahone +cameltoe +carpetmuncher +cawk +cervix +chinc +chincs +chink +chink +chode +chodes +cl1t +climax +clit +clitoris +clitorus +clits +clitty +cocain +cocaine +cock +c-o-c-k +cockblock +cockholster +cockknocker +cocks +cocksmoker +cocksucker +cock sucker +coital +commie +condom +coon +coons +corksucker +crabs +crack +cracker +crackwhore +crap +crappy +cum +cummin +cumming +cumshot +cumshots +cumslut +cumstain +cunilingus +cunnilingus +cunny +cunt +cunt +c-u-n-t +cuntface +cunthunter +cuntlick +cuntlicker +cunts +d0ng +d0uch3 +d0uche +d1ck +d1ld0 +d1ldo +dago +dagos +dammit +damn +damned +damnit +dawgie-style +dick +dickbag +dickdipper +dickface +dickflipper +dickhead +dickheads +dickish +dick-ish +dickripper +dicksipper +dickweed +dickwhipper +dickzipper +diddle +dike +dildo +dildos +diligaf +dillweed +dimwit +dingle +dipship +doggie-style +doggy-style +dong +doofus +doosh +dopey +douch3 +douche +douchebag +douchebags +douchey +drunk +dumass +dumbass +dumbasses +dummy +dyke +dykes +ejaculate +enlargement +erect +erection +erotic +essohbee +extacy +extasy +f.u.c.k +fack +fag +fagg +fagged +faggit +faggot +fagot +fags +faig +faigt +fannybandit +fart +fartknocker +fat +felch +felcher +felching +fellate +fellatio +feltch +feltcher +fisted +fisting +fisty +floozy +foad +fondle +foobar +foreskin +freex +frigg +frigga +fubar +fuck +f-u-c-k +fuckass +fucked +fucked +fucker +fuckface +fuckin +fucking +fucknugget +fucknut +fuckoff +fucks +fucktard +fuck-tard +fuckup +fuckwad +fuckwit +fudgepacker +fuk +fvck +fxck +gae +gai +ganja +gay +gays +gey +gfy +ghay +ghey +gigolo +glans +goatse +godamn +godamnit +goddam +goddammit +goddamn +goldenshower +gonad +gonads +gook +gooks +gringo +gspot +g-spot +gtfo +guido +h0m0 +h0mo +handjob +hard on +he11 +hebe +heeb +hell +hemp +heroin +herp +herpes +herpy +hitler +hiv +hobag +hom0 +homey +homo +homoey +honky +hooch +hookah +hooker +hoor +hootch +hooter +hooters +horny +hump +humped +humping +hussy +hymen +inbred +incest +injun +j3rk0ff +jackass +jackhole +jackoff +jap +japs +jerk +jerk0ff +jerked +jerkoff +jism +jiz +jizm +jizz +jizzed +junkie +junky +kike +kikes +kill +kinky +kkk +klan +knobend +kooch +kooches +kootch +kraut +kyke +labia +lech +leper +lesbians +lesbo +lesbos +lez +lezbian +lezbians +lezbo +lezbos +lezzie +lezzies +lezzy +lmao +lmfao +loin +loins +lube +lusty +mams +massa +masterbate +masterbating +masterbation +masturbate +masturbating +masturbation +maxi +menses +menstruate +menstruation +meth +m-fucking +mofo +molest +moolie +moron +motherfucka +motherfucker +motherfucking +mtherfucker +mthrfucker +mthrfucking +muff +muffdiver +murder +muthafuckaz +muthafucker +mutherfucker +mutherfucking +muthrfucking +nad +nads +naked +napalm +nappy +nazi +nazism +negro +nigga +niggah +niggas +niggaz +nigger +nigger +niggers +niggle +niglet +nimrod +ninny +nipple +nooky +nympho +opiate +opium +oral +orally +organ +orgasm +orgasmic +orgies +orgy +ovary +ovum +ovums +p.u.s.s.y. +paddy +paki +pantie +panties +panty +pastie +pasty +pcp +pecker +pedo +pedophile +pedophilia +pedophiliac +pee +peepee +penetrate +penetration +penial +penile +penis +perversion +peyote +phalli +phallic +phuck +pillowbiter +pimp +pinko +piss +pissed +pissoff +piss-off +pms +polack +pollock +poon +poontang +porn +porno +pornography +pot +potty +prick +prig +prostitute +prude +pube +pubic +pubis +punkass +punky +puss +pussies +pussy +pussypounder +puto +queaf +queef +queef +queer +queero +queers +quicky +quim +racy +rape +raped +raper +rapist +raunch +rectal +rectum +rectus +reefer +reetard +reich +retard +retarded +revue +rimjob +ritard +rtard +r-tard +rum +rump +rumprammer +ruski +s.h.i.t. +s.o.b. +s0b +sadism +sadist +scag +scantily +schizo +schlong +screw +screwed +scrog +scrot +scrote +scrotum +scrud +scum +seaman +seamen +seduce +semen +sex +sexual +sh1t +s-h-1-t +shamedame +shit +s-h-i-t +shite +shiteater +shitface +shithead +shithole +shithouse +shits +shitt +shitted +shitter +shitty +shiz +sissy +skag +skank +slave +sleaze +sleazy +slut +slutdumper +slutkiss +sluts +smegma +smut +smutty +snatch +sniper +snuff +s-o-b +sodom +souse +soused +sperm +spic +spick +spik +spiks +spooge +spunk +steamy +stfu +stiffy +stoned +strip +stroke +stupid +suck +sucked +sucking +sumofabiatch +t1t +tampon +tard +tawdry +teabagging +teat +terd +teste +testee +testes +testicle +testis +thrust +thug +tinkle +tit +titfuck +titi +tits +tittiefucker +titties +titty +tittyfuck +tittyfucker +toke +toots +tramp +transsexual +trashy +tubgirl +turd +tush +twat +twats +ugly +undies +unwed +urinal +urine +uterus +uzi +vag +vagina +valium +viagra +virgin +vixen +vodka +vomit +voyeur +vulgar +vulva +wad +wang +wank +wanker +wazoo +wedgie +weed +weenie +weewee +weiner +weirdo +wench +wetback +wh0re +wh0reface +whitey +whiz +whoralicious +whore +whorealicious +whored +whoreface +whorehopper +whorehouse +whores +whoring +wigger +womb +woody +wop +wtf +x-rated +xxx +yeasty +yobbo +zoophile diff --git a/code/misc/python/scripts/MITM/app.py b/code/misc/python/scripts/MITM/app.py new file mode 100644 index 0000000..eb322a2 --- /dev/null +++ b/code/misc/python/scripts/MITM/app.py @@ -0,0 +1,113 @@ +from flask import Flask, render_template, redirect, url_for, request, flash +from flask_sqlalchemy import SQLAlchemy +from flask_login import LoginManager, UserMixin, login_user, login_required, logout_user, current_user +from werkzeug.security import generate_password_hash, check_password_hash +import getpass,datetime + +app = Flask(__name__) +app.secret_key = 'your_secret_key' +app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///app.db' +db = SQLAlchemy(app) +login_manager = LoginManager() +login_manager.init_app(app) +login_manager.login_view = 'login' + +class User(UserMixin, db.Model): + id = db.Column(db.Integer, primary_key=True) + username = db.Column(db.String(150), unique=True, nullable=False) + password_hash = db.Column(db.String(150), nullable=False) + must_change_password = db.Column(db.Boolean, default=True, nullable=False) + + def __init__(self, username, password, must_change_password=True): + self.username = username + self.password_hash = generate_password_hash(password) + self.must_change_password = must_change_password + + def check_password(self, password): + return check_password_hash(self.password_hash, password) + +class UserRequest(db.Model): + id = db.Column(db.Integer, primary_key=True) + url = db.Column(db.String(500), nullable=False) + reason = db.Column(db.String(500), nullable=False) + status = db.Column(db.String(50), nullable=False, default='pending') + user = db.Column(db.String(150), nullable=False) + mac_address = db.Column(db.String(50), nullable=False) + ip_address = db.Column(db.String(50), nullable=False) + timestamp = db.Column(db.DateTime, nullable=False) + +@login_manager.user_loader +def load_user(user_id): + return User.query.get(int(user_id)) + +@app.route('/login', methods=['GET', 'POST']) +def login(): + if request.method == 'POST': + username = request.form['username'] + password = request.form['password'] + user = User.query.filter_by(username=username).first() + if user and user.check_password(password): + login_user(user) + if user.must_change_password: + return redirect(url_for('change_password')) + return redirect(url_for('admin')) + else: + flash('Invalid username or password') + return render_template('login.html') + +@app.route('/logout') +@login_required +def logout(): + logout_user() + return redirect(url_for('login')) + +@app.route('/change_password', methods=['GET', 'POST']) +@login_required +def change_password(): + if request.method == 'POST': + new_password = request.form['new_password'] + current_user.password_hash = generate_password_hash(new_password) + current_user.must_change_password = False + db.session.commit() + flash('Password changed successfully') + return redirect(url_for('admin')) + return render_template('change_password.html') + +@app.route('/admin') +@login_required +def admin(): + requests = UserRequest.query.all() + return render_template('admin.html', requests=requests) + +@app.route('/') +def index(): + return render_template('index.html') + +@app.route('/whitelist', methods=['POST']) +def whitelist(): + url = request.form['url'] + reason = request.form['reason'] + user = current_user.username if current_user.is_authenticated else 'anonymous' + mac_address = '00:00:00:00:00:00' # Placeholder, replace with actual MAC address retrieval logic + ip_address = request.remote_addr # Gets the IP address of the client + timestamp = datetime.utcnow() + new_request = UserRequest(url=url, reason=reason, user=user, mac_address=mac_address, ip_address=ip_address, timestamp=timestamp) + db.session.add(new_request) + db.session.commit() + return redirect(url_for('index')) + +def create_admin_user(): + admin_user = User.query.filter_by(username='admin').first() + if not admin_user: + print("No admin user found. Please set a password for the admin user.") + password = getpass.getpass("Enter password for admin user: ") + admin_user = User(username='admin', password=password) + db.session.add(admin_user) + db.session.commit() + print("Admin user created successfully.") + +if __name__ == '__main__': + with app.app_context(): + db.create_all() + create_admin_user() + app.run(debug=True) \ No newline at end of file diff --git a/code/misc/python/scripts/MITM/appv1.py b/code/misc/python/scripts/MITM/appv1.py new file mode 100644 index 0000000..e7aaebc --- /dev/null +++ b/code/misc/python/scripts/MITM/appv1.py @@ -0,0 +1,133 @@ +from flask import Flask, request, render_template, redirect, url_for, session +from flask_sqlalchemy import SQLAlchemy +from werkzeug.security import generate_password_hash, check_password_hash +from datetime import datetime, timedelta +from scapy.all import ARP, Ether, srp + +app = Flask(__name__) +app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///whitelist.db' +app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False +app.secret_key = 'supersecretkey' +app.config['PERMANENT_SESSION_LIFETIME'] = timedelta(minutes=5) +db = SQLAlchemy(app) + +class Whitelist(db.Model): + id = db.Column(db.Integer, primary_key=True) + url = db.Column(db.String(255), unique=True, nullable=False) + +class Request(db.Model): + id = db.Column(db.Integer, primary_key=True) + url = db.Column(db.String(255), nullable=False) + reason = db.Column(db.String(255), nullable=False) + status = db.Column(db.String(50), nullable=False, default='pending') + timestamp = db.Column(db.DateTime, nullable=False, default=datetime.utcnow) + mac_address = db.Column(db.String(17), nullable=False) + ip_address = db.Column(db.String(45), nullable=False) + +class Admin(db.Model): + id = db.Column(db.Integer, primary_key=True) + password = db.Column(db.String(255), nullable=False) + + + +def get_mac_address(ip_address): + try: + # Create an ARP request packet + arp_request = ARP(pdst=ip_address) + # Create an Ethernet frame to encapsulate the ARP request + ether = Ether(dst="ff:ff:ff:ff:ff:ff") + # Combine the Ethernet frame and ARP request + packet = ether / arp_request + # Send the packet and capture the response + result = srp(packet, timeout=3, verbose=False)[0] + # Extract the MAC address from the response + mac_address = result[0][1].hwsrc + return mac_address + except Exception as e: + print(f"Error getting MAC address: {e}") + return "00:00:00:00:00:00" + +@app.route('/set_admin_password', methods=['GET', 'POST']) +def set_admin_password(): + if Admin.query.first(): + return redirect(url_for('admin_login')) + if request.method == 'POST': + password = request.form['password'] + hashed_password = generate_password_hash(password) + new_admin = Admin(password=hashed_password) + db.session.add(new_admin) + db.session.commit() + return redirect(url_for('admin_login')) + return render_template('set_admin_password.html') + +@app.route('/admin_login', methods=['GET', 'POST']) +def admin_login(): + if request.method == 'POST': + password = request.form['password'] + admin = Admin.query.first() + if admin and check_password_hash(admin.password, password): + session['admin_logged_in'] = True + session.permanent = True # Mark the session as permanent + return redirect(url_for('admin')) + else: + return "Invalid password" + return render_template('admin_login.html') + +@app.route('/admin_logout') +def admin_logout(): + session.pop('admin_logged_in', None) + return redirect(url_for('admin_login')) + +@app.route('/admin', methods=['GET', 'POST']) +def admin(): + if not session.get('admin_logged_in'): + return redirect(url_for('admin_login')) + if request.method == 'POST': + action = request.form['action'] + url = request.form['url'] + req = Request.query.filter_by(url=url).first() + if req: + if action == 'approve': + req.status = 'approved' + if not Whitelist.query.filter_by(url=url).first(): + new_whitelist = Whitelist(url=url) + db.session.add(new_whitelist) + elif action == 'reject': + req.status = 'rejected' + whitelist_entry = Whitelist.query.filter_by(url=url).first() + if whitelist_entry: + db.session.delete(whitelist_entry) + elif action == 'revoke': + req.status = 'revoked' + whitelist_entry = Whitelist.query.filter_by(url=url).first() + if whitelist_entry: + db.session.delete(whitelist_entry) + db.session.commit() + return redirect(url_for('admin')) + requests = Request.query.all() + whitelist = Whitelist.query.all() + return render_template('admin.html', requests=requests, whitelist=whitelist) + +@app.route('/whitelist', methods=['GET']) +def get_whitelist(): + whitelist = Whitelist.query.all() + return {"whitelist": [entry.url for entry in whitelist]} + +@app.route('/', methods=['GET', 'POST']) +def request_whitelist(): + if request.method == 'POST': + url = request.form['url'] + reason = request.form['reason'] + ip_address = request.remote_addr + mac_address = get_mac_address(ip_address) + new_request = Request(url=url, reason=reason, mac_address=mac_address, ip_address=ip_address) + db.session.add(new_request) + db.session.commit() + return redirect(url_for('request_whitelist')) + return render_template('request.html') + +if __name__ == '__main__': + with app.app_context(): + db.create_all() + + app.run(debug=True) \ No newline at end of file diff --git a/code/misc/python/scripts/MITM/driver.py b/code/misc/python/scripts/MITM/driver.py new file mode 100644 index 0000000..c9c776e --- /dev/null +++ b/code/misc/python/scripts/MITM/driver.py @@ -0,0 +1,209 @@ +import asyncio +import sys +import re +import zlib +import json +import csv +import requests +from mitmproxy import http, ctx +from mitmproxy import options +from mitmproxy.tools import dump +import sqlite3 +from bs4 import BeautifulSoup + +# Method 1: Load blocked words from a CSV file +def load_blocked_words_from_csv(file_path): + """ + Loads blocked words from a CSV file. + + Args: + file_path (str): The path to the CSV file containing blocked words. + + Returns: + list: A list of blocked words loaded from the CSV file. + """ + blocked_words = [] + with open(file_path, newline='') as csvfile: + reader = csv.reader(csvfile) + for row in reader: + blocked_words.extend(row) + return blocked_words + +# Method 2: Load blocked words from a web service +def load_blocked_words_from_web_service(url): + """ + Fetches blocked words from a web service. + + Args: + url (str): The URL of the web service to fetch blocked words from. + + Returns: + list: A list of blocked words. + """ + try: + response = requests.get(url) + response.raise_for_status() # Raise an error for bad status codes + blocked_words = response.json() # Assuming the response is a JSON array of words + return blocked_words + except requests.RequestException as e: + ctx.log.error(f"Error fetching blocked words: {e}") + return [] + +# Load blocked words from the web service +blocked_words = ['fdhfghrth']#load_blocked_words_from_csv('Terms-to-Block.csv') +#blocked_words = load_blocked_words_from_web_service('https://example.com/api/blocked_words') + +# Compile a regex pattern for blocked words +pattern = re.compile(r'\b(?:' + '|'.join(re.escape(word) for word in blocked_words) + r')\b', re.IGNORECASE) + +def check_string_in_list(target_string, string_list): + """ + Checks if any string in a list is present in the target string. + + Args: + target_string (str): The string to search within. + string_list (list): The list of strings to search for. + + Returns: + bool: True if any string in the list is found in the target string, False otherwise. + """ + return any(item in target_string for item in string_list) + +def search_blocked_words_in_json(data, pattern): + """ + Recursively searches for blocked words in a JSON object. + + Args: + data (dict or list or str): The JSON data to search within. + pattern (re.Pattern): The compiled regex pattern for blocked words. + + Returns: + list: A list of matches found in the JSON data. + """ + matches = [] + if isinstance(data, dict): + for key, value in data.items(): + matches.extend(search_blocked_words_in_json(value, pattern)) + elif isinstance(data, list): + for item in data: + matches.extend(search_blocked_words_in_json(item, pattern)) + elif isinstance(data, str): + matches.extend(pattern.findall(data)) + return matches + +class RequestLogger: + """ + A class to log and filter HTTP requests and responses. + """ + def __init__(self): + """ + Initializes the RequestLogger and loads the whitelist. + """ + self.whitelist = [] + asyncio.create_task(self.load_whitelist_periodically()) + + async def load_whitelist(self): + """ + Loads the whitelist from the SQLite database. + + Returns: + list: A list of whitelisted URLs. + """ + conn = sqlite3.connect('whitelist.db') + c = conn.cursor() + c.execute("SELECT url FROM whitelist WHERE status='approved'") + self.whitelist = [row[0] for row in c.fetchall()] + conn.close() + + async def load_whitelist_periodically(self): + """ + Periodically loads the whitelist every 20 seconds. + """ + while True: + await self.load_whitelist() + await asyncio.sleep(20) + + def request(self, flow: http.HTTPFlow): + """ + Handles HTTP requests. Blocks requests to non-whitelisted URLs. + + Args: + flow (http.HTTPFlow): The HTTP flow object. + """ + if flow.request.pretty_host not in self.whitelist: + ctx.log.info('Blocked request to %s' % flow.request.host) + flow.response = http.Response.make( + 403, # Forbidden status code + b"Blocked by URL whitelist", # Response content + {"Content-Type": "text/plain"} # Response headers + ) + return + + def response(self, flow: http.HTTPFlow): + """ + Handles HTTP responses. Searches for blocked words in the response content. + + Args: + flow (http.HTTPFlow): The HTTP flow object. + """ + content_type = flow.response.headers.get("Content-Type", "") + content = flow.response.content + + # Handle compressed content + if "gzip" in flow.response.headers.get("Content-Encoding", ""): + content = zlib.decompress(content, zlib.MAX_WBITS | 16) + + if "deflate" in flow.response.headers.get("Content-Encoding", ""): + content = zlib.decompress(content) + + # Decode content to text + if isinstance(content, bytes): + content = content.decode('utf-8', errors='ignore') + + # Check if content is HTML + if "text/html" in content_type: + soup = BeautifulSoup(content, 'html.parser') + text = soup.get_text() + matches = pattern.findall(text) + elif "application/json" in content_type: + data = json.loads(content) + matches = search_blocked_words_in_json(data, pattern) + else: + matches = [] + + # Search for matches in the text content + if matches: + matched_keyword = matches[0] + flow.response.text = 'response contains filtered contents' + ctx.log.error(matched_keyword) + + flow.response = http.Response.make( + 200, # (optional) status code + b"Hello World", # (optional) content + {"Content-Type": "text/html"}, # (optional) headers + ) + +async def start_proxy(host, port): + """ + Starts the proxy server. + + Args: + host (str): The host address to listen on. + port (int): The port to listen on. + """ + opts = options.Options(listen_host=host, listen_port=port) + + master = dump.DumpMaster( + opts, + with_termlog=False, + with_dumper=False, + ) + master.addons.add(RequestLogger()) + + await master.run() + return master + +if __name__ == '__main__': + host = sys.argv[1] + port = int(sys.argv[2]) + asyncio.run(start_proxy(host, port)) \ No newline at end of file diff --git a/code/misc/python/scripts/MITM/myaddon.py b/code/misc/python/scripts/MITM/myaddon.py new file mode 100644 index 0000000..8f7405e --- /dev/null +++ b/code/misc/python/scripts/MITM/myaddon.py @@ -0,0 +1,9 @@ +import mitmproxy.http + +class MyAddon: + def request(self, flow: mitmproxy.http.HTTPFlow) -> None: + print(flow.request.url) + +addons = [ + MyAddon() +] \ No newline at end of file diff --git a/code/misc/python/scripts/MITM/templates/admin.html b/code/misc/python/scripts/MITM/templates/admin.html new file mode 100644 index 0000000..78df24e --- /dev/null +++ b/code/misc/python/scripts/MITM/templates/admin.html @@ -0,0 +1,67 @@ + + + + Admin Dashboard + + + +
+

Admin Dashboard

+ Logout +

Pending Requests

+ + + + + + + + + + + + + + {% for req in requests %} + + + + + + + + + + {% endfor %} + +
URL/DomainReasonStatusDate & TimeIP AddressMAC AddressAction
{{ req.url }}{{ req.reason }}{{ req.status }}{{ req.timestamp }}{{ req.ip_address }}{{ req.mac_address }} +
+ + + +
+
+ + + +
+
+

Whitelisted URLs/Domains

+
    + {% for url in whitelist %} +
  • + {{ url.url }} +
    + + + +
    +
    • + {% endfor %} +
+
+ + + + + \ No newline at end of file diff --git a/code/misc/python/scripts/MITM/templates/admin_login.html b/code/misc/python/scripts/MITM/templates/admin_login.html new file mode 100644 index 0000000..aafe955 --- /dev/null +++ b/code/misc/python/scripts/MITM/templates/admin_login.html @@ -0,0 +1,22 @@ + + + + Admin Login + + + +
+

Admin Login

+
+
+ + +
+ +
+
+ + + + + \ No newline at end of file diff --git a/code/misc/python/scripts/MITM/templates/change_password.html b/code/misc/python/scripts/MITM/templates/change_password.html new file mode 100644 index 0000000..ad76da9 --- /dev/null +++ b/code/misc/python/scripts/MITM/templates/change_password.html @@ -0,0 +1,15 @@ + + + + Change Password + + +

Change Password

+
+ + +
+ +
+ + \ No newline at end of file diff --git a/code/misc/python/scripts/MITM/templates/index.html b/code/misc/python/scripts/MITM/templates/index.html new file mode 100644 index 0000000..1194e53 --- /dev/null +++ b/code/misc/python/scripts/MITM/templates/index.html @@ -0,0 +1,23 @@ + + + + Whitelist Request + + + +
+

Request to Whitelist a URL

+
+
+ + +
+
+ + +
+ +
+
+ + \ No newline at end of file diff --git a/code/misc/python/scripts/MITM/templates/login.html b/code/misc/python/scripts/MITM/templates/login.html new file mode 100644 index 0000000..37babca --- /dev/null +++ b/code/misc/python/scripts/MITM/templates/login.html @@ -0,0 +1,27 @@ + + + + Login + + +

Login

+
+ + +
+ + +
+ +
+ {% with messages = get_flashed_messages() %} + {% if messages %} +
    + {% for message in messages %} +
  • {{ message }}
    • + {% endfor %} +
+ {% endif %} + {% endwith %} + + \ No newline at end of file diff --git a/code/misc/python/scripts/MITM/templates/request.html b/code/misc/python/scripts/MITM/templates/request.html new file mode 100644 index 0000000..489da3c --- /dev/null +++ b/code/misc/python/scripts/MITM/templates/request.html @@ -0,0 +1,26 @@ + + + + Request Whitelist + + + +
+

Request URL/Domain Whitelisting

+
+
+ + +
+
+ + +
+ +
+
+ + + + + \ No newline at end of file diff --git a/code/misc/python/scripts/MITM/templates/set_admin_password.html b/code/misc/python/scripts/MITM/templates/set_admin_password.html new file mode 100644 index 0000000..5b78f61 --- /dev/null +++ b/code/misc/python/scripts/MITM/templates/set_admin_password.html @@ -0,0 +1,22 @@ + + + + Set Admin Password + + + +
+

Set Admin Password

+
+
+ + +
+ +
+
+ + + + + \ No newline at end of file diff --git a/code/misc/python/scripts/MITM/templates/whitelist.html b/code/misc/python/scripts/MITM/templates/whitelist.html new file mode 100644 index 0000000..b6769ac --- /dev/null +++ b/code/misc/python/scripts/MITM/templates/whitelist.html @@ -0,0 +1,27 @@ + + + + Whitelisted URLs + + + +
+

Whitelisted URLs

+ Back to Admin + + + + + + + + {% for url in approved_urls %} + + + + {% endfor %} + +
URL
{{ url[0] }}
+
+ + \ No newline at end of file diff --git a/code/misc/python/scripts/MITM/testwflow.ipynb b/code/misc/python/scripts/MITM/testwflow.ipynb new file mode 100644 index 0000000..8d53eb8 --- /dev/null +++ b/code/misc/python/scripts/MITM/testwflow.ipynb @@ -0,0 +1,73 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Error logged during startup, exiting...\n" + ] + }, + { + "ename": "SystemExit", + "evalue": "1", + "output_type": "error", + "traceback": [ + "An exception has occurred, use %tb to see the full traceback.\n", + "\u001b[0;31mSystemExit\u001b[0m\u001b[0;31m:\u001b[0m 1\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/ys/.pyenv/versions/3.12.0/envs/mitm/lib/python3.12/site-packages/IPython/core/interactiveshell.py:3585: UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.\n", + " warn(\"To exit: use 'exit', 'quit', or Ctrl-D.\", stacklevel=1)\n" + ] + } + ], + "source": [ + "import driver\n", + "import asyncio\n", + "import nest_asyncio\n", + "\n", + "# Apply nest_asyncio to allow nested event loops\n", + "#nest_asyncio.apply()\n", + "\n", + "await driver.start_proxy('127.0.0.1', 8083)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "mitm", + "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.12.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/code/misc/python/scripts/SIMM Gamma check.ipynb b/code/misc/python/scripts/SIMM Gamma check.ipynb new file mode 100644 index 0000000..677b207 --- /dev/null +++ b/code/misc/python/scripts/SIMM Gamma check.ipynb @@ -0,0 +1,1250 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib notebook\n", + "from scipy.stats import norm\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "import pandas as pd\n", + "from pandas import DataFrame as df\n", + "from scipy.stats import norm as NORM\n", + "from numpy.random import randn,rand,random,multivariate_normal\n", + "from numpy.linalg import eig,eigvals,cholesky,det\n", + "from numpy import diag,sqrt,transpose,matmul,dot,trace" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "code_folding": [], + "hide_input": false + }, + "outputs": [ + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support. ' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('
');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " fig.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '
');\n", + " var titletext = $(\n", + " '
');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('
');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('
');\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('\n", + " {{ message }}\n", + "
\n", + " {% endfor %}\n", + " {% block page_content %}{% endblock %}\n", + "
\n", + "{% endblock %}\n", + "In this example, messages are rendered using Bootstrap’s alert CSS styles for warning\n", + "messages (one is shown in Figure 4-4).\n", + "54 \n", + "| \n", + "Chapter 4: Web Forms\n", + "\n", + "Figure 4-4. Flashed message\n", + "A loop is used because there could be multiple messages queued for display, one for\n", + "each time flash() was called in the previous request cycle. Messages that are\n", + "retrieved from get_flashed_messages() will not be returned the next time this func‐\n", + "tion is called, so flashed messages appear only once and are then discarded.\n", + "If you have cloned the application’s Git repository on GitHub, you\n", + "can run git checkout 4c to check out this version of the applica‐\n", + "tion.\n", + "Being able to accept data from the user through web forms is a feature required by\n", + "most applications, and so is the ability to store that data in permanent storage. Using\n", + "databases with Flask is the topic of the next chapter.\n", + "Message Flashing \n", + "| \n", + "55\n", + "\n", + "\n", + "CHAPTER 5\n", + "Databases\n", + "A database stores application data in an organized way. The application then issues\n", + "queries to retrieve specific portions of the data as they are needed. The most com‐\n", + "monly used databases for web applications are those based on the relational model,\n", + "also called SQL databases in reference to the Structured Query Language they use.\n", + "But in recent years document-oriented and key-value databases, informally known\n", + "together as NoSQL databases, have become popular alternatives.\n", + "SQL Databases\n", + "Relational databases store data in tables, which model the different entities in the\n", + "application’s domain. For example, a database for an order management application\n", + "will likely have customers, products, and orders tables.\n", + "A table has a fixed number of columns and a variable number of rows. The columns\n", + "define the data attributes of the entity represented by the table. For example, a\n", + "customers table will have columns such as name, address, phone, and so on. Each\n", + "row in a table defines an actual data element that assigns values to some or all the\n", + "columns.\n", + "Tables have a special column called the primary key, which holds a unique identifier\n", + "for each row stored in the table. Tables can also have columns called foreign keys,\n", + "which reference the primary key of a row in the same or another table. These links\n", + "between rows are called relationships and are the foundation of the relational database\n", + "model.\n", + "Figure 5-1 shows a diagram of a simple database with two tables that store users and\n", + "user roles. The line that connects the two tables represents a relationship between the\n", + "tables.\n", + "57\n", + "\n", + "Figure 5-1. Relational database example\n", + "This graphical style of representing the structure of a database is called an entity-\n", + "relationship diagram. In this representation, boxes represent database tables, showing\n", + "lists of the table’s attributes or columns. The roles table stores the list of all possible\n", + "user roles, each identified by a unique id value—the table’s primary key. The users\n", + "table contains the list of users, each with its own unique id as well. Besides the id\n", + "primary keys, the roles table has a name column and the users table has username\n", + "and password columns.\n", + "The role_id column in the users table is a foreign key. The line that connects the\n", + "roles.id and users.role_id columns represents a relationship between the two\n", + "tables. The symbols attached to the line at each end indicate the cardinality of the\n", + "relationship. On the roles.id side, the line is shown to have a “one,” while on the\n", + "users.role_id side a “many” is represented. This depicts a one-to-many relationship,\n", + "indicating that each row from the roles table can be associated with many rows from\n", + "the users table.\n", + "As seen in the example, relational databases store data efficiently and avoid duplica‐\n", + "tion. Renaming a user role in this database is simple because role names exist in a\n", + "single place. Immediately after a role name is changed in the roles table, all users\n", + "that have a role_id that references the changed role will see the update.\n", + "On the other hand, having the data split into multiple tables can be a complication.\n", + "Producing a listing of users with their roles presents a small problem, because users\n", + "and user roles need to be read from two tables and joined before they can be presen‐\n", + "ted together. Relational database engines provide the support to perform join opera‐\n", + "tions between tables when necessary.\n", + "NoSQL Databases\n", + "Databases that do not follow the relational model described in the previous section\n", + "are collectively referred to as NoSQL databases. One common organization for\n", + "NoSQL databases uses collections instead of tables and documents instead of records.\n", + "NoSQL databases are designed in a way that makes joins difficult, so most of them do\n", + "not support this operation at all. For a NoSQL database structured as in Figure 5-1,\n", + "58 \n", + "| \n", + "Chapter 5: Databases\n", + "\n", + "listing the users with their roles requires the application itself to perform the join\n", + "operation by reading the role_id field of each user and then searching the roles\n", + "table for it.\n", + "A more appropriate design for a NoSQL database is shown in Figure 5-2. This is the\n", + "result of applying an operation called denormalization, which reduces the number of\n", + "tables at the expense of data duplication.\n", + "Figure 5-2. NoSQL database example\n", + "A database with this structure has the role name explicitly stored with each user.\n", + "Renaming a role can then turn out to be an expensive operation that may require\n", + "updating a large number of documents.\n", + "But it isn’t all bad news with NoSQL databases. Having the data duplicated allows for\n", + "faster querying. Listing users and their roles is straightforward because no joins are\n", + "needed.\n", + "SQL or NoSQL?\n", + "SQL databases excel at storing structured data in an efficient and compact form.\n", + "These databases go to great lengths to preserve consistency, even in the face of power\n", + "failures or hardware malfunctions. The paradigm that allows relational databases to\n", + "reach this high level of reliability is called ACID, which stands for Atomicity, Consis‐\n", + "tency, Isolation, and Durability. NoSQL databases relax some of the ACID require‐\n", + "ments and as a result can sometimes get a performance edge.\n", + "A full analysis and comparison of database types is outside the scope of this book. For\n", + "small to medium-sized applications, both SQL and NoSQL databases are perfectly\n", + "capable and have practically equivalent performance.\n", + "Python Database Frameworks\n", + "Python has packages for most database engines, both open source and commercial.\n", + "Flask puts no restrictions on what database packages can be used, so you can work\n", + "with MySQL, Postgres, SQLite, Redis, MongoDB, CouchDB, or DynamoDB if any of\n", + "these is your favorite.\n", + "SQL or NoSQL? \n", + "| \n", + "59\n", + "\n", + "As if those weren’t enough choices, there are also a number of database abstraction\n", + "layer packages, such as SQLAlchemy or MongoEngine, that allow you to work at a\n", + "higher level with regular Python objects instead of database entities such as tables,\n", + "documents, or query languages.\n", + "There are a number of factors to evaluate when choosing a database framework:\n", + "Ease of use\n", + "When comparing straight database engines to database abstraction layers, the\n", + "second group clearly wins. Abstraction layers, also called object-relational map‐\n", + "pers (ORMs) or object-document mappers (ODMs), provide transparent conver‐\n", + "sion of high-level object-oriented operations into low-level database instructions.\n", + "Performance\n", + "The conversions that ORMs and ODMs have to do to translate from the object\n", + "domain into the database domain have an overhead. In most cases, the perfor‐\n", + "mance penalty is negligible, but it may not always be. In general, the productivity\n", + "gain obtained with ORMs and ODMs far outweighs a minimal performance deg‐\n", + "radation, so this isn’t a valid argument to drop ORMs and ODMs completely.\n", + "What makes sense is to choose a database abstraction layer that provides optional\n", + "access to the underlying database in case specific operations need to be optimized\n", + "by implementing them directly as native database instructions.\n", + "Portability\n", + "The database choices available on your development and production platforms\n", + "must be considered. For example, if you plan to host your application on a cloud\n", + "platform, then you should find out what database choices this service offers.\n", + "Another portability aspect applies to ORMs and ODMs. Although some of these\n", + "frameworks provide an abstraction layer for a single database engine, others\n", + "abstract even higher and provide a choice of database engines—all accessible\n", + "with the same object-oriented interface. The best example of this is the SQL‐\n", + "Alchemy ORM, which supports a list of relational database engines including the\n", + "popular MySQL, Postgres, and SQLite.\n", + "Flask integration\n", + "Choosing a framework that has integration with Flask is not absolutely required,\n", + "but it will save you from having to write the integration code yourself. Flask inte‐\n", + "gration could simplify configuration and operation, so using a package specifi‐\n", + "cally designed as a Flask extension should be preferred.\n", + "Based on these goals, the chosen database framework for the examples in this book\n", + "will be Flask-SQLAlchemy, the Flask extension wrapper for SQLAlchemy.\n", + "60 \n", + "| \n", + "Chapter 5: Databases\n", + "\n", + "Database Management with Flask-SQLAlchemy\n", + "Flask-SQLAlchemy is a Flask extension that simplifies the use of SQLAlchemy inside\n", + "Flask applications. SQLAlchemy is a powerful relational database framework that\n", + "supports several database backends. It offers a high-level ORM and low-level access\n", + "to the database’s native SQL functionality.\n", + "Like most other extensions, Flask-SQLAlchemy is installed with pip:\n", + "(venv) $ pip install flask-sqlalchemy\n", + "In Flask-SQLAlchemy, a database is specified as a URL. Table 5-1 lists the format of\n", + "the URLs for the three most popular database engines.\n", + "Table 5-1. Flask-SQLAlchemy database URLs\n", + "Database engine\n", + "URL\n", + "MySQL\n", + "mysql://username:password@hostname/database\n", + "Postgres\n", + "postgresql://username:password@hostname/database\n", + "SQLite (Linux, macOS) sqlite:////absolute/path/to/database\n", + "SQLite (Windows)\n", + "sqlite:///c:/absolute/path/to/database\n", + "In these URLs, hostname refers to the server that hosts the database service, which\n", + "could be localhost or a remote server. Database servers can host several databases, so\n", + "database indicates the name of the database to use. For databases that need authenti‐\n", + "cation, username and password are the database user credentials.\n", + "SQLite databases do not have a server, so hostname, username, and\n", + "password are omitted and database is the filename on disk for the\n", + "database.\n", + "The URL of the application database must be configured as the key\n", + "SQLALCHEMY_DATABASE_URI in the Flask configuration object. The Flask-SQLAlchemy\n", + "documentation also suggests setting key SQLALCHEMY_TRACK_MODIFICATIONS to False\n", + "to use less memory unless signals for object changes are needed. Consult the Flask-\n", + "SQLAlchemy documentation for information on other configuration options.\n", + "Example 5-1 shows how to initialize and configure a simple SQLite database.\n", + "Example 5-1. hello.py: database configuration\n", + "import os\n", + "from flask_sqlalchemy import SQLAlchemy\n", + "basedir = os.path.abspath(os.path.dirname(__file__))\n", + "Database Management with Flask-SQLAlchemy \n", + "| \n", + "61\n", + "\n", + "app = Flask(__name__)\n", + "app.config['SQLALCHEMY_DATABASE_URI'] =\\\n", + " 'sqlite:///' + os.path.join(basedir, 'data.sqlite')\n", + "app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False\n", + "db = SQLAlchemy(app)\n", + "The db object instantiated from the class SQLAlchemy represents the database and\n", + "provides access to all the functionality of Flask-SQLAlchemy.\n", + "Model Definition\n", + "The term model is used when referring to the persistent entities used by the applica‐\n", + "tion. In the context of an ORM, a model is typically a Python class with attributes that\n", + "match the columns of a corresponding database table.\n", + "The database instance from Flask-SQLAlchemy provides a base class for models as\n", + "well as a set of helper classes and functions that are used to define their structure. The\n", + "roles and users tables from Figure 5-1 can be defined as the models Role and User\n", + "as shown in Example 5-2.\n", + "Example 5-2. hello.py: Role and User model definition\n", + "class Role(db.Model):\n", + " __tablename__ = 'roles'\n", + " id = db.Column(db.Integer, primary_key=True)\n", + " name = db.Column(db.String(64), unique=True)\n", + " def __repr__(self):\n", + " return '' % self.name\n", + "class User(db.Model):\n", + " __tablename__ = 'users'\n", + " id = db.Column(db.Integer, primary_key=True)\n", + " username = db.Column(db.String(64), unique=True, index=True)\n", + " def __repr__(self):\n", + " return '' % self.username\n", + "The __tablename__ class variable defines the name of the table in the database. Flask-\n", + "SQLAlchemy assigns a default table name if __tablename__ is omitted, but those\n", + "default names do not follow the popular convention of using plurals for table names,\n", + "so it is best to name tables explicitly. The remaining class variables are the attributes\n", + "of the model, defined as instances of the db.Column class.\n", + "62 \n", + "| \n", + "Chapter 5: Databases\n", + "\n", + "The first argument given to the db.Column constructor is the type of the database col‐\n", + "umn and model attribute. Table 5-2 lists some of the column types that are available,\n", + "along with the Python types used in the model.\n", + "Table 5-2. Most common SQLAlchemy column types\n", + "Type name\n", + "Python type\n", + "Description\n", + "Integer\n", + "int\n", + "Regular integer, typically 32 bits\n", + "SmallInteger\n", + "int\n", + "Short-range integer, typically 16 bits\n", + "BigInteger\n", + "int or long\n", + "Unlimited precision integer\n", + "Float\n", + "float\n", + "Floating-point number\n", + "Numeric\n", + "decimal.Decimal\n", + "Fixed-point number\n", + "String\n", + "str\n", + "Variable-length string\n", + "Text\n", + "str\n", + "Variable-length string, optimized for large or unbounded length\n", + "Unicode\n", + "unicode\n", + "Variable-length Unicode string\n", + "UnicodeText\n", + "unicode\n", + "Variable-length Unicode string, optimized for large or unbounded length\n", + "Boolean\n", + "bool\n", + "Boolean value\n", + "Date\n", + "datetime.date\n", + "Date value\n", + "Time\n", + "datetime.time\n", + "Time value\n", + "DateTime\n", + "datetime.datetime\n", + "Date and time value\n", + "Interval\n", + "datetime.timedelta Time interval\n", + "Enum\n", + "str\n", + "List of string values\n", + "PickleType\n", + "Any Python object\n", + "Automatic Pickle serialization\n", + "LargeBinary\n", + "str\n", + "Binary blob\n", + "The remaining arguments to db.Column specify configuration options for each\n", + "attribute. Table 5-3 lists some of the options available.\n", + "Table 5-3. Most common SQLAlchemy column options\n", + "Option name\n", + "Description\n", + "primary_key\n", + "If set to True, the column is the table’s primary key.\n", + "unique\n", + "If set to True, do not allow duplicate values for this column.\n", + "index\n", + "If set to True, create an index for this column, so that queries are more efficient.\n", + "nullable\n", + "If set to True, allow empty values for this column. If set to False, the column will not allow null values.\n", + "default\n", + "Define a default value for the column.\n", + "Model Definition \n", + "| \n", + "63\n", + "\n", + "Flask-SQLAlchemy requires all models to define a primary key col‐\n", + "umn, which is commonly named id.\n", + "Although it’s not strictly necessary, the two models include a __repr__() method to\n", + "give them a readable string representation that can be used for debugging and testing\n", + "purposes.\n", + "Relationships\n", + "Relational databases establish connections between rows in different tables through\n", + "the use of relationships. The relational diagram in Figure 5-1 expresses a simple rela‐\n", + "tionship between users and their roles. This is a one-to-many relationship from roles\n", + "to users, because one role can belong to many users, but each user can have only one\n", + "role.\n", + "Example 5-3 shows how the one-to-many relationship in Figure 5-1 is represented in\n", + "the model classes.\n", + "Example 5-3. hello.py: relationships in the database models\n", + "class Role(db.Model):\n", + " # ...\n", + " users = db.relationship('User', backref='role')\n", + "class User(db.Model):\n", + " # ...\n", + " role_id = db.Column(db.Integer, db.ForeignKey('roles.id'))\n", + "As seen in Figure 5-1, a relationship connects two rows through the use of a foreign\n", + "key. The role_id column added to the User model is defined as a foreign key, and\n", + "that establishes the relationship. The 'roles.id' argument to db.ForeignKey()\n", + "specifies that the column should be interpreted as having id values from rows in the\n", + "roles table.\n", + "The users attribute added to the model Role represents the object-oriented view of\n", + "the relationship, as seen from the “one” side. Given an instance of class Role, the\n", + "users attribute will return the list of users associated with that role (i.e., the “many”\n", + "side). The first argument to db.relationship() indicates what model is on the other\n", + "side of the relationship. The model class can be provided as a string if the class is\n", + "defined later in the module.\n", + "The backref argument to db.relationship() defines the reverse direction of the\n", + "relationship, by adding a role attribute to the User model. This attribute can be used\n", + "64 \n", + "| \n", + "Chapter 5: Databases\n", + "\n", + "on any instance of User instead of the role_id foreign key to access the Role model\n", + "as an object.\n", + "In most cases db.relationship() can locate the relationship’s foreign key on its own,\n", + "but sometimes it cannot determine what column to use as a foreign key. For example,\n", + "if the User model had two or more columns defined as Role foreign keys, then\n", + "SQLAlchemy would not know which one of the two to use. Whenever the foreign key\n", + "configuration is ambiguous, additional arguments to db.relationship() need to be\n", + "given. Table 5-4 lists some of the common configuration options that can be used to\n", + "define a relationship.\n", + "Table 5-4. Common SQLAlchemy relationship options\n", + "Option name\n", + "Description\n", + "backref\n", + "Add a back reference in the other model in the relationship.\n", + "primaryjoin\n", + "Specify the join condition between the two models explicitly. This is necessary only for ambiguous\n", + "relationships.\n", + "lazy\n", + "Specify how the related items are to be loaded. Possible values are select (items are loaded on\n", + "demand the first time they are accessed), immediate (items are loaded when the source object is\n", + "loaded), joined (items are loaded immediately, but as a join), subquery (items are loaded\n", + "immediately, but as a subquery), noload (items are never loaded), and dynamic (instead of loading\n", + "the items, the query that can load them is given).\n", + "uselist\n", + "If set to False, use a scalar instead of a list.\n", + "order_by\n", + "Specify the ordering used for the items in the relationship.\n", + "secondary\n", + "Specify the name of the association table to use in many-to-many relationships.\n", + "secondaryjoin Specify the secondary join condition for many-to-many relationships when SQLAlchemy cannot\n", + "determine it on its own.\n", + "If you have cloned the application’s Git repository on GitHub, you\n", + "can run git checkout 5a to check out this version of the applica‐\n", + "tion.\n", + "There are other relationship types besides one-to-many. The one-to-one relationship\n", + "can be expressed the same way as one-to-many, as described earlier, but with the\n", + "uselist option set to False within the db.relationship() definition so that the\n", + "“many” side becomes a “one” side. The many-to-one relationship can also be\n", + "expressed as a one-to-many if the tables are reversed, or it can be expressed with the\n", + "foreign key and the db.relationship() definition both on the “many” side. The\n", + "most complex relationship type, many-to-many, requires an additional table called an\n", + "association or junction table. You will learn about many-to-many relationships in\n", + "Chapter 12.\n", + "Relationships \n", + "| \n", + "65\n", + "\n", + "Database Operations\n", + "The models are now fully configured according to the database diagram in Figure 5-1\n", + "and are ready to be used. The best way to learn how to work with these models is in a\n", + "Python shell. The following sections will walk you through the most common data‐\n", + "base operations in a shell started with the flask shell command. Before you use\n", + "this command, make sure the FLASK_APP environment variable is set to hello.py, as\n", + "shown in Chapter 2.\n", + "Creating the Tables\n", + "The very first thing to do is to instruct Flask-SQLAlchemy to create a database based\n", + "on the model classes. The db.create_all() function locates all the subclasses of\n", + "db.Model and creates corresponding tables in the database for them:\n", + "(venv) $ flask shell\n", + ">>> from hello import db\n", + ">>> db.create_all()\n", + "If you check the application directory, you will now see a new file there called\n", + "data.sqlite, the name that was given to the SQLite database in the configuration. The\n", + "db.create_all() function will not re-create or update a database table if it already\n", + "exists in the database. This can be inconvenient when the models are modified and\n", + "the changes need to be applied to an existing database. The brute-force solution to\n", + "update existing database tables to a different schema is to remove the old tables first:\n", + ">>> db.drop_all()\n", + ">>> db.create_all()\n", + "Unfortunately, this method has the undesired side effect of destroying all the data in\n", + "the old database. A better solution to the problem of updating databases is presented\n", + "near the end of the chapter.\n", + "Inserting Rows\n", + "The following example creates a few roles and users:\n", + ">>> from hello import Role, User\n", + ">>> admin_role = Role(name='Admin')\n", + ">>> mod_role = Role(name='Moderator')\n", + ">>> user_role = Role(name='User')\n", + ">>> user_john = User(username='john', role=admin_role)\n", + ">>> user_susan = User(username='susan', role=user_role)\n", + ">>> user_david = User(username='david', role=user_role)\n", + "The constructors for models accept initial values for the model attributes as keyword\n", + "arguments. Note that the role attribute can be used, even though it is not a real data‐\n", + "base column but a high-level representation of the one-to-many relationship. The id\n", + "66 \n", + "| \n", + "Chapter 5: Databases\n", + "\n", + "attribute of these new objects is not set explicitly: the primary keys in many databases\n", + "are managed by the database itself. The objects exist only on the Python side so far;\n", + "they have not been written to the database yet. Because of that, their id values have\n", + "not yet been assigned:\n", + ">>> print(admin_role.id)\n", + "None\n", + ">>> print(mod_role.id)\n", + "None\n", + ">>> print(user_role.id)\n", + "None\n", + "Changes to the database are managed through a database session, which Flask-\n", + "SQLAlchemy provides as db.session. To prepare objects to be written to the data‐\n", + "base, they must be added to the session:\n", + ">>> db.session.add(admin_role)\n", + ">>> db.session.add(mod_role)\n", + ">>> db.session.add(user_role)\n", + ">>> db.session.add(user_john)\n", + ">>> db.session.add(user_susan)\n", + ">>> db.session.add(user_david)\n", + "Or, more concisely:\n", + ">>> db.session.add_all([admin_role, mod_role, user_role,\n", + "... user_john, user_susan, user_david])\n", + "To write the objects to the database, the session needs to be committed by calling its\n", + "commit() method:\n", + ">>> db.session.commit()\n", + "Check the id attributes again after having the data committed to see that they are\n", + "now set:\n", + ">>> print(admin_role.id)\n", + "1\n", + ">>> print(mod_role.id)\n", + "2\n", + ">>> print(user_role.id)\n", + "3\n", + "The db.session database session is not related to the Flask\n", + "session object discussed in Chapter 4. Database sessions are also\n", + "called transactions.\n", + "Database sessions are extremely useful in keeping the database consistent. The com‐\n", + "mit operation writes all the objects that were added to the session atomically. If an\n", + "Database Operations \n", + "| \n", + "67\n", + "\n", + "error occurs while the session is being written, the whole session is discarded. If you\n", + "always commit related changes together in a session, you are guaranteed to avoid\n", + "database inconsistencies due to partial updates.\n", + "A \n", + "database \n", + "session \n", + "can \n", + "also \n", + "be \n", + "rolled \n", + "back. \n", + "If\n", + "db.session.rollback() is called, any objects that were added to\n", + "the database session are restored to the state they have in the data‐\n", + "base.\n", + "Modifying Rows\n", + "The add() method of the database session can also be used to update models. Con‐\n", + "tinuing in the same shell session, the following example renames the \"Admin\" role to\n", + "\"Administrator\":\n", + ">>> admin_role.name = 'Administrator'\n", + ">>> db.session.add(admin_role)\n", + ">>> db.session.commit()\n", + "Deleting Rows\n", + "The database session also has a delete() method. The following example deletes the\n", + "\"Moderator\" role from the database:\n", + ">>> db.session.delete(mod_role)\n", + ">>> db.session.commit()\n", + "Note that deletions, like insertions and updates, are executed only when the database\n", + "session is committed.\n", + "Querying Rows\n", + "Flask-SQLAlchemy makes a query object available in each model class. The most\n", + "basic query for a model is triggered with the all() method, which returns the entire\n", + "contents of the corresponding table:\n", + ">>> Role.query.all()\n", + "[, ]\n", + ">>> User.query.all()\n", + "[, , ]\n", + "A query object can be configured to issue more specific database searches through\n", + "the use of filters. The following example finds all the users that were assigned the\n", + "\"User\" role:\n", + ">>> User.query.filter_by(role=user_role).all()\n", + "[, ]\n", + "68 \n", + "| \n", + "Chapter 5: Databases\n", + "\n", + "It is also possible to inspect the native SQL query that SQLAlchemy generates for a\n", + "given query by converting the query object to a string:\n", + ">>> str(User.query.filter_by(role=user_role))\n", + "'SELECT users.id AS users_id, users.username AS users_username,\n", + "users.role_id AS users_role_id \\nFROM users \\nWHERE :param_1 = users.role_id'\n", + "If you exit the shell session, the objects created in the previous example will cease to\n", + "exist as Python objects but will continue to exist as rows in their respective database\n", + "tables. If you then start a brand-new shell session, you have to re-create the Python\n", + "objects from their database rows. The following example issues a query that loads the\n", + "user role with name \"User\":\n", + ">>> user_role = Role.query.filter_by(name='User').first()\n", + "Note how in this case, the query was issued with the first() method instead of\n", + "all(). While all() returns all the results of the query as a list, first() returns only\n", + "the first result or None if there are no results, so it is a convenient method to use for\n", + "queries that are known to return one result at the most.\n", + "Filters such as filter_by() are invoked on a query object and return a new refined\n", + "query. Multiple filters can be called in sequence until the query is configured as\n", + "needed.\n", + "Table 5-5 shows some of the most common filters available to queries. The complete\n", + "list is in the SQLAlchemy documentation.\n", + "Table 5-5. Common SQLAlchemy query filters\n", + "Option\n", + "Description\n", + "filter()\n", + "Returns a new query that adds an additional filter to the original query\n", + "filter_by()\n", + "Returns a new query that adds an additional equality filter to the original query\n", + "limit()\n", + "Returns a new query that limits the number of results of the original query to the given number\n", + "offset()\n", + "Returns a new query that applies an offset into the list of results of the original query\n", + "order_by()\n", + "Returns a new query that sorts the results of the original query according to the given criteria\n", + "group_by()\n", + "Returns a new query that groups the results of the original query according to the given criteria\n", + "After the desired filters have been applied to the query, a call to all() will cause the\n", + "query to execute and return the results as a list—but there are other ways to trigger\n", + "the execution of a query besides all(). Table 5-6 shows other query execution meth‐\n", + "ods.\n", + "Database Operations \n", + "| \n", + "69\n", + "\n", + "Table 5-6. Most common SQLAlchemy query executors\n", + "Option\n", + "Description\n", + "all()\n", + "Returns all the results of a query as a list\n", + "first()\n", + "Returns the first result of a query, or None if there are no results\n", + "first_or_404() Returns the first result of a query, or aborts the request and sends a 404 error as the response if there\n", + "are no results\n", + "get()\n", + "Returns the row that matches the given primary key, or None if no matching row is found\n", + "get_or_404()\n", + "Returns the row that matches the given primary key or, if the key is not found, aborts the request and\n", + "sends a 404 error as the response\n", + "count()\n", + "Returns the result count of the query\n", + "paginate()\n", + "Returns a Pagination object that contains the specified range of results\n", + "Relationships work similarly to queries. The following example queries the one-to-\n", + "many relationship between roles and users from both ends:\n", + ">>> users = user_role.users\n", + ">>> users\n", + "[, ]\n", + ">>> users[0].role\n", + "\n", + "The user_role.users query here has a small problem. The implicit query that runs\n", + "when the user_role.users expression is issued internally calls all() to return the\n", + "list of users. Because the query object is hidden, it is not possible to refine it with\n", + "additional query filters. In this particular example, it may have been useful to request\n", + "that the user list be returned in alphabetical order. In Example 5-4, the configuration\n", + "of the relationship is modified with a lazy='dynamic' argument to request that the\n", + "query is not automatically executed.\n", + "Example 5-4. hello.py: dynamic database relationships\n", + "class Role(db.Model):\n", + " # ...\n", + " users = db.relationship('User', backref='role', lazy='dynamic')\n", + " # ...\n", + "With the relationship configured in this way, user_role.users returns a query that\n", + "hasn’t executed yet, so filters can be added to it:\n", + ">>> user_role.users.order_by(User.username).all()\n", + "[, ]\n", + ">>> user_role.users.count()\n", + "2\n", + "70 \n", + "| \n", + "Chapter 5: Databases\n", + "\n", + "Database Use in View Functions\n", + "The database operations described in the previous sections can be used directly inside\n", + "view functions. Example 5-5 shows a new version of the home page route that records\n", + "names entered by users in the database.\n", + "Example 5-5. hello.py: database use in view functions\n", + "@app.route('/', methods=['GET', 'POST'])\n", + "def index():\n", + " form = NameForm()\n", + " if form.validate_on_submit():\n", + " user = User.query.filter_by(username=form.name.data).first()\n", + " if user is None:\n", + " user = User(username=form.name.data)\n", + " db.session.add(user)\n", + " db.session.commit()\n", + " session['known'] = False\n", + " else:\n", + " session['known'] = True\n", + " session['name'] = form.name.data\n", + " form.name.data = ''\n", + " return redirect(url_for('index'))\n", + " return render_template('index.html',\n", + " form=form, name=session.get('name'),\n", + " known=session.get('known', False))\n", + "In this modified version of the application, each time a name is submitted the appli‐\n", + "cation checks for it in the database using the filter_by() query filter. A known vari‐\n", + "able is written to the user session so that after the redirect the information can be sent\n", + "to the template, where it is used to customize the greeting. Note that for the applica‐\n", + "tion to work, the database tables must be created in a Python shell as shown earlier.\n", + "The new version of the associated template is shown in Example 5-6. This template\n", + "uses the known argument to add a second line to the greeting that is different for\n", + "known and new users.\n", + "Example 5-6. templates/index.html: customized greeting in template\n", + "{% extends \"base.html\" %}\n", + "{% import \"bootstrap/wtf.html\" as wtf %}\n", + "{% block title %}Flasky{% endblock %}\n", + "{% block page_content %}\n", + "
\n", + "

Hello, {% if name %}{{ name }}{% else %}Stranger{% endif %}!

\n", + " {% if not known %}\n", + "Database Use in View Functions \n", + "| \n", + "71\n", + "\n", + "

Pleased to meet you!

\n", + " {% else %}\n", + "

Happy to see you again!

\n", + " {% endif %}\n", + "
\n", + "{{ wtf.quick_form(form) }}\n", + "{% endblock %}\n", + "If you have cloned the application’s Git repository on GitHub, you\n", + "can run git checkout 5b to check out this version of the applica‐\n", + "tion.\n", + "Integration with the Python Shell\n", + "Having to import the database instance and the models each time a shell session is\n", + "started is tedious work. To avoid having to constantly repeat these steps, the flask\n", + "shell command can be configured to automatically import these objects.\n", + "To add objects to the import list, a shell context processor must be created and regis‐\n", + "tered with the app.shell_context_processor decorator. This is shown in\n", + "Example 5-7.\n", + "Example 5-7. hello.py: adding a shell context\n", + "@app.shell_context_processor\n", + "def make_shell_context():\n", + " return dict(db=db, User=User, Role=Role)\n", + "The shell context processor function returns a dictionary that includes the database\n", + "instance and the models. The flask shell command will import these items auto‐\n", + "matically into the shell, in addition to app, which is imported by default:\n", + "$ flask shell\n", + ">>> app\n", + "\n", + ">>> db\n", + "\n", + ">>> User\n", + "\n", + "If you have cloned the application’s Git repository on GitHub, you\n", + "can run git checkout 5c to check out this version of the applica‐\n", + "tion.\n", + "72 \n", + "| \n", + "Chapter 5: Databases\n", + "\n", + "Database Migrations with Flask-Migrate\n", + "As you make progress developing an application, you will find that your database\n", + "models need to change, and when that happens the database needs to be updated as\n", + "well. Flask-SQLAlchemy creates database tables from models only when they do not\n", + "exist already, so the only way to make it update tables is by destroying the old tables\n", + "first—but of course, this causes all the data in the database to be lost.\n", + "A better solution is to use a database migration framework. In the same way source\n", + "code version control tools keep track of changes to source code files, a database\n", + "migration framework keeps track of changes to a database schema, allowing incre‐\n", + "mental changes to be applied.\n", + "The developer of SQLAlchemy has written a migration framework called Alembic,\n", + "but instead of using Alembic directly, Flask applications can use the Flask-Migrate\n", + "extension, a lightweight Alembic wrapper that integrates it with the flask command.\n", + "Creating a Migration Repository\n", + "To begin, Flask-Migrate must be installed in the virtual environment:\n", + "(venv) $ pip install flask-migrate\n", + "Example 5-8 shows how the extension is initialized.\n", + "Example 5-8. hello.py: Flask-Migrate initialization\n", + "from flask_migrate import Migrate\n", + "# ...\n", + "migrate = Migrate(app, db)\n", + "To expose the database migration commands, Flask-Migrate adds a flask db com‐\n", + "mand with several subcommands. When you work on a new project, you can add\n", + "support for database migrations with the init subcommand:\n", + "(venv) $ flask db init\n", + " Creating directory /home/flask/flasky/migrations...done\n", + " Creating directory /home/flask/flasky/migrations/versions...done\n", + " Generating /home/flask/flasky/migrations/alembic.ini...done\n", + " Generating /home/flask/flasky/migrations/env.py...done\n", + " Generating /home/flask/flasky/migrations/env.pyc...done\n", + " Generating /home/flask/flasky/migrations/README...done\n", + " Generating /home/flask/flasky/migrations/script.py.mako...done\n", + " Please edit configuration/connection/logging settings in\n", + " '/home/flask/flasky/migrations/alembic.ini' before proceeding.\n", + "Database Migrations with Flask-Migrate \n", + "| \n", + "73\n", + "\n", + "This command creates a migrations directory, where all the migration scripts will be\n", + "stored. If you are following the example project using git checkout, you do not need\n", + "to do this step, as the migration repository is already included in the GitHub reposi‐\n", + "tory.\n", + "The files in a database migration repository must always be added\n", + "to version control along with the rest of the application.\n", + "Creating a Migration Script\n", + "In Alembic, a database migration is represented by a migration script. This script has\n", + "two functions called upgrade() and downgrade(). The upgrade() function applies\n", + "the database changes that are part of the migration, and the downgrade() function\n", + "removes them. This ability to add and remove changes means, Alembic can reconfig‐\n", + "ure a database to any point in the change history.\n", + "Alembic migrations can be created manually or automatically using the revision and\n", + "migrate commands, respectively. A manual migration creates a migration skeleton\n", + "script with empty upgrade() and downgrade() functions that need to be imple‐\n", + "mented by the developer using directives exposed by Alembic’s Operations object.\n", + "An automatic migration attempts to generate the code for the upgrade() and\n", + "downgrade() functions by looking for differences between the model definitions and\n", + "the current state of the database.\n", + "Automatic migrations are not always accurate and can miss some\n", + "details that are ambiguous. For example, if a column is renamed, an\n", + "automatically generated migration may show that the column in\n", + "question was deleted and a new column was added with the new\n", + "name. Leaving the migration as is will cause the data in this column\n", + "to be lost! For this reason, migration scripts generated automati‐\n", + "cally should always be reviewed and manually corrected if they\n", + "have any inaccuracies.\n", + "To make changes to your database schema with Flask-Migrate, the following proce‐\n", + "dure needs to be followed:\n", + "1. Make the necessary changes to the model classes.\n", + "2. Create an automatic migration script with the flask db migrate command.\n", + "3. Review the generated script and adjust it so that it accurately represents the\n", + "changes that were made to the models.\n", + "74 \n", + "| \n", + "Chapter 5: Databases\n", + "\n", + "4. Add the migration script to source control.\n", + "5. Apply the migration to the database with the flask db upgrade command.\n", + "The flask db migrate subcommand creates an automatic migration script:\n", + "(venv) $ flask db migrate -m \"initial migration\"\n", + "INFO [alembic.migration] Context impl SQLiteImpl.\n", + "INFO [alembic.migration] Will assume non-transactional DDL.\n", + "INFO [alembic.autogenerate] Detected added table 'roles'\n", + "INFO [alembic.autogenerate] Detected added table 'users'\n", + "INFO [alembic.autogenerate.compare] Detected added index\n", + "'ix_users_username' on '['username']'\n", + " Generating /home/flask/flasky/migrations/versions/1bc\n", + " 594146bb5_initial_migration.py...done\n", + "If you are following the git checkout instructions to incrementally update the exam‐\n", + "ple application, you do not need to issue the migrate commands, as the migration\n", + "scripts are already incorporated into the Git repository tags.\n", + "If you have cloned the application’s Git repository on GitHub, you\n", + "can run git checkout 5d to check out this version of the applica‐\n", + "tion. Note that you do not need to generate the migration reposi‐\n", + "tory and the migration scripts for this application as these are\n", + "included in the GitHub repository.\n", + "Upgrading the Database\n", + "Once a migration script has been reviewed and accepted, it can be applied to the data‐\n", + "base using the flask db upgrade command:\n", + "(venv) $ flask db upgrade\n", + "INFO [alembic.migration] Context impl SQLiteImpl.\n", + "INFO [alembic.migration] Will assume non-transactional DDL.\n", + "INFO [alembic.migration] Running upgrade None -> 1bc594146bb5, initial migration\n", + "For a first migration, this is effectively equivalent to calling db.create_all(), but in\n", + "successive migrations the flask db upgrade command applies updates to the tables\n", + "without affecting their contents.\n", + "Database Migrations with Flask-Migrate \n", + "| \n", + "75\n", + "\n", + "If you have been working with the application in its previous\n", + "stages, you already have a database file that was created with the\n", + "db.create_all() function earlier. In this state, the flask db\n", + "upgrade will fail because it will try to create database tables that\n", + "already exist. A simple way to address this problem is to delete\n", + "your data.sqlite database file and then run flask db upgrade to\n", + "generate a new database through the migration framework.\n", + "Another option is to skip the flask db upgrade and instead mark\n", + "the existing database as upgraded using the flask db stamp com‐\n", + "mand.\n", + "Adding More Migrations\n", + "As you work on your own projects, you are going to find that you need to make\n", + "changes to your database models very often. When you manage the database through\n", + "a migration framework, all changes must be defined in migration scripts, because\n", + "anything that is not tracked in a migration will not be repeatable. The procedure to\n", + "introduce a change in the database is similar to what was done to introduce the first\n", + "migration:\n", + "1. Make the necessary changes in the database models.\n", + "2. Generate a migration with the flask db migrate command.\n", + "3. Review the generated migration script and correct it if it has any inaccuracies.\n", + "4. Apply the changes to the database with the flask db upgrade command.\n", + "While working on a specific feature, you may find that you need to make several\n", + "changes to your database models before you get them the way you want them. If your\n", + "last migration has not been committed to source control yet, you can opt to expand it\n", + "to incorporate new changes as you make them, and this will save you from having\n", + "lots of very small migration scripts that are meaningless on their own. The procedure\n", + "to expand the last migration script is as follows:\n", + "1. Remove the last migration from the database with the flask db downgrade com‐\n", + "mand (note that this may cause some data to be lost).\n", + "2. Delete the last migration script, which is now orphaned.\n", + "3. Generate a new database migration with the flask db migrate command,\n", + "which will now include the changes in the migration script you just removed,\n", + "plus any other changes you’ve made to the models.\n", + "4. Review and apply the migration script as described previously.\n", + "76 \n", + "| \n", + "Chapter 5: Databases\n", + "\n", + "Consult the Flask-Migrate documentation to learn about other\n", + "subcommands related to database migrations.\n", + "The topic of database design and usage is very important; entire books have been\n", + "written on the subject. You should consider this chapter as an overview; more\n", + "advanced topics will be discussed in later chapters. The next chapter is dedicated to\n", + "sending email.\n", + "Database Migrations with Flask-Migrate \n", + "| \n", + "77\n", + "\n", + "\n", + "CHAPTER 6\n", + "Email\n", + "Many types of applications need to notify users when certain events occur, and the\n", + "usual method of communication is email. In this chapter you are going to learn how\n", + "to send emails from a Flask application.\n", + "Email Support with Flask-Mail\n", + "Although the smtplib package from the Python standard library can be used to send\n", + "email inside a Flask application, the Flask-Mail extension wraps smtplib and integra‐\n", + "tes it nicely with Flask. Flask-Mail is installed with pip:\n", + "(venv) $ pip install flask-mail\n", + "The extension connects to a Simple Mail Transfer Protocol (SMTP) server and passes\n", + "emails to it for delivery. If no configuration is given, Flask-Mail connects to localhost\n", + "at port 25 and sends email without authentication. Table 6-1 shows the list of configu‐\n", + "ration keys that can be used to configure the SMTP server.\n", + "Table 6-1. Flask-Mail SMTP server configuration keys\n", + "Key\n", + "Default\n", + "Description\n", + "MAIL_SERVER\n", + "localhost\n", + "Hostname or IP address of the email server\n", + "MAIL_PORT\n", + "25\n", + "Port of the email server\n", + "MAIL_USE_TLS\n", + "False\n", + "Enable Transport Layer Security (TLS) security\n", + "MAIL_USE_SSL\n", + "False\n", + "Enable Secure Sockets Layer (SSL) security\n", + "MAIL_USERNAME\n", + "None\n", + "Mail account username\n", + "MAIL_PASSWORD\n", + "None\n", + "Mail account password\n", + "79\n", + "\n", + "During development it may be more convenient to connect to an external SMTP\n", + "server. As an example, Example 6-1 shows how to configure the application to send\n", + "email through a Google Gmail account.\n", + "Example 6-1. hello.py: Flask-Mail configuration for Gmail\n", + "import os\n", + "# ...\n", + "app.config['MAIL_SERVER'] = 'smtp.googlemail.com'\n", + "app.config['MAIL_PORT'] = 587\n", + "app.config['MAIL_USE_TLS'] = True\n", + "app.config['MAIL_USERNAME'] = os.environ.get('MAIL_USERNAME')\n", + "app.config['MAIL_PASSWORD'] = os.environ.get('MAIL_PASSWORD')\n", + "Never write account credentials directly in your scripts, particularly\n", + "if you plan to release your work as open source. To protect your\n", + "account information, have your script import sensitive information\n", + "from environment variables.\n", + "For security reasons, Gmail accounts are configured to require\n", + "external applications to use OAuth2 authentication to connect to\n", + "the email server. Unfortunately, Python’s smtplib library does not\n", + "support this method of authentication. To make your Gmail\n", + "account accept standard SMTP authentication, go to your Google\n", + "account settings page and select “Signing in to Google” from the\n", + "left menu bar. On that page, locate the “Allow less secure apps” set‐\n", + "ting and make sure it is enabled. If enabling this setting on your\n", + "personal Gmail account concerns you, create a secondary account\n", + "only to test sending emails.\n", + "Flask-Mail is initialized as shown in Example 6-2.\n", + "Example 6-2. hello.py: Flask-Mail initialization\n", + "from flask_mail import Mail\n", + "mail = Mail(app)\n", + "The two environment variables that hold the email server username and password\n", + "need to be defined in the environment. If you are on Linux or macOS, you can set\n", + "these variables as follows:\n", + "(venv) $ export MAIL_USERNAME=\n", + "(venv) $ export MAIL_PASSWORD=\n", + "80 \n", + "| \n", + "Chapter 6: Email\n", + "\n", + "For Microsoft Windows users, the environment variables are set as follows:\n", + "(venv) $ set MAIL_USERNAME=\n", + "(venv) $ set MAIL_PASSWORD=\n", + "Sending Email from the Python Shell\n", + "To test the configuration, you can start a shell session and send a test email (replace\n", + "you@example.com with your own email address):\n", + "(venv) $ flask shell\n", + ">>> from flask_mail import Message\n", + ">>> from hello import mail\n", + ">>> msg = Message('test email', sender='you@example.com',\n", + "... recipients=['you@example.com'])\n", + ">>> msg.body = 'This is the plain text body'\n", + ">>> msg.html = 'This is the HTML body'\n", + ">>> with app.app_context():\n", + "... mail.send(msg)\n", + "...\n", + "Note that Flask-Mail’s send() function uses current_app, so it needs to be executed\n", + "with an activated application context.\n", + "Integrating Emails with the Application\n", + "To avoid having to create email messages manually every time, it is a good idea to\n", + "abstract the common parts of the application’s email sending functionality into a\n", + "function. As an added benefit, this function can render email bodies from Jinja2 tem‐\n", + "plates to have the most flexibility. The implementation is shown in Example 6-3.\n", + "Example 6-3. hello.py: email support\n", + "from flask_mail import Message\n", + "app.config['FLASKY_MAIL_SUBJECT_PREFIX'] = '[Flasky]'\n", + "app.config['FLASKY_MAIL_SENDER'] = 'Flasky Admin '\n", + "def send_email(to, subject, template, **kwargs):\n", + " msg = Message(app.config['FLASKY_MAIL_SUBJECT_PREFIX'] + subject,\n", + " sender=app.config['FLASKY_MAIL_SENDER'], recipients=[to])\n", + " msg.body = render_template(template + '.txt', **kwargs)\n", + " msg.html = render_template(template + '.html', **kwargs)\n", + " mail.send(msg)\n", + "The function relies on two application-specific configuration keys that define a prefix\n", + "string for the subject and the address that will be used as the sender. The\n", + "send_email() function takes the destination address, a subject line, a template for the\n", + "email body, and a list of keyword arguments. The template name must be given\n", + "Email Support with Flask-Mail \n", + "| \n", + "81\n", + "\n", + "without the extension, so that two versions of the template can be used for the plain\n", + "text and HTML bodies. The keyword arguments passed by the caller are given to\n", + "render_template() so that they can be used by the templates that generate the email\n", + "body as template variables.\n", + "The index() view function can easily be expanded to send an email to the adminis‐\n", + "trator whenever a new name is received with the form. Example 6-4 shows this\n", + "change.\n", + "Example 6-4. hello.py: email example\n", + "# ...\n", + "app.config['FLASKY_ADMIN'] = os.environ.get('FLASKY_ADMIN')\n", + "# ...\n", + "@app.route('/', methods=['GET', 'POST'])\n", + "def index():\n", + " form = NameForm()\n", + " if form.validate_on_submit():\n", + " user = User.query.filter_by(username=form.name.data).first()\n", + " if user is None:\n", + " user = User(username=form.name.data)\n", + " db.session.add(user)\n", + " session['known'] = False\n", + " if app.config['FLASKY_ADMIN']:\n", + " send_email(app.config['FLASKY_ADMIN'], 'New User',\n", + " 'mail/new_user', user=user)\n", + " else:\n", + " session['known'] = True\n", + " session['name'] = form.name.data\n", + " form.name.data = ''\n", + " return redirect(url_for('index'))\n", + " return render_template('index.html', form=form, name=session.get('name'),\n", + " known=session.get('known', False))\n", + "The recipient of the email is given in the FLASKY_ADMIN environment variable that’s\n", + "loaded into a configuration variable of the same name during startup. Two template\n", + "files need to be created for the text and HTML versions of the email. These files are\n", + "stored in a mail subdirectory inside templates to keep them separate from regular\n", + "templates. The email templates expect the user to be given as a template argument, so\n", + "the call to send_email() includes it as a keyword argument.\n", + "If you have cloned the application’s Git repository on GitHub, you\n", + "can run git checkout 6a to check out this version of the applica‐\n", + "tion.\n", + "82 \n", + "| \n", + "Chapter 6: Email\n", + "\n", + "In addition to the MAIL_USERNAME and MAIL_PASSWORD environment variables\n", + "described earlier, this version of the application needs the FLASKY_ADMIN environment\n", + "variable. For Linux and macOS users, the command to set this variable is:\n", + "(venv) $ export FLASKY_ADMIN=\n", + "For Microsoft Windows users, this is the equivalent command:\n", + "(venv) $ set FLASKY_ADMIN=\n", + "With these environment variables set, you can test the application and receive an\n", + "email every time you enter a new name in the form.\n", + "Sending Asynchronous Email\n", + "If you sent a few test emails, you likely noticed that the mail.send() function blocks\n", + "for a few seconds while the email is sent, making the browser look unresponsive dur‐\n", + "ing that time. To avoid unnecessary delays during request handling, the email send\n", + "function can be moved to a background thread. Example 6-5 shows this change.\n", + "Example 6-5. hello.py: asynchronous email support\n", + "from threading import Thread\n", + "def send_async_email(app, msg):\n", + " with app.app_context():\n", + " mail.send(msg)\n", + "def send_email(to, subject, template, **kwargs):\n", + " msg = Message(app.config['FLASKY_MAIL_SUBJECT_PREFIX'] + subject,\n", + " sender=app.config['FLASKY_MAIL_SENDER'], recipients=[to])\n", + " msg.body = render_template(template + '.txt', **kwargs)\n", + " msg.html = render_template(template + '.html', **kwargs)\n", + " thr = Thread(target=send_async_email, args=[app, msg])\n", + " thr.start()\n", + " return thr\n", + "This implementation highlights an interesting problem. Many Flask extensions oper‐\n", + "ate under the assumption that there are active application and/or request contexts. As\n", + "mentioned previously, Flask-Mail’s send() function uses current_app, so it requires\n", + "the application context to be active. But since contexts are associated with a thread,\n", + "when the mail.send() function executes in a different thread it needs the application\n", + "context to be created artificially using app.app_context(). The app instance is passed\n", + "to the thread as an argument so that a context can be created.\n", + "Email Support with Flask-Mail \n", + "| \n", + "83\n", + "\n", + "If you have cloned the application’s Git repository on GitHub, you\n", + "can run git checkout 6b to check out this version of the applica‐\n", + "tion.\n", + "If you run the application now, you will notice that it is much more responsive, but\n", + "keep in mind that for applications that send a large volume of email, having a job\n", + "dedicated to sending email is more appropriate than starting a new thread for each\n", + "email send operation. For example, the execution of the send_async_email() func‐\n", + "tion can be sent to a Celery task queue.\n", + "This chapter completes the overview of the features that are a must-have for most\n", + "web applications. The problem now is that the hello.py script is starting to get large,\n", + "and that makes it harder to work with. In the next chapter, you will learn how to\n", + "structure a larger application.\n", + "84 \n", + "| \n", + "Chapter 6: Email\n", + "\n", + "CHAPTER 7\n", + "Large Application Structure\n", + "Although having small web applications stored in a single script file can be very con‐\n", + "venient, this approach does not scale well. As the application grows in complexity,\n", + "working with a single large source file becomes problematic.\n", + "Unlike most other web frameworks, Flask does not impose a specific organization for\n", + "large projects; the way to structure the application is left entirely to the developer. In\n", + "this chapter, a possible way to organize a large application in packages and modules is\n", + "presented. This structure will be used in the remaining examples of the book.\n", + "Project Structure\n", + "Example 7-1 shows the basic layout for a Flask application.\n", + "Example 7-1. Basic multiple-file Flask application structure\n", + "|-flasky\n", + " |-app/\n", + " |-templates/\n", + " |-static/\n", + " |-main/\n", + " |-__init__.py\n", + " |-errors.py\n", + " |-forms.py\n", + " |-views.py\n", + " |-__init__.py\n", + " |-email.py\n", + " |-models.py\n", + " |-migrations/\n", + " |-tests/\n", + " |-__init__.py\n", + " |-test*.py\n", + " |-venv/\n", + " |-requirements.txt\n", + " |-config.py\n", + " |-flasky.py\n", + "85\n", + "\n", + "This structure has four top-level folders:\n", + "• The Flask application lives inside a package generically named app.\n", + "• The migrations folder contains the database migration scripts, as before.\n", + "• Unit tests are written in a tests package.\n", + "• The venv folder contains the Python virtual environment, as before.\n", + "There are also a few new files:\n", + "• requirements.txt lists the package dependencies so that it is easy to regenerate an\n", + "identical virtual environment on a different computer.\n", + "• config.py stores the configuration settings.\n", + "• flasky.py defines the Flask application instance, and also includes a few tasks that\n", + "help manage the application.\n", + "To help you fully understand this structure, the following sections describe the pro‐\n", + "cess to convert the hello.py application to it.\n", + "Configuration Options\n", + "Applications often need several configuration sets. The best example of this is the\n", + "need to use different databases during development, testing, and production so that\n", + "they don’t interfere with each other.\n", + "Instead of the simple app.config dictionary-like configuration used by hello.py, a\n", + "hierarchy of configuration classes can be used. Example 7-2 shows the config.py file,\n", + "with all the settings imported from hello.py.\n", + "Example 7-2. config.py: application configuration\n", + "import os\n", + "basedir = os.path.abspath(os.path.dirname(__file__))\n", + "class Config:\n", + " SECRET_KEY = os.environ.get('SECRET_KEY') or 'hard to guess string'\n", + " MAIL_SERVER = os.environ.get('MAIL_SERVER', 'smtp.googlemail.com')\n", + " MAIL_PORT = int(os.environ.get('MAIL_PORT', '587'))\n", + " MAIL_USE_TLS = os.environ.get('MAIL_USE_TLS', 'true').lower() in \\\n", + " ['true', 'on', '1']\n", + " MAIL_USERNAME = os.environ.get('MAIL_USERNAME')\n", + " MAIL_PASSWORD = os.environ.get('MAIL_PASSWORD')\n", + " FLASKY_MAIL_SUBJECT_PREFIX = '[Flasky]'\n", + " FLASKY_MAIL_SENDER = 'Flasky Admin '\n", + " FLASKY_ADMIN = os.environ.get('FLASKY_ADMIN')\n", + " SQLALCHEMY_TRACK_MODIFICATIONS = False\n", + "86 \n", + "| \n", + "Chapter 7: Large Application Structure\n", + "\n", + " @staticmethod\n", + " def init_app(app):\n", + " pass\n", + "class DevelopmentConfig(Config):\n", + " DEBUG = True\n", + " SQLALCHEMY_DATABASE_URI = os.environ.get('DEV_DATABASE_URL') or \\\n", + " 'sqlite:///' + os.path.join(basedir, 'data-dev.sqlite')\n", + "class TestingConfig(Config):\n", + " TESTING = True\n", + " SQLALCHEMY_DATABASE_URI = os.environ.get('TEST_DATABASE_URL') or \\\n", + " 'sqlite://'\n", + "class ProductionConfig(Config):\n", + " SQLALCHEMY_DATABASE_URI = os.environ.get('DATABASE_URL') or \\\n", + " 'sqlite:///' + os.path.join(basedir, 'data.sqlite')\n", + "config = {\n", + " 'development': DevelopmentConfig,\n", + " 'testing': TestingConfig,\n", + " 'production': ProductionConfig,\n", + " 'default': DevelopmentConfig\n", + "}\n", + "The Config base class contains settings that are common to all configurations; the\n", + "different subclasses define settings that are specific to a configuration. Additional\n", + "configurations can be added as needed.\n", + "To make configuration more flexible and safe, most settings can be optionally impor‐\n", + "ted from environment variables. For example, the value of the SECRET_KEY, due to its\n", + "sensitive nature, can be set in the environment, but a default value is provided in case\n", + "the environment does not define it. Typically, these settings can be used with their\n", + "defaults during development but should each have an appropriate value set in the\n", + "corresponding environment variable on the production server. The configuration\n", + "options for the email server are all imported from environment variables as well, with\n", + "defaults pointing to the Gmail server for convenience during development.\n", + "Never write passwords or other secrets in a configuration file that is\n", + "committed to source control.\n", + "The SQLALCHEMY_DATABASE_URI variable is assigned different values under each of the\n", + "three configurations. This enables the application to use a different database in each\n", + "Configuration Options \n", + "| \n", + "87\n", + "\n", + "configuration. This is very important, as you don’t want a run of the unit tests to\n", + "change the database that you use for day-to-day development. Each configuration\n", + "tries to import the database URL from an environment variable, and when that is not\n", + "available it sets a default one based on SQLite. For the testing configuration, the\n", + "default is an in-memory database, since there is no need to store any data outside of\n", + "the test run.\n", + "The development and production configurations each have a set of mail server con‐\n", + "figuration options. As an additional way to allow the application to customize its con‐\n", + "figuration, the Config class and its subclasses can define an init_app() class method\n", + "that takes the application instance as an argument. For now the base Config class\n", + "implements an empty init_app() method.\n", + "At the bottom of the configuration script, the different configurations are registered\n", + "in a config dictionary. One of the configurations (the one for development, in this\n", + "case) is also registered as the default.\n", + "Application Package\n", + "The application package is where all the application code, templates, and static files\n", + "live. It is called simply app here, though it can be given an application-specific name if\n", + "desired. The templates and static directories are now part of the application package,\n", + "so they are moved inside app. The database models and the email support functions\n", + "are also moved inside this package, each in its own module, as app/models.py and\n", + "app/email.py.\n", + "Using an Application Factory\n", + "The way the application is created in the single-file version is very convenient, but it\n", + "has one big drawback. Because the application is created in the global scope, there is\n", + "no way to apply configuration changes dynamically: by the time the script is running,\n", + "the application instance has already been created, so it is already too late to make\n", + "configuration changes. This is particularly important for unit tests because sometimes\n", + "it is necessary to run the application under different configuration settings for better\n", + "test coverage.\n", + "The solution to this problem is to delay the creation of the application by moving it\n", + "into a factory function that can be explicitly invoked from the script. This not only\n", + "gives the script time to set the configuration, but also the ability to create multiple\n", + "application instances—another thing that can be very useful during testing. The\n", + "application factory function, shown in Example 7-3, is defined in the app package\n", + "constructor.\n", + "88 \n", + "| \n", + "Chapter 7: Large Application Structure\n", + "\n", + "Example 7-3. app/__init__.py: application package constructor\n", + "from flask import Flask, render_template\n", + "from flask_bootstrap import Bootstrap\n", + "from flask_mail import Mail\n", + "from flask_moment import Moment\n", + "from flask_sqlalchemy import SQLAlchemy\n", + "from config import config\n", + "bootstrap = Bootstrap()\n", + "mail = Mail()\n", + "moment = Moment()\n", + "db = SQLAlchemy()\n", + "def create_app(config_name):\n", + " app = Flask(__name__)\n", + " app.config.from_object(config[config_name])\n", + " config[config_name].init_app(app)\n", + " bootstrap.init_app(app)\n", + " mail.init_app(app)\n", + " moment.init_app(app)\n", + " db.init_app(app)\n", + " # attach routes and custom error pages here\n", + " return app\n", + "This constructor imports most of the Flask extensions currently in use, but because\n", + "there is no application instance to initialize them with, it creates them uninitialized\n", + "by passing no arguments into their constructors. The create_app() function is the\n", + "application factory, which takes as an argument the name of a configuration to use\n", + "for the application. The configuration settings stored in one of the classes defined in\n", + "config.py can be imported directly into the application using the from_object()\n", + "method available in Flask’s app.config configuration object. The configuration\n", + "object is selected by name from the config dictionary. Once an application is created\n", + "and configured, the extensions can be initialized. Calling init_app() on the exten‐\n", + "sions that were created earlier completes their initialization.\n", + "The application initialization is now done in this factory function, using the\n", + "from_object() method from the Flask configuration object, which takes as an argu‐\n", + "ment one of the configuration classes defined in config.py. The init_app() method of\n", + "the selected configuration is also invoked, to allow more complex initialization proce‐\n", + "dures to take place.\n", + "The factory function returns the created application instance, but note that applica‐\n", + "tions created with the factory function in its current state are incomplete, as they are\n", + "missing routes and custom error page handlers. This is the topic of the next section.\n", + "Application Package \n", + "| \n", + "89\n", + "\n", + "Implementing Application Functionality in a Blueprint\n", + "The conversion to an application factory introduces a complication for routes. In\n", + "single-script applications, the application instance exists in the global scope, so routes\n", + "can be easily defined using the app.route decorator. But now that the application is\n", + "created at runtime, the app.route decorator begins to exist only after create_app()\n", + "is invoked, which is too late. Custom error page handlers present the same problem,\n", + "as these are defined with the app.errorhandler decorator.\n", + "Luckily, Flask offers a better solution using blueprints. A blueprint is similar to an\n", + "application in that it can also define routes and error handlers. The difference is that\n", + "when these are defined in a blueprint they are in a dormant state until the blueprint is\n", + "registered with an application, at which point they become part of it. Using a blue‐\n", + "print defined in the global scope, the routes and error handlers of the application can\n", + "be defined in almost the same way as in the single-script application.\n", + "Like applications, blueprints can be defined all in a single file or can be created in a\n", + "more structured way with multiple modules inside a package. To allow for the great‐\n", + "est flexibility, a subpackage inside the application package will be created to host the\n", + "first blueprint of the application. Example 7-4 shows the package constructor, which\n", + "creates the blueprint.\n", + "Example 7-4. app/main/__init__.py: main blueprint creation\n", + "from flask import Blueprint\n", + "main = Blueprint('main', __name__)\n", + "from . import views, errors\n", + "Blueprints are created by instantiating an object of class Blueprint. The constructor\n", + "for this class takes two required arguments: the blueprint name and the module or\n", + "package where the blueprint is located. As with applications, Python’s __name__ vari‐\n", + "able is in most cases the correct value for the second argument.\n", + "The routes of the application are stored in an app/main/views.py module inside the\n", + "package, and the error handlers are in app/main/errors.py. Importing these modules\n", + "causes the routes and error handlers to be associated with the blueprint. It is impor‐\n", + "tant to note that the modules are imported at the bottom of the app/main/__init__.py\n", + "script to avoid errors due to circular dependencies. In this particular example the\n", + "problem is that app/main/views.py and app/main/errors.py in turn are going to import\n", + "the main blueprint object, so the imports are going to fail unless the circular reference\n", + "occurs after main is defined.\n", + "90 \n", + "| \n", + "Chapter 7: Large Application Structure\n", + "\n", + "The from . import syntax is used in Python to\n", + "represent relative imports. The . in this statement represents the\n", + "current package. You are going to see another very useful relative\n", + "import soon that uses the form from .. import ,\n", + "where .. represents the parent of the current package.\n", + "The blueprint is registered with the application inside the create_app() factory func‐\n", + "tion, as shown in Example 7-5.\n", + "Example 7-5. app/__init__.py: main blueprint registration\n", + "def create_app(config_name):\n", + " # ...\n", + " from .main import main as main_blueprint\n", + " app.register_blueprint(main_blueprint)\n", + " return app\n", + "Example 7-6 shows the error handlers.\n", + "Example 7-6. app/main/errors.py: error handlers in main blueprint\n", + "from flask import render_template\n", + "from . import main\n", + "@main.app_errorhandler(404)\n", + "def page_not_found(e):\n", + " return render_template('404.html'), 404\n", + "@main.app_errorhandler(500)\n", + "def internal_server_error(e):\n", + " return render_template('500.html'), 500\n", + "A difference when writing error handlers inside a blueprint is that if the\n", + "errorhandler decorator is used, the handler will be invoked only for errors that orig‐\n", + "inate in the routes defined by the blueprint. To install application-wide error han‐\n", + "dlers, the app_errorhandler decorator must be used instead.\n", + "Example 7-7 shows the route of the application updated to be in the blueprint.\n", + "Application Package \n", + "| \n", + "91\n", + "\n", + "Example 7-7. app/main/views.py: application routes in main blueprint\n", + "from datetime import datetime\n", + "from flask import render_template, session, redirect, url_for\n", + "from . import main\n", + "from .forms import NameForm\n", + "from .. import db\n", + "from ..models import User\n", + "@main.route('/', methods=['GET', 'POST'])\n", + "def index():\n", + " form = NameForm()\n", + " if form.validate_on_submit():\n", + " # ...\n", + " return redirect(url_for('.index'))\n", + " return render_template('index.html',\n", + " form=form, name=session.get('name'),\n", + " known=session.get('known', False),\n", + " current_time=datetime.utcnow())\n", + "There are two main differences when writing a view function inside a blueprint. First,\n", + "as was done for error handlers earlier, the route decorator comes from the blueprint,\n", + "so main.route is used instead of app.route. The second difference is in the usage of\n", + "the url_for() function. As you may recall, the first argument to this function is the\n", + "endpoint name of the route, which for application-based routes defaults to the name\n", + "of the view function. For example, in a single-script application the URL for an\n", + "index() view function can be obtained with url_for('index').\n", + "The difference with blueprints is that Flask applies a namespace to all the endpoints\n", + "defined in a blueprint, so that multiple blueprints can define view functions with the\n", + "same endpoint names without collisions. The namespace is the name of the blueprint\n", + "(the first argument to the Blueprint constructor) and is separated from the endpoint\n", + "name with a dot. The index() view function is then registered with endpoint name\n", + "main.index and its URL can be obtained with url_for('main.index').\n", + "The url_for() function also supports a shorter format for endpoints in blueprints in\n", + "which the blueprint name is omitted, such as url_for('.index'). With this nota‐\n", + "tion, the blueprint name for the current request is used to complete the endpoint\n", + "name. This effectively means that redirects within the same blueprint can use the\n", + "shorter form, while redirects across blueprints must use the fully qualified endpoint\n", + "name that includes the blueprint name.\n", + "To complete the changes to the application package, the form objects are also stored\n", + "inside the blueprint in the app/main/forms.py module.\n", + "92 \n", + "| \n", + "Chapter 7: Large Application Structure\n", + "\n", + "Application Script\n", + "The flasky.py module in the top-level directory is where the application instance is\n", + "defined. This script is shown in Example 7-8.\n", + "Example 7-8. flasky.py: main script\n", + "import os\n", + "from app import create_app, db\n", + "from app.models import User, Role\n", + "from flask_migrate import Migrate\n", + "app = create_app(os.getenv('FLASK_CONFIG') or 'default')\n", + "migrate = Migrate(app, db)\n", + "@app.shell_context_processor\n", + "def make_shell_context():\n", + " return dict(db=db, User=User, Role=Role)\n", + "The script begins by creating an application. The configuration is taken from the\n", + "environment variable FLASK_CONFIG if it’s defined, or else the default configuration is\n", + "used. Flask-Migrate and the custom context for the Python shell are then initialized.\n", + "Because the main script of the application changed from hello.py to flasky.py, the\n", + "FLASK_APP environment variable needs to be updated accordingly so that the flask\n", + "command can locate the application instance. It is also useful to enable Flask’s debug\n", + "mode by setting FLASK_DEBUG=1. For Linux and macOS, this is all done as follows:\n", + "(venv) $ export FLASK_APP=flasky.py\n", + "(venv) $ export FLASK_DEBUG=1\n", + "And for Microsoft Windows:\n", + "(venv) $ set FLASK_APP=flasky.py\n", + "(venv) $ set FLASK_DEBUG=1\n", + "Requirements File\n", + "It is a good practice for applications to include a requirements.txt file that records all\n", + "the package dependencies, with the exact version numbers. This is important in case\n", + "the virtual environment needs to be regenerated on a different machine, such as the\n", + "machine on which the application will be deployed for production use. This file can\n", + "be generated automatically by pip with the following command:\n", + "(venv) $ pip freeze >requirements.txt\n", + "It is a good idea to refresh this file whenever a package is installed or upgraded. An\n", + "example requirements file is shown here:\n", + "Application Script \n", + "| \n", + "93\n", + "\n", + "alembic==0.9.3\n", + "blinker==1.4\n", + "click==6.7\n", + "dominate==2.3.1\n", + "Flask==0.12.2\n", + "Flask-Bootstrap==3.3.7.1\n", + "Flask-Mail==0.9.1\n", + "Flask-Migrate==2.0.4\n", + "Flask-Moment==0.5.1\n", + "Flask-SQLAlchemy==2.2\n", + "Flask-WTF==0.14.2\n", + "itsdangerous==0.24\n", + "Jinja2==2.9.6\n", + "Mako==1.0.7\n", + "MarkupSafe==1.0\n", + "python-dateutil==2.6.1\n", + "python-editor==1.0.3\n", + "six==1.10.0\n", + "SQLAlchemy==1.1.11\n", + "visitor==0.1.3\n", + "Werkzeug==0.12.2\n", + "WTForms==2.1\n", + "When you need to build a perfect replica of the virtual environment, you can create a\n", + "new virtual environment and run the following command on it:\n", + "(venv) $ pip install -r requirements.txt\n", + "The version numbers in the example requirements.txt file are likely going to be outda‐\n", + "ted by the time you read this. You can try using more recent releases of the packages,\n", + "if you like. If you experience any problems, you can always go back to the versions\n", + "specified here, as those are known to be compatible with the application.\n", + "Unit Tests\n", + "This application is very small, so there isn’t a lot to test yet. But as an example, two\n", + "simple tests can be defined, as shown in Example 7-9.\n", + "Example 7-9. tests/test_basics.py: unit tests\n", + "import unittest\n", + "from flask import current_app\n", + "from app import create_app, db\n", + "class BasicsTestCase(unittest.TestCase):\n", + " def setUp(self):\n", + " self.app = create_app('testing')\n", + " self.app_context = self.app.app_context()\n", + " self.app_context.push()\n", + " db.create_all()\n", + "94 \n", + "| \n", + "Chapter 7: Large Application Structure\n", + "\n", + " def tearDown(self):\n", + " db.session.remove()\n", + " db.drop_all()\n", + " self.app_context.pop()\n", + " def test_app_exists(self):\n", + " self.assertFalse(current_app is None)\n", + " def test_app_is_testing(self):\n", + " self.assertTrue(current_app.config['TESTING'])\n", + "The tests are written using the standard unittest package from the Python standard\n", + "library. The setUp() and tearDown() methods of the test case class run before and\n", + "after each test, and any methods that have a name that begins with test_ are executed\n", + "as tests.\n", + "If you want to learn more about writing unit tests with Python’s\n", + "unittest package, read the official documentation.\n", + "The setUp() method tries to create an environment for the test that is close to that of\n", + "a running application. It first creates an application configured for testing and acti‐\n", + "vates its context. This step ensures that tests have access to current_app, like regular\n", + "requests do. Then it creates a brand-new database for the tests using Flask-\n", + "SQLAlchemy’s create_all() method. The database and the application context are\n", + "removed in the tearDown() method.\n", + "The first test ensures that the application instance exists. The second test ensures that\n", + "the application is running under the testing configuration. To make the tests directory\n", + "a proper package, a tests/init.py module needs to be added, but this can be an empty\n", + "file, as the unittest package scans all the modules to discover the tests.\n", + "If you have cloned the application’s Git repository on GitHub, you\n", + "can run git checkout 7a to check out the converted version of the\n", + "application. To ensure that you have all the dependencies installed,\n", + "also run pip install -r requirements.txt.\n", + "To run the unit tests, a custom command can be added to the flasky.py script.\n", + "Example 7-10 shows how to add a test command.\n", + "Unit Tests \n", + "| \n", + "95\n", + "\n", + "Example 7-10. flasky.py: unit test launcher command\n", + "@app.cli.command()\n", + "def test():\n", + " \"\"\"Run the unit tests.\"\"\"\n", + " import unittest\n", + " tests = unittest.TestLoader().discover('tests')\n", + " unittest.TextTestRunner(verbosity=2).run(tests)\n", + "The app.cli.command decorator makes it simple to implement custom commands.\n", + "The name of the decorated function is used as the command name, and the function’s\n", + "docstring is displayed in the help messages. The implementation of the test() func‐\n", + "tion invokes the test runner from the unittest package.\n", + "The unit tests can be executed as follows:\n", + "(venv) $ flask test\n", + "test_app_exists (test_basics.BasicsTestCase) ... ok\n", + "test_app_is_testing (test_basics.BasicsTestCase) ... ok\n", + ".----------------------------------------------------------------------\n", + "Ran 2 tests in 0.001s\n", + "OK\n", + "----\n", + "Database Setup\n", + "The restructured application uses a different database than the single-script version.\n", + "The database URL is taken from an environment variable as a first choice, with a\n", + "default SQLite database as an alternative. The environment variables and SQLite\n", + "database filenames are different for each of the three configurations. For example, in\n", + "the development configuration the URL is obtained from the environment variable\n", + "DEV_DATABASE_URL, and if that is not defined then an SQLite database with the name\n", + "data-dev.sqlite is used.\n", + "Regardless of the source of the database URL, the database tables must be created for\n", + "the new database. When working with Flask-Migrate to keep track of migrations,\n", + "database tables can be created or upgraded to the latest revision with a single com‐\n", + "mand:\n", + "(venv) $ flask db upgrade\n", + "96 \n", + "| \n", + "Chapter 7: Large Application Structure\n", + "\n", + "Running the Application\n", + "The refactoring is now complete, and the application can be started. Make sure you\n", + "have updated the FLASK_APP environment variable as indicated in “Application Script”\n", + "on page 93, and then run the application as usual:\n", + "(venv) $ flask run\n", + "Having to set the FLASK_APP and FLASK_DEBUG environment variables every time a\n", + "new command-prompt session is started can get tedious, so you should configure\n", + "your system so that these variables are set by default. If you are using bash, you can\n", + "add them to your ~/.bashrc file.\n", + "Believe it or not, you have reached the end of Part I. You have now learned about the\n", + "basic elements necessary to build a web application with Flask, but you probably feel\n", + "unsure about how all these pieces fit together to form a real application. The goal of\n", + "Part II is to help with that by walking you through the development of a complete\n", + "application.\n", + "Running the Application \n", + "| \n", + "97\n", + "\n", + "\n", + "PART II\n", + "Example: A Social\n", + "Blogging Application\n", + "\n", + "\n", + "CHAPTER 8\n", + "User Authentication\n", + "Most applications need to keep track of who their users are. When users connect with\n", + "an application, they authenticate with it, a process by which they make their identity\n", + "known. Once the application knows who the user is, it can offer a customized experi‐\n", + "ence.\n", + "The most commonly used method of authentication requires users to provide a piece\n", + "of identification, which is either their email address or username, and a secret only\n", + "known to them, which is called the password. In this chapter, the complete authenti‐\n", + "cation system for Flasky is created.\n", + "Authentication Extensions for Flask\n", + "There are many excellent Python authentication packages, but none of them do\n", + "everything. The user authentication solution presented in this chapter uses several\n", + "packages and provides the glue that makes them work well together. This is the list of\n", + "packages that will be used, and what they’re used for:\n", + "• Flask-Login: Management of user sessions for logged-in users\n", + "• Werkzeug: Password hashing and verification\n", + "• itsdangerous: Cryptographically secure token generation and verification\n", + "In addition to authentication-specific packages, the following general-purpose exten‐\n", + "sions will be used:\n", + "• Flask-Mail: Sending of authentication-related emails\n", + "• Flask-Bootstrap: HTML templates\n", + "• Flask-WTF: Web forms\n", + "101\n", + "\n", + "Password Security\n", + "The safety of user information stored in databases is often overlooked during the\n", + "design of web applications. If an attacker is able to break into your server and access\n", + "your user database, then you risk the security of your users—and the risk is bigger\n", + "than you think. It is a known fact that most users use the same password on multiple\n", + "sites, so even if you don’t store any sensitive information, access to the passwords\n", + "stored in your database can give the attacker access to accounts your users have on\n", + "other sites.\n", + "The key to storing user passwords securely in a database relies on not storing the\n", + "password itself but a hash of it. A password hashing function takes a password as\n", + "input, adds a random component to it (the salt), and then applies several one-way\n", + "cryptographic transformations to it. The result is a new sequence of characters that\n", + "has no resemblance to the original password, and has no known way to be trans‐\n", + "formed back into the original password. Password hashes can be verified in place of\n", + "the real passwords because hashing functions are repeatable: given the same inputs\n", + "(the password and the salt), the result is always the same.\n", + "Password hashing is a complex task that is hard to get right. It is\n", + "recommended that you don’t implement your own solution but\n", + "instead rely on well-known libraries that have been reviewed by the\n", + "community. In the next section, Werkzeug’s password hashing\n", + "functions will be demonstrated. Other good choices for password\n", + "hashing are bcrypt and Passlib. If you are interested in learning\n", + "what’s involved in generating secure password hashes, the article\n", + "“Salted Password Hashing - Doing It Right” by Defuse Security is a\n", + "worthwhile read.\n", + "Hashing Passwords with Werkzeug\n", + "Werkzeug’s security module conveniently implements secure password hashing. This\n", + "functionality is exposed with just two functions, used in the registration and verifica‐\n", + "tion phases, respectively:\n", + "generate_password_hash(password, method='pbkdf2:sha256', salt_length=8)\n", + "This function takes a plain-text password and returns the password hash as a\n", + "string that can be stored in the user database. The default values for method and\n", + "salt_length are sufficient for most use cases.\n", + "check_password_hash(hash, password)\n", + "This function takes a password hash previously stored in the database and the\n", + "password entered by the user. A return value of True indicates that the user pass‐\n", + "word is correct.\n", + "102 \n", + "| \n", + "Chapter 8: User Authentication\n", + "\n", + "Example 8-1 shows the changes to the User model created in Chapter 5 to accommo‐\n", + "date password hashing.\n", + "Example 8-1. app/models.py: password hashing in the User model\n", + "from werkzeug.security import generate_password_hash, check_password_hash\n", + "class User(db.Model):\n", + " # ...\n", + " password_hash = db.Column(db.String(128))\n", + " @property\n", + " def password(self):\n", + " raise AttributeError('password is not a readable attribute')\n", + " @password.setter\n", + " def password(self, password):\n", + " self.password_hash = generate_password_hash(password)\n", + " def verify_password(self, password):\n", + " return check_password_hash(self.password_hash, password)\n", + "The password hashing function is implemented through a write-only property called\n", + "password. When this property is set, the setter method will call Werkzeug’s\n", + "generate_password_hash() function and write the result to the password_hash field.\n", + "Attempting to read the password property will return an error, as clearly the original\n", + "password cannot be recovered once hashed.\n", + "The verify_password() method takes a password and passes it to Werkzeug’s\n", + "check_password_hash() function for verification against the hashed version stored\n", + "in the User model. If this method returns True, then the password is correct.\n", + "If you have cloned the application’s Git repository on GitHub, you\n", + "can run git checkout 8a to check out this version of the applica‐\n", + "tion.\n", + "Password Security \n", + "| \n", + "103\n", + "\n", + "The password hashing functionality is now complete and can be tested in the shell:\n", + "(venv) $ flask shell\n", + ">>> u = User()\n", + ">>> u.password = 'cat'\n", + ">>> u.password\n", + "Traceback (most recent call last):\n", + " File \"\", line 1, in \n", + " File \"/home/flask/flasky/app/models.py\", line 24, in password\n", + " raise AttributeError('password is not a readable attribute')\n", + "AttributeError: password is not a readable attribute\n", + ">>> u.password_hash\n", + "'pbkdf2:sha256:50000$moHwFH1B$ef1574909f9c549285e8547cad181c5e0213cfa44a4aba4349\n", + "fa830aa1fd227f'\n", + ">>> u.verify_password('cat')\n", + "True\n", + ">>> u.verify_password('dog')\n", + "False\n", + ">>> u2 = User()\n", + ">>> u2.password = 'cat'\n", + ">>> u2.password_hash\n", + "'pbkdf2:sha256:50000$Pfz0m0KU$27be930b7f0e0119d38e8d8a62f7f5e75c0a7db61ae16709bc\n", + "aa6cfd60c44b74'\n", + "Note how trying to access the password property of a user returns an\n", + "AttributeError. Also, users u and u2 have completely different password hashes,\n", + "even though they both use the same password. To ensure that this functionality con‐\n", + "tinues to work in the future, the preceding tests done manually can be written as unit\n", + "tests that can be repeated easily. In Example 8-2 a new module inside the tests package\n", + "is shown with three new tests that exercise the recent changes to the User model.\n", + "Example 8-2. tests/test_user_model.py: password hashing tests\n", + "import unittest\n", + "from app.models import User\n", + "class UserModelTestCase(unittest.TestCase):\n", + " def test_password_setter(self):\n", + " u = User(password = 'cat')\n", + " self.assertTrue(u.password_hash is not None)\n", + " def test_no_password_getter(self):\n", + " u = User(password = 'cat')\n", + " with self.assertRaises(AttributeError):\n", + " u.password\n", + " def test_password_verification(self):\n", + " u = User(password = 'cat')\n", + " self.assertTrue(u.verify_password('cat'))\n", + " self.assertFalse(u.verify_password('dog'))\n", + "104 \n", + "| \n", + "Chapter 8: User Authentication\n", + "\n", + " def test_password_salts_are_random(self):\n", + " u = User(password='cat')\n", + " u2 = User(password='cat')\n", + " self.assertTrue(u.password_hash != u2.password_hash)\n", + "To run these new unit tests, use the following command:\n", + "(venv) $ flask test\n", + "test_app_exists (test_basics.BasicsTestCase) ... ok\n", + "test_app_is_testing (test_basics.BasicsTestCase) ... ok\n", + "test_no_password_getter (test_user_model.UserModelTestCase) ... ok\n", + "test_password_salts_are_random (test_user_model.UserModelTestCase) ... ok\n", + "test_password_setter (test_user_model.UserModelTestCase) ... ok\n", + "test_password_verification (test_user_model.UserModelTestCase) ... ok\n", + ".----------------------------------------------------------------------\n", + "Ran 6 tests in 0.379s\n", + "OK\n", + "You can run the unit test suite like this every time you want to confirm everything is\n", + "working as expected. Having the automation in place makes verifying this feature\n", + "very low cost, so testing should be repeated often, to ensure that this functionality\n", + "does not break in the future.\n", + "Creating an Authentication Blueprint\n", + "Blueprints were introduced in Chapter 7 as a way to define routes in the global scope\n", + "after the creation of the application was moved into a factory function. In this sec‐\n", + "tion, the routes related to the user authentication subsystem will be added to a second\n", + "blueprint, called auth. Using different blueprints for different subsystems of the\n", + "application is a great way to keep the code neatly organized.\n", + "The auth blueprint will be hosted in a Python package with the same name. The blue‐\n", + "print’s package constructor creates the blueprint object and imports routes from a\n", + "views.py module. This is shown in Example 8-3.\n", + "Example 8-3. app/auth/__init__.py: authentication blueprint creation\n", + "from flask import Blueprint\n", + "auth = Blueprint('auth', __name__)\n", + "from . import views\n", + "The app/auth/views.py module, shown in Example 8-4, imports the blueprint and\n", + "defines the routes associated with authentication using its route decorator. For now,\n", + "a /login route is added, which renders a placeholder template of the same name.\n", + "Creating an Authentication Blueprint \n", + "| \n", + "105\n", + "\n", + "Example 8-4. app/auth/views.py: authentication blueprint routes and view functions\n", + "from flask import render_template\n", + "from . import auth\n", + "@auth.route('/login')\n", + "def login():\n", + " return render_template('auth/login.html')\n", + "Note that the template file given to render_template() is stored inside the auth\n", + "directory. This directory must be created inside app/templates, as Flask expects the\n", + "templates’ paths to be relative to the application’s templates directory. By storing the\n", + "blueprint templates in their own subdirectory, there is no risk of naming collisions\n", + "with the main blueprint or any other blueprints that will be added in the future.\n", + "Blueprints can also be configured to have their own independent\n", + "directories for templates. When multiple template directories have\n", + "been configured, the render_template() function searches the\n", + "templates directory configured for the application first, and then\n", + "searches the template directories defined by blueprints.\n", + "The auth blueprint needs to be attached to the application in the create_app() fac‐\n", + "tory function, as shown in Example 8-5.\n", + "Example 8-5. app/__init__.py: authentication blueprint registration\n", + "def create_app(config_name):\n", + " # ...\n", + " from .auth import auth as auth_blueprint\n", + " app.register_blueprint(auth_blueprint, url_prefix='/auth')\n", + " return app\n", + "The url_prefix argument in the blueprint registration is optional. When used, all\n", + "the routes defined in the blueprint will be registered with the given prefix, in this\n", + "case /auth. For example, the /login route will be registered as /auth/login, and the fully\n", + "qualified URL under the development web server then becomes http://localhost:5000/\n", + "auth/login.\n", + "If you have cloned the application’s Git repository on GitHub, you\n", + "can run git checkout 8b to check out this version of the applica‐\n", + "tion.\n", + "106 \n", + "| \n", + "Chapter 8: User Authentication\n", + "\n", + "User Authentication with Flask-Login\n", + "When users log in to the application, their authenticated state has to be recorded in\n", + "the user session, so that it is remembered as they navigate through different pages.\n", + "Flask-Login is a small but extremely useful extension that specializes in managing\n", + "this particular aspect of a user authentication system, without being tied to a specific\n", + "authentication mechanism.\n", + "To begin, the extension needs to be installed in the virtual environment:\n", + "(venv) $ pip install flask-login\n", + "Preparing the User Model for Logins\n", + "Flask-Login works closely with the application’s own User objects. To be able to work\n", + "with the application’s User model, the Flask-Login extension requires it to implement\n", + "a few common properties and methods. The required items are shown in Table 8-1.\n", + "Table 8-1. Flask-Login required items\n", + "Property/method\n", + "Description\n", + "is_authenticated Must be True if the user has valid login credentials or False otherwise.\n", + "is_active\n", + "Must be True if the user is allowed to log in or False otherwise. A False value can be used for\n", + "disabled accounts.\n", + "is_anonymous\n", + "Must always be False for regular users and True for a special user object that represents\n", + "anonymous users.\n", + "get_id()\n", + "Must return a unique identifier for the user, encoded as a Unicode string.\n", + "These properties and methods can be implemented directly in the model class, but as\n", + "an easier alternative Flask-Login provides a UserMixin class that has default imple‐\n", + "mentations that are appropriate for most cases. The updated User model is shown in\n", + "Example 8-6.\n", + "Example 8-6. app/models.py: updates to the User model to support user logins\n", + "from flask_login import UserMixin\n", + "class User(UserMixin, db.Model):\n", + " __tablename__ = 'users'\n", + " id = db.Column(db.Integer, primary_key = True)\n", + " email = db.Column(db.String(64), unique=True, index=True)\n", + " username = db.Column(db.String(64), unique=True, index=True)\n", + " password_hash = db.Column(db.String(128))\n", + " role_id = db.Column(db.Integer, db.ForeignKey('roles.id'))\n", + "User Authentication with Flask-Login \n", + "| \n", + "107\n", + "\n", + "Note that an email field was also added. In this application, users will log in with\n", + "their email addresses, as they are less likely to forget those than their usernames.\n", + "Flask-Login is initialized in the application factory function, as shown in\n", + "Example 8-7.\n", + "Example 8-7. app/__init__.py: Flask-Login initialization\n", + "from flask_login import LoginManager\n", + "login_manager = LoginManager()\n", + "login_manager.login_view = 'auth.login'\n", + "def create_app(config_name):\n", + " # ...\n", + " login_manager.init_app(app)\n", + " # ...\n", + "The login_view attribute of the LoginManager object sets the endpoint for the login\n", + "page. Flask-Login will redirect to the login page when an anonymous user tries to\n", + "access a protected page. Because the login route is inside a blueprint, it needs to be\n", + "prefixed with the blueprint name.\n", + "Finally, Flask-Login requires the application to designate a function to be invoked\n", + "when the extension needs to load a user from the database given its identifier. This\n", + "function is shown in Example 8-8.\n", + "Example 8-8. app/models.py: user loader function\n", + "from . import login_manager\n", + "@login_manager.user_loader\n", + "def load_user(user_id):\n", + " return User.query.get(int(user_id))\n", + "The login_manager.user_loader decorator is used to register the function with\n", + "Flask-Login, which will call it when it needs to retrieve information about the logged-\n", + "in user. The user identifier will be passed as a string, so the function converts it to an\n", + "integer before it passes it to the Flask-SQLAlchemy query that loads the user. The\n", + "return value of the function must be the user object, or None if the user identifier is\n", + "invalid or any other error occurred.\n", + "Protecting Routes\n", + "To protect a route so that it can only be accessed by authenticated users, Flask-Login\n", + "provides a login_required decorator. An example of its usage follows:\n", + "108 \n", + "| \n", + "Chapter 8: User Authentication\n", + "\n", + "from flask_login import login_required\n", + "@app.route('/secret')\n", + "@login_required\n", + "def secret():\n", + " return 'Only authenticated users are allowed!'\n", + "You can see from this example that it is possible to “chain” multiple function decora‐\n", + "tors. When two or more decorators are added to a function, each decorator only\n", + "affects those that are below it, in addition to the target function. In this example, the\n", + "secret() \n", + "function \n", + "will \n", + "be \n", + "protected \n", + "against \n", + "unauthorized \n", + "users \n", + "with\n", + "login_required, and then the resulting function will be registered with Flask as a\n", + "route. Reversing the order will produce the wrong result, as the original function will\n", + "be registered as a route before it receives the additional properties from the\n", + "login_required decorator.\n", + "Thanks to the login_required decorator, if this route is accessed by a user who is not\n", + "authenticated, Flask-Login will intercept the request and send the user to the login\n", + "page instead.\n", + "Adding a Login Form\n", + "The login form that will be presented to users has a text field for the email address, a\n", + "password field, a “remember me” checkbox, and a submit button. The Flask-WTF\n", + "form class that defines this form is shown in Example 8-9.\n", + "Example 8-9. app/auth/forms.py: login form\n", + "from flask_wtf import FlaskForm\n", + "from wtforms import StringField, PasswordField, BooleanField, SubmitField\n", + "from wtforms.validators import DataRequired, Length, Email\n", + "class LoginForm(FlaskForm):\n", + " email = StringField('Email', validators=[DataRequired(), Length(1, 64),\n", + " Email()])\n", + " password = PasswordField('Password', validators=[DataRequired()])\n", + " remember_me = BooleanField('Keep me logged in')\n", + " submit = SubmitField('Log In')\n", + "The PasswordField class represents an element with type=\"password\". The\n", + "BooleanField class represents a checkbox.\n", + "The email field uses the Length() and Email() validators from WTForms in addition\n", + "to DataRequired(), to ensure that the user not only provides a value for this field, but\n", + "that it is valid. When providing a list of validators, WTForms will evaluate them in\n", + "the order provided, and in case of a validation failure the error message shown will be\n", + "the one of the first validator that failed.\n", + "User Authentication with Flask-Login \n", + "| \n", + "109\n", + "\n", + "The template associated with the login page is stored in auth/login.html. This tem‐\n", + "plate just needs to render the form using Flask-Bootstrap’s wtf.quick_form() macro.\n", + "Figure 8-1 shows the login form rendered by the web browser.\n", + "Figure 8-1. Login form\n", + "The navigation bar in the base.html template uses a Jinja2 conditional to display “Log\n", + "In” or “Log Out” links depending on the logged-in state of the current user. The con‐\n", + "ditional is shown in Example 8-10.\n", + "Example 8-10. app/templates/base.html: Log In and Log Out navigation bar links\n", + "
    \n", + " {% if current_user.is_authenticated %}\n", + "
  • Log Out
    • \n", + " {% else %}\n", + "
  • Log In
    • \n", + " {% endif %}\n", + "
\n", + "The current_user variable used in the conditional is defined by Flask-Login and is\n", + "automatically available to view functions and templates. This variable contains the\n", + "currently logged-in user, or a proxy anonymous user object if the user is not logged\n", + "in. Anonymous user objects have the is_authenticated property set to False, so the\n", + "110 \n", + "| \n", + "Chapter 8: User Authentication\n", + "\n", + "expression current_user.is_authenticated is a convenient way to know whether\n", + "the current user is logged in.\n", + "Signing Users In\n", + "The implementation of the login() view function is shown in Example 8-11.\n", + "Example 8-11. app/auth/views.py: login route\n", + "from flask import render_template, redirect, request, url_for, flash\n", + "from flask_login import login_user\n", + "from . import auth\n", + "from ..models import User\n", + "from .forms import LoginForm\n", + "@auth.route('/login', methods=['GET', 'POST'])\n", + "def login():\n", + " form = LoginForm()\n", + " if form.validate_on_submit():\n", + " user = User.query.filter_by(email=form.email.data).first()\n", + " if user is not None and user.verify_password(form.password.data):\n", + " login_user(user, form.remember_me.data)\n", + " next = request.args.get('next')\n", + " if next is None or not next.startswith('/'):\n", + " next = url_for('main.index')\n", + " return redirect(next)\n", + " flash('Invalid username or password.')\n", + " return render_template('auth/login.html', form=form)\n", + "The view function creates a LoginForm object and uses it like the simple form in\n", + "Chapter 4. When the request is of type GET, the view function just renders the tem‐\n", + "plate, which in turn displays the form. When the form is submitted in a POST request,\n", + "Flask-WTF’s validate_on_submit() function validates the form variables, and then\n", + "attempts to log the user in.\n", + "To log a user in, the function begins by loading the user from the database using the\n", + "email provided with the form. If a user with the given email address exists, then its\n", + "verify_password() method is called with the password that also came with the form.\n", + "If the password is valid, Flask-Login’s login_user() function is invoked to record the\n", + "user as logged in for the user session. The login_user() function takes the user to\n", + "log in and an optional “remember me” Boolean, which was also submitted with the\n", + "form. A value of False for this argument causes the user session to expire when the\n", + "browser window is closed, so the user will have to log in again next time. A value of\n", + "True causes a long-term cookie to be set in the user’s browser, which Flask-Login uses\n", + "to restore the user session. The optional REMEMBER_COOKIE_DURATION configuration\n", + "option can be used to change the default one-year duration for the remember cookie.\n", + "User Authentication with Flask-Login \n", + "| \n", + "111\n", + "\n", + "In accordance with the Post/Redirect/Get pattern discussed in Chapter 4, the POST\n", + "request that submitted the login credentials ends with a redirect, but there are two\n", + "possible URL destinations. If the login form was presented to the user to prevent\n", + "unauthorized access to a protected URL the user wanted to visit, then Flask-Login\n", + "will have saved that original URL in the next query string argument, which can be\n", + "accessed from the request.args dictionary. If the next query string argument is not\n", + "available, a redirect to the home page is issued instead. The URL in next is validated\n", + "to make sure it is a relative URL, to prevent a malicious user from using this argu‐\n", + "ment to redirect unsuspecting users to another site.\n", + "For the case where the email address or password provided by the user is invalid, a\n", + "flash message is set and the form is rendered again for the user to retry.\n", + "On a production server, the application must be made available\n", + "over secure HTTP, so that login credentials and user sessions are\n", + "always transmitted encrypted. Without secure HTTP, sensitive data\n", + "can be intercepted during transit by an attacker.\n", + "The login template needs to be updated to render the form. These changes are shown\n", + "in Example 8-12.\n", + "Example 8-12. app/templates/auth/login.html: login form template\n", + "{% extends \"base.html\" %}\n", + "{% import \"bootstrap/wtf.html\" as wtf %}\n", + "{% block title %}Flasky - Login{% endblock %}\n", + "{% block page_content %}\n", + "
\n", + "

Login

\n", + "
\n", + "
\n", + " {{ wtf.quick_form(form) }}\n", + "
\n", + "{% endblock %}\n", + "Signing Users Out\n", + "The implementation of the logout route is shown in Example 8-13.\n", + "Example 8-13. app/auth/views.py: logout route\n", + "from flask_login import logout_user, login_required\n", + "@auth.route('/logout')\n", + "112 \n", + "| \n", + "Chapter 8: User Authentication\n", + "\n", + "@login_required\n", + "def logout():\n", + " logout_user()\n", + " flash('You have been logged out.')\n", + " return redirect(url_for('main.index'))\n", + "To log a user out, Flask-Login’s logout_user() function is called to remove and reset\n", + "the user session. The logout is completed with a flash message that confirms the\n", + "action and a redirect to the home page.\n", + "If you have cloned the application’s Git repository on GitHub, you\n", + "can run git checkout 8c to check out this version of the applica‐\n", + "tion. This update contains a database migration, so remember to\n", + "run flask db upgrade after you check out the code. To ensure that\n", + "you have all the dependencies installed, also run pip install -r\n", + "requirements.txt.\n", + "Understanding How Flask-Login Works\n", + "Flask-Login is a fairly small extension, but due to the many moving pieces involved in\n", + "the authentication flow, Flask users often have trouble understanding how the exten‐\n", + "sion works. The following is the sequence of operations that occur when a user logs in\n", + "to the system:\n", + "1. The user navigates to http://localhost:5000/auth/login by clicking on the “Log In”\n", + "link. The handler for this URL returns the login form template.\n", + "2. The user enters their username and password, and presses the Submit button.\n", + "The same handler is invoked again, but now as a POST request instead of GET.\n", + "a. The handler validates the credentials submitted with the form, and then\n", + "invokes Flask-Login’s login_user() function to log the user in.\n", + "b. The login_user() function writes the ID of the user to the user session as a\n", + "string.\n", + "c. The view function returns with a redirect to the home page.\n", + "3. The browser receives the redirect and requests the home page.\n", + "a. The view function for the home page is invoked, and it triggers the rendering\n", + "of the main Jinja2 template.\n", + "b. During the rendering of the Jinja2 template, a reference to Flask-Login’s\n", + "current_user appears for the first time.\n", + "c. The current_user context variable does not have a value assigned for this\n", + "request yet, so it invokes Flask-Login’s internal function _get_user() to find\n", + "out who the user is.\n", + "User Authentication with Flask-Login \n", + "| \n", + "113\n", + "\n", + "d. The _get_user() function checks if there is a user ID stored in the user ses‐\n", + "sion. If there isn’t one, it returns an instance of Flask-Login’s AnonymousUser.\n", + "If there is an ID, it invokes the function that the application registered with\n", + "the user_loader decorator, with the ID as its argument.\n", + "e. The application’s user_loader handler reads the user from the database and\n", + "returns it. Flask-Login assigns it to the current_user context variable for the\n", + "current request.\n", + "f. The template receives the newly assigned value of current_user.\n", + "The login_required decorator builds on top of the current_user context variable\n", + "by only allowing the decorated view function to run when the expression\n", + "current_user.is_authenticated is True. The logout_user() function simply dele‐\n", + "tes the user ID from the user session.\n", + "Testing Logins\n", + "To verify that the login functionality is working, the home page can be updated to\n", + "greet the logged-in user by name. The template section that generates the greeting is\n", + "shown in Example 8-14.\n", + "Example 8-14. app/templates/index.html: greeting the logged-in user\n", + "Hello,\n", + "{% if current_user.is_authenticated %}\n", + " {{ current_user.username }}\n", + "{% else %}\n", + " Stranger\n", + "{% endif %}!\n", + "In this template once again current_user.is_authenticated is used to determine\n", + "whether the user is logged in.\n", + "Because no user registration functionality has been built, a new user can only be reg‐\n", + "istered from the shell at this time:\n", + "(venv) $ $ flask shell\n", + ">>> u = User(email='john@example.com', username='john', password='cat')\n", + ">>> db.session.add(u)\n", + ">>> db.session.commit()\n", + "The user created previously can now log in. Figure 8-2 shows the application home\n", + "page with the user logged in.\n", + "114 \n", + "| \n", + "Chapter 8: User Authentication\n", + "\n", + "Figure 8-2. Home page after successful login\n", + "New User Registration\n", + "When new users want to become members of the application, they must register with\n", + "it so that they are known and can log in. A link in the login page will send them to a\n", + "registration page, where they can enter their email address, username, and password.\n", + "Adding a User Registration Form\n", + "The form that will be used in the registration page asks the user to enter an email\n", + "address, username, and password. This form is shown in Example 8-15.\n", + "Example 8-15. app/auth/forms.py: user registration form\n", + "from flask_wtf import FlaskForm\n", + "from wtforms import StringField, PasswordField, BooleanField, SubmitField\n", + "from wtforms.validators import DataRequired, Length, Email, Regexp, EqualTo\n", + "from wtforms import ValidationError\n", + "from ..models import User\n", + "class RegistrationForm(FlaskForm):\n", + " email = StringField('Email', validators=[DataRequired(), Length(1, 64),\n", + " Email()])\n", + "New User Registration \n", + "| \n", + "115\n", + "\n", + " username = StringField('Username', validators=[\n", + " DataRequired(), Length(1, 64),\n", + " Regexp('^[A-Za-z][A-Za-z0-9_.]*$', 0,\n", + " 'Usernames must have only letters, numbers, dots or '\n", + " 'underscores')])\n", + " password = PasswordField('Password', validators=[\n", + " DataRequired(), EqualTo('password2', message='Passwords must match.')])\n", + " password2 = PasswordField('Confirm password', validators=[DataRequired()])\n", + " submit = SubmitField('Register')\n", + " def validate_email(self, field):\n", + " if User.query.filter_by(email=field.data).first():\n", + " raise ValidationError('Email already registered.')\n", + " def validate_username(self, field):\n", + " if User.query.filter_by(username=field.data).first():\n", + " raise ValidationError('Username already in use.')\n", + "This form uses the Regexp validator from WTForms to ensure that the username field\n", + "starts with a letter and only contains letters, numbers, underscores, and dots. The two\n", + "arguments to the validator that follow the regular expression are the regular expres‐\n", + "sion flags and the error message to display on failure.\n", + "The password is entered twice as a safety measure, but this step makes it necessary to\n", + "validate that the two password fields have the same content, which is done with\n", + "another validator from WTForms called EqualTo. This validator is attached to one of\n", + "the password fields with the name of the other field given as an argument.\n", + "This form also has two custom validators implemented as methods. When a form\n", + "defines a method with the prefix validate_ followed by the name of a field, the\n", + "method is invoked in addition to any regularly defined validators. In this case, the\n", + "custom validators for email and username ensure that the values given are not dupli‐\n", + "cates. The custom validators indicate a validation error by raising a ValidationError\n", + "exception with the text of the error message as an argument.\n", + "The template that presents this form is called /templates/auth/register.html. Like the\n", + "login template, this one also renders the form with wtf.quick_form(). The registra‐\n", + "tion page is shown in Figure 8-3.\n", + "116 \n", + "| \n", + "Chapter 8: User Authentication\n", + "\n", + "Figure 8-3. New user registration form\n", + "The registration page needs to be linked from the login page so that users who don’t\n", + "have an account can easily find it. This change is shown in Example 8-16.\n", + "Example 8-16. app/templates/auth/login.html: link to the registration page\n", + "

\n", + " New user?\n", + " \n", + " Click here to register\n", + " \n", + "

\n", + "Registering New Users\n", + "Handling user registrations does not present any big surprises. When the registration\n", + "form is submitted and validated, a new user is added to the database using the infor‐\n", + "mation provided by the user. The view function that performs this task is shown in\n", + "Example 8-17.\n", + "New User Registration \n", + "| \n", + "117\n", + "\n", + "Example 8-17. app/auth/views.py: user registration route\n", + "@auth.route('/register', methods=['GET', 'POST'])\n", + "def register():\n", + " form = RegistrationForm()\n", + " if form.validate_on_submit():\n", + " user = User(email=form.email.data,\n", + " username=form.username.data,\n", + " password=form.password.data)\n", + " db.session.add(user)\n", + " db.session.commit()\n", + " flash('You can now login.')\n", + " return redirect(url_for('auth.login'))\n", + " return render_template('auth/register.html', form=form)\n", + "If you have cloned the application’s Git repository on GitHub, you\n", + "can run git checkout 8d to check out this version of the applica‐\n", + "tion.\n", + "Account Confirmation\n", + "For certain types of applications, it is important to ensure that the user information\n", + "provided during registration is valid. A common requirement is to ensure that the\n", + "user can be reached through the provided email address.\n", + "To validate the email address, applications send a confirmation email to users imme‐\n", + "diately after they register. The new account is initially marked as unconfirmed until\n", + "the instructions in the email are followed, which proves that the user has received the\n", + "email. The account confirmation procedure usually involves clicking a specially craf‐\n", + "ted URL link that includes a confirmation token.\n", + "Generating Confirmation Tokens with itsdangerous\n", + "The simplest account confirmation link would be a URL with the format http://\n", + "www.example.com/auth/confirm/ included in the confirmation email, where\n", + " is the numeric id assigned to the user in the database. When the user clicks the\n", + "link, the view function that handles this route receives the user id to confirm as an\n", + "argument and can easily update the confirmed status of the user.\n", + "But this is obviously not a secure implementation, as any user who figures out the\n", + "format of the confirmation links will be able to confirm arbitrary accounts just by\n", + "sending random numbers in the URL. The idea is to replace the in the URL\n", + "with a token that contains the same information, but in such a way that only the\n", + "server can generate valid confirmation URLs.\n", + "118 \n", + "| \n", + "Chapter 8: User Authentication\n", + "\n", + "If you recall the discussion on user sessions in Chapter 4, Flask uses cryptographically\n", + "signed cookies to protect the content of user sessions against tampering. The user ses‐\n", + "sion cookies contain a cryptographic signature generated by a package called\n", + "itsdangerous. If the contents of the user session is altered, the signature will not\n", + "match the content anymore, so Flask discards the session and starts a new one. The\n", + "same concept can be applied to confirmation tokens.\n", + "The following is a short shell session that shows how itsdangerous can generate a\n", + "signed token that contains a user id inside:\n", + "(venv) $ flask shell\n", + ">>> from itsdangerous import TimedJSONWebSignatureSerializer as Serializer\n", + ">>> s = Serializer(app.config['SECRET_KEY'], expires_in=3600)\n", + ">>> token = s.dumps({ 'confirm': 23 })\n", + ">>> token\n", + "'eyJhbGciOiJIUzI1NiIsImV4cCI6MTM4MTcxODU1OCwiaWF0IjoxMzgxNzE0OTU4fQ.ey ...'\n", + ">>> data = s.loads(token)\n", + ">>> data\n", + "{'confirm': 23}\n", + "The itsdangerous package provides several types of token generators. Among them,\n", + "the class TimedJSONWebSignatureSerializer generates JSON Web Signatures (JWSs)\n", + "with a time expiration. The constructor of this class takes an encryption key as an\n", + "argument, which in a Flask application can be the configured SECRET_KEY.\n", + "The dumps() method generates a cryptographic signature for the data given as an\n", + "argument and then serializes the data plus the signature as a convenient token string.\n", + "The expires_in argument sets an expiration time for the token, expressed in sec‐\n", + "onds.\n", + "To decode the token, the serializer object provides a loads() method that takes the\n", + "token as its only argument. The function verifies the signature and the expiration\n", + "time and, if both are valid, it returns the original data. When the loads() method is\n", + "given an invalid token or a valid token that is expired, an exception is raised.\n", + "Token generation and verification using this functionality can be added to the User\n", + "model. The changes are shown in Example 8-18.\n", + "Example 8-18. app/models.py: user account confirmation\n", + "from itsdangerous import TimedJSONWebSignatureSerializer as Serializer\n", + "from flask import current_app\n", + "from . import db\n", + "class User(UserMixin, db.Model):\n", + " # ...\n", + " confirmed = db.Column(db.Boolean, default=False)\n", + "Account Confirmation \n", + "| \n", + "119\n", + "\n", + " def generate_confirmation_token(self, expiration=3600):\n", + " s = Serializer(current_app.config['SECRET_KEY'], expiration)\n", + " return s.dumps({'confirm': self.id}).decode('utf-8')\n", + " def confirm(self, token):\n", + " s = Serializer(current_app.config['SECRET_KEY'])\n", + " try:\n", + " data = s.loads(token.encode('utf-8'))\n", + " except:\n", + " return False\n", + " if data.get('confirm') != self.id:\n", + " return False\n", + " self.confirmed = True\n", + " db.session.add(self)\n", + " return True\n", + "The generate_confirmation_token() method generates a token with a default val‐\n", + "idity time of one hour. The confirm() method verifies the token and, if valid, sets the\n", + "new confirmed attribute in the user model to True.\n", + "In addition to verifying the token, the confirm() function checks that the id from\n", + "the token matches the logged-in user, which is stored in current_user. This ensures\n", + "that a confirmation token for a given user cannot be used to confirm a different user.\n", + "Because a new column was added to the model to track the con‐\n", + "firmed state of each account, a new database migration needs to be\n", + "generated and applied.\n", + "The two new methods added to the User model are easily tested in unit tests. You can\n", + "find the unit tests in the GitHub repository for the application.\n", + "Sending Confirmation Emails\n", + "The current /register route redirects to /index after adding the new user to the data‐\n", + "base. Before redirecting, this route now needs to send the confirmation email. This\n", + "change is shown in Example 8-19.\n", + "Example 8-19. app/auth/views.py: registration route with confirmation email\n", + "from ..email import send_email\n", + "@auth.route('/register', methods=['GET', 'POST'])\n", + "def register():\n", + " form = RegistrationForm()\n", + " if form.validate_on_submit():\n", + " # ...\n", + "120 \n", + "| \n", + "Chapter 8: User Authentication\n", + "\n", + " db.session.add(user)\n", + " db.session.commit()\n", + " token = user.generate_confirmation_token()\n", + " send_email(user.email, 'Confirm Your Account',\n", + " 'auth/email/confirm', user=user, token=token)\n", + " flash('A confirmation email has been sent to you by email.')\n", + " return redirect(url_for('main.index'))\n", + " return render_template('auth/register.html', form=form)\n", + "Note that a db.session.commit() call had to be added before the confirmation email\n", + "is sent out. The problem is that new users get assigned an id when they are commit‐\n", + "ted to the database, and this id is needed to generate the confirmation token.\n", + "The email templates used by the authentication blueprint will be added in the tem‐\n", + "plates/auth/email directory to keep them separate from the HTML templates. As dis‐\n", + "cussed in Chapter 6, for each email two templates are needed for the plain-text and\n", + "HTML versions of the body. As an example, Example 8-20 shows the plain-text ver‐\n", + "sion of the confirmation email template, and you can find the equivalent HTML ver‐\n", + "sion in the GitHub repository.\n", + "Example 8-20. app/templates/auth/email/confirm.txt: text body of confirmation email\n", + "Dear {{ user.username }},\n", + "Welcome to Flasky!\n", + "To confirm your account please click on the following link:\n", + "{{ url_for('auth.confirm', token=token, _external=True) }}\n", + "Sincerely,\n", + "The Flasky Team\n", + "Note: replies to this email address are not monitored.\n", + "By \n", + "default, \n", + "url_for() \n", + "generates \n", + "relative \n", + "URLs; \n", + "so, \n", + "for \n", + "example,\n", + "url_for('auth.confirm', token='abc') returns the string '/auth/confirm/abc'.\n", + "This, of course, is not a valid URL that can be sent in an email, since it is only the\n", + "path portion of the URL. Relative URLs work fine when they are used within the con‐\n", + "text of a web page because the browser converts them to absolute URLs by adding the\n", + "hostname and port number from the current page, but when sending a URL over\n", + "email there is no such context. The _external=True argument is added to the\n", + "url_for() call to request a fully qualified URL that includes the scheme (http:// or\n", + "https://), hostname, and port.\n", + "The view function that confirms accounts is shown in Example 8-21.\n", + "Account Confirmation \n", + "| \n", + "121\n", + "\n", + "Example 8-21. app/auth/views.py: confirming a user account\n", + "from flask_login import current_user\n", + "@auth.route('/confirm/')\n", + "@login_required\n", + "def confirm(token):\n", + " if current_user.confirmed:\n", + " return redirect(url_for('main.index'))\n", + " if current_user.confirm(token):\n", + " db.session.commit()\n", + " flash('You have confirmed your account. Thanks!')\n", + " else:\n", + " flash('The confirmation link is invalid or has expired.')\n", + " return redirect(url_for('main.index'))\n", + "This route is protected with the login_required decorator from Flask-Login, so that\n", + "when the users click on the link from the confirmation email they are asked to log in\n", + "before they reach this view function.\n", + "The function first checks if the logged-in user is already confirmed, and in that case it\n", + "redirects to the home page, as obviously there is nothing to do. This can prevent\n", + "unnecessary work if a user clicks the confirmation token multiple times by mistake.\n", + "Because the actual token confirmation is done entirely in the User model, all the view\n", + "function needs to do is call the confirm() method and then flash a message accord‐\n", + "ing to the result. When the confirmation succeeds, the User model’s confirmed\n", + "attribute is changed and added to the session and then the database session is com‐\n", + "mitted.\n", + "Each application can decide what unconfirmed users are allowed to do before they\n", + "confirm their accounts. One possibility is to allow unconfirmed users to log in, but\n", + "only show them a page that asks them to confirm their accounts before they can gain\n", + "further access.\n", + "This step can be done using Flask’s before_request hook, which was briefly\n", + "described in Chapter 2. From a blueprint, the before_request hook applies only to\n", + "requests that belong to the blueprint. To install a blueprint hook for all application\n", + "requests, the before_app_request decorator must be used instead. Example 8-22\n", + "shows how this handler is implemented.\n", + "122 \n", + "| \n", + "Chapter 8: User Authentication\n", + "\n", + "Example 8-22. app/auth/views.py: filtering unconfirmed accounts with the\n", + "before_app_request handler\n", + "@auth.before_app_request\n", + "def before_request():\n", + " if current_user.is_authenticated \\\n", + " and not current_user.confirmed \\\n", + " and request.blueprint != 'auth' \\\n", + " and request.endpoint != 'static':\n", + " return redirect(url_for('auth.unconfirmed'))\n", + "@auth.route('/unconfirmed')\n", + "def unconfirmed():\n", + " if current_user.is_anonymous or current_user.confirmed:\n", + " return redirect(url_for('main.index'))\n", + " return render_template('auth/unconfirmed.html')\n", + "The before_app_request handler will intercept a request when three conditions are\n", + "true:\n", + "1. A user is logged in (current_user.is_authenticated is True).\n", + "2. The account for the user is not confirmed.\n", + "3. The requested URL is outside of the authentication blueprint and is not for a\n", + "static file. Access to the authentication routes needs to be granted, as those are the\n", + "routes that will enable the user to confirm the account or perform other account\n", + "management functions.\n", + "If these three conditions are met, then a redirect is issued to a new /auth/unconfirmed\n", + "route that shows a page with information about account confirmation.\n", + "When a before_request or before_app_request callback returns\n", + "a response or a redirect, Flask sends that to the client without\n", + "invoking the view function associated with the request. This effec‐\n", + "tively allows these callbacks to intercept a request when necessary.\n", + "The page that is presented to unconfirmed users (shown in Figure 8-4) just renders a\n", + "template that gives users instructions for how to confirm their accounts and offers a\n", + "link to request a new confirmation email, in case the original email was lost. The\n", + "route that resends the confirmation email is shown in Example 8-23.\n", + "Account Confirmation \n", + "| \n", + "123\n", + "\n", + "Figure 8-4. Unconfirmed account page\n", + "Example 8-23. app/auth/views.py: resending the account confirmation email\n", + "@auth.route('/confirm')\n", + "@login_required\n", + "def resend_confirmation():\n", + " token = current_user.generate_confirmation_token()\n", + " send_email(current_user.email, 'Confirm Your Account',\n", + " 'auth/email/confirm', user=current_user, token=token)\n", + " flash('A new confirmation email has been sent to you by email.')\n", + " return redirect(url_for('main.index'))\n", + "This route repeats what was done in the registration route using current_user, the\n", + "user who is logged in, as the target user. This route is also protected with\n", + "login_required to ensure that when it is accessed, the user that is making the\n", + "request is authenticated.\n", + "If you have cloned the application’s Git repository on GitHub, you\n", + "can run git checkout 8e to check out this version of the applica‐\n", + "tion. This update contains a database migration, so remember to\n", + "run flask db upgrade after you check out the code.\n", + "124 \n", + "| \n", + "Chapter 8: User Authentication\n", + "\n", + "Account Management\n", + "Users who have accounts with the application may need to make changes to their\n", + "accounts from time to time. The following tasks can be added to the authentication\n", + "blueprint using the techniques presented in this chapter:\n", + "Password updates\n", + "Security-conscious users may want to change their passwords periodically. This is\n", + "an easy feature to implement, because as long as the user is logged in, it is safe to\n", + "present a form that asks for the old password and a new password to replace it.\n", + "This feature is implemented as commit 8f in the GitHub repository. As part of\n", + "this change, the “Log Out” link in the navigation bar was refactored into a drop‐\n", + "down that contains the “Change Password” and “Log Out” links.\n", + "Password resets\n", + "To avoid locking users out of the application when they forget their passwords, a\n", + "password reset option can be offered. To implement password resets in a secure\n", + "way, it is necessary to use tokens similar to those used to confirm accounts.\n", + "When a user requests a password reset, an email with a reset token is sent to the\n", + "registered email address. The user then clicks the link in the email and, after the\n", + "token is verified, a form is presented where a new password can be entered. This\n", + "feature is implemented as commit 8g in the GitHub repository.\n", + "Email address changes\n", + "Users can be given the option to change their registered email address, but before\n", + "the new address is accepted it must be verified with a confirmation email. To use\n", + "this feature, the user enters the new email address in a form. To confirm the\n", + "email address, a token is emailed to that address. When the server receives the\n", + "token back, it can update the user object. While the server waits to receive the\n", + "token, it can store the new email address in a new database field reserved for\n", + "pending email addresses, or it can store the address in the token along with the\n", + "id. This feature is implemented as commit 8h in the GitHub repository.\n", + "In the next chapter, the user subsystem of Flasky will be extended through the use of\n", + "user roles.\n", + "Account Management \n", + "| \n", + "125\n", + "\n", + "\n", + "CHAPTER 9\n", + "User Roles\n", + "Not all users of web applications are created equal. In most applications, a small per‐\n", + "centage of users are trusted with extra powers to help keep the application running\n", + "smoothly. Administrators are the best example, but in many cases middle-level power\n", + "users such as content moderators exist as well. To implement this, all users are\n", + "assigned a role.\n", + "There are several ways to implement roles in an application. The appropriate method\n", + "largely depends on how many roles need to be supported and how elaborate they are.\n", + "For example, a simple application may need just two roles, one for regular users and\n", + "one for administrators. In this case, having an is_administrator Boolean field in the\n", + "User model may be all that is necessary. A more complex application may need addi‐\n", + "tional roles with varying levels of power in between regular users and administrators.\n", + "In some applications it may not even make sense to talk about discrete roles, and\n", + "instead giving users a set of individual permissions may be the right approach.\n", + "The user role implementation presented in this chapter is a hybrid between discrete\n", + "roles and permissions. Users are assigned a discrete role, but each role defines what\n", + "actions it allows its users to perform through a list of permissions.\n", + "Database Representation of Roles\n", + "A simple roles table was created in Chapter 5 as a vehicle to demonstrate one-to-\n", + "many relationships. Example 9-1 shows an improved Role model with some addi‐\n", + "tions.\n", + "127\n", + "\n", + "Example 9-1. app/models.py: role database model\n", + "class Role(db.Model):\n", + " __tablename__ = 'roles'\n", + " id = db.Column(db.Integer, primary_key=True)\n", + " name = db.Column(db.String(64), unique=True)\n", + " default = db.Column(db.Boolean, default=False, index=True)\n", + " permissions = db.Column(db.Integer)\n", + " users = db.relationship('User', backref='role', lazy='dynamic')\n", + " def __init__(self, **kwargs):\n", + " super(Role, self).__init__(**kwargs)\n", + " if self.permissions is None:\n", + " self.permissions = 0\n", + "The default field is one of the additions to this model. This field should be set to\n", + "True for only one role and False for all the others. The role marked as default will be\n", + "the one assigned to new users upon registration. Since the application is going to\n", + "search the roles table to find the default one, this column is configured to have an\n", + "index, as that will make searches much faster.\n", + "Another addition to the model is the permissions field, which is an integer value that\n", + "defines the list of permissions for the role in a compact way. Since SQLAlchemy will\n", + "set this field to None by default, a class constructor is added that sets it to 0 if an initial\n", + "value isn’t provided in the constructor arguments.\n", + "The list of tasks for which permissions are needed is obviously application specific.\n", + "For Flasky, the list is shown in Table 9-1.\n", + "Table 9-1. Application permissions\n", + "Task name\n", + "Permission name Permission value\n", + "Follow users\n", + "FOLLOW\n", + "1\n", + "Comment on posts made by others\n", + "COMMENT\n", + "2\n", + "Write articles\n", + "WRITE\n", + "4\n", + "Moderate comments made by others\n", + "MODERATE\n", + "8\n", + "Administration access\n", + "ADMIN\n", + "16\n", + "The benefit of using powers of two for permission values is that it allows permissions\n", + "to be combined, giving each possible combination of permissions a unique value to\n", + "store in the role’s permissions field. For example, for a user role that gives users per‐\n", + "mission to follow other users and comment on posts, the permission value is FOLLOW\n", + "+ COMMENT = 3. This is a very efficient way to store the list of permissions assigned to\n", + "each role.\n", + "128 \n", + "| \n", + "Chapter 9: User Roles\n", + "\n", + "The code representation of Table 9-1 is shown in Example 9-2.\n", + "Example 9-2. app/models.py: permission constants\n", + "class Permission:\n", + " FOLLOW = 1\n", + " COMMENT = 2\n", + " WRITE = 4\n", + " MODERATE = 8\n", + " ADMIN = 16\n", + "With the permission constants in place, a few new methods can be added to the Role\n", + "model to manage permissions. These are shown in Example 9-3.\n", + "Example 9-3. app/models.py: permission management in the Role model\n", + "class Role(db.Model):\n", + " # ...\n", + " def add_permission(self, perm):\n", + " if not self.has_permission(perm):\n", + " self.permissions += perm\n", + " def remove_permission(self, perm):\n", + " if self.has_permission(perm):\n", + " self.permissions -= perm\n", + " def reset_permissions(self):\n", + " self.permissions = 0\n", + " def has_permission(self, perm):\n", + " return self.permissions & perm == perm\n", + "The add_permission(), remove_permission(), and reset_permission() methods\n", + "all use basic arithmetic operations to update the permission list. The\n", + "has_permission() method is the most complex of the set, as it relies on the bitwise\n", + "and operator & to check if a combined permission value includes the given basic per‐\n", + "mission. You can play with these methods in a Python shell:\n", + "(venv) $ flask shell\n", + ">>> r = Role(name='User')\n", + ">>> r.add_permission(Permission.FOLLOW)\n", + ">>> r.add_permission(Permission.WRITE)\n", + ">>> r.has_permission(Permission.FOLLOW)\n", + "True\n", + ">>> r.has_permission(Permission.ADMIN)\n", + "False\n", + ">>> r.reset_permissions()\n", + "Database Representation of Roles \n", + "| \n", + "129\n", + "\n", + ">>> r.has_permission(Permission.FOLLOW)\n", + "False\n", + "Table 9-2 shows the list of user roles that will be supported in this application, along\n", + "with the permission combinations that define each of them.\n", + "Table 9-2. User roles\n", + "User role\n", + "Permissions\n", + "Description\n", + "None\n", + "None\n", + "Read-only access to the application. This applies to unknown users who are not\n", + "logged in.\n", + "User\n", + "FOLLOW, COMMENT,\n", + "WRITE\n", + "Basic permissions to write articles and comments and to follow other users.\n", + "This is the default for new users.\n", + "Moderator\n", + "FOLLOW, COMMENT,\n", + "WRITE, MODERATE\n", + "Adds permission to moderate comments made by other users.\n", + "Administrator\n", + "FOLLOW, COMMENT,\n", + "WRITE, MODERATE,\n", + "ADMIN\n", + "Full access, which includes permission to change the roles of other users.\n", + "Adding the roles to the database manually is time consuming and error prone, so\n", + "instead a class method can be added to the Role class for this purpose, as shown in\n", + "Example 9-4. This will make it easy to re-create the correct roles and permissions\n", + "during unit testing and, more importantly, on the production server once the applica‐\n", + "tion is deployed.\n", + "Example 9-4. app/models.py: creating roles in the database\n", + "class Role(db.Model):\n", + " # ...\n", + " @staticmethod\n", + " def insert_roles():\n", + " roles = {\n", + " 'User': [Permission.FOLLOW, Permission.COMMENT, Permission.WRITE],\n", + " 'Moderator': [Permission.FOLLOW, Permission.COMMENT,\n", + " Permission.WRITE, Permission.MODERATE],\n", + " 'Administrator': [Permission.FOLLOW, Permission.COMMENT,\n", + " Permission.WRITE, Permission.MODERATE,\n", + " Permission.ADMIN],\n", + " }\n", + " default_role = 'User'\n", + " for r in roles:\n", + " role = Role.query.filter_by(name=r).first()\n", + " if role is None:\n", + " role = Role(name=r)\n", + " role.reset_permissions()\n", + " for perm in roles[r]:\n", + " role.add_permission(perm)\n", + " role.default = (role.name == default_role)\n", + "130 \n", + "| \n", + "Chapter 9: User Roles\n", + "\n", + " db.session.add(role)\n", + " db.session.commit()\n", + "The insert_roles() function does not directly create new role objects. Instead, it\n", + "tries to find existing roles by name and update those. A new role object is created\n", + "only for roles that aren’t in the database already. This is done so that the role list can\n", + "be updated in the future when changes need to be made. To add a new role or change\n", + "the permission assignments for a role, change the roles dictionary at the top of the\n", + "function and then run the function again. Note that the \"Anonymous\" role does not\n", + "need to be represented in the database, as it is the role that represents users who are\n", + "not known and therefore are not in the database.\n", + "Note also that insert_roles() is a static method, a special type of method that does\n", + "not require an object to be created as it can be invoked directly on the class, for exam‐\n", + "ple, as Role.insert_roles(). Static methods do not take a self argument like\n", + "instance methods.\n", + "Role Assignment\n", + "When users register an account with the application, the correct role should be\n", + "assigned to them. For most users, the role assigned at registration time will be the\n", + "\"User\" role, as that is the role that is marked as a default. The only exception is made\n", + "for the administrator, who needs to be assigned the \"Administrator\" role from the\n", + "start. This user is identified by an email address stored in the FLASKY_ADMIN configu‐\n", + "ration variable, so as soon as that email address appears in a registration request it\n", + "can be given the correct role. Example 9-5 shows how this is done in the User model\n", + "constructor.\n", + "Example 9-5. app/models.py: defining a default role for users\n", + "class User(UserMixin, db.Model):\n", + " # ...\n", + " def __init__(self, **kwargs):\n", + " super(User, self).__init__(**kwargs)\n", + " if self.role is None:\n", + " if self.email == current_app.config['FLASKY_ADMIN']:\n", + " self.role = Role.query.filter_by(name='Administrator').first()\n", + " if self.role is None:\n", + " self.role = Role.query.filter_by(default=True).first()\n", + " # ...\n", + "The User constructor first invokes the constructors of the base classes, and if after\n", + "that the object does not have a role defined, it sets the administrator or default role\n", + "depending on the email address.\n", + "Role Assignment \n", + "| \n", + "131\n", + "\n", + "Role Verification\n", + "To simplify the implementation of roles and permissions, a helper method can be\n", + "added to the User model that checks whether users have a given permission in the\n", + "role they have been assigned. The implementation simply defers to the role methods\n", + "added previously. This is shown in Example 9-6.\n", + "Example 9-6. app/models.py: evaluating whether a user has a given permission\n", + "from flask_login import UserMixin, AnonymousUserMixin\n", + "class User(UserMixin, db.Model):\n", + " # ...\n", + " def can(self, perm):\n", + " return self.role is not None and self.role.has_permission(perm)\n", + " def is_administrator(self):\n", + " return self.can(Permission.ADMIN)\n", + "class AnonymousUser(AnonymousUserMixin):\n", + " def can(self, permissions):\n", + " return False\n", + " def is_administrator(self):\n", + " return False\n", + "login_manager.anonymous_user = AnonymousUser\n", + "The can() method added to the User model returns True if the requested permission\n", + "is present in the role, which means that the user should be allowed to perform the\n", + "requested task. The check for administration permissions is so common that it is also\n", + "implemented as a standalone is_administrator() method.\n", + "For added convenience, a custom AnonymousUser class that implements the can()\n", + "and is_administrator() methods is created as well. This will enable the application\n", + "to freely call current_user.can() and current_user.is_administrator() without\n", + "having to check whether the user is logged in first. Flask-Login is told to use the\n", + "application’s \n", + "custom \n", + "anonymous \n", + "user \n", + "by \n", + "setting \n", + "its \n", + "class \n", + "in \n", + "the\n", + "login_manager.anonymous_user attribute.\n", + "For cases in which an entire view function needs to be made available only to users\n", + "with certain permissions, a custom decorator can be used. Example 9-7 shows the\n", + "implementation of two decorators, one for generic permission checks and one that\n", + "checks specifically for the administrator permission.\n", + "132 \n", + "| \n", + "Chapter 9: User Roles\n", + "\n", + "Example 9-7. app/decorators.py: custom decorators that check user permissions\n", + "from functools import wraps\n", + "from flask import abort\n", + "from flask_login import current_user\n", + "from .models import Permission\n", + "def permission_required(permission):\n", + " def decorator(f):\n", + " @wraps(f)\n", + " def decorated_function(*args, **kwargs):\n", + " if not current_user.can(permission):\n", + " abort(403)\n", + " return f(*args, **kwargs)\n", + " return decorated_function\n", + " return decorator\n", + "def admin_required(f):\n", + " return permission_required(Permission.ADMIN)(f)\n", + "These decorators are built with the help of the functools package from the Python\n", + "standard library and return a 403 response, the “Forbidden” HTTP status code, when\n", + "the current user does not have the requested permission. In Chapter 3, custom error\n", + "pages were created for errors 404 and 500, so now a page for the 403 error is added in\n", + "a similar way.\n", + "The following are two examples that demonstrate the usage of these decorators:\n", + "from .decorators import admin_required, permission_required\n", + "@main.route('/admin')\n", + "@login_required\n", + "@admin_required\n", + "def for_admins_only():\n", + " return \"For administrators!\"\n", + "@main.route('/moderate')\n", + "@login_required\n", + "@permission_required(Permission.MODERATE)\n", + "def for_moderators_only():\n", + " return \"For comment moderators!\"\n", + "As a rule of thumb, the route decorator from Flask should be given first when using\n", + "multiple decorators in a view function. The remaining decorators should be given in\n", + "the order in which they need to evaluate when the view function is invoked. In these\n", + "two cases, the user authenticated state needs to be checked first, since the user needs\n", + "to be redirected to the login prompt if found to not be authenticated.\n", + "Permissions may also need to be checked from templates, so the Permission class\n", + "with all its constants needs to be accessible to them. To avoid having to add a tem‐\n", + "Role Verification \n", + "| \n", + "133\n", + "\n", + "plate argument in every render_template() call, a context processor can be used.\n", + "Context processors make variables available to all templates during rendering. This\n", + "change is shown in Example 9-8.\n", + "Example 9-8. app/main/__init__.py: adding the Permission class to the template context\n", + "@main.app_context_processor\n", + "def inject_permissions():\n", + " return dict(Permission=Permission)\n", + "The new roles and permissions can be exercised in unit tests. Example 9-9 shows two\n", + "of the tests. The source code on GitHub includes one for each role.\n", + "Example 9-9. tests/test_user_model.py: unit tests for roles and permissions\n", + "class UserModelTestCase(unittest.TestCase):\n", + " # ...\n", + " def test_user_role(self):\n", + " u = User(email='john@example.com', password='cat')\n", + " self.assertTrue(u.can(Permission.FOLLOW))\n", + " self.assertTrue(u.can(Permission.COMMENT))\n", + " self.assertTrue(u.can(Permission.WRITE))\n", + " self.assertFalse(u.can(Permission.MODERATE))\n", + " self.assertFalse(u.can(Permission.ADMIN))\n", + " def test_anonymous_user(self):\n", + " u = AnonymousUser()\n", + " self.assertFalse(u.can(Permission.FOLLOW))\n", + " self.assertFalse(u.can(Permission.COMMENT))\n", + " self.assertFalse(u.can(Permission.WRITE))\n", + " self.assertFalse(u.can(Permission.MODERATE))\n", + " self.assertFalse(u.can(Permission.ADMIN))\n", + "If you have cloned the application’s Git repository on GitHub, you\n", + "can run git checkout 9a to check out this version of the applica‐\n", + "tion. This update contains a database migration, so remember to\n", + "run flask db upgrade after you check out the code.\n", + "Before you move on to the next chapter, add the new roles to your development data‐\n", + "base in a shell session:\n", + "(venv) $ flask shell\n", + ">>> Role.insert_roles()\n", + ">>> Role.query.all()\n", + "[, , ]\n", + "134 \n", + "| \n", + "Chapter 9: User Roles\n", + "\n", + "It is also a good idea to update the user list so that all the user accounts that were\n", + "created before roles and permissions existed have a role assigned. You can run the fol‐\n", + "lowing code in a Python shell to perform this update:\n", + "(venv) $ flask shell\n", + ">>> admin_role = Role.query.filter_by(name='Administrator').first()\n", + ">>> default_role = Role.query.filter_by(default=True).first()\n", + ">>> for u in User.query.all():\n", + "... if u.role is None:\n", + "... if u.email == app.config['FLASKY_ADMIN']:\n", + "... u.role = admin_role\n", + "... else:\n", + "... u.role = default_role\n", + "...\n", + ">>> db.session.commit()\n", + "The user system is now fairly complete. The next chapter will make use of it to create\n", + "user profile pages.\n", + "Role Verification \n", + "| \n", + "135\n", + "\n", + "\n", + "CHAPTER 10\n", + "User Profiles\n", + "In this chapter, user profiles for Flasky are implemented. All socially aware sites give\n", + "their users a profile page, where a summary of the user’s participation in the website\n", + "is presented. Users can advertise their presence on the website by sharing the URL to\n", + "their profile page, so it is important that the URLs be short and easy to remember.\n", + "Profile Information\n", + "To make user profile pages more interesting, some additional information about\n", + "users can be stored in the database. In Example 10-1 the User model is extended with\n", + "several new fields.\n", + "Example 10-1. app/models.py: user information fields\n", + "class User(UserMixin, db.Model):\n", + " # ...\n", + " name = db.Column(db.String(64))\n", + " location = db.Column(db.String(64))\n", + " about_me = db.Column(db.Text())\n", + " member_since = db.Column(db.DateTime(), default=datetime.utcnow)\n", + " last_seen = db.Column(db.DateTime(), default=datetime.utcnow)\n", + "The new fields store the user’s real name, location, self-written bio, date of registra‐\n", + "tion, and date of last visit. The about_me field is assigned the type db.Text(). The\n", + "difference between db.String and db.Text is that db.Text is a variable-length field\n", + "and as such does not need a maximum length.\n", + "The two timestamps are given a default value of the current time. Note that the\n", + "datetime.utcnow is missing the () at the end. This is because the default argument\n", + "in db.Column() can take a function as a value. Each time a default value needs to be\n", + "137\n", + "\n", + "generated, SQLAlchemy invokes the function to produce it. This default value is all\n", + "that is needed to manage the member_since field.\n", + "The last_seen field is also initialized to the current time upon creation, but it needs\n", + "to be refreshed each time the user accesses the site. A method in the User class can be\n", + "added to perform this update. This is shown in Example 10-2.\n", + "Example 10-2. app/models.py: refreshing a user’s last visit time\n", + "class User(UserMixin, db.Model):\n", + " # ...\n", + " def ping(self):\n", + " self.last_seen = datetime.utcnow()\n", + " db.session.add(self)\n", + " db.session.commit()\n", + "To keep the last visit date for all users updated, the ping() method must be called\n", + "each time a request from a user is received. Because the before_app_request handler \n", + "in the auth blueprint runs before every request, it can do this easily, as shown in\n", + "Example 10-3.\n", + "Example 10-3. app/auth/views.py: pinging the logged-in user\n", + "@auth.before_app_request\n", + "def before_request():\n", + " if current_user.is_authenticated:\n", + " current_user.ping()\n", + " if not current_user.confirmed \\\n", + " and request.endpoint \\\n", + " and request.blueprint != 'auth' \\\n", + " and request.endpoint != 'static':\n", + " return redirect(url_for('auth.unconfirmed'))\n", + "User Profile Page\n", + "Creating a profile page for each user does not present any new challenges.\n", + "Example 10-4 shows the route definition.\n", + "Example 10-4. app/main/views.py: profile page route\n", + "@main.route('/user/')\n", + "def user(username):\n", + " user = User.query.filter_by(username=username).first_or_404()\n", + " return render_template('user.html', user=user)\n", + "138 \n", + "| \n", + "Chapter 10: User Profiles\n", + "\n", + "This route is added in the main blueprint. For a user named john, the profile page will\n", + "be at http://localhost:5000/user/john. The username given in the URL is searched in\n", + "the database and, if found, the user.html template is rendered with it as the argument.\n", + "An invalid username sent into this route will cause a 404 error to be returned. With\n", + "Flask-SQLAlchemy, the search and error cases can be nicely combined in a single\n", + "statement using the first_or_404() method of the query object. The user.html tem‐\n", + "plate is going to need to present user information, so it receives the user object as an\n", + "argument. An initial version of this template is shown in Example 10-5.\n", + "Example 10-5. app/templates/user.html: user profile template\n", + "{% extends \"base.html\" %}\n", + "{% block title %}Flasky - {{ user.username }}{% endblock %}\n", + "{% block page_content %}\n", + "
\n", + "

{{ user.username }}

\n", + " {% if user.name or user.location %}\n", + "

\n", + " {% if user.name %}{{ user.name }}{% endif %}\n", + " {% if user.location %}\n", + " From \n", + " {{ user.location }}\n", + " \n", + " {% endif %}\n", + "

\n", + " {% endif %}\n", + " {% if current_user.is_administrator() %}\n", + "

{{ user.email }}

\n", + " {% endif %}\n", + " {% if user.about_me %}

{{ user.about_me }}

{% endif %}\n", + "

\n", + " Member since {{ moment(user.member_since).format('L') }}.\n", + " Last seen {{ moment(user.last_seen).fromNow() }}.\n", + "

\n", + "
\n", + "{% endblock %}\n", + "This template has a few interesting implementation details:\n", + "• The name and location fields are rendered inside a single

element. A Jinja2\n", + "conditional ensures that the

element is created only when at least one of the\n", + "fields is defined.\n", + "• The user location field is rendered as a link to a Google Maps query, so that\n", + "clicking on it opens a map centered on the location.\n", + "User Profile Page \n", + "| \n", + "139\n", + "\n", + "• If the logged-in user is an administrator, then the email address of the user is\n", + "shown, rendered as a mailto link. This is useful when an administrator is viewing\n", + "the profile page of another user and needs to contact the user.\n", + "• The two timestamps for the user are rendered to the page using Flask-Moment,\n", + "as shown in Chapter 3.\n", + "As most users will want easy access to their own profile page, a link to it can be added\n", + "to the navigation bar. The relevant changes to the base.html template are shown in\n", + "Example 10-6.\n", + "Example 10-6. app/templates/base.html: add link to profile page in the navigation bar\n", + "{% if current_user.is_authenticated %}\n", + "

  • \n", + " \n", + " Profile\n", + " \n", + "
    • \n", + "{% endif %}\n", + "Using a conditional for the profile page link is necessary because the navigation bar is\n", + "also rendered for unauthenticated users, in which case the profile link is skipped.\n", + "Figure 10-1 shows how the profile page looks in the browser. The new profile link in\n", + "the navigation bar is also shown.\n", + "Figure 10-1. User profile page\n", + "140 \n", + "| \n", + "Chapter 10: User Profiles\n", + "\n", + "If you have cloned the application’s Git repository on GitHub, you\n", + "can run git checkout 10a to check out this version of the applica‐\n", + "tion. This update contains a database migration, so remember to\n", + "run flask db upgrade after you check out the code.\n", + "Profile Editor\n", + "There are two different use cases related to editing of user profiles. The most obvious\n", + "is that users need to have access to a page where they can enter information about\n", + "themselves to present in their profile pages. A less obvious but also important\n", + "requirement is to let administrators edit the profiles of other users—not only their\n", + "personal information items but also other fields in the User model to which users\n", + "have no direct access, such as the user role. Because the two profile editing require‐\n", + "ments are substantially different, two different forms will be created.\n", + "User-Level Profile Editor\n", + "The profile editing form for regular users is shown in Example 10-7.\n", + "Example 10-7. app/main/forms.py: edit profile form\n", + "class EditProfileForm(FlaskForm):\n", + " name = StringField('Real name', validators=[Length(0, 64)])\n", + " location = StringField('Location', validators=[Length(0, 64)])\n", + " about_me = TextAreaField('About me')\n", + " submit = SubmitField('Submit')\n", + "Note that as all the fields in this form are optional, the length validator allows a length\n", + "of zero as a minimum. The route definition that uses this form is shown in\n", + "Example 10-8.\n", + "Example 10-8. app/main/views.py: edit profile route\n", + "@main.route('/edit-profile', methods=['GET', 'POST'])\n", + "@login_required\n", + "def edit_profile():\n", + " form = EditProfileForm()\n", + " if form.validate_on_submit():\n", + " current_user.name = form.name.data\n", + " current_user.location = form.location.data\n", + " current_user.about_me = form.about_me.data\n", + " db.session.add(current_user._get_current_object())\n", + " db.session.commit()\n", + " flash('Your profile has been updated.')\n", + " return redirect(url_for('.user', username=current_user.username))\n", + " form.name.data = current_user.name\n", + "Profile Editor \n", + "| \n", + "141\n", + "\n", + " form.location.data = current_user.location\n", + " form.about_me.data = current_user.about_me\n", + " return render_template('edit_profile.html', form=form)\n", + "As in previous forms, the data associated with each form field is available at\n", + "form..data. This is useful not only to obtain values submitted by the\n", + "user, but also to provide initial values that are shown to the user for editing. When\n", + "form.validate_on_submit() is False, the three fields in this form are initialized\n", + "from the corresponding fields in current_user. Then, when the form is submitted,\n", + "the data attributes of the form fields contain the updated values, so these are moved\n", + "back into the fields of the user object before the object is saved back to the database.\n", + "Figure 10-2 shows the profile editing page.\n", + "Figure 10-2. Profile editor\n", + "To make it easy for users to reach this page, a direct link can be added in the profile\n", + "page, as shown in Example 10-9.\n", + "142 \n", + "| \n", + "Chapter 10: User Profiles\n", + "\n", + "Example 10-9. app/templates/user.html: edit profile link\n", + "{% if user == current_user %}\n", + "\n", + " Edit Profile\n", + "\n", + "{% endif %}\n", + "The conditional that encloses the link will make the link appear only when users are\n", + "viewing their own profiles.\n", + "Administrator-Level Profile Editor\n", + "The profile editing form for administrators is more complex than the one for regular\n", + "users. In addition to the three profile information fields, this form allows administra‐\n", + "tors to edit a user’s email, username, confirmed status, and role. The form is shown in\n", + "Example 10-10.\n", + "Example 10-10. app/main/forms.py: profile editing form for administrators\n", + "class EditProfileAdminForm(FlaskForm):\n", + " email = StringField('Email', validators=[DataRequired(), Length(1, 64),\n", + " Email()])\n", + " username = StringField('Username', validators=[\n", + " DataRequired(), Length(1, 64),\n", + " Regexp('^[A-Za-z][A-Za-z0-9_.]*$', 0,\n", + " 'Usernames must have only letters, numbers, dots or '\n", + " 'underscores')])\n", + " confirmed = BooleanField('Confirmed')\n", + " role = SelectField('Role', coerce=int)\n", + " name = StringField('Real name', validators=[Length(0, 64)])\n", + " location = StringField('Location', validators=[Length(0, 64)])\n", + " about_me = TextAreaField('About me')\n", + " submit = SubmitField('Submit')\n", + " def __init__(self, user, *args, **kwargs):\n", + " super(EditProfileAdminForm, self).__init__(*args, **kwargs)\n", + " self.role.choices = [(role.id, role.name)\n", + " for role in Role.query.order_by(Role.name).all()]\n", + " self.user = user\n", + " def validate_email(self, field):\n", + " if field.data != self.user.email and \\\n", + " User.query.filter_by(email=field.data).first():\n", + " raise ValidationError('Email already registered.')\n", + " def validate_username(self, field):\n", + " if field.data != self.user.username and \\\n", + "Profile Editor \n", + "| \n", + "143\n", + "\n", + " User.query.filter_by(username=field.data).first():\n", + " raise ValidationError('Username already in use.')\n", + "The SelectField is WTForm’s wrapper for the