BlogJava-Read Sean-随笔分类-On Python

pyPdf - 用Python方便的处理PDF文档

laogao — Tue, 26 Jul 2011 14:25:00 GMT

今天临时有个需求，那就是给某PDF文档切边，以方便在Kindle 3的6吋屏上阅读。

很久没碰Python了，不过我相信用Python一定有办法解决这个需求，于是经过简单的googling，便发现了这个pyPdf库 ( http://pybrary.net/pyPdf/ ) ，操作起来相当直接易懂，把代码贴在这儿，做个记录。

1 from pyPdf import PdfFileWriter, PdfFileReader
2
3 pdf = PdfFileReader(file('original.pdf', 'rb'))
4 out = PdfFileWriter()
5
6 for page in pdf.pages:
7   page.mediaBox.upperRight = (580,800)
8   page.mediaBox.lowerLeft = (128,232)
9   out.addPage(page)
10
11 ous = file('target.pdf', 'wb')
12 out.write(ous)
13 ous.close()

Enjoy!

laogao 2011-07-26 22:25 发表评论

[Pylons] Mako页面模板引擎

laogao — Tue, 27 Jan 2009 07:50:00 GMT

Pylons是一个典型的MVC Web框架，在之前的几篇随笔中，我们一起了解了Pylons的安装、默认项目结构、Routes和controller("C")以及SQLAlchemy("M")，在这个系列的最后，我们一起来看看"V"。

在我们的controller代码中，每个action在return的时候，可以选择：
1- 直接return字符串
2- 通过render()函数将输出交给页面模板引擎处理
3- redirect_to()重定向到其他URL

直接return太简单，redirect_to也没有特别需要介绍的，重点看render()。如果你一直follow这个系列，那么在你的controllers/hello.py中，可以看到这样一行import：

from newapp.lib.base import BaseController, render

从lib.base引入了一个render函数，跟到lib/base代码里查看，我们会知道：

from pylons.templating import render_mako as render

其实我们用到的render()函数，是pylons.templating.render_mako的别名。

注: 这里假定你在paster create时选择了默认的mako，其他Pylons原生支持的页面模板引擎还有结构相对更层次化的Genshi和更接近Django实现的Jinja。

render_mako()函数签名如下：
render_mako(template_name, extra_vars=None, cache_key=None, cache_type=None, cache_expire=None)

最基本的用法是给出template文件名，然后通过extra_vars传入参数，Pylons默认查找页面模板文件是在项目的templates子目录，这个路径也可以在config/environment.py中修改。在Pylons中，被推荐的传参做法是使用tmpl_context，在生成controller的时候，已经自动import了tmpl_context并别名为c，这样，我们只需要在c上绑上我们需要传递给模板的数据，模板在解析时，也就能够通过c得到这些数据了。像这样：

c.name = u'Pylons n00b'
return render('hello.mako')

然后，在hello.mako中：

<h3>Hello <b>${c.name}b>!h3>

在模板代码中，有些Pylons系统变量/函数是可以直接访问的，包括：
tmpl_context (c) - 用于controller和template传递数据
config - 配置信息
app_globals (g) - 应用的全局变量
h - WebHelpers，包括h.form、h.link_to、h.url_for等等实用函数
request - 请求
response - 应答
session - 会话信息
translator、ungettext()、_()、N_() - 处理国际化

除了基本的${}变量替代语法之外，类似JSP，Mako还支持注释、if/else/for控制逻辑、代码片段、return、标签等，具体的可以扫一眼官方说明：
http://www.makotemplates.org/docs/syntax.html
很精简，也非常容易理解，这里就不详细说明了。

至此，我们已经了解了Pylons最核心的几个组件，足够我们搭建常规的Web应用了。其他值得大家继续挖掘的内容包括：国际化、表单验证(FormEncode)、用户验证和权限(AuthKit、repoze.who、repoze.what)、AJAX、Python 3.0、WSGI基础架构等。

本文是该系列最后一篇，希望通过简单的介绍和学习，大家能够喜欢并顺利的上手Pylons，也希望越来越多的人关注这个优秀的Python Web应用框架。

laogao 2009-01-27 15:50 发表评论

[Pylons] 在Pylons环境下使用SQLAlchemy

laogao — Tue, 27 Jan 2009 06:00:00 GMT

在前面的4篇随笔中，我们简要的介绍了SQLAlchemy，不过SQLAlchemy如何被集成到Pylons应用中呢？

首先我们看一下自动生成代码中的model子目录，其中有两个文件__init__.py和meta.py，其中meta.py定义了engine、Session和metadata三个公用变量，而__init__.py提供了一个核心的init_model(engine)方法，该方法分别将数据库engine和经过sessionmaker和scoped_session包装的Session对象植入到meta中，像这样：

    sm = orm.sessionmaker(autoflush=True, autocommit=True, bind=engine)

    meta.engine = engine
    meta.Session = orm.scoped_session(sm)

这样一来，整个背后的"magic"就还剩下最后一块"拼图"：谁来把engine初始化好并调用init_model方法呢？看看config/environment.py就清楚了：

1 """Pylons environment configuration"""
2 import os
3
4 from mako.lookup import TemplateLookup
5 from pylons.error import handle_mako_error
6 from pylons import config
7 from sqlalchemy import engine_from_config
8
9 import newapp.lib.app_globals as app_globals
10 import newapp.lib.helpers
11 from newapp.config.routing import make_map
12 from newapp.model import init_model
13
14 def load_environment(global_conf, app_conf):
15     """Configure the Pylons environment via the ``pylons.config``
16     object
17     """
18     # Pylons paths
19     root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
20     paths = dict(root=root,
21                  controllers=os.path.join(root, 'controllers'),
22                  static_files=os.path.join(root, 'public'),
23                  templates=[os.path.join(root, 'templates')])
24
25     # Initialize config with the basic options
26     config.init_app(global_conf, app_conf, package='newapp', paths=paths)
27
28     config['routes.map'] = make_map()
29     config['pylons.app_globals'] = app_globals.Globals()
30     config['pylons.h'] = newapp.lib.helpers
31
32     # Create the Mako TemplateLookup, with the default auto-escaping
33     config['pylons.app_globals'].mako_lookup = TemplateLookup(
34         directories=paths['templates'],
35         error_handler=handle_mako_error,
36         module_directory=os.path.join(app_conf['cache_dir'], 'templates'),
37         input_encoding='utf-8', output_encoding='utf-8',
38         imports=['from webhelpers.html import escape'],
39         default_filters=['escape'])
40
41     # Setup SQLAlchemy database engine
42     engine = engine_from_config(config, 'sqlalchemy.')
43     init_model(engine)
44
45     # CONFIGURATION OPTIONS HERE (note: all config options will override
46     # any Pylons config options)

注意第7行的import和第42、43行代码，是不是豁然开朗？Pylons在初始化运行环境时，从config中读取sqlalchemy相关的配置信息，然后通过这些配置信息创建数据库engine，并调用init_model()方法初始化SQLAlchemy功能的核心对象：metadata和Session。有了meta.Session，我们就可以方便的在代码中执行对model层/数据库的访问了。

laogao 2009-01-27 14:00 发表评论

[Pylons] SQLAlchemy起步 - IV. Object Relational Mapper

laogao — Tue, 27 Jan 2009 04:52:00 GMT

接着前面的例子说，我们定义了book_table和author_table，接下来：

1 class Book(object):
2     def __init__(self, title):
3         self.title = title
4     def __repr__(self):
5         return "" % self.title
6
7 class Author(object):
8     def __init__(self, name):
9         self.name = name
10     def __repr__(self):
11         return "" % self.name

这里我们定义两个类，继承自object，类似JavaBeans或者POJO，这里的__init__方法和__repr__方法不是必须的，只是为了创建对象和输出对象内容比较方便。然后就可以用SQLAlchemy的mapper和sessionmaker来建立映射关系并处理持久和查询等操作：

1 from sqlalchemy.orm import mapper,sessionmaker
2
3 mapper(Book, book_table)
4 mapper(Author, author_table)
5
6 Session = sessionmaker(bind=engine)
7 session = Session()
8
9 gia = Book(u'Groovy in Action')
10 ag = Author(u'Andrew Glover')
11
12 session.add(gia)
13 session.add(ag)
14 session.add_all([Book('Hibernate in Action'), Author('Gavin King')])
15 s_gia = session.query(Book).filter_by(title=u'Groovy in Action').first()
16 s_gia.title =u'Groovy in Action Updated'
17
18 print "[DIRTY]", session.dirty
19
20 session.commit() # or session.rollback()

如果你用过Hibernate，那么这些代码对你来说，理解起来应该没有任何难度。

假如我告诉你，每次都要像这样先定义Table(schema)，再定义class，然后用mapper建立对照，是不是有点那啥？SQLAlchemy的开发者们也意识到这一点，所以从0.5开始，SQLAlchemy可以通过sqlalchemy.ext.declarative支持我们实现更紧凑的model/schema定义：

1 from sqlalchemy.schema import Table, Column, ForeignKey, Sequence
2 from sqlalchemy.types import *
3 from sqlalchemy.orm import relation
4 from sqlalchemy.ext.declarative import declarative_base
5
6 Base = declarative_base()
7 metadata = Base.metadata
8
9 bookauthor_table = Table('bookauthor', metadata,
10     Column('book_id', Integer, ForeignKey('book.id'), nullable=False),
11     Column('author_id', Integer, ForeignKey('author.id'), nullable=False),
12 )
13
14 class Book(Base):
15     __tablename__ = 'book'
16     id = Column(Integer, Sequence('seq_pk'), primary_key=True)
17     title = Column(Unicode(255), nullable=False)
18     authors = relation('Author', secondary=bookauthor_table)
19
20
21 class Author(Base):
22     __tablename__ = 'author'
23     id = Column(Integer, Sequence('seq_pk'), primary_key=True)
24     name = Column(Unicode(255), nullable=False)
25     books = relation('Book', secondary=bookauthor_table)

这里我们用到了many-to-many关系，其他的常见用法还包括many-to-one、one-to-many、JOIN、子查询、EXISTS、Lazy/Eager Load、Cascade (all/delete/delete-orphan)等等，大家可以根据需要查阅官方文档。

laogao 2009-01-27 12:52 发表评论

[Pylons] SQLAlchemy起步 - III. SQL Expression Language

laogao — Mon, 26 Jan 2009 15:40:00 GMT

在介绍SQLAlchemy最核心最有价值的ORM部分之前，我们再简单过一遍SQLAlchemy提供的SQL Expression Language用法，就从最基本的CRUD来举例说明吧（接着上一篇的示例）：

1 from sqlalchemy import select,update,delete
2
3 conn = engine.connect()
4 book_ins = book_table.insert(values=dict(title=u'Groovy in Action'))
5 author_ins = author_table.insert(values=dict(name=u'Andrew Glover'))
6 conn.execute(book_ins)
7 conn.execute(author_ins)
8 book = conn.execute(select([book_table], book_table.c.title.like(u'Groovy%'))).fetchone()
9 author = conn.execute(select([author_table])).fetchone()
10 bookauthor_ins = bookauthor_table.insert(values=dict(book_id=book[0],author_id=author[0]))
11 conn.execute(bookauthor_ins)
12 conn.execute(update(book_table,book_table.c.title==u'Groovy in Action'), title=u'Groovy in Action (中文版)')
13 conn.execute(delete(bookauthor_table))
14 conn.close()

简单说明一下代码逻辑：
首先从engine建立连接，然后做两个insert动作，分别insert一条book记录(title为'Groovy in Action')和一条author记录(name为'Andrew Glover')，这之后分别再做两次select，得到刚insert的这两条记录，其中book记录的select用到了过滤条件，相当于"WHERE book.title like 'Groovy%'"，然后构建一条新的insert语句，用于insert一条bookauthor关系记录，接下来，做一次update，将book.title为'Groovy in Action'的更新为'Groovy in Action (中文版)'，最后，在关闭连接之前，做一次delete，删除bookauthor中的记录。

在指定WHERE条件时，.c是.columns的简写，所以book_table.c.title指代的就是book表的title列。更高级的用法是采用"&"、"|"、"!"三个符号，分别表示AND、OR和NOT，加上必要的"("和")"实现复杂的条件定义。由于传递给select()的第一个参数是个list，所以你应该已经猜到了，我们也可以多张表做关联查询。

laogao 2009-01-26 23:40 发表评论

[Pylons] SQLAlchemy起步 - II. MetaData和Types

laogao — Mon, 26 Jan 2009 14:14:00 GMT

在sqlalchemy.schema和sqlalchemy.types这两个module中，包含了定义数据库schema所需要的所有类，如Table、Column、String、Text、Date、Time、Boolean等。还是来看一个例子：

1 from sqlalchemy.engine import create_engine
2 from sqlalchemy.schema import MetaData, Table, Column, ForeignKey, Sequence
3 from sqlalchemy.types import *
4
5 engine = create_engine('postgres://test:test@localhost/test', echo=True)
6
7 metadata = MetaData()
8 metadata.bind = engine
9
10 book_table = Table('book', metadata,
11     Column('id', Integer, Sequence('seq_pk'), primary_key=True),
12     Column('title', Unicode(255), nullable=False),
13 )
14
15 author_table = Table('author', metadata,
16     Column('id', Integer, Sequence('seq_pk'), primary_key=True),
17     Column('name', Unicode(255), nullable=False),
18 )
19
20 bookauthor_table = Table('bookauthor', metadata,
21    Column('book_id', Integer, ForeignKey('book.id'), nullable=False),
22    Column('author_id', Integer, ForeignKey('author.id'), nullable=False),
23)
24
25metadata.create_all(checkfirst=True)

首先我们还是create_engine，然后新建一个MetaData对象，把engine绑上去，接下来，开始在metadata中定义表结构(metadata由Table构造函数传入)，我们这里定义了3张表，分别是book、author和bookauthor关系表(“多对多”)，其中新建一个Sequence对象，专门处理主键生成。最后我们通过执行metadata.create_all()创建数据库表，参数checkfirst=True表示如果数据库相关对象已经存在，则不重复执行创建。

对于已经存在于数据库中的表，我们可以通过传入autoload=True参数到Table构造函数的方式来加载现有的表结构到metadata中，而不必挨个儿再写一遍Column清单。

看到这儿，你也许觉得挺麻烦，不是么？Django和RoR都是可以直接定义数据model类，顺带就把schema也定义了，而不是像这样单独去写表结构的schema，显得很"底层"。确实，这样用SQLAlchemy并不是最优化的，SQLAlchemy本身并不会自动的帮你做很多事，但它基础打得很牢。如果你感兴趣，也可以先去看一下SQLAlchemy的扩展模块Elixir，通过Elixir，你可以像Ruby on Rails那样定义出实体和关系("Active Record")。

在稍后的第4部分中，我们会去了解如何以声明方式来更紧凑的定义我们的model/schema(0.5新特性)。鉴于笔者倾向于更强的控制力，所以在这个系列中就不去介绍SQLAlchemy的其他扩展模块了，如Elixir、SQLSoup等，大家可以根据需要去找下官方文档。

laogao 2009-01-26 22:14 发表评论

[Pylons] SQLAlchemy起步 - I. Engine API

laogao — Mon, 26 Jan 2009 12:46:00 GMT

ORM是个大话题，大到可能好几本书都说不完。SQLAlchemy，别看它刚出到0.5.2，已然是Python世界ORM的事实标准，受到众多开发者和无数框架的青睐。

如果之前没有或很少接触SQLAlchemy，那么学习Pylons可能有相当一部分时间都会花在SQLAlchemy上。通常，人们选择Pylons或者TurboGears而不是Django，SQLAlchemy在这些决定的背后有着很重的分量。作为Pylons学习笔记的一部分，接下来我将分4篇随笔介绍SQLAlchemy，分别是Engine API、Schema Management (MetaData/Types)、SQL Expression Language和Object Relational Mapper。此文为第1篇，重点介绍Engine API。

类似Java的JDBC，Python也有一个类似的数据库访问接口规范，那就是DB-API(目前是2.0)，不同的常见RDBMS都有符合DB-API标准的Python库，比如PostgreSQL有psycopg2，Oracle有cx_Oracle等。有了这个基础，SQLAlchemy也就得以方便的通过DB-API连接不同的数据库。

以PostgreSQL为例，通过SQLAlchemy的Engine API访问数据库的代码可以这样来写：

1 from sqlalchemy.engine import create_engine
2
3 engine = create_engine('postgres://user:pass@localhost/testdb')
4 connection = engine.connect()
5 connection.execute(
6     """
7     CREATE TABLE book
8     (
9       id serial NOT NULL,
10      title character varying(30) NOT NULL,
11      CONSTRAINT pk_book PRIMARY KEY (id)
12     );
13    """
14 )
15 connection.execute(
16     """
17     INSERT INTO book (title) VALUES (%s);
18     """,
19     "The Art of UNIX Programming"
20 )
21 rs = connection.execute("SELECT title FROM book")
22 for row in rs:
23     print "Book Title: ", row['title']
24 connection.close()

基本步骤就是create_engine、connect、execute和close，没有很特别的地方，不过SQLAlchemy的Engine API，并不是简单的DBAPI调用，而是包装了其他内容，如数据库连接池，我们可以在create_engine的时候指定连接池参数和其他额外配置，类似这样：

engine = create_engine('postgres://user:pass@localhost/testdb', pool_size=10, convert_unicode=True)

类似Spring的JdbcTemplate，更多的时候，统一使用SQLAlchemy的Engine API而不是DB-API能给我们带来更大的灵活性，通常也更方便、更安全。

laogao 2009-01-26 20:46 发表评论

[Pylons] Routes和controller，一个简单的例子

laogao — Mon, 26 Jan 2009 08:21:00 GMT

在开始之前，说点提外话，随着对Pylons了解的深入，你可能时不时需要看看相关组件/软件包是否有更新出来，方法也不复杂，通过"easy_install -U [组件名]"即可，在学习或者是开发过程中，最好是保持环境相对较新，直到出现相对大的release或者即将进入产品部署阶段。

继续介绍Pylons组件，先看个例子。首先用"paster controller hello"增加一个controller，路径中会增加出以下两个文件：

controllers/hello.py
tests/functional/test_hello.py

分别对应新增的controller类HelloController和功能测试类TestHelloController，它们分别继承自WSGIController->BaseController和TestCase->TestController。

我们主要看hello.py，默认内容如下：

1 import logging
2
3 from pylons import request, response, session, tmpl_context as c
4 from pylons.controllers.util import abort, redirect_to
5
6 from newapp.lib.base import BaseController, render
7 #from newapp import model
8
9 log = logging.getLogger(__name__)
10
11 class HelloController(BaseController):
12
13     def index(self):
14         # Return a rendered template
15         #   return render('/template.mako')
16         # or, Return a response
17         return 'Hello World'

如果你的服务器没有Ctrl-C停掉，那么这个时候你已经可以通过
http://127.0.0.1:5000/hello/index
看到该controller的处理结果了(Hello World)。

简单改造一下17行：

from pylons import config
return '
'.join(config.keys())

我们就可以在返回页面上显示出所有可以通过pylons.config访问到的参数列表。出了返回文本，也可以通过render()方法交给页面模板引擎生成页面，也可以通过redirect_to()跳转到其他URL。

Pylons是如何找到该请求应该由HelloController的index方法来处理的呢？这背后发生了什么？答案就是Routes。

Routes的作者是Ben Bangert，是Pylons框架三个主要作者/维护者之一，早期的版本主要是仿照Ruby on Rails的routes.rb开发的，有RoR经验的朋友可能一眼就能发现它们之间的相似之处。目前Routes的最新版是1.10.2。

Pylons应用中，routing的配置在config/routing.py，默认生成的内容如下：

1 """Routes configuration
2
3 The more specific and detailed routes should be defined first so they
4 may take precedent over the more generic routes. For more information
5 refer to the routes manual at http://routes.groovie.org/docs/
6 """
7 from pylons import config
8 from routes import Mapper
9
10 def make_map():
11     """Create, configure and return the routes Mapper"""
12     map = Mapper(directory=config['pylons.paths']['controllers'],
13                  always_scan=config['debug'])
14     map.minimization = False
15
16     # The ErrorController route (handles 404/500 error pages); it should
17     # likely stay at the top, ensuring it can always be resolved
18     map.connect('/error/{action}', controller='error')
19     map.connect('/error/{action}/{id}', controller='error')
20
21     # CUSTOM ROUTES HERE
22
23     map.connect('/{controller}/{action}')
24     map.connect('/{controller}/{action}/{id}')
25
26     return map

在这个配置中，对我们刚才的实例起到决定性作用的是第23行，我们的输入URL为"http://127.0.0.1:5000/hello/index"，其中"/hello/index"通过"/{controller}/{action}"这个表达式match出controller为hello而action为index的解析结果，从而在controllers目录找到hello.py，和其中HelloController的index方法，进行调用。

map.connect()在上面代码中体现出两种用法：
map.connect('pattern', key=value) - 指定默认的controller、action、id等
map.connect('pattern') - 直接指定pattern

pattern字符串允许通配符，通常在最后一个元素上，比如'/{controller}/{action}/{*url}'，将后面的整个URL片段交给前面指定的controller/action处理。除此以外，map.connect()还支持

1- "路径别名"，如：
map.connect('name', 'pattern', [_static=True])
如果_static设为"True"，表示为"静态命名路径"。
2- 额外的匹配条件，如：
map.connect('/{controller}/{action}/{id}', requirements={'year': '\d+',})
map.connect('/{controller}/{action}/{id}', conditions=dict(method=['GET','POST']))

所有的route优先级为从上到下。Routes除了提供解析进来的URL的逻辑，在我们的controller和template代码中，我们还可以方便的通过WebHelpers的url_for()方法计算相应的URL。

Routes 1.x中的有一些仿routes.rb功能将会在2.0中被去掉，包括Route Minimization、Route Memory、Implicit Defaults等。如果有兴趣的话，可以参考一下官方文档，这里就不一一介绍了。为什么要去掉？当然主要的动机还是减少歧义，避免一些不必要的混淆。至于深层次的原因么，可以参考Tim Peters《The Zen of Python》中的一句经典的Python哲学：Explicit is better than implicit。什么？没有听说过？打开python命令行，输入"import this"后回车，慢慢体会其中的道理吧。:)

laogao 2009-01-26 16:21 发表评论

[Pylons] 默认项目结构

laogao — Mon, 26 Jan 2009 04:33:00 GMT

大家新年好！

在前一篇随笔中，大家了解了什么是Pylons，有哪些特点，今天笔者继续给介绍默认生成的项目结构。

通过Paste创建新的Pylons应用很简单，就是一句"paster create -t pylons [应用名]"命令，其中"-t pylons"或者全称"--template=pylons"，用以告诉Paste我们新建的项目，将是一个Pylons应用，或者说，从一个预定义好的Pylons默认项目模板生成。如果你愿意，你也可以自己来制作新的模板以符合需要。"paster create --list-templates"可以查看当前可用的模板。

假定我们新建的Pylons项目名称为NewApp，那么执行"paster create -t pylons NewApp"后，我们将得到一个新的NewApp目录，其中包含一个docs目录(文档)、一个newapp目录(代码)、一个NewApp.egg-info目录(元数据)和一些顶级配置文件。

在开发过程中，我们经常会用到的是代码目录(这里是newapp)和位于项目根目录下的development.ini和test.ini文件了。注意这里newapp的大小写，Pylons在生成项目的时候，不论你指定的项目名称大小写是怎样，这里会自动.lower()转小写，只有项目顶级路径和egg信息会保留原始大小写，笔者认为这更加符合Web应用的nature。

代码目录下包括config、controllers、lib、model、public、templates和tests子目录，分别用于存放配置(如环境、中间件、路径查找逻辑)、控制器(处理请求)、全局辅助代码(全局变量、helpers等)、模型(后台数据访问)、静态页面/媒体文件、页面模板和测试代码。

最后说说ini文件：默认生成的development.ini和test.ini顾名思义分别对应开发和测试需要的基本配置，我们可以通过修改相应的参数配置来指定具体设定，如服务器IP和端口、数据库连接、日志等。看到这里你也许会问，那么产品环境呢？答案是默认没有生成，你可以从development.ini修改成需要的产品环境配置，也可以通过paster make-config newapp production.ini生成一个默认的产品环境典型配置。

以development.ini为例，Pylons的ini文件主要包括4个部分的内容：

1- 全局默认参数，如

[DEFAULT]
debug = true
# Uncomment and replace with the address which should receive any error reports
#email_to = you@yourdomain.com
smtp_server = localhost
error_email_from = paste@localhost

2- 服务器配置，如

[server:main]
use = egg:Paste#http
host = 127.0.0.1
port = 5000

3- 应用程序配置，如

[app:main]
use = egg:NewApp
full_stack = true

cache_dir = %(here)s/data
beaker.session.key = newapp
beaker.session.secret = somesecret

# If you'd like to fine-tune the individual locations of the cache data dirs
# for the Cache data, or the Session saves, un-comment the desired settings
# here:
#beaker.cache.data_dir = %(here)s/data/cache
#beaker.session.data_dir = %(here)s/data/sessions

# SQLAlchemy database URL
sqlalchemy.url = sqlite:///%(here)s/development.db

# WARNING: *THE LINE BELOW MUST BE UNCOMMENTED ON A PRODUCTION ENVIRONMENT*
# Debug mode will enable the interactive debugging tool, allowing ANYONE to
# execute malicious code after an exception is raised.
#set debug = false

简单说明一下，这里的full_stack设置为true表示打开交互式调试和错误报告等功能，"%(here)s"会被替换成项目所在路径，类似相对路径url中的"."转绝对路径，而beaker.*为配置会话相关的设定，如缓存、cookie基本内容等。对于产品环境来说，比较重要的一个配置是"set debug=false"，否则一旦出现异常，交互式调试将使得攻击者能够执行系统命令。

4- 日志，如

[loggers]
keys = root, routes, newapp, sqlalchemy

[handlers]
keys = console

[formatters]
keys = generic

[logger_root]
level = INFO
handlers = console

[logger_routes]
level = INFO
handlers =
qualname = routes.middleware
# "level = DEBUG" logs the route matched and routing variables.

[logger_newapp]
level = DEBUG
handlers =
qualname = newapp

[logger_sqlalchemy]
level = INFO
handlers =
qualname = sqlalchemy.engine
# "level = INFO" logs SQL queries.
# "level = DEBUG" logs SQL queries and results.
# "level = WARN" logs neither. (Recommended for production systems.)

[handler_console]
class = StreamHandler
args = (sys.stderr,)
level = NOTSET
formatter = generic

[formatter_generic]
format = %(asctime)s,%(msecs)03d %(levelname)-5.5s [%(name)s] %(message)s
datefmt = %H:%M:%S

OK，这一篇就先讲到这儿，下一篇将介绍Routes和controller。

laogao 2009-01-26 12:33 发表评论

[Pylons] 简介+安装指南

laogao — Sun, 25 Jan 2009 12:05:00 GMT

Pylons是一个Python语言的Web应用程序框架，如果你简单了解过Ruby on Rails和Django，你大概会问，Pylons有什么不一样呢？Pylons最大的特点是模块化，将处理Web应用环境下不同领域、不同问题的软件包集成在一起，形成一个整体，在提供一揽子解决方案的同时，不阻碍你选择别的替代组件。另外，Pylons是目前对WSGI标准支持最好的框架之一，未来的TurboGears 2.0也会基于Pylons构建。

Pylons从Ruby on Rails借鉴了不少东西，比如Routes，比如WebHelpers，从表面看更像是Python版的RoR，不过底下的架构应该说更加轻量和灵活，因为你可以灵活选择自己熟悉或者更贴和具体应用实际的组件，从ORM到页面模板，Pylons只是推荐一些大家普遍比较认可的选项，但并不强制你使用它们。

说完和Ruby on Rails的异同，当然也要回过头来说说同样是Python编写的Django。如果你只是想迅速的构建一个可以支撑大量访问的Web应用，Django是个不错的选择，但和RoR一样，你在很大程度上被限制在一定的pattern中：如果你按照Django的思路去实现你的应用，你会很happy；但一旦你觉得某个组件你不喜欢、不符合某个实际要求，想要来点定制，你就会觉得有些伸不开拳脚，或者工程浩大。目前感觉Django比较不爽的地方有：页面模板较弱，表现力有些不足，也有人说够用了；ORM目前是自己的一套，暂时没有成熟的SQLAlchemy支持，需要第三方包或者自己做；从架构上，Django对MVC的解读是MTV(Model-Template-View)，大家都叫作controller的东东，在Django的世界里是view，以至于每次和别人解释，都要多费一番口舌。

Pylons目前版本是0.9.7(rc4)，主要用到的第三方/独立组件有Paste、Routes、Beaker、Mako、FormEncode、WebHelpers和SQLAlchemy。安装方法如下：

首先你必须有Python(2.3+)，然后你可以选择直接easy_install Pylons或者新建一个Virtual Environment，和系统中的Python环境隔离开，依赖的包可以独立升级。这里我们按照后一种方式，如果你是第一次使用Pylons，建议你也在独立Python virtualenv中安装。

1- easy_install virtualenv (这将安装Python虚拟环境工具)
2- python virtualenv.py ENV (创建新的虚拟环境。这里的ENV是你新建虚拟环境的路径，如"mydevenv")
3- source ENV/bin/activate (激活虚拟环境。如果是Windows的话，这里需要执行ENV\bin\activate.bat)
4- easy_install Pylons (这里使用的是虚拟环境的easy_install安装)

如果你觉得上面的步骤麻烦，Pylons开发团队提供了一个脚本来处理安装过程，下载后用Python执行即可：
http://www.pylonshq.com/download/0.9.7/go-pylons.py

如果需要SQLAlchemy，则再执行一下
easy_install SQLAlchemy

安装成功后，通过
paster create -t pylons [应用名]
即可新建Web应用主框架，然后cd到应用下，通过
paster serve --reload development.ini
启动Web服务，默认地址在
http://127.0.0.1:5000/

更详细的信息，可参考Pylons项目主页：
http://pylonshq.com/

随着使用的深入，笔者还会陆续对Pylons和其他相关组件进行进一步的介绍。祝各位农历新年快乐！

laogao 2009-01-25 20:05 发表评论

[备忘] 如何确定当前Python环境的site-packages目录

laogao — Fri, 23 Jan 2009 11:25:00 GMT

有时我们需要动态的确定当前采用的Python运行时环境对应的site-packages目录，在Python代码中，可以这样做：

from distutils.sysconfig import get_python_lib
print get_python_lib()

备忘。

laogao 2009-01-23 19:25 发表评论