pep correct python code

2025-12-07 06:24:27 +08:00 · 2012-02-21 00:21:00 +01:00
parent 49b7e778ce
commit 7597ed05a0
2 changed files with 157 additions and 106 deletions
--- a/pycomplete.py
+++ b/pycomplete.py
@@ -4,10 +4,10 @@ import pyclbr
 import cStringIO
 import sys
 import types
-from token import ENDMARKER , NT_OFFSET , NUMBER , STRING , NEWLINE , INDENT , DEDENT , LPAR , RPAR , LSQB , RSQB , COLON , COMMA , SEMI , PLUS , MINUS , STAR , SLASH , VBAR , AMPER , LESS , GREATER , EQUAL , DOT , PERCENT , BACKQUOTE , LBRACE , RBRACE , EQEQUAL , NOTEQUAL , LESSEQUAL , GREATEREQUAL , TILDE , CIRCUMFLEX , LEFTSHIFT , RIGHTSHIFT , DOUBLESTAR , PLUSEQUAL , MINEQUAL , STAREQUAL , SLASHEQUAL , PERCENTEQUAL , AMPEREQUAL , VBAREQUAL , CIRCUMFLEXEQUAL , LEFTSHIFTEQUAL , RIGHTSHIFTEQUAL , DOUBLESTAREQUAL , DOUBLESLASH , DOUBLESLASHEQUAL , AT , NAME , ERRORTOKEN , N_TOKENS , OP

 from pyfuzzyparser import PyFuzzyParser, _sanitize

+
 def complete(file_name, line, colon):
    options = []
    print file_name, line, colon
@@ -24,55 +24,62 @@ def complete(file_name, line, colon):
            pass
    return options

+
 print 1
 if __name__ == '__main__':
    #print complete('test.py', 50, 3)
    #print complete('test.py', 51, 10)
    pass

+
 class Completer(object):
    def __init__(self):
-       self.compldict = {}
-       self.parser = PyFuzzyParser()
+        self.compldict = {}
+        self.parser = PyFuzzyParser()

-    def evalsource(self,text,line=0):
-        sc = self.parser.parse(text,line)
-        self.sc = sc # TODO rm
+    def evalsource(self, text, line=0):
+        sc = self.parser.parse(text, line)
+        self.sc = sc  # TODO rm
        src = sc.get_code()
        dbg("source: %s" % src)
        #try: exec(src) in self.compldict
-        #except: dbg("parser: %s, %s" % (sys.exc_info()[0],sys.exc_info()[1]))
+        #except: dbg("parser: %s, %s" % (sys.exc_info()[0], sys.exc_info()[1]))
        #for l in sc.locals:
        #    dbg("local: %s" % l)
        #    try: exec(l) in self.compldict
-        #    except: dbg("locals: %s, %s [%s]" % (sys.exc_info()[0],sys.exc_info()[1],l))
+        #    except: dbg("locals: %s, %s [%s]" % (sys.exc_info()[0], sys.exc_info()[1], l))

-    def _cleanstr(self,doc):
-        return doc.replace('"',' ').replace("'",' ')
+    def _cleanstr(self, doc):
+        return doc.replace('"', ' ').replace("'", ' ')

-    def get_arguments(self,func_obj):
+    def get_arguments(self, func_obj):
        def _ctor(obj):
-            try: return class_ob.__init__.im_func
+            try:
+                return class_ob.__init__.im_func
            except AttributeError:
                for base in class_ob.__bases__:
                    rc = _find_constructor(base)
-                    if rc is not None: return rc
+                    if rc is not None:
+                        return rc
            return None

        arg_offset = 1
-        if type(func_obj) == types.ClassType: func_obj = _ctor(func_obj)
-        elif type(func_obj) == types.MethodType: func_obj = func_obj.im_func
-        else: arg_offset = 0
+        if type(func_obj) == types.ClassType:
+            func_obj = _ctor(func_obj)
+        elif type(func_obj) == types.MethodType:
+            func_obj = func_obj.im_func
+        else:
+            arg_offset = 0

-        arg_text=''
+        arg_text = ''
        if type(func_obj) in [types.FunctionType, types.LambdaType]:
            try:
                cd = func_obj.func_code
                real_args = cd.co_varnames[arg_offset:cd.co_argcount]
                defaults = func_obj.func_defaults or ''
                defaults = map(lambda name: "=%s" % name, defaults)
-                defaults = [""] * (len(real_args)-len(defaults)) + defaults
-                items = map(lambda a,d: a+d, real_args, defaults)
+                defaults = [""] * (len(real_args) - len(defaults)) + defaults
+                items = map(lambda a, d: a + d, real_args, defaults)
                if func_obj.func_code.co_flags & 0x4:
                    items.append("...")
                if func_obj.func_code.co_flags & 0x8:
@@ -80,7 +87,7 @@ class Completer(object):
                arg_text = (','.join(items)) + ')'

            except:
-                dbg("arg completion: %s: %s" % (sys.exc_info()[0],sys.exc_info()[1]))
+                dbg("arg completion: %s: %s" % (sys.exc_info()[0], sys.exc_info()[1]))
                pass
        if len(arg_text) == 0:
            # The doc string sometimes contains the function signature
@@ -95,15 +102,18 @@ class Completer(object):
                    lidx = sigline.find('(')
                    ridx = sigline.find(')')
                    if lidx > 0 and ridx > 0:
-                        arg_text = sigline[lidx+1:ridx] + ')'
-        if len(arg_text) == 0: arg_text = ')'
+                        arg_text = sigline[lidx + 1:ridx] + ')'
+        if len(arg_text) == 0:
+            arg_text = ')'
        return arg_text

-    def get_completions(self,context,match):
-        dbg("get_completions('%s','%s')" % (context,match))
+    def get_completions(self, context, match):
+        dbg("get_completions('%s','%s')" % (context, match))
        stmt = ''
-        if context: stmt += str(context)
-        if match: stmt += str(match)
+        if context:
+            stmt += str(context)
+        if match:
+            stmt += str(match)
        try:
            result = None
            all = {}
@@ -111,14 +121,15 @@ class Completer(object):
            if len(stmt) > 0 and stmt[-1] == '(':
                result = eval(_sanitize(stmt[:-1]), self.compldict)
                doc = result.__doc__
-                if doc is None: doc = ''
+                if doc is None:
+                    doc = ''
                args = self.get_arguments(result)
-                return [{'word':self._cleanstr(args),'info':self._cleanstr(doc)}]
+                return [{'word': self._cleanstr(args), 'info': self._cleanstr(doc)}]
            elif ridx == -1:
                match = stmt
                all = self.compldict
            else:
-                match = stmt[ridx+1:]
+                match = stmt[ridx + 1:]
                stmt = _sanitize(stmt[:ridx])
                result = eval(stmt, self.compldict)
                all = dir(result)
@@ -126,23 +137,32 @@ class Completer(object):
            dbg("completing: stmt:%s" % stmt)
            completions = []

-            try: maindoc = result.__doc__
-            except: maindoc = ' '
-            if maindoc is None: maindoc = ' '
+            try:
+                maindoc = result.__doc__
+            except:
+                maindoc = ' '
+            if maindoc is None:
+                maindoc = ' '
            for m in all:
-                if m == "_PyCmplNoType": continue #this is internal
+                if m == "_PyCmplNoType":
+                    continue  # this is internal
                try:
                    dbg('possible completion: %s' % m)
                    if m.find(match) == 0:
-                        if result is None: inst = all[m]
-                        else: inst = getattr(result,m)
-                        try: doc = inst.__doc__
-                        except: doc = maindoc
+                        if result is None:
+                            inst = all[m]
+                        else:
+                            inst = getattr(result, m)
+                        try:
+                            doc = inst.__doc__
+                        except:
+                            doc = maindoc
                        typestr = str(inst)
-                        if doc is None or doc == '': doc = maindoc
+                        if doc is None or doc == '':
+                            doc = maindoc

                        wrd = m[len(match):]
-                        c = {'word':wrd, 'abbr':m,  'info':self._cleanstr(doc)}
+                        c = {'word': wrd, 'abbr': m,  'info': self._cleanstr(doc)}
                        if "function" in typestr:
                            c['word'] += '('
                            c['abbr'] += '(' + self._cleanstr(self.get_arguments(inst))
@@ -157,23 +177,26 @@ class Completer(object):
                        completions.append(c)
                except:
                    i = sys.exc_info()
-                    dbg("inner completion: %s,%s [stmt='%s']" % (i[0],i[1],stmt))
+                    dbg("inner completion: %s, %s [stmt='%s']" % (i[0], i[1], stmt))
            return completions
        except:
            i = sys.exc_info()
-            dbg("completion: %s,%s [stmt='%s']" % (i[0],i[1],stmt))
+            dbg("completion: %s, %s [stmt='%s']" % (i[0], i[1], stmt))
            return []

-debugstmts=[]
-def dbg(s): debugstmts.append(s)
-def showdbg():
-    for d in debugstmts: print "DBG: %s " % d
+debugstmts = []
+def dbg(s):
+    debugstmts.append(s)


+def showdbg():
+    for d in debugstmts:
+        print "DBG: %s " % d
+

 text = cStringIO.StringIO(open('test.py').read())
 cmpl = Completer()
-cmpl.evalsource(text,51)
+cmpl.evalsource(text, 51)
 print cmpl.sc.get_code()
 all = cmpl.get_completions("cdef.", '')

--- a/pyfuzzyparser.py
+++ b/pyfuzzyparser.py
@@ -5,13 +5,15 @@ import sys
 import tokenize
 import cStringIO

+
 def indent_block(text, indention="    "):
    """ This function indents a text block with a default of four spaces """
    lines = text.split('\n')
-    return '\n'.join(map(lambda s: indention+s, lines))
+    return '\n'.join(map(lambda s: indention + s, lines))
+

 class Scope(object):
-    def __init__(self,name,indent,docstr=''):
+    def __init__(self, name, indent, docstr=''):
        self.subscopes = []
        self.locals = []
        self.imports = []
@@ -20,29 +22,32 @@ class Scope(object):
        self.name = name
        self.indent = indent

-    def add_scope(self,sub):
-        #print 'push scope: [%s@%s]' % (sub.name,sub.indent)
+    def add_scope(self, sub):
+        #print 'push scope: [%s@%s]' % (sub.name, sub.indent)
        sub.parent = self
        self.subscopes.append(sub)
        return sub

-    def doc(self,str):
+    def doc(self, str):
        """ Clean up a docstring """
-        d = str.replace('\n',' ')
-        d = d.replace('\t',' ')
-        while d.find('  ') > -1: d = d.replace('  ',' ')
-        while d[0] in '"\'\t ': d = d[1:]
-        while d[-1] in '"\'\t ': d = d[:-1]
-        dbg("Scope(%s)::docstr = %s" % (self,d))
+        d = str.replace('\n', ' ')
+        d = d.replace('\t', ' ')
+        while d.find('  ') > -1:
+            d = d.replace('  ', ' ')
+        while d[0] in '"\'\t ':
+            d = d[1:]
+        while d[-1] in '"\'\t ':
+            d = d[:-1]
+        dbg("Scope(%s)::docstr = %s" % (self, d))
        self.docstr = d

-    def add_local(self,loc):
+    def add_local(self, loc):
        self.locals.append(loc)

    def add_import(self, imp):
        self.imports.append(imp)

-    def _checkexisting(self,test):
+    def _checkexisting(self, test):
        "Convienance function... keep out duplicates"
        if test.find('=') > -1:
            var = test.split('=')[0].strip()
@@ -52,25 +57,26 @@ class Scope(object):

    def get_code(self, first_indent=False, indention="    "):
        str = ""
-        #str += 'class _PyCmplNoType:\n    def __getattr__(self,name):\n        return None\n'
-        if len(self.docstr) > 0: str += '"""'+self.docstr+'"""\n'
+        if len(self.docstr) > 0:
+            str += '"""' + self.docstr + '"""\n'
        for i in self.imports:
            str += i.get_code() + '\n'
-        #str += 'class _PyCmplNoType:\n    def __getattr__(self,name):\n        return None\n'
        for sub in self.subscopes:
            str += sub.get_code(first_indent=True, indention=indention)
        for l in self.locals:
-            str += l+'\n'
+            str += l + '\n'

-        if first_indent: str = indent_block(str, indention = indention)
+        if first_indent:
+            str = indent_block(str, indention=indention)
        return "_%s_%s" % (self.indent, str)

    def is_empty(self):
-        """ 
+        """
        this function returns true if there are no subscopes, imports, locals.
        """
        return not (self.locals, self.imports, self.subscopes)

+
 class Class(Scope):
    def __init__(self, name, supers, indent, docstr=''):
        super(Class, self).__init__(name, indent, docstr)
@@ -78,7 +84,8 @@ class Class(Scope):

    def get_code(self, first_indent=False, indention="    "):
        str = 'class %s' % (self.name)
-        if len(self.supers) > 0: str += '(%s)' % ','.join(self.supers)
+        if len(self.supers) > 0:
+            str += '(%s)' % ','.join(self.supers)
        str += ':\n'
        str += super(Class, self).get_code(True, indention)
        if self.is_empty():
@@ -88,18 +95,20 @@ class Class(Scope):

 class Function(Scope):
    def __init__(self, name, params, indent, docstr=''):
-        Scope.__init__(self,name,indent, docstr)
+        Scope.__init__(self, name, indent, docstr)
        self.params = params

    def get_code(self, first_indent=False, indention="    "):
-        str = "def %s(%s):\n" % (self.name,','.join(self.params))
-        #if len(self.docstr) > 0: str += self.childindent()+'"""'+self.docstr+'"""\n'
+        str = "def %s(%s):\n" % (self.name, ','.join(self.params))
+        #if len(self.docstr) > 0:
+        #    str += self.childindent()+'"""'+self.docstr+'"""\n'
        str += super(Function, self).get_code(True, indention)
        if self.is_empty():
            str += indent_block("pass\n", indention=indention)
        print "func", self.locals
        return str

+
 class Import(object):
    """
    stores the imports of class files
@@ -128,29 +137,33 @@ class Import(object):
        else:
            return "test import " + ns_str

+
 class PyFuzzyParser(object):
    """
    This class is used to parse a Python file, it then divides them into a
    class structure of differnt scopes.
    """
    def __init__(self):
-        self.top = Scope('global',0)
+        self.top = Scope('global', 0)
        self.scope = self.top

-    def _parsedotname(self,pre=None):
+    def _parsedotname(self, pre=None):
        #returns (dottedname, nexttoken)
        name = []
        if pre is None:
            tokentype, tok, indent = self.next()
            if tokentype != tokenize.NAME and tok != '*':
                return ('', tok)
-        else: tok = pre
+        else:
+            tok = pre
        name.append(tok)
        while True:
            tokentype, tok, indent = self.next()
-            if tok != '.': break
+            if tok != '.':
+                break
            tokentype, tok, indent = self.next()
-            if tokentype != tokenize.NAME: break
+            if tokentype != tokenize.NAME:
+                break
            name.append(tok)
        return (".".join(name), tok)

@@ -158,13 +171,16 @@ class PyFuzzyParser(object):
        imports = []
        while True:
            name, tok = self._parsedotname()
-            if not name: break
+            if not name:
+                break
            name2 = ''
-            if tok == 'as': name2, tok = self._parsedotname()
+            if tok == 'as':
+                name2, tok = self._parsedotname()
            imports.append((name, name2))
            while tok != "," and "\n" not in tok:
                tokentype, tok, indent = self.next()
-            if tok != ",": break
+            if tok != ",":
+                break
        return imports

    def _parseparen(self):
@@ -174,7 +190,8 @@ class PyFuzzyParser(object):
        while True:
            tokentype, tok, indent = self.next()
            if tok in (')', ',') and level == 1:
-                if '=' not in name: name = name.replace(' ', '')
+                if '=' not in name:
+                    name = name.replace(' ', '')
                names.append(name.strip())
                name = ''
            if tok == '(':
@@ -182,8 +199,10 @@ class PyFuzzyParser(object):
                name += "("
            elif tok == ')':
                level -= 1
-                if level == 0: break
-                else: name += ")"
+                if level == 0:
+                    break
+                else:
+                    name += ")"
            elif tok == ',' and level == 1:
                pass
            else:
@@ -192,31 +211,36 @@ class PyFuzzyParser(object):

    def _parsefunction(self, indent):
        tokentype, fname, ind = self.next()
-        if tokentype != tokenize.NAME: return None
+        if tokentype != tokenize.NAME:
+            return None

        tokentype, open, ind = self.next()
-        if open != '(': return None
-        params=self._parseparen()
+        if open != '(':
+            return None
+        params = self._parseparen()

        tokentype, colon, ind = self.next()
-        if colon != ':': return None
+        if colon != ':':
+            return None

        return Function(fname, params, indent)

    def _parseclass(self, indent):
        tokentype, cname, ind = self.next()
-        if tokentype != tokenize.NAME: return None
+        if tokentype != tokenize.NAME:
+            return None

        super = []
        tokentype, next, ind = self.next()
        if next == '(':
-            super=self._parseparen()
-        elif next != ':': return None
+            super = self._parseparen()
+        elif next != ':':
+            return None

-        return Class(cname,super,indent)
+        return Class(cname, super, indent)

    def _parseassignment(self):
-        assign=''
+        assign = ''
        tokentype, tok, indent = self.next()
        if tokentype == tokenize.STRING or tok == 'str':
            return '""'
@@ -233,41 +257,42 @@ class PyFuzzyParser(object):
        elif tok == 'None':
            return '_PyCmplNoType()'
        elif tok == 'type':
-            return 'type(_PyCmplNoType)' #only for method resolution
+            return 'type(_PyCmplNoType)'  # only for method resolution
        else:
            assign += tok
            level = 0
            while True:
                tokentype, tok, indent = self.next()
-                if tok in ('(','{','['):
+                if tok in ('(', '{', '['):
                    level += 1
-                elif tok in (']','}',')'):
+                elif tok in (']', '}', ')'):
                    level -= 1
-                    if level == 0: break
+                    if level == 0:
+                        break
                elif level == 0:
-                    if tok in (';','\n'): break
+                    if tok in (';', '\n'):
+                        break
                    assign += tok
        return "%s" % assign

    def next(self):
        type, tok, (lineno, indent), end, self.parserline = self.gen.next()
        if lineno == self.curline:
-            #print 'line found [%s] scope=%s' % (line.replace('\n',''),self.scope.name)
            self.currentscope = self.scope
        return (type, tok, indent)

-    #p.parse(vim.current.buffer[:],vim.eval("line('.')"))
-    def parse(self,text,curline=0):
+    #p.parse(vim.current.buffer[:], vim.eval("line('.')"))
+    def parse(self, text, curline=0):
        self.curline = int(curline)
        buf = cStringIO.StringIO(''.join(text) + '\n')
        self.gen = tokenize.generate_tokens(buf.readline)
        self.currentscope = self.scope

        try:
-            freshscope=True
+            freshscope = True
            while True:
                tokentype, tok, indent = self.next()
-                dbg( 'main: tok=[%s] indent=[%s]' % (tok,indent))
+                dbg('main: tok=[%s] indent=[%s]' % (tok, indent))

                if tokentype == tokenize.DEDENT:
                    self.scope = self.scope.parent
@@ -302,33 +327,36 @@ class PyFuzzyParser(object):
                        self.scope.add_import(Import(name, alias, mod))
                    freshscope = False
                elif tokentype == tokenize.STRING:
-                    if freshscope: self.scope.doc(tok)
+                    if freshscope:
+                        self.scope.doc(tok)
                elif tokentype == tokenize.NAME:
-                    name,tok = self._parsedotname(tok)
+                    name, tok = self._parsedotname(tok)
                    if tok == '=':
                        stmt = self._parseassignment()
                        dbg("parseassignment: %s = %s" % (name, stmt))
                        if stmt != None:
-                            self.scope.add_local("%s = %s" % (name,stmt))
+                            self.scope.add_local("%s = %s" % (name, stmt))
                    freshscope = False
-        except StopIteration: #thrown on EOF
+        except StopIteration:  # thrown on EOF
            pass
        #except:
        #    dbg("parse error: %s, %s @ %s" %
        #        (sys.exc_info()[0], sys.exc_info()[1], self.parserline))
-        return self.top #self._adjustvisibility()
+        return self.top  # self._adjustvisibility()
+

 def _sanitize(str):
    val = ''
    level = 0
    for c in str:
-        if c in ('(','{','['):
+        if c in ('(', '{', '['):
            level += 1
-        elif c in (']','}',')'):
+        elif c in (']', '}', ')'):
            level -= 1
        elif level == 0:
            val += c
    return val

+
 def dbg(*args):
    print args