o .di@sJdZddlmZddlmZddlmZddlmZddlm Z ddlm Z ddlm Z dd lm Z dd lm Z dd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddl m!Z!ddl m"Z"ddl m#Z#ddl m$Z$ddl m%Z%ddl m&Z&ddl m'Z'ddl m(Z(ddl m)Z)dd l m*Z*dd!l m+Z+dd"l m,Z,dd#l m-Z-dd$l m.Z.dd%l m/Z/dd&l m0Z0dd'l m1Z1dd(l m2Z2dd)l m3Z3dd*l m4Z4dd+l m5Z5dd,l m6Z6dd-l m7Z7dd.l m8Z8dd/l m9Z9dd0l m:Z:dd1l m;Z;dd2l mZ>dd5l m?Z?dd6l m@Z@dd7l mAZAdd8l mBZBdd9l mCZCdd:l mDZDdd;l mEZEddl mHZHdd?l mIZIdd@l mJZJddAl mKZKddBl mLZLe rddClmMZMGdDdEdEZNddLdMZOedNdOddRdSZPddd[d\ZQddd]d^ZRddd_d`ZSddbdcZTGdddedeeZUe1eUjVe,eUjWe;eUjWe0eUjWerI)selfrJrMD/var/www/Matress/matenv/lib/python3.10/site-packages/liquid/parse.py__init__bs   zParser.__init__streamrreturn ast.ParseTreec Cst}|j}|jjtkr>z |||Wnty3}z|j j ||jj dWYd}~nd}~ww| |jjtks |S)z-Parse the given stream of tokens into a tree.linenumN) r ParseTree statementscurrenttyper"appendparse_statementrrJerrorrT next_token)rLrProotrVerrrMrMrNparsejs   z Parser.parseast.NodecCs|jjtkr|j|}|S|jjtkr;|j|jj|j }||}t |t j r9t d|jd|jd|S|j|}|S)z%Parse a node from a stream of tokens.zunexpected tag ''rS)rWrXr>rIget_noder@rFgetvaluerG isinstancer IllegalNodertokenrTrH)rLrPnodetagrMrMrNrZys      zParser.parse_statementendContainer[str] ast.BlockNodecCst|j}|j}|jjtkr>|jjtkr|jj|vr |S||}| ||j s1t |ddr4d|_ | |jjtks|S)zParse multiple nodes from a stream of tokens. Stop parsing nodes when we find a token in `end` or we reach the end of the stream. forced_outputFT)r BlockNoderWrVrXr"r@rdrZrY force_outputgetattrrmr\)rLrPrjblockrVstmtrMrMrN parse_blocks     zParser.parse_blockN)rJrD)rPrrQrR)rPrrQr`)rPrrjrkrQrl) __name__ __module__ __qualname____doc__ __slots__rOr_rZrsrMrMrMrNrE]s   rErPrrjrkrQNonecCsD|jjtkr |jjtkr|jj|vrdS||jjtksdSdS)zAdvance the stream pointer past the next end tag. This is used to discard blocks after a syntax error is found, in the hope that we can continue to parse more of the stream after the offending block. N)rWrXr"r@rdr\)rPrjrMrMrN eat_blocks rz)maxsizerJrDcCst|S)z3Return a template parser for the given environment.)rE)rJrMrMrN get_parsersr}NtokrBtypstrrd Optional[str]c Cs|j|ks|durA|j|krCt|j|j}t||}|dur1d|d|d|d|jd }n d|d|d}t||jddSdS)N expected z with value 'z ', found raz expected 'z ', found 'rS)rXrdrCrcrrT)r~rrd_typ _expected_typmsgrMrMrN_expects rcCt|j||dS)z}Check the current token in the stream matches the given type and value. Raises a `LiquidSyntaxError` if they don't. N)rrWrPrrdrMrMrNexpectrcCr)zzCheck the next token in the stream matches the given type and value. Raises a `LiquidSyntaxError` if they don't. N)rpeekrrMrMrN expect_peekrrboolcCs |jdS)z9Return `True` if the current token looks like an end tag.rj)rd startswith)r~rMrMrN is_end_tags rc@s.eZdZdZdZdZdZeZeZ eZ dS) PrecedencezOperator precedence.12N) rtrurvrwLOWEST LOGICALRIGHTLOGICALr RELATIONAL MEMBERSHIPPREFIXrMrMrMrNrs rexpression.BooleancCs|jjtkr tjStjS)z=Read a boolean literal (true or false) from the token stream.)rWrXrArTRUEFALSErPrMrMrN parse_booleans r_expression.NilcCtjS)z+Read a 'nil' keyword from the token stream.)rNILrrMrMrN parse_nilrexpression.EmptycCr)z-Read a 'empty' keyword from the token stream.)rEMPTYrrMrMrN parse_emptyrrexpression.BlankcCr)z-Read a 'blank' keyword from the token stream.)rBLANKrrMrMrN parse_blankrrexpression.StringLiteralcCstj|jjdS)z$Read a string from the token stream.rd)r StringLiteralrWrdrrMrMrNparse_string_literalrexpression.IntegerLiteralcCtjt|jjdS)z&Read an integer from the token stream.r)rIntegerLiteralrrWrdrrMrMrNparse_integer_literal#rexpression.FloatLiteralcCr)z#Read a float from the token stream.r)r FloatLiteralfloatrWrdrrMrMrNparse_float_literal(rrexpression.RangeLiteralcCst|t|t|}t|t||t|}t|tt|tj tj tj fs0Jt|tj tj tj fs=Jt ||}||S)z+Read a range literal from the token stream.) rr1r\parse_range_argumentrr:r=rer Identifierrr RangeLiteral)rPstartstopexprrMrMrNparse_range_literal-s&    rexpression.IdentifiercCspg}|jjtvr|jjtkr|t|jjn|jjtkr*|tt|jjny|jjt kr| |jjt krD|t|jjnE|jjt kr`t |t| |tt|jj n)|jjtkrr|tt|jjn|jjtkr|t|n td|jjt |t| n|jjtkrn td|jj| |jjtvs||jt|S)zRead an identifier from the token stream. . [""] [""]. [ int/str>] [. int/str>] [] []. zinvalid identifier, found )rWrXIDENTIFIER_TOKENSr(rYrrdr+rr,r\r?r4rparse_identifierrr;r pushrr)rPpathrMrMrNrIs<              ' rrT Optional[int]expression.ExpressioncCsn|jjtkr t|}|S|jjtkrt|}|St|jj|jj}dtdtd|}t||p4|jj d)zParse an expression from a stream of tokens. If the stream is not at a string or identifier expression, raise a syntax error. rz or z, found rS) rWrXr(rr?rrCrcrrT)rPrTrrrrMrMrNparse_string_or_identifiers  rcCsDt|t|j}t|}t|jdkr td|d|p|jd|S)zParse an identifier from a stream of tokens. If the stream is not at an identifier or the identifier is chained, raise a syntax error rzinvalid identifier 'rarS)rr(rWrlenrrrT)rPrTr~identrMrMrNparse_unchained_identifiers rc@s"eZdZUdZded<ded<dS) RangeOptionzGA token and value representing a keyword argument in a loop expression.rBr~RangeArgargN)rtrurvrw__annotations__rMrMrMrNrs  rrcCsp|jjtkr t|}|S|jjtkrt|}|S|jjtkr$t|}|S|jjtkr/t j }|St d|jj)zParse a loop argument value from a stream of tokens. If the stream is not at a valid token for a loop argument value, raise a syntax error. z7invalid range expression, expected an integer, found a ) rWrXr(rr+rr%rrrCONTINUEr)rPrrMrMrNrs"    rcCsv|j}|jjtttfvr)t|t||t|}|t ||d}|St |t |t |t j d}|S)zParse a loop keyword argument from a stream of tokens. If the stream is not at a valid loop keyword argument, raise a syntax error. )r~r)rWrXr/r7rrrr\rrrr<rr)rPr~roptrMrMrNparse_range_options   rexpression.LoopExpressioncCsttt|S)z,Parse the given string as a loop expression.)parse_loop_expressionrrrrMrMrNparse_loop_expression_valuerrcCst|tt|t|jj}|||jjtkr%t|}|n|jjt kr4t |}|nt dt j ||d}|jjtvryt|}|jjtkrSd|_n |jjtkr^|j|_n|jjtkri|j|_n |jjtkrs|j|_|jjtvsE|S)zParse a liquid loop expression, as one might find in a `for` tag. If any of the optional parameters are duplicated, the last (right most) is used. zinvalid loop expression)nameiterableT)rr(rr*rWrdr\rXrr1rrrLoopExpression LOOP_TOKENSrr~r<reversedr/rlimitr7offsetrcols)rPrrrrrMrMrNrs2               rc@seZdZUdZeeefZded<d/ddZ d0d d Z d0d dZ d1ddZ d2ddZ d3ddZd4ddZejfd5ddZd6d#d$Zd7d%d&Zd8d'd(Zd9d)d*Zd:d,d-Zd.S);ExpressionParserzThe standard expression parser. Custom, non "standard" tags can subclass `ExpressionParser` to change expression parsing behavior. Such as adding a logical `NOT` operator. zTuple[str, ...]END_EXPRESSIONrQrycCst|_t|_tttttt t t t t t tt|jtttttttttti |_t|jt|jt|jt |jt!|jt"|jt#|jt$|jt%|jt&|ji |_'dSrK)( PRECEDENCEScopy precedencesRIGHT_ASSOCIATIVEright_associativer$rrAr5rr6r!rrrr4parse_prefix_expressionr?rr+rr%rr(rr1r prefix_funcsr#parse_infix_expressionr8rr2r'r3r.r-r&r infix_funcs)rLrMrMrNrO%s4   zExpressionParser.__init__rPrrc CsDz |j|jj}W|Sty!}z td|jjd|d}~ww)z6Return the precedence of the next token in the stream.zunknown operator 'raN)rrrXKeyErrorrrd)rLrP precedencer^rMrMrNpeek_precedenceEsz ExpressionParser.peek_precedencecCs6|j|jjtj}|jj|jvrt|d}t|S)z9Return the precedence of the current token in the stream.r)rrcrWrXrrr)rLrPrrMrMrNcurrent_precedenceMs z#ExpressionParser.current_precedenceList[expression.Filter]cCs0g}|jjtkr||||jjtks|S)zCKeep reading filters from the token stream until end of expression.)rWrXr"rY parse_filter)rLrPfiltersrMrMrN parse_filtersTs   zExpressionParser.parse_filtersexpression.FiltercCst|t|t|t|jj}|g}i}|jjtkrb||jjtvrb|j jtkrF|jj}||| |}|||<n| | |||jjt kr\||jjtvs*t |||S)zCRead a single filter with optional arguments from the token stream.)rr9r\r(rWrdrXrFILTER_END_TOKENSrparse_expressionrYrrFilter)rLrP filter_nameargskwargs param_name param_valuerMrMrNr[s,         zExpressionParser.parse_filterexpression.PrefixExpressioncCs*|j}|tj|j|j|tjddS)z2Parse a prefix expression from a stream of tokens.)r)right)rWr\rPrefixExpressionrdrrr)rLrPr~rMrMrNrs z(ExpressionParser.parse_prefix_expressionleftrexpression.InfixExpressioncCs2|j}||}|tj||j|||dS)z2Parse an infix expression from a stream of tokens.)roperatorr)rWrr\rInfixExpressionrdr)rLrPrr~rrMrMrNrs  z'ExpressionParser.parse_infix_expressionrc Cs|j}|j}|j|jj}|dur$t|jj|jj}td|d||}|j j|vrX|| |krX||j j}|durB|S| |||}|j j|vrX|| |ks5|S)z&Parse a literal or logical expression.Nzunknown prefix operator 'ra) rrrrcrWrXrCrdrrrr\) rLrPrend_expressionrprefixrrinfixrMrMrNrs"    z!ExpressionParser.parse_expressionrdrexpression.FilteredExpressioncC|tt|S)z/Parse the given value as a filtered expression.)parse_filtered_expressionrrrLrdrMrMrNparse_filtered_expression_value z0ExpressionParser.parse_filtered_expression_valuecCs(||}|||}t||S)zParse a statement (output) expression with optional filters. A statement expression is assumed to start with exactly one identifier, followed by zero or more filters. )rr\rrFilteredExpression)rLrPrrrMrMrNrs   z*ExpressionParser.parse_filtered_expressioncCr)z/Parse the given string as a boolean expression.)parse_boolean_expressionrrrrMrMrNparse_boolean_expression_valuer z/ExpressionParser.parse_boolean_expression_valuecCs$|jjtkr tjStj||dS)ajParse a liquid expression that evaluates to a Boolean value. This is primarily used by control flow tags like `if`, `unless` and `case`/ `when`. Logical operators (`and` and `or`) are right associative. They are evaluated from right to left. The use of parentheses to control operator precedence is not allowed. r)rWrXr"rrBooleanExpressionr)rLrPrMrMrNr s z)ExpressionParser.parse_boolean_expressionexpression.AssignmentExpressioncCsHt|tt|tt|}||||}tjt ||dS)zParse a liquid assignment expression, as one might find in an `assign` tag. This is essentially the same as a parse_filtered_expression, but with an additional name to bind the expression result to. )rr) rr(rrrr\rrAssignmentExpressionr)rLrPrrrMrMrNparse_assignment_expressions   z,ExpressionParser.parse_assignment_expressionN)rQry)rPrrQr)rPrrQr)rPrrQr)rPrrQr)rPrrrrQr)rPrrrrQr)rdrrQr)rPrrQr)rdrrQr)rPrrQr)rPrrQr)rtrurvrwr9rr"rrrOrrrrrrrrrr rr r rrMrMrMrNrs(      '    rcCstS)z6Return an expression parser for the given environment.)STANDARD_EXPRESSION_PARSERrrMrMrNget_expression_parsersr)rPrrjrkrQry)rJrDrQrErK)r~rBrrrdrrQry)rPrrrrdrrQry)r~rBrQr)rPrrQr)rrrQr)rrrQr)rrrQr)rPrrQr)rPrrQr)rPrrQr)rPrrQr)rPrrQr)rPrrTrrQr)rPrrTrrQr)rPrrQr)rPrrQr)rdrrQr)rPrrQr)rrDrQr)rw __future__renumrr functoolsrtypingrrrr r r r liquidr rliquid.exceptionsrrliquid.expressionr liquid.lexrrr liquid.limitsr liquid.streamr liquid.tokenrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5r6r7r8r9r:r;r<r=r>r?r@rArBrCrDrErzr}rrrrrrrrrr frozensetrrrrrrrrrrrrrrrrrrContinueNilrrrrrrrrrrrrrrrrr r r rrrMrMrMrNs$                                                                   G                :      +f