Rubyの StringScanner は個人的にかなり好きなモジュールで、Rubyでちょっとしたパーサなどを書くときに重宝しています。

一方、Pythonにはexperimentalながら re.Scanner というクラスがあります( >= 2.4 )。experimentalなのでマニュアルにはのっていませんが。この re.Scanner はかなりシンプルなんですが典型的な StringScanner の使い方の範疇では、こちらのほうがキレイに書けるような気がします。

re.Scanner の使い方

使い方は非常に簡単で

  • (regex, action) のリストを渡してScannerオブジェクトを作成

    • action は(scanner, string_matched) => stringな関数、Noneを返せば結果は無視される。
  • scanメソッドでスキャン。結果が配列で返ってくる

といった感じ。関数を渡すので、 StringScanner のようなwhileループを作る必要がなく、キレイにまとまります。

例:S式パーサ

re.Scanner は簡単、ということでS式パーサでも。トークナイズ+αな処理をするので、 action をインスタンスメソッドにして状態を保存することにします。

目標は

  • 数値(っぽいもの)、文字列、シンボルが使える
  • シンボルのみ、新たにクラスを定義して(unicodeのサブクラス)それにマップ。それ以外は組み込み型に。
  • パースエラーも分かりやすく
  • 結果はPythonのリストorオブジェクトとして返る

import re, sys
from unicodedata import east_asian_width

try:
  from re import Scanner
except ImportError:
  from sre import Scanner

class ParseError(StandardError): pass

class Symbol(unicode):
  def __repr__(self):
    return "Symbol(%s)"%unicode.__repr__(self)

class TokenProcessor(object):
  PAREN = {"]":"[", ")":"("}
  def __init__(self, value):
    self.result = []
    self.append = self.result.append
    self.string = value
    self.paren_stack = []
    self.pos = 0

  def __call__(self, name):
    def _(*a):
      self.before(*a)
      return getattr(self, name)(*a)
    return _

  def before(self, scanner, s):
    self.pos += len(s)
    self.skip(scanner, s)

  def error(self, scanner, s): self.raise_error("unknown token: %s"%s)

  def skip_whitespaces(self, scanner, s): self.append(",")

  def skip(self, scanner, s):
    last = "".join(self.result[-2:])
    if last in ["[,", ",,", ",]"]: 
      self.result[-2:] = sorted(last, key=ord)[1]

  def atom(self, scanner, s):
    if s in ["(", "["]:
      self.append("[")
      self.paren_stack.append(s)
    elif s in [")", "]"]:
      if not self.paren_stack:
        self.raise_error("missing opening parenthesis.")
      if self.PAREN[s] != self.paren_stack.pop():
        self.raise_error("missing closing parenthesis.")
      self.append("]")
    elif re.match(r"""^(".*)$""", s or ""):
      self.append("u"+s)
    elif re.match(r"""^((\-?\d[\de\.]+)|(\s*)|(.*"))$""", s or ""):
      self.append(s)
    else:
      self.append("Symbol(u\"%s\")"%s)

  def raise_error(self, msg="parse error", range=3):
    lines = self.string.split("\n")
    curline = self.string[:self.pos].count("\n")
    linepos = self.pos - len("\n".join(lines[:curline]))
    buf = ["\n"] 
    for i in xrange(max(0, curline-range), curline+1):
      buf.append("% 5d: %s"%(i+1, lines[i]))
    width = 6 + sum(east_asian_width(c) == 'W' and 2 or 1 for c in lines[i])
    buf.append("%s~"%(" "*width))
    buf.append("line %d, %d: %s"%(curline+1,linepos, msg))
    raise ParseError(("\n".join(buf)).encode(sys.stderr.encoding))

def read_sexp(sexp):
  processor = TokenProcessor(sexp)
  scanner = Scanner([
    (r"\s+", processor("skip_whitespaces")),
    (r";[^\n]*\n", processor("skip")),
    (r""""(?:[^"])*"|(\]|\[|\)|\(|[^\(\)\s]+)""", processor("atom")),
    (r".*", processor("error"))
  ], re.M)
  scanner.scan(processor.string)
  if processor.paren_stack:
    processor.raise_error("missing closing parenthesis.")
  result = eval("".join(processor.result).lstrip(","))
  return (isinstance(result, tuple) and (result[0],0) or (result,0))[0]

こんな感じ。非常にシンプルな気がします。

print read_sexp(u"""("ほげほげ"
;comment
  ;comment
  (hogehoge 123) ;aaaaaaa
  "hoge\\"aaaa"
;comment
;comment

aaaa          b)""")

output:

[u'\u307b\u3052\u307b\u3052', [Symbol(u'hogehoge'), 123], u'hoge"aaaa', Symbol(u'aaaa'), Symbol(u'b')]

エラーも一応。

print read_sexp(u"""(
aaaa
bbbb (ccc ddd) )
(eee 
ああああああ""")

output:

__main__.ParseError:

    2: aaaa
    3: bbbb (ccc ddd) )
    4: (eee
    5: ああああああ
                  ~
line 5, 7: missing closing parenthesis.

エラー表示もいい感じ。フォントにもよりますが(等幅なら大丈夫)、一応文字幅を考慮して ~ をエラー箇所に出すようにしています。HTML上だと日本語はずれちゃうかもだけど。

というわけで

Pythonでトークナイズするときにはかなり便利なんじゃないかと思いました。


前のエントリー でGAEにおけるトランザクションの問題は一応解決をみた。

その後、GAEで開発を続けた結果、やはりGAEにブログを移行するのは断念した。理由としては

  • os.listdir などで不審な挙動が見られた
  • スキーマを変更したときが非常に面倒
  • インポート、エクスポートの難しさ

が主なところ。

os.listdir については、web.pyでテンプレートを検索するときに os.listdir を使っているのだけど、どうも動きが怪しい。正しくファイルリストが帰ってきたり帰ってこなかったりするのだ。何回も本番にアップして試したところ、 os.listdir("hoge");os.listdir("hoge") というように同じ内容で2回連続で呼び出すとなぜか確実にファイルリストが帰ってくる、という・・・これはちょっと・・・

スキーマの変更に関しては、まんま。変更したとき、それを本番に反映させるのがめんどくさい。

インポートエクスポートも負荷を考えるとしんどい。現在もWEBはレンタルサーバで運用しているのでわざわざGAEにもっていく旨みもない。

ということでせっかくブログをつくったのに移行をやめたのである。


しかし、せっかく作ったのにもったいない。ということで今度はGAE用につくったブログを普通にMySQLを使うようにポーティングした。今回はそれに試験的に移行してみたのだ。

なぜWordpressからわざわざ独自ブログソフトウェアに移行したのか。理由は前のエントリーにも書いたとおりだけど

  • Wordpressのコードが気に食わない(OSSとしてバランスをとっている、というのはあるんですが)
  • 使用しているテンプレートや、プラグインも含めると出力されるHTMLが汚い。
  • ついている機能の半分以上は使っていない。ブログライトユーザの俺には機能が多すぎる。

    • 自分の使う機能が固まった。それさえあれば俺には十分とわかり始めた。
  • セキュリティ的にもWordpressはターゲットになっていて微妙。

以上のようなところをふまえ

  • 明快なコード。
  • キレイなXHTML。
  • 自分が使う機能だけ実装。
  • 堅牢なコード。

ということを心がけた。またレンタルサーバで動かすということで

  • なるべく静的HTMLとしてキャッシュしてmod_rewriteで飛ばす
  • 見た目や外部連携に関する動的な部分はなるべくクライアントサイドで

ということにも気を配った。

このブログは3年目に入るのだけど、やはりWEBの世界というのは流れが速いもので大分変化があった。その中で、外部連携はほぼJSONPで行えるようになったのでサーバサイドでやらなくても良くなった。今回実装したブログでは各SBMのブクマ数を表示しているけど、これも全てJSONPでクライアントサイドで実現している。それに対し、旧ブログ(Wordpress)ではサーバサイドで定期的に取得していた。

という感じで出来上がったのがこのブログだ。もうひとつ、実はこのブログ、XREAでしかもPython2.5で動かしている。あれ、XREAでPython2.5使えたっけ、というあなた。実は簡単に使えちゃうワザがあるんですよ。それについては、また。


あまりテストもせず試験的に移行してみたのでおかしい部分もあるかと思いますが、そこはおいおい。パーマリンクはそのままになっていると思います。基本的にURLは変更していません。また、CGIで動かしていますので、負荷が高ければ前のに戻す予定です。


前のエントリー で書いたように、GoogleAppEngineのトランザクションは使い勝手が悪い。しかし、GAEにブログを移行しようと思うとこれは乗り越えなければならない。

GAEでトランザクションを行う条件を簡単にまとめると

  • db.run_in_transactionにトランザクションとして実行したい関数を渡すがその関数内では
  • 同じエンティティグループに属しているモデルで
  • get, put, deleteのみ

しか実行できない。なのでトランザクションのページに紹介されているような

from google.appengine.ext import db

class Accumulator(db.Model):
  counter = db.IntegerProperty()

def increment_counter(key, amount):
  obj = db.get(key)
  obj.counter += amount
  obj.put()

q = db.GqlQuery("SELECT * FROM Accumulator")
acc = q.get()

db.run_in_transaction(increment_counter, acc.key(), 5)

先にGQLを発行しておいて、 run_in_transaction に渡す関数ではGQLの結果として取得した key を引数にとる、という回りくどいコードになる。コレは書きづらい。

これも前のエントリーに書いたように、今回作ったブログアプリでは月別アーカイブやタグアーカイブの記事数をエントリのCRUD時に操作している。

エントリ作成時なら

@classmethod
def create(cls, *a, **k):
  obj = super(Entry, cls).create(*a, **k)
  TagCount.inc(obj.status, *obj.tags)
  MonthCount.inc(obj.status, obj.created_month)
  return obj

というような感じだ( status は公開、とか非公開とかが入る)。当然、この create メソッドでは TagCount , MonthCountobj について一貫性が保たれなければならない。しかし、 TagCount.inc では対象のタグを検索して、なければ作成し put する、という操作を行う。「対象のタグを検索して」というトランザクション内で許可されていない操作が入っているのだ。

さて、こういうときはとりあえず?力技で乗り切ろう。かなり強引だが、下のようなコードで乗り切ってみた。一応、サーバにアップロードして動作することは確認している。

class RootModel(db.Model):
  id = db.IntegerProperty(default=1)
  def __call__(self, k):
    v = k or {}
    v.update(parent=with_parent)
    return v
with_parent = RootModel.get_or_insert("id", id=1)

まず、全てのエンティティを同一エンティティグループに所属させることにする。そのため、全てのエンティティの親となるエンティティを作成する。

次は強引さの根源のようなクラスだ。

class Transaction(object):
  MAGIC_NAME = "__magic__lst__"
  SEARCH_MAX = 12
  def __init__(self, f):
    self.f = f

  def execute(self):
    __magic__lst__ = []
    result = self.f()
    def commit():
      for dbop in __magic__lst__:
        dbop()
      return True
    committed = db.run_in_transaction(commit)
    if committed is None:
      raise db.Rollback()
    return result

これだけでは分からないと思うが、 execute 内で run_in_transaction が実行されている。その引数には commitcommit の中では __magic__lst__ というリスト内の関数を実行しているようだが、 __magic__lst__ に要素が追加されている形跡がない。

そして、全てのモデルの親となる基本モデルを定義する。

class BaseModel(db.Model):
  @classmethod
  def create(cls, *a, **k):
    obj = cls(*a, **with_parent(k))
    obj.put()
    return obj

  def _with_transaction(self, name):
    i = 1
    f = sys._getframe(i)
    while f and i < Transaction.SEARCH_MAX:
      if Transaction.MAGIC_NAME in f.f_locals:
        f.f_locals[Transaction.MAGIC_NAME].append( \
          lambda : getattr(super(BaseModel, self), name)())
        return
      i += 1
      f = sys._getframe(i)
    return getattr(super(BaseModel, self),name)()

  def put(self):
    return self._with_transaction("put")

  def delete(self):
    return self._with_transaction("delete")

  def update(self, **k):
    for prop in self.properties().values():
      if prop.name in k:
        prop.__set__(self, k[prop.name])
    self.put()

  @classmethod
  def get_by_id(cls, id):
    return super(BaseModel, cls).get_by_id(id, parent=with_parent)

この基本クラスではまず、 create というメソッドを定義し、エンティティはすべてこのメソッドを通して作成するようにしている。 create では必ず親エンティティとして with_parent を指定する。これにより全てのエンティティは同一エンティティグループに属することになる。

  • 同じエンティティグループに属しているモデルで

という条件はクリアしたことになる。次は

  • get, put, deleteのみ

という条件だ。これは _with_transaction というメソッドでクリアしている。 putdelete をオーバーライドして _with_transaction を呼び出すようにしている。さて、この _with_transaction ではフレームをさかのぼって、 __magic__lst__ という名前のローカル変数が存在するフレームがないか探索する。そのフレームが存在した場合、一連のトランザクション内での実行とみなし、 __magic__lst__put , delete を行うthunkを登録し、終了する。存在しない場合は通常の実行ということで、その場で put , delete を行う。つまり、トランザクション内で実行されたことを検出して put , delete の評価を遅延させるのだ。

さきほどの create

@classmethod
def create(cls, *a, **k):
  def _():
    obj = super(Entry, cls).create(*a, **k)
    TagCount.inc(obj.status, *obj.tags)
    MonthCount.inc(obj.status, obj.created_month)
    return obj
  return Transaction(_).execute()

と若干のコード挿入のみできちんと一貫性が保証されるようになる。     *********************************   というわけで、かなり強引な気がするけどトランザクションの問題は一応クリアされた。めんどくさければHTTPリクエストを受けてから、レスポンスを返すまでを関数でラップし、 Transaction.execute すれば大丈夫だ。

ここまでやってしまったので、やっぱり今のブログはGAEに移行しようかなあ、と思い始めたり。デザインも今と似ているけどやっぱ一から自分でマークアップしたから好みだし、なによりXHTMLとしてValidだ。機能的にはあと、スパム対策さえあれば大丈夫。

実はOpenIDも自分でサーバ立ててたりするので、それもGAEで実装しなおしたいなあとか色々やりたいことは尽きない。GAEでの開発はこのモデルの問題さえつぶしてしまえばかなり楽だし、夢がひろがるなあ。