o DDia @sUddlZddlmZmZddlmZmZmZmZm Z m Z m Z m Z ddl Zddl mZmZddlmZmZeeeZe eed<dZdZGd d d ejZGd d d ejZGd ddejZdejdeedejfddZ GdddejZ!dejdejfddZ"dejdej#fddZ$dedejdejfddZ%GdddejZ&Gd d!d!ejZ'dej#fd"d#Z(dej#fd$d%Z)d&ejd'ej#d(ej#dej*fd)d*Z+eZ,e eed+<ed,d-Gd.d/d/Z-ed,d-Gd0d1d1Z.d&ej/deefd2d3Z0d&ej/deefd4d5Z1d6ee-deed7ej*dejfd8d9Z2d6ee-d:ejdejfd;d<Z3d6ee-d:ej#dej#fd=d>Z4d6ee-d:ej*dejfd?d@Z5d6ee-d:ej*dejfdAdBZ6dCe7de eee-ffdDdEZ8d&e ej/dee.ddffdFdGZ9eZ:e eedH<gZ;eeedI<e;e;j?d\e;j?qe;z"typing\.Union\[([^,]*?), NoneType]c@sReZdZdZdejdejdejfddZdejdejdeejejffddZ d S) NormalizeUnionsa Convert a binary operation with | operators into a Union type. For example, converts `foo | bar | baz` into `typing.Union[foo, bar, baz]`. Special case: converts `foo | None` or `None | foo` into `typing.Optional[foo]`. Also flattens nested typing.Union types. original_node updated_nodereturncCst|jtjrzt|jjtjrz|jjjdkrz|jjjdkrzg}|jD]B}t|jtjs,q"|jj}t|tjr_t|jtjr_t|jjtjr_|jjjdkr_|jjjdkr_| dd|jDq"| |q"tttdtddd|DS|S)Nr typingcss&|]}t|jtjr|jjVqdSN isinstanceslicecstIndexvalue).0 nested_slcr[/var/www/Datamplify/venv/lib/python3.10/site-packages/libcst/codegen/gen_matcher_classes.py 3s  z2NormalizeUnions.leave_Subscript..cSg|] }tt|qSrrSubscriptElementrroperandrrr >z3NormalizeUnions.leave_Subscript..) rrr AttributeNameattrrr Subscriptextendappend)selfrroperandsslcrrrr leave_Subscripts8       zNormalizeUnions.leave_Subscriptcs|jts |Sdtjdttjffdd |}tdd|D}|dkrPt|dkrPtd d|D}t t t d t d t t |gSt t t d t d d d|DS)Nnodercst|tjs4t|tjr1t|jtjr1t|jjtjr1|jjjdkr1|jjjdkr1dd|jDS|gS|j t s?|gS|j }|j }||S)z8Flatten a binary operation tree into a list of operands.r rcSs"g|] }t|jtjr|jjqSrrrr1rrr r'Ss  zTNormalizeUnions.leave_BinaryOperation..flatten_binary_op..)rrBinaryOperationr,rr)r*r+roperator deep_equalsBitOrleftright)r3 left_operandsright_operandsflatten_binary_oprr r>Hs$     z@NormalizeUnions.leave_BinaryOperation..flatten_binary_opcss*|]}t|tjr|jdkrdVqdS)NoneNrrr*rroprrr r!ds  z8NormalizeUnions.leave_BinaryOperation..r@css*|]}t|tjr|jdks|VqdS)r?NrArBrrr r!is  rrr cSr"rr#r%rrr r'vr(z9NormalizeUnions.leave_BinaryOperation..)r6r7rr8BaseExpressionrsumlennextr,r)r*r$r)r/rrr0 none_countnon_nonerr=r leave_BinaryOperationBs& z%NormalizeUnions.leave_BinaryOperationN) __name__ __module__ __qualname____doc__rr,r2r5r rKrrrr rs  'rc@seZdZdejdejdejfddZdejdejdeejej ffddZ dej dej deej ej ffdd Z dej dej deej ejffd d Zd S) CleanseFullTypeNamesrrrcCsBt|jtjr|jtds|jtdr|jdjS|S)N _ForwardRef ForwardRefr)rfuncrr*r7argsrr/rrrrr leave_Call{s zCleanseFullTypeNames.leave_CallcCs|jSr)r+rUrrr leave_Attributesz$CleanseFullTypeNames.leave_AttributecCs>|j}|dkr |jddS|tvr|dstt|S|S)NNoneTyper?)rSentinel)r with_changesrendswithr SimpleStringreprr/rrrrrr leave_Names  zCleanseFullTypeNames.leave_NamecCsF|j}t|tjr|j}t|tjrd|jvrtS|jtjj dS)NrY)comma) rrrrrr*RemoveFromParentrZ MaybeSentinelDEFAULTr/rrr1valrrr leave_SubscriptElements   z+CleanseFullTypeNames.leave_SubscriptElementN)rLrMrNrCallrErVr)r r*rWr\r_r$RemovalSentinelrfrrrr rPzs:     rPc@sHeZdZdeeddfddZdejdejdeejej ffdd Z dS) RemoveTypesFromGenericvaluesrNcCst||_dSr)setrj)r/rjrrr __init__szRemoveTypesFromGeneric.__init__rrcCs<|j}t|tjr|j}t|tjr|j|jvrtS|Sr)rrrrrr*rjrardrrr rfs   z-RemoveTypesFromGeneric.leave_SubscriptElement) rLrMrNrstrrlrr$r rhrfrrrr risrioldtyperjrcCst|t|tjS)z Given a BaseExpression from a type, return a new BaseExpression that does not refer to any types listed in values. )r visitrirrE)rnrjrrr _remove_typessrpc@s2eZdZdejdejdeejejffddZdS)MatcherClassToLibCSTClassrrrcCs*|j}|tvrttdt|S|S)Nr)evaluated_valuerrr)r*r^rrr leave_SimpleStringsz,MatcherClassToLibCSTClass.leave_SimpleStringN)rLrMrNrr\r r)rsrrrr rqsrq matchtypecCst|ttjS)z Given a BaseExpression in a type, convert this to a new BaseExpression that refers to LibCST nodes instead of forward references to matcher nodes. )r rorqrrE)rtrrr !_convert_match_nodes_to_cst_nodessruc Cs2tttjtdttt|fdS)zO Construct a MatchIfTrue type node appropriate for going into a Union. MatchIfTruer)rr$rr,r*ru)rnrrr _get_match_if_truesrxnamecCs tt|tt|fSrrr,r*r$r)ryrnrrr _add_generics r{c@s(eZdZdejdejdejfddZdS)AddLogicMatchersToUnionsrrrc Cs`|jtdr.t|dg}|jg|jttt d|ttt d|dS|S)Nr DoNotCareSentinelOneOfAllOfrw) rr7rr*rprZrr$rr{)r/rrconcrete_only_exprrrr r2s   z(AddLogicMatchersToUnions.leave_SubscriptN)rLrMrNrr,r2rrrr r|sr|csNeZdZd fdd ZdejddfddZdejd ejdejfd d ZZS) AddWildcardsToSequenceUnionsrNcstt|_t|_dSr)superrlrkin_match_if_true fixup_nodes)r/ __class__rr rls  z%AddWildcardsToSequenceUnions.__init__r3cCs|jtdr|j|dS|jtdrP|jrdSt|jdkr*td|jdj}t |tj rR|j}t |tj rT|jtdrV|j |dSdSdSdSdS)Nrvrr@zGUnexpected number of sequence elements inside Sequence type annotation!rr ) rr7rr*raddrGr Exceptionrrr,r)r/r3 nodeslice possibleunionrrr visit_Subscripts&    z,AddWildcardsToSequenceUnions.visit_Subscriptrrc Csn||jvr |j|||jvr5|j||jg|jtttd|tttd|dS|S)NAtLeastNAtMostNrw) rremoverrZrrr$rr{rUrrr r2)s$     z,AddWildcardsToSequenceUnions.leave_Subscript)rN) rLrMrNrlrr,rr2 __classcell__rrrr r srcCtttdS)zQ Construct a DoNotCareSentinel entry appropriate for going into a Union. r}rr$rr*rrrr _get_do_not_care>rcCr)zQ Construct a MetadataMatchType entry appropriate for going into a Union. MetadataMatchTyperrrrr _get_match_metadataFrrr3addition additionscGs&ttdtt||g|S)z Take two or more nodes, wrap them in a union type. Function signature is explicitly defined as taking at least one addition for type safety. r rz)r3rrrrr _get_wrapped_union_typeNs r_global_aliasesT)frozenc@seZdZUeed<eed<dS)AliasrytypeN)rLrMrNrm__annotations__rrrr rbs  rc@s*eZdZUeed<eed<eeed<dS)FieldryraliasesN)rLrMrNrmrrrrrrr rhs rcCsft|tjr |jSt|tjr|j}t|tr|SdSt|tjr&t|j St|tj r1t|jSdSr) rrr*rr\rrrmr$ _get_raw_namerr)r3rrrrr ros       rcCst|tjtjfrt|dSt|tjr>|jtdr>dd|jD}t dd|Dr2dSd dd|DdSdS) N MatchTyper cSsg|]}t|qSr)r)rsrrr r'sz#_get_alias_name..css|]}|duVqdSrrrnrrr r!sz"_get_alias_name..Orcss|] }|dur|VqdSrrrrrr r!s) rrr*r\rr,rr7ranyjoin)r3namesrrr _get_alias_name~s rrrcCsR|dur|t|tjdd|dtt|tS|jg|j tdS)Nrbody)ryrrw) r.rrModule code_for_noderr*rrZr)rryrrrr _wrap_clean_types rtypecstcCs&t|}t|tt|}t|||Sr)rrrrxrrrryrrrr _get_clean_type_from_expressions   rcCsD|j}t|tjr |j}t|tjr t||t||tj S|Sr) rrrrrr,r deep_replace_get_clean_type_from_subscriptr$)rrr1rerrr _maybe_fix_sequence_in_unions  rcsBt|}|jgfdd|jDtt|d}t||S)Ncsg|]}t|qSr)rr4rrr r'sz._get_clean_type_from_union..rw)rrZrrrxrrrrr _get_clean_type_from_unions rcCs|jtdrYt|jdkrtd|jdj}t|tjs$td|j}t|tj r3t ||}nt|tjtj frBt ||}n tdt |dt|||tt|S|jtdrgt||St ||S) Nrr@z9Logic error, Sequence shouldn't have more than one param!rz7Logic error, expecting Index for only Sequence element!z*Logic error, unexpected type in Sequence: !r )rr7rr*rGrrrrr,rr\rrrrrrxr)rr inner_typeclean_inner_typerrr rs,        rtypeobjcCst|}ttd|}ttd|}t|}|t}t|t j s$J|t }t|t j s2Jg}t|t j r@t ||}nt|t jt jfrOt||}n tdt|dt|tt j}t|tt j}t jdd||fS)z Given a type object as returned by dataclasses, sanitize it and convert it to a type string that is appropriate for our codegen below. z\1ztyping.Optional[\1]z(Logic error, unexpected top level type: rrr)r]resubCLASS_RE OPTIONAL_REr rorrrrErPr,rr*r\rrrr r|CSTNoderrr)rtypestrrr clean_typerrr _get_clean_type_and_aliasess&      rccsbt|pgD]'}|jdkrqt|j\}}t|j|dd|DdVtdd|DqdS)zJ Given a CSTNode, generate a field name and type string for each. _metadatacSsg|] }|jtvr|qSr)ryrrarrr r'sz_get_fields..)ryrrcss|]}|jVqdSr)ryrrrr r!sz_get_fields..N)rryrrrrupdate)r3field fieldtyperrrr _get_fields s  r all_exportsgenerated_codez4# Copyright (c) Meta Platforms, Inc. and affiliates.#zA# This source code is licensed under the MIT license found in thez9# LICENSE file in the root directory of this source tree.z?# This file was generated by libcst.codegen.gen_matcher_classesz!from dataclasses import dataclassz5from typing import Literal, Optional, Sequence, Unionzimport libcst as csta@from libcst.matchers._matcher_base import AbstractBaseMatcherNodeMeta, BaseMatcherNode, DoNotCareSentinel, DoNotCare, TypeOf, OneOf, AllOf, DoesNotMatch, MatchIfTrue, MatchRegex, MatchMetadata, MatchMetadataIfTrue, ZeroOrMore, AtLeastN, ZeroOrOne, AtMostN, SaveMatchedNode, extract, extractall, findall, matches, replace)BaseMatcherNoder} DoNotCarer~r DoesNotMatchrv MatchRegex MatchMetadataMatchMetadataIfTrueTypeOf ZeroOrMorer ZeroOrOnerSaveMatchedNodeextract extractallfindallmatchesreplacezXfrom libcst.matchers._decorators import call_if_inside, call_if_not_inside, visit, leave)call_if_insidecall_if_not_insideroleavezvfrom libcst.matchers._visitors import MatchDecoratorMismatch, MatcherDecoratableTransformer, MatcherDecoratableVisitor)MatchDecoratorMismatchMatcherDecoratableTransformerMatcherDecoratableVisitorz6class _NodeABC(metaclass=AbstractBaseMatcherNodeMeta):z __slots__ = ()zclass z (_NodeABC):z passz=MetadataMatchType = Union[MatchMetadata, MatchMetadataIfTrue]BaseclassesrFz = z4@dataclass(frozen=True, eq=False, unsafe_hash=False)(z, z):z z: z = DoNotCare()z{ metadata: Union[MetadataMatchType, DoNotCareSentinel, OneOf[MetadataMatchType], AllOf[MetadataMatchType]] = DoNotCare()z __all__ = __main__ )Sr dataclassesrrrrrrrrr r r libcstrr r libcst.codegen.gatherrrrkdirrrmrrrCSTTransformerrrPrirErprqrur$rxr{r|rrrr,rrrrrrrrrrrrobjectrrrrr.rbaserLrr3 startswithrtc issubclass has_aliaseslist node_fieldsrraliasryrrfields_printedr]sortedprintrrrr sR (g-     1         " ",