3 OXPmq@sdZddlmZddlmZmZddlmZddlm Z ddl m Z ddl m Z mZmZmZmZmZmZGd d d eZGd d d eZGd ddeZGdddeZGdddeZGdddeZGdddeZddZGdddeZdS)z tinycss.css21 ------------- Parser for CSS 2.1 http://www.w3.org/TR/CSS21/syndata.html :copyright: (c) 2012 by Simon Sapin. :license: BSD, see LICENSE for more details. )unicode_literals)chainislice)decode) TokenList)tokenize_grouped)strip_whitespaceremove_whitespacesplit_on_commavalidate_valuevalidate_block validate_any ParseErrorc@s eZdZdZddZddZdS) Stylesheetal A parsed CSS stylesheet. .. attribute:: rules A mixed list, in source order, of :class:`RuleSet` and various at-rules such as :class:`ImportRule`, :class:`MediaRule` and :class:`PageRule`. Use their :obj:`at_keyword` attribute to distinguish them. .. attribute:: errors A list of :class:`~.parsing.ParseError`. Invalid rules and declarations are ignored, with the details logged in this list. .. attribute:: encoding The character encoding that was used to decode the stylesheet from bytes, or ``None`` for Unicode stylesheets. cCs||_||_||_dS)N)ruleserrorsencoding)selfrrrrM/var/www/html/enquirykeeper_venv/lib/python3.6/site-packages/tinycss/css21.py__init__>szStylesheet.__init__cCsdj|t|jt|jS)Nz-<{0.__class__.__name__} {1} rules {2} errors>)formatlenrr)rrrr__repr__CszStylesheet.__repr__N)__name__ __module__ __qualname____doc__rrrrrrr(src@s eZdZdZddZddZdS)AtRulea An unparsed at-rule. .. attribute:: at_keyword The normalized (lower-case) at-keyword as a string. Eg: ``'@page'`` .. attribute:: head The part of the at-rule between the at-keyword and the ``{`` marking the body, or the ``;`` marking the end of an at-rule without a body. A :class:`~.token_data.TokenList`. .. attribute:: body The content of the body between ``{`` and ``}`` as a :class:`~.token_data.TokenList`, or ``None`` if there is no body (ie. if the rule ends with ``;``). The head was validated against the core grammar but **not** the body, as the body might contain declarations. In case of an error in a declaration, parsing should continue from the next declaration. The whole rule should not be ignored as it would be for an error in the head. These at-rules are expected to be parsed further before reaching the user API. cCs6||_t||_|dk r t|n||_||_||_dS)N) at_keywordrheadbodylinecolumn)rr r!r"r#r$rrrrfs  zAtRule.__init__cCs dj|S)Nz;<{0.__class__.__name__} {0.line}:{0.column} {0.at_keyword}>)r)rrrrrmszAtRule.__repr__N)rrrrrrrrrrrHsrc@s$eZdZdZdZddZddZdS)RuleSetaA ruleset. .. attribute:: at_keyword Always ``None``. Helps to tell rulesets apart from at-rules. .. attribute:: selector The selector as a :class:`~.token_data.TokenList`. In CSS 3, this is actually called a selector group. ``rule.selector.as_css()`` gives the selector as a string. This string can be used with *cssselect*, see :ref:`selectors3`. .. attribute:: declarations The list of :class:`Declaration`, in source order. NcCs t||_||_||_||_dS)N)rselector declarationsr#r$)rr&r'r#r$rrrrs zRuleSet.__init__cCsdj||jjS)Nz3<{0.__class__.__name__} at {0.line}:{0.column} {1}>)rr&as_css)rrrrrszRuleSet.__repr__)rrrrr rrrrrrr%rsr%c@s eZdZdZddZddZdS) DeclarationaA property declaration. .. attribute:: name The property name as a normalized (lower-case) string. .. attribute:: value The property value as a :class:`~.token_data.TokenList`. The value is not parsed. UAs using tinycss may only support some properties or some values and tinycss does not know which. They need to parse values themselves and ignore declarations with unknown or unsupported properties or values, and fall back on any previous declaration. :mod:`tinycss.color3` parses color values, but other values will need specific parsing/validation code. .. attribute:: priority Either the string ``'important'`` or ``None``. cCs&||_t||_||_||_||_dS)N)namervaluepriorityr#r$)rr*r+r,r#r$rrrrs  zDeclaration.__init__cCs(|jrd|jnd}dj||jj|S)Nz !z=<{0.__class__.__name__} {0.line}:{0.column} {0.name}: {1}{2}>)r,rr+r()rr,rrrrszDeclaration.__repr__N)rrrrrrrrrrr)sr)c@s$eZdZdZdZddZddZdS)PageRuleaA parsed CSS 2.1 @page rule. .. attribute:: at_keyword Always ``'@page'`` .. attribute:: selector The page selector. In CSS 2.1 this is either ``None`` (no selector), or the string ``'first'``, ``'left'`` or ``'right'`` for the pseudo class of the same name. .. attribute:: specificity Specificity of the page selector. This is a tuple of four integers, but these tuples are mostly meant to be compared to each other. .. attribute:: declarations A list of :class:`Declaration`, in source order. .. attribute:: at_rules The list of parsed at-rules inside the @page block, in source order. Always empty for CSS 2.1. z@pagecCs(||_||_||_||_||_||_dS)N)r& specificityr'at_rulesr#r$)rr&r/r'r0r#r$rrrrs zPageRule.__init__cCs dj|S)Nz9<{0.__class__.__name__} {0.line}:{0.column} {0.selector}>)r)rrrrrszPageRule.__repr__N)rrrrr rrrrrrr.s r.c@s$eZdZdZdZddZddZdS) MediaRuleaOA parsed @media rule. .. attribute:: at_keyword Always ``'@media'`` .. attribute:: media For CSS 2.1 without media queries: the media types as a list of strings. .. attribute:: rules The list :class:`RuleSet` and various at-rules inside the @media block, in source order. z@mediacCs||_||_||_||_dS)N)mediarr#r$)rr2rr#r$rrrrszMediaRule.__init__cCs dj|S)Nz6<{0.__class__.__name__} {0.line}:{0.column} {0.media}>)r)rrrrrszMediaRule.__repr__N)rrrrr rrrrrrr1sr1c@s$eZdZdZdZddZddZdS) ImportRuleaA parsed @import rule. .. attribute:: at_keyword Always ``'@import'`` .. attribute:: uri The URI to be imported, as read from the stylesheet. (URIs are not made absolute.) .. attribute:: media For CSS 2.1 without media queries: the media types as a list of strings. This attribute is explicitly ``['all']`` if the media was omitted in the source. z@importcCs||_||_||_||_dS)N)urir2r#r$)rr4r2r#r$rrrrszImportRule.__init__cCs dj|S)Nz4<{0.__class__.__name__} {0.line}:{0.column} {0.uri}>)r)rrrrr#szImportRule.__repr__N)rrrrr rrrrrrr3sr3cCsjt|}tt|d}dd|Dddddgkr`|\}}}}|j|jfd kr`|jd d kr`|St||S) zRemove any valid @charset at the beggining of a token stream. :param tokens: An iterable of tokens :returns: A possibly truncated iterable of tokens cSsg|] }|jqSr)type).0trrr 4sz&_remove_at_charset.. ATKEYWORDSSTRING;@charset r")r>r?)iterlistrr+r(r)tokensheaderZatkwspacestringZ semicolonrrr_remove_at_charset)s  rGc@seZdZdZd ddZd!ddZd"ddZd d Zd d Zd dZ dgZ ddZ ddZ ddZ ddZddZddZddZddZdS)# CSS21ParserarParser for CSS 2.1 This parser supports the core CSS syntax as well as @import, @media, @page and !important. Note that property values are still not parsed, as UAs using this parser may only support some properties or some values. Currently the parser holds no state. It being a class only allows subclassing and overriding its methods. Nc CsBt|dr|j}nt|d}|j}WdQRX|j||||S)a]Parse a stylesheet from a file or filename. Character encoding-related parameters and behavior are the same as in :meth:`parse_stylesheet_bytes`. :param css_file: Either a file (any object with a :meth:`~file.read` method) or a filename. :return: A :class:`Stylesheet`. readrbN)hasattrrIopenparse_stylesheet_bytes)rZcss_fileprotocol_encodinglinking_encodingdocument_encoding css_bytesfdrrrparse_stylesheet_fileMs    z!CSS21Parser.parse_stylesheet_filecCs t||||\}}|j||dS)aNParse a stylesheet from a byte string. The character encoding is determined from the passed metadata and the ``@charset`` rule in the stylesheet (if any). If no encoding information is available or decoding fails, decoding defaults to UTF-8 and then fall back on ISO-8859-1. :param css_bytes: A CSS stylesheet as a byte string. :param protocol_encoding: The "charset" parameter of a "Content-Type" HTTP header (if any), or similar metadata for other protocols. :param linking_encoding: ```` or other metadata from the linking mechanism (if any) :param document_encoding: Encoding of the referring style sheet or document (if any) :return: A :class:`Stylesheet`. )r)rparse_stylesheet)rrQrNrOrP css_unicoderrrrrMcs z"CSS21Parser.parse_stylesheet_bytescCs2t|}|rt|}|j|dd\}}t|||S)a2Parse a stylesheet from an Unicode string. :param css_unicode: A CSS stylesheet as an unicode string. :param encoding: The character encoding used to decode the stylesheet from bytes, if any. :return: A :class:`Stylesheet`. stylesheet)context)rrG parse_rulesr)rrUrrCrrrrrrT~s zCSS21Parser.parse_stylesheetcCs|jt|S)aParse a "style" attribute (eg. of an HTML element). This method only accepts Unicode as the source (HTML) document is supposed to handle the character encoding. :param css_source: The attribute value, as an unicode string. :return: A tuple of the list of valid :class:`Declaration` and a list of :class:`~.parsing.ParseError`. )parse_declaration_listr)rZ css_sourcerrrparse_style_attrs zCSS21Parser.parse_style_attrc Csg}g}t|}x|D]}|jdkryZ|jdkrX|j||}|j||||}|j|n$|j||\}}|j||j|Wqtk r} z|j| WYdd} ~ XqXqW||fS)aParse a sequence of rules (rulesets and at-rules). :param tokens: An iterable of tokens. :param context: Either ``'stylesheet'`` or an at-keyword such as ``'@media'``. (Most at-rules are only allowed in some contexts.) :return: A tuple of a list of parsed rules and a list of :class:`~.parsing.ParseError`. r;CDOCDCr:N)r;r[r\)rAr6 read_at_rule parse_at_ruleappend parse_rulesetextendr) rrCrWrrtokenruleresult rule_errorsexcrrrrXs"         zCSS21Parser.parse_rulescCs|jj}g}|}x$|D]}|jdkr*Pq|j|qWt|}x|D]}t|dqFW|jdkrh|jnd}t||||j|j S)aGRead an at-rule from a token stream. :param at_keyword_token: The ATKEYWORD token that starts this at-rule You may have read it already to distinguish the rule from a ruleset. :param tokens: An iterator of subsequent tokens. Will be consumed just enough for one at-rule. :return: An unparsed :class:`AtRule`. :raises: :class:`~.parsing.ParseError` if the head is invalid for the core grammar. The body is **not** validated. See :class:`AtRule`. z{;z at-rule head{N) r+lowerr6r_r rcontentrr#r$)rZat_keyword_tokenrCr r!rbZ head_tokenr"rrrr]s    zCSS21Parser.read_at_rulerVcCs(|jdkr||jkr"t|d||j|j\}}|jdkrNt|dj|j|j|jd\}}} |j| t |||||j |j S|jdkr |dkrt|d||jst|d|j |j} |jdkrt|dj|j|j |jd\} } |j| t| | |j |j S|jd kr|dkr.t|d |xB|D]:} | jdkr4| jrZd j| j} nd } t| d| q4W|j}|st|d|djdkrt|d|dj|dj}|j t|dd} |jdk rt|ddt|| |j |j S|jd krt|dnt|dj||jdS)aParse an at-rule. Subclasses that override this method must use ``super()`` and pass its return value for at-rules they do not know. In CSS 2.1, this method handles @charset, @import, @media and @page rules. :param rule: An unparsed :class:`AtRule`. :param previous_rules: The list of at-rules and rulesets that have been parsed so far in this context. This list can be used to decide if the current rule is valid. (For example, @import rules are only allowed before anything but a @charset rule.) :param context: Either ``'stylesheet'`` or an at-keyword such as ``'@media'``. (Most at-rules are only allowed in some contexts.) :raises: :class:`~.parsing.ParseError` if the rule is invalid. :return: A parsed at-rule z@pagez@page rule not allowed in Nzinvalid {0} rule: missing blockz@mediarVz@media rule not allowed in zexpected media types for @media@importz@import rule not allowed in @charsetz an {0} rulez a rulesetz@import rule not allowed after z'expected URI or STRING for @import rulerURIr<z-expected URI or STRING for @import rule, got rzexpected ';', got a blockz%mis-placed or malformed @charset rulez#unknown at-rule in {0} context: {1})rkrj)rlr<)r at_page_allowed_contextsrparse_page_selectorr!r"rparse_declarations_and_at_rulesrar.r#r$ parse_mediarXr1r6r+r r3)rrcZprevious_rulesrrWr&r/r'r0rer2rZ previous_ruletype_r!r4rrrr^sf                    zCSS21Parser.parse_at_rulecCsv|s dgSg}xbtt|D]R}dd|D}|dgkrJ|j|djqt|dd|rfddj|nd qW|S) aCFor CSS 2.1, parse a list of media types. Media Queries are expected to override this. :param tokens: A list of tokens :raises: :class:`~.parsing.ParseError` on invalid media types/queries :returns: For CSS 2.1, a list of media types as strings allcSsg|] }|jqSr)r6)r7rbrrrr9Msz+CSS21Parser.parse_media..IDENTrzexpected a media typez, got z, r-)r r r_r+rjoin)rrCZ media_typesparttypesrrrrq=s   zCSS21Parser.parse_mediacCsj|sd St|dkrX|djdkrX|djdkrX|dj}d d d dj|}|rX||fSt|dddS)aParse an @page selector. :param tokens: An iterable of token, typically from the ``head`` attribute of an unparsed :class:`AtRule`. :returns: A page selector. For CSS 2.1, this is ``'first'``, ``'left'``, ``'right'`` or ``None``. :raises: :class:`~.parsing.ParseError` on invalid selectors Nr:rrt)firstleftrightzinvalid @page selectorrr)Nr})rr)rr)rr)rr6r+getr)rrCZ pseudo_classr/rrrroUs   zCSS21Parser.parse_page_selectorc Cs g}g}g}t|}x|D]}|jdkry*|j||}|j||||}|j|Wqtk r~} z|j| WYdd} ~ XqXq|jdkrg} x&|r|jdkr| j|t|d}qW| ry|j|j| Wqtk r} z|j| WYdd} ~ XqXqW|||fS)aParse a mixed list of declarations and at rules, as found eg. in the body of an @page rule. Note that to add supported at-rules inside @page, :class:`~.page3.CSSPage3Parser` extends :meth:`parse_at_rule`, not this method. :param tokens: An iterable of token, typically from the ``body`` attribute of an unparsed :class:`AtRule`. :param context: An at-keyword such as ``'@page'``. (Most at-rules are only allowed in some contexts.) :returns: A tuple of: * A list of :class:`Declaration` * A list of parsed at-rules (empty for CSS 2.1) * A list of :class:`~.parsing.ParseError` r:Nr;r=)rAr6r]r^r_rnextparse_declaration) rrCrWr0r'rrbrcrderrZdeclaration_tokensrrrrpns2       z+CSS21Parser.parse_declarations_and_at_rulesc Csg}xt|g|D]p}|jdkrxt|}|s6t|dx|D]}t|dq s    $ *"'-"