Introduction¶

Ocampickle is a samll library to Pickle/unPickle simple Python object in OCaml, corresponding to the cPickle module in Python.

You can get it from https://github.com/KDr2/ocampickle .

Install¶

• git clone git://github.com/KDr2/ocampickle.git
• cd ocampickle
• omake
• omake install

Getting Start¶

$ocaml
       Objective Caml version 3.12.0

# #use "topfind";;
- : unit = ()
Findlib has been successfully loaded. Additional directives:
  #require "package";;      to load a package
  #list;;                   to list the available packages
  #camlp4o;;                to load camlp4 (standard syntax)
  #camlp4r;;                to load camlp4 (revised syntax)
  #predicates "p,q,...";;   to set these predicates
  Topfind.reset();;         to force that packages will be reloaded
  #thread;;                 to enable threads

- : unit = ()
# #load "nums.cma";;
# #require "ocampickle";;
/opt/local/lib/ocaml/site-lib/ocampickle: added to search path
/opt/local/lib/ocaml/site-lib/ocampickle/ocampickle.cma: loaded
# Ocampickle.loads;;
- : string -> Ocampickle_type.t = <fun>
# let x=Ocampickle.loads "(lp1\nS'a'\naS'b'\na(dp2\nS'x'\nS'\\xe6\\xb5\\x8b\\xe8\\xaf\\x95'\np3\nsa.";;
val x : Ocampickle_type.t =
  Ocampickle_type.List
   [Ocampickle_type.String "a"; Ocampickle_type.String "b";
    Ocampickle_type.Dict <abstr>]
# Ocampickle_utils.pyprint x;;
["a","b",{"x":"测试",},]- : unit = ()
#...

Simple API¶

(* TYPE : Ocampickle_type.t *)
type t =
  | Dict of (t, t) Hashtbl.t  (* dict    *)
  | List of t list            (* list    *)
  | Tuple of t list           (* tuple   *)
  | String of string          (* str     *)
  | Unicode of string         (* unicode *)
  | Int of int                (* int     *)
  | Long of Big_int.big_int   (* int     *)
  | Float of float            (* float   *)
  | Bool of bool              (* bool    *)
  | Object of string          (* object  *)
  | Null                      (* None    *)
  | Ref of (t ref)            (* Ref     *);;

(* pickle object *)
val  Ocampickle.dumps : ?proto:int -> Ocampickle_type.t -> string = <fun>

(* unpickle object *)
val Ocampickle.loads : string -> Ocampickle_type.t = <fun>

(* print python object *)
val Ocampickle_utils.pyoutput : out_channel -> Ocampickle_type.t -> unit = <fun>
val Ocampickle_utils.pyprint :  Ocampickle_type.t -> unit = <fun>

Data Type Supported¶

Unfortunately, not all kinds of python data type are supported now, here is a table demonstrating this below, and it will support all kind of the data types (actually, all of the pickle opcode) later.

Bug Report¶

• on github : https://github.com/KDr2/ocampickle
• email me : killy.draw<@>gmail.com

PYC文件简介¶

不说废话,这里说的pyc文件就是 Python 程序编译后得到的字节码文件 (py->pyc).

基本格式¶

pyc文件一般由3个部分组成:

• 最开始4个字节是一个Maigc int, 标识此pyc的版本信息, 不同的版本的 Magic 都在 Python/import.c 内定义
• 接下来四个字节还是个int,是pyc产生的时间(1970.01.01到产生pyc时候的秒 数)
• 接下来是个序列化了的 PyCodeObject(此结构在 Include/code.h 内定 义),序列化方法在 Python/marshal.c 内定义

前两个字段的读写很简单,接下来咱们主要看一下 PyCodeObject 的序列化过程, 由于 PyCodeObject 内还有其他很多类型的 PyObject, 所以咱们从一般的 PyObject 的序列化开始看起:

PyObject的序列化¶

PyObject的序列化在 Python/marshal.c 内实现, 一般是先写入一个 byte 来标识此 PyObject 的类型, 每种 PyObject 对应的类型也在 Python/marshal.c 内定义:

//Python/marshal.c:22
#define TYPE_NULL               '0'
#define TYPE_NONE               'N'
#define TYPE_FALSE              'F'
#define TYPE_TRUE               'T'
#define TYPE_STOPITER           'S'
#define TYPE_ELLIPSIS           '.'
#define TYPE_INT                'i'
#define TYPE_INT64              'I'
#define TYPE_FLOAT              'f'
#define TYPE_BINARY_FLOAT       'g'
#define TYPE_COMPLEX            'x'
#define TYPE_BINARY_COMPLEX     'y'
#define TYPE_LONG               'l'
#define TYPE_STRING             's'
#define TYPE_INTERNED           't'
#define TYPE_STRINGREF          'R'
#define TYPE_TUPLE              '('
#define TYPE_LIST               '['
#define TYPE_DICT               '{'
#define TYPE_CODE               'c'
#define TYPE_UNICODE            'u'
#define TYPE_UNKNOWN            '?'
#define TYPE_SET                '<'
#define TYPE_FROZENSET          '>'

之后是 PyObject 的具体数据内容, 变长的对象(str, tuple, list 等)往往还 包含了一个 4 bytes 的 len, 比如 PyIntObject 的存储可能是这样的:

而 PyStringObject 的存储是这样的:

PyTupleObject 和 PyListObject 的存储分别是:

各种 PyObject 如何序列化,哪些内容被参与了序列化, 可以参看 Python/marshal.c 内的函数 w_object 函数, 接下来咱们着重看下前 面提到的 PyCodeObject 的序列化:

PyCodeObject 的序列化¶

结构体 PyCodeObject 在 Include/code.h 中定义如下:

//Include/code.h
typedef struct {
    PyObject_HEAD
    int co_argcount;        /* #arguments, except *args */
    int co_nlocals;     /* #local variables */
    int co_stacksize;       /* #entries needed for evaluation stack */
    int co_flags;       /* CO_..., see below */
    PyObject *co_code;      /* instruction opcodes */
    PyObject *co_consts;    /* list (constants used) */
    PyObject *co_names;     /* list of strings (names used) */
    PyObject *co_varnames;  /* tuple of strings (local variable names) */
    PyObject *co_freevars;  /* tuple of strings (free variable names) */
    PyObject *co_cellvars;      /* tuple of strings (cell variable names) */
    /* The rest doesn't count for hash/cmp */
    PyObject *co_filename;  /* string (where it was loaded from) */
    PyObject *co_name;      /* string (name, for reference) */
    int co_firstlineno;     /* first source line number */
    PyObject *co_lnotab;    /* string (encoding addr<->lineno mapping) See
                   Objects/lnotab_notes.txt for details. */
    void *co_zombieframe;     /* for optimization only (see frameobject.c) */
    PyObject *co_weakreflist;   /* to support weakrefs to code objects */
} PyCodeObject;

我们再看 Python/marshal.c 里面的 w_object 函数,从中找出写 PyCodeObject 的部分如下:

//...
else if (PyCode_Check(v)) {
    PyCodeObject *co = (PyCodeObject *)v;
    w_byte(TYPE_CODE, p);
    w_long(co->co_argcount, p);
    w_long(co->co_nlocals, p);
    w_long(co->co_stacksize, p);
    w_long(co->co_flags, p);
    w_object(co->co_code, p);
    w_object(co->co_consts, p);
    w_object(co->co_names, p);
    w_object(co->co_varnames, p);
    w_object(co->co_freevars, p);
    w_object(co->co_cellvars, p);
    w_object(co->co_filename, p);
    w_object(co->co_name, p);
    w_long(co->co_firstlineno, p);
    w_object(co->co_lnotab, p);
}
//...

根据上面两段代码,我们很容易就能看到 PyCodeObject 里哪些字段需要参数序 列化了,我们就挨个解释下需要序列化的字段们:

• co_argcount : code需要的位置参数个数,不包括变长参数(*args和**kwargs)
• co_nlocals : code内所有的局部变量的个数,包括所有参数
• co_stacksize : code段运行时所需要的最大栈深度
• co_flags : 一些标识位,也在code.h里定义,注释很清楚,比如 CO_NOFREE(64) 表示此 PyCodeObject 内无 freevars 和 cellvars 等
• co_code : PyStringObject(‘s’), code对应的字节码(参看 Include/opcode.h 以及此文后续章节)
• co_consts : 所有常量组成的tuple
• co_names : code所用的到符号表, tuple类型,元素是字符串
• co_varnames : code所用到的局部变量名, tuple类型, 元素是 PyStringObject(‘s/t/R’)
• co_freevars : code所用到的freevar的变量名,tuple类型, 元素是 PyStringObject(‘s/t/R’)
• co_cellvars : code所用到的cellvar的变量名,tuple类型, 元素是 PyStringObject(‘s/t/R’)
• co_filename : PyStringObject(‘s’), 此code对应的py文件
• co_name : 此code的名称
• co_firstlineno : 此code对应的py文件里的第一行的行号
• co_lnotab : PyStringObject(‘s’),指令与行号的对应表

在 Python 代码中,每个作用域(或者叫block或者名字空间?)对应一个 PyCodeObject 对象, 所以会出现嵌套: 比如 一个 module 类 定义了 N 个 class, 每个 class 内又定义了 M 个方法. 每个 子作用域 对应的 PyCodeObject 会出现在它的 父作用域 对应的 PyCodeObject 的 co_consts 字段里.

接下来用个例子对上面的某些字段做个说明, 比如下面的python代码

#test.py
import struct

def abc(c):
    a=1
    b=2
    return struct.pack("S",a+b+c)

var_a="abc"
var_b={var_a:123,"sec_key":abc}

它编译后对应的 pyc 在 magic 和 time 后就放着一个 PyCodeObject 对象, 这个对象的个字段指如下

这其中的 co_consts 里面的第三个元素是function abc的PyCodeObject, 我们来看下function abc的code的各字段:

图解 test.py 与 test.pyc 的结构关系¶

def outter(o1,o2):
    fc1=o1+o2
    fc2=o1*o2
    def inner(i):
        return (fc1+fc2)*i

//...
else if (PyString_CheckExact(v)) {
    if (p->strings && PyString_CHECK_INTERNED(v)) {
        PyObject *o = PyDict_GetItem(p->strings, v);
        if (o) {
            long w = PyInt_AsLong(o);
            w_byte(TYPE_STRINGREF, p);
            w_long(w, p);
            goto exit;
        }
        else {
            int ok;
            o = PyInt_FromSsize_t(PyDict_Size(p->strings));
            ok = o &&
                 PyDict_SetItem(p->strings, v, o) >= 0;
            Py_XDECREF(o);
            if (!ok) {
                p->depth--;
                p->error = WFERR_UNMARSHALLABLE;
                return;
            }
            w_byte(TYPE_INTERNED, p);
        }
    }
    else {
        w_byte(TYPE_STRING, p);
    }
    n = PyString_GET_SIZE(v);
    if (n > INT_MAX) {
        /* huge strings are not supported */
        p->depth--;
        p->error = WFERR_UNMARSHALLABLE;
        return;
    }
    w_long((long)n, p);
    w_string(PyString_AS_STRING(v), (int)n, p);
}
//...

字段 co_code 与 Python的OPCODE¶

PyCodeObject 的 co_code 字段就是 python opcode 组成的序列, 具体有哪些 opcode可以参看 Include/opcode.h , 这里面有些opcode有参数,有些没有 参数, 从opcode.h内的代码段:

#define HAVE_ARGUMENT 90  /* Opcodes from here have an argument: */
//...
#define HAS_ARG(op) ((op) >= HAVE_ARGUMENT)

可以看出,大于等与90的opcode是有参数的, 有参数的opcode的参数是两个 unsigned byte, 第一个是操作数, 第二个目前固定为0x00但是不能省略,举例来 说,我要把当前code的co_consts里的第二个常量(index是1)载入到栈顶,则对应 的opcode序列为: |LOAD_CONST|0x01|0x00| ,也就是 '0x640x010x00'

其他的opcode大都类似,主要是对函数调用栈以及co_consts, co_varnames, co_freevars, co_cellvars的操作, 还有些BUILD_CLASS, BUILD_MAP, BUILD_LIST, BUILD_TUPLE, BUILD_SLICE, MAKE_FUNCTION, MAKE_CLOSURE 等构 建对象的特殊指令.

有参数的 opcode 的参数的参数大多时候是个 index, 比如 LOAD_CONST 1 的 1 就是个 index, 表示把当前 PyCodeObject.co_consts[1] 这个常量载 入到栈顶, LOAD_FAST 2 则是把 PyCodeObject.co_varnames[2] 这个 局部变量载入到栈顶；而 MAKE_FUNCTION 2 则表示栈顶code-obj对应的 function有两个默认参数.

前面 test.pyc 之外的东西, 比如 class/closure 的创建, 也都逃不过这 些指令, 具体每个指令的解释和用法可以参看 : http://docs.python.org/release/2.7/library/dis.html#python-bytecode-instructions

讨厌在线写东西¶

用过 WordPress, 用过Drupal, 用过门户们运营的Blog, 都要在线写东西，这 是我所不能接受的，找过一些离线书写的工具，体验也都很差，俺要找个离线写 的，最好能在俺的 Emacs 里写的(blogger.el等体验也很差...)，没找到趁手 的，干脆自己攒吧，于是现在的站点就来了，用 Emacs 写 reStructuredText, 提交到 GitHub, 服务器上用crontab定时pull GitHub 上的 reStructuredText, 之后 再用 SphinxDoc 把 reStructuredText 编译成html放到webserver的根目录下，就好了，一 个静态的站就攒起来了，每次更新就在 Emacs 里舒舒服服的编辑 reStructuredText 之后 commit/push到 GitHub 上就可以。这样不仅做到了离线写作，站点的 reStructuredText 代码本地有， GitHub 上有，server上也有，备份也不用额外做了。

我要动态站¶

一个静态的站点，貌似没什么意思... 写的狗屁玩意连评论下都不行，我想要一 些动态功能和朋友交流， 该咋办呢...

还是得自己动手丰衣足食啊，先在某 reStructuredText 文件里写个javascript脚本，操作 dom生成用于提交comment的表单，然后做个动态的(Rest风格?)的服务来接收 用户comment时候发起的请求，在前面提到js里加上页面加载时的从动态的(Rest 风格?)的服务那里获取与当前页面相关的comments，灌到页面里就好了。要做就 做，不到2个小时，做成了，现在想在某页面里开启评论功能只要include写有js 脚本的那个 reStructuredText 文件即可。

顺带说一句，这个动态的评论最初我使用 django 做的，后来由于发现 pylons 更符合我的胃口，就换到 pylons 了。

其他还需要什么动态服务，基本就两个思路:

• 看有现成的第三方的线上服务能直接用不，有的话直接拿来主义。
• 上一条中没有的话就自己整一个，按comment功能的方式加上。

为什么说 “Back to Dreamhost”?¶

2007年就买了 DreamHost 的虚拟主机，那时还用 WordPress, DreamHost 上也没有 fastcgi支持，基本只能放php程序和静态的东西，后来因为一次服务器数据转移 停了下服务, DreamHost 为了补偿就给升级成 存储不限，流量不限 的账号了， 但是我为了方便自己折腾，忘了去年还是今年初买了个低配的VPS, 在上面跑些 自己的程序以及做一些不能说太细的事情，前面的我所那些工作都是在我用那个 VPS的时候完成的，也是放到那VPS上的。

但是，这个周末，我把这些都搬回DreamHost上了。才发现现在 DreamHost 的php都 是fastcgi方式在跑了(我土...), 静态页面的迁移体不用说了，在上面用 fastcgi跑 pylons 倒是折腾了一番，先是因为我的 ‘追新强迫症’ 让我启用 DreamHost 自带的 Python 2.5.2 自己装了个 2.7, 之后开始测试fastcgi就开始不 断500了，log里也只说什么 header byte(0) 之类的， 后来在 fastcgi里打印 了下环境变量以及sys.path，发现少了一些egg路径(因为我在.bashrc自己加了 条 PYTHONPATH, easy_install装到这个PYTHONPATH里面了)，然后我有把fcgi改 成让cgi handler处理，发现error.log里有东西了，说paster.deploy找不到... 真相大白了...

说下整个步骤吧:

安装Python

我装到了$HOME/local下 (configure的时候指定–prefix=$HOME/local),之后 在.bashrc里写:

export PATH=$HOME/local/bin:$HOME/local/script:$PATH
export PYTHONPATH=$HOME/local/lib/python
alias python=$HOME/local/bin/python

之所以要 export PYTHONPATH=$HOME/local/lib/python 是因为那些python的本 地library(比如_socket.so)都装在了这里，而这个路径没在sys.path里。

之后安装easy_install(setuptools), 然后用easy_install安装pylons, flup, sqlalchemy, mysql-python等包，按惯例这些包会被装到 $HOME/local/lib/python2.7/site-packages/下，但是由于前面我 export PYTHONPATH=$HOME/local/lib/python, 导致这些包都装在了 $HOME/local/lib/python 下面，造成了fastcgi脚本里需要额外 的设置路径。 其实把$HOME/local/lib/python下面的eggs移到 $HOME/local/lib/python2.7/site-packages/下估计也可以。

dispatch.fcgi

#!$HOME/local/bin/python

import os
import sys
import glob
def add_path_and_eggs(path):
    eggs=glob.glob(path+"/*.egg")
    [sys.path.insert(0,e) for e in eggs]
    sys.path.insert(0,path)

add_path_and_eggs("$HOME/local/lib/python")
add_path_and_eggs('$HOME/local/lib/python2.7/site-packages')
other_path=['',
            '$HOME/local/lib/python27.zip',
            '$HOME/local/lib/python2.7',
            '$HOME/local/lib/python2.7/plat-linux2',
            '$HOME/local/lib/python2.7/lib-tk',
            '$HOME/local/lib/python2.7/lib-old',
            '$HOME/local/lib/python2.7/lib-dynload']
[sys.path.insert(0,e) for e in other_path]

import logging
from paste.deploy import loadapp

config_file = "$HOME/xxx/pylon-app/production.ini"
wsgi_app = loadapp('config:'+config_file)

def serve_with_flup():
    from flup.server.fcgi import WSGIServer
    logging.config.fileConfig(config_file)
    WSGIServer(wsgi_app).run()

serve_with_flup()

.htaccess

#AddHandler cgi-script .cgi
AddHandler fastcgi-script .fcgi
Options +FollowSymLinks +ExecCGI

RewriteEngine On
RewriteRule ^dispatch\.fcgi/ - [L]
RewriteRule ^(.*)$ dispatch.fcgi [L]

经验，提示

• DreamHost 上fcgi出错时不好找原因，可以把fcgi当cgi跑来看看错误信息