tikEPSSKrSSKrSSKrSSKrSSKrSSKJr SSKJrJrJ r J r J r J r J r Jr SSKJr SSKJrJrJrJrJrJrJrJrJr \(aSSKJrJr "SS \R:S 9r"S S \5r"S S\5r Sr!\RDSSS:Xa \!S- r!\!S- r!SSjr#g)N)Module)IterableIteratorListOptionalTupleAnycast TYPE_CHECKING) LineNumbers) Token match_tokenis_non_coding_tokenpatched_generate_tokens last_stmtannotate_fstring_nodesgenerate_tokens is_moduleis_stmt)AstNode TokenInfocb\rSrSrS\S\SS4Sjr\RS5rS Sjr S S jr S r g) ASTTextBase! source_textfilenamereturnNcRX l[U5nXl[U5UlgN) _filenamestr_textr _line_numbers)selfrrs P/home/mande/repo/quber/.venv/lib/python3.13/site-packages/asttokens/asttokens.py__init__ASTTextBase.__init__"s%N k"KJ$[1Dc[e) Returns two ``(lineno, col_offset)`` tuples for the start and end of the given node. If the positions can't be determined, or the nodes don't correspond to any particular text, returns ``(1, 0)`` for both. ``padded`` corresponds to the ``padded`` argument to ``ast.get_source_segment()``. This means that if ``padded`` is True, the start position will be adjusted to include leading whitespace if ``node`` is a multiline statement. )NotImplementedErrorr%nodepaddeds r&get_text_positionsASTTextBase.get_text_positions-s  r)cURX5up4URR"U6URR"U64$)z Returns the (startpos, endpos) positions in source text corresponding to the given node. Returns (0, 0) for nodes (like `Load`) that don't correspond to any particular text. See ``get_text_positions()`` for details on the ``padded`` argument. )r0r$line_to_offsetr%r.r/startends r&get_text_rangeASTTextBase.get_text_range;sH((6JE ''/ ''- r)cDURX5up4URX4$)z Returns the text corresponding to the given node. Returns '' for nodes (like `Load`) that don't correspond to any particular text. See ``get_text_positions()`` for details on the ``padded`` argument. )r7r#r4s r&get_textASTTextBase.get_textIs%$$T2JE ::e !!r))r!r$r#)T) __name__ __module__ __qualname____firstlineno__r"r'abcabstractmethodr0r7r:__static_attributes__r)r&rr!s@ 2# 2 2 2    "r)r) metaclassc^\rSrSrSrSU4SjjrSrSr\S5r \S5r \S5r \S 5r S r S rS rSS jrSSjrSSjrSSjrSSjrSrSrU=r$) ASTTokensUa ASTTokens maintains the text of Python code in several forms: as a string, as line numbers, and as tokens, and is used to mark and access token and position information. ``source_text`` must be a unicode or UTF8-encoded string. If you pass in UTF8 bytes, remember that all offsets you'll get are to the unicode text, which is available as the ``.text`` property. If ``parse`` is set, the ``source_text`` will be parsed with ``ast.parse()``, and the resulting tree marked with token info and made available as the ``.tree`` property. If ``tree`` is given, it will be marked and made available as the ``.tree`` property. In addition to the trees produced by the ``ast`` module, ASTTokens will also mark trees produced using ``astroid`` library . If only ``source_text`` is given, you may use ``.mark_tokens(tree)`` to mark the nodes of an AST tree created separately. c>[[U] X5 U(a[R"X5OUUlUc[ UR5n[URU55Ul URVs/sHofRPM snUl UR (aURUR 5 ggs snfr )superrFr'astparse_treerr#list_translate_tokens_tokensstartpos_token_offsets mark_tokens)r%rrKtreertokenstok __class__s r&r'ASTTokens.__init__is )T#K:5:;1DJ~tzz*f..v67DL48<<@C c>SSKJn U"U5RU5 g)a] Given the root of the AST or Astroid tree produced from source_text, visits all nodes marking them with token and position information by adding ``.first_token`` and ``.last_token`` attributes. This is done automatically in the constructor when ``parse`` or ``tree`` arguments are set, but may be used manually with a separate AST or Astroid tree. r ) MarkTokensN)rRrY visit_tree)r% root_noderYs r&rRASTTokens.mark_tokenszs(t *r)c## [[U55H\up#UupEpgn[XEXgXURR USUS5URR USUS55v M^ g7f)zK Translates the given standard library tokens into our own representation. rr N) enumeraterrr$r3) r%original_tokensindexrUtok_typetok_strr5r6lines r&rNASTTokens._translate_tokenss|  7 HI ,/)hT (U$$33E!HeAhG$$33CFCFC EEJsA6A8cUR$)z,The source code passed into the constructor.)r#r%s r&textASTTokens.text ::r)cUR$)zIThe list of tokens corresponding to the source code from the constructor.)rOrfs r&rTASTTokens.tokenss <<r)cUR$)zTThe root of the AST tree passed into the constructor or parsed from the source code.)rLrfs r&rSASTTokens.treerir)cUR$)zThe filename that was parsed)r!rfs r&rASTTokens.filenames >>r)cdUR[R"URU5S- $)z Returns the token containing the given character offset (0-based position in source text), or the preceeding token if the position is between tokens. r )rObisectrQ)r%offsets r&get_token_from_offsetASTTokens.get_token_from_offsets) << d&9&96BQF GGr)cVURURRX55$)z Returns the token containing the given (lineno, col_offset) position, or the preceeding token if the position is between tokens. )rsr$r3r%lineno col_offsets r& get_tokenASTTokens.get_tokens&  % %d&8&8&G&G&[ \\r)cVURXRRX55$)z\ Same as get_token(), but interprets col_offset as a UTF8 offset, which is what `ast` uses. )ryr$ from_utf8_colrvs r&get_token_from_utf8ASTTokens.get_token_from_utf8s$ >>&"4"4"B"B6"V WWr)cURS-nU(dU[URUR5(a.US- n[URUR5(aM.URU$)z Returns the next token after the given one. If include_extra is True, includes non-coding tokens from the tokenize module, such as NL and COMMENT. r r`rrOtyper%rU include_extrais r& next_tokenASTTokens.next_token_ A A   Q 4 4 5 5 Q  Q 4 4 5 5 <<?r)cURS- nU(dU[URUR5(a.US-n[URUR5(aM.URU$)z Returns the previous token before the given one. If include_extra is True, includes non-coding tokens from the tokenize module, such as NL and COMMENT. r rrs r& prev_tokenASTTokens.prev_tokenrr)c2UnU(a URO URn[XRU5(dd[R"UR 5(d?U"USS9n[XRU5(d'[R"UR 5(dM?U$)z Looks for the first token, starting at start_token, that matches tok_type and, if given, the token string. Searches backwards if reverse is True. Returns ENDMARKER token if not found (you can check it with `token.ISEOF(t.type)`). Tr)rrrtokenISEOFr)r% start_tokenrarbreversetadvances r& find_tokenASTTokens.find_tokensk A!(doodooG!w// AFF8K8K !4 (a!w// AFF8K8K Hr)c## [URURS-5HDnU(d)[URUR5(aM3URUv MF g7f)z Yields all tokens in order from first_token through and including last_token. If include_extra is True, includes non-coding tokens such as tokenize.NL and .COMMENT. r N)ranger`rrOr)r% first_token last_tokenrrs r& token_rangeASTTokens.token_rangesS;$$j&6&6&: ; 1$,,q/2F2FGGll1o/ASTTokens.get_text_positions..s S=Rk!U]]33=Rs')r)hasattrrr5rr6anyrr4s r&r0ASTTokens.get_text_positionsse 4 ' '     " "E //  C #ST__T=RSSSQxme :r))rQrOrL)FN N)F)NF)r<r=r>r?__doc__r'rRrNpropertyrgrTrSrrsryr}rrrrrr0rB __classcell__rVs@r&rFrFUs&#" + E            H ]X    !& \r)rFc\^\rSrSrSrS U4Sjjr\S5r\S5rSr Sr Sr U=r $) ASTTextia4 Supports the same ``get_text*`` methods as ``ASTTokens``, but uses the AST to determine the text positions instead of tokens. This is faster than ``ASTTokens`` as it requires less setup work. It also (sometimes) supports nodes inside f-strings, which ``ASTTokens`` doesn't. Some node types and/or Python versions are not supported. In these cases the ``get_text*`` methods will fall back to using ``ASTTokens`` which incurs the usual setup cost the first time. If you want to avoid this, check ``supports_tokenless(node)`` before calling ``get_text*`` methods. c>[[U] X5 X lURb[ UR5 SUlgr )rIrr'rLr _asttokens)r%rrSrrVs r&r'ASTText.__init__"s4 '4!+8J zzTZZ(DOr)cURcE[R"URUR5Ul[ UR5 UR$r )rLrJrKr#r!rrfs r&rS ASTText.tree,s> zz99TZZ8djTZZ( ::r)cURc.[URURURS9UlUR$)N)rSr)rrFr#rSr!rfs r& asttokensASTText.asttokens4s; ! **yy>>do ??r)c[U5(a0SURR[UR554$[ USS5cgU(de[ US/5nU(d[ USS5n[ US/5nU(aUSnOUnUR n[U5nU(aCXgR :wd1XaR:wa%[ US S5(a[U5(aSnO%URRXeR5nXh4n [[UR5n [[UR5n URRX5n X4n X4$) z> Version of ``get_text_positions()`` that doesn't use tokens. rrwNrdecorator_list decoratorsnodesrdoc_node)rr$offset_to_linelenr#getattrrwr end_linenorr|rxr intend_col_offset) r%r.r/rdecorators_node start_node start_linenoend_nodestart_col_offsetr5rrr6s r&_get_text_positions_tokenless%ASTText._get_text_positions_tokenless?sM  T''66s4::G GGtXt$,  K4/4J lD9o?GR8ja=jj$$LH' OO +j$// ++99,H]H]^  ,E c8../J#x667N''55jQN  &C :r)c[USS5(ag[U5(aURX5$URR X5$)r+_broken_positionsNr)rsupports_tokenlessrrr0r-s r&r0ASTText.get_text_positionssHt($// $  / / == >> , ,T ::r))rrL)Nr) r<r=r>r?rr'rrSrrr0rBrrs@r&rrsF     @D;;r)r) arguments Argumentswithitem))argStarred)SliceExtSliceIndexkeywordc[U5R[;=(a [U[R 5(+=(aL USL=(aA [U5RS:H=(a" [UR 5RS;(+=(a! S[RR5;$)aT Returns True if the Python version and the node (if given) are supported by the ``get_text*`` methods of ``ASTText`` without falling back to ``ASTTokens``. See ``ASTText`` for why this matters. The following cases are not supported: - PyPy - ``ast.arguments`` / ``astroid.Arguments`` - ``ast.withitem`` - ``astroid.Comprehension`` - ``astroid.AssignName`` inside ``astroid.Arguments`` or ``astroid.ExceptHandler`` - The following nodes in Python 3.8 only: - ``ast.arg`` - ``ast.Starred`` - ``ast.Slice`` - ``ast.ExtSlice`` - ``ast.Index`` - ``ast.keyword`` N AssignName)r ExceptHandlerpypy) rr<_unsupported_tokenless_types isinstancerJASTparentsysversionlower)r.s r&rrs. 4j!== , tSWW %% $d*: J  < / MT[[!**.LL   ,  ))+ + r)r )$r@rJrqrrrtypingrrrrrr r r line_numbersr utilrrrrrrrrrrrABCMetarrFrr version_inforrCr)r&rs VVV% &1"CKK1"h} }@~;k~;F FBQ6!"44"KK"r)