Pyramid программный каркас: Pyramid для Людей — часть 2 / Хабр

Pyramid для Людей — часть 2 / Хабр

Часть 1 — предисловие и содержание.

Сценарий

Pyramid превосходен в построении веб-приложений несколькими способами. Также как и Pylons, до его появления, Pyramid может строить традиционные маршрут-ориентированные(routes-oriented) RDBMS приложения, используя SQLAlchemy. В отличии от других, основанных на RDBMS, веб-фреймворков, Pyramid к тому же очень хорошо оснащен, чтобы легко строить контент-ориентированные приложения, знакомые из мира Plone и Zope.

Поскольку это пособие для Plone конференции, мы выбрали сценарий представления, который показывает сильные стороны Pyramid в контент-ориентированных приложениях. Если точнее — иерархическая система управления проектами, где вы можете ставить задачи командам.

По ходу изучения этого пособия, мы будем создавать приложение под названием Projector.

Как устанавливать

В этом пособии предполагается, что у вас уже установлен Python 2.6 и выше, у вас есть соединение с интернетом, и текстовый редактор по вашим предпочтениям. Этого достаточно, чтобы вы начали с первого шага. Другие шаги могут потребовать установки дополнительных пакетов.

Примечание по тексту: Windows-пользователям нужно адаптировать UNIX-измы, чтобы это соответствовало вашему рабочему окружению.

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

someworkingdirectory/

  tutorial_workspace/

    venv ### Target for our virtualenv

    creatingux/

        step01

        step02

        etc.

    resources

      step01

      step02

    etc.

  etc.

Шаги

Открываем shell и заходим в нем в рабочую директорию

• $ mkdir tutorial_workspace; cd tutorial_workspace
• $ virtualenv —no-site-packages venv
• $ export PATH=/путь/до/tutorial_workspace/venv/bin:$PATH
• $ which easy_install

должно вывести что-то вроде:
/home/ks/projects/tutorial_workspace/venv/bin/easy_install

• $ easy_install pyramid WebTest nose
• $ export PYRAMID_RELOAD_TEMPLATES=1

Примеры кода

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

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

Создание простого UX для Pyramid

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

Цели

• Простейшая из возможных демонстрация Pyramid
• Использование unit-тестов и WebTest, для ускорения разработки
• Шаблонизация с Chameleon и ZPT
• Использование макросов и “схем”(layouts), для продуктивности работы шаблонов
• Статические ресурсы
• AJAX через JSON рендерер(renderer)

Рабочий поток

У многих проектов есть неизменный рабочий поток, который начинается с клиента, кто обычно хочет увидеть что-то, чтобы понять и утвердить. Обычно «UI персона» в команде работает на данном этапе, получая рабочий прототип на месте, и тогда логика считается заполненной.

Это пособие моделирует такой рабочий процесс. В этой первой части мы покажем, как человек, без глубоких знаний Pyramid архитектуры, может создавать работающие прототипы различных видов, в Projector’е.

Шаг 01: Hello World в Pyramid

Какой простейший путь начать в Pyramid? Отдельный-файл модуль. Без пакетов, импортов, setup.py и другого подобного.

Цели

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

Технические требования

• Создать модуль с видом(view), чтобы он действовал как HTTP-сервер
• Посетить URL в своем браузере

Предпосылки

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

Pyramid особенный потому что он может действовать как отдельный файл-микрофреймворк. У вас есть простой Python файл который может быть исполнен напрямую через Python. Но Pyramid также масштабируется до громадных приложений.

Шаги

Убедитесь, что вы сделали все, как сказано здесь.
И поехали дальше:
$ mkdir creatingux; cd creatingux

$ mkdir step01; cd step01
Копируем текст ниже во вновь создаваемый файл step01/application.py:

from wsgiref.simple_server import make_server

from pyramid.config import Configurator
from pyramid.response import Response

# This acts as the view function
def hello_world(request):

    return Response(‘hello!’)

def main():

    # Grab the config, add a view, and make a WSGI app

    config = Configurator()

    config.add_view(hello_world)

    app = config.make_wsgi_app()

    return app

if __name__ == ‘__main__’:

    # When run from command line, launch a WSGI server and app

    app = main()

    server = make_server(‘0.0.0.0’, 8080, app)

    server.serve_forever()

$ python application.py
Открываем 127.0.0.1:8080 в браузере, смотрим, радуемся.

Дополнительные вопросы

• Что случится, если если вы вернете строку of HTML? Последовательность of integers?
• Поставьте что-нибудь неправильное, такое как print xyz, в view функцию. Убейте ваше python приложение и перезапустите, потом обновите браузер. Какое исключение в консоли?
• Поддерживает ли Pyramid автоматическое обновление Python кода?

Анализ

Этот простой модуль делает совсем немного, для нескольких строк кода, таким образом создание веб-приложения по духу схоже с микрофреймворками. Функция представления добавлена к конфигурации. При вызове, представление возвращает ответ.

Пояснения

Предпосылки к мегафреймворкам, микрофреймворкам и Pyramid основаны на этом.

Часть 3:

Pyramid для Людей — оглавление / Хабр

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

Pyramid появился как быстрый, современный, web-фреймворк, для Pylons и Zope сообществ. Когда вам нужно только веб-приложение, а не полноценная CMS, Pyramid дает вам возможность сохранить большинство похожих на Plone технологий, или собрать проект на скорую руку.

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

На подходе к основной части

Методичка собрана, по основным разделам. Начинается с создания UI\UX(прим.перевод.UI — англ. user interface; UX — User eXperience) для чайников. Каждая основная область состоит из последовательности шагов, в которых есть очень небольшое количество определений. Рабочий код понемногу накапливается.

Как описано в сценарии, простое приложение это система управления проектом, для большого количества компаний, которые ведут множество проектов. Мы выбрали traversal и ZODB как начальную архитектуру, для этого пособия.

Оглавление

Общее описание(сценарий)
Как устанавливать

    Шаги

    Примеры кода
Создаем простой UX для Pyramid

    Цели

    Наш рабочий поток(The Workflow)

    Содержание

        Step 01: Hello World в Pyramid

        Step 02: Юнит- и Функциональное тестирование

        Step 03: Hello World в Chameleon

        Step 04: Каркас представлений

        Step 05: Создание основного шаблона

        Step 06: Классы представлений

        Step 07: Макеты(Layouts)

        Step 08: CSS и JS со Static активами(Assets)

        Step 09: AJAX с JSON представлениями

        Step 10: Повторно используемый макрос шаблона

Ресурсы(Resources), Иерархии(Hierarchies), и Traversal

    Цели

    Содержание

        Step 01: Стартовая страница: корень сайта(Site Root)

        Step 02: Базовая иерархия для Traversal

        Step 03: Определенные типом(Type-Specific) представления

        Step 04: Создание базового контента

        Step 05: Projector с ресурсами(Resources)

Формы и Схемы с Deform и Colander

    Цели

    Содержание

        Step 01: Hello World с Deform

        Step 02: Обработка форм

Далее по-списку

Следующие разделы все ещё нуждаются в переработке после получения обратной связи от конференции:

Безопасность в Pyramid

    Содержание

        Step 01: Hello World для ACLs

        Step 02: Вход(Login) и выход(Logout)

Хранение контента в ZODB

    Цели

    Предустановки

    Шаги

    Дополнительные задания

    Анализ

    Обсуждение

Используем repoze.catalog

    Цели

    Предустановки

    Шаги

    Дополнительные задания

    Анализ

        resources.py

        views.py

    Обсуждение

Pyramid (программный каркас) 🎓²

У этого термина существуют и другие значения, см. Pyramid.

Pyramid (англ. pyramid — пирамида) — программный каркас (фреймворк) для разработки веб-приложений с открытым исходным кодом, написанный на языке Python в рамках проекта Pylons^[1]

.

На создание Pyramid оказали влияние такие фреймворки, как Zope, Pylons и Django. Код Pyramid разрабатывался в проекте repoze.bfg, а название поменялось в результате слияния проектов BFG и Pylons.^[2]

Дизайн Pyramid основан на следующих принципах^[3]

:

В защиту своего дизайна авторы Pyramid написали довольно большой документ, который призван развеять мифы о фреймворке. Например, на критику модели MVC в Pyramid следует подробное объяснение, что MVC «притянут за уши» к веб-приложениям. Следующая цитата^[4] хорошо характеризует подход к терминологии в Pyramid

:

Основными «изюминками» Pyramid являются^[3]

:

Хотя не составляет большой трудности написать Pyramid-приложение (проект) с нуля, Pyramid имеет инструменты для инициализации кода нового приложения по выбранному шаблону, или, в терминологии Pyramid, каркасной структуре (англ. scaffolds^[6]). Например, в поставке имеются каркасные структуры для проектов, использующих ZODB или SQLAlchemy

.

Проект — это каталог, содержащий по крайней мере один пакет на Python

.

Типичная структура каталога для небольшого проекта

:

MyProject/
|-- CHANGES.txt
|-- development.ini
|-- MANIFEST.in
|-- myproject
|   |-- __init__.py
|   |-- static
|   |   |-- favicon.ico
|   |   |-- logo.png
|   |   `-- pylons.css
|   |-- templates
|   |   `-- mytemplate.pt
|   |-- tests.py
|   `-- views.py
|-- production.ini
|-- README.txt
|-- setup.cfg
`-- setup.py

Приведённую структуру, как следует из документации, не следует сильно изменять, так как это может помешать другим разработчикам быстро ориентироваться в коде проекта^[7]. Тем не менее, растущий проект может потребовать некоторых изменений. Например, виды, модели (если они используются) и тесты можно, разбив на модули, перенести соответственно в подкаталоги views, models и tests (не забыв снадбить их файлом __init__.py

).

Проект может, Например, находиться в составе buildout (скажем, в каталоге src), который собирает все необходимые компоненты вместе. Совсем необязательно, чтобы Pyramid-проект состоял из одного пакета. Величина проекта ограничивается только достаточностью знаний разработчиков о возможностях Pyramid^[8]

.

Следует отметить, что Pyramid может работать с любым WSGI-сервером. Проекты, созданные по готовым каркасным структурам, используют сервер Waitress

.

Каждый поступающий на сервер приложений Pyramid запрос (request) должен найти вид (view), который и будет его обрабатывать

.

В Pyramid имеется два базовых подхода к поиску нужного вида для обрабатываемого запроса: на основе сопоставления (matching), как в большинстве подобных фреймворков, и обхода (traversal), как в Zope. Кроме того, в одном приложении можно с успехом сочетать оба подхода

.

Простейший пример с заданием маршрута (заимствован из документации

):

# Здесь config - экземпляр pyramid.config.Configurator
config.add_route('idea', 'site/{id}')
config.add_view('mypackage.views.site_view', route_name='idea'

)

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

:

from wsgiref.simple_server import make_server
from pyramid.config import Configurator
from pyramid.response import Response
 
# Класс некоторого ресурса
class Resource(dict):
    pass
 
# Дерево ресурсов (жёстко закодированное) в фабрике корня
def get_root(request):
    return Resource({'a': Resource({'b': Resource({'c': Resource()})})})
 
# Вид-для-вызова, который умеет показывать ресурс Resource (в context)
def hello_world_of_resources(context, request):
    output = "Ресурс и его дети: %s" % context
    return Response(output)
 
if __name__ == '__main__':
    config = Configurator(root_factory=get_root)
    config.add_view(hello_world_of_resources, context=Resource)
    app = config.make_wsgi_app()
    server = make_server('0.0.0.0', 8080, app)
    server.serve_forever(

)

В этом примере иерархия для обхода жестко задана в методе get_root с помощью вложенных словарей, тогда как реальные приложения должны сами определять необходимый доступ по ключам (метод __getitem__ помогает организовать такой доступ). В коде также присутствует корневая фабрика, с которой собственно и начинается обход узлов (node) дерева ресурсов. Вид-для-вызова (view callable) представлен функцией hello_world_of_resources. Говоря несколько упрощённо, на основе URL запроса в результате обхода иерархии Pyramid находит ресурс и применяет к нему «наилучший» вид-для-вызова (в нашем примере — он единственный).^[9]

Конфигурирование приложения, то есть, задание настроек, влияющих на его работу, может осуществляться в Pyramid двумя способами: императивным и декларативным

.

Императивное конфигурирование производится вызовами методов конфигуратора непосредственно перед стартом приложения

.

Декларативное конфигурирование задается декораторами видов. Перед запуском приложение «сканируется» на предмет конфигурационных параметров методом scan() конфигуратора. Пример из документации

:

Оба метода конфигурирования полностью взаимозаменяемы.^[10]

Желающие могут использовать для конфигурирования ZCML, установив соответствующий пакет

.

В Pyramid можно использовать различные движки для генерации HTML. Так, Chameleon и Mako входят в поставку.^[11] Кроме них, можно подключить и другие, Например, Jinja2

.

Работа с формами может осуществляться, Например, с помощью троицы Peppercorn-Colander-Deform

.

Одно из наиболее простых приложений для Pyramid^[12]

:

Каркас пирамиды — CoderLessons.com

Pyramid — это общая среда разработки веб-приложений с открытым исходным кодом, построенная на python. Это позволяет разработчику Python создавать веб-приложения с легкостью.

Пирамида поддерживается Системой управления знаниями предприятия KARL (проект Джорджа Сороса).

Установка, запуск и настройка

Как уже говорилось, «начните с малого, закончите с большим, оставайтесь законченным фреймворком», Pyramid очень похожа на Flask, который требует очень мало усилий для установки и запуска. Фактически, вы поймете, что некоторые шаблоны похожи на Flask, как только вы начнете создавать это приложение.

Ниже приведены шаги по созданию среды фреймворка пирамиды —

• Сначала создайте каталог проекта. Здесь мы создали каталог с именем pyramidProject (вы можете выбрать любое имя).

• Затем создайте виртуальную среду, в которую вы будете устанавливать все специфичные для проекта зависимости. Здесь мы создали папку виртуальной среды с именем pyramidEnv, в которой установлена ​​Pyramid.

• Затем перейдите в каталог pyramidEnv и установите пирамиду с помощью pip install pyramid .

Сначала создайте каталог проекта. Здесь мы создали каталог с именем pyramidProject (вы можете выбрать любое имя).

Затем создайте виртуальную среду, в которую вы будете устанавливать все специфичные для проекта зависимости. Здесь мы создали папку виртуальной среды с именем pyramidEnv, в которой установлена ​​Pyramid.

Затем перейдите в каталог pyramidEnv и установите пирамиду с помощью pip install pyramid .

Как только все будет сделано, как указано выше, ваша структура каталогов будет такой, как показано ниже —

И версия пирамиды, установленная в системе, приведена ниже —

Основные понятия

Структура Pyramid основана на следующих основных концепциях —

• Zope (расширяемость, обход, декларативная безопасность) — Pyramid свободно основана на Zope с точки зрения расширяемости, концепции обхода и декларативной безопасности.

• Пилоны (отправка URL-адресов, неуверенный взгляд на постоянство, создание шаблонов и т. Д.). Еще одна область, из которой пирамида строит свою концепцию, — это проект пилонов. У Pylons есть такая концепция маршрутов, которая вызывает диспетчеризацию URL-адресов внутри структуры пирамиды, и они также имеют неубежденное представление о уровне персистентности или шаблонах.

• Джанго (Вид, уровень документации) — Пирамида также получает подсказку от Джанго. То, как мы воспринимаем наше мнение, перенаправляет наш URL и уровень документации очень похож на Django.

Zope (расширяемость, обход, декларативная безопасность) — Pyramid свободно основана на Zope с точки зрения расширяемости, концепции обхода и декларативной безопасности.

Пилоны (отправка URL-адресов, неуверенный взгляд на постоянство, создание шаблонов и т. Д.). Еще одна область, из которой пирамида строит свою концепцию, — это проект пилонов. У Pylons есть такая концепция маршрутов, которая вызывает диспетчеризацию URL-адресов внутри структуры пирамиды, и они также имеют неубежденное представление о уровне персистентности или шаблонах.

Джанго (Вид, уровень документации) — Пирамида также получает подсказку от Джанго. То, как мы воспринимаем наше мнение, перенаправляет наш URL и уровень документации очень похож на Django.

Ниже приведены особенности фреймворка Pyramid —

• Это самый быстрый из известных веб-фреймворков Python.

• Он поддерживает малые и большие проекты (зачем переписывать, когда вы перерастаете свой маленький фреймворк).

• Он поддерживает однофайловые веб-приложения, такие как микрофреймы.

• Он имеет встроенные сессии.

• Поддерживаются события, похожие на Plone / Zope.

• Он обеспечивает управление транзакциями (если уже заметил, что мы использовали Zope раньше).

Это самый быстрый из известных веб-фреймворков Python.

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

Он поддерживает однофайловые веб-приложения, такие как микрофреймы.

Он имеет встроенные сессии.

Поддерживаются события, похожие на Plone / Zope.

Он обеспечивает управление транзакциями (если уже заметил, что мы использовали Zope раньше).

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

Конфигурация — это настройки, которые влияют на работу приложения. Существует два способа настройки приложения-пирамиды: императивная конфигурация и декларативная конфигурация.

Конфигурация пирамиды поддерживает —

• Настраиваемая конфигурация или даже переопределение конфигов на основе декоратора

• Обнаружение конфликта конфигурации (включая более локальное или меньшее локальное определение)

• Расширяемость конфигурации (включена из нескольких приложений)

• Гибкая политика аутентификации и авторизации

• Программный анализ конфигурации (просмотр текущего состояния маршрутов для генерации навигации)

Настраиваемая конфигурация или даже переопределение конфигов на основе декоратора

Обнаружение конфликта конфигурации (включая более локальное или меньшее локальное определение)

Расширяемость конфигурации (включена из нескольких приложений)

Гибкая политика аутентификации и авторизации

Программный анализ конфигурации (просмотр текущего состояния маршрутов для генерации навигации)

Генерация URL

В пирамиде мы можем генерировать URL для маршрутов, ресурсов и статических ресурсов. Работать с API генерации URL легко и гибко. Создавая URL-адреса с помощью различных API-интерфейсов пирамиды, пользователи могут произвольно изменять конфигурацию, не беспокоясь о разрыве ссылки на любую из ваших веб-страниц.

Короче говоря, URL в пирамиде —

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

• генерирует URL-адреса статических ресурсов, которые находятся внутри или вне приложения.

• поддерживает маршруты и обход.

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

генерирует URL-адреса статических ресурсов, которые находятся внутри или вне приложения.

поддерживает маршруты и обход.

Просмотры

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

Когда вы отображаете ваши взгляды на ваш URL-адрес или код Python, может быть любой вид вызова. Представления могут быть объявлением функции или экземпляром, его можно использовать как представление в пирамиде.

Некоторые важные моменты о взглядах приведены ниже —

• Представления генерируются из любого вызываемого.

• Представления на основе рендерера могут просто возвращать словари (не требуется возвращать объект стиля webby).

• Поддержка нескольких представлений на маршрут (проверка GET против POST против HTTP-заголовка и т. Д.).

• Просмотр адаптеров ответа (когда вы хотите указать, как представления должны обрабатывать возвращаемые значения по сравнению с объектами ответа).

Представления генерируются из любого вызываемого.

Представления на основе рендерера могут просто возвращать словари (не требуется возвращать объект стиля webby).

Поддержка нескольких представлений на маршрут (проверка GET против POST против HTTP-заголовка и т. Д.).

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

растяжимость

Пирамида разработана с учетом расширяемости. Поэтому, если разработчик пирамиды учитывает определенные ограничения при создании приложения, третья сторона должна иметь возможность изменять поведение приложения без необходимости изменять его исходный код. Поведение приложения-пирамиды, которое подчиняется определенным ограничениям, может быть изменено или расширено без каких-либо изменений. Он предназначен для гибкого развертывания в нескольких средах (без синглетонов). Pyramid имеет поддержку промежуточного программного обеспечения «Tweens» (промежуточное программное обеспечение WSGI, но работает в контексте самой Pyramid).

Запуск программы Hello, Pyramid

Простейшая программа, которую мы можем подумать после установки каркаса пирамиды, чтобы проверить, все ли работает нормально, — это запустить простую программу «Hello, World» или «Hello, Pyramid».

Ниже моя пирамида «Привет, пирамида», программа с номером порта 8000 —

Выше простой пример легко запустить. Сохраните это как app.py (в этом мы дали имя pyramid_helloW.py).

Запуск самой простой программы: —

Затем откройте http: // localhost: 8000 / в браузере, и вы увидите Hello, Pyramid! Сообщение следующим образом —

Ниже приведено объяснение приведенного выше кода.

Строка № 1-3

В начале файла у нас есть операторы импорта. Первая строка импортирует функцию make_server, которая может создать простой веб-сервер при передаче в приложение. Вторая и третья строка импортируют конфигурацию и функцию Response из пирамиды. Эти функции используются для настройки деталей и установки параметров приложения и ответа на запросы соответственно.

Строка № 5-6

Теперь у нас есть определение функции hello_world . Реализуйте код представления, который генерирует ответ. Функция, которая удовлетворяет требованию представления, отвечает за визуализацию текста, который будет передан запрашивающему объекту. В приведенном выше случае функция при вызове использует функцию Response, которую мы импортировали ранее. Это возвращает значение, которое должно быть передано клиенту.

Строка № 8

if __name__ == ‘__main__’: Python говорит: «Начните здесь при запуске из командной строки», а не когда этот модуль импортирован.

Строка № 9-11

В строке № 9 мы создаем переменную с именем config из объекта, созданного функцией конфигуратора, которую мы импортировали вверху программы. Строки 10 и 11 вызывают методы add_route и add_view этого объекта. Этот метод используется для определения представления, которое может использоваться приложением. Как мы видим, мы передаем функцию hello_world, которую мы определили ранее. Это где эта функция фактически включена в качестве представления.

Строка № 12-14

В этом мы фактически создаем приложение WSGI, вызывая метод make_wsgi_app объекта config. При этом используются атрибуты объекта, такие как добавленное нами представление, для создания приложения. Затем это приложение передается импортированной нами функции make_server для создания объекта, который может запускать веб-сервер для обслуживания нашего приложения. Последняя строка запускает этот сервер.

Наше приложение hello world является одним из самых простых и легких из возможных пирамидальных приложений, настроенных «обязательно». Это необходимо, потому что вся мощь Python доступна для нас, когда мы выполняем задачи по настройке.

Подводя итог, можно сказать, что Pyramid — это веб-фреймворк с открытым исходным кодом Python, в котором большое и активное сообщество. Это большое сообщество способствует популяризации и актуальности веб-фреймворка Python. Веб-инфраструктура Pyramid упрощает и ускоряет разработку веб-приложений, предоставляя набор надежных функций и инструментов.

pyramid — с английского на русский

Введение в веб-платформу Pyramid для Python

В первой статье из этой серии из четырех частей, сравнивающих различные веб-платформы Python, я объяснил, как создать веб-приложение To-Do List в веб-платформе Flask. В этой второй статье я проделаю ту же задачу с веб-фреймворком Pyramid. В следующих статьях будут рассмотрены Tornado и Django; По мере продвижения я буду исследовать больше различий между ними.

Установка, запуск и настройка

Самопровозглашенная как «начало с малого, крупное завершение и завершение работы», Pyramid очень похож на Flask в том, что для его запуска и запуска требуется очень мало усилий.Фактически, вы узнаете многие из тех же шаблонов при создании этого приложения. Однако основное различие между ними заключается в том, что Pyramid поставляется с несколькими полезными утилитами, о которых я вскоре расскажу.

Для начала создайте виртуальную среду и установите пакет.

 
 $ mkdir pyramid_todo 
 $ cd pyramid_todo 
 $ pipenv install --python 3.6 
 $ pipenv shell 
 (pyramid-someHash) $ pipenv install pyramid 
 

Как и в случае с Flask, разумно создать установку .py , чтобы создать приложение, которое вы создаете, легко устанавливаемым дистрибутивом Python.

 # setup.py 
 из setuptools import setup, find_packages 
 требует = [
 'pyramid', 
 'paster_pastedeploy', 
 'pyramid-ipython', 
 'waitress' 
] 
 
 setup (
 name = 'pyramid_todo', 
 version = '0.0', 
 description = 'Составление списка дел с помощью пирамиды', 
 author = '<Ваше имя>', 
 author_email = '<Ваш адрес электронной почты>', 
 keywords = 'пилоны веб-пирамиды', 
 packages = find_packages (), 
 include_package_data = True, 
 install_requires = required, 
 entry_points = {
 'вставить.app_factory ': [
' main = todo: main ', 
] 
} 
) 
 

entry_points Раздел рядом с концом устанавливает точки входа в приложение, которые могут использовать другие службы. Это позволяет пакету plaster_pastedeploy получить доступ к основной функции в приложении для создания объекта приложения и его обслуживания. (Я вернусь к этому чуть позже.)

Когда вы установили pyramid , вы также получили несколько команд оболочки, специфичных для Pyramid; основные, на которые стоит обратить внимание, — это pserve и pshell . pserve примет файл конфигурации в стиле INI, указанный в качестве аргумента, и будет обслуживать приложение локально. pshell также примет файл конфигурации в качестве аргумента, но вместо обслуживания приложения он откроет оболочку Python, которая знает о приложении и его внутренней конфигурации.

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

Создайте файл с именем config.ini

 [app: main] 
 use = egg: todo 

pyramid.default_locale_name = en 
 [server: main] 
 use = egg: waitress # main 
 listen = localhost: 6543 
 

Это говорит о нескольких вещах:

• Фактическое приложение будет происходить из функции main , расположенной в пакете todo , установленном в среде
• Для обслуживания этого приложения используйте пакет официантка , установленный в среде и обслуживающий порт локального хоста 6543

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

 # продолжение ... 
 [logger] 
 keys = root, todo 
 [handlers] 
 keys = console 
 
 [formatters] 
 keys = generic 
 
 [logger_root] 
 level = INFO 
 handlers = console 
 
 [ logger_todo] 
 level = DEBUG 
 handlers = 
 qualname = todo 
 
 [handler_console] 
 class = StreamHandler 
 args = (sys.stderr,) 
 level = NOTSET 
 formatter = generic 
 
 [formatter_generic] 
 format =% (as ) s% (имя уровня) -5.5s [% (name) s:% (белье) s] [% (threadName) s]% (message) s 
 

Короче говоря, эта конфигурация требует, чтобы все, что связано с приложением, регистрировалось в консоли. Если вы хотите меньше вывода, установите уровень ведения журнала WARN , чтобы сообщение появлялось только в случае возникновения проблемы.

Поскольку Pyramid предназначена для растущего приложения, спланируйте файловую структуру, которая могла бы поддерживать этот рост. Конечно, веб-приложения можно создавать так, как вы хотите. В общем, концептуальные блоки, которые вы хотите охватить, будут содержать:

• Модели для содержания кода и логики для работы с представлениями данных
• Просмотры кода и логики, относящиеся к циклу запрос-ответ
• Маршруты для путей доступа к функциям вашего приложения
• Скрипты для любого кода, который может использоваться в настройке или управлении самим приложением

Учитывая вышесказанное, файловая структура может выглядеть так:

 
 настройка.py 
 config.ini 
 todo / 
 __init__.py 
 models.py 
 routes.py 
 views.py 
 скрипты / 
 

Как и объект приложения Flask , Pyramid имеет собственную центральную конфигурацию. Он исходит из его модуля config и известен как объект Configurator . Этот объект будет обрабатывать все, от конфигурации маршрута до указания того, где существуют модели и представления. Все это делается во внутреннем каталоге под названием todo внутри __init__.py файл.

 # todo / __ init__.py 
 из pyramid.config import Configurator 
 
 def main (global_config, ** settings): 
 "" "Возвращает приложение Pyramid WSGI." "" 
 config = Configurator (settings = settings) 
 config .scan () 
 вернуть config.make_wsgi_app () 
 

Основная функция ищет некоторую глобальную конфигурацию из вашей среды, а также любые настройки, которые поступают через конкретный файл конфигурации, который вы предоставляете при запуске приложения.Он берет эти настройки и использует их для создания экземпляра объекта Configurator , который (для всех намерений и целей) является фабрикой для вашего приложения. Наконец, config.scan () ищет любые представления, которые вы хотите прикрепить к своему приложению, которые помечены как представления пирамиды.

Ух ты, надо было много настраивать.

Использование маршрутов и представлений

Теперь, когда часть конфигурации завершена, вы можете начать добавлять функции в приложение.Функциональные возможности представлены в виде URL-маршрутов, по которым могут работать внешние клиенты, которые затем сопоставляются с функциями, которые может запускать Python.

При использовании Pyramid все функциональные возможности должны быть добавлены к Configurator каким-либо образом, формой или формой. Например, предположим, что вы хотите создать такое же простое представление hello_world , которое вы создали с помощью Flask, сопоставив его с маршрутом /. С Pyramid вы можете зарегистрировать маршрут / с помощью конфигуратора , используя .add_route () метод. Этот метод принимает в качестве аргументов имя маршрута, который вы хотите добавить, а также фактический шаблон, который должен быть сопоставлен для доступа к этому маршруту. В этом случае добавьте в конфигуратор :

  config.add_route ('дом', '/')
  

До тех пор, пока вы не создадите представление и не прикрепите его к этому маршруту, этот путь в ваше приложение остается открытым и единственным. При добавлении представления обязательно включите объект request в список параметров.Каждое представление Pyramid должно иметь объект запроса в качестве своего первого параметра, поскольку он передается в качестве первого аргумента в представление, когда оно вызывается Pyramid.

Схожесть представлений Pyramid и Flask заключается в том, что вы можете пометить функцию как представление с помощью декоратора. В частности, декоратор @view_config из pyramid.view .

В views.py создайте представление, которое вы хотите видеть в мире.

 от пирамиды.view import view_config 
 @view_config (route_name = "hello", renderer = "string") 
 def hello_world (request): 
 "" "Печать 'Hello, world!' в качестве тела ответа. "" "
 return 'Hello, world!' 
 

С помощью декоратора @view_config вы должны как минимум указать имя маршрута, который будет отображаться на это конкретное представление. Вы можете складывать декораторы view_config друг на друга для сопоставления с несколькими маршрутами, если хотите, но у вас должен быть хотя бы один для подключения к просмотру представления вообще, и каждый из них должен включать имя маршрута. [ПРИМЕЧАНИЕ. Правильно ли сформулировано «для подключения просмотра и просмотра»?]

Другой аргумент, модуль рендеринга , является необязательным, но не совсем . Если вы не укажете средство визуализации, вы должны сознательно создать HTTP-ответ, который вы хотите отправить обратно клиенту, используя объект Response из pyramid.response . Указав средство визуализации в виде строки, Pyramid знает, что нужно взять все, что возвращается этой функцией, и обернуть это в тот же объект Response с типом MIME text / plain .По умолчанию Pyramid позволяет использовать string и json в качестве средств визуализации. Если вы подключили механизм шаблонов к своему приложению, потому что хотите, чтобы Pyramid также генерировал ваш HTML, вы можете указать прямо на свой HTML-шаблон в качестве средства визуализации.

Первый просмотр готов. Вот как теперь выглядит __init__.py с прикрепленным маршрутом.

 # в __init__.py 
 из pyramid.config import Configurator 
 def main (global_config, ** settings): 
 "" "Возвращает приложение Pyramid WSGI."" "
 config = Конфигуратор (settings = settings) 
 config.add_route ('hello', '/') 
 config.scan () 
 return config.make_wsgi_app () 
 

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

Сглаживание неровной кромки

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

One : в файле routes.py создайте функцию с именем includeme (да, на самом деле она должна называться так), которая принимает в качестве аргумента объект конфигуратора.

 
 # в routes.py 
 def includeme (config): 
 "" "Включить эти маршруты в приложение."" "
 

Два : переместите вызов метода config.add_route из __init__.py в функцию includeme :

 
 def includeme (config): 
 "" "Включить эти маршруты в приложение." "" 
 config.add_route ('hello', '/') 
 

Three : Предупредите конфигуратор, что вам необходимо включить этот файл routes.py как часть его конфигурации. Потому что он находится в том же каталоге, что и __init__.py , вы можете указать путь импорта к этому файлу как .routes .

 # в __init__.py 
 из pyramid.config import Configurator 
 def main (global_config, ** settings): 
 "" "Возвращает приложение Pyramid WSGI." "" 
 config = Configurator (settings = settings) 
 config.include ('.routes') 
 config.scan () 
 return config.make_wsgi_app () 
 

Подключение базы данных

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

Сначала избавьтесь от легкого. psycopg2 и sqlalchemy необходимы для взаимодействия с базой данных Postgres и управления моделями, поэтому добавьте их в setup.py .

 
 # в setup.py 
 требует = [
 'пирамида', 
 'пирамида-ipython', 
 'официантка', 
 'sqlalchemy', 
 'psycopg2' 
] 
 # бла-бла другой код 
 

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

Первый вариант сохранит максимально возможную конфигурацию в одном месте, жестко закодировав URL базы данных в файле config.ini . Один из недостатков заключается в том, что это создает угрозу безопасности для приложений с общедоступной кодовой базой. Любой, кто может просмотреть базу кода, сможет увидеть полный URL-адрес базы данных, включая имя пользователя, пароль, имя базы данных и порт.Другой - ремонтопригодность; если вам нужно было изменить среду или расположение базы данных приложения, вам придется напрямую изменить файл config.ini . Либо это, либо вам придется поддерживать один файл конфигурации для каждой новой среды, что увеличивает вероятность прерывания работы и ошибок в приложении. Если вы выберете эту опцию , измените файл config.ini под заголовком [app: main] , включив в него эту пару "ключ-значение":

  sqlalchemy.url = postgres: // локальный: 5432 / pyramid_todo
  

Второй вариант определяет расположение URL-адреса базы данных при создании Configurator , указывая на переменную среды, значение которой может быть установлено в зависимости от среды, в которой вы работаете. Один из недостатков заключается в том, что вы еще больше разбиваете конфигурацию, причем некоторые из них находятся в файле config.ini , а некоторые непосредственно в базе кода Python. Еще один недостаток заключается в том, что, когда вам нужно использовать URL-адрес базы данных в любом другом месте приложения (например,g. в сценарии управления базой данных), вы должны указать вторую ссылку на ту же переменную среды (или настроить переменную в одном месте и импортировать из этого места). Если вы выберете эту опцию , добавьте следующее:

 # в __init__.py 
 import os 
 from pyramid.config import Configurator 
 SQLALCHEMY_URL = os.environ.get ('DATABASE_URL', '') 
 
 def main (global_config, ** settings): 
 "" "Возвращает Приложение Pyramid WSGI. "" "
 settings ['sqlalchemy.url '] = SQLALCHEMY_URL # <- важно! 
 config = Конфигуратор (settings = settings) 
 config.include ('. Routes') 
 config.scan () 
 return config.make_wsgi_app () 
 

Определение объектов

Хорошо, теперь у вас есть база данных. Теперь вам нужны объекты Task и User .

Поскольку Pyramid напрямую использует SQLAlchemy, он несколько отличается от Flash в том, как строятся объекты. Во-первых, каждый объект, который вы хотите построить, должен быть унаследован от декларативного базового класса SQLAlchemy.Он будет отслеживать все, что от него унаследовано, что упрощает управление базой данных.

 # в models.py 
 из sqlalchemy.ext.declarative import declarative_base 
 Base = declarative_base () 
 
 class Task (Base): 
 pass 
 
 class User (Base): 
 pass 
 

Столбцы, типы данных для этих столбцов и отношения моделей будут объявлены во многом так же, как и в Flask, хотя они будут импортированы непосредственно из SQLAlchemy вместо некоторого предварительно созданного объекта db .В остальном все то же самое.

 # в models.py 
 из datetime import datetime 
 import secret 
 from sqlalchemy import (
 Column, Unicode, Integer, DateTime, Boolean, Relationship 
) 
 from sqlalchemy.ext.declarative import declarative_base 
 
 Base = declarative_base () 
 
 class Task (Base): 
 "" "Задачи для списка дел." "" 
 id = Column (Integer, primary_key = True) 
 name = Column (Unicode, nullable = False) 
 note = Column (Unicode) 
 creation_date = Column (DateTime, nullable = False) 
 due_date = Column (DateTime) 
 completed = Column (Boolean, default = False) 
 user_id = Column (Integer, ForeignKey ('user.id '), nullable = False) 
 user = Relationship ("user", back_populate = "tasks") 
 
 def __init __ (self, * args, ** kwargs): 
 "" "При построении укажите дату создания. "" "
 super () .__ init __ (* args, ** kwargs) 
 self.creation_date = datetime.now () 
 
 class User (Base): 
" "" Объект User, которому принадлежат задачи. "" "
 id = Column (Integer, primary_key = True) 
 username = Column (Unicode, nullable = False) 
 email = Column (Unicode, nullable = False) 
 password = Column (Unicode, nullable = False) 
 date_joined = Column (DateTime, nullable = False) 
 token = Column (Unicode, nullable = False) 
 tasks = Relations ("Задача", back_populate = "user") 
 
 def __init __ (self, * args, ** kwargs): 
 "" "Вкл. строительство, установить дату создания."" "
 super () .__ init __ (* args, ** kwargs) 
 self.date_joined = datetime.now () 
 self.token = secrets.token_urlsafe (64) 
 

Обратите внимание, что нигде нет строки config.include для models.py , потому что она не нужна. Строка config.include нужна только в том случае, если необходимо изменить некоторую часть конфигурации приложения. Это создало только два объекта, унаследованных от некоторого класса Base , который нам дал SQLAlchemy.

Инициализация базы данных

Теперь, когда модели готовы, вы можете написать сценарий для взаимодействия и инициализации базы данных. В каталоге сценариев создайте два файла: __init__.py и initializedb.py . Первый - просто превратить каталог скриптов в пакет Python. Второй — сценарий, необходимый для управления базой данных.

initializedb.py нужна функция для создания необходимых таблиц в базе данных.Как и в случае с Flask, этот сценарий должен знать об объекте Base , метаданные которого отслеживают каждый класс, наследующий от него. URL-адрес базы данных требуется для указания и изменения ее таблиц.

Таким образом, этот сценарий инициализации базы данных будет работать:

 # initializedb.py 
 из sqlalchemy import engine_from_config 
 from todo import SQLALCHEMY_URL 
 from todo.models import Base 
 def main (): 
 settings = {'sqlalchemy.url': SQLALCHEMY_URL} 
 engine = engine_from_config = '(settings, sqlalchemy.') 
 if bool (os.environ.get (' DEBUG ',' ')): 
 Base.metadata.drop_all (engine) 
 Base.metadata.create_all (engine) 
 

Важное примечание: Это будет работать, только если вы включите URL-адрес базы данных в качестве переменной среды в todo / __ init__.py (второй вариант выше). Если URL-адрес базы данных был сохранен в файле конфигурации, вам нужно будет включить несколько строк для чтения этого файла. Это будет выглядеть примерно так:

 # альтернативная инициализация b.py 
 из pyramid.paster import get_appsettings 
 из pyramid.scripts.common import parse_vars 
 from sqlalchemy import engine_from_config 
 import sys 
 from todo.models import Base 
 def main (): 
 config_uri = sys.argv [1] 
 options = parse_vars (sys.argv [2:]) 
 settings = get_appsettings (config_uri, options = options) 
 engine = engine_from_config (settings, prefix = 'sqlalchemy.') 
 if bool (os.environ.get ('DEBUG', ' ')): 
 Base.metadata.drop_all (двигатель) 
 Base.metadata.create_all (двигатель) 
 

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

 
 # нижняя часть setup.py 
 setup (
 # ... другие вещи 
 entry_points = {
 'paste.app_factory': [
 'main = todo: main', 
], 
 'console_scripts': [
 ' initdb = todo.scripts.initializedb: main ', 
], 
} 
) 
 

Когда этот пакет будет установлен, у вас будет доступ к новому сценарию консоли с именем initdb , который будет создавать таблицы в вашей базе данных.Если URL-адрес базы данных хранится в файле конфигурации, вам нужно будет указать путь к этому файлу при вызове команды. Это будет выглядеть так: $ initdb /path/to/config.ini .

Обработка запросов и база данных

Хорошо, вот где это немного углубляется. Поговорим о транзакциях . «Транзакция» в абстрактном смысле — это любое изменение, внесенное в существующую базу данных. Как и в случае с Flask, транзакции сохраняются не раньше, чем они были зафиксированы.Если были внесены изменения, которые еще не были зафиксированы, и вы не хотите, чтобы они происходили (возможно, в процессе возникла ошибка), вы можете откатить транзакцию и отменить эти изменения.

В Python пакет транзакций позволяет вам взаимодействовать с транзакциями как с объектами, которые могут объединять несколько изменений в одну фиксацию. Транзакция предоставляет диспетчеров транзакций , которые предоставляют приложениям простой, ориентированный на потоки способ обработки транзакций, поэтому все, о чем вам нужно думать, это то, что нужно изменить.Пакет pyramid_tm возьмет менеджер транзакций из транзакции и подключит его таким образом, чтобы это соответствовало циклу запрос-ответ Pyramid, присоединяя диспетчер транзакций к каждому входящему запросу.

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

Ура, почему это так важно?

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

 # __init__.py 
 import os 
 from pyramid.config import Configurator 
 from sqlalchemy import engine_from_config 
 from sqlalchemy.orm import sessionmaker 
 import zope.sqlalchemy 
 SQLALCHEMY_URL = os.environ.get ('9L' def get_session_factory (engine): 
 "" "Возвращает генератор объектов сеанса базы данных." "" 
 factory = sessionmaker () 
 factory.configure (bind = engine) 
 return factory 
 
 def get_tm_session (session_factory, transaction_manager): 
 "" "Создайте сеанс и зарегистрируйте его как сеанс, управляемый транзакциями."" "
 dbsession = session_factory () 
 zope.sqlalchemy.register (dbsession, transaction_manager = transaction_manager) 
 return dbsession 
 
 def main (global_config, ** settings): 
" "" Возвращает приложение Pyramid WSGI. "" " 
 settings ['sqlalchemy.url'] = SQLALCHEMY_URL 
 settings ['tm.manager_hook'] = 'pyramid_tm.explicit_manager' 
 config = Configurator (settings = settings) 
 config.include ('. Routes') 
 config.include ( 'pyramid_tm') 
 session_factory = get_session_factory (engine_from_config (settings, prefix = 'sqlalchemy.')) 
 config.registry [' dbsession_factory '] = session_factory 
 config.add_request_method (
 лямбда-запрос: get_tm_session (session_factory, request.tm), 
' dbsession ', 
 reify = True 
) 
 
 config.scan () 
 возврат config.make_wsgi_app () 
 

Похоже, что это много, но это было только то, что было объяснено выше, плюс он добавил к объекту request атрибут под названием request.dbsession .

Сюда было включено несколько новых пакетов, поэтому обновите setup.py этими пакетами.

 
 # в setup.py 
 требует = [
 'пирамида', 
 'пирамида-ipython', 
 'официантка', 
 'sqlalchemy', 
 'psycopg2', 
 'pyramid_tm', 
 'транзакция', 
 ' zope.sqlalchemy '
] 
 # бла-бла прочее 
 

Новые маршруты и виды

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

Начнем с маршрутов. Вы создали файл routes.py для обработки ваших маршрутов, но не сделали ничего, кроме базового маршрута /. Давай исправим это.

 
 # routes.py 
 def includeme (config): 
 config.add_route ('info', '/ api / v1 /') 
 config.add_route ('register', '/ api / v1 / accounts') 
 config .add_route ('profile_detail', '/ api / v1 / accounts / {username}') 
 config.add_route ('login', '/ api / v1 / accounts / login') 
 config.add_route ('logout', '/ api / v1 / accounts / logout') 
 config.add_route ('tasks', '/ api / v1 / accounts / {username} / tasks') 
 config.add_route ('task_detail', '/ api / v1 / accounts / {username} / tasks / {id}') 
 

Теперь он не только имеет статические URL-адреса, например / api / v1 / accounts , но и может обрабатывать некоторые переменные URL-адреса, например / api / v1 / accounts / {username} / tasks / {id} , где любая переменная в URL будет заключен в фигурные скобки.

Чтобы создать представление для создания отдельной задачи в вашем приложении (как в примере Flash), вы можете использовать декоратор @view_config , чтобы убедиться, что он принимает только входящие запросы POST и проверить, как Pyramid обрабатывает данные из клиент.

Взгляните на код, а затем проверьте, чем он отличается от версии Flask.

 # в views.py 
 из datetime import datetime 
 из pyramid.view import view_config 
 из todo.models import Task, User 
 INCOMING_DATE_FMT = '% d /% m /% Y% H:% M:% S' 
 
 @view_config (route_name = "tasks", request_method = "POST", renderer = 'json') 
 def create_task (request): 
 "" "Создать задачу для одного пользователя." "" 
 response = request.response 
 response .headers.extend ({'Content-Type': 'application / json'}) 
 user = request.dbsession.query (User) .filter_by (username = request.matchdict ['username']). first () 
 if user : 
 due_date = request.json ['due_date'] 
 task = Task (
 name = request.json ['name'], 
 note = request.json ['note'], 
 due_date = datetime.strptime (due_date, INCOMING_DATE_FMT) if due_date else None, 
 completed = bool (request.json ['completed']), 
 user_id = user.id 
) 
 request.dbsession.add (task) 
 response.status_code = 201 
 return {'msg': 'posted'} 
 

Для начала обратите внимание на декоратор @view_config , что единственный тип запроса, который вы хотите, чтобы это представление обрабатывало, — это запрос POST. Если вы хотите указать один тип запроса или один набор запросов, предоставьте либо строку с указанием запроса, либо кортеж / список таких строк.

 
 response = request.response 
 ответ.headers.extend ({'Content-Type': 'application / json'}) 
 # ... другой код ... 
 response.status_code = 201 
 

HTTP-ответ, отправляемый клиенту, генерируется на основе request.response . Обычно вам не нужно беспокоиться об этом объекте. Он просто выдаст правильно отформатированный HTTP-ответ, и вы никогда не заметите разницы. Однако, поскольку вы хотите сделать что-то конкретное, например изменить код состояния и заголовки ответа, вам необходимо получить доступ к этому ответу и его методам / атрибутам.

В отличие от Flask, вам не нужно изменять список параметров функции просмотра только потому, что у вас есть переменные в URL-адресе маршрута. Вместо этого каждый раз, когда переменная существует в URL-адресе маршрута, она собирается в атрибуте matchdict запроса . Он будет существовать там как пара «ключ-значение», где ключом будет переменная (например, «имя пользователя»), а значением будет любое значение, указанное в маршруте (например, «bobdobson»). Независимо от того, какое значение передается через URL-адрес маршрута, оно всегда будет отображаться в виде строки в matchdict .Итак, если вы хотите получить имя пользователя из URL-адреса входящего запроса, обратитесь к нему с помощью request.matchdict ['username']

  user = request.dbsession.query (Пользователь) .filter_by (username = request.matchdict ['username']). First ()
  

Запросы объектов при использовании sqlalchemy напрямую значительно отличаются от того, что позволяет пакет flask-sqlalchemy . Напомним, что когда вы использовали flask-sqlalchemy для построения своих моделей, модели унаследованы от db.Объект Model . Этот объект db уже содержал соединение с базой данных , так что это соединение могло выполнять простую операцию, такую ​​как User.query.all () .

Этого простого интерфейса здесь нет, поскольку модели в приложении Pyramid наследуются от Base , который генерируется из declarative_base () , поступающих непосредственно из пакета sqlalchemy . Он не знает напрямую о базе данных, к которой он будет обращаться.Эта информация была привязана к объекту запроса через центральную конфигурацию приложения как атрибут dbsession . Вот код сверху, который сделал это:

 
 config.add_request_method (
 лямбда-запрос: get_tm_session (session_factory, request.tm), 
 'dbsession', 
 reify = True 
) 
 

С учетом всего сказанного, всякий раз, когда вы хотите запросить ИЛИ изменить базу данных, вы должны выполнить запросы с по .dbsession . В этом случае вы хотите запросить вашу таблицу «пользователей» для конкретного пользователя, используя его имя пользователя в качестве идентификатора. Таким образом, объект User предоставляется в качестве аргумента для метода .query , после чего обычные операции SQLAlchemy выполняются оттуда.

Интересным в этом способе запроса к базе данных является то, что вы можете запрашивать более одного объекта или списка одного типа объектов. Вы можете запросить:

• Атрибуты объекта сами по себе, e.g., request.dbsession.query (User.username) будет запрашивать имена пользователей
• Кортежи атрибутов объекта, например request.dbsession.query (User.username, User.date_joined)
• Кортежи из нескольких объектов, например request.dbsession.query (User, Task)

Данные, отправленные вместе с входящим запросом, будут найдены в словаре request.json .

Последнее существенное отличие состоит в том, что из-за всех махинаций, необходимых для присоединения фиксации активности сеанса к циклу запрос-ответ Pyramid, вам не нужно вызывать запрос .dbsession.commit () в конце вашего представления. Это удобно, но нужно помнить об одном, когда нужно двигаться вперед. Если вместо нового добавления в базу данных вы хотите отредактировать уже существующий объект в базе данных, вы не сможете использовать request.dbsession.commit () . Pyramid выдаст ошибку, сообщив что-то вроде «поведение фиксации обрабатывается менеджером транзакций, поэтому вы не можете вызвать его самостоятельно». И если вы не сделаете что-то похожее на фиксацию изменений, ваши изменения не сохранятся.

Решением здесь является использование request.dbsession.flush () . Задача .flush () — сигнализировать базе данных о том, что были внесены некоторые изменения, которые необходимо включить в следующую фиксацию.

Планирование на будущее

На этом этапе вы настроили большинство важных частей Pyramid, аналогично тому, что вы построили с помощью Flask в первой части. В приложение входит гораздо больше, но большая часть мяса обрабатывается здесь. Другие функции просмотра будут следовать аналогичному форматированию, и, конечно же, всегда есть вопрос безопасности (который встроен в Pyramid!).

Одно из основных отличий, которые я вижу в настройке приложения Pyramid, заключается в том, что оно имеет гораздо более сложный этап настройки, чем у Flask. Я разбил эти шаги настройки, чтобы подробнее объяснить, что происходит при создании приложения Pyramid. Однако было бы неискренне вести себя так, будто я все это знал с тех пор, как начал программировать. Мой первый опыт работы с фреймворком Pyramid был с Pyramid 1.7 и его системой строительных лесов pcreate , которая строит большую часть необходимой конфигурации, поэтому все, что вам нужно сделать, это подумать о функциональности, которую вы хотите создать.

Начиная с Pyramid 1.8, pcreate устарел и заменен cookiecutter, который фактически делает то же самое. Разница в том, что он поддерживается кем-то другим, а шаблоны cookiecutter существуют не только для проектов Pyramid. Теперь, когда мы рассмотрели компоненты проекта Pyramid, , я бы никогда больше не одобрил создание проекта Pyramid с нуля, когда доступен шаблон cookiecutter . Зачем так тяжело работать, если не нужно? Фактически, шаблон пирамида-cookie-резак-алхимия выполняет многое из того, что я здесь написал (и немного больше).На самом деле это похоже на каркас pcreate , который я использовал, когда впервые изучал Pyramid.

Узнайте больше о Python на PyCon Cleveland 2018.

.

Pyramid Software Solutions — Милуоки Веб-дизайн и разработка программного обеспечения

Теперь предлагает 3D веб-дизайн

Теперь мы предлагаем разработку на базе ThreeJS / WebGL, чтобы предоставить клиентам
возможность создавать уникальные веб-сайты, которые обязательно привлекут внимание посетителей.

технология WebGL
позволяет отображать трехмерную графику в исходном виде во всех основных современных настольных и мобильных веб-браузерах.
Это позволяет использовать возможности дизайна, которые до сих пор были нереальными.Очень мало компаний
еще не использовали эту технологию, поэтому работайте с нами, чтобы включить WebGL в ваш веб-дизайн
— отличный способ резко выделить ваш сайт.

Уникальный

WebGL еще не используется многими компаниями, и его использование — отличный способ выделить ваш сайт среди конкурентов.
WebGL позволяет нам, как веб-разработчикам, создавать как 2D-, так и 3D-эффекты.
что ранее было невозможно с традиционным HTML и Javascript.Это может не только дать
пользователям вашего веб-сайта приятное впечатление, но ощущение, что ваша компания является передовой технологически.

Мобильная версия

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

Узнать больше

Узнайте больше о том, как мы можем использовать WebGL для увеличения веб-трафика и удовлетворенности пользователей веб-сайтом вашей компании.

Примеры WebGL

Вот несколько примеров виджетов и фоновых сцен, разработанных Pyramid Software Solutions.Их можно изменять, расширять и персонализировать, чтобы они соответствовали вашему веб-сайту. Их даже можно интегрировать
с вашим существующим сайтом.

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

Галерея

3D-галерея, которую можно использовать для изображений, новостных статей или любой коллекции миниатюрных ссылок.Галерея использует отражения в реальном времени и может быть смешана с обычным HTML.

Земля

Это пример 3D-изображения Земли, отображаемого в реальном времени с помощью WebGL. Пример
также показаны преимущества использования 3D-контента в реальном времени, а не видеоконтента.

Обработка видео

WebGL можно использовать для обработки видео в реальном времени.Этот пример демонстрирует это с искажением
эффект каждый раз, когда пользователь нажимает на видео.

.