agglovar.merge.config.parser
============================

.. py:module:: agglovar.merge.config.parser

.. autoapi-nested-parse::

   Lexer and parser for intersect configuration strings. Contains code for
   parsing string and generating an AST from according to grammar rules.
   Downstream objects will generate a configuration object from the AST.



Classes
-------

.. autoapisummary::

   agglovar.merge.config.parser.IntersectConfigLexer
   agglovar.merge.config.parser.IntersectConfigParser


Module Contents
---------------

.. py:class:: IntersectConfigLexer(**kwdargs: dict)

   Bases: :py:obj:`object`


   Token lexer for intersect configuration strings.


   .. py:method:: parse_float(str_val: str) -> float

      Parse float from string.

      :param str_val: String to parse.

      :returns: Float value.

      :raises ValueError: If the string does not represent a float value.



   .. py:method:: parse_int(str_val: str) -> int

      Parse int from string.

      :param str_val: String to parse.

      :returns: Integer value.

      :raises ValueError: If the string does not represent an int value.



   .. py:method:: t_KEYWORD(t)

      \w(\w|\d)*



   .. py:method:: t_KW_FALSE(t)

      [fF][aA][lL][sS][eE]



   .. py:method:: t_KW_MATCH(t)

      [mM][aA][tT][cC][hH]



   .. py:method:: t_KW_TRUE(t)

      [tT][rR][uU][eE]



   .. py:method:: t_T_FLOAT(t)

      [+-]?(\d+\.\d*)|(\d*\.\d+)



   .. py:method:: t_T_FLOAT_EXP(t)

      [+-]?((\d+\.?\d*)|(\.\d+))[eE][+-]?((\d+\.?\d*)|(\.\d+))



   .. py:method:: t_T_INT(t)

      [+-]?(\d+)



   .. py:method:: t_T_INT_MULT(t)

      [+-]?((\d+\.?\d*)|(\.\d+))[kKmMgG]



   .. py:method:: t_T_UNLIMITED(t)

      [uU][nN][lL][iI][mM][iI][tT][eE][dD]



   .. py:method:: t_error(t)

      Handle lexer errors.

      :param t: Token that caused the error.

      :raises ValueError: Always raised for illegal characters.



   .. py:attribute:: lexer
      :type:  ply.lex.Lexer


   .. py:attribute:: literals
      :type:  tuple[str]


   .. py:attribute:: tokens
      :type:  tuple[str]


.. py:class:: IntersectConfigParser(**kwdargs: Any)

   Bases: :py:obj:`object`


   Intersect configuration parser.


   .. py:method:: p_error(p) -> None


   .. py:method:: p_merge_config(p) -> None

      merge_config : KEYWORD ':' ':' spec_list



   .. py:method:: p_primitive_list_element(p) -> None

      primitive_list_element : t_int
                             | t_float



   .. py:method:: p_primitive_list_elements(p) -> None

      primitive_list_elements : primitive_list_element
                              | primitive_list_element ',' primitive_list_elements
                              | ',' primitive_list_elements



   .. py:method:: p_spec(p) -> None

      spec : KEYWORD
           | KEYWORD '(' val_list ')'
           | t_match



   .. py:method:: p_spec_list(p) -> None

      spec_list : spec
                | spec ':' spec_list



   .. py:method:: p_t_bool(p) -> None

      t_bool : KW_TRUE
             | KW_FALSE



   .. py:method:: p_t_float(p) -> None

      t_float : T_FLOAT
              | T_FLOAT_EXP



   .. py:method:: p_t_int(p) -> None

      t_int : T_INT
            | T_INT_MULT



   .. py:method:: p_t_match(p) -> None

      t_match : KW_MATCH '(' val_list ')'
              | KW_MATCH



   .. py:method:: p_t_primitive_list(p) -> None

      t_primitive_list : '[' primitive_list_elements ']'



   .. py:method:: p_t_unlimited(p) -> None

      t_unlimited : T_UNLIMITED



   .. py:method:: p_val(p) -> None

      val : val_primitive
          | KEYWORD '=' val_primitive
          | KW_MATCH '=' val_primitive



   .. py:method:: p_val_list(p) -> None

      val_list : val
               | val ',' val_list
               | ',' val_list



   .. py:method:: p_val_primitive(p) -> None

      val_primitive : t_int
                    | t_float
                    | t_bool
                    | t_unlimited
                    | t_match
                    | t_primitive_list



   .. py:method:: parse(*args, **kwdargs) -> dict

      Parse a configuration string.

      Arguments are passed to the parser.

      :returns: AST as a dictionary.

      :raises Exception: If the ply parser or lexer throws an exception. Multiple exception types may be thrown.



   .. py:attribute:: lexer
      :type:  ply.lex.Lexer


   .. py:attribute:: parser
      :type:  ply.yacc.LRParser


   .. py:attribute:: tokens
      :type:  tuple[str]