修改一下格式 pep8

miniakio/blog.py

@@ -4,13 +4,15 @@
 import re
 from tornado.web import removeslash
 from tornado.log import access_log
+
+from blogconfig import PICKY_DIR
+
 from .libs.handler import BaseHandler
 from .libs.crypto import PasswordCrypto, get_random_string
 from .libs.models import PostMixin, TagMixin
 from .libs.markdown import RenderMarkdownPost
 from .libs.utils import authenticated, signer_code
 from .libs.utils import unsigner_code, archives_list
-from blogconfig import PICKY_DIR
 
 
 class EntryHandler(BaseHandler, PostMixin):
@@ -23,8 +25,13 @@ def get(self, slug):
         tags = [tag.strip() for tag in post.tags.split(",")]
         next_prev = self.get_next_prev_post(post.published)
         signer = signer_code(str(post.id))
-        self.render("post.html", post=post, tags=tags, next_prev=next_prev,
-                                    signer=signer)
+        self.render(
+            "post.html",
+            post=post,
+            tags=tags,
+            next_prev=next_prev,
+            signer=signer
+        )
 
 
 class TagsHandler(BaseHandler, PostMixin):
@@ -35,8 +42,13 @@ def get(self, name):
         if not posts:
             self.abort(404)
         count = len(posts)
-        self.render("archive.html", posts=posts, type="tag", name=name,
-            count=count)
+        self.render(
+            "archive.html",
+            posts=posts,
+            type="tag",
+            name=name,
+            count=count
+        )
 
 
 class CategoryHandler(BaseHandler, PostMixin):
@@ -47,8 +59,13 @@ def get(self, category):
         if not posts:
             self.abort(404)
         count = len(posts)
-        self.render("archive.html", posts=posts, type="category",
-                                    name=category, count=count)
+        self.render(
+            "archive.html",
+            posts=posts,
+            type="category",
+            name=category,
+            count=count
+        )
 
 
 class FeedHandler(BaseHandler, PostMixin):
@@ -74,24 +91,28 @@ def get(self):
         else:
             posts = self.get_count_posts(8)
             self.render("home.html", posts=posts)
-            
+
 
 class ArchiveHandler(BaseHandler, PostMixin, TagMixin):
 
     def get(self):
         posts = self.get_count_posts()
         count = len(posts)
-        self.render('archives.html', posts=posts, count=count,
-            archives_list=archives_list)
+        self.render(
+            "archives.html",
+            posts=posts,
+            count=count,
+            archives_list=archives_list
+        )
 
 
 class TagListHandler(BaseHandler, TagMixin):
 
     def get(self):
         tags = self.get_all_tag_count()
         count = len(tags)
-        self.render('taglist.html', tags=tags, count=count)
-      
+        self.render("taglist.html", tags=tags, count=count)
+
 
 class NewPostHandler(BaseHandler, PostMixin):
 
@@ -108,7 +129,7 @@ def post(self):
 
         render = RenderMarkdownPost(markdown)
         post = render.get_render_post()
-        if comment == '0':
+        if comment == "0":
             comment = 0
         post.update({"comment": comment})
         self.create_new_post(**post)
@@ -122,7 +143,7 @@ class UpdatePostHandler(BaseHandler, PostMixin):
     def get(self, id):
         post = self.get_post_by_id(int(id))
         if not post:
-            self.redirect('/')
+            self.redirect("/")
         self.render("admin/update.html", id=id)
 
     @authenticated
@@ -136,7 +157,7 @@ def post(self, id):
         render = RenderMarkdownPost(markdown)
         post = render.get_render_post()
 
-        if comment == '0':
+        if comment == "0":
             comment = 0
 
         post.update({"comment": comment})
@@ -195,18 +216,19 @@ def get(self):
     @authenticated
     def post(self):
         try:
-            files = self.request.files['picky'][0]
+            files = self.request.files["picky"][0]
         except KeyError:
-            self.redirect('/post/picky')
+            self.redirect("/post/picky")
             return
-
-        if files['body'] and (files['filename'].split(".").pop().lower()=='md'):
-            f = open(PICKY_DIR + '/' + files['filename'], 'w')
-            f.write(files['body'])
+
+        ext = files['filename'].split(".").pop().lower()
+        if files["body"] and (ext == "md"):
+            f = open(PICKY_DIR + "/" + files["filename"], "w")
+            f.write(files["body"])
             f.close()
-            slug = files['filename'].split('.')[0]
+            slug = files["filename"].split(".")[0]
             self.redirect("/picky/%s" % slug)
-        self.redirect('/post/picky')
+        self.redirect("/post/picky")
 
 
 class SigninHandler(BaseHandler):
@@ -223,7 +245,7 @@ def post(self):
         if (not email) or (not password):
             self.redirect("/auth/signin")
             return
-        pattern = r'^.+@[^.].*\.[a-z]{2,10}$'
+        pattern = r"^.+@[^.].*\.[a-z]{2,10}$"
         if isinstance(pattern, basestring):
             pattern = re.compile(pattern, flags=0)
 
@@ -265,21 +287,22 @@ def get(self):
         self.abort(404)
 
 
-handlers = [('/', HomeHandler),
-            ('/([a-zA-Z0-9-]+)/*', EntryHandler),
-            ('/picky/([a-zA-Z0-9-]+)/*', PickyHandler),
-            ('/picky/([a-zA-Z0-9-]+.md)', PickyDownHandler),
-            ('/tag/([^/]+)/*', TagsHandler),
-            ('/category/([^/]+)/*', CategoryHandler),
-            ('/post/new', NewPostHandler),
-            ('/post/delete/([0-9]+)', DeletePostHandler),
-            ('/post/update/([0-9]+)', UpdatePostHandler),
-            ('/post/picky', NewPickyHandler),
-            ('/auth/signin', SigninHandler),
-            ('/auth/signout', SignoutHandler),
-            ('/blog/feed', FeedHandler),
-            ('/search/all', SearchHandler),
-            ('/blog/all', ArchiveHandler),
-            ('/blog/tags', TagListHandler),
-            (r'.*', PageNotFound),
+handlers = [
+    (r"/", HomeHandler),
+    (r"/([a-zA-Z0-9-]+)/*", EntryHandler),
+    (r"/picky/([a-zA-Z0-9-]+)/*", PickyHandler),
+    (r"/picky/([a-zA-Z0-9-]+.md)", PickyDownHandler),
+    (r"/tag/([^/]+)/*", TagsHandler),
+    (r"/category/([^/]+)/*", CategoryHandler),
+    (r"/post/new", NewPostHandler),
+    (r"/post/delete/([0-9]+)", DeletePostHandler),
+    (r"/post/update/([0-9]+)", UpdatePostHandler),
+    (r"/post/picky", NewPickyHandler),
+    (r"/auth/signin", SigninHandler),
+    (r"/auth/signout", SignoutHandler),
+    (r"/blog/feed", FeedHandler),
+    (r"/search/all", SearchHandler),
+    (r"/blog/all", ArchiveHandler),
+    (r"/blog/tags", TagListHandler),
+    (r".*", PageNotFound),
 ]

miniakio/libs/crypto.py

@@ -10,11 +10,10 @@
 
 trans_5c = "".join([chr(x ^ 0x5C) for x in xrange(256)])
 trans_36 = "".join([chr(x ^ 0x36) for x in xrange(256)])
+rand_chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
 
 
-def get_random_string(length=12,
-                      allowed_chars='abcdefghijklmnopqrstuvwxyz'
-                                    'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'):
+def get_random_string(length=12):
     """
     Returns a random string of length characters from the set of a-z, A-Z, 0-9
     for use as a salt.
@@ -23,11 +22,12 @@ def get_random_string(length=12,
     a 71-bit salt. log_2((26+26+10)^12) =~ 71 bits
     """
     import random
+
     try:
         random = random.SystemRandom()
     except NotImplementedError:
         pass
-    return ''.join([random.choice(allowed_chars) for i in range(length)])
+    return "".join([random.choice(rand_chars) for i in range(length)])
 
 
 def constant_time_compare(val1, val2):
@@ -50,7 +50,7 @@ def bin_to_long(x):
 
     This is a clever optimization for fast xor vector math
     """
-    return long(x.encode('hex'), 16)
+    return long(x.encode("hex"), 16)
 
 
 def long_to_bin(x):
@@ -59,7 +59,7 @@ def long_to_bin(x):
     """
     hex = "%x" % (x)
     if len(hex) % 2 == 1:
-        hex = '0' + hex
+        hex = "0" + hex
     return binascii.unhexlify(hex)
 
 
@@ -123,18 +123,18 @@ class PasswordCrypto(object):
     def get_encrypted(cls, password, salt=None, iterations=None):
         if not password:
             return None
-        if (not salt) or ('$' in salt):
+        if (not salt) or ("$" in salt):
             salt = get_random_string()
         if not iterations:
             iterations = cls.ITERATIONS
         password = str(password)
         encrypted = pbkdf2(password, salt, iterations, digest=cls.DIGEST)
-        encrypted = encrypted.encode('base64').strip()
+        encrypted = encrypted.encode("base64").strip()
         return "%s$%d$%s$%s" % (cls.ALGORITHM, cls.ITERATIONS, salt, encrypted)
-    
+
     @classmethod
     def authenticate(cls, password, encrypted):
-        algorithm, iterations, salt, encrypt = encrypted.split('$', 3)
+        algorithm, iterations, salt, encrypt = encrypted.split("$", 3)
         if algorithm != cls.ALGORITHM:
             return False
         encrypted_new = cls.get_encrypted(password, salt, int(iterations))

miniakio/libs/markdown.py

@@ -2,9 +2,9 @@
 # -*- coding: utf-8 -*-
 
 import re
-from StringIO import StringIO
 import misaka as m
 
+from StringIO import StringIO
 from pygments import highlight
 from pygments.formatters import HtmlFormatter
 from pygments.lexers import get_lexer_by_name
@@ -19,31 +19,33 @@ def block_code(self, text, lang):
         if lang:
             lexer = get_lexer_by_name(lang, stripall=True)
         else:
-            return '<pre><code>%s</code></pre>' % xhtml_escape(text.strip())
+            return "<pre><code>%s</code></pre>" % xhtml_escape(text.strip())
 
         formatter = HtmlFormatter(
             noclasses=False,
             linenos=True,
         )
 
         return '<div class="highlight-pre">%s</div>' % \
-                        highlight(text, lexer, formatter)
+            highlight(text, lexer, formatter)
 
     def autolink(self, link, is_email):
         if is_email:
-            mailto = "".join(['&#%d;' % ord(letter) for letter in "mailto:"])
-            email = "".join(['&#%d;' % ord(letter) for letter in link])
+            mailto = "".join(["&#%d;" % ord(letter) for letter in "mailto:"])
+            email = "".join(["&#%d;" % ord(letter) for letter in link])
             url = mailto + email
-            return '<a href="%(url)s">%(link)s</a>' % {'url': url, 'link': email}
+            return '<a href="%(url)s">%(link)s</a>' % {
+                "url": url, "link": email
+            }
 
-        title = link.replace('http://', '').replace('https://', '')
+        title = link.replace("http://", "").replace("https://", "")
         if len(title) > 30:
             title = title[:24] + "..."
 
-        pattern = r'http://v.youku.com/v_show/id_([a-zA-Z0-9\=]+).html'
+        pattern = r"http://v.youku.com/v_show/id_([a-zA-Z0-9\=]+).html"
         match = re.match(pattern, link)
         if not match:
-            pattern = r'http://v.youku.com/v_show/id_([a-zA-Z0-9\=]+).html'
+            pattern = r"http://v.youku.com/v_show/id_([a-zA-Z0-9\=]+).html"
             match = re.match(pattern, link)
         if match:
             value = (
@@ -76,29 +78,29 @@ def get_render_post(self):
         if not self.markdown:
             return None
         f = StringIO(self.markdown)
-        header = ''
+        header = ""
         body = None
         for line in f:
-            if line.startswith('---'):
-                body = ''
+            if line.startswith("---"):
+                body = ""
             elif body is not None:
                 body += line
             else:
                 header += line
 
-        meta = self.__get_post_meta(header)
+        meta = self._get_post_meta(header)
         content = markdown(body)
         meta.update({"content": content})
         return meta
 
-    def __get_post_meta(self, header):
+    def _get_post_meta(self, header):
         header = markdown(header)
-        title = re.findall(r'<h1>(.*)</h1>', header)[0]
+        title = re.findall(r"<h1>(.*)</h1>", header)[0]
 
-        meta = {'title': title}
-        items = re.findall(r'<li>(.*?)</li>', header, re.S)
+        meta = {"title": title}
+        items = re.findall(r"<li>(.*?)</li>", header, re.S)
         for item in items:
-            index = item.find(':')
+            index = item.find(":")
             key = item[:index].rstrip()
             value = item[index + 1:].lstrip()
             meta[key] = value