`N`epdZddlmZddlZddlZddlZddlmZddlm Z ddl m Z ddl m Z ddl m Z dd l mZdd l mZdd l mZd,d ZdZdZdZdZdZdZdZdZdZdZdZGddeZejdddgZ ejddd gZ!d!Z"d"Z#d#Z$ga%d$Z&d%Z'd&Z(d'Z)d(Z*d)Z+d*Z,d+Z-dS)-a Decide what the format for the code should be. The `unwrapped_line.UnwrappedLine`s are now ready to be formatted. UnwrappedLines that can be merged together are. The best formatting is returned as a string. Reformat(): the main function exported by this module. )unicode_literalsN)pytree)token)format_decision_state) format_token) line_joiner) pytree_utils)style)verifierFcg}d}tjd}t|D]}|j}t ||j||||jz}t j||} | |j s|jj r3|jj j |jj _ n>|jj r2|jj j |jj _ |r"|j rt|j|j|t!d|jDrt%||j st'|r0t)|t+|||t-| nt/|st1|r!t+|||t-| nt3|rDt!d|jDs&| jr| dd| jngt9| sXt j||} | t)|t+||dt-| |||}t=|t?||S)aoReformat the unwrapped lines. Arguments: uwlines: (list of unwrapped_line.UnwrappedLine) Lines we want to format. verify: (bool) True if reformatted code should be verified for syntax. lines: (set of int) The lines which can be modified or None if there is no line range restriction. Returns: A string representing the reformatted code. N INDENT_WIDTHc3$K|] }|jV dSN is_comment.0toks 8lib/python3.11/site-packages/yapf/yapflib/reformatter.py zReformat..Is$ 5 5S^ 5 5 5 5 5 5c3$K|] }|jV dSr) must_splitrs rrzReformat..Ws@3M3M7:47>3M3M3M3M3M3MrFnewlinedry_run) r Get_SingleOrMergedLinesfirst_FormatFirstTokendepthrFormatDecisionStateMoveStateToNextTokendisablernodevaluerstriplast+_RetainRequiredVerticalSpacingBetweenTokensanytokens$_RetainVerticalSpacingBeforeComments_LineHasContinuationMarkers_RetainHorizontalSpacing_RetainRequiredVerticalSpacing_EmitLineUnformatted%_LineContainsPylintDisableLineTooLong_LineContainsI18n_CanPlaceOnSingleLine next_tokenAddTokenToState_AnalyzeSolutionSpaceappend_AlignTrailingComments_FormatFinalLines) uwlinesverifylines final_lines prev_uwline indent_widthuwline first_token indent_amtstates rReformatrD's++>**,$W--11f,Kk6<kJJJ ,J ! 5fj I IE    > 5  A"(,"3"9"@"@"B"B  ; !A!'!1!7!>!>!@!@  M,M 4FL4?4De M M M 5 5v} 5 5 5 5 55,V444 ~$4V<<$v&&&$V[%@@@5!!!! / 7 7$ F # #$%V[%@@@5!!!! v & &$s3M3M>Dm3M3M3M0M0M$  < eU;;;  <#5 ) )$&9&*MM ""$$$ (((&v{DAAAU###vKK%%% ; / //rcd|jD]'}||jj|j(dS)z-Retain all horizontal spacing between tokens.N)r+RetainHorizontalSpacingrcolumnr!)r@rs rr.r.nsA ]CCc 3V\BBBBCCrcd}||j}|jD]*}t||||}|jrt }+dS)z*Retain all vertical spacing between lines.N)r(r+r)r$set) cur_uwliner>r<prev_tokcur_toks rr/r/ts_ (H"g/5IIIHeeerc|dS|jr#|j|jdz}n/|jr!|jjs |jj}n|j}n|j}|jr#|j|jdz }n|j}|js7|jdr||jdz }||z }|jr|jsn|r| t||dzrb|j d}t|dz|}t| |}t||z |}||dS)zDRetain vertical spacing between two tokens if not in editable range.N \) is_stringlinenor&countis_pseudo_parenprevious_tokenis_multiline_stringrendswith intersectionrangewhitespace_prefixlenmaxAdjustNewlinesBefore) rLrKr< prev_lineno cur_linenorequired_newlinesdesired_newlineswhitespace_linesdeletable_liness rr)r)s  F "/HN$8$8$>$>>KK"  " 6$+2kkOkk/K  '-"5"5d";";;JJJ  .!8!8!>!>.8>''---K ;. . 3. .##E+zA~$F$FGG.066t<<[1_j99%,,-=>>??O-?,.. 011111rcd}|jD]U}|jrJ|rH|j|jdz |jz dkr|t |}VdS)z(Retain vertical spacing before comments.NrNrP)r+rrRr&rSr]ONE_BLANK_LINE)r@ prev_tokenrs rr,r,sv* ]c ~1*1 ciood++ +j.? ?! C C   000JJ rc|jrx|jj}|j}|js|jr||jdz }|jrd}n|jj|k}||d|jvdSdS)aEmit the line without formatting. The line contains code that if reformatted would break a non-syntactic convention. E.g., i18n comments and function calls are tightly bound by convention. Instead, we calculate when / if a newline should occur and honor that. But otherwise the code emitted will be the same as the original code. Arguments: state: (format_decision_state.FormatDecisionState) The format decision state. rNFrN) r4rUrRrVrQr&rSis_continuationr5)rCrUprevious_linenors rr0r0s  :%4N$+O):^-E:-33D999o%:gg '/9g '5999  : : : : :rctjdr@|jD]8}|jr/t jtjd|jrdS9tjdrnt|j}d}||dz krO|j|dzjdkr(|j|jtjdvrdS|dz }||dz kOdS)auReturn true if there are i18n comments or function calls in the line. I18n comments and pseudo-function calls are closely related. They cannot be moved apart without breaking i18n. Arguments: uwline: (unwrapped_line.UnwrappedLine) The line currently being formatted. Returns: True if the line contains i18n comments or function calls. False otherwise. I18N_COMMENTTI18N_FUNCTION_CALLrrP(F)r rr+rrematchr&r[)r@rlengthindexs rr2r2s Y~} BHUY~%>%> JJtt Y#$$   F E &1*   - " (C / / -  $ 2F(G(G G Gt qje &1*   rc@tjd|jjS)zBReturn true if there is a "pylint: disable=line-too-long" comment.z#\bpylint:\s+disable=line-too-long\b)rnsearchr(r&r@s rr1r1s 96;;L M MMrc>td|jDS)z7Return true if the line has continuation markers in it.c3$K|] }|jV dSr)rhrs rrz._LineHasContinuationMarkers..s% : :SS : : : : : :r)r*r+rts rr-r-s! : :FM : : : : ::rctd|jD}tjdrd|vrdStjd|jz}|j}d}|js|js|jr |j}d}|d S|j |ztjd ko&td |jd|D S) zDetermine if the unwrapped line can go on a single line. Arguments: uwline: (unwrapped_line.UnwrappedLine) The line currently being formatted. Returns: True if the line can or should be added to a single line. False otherwise. cg|] }|j S)name)rxs r z)_CanPlaceOnSingleLine..s///A///rFORCE_MULTILINE_DICTLBRACEFr NT COLUMN_LIMITc3$K|] }|jV dSrrrs rrz(_CanPlaceOnSingleLine.. s$GGS#.GGGGGGr) r+r rr!r(is_pylint_commentis_pytype_commentis_copybara_commentrU total_lengthr*)r@ token_namesrBr( last_indexs rr3r3s0////+ i&''H ,C,C 5y((6<7* $*  6   DJ \ 4  j (EIn,E,E E HGGFM+:+,FGGGGG GIrc *d}|t|kr|||}|jsJd}|jD]C}|jr8t|jt r|jdrg}d} |t|zt|krn@||t|z}|jsJ|r&|jdjdrn|j r| gd}g} |jD]} | j} | d} | dkr,t|t|}d}| | d zd } | jr#| t|z|d | | jz }| rt|t| }| | e|d z }d } |jD] }||kr|} n | |} t|D]R\}} | s |||z}d}|jD]} | jr|t| ksJ| || ksJd | | |z d z z}|d z }g}t| jdD]N\}}| d |||dkrd | d z z}Od|}| jd}||r|t|d }|| _ |t| ksJT|t|z }d}nE|s|d z }|t|kzd Sd S)z+Align trailing comments to the same column.rF#Tz rNrrPNz{}{} )r[r+r isinstancespaces_required_beforelistr& startswithformatted_whitespace_prefixr$r7rfindr\format enumeratesplitstripjoinlstrip)r=final_lines_indexlineprocessed_contentrall_pc_line_lengthsmax_line_length this_line line_contentpc_line_lengthsline_tokrZ newline_index aligned_col potential_colall_pc_line_lengths_indexpc_line_length_index whitespacecomment_line_index comment_lineexisting_whitespace_prefixs rr8r8sC ,,,, ( )D ;{rr .qZ(BDIIq )  s # #q!) 6 %8!9!9 9S=M=M M M !"3c:M6N6N"NO)! ! ! !! q!=HHPP       & &r * * * ,/#* O Oh ( D -33D99M"" #OS5F5F G Gol"3MA4E4F4F"G" O$$S%6%67777fmm,=x~NNNll  I!/33G3GHHO  $ $_ 5 5 5S) 6X 1  7  M _ , ,'K E-  '+;D ;!;!) >) > 6 %   !"36O"OP)!" #* , ,h" ,)C,@,@@@@@$%9:[HHHH0D EEIKj"a'"l6?.&&t,,7.7.772$l##FMM*2>2D2D2F2F%H%HIII&**"kAo6*!YY|44l 4;;DAA)(()CDDN+C0J,K,K,L,LM +hn%_)=)======S!4555   1w C ,,,,,,,,rc>g}|D]}g}|jD]}|js5||j||j>|jjdsR|jjds3|jjdks|jjdvr|d|d ||rtj |dd |dzS)z2Compose the final output from the finalized lines.rNr:z,}])rr) r+rTr7rr&r4rZrrUrr VerifyCode)r=r;formatted_coderformatted_liners rr9r9s)...dN{ ' '  'c=>>>ci((((0;;DAA '0;;C@@ ' &#--n"&00  ! !# & & &"''.11222 ..,---  4 ''rceZdZdZdZdZdS) _StateNodea]An edge in the solution space from 'previous.state' to 'state'. Attributes: state: (format_decision_state.FormatDecisionState) The format decision state for this node. newline: If True, then on the edge from 'previous.state' to 'state' a newline is inserted. previous: (_StateNode) The previous state node in the graph. cT||_||_||_dSr)ClonerCrprevious)selfrCrrs r__init__z_StateNode.__init__s#DJDLDMMMrcBd|j|jS)Nz%StateNode(state=[ {0} ], newline={1}))rrCr)rs r__repr__z_StateNode.__repr__s# 4 ; ; DL " ""rN)__name__ __module__ __qualname____doc__rrryrrrrs< """""rrOrderedPenaltypenaltyrS QueueItemordered_penalty state_nodec Fd}t}g}t|dd}tj|t t d|||dz }|r|d}|jj}|j}|j j snrtj ||dkr d|j _ |j |vrZ| |j t||d||}t||d||}||sdSt|tj |jdS)aAnalyze the entire solution space starting from initial_state. This implements a variant of Dijkstra's algorithm on the graph that spans the solution space (LineStates are the nodes). The algorithm tries to find the shortest path (the one with the lowest penalty) from 'initial_state' to the state where all tokens are placed. Arguments: initial_state: (format_decision_state.FormatDecisionState) The initial state to start the search from. Returns: True if a formatting solution was found. False otherwise. rFNrPi'T)rIrheapqheappush _QueueItem_OrderedPenaltyrrrrCr4heappopignore_stack_for_comparisonadd_AddNextStateToQueue_ReconstructPath) initial_staterSseenp_queuer%itemrs rr6r6s< % $ ' M5$ / /$.*_Q%>%>EEFFF1*%F 1:D"*G ?D :    M' u}}/3dj, zTHHTZ !$ug F FE $eW E EE' F*  5=%-"8"8"CDDD rc T|j}|r|j|s|S|s|r|St|j||}||j|d|z }t j|tt||||dzS)aYAdd the following state to the analysis queue. Assume the current state is 'previous_node' and has been reached with a penalty of 'penalty'. Insert a line break if 'newline' is True. Arguments: penalty: (int) The penalty associated with the path up to this point. previous_node: (_StateNode) The last _StateNode inserted into the priority queue. newline: (bool) Add a newline if True. count: (int) The number of elements in the queue. p_queue: (heapq) The priority queue representing the solution space. Returns: The updated number of elements in the queue. T)rrrrP) rC MustSplitCanSplitrr5rrrr)r previous_noderrSrrr%s rrrs"",,..* ](11*== L Z L M'- @ @$ TZ ' 't (<<<'.*_We%D%DdKKLLL rctj}|jr#|||j}|j#|D]}||jddS)a6Reconstruct the path through the queue with lowest penalty. Arguments: initial_state: (format_decision_state.FormatDecisionState) The initial state to start the search from. current: (_StateNode) The node in the decision graph that is the end point of the path with the least penalty. FrN) collectionsdequer appendleftr5r)rcurrentpathr%s rrr s    $OOGG GGd!!$,!FFFFGGrc ztrBtd|kr1ttrtd|k1d}t|r8ts|gan-td|krd}t||t ||||||dS)aFormat the first token in the unwrapped line. Add a newline and the required indent before the first token of the unwrapped line. Arguments: first_token: (format_token.FormatToken) The first token in the unwrapped line. indent_depth: (int) The line's indentation depth. prev_uwline: (list of unwrapped_line.UnwrappedLine) The unwrapped line previous to this line. final_lines: (list of unwrapped_line.UnwrappedLine) The unwrapped lines that have already been processed. rFT) indent_levelN) NESTED_DEPTHpop _IsClassOrDefr7AddWhitespacePrefix_CalculateNumberOfNewlines)rA indent_depthr>r= first_nesteds rr r 6s b)L88 b)L88,;( ("^ll b L ( (l,''' !! lK!,l<<"!!!!!rrPrc\|jdvrdS|jo|jdko|jjdkS)N>defclass@Tasyncr)r&r4)rs rrr\s?Y''' 4 . (SY'1 ( . % ')rc|3|j*tj|jtjjddS|jrl|jjdkrtj drtS|jj drtj drtStS|jr9|s7|jjdks|jjdkrd tj d zS|j}|jr|s |jd vrd tj d zS|rTtj d s@t!|r1tj|jtjjdtSt#|j||rtStSt!|rx|s|jddk}|js|jr|st#|j||rt-|d z }|dkr||d z jsn |d z}|dk||d z jjdkr&||jtn*|d tj d z|j*tj|jtjjdtSn[t!|jrG|rEtj d s1tj|jtjjdtS|jr#|j|jdz }n|j}|j} |jr| |jdz } || z d krtStS)aBCalculate the number of newlines we need to add. Arguments: first_token: (format_token.FormatToken) The first token in the unwrapped line. indent_depth: (int) The line's indentation depth. prev_uwline: (list of unwrapped_line.UnwrappedLine) The unwrapped line previous to this line. final_lines: (list of unwrapped_line.UnwrappedLine) The unwrapped lines that have already been processed. first_nested: (boolean) Whether this is the first nested class or function. Returns: The number of newlines needed before the first token. Nrr!BLANK_LINE_BEFORE_CLASS_DOCSTRINGr"BLANK_LINE_BEFORE_MODULE_DOCSTRINGfromimportrP3BLANK_LINES_BETWEEN_TOP_LEVEL_IMPORTS_AND_VARIABLES>rrr'BLANK_LINES_AROUND_TOP_LEVEL_DEFINITION%BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEFrNr)newlinesr SetNodeAnnotationr% AnnotationNEWLINES is_docstringrr&r rrerNO_BLANK_LINESis_namer(r_NoBlankLinesBeforeCurrentTokenrZrSr$rr[r]rRrV) rArr>r=rprev_last_tokenis_inline_commentrqfirst_token_linenoprev_last_token_linenos rrrcs&'$[%5%1%<%EtMMM 1 7** 566 +   ! , ,S 1 1 )8 9 9 AA6))8++ ?AAAA $/! F[.2KKKDEE EE I= > >k""$[%5%1%<%EtMMM &''G O O O,$+k.?.E.Ed.K.KK$+*1(@o399$???00144  rc#Kd}d}|t|kr||jr||}|dz }|t|kr|jjdz}||j|jkrn|jjdkrQt jtj dd|j|ff}| tj |||j D]}| ||dz }|t|k|Vntj||d |rs||dz}|j D]}|| |t|j dkr|jjr d ||_||V|dz }d }n||V|dz }d}|t|kd Sd S) aGenerate the lines we want to format. Arguments: uwlines: (list of unwrapped_line.UnwrappedLine) Lines we want to format. Yields: Either a single line, if the current line cannot be merged with the succeeding line, or the next two lines merged into one line. rFrPrr;r)typer&contextNT)r[r$r(rGrRr&rLeafrSEMI AppendTokenr FormatTokenr+rCanMergeMultipleLinesrrV)r:rqlast_was_mergedr@rGleafr next_uwlines rrrs %/ G u~ u~f qje CLL #a' 5> FM 1 1  ;  # #:S2 v7N2OQQQ$   \5d;; < < <5>( " "C   S ! ! ! !   CLL  llll  *7566?O L LEAI&k#((#""3'''' k ! !Q & &   / '"& EN qjeoo EN qjeoC G rc|j}|jr||jdz}|js|dnd}|j|z|dz kS)aDetermine if there are no blank lines before the current token. The previous token is a docstring or comment. The prev_token_lineno is the start of the text of that token. Counting the number of newlines in its text gives us the extent and thus where the line number of the end of the docstring or comment. After that, we just compare it to the current token's line number to see if there are blank lines between them. Arguments: text: (unicode) The text of the docstring or comment before the current token. cur_token: (format_token.FormatToken) The current token in the unwrapped line. prev_token: (format_token.FormatToken) The previous token in the unwrapped line. Returns: True if there is no blank line before the current token. rNrrP)rRrr&rS)text cur_tokenrfcur_token_lineno num_newliness rrrsj(%4 --d333)3)>ED!!!A,  \ )-=-A AAr)FN).r __future__rrrrnlib2to3r lib2to3.pgen2r yapf.yapflibrrrr r r rDr.r/r)r,r0r2r1r-r3r8r9objectr namedtuplerrr6rrrr rreTWO_BLANK_LINESrrrrryrrrs(''''' ......%%%%%%$$$$$$%%%%%%!!!!!!D0D0D0D0NCCC    "2"2"2J:::6<NNN ;;; III2~~~B(((.""""""""6)+()9Iw;OPP$[ #K%6 $EGG 222j@GGG& !!!B)))rrrj---`BBBBBr