15 - Web programming/16 - Web programming.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Уеб програмиране. Flask"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Съдържание:\n",
    "- Какво е Flask ?\n",
    "- Просто приложение\n",
    "- Шаблони\n",
    "- Routing\n",
    "- Работа с ресурси\n",
    "- Работа със заявки\n",
    "- JSON API"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Накратко за Web:\n",
    "[Полезна статия за Web](https://www.tutorialspoint.com/http/http_quick_guide.htm#:~:text=HTTP%20is%20a%20generic%20and,on%20the%20World%20Wide%20Web)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Какво е Flask ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Flask е библиотека за Python, която ни позволява да създаваме уеб приложения. Тя е написана на Python и е свободен софтуер, който може да се използва безплатно.\n",
    "\n",
    "Можем да си я инсталираме чрез `pip install flask`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Просто приложение"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Първото нещо, което трябва да направим е да заредим Flask модула. Това става с `from flask import Flask`. След това трябва да създадем обект от тип `Flask`. Това става с `app = Flask(__name__)`. Като първи аргумент на конструктора на `Flask` подаваме името на модула, в който се намираме. Това е необходимо, за да Flask знае къде да търси файловете, които са свързани с приложението. \n",
    "След това трябва да дефинираме функции, които ще се изпълняват, при поискване на даден път. За целта използваме декоратора `@app.route`. Това е декоратор, който се използва за да се определи къде да се изпълни функцията. Нека дефинираме функция, която да връща текста `Hello world`, обвит като `<p>` таг. Това става с `return \"<p>Hello world</p>\"`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from flask import Flask\n",
    "\n",
    "app = Flask(__name__)\n",
    "\n",
    "@app.route(\"/\")\n",
    "def hello_world():\n",
    "    return \"<p>Hello, World!</p>\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "За да стартираме нашето уеб приложение, трябва да изпълним следната команда: `python3 -m flask --app simple_app run`. Това ще стартира нашето приложение на адрес `http://127.0.0.1:5000`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!python -m flask --app examples/simple_app run"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Друг начин да стартираме нашето приложение е като добавим `app.run()` в main частта от кода ни."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Шаблони"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Flask поддържа и т.нар. HTML шаблони - това са HTML страници, които могат да получават данни от нашия Python код. Flask търси тези template-и в специална папка на име `templates`. \n",
    "\n",
    "Шаблоните във Flask са реализирани с помощта на [Jinja](https://jinja.palletsprojects.com/en/3.1.x/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ще създадем един базов шаблон, който ще съдържа общата част на всяка наша страница:\n",
    "```html\n",
    "<!DOCTYPE html>\n",
    "<html lang=\"en\">\n",
    "<head>\n",
    "    <meta charset=\"UTF-8\">\n",
    "    <title>{{ title }}</title>\n",
    "    <link rel=\"stylesheet\" href=\"https://www.w3schools.com/w3css/4/w3.css\">\n",
    "\n",
    "    {% block styles %}\n",
    "    {% endblock %}\n",
    "\n",
    "    {% block scripts %}\n",
    "    {% endblock %}\n",
    "</head>\n",
    "<body>\n",
    "    <div id=\"main-content\">\n",
    "        {% block content %}\n",
    "        {% endblock %}\n",
    "    </div>\n",
    "</body>\n",
    "</html>\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Забелязваме някои нестандартни за HTML елементи - всичко, което е оградено от `{}` скоби е израз, който ще бъде изчислен от Python кода. Това са `{{ title }}` и `{% block content %}{% endblock %}`. Първият израз ще бъде заменен със стойността на променливата `title`, а вторият израз ще бъде заменен със съдържанието на блока `content`.\n",
    "\n",
    "Нека разширим нашия базов шаблон, като направим началната ни страница - тя ще е с името `index.html`\n",
    "\n",
    "```html\n",
    "{% extends \"base.html\" %}\n",
    "\n",
    "{% block content %}\n",
    "    <h1>This is the home page</h1> \n",
    "    <h2>Hi, {{user}}</h2>\n",
    "{% endblock %}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Остава единствено да кажем на Flask да зареди нашия шаблон - това става с помощта на метода `render_template\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from flask import Flask, render_template\n",
    "\n",
    "app = Flask(__name__)\n",
    "\n",
    "@app.route(\"/\")\n",
    "def home():\n",
    "    return render_template('index.html', title='Home', user='Lyubo')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Освен името на шаблона, към `render_template` можем да подадем и стойности, с които да бъдат заместени изразите в шаблона."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "^C\n"
     ]
    }
   ],
   "source": [
    "!python -m flask --app examples/simple_templates run"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Routing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Дотук работехме само с една страница - как може да добавим допълнителни страници ?\n",
    "\n",
    "Можем да използваме `@app.route` декоратора, но с друг път, за да можем да създадем други страници. Нека направим примитивна логин страница.\n",
    "\n",
    "Нека създадем нов template, който да бъде използван за логин страница.\n",
    "\n",
    "```html\n",
    "{% extends \"base.html\" %}\n",
    "\n",
    "{% block content %}\n",
    "    <h1>This is the login page</h1>\n",
    "    <form action=\"/login_action\" method=\"POST\">\n",
    "        <input type=\"text\" name=\"username\" placeholder=\"Username\">\n",
    "        <input type=\"password\" name=\"password\" placeholder=\"Password\">\n",
    "        <input type=\"submit\" value=\"Login\">\n",
    "    </form>\n",
    "\n",
    "    {% if message %}\n",
    "        <h2>{{ message }}</h2>\n",
    "    {% endif %}\n",
    "{% endblock %}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from flask import Flask, render_template\n",
    "\n",
    "app = Flask(__name__)\n",
    "\n",
    "@app.route(\"/\")\n",
    "def home():\n",
    "    return render_template('index.html', title='Home', user='Lyubo')\n",
    "\n",
    "@app.route(\"/login\")\n",
    "def login():\n",
    "    return render_template('login.html', title='Login')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!python3 -m flask --app examples/simple_login run"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Друга особеност на Flask е възможността за работа с динамични адреси - адреси, които се състоят от части, които се дефинират по време на изпълнение. Нека направим такъв адрес за потребителската страница."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from flask import Flask, render_template\n",
    "\n",
    "app = Flask(__name__)\n",
    "\n",
    "\n",
    "@app.route(\"/\")\n",
    "def home():\n",
    "    return render_template('index.html', title='Home', user='Lyubo')\n",
    "\n",
    "\n",
    "@app.route(\"/login\")\n",
    "def login():\n",
    "    return render_template('login.html', title='Login')\n",
    "\n",
    "\n",
    "@app.route(\"/user/<username>\")\n",
    "def user_page(username):\n",
    "    return render_template('index.html', title='User', user=username)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Каквото бъде подадено като адрес след `/user/` ще бъде записано в променливата `username`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!python3 -m flask --app examples/simple_user_page run"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Бележка: За работа с по-сложни логин страници, може да погледнете [тук](https://flask-login.readthedocs.io/en/latest/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Работа с ресурси"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Почти винаги ще ни се наложи да работим с някакви статични ресурси в нашето уеб приложение - било то CSS файлове, JS файлове или изображения. За да можем да достъпваме тези ресурси, ще трябва да ги копираме в папка на нашето приложение. \n",
    "Нека създадем файла `style.css` в папката `static`.\n",
    "\n",
    "```css\n",
    "#main-content {\n",
    "    width: 100%;\n",
    "    height: 100%;\n",
    "    background-color: #333333;\n",
    "    padding: 10px;\n",
    "    border: 1px solid #ccc;\n",
    "    border-radius: 5px;\n",
    "    box-shadow: 0 0 10px #ccc;\n",
    "}\n",
    "\n",
    "h1 {\n",
    "    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;\n",
    "    color: white;\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "За да достъпим такъв статичен ресурс през нашия HTML код, можем да използваме `{{ url_for('static', filename='img/logo.png') }}`. Това ще ни върне пътя до файла `logo.png` в папката `img` в папката `static`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!python3 -m flask --app examples/fancy_page run"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Работа със заявки"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Във Flask можем да зададем метода на достъп до страницата, който да бъде използван. По подразбиране, методът е `GET`, но можем да го променим с `@app.route('/login', methods=['POST'])`.\n",
    "\n",
    "Нека създадем една нова страница, която да бъде достъпна само с POST заявка. Тя ще има за цел да обработва данните, които са подадени от логин формата."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Цялата информация около подадената заявка се намира в специалния `request` обект. Чрез него можем да проверим метода, с който е поискана страницата. В случай, че това не е `POST` метод, можем да върнем грешка.\n",
    "\n",
    "Освен това, можем да достъпим данни подадени през нашата логин форма - данните от нея се намират в `request.form`.\n",
    "\n",
    "Ако се въвели правилната парола за администраторския профил, ще бъдем пренасочени към страницата `/user/admin`. \n",
    "Ако пък имаме грешна парола или потребителско име, ще покажем подходящо съобщение.\n",
    "\n",
    "```python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from flask import Flask, render_template, request, redirect, url_for\n",
    "\n",
    "app = Flask(__name__)\n",
    "\n",
    "@app.route(\"/\")\n",
    "def home():\n",
    "    return render_template('index.html', title='Home', user='Guest')\n",
    "\n",
    "\n",
    "@app.route(\"/login_action\", methods=['POST'])\n",
    "def login_action():\n",
    "    if request.method != 'POST':\n",
    "        return redirect(url_for('/login', message='Invalid method'))\n",
    "\n",
    "    if request.form['username'] == 'admin' and request.form['password'] == 'admin':\n",
    "        username = request.form['username']\n",
    "        return redirect(url_for('user_page', name=username))\n",
    "    else:\n",
    "        return redirect(url_for('login', message='Invalid username or password'))\n",
    "\n",
    "\n",
    "@app.route(\"/login\")\n",
    "def login(message=None):\n",
    "    if 'message' in request.args:\n",
    "        message = request.args['message']\n",
    "    print(message)\n",
    "    return render_template('login.html', title='Login', message=message)\n",
    "\n",
    "\n",
    "@app.route(\"/user_page/<name>\")\n",
    "def user_page(name):\n",
    "    return render_template('user.html', title='User', user=name)\n",
    "\n",
    "app.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Можем да забележим обаче, че администраторската ни страница е достъпна и без да трябва да сме се логнали. \n",
    "За достъп до нея, можем да изискваме даден ключ, или token. Него можем да подадем като параметър на заявката."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from flask import Flask, render_template, request, redirect, url_for\n",
    "\n",
    "app = Flask(__name__)\n",
    "\n",
    "@app.route(\"/\")\n",
    "def home():\n",
    "    return render_template('index.html', title='Home', user='Guest')\n",
    "\n",
    "\n",
    "@app.route(\"/login_action\", methods=['POST'])\n",
    "def login_action():\n",
    "    if request.method != 'POST':\n",
    "        return redirect(url_for('/login', message='Invalid method'))\n",
    "\n",
    "    if request.form['username'] == 'admin' and request.form['password'] == 'admin':\n",
    "        username = request.form['username']\n",
    "        return redirect(url_for('user_page', name=username, token='123456'))\n",
    "    else:\n",
    "        return redirect(url_for('login', message='Invalid username or password'))\n",
    "\n",
    "\n",
    "@app.route(\"/login\")\n",
    "def login(message=None):\n",
    "    if 'message' in request.args:\n",
    "        message = request.args['message']\n",
    "    print(message)\n",
    "    return render_template('login.html', title='Login', message=message)\n",
    "\n",
    "\n",
    "@app.route(\"/user_page/<name>\")\n",
    "def user_page(name):\n",
    "    if 'token' not in request.args:\n",
    "        return redirect(url_for('login', message='You must login first'))\n",
    "    return render_template('user.html', title='User', user=name)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Естествено, това е доста прост начин за аутентикация. Повече по темата може да прочетете [тук](https://realpython.com/token-based-authentication-with-flask/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## JSON API"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "С помощта на Flask можем и да направим API, който ни връща отговорите в JSON формат. За целта ще разгледаме някои полезни методи на Flask."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `jsonify`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Методът `jsonify` ни позволява лесно да превърнем дадени променливи, в отговор на заявка в JSON формат."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from flask import Flask, Response, jsonify\n",
    "\n",
    "app = Flask(__name__)\n",
    "\n",
    "@app.route(\"/\")\n",
    "def home() -> Response:\n",
    "    return jsonify(status='success', message='Hello, World!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Резултатът от извикването на `jsonify` ще е `Response` обект, с mimetype `application/json`. Подадените аргументи пък, ще бъдат върнати в JSON формат."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!python3 -m flask --app examples/api_jsonify run"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Има два прости начина да \"тестваме\" нашето API. Първият е да използваме браузъра, като отворим адреса на нашата страница, като добавим `/api` в края. Вторият начин е да използваме `curl` командата.\n",
    "\n",
    "```bash\n",
    "curl http://127.0.0.1:5000\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!curl \"http://127.0.0.1:5000\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### make_response"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Понякога се налага да промени нещо по `Response` обекта - било то response code, header-и или други елементи.\n",
    "За тази цел, можем да използваме `make_response` функцията."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Освен текст, можем да зададем и статус кода на нашия отговор като аргумент на `make_response` функцията.\n",
    "\n",
    "Друг полезен аргумент е `headers`, който приема речник с header-и, които да бъдат добавени към отговора."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from flask import Flask, make_response\n",
    "\n",
    "app = Flask(__name__)\n",
    "\n",
    "@app.route(\"/\")\n",
    "def home():\n",
    "    return make_response(\"Hello World!\", 200, {\"Debug\": \"Hello World!\"})\n",
    "\n",
    "@app.route(\"/error\")\n",
    "def error():\n",
    "    return make_response(\"Error!\", 404, {\"Debug\": \"Error!\"})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!python3 -m flask --app examples/make_response_example run"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Можем да видим върнатия ни header, като използваме `curl` командата с опция `-i`.\n",
    "\n",
    "```bash\n",
    "curl -i http://127.0.0.1:5000/error\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Достъп до header-и"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Видяхме как можем да изпращаме header-и към нашия отговор. Но как можем да ги прочетем?\n",
    "\n",
    "За да прочетем header-и, можем да използваме `request.headers` атрибут. Той е речник, който съдържа всички header-и, които са изпратени от клиента."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Нека разгледаме пример, в който ще очакваме от клиента да ни изпрати в header-а стойност за `user`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from flask import Flask, render_template, request, redirect, url_for\n",
    "\n",
    "app = Flask(__name__)\n",
    "\n",
    "@app.route(\"/\")\n",
    "def home():\n",
    "    if 'user' in request.headers:\n",
    "        user = request.headers['user']\n",
    "        return render_template('index.html', title='Home', user=user)\n",
    "    return render_template('index.html', title='Home', user='Guest')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!python3 -m flask --app examples/accessing_headers run"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Можем да тестваме примера отново чрез командата `curl`. Ако искаме да изпратим header, можем да използваме опция `-H`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!curl \"http://127.0.0.1:5000\"\n",
    "!echo \"\"\n",
    "!curl -H \"user:Lyubo\" \"http://127.0.0.1:5000\" "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Работа с конфигурационни файлове"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Flask поддържа няколко настройки. Те се намират в `config` атрибута на `Flask` обекта.\n",
    "\n",
    "Някой от най-използваните са `ENV`, `DEBUG`, `TESTING` и `SECRET_KEY`.\n",
    "\n",
    "- `ENV` - средата, в която работи Flask. Може да бъде `development`, `production` или `testing`.\n",
    "- `DEBUG` - ако е `True`, Flask ще бъде стартиран в режим на debug. Това означава, че при грешка, Flask ще покаже по-подробна информация за грешката. Друга удобна функционалност е, че когато променим нашия код, Flask сървъра ще се рестартира автоматично.\n",
    "- `TESTING` - ако е `True`, Flask няма да хваща грешки. Използва се при тестване.\n",
    "- `SECRET_KEY` - таен ключ, който се използва за криптиране на данни\n",
    "\n",
    "Пълен списък може да намерите в [документацията](https://flask.palletsprojects.com/en/2.2.x/config/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Като пример, можем да създадем страница, която да е достъпна, само като `ENV` е равна на `development`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from flask import Flask, make_response\n",
    "\n",
    "app = Flask(__name__)\n",
    "# app.config['ENV'] = 'development'\n",
    "\n",
    "@app.route(\"/\")\n",
    "def home():\n",
    "    return make_response(\"Hello World!\", 200, {\"Debug\": \"Hello World!\"})\n",
    "\n",
    "if app.config['ENV'] == 'development':\n",
    "    @app.route(\"/dev\")\n",
    "    def dev():\n",
    "        return make_response(\"This is the development panel !\", 200)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!python3 -m flask --app examples/config_example run"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Освен в кода, можем да задаваме настройки и във файлове. Това е удобно, когато искаме да съхраняваме тайни данни, като пароли, ключове и т.н."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Нека създадем файл на име `dev.conf`, със следното съдържание:\n",
    "\n",
    "```conf\n",
    "TESTING = True\n",
    "ENV = 'development'\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Освен това, ще зададем стойността на средата `FLASK_CONFIG` на пътя към нашия конфигурационен файл."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from flask import Flask, make_response\n",
    "\n",
    "app = Flask(__name__)\n",
    "app.config.from_envvar('FLASK_CONFIG')\n",
    "\n",
    "@app.route(\"/\")\n",
    "def home():\n",
    "    return make_response(\"Hello World!\", 200, {\"Debug\": \"Hello World!\"})\n",
    "\n",
    "if app.config['ENV'] == 'development':\n",
    "    @app.route(\"/dev\")\n",
    "    def dev():\n",
    "        return make_response(\"This is the development panel !\", 200)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "С `app.config.from_envvar` казваме на Flask да зареди настройките от конфигурационния файл, намиращ се на пътя записан в `FLASK_CONFIG`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!export FLASK_CONFIG='dev.conf' && python3 -m flask --app examples/external_config_example run"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Обработка на грешки"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Понякога бихме искали да обработим грешки, които са възникнали в нашето приложение. Например, ако някой от нашите view-та върне `404`, можем да направим нещо по-интересно, отколкото да покажем само текста `Not Found`.\n",
    "\n",
    "С помощта на `errorhandler` декоратора, можем да обработим грешки, които са възникнали в нашето приложение."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ще добавим една нова страница, която ще връща `404` код. Така ще можем да видим как се обработва грешката.\n",
    "\n",
    "```html\n",
    "{% extends \"base.html\" %}\n",
    "\n",
    "{% block styles %}\n",
    "<link rel=\"stylesheet\" href=\"{{ url_for('static', filename='style.css') }}\">\n",
    "{% endblock %}\n",
    "\n",
    "{% block content %}\n",
    "    <h1>Page was not found</h1> \n",
    "    <img src=\"{{ url_for('static', filename='logo.png') }}\"/>\n",
    "{% endblock %}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from flask import Flask, request, make_response, render_template\n",
    "\n",
    "app = Flask(__name__)\n",
    "\n",
    "@app.route(\"/\")\n",
    "def home():\n",
    "    if 'user' in request.headers:\n",
    "        user = request.headers['user']\n",
    "        return make_response(f\"Hi, {user}\", 200)\n",
    "    return make_response(\"Hi, Guest\", 200)\n",
    "\n",
    "@app.errorhandler(404)\n",
    "def page_not_found(e):\n",
    "    return make_response(render_template('custom_404.html'), 404)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!python3 -m flask --app examples/custom_404 run"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.4"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}