Ural penguins - Сообщений в Pyramid

REST API для Pyramid при помощи Cornice и SACRUD

2014-09-05T16:33:00Z

Mozilla использует в своих проектах Pyramid и у них есть отличный модуль для создания REST API https://cornice.readthedocs.org/en/latest/

REST API обычно меняет, создает и удаляет записи, которые хранятся в БД. Что бы не писать много кода на SQLAlchemy я использую заготовленные функции из sacrud.

Итак поехали, представим сервис REST API для платежных карт с моделью типа:

class Card(Base):
    __tablename__ = 'card'

    id = Column(Integer, primary_key=True)
    number = Column(BigInteger, nullable=False, unique=True)
    uid = Column(BYTEA, nullable=False, unique=True)
    balance = Column(Numeric(10, 2), nullable=False, default=0)
    preference = Column(GUID())

    def __json__(self):
        return {'id': self.id,
                'number': self.number,
                'uid': str(self.uid),
                'balance': str(self.balance)
                }

Создадим отдельную папку в pyramid проекте с названием rest, где будут храниться функции api, и пропишем это в основном конфиге.

# REST API
config.include("cornice")
config.include("myapp.rest", route_prefix="/api")

В pyramid’е есть такая штука как config.scan() она смотрит все файлы в проекте с расширением *.py (от текущей директории) и ищет вьюхи обернутые декоратором @view_config. Я предпочитаю включать в основной конфиг папочки через инклуд как в примере выше, а локально в каждой папке уже вызывать config.scan().

Структура папки rest:

rest/
├── card.py
├── __init__.py
└── validators.py

Файл __init__.py:

__init__.py

def includeme(config):
    config.scan()

В card.py сама реализация REST API:

GET

import json

from cornice import Service

from myapp.models import DBSession
from myapp.models import Card
from myapp.rest.validators import _400, _404, valid_hex

from sacrud.action import CRUD
from sqlalchemy.exc import DataError
from sqlalchemy.orm.exc import NoResultFound

card_api = Service(name='card', path='/card/{UID}',
                   description="REST API for card")


@card_api.get(validators=valid_hex)
def get_card(request):
    """``GET``: возвращает данные о карте.

    .. code-block:: bash

        $ curl -D - http://0.0.0.0:6543/api/card/07a8e29d

        HTTP/1.1 200 OK
        Content-Length: 69
        Content-Type: application/json; charset=UTF-8
        Date: Sat, 02 Aug 2014 11:22:52 GMT
        Server: waitress

        {"uid": "07a8e29d", "balance": 507.05, "id": 3, "number": 8224548674}
    """
    key = request.validated['UID']
    card = DBSession.query(Card)
    if key:
        try:
            card = card.filter_by(uid=key).one()
        except NoResultFound:
            raise _404()
        except DataError:
            raise _400()
        return card.__json__()

Декоратор card_api превращает функцию get_card во вьюху, ожидающею HTTP метод GET, и config.scan() её автоматически подхватит. Внутри можно реализовывать все что угодно. Про метод validated ниже.

POST

@card_api.post(validators=valid_hex)
def set_card(request):
    """``POST``: передает параметры для редактирования карты.

    .. code-block:: bash

        $ curl -H 'Accept: application/json'\\
            -H 'Content-Type: application/json'\\
            http://0.0.0.0:6543/api/card/07a8e29d\\
            -d '{"number": "8224548674", "balance": "507.05"}'

        {"uid": "07a8e29d", "balance": 507.05, "id": 3, "number": 8224548674}

    Если карты нету, то создается новая

    .. code-block:: bash

        $ curl -H 'Accept: application/json'\\
            -H 'Content-Type: application/json'\\
            http://0.0.0.0:6543/api/card/550e8400\\
            -d '{"balance": "100.11", "preference": "956bfc40"}'

        {"uid": "550e8400", "balance": 100.11, "id": 7, "number": 91328937986}
    """
    key = request.validated['UID']
    data = {'request': json.loads(request.body)}

    card = DBSession.query(Card).filter_by(uid=key).first()
    if card:
        data['pk'] = {'id': card.id}
    else:
        data['request']['uid'] = key

    try:
        CRUD(DBSession, Card, **data).add()
    except Exception as e:
        raise _400(msg=str(e.message))
    card = DBSession.query(Card).filter_by(uid=key).one()
    return card.__json__()

Метод POST меняет параметры карты или создает новую если такой нету. Карта создается при помощи мега модуля sacrud. Подробнее о создании записей через sacrud здесь http://sacrud.readthedocs.org/en/latest/plain_usage.html#create-action

DELETE

@card_api.delete(validators=valid_hex)
def del_card(request):
    """``DELETE``: удаляет карту по UID

    .. code-block:: bash

        $ curl -H 'Accept: application/json'\\
            -H 'Content-Type: application/json'\\
            http://0.0.0.0:6543/api/card/550e8400 -X DELETE

        {"Goodbye": "550e8400"}
    """
    key = request.validated['UID']
    card = DBSession.query(Card).filter_by(uid=key).first()
    if not card:
        raise _404()
    try:
        CRUD(DBSession, Card, pk={'id': card.id}).delete()
    except DataError as e:
        raise _400(msg=str(e.message))
    return {'Goodbye': key}

Удаление происходит при вызове HTTP метода DELETE. sacrud опять же несколько упрощает эту операцию http://sacrud.readthedocs.org/en/latest/plain_usage.html#delete-action

В файле validators.py хранятся всякие исключения и сами проверки. Если в декораторе card_api указан валидатор, то валидные данные нужно будет выбирать не через request.matchdict а через request.validated.

Пример файла validators.py

import json
import string

from webob import exc, Response


class _404(exc.HTTPError):
    def __init__(self, msg='Not Found'):
        body = {'status': 404, 'message': msg}
        Response.__init__(self, json.dumps(body))
        self.status = 404
        self.content_type = 'application/json'


class _400(exc.HTTPError):
    def __init__(self, msg='Bad Request'):
        body = {'status': 400, 'message': msg}
        Response.__init__(self, json.dumps(body))
        self.status = 400
        self.content_type = 'application/json'


def valid_hex(request):
    key = request.matchdict['UID']

    if not all(c in string.hexdigits for c in key):
        raise _400(msg="Not valid UID '%s'" % key)

    request.validated['UID'] = str(key)

Таким образом можно довольно просто создать API для вашего проекта на пирамиде. Cornice делает много за вас, создает вьюхи, пути, валидацию, может генерить автоматически Sphinx документацию, а SACRUD упрощает работу с БД.

Обновление sacrud. Версия 0.1.2

2014-03-10T14:34:00Z

Код: https://github.com/uralbash/sacrud

Описание: http://sacrud.readthedocs.org/

В этой версии делался упор на кастомизацию интерфейса.

Что нового?

добавлена пагинация
теперь pk показывается по умолчанию в форме создания/редактирования
новая опция sacrud_detail_col где можно задать отображаемые поля в форме редактирования
новая опция sacrud_list_col где можно задать отображаемые поля в списке записей
новая опция verbose_name для полей и таблиц
опция sacrud_css_class, назначает CSS стили полям
новый атрибут колонки sacrud_position: “inline” (см. реализацию horizontal_fields)
новая функция horizontal_fields
новый тип exttype.GUID
для переопределения base.html создан шаблон redefineme.html
вывод флеш уведомлений если задана sesion_factory
исправлены названия классов в шаблонах у полей
исправлен шаблон ForeignKey.jinja2
sa_create, sa_read, sa_update, sa_delete view вынесены в общий класс CRUD
в example добавлены pyramid_beaker, примеры с кастомизацией, FileField и все остальные поля которые есть в sacrud/templates/sacrud/types.

Пример кастомизации:

models.py

class TestCustomizing(Base):
    __tablename__ = "test_customizing"

    id = Column(Integer, primary_key=True)
    name = Column(String)
    date = Column(Date, info={"verbose_name": 'date JQuery-ui'})
    name_ru = Column(String, info={"verbose_name": u'Название', })
    name_fr = Column(String, info={"verbose_name": u'nom', })
    name_bg = Column(String, info={"verbose_name": u'Име', })
    name_cze = Column(String, info={"verbose_name": u'název', })
    description = Column(Text)
    description2 = Column(Text)

    visible = Column(Boolean)
    in_menu = Column(Boolean, info={"verbose_name": u'menu?', })
    in_banner = Column(Boolean, info={"verbose_name": u'on banner?', })

    # SACRUD
    verbose_name = u'Customizing table'
    sacrud_css_class = {'tinymce': [description, description2],
                        'content': [description],
                        'name': [name], 'Date': [date]}
    sacrud_list_col = [name, name_ru, name_cze]
    sacrud_detail_col = [name,
                         hosrizontal_field(name_ru, name_bg, name_fr, name_cze,
                                           sacrud_name=u"i18n names"),
                         description, date,
                         hosrizontal_field(in_menu, visible, in_banner,
                                           sacrud_name=u"Расположение"),
                         description2]

templates/sacrud/redefineme.jinja2

{% extends "sacrud/base.jinja2" %}

{% block userspace %}
  {{ super() }}

  <!-- Date field -->
  <script src="http://code.jquery.com/jquery-1.10.2.js"></script>
  <script src="http://code.jquery.com/ui/1.10.4/jquery-ui.js"></script>

  <link href="//code.jquery.com/ui/1.10.4/themes/smoothness/jquery-ui.css" rel="stylesheet"></link>
  <style>
    .content {
      height: 550px;
    }
    .name {
      width: 400px;
    }
  </style>

  <script>
    $(function() {
      $(".Date").datepicker({ dateFormat: 'yy-mm-dd' });
    });
  </script>

  <script src="//tinymce.cachefly.net/4.0/tinymce.min.js"></script>
  <script>
    tinymce.init({
      selector:'textarea.tinymce',
      plugins: "image link",
      file_browser_callback: function(field_name, url, type, win) {
        tinymce.activeEditor.windowManager.open({
            title: "SACRUD file browser",
            url: "/image/filebrowser",
            width: 600,
            height: 400,
          }, {
            oninsert: function(url) {
              win.document.getElementById(field_name).value = url;
            }
        });
      },
    });
  </script>
{% endblock %}

{% block sa_body %}
  {{ super() }}
{% endblock %}

Результат:

Пример кастомного CRUD интерфейса для SQLAlchemy

Демо приложение: https://github.com/uralbash/pyramid_sacrud_example

Своя панель в pyramid_debugtoolbar

2014-02-28T22:03:00Z

В pyramid_debugtoolbar можно создавать панели для своих нужд.

Документация здесь: http://docs.pylonsproject.org/projects/pyramid_debugtoolbar/en/latest/#adding-custom-panels

Я создал небольшой пример, как это сделать на примере sadisplay. sadisplay - это модуль который отображает модели SQLAlchemy в виде UML диаграммы.

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

├── __init__.py
├── panel.py
└── templates
    └── base.dbtmako

panel.py

#! /usr/bin/env python
# -*- coding: utf-8 -*-
# vim:fenc=utf-8
#
# Copyright © 2014 uralbash <root uralbash.ru="">
#
# Distributed under terms of the MIT license.

"""
sadisplay in pyramid_debugtoolbar
"""
import pydot
import sadisplay
import sqlalchemy

from sqlalchemy import engine_from_config
from pyramid_debugtoolbar.panels import DebugPanel

_ = lambda x: x


def get_sa_base(request, settings=None):
    if settings is None:
        settings = request.registry.settings
    engine = engine_from_config(settings, 'sqlalchemy.')
    sabase = sqlalchemy.ext.declarative.declarative_base()
    sabase.metadata.reflect(engine)
    return sabase


class SadisplayDebugPanel(DebugPanel):
    """
debug panel
"""
    name = 'SADisplay'
    has_content = True
    template = 'pyramid_debugtoolbar_sadisplay:templates/base.dbtmako'

    def __init__(self, request):
        self.request = request
        self.data = {}
        self.Base = get_sa_base(request)

    def nav_title(self):
        return _('SADisplay')

    def url(self):
        return ''

    def title(self):
        return _('SADisplay')

    def render_vars(self, request):
        tables = self.Base.metadata.tables.values()
        desc = sadisplay.describe(tables)
        dot_data = sadisplay.dot(desc)
        graph = pydot.graph_from_dot_data(str(dot_data))
        svg_img = graph.create_svg()
        return {'svg_img': svg_img}

    def content(self):
        vars = self.render_vars(self.request)
        return self.render(
            'pyramid_debugtoolbar_sadisplay:templates/base.dbtmako',
            vars, self.request)

Функция get_sa_base создает base объект и заполняет его метаданными по строке подключения к БД, в дальнейшем мы сможем получить все модели проекта. Метод render_vars при помощи sadisplay генерит текст формата dot и при помощи pydot конвертит его в svg.

В версии pyramid_debugtoolbar 1.0.* нужно рендерить шаблон в методе content. В 2.0.* метод content не нужен, шаблон указывается в виде атрибута template, а параметры отдаются в методе render_vars. В примере используются оба метода, что бы работало во всех версиях.

шаблон base.dbtmako:

base.dbtmako

<h4>SQLAlchemy models preview</h4>
${ svg_img|n }
link: <a href="https://github.com/uralbash/pyramid_debugtoolbar_sadisplay" style="color: blue;">pyramid_debugtoolbar_sadisplay</a>

Подключаем к приложению:

__init__.py

# SADisplay in pyramid_debugtoolbar
from pyramid_debugtoolbar_sadisplay.panel import SadisplayDebugPanel
config.registry.settings['debugtoolbar.panels'].append(SadisplayDebugPanel)

Результат:

Код примера здесь: https://github.com/uralbash/pyramid_debugtoolbar_sadisplay

Обновление sacrud. Версия 0.1.1

2014-02-23T18:02:00Z

Код: https://github.com/uralbash/sacrud

Описание: http://sacrud.readthedocs.org/

Что нового?

в расширении для pyramid параметр “sacrud_models” переименован в “sacrud.models”

“sacrud.models” теперь словарь, а не список:

settings['sacrud.models'] = {
    'Company': [Company, User, EmployeeType],
    'Auth': [Group, GroupPermission, UserGroup,
    GroupResourcePermission, Resource, UserPermission,
    UserResourcePermission, ExternalIdentity],
    '': [Company]
}

в словаре можно поделить модели на группы
тесты исправлены для Pyramid 1.5:

Не рекомендуется, начиная с версии pyramid: 1.5

Removed the ability to influence and query a pyramid.request.Request object as if it were a dictionary. Previously it was possible to use methods like __getitem__, get, items, and other dictlike methods to access values in the WSGI environment. This behavior had been deprecated since Pyramid 1.1. Use methods of request.environ (a real dictionary) instead.

миграции в Pyramid

2014-02-16T02:04:00Z

Пример миграций в пирамиде:

В Django south в Pyramid alembic. Создаём файл alembic.ini и указываем путь до настроек :, т.е. <имя проекта>:<название папки> например hlp:alembic:

alembic.ini

pyramid.includes =
    pyramid_debugtoolbar
    pyramid_tm
    ziggurat_foundations.ext.pyramid.sign_in

ziggurat_foundations.model_locations.User = hlp.models.auth:User
#sqlalchemy.url = sqlite:///%(here)s/hlp.sqlite
sqlalchemy.url = postgresql://postgres:postgres@localhost:5432/hlp

# By default, the toolbar only appears for clients from IP addresses
# '127.0.0.1' and '::1'.
# debugtoolbar.hosts = 127.0.0.1 ::1

###
# wsgi server configuration
###

[server:main]
use = egg:waitress#main
host = 0.0.0.0
port = 6543

[alembic]
# path to migration scripts
script_location = hlp:alembic

в проекте создаем папку alembic со следующей структурой:

 alembic/$ tree
.
├── env.py
├── script.py.mako
└── versions
    └── 29ac938c56f_starting.py

env.py

from __future__ import with_statement
from alembic import context
from sqlalchemy import engine_from_config
from sqlalchemy.engine.base import Engine
from pyramid.paster import setup_logging

# this is the Alembic Config object, which provides
# access to the values within the .ini file in use.
config = context.config

from hlp.models import Base

setup_logging(config.config_file_name)

engine = engine_from_config(config.get_section('app:main'), 'sqlalchemy.')

target_metadata = Base.metadata


def run_migrations_offline():
    """Run migrations in 'offline' mode.

    This configures the context with just a URL
    and not an Engine, though an Engine is acceptable
    here as well. By skipping the Engine creation
    we don't even need a DBAPI to be available.

    Calls to context.execute() here emit the given string to the
    script output.

    """
    context.configure(url=engine.url)

    with context.begin_transaction():
        context.run_migrations()


def run_migrations_online():
    """Run migrations in 'online' mode.

    In this scenario we need to create an Engine
    and associate a connection with the context.

    """

    if isinstance(engine, Engine):
        connection = engine.connect()
    else:
        raise Exception(
            'Expected engine instance got %s instead' % type(engine)
        )

    context.configure(
        connection=connection,
        target_metadata=target_metadata
    )

    try:
        with context.begin_transaction():
            context.run_migrations()
    finally:
        connection.close()

if context.is_offline_mode():
    run_migrations_offline()
else:
    run_migrations_online()

script.py.mako

"""${message}

Revision ID: ${up_revision}
Revises: ${down_revision}
Create Date: ${create_date}

"""

# revision identifiers, used by Alembic.
revision = ${repr(up_revision)}
down_revision = ${repr(down_revision)}

from alembic import op
import sqlalchemy as sa
${imports if imports else ""}

def upgrade():
${upgrades if upgrades else "pass"}


def downgrade():
${downgrades if downgrades else "pass"}

Создаем первую миграцию:

$ alembic revision --autogenerate -m "create table"

переходим к последней миграции:

$ alembic upgrade head

Есть ешё ништиковые команды типа:

$ alembic upgrade +2
$ alembic downgrade -1
$ alembic upgrade 29ac
$ alembic history
$ alembic current

пример исключения таблиц из миграций http://blog.utek.pl/2013/ignoring-tables-in-alembic/

подробнее здесь https://alembic.readthedocs.org/en/latest/tutorial.html

Демо репозитарий 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).

CRUD интерфейс для SQLAlchemy и подключение к Pyramid

2013-03-09T02:55:00Z

Запилил Yet another CRUD интерфейс для SQLAlchemy. По сути это аналог Django админки или FormAlchemy, но ОЧЕНЬ сильно упрощенный, ничего лишнего. Есть поддержка большинства полей + кастомные поля типа файл (для загрузки файлов, изображений) и GUID. Довольно просто подключить к Pyramid проекту и сразу начать работать по адресу http://localhost:6543/sacrud

Проект доступен на github https://github.com/uralbash/sacrud

В след. релизах планирую добавить новые типы полей, кастомные поля типа tree и btree с AJAX обработкой в интерфейсе, расширение для других фреймворков (например flask), кастомные фильтры, пагинацию итд

Установка

PyPi

$ pip install sacrud

source

$ python setup.py install

Пример использования в Pyramid

Add to your project config:

# pyramid_jinja2 configuration
config.include('pyramid_jinja2')
config.add_jinja2_search_path("myprojectname:templates")

from .models import (Model1, Model2, Model3,)
# add sacrud and project models
config.include('sacrud.pyramid_ext')
settings = config.registry.settings
settings['sacrud_models'] = (Model1, Model2, Model3)

go to http://localhost:6543/sacrud

Скриншоты

список таблиц

список записей в таблице

редактирование записи

Использование SQLAlchemy в дополнениях к Pyramid

2013-02-17T17:43:00Z

У меня есть дополнение к pyramid которое я включаю почти в каждый проект при помощи includeme (include()). Приложение это дает мне простой CRUD интерфейс с Jinja шаблонами малой кровью. Что позволяет избавиться от монстра FormAlchemy. Естественно каждый проект имеет свое название поэтому пришлось применить немного магии что бы создать универсальный механизм получения DBSession в своем подключаемом дополнении.

Примерная структура папок дополнения:

pyramid_ext_plugin
|-- __init__.py
`-- action.py

В __init__.py находятся все настройки includeme, а в action.py действия с базой. Для получения DBSession в action.py исправим сначала __init__.py:

__init__.py

import sqlalchemy
import sqlalchemy.orm as orm
from zope.sqlalchemy import ZopeTransactionExtension

DBSession = None


def includeme(config):
    global DBSession
    engine = sqlalchemy.engine_from_config(config.registry.settings)
    if DBSession is None:
        DBSession = orm.scoped_session(
            orm.sessionmaker(extension=ZopeTransactionExtension()))
    DBSession.remove()
    DBSession.configure(bind=engine)

Все Ж) теперь можно в action.py писать так:

action.py

from pyramid_ext_pugin import DBSession

Меняем заголовок ответа в Pyramid/Pylons

2012-12-04T15:27:00Z

Обычно в заголовке находится что то типа:

Content-Length 6657
Content-Type text/html; charset=UTF-8
итд

Изменить заголовок можно например в настройках Apache или nginx или в самом приложении.

Для Pylons пишем WSGI middleware:

class HeaderMiddleware(object):
    '''WSGI middleware'''

    def __init__(self, application):

        self.app = application

    def __call__(self, environ, start_response):

        request = Request(environ)
        resp = request.get_response(self.app)
        resp.headers['X-Frame-Options'] = 'DENY'

        return resp(environ, start_response)

Для Pyramid можно обойтись без WSGI:

view.py

from pyramid.events import subscriber
from pyramid.events import NewRequest

@subscriber(NewRequest)
def add_header(event):
    response = event.request.response
    response.headers.add('X-Frame-Options', 'DENY')

CMS на python-pyramid

2012-11-21T15:41:00Z

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

pyramid_promosite - это не CMS это движок сайта написанный на Pyramid. Этот движок дает вам из коробки редактор страниц как django flatpages, простую админку, возможность переводить страницу на другие языки и ВАЙСВИГ редактор с возможностью загружать изображения

Способ применения:

устанавливаем pyramid_promosite
создаем свой проект
включаем pyramid_promosite в свой проект через include
делаем свои шаблоны
пишем свои страницы со вьюхами (если нужны)

все...

Пример сайта https://github.com/uralbash/platonaps.ru:

Подробнее на https://github.com/uralbash/pyramid_promosite

Документация в планах, если что то непонятно то отвечу здесь либо в github’е

Redactor-js WYSIWYG редактор и python

2012-11-02T16:11:00Z

Redactor-js - это простой вайсвиг с возможностью загрузки изображений.

demo: http://imperavi.com/redactor/

github: https://github.com/dybskiy/redactor-js

Как сочленить это с php можно прочитать из документации http://imperavi.com/redactor/docs/images/. Там же есть ссылка на пример с Django от Patrick Altman. Я же постараюсь описать как загружать картинки при помощи pyramid фреймворка, думаю переписать на что то другое не составит труда.

js функция redactor’а у меня выглядит вот так:

<!-- Redactor is here -->
<link rel="stylesheet" href="/static/redactor/redactor/redactor.css">
<script src="/static/redactor/redactor/redactor.js"></script>

<script type="text/javascript">
$(document).ready(
  function()
  {
    $('#redactor_content').redactor({
      imageUpload: '/image/upload',
      imageGetJson: '/image/GetJson',
      mobile: true
    });
  }
);
</script>

вьюха для загрузки изображений:

@view_config(route_name='upload_image', renderer='json')
def upload_image(request):
    # путь к директории куда загружать картинку
    path = request.registry.settings.get('redactor_images')

    filename = str(time.time()) + request.POST['file'].filename
    input_file = request.POST['file'].file

    # Using the filename like this without cleaning it is very
    # insecure so please keep that in mind when writing your own
    # file handling.
    file_path = os.path.join(path, filename)
    output_file = open(file_path, 'wb')

    # Finally write the data to the output file
    input_file.seek(0)
    while 1:
        data = input_file.read(2 << 16)
        if not data:
            break
        output_file.write(data)
    output_file.close()

    return {"filelink": "/static/uploaded/images/" + filename}

И вьюха для выбора изображений из уже загруженных:

@view_config(route_name='GetJson'), renderer='json')
def imageGetJson(request):
    path = request.registry.settings.get('redactor_images')
    types = ('*.jpg', '*.jpeg', '*.gif')  # the tuple of file types

    files_grabbed = []
    for files in types:
        files_grabbed.extend(glob.glob(path + "/" + files))
    images = []
    for file in files_grabbed:
        file = file.replace(path, "")
        images.append({"thumb": "/static/uploaded/images/" + file,
             "image": "/static/uploaded/images/" + file,
             "title": file, "folder": "images"})

    return images

Пользуйтесь, хороший редактор.

Перевод шаблонов Jinja в Pyramid

2012-09-28T17:58:00Z

Основная документация как это делать здесь. Но как обычно есть нюансы.

Рабочий пример можно посмотреть установив шаблон. Устанавливаем pyramid_jinja2 и пишем:

$ pcreate -t pyramid_jinja2_starter yoyoyoyo

Если лень устанавливать пример, то нужно сделать следующее:

Добавить файл message-extraction.ini

[python: **.py]
[jinja2: **.jinja2]
encoding = utf-8

Добавить в setup.cfg:

[extract_messages]
add_comments = TRANSLATORS:
output_file = myprojectname/locale/myprojectname.pot
width = 80
mapping_file = message-extraction.ini

далее в __init__.py:

settings = dict(settings)
settings.setdefault('jinja2.i18n.domain', 'myprojectname')
...
config.add_translation_dirs("myprojectname:locale/")
config.include('pyramid_jinja2')
config.add_jinja2_search_path("myprojectname:templates")

В шаблоне:

{{ gettext('Logo') }}
{% trans %}Home{% endtrans %}

все остальное по документации... Я для упрощения использую скрипт i18n.sh:

#!/usr/bin/env bash

py=python

$py setup.py extract_messages
$py setup.py update_catalog
$py setup.py compile_catalog
# vim:set et sts=4 ts=4 tw=80:

CMS на Pyramid фреймворке

2012-09-26T15:30:00Z

Poolyx CMS - малоизвестная система управления сайтом написанная на Python с применением Pyramid немецкими кодерами.

В будущем будет называться nive. Советую попробовать, по крайне мере мне показалась намного удобнее Kotti.

Простой блог на фреймворке Pyramid

2012-09-11T17:14:00Z

Пример простого блога на Pyramid https://github.com/uralbash/pyramid_easy_blog

Фьючерсы:

wysiwyg редактор
загрузка изображений
мобайл фон реди

Туду:

коменты
теги
удаление изображений (файл менеджер)

пул реквест реди

Структура Pyramid приложений как в Django

2012-07-05T10:42:00Z

Одной из причин отказа развивать ветку Pylons стала его архитектура проекта. Все контроллеры хранятся в директории controllers, модели в models, шаблоны в templates. Это очень удобно когда у вас маленький проект, но если он разрастается до десятков и сотен сущностей, то становится крайне сложно скакать по этим папкам выискивая нужный файл, относящийся именно к этой сущности. В Django сделано по другому, в проекте хранятся приложения (application) - это такие маленькие подпрограммы которые отвечают за конкретный функционал проекта (например фотогалерея django-photologue или дерево сайта django-sitetree и прочее). Каждое такое приложение имеет свою папку и уже в ней хранятся контроллеры (views в данном случае) и модели (models). Т.е. вместо такой архитектуры Pylons:

Project/
    controllers/
        controllers1.py
        controllers2.py
    model/
        models1.py
        models2.py
    templates/
        templates1/
        templates2/
    routes.py

мы получаем:

Project/
    app1/
        models.py
        routes.py
        views.py
    app2/
        models.py
        routes.py
        views.py
    templates/
        templates1/
        templates2/

Разработчики не стали менять архитектуру Pylons и создавать Pylons 2.0, а начали развивать новый проект Pyramid с похожей на Django структурой проекта. При этом Pylons не считается устаревшим, а просто имеет немного другой подход к разработке.

Стоит ли сейчас выбирать Pylons? Да, если вы его хорошо знаете и не планируете создавать слишком масштабное приложение, иначе лучше все таки выбрать Pyramid.

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

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

MyProject/
├── CHANGES.txt
├── development.ini
├── MANIFEST.in
├── myproject
│   ├── __init__.py
│   ├── models.py
│   ├── scripts/
│   ├── static/
│   ├── templates/
│   ├── tests.py
│   └── views.py
├── production.ini
├── README.txt
├── setup.cfg
└── setup.py

Наша задача перенести models.py, views.py, tests.py в app1. Создаем папку app1 и переносим файлы.

Должно получится так:

MyProject/
.
├── CHANGES.txt
├── development.ini
├── MANIFEST.in
├── myproject
│   ├── app1
│   │   ├── __init__.py
│   │   ├── models.py
│   │   ├── tests.py
│   │   └── views.py
│   ├── __init__.py
│   ├── scripts
│   │   ├── initializedb.py
│   │   └── __init__.py
│   ├── static
│   │   ├── favicon.ico
│   │   ├── footerbg.png
│   │   ├── headerbg.png
│   │   ├── ie6.css
│   │   ├── middlebg.png
│   │   ├── pylons.css
│   │   ├── pyramid.png
│   │   ├── pyramid-small.png
│   │   └── transparent.gif
│   └── templates
│       └── mytemplate.pt
├── production.ini
├── README.txt
├── setup.cfg
└── setup.py

Меняем __init__.py в проекте:

Вместо

from pyramid.config import Configurator
from sqlalchemy import engine_from_config

from .models import DBSession

def main(global_config, **settings):
    """ This function returns a Pyramid WSGI application.
    """
    engine = engine_from_config(settings, 'sqlalchemy.')
    DBSession.configure(bind=engine)
    config = Configurator(settings=settings)
    config.add_static_view('static', 'static', cache_max_age=3600)
    config.add_route('home', '/')
    config.scan()
    return config.make_wsgi_app()

Делаем

from pyramid.config import Configurator
from sqlalchemy import engine_from_config

from .models import DBSession

def main(global_config, **settings):
    """ This function returns a Pyramid WSGI application.
    """
    engine = engine_from_config(settings, 'sqlalchemy.')
    DBSession.configure(bind=engine)
    config = Configurator(settings=settings)
    config.add_static_view('static', 'static', cache_max_age=3600)

    # add config for each of your subapps
    config.include('myproject.app1')

    # pyramid_jinja2 configuration
    config.include('pyramid_jinja2')
    config.add_jinja2_search_path("myproject:templates")

    return config.make_wsgi_app()

Теперь в этом __init__.py мы будем хранить глобальные настройки, а в инитах апликайшинах настройки самих апликайшинов.

Добавляем models.py в основной проект:

MyProject/
.
├── CHANGES.txt
├── development.ini
├── MANIFEST.in
├── myproject
│   ├── app1
│   │   ├── __init__.py
│   │   ├── models.py
│   │   ├── tests.py
│   │   └── views.py
│   ├── __init__.py
│   ├── scripts
│   │   ├── initializedb.py
│   │   └── __init__.py
│   ├── models.py
│   ├── static
│   │   ├── favicon.ico
│   │   ├── footerbg.png
│   │   ├── headerbg.png
│   │   ├── ie6.css
│   │   ├── middlebg.png
│   │   ├── pylons.css
│   │   ├── pyramid.png
│   │   ├── pyramid-small.png
│   │   └── transparent.gif
│   └── templates
│       └── mytemplate.pt
├── production.ini
├── README.txt
├── setup.cfg
└── setup.py

В нем будет хранится сессия SQLAlchemy общая для всех проектов:

from zope.sqlalchemy import ZopeTransactionExtension
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import (
    scoped_session,
    sessionmaker,
    )

DBSession = scoped_session(sessionmaker(extension=ZopeTransactionExtension()))
Base = declarative_base()

Меняем __init__.py в app1:

def includeme(config):
    config.add_route('home', '/')
    config.scan()

Меняем models.py в app1:

from sqlalchemy import (
    Column,
    Integer,
    Text,
    )

from sqlalchemy.ext.declarative import declarative_base

from sqlalchemy.orm import (
    scoped_session,
    sessionmaker,
    )

from ..models import (
    DBSession,
    Base,
    )

class MyModel(Base):
    __tablename__ = 'models'
    id = Column(Integer, primary_key=True)
    name = Column(Text, unique=True)
    value = Column(Integer)

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

Меняем tests.py:

import unittest
import transaction

from pyramid import testing

from ..models import DBSession

class TestMyView(unittest.TestCase):
    def setUp(self):
        self.config = testing.setUp()
        from sqlalchemy import create_engine
        engine = create_engine('sqlite://')
        from .models import (
            Base,
            MyModel,
            )
        DBSession.configure(bind=engine)
        Base.metadata.create_all(engine)
        with transaction.manager:
            model = MyModel(name='one', value=55)
            DBSession.add(model)

    def tearDown(self):
        DBSession.remove()
        testing.tearDown()

    def test_it(self):
        from .views import my_view
        request = testing.DummyRequest()
        info = my_view(request)
        self.assertEqual(info['one'].name, 'one')
        self.assertEqual(info['project'], 'MyProject')

Меняем views.py:

from sqlalchemy.exc import DBAPIError

from ..models import DBSession
from .models import MyModel

@view_config(route_name='home', renderer='../templates/mytemplate.pt')
def my_view(request):
    try:
        one = DBSession.query(MyModel).filter(MyModel.name=='one').first()
    except DBAPIError:
        return Response(conn_err_msg, content_type='text/plain', status_int=500)
    return {'one':one, 'project':'MyProject'}

conn_err_msg = """\
Pyramid is having a problem using your SQL database.  The problem
might be caused by one of the following things:

A.  You may need to run the "initialize_MyProject_db" script
    to initialize your database tables.  Check your virtual
    environment's "bin" directory for this script and try to run it.

B.  Your database server may not be running.  Check that the
    database server referred to by the "sqlalchemy.url" setting in
    your "development.ini" file is running.

After you fix the problem, please restart the Pyramid application to
try it again.
"""

Меняем initializedb.py в scripts:

import os
import sys
import transaction

from sqlalchemy import engine_from_config

from pyramid.paster import (
    get_appsettings,
    setup_logging,
    )

from ..models import (
    DBSession,
    Base,
    )

from ..app1.models import MyModel

def usage(argv):
    cmd = os.path.basename(argv[0])
    print('usage: %s <config_uri>\n'
          '(example: "%s development.ini")' % (cmd, cmd))
    sys.exit(1)

def main(argv=sys.argv):
    if len(argv) != 2:
        usage(argv)
    config_uri = argv[1]
    setup_logging(config_uri)
    settings = get_appsettings(config_uri)
    engine = engine_from_config(settings, 'sqlalchemy.')
    DBSession.configure(bind=engine)
    Base.metadata.create_all(engine)
    with transaction.manager:
        model = MyModel(name='one', value=1)
        DBSession.add(model)

Выполняем python setup.py install, запускаем проект, профит!
Остальные апликайшины добавляются по аналогии.
Навеянно этим http://stackoverflow.com/questions/6012991/pyramid-project-structure

pyramid_formalchemy

2012-07-04T11:51:00Z

FormAlchemy это CRUD для SQLAlchemy. Для Pylons существовало расширение прямо в самом модуле в разделе ext. Для Pyramid создали отдельный пакет pyramid_formalchemy. Посмотрим как это работает:

Создаем проект:

$ pcreate -s alchemy -s pyramid_fa myapp

добавляем в проект файл forms.py:

forms.py

from formalchemy import FieldSet, Grid

структура файлов должна выглядеть так:

| |+static/
| |+templates/
| |-__init__.py
| |-faforms.py
| |-fainit.py
| |-faroutes.py
| |-forms.py
| |-models.py
| |-tests.py
| `-views.py

изменяем __init__.py:

__init__.py

from pyramid.config import Configurator
from sqlalchemy import engine_from_config

from .models import DBSession

def main(global_config, **settings):
    """ This function returns a Pyramid WSGI application.
    """
    engine = engine_from_config(settings, 'sqlalchemy.')
    DBSession.configure(bind=engine)
    config = Configurator(settings=settings)
    config.add_static_view('static', 'static', cache_max_age=3600)
    config.add_route('home', '/')
    config.scan()

    # pyramid_formalchemy's configuration
    config.include('pyramid_fanstatic')
    config.include('pyramid_formalchemy')
    config.include('fa.jquery')

    # register an admin UI
    config.formalchemy_admin('/admin', package='youAppName',
            view='fa.jquery.pyramid.ModelView')

 return config.make_wsgi_app()

Заходим в http://0.0.0.0:6543/admin/ и радуемся.

Online демо находится здесь.