^Yc@sdZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl m Z ddl m Z y$ddlmZddlmZWn!ek rddlmZnXdZd Zd ZyXejd krejjd Zn0ejjejd p>ejjddZWnek raeZnXddfZejjejje dZ!dZ"idd6dd6Z#dZ$e%dddgZ&e%ej'dge&Z(e%dddd d!gZ)e%ddd"d#d d!gZ*e*j+d$d%d&d'dd(gZ,e%d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;d<gZ-e%d=Z.e%e j/e j0gZ0e0j+e j1e j2gZ3e3j+e j4e j5gZ6d>d?d@dAgZ7ej8dBZ9ej8dCZ:ej8dDZ;ej8dEZ<ej8dFZ=ej8dGZ>ej8dHZ?ej8dIZ@ej8dJZAej8dKZBej8dLd&je(ZCej8dMZDej8dNZEej8dOZFej8dPZGej8dQZHej8dRjId&jdSdTdUdVdWdXdYdZd[d\d]d^d_d`dafDZJej8dbZKe jLdcgjMjNedddckZOdeZPdfZQdgZRdhZSdiZTdjZUdkZVdlZWdmZXdnZYdoZZdpZ[dqZ\drZ]dsZ^dtZ_duZ`dvZadwZbdxZcdyZddzZed{Zfd|Zgd}Zhd~ZidZjdZkdZldZmdZndZoejpdfkrdZqej8djrZsejtjuZvndZqewjsZsdZvej8dejxjyZzdZ{dZ|eddZ}ej~dZedZdZdZeOrgedZniid6id6id6ZdZedZdZedefdYZdefdYZdefdYZdefdYZdefdYZdefdYZdedZdZeeeedZddZdZedkrendS(s Check Python source code formatting, according to PEP 8. For usage and a list of options, try this: $ python pycodestyle.py -h This program and its regression test suite live here: https://github.com/pycqa/pycodestyle Groups of errors and warnings: E errors W warnings 100 indentation 200 whitespace 300 blank lines 400 imports 500 line length 600 deprecation 700 statements 900 syntax error i(twith_statementN(tfnmatch(t OptionParser(tRawConfigParser(t TextIOWrappers2.3.1s'.svn,CVS,.bzr,.hg,.git,__pycache__,.toxs!E121,E123,E126,E226,E24,E704,W503twin32s~\.pycodestyletXDG_CONFIG_HOMEs ~/.configt pycodestyles setup.cfgstox.init testsuiteiOs+%(path)s:%(row)d:%(col)d: %(code)s %(text)stdefaults%%(path)s:%(row)d: [%(code)s] %(text)stpylintitFalsetNonetTruetprints>>s**t*t+t-t/s//t^t&t|s<ts%=s^=s&=s|=s==s<=s>=s<<=s>>=t=s t directoriestfiless logical linessphysical liness([ \t]*)sraise\s+\w+\s*,sraise\s+\w+\s*,.*,\s*\w+\s*$s\b[A-Z]\d{3}\bs u?r?["\']s[[({] | []}),;:]s[,;:]\s*(?: |\t)s?(\bNone|\bFalse|\bTrue)?\s*([=!]=)\s*(?(1)|(None|False|True))\bs!\b(not)\s+[^][)(}{ ]+\s+(in|is)\ssE(?:[=!]=|is(?:\s+not)?)\s*type(?:s.\w+Type|\s*\(\s*([^)]*[^ )])\s*\))s(\s*)\b(?:%s)\b(\s*)s'(?:[^,\s])(\s*)(?:[-+*/|!<=>%&^]+)(\s*)s \blambda\bs*^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@.*$s^(async\s+def|def)s#^(async\s+def\s+|def\s+|class\s+|@)s ^\s*({0})ccs!|]}|jddVqdS(t s\s+N(treplace(t.0ts((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pys stdefs async deftfors async fortifteliftelsettrytexcepttfinallytwiths async withtclasstwhiles^__([^\s]+)__ = s# icCsOtj|jd}x0t|D]"\}}||kr%|dfSq%WdS(sINever mix tabs and spaces. The most popular way of indenting Python is with spaces only. The second-most popular way is with tabs only. Code indented with a mixture of tabs and spaces should be converted to using spaces exclusively. When invoking the Python command line interpreter with the -t option, it issues warnings about code that illegally mixes tabs and spaces. When using -tt these warnings become errors. These options are highly recommended! Okay: if a == 0:\n a = 1\n b = 1 E101: if a == 0:\n a = 1\n\tb = 1 is/E101 indentation contains mixed spaces and tabsN(t INDENT_REGEXtmatchtgroupt enumerate(t physical_linet indent_chartindenttoffsettchar((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pyttabs_or_spacess  cCs;tj|jd}d|kr7|jddfSdS(sFor new projects, spaces-only are strongly recommended over tabs. Okay: if True:\n return W191: if True:\n\treturn is sW191 indentation contains tabsN(R+R,R-tindex(R/R1((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pyt tabs_obsoletes cCsi|jd}|jd}|jd}|jd}||kre|r^t|dfSd SndS( sTrailing whitespace is superfluous. The warning returned varies on whether the line itself is blank, for easier filtering for those who want to indent their blank lines. Okay: spam(1)\n# W291: spam(1) \n# W293: class Foo(object):\n \n bang = 12 s s s s sW291 trailing whitespaceis#W293 blank line contains whitespaceN(is#W293 blank line contains whitespace(trstriptlen(R/tstripped((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pyttrailing_whitespaces  cCsE||krA|j}|s"dS||krAt|dfSndS(sTrailing blank lines are superfluous. Okay: spam(1) W391: spam(1)\n However the last line should end with a new line (warning W292). isW391 blank line at end of filesW292 no newline at end of fileN(isW391 blank line at end of file(R7R8(R/tlinest line_numbert total_lineststripped_last_line((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pyttrailing_blank_liness    cCs|j}t|}||kr| r|j}t|dkrO|sqt|dkr|ddkrt|t|d|dkrdSt|dryt|jd }Wqtk rqXn||kr|d ||ffSndS( sLimit all lines to a maximum of 79 characters. There are still many devices around that are limited to 80 character lines; plus, limiting windows to 80 characters makes it possible to have several windows side-by-side. The default wrapping on such devices looks ugly. Therefore, please limit all lines to a maximum of 79 characters. For flowing long blocks of text (docstrings or comments), limiting the length to 72 characters is recommended. Reports error E501. iiit#iiNtdecodesutf-8s'E501 line too long (%d > %d characters)(R7R8tsplitthasattrRAt UnicodeError(R/tmax_line_lengtht multilinetnoqatlinetlengthtchunks((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pytmaximum_line_lengths   "$  c cs|dkr| rdS|jdr7|rdVqn`|dksU|rg|dkrgdd|fVn0tj|r]|r<|p||kptj|sZ|} t} xw||dddD]^} | jrt| | krt| } | jjd } | s| dkrPqqqW| r1dVq9dVqZq|dkrdd |fVqn:|r| r|dkr|jdrdd|fVndS(sCSeparate top-level function and class definitions with two blank lines. Method definitions inside a class are separated by a single blank line. Extra blank lines may be used (sparingly) to separate groups of related functions. Blank lines may be omitted between a bunch of related one-liners (e.g. a set of dummy implementations). Use blank lines in functions, sparingly, to indicate logical sections. Okay: def a():\n pass\n\n\ndef b():\n pass Okay: def a():\n pass\n\n\nasync def b():\n pass Okay: def a():\n pass\n\n\n# Foo\n# Bar\n\ndef b():\n pass Okay: default = 1\nfoo = 1 Okay: classify = 1\nfoo = 1 E301: class Foo:\n b = 0\n def bar():\n pass E302: def a():\n pass\n\ndef b(n):\n pass E302: def a():\n pass\n\nasync def b(n):\n pass E303: def a():\n pass\n\n\n\ndef b(n):\n pass E303: def a():\n\n\n\n pass E304: @decorator\n\ndef a():\n pass E305: def a():\n pass\na() E306: def a():\n def b():\n pass\n def c():\n pass iNt@is/E304 blank lines found after function decoratorisE303 too many blank lines (%d)isdef s>E306 expected 1 blank line before a nested definition, found 0s#E301 expected 1 blank line, found 0s%E302 expected 2 blank lines, found %dsclass sHE305 expected 2 blank lines after class or function definition, found %d(is/E304 blank lines found after function decorator(is>E306 expected 1 blank line before a nested definition, found 0(is#E301 expected 1 blank line, found 0(sdef sclass (t startswithtSTARTSWITH_TOP_LEVEL_REGEXR,tDOCSTRING_REGEXR tstript expand_indenttlstrip( t logical_linet blank_linest indent_levelR<t blank_beforetprevious_logicalt previous_unindented_logical_linetprevious_indent_levelR;tancestor_leveltnestedRH((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pyRTs8     ccs|}xtj|D]}|j}|j}|j}||dkrf|dd|fVq||ddkr|dkrdnd}|d||ffVqqWd S( sHAvoid extraneous whitespace. Avoid extraneous whitespace in these situations: - Immediately inside parentheses, brackets or braces. - Immediately before a comma, semicolon, or colon. Okay: spam(ham[1], {eggs: 2}) E201: spam( ham[1], {eggs: 2}) E201: spam(ham[ 1], {eggs: 2}) E201: spam(ham[1], { eggs: 2}) E202: spam(ham[1], {eggs: 2} ) E202: spam(ham[1 ], {eggs: 2}) E202: spam(ham[1], {eggs: 2 }) E203: if x == 4: print x, y; x, y = y , x E203: if x == 4: print x, y ; x, y = y, x E203: if x == 4 : print x, y; x, y = y, x RisE201 whitespace after '%s't,s}])tE202tE203s%s whitespace before '%s'N(tEXTRANEOUS_WHITESPACE_REGEXtfinditerR-RPtstart(RSRHR,ttextR3tfoundtcode((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pytextraneous_whitespace<s   ccsxtj|D]}|j\}}d|krK|jddfVn)t|dkrt|jddfVnd|kr|jddfVqt|dkr|jddfVqqWdS( sAvoid extraneous whitespace around keywords. Okay: True and False E271: True and False E272: True and False E273: True and\tFalse E274: True\tand False s isE274 tab before keywords#E272 multiple spaces before keywordisE273 tab after keywords"E271 multiple spaces after keywordN(t KEYWORD_REGEXR`tgroupsRaR8(RSR,tbeforetafter((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pytwhitespace_around_keywords\s   ccs_|}d}|jdr[|j|}d|kr[|t|d}|dfVq[ndS(sMultiple imports in form from x import (a, b, c) should have space between import statement and parenthesised name list. Okay: from foo import (bar, baz) E275: from foo import(bar, baz) E275: from importable.module import(bar, baz) s import(sfrom iis%E275 missing whitespace after keywordN(RMtfindR8(RSRHt indicatorRctpos((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pyt'missing_whitespace_after_import_keywordss ccs|}xtt|dD]}||}|dkr||dtkr|| }|dkr|jd|jdkr|jd|jdkrqn|dkr||ddkrqn|d |fVqqWd S( sEach comma, semicolon or colon should be followed by whitespace. Okay: [a, b] Okay: (3,) Okay: a[1:4] Okay: a[:4] Okay: a[1:] Okay: a[1:4:2] E231: ['a','b'] E231: foo(bar,baz) E231: [{'a':'b'}] is,;:t:t[t]t{R\t)s"E231 missing whitespace after '%s'N(trangeR8t WHITESPACEtcounttrfind(RSRHR5R3Rh((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pytmissing_whitespaces    * ccs|r dnd}|rdnd}|drJd|d|dffVn|jd}|r||krd|d |d ffVn/| r||krd|d|d ffVnd S( sUse 4 spaces per indentation level. For really old code that you don't want to mess up, you can continue to use 8-space tabs. Okay: a = 1 Okay: if a == 0:\n a = 1 E111: a = 1 E114: # a = 1 Okay: for item in items:\n pass E112: for item in items:\npass E115: for item in items:\n# Hi\n pass Okay: a = 1\nb = 2 E113: a = 1\n b = 2 E116: a = 1\n # b = 2 iisE11%d %ssE11%d %s (comment)iis%indentation is not a multiple of fourRoisexpected an indented blocksunexpected indentationN(tendswith(RSRWR0RURYtcttmplt indent_expect((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pyt indentations c'csE|ddd}d|ddd|}|s>|dkrBdS|jd} d} } |dkrmd)nd*} dg|} dg|}dgg}dg}i}|dd}d}t}|dg}|d krd |ddjGHnx|D]\}}}}}| |d|k}|rO|d|} | oI|tk}n|r|}|d kryd |jGHnt|||| <|tjko|d k}x@t|| D].}|| ||}|| k}|rPqqW|| r||| k}n| o+|dko+|j |d}|rc|| rc|d|| kr|dfVqq|r| r|r|dfVqq|| r|d|| kr|t k r|dfVqq|s| r|| d kr|r| r|dfVn||| >> s... s]})s6E124 closing bracket does not match visual indentations+E133 closing bracket is missing indentations7E128 continuation line under-indented for visual indentsIE123 closing bracket does not match indentation of opening bracket's linetE122s missing indentation or outdentedtE127sover-indented for visual indenttE131sunaligned for hanging indenttE126s over-indented for hanging indenttE121s!under-indented for hanging indents%s continuation line %ssbracket depth %s indent to %stuturtbtbrR"s([{s.bracket depth %s seen, col %s, visual min = %ss)]}sE129 visually indented linesE125 continuation lines(%s with same indent as next logical line(i(ii(R~s missing indentation or outdented(Rsover-indented for visual indent(Rsunaligned for hanging indent(Rs over-indented for hanging indent(Rs!under-indented for hanging indent(RsurRsbr(RyR R R7tNEWLINERQttokenizetOPtreversedtgetR tstrtNLtCOMMENTtSTRINGtisspacetappendR8tpopRttlisttAssertionError('RSttokensRUt hang_closingR0RGtverboset first_rowtnrowst indent_nexttrowtdeptht valid_hangstparenst rel_indentt open_rowsthangstindent_chancest last_indentt visual_indenttlast_token_multilineR1t token_typeRbRatendRHtnewlinet close_brackettopen_rowthangthanging_indentterrort prev_indenttdtindtidxRmRd((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pytcontinued_indentations                           !             c cs|d\}}}}}xtdt|D]}||\}}} } }|tjkr|dkr| |kr|tjks|dkr|dks||dddkrtj| r|d|fVn|}|}| }q/WdS( sAvoid extraneous whitespace. Avoid extraneous whitespace in the following situations: - before the open parenthesis that starts the argument list of a function call. - before the open parenthesis that starts an indexing or slicing. Okay: spam(1) E211: spam (1) Okay: dict['key'] = list[index] E211: dict ['key'] = list[index] E211: dict['key'] = list [index] iis([s}])iR)sE211 whitespace before '%s'N(RtR8RRtNAMEtkeywordt iskeyword( RSRt prev_typet prev_textt__tprev_endR5RRbRaR((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pytwhitespace_before_parameterss  $ccsxtj|D]}|j\}}d|krK|jddfVn)t|dkrt|jddfVnd|kr|jddfVqt|dkr|jddfVqqWdS( sAvoid extraneous whitespace around an operator. Okay: a = 12 + 3 E221: a = 4 + 5 E222: a = 4 + 5 E223: a = 4\t+ 5 E224: a = 4 +\t5 s isE223 tab before operators$E221 multiple spaces before operatorisE224 tab after operators#E222 multiple spaces after operatorN(tOPERATOR_REGEXR`RgRaR8(RSR,RhRi((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pytwhitespace_around_operators   ccsrd}t}tj}d}}xL|D]D\}}} } } |tkrMq&n|dkrf|d7}n|dkr|d8}n|ru| |kr|tk r|d r|ddfVnt}qX|dkr|dkrqX|tks|dr|dfVnj|d krld\} } |d kr5d\} } n|tkrPd\} } n|dd| | ffVnt}n|tjkrX|dk rX|dkr|rni|tkrt}nT|tkr|tjkr|dkn |t krd}qn|t krd}n|dkr/|| |kf}qX|rX| |krX|dfVt}qXn|}|}| }q&WdS(sASurround operators with a single space on either side. - Always surround these binary operators with a single space on either side: assignment (=), augmented assignment (+=, -= etc.), comparisons (==, <, >, !=, <=, >=, in, not in, is, is not), Booleans (and, or, not). - If operators with different priorities are used, consider adding whitespace around the operators with the lowest priorities. Okay: i = i + 1 Okay: submitted += 1 Okay: x = x * 2 - 1 Okay: hypot2 = x * x + y * y Okay: c = (a + b) * (a - b) Okay: foo(bar, key='word', *args, **kwargs) Okay: alpha[:-i] E225: i=i+1 E225: submitted +=1 E225: x = x /2 - 1 E225: z = x **y E226: c = (a+b) * (a-b) E226: hypot2 = x*x + y*y E227: c = a|b E228: msg = fmt%(errno, errmsg) it(tlambdaiRss'E225 missing whitespace around operatorRRRs**tE226t arithmeticRtE228tmodulotE227sbitwise or shifts(%s missing whitespace around %s operatorRs}])N(Rslambda(RR(RR(RR(Rsbitwise or shift( R RRR t SKIP_COMMENTSR t ARITHMETIC_OPtWS_NEEDED_OPERATORStUNARY_OPERATORStKEYWORDStWS_OPTIONAL_OPERATORS(RSRRt need_spaceRRRRRbRaRRHRdtoptype((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pyt"missing_whitespace_around_operatorsb                          ccs{|}xntj|D]]}|jd}d|jkrZ|d|jdfVq|d|jdfVqWdS(sAvoid extraneous whitespace after a comma or a colon. Note: these checks are disabled by default Okay: a = (1, 2) E241: a = (1, 2) E242: a = (1,\t2) is sE242 tab after '%s'isE241 multiple spaces after '%s'N(tWHITESPACE_AFTER_COMMA_REGEXR`RaR-(RSRHtmRc((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pytwhitespace_around_commas c csxd}t}d }t}ttj|}d}x>|D]6\}} } } } |tjkrdq:n|rt}| |kr||fVqn|tjkrj| dkr|d7}n| dkr|d8}n|r| dkr|dkrt}nc|r| dkr|dkrt}n<|rX| dkrX| rXt}| |krX||fVqXn|sjt}qjn| }q:Wd S( s Don't use spaces around the '=' sign in function arguments. Don't use spaces around the '=' sign when used to indicate a keyword argument or a default parameter value. Okay: def complex(real, imag=0.0): Okay: return magic(r=real, i=imag) Okay: boolean(a == b) Okay: boolean(a != b) Okay: boolean(a <= b) Okay: boolean(a >= b) Okay: def foo(arg: int = 42): Okay: async def foo(arg: int = 42): E251: def complex(real, imag = 0.0): E251: return magic(r = real, i = imag) is8E251 unexpected spaces around keyword / parameter equalss([is)]RoR\RN( R R tbooltSTARTSWITH_DEF_REGEXR,RRRR ( RSRRtno_spaceRtannotated_func_argtin_deftmessageRRbRaRRH((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pyt(whitespace_around_named_parameter_equals)s:         c cshd }x[|D]S\}}}}}|tjkrH||d j}|r|d|dkr|d|ddkr|dfVqn|jd\} } } | dko| jdd pd} |r| s| d tkrE|dfVqEq`| r`| d ks|ddkr`| dkr.|d fVqE| rE|d fVqEq`q |tjkr |}q q Wd S(s{Separate inline comments by at least two spaces. An inline comment is a comment on the same line as a statement. Inline comments should be separated by at least two spaces from the statement. They should start with a # and a single space. Each line of a block comment starts with a # and a single space (unless it is indented text inside the comment). Okay: x = x + 1 # Increment x Okay: x = x + 1 # Increment x Okay: # Block comment E261: x = x + 1 # Increment x E262: x = x + 1 #Increment x E262: x = x + 1 # Increment x E265: #Block comment E266: ### Block comment iiis.E261 at least two spaces before inline commentRs#:R@s*E262 inline comment should start with '# 't!s)E265 block comment should start with '# 's+E266 too many leading '#' for block commentN(ii(RRRPt partitionRRRuR( RSRRRRbRaRRHtinline_commenttsymboltsptcommentt bad_prefix((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pytwhitespace_before_comment[s(,%" ccsU|}|jdrQ|jd}d|krQd|| krQ|dfVqQndS(s Place imports on separate lines. Okay: import os\nimport sys E401: import sys, os Okay: from subprocess import Popen, PIPE Okay: from myclas import MyClass Okay: from foo.bar.yourclass import YourClass Okay: import myclass Okay: import foo.bar.yourclass simport R\it;s!E401 multiple imports on one lineN(RMRk(RSRHRc((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pytimports_on_separate_liness c#sd}d}|rdS|s#dS|r-dS|jdsQjdrn|jd trdVqnxtjtrdStfd |DrdS|r|jd trt|d stseen_docstring(strysexceptselsesfinally(is+E402 module level import not at top of file(RMRR treR,t DUNDER_REGEXtanyR (RSRUt checker_stateRGRtallowed_try_keywords((RHs0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pytmodule_imports_on_top_of_files*     ccs|}t|d}|jd}d}tddD}x&d|ko[|knrit|||!||d|dkrJ|d |d krJ|d |d krJtj|d|}|r||j j}|dd krt|d j rdVnPnt j |r*dVqJt j |rJ|dfVqJn|}|jd|d}qDW|jd}xKd|kr||kr|dfVn |dfV|jd|d}q|WdS(sCompound statements (on the same line) are generally discouraged. While sometimes it's okay to put an if/for/while with a small body on the same line, never do this for multi-clause statements. Also avoid folding such long lines! Always use a def statement instead of an assignment statement that binds a lambda expression directly to a name. Okay: if foo == 'blah':\n do_blah_thing() Okay: do_one() Okay: do_two() Okay: do_three() E701: if foo == 'blah': do_blah_thing() E701: for x in lst: total += x E701: while t < 10: t = delay() E701: if foo == 'blah': do_blah_thing() E701: else: do_non_blah_thing() E701: try: something() E701: finally: cleanup() E701: if foo == 'blah': one(); two(); three() E702: do_one(); do_two(); do_three() E703: do_four(); # useless semicolon E704: def f(x): return 2*x E731: f = lambda x: 2*x iRoicss|]}|dfVqdS(iN((RR3((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pys ss{}[]()iRrt}RpRqRRsRs1E731 do not assign a lambda expression, use a defs*E704 multiple statements on one line (def)s,E701 multiple statements on one line (colon)Rs0E702 multiple statements on one line (semicolon)s$E703 statement ends with a semicolonN(is1E731 do not assign a lambda expression, use a def(is*E704 multiple statements on one line (def)( R8Rktdictt update_countst LAMBDA_REGEXtsearchRaR7t isidentifierRPRR,t!STARTSWITH_INDENT_STATEMENT_REGEX(RSRHt last_charRct prev_foundtcountst lambda_kwRh((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pytcompound_statementss8&  c cs;d}}}t}d }x|D]\}}} } } |tjkrNt}n| d|kr|r|r| r|dfVn| d|kr| jdjdr| dt| jddf}nd }| d}}n | d}|tj kr!|dkr|d7}q3|dkr3|d8}q3q!q!Wd S( s?Avoid explicit line join between brackets. The preferred way of wrapping long lines is by using Python's implied line continuation inside parentheses, brackets and braces. Long lines can be broken over multiple lines by wrapping expressions in parentheses. These should be used in preference to using a backslash for line continuation. E502: aaa = [123, \\n 123] E502: aaa = ("bbb " \\n "ccc") Okay: aaa = [123,\n 123] Okay: aaa = ("bbb "\n "ccc") Okay: aaa = "bbb " \\n "ccc" Okay: aaa = 123 # \\ is0E502 the backslash is redundant between bracketss s\iis([{s)]}N( R R RRR R7RyR8t splitlinesR( RSRt prev_startRRRt backslashRRbRaRRH((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pytexplicit_line_join s& #'    c csd}t}t}d}d}x|D]\}}} } } |tjkrRq(nd|ksjd|kr|tjkrt}q(|||r|r| r||| r| dfVn|dk}t}|}|}q(WdS(s  Avoid breaks before binary operators. The preferred place to break around a binary operator is after the operator, not before it. W503: (width == 0\n + height == 0) W503: (width == 0\n and height == 0) Okay: (width == 0 +\n height == 0) Okay: foo(\n -x) Okay: foo(x\n []) Okay: x = '''\n''' + '' Okay: foo(x,\n -y) Okay: foo(x, # comment\n -y) Okay: var = (1 &\n ~2) Okay: var = (1 /\n -2) Okay: var = (1 +\n -1 +\n -2) cSs%|tjks|dko$|dkS(Ntandtors()[]{},:.;@=%~(sandsor(RR(RRb((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pytis_binary_operatorFss s s&W503 line break before binary operators([{,;N(R R R RRR( RSRRt line_breakt unary_contexttprevious_token_typet previous_textRRbRaRRH((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pytbreak_around_binary_operator2s& '   ccs| otj|}|r|jdp7|jd}|jddk}d|r^dnd|}|dkr~d }nEd }|d kr|p|d ko| }|d |rdnd7}|jdd|||ffVndS(sXComparison to singletons should use "is" or "is not". Comparisons to singletons like None should always be done with "is" or "is not", never the equality operators. Okay: if arg is not None: E711: if arg != None: E711: if None == arg: E712: if arg == True: E712: if False == arg: Also, beware of writing if x when you really mean if x is not None -- e.g. when testing whether a variable or argument that defaults to None was set to some other value. The other value might have a type (such as a container) that could be false in a boolean context! iiis==s'if cond is %s:'tsnot R tE711tE712R R s or 'if %scond:'s %s comparison to %s should be %sN(sNone(tCOMPARE_SINGLETON_REGEXRR-Ra(RSRGR,t singletontsametmsgRdtnonzero((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pytcomparison_to_singletoncs  ccsYtj|}|rU|jd}|jddkrG|dfVqU|dfVndS(sGNegative comparison should be done using "not in" and "is not". Okay: if x not in y:\n pass Okay: assert (X in Y or X is Z) Okay: if not (X in Y):\n pass Okay: zz = x is not y E713: Z = not X in Y E713: if not X.B in Y:\n pass E714: if not X is Y:\n pass E714: Z = not X.B is Y iitins+E713 test for membership should be 'not in's0E714 test for object identity should be 'is not'N(tCOMPARE_NEGATIVE_REGEXRRaR-(RSR,Rm((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pytcomparison_negatives ccsetj|}|ra| ra|jd}|rMt|rM|tkrMdS|jdfVndS(sObject type comparisons should always use isinstance(). Do not compare types directly. Okay: if isinstance(obj, int): E721: if type(obj) is type(1): When checking if an object is a string, keep in mind that it might be a unicode string too! In Python 2.3, str and unicode have a common base class, basestring, so you can do: Okay: if isinstance(obj, basestring): Okay: if type(a1) is type(b1): iNs-E721 do not compare types, use 'isinstance()'(tCOMPARE_TYPE_REGEXRR-Rt SINGLETONSRa(RSRGR,tinst((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pytcomparison_types  ccsF|r dStjd}|j|}|rB|jdfVndS(sWhen catching exceptions, mention specific exceptions whenever possible. Okay: except Exception: Okay: except BaseException: E722: except: Ns except\s*:sE722 do not use bare except'(RtcompileR,Ra(RSRGtregexR,((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pyt bare_excepts ccs2d}|d\}}}}}x |dD]\}} } } } d} }|tjkrd| kr||kr|} |}qn|dkr| |kr| } | }qn|d kr| |kr| d | fVqn|d kr| |kr| d | fVqn| r|d| fVn| }| }q*WdS(sNever use the characters 'l', 'O', or 'I' as variable names. In some fonts, these characters are indistinguishable from the numerals one and zero. When tempted to use 'l', use 'L' instead. Okay: L = 0 Okay: o = 123 Okay: i = 42 E741: l = 0 E741: O = 123 E741: I = 42 Variables can be bound in several other contexts, including class and function definitions, 'global' and 'nonlocal' statements, exception handlers, and 'with' statements. Okay: except AttributeError as o: Okay: with lock as L: E741: except AttributeError as O: E741: with lock as l: E741: global I E741: nonlocal l E742: class I(object): E743: def l(x): tltOtIiiRtastglobaltnonlocalR)s$E742 ambiguous class definition '%s'R s'E743 ambiguous function definition '%s's!E741 ambiguous variable name '%s'N(RRR(sassglobalR(R RR(RSRtidents_to_avoidRRRRRRRbRaRRHtidentRm((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pytambiguous_identifiers,           ccs4|jd}|dkr0| r0|dfVndS(sThe {}.has_key() method is removed in Python 3: use the 'in' operator. Okay: if "alph" in d:\n print d["alph"] W601: assert d.has_key('alph') s .has_key(is'W601 .has_key() is deprecated, use 'in'N(Rk(RSRGRm((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pytpython_3000_has_keysccsAtj|}|r=tj| r=|jddfVndS(sWhen raising an exception, use "raise ValueError('message')". The older form is removed in Python 3. Okay: raise DummyError("Message") W602: raise DummyError, "Message" is)W602 deprecated form of raising exceptionN(tRAISE_COMMA_REGEXR,tRERAISE_COMMA_REGEXR(RSR,((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pytpython_3000_raise_commasccs-|jd}|dkr)|dfVndS(sNew code should always use != instead of <>. The older syntax is removed in Python 3. Okay: if a != 'no': W603: if a <> 'no': s<>is!W603 '<>' is deprecated, use '!='N(Rk(RSRm((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pytpython_3000_not_equal s ccs-|jd}|dkr)|dfVndS(sfUse repr() instead of backticks in Python 3. Okay: val = repr(1 + 2) W604: val = `1 + 2` t`is+W604 backticks are deprecated, use 'repr()'N(Rk(RSRm((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pytpython_3000_backtickss icCs&t|d}|jSWdQXdS(sRead the source code.trUN(topent readlines(tfilenametf((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pyR,,ss [a-zA-Z_]\w*$c Csyst|d^}tj|j\}}t||dt}g|D]}|j|^qI|jSWdQXWn?tt t fk rt|dd}|jSWdQXnXdS(sRead the source code.trbtline_bufferingNtencodingslatin-1( R+Rtdetect_encodingtreadlineRR RAR,t LookupErrort SyntaxErrorRD(R-R.tcodingR;RH((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pyR,4s4cCsttjjddjS(sRead the value from stdin.terrorstignore(Rtsyststdintbuffertread(((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pytstdin_get_valueAss# no(?:qa|pep8)\bcCs|d|kr&t|t|jSd}xI|D]A}|dkrZ|ddd}q3|dkrs|d7}q3Pq3W|S(sReturn the amount of indentation. Tabs are expanded to the next multiple of 8. >>> expand_indent(' ') 4 >>> expand_indent('\t') 8 >>> expand_indent(' \t') 8 >>> expand_indent(' \t') 16 s iiRi(R8RR(RHtresultR3((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pyRQHs     cCsj|j|dd}t|d}|ddkrN|d7}|d8}n|| d||||S( sReplace contents with 'xxx' to prevent syntax matching. >>> mute_string('"abc"') '"xxx"' >>> mute_string("'''abc'''") "'''xxx'''" >>> mute_string("r'abc'") "r'xxx'" iiis"""s'''itx(s"""s'''(R5R8(RbRaR((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pyt mute_stringcs   t.c Cski}d }}x|jD]}|rL|d dkr|d8}qqn|d dkrtj|}g|jD]}t|pd^qx\} }||jt| | |q|d dkr|djddd }|d d kr|d }nt ||s(R(R-RMR ((R-s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pyRHscCs4x-|D]%}||kr||cd7dg|ft||R2Rb((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pytcheck_physical?s   cCsg}g}d}d}}}xT|jD]I\}}} } } |tkrQq*n|sid| fg}n|tjkr|j|q*n|tjkrt|}n|r7| \} } || kr|j|d|d}|dks|dkr4|dkr4d|}q4q7|| kr7| || !|}q7n|j||t |7}|j|| f| \}}q*Wdj ||_ |ot dj ||_ |S( s!Build a logical line from tokens.iiR\s{[(s}])RRN( R Rt SKIP_TOKENSRRRRR@R;R8RKRSRG(RptlogicaltcommentsRItprev_rowtprev_coltmappingRRbRaRRHt start_rowt start_colR((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pytbuild_tokens_lineKs<       c Cs|jj|j}|s#dS|dd\}}|j|d}t|| |_|j|jkr||j|_n|jdkr|j d j GHnx|j D]\}}}|jdkrd|GHn|j ||x|j ||pdD]\}} t|ts^x$|D]\} } || krPqqW| d| d|| f}n|j|d|d| |qWqW|j r|j|_|j |_|js|j |_qnd|_g|_dS( s:Build a line from tokens and run all logical checks on it.NiiiiPis ((Rtincrement_logical_lineRR;RQRURVRTRRSR7RRRRTttupleRRYRWRXR( RpRRRt start_lineReRlRR2Rbt token_offsetRm((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pyt check_logicalls:   % &     c Csy%tdj|jddt}Wn!tttfk rH|jSXx|jD]\}}}|||j }x[|j D]M\}}}} |j st |j|d r|j |||| qqWqSWdS(s,Build the file's AST and run all AST checks.RtexeciN( RRKR;t PyCF_ONLY_ASTt ValueErrorR5t TypeErrorRRR-trunRGR( RpR]RetclsRtcheckertlinenoR2RbRl((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pyt check_asts% "ccs|jr)|jddd|jtntj|j}y_xX|D]P}|dd|jkrfdS|do}t|d|_|j||VqEWWn$t tj fk r|j nXdS(s=Tokenize the file, run physical line checks and yield tokens.iisE902 %siNi( RRR,Rtgenerate_tokensR3R=RGtmaybe_check_physicalR5t TokenErrorR(RpttokengenRZ((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pyRs     cCst|r |j|dn|dtjkrd|dkrt|drWdSt|_|dd|_x?|djdd D]&}|j|d|jd7_qWt |_ndS(s@If appropriate (based on token), check current physical line(s).iis iNii( R[RRRRGR RFR<RBR (RpRZRH((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pyRs # icCs|jj|j|j||t|j|_|jrG|jnd|_d |_ d|_ |_ d|_ d|_g|_d|_|_d}x|jD]}|jj||dd!\}}|jdkra|dd|ddkr$d|ddpd|ddf}nd|dd}d|dd|tj|d|fGHn|tjkr|d kr|d7}q|d kr|d8}qq|s|tkr|tjkr|jd|_qt|jdkr |jd7_|jd=q|jqtr|tjkrt|jdkrt|}|jd |d<|dd|ddt|df|ds(R8RR~RR RMR8(RpRd((Rds0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pyR s !csug}xbt|jD]P\}}|\}}tfd|Dr|j|j||fqqWt|S(sGet all the checks for this category. Find all globally visible functions where the first argument name starts with argument_name and which contain selected tests. c3s%|]}|oj| VqdS(N(R(RRd(Rp(s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pys #s(RjRGRRRR(Rpt argument_nametchecksRltattrsRmRn((Rps0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pyRs   N( RRRtRvR RRRRRRR(((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pyR}s %     c Cstd|d|dd}ddddd d d d d ddddg |_|jdddddd dd|jdddddd dd|jdddtdddd|jd dd!d"d#dd$|jd%d&d'dtdd(|jd)d&d'dd*dd+|jd,d&d-dd.dd/|jd0d&d-dd.dd1t|jd2dddd3|jd4dddd5|jd6dddd7|jd8dddd9|jd:d;d<d&d=dtdd>|jd?dddd@|jdAd&d ddddB|jdCddddD|jdE}tj j t r|jdFd&dGddH|jdIddddJn|jdKddddL|S(Ms"Create the parser for the program.tprogtversiontusages%prog [options] input ...R R-RR8smax-line-lengths hang-closingRvRRs show-pep8s show-sourcet statisticsRs-vs --verboseR itactionthelps(print status messages, or debug with -vvs-qs--quiets+report only file names, or nothing with -qqs-rs--repeatt store_trues1(obsolete) show all occurrences of the same errors--firstt store_falsetdestRs#show first occurrence of each errors --excludetmetavarRMs[exclude files or directories which match these comma separated patterns (default: %default)s --filenames*.pysjwhen parsing directories, only check filenames matching these comma separated patterns (default: %default)s--selectR7Rs&select errors and warnings (e.g. E,W6)s--ignores2skip errors and warnings (e.g. E4,W) (default: %s)s --show-sourcesshow source code for each errors --show-pep8s3show text of PEP 8 for each error (implies --first)s --statisticsscount errors and warningss--countsgprint total number of errors and warnings to standard error and set exit code to 1 if total is not nulls--max-line-lengthttypeRDtns3set maximum allowed line length (default: %default)s--hang-closingsNhang closing bracket instead of matching indentation of opening bracket's lines--formats.set the error format [default|pylint|]s--diffsSreport changes only within line number ranges in the unified diff received on STDINsTesting Optionss --testsuitetdirsrun regression tests from dirs --doctestsrun doctest on myselfs --benchmarksmeasure processing speed( Rtconfig_optionst add_optionR tDEFAULT_EXCLUDERtMAX_LINE_LENGTHtadd_option_groupRIRJtexiststTESTSUITE_PATH(RRRR-((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pyt get_parser(s`  cst}|j}tj}trXtjjtrX|jrHdtGHn|jtn|oytjj tjj |}x`|r|jfdt Dr}|jrdGHnPntjj \}qW|r tjj|r |jrd|GHn|j|nd}|j|jrD|j}n%|jdrid}tjdn|rtg|jD]!} | j| jp| jf^q|} |jg\} } x |j|D]} | jdd|jkrd | GHqn|jd kr(d | |j|| fGHn| jdd}| |}|dkre|j|| }nQ|dkr|j|| }n0|j|| }|dkrt||}nt| ||qW|j|d| \}} nt |_!|_"|S(swRead and parse configurations. If a config file is specified on the command line with the "--config" option, then only it is used for configuration. Otherwise, the user configuration (~/.config/pycodestyle) and any local configurations in the current directory or above will be merged together (in that order) using the read method of ConfigParser. suser configuration: %sc3s$|]}tjj|VqdS(N(RIRJRK(Rtfn(RN(s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pys }sslocal configuration: in %sscli configuration: %stpep8s0[pep8] section is deprecated. Use [pycodestyle].t_Rs unknown option '%s' ignoredis %s = %sRDRvRRR RbN(sintscount(s store_trues store_false(#RtconfigRItcurdirt USER_CONFIGRJtisfileRR<RUt commonprefixtPROJECT_CONFIGRBR t has_sectionRtwarningstwarnRt option_listRRRt parse_argsR~RRRtgetintt getbooleanRXtsetattrR RR(R~RnRRR'tcli_conft local_dirttailtpycodestyle_sectiontoR0t new_optionsRtopttnormalized_opttopt_typeRV((RNs0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pyt read_configfsb     (      1     cCs|st}n|jdsq|jddd|jdj|jf}|jdddd|d d n| r| rg}n|j|\}}d|_ |j d t r|j |j n|j d t s[|r%| r%|js td tDrdg}q%|jdnt||||}|oR|jdkoRt|_ nt|j|_t|j|_t|j|_t|j|_|jrt|_ t}t||j|d|_t|j}n||fS(sProcess options passed either via arglist or via command line args. Passing in the ``config_file`` parameter allows other tools, such as flake8 to specify their own options to be processed in pycodestyle. s--configt Configurationt descriptionsThe project options are read from the [%s] section of the tox.ini file or the setup.cfg file located in any parent folder of the path(s) being processed. Allowed options are: %s.s, RRJR Rsuser config file locationRRcss!|]}tjj|VqdS(N(RIRJR!(RRe((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pys sRAsinput not specifiediiN( R#t has_optionR RRKRRR1R Rt ensure_valueR RRRLRR,RR>RRt_parse_multi_optionsR-RXR RR8RR=RSRR(RRRRR-R~RnR:((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pyRs@        !   R\cCs@|r8g|j|D]}|jr|j^qS|SdS(sgSplit and strip and discard empties. Turns the following: A, B, into ["A", "B"] N(RBRP(R~t split_tokenR9((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pyRCs 2cCs!ddl}y|j|jdWntk r9nXtdt}|j}|jsd|jrddlm }||}n |j }|j r|j n|j r|jn|jr|j r|jn|jr|jr tjjt|jdntjdndS(s.Parse options and run checks on Python source.iNcSs tjdS(Ni(R9texit(tsignumtframe((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pytsR(t run_testss i(tsignaltSIGPIPEtAttributeErrorR}R R~RRttestsuite.supportRIRRRt benchmarkRRt print_resultsRRvR9tstderrtwriteRRE(RJt style_guideR~RIR((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pyt_mains*            t__main__(Rtt __future__RR_RRIRR9RRR.RtoptparseRt configparserRtioRt ImportErrort ConfigParsert __version__RRtplatformRJt expanduserR)RKtgetenvR R,Rt__file__R"RRRt frozensetRtkwlistRRRtunionRRRuRRtINDENTtDEDENTRRt ERRORTOKENRRRR+R$R%RrROR_RR RRRfRRRCRRNRRRRRtsendRR4R6R:R?RKRTReRjRnRxR}RRRRRRRRRRRRRRRRR"R#R&R'R)R^R,R,RR:R<R=RRRRGRQR@RSR(RXR RHRR[RjRiRwR{tobjectR|RRRRR}R#R>R RRCRSR(((s0/tmp/pip-build-EndXZ2/pycodestyle/pycodestyle.pyt0s              ! !'   (    & >      \  2 )  8 < ' 1 "    4           Z7 > K  2  "