ddZddlmZddlmZddlmZddlZddlZddlZddlm Z ddl m Z ddl m Z dd l m Z dd lmZdd lmZddlZd:d Zd Zd;dZdZdZdZGddeZej4ej6GddeZGddeZGddeZGddeZGddeZ GddeZ!Gd d!eZ"Gd"d#eZ#ej4ej6Gd$d%eZ$Gd&d'e$Z%Gd(d)e$Z&Gd*d+e$Z'Gd,d-e'Z(Gd.d/e'Z)Gd0d1e)Z*Gd2d3e$Z+Gd4d5e$Z,Gd6d7e$Z-Gd8d9e$Z.y)]*>NFKD)r!lowerr subjoin unicodedata normalize combining)r htmltextcs rNormalizeForSearchr/Asw E  "$ 66)R &D [2264@3@$..q1@3 443sA;ct|tst|tr|S t|S#t$rt|cYSwxYw)z-Returns value converted to int or float type.)rintfloat ValueErrorrs r _NumericTyper4VsDsz%7 L u:  <s /AAc ||\}}}t|ttfrd |t|k(ry |dk(r|j dk(ry|dk(r|j dk(ryt jddt|} n||k(ry||d vry|d k(r|d k(ry d } n||rmt|tjjrI |jrtjnd} |tj|| k(ry t!|d} n t!|d} t#|j%| } |s| St#|j%| } t'|dk(r6|ddvr/| t#|j%| j)ddz} | | k7rd|rbt+||d sUt-||d| rdnd} | rdnd}t/j0dj3t5j6|||| || S#t$rYwxYw#ttjtjf$rY=wxYw)a'Returns True if value word matches pattern. Args: backend: The parser backend object. key: The parsed expression key. op: The expression operator string. warned_attribute: Deprecation warning Boolean attribute name. value: The value to be matched by pattern. pattern: An (operand, standard_regex, deprecated_regex) tuple. Raises: ValueError: To catch codebase reliance on deprecated usage. Returns: True if pattern matches value. Examples: See surface/topic/filters.py for a table of example matches. Trfalsetruez\.0*$r$N)r$N*:Frtzinfo)r,)zoneregion/matcheszdoes not matchz will matchzwill not matchz--filter : operator evaluation is changing for consistency across Google APIs. {key}{op}{operand} currently {old_match} but {new_match} in the near future. Run `gcloud topic filters` for details.)keyopoperand old_match new_match)rr1r2r4r3r&r r'r!r datetimer<LOCAL ParseDateTimeDateTimeSyntaxErrorDateTimeValueErrorr/boolsearchlensplitgetattrsetattrrwarningrr GetKeyName)backendrBrCwarned_attributer rrDstandard_regexdeprecated_regexr-r<matcheddeprecated_matchedrErFs r_MatchOneWordInTextrZasD(/6+'>+U|$ ,w' ' ( zgmmo0  zgmmo/  66(B 5 1 2D   }* #~")  D:eU^^%<%<= #llu{{f %%%gf= = > e$ /D e$ /D &&t, -'  N,33D9:  X]s1v!33$/66tzz#r7JKLL ##(8 '+U 3 G%t,/ 5EI ' -=IKK67=f$//4#'' 7=7)* u    * 1153K3K L   s#G?8H? H  H (H;:H;c tt|trOd}g}|re|jtj||jtj |nt|t tfr|}n|g}t|t tfr|}n|h}|D]}|D]} t|||||| syy)aApplies _MatchOneWordInText to determine if value matches pattern. Both value and operand can be lists. Args: backend: The parser backend object. key: The parsed expression key. op: The expression operator string. warned_attribute: Deprecation warning Boolean attribute name. value: The key value or list of values. pattern: Pattern value or list of values. Returns: True if the value (or any element in value if it is a list) matches pattern (or any element in operand if it is a list). NTF) rdictextendriterkeys itervalueslisttuplerZ) rTrBrCrUr rvaluespatternsvps r _WordMatchrfs"t F  mmCLL'( mmCNN5)*%$' FWF$'HyH a  Wc2/?A F  r"ceZdZdZdZdZdZdZdZdZ dd Z dd Z dd Z dd Z dd ZddZddZddZddZdZy)BackendaCloud resource list filter expression evaluator backend. This is a backend for resource_filter.Parser(). The generated "evaluator" is a parsed resource expression tree with branching factor 2 for binary operator nodes, 1 for NOT and function nodes, and 0 for TRUE nodes. Evaluation for a resource object starts with expression_tree_root.Evaluate(obj) which recursively evaluates child nodes. The logic operators use left-right shortcut pruning, so an evaluation may not visit every node in the expression tree. ct|SN) _ExprTRUEselfs rExprTRUEzBackend.ExprTRUEs T?r"ct|||Srj)_ExprANDrmleftrights rExprANDzBackend.ExprANDs D$ &&r"ct|||Srj)_ExprORrqs rExprORzBackend.ExprORs 4u %%r"ct||Srj)_ExprNOT)rmexprs rExprNOTzBackend.ExprNOTs D$ r"ct||Srj) _ExprGlobal)rmcalls r ExprGlobalzBackend.ExprGlobals tT ""r"ct||Srj) _ExprOperand)rmr s r ExprOperandzBackend.ExprOperands e $$r"Nct||||Srj)_ExprLTrmrBrD transforms rExprLTzBackend.ExprLT 4gy 11r"ct||||Srj)_ExprLErs rExprLEzBackend.ExprLErr"ct||||S)aCase insensitive membership node. This is the pre-compile Expr for the ':' operator. It compiles into an _ExprHAS node for prefix*suffix matching. The * operator splits the operand into prefix and suffix matching strings. Args: key: Resource object key (list of str, int and/or None values). operand: The term ExprOperand operand. transform: Optional key value transform calls. Returns: _ExprHAS. )_ExprHASrs rExprHASzBackend.ExprHASs D#w 22r"ct||||S)zCase sensitive EQ node. Args: key: Resource object key (list of str, int and/or None values). operand: The term ExprOperand operand. transform: Optional key value transform calls. Returns: _ExprEQ. )_ExprEQrs rExprEQzBackend.ExprEQs 4gy 11r"ct||||Srj)_ExprNErs rExprNEzBackend.ExprNE$rr"ct||||Srj)_ExprGErs rExprGEzBackend.ExprGE'rr"ct||||Srj)_ExprGTrs rExprGTzBackend.ExprGT*rr"ct||||Srj)_ExprRErs rExprREzBackend.ExprRE-rr"ct||||Srj) _ExprNotRErs r ExprNotREzBackend.ExprNotRE0s dC) 44r"cyNFrls r IsRewriterzBackend.IsRewriter3s r"rj)__name__ __module__ __qualname____doc__rnrtrwr{rrrrrrrrrrrrrr"rrhrhsW'& #%223$ 222225r"rhcJeZdZdZdZej dZedZ y)_ExprzExpression base class.c||_yrj)rT)rmrTs r__init__z_Expr.__init__>s DLr"cy)zReturns the value of the subexpression applied to obj. Args: obj: The current resource object. Returns: True if the subexpression matches obj, False if it doesn't match, or None if the subexpression is not supported. Nrrmobjs rEvaluatez_Expr.EvaluateA r"cyrrrls r contains_keyz_Expr.contains_keyNs r"N) rrrrrabcabstractmethodrpropertyrrr"rrr:s8      r"rceZdZdZdZy)rkz'TRUE node. Always evaluates True. cyNTr)rm unused_objs rrz_ExprTRUE.EvaluateYs r"Nrrrrrrr"rrkrkSs  r"rkc"eZdZdZfdZxZS) _ExprLogicalziBase logical operator node. Attributes: left: Left Expr operand. right: Right Expr operand. cHtt| |||_||_yrj)superrr_left_right)rmrTrrrs __class__s rrz_ExprLogical.__init__es  ,&w/DJDKr")rrrrr __classcell__rs@rrr]sr"rceZdZdZdZy)rpz8AND node. AND with left-to-right shortcut pruning. ct|jj|sy|jj|syy)NFTrrrrs rrz_ExprAND.Evaluateqs/ ::  s #  ;;   $  r"Nrrr"rrprpks  r"rpceZdZdZdZy)rvz6OR node. OR with left-to-right shortcut pruning. ct|jj|ry|jj|ryy)NTFrrs rrz_ExprOR.Evaluates/ zz3  {{C  r"Nrrr"rrvrvys  r"rvc(eZdZdZfdZdZxZS)ryz NOT node.c:tt| |||_yrj)rryr_expr)rmrTrzrs rrz_ExprNOT.__init__s (D"7+DJr"c:|jj| Srj)rrrs rrz_ExprNOT.Evaluateszz""3' ''r"rrrrrrrrs@rryrys(r"ryc(eZdZdZfdZdZxZS)r}z]Global restriction function call node. Attributes: _call: The function call object. c:tt| |||_yrj)rr}r_call)rmrTr~rs rrz_ExprGlobal.__init__s +t%g.DJr"c8|jj|Srj)rrrs rrz_ExprGlobal.Evaluates ::  s ##r"rrs@rr}r}s $r"r}c*eZdZdZdddZddZddZy) raOperand node. Converts an expession value token string to internal string and/or numeric values. If an operand has a numeric value then the actual key values are converted to numbers at Evaluate() time if possible for Apply(); if the conversion fails then the key and operand string values are passed to Apply(). Attributes: list_value: A list of operands. numeric_value: The int or float number, or None if the token string does not convert to a number. string_value: The token string. rr7)r6r8Ncp||_d|_d|_d|_d|_|j ||y)NFr*)rT list_valuenumeric_constant numeric_value string_value Initialize)rmrTr r*s rrz_ExprOperand.__init__s8DLDO!DDDOOEYO/r"ct|tr@g|_|D]3}|jjt |j ||5y|r|r|||_yt|tjr2||_ |j|j|_ d|_ yt!||_||_ y#t$r& t||_ n#t$rYnwxYwYyYywxYw)zInitializes an operand string_value and numeric_value from value. Args: value: The operand expression string value. normalize: Optional normalization function. rTN)rr`rappendrrTrrr_NUMERIC_CONSTANTSr&rrKeyErrorr4r3r!)rmr r*vals rrz_ExprOperand.Initializes%do#  si @ B 9#E*d E3++ ,d!44U[[]C $%U+d d +E2$      s6)C C6C"!C6" C.+C6-C..C65C6rj)rrrrrrrrr"rrrs!  0!r"rceZdZdZej j ej jej jej jfZ fdZ dZ e dZe dZdZej$dZxZS) _ExprOperatoraBase term () node. ExprOperator subclasses must define the function Apply(self, value, operand) that returns the result of . Attributes: _key: Resource object key (list of str, int and/or None values). _normalize: The resource value normalization function. _operand: The term ExprOperand operand. _transform: Optional key value transform calls. key : Property decorator for the resource object key. ctt| |||_||_||_|r d|_y|j|_y)Nc|Srjrxs rz(_ExprOperator.__init__..s!r")rrr_key_operand _transform _normalizeInitializeNormalizationrmrTrBrDrrs rrz_ExprOperator.__init__s> -'0DIDMDO#do44dor"cd|_tjd|r tj|}|j rtj nd|jj|jjxs|jjfdtj|_|S|S#t$rY|SwxYw)aChecks the first non-empty resource value to see if it can be normalized. This method is called at most once on the first non-empty resource value. After that a new normalization method is set for the remainder of the resource values. Resource values are most likely well defined protobuf string encodings. The RE patterns match against those. Args: value: A resource value to normalize. Returns: The normalized value. c|Srjrrs rrz7_ExprOperator.InitializeNormalization.. sr"z$\d\d\d\d-\d\d-\d\d[ T]\d\d:\d\d:\d\dNc2tj|S)Nr;)r rI)rr<s rrz7_ExprOperator.InitializeNormalization..s 3 3Af Er"r) rr matchr rIr<rHrrrrr3)rmr r<s @rrz%_ExprOperator.InitializeNormalizations "DO xx7?  ##E*!& $   MM $ $ B (B(BE ! G -- L5L    L  sBB99 CCcyrrrls rrz_ExprOperator.contains_keys r"c|jSrj)rrls rrBz_ExprOperator.key#s 99r"c ^tj||j}|jr|jj |}|rt |t tfr|}n|g}g}|D]'}|r |j|}|j|)|jjr|jj}n |jg}|D]}|D]}|j7 |jt!||jry|j"sE |s!t |j$|j&ri |j||j$ryy#ttf$rYwxYw#ttf$rYnwxYw#t(tf$rYt$r|Nt |t*j,t.t fs)|jt1||j$rYyt*j2r"| |jd|j$rYyYVwxYw)zEvaluate a term node. Args: obj: The resource object to evaluate. Returns: The value of the operator applied to the key value and operand. Tr$F)r Getrrrrr`rar TypeErrorr3rrrrApplyr4rr _TIME_TYPESAttributeErrorrrr\r!PY3)rmrr resource_valuesrboperandsrDs rrz_ExprOperator.Evaluate's  ! !#tyy 1E oo&&u-e ED%=1oo F   //%(% mmE ! }}))h--h'  , zz,u-w/D/DE++, G$8$8$:J:JK   ZZw33 45#H ]:&   *Z(    +    )9)94(FG**Z.0D0DEgg-**R!5!56 sI0E#%%E8 E8?F #E54E58F  F  H,AH,6.H,+H,cy)zReturns the value of applying a term. Args: value: The term key value. operand: The term operand value. Returns: The Boolean value of applying a term. Nrrmr rDs rrz_ExprOperator.Applylrr")rrrrr rGdatetime timedeltar<rrrrrrBrrrrrrs@rrrs  nn nn nn nn +5#J    CJ    r"rceZdZdZdZy)rzLT node.c ||kSrjrrs rrz _ExprLT.Apply} 7?r"Nrrrrrrr"rrrz r"rceZdZdZdZy)rzLE node.c ||kSrjrrs rrz _ExprLE.Apply G r"Nrrr"rrr r"rcReZdZdZ dfd Zej dZdZxZ S)_ExprWordMatchBasez${ HAS EQ NE } word match base class.ctt| ||||||_||_g|_|j jU|j jD];}|j|j|_|j|j=y|j j7|j|_|j|j jyyrj) rr r_op_warned_attribute _patternsrrr _AddPattern)rmrTrBrDrrCrUrs rrz_ExprWordMatchBase.__init__s d,Wc7INDH-DDN }}+]]--'    +!(!5!5'    7// 0.  # # /$11g t}}112 0r"cy)z,Adds a word match pattern to self._patterns.Nr)rmrs rrz_ExprWordMatchBase._AddPatterns r"ct|j|j|j|j||j S)aQChecks if value word matches operand ignoring case differences. Args: value: The number, string, dict or list object value. operand: Non-pattern operand for equality check. The ':' HAS operator operand can be a prefix*suffix pattern or a literal value. Literal values are first checked by the _Equals method to handle numeric constant matching. String literals and patterns are then matched by the _Has method. Returns: True if value HAS matches operand (or any value in operand if it is a list) ignoring case differences. )rfrTrr rrrs rrz_ExprWordMatchBase.Applys4 dllDIItxx9O9OT^^ --r")NN) rrrrrrrrrrrs@rr r s0,:> $3   -r"r c(eZdZdZfdZdZxZS)rzHAS word match node.c8tt| ||||ddy)Nr:_deprecated_has_warnedrCrU)rrrrs rrz_ExprHAS.__init__s% (D"7C)4L#Nr"c|dk(rd}d}nMd}d}d}t|}|jd}t|dkDr$tjdj ||j dr|dd}d}tj|} || z|z}t|d k(r|jdn*|jdrd}n|j drd}nd }|d rtj|d nd} |d rtj|d nd} |r|r|rd | z|z| zd z}n'| |z| z}n|r d | z|z| z}n|r | |z| zd z}nd}tjtjztjz} t|| } |r t|| }nd}|jj|| |fy)ahAdds a HAS match pattern to self._patterns. A pattern is a word that optionally contains one trailing * that matches 0 or more characters. This method re-implements both the original and the OnePlatform : using REs. It was tested against the original tests with no failures. This cleaned up the code (really!) and made it easier to reason about the two implementations. Args: pattern: A string containing at most one trailing *. Raises: resource_exceptions.ExpressionSyntaxError if the pattern contains more than one leading or trailing * glob character. r9.N\br$z*At most one * expected in : patterns [{}].r@r7z.*r^$)r/rOrNrrrendswithr escaper startswith IGNORECASE MULTILINEUNICODErr)rmrstandard_patterndeprecated_patternheadglobtailnormalized_patternpartswordrrrsreflagsrVrWs rrz_ExprHAS._AddPatterns$#~ d d d-g6 &&s+e Ua!77 8 ? ? HJ J  $ $S )/4 YY) *dt+ Uq R   c "   C $)!HRYYuQx "d%*1Xbiia!2e $ "TzD0583> #d{U2   D[4/%7 !D[5036!mmBLL(3G 0':N#$6@NN7N4DEFr"rrrrrrrrs@rrrsNCGr"rc*eZdZdZdfd ZdZxZS)rzEQ word match node.c@tt| |||||xsddy)N=_deprecated_eq_warnedr)rrr)rmrTrBrDrrCrs rrz_ExprEQ.__init__s* '4!'3%'Y33J"Lr"c4t|}tj|}d|zdz}d|zdz}tjtjztj z}t ||}t ||}|jj|||fy)aAdds an EQ match pattern to self._patterns. A pattern is a word. This method re-implements both the original and the OnePlatform = using REs. It was tested against the original tests with no failures. This cleaned up the code (really!) and made it easier to reason about the two implementations. Args: pattern: A string containing a word to match. rrrN) r/r rr r!r"rrr) rmrr(r*r#r$r+rVrWs rrz_ExprEQ._AddPatterns,G4 99' (Dt|e+tc)mmBLL(3G 0':N!"4g>NN7N4DEFr"rjr,rs@rrrsL Gr"rc,eZdZdZfdZfdZxZS)rzNE node.c6tt| ||||dy)Nz!=)rC)rrrrs rrz_ExprNE.__init__'s '4!'3t!Lr"c.tt| || Srj)rrr)rmr rDrs rrz _ExprNE.Apply*sWd)%9 99r"rrrrrrrrs@rrr$sM::r"rceZdZdZdZy)rzGE node.c ||k\Srjrrs rrz _ExprGE.Apply1rr"Nrrr"rrr.r r"rceZdZdZdZy)rzGT node.c ||kDSrjrrs rrz _ExprGT.Apply8rr"Nrrr"rrr5rr"rc(eZdZdZfdZdZxZS)rzUnanchored RE match node.cztt| ||||t|jj |_yrj)rrrrrrrrs rrz_ExprRE.__init__?s. '4!'3Cdmm889DLr"ct|tjs td|jj |duSNz(RE match subject value must be a string.rrrrrrMrmr unused_operands rrz _ExprRE.ApplyCs8 eS-- . @ AA <<  u %T 11r"r5rs@rrr<s!:2r"rc(eZdZdZfdZdZxZS)rzUnanchored RE not match node.cztt| ||||t|jj |_yrj)rrrrrrrrs rrz_ExprNotRE.__init__Ms. *d$Wc7IFdmm889DLr"ct|tjs td|jj |duSr=r>r?s rrz_ExprNotRE.ApplyQs8 eS-- . @ AA <<  u % --r"r5rs@rrrJs%:.r"r)r)F)/r __future__rrrrr r)googlecloudsdk.corergooglecloudsdk.core.resourcerrr googlecloudsdk.core.utilr r rrr!r/r4rZrfobjectrh add_metaclassABCMetarrkrrprvryr}rrrrr rrrrrrrrr"rrKs ?&' #<5:-* D(/4*Sl&RTfTt3;;F 0 5  |  l (u( $% $6!66!r3;;\ E\  \ ~mm(-(-VJG!JGZ!G !GH:g:mm 2m 2 . .r"