Flask — ploshadka.net

Flask Pedantic

Admin — Mon, 12 Dec 2022 08:00:00 +0000

Примеры кода проверок на Pedantic для Flask.

Эта статья будет пополняться примерами.

Проверка списка данных

Модель проверки:

class OperationsUpdateModel(BaseModel):
id: int
confirmed: bool

Как проверить валидацию данных в API и отправить ошибку:

@operations_bp.route('/update-operations/', methods=['PATCH'])
@login_required
def update_operations_route():
try:
data = request.get_json()
try:
list_ = parse_obj_as(List[OperationsUpdateModel], data)
except Exception:
return {"error": "Must be a list {id: int, confirmed: bool}"}, 400

return jsonify('ok')
except Exception as e:
logger.error({e}, exc_info=True)

Минимализм SQLAlchemy — передача списка и распаковка

Admin — Wed, 09 Nov 2022 08:00:00 +0000

Как передавать разные параметры в SQLAlchemy и распаковать их. Как одновременно создать объект в SQLAlchemy, а если он создан, то обновить объект. Как передавать любые параметры при этом не создавая много одинаковых функций.

Ниже приведены несколько вариантов длинного кода, но сокращение для всех применяется одно и то же.

Сокращение при создании и обновлении БД

Вместо увеличения списка параметров:

query = db.session.query(Result).filter_by(user_id=user_id, date=date).first()
if not query:
new = Result(
rub=balance['rub'],
usd=balance['usd'],
time=balance['time'],
)
else:
db.session.query(Result).filter_by(user_id=user_id, date=date).update(
{
'rub': balance['rub'],
'usd': balance['usd'],
'time': balance['time'],
})
db.session.commit()

Можно сделать так:

def update_results(user_id, balance):
balance['user_id'] = user_id
balance['updated_at'] = datetime.utcnow()

query = db.session.query(Result).filter_by(user_id=user_id, date=balance['date']).first()
if not query:
new = Result(**balance)
db.session.add(new)
else:
for key, value in balance.items():
setattr(query, key, value)
db.session.commit()

Сокращение при создании нового объекта

Вместо:

def add_new_balance_assets(
user_id: int, portfolio_id: int, instrument_type: str, currency: str,
quantity: float
):
new = BalanceAssets(
user_id=user_id,
portfolio_id=portfolio_id,
instrument_type=instrument_type,
currency=currency,
quantity=quantity
)
db.session.add(new)

Это:

def add_new_balance_assets(balance):
new = BalanceAssets(**balance)
db.session.add(new)

Сокращение при обновлении объекта

Вместо:

def update_balance(user_id, id_, date_time, description, sum_in_rub):
if date_time:
db.session.query(Balance).filter_by(user_id=user_id, id=id_).update(
{'date': date_time}
)
if description or description is None:
db.session.query(Balance).filter_by(user_id=user_id, id=id_).update(
{'description': description}
)
if sum_in_rub:
db.session.query(Balance).filter_by(user_id=user_id, id=id_).update(
{'sum_in_rub': sum_in_rub}

Так:

def update_balance(balance):
query = db.session.query(Balance).filter_by(user_id=balance['user_id'], id=balance['id']).first()
for key, value in balance.items():
setattr(query, key, value)
db.session.commit()

SQLAlchemy — связи relationship

Admin — Mon, 24 Oct 2022 10:16:48 +0000

Как связать несколько моделей таблиц базы данных PostgreSQL между собой в SQLAlchemy.

Пример связей

Я уже когда-то писал статью в которой затрагивалась тема связей SQLAlchemy. Это статья будет эволюционным продолжением предыдущий.

Возьмём пример из официальной документации:
https://docs.sqlalchemy.org/en/14/orm/basic_relationships.html

class Association(Base):
__tablename__ = "association_table"
left_id = Column(ForeignKey("left_table.id"), primary_key=True)
right_id = Column(ForeignKey("right_table.id"), primary_key=True)
extra_data = Column(String(50))
child = relationship("Child", back_populates="parents")
parent = relationship("Parent", back_populates="children")

class Parent(Base):
__tablename__ = "left_table"
id = Column(Integer, primary_key=True)
children = relationship("Association", back_populates="parent")

class Child(Base):
__tablename__ = "right_table"
id = Column(Integer, primary_key=True)
parents = relationship("Association", back_populates="child")

В примере выше есть все необходимое. Я лишь обращу внимание на конкретные места, чтобы не было путаницы.

1. Начинаем строить наши связи с таблицы, через которую будет связываться две другие.

2. Обратим внимание на первую модель, на свойство child:

child = relationship("Child", back_populates="parents")

Название переменной в единственном роде и оно же ссылается на класс (модель, таблицу) с названием в единственном роде. Принцип построения этой связи легко запоминается по критерию — единственный род.

3. Второй параметр из примера выше (но для разнообразия возьмем другую связь) back_populates:

parent = relationship("Parent", back_populates="children")

Видим, что back_populates ссылается на свойство children в классе Parent.

4. В обоих моделях (таблицах), которые мы связываем есть отсылки к связанной модели через модель ассоциаций:

children = relationship("Association", back_populates="parent")

Т.е. class Parent(Base) мы связываем не напрямую через класс class Child(Base), а через класс class Association(Base) и свойство в нем parent, которое уже ссылается на другой класс class Child(Base).

Важно понимать как строится связи, иначе будут возникать ошибки:

SAWarning: relationship ‘Task.cat_Task’ will copy column Task.id to column categories_Task.Task_id, which conflicts with relationship(s): ‘Category.Task’ (copies Task.id to categories_Task.Task_id), ‘Task.cats’ (copies Task.id to categories_Task.Task_id). If this is not the intention, consider if these relationships should be linked with back_populates, or if viewonly=True should be applied to one or more if they are read-only. For the less common case that foreign key constraints are partially overlapping, the orm.foreign() annotation can be used to isolate the columns that should be written towards. To silence this warning, add the parameter ‘overlaps=»cats,Task»‘ to the ‘Task.cat_Task’ relationship. (Background on this error at: https://sqlalche.me/e/14/qzyx)

Пример доступа к связанным объектам

Рассмотрим следующий пример. Допустим нам нужно получить объект из одной таблицы, но подтянуть связи из других таблиц. Весь код выглядит так:

class TaskCategory(db.Model):
__tablename__ = 'task_categories'
id = db.Column(db.Integer, primary_key=True, unique=True)
category = db.relationship('Category', back_populates="tasks")
task = db.relationship('Task', back_populates="categories")

@property
def get_task_cats(self):
return {
'task_cat_id': self.id,
}

@property
def get_cats(self):
return self.category.get_cats

class Task(db.Model):
__tablename__ = 'tasks'
id = db.Column(db.Integer, primary_key=True, unique=True)
categories = db.relationship('TaskCategory', back_populates="task")

@property
def serialize(self):
return {
'task_id': self.id,
'cats': [x.get_cats for x in self.categories],
'task_cats': [x.get_task_cats for x in self.categories],
}

class Category(db.Model):
__tablename__ = 'categories'
tasks = db.relationship('TaskCategory', back_populates="category")

@property
def get_cats(self):
return {}

Я говорю об этом участке:

@property
def serialize(self):
return {
'task_cats': [x.get_task_cats for x in self.categories],
'cats': [x.get_cats for x in self.categories],
}

В примере выше мы хотим получить по свойству serialize данные из таблицы class Task(db.Model), но одновременно запрашиваем обработанные данные из двух других связанных таблиц.

В этом случае:

'task_cats': [x.get_task_cats for x in self.categories]

обращение идет к данным class TaskCategory(db.Model).

В другом случае:

'cats': [x.get_cats for x in self.categories]

обращение идет также к классу class TaskCategory(db.Model), но к функции, которая обращается за данными уже к третей таблице.

Таким образом мы берем данные по связи из третей таблицы через вторую (таблица которая связывает обе).

Как передать пустое значение с фронта на бэкенд

Admin — Wed, 19 Oct 2022 18:39:17 +0000

Как передать пустое значение с фронта, чтобы на бэкенде оно приходило пустым. Для чего это нужно? Например, для удаление из поля данных.

Например, при передаче пустой строки " ", бэкенд может вернуть ошибку, если входящие данные проверяются на int или на none.

Для передачи пустого значения приведем его к null

На фронте, если передается пустое значение, то превратим в null:

<input class="rub edit" type="text" bind:value="{b.rub}" on:change={saveUsersData(b)}>

function saveUsersData(b) {
if (b.rub === '') {
b.rub = null
}

let data = {
'rub': b.rub,
}

patchFetch('balance/update/', data);
}

На бэкенде проверим это значение на число через pydantic:

sum_in_rub: Optional[int]

Видим, что пройдет только int и на пустое значение " " возвратит ошибку.

А затем сохраним или значение, которое есть или значения, которого нет:

def update_balance(user_id, rub):
if rub or rub is None:
db.session.query(Balance).filter_by(user_id=user_id, id=id_).update(
{'rub': rub}
)

Flask Login Pytest API

Admin — Mon, 01 Aug 2022 12:46:12 +0000

Конфигурация PyTest для тестирования Flask API при использовании Flask-Login (Flask-Admin, Flask-Security) при которой тесты обходят авторизацию на сайте.

Описание проблемы

При тестировании, особенно при тестировании API для прохождения тестов необходимо обойти авторизацию на сайте. Для этого будем использовать встроенные функции. Ниже две конфигурации при которой всё работает.

Код учитывает обход как @login_required для путей API, так и авторизирует пользователя при прохождении тестов. В результате flask_login.current_user.id видит указанного пользователя.

Конфигурация 1

Содержимое файла conftest.py. Этот файл используется для инициализации тестов.

import flask_login
import pytest
from app import app, db
from app.models.users import User

@pytest.fixture
def client():
app.config["TESTING"] = True
# Обходит @login_required
app.config["LOGIN_DISABLED"] = True
with app.test_client() as client:
yield client

@pytest.fixture
def authenticated_request():
# Решает проблему с flask_login.current_user.id:
# AttributeError: 'AnonymousUser' object has no attribute 'id'
# Создает авторизацию пользователя
with app.test_request_context():
test_user = db.session.query(User).filter_by(id=1).first()
yield flask_login.login_user(test_user)

Содержимое файла test-category.py

import json
import pytest

from app import db
from app.models.categories import Category
from app.repositories.category import get_category_by_id

headers = {"Content-Type": "application/json"}

@pytest.mark.usefixtures("authenticated_request")
def test_category_rename(client):
# Create test data
user_id = 1
cat = Category(user_id=user_id, name='Test Category')
db.session.add(cat)
db.session.commit()

# Mock
mock_name = 'Test Category New'
mock_request_data = {
'cat_id': cat.id,
'name': mock_name,
}

# Rename category
url = 'http://127.0.0.1:5000/categories/update/'
client.patch(url, headers=headers, data=json.dumps(mock_request_data))

# Check new name
category = get_category_by_id(user_id, cat.id)
assert category.name == mock_name

# Clear test data
db.session.delete(category)
db.session.commit()

Ссылка на репозиторий в GitHub.

Конфигурация 2

Если не нужен обход авторизации во всех тестах можно обходить авторизацию в каждом отдельном тесте.

Содержимое файла conftest.py:

import pytest
from app import app, db

@pytest.fixture
def client():
app.config["TESTING"] = True
# Bypasses @login_required
app.config["LOGIN_DISABLED"] = True
with app.test_client() as client:
yield client

Содержимое файла test_category.py:

import json
from app import db, app
from app.models.categories import Category
from app.models.users import User
from app.repositories.category import get_category_by_id

headers = {
"Content-Type": "application/json",
}

def test_category_rename(client):
# Create test data
user_id = 1
cat = Category(user_id=user_id, name='Test Category')
db.session.add(cat)
db.session.commit()

# Mock
mock_name = 'Test Category New'
mock_request_data = {
'cat_id': cat.id,
'name': mock_name,
}

with app.test_client() as client:
# Решает проблему с flask_login.current_user.id:
# AttributeError: 'AnonymousUser' object has no attribute 'id'
test_user = db.session.query(User).filter_by(id=user_id).first()

@app.login_manager.request_loader
def load_user_from_request(request):
return test_user

# Tests starts here
url = 'http://127.0.0.1:5000/categories/update/'
client.patch(url, headers=headers, data=json.dumps(mock_request_data))

# Check new name
category = get_category_by_id(user_id, 576)
assert category.name == mock_name

# Clear test data
db.session.delete(category)
db.session.commit()

Ссылка на репозиторий в GitHub.

Запуск тестов

Запуск тестов осуществляется командой:

pytest app/tests/

Дополнительные ключи:

# -s - отображает содержимое print
# -v - отображает полное название тестов
# --disable-pytest-warnings - убирает warnings summary

SQLAlchemy — как получить единичный связанный объект

Admin — Sun, 07 Nov 2021 08:00:00 +0000

Получаем сериализированное свойство в связанном объекте.

Как получить единичный объект

Для этого нужна функция:

def __str__(self):
return self.name_ru

Весь пример:

class Category(db.Model, RoleMixin):
__tablename__ = 'categories'
id = db.Column(db.Integer, primary_key=True, unique=True)
cat_global_id = db.Column(db.Integer, db.ForeignKey('categories_global.id'))

parent_global_name = db.relationship('CategoryGlobal', backref=db.backref('categories'))

@property
def serialize_for_categories(self):
return {
'id': self.id,
'cat_global_name': self.parent_global_name.__str__(),
}

class CategoryGlobal(db.Model, RoleMixin):
__tablename__ = 'categories_global'
id = db.Column(db.Integer, primary_key=True, unique=True)
name_ru = db.Column(db.String(255))

def __str__(self):
return self.name_ru

Как получить массив из ID

В классе моделей:

@property
def serialize_time(self):
return {
self.time.strftime('%d'),
}

В файле, где нужно получить данные

query = db.session.query(Task).filter_by(user_id=user_id)
query = [x.serialize_time for x in query]

# Переделываем множество [{'15'}, {'4'}] в список id -> [15, 4]
query = [int(list(x)[0]) for x in query]

# Отсортируем цифры по увеличению
query.sort(key=lambda x: x)

SQLAlchemy — пример сложной выборки many to many

Admin — Tue, 19 Oct 2021 08:00:00 +0000

Пример выборки через SQLAlchemy, когда нужно забрать данные связанные по цепочке с другими таблицами, где в последней из них нужно отобрать данные по определенному значению.

Имеем класс CategoryGlobal:

class CategoryGlobal(db.Model, RoleMixin):
__tablename__ = 'categories_global'
id = db.Column(db.Integer, primary_key=True, unique=True)
name = db.Column(db.String(255))

Внутри этого класса есть связь с двумя другими таблицами по методу many to many:

items = db.relationship(
'Item',
secondary='categories_item',
backref=db.backref('categories_global'),
)

Там же указано свойство:

@property
def serialize_for_favorites(self):
return {
'id': self.id,
'name': self.name,
'items': [x.serialize if x.favorite == False else '' for x in self.items],
}

Рассмотрим последний участок кода:

'items': [x.serialize if x.favorite == False else '' for x in self.items]

Обычно это выглядит так:

'items': [x.serialize for x in self.items]

И в этом случае будут собраны все items для всех categories_global.

Нам же нужно собрать только избранные записи, в которых у item есть значение в колонке favorite и оно равно True. В противном случае вернуть пустой массив. Поэтому и используется сравнение:

if x.favorite == False else ''

Теперь сформируем сам запрос в python, чтобы забрать данные:

query = db.session.query(CategoryGlobal).all()
categories_global = [x.serialize_for_favorites for x in query]

Если item у categories_global существует, но True у favorite нет:

{'items': [], 'id': 11, 'name': 'корова'},
{'items': [''], 'id': 4, 'name': 'бык'},

Из примера выше видно, что там где был item появилось [одинарные кавычки], если было бы у item True, тогда результат был бы такой:

{'items': [], 'id': 11, 'name': 'корова'},
{'items': [{'cats': [{'hidden': False,
'id': 263,
'name': 'слон'}],
'date': '2021-09-11',
'favorite': True,
'id': 283,
'name': 'пошел',
'note': None,
'time_passed': [{'cat_inner_id': 263,
'item_id': 283,
'time_passed': 32426}],
'timestamp': 1631349025.560444,
'weekday': 'сб'}], 'id': 4, 'name': 'бык'},

Затем можно удалим все где нет значений:

new_list = categories_global[:]
for cat in new_list:
if not cat['items']:
categories_global.remove(cat)

Теперь в categories_global только одно значение.

Как подключить стили в jinja2

Admin — Sat, 10 Apr 2021 08:00:00 +0000

По умолчанию стили должны находится в папке static на уровне корневой директории. 

Подключение будет таким:

{% block head %}
<link rel="stylesheet" href="{{ url_for('static', filename='styles.css', v='1') }}">
{% endblock %}

По умолчанию стили для jinja2 должны находится в корневой директории сайта в папке static иначе будет ошибка.

Директорию «по умолчанию» можно переопределить, но у меня не работали типовые команды во Flask для этого, поэтому приводить их не буду.

Flask: Celery + RabbitMQ

Admin — Sun, 03 Jan 2021 18:47:59 +0000

Полное руководство по настройки очередей задач на Flask через Celery и RabbitMQ.

В Интернете сложно найти полноценное описание настройки Celery через RabbitMQ и Flask. В основном попадаются примеры на Redis и Django. В этой статье попробую это исправить и расскажу о полной настройке и запуске Celery на Flask.

Что такое очереди задач?

Это что-то вроде cron-задач, только более продвинутое использование. Celery позволяет запускать задачи не перегружая процессор (умеет распределять нагрузку). В отличии от cron задач celery может запускать задачи параллельно. Также имеется обработчики ошибок и легко следить за результатом.

В Celery встроен свой cron-обработчик. С этим мы получаем все преимущества celery и одновременно можем запланировать события по типу cron.

Зачем нужен RabbitMQ?

Из-за объема информацию RabbitMQ вынесен в отдельную статью.

А нужны ли вам очереди задач?

Очереди задач довольно замороченная штука. Вы можете увидеть это посмотрев на объем текущей статьи. Я постарался учесть большую часть для того, чтобы все настроить, но описано тут далеко не все.

А что делает в конечном счете celery? Если отбросить нюансы, он делает то же самое что и cron, но требует гораздо больше дополнительных сущностей, зависимостей и настроек.

Конечно с этой статьей учиться будет быстрее, но никто не гарантирует что вы не столкнетесь с другими проблемами или задачами не описанными здесь. Или допустим у вас будет не RabbitMQ, а Redis или не Flask, а Django. Тогда придется разбираться во многих других нюансах самостоятельно.

Возможно вы сможете обойтись cron-ом на питоне.

Или может быть вам подойдет зацикливание таймером (timer)? Несмотря на простоту таймера есть в нём одно большое преимущество: функция не будет выполнена второй раз прежде чем она завершится. Однако это можно решить с помощью кэша, об этом будет в этой статье.

Установка Celery на Flask

Установка:

pip install celery

Настройка «очередей задач» будет на той же архитектуре, что рассказывается в цикле основных статей в архитектуре проекта на Flask.

Ниже приведены 2 конфигурации: та к которой я пришел и та которая описана в примерах на Flask.

Моя конфигурация

init.py

Это основной файл инициализации, который запускается вместе с запуском приложения на Flask. Смотрите структуру проекта на Flask. В этом же файле настраиваются конфигурационные файлы Flask.

Расположение файла

app/__init__.py

В функцию create_app (основная функция создания приложения на Flask) добавим новые конфигурационные файлы:

def create_app():
app = Flask(__name__)
app.config.from_pyfile('../configs/private/celery.py')
app.config.from_pyfile('../configs/beatschedule.py')
return app

app = create_app()

beatschedule.py

Расположение файла:

configs/beatschedule.py

Это конфигурационный файл в котором будут планироваться задачи. Его содержимое:

imports = ('tasks.updates',)
task_default_queue = 'ploshadka_queue'

BEAT_SCHEDULE = {
'updates': {
'options': {'queue': 'ploshadka_queue'},
'task': 'task_update',
'schedule': 30.0,
},
}

celery.py

Расположение файла:

configs/private/celery.py

Это приватный файл для сельдерея. Локальный конфиг будет отличаться от конфига продакшена. Этот конфиг обязательно должен быть добавлен в исключении файла .gitignore.

Его содержимое для PostgreSQL для локальной среды:

from configs.beatschedule import *

broker_url = 'pyamqp://guest@localhost//'
result_backend = 'db+postgresql+psycopg2://localhost/ploshadka_db'
beat_schedule = BEAT_SCHEDULE

также будет работать:

broker_url = 'pyamqp://localhost'

Для прода в result_backend добавляем пользователя БД и пароль, остальное аналогично тому что выше:

from configs.beatschedule import *

broker_url = 'pyamqp://guest@localhost//'
result_backend = 'db+postgresql+psycopg2://<пользователь>:<пароль>@localhost/ploshadka_db'
beat_schedule = BEAT_SCHEDULE

В старых инструкциях вместо result_backend указана константа CELERY_RESULT_BACKEND, но сейчас она считается deprecated и будет в последствии удалена.

В результате этой настройки брокер сообщений создаст две таблицы в БД, в которых будет хранить свои данные:

Задачи

Расположение задач:

tasks
--__init__.py
--updates.py

Внутри файла updates.py:

from celery import Celery
celery = Celery('updates')

@celery.task(name='task_update')
def task_update():
return "task_update: success"

name=’task_update’ должно равняться имени ‘task’: ‘task_update’ в BEAT_SCHEDULE.

Запуск

Обязательно запускать с опцией конфига. Обо всех этих и других командах (и опциях для них) будет описано подробнее ниже в текущей статье.

celery -A tasks.updates.celery --config=configs.private.celery beat --detach --logfile=logs/beat.log -l INFO

celery -A tasks.updates.celery --config=configs.private.celery worker -D --logfile=logs/celery.log -l INFO --purge

Классическая конфигурация Flask

Ближе к официальной доке для Flask, но использую то что выше, а это сохранил на память.

init.py

from celery import Celery

def make_celery(app):
celery = Celery(
app.import_name,
broker=app.config['CELERY_BROKER_URL'],
backend=app.config['RESULT_BACKEND'],
)
celery.conf.update(app.config)

# Настройки для cron
celery.conf.beat_schedule = app.config['BEAT_SCHEDULE']

return celery

config.py

Доступы к серверу сообщений RabbitMQ пропишем внутри файла config.py

Для локалки подключение к PostgreSQL:

# Celery
CELERY_BROKER_URL='pyamqp://guest@localhost//'
RESULT_BACKEND='db+postgresql+psycopg2://localhost/bd_name'

На удаленном сервере:

# Celery
CELERY_BROKER_URL = 'pyamqp://localhost'
RESULT_BACKEND = 'db+postgresql+psycopg2://user_name:password@localhost/bd_name'

Cron настройки

Если мы хотим запускать наши задачи через cron celery, то здесь же укажем настройки:

imports = ('tasks.updates',)
task_default_queue = 'ploshadka_queue'

BEAT_SCHEDULE = {
'updates': {
'options': {'queue': 'ploshadka_queue'},
'task': 'task_update',
'schedule': 30.0,
},
}

Вместо BEAT_SCHEDULE раньше было CELERYBEAT_SCHEDULE, но сейчас является устаревшей.

Создаём задачи

Под задачи отведем отдельную директорию, назовем её tasks. В ней создадим файл updates.py.

Внутри файла. Функция с аргументами:

from app import make_celery, app

celery = make_celery(app)

@celery.task()
def add(a, b):
return a + b

add.delay(1, 5)

Метод delay() отвечает за запуск нашей задачи (функции add).

Функция с именем:

@celery.task(name='Update Balance')
def celery_update_balance():
update_deposit()
return {'status': 'Задача завершена!', 'result': 100}

celery_update_balance.delay()

Функция для запуска по крону:

@celery.task(name='tasks.update_balance')
def update_balance():
update()
return {'status': 'Задача завершена!', 'result': 100}

Варианты конфига cron

from celery.schedules import crontab

BEAT_SCHEDULE = {
'updates': {
'options': {'queue': 'ploshadka_queue'},
'task': 'task_update',
'schedule': 30.0, # Раз в 30 секунд

# Другие варианты:
# 'schedule': crontab(hour=5, minute=20, day_of_week=1),
# 'schedule': crontab(*), # Раз в минуту
# 'args': (16, 16) # Аргументы у функции
},
}

Запуск задач вне крона (worker)

а) Мы запустили наше приложении.
б) Находимся внутри виртуального окружения python.

После этого запускаем:

celery -A tasks.updates.celery worker -l info

где:
tasks — директория
updates — файл (модуль)
-l info — вывести мониторинг в консоли

Эта команда запустит worker и выполнит функцию с delay. Если все настроено было верно в базе данных появится новая запись, а в консоли отобразится информация о ходе работ:

Если в команду выше докинуть атрибут -B, то в этом файле одновременно будут запущены все задачи, как с кроном, так и без него.

celery -A tasks.updates.celery worker -B -l info

Предварительно надо запустить beat (об этом будет ниже).

Запуск воркера с -B использовать только для отладки, в противном случае задача может запускаться более одного раза. На боевом сервере команды запуска обычных задач и запланированных надо осуществлять отдельными командами.

Запуск задач по крону (beat)

Есть важная особенность в работе планировщика celery beat, в которой сразу сложно разобраться.

Для запуска планировщика нужны две команды worker и beat. Важно запускать сначала worker, а потом beat. Иначе задача будет сделана 2 раза.

Задвоение задач можно избежать также, если запускать команды с очисткой очередей —purge.

Запускаем воркер:

celery -A tasks.updates.celery worker --purge -l info

В другой вкладке:

celery -A tasks.updates.celery beat --detach

где:
detach — запуск в «тихом» (демон) режиме (без блокировки консоли). Для worker можно использовать вместо detach опцию -D.

worker тоже можно запускать с detach:

celery -A tasks.updates.celery worker --purge -D
celery -A tasks.updates.celery beat --detach

Сначала запускается worker и он начинает мониторинг и обработку очередей задач. Затем туда с помощью beat добавляются задачи, которые подхватываются и выполняются worker-ом.

Запуск на сервере

На сервере запуск можно сделать через демонов. Но мне нравится запускать через detach. Так больше контроля в одном месте.

Если используется «моя конфигурация», то запуск осуществляется:

celery -A tasks.updates.celery --config=configs.private.celery beat -l INFO --logfile=logs/beat.log --detach

celery -A tasks.updates.celery --config=configs.private.celery worker --purge -l INFO --logfile=logs/celery.log -D

Если используется «классическая конфигурация Flask», то для beat:

celery -A tasks.updates.celery beat -l INFO --logfile=logs/beat.log --detach

А вот команда worker может не видеть всего что указано в make_celery и для этого надо прописать в ней все опции. При этом т.к. мы не создавали конфиг отдельный, то конфиг тоже указываем, но ссылаемся на модуль с задачей. Не знаю почему такие костыли, но только так оно работает в этом случае:

celery -A tasks.updates.celery --config=tasks.updates worker --purge -l INFO --logfile=logs/celery.log -D -Q ploshadka_queue --result-backend=db+postgresql+psycopg2://localhost/ploshadka_db

Для этих целей удобно сделать скрипт и добавить в автозапуск после перезагрузки сервера.

Работа с очередями

Очереди нужны, чтобы не запутаться внутри кролика, если сайтов на сервере несколько или задач очень много, то их лучше поделить на категории.

По умолчанию используется очередь с названием celery.

Для того чтобы добавить очередь к задачи надо добавить в конфиг следующее:

BEAT_SCHEDULE = {
'updates': {
'options': {'queue': 'ploshadka.net'},
},
}

В случае запуска worker с определенной очередью:

celery -A tasks.updates.celery worker -Q ploshadka.net -l info

Можно избежать запуск с указанием очереди прописав в файле __init__.py (там где мы инициализируем функцию celery):

celery.conf.task_default_queue = 'ploshadka.net'

Или указать в конфигурационном файле:

task_default_queue = 'ploshadka.net'

Проверка очередей

Предварительно должен быть запущен worker.

Показать какие задачи сейчас в работе:

celery inspect registered

Для проверки есть ещё такие команды, но они не покажут название текущей рабочей задачи как это сделает команда выше:

celery status
celery inspect active
celery inspect scheduled

Логирование в Celery

Celery перехватывает логирование тех задач, которые она выполняет. Даже если для тех задач настроено логирование, оно будет записываться в лог celery, а не в тот который был ранее указан в логировании.

Это можно переопределить добавив в конфигурацию создания make_celery такую директиву:

'worker_hijack_root_logger': False

Но я бы не советовал, потому что такое переопределение может привести к непредсказуемым результатам, да и после небольшого понимания становится удобнее читать все что касается задачи в одном месте — в логах сельдерея.

Для того чтобы логи записывались мы можем указать их в консольной команде:

celery -A tasks.updates.celery worker -D --logfile=logs/celery.log -l INFO

Стоит обратить внимание, что одновременно с указанием файла —logfile=logs/celery.log надо указать, что именно будет записываться -l INFO.

Вместо info можно записывать дебаг: -l DEBUG. Использовать на случай отладки, иначе слишком много дополнительной информации будет записано.

Для beat точно такая же система.

Задвоения и дубликаты задач

Как было сказано выше дубли задач celery будут, если сначала добавляются beat, а потом запускать worker или если перед запуском воркера не очищать задачи.

Удалить повторы задач можно командами ниже. Иногда не сразу происходит удаление, нужно подождать около минуты.

Как удалить и очистить задачи ниже.

Как удалить задачи

Удаление задач не стоит путать с очисткой очередей. Удаление задач — это удаление их из планировщика (beat). Все что ранее добавилось в очередь будет находится в очереди и ждать выполнения. 

Показать все планировщики celery:

ps -ef | grep celery

Вывод:

501 82926 1 0 11:51PM ?? 0:00.23 /usr/local/Cellar/python@3.8/3.8.5/Frameworks/Python.framework/Versions/3.8/Resources/Python.app/Contents/MacOS/Python /venv/bin/celery -A tasks.updates.celery beat --detach
501 83252 59866 0 11:52PM ttys001 0:00.00 grep celery

Завершить все задачи и планирощик:

pkill -9 -f tasks.updates.celery

Или эту (они должны были бы заменять друг друга, но на деле иногда одна из команд отказывается работать корректно):

celery -A tasks.updates.celery control shutdown

После этой команды возникает надпись:

Error: No nodes replied within time constraint.

Можно не обращать внимание. Все воркеры и планировщики останавливаются. Это можно проверить командой выше (grep).

Как очистить или удалить очереди

Если запустить планировщик beat без worker, он все равно начнет работать. Это значит, что в нужное время будет добавлена задача в очередь. Иными словами, если была запланирована задача, которая каждую минуту что-то делает, то каждую минуту будет добавлена выполнение этой задачи. Очередь задач можно увидеть в RebbitMQ:

В тот момент когда будет запущен воркер, все накопленные задачи будут запущены друг за другом без того интервала, который раньше подразумевался (например, 1 минута). Это может привести к неприятным последствиям.

Есть несколько способов очистки очереди. Надо понимать, что в случае очистки очереди, если не отключен планировщик beat, задачи будут снова накапливаться.

1

Удалить очереди конкретной задачи:

celery -A tasks.updates.celery purge -f

Должно показать что-то вроде:

Purged 108 messages from 1 known task queue.

2

Удалить очередь по её названию.

celery amqp queue.delete название_очереди

Теперь до запуска нового worker ничего накапливаться не будет, потому что мы вовсе удаляем очередь, а не просто очищаем ее.

3

Можно сразу запускать воркер с очищением очереди:

celery -A tasks.updates.celery worker -l info --purge

Как не повторять задачу пока она не завершится

Встроенных инструментов для этого не придумано. Надо самостоятельно делать блокировку внутри функции с помощью кэша. Можно сделать так:

# Проверяем есть ли кэш
is_running = cache.get("running")

# Если кэш есть, значит предыдущая функция не закончена, выйдем из функции
if is_running:
return

# Ставим кэш.
cache.set('running', '1')

# Удалим кэш в конце функции
cache.delete("running")

Дебаг

Если ничего не работает, попробовать найти ошибку через команды с дебагом.

Для worker в консоли или в режиме демона:

celery -A tasks.updates.celery worker --purge -l DEBUG
celery -A tasks.updates.celery worker --purge -l DEBUG --logfile=logs/celery.log -D

Для beat:

celery -A tasks.updates.celery beat -l DEBUG
celery -A tasks.updates.celery beat -l DEBUG --logfile=logs/beat.log --detach

Celery Flower

Для просмотра задач воспользуетесь flower. Альтернативные варианты вывести на фронт данные из бд таблицы celery_taskmeta или просматривать данные там напрямую, например, через DataGrip.

Настройка конфигов

Если запускать worker в режиме демона с помощью detach, он может перестать видеть конфиги. При этом, если запускать его обычным образом с мониторингом в консоли, то все прекрасно работает. Для исправления этой ситуации надо прописывать дополнительные настройки в файле конфигурации и указывать дополнительные параметры в консольной команде.

При запуске worker в режиме detach может возникнуть такая ошибка:

[2020-12-31 11:11:35,802: ERROR/MainProcess] Received unregistered task of type ‘task_update’.
The message has been ignored and discarded.

Did you remember to import the module containing this task?
Or maybe you’re using relative imports?

Please see
http://docs.celeryq.org/en/latest/internals/protocol.html
for more information.

The full contents of the message body was:
‘[[], {}, {«callbacks»: null, «errbacks»: null, «chain»: null, «chord»: null}]’ (77b)
Traceback (most recent call last):
File «venv/lib/python3.9/site-packages/celery/worker/consumer/consumer.py», line 562, in on_task_received
strategy = strategies[type_]
KeyError: ‘task_update’

Дело в том, что worker не видит путь к задачам. Исправить можно двумя вариантами.

Вариант 1

Использовать в командной строке указатель на файл конфигурации, в котором описать настройки. Для этого в консольной команде надо указать:

––config=configs.celery-config

где configs это директория в которой находится файл конфигурации celery-config.py.

Содержимое этого файла:

# List of modules to import when the Celery worker starts.
imports = ('tasks.updates',)

В импорте указываем путь до файла с задачами.

Вариант 2

Во втором варианте больше писанины, но так тоже будет работать: можно без указания дополнительных настроек в файле.

В самом BEAT_SCHEDULE указать полный путь до задачи:

BEAT_SCHEDULE = {
'every_minute': {
'options': {'queue': 'task'},
'task': 'tasks.updates.task_update',
'schedule': 59.0,
},
}

где tasks.updates это директория и файл:

tasks
--__init__.py
--updates.py

А task_update название функции в файле updates.py.

В этом случае в самой задаче тоже обязательно указать полный путь:

@celery.task(name='tasks.updates.task_update')
def task_update():
return "Все ок"

Также все равно придется добавлять в командную строку опцию, но указывать уже на сам модуль с задачей:

--config=tasks.updates

Несколько очередей для разных сайтов на одном сервере

Добавляем такой атрибут к команде по запуска worker:

-n worker1@%h

где каждая цифра под отдельный сайт, т.е. для второго сайта будет 2

Ошибка когда не указан параметр:

celery@domain1 ready.warnings.warn(W_PIDBOX_IN_USE.format(node=self))you give each node a unique node name!Or if you meant to start multiple nodes on the same host please make sure

Maybe you forgot to shutdown the other node or did not do so properly?
2021-01-10 22:38:19,893: venv/lib/python3.8/site-packages/kombu/pidbox.py:72:
UserWarning:
A node named celery@domain1 is already using this process mailbox!
2021-01-10 22:38:19,875: mingle: all alone2021-01-10 22:38:18,816: mingle: searching for neighbors
2021-01-10 22:38:18,802: Connected to amqp://guest:**@127.0.0.1:5672//

Не работает сохранение в БД

Если через worker detach не работает сохранение в БД, то ошибка аналогично предыдущей. Мы или указываем в файле конфигурации такие настройки:

# Using the database to store task state and results.
result_backend = 'db+postgresql+psycopg2://localhost/ploshadka_net_db'

Или к консольной команде worker добавляем наш бэкенд:

--result-backend=db+postgresql+psycopg2://localhost/ploshadka_net_db

Не запускается очередь

Ровно такая же ситуация с очередями. Можно указывать в консольной команде:

-Q название_очереди

Или занести в файл конфигурации:

# Queue by default
task_default_queue = 'ploshadka_queue'

Если не указывать очередь по умолчанию в конфигурации и не указывать ее в консольной команде, то в логах можно наблюдать такие надписи:

DEBUG/MainProcess] heartbeat_tick : for connection

Другие ошибки в процессе настройки

Scheduler: Sending due task every_minute

Ошибка:

LocalTime -> 2020-12-16 10:12:49
Configuration ->
. broker -> amqp://guest:**@localhost:5672//
. loader -> celery.loaders.app.AppLoader
. scheduler -> celery.beat.PersistentScheduler
. db -> celerybeat-schedule
. logfile -> [stderr]@%INFO
. maxinterval -> 5.00 minutes (300s)
[2020-12-16 10:12:49,940: INFO/MainProcess] beat: Starting…
[2020-12-16 10:13:00,017: INFO/MainProcess] Scheduler: Sending due task every_minute (tasks.update_balance)

Запущен beat, но не запущен worker.

Ошибка:

Error: no such option: —config

В новой версии celery изменилось расположение конфигов. Надо поставить опцию с конфигом перед beat или worker.

Также могут быть такие ошибки:

Сравнение версий Celery 4 и Celery 5

В четвертой версии Celery при запуске создавал pid файл с номером процесса внутри. Это было и плюсом и минусом. Плюс в том, что нельзя было запустить команду beat или worker дважды, показывало ошибку:

Stale pidfile exists - Removing it.
Seems we're already running? (pid: 34944)

А минус, чтобы убить процесс надо было использовать команду:

pkill -9 -f celery

А она убивала не только процессы одного сайта, но и процессы celery для всех других сайтов. Начиная с версии 5, можно использовать команду:

pkill -9 -f tasks.updates.celery

Еще одно изменение в порядке опций в команде:

celery -A tasks.updates.celery --config=configs.private.celery worker -D --logfile=logs/celery.log -l INFO --purge

Теперь config и некоторые другие опции надо ставить перед worker, как показано выше.

Еще изменились константы. Вместо них сейчас переменные с другим наименованием.

Конечно это не все изменения, остальные можно узнать в официальных источниках.

Окончательный вариант запуска на сервере

Запускаем несколько worker:

celery --config=configs.private.celery worker -Q update -D --purge -l INFO --logfile=logs/celery.log
celery --config=configs.private.celery worker -Q analyse -D --purge -l INFO --logfile=logs/celery.log

И запускаем только один beat:

celery --config=configs.private.celery beat --detach -l INFO --logfile=logs/beat.log

Импорты указаны в файле beatschedule и в команде их дублировать не нужно:

imports = ('app.tasks.update', )

Для перезапуска используем (осторожно, убивает все воркеры и биты):

pkill -9 -f celery

и повторяем запуск снова.

SqlAlchemy vs psycopg2 — сравниваем скорость

Admin — Thu, 31 Dec 2020 08:00:00 +0000

Вряд ли найдется спор в том, что «обертка» может быть быстрее «обертываемого». А на сколько медленнее работает обертка, вот здесь может быть интересно. В этой статье приведу два сценария, делающих одно и тоже в двух вариантах: на SqlAlchemy и чистый psycopg2.

SqlAlchemy это ОРМ для упрощения взаимодействия с базой данных. В случае с PostgreSQL, SqlAlchemy выступает надстройкой над psycopg2, который в свою очередь является адаптером базы данных.

В примерах ниже операции абсолютно одинаковые с той лишь разницей, что в одном случае это делается через SqlAlchemy, в другом на psycopg2.

Как измерить скорость работы скриптов на python.

SqlAlchemy

Код:

def __save_operations(operations, user_id):
for operation in operations:
exist = db.session.query(Operation.id).filter_by(id_operation=operation['id_operation']).first()

if not exist:
new = Operation(
user_id=user_id,
id_operation=operation['id_operation'],
name=operation['name'],
currency=operation['currency'],
price=operation['price'],
quantity=operation['quantity'],
payment=operation['payment'],
commission=operation['commission'],
operation_type=operation['operation_type'],
date=operation['date']
)
db.session.add(new)
log_message(operation['name'], 'Добавлена новая операция')
db.session.commit()

Выходные данные:

Запускаются обновления

41:21 | Cinemark Holdings Inc | Добавлена новая операция

41:21 | Macerich | Добавлена новая операция

41:21 | Macerich | Добавлена новая операция

41:21 | Macerich | Добавлена новая операция

41:21 | Macerich | Добавлена новая операция

41:21 | American Airlines Group | Добавлена новая операция

41:21 | American Airlines Group | Добавлена новая операция

41:21 | Spirit Airlines Inc | Добавлена новая операция

41:21 | Carnival | Добавлена новая операция

41:21 | Carnival | Добавлена новая операция

41:21 | Macerich | Добавлена новая операция

41:21 | American Airlines Group | Добавлена новая операция

41:21 | Spirit Airlines Inc | Добавлена новая операция

41:21 | Carnival | Добавлена новая операция

41:21 | Carnival | Добавлена новая операция

41:21 | Cinemark Holdings Inc | Добавлена новая операция

— 0.04560375213623047 seconds —

Все замеры:

— 0.04560375213623047 seconds —

— 0.044077157974243164 seconds —

— 0.044499874114990234 seconds —

psycopg2

def __save_operations(operations, user_id):
""" Add shares to DB """
for operation in operations:
query = """
INSERT INTO operations (user_id, id_operation, name, currency, price, quantity, payment,
commission, operation_type, date)
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
ON CONFLICT DO NOTHING
;"""

db_psycopg.query_update(query, (user_id,
operation['id_operation'],
operation['name'],
operation['currency'],
operation['price'],
operation['quantity'],
operation['payment'],
operation['commission'],
operation['operation_type'],
operation['date']))
log_message(operation['name'], 'Добавлена новая операция')

def query_update(self, query, arg, message=None):
""" Обновляет данные в таблице и возвращает сообщение об успешной операции """
try:
cur = self.conn.cursor()
cur.execute(query, arg)
return message

except (Exception, psycopg2.Error) as error:
self.__error(error)

Все замеры:

— 0.012418031692504883 seconds —

— 0.015745878219604492 seconds —

— 0.009712934494018555 seconds —

Выводы

Лучший результат в секундах:

0.044 (SQLAlchemy) vs 0.0097 (psycopg2)

С ОРМ SQLAlchemy удобнее и быстрее писать код, но как видим проигрывает он по скорости в 3 раза, а в одном из случаев аж в 5 раз.

В своих проектах, там где тяжелые запросы, использую чистый psycopg2. Там где скорость запрос не нужна — SQLAlchemy.

Celery — вывод на фронт

Admin — Tue, 29 Dec 2020 12:15:13 +0000

Выводим результаты работы периодических задач Celery на фронт.

Для этих целей можно установить flower. Но у него есть ряд недостатков:

Доступ на сервере настраивается витиевато: либо дополнительно писать конфиги в Nginx либо подключаться через google api. На мой взгляд слишком далеко от кода все это, потом не вспомнить где это лежит.
Нет мониторинга записанных в БД задач. Мониторинг только в лайв режиме.

Все недостатки легко обойти быстро соорудив страницу в админке для просмотра результатов работы периодических задач.

Весь код:

from flask import Blueprint, json
from flask_login import login_required
from app import db

celery_bp = Blueprint('celery_bp', __name__)

def serialize_query(msg):
return {
"task_id": msg.task_id,
"status": msg.status,
"result": msg.result.tobytes().decode('utf-8', errors='ignore').replace(
'\x05C\x00\x00\x00\x00\x00\x00\x00?', ''),
"date_done": msg.date_done.strftime('%H:%M | %d %B %Y'),
}

@login_required
@celery_bp.route('/get-logs/', methods=['GET'])
def get_logs():
query = [serialize_query(x) for x in db.engine.execute('select * from celery_taskmeta order by date_done')]
return json.dumps(query)

Это получение данных с бэкенда. Здесь используются Flask, Blueprint, SQLAlchemy. Остается только на фронте отправить запрос на указанный урл, распарсить json и вывести на страницу.

Ошибки

TypeError: Object of type memoryview is not JSON serializable

Из особенностей Celery. Он сохраняет результат в БД в формате memoryview. Мы этот формат переводим в байты командой:

tobytes()

Затем декодируем игнорируя ошибки:

.decode('utf-8', errors='ignore')

Почему-то у меня celery сохраняет memoryview с неправильными символами на что собственно и ругается интерпретатор. Дальше эти символы удаляем командой:

.replace('\x05C\x00\x00\x00\x00\x00\x00\x00?', '')

Кэширование на Flask

Admin — Wed, 23 Dec 2020 11:11:19 +0000

Описание кэширования на python в фреймворке Flask.

Установка

Для кэширования во Flask есть модуль Flask-Caching. Он поддерживает разные виды кэшей и требует дополнительных настроек. Вместо Flask-Caching сразу установим модуль для работы с memcached. Есть много различных модулей для работы с ним. Самый популярный это pylibmc написанный на C. Я же буду использовать дальше модуль pymemcache.

Установим модуль memcached:

pip install pymemcache

Добавляем установленный модуль в файл зависимостей:

pip freeze > requirements.txt

Как установить сервис memcached на Mac OS и на memcached на Ubuntu.

Интеграция

В файле __init__.py добавляем:

from pymemcache.client import base
cache = base.Client(('127.0.0.1', 11211), timeout=60, connect_timeout=60)

Использование

from app import cache
cache.set('running', '1', expire=300)
cache_running = cache.get("running")
cache.delete("running")

где expire — необязательный параметр, который означает время жизни кэша по истечении которого он будет удален. По умолчанию 0. Указывается в секундах.

Разрешим подключение к порту

Для использования мемкэша на локалхосте (без внешнего подключения к серверу) открывать ничего не требуется. А иначе в случае использования фаервола может потребоваться разрешение.

Добавить правило в ufw можно так:

sudo ufw allow 11211/tcp # memcached

Если правило больше не нужно, его можно удалить.

Показать по номерам все правила:

sudo ufw status numbered

Удалить конкретное правило:

sudo ufw delete 4

SQLAlchemy — many-to-many

Admin — Sun, 29 Nov 2020 22:20:35 +0000

Описание связи many-to-many (многие ко многим) в SQLAlchemy. Пример создания таблиц и сохранения данных.

Более новая статья по теме связей relationship SQLAlchemy, более точная, но в чем-то не заменяющая текущую.

Описание моделей (классов)

Мы создаем два класса: Task и Category, в одной таблице будут сохранятся задачи, в другой категории.

Таблица задач

Таблица категорий

У одной задачи может быть несколько категорий. Для этих целей наилучшим образом подойдет сохранение связи между задачей и категорией в отдельной таблице. Это будет третья таблица, которая будет создана с помощью связи db.relationship.

Все это делается описанием классов моделей таким образом:

# ploshadka.net
from datetime import datetime
from flask_login import UserMixin
from flask_security import RoleMixin

tasks_categories = db.Table(
'tasks_categories',
db.Column('task_id', db.Integer(), db.ForeignKey('task.id')),
db.Column('cat_id', db.Integer(), db.ForeignKey('categories.id'))
)

class Task(db.Model, RoleMixin):
__tablename__ = 'tasks'
id = db.Column(db.Integer(), primary_key=True, unique=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
name = db.Column(db.String(255))
time = db.Column(db.DateTime())

# Для получения доступа к связанным объектам
cats = db.relationship('Category', secondary=tasks_categories, backref=db.backref('tasks', lazy='dynamic'))

class Category(db.Model, RoleMixin):
__tablename__ = 'categories'
id = db.Column(db.Integer(), primary_key=True, unique=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
name = db.Column(db.String(255))

Если требуется в дальнейшем удалять одной командой все связанные данные, то в db.relationship надо добавить пару дополнительных свойств такого плана:

cats = db.relationship(
'Category',
secondary=tasks_categories,
backref=db.backref('task', lazy='dynamic'),
single_parent=True,
cascade="all, delete, delete-orphan"
)

Однако в данном примере это не подходит, иначе удалив задачу с привязанной к ней категорией, мы удалим эти категории из всех других задач в том числе.

Как сохранить данные

Пример ниже представляет из себя методы с роутом (через блюпринт). Она получает данные через метод POST. Затем эти данные сохраняются в БД и возвращаются обратно.

Внутри методов осуществляется сохранение задачи, категорий и связи с ними. Все основные моменты пояснены в первом методе.

Метод сохранения к задаче одной категории

# ploshadka.net
@task.route('/add-new-item/', methods=['POST'])
@login_required
def add_new_item():

# Данные с фронта
data = request.get_json()
name = data['name']
category = data['category']

# Текущий пользователь
user_id = flask_login.current_user.id

# Определим существование категории
c1 = db.session.query(Category).filter_by(user_id=user_id, name=category).first()

# Если категории нет, создадим её
if c1 is None:
c1 = Category(user_id=user_id, name=category)
db.session.add(c1)

# Используем flush, чтобы получить id категории, которая будет добавлена
db.session.flush()

# Добавим задачу
new_task = Task(user_id=user_id, name=name, time=datetime.now())

# Добавим связь
new_task.cats.append(c1)
db.session.add(new_task)

# Теперь сохраним все что выше в нашу базу данных
db.session.commit()

# Вернем обновленные данные обратно на фронт
return get_items()

Метод сохранения к задаче несколько категорий

В этом случае наш метод немного изменится. С фронта мы получаем список категорий через запятую. Формируем из этой строки список категорий. Проверяем каждую категорию на существование в базе данных. Затем или добавляем к задаче её или создаём и опять же добавляем к задаче.

# ploshadka.net
@task_bp.route('/add-new-item/', methods=['POST'])
@login_required
def add_new_item():
user_id = flask_login.current_user.id

# Получим данные с фронта
data = request.get_json()
name = data['name']
categories = data['categories']

# Добавим новую задачу
new_task = Task(user_id=user_id, name=name, time=datetime.now())

# Сделаем лист из нескольких категорий (разделим их по запятым)
categories = [x.strip() for x in categories.split(',')]

# Для каждой категории
for category_name in categories:

# Определим существует ли категория
category_in_db = db.session.query(Category).filter_by(user_id=user_id, name=category_name).first()

if category_in_db:
new_task.cats.append(category_in_db)
else:
c = Category(user_id=user_id, name=category_name)
db.session.add(c)
db.session.flush()
new_task.cats.append(c)

# Сохраним
db.session.add(new_task)
db.session.commit()

# Вернем обновленные данные
return get_items()

Как получить задачи по категориям

Мы должны в класс категорий:

class Category(db.Model, RoleMixin):
__tablename__ = 'categories'
id = db.Column(db.Integer(), primary_key=True, unique=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
name = db.Column(db.String(255))

добавить связь:

tasks = db.relationship(
'Task',
secondary=categories_task,
backref=db.backref('tasks', lazy='dynamic')
)

Теперь мы можем получать задачи по id категории так:

response = db.session.query(Category).filter_by(id=45).first().tasks

Ответ:

[<task 69>, <task 70>]

Получение сериализованных данных

Также эти данные можно получить сериализованными (обработанными).

Больше о серилизации данных можно узнать в статьях получение списков из SQLAlchemy и в примерах запросов на SQLAlchemy.

Запросим обработанные данные:

response = [x.serialize for x in db.session.query(Category).filter_by(id=45).first().tasks]

Для этого в метод Task (не перепутайте) надо добавить обработку:

@property
def serialize(self):
return {
'id': self.id,
'time': self.time.strftime('%H:%M'),
'time_min': self.time.strftime('%M'),
'time_hour': self.time.strftime('%H'),
'date': self.time.strftime('%Y-%m-%d'),
'name': self.name,
'cats': [x.get_name for x in self.cats]
}

Ответ будет таким:

[{'cats': [{'id': 45, 'name': 'солнце'}],
'date': '2021-02-19',
'id': 69,
'name': 'тест 1',
'time': '12:27',
'time_hour': '12',
'time_min': '27'},
{'cats': [{'id': 45, 'name': 'солнце'}],
'date': '2021-02-19',
'id': 70,
'name': 'тест 2',
'time': '12:28',
'time_hour': '12',
'time_min': '28'}]

Еще один пример выборки many to many

categories_task = db.Table(
'categories_task',
db.Column('task_id', db.Integer(), db.ForeignKey('task.id')),
db.Column('cat_id', db.Integer(), db.ForeignKey('categories.id'))
)

Вот как можно отобрать task-и из категорий:

def get_tasks_by_category(cat_id):

# Получим все task присоединенные к категориям
response = db.session.query(categories_task).filter_by(cat_id=cat_id).all()

# Затем по категориям отберем task
tasks = []
for x in response:
task = db.session.query(Task).filter_by(id=x.task_id).first().serialize
tasks.append(task)

return json.dumps(tasks)

Из участка выше, это:

tasks = []
for x in response:
task = db.session.query(Task).filter_by(id=x.task_id).first().serialize
tasks.append(task)

Можно также записать так:

# Сформируем основной запрос по tasks
query = db.session.query(Task).filter_by(user_id=user_id).order_by(db.desc(Task.time))

# Заберем все tasks с учетом параметров пагинации
tasks = [x.serialize for x in query.offset(offset).limit(limit)]

Python + Svelte — post и get запросы

Admin — Sat, 28 Nov 2020 21:52:09 +0000

Описание взаимодействия передачи информации от фронта к бэку через GET и POST на Svelte и Python.

GET

JavaScript

Функция получает домен в зависимости от окружения (локальный или лайв). Она пригодится нам в дальнейшем.

export function getDomain() {
let url = window.location.href.split("/");
let domain = url[0] + "//" + url[2] + '/';

if (url[2] === 'localhost') {
return domain + url[3];
}

return domain;
}

Основная функция для отправки запроса get. В ней же мы используем функцию выше для подстановки домена.

export async function getFetch(url) {
let response = await fetch(getDomain() + url);
return response.json();
}

Положим эти функции в файл main.js. Это общие функции, которые будут использоваться во всём проекте.

Svelte

На стороне Svelte мы импортируем функцию для запроса get из файла main:

import {getFetch} from '../main';

Дальше мы будем обращаться к этой функции, чтобы передать нужные нам значения. Например, таким образом:

function saveUsersData(deposit) {
getFetch('deposit/save-user-data/'
+ deposit.user_id_time + '/'
+ deposit.time + '/'
+ deposit.date + '/'
+ deposit.deposit
);
}

На том как сюда передаются значения останавливаться не будем. Эти данные передаются в функцию через события — об этом можно узнать в статье о событиях на Svelte.

Python

На стороне питона мы используем Flask и Blueprint и получаем данные так:

@deposit_bp.route('/save-user-data////', methods=['GET'])
@login_required
def save_user_data(user_id_time, time, date, deposit):
pass

Внутри этой функции полученные данные обрабатываете на своё усмотрение.

POST

JavaScript

Добавим в наш файл main.js функцию для отправки Post запросов:

export async function postFetch(url, data) {
let response = await fetch(getDomain() + url, {
method: 'POST',
headers: { "Content-Type": "application/json" },
body: JSON.stringify(data)
});
return response.json();
}

Svelte

Точно также импортируем функцию:

import {postFetch} from '../main';

Дальше мы её вызываем и передаём туда свои данные:

function saveUsersData(deposit) {
let data = {
'user_id_time': deposit.user_id_time,
'time': deposit.time,
'date': deposit.date,
'deposit': deposit.deposit,
'description': deposit.description
}

postFetch('deposit/save-user-data/', data);
}

Python

На python мы получаем эти данные так:

@deposit_bp.route('/save-user-data/', methods=['POST'])
@login_required
def save_user_data():
data = request.get_json()
description = data['description']
user_id_time = data['user_id_time']
time = data['time']
date = data['date']
deposit = data['deposit']

return json.dumps('ok')

Что-то делаем с ними и если нужно возвращаем обратно. В данном пример возвращаем всегда, потому что наша JS функция после отправки всегда ждет ответа.

SQLAlchemy — о проблемах с сессиями

Admin — Thu, 26 Nov 2020 08:00:00 +0000

SQLAlchemy, как и многие другие ОРМ работает с базой данных через сессии. Это отличается от работы на прямую с базой данных. Не понимания принципа работы сессий может приводить к надоедливым ошибкам.

Ошибки

sqlalchemy.orm.exc.DetachedInstanceError: Instance is not bound to a Session; attribute refresh operation cannot proceed (Background on this error at: http://sqlalche.me/e/13/bhk3)

«attribute refresh operation cannot proceed» % (state_str(state))
sqlalchemy.orm.exc.DetachedInstanceError: Instance is not bound to a Session; attribute refresh operation cannot proceed (Background on this error at: http://sqlalche.me/e/13/bhk3)

Как избежать ошибок на примере кода ниже, где все работает корректно:

def ploshadka_function(self):

# Положим в переменную все ID пользователей (чтобы потом работать с другой сессией)
user_ids = [x.id for x in db.session.query(User.id).distinct()]

for x_id in user_ids:
# Теперь мы можем работать с новой сессией
user = db.session.query(User).filter_by(id=x_id).first()

for setting in user.settings:
row = vars(setting)

if row['name'] == 'market_direction':
self.send_market_direction(user)

elif row['name'] == 'change_percent':
self.send_change_percent(user, row['percent'])

# Обновляем дату
db.session.query(UserSetting).filter_by(name=row['name']).update({'key': value})

# Коммитим все изменения после обработки одного пользователя
db.session.commit()

В этом коде могло быть 2 ошибки в пересечениях сессий.

1.
Если бы мы использовали db.session.commit() внутри второго цикла for, то SQLAlchemy закрыл бы сессию, посчитав, что задача выполнена.

Вместо этого мы обновляем методом update наш экземпляр класса User, созданный выше. А в самом конце делаем commit.

2.
Но db.session.commit() все еще внутри первого цикла и мы не можем вынести его за него. Поэтому мы кладем наверху ID пользователей в переменную user_ids. ID собраны отдельно и при закрытии сессии нам не страшно, что закроется сеанс.

Например, такой код при взаимодействии выше, вызвал бы ошибки с сессиями:

users = db.session.query(User).all()
for user in users:
settings = db.session.query(UserSetting).filter_by(user_id=user.id).all()

Это произошло бы из-за db.session.commit() внутри первого цикла for. После первого прохода в переменной users ничего бы не осталось. И во втором проходе возникла бы ошибка «Instance is not bound to a Session».

Python + Svelte — таблицы — как сравнить сумму с предыдущей и проставить цвета

Admin — Sat, 21 Nov 2020 22:40:01 +0000

У нас есть некая таблица с данными. В ней одна из колонок состоит из цифр. Мы хотим чтобы цвет следующего значения подкрашивался зеленым цветом, если оно больше предыдущего. И наоборот — красным, если меньше. Как это сделать ниже.

Введение

Пример участка готовой таблицы:

Все было бы очень просто, если бы список формировался от последнего к первому. В таком случае следующий элемент будет знать значение предыдущего.

У нас же наоборот — последний элемент по дате формируется первым в списке. И он ничего не знает о следующей строке, ведь она еще не создана.

Для решение этой проблемы на бэке мы позже добавим одну дополнительную колонку, в которой будет сохранено предыдущее значение.

Svelte

Функция, которая присваивает цвет:

let colour;
function compare(previousDeposit, currentDeposit) {
if (currentDeposit > previousDeposit) {
colour = 'green';
} else {
colour = 'red';
}

return colour;
}

В отдельной статье можно узнать как создать таблицу из данных массива на Svelte.

В одном из участков формировании таблицы, там где формируется сумма мы вызываем нашу функцию сравнения и передаем ей данные предыдущего и следующего значения, а возвращаем класс с цветом.

Про conteneditable (в этом задаче он не имеет значения) можно прочитать тут.

Python

На стороне бэкэнда мы забираем из БД данные отсортированные так, чтобы последняя запись по дате была первой.

В примере данные берутся с помощью SQLAlchemy. Останавливаться подробнее не будем. Нас интересуют в этой задаче другие участки.

def get_deposits(user_id):
response = [x.serialize for x in db.session.query(Budget).filter_by(user_id=user_id).order_by(db.desc(Budget.time)).all()]

# Заберем из списка тюплов данные из одной колонки
deposits = [i['deposit'] for i in response]

# Узнаем кол-во элементов чтобы пройтись меньше на 1 раз
length = len(deposits)

# Удалим первый элемент, он нам не нужен
deposits.pop(0)

# Добавим в наш список новую колонку
i = 0
for x in response:
i += 1
if length > i:
# Заберем первый элемент и удалим его из списка
x['previous_deposit'] = deposits.pop(0)

return response

Разберем подробнее.

Сначала мы получаем из БД данные такого формата:

[{'date': '2020-11-14',
'deposit': 71721,
'time': '00:58',
'user_id_time': '1_1605986079'},
{'date': '2020-10-30',
'deposit': 15890,
'time': '10:05',
'user_id_time': '1_1603985712'}]

Затем мы делаем ряд преобразований (в комментариях кода подробно все расписано) и получаем такой список тюплов:

[{'date': '2020-11-14',
'deposit': 71721,
'time': '00:58',
'previous_deposit': 15890,
'user_id_time': '1_1605986079'},
{'date': '2020-10-30',
'deposit': 15890,
'time': '10:05',
'previous_deposit': 17518,
'user_id_time': '1_1603985712'}]

Вот и все.

Простой случай

Если колонка отсортирована от первого к последнему.

Svelte

Python

А на питоне делать никаких лишних преобразований не нужно, кроме получения данные через asc.

response = [x.serialize for x in db.session.query(Budget).filter_by(user_id=user_id).order_by(db.asc(Budget.time)).all()]

Варианты запуска скрипта на сервере для python

Admin — Sun, 15 Nov 2020 20:02:52 +0000

Отдельный запуск команд с cli flask python.

Этот материал из цикла статей по разработке сайтов на python: от локальной разработки до развертывания на удаленном сервере.

Варианты запуска скипта на Flask

Предположим у нас есть такой код, который что-то обновляет:

# Flask CLI
@app.cli.command()
def update():
from app.updates.updates import start_updating
start_updating()

Для его запуска в командной строке ввести:

flask update

Эта команда запустит скрипт и выведет мониторинг этого процесса в командной строке:

Запустит в «тихом» режиме:

flask update >/dev/null

При запуске скрипта, покажет его PID, а также освободит командную строку для ввода следующей команды:

flask update >/dev/null &

Покажет:

[1] 37000

Цифра выше это номер процесса. Удобно его знать, если позже нужно завершить работу этого процесса вручную.

Варианты остановки скрипта на Flask

Как найти в системе запущенный скрипт python:

ps -ef | grep python

Как остановить скрипт

kill 37000

Остановит все скрипты с названием script_name_or_file_name:

pkill -9 -f script_name_or_file_name

Регистрация путей через Blueprint

Admin — Sun, 15 Nov 2020 20:01:33 +0000

Blueprint — упрощает организацию путей на Flask.

Упрощенный вид кода для работы сайта на Flask:

Стандартный Flask

from flask import Flask
app = Flask(__name__)
app.config.from_object('config.DevConfig')

# Website routes
@app.route('/')
def home():
return "Home"

# Admin pages
@app.route('/portfolio')
def portfolio_home():
return "portfolio Home"

if __name__ == "__main__":
app.run()

Отсюда нам интересны только роуты (route). Мы можем эти роуты вынести в отдельный файл. Это нормальная практика даже для небольшого проекта. Однако что делать, если роутов слишком много?

Для этих целей подходит распределение роутов через Blueprint.

Роуты через Blueprint

В файле app/__init__.py подключаем несколько файлов routes.py:

# Регистрация путей Blueprint
from app.routes import main_bp
app.register_blueprint(main_bp, url_prefix="/")

from app.admin.routes import admin_bp
app.register_blueprint(admin_bp, url_prefix="/admin")

Как видно выше, у нас два файла routes.py в двух директориях. Для главной страницы это файл app/routes.py. Для страницы админки это файл app/admin/routes.py.

app/routes.py

Содержимое файла:

import flask
from flask import Blueprint, render_template

main_bp = Blueprint('main_blueprint', __name__)

# Include main page
# Подключение главной страницы
@main_bp.route('/')
def portfolio_home_route():
# return 'Сайт работает.'
return flask.redirect("/admin/")
return render_template('/admin/index.html')

app/portfolio/routes.py

Содержимое файла:

portfolio_bp = Blueprint('portfolio', __name__)

# Получение списка всех названий когда-либо купленных акций
@portfolio_bp.route('/get-user/', methods=['GET'])
@login_required
def get_all_user_shares_route():
query = db.session.query(Portfolio.name).filter_by(user_id=flask_login.current_user.id)
shares = [x.name for x in query.all()]
return json.dumps(shares)

Flask — делаем авторизацию на сайте

Admin — Sat, 10 Oct 2020 12:25:57 +0000

Есть много способов построить авторизацию и административную часть (личный кабинет) на Flask. Некоторые предполагают самостоятельно все строить, другие имеют уже готовые концепции.

Статья входит в цикл статей по разработке на python.

Перед тем как приступить к этой статье следует сделать всё что описано в статье делаем приложение на Flask в локальной среде.

Введение

Нет особого смысла делать с нуля то, что уже было сделано и оттестировано другими. Мы пойдем по проторенной дорожке и выберем готовые ингредиенты, которые останется только правильно смешать.

Flask — это микрофреймворк, что предполагает создание проекта по модулям.

Ниже мы построим личный кабинет с авторизацией.

Установка расширений

Flask-Login — расширение, которое обеспечит управление пользовательскими сеансами во Flask. Благодаря этому мы сможем входить и выходить из системы, ограничивать страницы авторизацией.

pip install Flask-Login

Flask-Admin — с помощью этого расширения мы сможем создать личный кабинет на подобии того, что есть в Django.

pip install Flask-Admin

Flask-WTF — расширение для Flask, являющееся оберткой WTForms, с помощью которого можно строить безопасные формы.

Также установим здесь email_validator, библиотеку для проверки эмейлов.

pip install Flask-WTF
pip install email_validator

Flask-Security — разделение пользователей на роли.

pip install Flask-Security

Создаем модели для базы данных

Создаем файл:
app/models.py

Внутри которого пишем:

from datetime import datetime
from flask_login import UserMixin
from flask_security import RoleMixin
from app import db, login_manager
from werkzeug.security import generate_password_hash, check_password_hash

roles_users = db.Table(
'roles_users',
db.Column('user_id', db.Integer(), db.ForeignKey('users.id')),
db.Column('role_id', db.Integer(), db.ForeignKey('roles.id'))
)

class Role(db.Model, RoleMixin):
__tablename__ = 'roles'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))

def __str__(self):
return self.name

class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, unique=True, primary_key=True)
name = db.Column(db.String)
username = db.Column(db.String, unique=True)
email = db.Column(db.String, unique=True)
password = db.Column(db.String)
created_on = db.Column(db.DateTime(), default=datetime.utcnow)
updated_on = db.Column(db.DateTime(), default=datetime.utcnow, onupdate=datetime.utcnow)
# Нужен для security!
active = db.Column(db.Boolean())
# Для получения доступа к связанным объектам
roles = db.relationship('Role', secondary=roles_users, backref=db.backref('users', lazy='dynamic'))

# Flask - Login
@property
def is_authenticated(self):
return True

@property
def is_active(self):
return True

@property
def is_anonymous(self):
return False

# Flask-Security
def has_role(self, *args):
return set(args).issubset({role.name for role in self.roles})

def get_id(self):
return self.id

# Required for administrative interface
def __unicode__(self):
return self.username

def set_password(self, password):
self.password = generate_password_hash(password)

def check_password(self, password):
return check_password_hash(self.password, password)

# Отвечает за сессию пользователей. Запрещает доступ к роутам, перед которыми указано @login_required
@login_manager.user_loader
def load_user(user_id):
return db.session.query(User).get(user_id)

Разберем код.

class Role — класс ролей связанная с таблицей roles.
class User — класс пользователей связанный с таблицей users.
roles_users = db.Table — создание связей между этими двумя таблицами, значение которых будет записываться в новую таблицу roles_users.

@property в виде is_authenticated, is_active, is_anonymous нужны будут для определения авторизованных, активных и анонимных пользователей.

@login_required — пригодится позже для разделения показа страниц на авторизованных и не авторизованных пользователей.

Другие дополнительные участки кода тоже пригодятся или могут пригодиться в дальнейшем.

Запускаем миграцию этих таблиц:

flask db init
flask db migrate -m "Initial migration."
flask db upgrade

На этом этапе скорее всего покажет ошибку, что бд нет. В этом случае команды миграции можно пропустить. Мы их запустим когда будем создавать базу данных.

Подробнее о миграции таблиц в SQLAlchemy.

Добавляем модуль admin

Создаём директорию admin в директории app со следующими файлами:

Содержимое файла __init__.py:

from app import db, app
from flask import url_for, redirect, request, abort
from app.models import User, Role

# flask-login
from flask_login import current_user
import flask_login as login

# flask-security
from flask_security import SQLAlchemyUserDatastore, Security

# flask-admin
import flask_admin
from flask_admin import helpers, expose
from flask_admin.contrib import sqla

# Setup Flask-Security
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
security = Security(app, user_datastore)

# Create customized model view class
class MyModelView(sqla.ModelView):

def is_accessible(self):
return (current_user.is_active and
current_user.is_authenticated and
current_user.has_role('admin')
)

def _handle_view(self, name, **kwargs):
"""
Override builtin _handle_view in order to redirect users when a view is not accessible.
"""
if not self.is_accessible():
if current_user.is_authenticated:
# permission denied
abort(403)
else:
return redirect(url_for('security.login', next=request.url))

# Переадресация страниц (используется в шаблонах)
class MyAdminIndexView(flask_admin.AdminIndexView):
@expose('/')
def index(self):
if not current_user.is_authenticated:
return redirect(url_for('.login_page'))
return super(MyAdminIndexView, self).index()

@expose('/login/', methods=('GET', 'POST'))
def login_page(self):
if current_user.is_authenticated:
return redirect(url_for('.index'))
return super(MyAdminIndexView, self).index()

@expose('/logout/')
def logout_page(self):
login.logout_user()
return redirect(url_for('.index'))

@expose('/reset/')
def reset_page(self):
return redirect(url_for('.index'))

# Create admin
admin = flask_admin.Admin(app, index_view=MyAdminIndexView(), base_template='admin/master-extended.html')

# Add view
admin.add_view(MyModelView(User, db.session))

# define a context processor for merging flask-admin's template context into the
# flask-security views.
@security.context_processor
def security_context_processor():
return dict(
admin_base_template=admin.base_template,
admin_view=admin.index_view,
h=helpers,
get_url=url_for
)

Создаем шаблоны для административной части

templates/admin

Создаем внутри директории templates директорию admin. В этой директории добавляем файлы.

master-extended.html

Файлом master-extended.html мы расширяем админ панель. В конкретно данном случае добавляем кнопку выхода на админ панель справа:

Содержимое файла:

{% extends 'admin/base.html' %}
{% block access_control %}

{% if current_user.is_authenticated %}
<div class="btn-group pull-right">
<a class="btn" href="{{ url_for('admin.logout_page') }}">{{ current_user.username }} - Log out</a>
</div>
{% endif %}
{% endblock %}

index.html

Файл index.html у нас выступит формой входа:

Содержимое файла может быть таким:

{% extends 'admin/master.html' %}
{% block body %}
{{ super() }}
<div class="row-fluid">

<div>
{% if current_user.is_authenticated %}
<div>
<h2>Logged in User details</h2>
<ul>
<li>Username: {{ current_user.username }}</li>
<li>Email: {{ current_user.email }}</li>
<li>Created on: {{ current_user.created_on }}</li>
<li>Updated on: {{ current_user.updated_on }}</li>
</ul>

<h2>Основные ваши настройки</h2>
<p class="lead">Вы можете:</p>
<p><a href="/admin/change/">Изменить пароль</a></p>
</div>

{% else %}
<form method="POST" action="">
{{ form.hidden_tag() if form.hidden_tag }}
{% for f in form if f.type != 'CSRFTokenField' %}
<div>
{{ f.label }}
{{ f }}
{% if f.errors %}
<ul>
{% for e in f.errors %}
<li>{{ e }}</li>
{% endfor %}
</ul>
{% endif %}
</div>
{% endfor %}
<button class="btn" type="submit">Submit</button>
</form>
{{ link | safe }}
{% endif %}
</div>

</div>
{% endblock body %}

templates/security

Когда было установлено расширение Flask-Security в директории templates появилась директория security, а в ней следующие файлы:

Файлы могли и не появиться после установки. Тогда их можно перенести вручную. Путь указан ниже.

Подробно на них останавливаться не будем. Скажу лишь, что эти файлы переопределяют шаблоны расширения Flask-Security.

Шаблоны, которые они расширяют находятся здесь:

/venv/lib/python3.8/site-packages/flask_security/templates/security

Если какой-то из шаблонов хочется поменять, его нужно скопировать оттуда к себе в директорию security. И дальше можно его менять.

Config

Для того, чтобы все работало нам нужно добавить данные в файл конфига config-extended. К этому моменты вы должны были ознакомиться с конфигурационными файлами Flask.

Содержимое конфига:

################
# Flask-Security
################

# URLs
SECURITY_URL_PREFIX = "/admin"
SECURITY_LOGIN_URL = "/login/"
SECURITY_LOGOUT_URL = "/logout/"
SECURITY_POST_LOGIN_VIEW = "/admin/"
SECURITY_POST_LOGOUT_VIEW = "/admin/"
SECURITY_POST_REGISTER_VIEW = "/admin/"

# Включает регистрацию
SECURITY_REGISTERABLE = True
SECURITY_REGISTER_URL = "/register/"
SECURITY_SEND_REGISTER_EMAIL = False

# Включет сброс пароля
SECURITY_RECOVERABLE = True
SECURITY_RESET_URL = "/reset/"
SECURITY_SEND_PASSWORD_RESET_EMAIL = True

# Включает изменение пароля
SECURITY_CHANGEABLE = True
SECURITY_CHANGE_URL = "/change/"
SECURITY_SEND_PASSWORD_CHANGE_EMAIL = False

С другими директивами можно ознакомиться в официальном источнике.

Blueprint

Последнее что нам нужно сделать для работы админки добавить регистрацию путей через Blueprint. Зачем нужен Blueprint и его настройка.

В файл app/__init__.py нужно добавить:

# Регистрация путей Blueprint
from app.admin.routes import admin_bp
app.register_blueprint(admin_bp, url_prefix="/admin")

Может быть вы обратили внимание, что на скрине выше в модуле admin есть файл routes.py.

Если мы строим большой и расширяемый проект, то у нас в каждом модуле, где требуются роуты, будет свой файл routes.py с путями.

В файл routes.py надо добавить:

from flask import Blueprint
admin_bp = Blueprint('admin_blueprint', __name__)

В этом файле на текущий момент больше ничего не нужно. Все наши роуты для админки прописаны в файле admin/__init__.py там где класс class MyAdminIndexView, но именно потому что они идут немного в другом формате и переплетены с функционалом. Чтобы все не усложнять мы оставим как есть, но практику применения роутов добавим.

Вход в админку

Теперь у нас есть админка. Заходим по адресу:

http://127.0.0.1:5000/admin/login/

Регистрируемся на свой эмейл и заходим внутрь. Наша админка выглядит так (пока видны не все вкладки, мы дадим доступ к ним ниже):

Отдельные вкладки для неё мы можем добавлять в файле __init__.py. Например, вот как мы можем добавить новую вкладку для работы с таблицей UserSetting в базе данных (предварительно для неё должна быть создана модель в файле models.py, по инструкции выше):

# Add view
admin.add_view(MyModelView(User, db.session))
admin.add_view(MyModelView(UserSetting, db.session))

Добавим роли для админки. Заходим к себе в БД. Как зайти в локальную ДБ через DataGrip или соединяемся удаленно с базой данных.

В таблице role добавим данные:

И добавим нашему пользователю роль администратора в таблице roles_users:

Flask — конфигурационные файлы

Admin — Sat, 10 Oct 2020 07:57:38 +0000

Несколько способов использования различных конфигураций настроек сервера для Flask.

Вариант 1: как в официальной доке

С советами в официальной части можно ознакомиться здесь.

В официальной инструкции, помимо прочего, дают рекомендации делать через смену конфигураций:

def create_app():
app = Flask(__name__)

# app.config.from_object('config.DevelopmentConfig')
app.config.from_object('config.ProductionConfig')

return app

Минус такого подхода в заливке. Перед отправкой изменений на сервер придется постоянно комментировать/раскомментировать код.

Вариант 2: делим конфиги на две части

Разделить конфиги на 2 части:

def create_app():
app = Flask(__name__)

app.config.from_object(Config)
app.config.from_pyfile('../config-extended.py')

return app

ploshadka.net/config.py — этот файл нужно создать самостоятельно на сервере, потому что там важная секретная информация. И такой же создаем у себя на локальном компьютере. А если нужно, также и на тестовом.

ploshadka.net/config-extended.py — этот файл будет у нас отправляться в git и здесь ничего важного с точки зрения безопасности.

Теперь в зависимости от нахождения кода будет подтягиваться разная конфигурация сервера.

Содержимое файла config.py может быть таким:

import os

class Config(object):
DEBUG = True
SECRET_KEY = os.environ.get('SECRET_KEY') or 'fsdkfd32r234fsdf'
SQLALCHEMY_DATABASE_URI = 'postgresql://localhost/db_name'

################
# Flask-Security
################

SECURITY_PASSWORD_HASH = "pbkdf2_sha512"
SECURITY_PASSWORD_SALT = "fsdfdfsdfdfsdafds"

На сервере тот же файл:

import os

class Config(object):
DEBUG = False
SECRET_KEY = os.environ.get('SECRET_KEY') or 'fsDFKsmf923jnagd'
SQLALCHEMY_DATABASE_URI = 'postgresql://user:pass/db_name'
SQLALCHEMY_TRACK_MODIFICATIONS = False

################
# Flask-Security
################

SECURITY_PASSWORD_HASH = "pbkdf2_sha512"
SECURITY_PASSWORD_SALT = "fsdfk3fsdDFFdfsr0fsa"

Следует отметить, что такие данные как SECRET_KEY, SECURITY_PASSWORD_SALT или другие подобные можно еще более безопасно хранить в переменных окружения. Но это тема отдельной статьи и тут разбираться не будет.

Содержимое файла config-extended.py может быть таким:

##########
# Features
##########

SQLALCHEMY_TRACK_MODIFICATIONS = False

################
# Flask-Security
# https://pythonhosted.org/Flask-Security/configuration.html
################

# URLs
SECURITY_URL_PREFIX = "/admin"
SECURITY_LOGIN_URL = "/login/"
SECURITY_LOGOUT_URL = "/logout/"
SECURITY_POST_LOGIN_VIEW = "/admin/"
SECURITY_POST_LOGOUT_VIEW = "/admin/"
SECURITY_POST_REGISTER_VIEW = "/admin/"

# Включает регистрацию
SECURITY_REGISTERABLE = True
SECURITY_REGISTER_URL = "/register/"
SECURITY_SEND_REGISTER_EMAIL = False

# Включет сброс пароля
SECURITY_RECOVERABLE = True
SECURITY_RESET_URL = "/reset/"
SECURITY_SEND_PASSWORD_RESET_EMAIL = True

# Включает изменение пароля
SECURITY_CHANGEABLE = True
SECURITY_CHANGE_URL = "/change/"
SECURITY_SEND_PASSWORD_CHANGE_EMAIL = False

# todo не работает отправка email
# AttributeError: 'NoneType' object has no attribute 'send'

Вариант 3: разделяем конфиги на много частей

С расширением проекта увеличивается кол-во конфигов. Для порядка выносим все конфиги в отдельную директорию configs. В поддиректории private храним конфиги в которых содержимое отличается от продакшена и локальной разработки. Эти конфиги добавляем в файл .gitignore и вручную создаем на сервере.

def create_app():
app = Flask(__name__)
app.config.from_pyfile('../configs/private/main.py')
app.config.from_pyfile('../configs/private/celery.py')
app.config.from_pyfile('../configs/sqlalchemy.py')
app.config.from_pyfile('../configs/flask-security.py')
app.config.from_pyfile('../configs/beatschedule.py')
return app