o DDi @sddlmZmZddlmZmZmZddlmZm Z m Z ddl m Z ddl mZddlmZGdddZe ed d Gd d d eZGd ddeeZdS)) dataclassfield)ListOptionalSequence) BaseStatementCSTNodeModule) add_slots) CodegenState)BaseMetadataProviderc@seZdZdZgdZdddZdefd d Zdefd d Z defd dZ de defddZ de defddZ de defddZdS)CodegenPartiala Provided by :class:`ExperimentalReentrantCodegenProvider`. Stores enough information to generate either a small patch (:meth:`get_modified_code_range`) or a new file (:meth:`get_modified_code`) by replacing the old node at this position. ) start_offset end_offsethas_trailing_newline_indent_tokens_prev_codegen_statestate_ReentrantCodegenStatereturnNcCs0|jd|_|j|_d|_t|j|_||_dS)NT) start_offset_stackr char_offsetrrtuple indent_tokensrr)selfrrZ/var/www/Datamplify/venv/lib/python3.10/site-packages/libcst/metadata/reentrant_codegen.py__init__!s   zCodegenPartial.__init__cCs |jSz Equivalent to :meth:`libcst.Module.bytes` on the top-level module that contains this statement, except that it uses the cached result from our previous code generation pass, so it's faster. )rget_coderrrrget_original_module_code*s z'CodegenPartial.get_original_module_codecCs||jjSr)r"encoderencodingr!rrrget_original_module_bytes2sz(CodegenPartial.get_original_module_bytescCs|j|j|jS)z Equivalent to :meth:`libcst.Module.code_for_node` on the current statement, except that it uses the cached result from our previous code generation pass, so it's faster. )rr rrr!rrrget_original_statement_code:sz*CodegenPartial.get_original_statement_codenodecCs@t|jj|jjt|jd}|||js|d |j S)z Gets the new code for ``node`` as if it were in same location as the old statement being replaced. This means that it inherits details like the old statement's indentation. )default_indentdefault_newliner) r rr(r)listr_codegenrpop_trailing_newlinejointokens)rr'new_codegen_staterrrget_modified_statement_codeBs  z*CodegenPartial.get_modified_statement_codecCs6|}||}|d|j|||jdS)z Gets the new code for the module at the root of this statement's tree, but with the supplied replacement ``node`` in its place. N)r"r1rr)rr'originalpatchrrrget_modified_module_codeRs $z'CodegenPartial.get_modified_module_codecCs|||jjS)z Gets the new bytes for the module at the root of this statement's tree, but with the supplied replacement ``node`` in its place. )r4r#rr$rr'rrrget_modified_module_bytes[s z(CodegenPartial.get_modified_module_bytes)rrrN)__name__ __module__ __qualname____doc__ __slots__rstrr"bytesr%r&rr1r4r6rrrrr s   r F)frozencseZdZUeeed<dZeed<dZe ed<dZ e ed<e e dZ ee ed<d Zeeed <e e dZeeed <d ed d ffdd Zdfdd Zdfdd Zd ed d ffdd Zded d fddZded d fddZdfdd Zd efddZZS) rproviderzutf-8r$r indent_sizer)default_factoryrN cached_codetrailing_partialsvaluercs&tt|||jt|7_dSN)superrincrease_indentr@lenrrD __class__rrrGpsz&_ReentrantCodegenState.increase_indentcs*|jt|jd8_tt|dS)Nr)r@rHrrFrdecrease_indentr!rJrrrLtsz&_ReentrantCodegenState.decrease_indentcs"tt||j|j7_dSrE)rFradd_indent_tokensrr@r!rJrrrMxsz(_ReentrantCodegenState.add_indent_tokenscs0tt|||jt|7_|jdSrE)rFr add_tokenrrHrCclearrIrJrrrN|sz _ReentrantCodegenState.add_tokenr'cCs t|tsdS|j|jdSrE) isinstancerrappendrr5rrrbefore_codegens z%_ReentrantCodegenState.before_codegencCs>t|tsdSt|}|j|||j|j|dSrE) rPrr r? set_metadatarpoprCrQ)rr'partialrrr after_codegens  z$_ReentrantCodegenState.after_codegencs<|jD]}|jt|jd8_d|_qtt|dS)a :class:`libcst.Module` contains a hack where it removes the last token (a newline) if the original file didn't have a newline. If this happens, we need to go back through every node at the end of the file, and fix their `end_offset`. rFN)rCrrHr/rrFrr-)rtprJrrr-s z+_ReentrantCodegenState.pop_trailing_newlinecCs(|j}|dur |Sd|j}||_|S)Nr*)rBr.r/)rrBrrrr s  z_ReentrantCodegenState.get_code)rN)r7r8r9r r __annotations__r$r<r@intrrr+rrrBrrCrGrLrMrNrrRrVr-r __classcell__rrrJrres      rc@s"eZdZdZdeddfddZdS)$ExperimentalReentrantCodegenProvidera An experimental API that allows fast generation of modified code by recording an initial code-generation pass, and incrementally applying updates. It is a performance optimization for a few niche use-cases and is not user-friendly. **This API may change at any time without warning (including in minor releases).** This is rarely useful. Instead you should make multiple modifications to a single syntax tree, and generate the code once. However, we can think of a few use-cases for this API (hence, why it exists): - When linting a file, you might generate multiple independent patches that a user can accept or reject. Depending on your architecture, it may be advantageous to avoid regenerating the file when computing each patch. - You might want to call out to an external utility (e.g. a typechecker, such as pyre or mypy) to validate a small change. You may need to generate and test lots of these patches. Restrictions: - For safety and sanity reasons, the smallest/only level of granularity is a statement. If you need to patch part of a statement, you regenerate the entire statement. If you need to regenerate an entire module, just call :meth:`libcst.Module.code`. - This does not (currently) operate recursively. You can patch an unpatched piece of code multiple times, but you can't layer additional patches on an already patched piece of code. modulerNcCs$t|j|j||jd}||dS)N)r(r)r?r$)rr(r)r$r,)rr\rrrr _gen_implsz.ExperimentalReentrantCodegenProvider._gen_impl)r7r8r9r:r r]rrrrr[sr[N) dataclassesrrtypingrrrlibcstrrr libcst._add_slotsr libcst._nodes.internalr libcst.metadatar r rr[rrrrs   UC