Ural penguins - Сообщения с тегом pyramid

Visual Studio Code для Python

2016-09-07T20:48:00Z

Примечание

Это статья из лекций http://lectureswww.readthedocs.io/999.additions/texteditors/vscode.html

Visual Studio Code

См.также

https://www.visualstudio.com/ru-ru/products/code-vs.aspx

Visual Studio Code отличный выбор для начинающего программиста, имеет необходимый минимум:

неплохую документацию
автодополнение кода (с использованием IntelliSense)
подсветка синтаксиса
встроенный отладчик
расширение функционала за счет плагинов
управление системой контроля версий git
кроссплатформенный
бесплатный, с открытым исходным кодом

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

Установка

См.также

https://code.visualstudio.com/docs/setup/setup-overview

Linux

См.также

https://code.visualstudio.com/docs/setup/linux

Скачиваем дистрибутив для своей ОС https://code.visualstudio.com/download
Для Linux существуют два типа пакетов, самых популярных форматов, rpm и deb.

Установка в Ubuntu/Debian:
```
$ sudo dpkg -i <file>.deb
```
CentOS/Fedora:
```
$ sudo yum install <file>.rpm
```
Fedora > 22 версии:
```
$ sudo dnf install <file>.rpm
```
После установки можно запустить редактор следующей командой:
```
$ code
```

Nix

Пакетный менеджер Nix работает на любом Linux дистрибутиве, содержит богатую базу уже готовых пакетов, в том числе и vscode.

Установка пакетного менеджера:
```
$ curl https://nixos.org/nix/install | sh
```
Установка Visual Studio Code:
```
$ nix-env -i vscode
```

Плагины

См.также

https://code.visualstudio.com/docs/editor/extension-gallery

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

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

Расширения можно искать введя название или ключевые слова в строке поиска, например Python.

Существует огромное количество расширений для Go, C#, C/C++, Nix, Haskell, Python, JS, TypeScript и др.

Python

См.также

https://code.visualstudio.com/docs/languages/python

После установки плагина Python нам становятся доступны многие функции:

Автодополнение кода
Проверка синтаксиса
Отладка
Подсказки
Переход к определению функции, класса и прочее

Автодополнение

Работает при наборе по нажатию Ctrl + Space.

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

Показывает ошибки в коде:

Работает если установлены Python пакеты Pylint, Pep8 или Flake8.

Совет

$ pip install -U --user pylint pep8 flake8

Отладка

См.также

https://code.visualstudio.com/docs/editor/debugging

Встроенный в редактор отладчик позволяет отлаживать код визуально, устанавливать точки останова мышкой и просматривать переменные в отдельном окне. Это похоже на отладку в различных IDE, таких как QtCreator или Wingware.

Также избавляет программиста писать мучительные строки типа printf или import pdb;pdb.set_trace();.

Настройки

См.также

https://code.visualstudio.com/docs/customization/userandworkspace

Настройки хранятся в формате JSON и доступны из меню File->Preferences->User Settings.

Шрифт

Шрифт задается в настройках File->Preferences->User Settings:

// Place your settings in this file to overwrite the default settings
{
    // Controls the font size.
    "editor.fontSize": 16
}

Автодополнение через <Tab>

Более привычно дополнять код по клавише <Tab>. Для этого необходимо открыть настройки пользователя File->Preferences->User Settings и прописать опцию editor.tabCompletion:

// Place your settings in this file to overwrite the default settings
{
    // Controls the font size.
    "editor.fontSize": 16,
    // Insert snippets when their prefix matches. Works best when 'quickSuggestions' aren't enabled.
    "editor.tabCompletion": true
}

Язык

См.также

https://code.visualstudio.com/docs/customization/locales

Открываем командную строку Ctrl + Shift + P
Вводим команду Configure Language

Меняем локаль на нужную, например ru:

{
    // Defines VS Code's display language.
    "locale": "ru"
}

Тема

Цветовое оформление задается в настройках File->Preferences->Color Theme.

Git

См.также

https://code.visualstudio.com/docs/editor/versioncontrol

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

Python скрипты

См.также

http://trypyramid.com

Visual Studio Code требует для отладки открывать не просто файл, а директорию. Это необходимо, что бы в этом каталоге сохранить локальные настройки редактора. Такая директория будет считаться проектом для редактора.

Для примера, создадим директорию hello1 и откроем в редакторе File->Open Folder....

Создадим в этой директории файл myapp.py:

Добавим в файл пример с сайта http://trypyramid.com

from wsgiref.simple_server import make_server
from pyramid.config import Configurator
from pyramid.response import Response

def hello_world(request):
    return Response('Hello %(name)s!' % request.matchdict)

config = Configurator()
config.add_route('hello', '/hello/{name}')
config.add_view(hello_world, route_name='hello')
app = config.make_wsgi_app()
server = make_server('0.0.0.0', 8080, app)
server.serve_forever()

Для запуска приложения, заходим в режим отладки по нажатию на кнопку:

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

Шаблон Python создает настройки в файле launch.json в локальной директории, которые выглядят примерно так:

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Python",
            "type": "python",
            "request": "launch",
            "stopOnEntry": true,
            "pythonPath": "${config.python.pythonPath}",
            "program": "${file}",
            "debugOptions": [
                "WaitOnAbnormalExit",
                "WaitOnNormalExit",
                "RedirectOutput"
            ]
        },
        {
            "name": "Python Console App",
            "type": "python",
            "request": "launch",
            "stopOnEntry": true,
            "pythonPath": "${config.python.pythonPath}",
            "program": "${file}",
            "externalConsole": true,
            "debugOptions": [
                "WaitOnAbnormalExit",
                "WaitOnNormalExit"
            ]
        },
        {
            "name": "Django",
            "type": "python",
            "request": "launch",
            "stopOnEntry": true,
            "pythonPath": "${config.python.pythonPath}",
            "program": "${workspaceRoot}/manage.py",
            "args": [
                "runserver",
                "--noreload"
            ],
            "debugOptions": [
                "WaitOnAbnormalExit",
                "WaitOnNormalExit",
                "RedirectOutput",
                "DjangoDebugging"
            ]
        },
        {
            "name": "Watson",
            "type": "python",
            "request": "launch",
            "stopOnEntry": true,
            "pythonPath": "${config.python.pythonPath}",
            "program": "${workspaceRoot}/console.py",
            "args": [
                "dev",
                "runserver",
                "--noreload=True"
            ],
            "debugOptions": [
                "WaitOnAbnormalExit",
                "WaitOnNormalExit",
                "RedirectOutput"
            ]
        },
        {
            "name": "Attach",
            "type": "python",
            "request": "attach",
            "localRoot": "${workspaceRoot}",
            "remoteRoot": "${workspaceRoot}",
            "port": 3000,
            "secret": "my_secret",
            "host": "localhost"
        }
    ]
}

Это универсальный шаблон, который добавляет несколько вариантов запуска приложений. Нас будет интересовать первый вариант Python, просто запускающий python файл.

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

После выполнения второй строки, интерпретатор выдаст ошибку ImportError: No module named pyramid.config. Это происходит из-за того что в нашем Python окружении не установлен модуль pyramid.

Решить эту проблему можно двумя способами:

Установить Pyramid в глобальное окружение.
```
$ pip install --user pyramid
```

Создать виртуальное окружение, установить в нем Pyramid и прописать его в настройках Visual Studio Code.

См.также

Как создать virtualenv

Создаем виртуальное окружение:

$ cd /path/to/hello1/
$ pyvenv hello1_env
$ source ./hello1_env/bin/activate

Устанавливаем Pyramid:
```
(hello1_env)$ pip install pyramid
```

Прописываем путь до виртуального окружения в настройках проекта Visual Studio Code (файл launch.json):

{
    "name": "PythonVenv",
    "type": "python",
    "request": "launch",
    "stopOnEntry": true,
    "pythonPath": "${workspaceRoot}/hello1_env/bin/python",
    "program": "${file}",
    "debugOptions": [
        "WaitOnAbnormalExit",
        "WaitOnNormalExit",
        "RedirectOutput"
    ]
}

После этого появится возможность запускать наш скрипт в локальном виртуальном окружении. Запущенная программа будет доступна по адресу http://localhost:8080/hello/foo. В консоле отладчика можно наблюдать ее вывод.

Поставим точку останова внутри функции hello_world, в строке 6. Это позволит нам остановить программу при запуске этой функции. После запуска, программа будет нормально работать, пока мы не зайдем по адресу http://localhost:8080/hello/foo, в этом случае запустится функция hello_world и выполнение программы прервется, до тех пор пока мы ее не продолжим вручную.

Примерно так выглядит процесс разработки и отладки программ на Python. Осталось только инициализировать git репозиторий и выложить проект на https://github.com.

Инициализируем репозиторий:
Добавим файл .gitignore:

Для этого нам потребуется скопировать содержимое https://www.gitignore.io/api/visualstudiocode,python в файл .gitignore и добавить туда директорию hello1_env, что бы она не участвовала в процессе создания версий.
```
# Created by https://www.gitignore.io/api/visualstudiocode,python

hello1_env

### VisualStudioCode ###
.vscode/*
!.vscode/settings.json
!.vscode/tasks.json
!.vscode/launch.json


### Python ###
# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]

...
```
Создаем первый коммит

Для создания коммита требуется ввести комментарий и нажать на кнопку в виде галочки.
Отправляем изменения на https://github.com
- Добавляем плагин Git Easy в проект
- Создаем репозиторий на GitHub
- Прописываем путь до гитхаба в нашем проекте, при помощи команды Git Easy:Add Orign
- Отправляем изменения на GitHub, при помощи команды Git Easy:Push Current Branch to Origin
  
  При успешном выполнении команды, мы должны увидеть сообщение типа:
```
To github.com:uralbash/hello1.git
* [new branch]      master -> master
```
  Файлы будут доступны по адресу https://github.com/uralbash/hello1

Для того что бы проверка синтаксиса заработала, необходимо создать файл .vscode/settings.json и переопределить в нем глобальные настройки для нашего проекта:

{
    "editor.fontSize": 18,

    //Python
    "python.pythonPath": "${workspaceRoot}/hello1_env/bin/python",

    // Whether to lint Python files using pylint.
    "python.linting.pylintEnabled": true,

    // Whether to lint Python files using pep8
    "python.linting.pep8Enabled": true,

    // Whether to lint Python files using flake8
    "python.linting.flake8Enabled": true
}

Pyramid

См.также

http://docs.pylonsproject.org/projects/pyramid/en/latest/narr/project.html

Фреймворк Pyramid имеет несколько стартовых шаблонов, которые нужны для того, что бы не начинать писать код с нуля. Рассмотрим как создать шаблон с БД sqlite + SQLAlchemy и настроить его в Visual Studio Code.

Для начала создадим директорию hello2 и виртуальное окружение hello2_env:

$ mkdir hello2
$ cd hello2/
$ pyvenv hello2_env
$ source hello2_env/bin/activate
$ pip install pyramid

См.также

http://docs.pylonsproject.org/projects/pyramid/en/latest/pscripts/index.html

После установки Pyramid, в окружении появляется команда pcreate. С ее помощью создадим проект по шаблону:

$ pcreate -t alchemy .
$ ls
CHANGES.txt  development.ini  hello2  hello2_env  MANIFEST.in  production.ini  pytest.ini  README.txt  setup.py

Устанавливаем его как Python пакет:

$ pip install -e .
$ pserve development.ini
Starting server in PID 17311.
Serving on http://localhost:6543

После запуска, становится доступен адрес http://localhost:6543

Но так-как БД еще не создана, отображается страница с подсказкой как ее инициализировать:

$ initialize_hello2_db development.ini

Теперь мы увидим стартовую страницу шаблона alchemy.

Проект на пирамиде запускается при помощи утилиты pserve. Добавим конфигурацию для Pyramid в файл настроек launch.json, что бы можно было запускать/отлаживать приложение из редактора:

{
    "version": "0.2.0",
    "configurations": [{
        "name": "Pyramid",
        "type": "python",
        "request": "launch",
        "stopOnEntry": true,
        "pythonPath": "${workspaceRoot}/hello2_env/bin/python",
        "program": "${workspaceRoot}/hello2_env/bin/pserve",
        "args": ["${workspaceRoot}/development.ini"],
        "debugOptions": [
            "WaitOnNormalExit",
            "RedirectOutput"
        ]
    }]
}

Попробуем запустить:

Поставим точку останова в функции my_view в файле hello2/views/default.py.

После обновления страницы http://localhost:6543 в браузере, программа остановит свое выполнение в этой точке, а браузер будет ждать пока мы не закончим отладку и не продолжим выполнение вручную.

JavaScript

Итог

Я, конечно, использую Vim, но советую Visual Studio Code, особенно тем кто не знает что выбрать. Очень, оказался, самодостаточный редактор, git, дбаггер, плагины, vi-мод. Ай да Микрософт!

REST API в Pyramid

2016-05-31T14:49:00Z

Примечание

Это статья из лекций http://lectureswww.readthedocs.io/6.www.sync/3.framework/pyramid/5.1.rest.html

REST API

См.также

REST API подразумевает под собой простые правила:

Каждый URL является ресурсом
При обращении к ресурсу методом GET возвращается описание этого ресурса
Метод POST добавляет новый ресурс
Метод PUT изменяет ресурс
Метод DELETE удаляет ресурс

Эти правила предоставляют простой CRUD интерфейс для других приложений, взаимодействие с которым происходит через протокол HTTP.

Соответствие CRUD операций и HTTP методов:

CREATE - POST
READ - GET
UPDATE - PUT
DELETE - DELETE

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

Pattern matching

Пример выше добавляет View с тремя методами, каждый из которых вызывается при соответствующем GET, POST, DELETE запросе. Ресурсом здесь является конкретный человек, получить которого можно по URL http://localhost:8080/api/v1/people/123

Результатом запроса будет:

{"get": {}, "id": "123", "method": "GET"}

Для отправки POST запроса воспользуемся консольной утилитой curl:

$ curl -X POST -d 'param1=value1&param2=value2' http://localhost:8080/api/v1/people/1

Результат запроса:

{"id": "1", "post": {"param1": "value1", "param2": "value2"}, "method": "POST"}

DELETE запрос выполняется по аналогии:

$ curl -X DELETE http://localhost:8080/api/v1/people/1

Результат запроса:

{"status": "success"}

Traversal

См.также

Метод URL диспетчеризации Traversal

В предыдущем примере показан только один ресурс - конкретный человек и в принципе все выглядит неплохо, пока не появится другой смежный ресурс, например список всех людей по адресу http://localhost:8080/api/v1/people

В этом случае, придется добавлять новый путь (rout), привязывать его к представлению (View) и самое неприятное менять само представление, или еще хуже писать новое. Таким образом с увеличением ресурсов, сложность REST API растет не пропорционально и в какой то момент код становится не читаемым из-за больших размеров и постоянно меняющейся логики во View.

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

Ресурсы

Ресурсы могут выглядеть так:

PeopleResource представляет список всех людей и будет доступен по адресу http://localhost:8080/api/v1/people. PeopleResource имеет метод __getitem__, что делает его похожим на словарь. При обращении к объекту ресурса как к словарю, он вызовет эту функцию и передаст ключ в параметр people_id, например:

foo = PeopleResource()
bar = foo[123]  # Вернет объект PersonResource(123)

Метод __json__ определяет каким образом преобразовывать ресурс в json.

PersonResource представляет конкретного человека и будет доступен по адресу http://localhost:8080/api/v1/people/{id}. Здесь отличительной особенностью является то, что метод __json__ наследует часть словаря из класса PeopleResource, при помощи конструкции super:

View

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

Рендерер json по умолчанию ищет метод __json__ и если он есть то возвращает его результат вызова.

Route

Путь, в нашем случае, будет один, так-как вся структура вынесена в ресурсы (метод __getitem__).

config.add_route('rest_api', '/api/v1/*traverse', factory=rest_factory)

Полный пример

Traversal роутинг в Pyramid

2016-05-30T14:49:00Z

Примечание

Это статья из лекций http://lectureswww.readthedocs.io/6.www.sync/3.framework/pyramid/5.urldispatch.html

Диспетчеризация URL

См.также

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

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

Pattern Matching

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

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

Traversal

См.также

http://docs.pylonsproject.org/projects/pyramid/en/latest/narr/traversal.html

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

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 находит ресурс и применяет к нему «наилучший» вид-для-вызова (в нашем примере — он единственный).

Обход словаря

Предупреждение

В примерах используется Python3

Метод обхода дерева (traversal), позволяет находить ресурсы во вложенных структурах. Такой механизм хорошо применим для некоторых практических задач, например список всех URL маршрутов сайта является деревом, в котором каждый конечный URL это отдельная ветка дерева. Поэтому всю структуру сайта можно поместить в словарь.

К примеру, известно, что смерь сказочного персонажа “кащея” находится в яйце, которое в свою очередь в утке, которая в зайце и т.д. В сумме получается вложенная структура, которую можно описать так:

остров -> дуб -> сундук -> заяц -> утка -> яйцо -> игла -> СмертьКощея

Мы можем такую, плоскую, вложенную структуру легко представить в виде URL:

http://localhost:8080/mytraversal/остров/дуб/сундук/заяц/утка/яйцо/игла

А так-как любой URL является веткой дерева, то несложно описать это в Python:

{
     'остров': {
         'дуб': {
             'сундук': {
                 'заяц': {
                     'утка': {
                         'яйцо': {
                             'игла': СмертьКощея()
                         }
                     }
                 }
             }
         }
     }
 }

СмертьКощея() - это объект класса СмертьКощея, который может выглядеть к примеру так:

class СмертьКощея(object):

    def __json__(self, request):

        return {
            'имя': 'кощей',
            'статус': request.context == self and 'мертв' or 'жив ещё',
        }

В принципе, этого достаточно что бы наш сайт-убийца “кощея” заработал. Осталось лишь прописать пути и добавить представление (view).

View будет просто возвращать объект, например, если мы ввели:

URL: 'остров'
объект: {'дуб': {
            'сундук': {
                'заяц': {
                    'утка': {
                        'яйцо': {
                            'игла': СмертьКощея()
                        }
                    }
                }
            }
        }}

URL: 'остров/дуб'
объект: {'сундук': {
            'заяц': {
                'утка': {
                    'яйцо': {
                        'игла': СмертьКощея()
                    }
                }
            }
        }}

URL: 'остров/дуб/сундук'
объект: {'заяц': {
            'утка': {
                'яйцо': {
                    'игла': СмертьКощея()
                }
            }
        }}

URL: 'остров/дуб/сундук/заяц'
объект: {'утка': {
            'яйцо': {
                'игла': СмертьКощея()
            }
        }}

URL: 'остров/дуб/сундук/заяц/утка'
объект: {'яйцо': {
            'игла': СмертьКощея()
        }}

URL: 'остров/дуб/сундук/заяц/утка/яйцо'
объект: {'игла': СмертьКощея()}

URL: 'остров/дуб/сундук/заяц/утка/яйцо/игла'
объект: СмертьКощея()

Такие функции-представления (View) должны принимать 2 параметра, где первый параметр будет являться объектом, обычно именуемым context, а второй параметр request:

def traverse_koshey(context, request):
    return context  # Наш объект

Роуты создаются почти так же как в pattern matching, за исключением того, что структура путей передается в виде “фабрики”, которая возвращает словарь или ему подобный (dict-like) объект. Путь указывается в виде статической и динамической части, например /fixedpath/*traverse:

config.add_route('koshey', '/mytraversal/*traverse', factory=my_factory)

Фабрика, которая возвращает структуру сайта:

def my_factory(request):
    return {
        'остров': {
            'дуб': {
                'сундук': {
                    'заяц': {
                        'утка': {
                            'яйцо': {
                                'игла': СмертьКощея()
                            }
                        }
                    }
                }
            }
        }
    }

View добавляется стандартно:

config.add_view(traverse_koshey, route_name='koshey', renderer='json')

Все готово, можно перемещаться по объектам:

Полный пример:

Есть один нюанс, json renderer, по умолчанию, все не латинские символы отображает как UTF коды \uxxxx, поэтому мы увидим следующий вывод:

{"\u043e\u0441\u0442\u0440\u043e\u0432": {"\u0434\u0443\u0431": {"\u0441\u0443\u043d\u0434\u0443\u043a": {"\u0437\u0430\u044f\u0446": {"\u0443\u0442\u043a\u0430": {"\u044f\u0439\u0446\u043e": {"\u0438\u0433\u043b\u0430": {"\u0441\u0442\u0430\u0442\u0443\u0441": "\u0436\u0438\u0432 \u0435\u0449\u0451", "\u0438\u043c\u044f": "\u043a\u043e\u0449\u0435\u0439"}}}}}}}}

Но можно изменить его поведение следующим образом:

 from pyramid.renderers import JSON
 ...
 config.add_renderer('myjson', JSON(indent=4, ensure_ascii=False))
 config.add_view(traverse_koshey, route_name='koshey', renderer='myjson')

Результат:

http://localhost:8080/mytraversal/

{
    "остров": {
        "дуб": {
            "сундук": {
                "заяц": {
                    "утка": {
                        "яйцо": {
                            "игла": {
                                "имя": "кощей",
                                "статус": "жив ещё"
                            }
                        }
                    }
                }
            }
        }
    }
}

http://localhost:8080/mytraversal/остров/дуб/сундук/заяц/утка/яйцо/игла

{
    "имя": "кощей",
    "статус": "мертв"
}

Полный код:

Привязка View к ресурсам

В Пирамиде объект (context) который передается во вью, именуют еще как “ресурс”. Есть возможность жестко привязать View к типу ресурса. Например, наше представление traverse_koshey должно вызываться, только когда пришел объект класса СмертьКощея:

config.add_view(traverse_koshey, route_name='koshey_context',
                renderer='myjson',
                context=СмертьКощея)

Параметр context указывает на то, что это View принадлежит ТОЛЬКО объектам класса СмертьКащея.

Все пути, кроме полного (который возвращает нужный объект), вернут 404 код ответа. Полный путь http://localhost:8080/mytraversal/остров/дуб/сундук/заяц/утка/яйцо/игла.

Добавим в нашу структуру еще ресурсов:

def my_factory(request):
    return {
        'превед': Человек(),
        'остров': {
            'ясень': {
                'что то здесь': 'не так!'
            },
            'дуб': {
                'сундук': {
                    'заяц': {
                        'утка': {
                            'яйцо': {
                                'игла': СмертьКощея()
                            }
                        }
                    }
                }
            }
        }
    }

Здесь Человек() это новый тип ресурса, который имеет метод __getitem__ как у словаря и при обращении по ключу возвращает другой ресурс:

class Человек(object):

    name = 'Человек'

    def __getitem__(self, name):
        return Имя(name)

class Имя(object):

    __parent__ = Человек()

    def __init__(self, name):
        self.name = name

Например мы обращаемся по URL http://localhost:8080/mytraversal/превед/Пирамид. превед вернет ресурс Человек, а Пирамид вызовет метод __getitem__, который вернет ресурс Имя('Пирамид'). Таким образом мы можем строить дерево динамически при помощи dict-like объектов.

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

def traverse_hello(context, request):
    """
    http://localhost:8080/mytraversal/первед/Пирамид
    """
    return Response('Превед ' + context.__parent__.name + ' ' + context.name)

...

config.add_view(traverse_hello, route_name='koshey_context',
                renderer='text',
                context=Имя)

Результат вывода по адресу http://localhost:8080/mytraversal/превед/Пирамид, будет обычный текст (Content-Type: plain/text):

Превед Человек Пирамид

Полный пример:

Комбинация обоих методов

Фреймворк Pyramid позволяет использовать оба способа URL маршрутизации одновременно.

Добавим к примеру с “кащеем” hello world с использованием pattern matching:

def hello_world(request):
    return Response('Hello %(name)s!' % request.matchdict)

...

# Pattern matching routes
config.add_route('hello', '/hello/{name}')
config.add_view(hello_world, route_name='hello')

Полный пример:

Демо репозитарий Pyramid + sacrud

2013-09-29T05:21:00Z

pyramid_sacrud_example - пример работы sacrud в Pyramid вместе с PostgreSQL.

Запись в БД через sacrud используя SQLAlchemy session.

2013-08-26T17:06:00Z

Для простых CRUD действий с БД, можно воспользоваться модулем action из sacrud. Это немного сократит код и добавит некоторой универсальности в ПО со сложной логикой.

from sacrud import action
from models import (
    DBSession,
    TestTable,
)

hstore_data = str({'param1': 'bla bla bla',
            'param2': 'bla bla bla2',
            'param3': '7389a498-9347-48e3-835d-c3900dcd2566',
            'patam4': 'dddddddd'})

param = {'value': ('123',),
         'description': ('test description',),
         'myhash': [hstore_data, ],
        }
# записывает транзакцию в БД
action.create(DBSession, TestTable, param)

параметры в виде списка сделаны для того что бы можно было принимать множественные значения поля с HTML формы.

UPD: в новой версии можно делать так:

param = {'value': '123',
         'description': 'test description',
         'myhash': hstore_data,
        }
# записывает транзакцию в БД
action.create(DBSession, TestTable, param)

Обновление sacrud и pyramid_ext

2013-08-26T16:24:00Z

Новая версия sacrud 0.0.3. В ней поправлены некоторые баги, добавлены нескучные обои элементы дизайна в расширении для Pyramid и создан отдельный репозитарий с примерами работы разных типов полей (pyramid_sacrud_example). Pyramid_sacrud_example работает только с Postgres потому что включает в себя примеры полей специфичных именно для этой БД (таких как hstore).