o h @s&ddlZddlZddlmZmZddlmZmZmZm Z m Z m Z m Z m Z mZmZddlmZmZmZddlmZmZddlmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(ddl)m*Z*ddl+m,Z,dd l-m.Z.m/Z/e d Z0e1Z2e1Z3ee.e/fZ4eGd d d Z5eGd ddZ6eGdddZ7eGdddZ8de e0dee e2e0ffddZ9 d3de5de5de e.de:ddf ddZ;ddd e5d!ed"ed'e6d(e1de:fd)d*Z?d e5d+e.d(e1de:fd,d-Z@d e5d.e.d(e1de:fd/d0ZAd e5deZ.d?e defd@dAZ/de de e fdBdCZ0dSdDdEZ1de defdFdGZ2 dRdHede3e4e5e e ffdIdJZ6dTdKdLZ7de8fdMdNZ9defdOdPZ:d S)ULinez;Holds leaves and comments. Can be printed with `str(line)`.F)reprmoderdepthdefault_factoryleavescommentsbracket_trackerinside_bracketsshould_split_rhsNmagic_trailing_commaleaf preformatted track_bracketreturncCs|jtvp t|j}|sdStj|jkr|jr|jdd=|jr4|s4|j t || ||j d7_ |j s;|r;|rY|j||j jrN||rM||_n |j|ddrY|||sf|j|dSdS)agAdd a new `leaf` to the end of the line. Unless `preformatted` is True, the `leaf` will receive a new consistent whitespace prefix and metadata applied by :class:`BracketTracker`. Trailing commas are maybe removed, unpacked for loop variables are demoted from being delimiters. Inline comments are put aside. N)complex_subscriptr+T)ensure_removable)typerboolvaluestripr%COLONis_class_paren_emptyr/prefixr#is_complex_subscriptr+r2r1markr4has_magic_trailing_commaremove_trailing_commaappend_commentappend)selfr5r6r7 has_valuerKA/var/www/html/ai/venv/lib/python3.10/site-packages/black/lines.pyrH?s,       z Line.appendcCsN|jjdks |jr|jrtd|jr|jtkrtd|j||ddS)zLike :func:`append()` but disallow invalid standalone comment structure. Raises ValueError when any `leaf` is appended after a standalone comment or when a standalone comment is not the first leaf on the line. rz$cannot append to standalone commentsz5cannot append standalone comments to a populated liner6N) r1r,any_open_for_or_lambda is_comment ValueErrorr/r<rrH)rIr5r6rKrKrL append_safecs zLine.append_safecCst|jdko|jdjtkS)z"Is this line a standalone comment?r)lenr/r<rrIrKrKrLrOwszLine.is_commentcCst|o |jdjtjkS)zIs this line a decorator?r)r=r/r<r%ATrTrKrKrL is_decorator|szLine.is_decoratorcCt|o t|jdS)zIs this an import line?r)r=rr/rTrKrKrLrzLine.is_importcCrW)zIs this a with_stmt line?r)r=r r/rTrKrKrLr rXzLine.is_with_or_async_with_stmtcCs*t|o|jdjtjko|jdjdkS)z Is this line a class definition?rclass)r=r/r<r%NAMEr>rTrKrKrLis_classs z Line.is_classcCs&|jo|jddddtdDkS)zEIs this line a class definition with a body consisting only of "..."?NcSg|]}ttjdqS.r&r%DOT.0_rKrKrL  z&Line.is_stub_class..)r[r/rangerTrKrKrL is_stub_classszLine.is_stub_classcCsz|jd}Wn tyYdSwz|jd}Wn ty$d}Ynw|jtjkr0|jdkpD|jtjkoD|duoD|jtjkoD|jdkS)zBIs this a function definition? (Also returns True for async defs.)rFrRNdef)r/ IndexErrorr<r%rZr>ASYNC)rI first_leaf second_leafrKrKrLis_defs$    z Line.is_defcCs4|jo|jddttjdgddtdDkS)zHIs this line a function definition with a body consisting only of "..."?N:cSr]r^r`rbrKrKrLrerfz$Line.is_stub_def..rg)ror/r&r%r@rhrTrKrKrL is_stub_defs$ zLine.is_stub_defcCs`t|o/t|jdko/|jo/|jdjtjko/|jdjdko/|jdjtjko/|jdjdkS)zzIs this a class with no base classes but using parentheses? Those are unnecessary and should be removed. (rg)) r=rSr/r[r<r%LPARr>RPARrTrKrKrLrAs zLine.is_class_paren_emptycCsR|r |jdjtjkr dS|jdj}|drdStj|jvr'|dr'dSdS)z#Is the line a triple quoted string?rF)z"""z'''T)zr'''zr"""zR'''zR""") r/r<r%STRINGr> startswithraccept_raw_docstringsr+)rIr>rKrKrLis_triple_quoted_strings  zLine.is_triple_quoted_stringcCs$t|jdkr dS|jdjtjkS)z/Does this line open a new level of indentation.rF)rSr/r<r%r@rTrKrKrL opens_blockszLine.opens_blockfirst_leaf_matchesrcCsFt|jdkr dS|jd}|jtks|jdurdS|dup"||jS)zIs this line converted from fmt off/skip code? If first_leaf_matches is not None, it only returns True if the first leaf of converted code matches. rRFrN)rSr/r<rfmt_pass_converted_first_leaf)rIrr5rKrKrLis_fmt_pass_converteds    zLine.is_fmt_pass_convertedcCs |jD] }|jtkr dSqdS)z)If so, needs to be split before emitting.TF)r/r<rrIr5rKrKrLcontains_standalone_commentss  z!Line.contains_standalone_commentscCs^t|jddD]#\}}|tjkrq t|}t|dkrq |D] }||r+dSq q dS)zFChck if we have an implicit multiline string with comments on the linecSs|jSN)r<)r5rKrKrLszGLine.contains_implicit_multiline_string_with_comments..rRTF) itertoolsgroupbyr/r%rylistrScomments_after)rI leaf_typeleaf_group_iterator leaf_listr5rKrKrL0contains_implicit_multiline_string_with_commentss    z5Line.contains_implicit_multiline_string_with_commentscCst}z)|jd}|t||jtjks|jtjkr+|js+|jd}|t|Wn t y6YdSwd}|j D]\}}|D]}t |rX|sTt |sX||vrXdSd}qDq>dS)Nr}r9FT)setr/addidr<r%COMMArxr>rkr0itemsrr)rI ignored_ids last_leaf comment_seenleaf_idr0commentrKrKrL$contains_uncollapsable_type_commentss0     z)Line.contains_uncollapsable_type_commentscCs|jsdStdd|jDd}tddt|jDd}||kr?|jddD]}|jt|gD] }t|r=dSq3q(dS)NFcs |] }|jdkr|jVqdSrNlinenorcr5rKrKrL :z9Line.contains_unsplittable_type_ignore..rcsrrrrrKrKrLr<rr9T)r/nextreversedr0getrr)rI first_line last_linenoderrKrKrL!contains_unsplittable_type_ignore)sz&Line.contains_unsplittable_type_ignorecCstdd|jDS)Ncss|]}t|VqdSr)rrrKrKrLrKz2Line.contains_multiline_strings..)anyr/rTrKrKrLcontains_multiline_stringsJszLine.contains_multiline_stringsclosingr;cCs|jtvr|jr|jdjtjksdS|jtjkrdS|jtjkrD|jdurB|jjtj krB|j durBt |j ||jtj tjfdrBdSdS|j rIdS|j durXt |j ||jsXdSdS)aTReturn True if we have a magic trailing comma, that is when: - there's a trailing comma here - it's not a one-tuple - it's not a single-element subscript Additionally, if ensure_removable: - it's not from square bracket indexing (specifically, single-element square bracket indexing) r}FTN)brackets)r<rr/r%rRBRACERSQBparentr"traileropening_bracketrLSQBr)rIrr;rKrKrLrEMs6        zLine.has_magic_trailing_commarcCs|jtkr|jrd|_dS|jtjkrdS|js"t|_d|_dS|jd}|jtjkrV|j sV|j rVt t |j dkrVt |sVt |jdkrQt|_d|_dS|jd}|jt|g|dS)z0Add an inline or standalone comment to the line.Fr}rgrtr9T)r<rr1any_open_bracketsrBr%COMMENTr/rxr>rrSrrr0 setdefaultrrH)rIrrrKrKrLrG|s6     zLine.append_commentcCs|jt|gS)z;Generate comments that should appear directly after `leaf`.)r0rrrrKrKrLrszLine.comments_aftercCs>|j}|jt|g}|jt|jdg|dS)z@Remove the trailing comma and moves the comments attached to it.r}N)r/popr0rrextend)rItrailing_commatrailing_comma_commentsrKrKrLrFs zLine.remove_trailing_commacCsj|j}|dur dS|j}t|tr&|jtjkrdS|jtjkr&t ||}|duo4t dd| DS)zAReturn True iff `leaf` is part of a slice with non-trivial exprs.NFcss|]}|jtvVqdSr)r<r)rcnrKrKrLrs  z,Line.is_complex_subscript..) r1 get_open_lsqb next_sibling isinstancer'r<r" listmaker subscriptlistrr pre_order)rIr5 open_lsqbsubscript_startrKrKrLrCs     zLine.is_complex_subscriptrccsttttgttttff|rtnt}||j D]+\}}t |j t |j }d|j vr2dS| |D] }|t |j 7}q7|||fVqdS)zReturn an enumeration of leaves with their length. Stops prematurely on multiline strings and standalone comments.  N)r rr r&rr Indexenumerate_reversed enumerater/rSrBr>r)rIropindexr5lengthrrKrKrLenumerate_with_lengths  zLine.enumerate_with_lengthcCst|j|j|j|j|jdS)N)r+r,r2r3r4)r)r+r,r2r3r4rTrKrKrLclonesz Line.clonecCsz|sdSd|j}t|j}t|}|j||j}|D]}|t|7}qtj |j D]}|t|7}q0|dS)zRender the line.rz ) r,iterr/rrBr>strrchain from_iterabler0values)rIindentr/firstresr5rrKrKrL__str__s  z Line.__str__cCst|jp|jS)z/Return True if the line has leaves or comments.)r=r/r0rTrKrKrL__bool__sz Line.__bool__)FFF)r8N)r8r));__name__ __module__ __qualname____doc__rr+r__annotations__r,intrr/rr&dictr0rLeafIDrr1r2r=r3r4rrHrQpropertyrOrVrr r[rirorrrAr|r~rrrrrrrrErGrrFrCrr rrrrrrrKrKrKrLr)1s     $  $! /%   r)c@s:eZdZUdZeed<eed<eed<eed<eed<dS) RHSResultz2Intermediate split result from a right hand split.headbodytailrclosing_bracketN)rrrrr)rr&rKrKrKrLrs  rc@sneZdZUdZeed<eded<eed<dZe ed<e e dZ e eed<dZe ed <d e efd d Zd S) LinesBlockzClass that holds information about a block of formatted lines. This is introduced so that the EmptyLineTracker can look behind the standalone comments and adjust their empty lines for class or def lines. r+previous_block original_linerbeforer- content_linesafterr8cCs.tt|jd}||jg|j||jgS)N)r+)rr)r+rrr)rI empty_linerKrKrL all_lines szLinesBlock.all_linesN)rrrrrrrr)rrrrrrrrrrKrKrKrLrs    rc @seZdZUdZeed<dZeeed<dZ ee ed<e e dZ eeed<dZee ed<d ed e fd d Zd ed eeeffd dZd ededed eeeffddZdS)EmptyLineTrackera{Provides a stateful method that returns the number of potential extra empty lines needed before and after the currently processed line. Note: this tracker works on lines that haven't been split yet. It assumes the prefix of the first leaf consists of optional newlines. Those newlines are consumed by `maybe_empty_lines()` and included in the computation. r+N previous_linerr- previous_defssemantic_leading_comment current_liner8cCs||\}}|jr|jjnd}|jdurdn||}tj|jvr@|jr@|jjdur@t|jjj dkr@|jjj r@|j s@|j s@d}t |j|j|||d}|jrh|jdusd|jjsg|jjr]|rg|jdusd|rg||_n|jrm|rpd|_||_||_|S)zReturn the number of extra empty lines before and after the `current_line`. This is for separating `def`, `async def` and `class` with extra empty lines (two on module-level). rNrR)r+rrrr)_maybe_empty_linesrrrrmodule_docstring_newlinesr+rSrr/r|r[rorrOrVr)rIrrrprevious_afterblockrKrKrLmaybe_empty_lines#sR     z"EmptyLineTracker.maybe_empty_linesc Cs^d}|jdkr|jjr dnd}|jr&|jd}|jd}t||}d|_nd}t|}|j}d}|jrL|jdj|krL|j }|jrL|jdj|ks<|dur|j dusWJ|jjr|rk|j sk|j j rk|rhdnd}n7t j |jvrz|jrz|jszd}n(|rd}n#d}n |rd}n|s|jr|jdjtjkr|jdjdvrd}nd}|js|j s|jr||||S|j r|j jr|js|jtds||j jkr|pddfS|j r|j jr|jrt j|jvrd S|dfSt j|jvo|jdjtkp|jpt|jdo|j o|j jdo|j jdjot|j jdj }|j r+|j jr+|s+d S|dfS) NrRrrtrrr})withtryforwhileifmatchrrrRrr) r,r+is_pyir/rBcountminr=rrrror"blank_line_after_nested_stub_classr[rir<r%r@r>rV#_maybe_empty_lines_for_class_or_defrrr|$no_blank_line_before_class_docstring2allow_empty_first_line_before_new_block_or_commentrr~rrr) rIr max_allowedrmruser_had_newliner, previous_defis_empty_first_line_okrKrKrLrUs              z#EmptyLineTracker._maybe_empty_linesrrcCs|js |j||jdurdS|jjr|jjr|jrdSdS|jj|jkr0|jjs.|jj r0dSd}|jj ra|jj|jkra|dkra|j }|dur_|j dur_|j j js_|j j js_|jdkr_|}ndS|jjr|jsl|jjr|jj|jkrvd}n_|jj|jkrd}nU|jr|jjrd}nKd}nHtj|jvr|jj|jkrd}n8|j s|jr|jj s|jrtd|}n%d}n"|jj|jkrd}nd}n|jrdnd}tj|jvr|jjr|sd}|dur|j }|durt|j||j|_d}|dfS)NrrrrRrt)rVrrHrr+rrir,r[rorOrrrr~rr+blank_line_between_nested_and_def_stub_filerdummy_implementationsrrmaxr)rIrrrcomment_to_add_newlinesslcnewlinesrrKrKrLrs       z4EmptyLineTracker._maybe_empty_lines_for_class_or_def)rrrrrrrrr)rrrrrrrrr rrr=rrKrKrKrLrs$ 2m rsequencer8ccs2t|d}t|D] }||fV|d8}q dS)z;Like `reversed(enumerate(sequence))` if that were possible.rRN)rSr)rrelementrKrKrLr"s     rFnew_lineold_liner/r6cCsR|D]$}t|j|j}t|||j||d||D] }|j|ddqqdS)a Append leaves (taken from @old_line) to @new_line, making sure to fix the underlying Node structure where appropriate. All of the leaves in @leaves are duplicated. The duplicates are then appended to @new_line and used to replace their originals in the underlying Node structure. Any comments attached to the old leaves are reattached to the new leaves. Pre-conditions: set(@leaves) is a subset of set(@old_line.leaves). rMTN)r&r<r>r!rHr)rrr/r6old_leafnew_leaf comment_leafrKrKrL append_leaves*s rr)line_strliner+rcCs|st|}|jr tnt}tj|vr"|||jko!d|vo!| S|r(dSd|vr3|||jkS|d^}}}|||jksJ|||jkrLdSg}d}g} t j } t |j D]\} } | t j krd} | j dt|krt|dn | j dt|kr|} | dur|dur|j | j dkr| j } | dkrdS| j | kr| jtjkrdg}|| 7}| j|vr| t|j dks|| j d7<| t j krt| | j } t| rt| dkrdS| }| }t||vr| ||jdurn |j}t||vsqZt| dkrdStdd|DS) aFor non-multiline strings, return True if `line` is no longer than `line_length`. For multiline strings, looks at the context around `line` to determine if it should be inlined or split up. Uses the provided `line_str` rendering, if any, otherwise computes a new one. rFNrRrTcss|]}|dkVqdSrrK)rcvalrKrKrLrrz'is_line_short_enough..)line_to_stringpreviewr$rSrmultiline_string_handling line_lengthrsplitmathinfrr/ bracket_depthrHrr<r%r prev_siblingrrrrall)rr+rwidthrrdlastcommasmultiline_stringmultiline_string_contextsmax_level_to_updateir5 had_comma ignore_ctxsctxrKrKrLis_line_short_enoughBsn          r0cCs|j}t|dkr dS|djtjkrr|djtjkrrd}d}|d}|dddD]G}|jtvr>|jtvr9dS|d7}n(|jtjkrI|d7}n|jtjkr^|jtjks]|jtvs]dSn|jtvrfdS|dkrq|dkrqdSq*dS) zReturn False if the line cannot be split *for sure*. This is not an exhaustive search but a cheap heuristic that we can use to avoid some unfortunate formattings (mostly around wrapping unsplittable code in unnecessary parentheses). rtFrrRr}r9NT) r/rSr<r%ryrarrrZ)rr/ call_count dot_countrr5rKrKrL can_be_splits0         r3rhsrc Cs|j}d}t|jD]'}|r||jurd}|jtkr|sdS|s1|jtvr1|j|jvr1|jr1|}q |j}|j s:dS| }| |}|dkrIdS|dkr]t j |jvr]|tkr]|jjr]dS|tkrcdSt|jdksnJd|jd}|jd} |jtvr| jtvrt|||drdS|jd } |jd } | jtjks| jtjks| jtjkr| jr| jjtjkr| jtvrdSt|rdSt|| |d rdSdS) aDoes `rhs.body` have a shape safe to reformat without optional parens around it? Returns True for only a subset of potentially nice looking formattings but the point is to not return false positives that end up producing lines that are too long. NFTrRrtzStranded delimiterr)rrr9r})r'r)rrr/rr<rrr>r1 delimitersmax_delimiter_prioritydelimiter_count_with_priorityr(wrap_multiple_context_managers_in_parensr+rrr rrSr_can_omit_opening_parenr%rxrrrr"rr_can_omit_closing_paren) r4rrrr5bt max_prioritydelimiter_countrsecond penultimater'rKrKrLcan_omit_invisible_parenssf             r@rcCsd}d|j}d}|D]%\}}}|jtvr|j|urd}|r2||7}||kr+dS|jtvr2d}q t|j|dkr>dSdS) See `can_omit_invisible_parens`.Frsr}TrR)r,rr<rrrrSr/)rrr remainderr_indexr5 leaf_lengthrKrKrLr9&s"  r9r'cCsZd|j}d}|D]\}}}||7}||jur#|s||kr"dSq |jtvr*d}q dS)rArsFT)r,rrr<r)rr'rrseen_other_bracketsrCr5rDrKrKrLr:?s    r:cCst|dS)zmReturns the string representation of @line. WARNING: This is known to be computationally expensive. r)rr?)rrKrKrLrPsrr)Crr! dataclassesrrtypingrrrrrr r r r r black.bracketsrrr black.moderr black.nodesrrrrrrrrrrrrrr r!r"r# black.stringsr$blib2to3.pgen2r%blib2to3.pytreer&r'r(rrrLNr)rrrrr=rrr0r3r@r9r:rrKrKrKrLsz0 L   C "   [$ e