• Smiles parser
• Smarts substructure searching
• SD file parser with SD field manipulations
• Depiction for SD files with coordinates
• Molecule Fingerprint generation
• Several forms of Ring Detection available
• Simple aromaticity perception
• Everything's a graph (i.e. can form canonical strings from incomplete pieces of a molecule)
  
• Full source code
• Really bad depiction of arbitray molecules! (requires AT&T's GraphViz)

Open Source cheminformatics toolkits such as OpenBabel, the CDK and the RDKit share the same core functionality but support different sets of file formats and forcefields, and calculate different fingerprints and descriptors. Despite their complementary features, using these toolkits in the same program is difficult as they are implemented in different languages (C++ versus Java), have different underlying chemical models and have different application programming interfaces (APIs).

Results

We describe Cinfony, a Python module that presents a common interface to all three of these toolkits, allowing the user to easily combine methods and results from any of the toolkits. In general, the run time of the Cinfony modules is almost as fast as accessing the underlying toolkits directly from C++ or Java, but Cinfony makes it much easier to carry out common tasks in cheminformatics such as reading file formats and calculating descriptors.

Conclusion

By providing a simplified interface and improving interoperability, Cinfony makes it easy to combine complementary features of OpenBabel, the CDK and the RDKit.

Cinfony presents a common API to several cheminformatics toolkits. It uses the Python programming language, and builds on top of OpenBabel, RDKit and the CDK.

Documentation

• The Cinfony paper
• Install on Windows, Linux or MacOSX
• A complete description of Cinfony
• API documentation. This documentation can also be accessed using the help command, e.g. help(cdk).
• Further information on Pybel and using the OpenBabel Python bindings is available on the OpenBabel wiki

编码要求：
1、编码中不出现“4”、“3”等不吉利数字，缺码编号；
2、卖品第一个字母“L”表示礼盒装、“B”表示标准装。第二个字母是“A”到“Z”中的任意字母，可根据编码需要任意选择。四位数字为编号；
3、卖品与赠品区别在于：卖品以“L”或者“B”开头，赠品以“ZL”或者“ZB”开头。

例如：
卖品礼盒装编码  L-A0001  L-D0001等
卖品标准装编码  B-A0001  B-H0888等
赠品礼盒装编码  ZL-A0001  ZL-D0001等
赠品标准装编码  ZB-A0001  ZB-H0888等
 
其中如果有3个3的号码也留下来，不用去掉。 本来想用js来实现，但如果那样只能把生成的结果写给页面上了，而且刷新就没了。

后来考虑了一下，选择使用wxPython加上py2exe来做一个小的可执行文件，并把生成的编号放入txt文件中。 由于之前没玩过wxPython，花了1个多小时终于搞定了！代码如下：

#encoding=utf-8
from __future__ import with_statement
import wx

class ChoiceFrame(wx.Frame):
    def __init__(self):
        wx.Frame.__init__(self, None, -1, u'编码生成器', size=(450, 150))
        icon=wx.EmptyIcon()
        icon.LoadFile("SetupIcon.ico",wx.BITMAP_TYPE_ICO)
        self.SetIcon(icon)
        panel = wx.Panel(self, -1)
       
        typeList = [u'卖品礼盒装',u'卖品标准装',u'赠品礼盒装',u'赠品标准装',]
        wx.StaticText(panel, -1, u"选择种类:", pos=(10, 20))
        self.type = wx.Choice(panel, -1, (85, 20), choices=typeList)
        self.type.SetSelection(0)
       
        sampleList = [chr(i) for i in range(65,91)]
        wx.StaticText(panel, -1, u"选择字母:", pos=(210, 20))
        self.choice = wx.Choice(panel, -1, (285, 20), choices=sampleList)
        self.choice.SetStringSelection('A')
       
        wx.StaticText(panel, -1, u"起始数字:", pos=(10, 50))
        self.start = wx.TextCtrl(panel, -1, "", pos=(80, 50))
       
        wx.StaticText(panel, -1, u"结束数字:", pos=(210, 50))
        self.end = wx.TextCtrl(panel, -1, "", pos=(280, 50))
       
        funbtn = wx.Button(panel, -1, u"运行", pos=(280, 90))
        self.Bind(wx.EVT_BUTTON, self.OnFunButton, funbtn)
       
        self.message = wx.StaticText(panel, -1, "", pos=(10, 90))
        self.message.SetForegroundColour("red")
       
    def OnFunButton(self, evt):
        self.message.SetLabel('')
        startNum = self.start.GetValue().strip()
        endNum = self.end.GetValue().strip()
        if not startNum.isdigit():
            self.message.SetLabel(u'*开始数字必须输入整整数')
            return
        if not endNum.isdigit():
            self.message.SetLabel(u'*结束数字必须输入整整数')
            return
        snum = int(startNum)
        enum = int(endNum)
        if enum <= snum:
            self.message.SetLabel(u'*结束数字必须大于开始数字')
            return
        if enum >= 10000:
            self.message.SetLabel(u'*结束数字必须小于10000')
            return
        type = self.type.GetSelection()
        choice = self.choice.GetStringSelection()

        if (type == 0):
            type = "L-"
        elif (type == 1):
            type = "B-"
        elif (type == 2):
            type = "ZL-"
        elif (type == 3):
            type = "ZB-"
       
        startCode = self.getCode(snum, type, choice)
        endCode = self.getCode(enum, type, choice)
           
        with open(startCode + "-" + endCode + ".txt", 'w') as f:
            for i in range(snum, enum+1):
                code = self.getCode(i, type, choice)
               
                num4 = code.count('4')
                if num4 > 0:
                    continue
                num3 = code.count('3')
                if num3 >0 and num3 < 3:
                    continue
                f.write(code)
                f.write('\n')
        self.message.SetLabel(u'编号生成成功！！！')
       
    def getCode(self, i, type, choice):
        code = i
        if i < 10:
            code = '000' + str(i)
        elif i < 100:
            code = '00' + str(i)
        elif i < 1000:
            code = '0' + str(i)
        return type + choice+ str(code)
   
if __name__ == '__main__':
    app = wx.PySimpleApp()
    ChoiceFrame().Show()
    app.MainLoop()

#encoding=utf-8
from distutils.core import setup
import py2exe

options = {"py2exe":  
            {   "compressed": 1,  
                "bundle_files": 1
            }  
          } 
         
setup(
    options = options,
    zipfile = None,
    windows=[{"script": "GeneratorCode.py", "icon_resources": [(1, "SetupIcon.ico")]}]
)

#encoding=utf-8
from __future__ import with_statement
import MySQLdb
import urllib
from lister import ListerTR

conn = MySQLdb.connect(host="localhost", user="root", passwd="root", db="coocoo", charset="utf8")
cursor = conn.cursor()
cursor.execute("select id, enname from compound where enname != '' and zhname = '' order by id")
row=cursor.fetchall()
for r in row:
    params = urllib.urlencode({'eng2chi':r[1]})      这里组织参数
    sock = urllib.urlopen("http://202.127.145.134/scdb/translate/translate.asp", params)   发送请求，并把参数传过去
    html = sock.read()
    sock.close()
    p = ListerTR()   以下为解析返回的数据代码
    p.feed(html)
    html = p.html
    if u"成功" in html:
        value = p.values[5]
        data = value.strip()
        print r[0], r[1], data    取回翻译成功的内容更新数据库里面的值
        cursor.execute("update compound set zhname = %s where id=%s", (data, r[0]))
        conn.commit()
    else:    把翻译失败的记录给文本文件中
        with open('failture.txt', 'a+') as f:
            f.write(str(r[0])+" | "+str(r[1]))
            f.write('\n')
cursor.close()
conn.close()

orcon = cx_Oracle.connect("username", "password", "172.29.131.25:1521/orcl")
orcursor = orcon.cursor()
orcursor.execute("select columnname from tablename ")
row=orcursor.fetchall()
for r in row:
    for cell in r:
        print cell
orcursor.close()
orcon.close()

from datetime import timedelta, datetime
from django.core.cache import cache
from django.contrib.sites.models import Site

ONLINE_MINUTES = 10
CACHE_KEY = '%s_online_user_ids' % Site.objects.get_current().domain

_last_purged = datetime.now()

def get_online_user_ids():
    user_dict = cache.get(CACHE_KEY)
    return hasattr(user_dict, 'keys') and user_dict.keys() or []

class OnlineUsers(object):
    def process_request(self, request):
        if request.user.is_anonymous():
            return

        user_dict = cache.get(CACHE_KEY)
        if not user_dict:
            # initialization
            user_dict = {}

        now = datetime.now()
        user_dict[request.user.id] = now

        # purge
        global _last_purged
        if _last_purged + timedelta(minutes=ONLINE_MINUTES) < now:
            purge_older_than = now - timedelta(minutes=ONLINE_MINUTES)
            for user_id, last_seen in user_dict.items():
                if last_seen < purge_older_than:
                    del(user_dict[user_id])
            _last_purged = now

        cache.set(CACHE_KEY, user_dict, 60*60*24)

This stores a dictionary in the form: {user_id: last_seen_time, ...}
in the cache and updates the cache once for every request by an
authenticated user.

An alternative would be to store a structure like Jeremy's,
{minute_seen: set(user_id, ...), ...} which I think will result in
nearly the same amount of cache hits on average.

I would like to hear your comments.

import win32serviceutil
import win32service
import win32event

class win32test(win32serviceutil.ServiceFramework):
    _svc_name_ = "Python Win32 Service"
    _svc_display_name_ = "Python Win32 Service"
    _svc_description_ = "Just for a demo, do nothing."
    def __init__(self, args):
        win32serviceutil.ServiceFramework.__init__(self, args)
        self.hWaitStop = win32event.CreateEvent(None, 0, 0, None)
       
    def SvcDoRun(self):
        win32event.WaitForSingleObject(self.hWaitStop, win32event.INFINITE)
       
    def SvcStop(self):
        self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING)
        win32event.SetEvent(self.hWaitStop)
   
if __name__=='__main__':
    win32serviceutil.HandleCommandLine(win32test)

from distutils.core import setup
import py2exe

class Target:
    def __init__(self, **kw):
        self.__dict__.update(kw)
        # for the versioninfo resources
        self.version = "1.0.0"
        self.company_name = "Founder Software Suzhou Co. Ltd."
        self.copyright = "Copyright &copy; 2009 Founder Software (Suzhou) Co., Ltd. "
        self.name = "Jchem cartridge windows service"

myservice = Target(
    description = 'foo',
    modules = ['win32test'],
    cmdline_style='pywin32',
    icon_resources=[(1, "cartrigde.ico")]
)

options = {"py2exe":  
            {   "compressed": 1,  
                "bundle_files": 1
            }  
          } 
         
setup(
    service=[myservice],
    options = options,
    zipfile = None,
    windows=[{"script": "win32test.py"}],
)

下面就可以使用python setup.py py2exe命令来生成安装文件了.
生成的安装文件可以使用一下命令来执行控制服务:
win32test.exe install
win32test.exe start
win32test.exe stop
win32test.exe remove

import traceback
import sys

def tracebacktest():
    raise SyntaxError, "traceback test"
try:
    tracebacktest()
except:
    info = sys.exc_info()
    for file, lineno, function, text in traceback.extract_tb(info[2]):
        print file, "line:", lineno, "in", function
        print text
    print "** %s: %s" % info[:2]

import tempfile
import os

tempf = tempfile.mktemp(dir="D:/")

print "tempfile", "=>", tempf

file = open(tempf, "w+b")
file.write("*" * 1000)
file.seek(0)
print len(file.read()), "bytes"
file.close()

try:
    os.remove(tempf)    #用完以后要注意删除临时文件
except OSError:
    pass

def map_imp(function, sequence) :

    if function is None: return list(sequence)

    retvals = []

    for element in sequence:

        if (function(element)):

            retvals.append(element)

            return retvals

def reduce_imp(function, sequence) :

    arg1 = function(sequence[0])

    for arg2 in sequence[1:] :

        arg1 = function(arg1, arg2)

    return arg1

def filter_imp(function, sequence) :

    retvals = []

    for element in sequence:

        if (function is None and element) or function(element) :

            retvals.append(element)

    return retvals

对于这种逻辑性强的东西，用语言来描述是无助的，代码则要清晰的多。

具体使用方法可以参考另外一篇:http://www.blogjava.net/rain1102/archive/2009/06/01/279478.html

关于decorator的详细介绍在 Python 2.4中的What's new中已经有介绍，大家可以看一下。

如何调用decorator

基本上调用decorator有两种形式

第一种：

@A
def f ():
    ...

这种形式是decorator不带参数的写法。最终 Python 会处理为：

f = A(f)

还可以扩展成：

@A
@B
@C
def f ():
    ...

最终 Python 会处理为：

f = A(B(C(f)))

注：文档上写的是@A @B @C的形式，但实际上是不行的，要写成多行。而且执行顺序是按函数调用顺序来的，先最下面的C，然后是B，然后是A。因此，如果decorator有顺序话，一定要注意：先要执行的放在最下面，最后执行的放在最上面。(应该不存在这种倒序的关系)

第二种：

@A(args)
def f ():
    ...

这种形式是decorator带参数的写法。那么 Python 会处理为：

def f(): ...
_deco = A(args)
f = _deco(f)

可以看出， Python 会先执行A(args)得到一个decorator函数，然后再按与第一种一样的方式进行处理。

decorator函数的定义

每一个decorator都对应有相应的函数，它要对后面的函数进行处理，要么返回原来的函数对象，要么返回一个新的函数对象。请注意，decorator只用来处理函数和类方法。

第一种：

针对于第一种调用形式

def A(func):
    #处理func
    #如func.attr='decorated'
    return func
@A
def f(args):pass

上面是对func处理后，仍返回原函数对象。这个decorator函数的参数为要处理的函数。如果要返回一个新的函数，可以为：

def A(func):
    def new_func(args):
        #做一些额外的工作
        return func(args) #调用原函数继续进行处理
    return new_func
@A
def f(args):pass

要注意 new_func的定义形式要与待处理的函数相同，因此还可以写得通用一些，如：

def A(func):
    def new_func(*args, **argkw):
        #做一些额外的工作
        return func(*args, **argkw) #调用原函数继续进行处理
    return new_func
@A
def f(args):pass

可以看出，在A中定义了新的函数，然后A返回这个新的函数。在新函数中，先处理一些事情，比如对参数进行检查，或做一些其它的工作，然后再调原始的函数进行处理。这种模式可以看成，在调用函数前，通过使用decorator技术，可以在调用函数之前进行了一些处理。如果你想在调用函数之后进行一些处理，或者再进一步，在调用函数之后，根据函数的返回值进行一些处理可以写成这样：

def A(func):
    def new_func(*args, **argkw):
        result = func(*args, **argkw) #调用原函数继续进行处理
        if result:
            #做一些额外的工作
            return new_result
        else:
            return result
    return new_func
@A
def f(args):pass

第二种：

针对第二种调用形式

在文档上说，如果你的decorator在调用时使用了参数，那么你的decorator函数只会使用这些参数进行调用，因此你需要返回一个新的decorator函数，这样就与第一种形式一致了。

def A(arg):
    def _A(func):
        def new_func(args):
            #做一些额外的工作
            return func(args)
        return new_func
    return _A
@A(arg)
def f(args):pass

可以看出A(arg)返回了一个新的 decorator _A。

decorator的应用场景

不过我也一直在想，到底decorator的魔力是什么？适合在哪些场合呢？是否我需要使用它呢？

decorator的魔力就是它可以对所修饰的函数进行加工。那么这种加工是在不改变原来函数代码的情况下进行的。有点象我知道那么一点点的AOP(面向方面编程)的想法。

它适合的场合我能想到的列举出下：

1. 象文档中所说，最初是为了使调用staticmethod和classmethod这样的方法更方便
2. 在某些函数执行前做一些工作，如web开发中，许多函数在调用前需要先检查一下用户是否已经登录，然后才能调用
3. 在某此函数执行后做一些工作，如调用完毕后，根据返回状态写日志
4. 做参数检查

可能还有许多，你可以自由发挥想象

那么我需要用它吗？

我想那要看你了。不过，我想在某些情况下，使用decorator可以增加程序的灵活性，减少耦合度。比如前面所说的用户登录检查。的确可以写一个通用的登录检查函数，然后在每个函数中进行调用。但这样会造成函数不够灵活，而且增加了与其它函数之间的结合程度。如果用户登录检查功能有所修改，比如返回值的判断发生了变化，有可能每个用到它的函数都要修改。而使用decorator不会造成这一问题。同时使用decorator的语法也使得代码简单，清晰(一但你熟悉它的语法的话)。当然你不使用它是可以的。不过，这种函数之间相互结合的方式，更符合搭积木的要求，它可以把函数功能进一步分解，使得功能足够简单和单一。然后再通过decorator的机制灵活的把相关的函数串成一个串，这么一想，还真是不错。比如下面：

@A
@B
def account(args):pass

假设这是一个记帐处理函数，account只管记帐。但一个真正的记帐还有一些判断和处理，比如：B检查帐户状态，A记日志。这样的效果其实是先检查B、通过在A中的处理可以先执行account，然后再进行记日志的处理。象搭积木一样很方便，改起来也容易。甚至可以把account也写成decorator，而下面执行的函数是一个空函数。然后再通过配置文件等方法，将decorator的组合保存起来，就基本实现功能的组装化。是不是非常理想。

Python 带给人的创造力真是无穷啊！

Trackback: http://tb.donews.net/TrackBack.aspx?PostId=207521

@audit
def test(a):
    print a

test("abc")

运行结果:
('abc',)
abc

#coding=utf-8
import os
import shutil
import sys
import stat

def deleteSubFile(svnpath):
    names = os.listdir(svnpath)
    for name in names:
       
        fp = os.path.join( svnpath, name)
        if (os.path.isfile(fp)):
            os.chmod( fp, stat.S_IWRITE)
            os.remove(fp)
        else:
            deleteSubFile(fp)
            

def deleteSVN(parentPath = None, dir = None):
    if (dir != None and dir == '.svn'):
        deleteSubFile(os.path.join( parentPath, dir))
        shutil.rmtree(os.path.join( parentPath, dir), True, False)
        print 'deleted ', os.path.join( parentPath, dir)
    else:
        if (dir != None):
            filePath = os.path.join( parentPath, dir)
        else:
            filePath = parentPath
        names = os.listdir(filePath)
        for name in names:
            fp = os.path.join( filePath, name)
            if (os.path.isdir(fp)):
                deleteSVN(filePath, name)

if len(sys.argv) < 2:
    print 'Usage: python % <file path>' % os.path.basename(sys.argv[0])
    sys.exit(-1)

if os.path.isfile(sys.argv[1]):
    print '请选择文件夹, 而不是文件'
else:
    deleteSVN(parentPath = sys.argv[1])

1. 包含yield的函数

2. yield是一个表达式

3. 透过next()语句看原理

4. send(msg) 与 next()

5. send(msg) 与 next()的返回值

6. throw() 与 close()中断 Generator

同样地, exec语句将字符串str当成有效Python代码来执行.提供给exec的代码的名称空间和exec语句的名称空间相同.

最后，execfile(filename [,globals [,locals ]])函数可以用来执行一个文件,看下面的例子:

>>> eval('3+4')
7
>>> exec 'a=100'
>>> a
100
>>> execfile(r'c:\test.py')
hello,world!
>>>
默认的，eval(),exec,execfile()所运行的代码都位于当前的名字空间中. eval(), exec,和 execfile()函数也可以接受一个或两个可选字典参数作为代码执行的全局名字空间和局部名字空间. 例如:

1 globals = {'x': 7,
2            'y': 10,
3            'birds': ['Parrot', 'Swallow', 'Albatross']
4           }
5 locals = { }
6
7 # 将上边的字典作为全局和局部名称空间
8 a = eval("3*x + 4*y", globals, locals)
9 exec "for b in birds: print b" in globals, locals   # 注意这里的语法
10 execfile("foo.py", globals, locals)

如果你省略了一个或者两个名称空间参数,那么当前的全局和局部名称空间就被使用.如果一个函数体内嵌嵌套函数或lambda匿名函数时,同时又在函数主体中使用exec或execfile()函数时， 由于牵到嵌套作用域，会引发一个SyntaxError异常.（此段原文:If you omit one or both namespaces, the current values of the global and local namespaces are used. Also,due to issues related to nested scopes, the use of exec or execfile() inside a function body may result in a SyntaxError exception if that function also contains nested function definitions or uses the lambda operator.）

在Python2.4中俺未发现可以引起异常
注意例子中exec语句的用法和eval(), execfile()是不一样的. exec是一个语句(就象print或while), 而eval()和execfile()则是内建函数.
exec(str) 这种形式也被接受，但是它没有返回值。
当一个字符串被exec,eval(),或execfile()执行时,解释器会先将它们编译为字节代码，然后再执行.这个过程比较耗时,所以如果需要对某段代码执行很多次时,最好还是对该代码先进行预编译,这样就不需要每次都编译一遍代码，可以有效提高程序的执行效率。
compile(str ,filename ,kind )函数将一个字符串编译为字节代码, str是将要被编译的字符串, filename是定义该字符串变量的文件，kind参数指定了代码被编译的类型-- 'single'指单个语句, 'exec'指多个语句, 'eval'指一个表达式. cmpile()函数返回一个代码对象，该对象当然也可以被传递给eval()函数和exec语句来执行,例如:

1 str = "for i in range(0,10): print i"
2 c = compile(str,'','exec')      # 编译为字节代码对象
3 exec c                          # 执行
4
5 str2 = "3*x + 4*y"
6 c2 = compile(str2, '', 'eval')  # 编译为表达

theString = 'saaaay yes no yaaaass'
print theString.strip('say')

 yes no

这样theString首尾字符在['s', 'a', 'y']中的字符将会被过滤掉. lstrip和rstrip原理以及用法和strip一样.

def f(x):
    return x % 2 != 0 and x % 3 != 0
print filter(f, range(2, 25))

[5, 7, 11, 13, 17, 19, 23]

def cube(x):
    return x * x * x
print map(cube, range(1, 11))

[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]

def add(x, y):
    return x + y
print map(add, range(1, 5), range(3, 7))

[4, 6, 8, 10]

print reduce(add, range(1, 11))

55

print sum(range(1, 11))

55

from __future__ import with_statement

with open('test.txt', 'r') as f:
    for line in f:
        print line

1 非贪婪flag

注意比较这种情况：

2 如果你要多行匹配，那么加上re.S和re.M标志
re.S：.将会匹配换行符，默认.不会匹配换行符

re.M：^$标志将会匹配每一行，默认^和$只会匹配第一行

但是，如果没有^标志，

可见，是无需re.M

原文地址:http://www.juyimeng.com/python-multi-line-non-greedy-regular-expression-sample.html

name = '''you test this is for mae <img src="/upload/images/123455.jpg"/>, test for you just liook <img src="/upload/images/1test455.jpg"/>'''
result = re.findall('<img src="(.*?)"/>', name, re.S)
print result

用作格式化高亮代码的

python-markdown

提供类似wiki格式的格式化功能（mark text转html）
http://www.freewisdom.org/projects/python-markdown/

markdown的帮助文档：
http://www.unix-center.net/moodle/help.php?file=markdown.html
http://daringfireball.net/projects/markdown/basics

python-textile

Textile is an XHTML generator that uses a simple markup, similar to the one you can find on most wikis.

This is a Python module that implements a parser and generator that supports the Textile markup syntax.