# Specifying definitions for the parser

Provides classes and helper functions to describe a LaTeX context of known macros and environments, specifying how they should be parsed by `pylatexenc.latexwalker`.

Added in version 2.0: The entire module `pylatexenc.macrospec` was introduced in pylatexenc 2.0.

## Macro and environment definitions

class pylatexenc.macrospec.MacroSpec(macroname, args_parser=MacroStandardArgsParser(argspec='', optional_arg_no_space=False, args_math_mode=None), **kwargs)

  Stores the specification of a macro.

  This stores the macro name and instructions on how to parse the macro arguments.

  macroname

    The name of the macro, without the leading backslash.

  args_parser

    The parser instance that can understand this macro’s arguments. For standard LaTeX macros this is usually a `MacroStandardArgsParser` instance.

    If you specify a string, then for convenience this is interpreted as an argspec argument for `MacroStandardArgsParser` and such an instance is automatically created.

  parse_args(*args, **kwargs)

    Shorthand for calling the `args_parser`‘s parse_args() method. See `MacroStandardArgsParser`.

class pylatexenc.macrospec.EnvironmentSpec(environmentname, args_parser=MacroStandardArgsParser(argspec='', optional_arg_no_space=False, args_math_mode=None), is_math_mode=False, **kwargs)

  Stores the specification of a LaTeX environment.

  This stores the environment name and instructions on how to parse any arguments provided after `\begin{environment}<args>`.

  environmentname

    The name of the environment, i.e., the argument of `\begin{...}` and `\end{...}`.

  args_parser

    The parser instance that can understand this environment’s arguments. For standard LaTeX environment this is usually a `MacroStandardArgsParser` instance.

    If you specify a string, then for convenience this is interpreted as an argspec argument for `MacroStandardArgsParser` and such an instance is automatically created.

  is_math_mode

    A boolean that indicates whether or not the contents is to be interpreted in Math Mode. This would be True for environments like `\begin{equation}`, `\begin{align}`, etc., but False for `\begin{figure}`, etc.

  Note

  Starred variants of environments (as in `\begin{equation*}`) must not be specified using an argspec as for macros (e.g., argspec=’*’). Rather, we need to define a separate environment spec for the starred variant with the star in the name itself (`EnvironmentSpec('equation*', None)`) because the star really is part of the environment name. If you happened to use `EnvironmentSpec('equation', '*')`, then the parser would recognize the expression `\begin{equation}*` but not `\begin{equation*}`.

  parse_args(*args, **kwargs)

    Shorthand for calling the `args_parser`‘s parse_args() method. See `MacroStandardArgsParser`.

class pylatexenc.macrospec.SpecialsSpec(specials_chars, args_parser=None, **kwargs)

  Specification of a LaTeX “special char sequence”: an active char, a ligature, or some other non-macro char sequence that has a special meaning.

  For instance, ‘&’, ‘~’, and ‘``’ are considered as “specials”.

  specials_chars

    The string (one or several characters) that has a special meaning. E.g., ‘&’, ‘~’, ‘``’, etc.

  args_parser

    A parser (e.g. `MacroStandardArgsParser`) that is invoked when the specials is encountered. Can/should be set to None if the specials should not parse any arguments (e.g. ‘~’).

  parse_args(*args, **kwargs)

    Basically a shorthand for calling the `args_parser`‘s parse_args() method. See `MacroStandardArgsParser`.

    If however the py:attr:args_parser attribute is None, then this method returns None.

pylatexenc.macrospec.std_macro(macname, *args, **kwargs)

  Return a macro specification for the given macro. Syntax:

      spec = std_macro(macname, argspec)
      #  or
      spec = std_macro(macname, optarg, numargs)
      #  or
      spec = std_macro( (macname, argspec), )
      #  or
      spec = std_macro( (macname, optarg, numargs), )
      #  or
      spec = std_macro( spec ) # spec is already a `MacroSpec` -- no-op

  - macname is the name of the macro, without the leading backslash.

  - argspec is a string either characters “*”, “{” or “[”, in which star indicates an optional asterisk character (e.g. starred macro variants), each curly brace specifies a mandatory argument and each square bracket specifies an optional argument in square brackets. For example, “{{*[{” expects two mandatory arguments, then an optional star, an optional argument in square brackets, and then another mandatory argument.

    argspec may also be None, which is the same as `argspec=''`.

  - optarg may be one of True, False, or None, corresponding to these possibilities:

    - if True, the macro expects as first argument an optional argument in square brackets. Then, numargs specifies the number of additional mandatory arguments to the command, given in usual curly braces (or simply as one TeX token like a single macro)

    - if False, the macro only expects a number of mandatory arguments given by numargs. The mandatory arguments are given in usual curly braces (or simply as one TeX token like a single macro)

    - if None, then numargs is a string like argspec above. I.e., `std_macro(macname, None, argspec)` is the same as `std_macro(macname, argspec)`.

  - numargs: depends on optarg, see above.

  To make environment specifications (`EnvironmentSpec`) instead of a macro specification, use the function `std_environment()` instead.

  The helper function `std_environment()` is a shorthand for calling this function with additional keyword arguments. An optional keyword argument make_environment_spec=True to the present function may be specified to return an EnvironmentSpec instead of a MacroSpec. In this case, you can further specify the environment_is_math_mode=True|False to specify whether of not the environment represents a math mode.

pylatexenc.macrospec.std_environment(envname, *args, **kwargs)

  Return an environment specification for the given environment. Syntax:

      spec = std_environment(envname, argspec, is_math_mode=True|False)
      #  or
      spec = std_environment(envname, optarg, numargs, is_math_mode=True|False)
      #  or
      spec = std_environment( (envname, argspec), is_math_mode=True|False)
      #  or
      spec = std_environment( (envname, optarg, numargs), is_math_mode=True|False)
      #  or
      spec = std_environment( spec ) # spec is already a `EnvironmentSpec` -- no-op

  - envname is the name of the environment, i.e., the argument to `\begin{...}`.

  - argspec is a string either characters “*”, “{” or “[”, in which star indicates an optional asterisk character (e.g. starred environment variants), each curly brace specifies a mandatory argument and each square bracket specifies an optional argument in square brackets. For example, “{{*[{” expects two mandatory arguments, then an optional star, an optional argument in square brackets, and then another mandatory argument.

    argspec may also be None, which is the same as `argspec=''`.

  Note

  See `EnvironmentSpec` for an important remark about starred variants for environments. TL;DR: a starred verison of an environment is defined as a separate EnvironmentSpec with the star in the name and not using an `argspec='*'`.

  - optarg may be one of True, False, or None, corresponding to these possibilities:

    - if True, the environment expects as first argument an optional argument in square brackets. Then, numargs specifies the number of additional mandatory arguments to the command, given in usual curly braces (or simply as one TeX token like a single environment)

    - if False, the environment only expects a number of mandatory arguments given by numargs. The mandatory arguments are given in usual curly braces (or simply as one TeX token like a single environment)

    - if None, then numargs is a string like argspec above. I.e., `std_environment(envname, None, argspec)` is the same as `std_environment(envname, argspec)`.

  - numargs: depends on optarg, see above.

  - is_math_mode: if set to True, then the environment represents a math mode environment (e.g., ‘equation’, ‘align’, ‘gather’, etc.), i.e., whose contents should be parsed in an appropriate math mode. Note that is_math_mode must be given as a keyword argument, in contrast to all other arguments which must be positional (non-keyword) arguments.

pylatexenc.macrospec.std_specials(specials_chars)

  Return a latex specials specification for the given character sequence. Syntax:

      spec = std_specials(specials_chars)

  where specials_chars is the sequence of characters that has a special LaTeX meaning, e.g. `&` or `''`.

  This helper function only allows to create specs for simple specials without any argument parsing. For more complicated specials, you can instantiate a `SpecialsSpec` directly.

## Macro arguments parser

class pylatexenc.macrospec.MacroStandardArgsParser(argspec=None, optional_arg_no_space=False, args_math_mode=None, **kwargs)

  Parses the arguments to a LaTeX macro.

  This class parses a simple macro argument specification with a specified arrangement of optional and mandatory arguments.

  This class also serves as base class for more advanced argument parsers (e.g. for a `\verb+...+` macro argument parser). In such cases, subclasses should attempt to provide the most suitable argspec (and argnlist for the corresponding `ParsedMacroArgs`) for their use, if appropriate, or set them to None.

  Arguments:

  > - argspec: must be a string in which each character corresponds to an argument. The character ‘{’ represents a mandatory argument (single token or LaTeX group) and the character ‘[’ denotes an optional argument delimited by braces. The character ‘*’ denotes a possible star char at that position in the argument list, a corresponding `latexwalker.LatexCharsNode('*')` (or None if no star) will be inserted in the argument node list. For instance, the string ‘*{[[{’ would be suitable to specify the signature of the ‘\newcommand’ macro.

  >   Currently, the argspec string may only contain the characters ‘*’, ‘{’ and ‘[‘.

  >   The argspec may also be None, which is the same as specifying an empty string.

  > - optional_arg_no_space: If set to True, then an optional argument cannot have any whitespace between the preceeding tokens and the ‘[’ character. Set this to True in cases such as for `\\` in AMS-math environments, where AMS apparently introduced a patch to prevent a bracket on a new line after `\\` from being interpreted as the optional argument to `\\`.

  > - args_math_mode: Either None, or a list of the same length as argspec. If a list is given, then each item must be True, False, or None. The corresponding argument (cf. argspec) is then respectively parsed in math mode (True), in text mode (False), or with the mode unchanged (None). If args_math_mode is None, then all arguments are parsed in the same mode as the current mode.

  > - additional unrecognized keyword arguments are passed on to superclasses in case of multiple inheritance

  Attributes:

  argspec

    Argument type specification provided to the constructor.

  optional_arg_no_space

    See the corresponding constructor argument.

  args_math_mode

    See the corresponding constructor argument.

  parse_args(w, pos, parsing_state=None)

    Parse the arguments encountered at position pos in the `LatexWalker` instance w.

    You may override this function to provide custom parsing of complicated macro arguments (say, `\verb+...+`). The method will be called by keyword arguments, so the argument names should not be altered.

    The argument w is the `pylatexenc.latexwalker.LatexWalker` object that is currently parsing LaTeX code. You can call methods like w.get_goken(), w.get_latex_expression() etc., to parse and read arguments.

    The argument parsing_state is the current parsing state in the `LatexWalker` (e.g., are we currently in math mode?). See doc for `ParsingState`.

    This function should return a tuple (argd, pos, len) where:

    - argd is a `ParsedMacroArgs` instance, or an instance of a subclass of `ParsedMacroArgs`. The base parse_args() provided here returns a `ParsedMacroArgs` instance.

    - pos is the position of the first parsed content. It should be the same as the pos argument, except if there is whitespace at that position in which case the returned pos would have to be the position where the argument contents start.

    - len is the length of the parsed expression. You will probably want to continue parsing stuff at the index pos+len in the string.

class pylatexenc.macrospec.ParsedMacroArgs(argnlist=[], argspec='', **kwargs)

  Parsed representation of macro arguments.

  The base class provides a simple way of storing the arguments as a list of parsed nodes.

  This base class can be subclassed to store additional information and provide more advanced APIs to access macro arguments for certain categories of macros.

  Arguments:

  > - argnlist is a list of latexwalker nodes that represent macro arguments. If the macro arguments are too complicated to store in a list, leave this as None. (But then code that uses the latexwalker must be aware of your own API to access the macro arguments.)

  >   The difference between argnlist and the legacy nodeargs is that all options, regardless of optional or mandatory, are stored in the list argnlist with possible None‘s at places where optional arguments were not provided. Previously, whether a first optional argument was included in nodeoptarg or nodeargs depended on how the macro specification was given.

  > - argspec is a string or a list that describes how each corresponding argument in argnlist represents. If the macro arguments are too complicated to store in a list, leave this as None. For standard macros and parsed arguments this is a string with characters ‘*’, ‘[‘, ‘{’ describing an optional star argument, an optional square-bracket-delimited argument, and a mandatory argument.

  Attributes:

  argnlist

    The list of latexwalker nodes that was provided to the constructor

  argspec

    Argument type specification provided to the constructor

  legacy_nodeoptarg_nodeargs

    A tuple (nodeoptarg, nodeargs) that should be exposed as properties in `LatexMacroNode` to provide (as best as possible) compatibility with pylatexenc < 2.

    This is either (<1st optional arg node>, <list of remaining args>) if the first argument is optional and all remaining args are mandatory; or it is (None, <list of args>) for any other argument structure.

  to_json_object()

    Called when we export the node structure to JSON when running latexwalker in command-line.

    Return a representation of the current parsed arguments in an object, typically a dictionary, that can easily be exported to JSON. The object may contain latex nodes and other parsed-argument objects, as we use a custom JSON encoder that understands these types.

    Subclasses may

## Argument parser for verbatim LaTeX constructs

class pylatexenc.macrospec.VerbatimArgsParser(verbatim_arg_type, **kwargs)

  Bases: `MacroStandardArgsParser`

  Parses the arguments to various LaTeX “verbatim” constructs such as `\begin{verbatim}...\end{verbatim}` environment or `\verb+...+`.

  This class also serves to illustrate how to write custom parsers for complicated macro arguments. See also `MacroStandardArgsParser`.

  Arguments:

  verbatim_arg_type

    One of ‘verbatim-environment’ or ‘verb-macro’.

  parse_args(w, pos, parsing_state=None)

    Parse the arguments encountered at position pos in the `LatexWalker` instance w.

    You may override this function to provide custom parsing of complicated macro arguments (say, `\verb+...+`). The method will be called by keyword arguments, so the argument names should not be altered.

    The argument w is the `pylatexenc.latexwalker.LatexWalker` object that is currently parsing LaTeX code. You can call methods like w.get_goken(), w.get_latex_expression() etc., to parse and read arguments.

    The argument parsing_state is the current parsing state in the `LatexWalker` (e.g., are we currently in math mode?). See doc for `ParsingState`.

    This function should return a tuple (argd, pos, len) where:

    - argd is a `ParsedMacroArgs` instance, or an instance of a subclass of `ParsedMacroArgs`. The base parse_args() provided here returns a `ParsedMacroArgs` instance.

    - pos is the position of the first parsed content. It should be the same as the pos argument, except if there is whitespace at that position in which case the returned pos would have to be the position where the argument contents start.

    - len is the length of the parsed expression. You will probably want to continue parsing stuff at the index pos+len in the string.

class pylatexenc.macrospec.ParsedVerbatimArgs(verbatim_chars_node, verbatim_delimiters=None, **kwargs)

  Bases: `ParsedMacroArgs`

  Parsed representation of arguments to LaTeX verbatim constructs, such as `\begin{verbatim}...\end{verbatim}` or `\verb|...|`.

  Instances of ParsedVerbatimArgs are returned by the args parser `VerbatimArgsParser`.

  Arguments:

  > - verbatim_chars_node — a properly initialized `pylatexenc.latexwalker.LatexCharsNode` that stores the verbatim text provided. It is used to initialize the base class `ParsedMacroArgs` to expose a single mandatory argument with the given verbatim text. The verbatim_text attribute is initialized from this node, too.

  > - verbatim_delimiters — a 2-item tuple of characters used to delimit the verbatim arguemnt (in case of a `\verb+...+` macro) or None.

  Attributes:

  verbatim_text

    The verbatim text that was provided

  verbatim_delimiters

    If the verbatim text was specified as an argument to `\verb$...$`, then this is set to a 2-item tuple that specifies the begin and end delimiters. Otherwise, the attribute is None.

## Latex Context “Database”

class pylatexenc.macrospec.LatexContextDb(**kwargs)

  Store a database of specifications of known macros, environments, and other latex specials. This might be, e.g., how many arguments a macro accepts, or how to determine the text representation of a macro or environment.

  When used with `pylatexenc.latexwalker.LatexWalker`, the specifications describe mostly rules for parsing arguments of macros and environments, and which sequences of characters to consider as “latex specials”. Specifications for macros, environments, and other specials are stored as `MacroSpec`, `EnvironmentSpec`, and `SpecialsSpec` instances, respectively. When used with `pylatexenc.latex2text.LatexNodes2Text`, the specifications for macros, environments, and other specials are stored as `pylatexenc.latex2text.MacroTextSpec` , `pylatexenc.latex2text.EnvironmentTextSpec`, and `pylatexenc.latex2text.SpecialsTextSpec` instances, respectively.

  In fact, the objects stored in this database may be of any type, except that macro specifications must have an attribute macroname, environment specifications must have an attribute environmentname, and specials specification must have an attribute specials_chars.

  The LatexContextDb instance is meant to be (pseudo-)immutable. Once constructed and all the definitions added with `add_context_category()`, one should refrain from modifying it directly after providing it to, e.g., a `LatexWalker` object. The reason is that the latex walker keeps track of what the latex context was when parsing nodes, and modifying the context will modify that stored information, too. Instead of being tempted to modify the object, create a new one with `filter_context()`.

  See `pylatexenc.latexwalker.get_default_latex_context_db()` for the default latex context for latexwalker with a default collection of known latex macros and environments. See `pylatexenc.latex2text.get_default_latex_context_db()` for the default latex context for latex2text with a set of text replacements for a collection of known macros and environments.

  add_context_category(category, macros=[], environments=[], specials=[], prepend=False, insert_before=None, insert_after=None)

    Register a category of macro and environment specifications in the context database.

    The category name category must not already exist in the database.

    The argument macros is an iterable (e.g., a list) of macro specification objects. The argument environments is an iterable (e.g., a list) of environment spec objects. Similarly, the specials argument is an iterable of latex specials spec instances.

    If you specify prepend=True, then macro and environment lookups will prioritize this category over other categories. Categories are normally searched for in the order they are registered to the database; if you specify prepend=True, then the new category is prepended to the existing list so that it is searched first.

    If insert_before is not None, then it must be a string; the definitions are inserted in the category list immediately before the given category name, or at the beginning of the list if the given category doesn’t exist. If insert_after is not None, then it must be a string; the definitions are inserted in the category list immediately after the given category name, or at the end of the list if the given category doesn’t exist.

    You may only specify one of prepend=True, insert_before=’…’ or insert_after=’…’.

  categories()

    Return a list of valid category names that are registered in the current database context.

  filter_context(keep_categories=[], exclude_categories=[], keep_which=[])

    Return a new `LatexContextDb` instance where we only keep certain categories of macro and environment specifications.

    If keep_categories is set to a nonempty list, then the returned context will not contain any definitions that do not correspond to the specified categories.

    If exclude_categories is set to a nonempty list, then the returned context will not contain any definitions that correspond to the specified categories.

    It is explicitly fine to have category names in keep_categories and exclude_categories that don’t exist in the present object (cf. `categories()`).

    The argument keep_which, if non-empty, specifies which definitions to keep. It should be a subset of the list [‘macros’, ‘environments’, ‘specials’].

    The returned context will make a copy of the dictionaries that store the macro and environment specifications, but the specification classes (and corresponding argument parsers) might correspond to the same instances. I.e., the returned context is not a full deep copy.

  get_environment_spec(environmentname)

    Look up an environment specification by environment name. The environment name is searched for in all categories one by one and the first match is returned.

    Returns the environment spec. If the environment name was not found, we return the default environment specification set by `set_unknown_environment_spec()` or None if no such spec was set.

  get_macro_spec(macroname)

    Look up a macro specification by macro name. The macro name is searched for in all categories one by one and the first match is returned.

    Returns a macro spec instance that matches the given macroname. If the macro name was not found, we return the default macro specification set by `set_unknown_macro_spec()` or None if no such spec was set.

  get_specials_spec(specials_chars)

    Look up a “latex specials” specification by character sequence. The sequence name is searched for in all categories one by one and the first match is returned.

    If you are parsing a chunk of LaTeX code, you should use `test_for_specials()` instead. Unlike `test_for_specials()`, `get_specials_spec()` returns the first match regardless of matched length. [Rationale: we only need to worry about matching the longest specials sequence when parsing LaTeX code. Calling get_specials_spec() means one has already parsed the sequence and one is looking up additional specs on it.]

    Returns the specials spec. If the latex specials was not found, we return the default latex specials specification set by `set_unknown_specials_spec()` or None if no such spec was set.

  iter_environment_specs(categories=None)

    Yield the environment specs corresponding to all environments in the given categories.

    If categories is None, then the known environment specs from all categories are provided in one long iterable sequence. Otherwise, categories should be a list or iterable of category names (e.g., ‘latex-base’) of environment specs to return.

    The environment specs from the different categories specified are concatenated into one long sequence which is yielded spec by spec.

  iter_macro_specs(categories=None)

    Yield the macro specs corresponding to all macros in the given categories.

    If categories is None, then the known macro specs from all categories are provided in one long iterable sequence. Otherwise, categories should be a list or iterable of category names (e.g., ‘latex-base’) of macro specs to return.

    The macro specs from the different categories specified are concatenated into one long sequence which is yielded spec by spec.

  iter_specials_specs(categories=None)

    Yield the specials specs corresponding to all environments in the given categories.

    If categories is None, then the known specials specs from all categories are provided in one long iterable sequence. Otherwise, categories should be a list or iterable of category names (e.g., ‘latex-base’) of specials specs to return.

    The specials specs from the different categories specified are concatenated into one long sequence which is yielded spec by spec.

  set_unknown_environment_spec(environmentspec)

    Set the environment spec to use when encountering a LaTeX environment that is not in the database.

  set_unknown_macro_spec(macrospec)

    Set the macro spec to use when encountering a macro that is not in the database.

  set_unknown_specials_spec(specialsspec)

    Set the latex specials spec to use when encountering a LaTeX environment that is not in the database.

  test_for_specials(s, pos, parsing_state=None)

    Test the given position in the string for any LaTeX specials. The lookup proceeds by searching for in all categories one by one and the first match is returned, except that the longest match accross all categories is returned. For instance, a match of ‘``’ in a later category will take precedence over a match of ‘`’ in a earlier-searched category.

    Returns a specials spec instance, or None if no specials are detected at the position pos.