Pypress

account.balance += 1

update account set balance = balance + 1 where id=1;

Table.update().where(Table.xxxxxxx).values({Table.c.value:Table.c.value+1});

account.balance = Account.__table__.c.balance + 1

client = suds.client.Client(wsdl, async=True)

import tornado.httpclient
import tornado.ioloop
import suds
wsdl = 'http://....'
client = suds.client.Client(wsdl, async=True)
iploop = tornado.ioloop.IOLoop.instance()
http_client = tornado.httpclient.AsyncHTTPClient()

# request即suds的异步Client返回的值
request = client.service.method(args)
http_request = tornado.httpclient.HTTPRequest(
                                        request.url,
                                        method='POST',
                                        headers=request.headers,
                                        body=request.message)
def callback(response):
    if response.error:
        print response.error
    else:
        # 解析suds
        reply = suds.transport.Reply(response.code, response.headers, response.body)
        content = client.service.method.processreply(reply)
        print content
    ioloop.stop()
    return

http_client.fetch(http_request, callback)
ioloop.start()

try:
    import cPickle as pickle
except ImportError:
    import pickle
import time
import logging
from uuid import uuid4

class RedisSessionStore(object):
    def __init__(self, redis_connection, **options):
        self.options = {
            'key_prefix': 'session',
            'expire': 7200,
        }
        self.options.update(options)
        self.redis = redis_connection

    def prefixed(self, sid):
        return '%s:%s' % (self.options['key_prefix'], sid)

    def generate_sid(self):
        return uuid4().get_hex()

    def get_session(self, sid, name):
        data = self.redis.hget(self.prefixed(sid), name)
        session = pickle.loads(data) if data else dict()
        return session

    def set_session(self, sid, session_data, name, expiry=None):
        self.redis.hset(self.prefixed(sid), name, pickle.dumps(session_data))
        expiry = expiry or self.options['expire']
        if expiry:
            self.redis.expire(self.prefixed(sid), expiry)

    def delete_session(self, sid):
        self.redis.delete(self.prefixed(sid))


class RedisSession(object):
    def __init__(self, session_store, session_id=None, expires_days=None):
        self._store = session_store
        self._sid = session_id if session_id else self._store.generate_sid()
        self._dirty = False
        self.set_expires(expires_days)
        try:
            self._data = self._store.get_session(self._sid, 'data')
        except:
            logging.error('Can not connect Redis server.')
            self._data = {}

    def clear(self):
        self._store.delete_session(self._sid)

    @property
    def id(self):
        return self._sid
    
    def access(self, remote_ip):
        access_info = {'remote_ip':remote_ip, 'time':'%.6f' % time.time()}
        self._store.set_session(
                self._sid,
                'last_access',
                pickle.dumps(access_info))

    def last_access(self):
        access_info = self._store.get_session(self._sid, 'last_access')
        return pickle.loads(access_info)

    def set_expires(self, days):
        self._expiry = days * 86400 if days else None

    def __getitem__(self, key):
        return self._data[key]

    def __setitem__(self, key, value):
        self._data[key] = value
        self._dirty = True

    def __delitem__(self, key):
        del self._data[key]
        self._dirty = True

    def __len__(self):
        return len(self._data)

    def __contains__(self, key):
        return key in self._data

    def __iter__(self):
        for key in self._data:
            yield key

    def __repr__(self):
        return self._data.__repr__()

    def __del__(self):
        self.save()

    def save(self):
        if self._dirty:
            self._store.set_session(self._sid, self._data, 'data', self._expiry)
            self._dirty = False

class Session(object):
    def __init__(self, get_secure_cookie, set_secure_cookie, name='_session', expires_days=None):
        self.set_session = set_secure_cookie
        self.get_session = get_secure_cookie
        self.name = name
        self._expiry = expires_days
        self._dirty = False
        self.get_data()
    
    def get_data(self):
        value = self.get_session(self.name)
        self._data = pickle.loads(value) if value else {}

    def set_expires(self, days):
        self._expiry = days

    def __getitem__(self, key):
        return self._data[key]
    
    def __setitem__(self, key, value):
        self._data[key] = value
        self._dirty = True
    
    def __delitem__(self, key):
        if key in self._data:
            del self._data[key]
            self._dirty = True
        
    def __contains__(self, key):
        return key in self._data
    
    def __len__(self):
        return len(self._data)
    
    def __iter__(self):
        for key in self._data:
            yield key
    
    def __del__(self):
        self.save()

    def save(self):
        if self._dirty:
            self.set_session(self.name, pickle.dumps(self._data), expires_days=self._expiry)
            self._dirty = False

self.session['user'] = user
self.session.save()

# REDIS_SERVER = False

# If set to None or 0 the session will be deleted when the user closes the browser.
# If set number the session lives for value days.
PERMANENT_SESSION_LIFETIME = 1 # days

@property
    def session(self):
        if hasattr(self, '_session'):
            return self._session
        else:
            self.require_setting('permanent_session_lifetime', 'session')
            expires = self.settings['permanent_session_lifetime'] or None
            if 'redis_server' in self.settings and self.settings['redis_server']:
                sessionid = self.get_secure_cookie('sid')
                self._session = RedisSession(self.application.session_store, sessionid, expires_days=expires)
                if not sessionid: 
                    self.set_secure_cookie('sid', self._session.id, expires_days=expires)
            else:
                self._session = Session(self.get_secure_cookie, self.set_secure_cookie, expires_days=expires)
            return self._session

#!/usr/bin/env python
#coding=utf-8
"""
    Base64 encoded images embedded in CSS file
    ~~~~~~~~~~~
    :author: laoqiu.com@gmail.com
"""
import sys
import os
import re
from base64 import encodestring

_url_re = re.compile(r'url\([\'\"]?(?P<url>[^\'\"\)]+)[\'\"]?\)')
        
class Base64Image(object):
    """
        bi = Base64Image()
        bi.encode_file('path/to/file.css', max_size=5) # max_size = 5k
    """
    def __init__(self):
        pass

    def encode_image(self, image_path, base_path='', max_size=1):
        full_path = os.path.join(base_path, image_path)

        if not os.path.isfile(full_path):
            return image_path

        if os.path.getsize(full_path) > max_size * 1024:
            return image_path

        template = 'data:image/%s;base64,%s'

        extension = os.path.splitext(os.path.basename(image_path))[-1][1:]
        assert extension in ('gif','png'), extension

        data = encodestring(file(full_path,'rb').read()).replace('\n','')
        result = template % (extension, data)
        
        return result

    def encode_file(self, file_path, max_size=1):
        """ max_size = 1 (k) """
        if not os.path.isfile(file_path):
            return "No such file: '%s'" % file_path
        
        base_path = os.path.dirname(file_path)
        
        outfile = open('%s_base64%s' % os.path.splitext(file_path), 'wb')

        with open(file_path, 'r') as f:
            for line in f:
                print >> outfile, self._encode(line, base_path).replace('\n','')
        return
    
    def _encode(self, value, base_path):
        f_list = _url_re.findall(value)

        if f_list:
            s_list = _url_re.split(value)

            for background_attr in _url_re.finditer(value):
            
                url = background_attr.group('url')
                index = s_list.index(url)

                s_list[index] = "url('%s')" % self.encode_image(url, base_path)

            return u''.join(s_list)

        return value


if __name__=="__main__":
    if len(sys.argv) < 2:
        print 'python static_base64.py path'
        sys.exit(1)

    path = sys.argv[1]

    b = Base64Image()
    if os.path.splitext(path)[1]=='.css':
        print b.encode_file(path)
    else:
        print b.encode_image(path)

document.execCommand('bold', false, null)

insertNewParagraph : function(elementArray, succeedingElement) {
                var body = $(this.iframe).contents().find('body');
                var paragraph = this.iframe.contentWindow.document.createElement("p");
                $(elementArray).each(function(){
                    $(paragraph).append(this);
                });
                if (typeof(succeedingElement) != "undefined"){
                    try {
                        body[0].insertBefore(paragraph, succeedingElement);
                    }
                    catch (e) {
                        body[0].insertBefore(paragraph, succeedingElement[0]);
                    }
                } else {
                    body.append(paragraph);
                }
                return true;
            }

class ErrorHandler(RequestHandler):
    """raise 404 error if url is not found.
    fixed tornado.web.RequestHandler HTTPError bug.
    """
    def prepare(self):
        self.set_status(404)
        raise tornado.web.HTTPError(404)

class FlashMessageMixIn(object):
    """
        Store a message between requests which the user needs to see.
        views
        -------
        self.flash("Welcome back, %s" % username, 'success')
        base.html
        ------------
        {% set messages = handler.get_flashed_messages() %}
        {% if messages %}
            {% for category, msg in messages %}
            {{ msg }}
            {% end %}
        {% end %}
    """
    def flash(self, message, category='message'):
        messages = self.messages()
        messages.append((category, message))
        self.set_secure_cookie('flash_messages', tornado.escape.json_encode(messages))
    
    def messages(self):
        messages = self.get_secure_cookie('flash_messages')
        messages = tornado.escape.json_decode(messages) if messages else []
        return messages
        
    def get_flashed_messages(self):
        messages = self.messages()
        self.clear_cookie('flash_messages')
        return messages

def create_forms():
    _forms = {}
    for locale in tornado.locale.get_supported_locales(None):
        _ = tornado.locale.get(locale).translate
        is_username = regexp(USERNAME_RE, 
                             message=_("You can only use letters, numbers or dashes"))
        
        class FormWrapper(object):
            class LoginForm(Form):
                pass        
        
        _forms[locale] = FormWrapper    
    return _forms

def _record(self, mapper, model, operation):
    pk = tuple(mapper.primary_key_from_instance(model))
    orm.object_session(model)._model_changes[pk] = (model, operation)
    return EXT_CONTINUE

def _record(self, mapper, model, operation):
        pk = tuple(mapper.primary_key_from_instance(model))
        #orm.object_session(model)._model_changes[pk] = (model, operation)
        changes = {}
        
        for prop in object_mapper(model).iterate_properties:
            if not isinstance(prop, RelationshipProperty):
                try:
                    history = attributes.get_history(model, prop.key)
                except:
                    continue

                added, unchanged, deleted = history

                newvalue = added[0] if added else None

                if operation=='delete':
                    oldvalue = unchanged[0] if unchanged else None
                else:
                    oldvalue = deleted[0] if deleted else None

                if newvalue or oldvalue:
                    changes[prop.key] = (oldvalue, newvalue)
        
        orm.object_session(model)._model_changes[pk] = (model.__tablename__, pk[0], changes, operation)
        return EXT_CONTINUE

from tornado.web import url

class Route(object):
    _routes = {}
    def __init__(self, pattern, kwargs={}, name=None, host='.* ):
        self.pattern = pattern
        self.kwargs = {}
        self.name = name
        self.host = host

    def __call__(self, handler_class):
        spec = url(self.pattern, handler_class, self.kwargs, name=self.name)
        self._routes.setdefault(self.host, []).append(spec)
        return handler_class

    @classmethod
    def routes(cls, application=None):
        if application:
            for host, handlers in cls._routes.items():
                application.add_handlers(host, handlers)
        else:
            return reduce(lambda x,y:x+y, cls._routes.values()) if cls._routes else []

    @classmethod
    def url_for(cls, name, *args):

        named_handlers = dict([(spec.name, spec) for spec in cls.routes() if spec.name])

        if name in named_handlers:

            return named_handlers[name].reverse(*args)

        raise KeyError("%s not found in named urls" % name)

route = Route

class Application(tornado.web.Application):
    def __init__(self):
        handlers = [
            # ...
        ] + Route.routes()

def endtags(html):
    """ close all open html tags at the end of the string """

    NON_CLOSING_TAGS = ['AREA', 'BASE', 'BASEFONT', 'BR', 'COL', 'FRAME',
            'HR', 'IMG', 'INPUT', 'ISINDEX', 'LINK', 'META', 'PARAM']

    opened_tags = re.findall(r"<([a-z]+)[^<>]*>",html)
    closed_tags = re.findall(r"<!--([a-z]+)-->",html)

    opened_tags = [i.lower() for i in opened_tags if i.upper() not in NON_CLOSING_TAGS]
    closed_tags = [i.lower() for i in closed_tags]

    len_opened = len(opened_tags)

    if len_opened==len(closed_tags):
        return html

    opened_tags.reverse()

    for tag in opened_tags:
        if tag in closed_tags:
            closed_tags.remove(tag)
        else:
            html += "</%s>" % tag
     
    return html

def oauth_request_from_flask_request(request):
    url = request.base_url
    params = dict([(str(k), v) for k, v in request.values.items()])
  
    post_data = request.data if request.method == 'POST' else ""
    headers = {}
    if 'HTTP_AUTHORIZATION' in request.environ:
        headers['Authorization'] = request.environ['HTTP_AUTHORIZATION']

    oauth_request = oauth.Request.from_request(
        request.method,
        url,
        headers=headers,
        query_string=post_data, 
        parameters=params)
  
    return oauth_request

consumer = oauth.Consumer(consumer_key, consumer_secret)
token = oauth.Token(token_key, token_secret)

# re-construct request
req = oauth_request_from_flask_request(request)

# check signature
oauth_server._check_signature(req, consumer, token)

class User(Base):
    __tablename__ = 'user'
    id = Column('user_id', Integer, primary_key=True)
    name = Column('user_name', String(50))
    email = Column('email', String(50))

    def __init__(self):
        ....

    def get_avatar_url(self):
        hash = hashlib.md5(self.email).hexdigest()
        return 'http://www.gravatar.com/avatar/%s' % hash

class User(Base):
    __tablename__ = 'user'
    id = Column('user_id', Integer, primary_key=True)
    name = Column('user_name', String(50))
    avatar = Column('email', String(50))

    def __init__(self):
        ....
    
    num_address = column_property(
        select([func.count(Address.user_id)]).\
            where(Address.user_id==id).as_scalar())

class PostQuery(BaseQuery):

    def get_or_404(self, id):
        post = self.get(id)
        if post is None:
            ...error...
        return post

class Post(Base):
    __tablename__ = 'posts'

    query_class = PostQuery
    
    id = Column('user_id', Integer, primary_key=True)    
    ....

cookie = cookielib.CookieJar()
cookie_support= urllib2.HTTPCookieProcessor(cookie)
opener = urllib2.build_opener(cookie_support)

import urllib, urllib2, socket, cookielib
import json, re, os
import time, datetime

# from gzipSupport import ContentEncodingProcessor

# set timeout
timeout = 20
timesleep = 10
socket.setdefaulttimeout(timeout)

httpHandler = urllib2.HTTPHandler()
httpsHandler = urllib2.HTTPSHandler()

# cookie support
cookie = cookielib.CookieJar()
cookie_support= urllib2.HTTPCookieProcessor(cookie)

# gzip support
# gzip_support = ContentEncodingProcessor

opener = urllib2.build_opener(cookie_support, httpHandler, httpsHandler)
urllib2.install_opener(opener)

def get_headers():
    headers = {
        "User-Agent":"Mozilla/5.0 (Windows; U; Windows NT 5.1; zh-CN; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13",
        #"User-Agent" = "Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.2.13) Gecko/20101206 Ubuntu/10.10 (maverick) Firefox/3.6.13",
        "Accept":"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
        "Accept-Language":"zh-cn,zh;q=0.5",
        #"Accept-Encoding":"gzip,deflate",
        "Accept-Charset":"GB2312,utf-8;q=0.7,*;q=0.7",
        "Keep-Alive":"115",
        "Connection":"keep-alive"
    }

    return headers

def get_login_data():
    login_data = {
            'TPL_username':u'用户名'.encode('gbk'),
            'action':'Authenticator',
            'event_submit_do_login':'anything',
            'TPL_redirect_url':'',
            'from':'tb',
            'fc':'2',
            'style':'default',
            'css_style':'',
            'tid':'',
            'support':'000001',
            'CtrlVersion':'1,0,0,7',
            'loginType':'3',
            'minititle':'',
            'minipara':'',
            'pstrong':'3',
            'longLogin':'-1',
            'llnick':'',
            'sign':'',
            'need_sign':'',
            'isIgnore':'',
            'popid':'',
            'callback':'',
            'guf':'',
            'not_duplite_str':'',
            'need_user_id':'',
            'poy':'',
            'gvfdcname':'10',
            'from_encoding':''
            }
    return login_data

def login(source=None):
    """ login """
    url = 'https://login.taobao.com/member/login.jhtml'
    if not source:
        source = request(url=url)
    token_list = re.findall(r"input name='_tb_token_' type='hidden' value='([a-zA-Z0-9]+)'", source)
    login_data = get_login_data()
    login_data['_tb_token_'] = token_list[0] if token_list else ''
    login_data['TPL_password'] = raw_input("input password:")

    source = request(url=url, data=login_data)
    r = re.findall(r'window.location = "([\w\W]+)";', source)
    if r:
        redirect_url = r[0]
    else:
        print "login failed, valid password and try again"
        return False

    request(url=redirect_url)
    return True

def request(url, headers=None, data=dict()):
    if headers is None:
        headers = get_headers()
    
    data = urllib.urlencode(data) if data else None
    req = urllib2.Request(
            url = url,
            data = data,
            headers = headers
            )
    try:
        request = urllib2.urlopen(req)
        source = request.read()
        # print url
        # print request.code,request.msg
        request.close()
    except:
        source = None
        print "connect timeout"

    return source

if __name__=="__main__":
    login()