Nexus File Manager
v2.0
🏠
Dashboard
⚡
System
🌐
›
opt
›
alt
›
python37
›
share
›
doc
›
alt-python37-pyparsing-doc
›
html
Quick:
⬆️ Parent
🌐 Root
🏠 Home
🌍 WWW
📁 Temp
⚙️ Etc
📤 Upload
📁 Create
⚡ WordPress Admin
🔄 Refresh
✏️ pyparsing.html
← Back
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <meta http-equiv="X-UA-Compatible" content="IE=Edge" /> <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <title>pyparsing module — PyParsing 3.0.9 documentation</title> <link rel="stylesheet" href="_static/alabaster.css" type="text/css" /> <link rel="stylesheet" href="_static/pygments.css" type="text/css" /> <script type="text/javascript" id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script> <script type="text/javascript" src="_static/jquery.js"></script> <script type="text/javascript" src="_static/underscore.js"></script> <script type="text/javascript" src="_static/doctools.js"></script> <link rel="index" title="Index" href="genindex.html" /> <link rel="search" title="Search" href="search.html" /> <link rel="next" title="Contributor Covenant Code of Conduct" href="CODE_OF_CONDUCT.html" /> <link rel="prev" title="pyparsing" href="modules.html" /> <link rel="stylesheet" href="_static/custom.css" type="text/css" /> <meta name="viewport" content="width=device-width, initial-scale=0.9, maximum-scale=0.9" /> </head><body> <div class="document"> <div class="documentwrapper"> <div class="bodywrapper"> <div class="body" role="main"> <div class="section" id="module-pyparsing"> <span id="pyparsing-module"></span><h1>pyparsing module<a class="headerlink" href="#module-pyparsing" title="Permalink to this headline">¶</a></h1> <div class="section" id="pyparsing-module-classes-and-methods-to-define-and-execute-parsing-grammars"> <h2>pyparsing module - Classes and methods to define and execute parsing grammars<a class="headerlink" href="#pyparsing-module-classes-and-methods-to-define-and-execute-parsing-grammars" title="Permalink to this headline">¶</a></h2> <p>The pyparsing module is an alternative approach to creating and executing simple grammars, vs. the traditional lex/yacc approach, or the use of regular expressions. With pyparsing, you don’t need to learn a new syntax for defining grammars or matching expressions - the parsing module provides a library of classes that you use to construct the grammar directly in Python.</p> <p>Here is a program to parse “Hello, World!” (or any greeting of the form <code class="docutils literal notranslate"><span class="pre">"<salutation>,</span> <span class="pre"><addressee>!"</span></code>), built up using <a class="reference internal" href="#pyparsing.Word" title="pyparsing.Word"><code class="xref py py-class docutils literal notranslate"><span class="pre">Word</span></code></a>, <a class="reference internal" href="#pyparsing.Literal" title="pyparsing.Literal"><code class="xref py py-class docutils literal notranslate"><span class="pre">Literal</span></code></a>, and <a class="reference internal" href="#pyparsing.And" title="pyparsing.And"><code class="xref py py-class docutils literal notranslate"><span class="pre">And</span></code></a> elements (the <a class="reference internal" href="#pyparsing.ParserElement.__add__" title="pyparsing.ParserElement.__add__"><code class="xref py py-meth docutils literal notranslate"><span class="pre">'+'</span></code></a> operators create <a class="reference internal" href="#pyparsing.And" title="pyparsing.And"><code class="xref py py-class docutils literal notranslate"><span class="pre">And</span></code></a> expressions, and the strings are auto-converted to <a class="reference internal" href="#pyparsing.Literal" title="pyparsing.Literal"><code class="xref py py-class docutils literal notranslate"><span class="pre">Literal</span></code></a> expressions):</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">pyparsing</span> <span class="k">import</span> <span class="n">Word</span><span class="p">,</span> <span class="n">alphas</span> <span class="c1"># define grammar of a greeting</span> <span class="n">greet</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)</span> <span class="o">+</span> <span class="s2">","</span> <span class="o">+</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)</span> <span class="o">+</span> <span class="s2">"!"</span> <span class="n">hello</span> <span class="o">=</span> <span class="s2">"Hello, World!"</span> <span class="nb">print</span><span class="p">(</span><span class="n">hello</span><span class="p">,</span> <span class="s2">"->"</span><span class="p">,</span> <span class="n">greet</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="n">hello</span><span class="p">))</span> </pre></div> </div> <p>The program outputs the following:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span>Hello, World! -> ['Hello', ',', 'World', '!'] </pre></div> </div> <p>The Python representation of the grammar is quite readable, owing to the self-explanatory class names, and the use of <a class="reference internal" href="#pyparsing.And" title="pyparsing.And"><code class="xref py py-class docutils literal notranslate"><span class="pre">'+'</span></code></a>, <a class="reference internal" href="#pyparsing.MatchFirst" title="pyparsing.MatchFirst"><code class="xref py py-class docutils literal notranslate"><span class="pre">'|'</span></code></a>, <a class="reference internal" href="#pyparsing.Or" title="pyparsing.Or"><code class="xref py py-class docutils literal notranslate"><span class="pre">'^'</span></code></a> and <a class="reference internal" href="#pyparsing.Each" title="pyparsing.Each"><code class="xref py py-class docutils literal notranslate"><span class="pre">'&'</span></code></a> operators.</p> <p>The <a class="reference internal" href="#pyparsing.ParseResults" title="pyparsing.ParseResults"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParseResults</span></code></a> object returned from <a class="reference internal" href="#pyparsing.ParserElement.parseString" title="pyparsing.ParserElement.parseString"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement.parseString</span></code></a> can be accessed as a nested list, a dictionary, or an object with named attributes.</p> <p>The pyparsing module handles some of the problems that are typically vexing when writing text parsers:</p> <blockquote> <div><ul class="simple"> <li>extra or missing whitespace (the above program will also handle “Hello,World!”, “Hello , World !”, etc.)</li> <li>quoted strings</li> <li>embedded comments</li> </ul> </div></blockquote> <div class="section" id="getting-started"> <h3>Getting Started -<a class="headerlink" href="#getting-started" title="Permalink to this headline">¶</a></h3> <p>Visit the classes <a class="reference internal" href="#pyparsing.ParserElement" title="pyparsing.ParserElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement</span></code></a> and <a class="reference internal" href="#pyparsing.ParseResults" title="pyparsing.ParseResults"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParseResults</span></code></a> to see the base classes that most other pyparsing classes inherit from. Use the docstrings for examples of how to:</p> <blockquote> <div><ul class="simple"> <li>construct literal match expressions from <a class="reference internal" href="#pyparsing.Literal" title="pyparsing.Literal"><code class="xref py py-class docutils literal notranslate"><span class="pre">Literal</span></code></a> and <a class="reference internal" href="#pyparsing.CaselessLiteral" title="pyparsing.CaselessLiteral"><code class="xref py py-class docutils literal notranslate"><span class="pre">CaselessLiteral</span></code></a> classes</li> <li>construct character word-group expressions using the <a class="reference internal" href="#pyparsing.Word" title="pyparsing.Word"><code class="xref py py-class docutils literal notranslate"><span class="pre">Word</span></code></a> class</li> <li>see how to create repetitive expressions using <a class="reference internal" href="#pyparsing.ZeroOrMore" title="pyparsing.ZeroOrMore"><code class="xref py py-class docutils literal notranslate"><span class="pre">ZeroOrMore</span></code></a> and <a class="reference internal" href="#pyparsing.OneOrMore" title="pyparsing.OneOrMore"><code class="xref py py-class docutils literal notranslate"><span class="pre">OneOrMore</span></code></a> classes</li> <li>use <a class="reference internal" href="#pyparsing.And" title="pyparsing.And"><code class="xref py py-class docutils literal notranslate"><span class="pre">'+'</span></code></a>, <a class="reference internal" href="#pyparsing.MatchFirst" title="pyparsing.MatchFirst"><code class="xref py py-class docutils literal notranslate"><span class="pre">'|'</span></code></a>, <a class="reference internal" href="#pyparsing.Or" title="pyparsing.Or"><code class="xref py py-class docutils literal notranslate"><span class="pre">'^'</span></code></a>, and <a class="reference internal" href="#pyparsing.Each" title="pyparsing.Each"><code class="xref py py-class docutils literal notranslate"><span class="pre">'&'</span></code></a> operators to combine simple expressions into more complex ones</li> <li>associate names with your parsed results using <a class="reference internal" href="#pyparsing.ParserElement.setResultsName" title="pyparsing.ParserElement.setResultsName"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement.setResultsName</span></code></a></li> <li>access the parsed data, which is returned as a <a class="reference internal" href="#pyparsing.ParseResults" title="pyparsing.ParseResults"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParseResults</span></code></a> object</li> <li>find some helpful expression short-cuts like <a class="reference internal" href="#pyparsing.delimitedList" title="pyparsing.delimitedList"><code class="xref py py-class docutils literal notranslate"><span class="pre">delimitedList</span></code></a> and <a class="reference internal" href="#pyparsing.oneOf" title="pyparsing.oneOf"><code class="xref py py-class docutils literal notranslate"><span class="pre">oneOf</span></code></a></li> <li>find more useful common expressions in the <a class="reference internal" href="#pyparsing.pyparsing_common" title="pyparsing.pyparsing_common"><code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing_common</span></code></a> namespace class</li> </ul> </div></blockquote> <dl class="class"> <dt id="pyparsing.__compat__"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">__compat__</code><a class="headerlink" href="#pyparsing.__compat__" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.util.__config_flags</span></code></p> <p>A cross-version compatibility configuration for pyparsing features that will be released in a future version. By setting values in this configuration to True, those features can be enabled in prior versions for compatibility development and testing.</p> <ul class="simple"> <li><code class="docutils literal notranslate"><span class="pre">collect_all_And_tokens</span></code> - flag to enable fix for Issue #63 that fixes erroneous grouping of results names when an <a class="reference internal" href="#pyparsing.And" title="pyparsing.And"><code class="xref py py-class docutils literal notranslate"><span class="pre">And</span></code></a> expression is nested within an <a class="reference internal" href="#pyparsing.Or" title="pyparsing.Or"><code class="xref py py-class docutils literal notranslate"><span class="pre">Or</span></code></a> or <a class="reference internal" href="#pyparsing.MatchFirst" title="pyparsing.MatchFirst"><code class="xref py py-class docutils literal notranslate"><span class="pre">MatchFirst</span></code></a>; maintained for compatibility, but setting to <code class="docutils literal notranslate"><span class="pre">False</span></code> no longer restores pre-2.3.1 behavior</li> </ul> </dd></dl> <dl class="class"> <dt id="pyparsing.__diag__"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">__diag__</code><a class="headerlink" href="#pyparsing.__diag__" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.util.__config_flags</span></code></p> </dd></dl> <dl class="class"> <dt id="pyparsing.And"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">And</code><span class="sig-paren">(</span><em>exprs_arg: Iterable[pyparsing.core.ParserElement], savelist: bool = True</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.And" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.ParseExpression</span></code></p> <p>Requires all given <a class="reference internal" href="#pyparsing.ParseExpression" title="pyparsing.ParseExpression"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParseExpression</span></code></a> s to be found in the given order. Expressions may be separated by whitespace. May be constructed using the <code class="docutils literal notranslate"><span class="pre">'+'</span></code> operator. May also be constructed using the <code class="docutils literal notranslate"><span class="pre">'-'</span></code> operator, which will suppress backtracking.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">integer</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="n">name_expr</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span> <span class="n">expr</span> <span class="o">=</span> <span class="n">And</span><span class="p">([</span><span class="n">integer</span><span class="p">(</span><span class="s2">"id"</span><span class="p">),</span> <span class="n">name_expr</span><span class="p">(</span><span class="s2">"name"</span><span class="p">),</span> <span class="n">integer</span><span class="p">(</span><span class="s2">"age"</span><span class="p">)])</span> <span class="c1"># more easily written as:</span> <span class="n">expr</span> <span class="o">=</span> <span class="n">integer</span><span class="p">(</span><span class="s2">"id"</span><span class="p">)</span> <span class="o">+</span> <span class="n">name_expr</span><span class="p">(</span><span class="s2">"name"</span><span class="p">)</span> <span class="o">+</span> <span class="n">integer</span><span class="p">(</span><span class="s2">"age"</span><span class="p">)</span> </pre></div> </div> <dl class="method"> <dt id="pyparsing.And.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>exprs_arg: Iterable[pyparsing.core.ParserElement], savelist: bool = True</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.And.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.AtLineStart"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">AtLineStart</code><span class="sig-paren">(</span><em>expr: Union[pyparsing.core.ParserElement, str]</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.AtLineStart" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.ParseElementEnhance</span></code></p> <p>Matches if an expression matches at the beginning of a line within the parse string</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">test</span> <span class="o">=</span> <span class="s1">'''</span><span class="se">\</span> <span class="s1">AAA this line</span> <span class="s1">AAA and this line</span> <span class="s1"> AAA but not this one</span> <span class="s1">B AAA and definitely not this one</span> <span class="s1">'''</span> <span class="k">for</span> <span class="n">t</span> <span class="ow">in</span> <span class="p">(</span><span class="n">AtLineStart</span><span class="p">(</span><span class="s1">'AAA'</span><span class="p">)</span> <span class="o">+</span> <span class="n">restOfLine</span><span class="p">)</span><span class="o">.</span><span class="n">search_string</span><span class="p">(</span><span class="n">test</span><span class="p">):</span> <span class="nb">print</span><span class="p">(</span><span class="n">t</span><span class="p">)</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="s1">'AAA'</span><span class="p">,</span> <span class="s1">' this line'</span><span class="p">]</span> <span class="p">[</span><span class="s1">'AAA'</span><span class="p">,</span> <span class="s1">' and this line'</span><span class="p">]</span> </pre></div> </div> <dl class="method"> <dt id="pyparsing.AtLineStart.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>expr: Union[pyparsing.core.ParserElement, str]</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.AtLineStart.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.AtStringStart"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">AtStringStart</code><span class="sig-paren">(</span><em>expr: Union[pyparsing.core.ParserElement, str]</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.AtStringStart" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.ParseElementEnhance</span></code></p> <p>Matches if expression matches at the beginning of the parse string:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">AtStringStart</span><span class="p">(</span><span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">))</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"123"</span><span class="p">)</span> <span class="c1"># prints ["123"]</span> <span class="n">AtStringStart</span><span class="p">(</span><span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">))</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">" 123"</span><span class="p">)</span> <span class="c1"># raises ParseException</span> </pre></div> </div> <dl class="method"> <dt id="pyparsing.AtStringStart.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>expr: Union[pyparsing.core.ParserElement, str]</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.AtStringStart.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.CaselessKeyword"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">CaselessKeyword</code><span class="sig-paren">(</span><em>match_string: str = ''</em>, <em>ident_chars: Union[str</em>, <em>NoneType] = None</em>, <em>*</em>, <em>matchString: str = ''</em>, <em>identChars: Union[str</em>, <em>NoneType] = None</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.CaselessKeyword" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.Keyword</span></code></p> <p>Caseless version of <a class="reference internal" href="#pyparsing.Keyword" title="pyparsing.Keyword"><code class="xref py py-class docutils literal notranslate"><span class="pre">Keyword</span></code></a>.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">CaselessKeyword</span><span class="p">(</span><span class="s2">"CMD"</span><span class="p">)[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"cmd CMD Cmd10"</span><span class="p">)</span> <span class="c1"># -> ['CMD', 'CMD']</span> </pre></div> </div> <p>(Contrast with example for <a class="reference internal" href="#pyparsing.CaselessLiteral" title="pyparsing.CaselessLiteral"><code class="xref py py-class docutils literal notranslate"><span class="pre">CaselessLiteral</span></code></a>.)</p> <dl class="method"> <dt id="pyparsing.CaselessKeyword.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>match_string: str = ''</em>, <em>ident_chars: Union[str</em>, <em>NoneType] = None</em>, <em>*</em>, <em>matchString: str = ''</em>, <em>identChars: Union[str</em>, <em>NoneType] = None</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.CaselessKeyword.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.CaselessLiteral"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">CaselessLiteral</code><span class="sig-paren">(</span><em>match_string: str = ''</em>, <em>*</em>, <em>matchString: str = ''</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.CaselessLiteral" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.Literal</span></code></p> <p>Token to match a specified string, ignoring case of letters. Note: the matched results will always be in the case of the given match string, NOT the case of the input text.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">CaselessLiteral</span><span class="p">(</span><span class="s2">"CMD"</span><span class="p">)[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"cmd CMD Cmd10"</span><span class="p">)</span> <span class="c1"># -> ['CMD', 'CMD', 'CMD']</span> </pre></div> </div> <p>(Contrast with example for <a class="reference internal" href="#pyparsing.CaselessKeyword" title="pyparsing.CaselessKeyword"><code class="xref py py-class docutils literal notranslate"><span class="pre">CaselessKeyword</span></code></a>.)</p> <dl class="method"> <dt id="pyparsing.CaselessLiteral.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>match_string: str = ''</em>, <em>*</em>, <em>matchString: str = ''</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.CaselessLiteral.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.CharsNotIn"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">CharsNotIn</code><span class="sig-paren">(</span><em>not_chars: str = ''</em>, <em>min: int = 1</em>, <em>max: int = 0</em>, <em>exact: int = 0</em>, <em>*</em>, <em>notChars: str = ''</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.CharsNotIn" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.Token</span></code></p> <p>Token for matching words composed of characters <em>not</em> in a given set (will include whitespace in matched characters if not listed in the provided exclusion set - see example). Defined with string containing all disallowed characters, and an optional minimum, maximum, and/or exact length. The default value for <code class="docutils literal notranslate"><span class="pre">min</span></code> is 1 (a minimum value < 1 is not valid); the default values for <code class="docutils literal notranslate"><span class="pre">max</span></code> and <code class="docutils literal notranslate"><span class="pre">exact</span></code> are 0, meaning no maximum or exact length restriction.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># define a comma-separated-value as anything that is not a ','</span> <span class="n">csv_value</span> <span class="o">=</span> <span class="n">CharsNotIn</span><span class="p">(</span><span class="s1">','</span><span class="p">)</span> <span class="nb">print</span><span class="p">(</span><span class="n">delimited_list</span><span class="p">(</span><span class="n">csv_value</span><span class="p">)</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"dkls,lsdkjf,s12 34,@!#,213"</span><span class="p">))</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="s1">'dkls'</span><span class="p">,</span> <span class="s1">'lsdkjf'</span><span class="p">,</span> <span class="s1">'s12 34'</span><span class="p">,</span> <span class="s1">'@!#'</span><span class="p">,</span> <span class="s1">'213'</span><span class="p">]</span> </pre></div> </div> <dl class="method"> <dt id="pyparsing.CharsNotIn.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>not_chars: str = ''</em>, <em>min: int = 1</em>, <em>max: int = 0</em>, <em>exact: int = 0</em>, <em>*</em>, <em>notChars: str = ''</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.CharsNotIn.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.Combine"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">Combine</code><span class="sig-paren">(</span><em>expr: pyparsing.core.ParserElement</em>, <em>join_string: str = ''</em>, <em>adjacent: bool = True</em>, <em>*</em>, <em>joinString: Union[str</em>, <em>NoneType] = None</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.Combine" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.TokenConverter</span></code></p> <p>Converter to concatenate all matching tokens to a single string. By default, the matching patterns must also be contiguous in the input string; this can be disabled by specifying <code class="docutils literal notranslate"><span class="pre">'adjacent=False'</span></code> in the constructor.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">real</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="o">+</span> <span class="s1">'.'</span> <span class="o">+</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="nb">print</span><span class="p">(</span><span class="n">real</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s1">'3.1416'</span><span class="p">))</span> <span class="c1"># -> ['3', '.', '1416']</span> <span class="c1"># will also erroneously match the following</span> <span class="nb">print</span><span class="p">(</span><span class="n">real</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s1">'3. 1416'</span><span class="p">))</span> <span class="c1"># -> ['3', '.', '1416']</span> <span class="n">real</span> <span class="o">=</span> <span class="n">Combine</span><span class="p">(</span><span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="o">+</span> <span class="s1">'.'</span> <span class="o">+</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">))</span> <span class="nb">print</span><span class="p">(</span><span class="n">real</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s1">'3.1416'</span><span class="p">))</span> <span class="c1"># -> ['3.1416']</span> <span class="c1"># no match when there are internal spaces</span> <span class="nb">print</span><span class="p">(</span><span class="n">real</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s1">'3. 1416'</span><span class="p">))</span> <span class="c1"># -> Exception: Expected W:(0123...)</span> </pre></div> </div> <dl class="method"> <dt id="pyparsing.Combine.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>expr: pyparsing.core.ParserElement</em>, <em>join_string: str = ''</em>, <em>adjacent: bool = True</em>, <em>*</em>, <em>joinString: Union[str</em>, <em>NoneType] = None</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.Combine.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.Combine.ignore"> <code class="descname">ignore</code><span class="sig-paren">(</span><em>other</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.Combine.ignore" title="Permalink to this definition">¶</a></dt> <dd><p>Define expression to be ignored (e.g., comments) while doing pattern matching; may be called repeatedly, to define multiple comment or other ignorable patterns.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">patt</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span> <span class="n">patt</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s1">'ablaj /* comment */ lskjd'</span><span class="p">)</span> <span class="c1"># -> ['ablaj']</span> <span class="n">patt</span><span class="o">.</span><span class="n">ignore</span><span class="p">(</span><span class="n">c_style_comment</span><span class="p">)</span> <span class="n">patt</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s1">'ablaj /* comment */ lskjd'</span><span class="p">)</span> <span class="c1"># -> ['ablaj', 'lskjd']</span> </pre></div> </div> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.Dict"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">Dict</code><span class="sig-paren">(</span><em>expr: pyparsing.core.ParserElement</em>, <em>asdict: bool = False</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.Dict" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.TokenConverter</span></code></p> <p>Converter to return a repetitive expression as a list, but also as a dictionary. Each element can also be referenced using the first token in the expression as its key. Useful for tabular report scraping when the first column can be used as a item key.</p> <p>The optional <code class="docutils literal notranslate"><span class="pre">asdict</span></code> argument when set to True will return the parsed tokens as a Python dict instead of a pyparsing ParseResults.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">data_word</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)</span> <span class="n">label</span> <span class="o">=</span> <span class="n">data_word</span> <span class="o">+</span> <span class="n">FollowedBy</span><span class="p">(</span><span class="s1">':'</span><span class="p">)</span> <span class="n">text</span> <span class="o">=</span> <span class="s2">"shape: SQUARE posn: upper left color: light blue texture: burlap"</span> <span class="n">attr_expr</span> <span class="o">=</span> <span class="p">(</span><span class="n">label</span> <span class="o">+</span> <span class="n">Suppress</span><span class="p">(</span><span class="s1">':'</span><span class="p">)</span> <span class="o">+</span> <span class="n">OneOrMore</span><span class="p">(</span><span class="n">data_word</span><span class="p">,</span> <span class="n">stop_on</span><span class="o">=</span><span class="n">label</span><span class="p">)</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="s1">' '</span><span class="o">.</span><span class="n">join</span><span class="p">))</span> <span class="c1"># print attributes as plain groups</span> <span class="nb">print</span><span class="p">(</span><span class="n">attr_expr</span><span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="n">text</span><span class="p">)</span><span class="o">.</span><span class="n">dump</span><span class="p">())</span> <span class="c1"># instead of OneOrMore(expr), parse using Dict(Group(expr)[1, ...]) - Dict will auto-assign names</span> <span class="n">result</span> <span class="o">=</span> <span class="n">Dict</span><span class="p">(</span><span class="n">Group</span><span class="p">(</span><span class="n">attr_expr</span><span class="p">)[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">])</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="n">text</span><span class="p">)</span> <span class="nb">print</span><span class="p">(</span><span class="n">result</span><span class="o">.</span><span class="n">dump</span><span class="p">())</span> <span class="c1"># access named fields as dict entries, or output as dict</span> <span class="nb">print</span><span class="p">(</span><span class="n">result</span><span class="p">[</span><span class="s1">'shape'</span><span class="p">])</span> <span class="nb">print</span><span class="p">(</span><span class="n">result</span><span class="o">.</span><span class="n">as_dict</span><span class="p">())</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="s1">'shape'</span><span class="p">,</span> <span class="s1">'SQUARE'</span><span class="p">,</span> <span class="s1">'posn'</span><span class="p">,</span> <span class="s1">'upper left'</span><span class="p">,</span> <span class="s1">'color'</span><span class="p">,</span> <span class="s1">'light blue'</span><span class="p">,</span> <span class="s1">'texture'</span><span class="p">,</span> <span class="s1">'burlap'</span><span class="p">]</span> <span class="p">[[</span><span class="s1">'shape'</span><span class="p">,</span> <span class="s1">'SQUARE'</span><span class="p">],</span> <span class="p">[</span><span class="s1">'posn'</span><span class="p">,</span> <span class="s1">'upper left'</span><span class="p">],</span> <span class="p">[</span><span class="s1">'color'</span><span class="p">,</span> <span class="s1">'light blue'</span><span class="p">],</span> <span class="p">[</span><span class="s1">'texture'</span><span class="p">,</span> <span class="s1">'burlap'</span><span class="p">]]</span> <span class="o">-</span> <span class="n">color</span><span class="p">:</span> <span class="s1">'light blue'</span> <span class="o">-</span> <span class="n">posn</span><span class="p">:</span> <span class="s1">'upper left'</span> <span class="o">-</span> <span class="n">shape</span><span class="p">:</span> <span class="s1">'SQUARE'</span> <span class="o">-</span> <span class="n">texture</span><span class="p">:</span> <span class="s1">'burlap'</span> <span class="n">SQUARE</span> <span class="p">{</span><span class="s1">'color'</span><span class="p">:</span> <span class="s1">'light blue'</span><span class="p">,</span> <span class="s1">'posn'</span><span class="p">:</span> <span class="s1">'upper left'</span><span class="p">,</span> <span class="s1">'texture'</span><span class="p">:</span> <span class="s1">'burlap'</span><span class="p">,</span> <span class="s1">'shape'</span><span class="p">:</span> <span class="s1">'SQUARE'</span><span class="p">}</span> </pre></div> </div> <p>See more examples at <a class="reference internal" href="#pyparsing.ParseResults" title="pyparsing.ParseResults"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParseResults</span></code></a> of accessing fields by results name.</p> <dl class="method"> <dt id="pyparsing.Dict.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>expr: pyparsing.core.ParserElement</em>, <em>asdict: bool = False</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.Dict.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.Each"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">Each</code><span class="sig-paren">(</span><em>exprs: Iterable[pyparsing.core.ParserElement], savelist: bool = True</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.Each" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.ParseExpression</span></code></p> <p>Requires all given <a class="reference internal" href="#pyparsing.ParseExpression" title="pyparsing.ParseExpression"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParseExpression</span></code></a> s to be found, but in any order. Expressions may be separated by whitespace.</p> <p>May be constructed using the <code class="docutils literal notranslate"><span class="pre">'&'</span></code> operator.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">color</span> <span class="o">=</span> <span class="n">one_of</span><span class="p">(</span><span class="s2">"RED ORANGE YELLOW GREEN BLUE PURPLE BLACK WHITE BROWN"</span><span class="p">)</span> <span class="n">shape_type</span> <span class="o">=</span> <span class="n">one_of</span><span class="p">(</span><span class="s2">"SQUARE CIRCLE TRIANGLE STAR HEXAGON OCTAGON"</span><span class="p">)</span> <span class="n">integer</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="n">shape_attr</span> <span class="o">=</span> <span class="s2">"shape:"</span> <span class="o">+</span> <span class="n">shape_type</span><span class="p">(</span><span class="s2">"shape"</span><span class="p">)</span> <span class="n">posn_attr</span> <span class="o">=</span> <span class="s2">"posn:"</span> <span class="o">+</span> <span class="n">Group</span><span class="p">(</span><span class="n">integer</span><span class="p">(</span><span class="s2">"x"</span><span class="p">)</span> <span class="o">+</span> <span class="s1">','</span> <span class="o">+</span> <span class="n">integer</span><span class="p">(</span><span class="s2">"y"</span><span class="p">))(</span><span class="s2">"posn"</span><span class="p">)</span> <span class="n">color_attr</span> <span class="o">=</span> <span class="s2">"color:"</span> <span class="o">+</span> <span class="n">color</span><span class="p">(</span><span class="s2">"color"</span><span class="p">)</span> <span class="n">size_attr</span> <span class="o">=</span> <span class="s2">"size:"</span> <span class="o">+</span> <span class="n">integer</span><span class="p">(</span><span class="s2">"size"</span><span class="p">)</span> <span class="c1"># use Each (using operator '&') to accept attributes in any order</span> <span class="c1"># (shape and posn are required, color and size are optional)</span> <span class="n">shape_spec</span> <span class="o">=</span> <span class="n">shape_attr</span> <span class="o">&</span> <span class="n">posn_attr</span> <span class="o">&</span> <span class="n">Opt</span><span class="p">(</span><span class="n">color_attr</span><span class="p">)</span> <span class="o">&</span> <span class="n">Opt</span><span class="p">(</span><span class="n">size_attr</span><span class="p">)</span> <span class="n">shape_spec</span><span class="o">.</span><span class="n">run_tests</span><span class="p">(</span><span class="s1">'''</span> <span class="s1"> shape: SQUARE color: BLACK posn: 100, 120</span> <span class="s1"> shape: CIRCLE size: 50 color: BLUE posn: 50,80</span> <span class="s1"> color:GREEN size:20 shape:TRIANGLE posn:20,40</span> <span class="s1"> '''</span> <span class="p">)</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">shape</span><span class="p">:</span> <span class="n">SQUARE</span> <span class="n">color</span><span class="p">:</span> <span class="n">BLACK</span> <span class="n">posn</span><span class="p">:</span> <span class="mi">100</span><span class="p">,</span> <span class="mi">120</span> <span class="p">[</span><span class="s1">'shape:'</span><span class="p">,</span> <span class="s1">'SQUARE'</span><span class="p">,</span> <span class="s1">'color:'</span><span class="p">,</span> <span class="s1">'BLACK'</span><span class="p">,</span> <span class="s1">'posn:'</span><span class="p">,</span> <span class="p">[</span><span class="s1">'100'</span><span class="p">,</span> <span class="s1">','</span><span class="p">,</span> <span class="s1">'120'</span><span class="p">]]</span> <span class="o">-</span> <span class="n">color</span><span class="p">:</span> <span class="n">BLACK</span> <span class="o">-</span> <span class="n">posn</span><span class="p">:</span> <span class="p">[</span><span class="s1">'100'</span><span class="p">,</span> <span class="s1">','</span><span class="p">,</span> <span class="s1">'120'</span><span class="p">]</span> <span class="o">-</span> <span class="n">x</span><span class="p">:</span> <span class="mi">100</span> <span class="o">-</span> <span class="n">y</span><span class="p">:</span> <span class="mi">120</span> <span class="o">-</span> <span class="n">shape</span><span class="p">:</span> <span class="n">SQUARE</span> <span class="n">shape</span><span class="p">:</span> <span class="n">CIRCLE</span> <span class="n">size</span><span class="p">:</span> <span class="mi">50</span> <span class="n">color</span><span class="p">:</span> <span class="n">BLUE</span> <span class="n">posn</span><span class="p">:</span> <span class="mi">50</span><span class="p">,</span><span class="mi">80</span> <span class="p">[</span><span class="s1">'shape:'</span><span class="p">,</span> <span class="s1">'CIRCLE'</span><span class="p">,</span> <span class="s1">'size:'</span><span class="p">,</span> <span class="s1">'50'</span><span class="p">,</span> <span class="s1">'color:'</span><span class="p">,</span> <span class="s1">'BLUE'</span><span class="p">,</span> <span class="s1">'posn:'</span><span class="p">,</span> <span class="p">[</span><span class="s1">'50'</span><span class="p">,</span> <span class="s1">','</span><span class="p">,</span> <span class="s1">'80'</span><span class="p">]]</span> <span class="o">-</span> <span class="n">color</span><span class="p">:</span> <span class="n">BLUE</span> <span class="o">-</span> <span class="n">posn</span><span class="p">:</span> <span class="p">[</span><span class="s1">'50'</span><span class="p">,</span> <span class="s1">','</span><span class="p">,</span> <span class="s1">'80'</span><span class="p">]</span> <span class="o">-</span> <span class="n">x</span><span class="p">:</span> <span class="mi">50</span> <span class="o">-</span> <span class="n">y</span><span class="p">:</span> <span class="mi">80</span> <span class="o">-</span> <span class="n">shape</span><span class="p">:</span> <span class="n">CIRCLE</span> <span class="o">-</span> <span class="n">size</span><span class="p">:</span> <span class="mi">50</span> <span class="n">color</span><span class="p">:</span> <span class="n">GREEN</span> <span class="n">size</span><span class="p">:</span> <span class="mi">20</span> <span class="n">shape</span><span class="p">:</span> <span class="n">TRIANGLE</span> <span class="n">posn</span><span class="p">:</span> <span class="mi">20</span><span class="p">,</span><span class="mi">40</span> <span class="p">[</span><span class="s1">'color:'</span><span class="p">,</span> <span class="s1">'GREEN'</span><span class="p">,</span> <span class="s1">'size:'</span><span class="p">,</span> <span class="s1">'20'</span><span class="p">,</span> <span class="s1">'shape:'</span><span class="p">,</span> <span class="s1">'TRIANGLE'</span><span class="p">,</span> <span class="s1">'posn:'</span><span class="p">,</span> <span class="p">[</span><span class="s1">'20'</span><span class="p">,</span> <span class="s1">','</span><span class="p">,</span> <span class="s1">'40'</span><span class="p">]]</span> <span class="o">-</span> <span class="n">color</span><span class="p">:</span> <span class="n">GREEN</span> <span class="o">-</span> <span class="n">posn</span><span class="p">:</span> <span class="p">[</span><span class="s1">'20'</span><span class="p">,</span> <span class="s1">','</span><span class="p">,</span> <span class="s1">'40'</span><span class="p">]</span> <span class="o">-</span> <span class="n">x</span><span class="p">:</span> <span class="mi">20</span> <span class="o">-</span> <span class="n">y</span><span class="p">:</span> <span class="mi">40</span> <span class="o">-</span> <span class="n">shape</span><span class="p">:</span> <span class="n">TRIANGLE</span> <span class="o">-</span> <span class="n">size</span><span class="p">:</span> <span class="mi">20</span> </pre></div> </div> <dl class="method"> <dt id="pyparsing.Each.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>exprs: Iterable[pyparsing.core.ParserElement], savelist: bool = True</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.Each.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.Empty"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">Empty</code><a class="headerlink" href="#pyparsing.Empty" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.Token</span></code></p> <p>An empty token, will always match.</p> <dl class="method"> <dt id="pyparsing.Empty.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.Empty.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.FollowedBy"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">FollowedBy</code><span class="sig-paren">(</span><em>expr: Union[pyparsing.core.ParserElement, str]</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.FollowedBy" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.ParseElementEnhance</span></code></p> <p>Lookahead matching of the given parse expression. <code class="docutils literal notranslate"><span class="pre">FollowedBy</span></code> does <em>not</em> advance the parsing position within the input string, it only verifies that the specified parse expression matches at the current position. <code class="docutils literal notranslate"><span class="pre">FollowedBy</span></code> always returns a null token list. If any results names are defined in the lookahead expression, those <em>will</em> be returned for access by name.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># use FollowedBy to match a label only if it is followed by a ':'</span> <span class="n">data_word</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)</span> <span class="n">label</span> <span class="o">=</span> <span class="n">data_word</span> <span class="o">+</span> <span class="n">FollowedBy</span><span class="p">(</span><span class="s1">':'</span><span class="p">)</span> <span class="n">attr_expr</span> <span class="o">=</span> <span class="n">Group</span><span class="p">(</span><span class="n">label</span> <span class="o">+</span> <span class="n">Suppress</span><span class="p">(</span><span class="s1">':'</span><span class="p">)</span> <span class="o">+</span> <span class="n">OneOrMore</span><span class="p">(</span><span class="n">data_word</span><span class="p">,</span> <span class="n">stop_on</span><span class="o">=</span><span class="n">label</span><span class="p">)</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="s1">' '</span><span class="o">.</span><span class="n">join</span><span class="p">))</span> <span class="n">attr_expr</span><span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"shape: SQUARE color: BLACK posn: upper left"</span><span class="p">)</span><span class="o">.</span><span class="n">pprint</span><span class="p">()</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[[</span><span class="s1">'shape'</span><span class="p">,</span> <span class="s1">'SQUARE'</span><span class="p">],</span> <span class="p">[</span><span class="s1">'color'</span><span class="p">,</span> <span class="s1">'BLACK'</span><span class="p">],</span> <span class="p">[</span><span class="s1">'posn'</span><span class="p">,</span> <span class="s1">'upper left'</span><span class="p">]]</span> </pre></div> </div> <dl class="method"> <dt id="pyparsing.FollowedBy.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>expr: Union[pyparsing.core.ParserElement, str]</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.FollowedBy.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.Forward"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">Forward</code><span class="sig-paren">(</span><em>other: Union[pyparsing.core.ParserElement</em>, <em>str</em>, <em>NoneType] = None</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.Forward" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.ParseElementEnhance</span></code></p> <p>Forward declaration of an expression to be defined later - used for recursive grammars, such as algebraic infix notation. When the expression is known, it is assigned to the <code class="docutils literal notranslate"><span class="pre">Forward</span></code> variable using the <code class="docutils literal notranslate"><span class="pre">'<<'</span></code> operator.</p> <p>Note: take care when assigning to <code class="docutils literal notranslate"><span class="pre">Forward</span></code> not to overlook precedence of operators.</p> <p>Specifically, <code class="docutils literal notranslate"><span class="pre">'|'</span></code> has a lower precedence than <code class="docutils literal notranslate"><span class="pre">'<<'</span></code>, so that:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">fwd_expr</span> <span class="o"><<</span> <span class="n">a</span> <span class="o">|</span> <span class="n">b</span> <span class="o">|</span> <span class="n">c</span> </pre></div> </div> <p>will actually be evaluated as:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">(</span><span class="n">fwd_expr</span> <span class="o"><<</span> <span class="n">a</span><span class="p">)</span> <span class="o">|</span> <span class="n">b</span> <span class="o">|</span> <span class="n">c</span> </pre></div> </div> <p>thereby leaving b and c out as parseable alternatives. It is recommended that you explicitly group the values inserted into the <code class="docutils literal notranslate"><span class="pre">Forward</span></code>:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">fwd_expr</span> <span class="o"><<</span> <span class="p">(</span><span class="n">a</span> <span class="o">|</span> <span class="n">b</span> <span class="o">|</span> <span class="n">c</span><span class="p">)</span> </pre></div> </div> <p>Converting to use the <code class="docutils literal notranslate"><span class="pre">'<<='</span></code> operator instead will avoid this problem.</p> <p>See <a class="reference internal" href="#pyparsing.ParseResults.pprint" title="pyparsing.ParseResults.pprint"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParseResults.pprint</span></code></a> for an example of a recursive parser created using <code class="docutils literal notranslate"><span class="pre">Forward</span></code>.</p> <dl class="method"> <dt id="pyparsing.Forward.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>other: Union[pyparsing.core.ParserElement</em>, <em>str</em>, <em>NoneType] = None</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.Forward.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.Forward.__or__"> <code class="descname">__or__</code><span class="sig-paren">(</span><em>other</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.Forward.__or__" title="Permalink to this definition">¶</a></dt> <dd><p>Implementation of <code class="docutils literal notranslate"><span class="pre">|</span></code> operator - returns <a class="reference internal" href="#pyparsing.MatchFirst" title="pyparsing.MatchFirst"><code class="xref py py-class docutils literal notranslate"><span class="pre">MatchFirst</span></code></a></p> </dd></dl> <dl class="method"> <dt id="pyparsing.Forward.copy"> <code class="descname">copy</code><span class="sig-paren">(</span><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.Forward.copy" title="Permalink to this definition">¶</a></dt> <dd><p>Make a copy of this <a class="reference internal" href="#pyparsing.ParserElement" title="pyparsing.ParserElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement</span></code></a>. Useful for defining different parse actions for the same parsing pattern, using copies of the original parse element.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">integer</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="k">lambda</span> <span class="n">toks</span><span class="p">:</span> <span class="nb">int</span><span class="p">(</span><span class="n">toks</span><span class="p">[</span><span class="mi">0</span><span class="p">]))</span> <span class="n">integerK</span> <span class="o">=</span> <span class="n">integer</span><span class="o">.</span><span class="n">copy</span><span class="p">()</span><span class="o">.</span><span class="n">add_parse_action</span><span class="p">(</span><span class="k">lambda</span> <span class="n">toks</span><span class="p">:</span> <span class="n">toks</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">*</span> <span class="mi">1024</span><span class="p">)</span> <span class="o">+</span> <span class="n">Suppress</span><span class="p">(</span><span class="s2">"K"</span><span class="p">)</span> <span class="n">integerM</span> <span class="o">=</span> <span class="n">integer</span><span class="o">.</span><span class="n">copy</span><span class="p">()</span><span class="o">.</span><span class="n">add_parse_action</span><span class="p">(</span><span class="k">lambda</span> <span class="n">toks</span><span class="p">:</span> <span class="n">toks</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">*</span> <span class="mi">1024</span> <span class="o">*</span> <span class="mi">1024</span><span class="p">)</span> <span class="o">+</span> <span class="n">Suppress</span><span class="p">(</span><span class="s2">"M"</span><span class="p">)</span> <span class="nb">print</span><span class="p">((</span><span class="n">integerK</span> <span class="o">|</span> <span class="n">integerM</span> <span class="o">|</span> <span class="n">integer</span><span class="p">)[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"5K 100 640K 256M"</span><span class="p">))</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="mi">5120</span><span class="p">,</span> <span class="mi">100</span><span class="p">,</span> <span class="mi">655360</span><span class="p">,</span> <span class="mi">268435456</span><span class="p">]</span> </pre></div> </div> <p>Equivalent form of <code class="docutils literal notranslate"><span class="pre">expr.copy()</span></code> is just <code class="docutils literal notranslate"><span class="pre">expr()</span></code>:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">integerM</span> <span class="o">=</span> <span class="n">integer</span><span class="p">()</span><span class="o">.</span><span class="n">add_parse_action</span><span class="p">(</span><span class="k">lambda</span> <span class="n">toks</span><span class="p">:</span> <span class="n">toks</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">*</span> <span class="mi">1024</span> <span class="o">*</span> <span class="mi">1024</span><span class="p">)</span> <span class="o">+</span> <span class="n">Suppress</span><span class="p">(</span><span class="s2">"M"</span><span class="p">)</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.Forward.ignoreWhitespace"> <code class="descname">ignoreWhitespace</code><span class="sig-paren">(</span><em>recursive: bool = True</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.Forward.ignoreWhitespace" title="Permalink to this definition">¶</a></dt> <dd><p>Enables the skipping of whitespace before matching the characters in the <a class="reference internal" href="#pyparsing.ParserElement" title="pyparsing.ParserElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement</span></code></a>’s defined pattern.</p> <table class="docutils field-list" frame="void" rules="none"> <col class="field-name" /> <col class="field-body" /> <tbody valign="top"> <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>recursive</strong> – If <code class="docutils literal notranslate"><span class="pre">True</span></code> (the default), also enable whitespace skipping in child elements (if any)</td> </tr> </tbody> </table> </dd></dl> <dl class="method"> <dt id="pyparsing.Forward.ignore_whitespace"> <code class="descname">ignore_whitespace</code><span class="sig-paren">(</span><em>recursive: bool = True</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.Forward.ignore_whitespace" title="Permalink to this definition">¶</a></dt> <dd><p>Enables the skipping of whitespace before matching the characters in the <a class="reference internal" href="#pyparsing.ParserElement" title="pyparsing.ParserElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement</span></code></a>’s defined pattern.</p> <table class="docutils field-list" frame="void" rules="none"> <col class="field-name" /> <col class="field-body" /> <tbody valign="top"> <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>recursive</strong> – If <code class="docutils literal notranslate"><span class="pre">True</span></code> (the default), also enable whitespace skipping in child elements (if any)</td> </tr> </tbody> </table> </dd></dl> <dl class="method"> <dt id="pyparsing.Forward.leaveWhitespace"> <code class="descname">leaveWhitespace</code><span class="sig-paren">(</span><em>recursive: bool = True</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.Forward.leaveWhitespace" title="Permalink to this definition">¶</a></dt> <dd><p>Disables the skipping of whitespace before matching the characters in the <a class="reference internal" href="#pyparsing.ParserElement" title="pyparsing.ParserElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement</span></code></a>’s defined pattern. This is normally only used internally by the pyparsing module, but may be needed in some whitespace-sensitive grammars.</p> <table class="docutils field-list" frame="void" rules="none"> <col class="field-name" /> <col class="field-body" /> <tbody valign="top"> <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>recursive</strong> – If true (the default), also disable whitespace skipping in child elements (if any)</td> </tr> </tbody> </table> </dd></dl> <dl class="method"> <dt id="pyparsing.Forward.leave_whitespace"> <code class="descname">leave_whitespace</code><span class="sig-paren">(</span><em>recursive: bool = True</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.Forward.leave_whitespace" title="Permalink to this definition">¶</a></dt> <dd><p>Disables the skipping of whitespace before matching the characters in the <a class="reference internal" href="#pyparsing.ParserElement" title="pyparsing.ParserElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement</span></code></a>’s defined pattern. This is normally only used internally by the pyparsing module, but may be needed in some whitespace-sensitive grammars.</p> <table class="docutils field-list" frame="void" rules="none"> <col class="field-name" /> <col class="field-body" /> <tbody valign="top"> <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>recursive</strong> – If true (the default), also disable whitespace skipping in child elements (if any)</td> </tr> </tbody> </table> </dd></dl> <dl class="method"> <dt id="pyparsing.Forward.validate"> <code class="descname">validate</code><span class="sig-paren">(</span><em>validateTrace=None</em><span class="sig-paren">)</span> → None<a class="headerlink" href="#pyparsing.Forward.validate" title="Permalink to this definition">¶</a></dt> <dd><p>Check defined expressions for valid structure, check for infinite recursive definitions.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.GoToColumn"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">GoToColumn</code><span class="sig-paren">(</span><em>colno: int</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.GoToColumn" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.PositionToken</span></code></p> <p>Token to advance to a specific column of input text; useful for tabular report scraping.</p> <dl class="method"> <dt id="pyparsing.GoToColumn.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>colno: int</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.GoToColumn.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.Group"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">Group</code><span class="sig-paren">(</span><em>expr: pyparsing.core.ParserElement</em>, <em>aslist: bool = False</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.Group" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.TokenConverter</span></code></p> <p>Converter to return the matched tokens as a list - useful for returning tokens of <a class="reference internal" href="#pyparsing.ZeroOrMore" title="pyparsing.ZeroOrMore"><code class="xref py py-class docutils literal notranslate"><span class="pre">ZeroOrMore</span></code></a> and <a class="reference internal" href="#pyparsing.OneOrMore" title="pyparsing.OneOrMore"><code class="xref py py-class docutils literal notranslate"><span class="pre">OneOrMore</span></code></a> expressions.</p> <p>The optional <code class="docutils literal notranslate"><span class="pre">aslist</span></code> argument when set to True will return the parsed tokens as a Python list instead of a pyparsing ParseResults.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">ident</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)</span> <span class="n">num</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="n">term</span> <span class="o">=</span> <span class="n">ident</span> <span class="o">|</span> <span class="n">num</span> <span class="n">func</span> <span class="o">=</span> <span class="n">ident</span> <span class="o">+</span> <span class="n">Opt</span><span class="p">(</span><span class="n">delimited_list</span><span class="p">(</span><span class="n">term</span><span class="p">))</span> <span class="nb">print</span><span class="p">(</span><span class="n">func</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"fn a, b, 100"</span><span class="p">))</span> <span class="c1"># -> ['fn', 'a', 'b', '100']</span> <span class="n">func</span> <span class="o">=</span> <span class="n">ident</span> <span class="o">+</span> <span class="n">Group</span><span class="p">(</span><span class="n">Opt</span><span class="p">(</span><span class="n">delimited_list</span><span class="p">(</span><span class="n">term</span><span class="p">)))</span> <span class="nb">print</span><span class="p">(</span><span class="n">func</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"fn a, b, 100"</span><span class="p">))</span> <span class="c1"># -> ['fn', ['a', 'b', '100']]</span> </pre></div> </div> <dl class="method"> <dt id="pyparsing.Group.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>expr: pyparsing.core.ParserElement</em>, <em>aslist: bool = False</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.Group.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.IndentedBlock"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">IndentedBlock</code><span class="sig-paren">(</span><em>expr: pyparsing.core.ParserElement</em>, <em>*</em>, <em>recursive: bool = False</em>, <em>grouped: bool = True</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.IndentedBlock" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.ParseElementEnhance</span></code></p> <p>Expression to match one or more expressions at a given indentation level. Useful for parsing text where structure is implied by indentation (like Python source code).</p> <dl class="method"> <dt id="pyparsing.IndentedBlock.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>expr: pyparsing.core.ParserElement</em>, <em>*</em>, <em>recursive: bool = False</em>, <em>grouped: bool = True</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.IndentedBlock.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.Keyword"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">Keyword</code><span class="sig-paren">(</span><em>match_string: str = ''</em>, <em>ident_chars: Union[str</em>, <em>NoneType] = None</em>, <em>caseless: bool = False</em>, <em>*</em>, <em>matchString: str = ''</em>, <em>identChars: Union[str</em>, <em>NoneType] = None</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.Keyword" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.Token</span></code></p> <p>Token to exactly match a specified string as a keyword, that is, it must be immediately followed by a non-keyword character. Compare with <a class="reference internal" href="#pyparsing.Literal" title="pyparsing.Literal"><code class="xref py py-class docutils literal notranslate"><span class="pre">Literal</span></code></a>:</p> <ul class="simple"> <li><code class="docutils literal notranslate"><span class="pre">Literal("if")</span></code> will match the leading <code class="docutils literal notranslate"><span class="pre">'if'</span></code> in <code class="docutils literal notranslate"><span class="pre">'ifAndOnlyIf'</span></code>.</li> <li><code class="docutils literal notranslate"><span class="pre">Keyword("if")</span></code> will not; it will only match the leading <code class="docutils literal notranslate"><span class="pre">'if'</span></code> in <code class="docutils literal notranslate"><span class="pre">'if</span> <span class="pre">x=1'</span></code>, or <code class="docutils literal notranslate"><span class="pre">'if(y==2)'</span></code></li> </ul> <p>Accepts two optional constructor arguments in addition to the keyword string:</p> <ul class="simple"> <li><code class="docutils literal notranslate"><span class="pre">identChars</span></code> is a string of characters that would be valid identifier characters, defaulting to all alphanumerics + “_” and “$”</li> <li><code class="docutils literal notranslate"><span class="pre">caseless</span></code> allows case-insensitive matching, default is <code class="docutils literal notranslate"><span class="pre">False</span></code>.</li> </ul> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">Keyword</span><span class="p">(</span><span class="s2">"start"</span><span class="p">)</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"start"</span><span class="p">)</span> <span class="c1"># -> ['start']</span> <span class="n">Keyword</span><span class="p">(</span><span class="s2">"start"</span><span class="p">)</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"starting"</span><span class="p">)</span> <span class="c1"># -> Exception</span> </pre></div> </div> <p>For case-insensitive matching, use <a class="reference internal" href="#pyparsing.CaselessKeyword" title="pyparsing.CaselessKeyword"><code class="xref py py-class docutils literal notranslate"><span class="pre">CaselessKeyword</span></code></a>.</p> <dl class="method"> <dt id="pyparsing.Keyword.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>match_string: str = ''</em>, <em>ident_chars: Union[str</em>, <em>NoneType] = None</em>, <em>caseless: bool = False</em>, <em>*</em>, <em>matchString: str = ''</em>, <em>identChars: Union[str</em>, <em>NoneType] = None</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.Keyword.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> <dl class="staticmethod"> <dt id="pyparsing.Keyword.setDefaultKeywordChars"> <em class="property">static </em><code class="descname">setDefaultKeywordChars</code><span class="sig-paren">(</span><em>chars</em><span class="sig-paren">)</span> → None<a class="headerlink" href="#pyparsing.Keyword.setDefaultKeywordChars" title="Permalink to this definition">¶</a></dt> <dd><p>Overrides the default characters used by <a class="reference internal" href="#pyparsing.Keyword" title="pyparsing.Keyword"><code class="xref py py-class docutils literal notranslate"><span class="pre">Keyword</span></code></a> expressions.</p> </dd></dl> <dl class="staticmethod"> <dt id="pyparsing.Keyword.set_default_keyword_chars"> <em class="property">static </em><code class="descname">set_default_keyword_chars</code><span class="sig-paren">(</span><em>chars</em><span class="sig-paren">)</span> → None<a class="headerlink" href="#pyparsing.Keyword.set_default_keyword_chars" title="Permalink to this definition">¶</a></dt> <dd><p>Overrides the default characters used by <a class="reference internal" href="#pyparsing.Keyword" title="pyparsing.Keyword"><code class="xref py py-class docutils literal notranslate"><span class="pre">Keyword</span></code></a> expressions.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.LineEnd"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">LineEnd</code><a class="headerlink" href="#pyparsing.LineEnd" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.PositionToken</span></code></p> <p>Matches if current position is at the end of a line within the parse string</p> <dl class="method"> <dt id="pyparsing.LineEnd.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.LineEnd.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.LineStart"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">LineStart</code><a class="headerlink" href="#pyparsing.LineStart" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.PositionToken</span></code></p> <p>Matches if current position is at the beginning of a line within the parse string</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">test</span> <span class="o">=</span> <span class="s1">'''</span><span class="se">\</span> <span class="s1">AAA this line</span> <span class="s1">AAA and this line</span> <span class="s1"> AAA but not this one</span> <span class="s1">B AAA and definitely not this one</span> <span class="s1">'''</span> <span class="k">for</span> <span class="n">t</span> <span class="ow">in</span> <span class="p">(</span><span class="n">LineStart</span><span class="p">()</span> <span class="o">+</span> <span class="s1">'AAA'</span> <span class="o">+</span> <span class="n">restOfLine</span><span class="p">)</span><span class="o">.</span><span class="n">search_string</span><span class="p">(</span><span class="n">test</span><span class="p">):</span> <span class="nb">print</span><span class="p">(</span><span class="n">t</span><span class="p">)</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="s1">'AAA'</span><span class="p">,</span> <span class="s1">' this line'</span><span class="p">]</span> <span class="p">[</span><span class="s1">'AAA'</span><span class="p">,</span> <span class="s1">' and this line'</span><span class="p">]</span> </pre></div> </div> <dl class="method"> <dt id="pyparsing.LineStart.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.LineStart.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.Literal"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">Literal</code><span class="sig-paren">(</span><em>match_string: str = ''</em>, <em>*</em>, <em>matchString: str = ''</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.Literal" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.Token</span></code></p> <p>Token to exactly match a specified string.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">Literal</span><span class="p">(</span><span class="s1">'blah'</span><span class="p">)</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s1">'blah'</span><span class="p">)</span> <span class="c1"># -> ['blah']</span> <span class="n">Literal</span><span class="p">(</span><span class="s1">'blah'</span><span class="p">)</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s1">'blahfooblah'</span><span class="p">)</span> <span class="c1"># -> ['blah']</span> <span class="n">Literal</span><span class="p">(</span><span class="s1">'blah'</span><span class="p">)</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s1">'bla'</span><span class="p">)</span> <span class="c1"># -> Exception: Expected "blah"</span> </pre></div> </div> <p>For case-insensitive matching, use <a class="reference internal" href="#pyparsing.CaselessLiteral" title="pyparsing.CaselessLiteral"><code class="xref py py-class docutils literal notranslate"><span class="pre">CaselessLiteral</span></code></a>.</p> <p>For keyword matching (force word break before and after the matched string), use <a class="reference internal" href="#pyparsing.Keyword" title="pyparsing.Keyword"><code class="xref py py-class docutils literal notranslate"><span class="pre">Keyword</span></code></a> or <a class="reference internal" href="#pyparsing.CaselessKeyword" title="pyparsing.CaselessKeyword"><code class="xref py py-class docutils literal notranslate"><span class="pre">CaselessKeyword</span></code></a>.</p> <dl class="method"> <dt id="pyparsing.Literal.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>match_string: str = ''</em>, <em>*</em>, <em>matchString: str = ''</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.Literal.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.Located"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">Located</code><span class="sig-paren">(</span><em>expr: Union[pyparsing.core.ParserElement, str], savelist: bool = False</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.Located" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.ParseElementEnhance</span></code></p> <p>Decorates a returned token with its starting and ending locations in the input string.</p> <p>This helper adds the following results names:</p> <ul class="simple"> <li><code class="docutils literal notranslate"><span class="pre">locn_start</span></code> - location where matched expression begins</li> <li><code class="docutils literal notranslate"><span class="pre">locn_end</span></code> - location where matched expression ends</li> <li><code class="docutils literal notranslate"><span class="pre">value</span></code> - the actual parsed results</li> </ul> <p>Be careful if the input text contains <code class="docutils literal notranslate"><span class="pre"><TAB></span></code> characters, you may want to call <a class="reference internal" href="#pyparsing.ParserElement.parse_with_tabs" title="pyparsing.ParserElement.parse_with_tabs"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement.parse_with_tabs</span></code></a></p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">wd</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)</span> <span class="k">for</span> <span class="n">match</span> <span class="ow">in</span> <span class="n">Located</span><span class="p">(</span><span class="n">wd</span><span class="p">)</span><span class="o">.</span><span class="n">search_string</span><span class="p">(</span><span class="s2">"ljsdf123lksdjjf123lkkjj1222"</span><span class="p">):</span> <span class="nb">print</span><span class="p">(</span><span class="n">match</span><span class="p">)</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="p">[</span><span class="s1">'ljsdf'</span><span class="p">],</span> <span class="mi">5</span><span class="p">]</span> <span class="p">[</span><span class="mi">8</span><span class="p">,</span> <span class="p">[</span><span class="s1">'lksdjjf'</span><span class="p">],</span> <span class="mi">15</span><span class="p">]</span> <span class="p">[</span><span class="mi">18</span><span class="p">,</span> <span class="p">[</span><span class="s1">'lkkjj'</span><span class="p">],</span> <span class="mi">23</span><span class="p">]</span> </pre></div> </div> </dd></dl> <dl class="class"> <dt id="pyparsing.PrecededBy"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">PrecededBy</code><span class="sig-paren">(</span><em>expr: Union[pyparsing.core.ParserElement, str], retreat: Union[int, NoneType] = None</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.PrecededBy" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.ParseElementEnhance</span></code></p> <p>Lookbehind matching of the given parse expression. <code class="docutils literal notranslate"><span class="pre">PrecededBy</span></code> does not advance the parsing position within the input string, it only verifies that the specified parse expression matches prior to the current position. <code class="docutils literal notranslate"><span class="pre">PrecededBy</span></code> always returns a null token list, but if a results name is defined on the given expression, it is returned.</p> <p>Parameters:</p> <ul class="simple"> <li>expr - expression that must match prior to the current parse location</li> <li>retreat - (default= <code class="docutils literal notranslate"><span class="pre">None</span></code>) - (int) maximum number of characters to lookbehind prior to the current parse location</li> </ul> <p>If the lookbehind expression is a string, <a class="reference internal" href="#pyparsing.Literal" title="pyparsing.Literal"><code class="xref py py-class docutils literal notranslate"><span class="pre">Literal</span></code></a>, <a class="reference internal" href="#pyparsing.Keyword" title="pyparsing.Keyword"><code class="xref py py-class docutils literal notranslate"><span class="pre">Keyword</span></code></a>, or a <a class="reference internal" href="#pyparsing.Word" title="pyparsing.Word"><code class="xref py py-class docutils literal notranslate"><span class="pre">Word</span></code></a> or <a class="reference internal" href="#pyparsing.CharsNotIn" title="pyparsing.CharsNotIn"><code class="xref py py-class docutils literal notranslate"><span class="pre">CharsNotIn</span></code></a> with a specified exact or maximum length, then the retreat parameter is not required. Otherwise, retreat must be specified to give a maximum number of characters to look back from the current parse position for a lookbehind match.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># VB-style variable names with type prefixes</span> <span class="n">int_var</span> <span class="o">=</span> <span class="n">PrecededBy</span><span class="p">(</span><span class="s2">"#"</span><span class="p">)</span> <span class="o">+</span> <span class="n">pyparsing_common</span><span class="o">.</span><span class="n">identifier</span> <span class="n">str_var</span> <span class="o">=</span> <span class="n">PrecededBy</span><span class="p">(</span><span class="s2">"$"</span><span class="p">)</span> <span class="o">+</span> <span class="n">pyparsing_common</span><span class="o">.</span><span class="n">identifier</span> </pre></div> </div> <dl class="method"> <dt id="pyparsing.PrecededBy.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>expr: Union[pyparsing.core.ParserElement, str], retreat: Union[int, NoneType] = None</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.PrecededBy.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.MatchFirst"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">MatchFirst</code><span class="sig-paren">(</span><em>exprs: Iterable[pyparsing.core.ParserElement], savelist: bool = False</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.MatchFirst" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.ParseExpression</span></code></p> <p>Requires that at least one <a class="reference internal" href="#pyparsing.ParseExpression" title="pyparsing.ParseExpression"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParseExpression</span></code></a> is found. If more than one expression matches, the first one listed is the one that will match. May be constructed using the <code class="docutils literal notranslate"><span class="pre">'|'</span></code> operator.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># construct MatchFirst using '|' operator</span> <span class="c1"># watch the order of expressions to match</span> <span class="n">number</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="o">|</span> <span class="n">Combine</span><span class="p">(</span><span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="o">+</span> <span class="s1">'.'</span> <span class="o">+</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">))</span> <span class="nb">print</span><span class="p">(</span><span class="n">number</span><span class="o">.</span><span class="n">search_string</span><span class="p">(</span><span class="s2">"123 3.1416 789"</span><span class="p">))</span> <span class="c1"># Fail! -> [['123'], ['3'], ['1416'], ['789']]</span> <span class="c1"># put more selective expression first</span> <span class="n">number</span> <span class="o">=</span> <span class="n">Combine</span><span class="p">(</span><span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="o">+</span> <span class="s1">'.'</span> <span class="o">+</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">))</span> <span class="o">|</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="nb">print</span><span class="p">(</span><span class="n">number</span><span class="o">.</span><span class="n">search_string</span><span class="p">(</span><span class="s2">"123 3.1416 789"</span><span class="p">))</span> <span class="c1"># Better -> [['123'], ['3.1416'], ['789']]</span> </pre></div> </div> <dl class="method"> <dt id="pyparsing.MatchFirst.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>exprs: Iterable[pyparsing.core.ParserElement], savelist: bool = False</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.MatchFirst.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.NoMatch"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">NoMatch</code><a class="headerlink" href="#pyparsing.NoMatch" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.Token</span></code></p> <p>A token that will never match.</p> <dl class="method"> <dt id="pyparsing.NoMatch.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.NoMatch.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.NotAny"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">NotAny</code><span class="sig-paren">(</span><em>expr: Union[pyparsing.core.ParserElement, str]</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.NotAny" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.ParseElementEnhance</span></code></p> <p>Lookahead to disallow matching with the given parse expression. <code class="docutils literal notranslate"><span class="pre">NotAny</span></code> does <em>not</em> advance the parsing position within the input string, it only verifies that the specified parse expression does <em>not</em> match at the current position. Also, <code class="docutils literal notranslate"><span class="pre">NotAny</span></code> does <em>not</em> skip over leading whitespace. <code class="docutils literal notranslate"><span class="pre">NotAny</span></code> always returns a null token list. May be constructed using the <code class="docutils literal notranslate"><span class="pre">'~'</span></code> operator.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">AND</span><span class="p">,</span> <span class="n">OR</span><span class="p">,</span> <span class="n">NOT</span> <span class="o">=</span> <span class="nb">map</span><span class="p">(</span><span class="n">CaselessKeyword</span><span class="p">,</span> <span class="s2">"AND OR NOT"</span><span class="o">.</span><span class="n">split</span><span class="p">())</span> <span class="c1"># take care not to mistake keywords for identifiers</span> <span class="n">ident</span> <span class="o">=</span> <span class="o">~</span><span class="p">(</span><span class="n">AND</span> <span class="o">|</span> <span class="n">OR</span> <span class="o">|</span> <span class="n">NOT</span><span class="p">)</span> <span class="o">+</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)</span> <span class="n">boolean_term</span> <span class="o">=</span> <span class="n">Opt</span><span class="p">(</span><span class="n">NOT</span><span class="p">)</span> <span class="o">+</span> <span class="n">ident</span> <span class="c1"># very crude boolean expression - to support parenthesis groups and</span> <span class="c1"># operation hierarchy, use infix_notation</span> <span class="n">boolean_expr</span> <span class="o">=</span> <span class="n">boolean_term</span> <span class="o">+</span> <span class="p">((</span><span class="n">AND</span> <span class="o">|</span> <span class="n">OR</span><span class="p">)</span> <span class="o">+</span> <span class="n">boolean_term</span><span class="p">)[</span><span class="o">...</span><span class="p">]</span> <span class="c1"># integers that are followed by "." are actually floats</span> <span class="n">integer</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="o">+</span> <span class="o">~</span><span class="n">Char</span><span class="p">(</span><span class="s2">"."</span><span class="p">)</span> </pre></div> </div> <dl class="method"> <dt id="pyparsing.NotAny.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>expr: Union[pyparsing.core.ParserElement, str]</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.NotAny.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.OneOrMore"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">OneOrMore</code><span class="sig-paren">(</span><em>expr: pyparsing.core.ParserElement</em>, <em>stop_on: Union[pyparsing.core.ParserElement</em>, <em>str</em>, <em>NoneType] = None</em>, <em>*</em>, <em>stopOn: Union[pyparsing.core.ParserElement</em>, <em>str</em>, <em>NoneType] = None</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.OneOrMore" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core._MultipleMatch</span></code></p> <p>Repetition of one or more of the given expression.</p> <p>Parameters: - expr - expression that must match one or more times - stop_on - (default= <code class="docutils literal notranslate"><span class="pre">None</span></code>) - expression for a terminating sentinel</p> <blockquote> <div>(only required if the sentinel would ordinarily match the repetition expression)</div></blockquote> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">data_word</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)</span> <span class="n">label</span> <span class="o">=</span> <span class="n">data_word</span> <span class="o">+</span> <span class="n">FollowedBy</span><span class="p">(</span><span class="s1">':'</span><span class="p">)</span> <span class="n">attr_expr</span> <span class="o">=</span> <span class="n">Group</span><span class="p">(</span><span class="n">label</span> <span class="o">+</span> <span class="n">Suppress</span><span class="p">(</span><span class="s1">':'</span><span class="p">)</span> <span class="o">+</span> <span class="n">OneOrMore</span><span class="p">(</span><span class="n">data_word</span><span class="p">)</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="s1">' '</span><span class="o">.</span><span class="n">join</span><span class="p">))</span> <span class="n">text</span> <span class="o">=</span> <span class="s2">"shape: SQUARE posn: upper left color: BLACK"</span> <span class="n">attr_expr</span><span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="n">text</span><span class="p">)</span><span class="o">.</span><span class="n">pprint</span><span class="p">()</span> <span class="c1"># Fail! read 'color' as data instead of next label -> [['shape', 'SQUARE color']]</span> <span class="c1"># use stop_on attribute for OneOrMore to avoid reading label string as part of the data</span> <span class="n">attr_expr</span> <span class="o">=</span> <span class="n">Group</span><span class="p">(</span><span class="n">label</span> <span class="o">+</span> <span class="n">Suppress</span><span class="p">(</span><span class="s1">':'</span><span class="p">)</span> <span class="o">+</span> <span class="n">OneOrMore</span><span class="p">(</span><span class="n">data_word</span><span class="p">,</span> <span class="n">stop_on</span><span class="o">=</span><span class="n">label</span><span class="p">)</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="s1">' '</span><span class="o">.</span><span class="n">join</span><span class="p">))</span> <span class="n">OneOrMore</span><span class="p">(</span><span class="n">attr_expr</span><span class="p">)</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="n">text</span><span class="p">)</span><span class="o">.</span><span class="n">pprint</span><span class="p">()</span> <span class="c1"># Better -> [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'BLACK']]</span> <span class="c1"># could also be written as</span> <span class="p">(</span><span class="n">attr_expr</span> <span class="o">*</span> <span class="p">(</span><span class="mi">1</span><span class="p">,))</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="n">text</span><span class="p">)</span><span class="o">.</span><span class="n">pprint</span><span class="p">()</span> </pre></div> </div> </dd></dl> <dl class="class"> <dt id="pyparsing.OnlyOnce"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">OnlyOnce</code><span class="sig-paren">(</span><em>method_call</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.OnlyOnce" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">object</span></code></p> <p>Wrapper for parse actions, to ensure they are only called once.</p> <dl class="method"> <dt id="pyparsing.OnlyOnce.__call__"> <code class="descname">__call__</code><span class="sig-paren">(</span><em>s</em>, <em>l</em>, <em>t</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.OnlyOnce.__call__" title="Permalink to this definition">¶</a></dt> <dd><p>Call self as a function.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.OnlyOnce.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>method_call</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.OnlyOnce.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.OnlyOnce.__weakref__"> <code class="descname">__weakref__</code><a class="headerlink" href="#pyparsing.OnlyOnce.__weakref__" title="Permalink to this definition">¶</a></dt> <dd><p>list of weak references to the object (if defined)</p> </dd></dl> <dl class="method"> <dt id="pyparsing.OnlyOnce.reset"> <code class="descname">reset</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.OnlyOnce.reset" title="Permalink to this definition">¶</a></dt> <dd><p>Allow the associated parse action to be called once more.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.OpAssoc"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">OpAssoc</code><a class="headerlink" href="#pyparsing.OpAssoc" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">enum.Enum</span></code></p> <p>An enumeration.</p> </dd></dl> <dl class="class"> <dt id="pyparsing.Opt"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">Opt</code><span class="sig-paren">(</span><em>expr: Union[pyparsing.core.ParserElement, str], default: Any = <pyparsing.core._NullToken object></em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.Opt" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.ParseElementEnhance</span></code></p> <p>Optional matching of the given expression.</p> <p>Parameters: - <code class="docutils literal notranslate"><span class="pre">expr</span></code> - expression that must match zero or more times - <code class="docutils literal notranslate"><span class="pre">default</span></code> (optional) - value to be returned if the optional expression is not found.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># US postal code can be a 5-digit zip, plus optional 4-digit qualifier</span> <span class="nb">zip</span> <span class="o">=</span> <span class="n">Combine</span><span class="p">(</span><span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">,</span> <span class="n">exact</span><span class="o">=</span><span class="mi">5</span><span class="p">)</span> <span class="o">+</span> <span class="n">Opt</span><span class="p">(</span><span class="s1">'-'</span> <span class="o">+</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">,</span> <span class="n">exact</span><span class="o">=</span><span class="mi">4</span><span class="p">)))</span> <span class="nb">zip</span><span class="o">.</span><span class="n">run_tests</span><span class="p">(</span><span class="s1">'''</span> <span class="s1"> # traditional ZIP code</span> <span class="s1"> 12345</span> <span class="s1"> # ZIP+4 form</span> <span class="s1"> 12101-0001</span> <span class="s1"> # invalid ZIP</span> <span class="s1"> 98765-</span> <span class="s1"> '''</span><span class="p">)</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># traditional ZIP code</span> <span class="mi">12345</span> <span class="p">[</span><span class="s1">'12345'</span><span class="p">]</span> <span class="c1"># ZIP+4 form</span> <span class="mi">12101</span><span class="o">-</span><span class="mi">0001</span> <span class="p">[</span><span class="s1">'12101-0001'</span><span class="p">]</span> <span class="c1"># invalid ZIP</span> <span class="mi">98765</span><span class="o">-</span> <span class="o">^</span> <span class="n">FAIL</span><span class="p">:</span> <span class="n">Expected</span> <span class="n">end</span> <span class="n">of</span> <span class="n">text</span> <span class="p">(</span><span class="n">at</span> <span class="n">char</span> <span class="mi">5</span><span class="p">),</span> <span class="p">(</span><span class="n">line</span><span class="p">:</span><span class="mi">1</span><span class="p">,</span> <span class="n">col</span><span class="p">:</span><span class="mi">6</span><span class="p">)</span> </pre></div> </div> <dl class="method"> <dt id="pyparsing.Opt.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>expr: Union[pyparsing.core.ParserElement, str], default: Any = <pyparsing.core._NullToken object></em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.Opt.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> </dd></dl> <dl class="attribute"> <dt id="pyparsing.Optional"> <code class="descclassname">pyparsing.</code><code class="descname">Optional</code><a class="headerlink" href="#pyparsing.Optional" title="Permalink to this definition">¶</a></dt> <dd><p>alias of <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.Opt</span></code></p> </dd></dl> <dl class="class"> <dt id="pyparsing.Or"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">Or</code><span class="sig-paren">(</span><em>exprs: Iterable[pyparsing.core.ParserElement], savelist: bool = False</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.Or" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.ParseExpression</span></code></p> <p>Requires that at least one <a class="reference internal" href="#pyparsing.ParseExpression" title="pyparsing.ParseExpression"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParseExpression</span></code></a> is found. If two expressions match, the expression that matches the longest string will be used. May be constructed using the <code class="docutils literal notranslate"><span class="pre">'^'</span></code> operator.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># construct Or using '^' operator</span> <span class="n">number</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="o">^</span> <span class="n">Combine</span><span class="p">(</span><span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="o">+</span> <span class="s1">'.'</span> <span class="o">+</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">))</span> <span class="nb">print</span><span class="p">(</span><span class="n">number</span><span class="o">.</span><span class="n">search_string</span><span class="p">(</span><span class="s2">"123 3.1416 789"</span><span class="p">))</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[[</span><span class="s1">'123'</span><span class="p">],</span> <span class="p">[</span><span class="s1">'3.1416'</span><span class="p">],</span> <span class="p">[</span><span class="s1">'789'</span><span class="p">]]</span> </pre></div> </div> <dl class="method"> <dt id="pyparsing.Or.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>exprs: Iterable[pyparsing.core.ParserElement], savelist: bool = False</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.Or.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> </dd></dl> <dl class="exception"> <dt id="pyparsing.ParseBaseException"> <em class="property">exception </em><code class="descclassname">pyparsing.</code><code class="descname">ParseBaseException</code><span class="sig-paren">(</span><em>pstr: str</em>, <em>loc: int = 0</em>, <em>msg: Union[str</em>, <em>NoneType] = None</em>, <em>elem=None</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.ParseBaseException" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">Exception</span></code></p> <p>base exception class for all parsing runtime exceptions</p> <dl class="method"> <dt id="pyparsing.ParseBaseException.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>pstr: str</em>, <em>loc: int = 0</em>, <em>msg: Union[str</em>, <em>NoneType] = None</em>, <em>elem=None</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.ParseBaseException.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseBaseException.__repr__"> <code class="descname">__repr__</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.ParseBaseException.__repr__" title="Permalink to this definition">¶</a></dt> <dd><p>Return repr(self).</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseBaseException.__str__"> <code class="descname">__str__</code><span class="sig-paren">(</span><span class="sig-paren">)</span> → str<a class="headerlink" href="#pyparsing.ParseBaseException.__str__" title="Permalink to this definition">¶</a></dt> <dd><p>Return str(self).</p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.ParseBaseException.__weakref__"> <code class="descname">__weakref__</code><a class="headerlink" href="#pyparsing.ParseBaseException.__weakref__" title="Permalink to this definition">¶</a></dt> <dd><p>list of weak references to the object (if defined)</p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.ParseBaseException.col"> <code class="descname">col</code><a class="headerlink" href="#pyparsing.ParseBaseException.col" title="Permalink to this definition">¶</a></dt> <dd><p>Return the 1-based column on the line of text where the exception occurred.</p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.ParseBaseException.column"> <code class="descname">column</code><a class="headerlink" href="#pyparsing.ParseBaseException.column" title="Permalink to this definition">¶</a></dt> <dd><p>Return the 1-based column on the line of text where the exception occurred.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseBaseException.explain"> <code class="descname">explain</code><span class="sig-paren">(</span><em>depth=16</em><span class="sig-paren">)</span> → str<a class="headerlink" href="#pyparsing.ParseBaseException.explain" title="Permalink to this definition">¶</a></dt> <dd><p>Method to translate the Python internal traceback into a list of the pyparsing expressions that caused the exception to be raised.</p> <p>Parameters:</p> <ul class="simple"> <li>depth (default=16) - number of levels back in the stack trace to list expression and function names; if None, the full stack trace names will be listed; if 0, only the failing input line, marker, and exception string will be shown</li> </ul> <p>Returns a multi-line string listing the ParserElements and/or function names in the exception’s stack trace.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">expr</span> <span class="o">=</span> <span class="n">pp</span><span class="o">.</span><span class="n">Word</span><span class="p">(</span><span class="n">pp</span><span class="o">.</span><span class="n">nums</span><span class="p">)</span> <span class="o">*</span> <span class="mi">3</span> <span class="k">try</span><span class="p">:</span> <span class="n">expr</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"123 456 A789"</span><span class="p">)</span> <span class="k">except</span> <span class="n">pp</span><span class="o">.</span><span class="n">ParseException</span> <span class="k">as</span> <span class="n">pe</span><span class="p">:</span> <span class="nb">print</span><span class="p">(</span><span class="n">pe</span><span class="o">.</span><span class="n">explain</span><span class="p">(</span><span class="n">depth</span><span class="o">=</span><span class="mi">0</span><span class="p">))</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">123</span> <span class="mi">456</span> <span class="n">A789</span> <span class="o">^</span> <span class="n">ParseException</span><span class="p">:</span> <span class="n">Expected</span> <span class="n">W</span><span class="p">:(</span><span class="mi">0</span><span class="o">-</span><span class="mi">9</span><span class="p">),</span> <span class="n">found</span> <span class="s1">'A'</span> <span class="p">(</span><span class="n">at</span> <span class="n">char</span> <span class="mi">8</span><span class="p">),</span> <span class="p">(</span><span class="n">line</span><span class="p">:</span><span class="mi">1</span><span class="p">,</span> <span class="n">col</span><span class="p">:</span><span class="mi">9</span><span class="p">)</span> </pre></div> </div> <p>Note: the diagnostic output will include string representations of the expressions that failed to parse. These representations will be more helpful if you use <cite>set_name</cite> to give identifiable names to your expressions. Otherwise they will use the default string forms, which may be cryptic to read.</p> <p>Note: pyparsing’s default truncation of exception tracebacks may also truncate the stack of expressions that are displayed in the <code class="docutils literal notranslate"><span class="pre">explain</span></code> output. To get the full listing of parser expressions, you may have to set <code class="docutils literal notranslate"><span class="pre">ParserElement.verbose_stacktrace</span> <span class="pre">=</span> <span class="pre">True</span></code></p> </dd></dl> <dl class="staticmethod"> <dt id="pyparsing.ParseBaseException.explain_exception"> <em class="property">static </em><code class="descname">explain_exception</code><span class="sig-paren">(</span><em>exc</em>, <em>depth=16</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.ParseBaseException.explain_exception" title="Permalink to this definition">¶</a></dt> <dd><p>Method to take an exception and translate the Python internal traceback into a list of the pyparsing expressions that caused the exception to be raised.</p> <p>Parameters:</p> <ul class="simple"> <li>exc - exception raised during parsing (need not be a ParseException, in support of Python exceptions that might be raised in a parse action)</li> <li>depth (default=16) - number of levels back in the stack trace to list expression and function names; if None, the full stack trace names will be listed; if 0, only the failing input line, marker, and exception string will be shown</li> </ul> <p>Returns a multi-line string listing the ParserElements and/or function names in the exception’s stack trace.</p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.ParseBaseException.line"> <code class="descname">line</code><a class="headerlink" href="#pyparsing.ParseBaseException.line" title="Permalink to this definition">¶</a></dt> <dd><p>Return the line of text where the exception occurred.</p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.ParseBaseException.lineno"> <code class="descname">lineno</code><a class="headerlink" href="#pyparsing.ParseBaseException.lineno" title="Permalink to this definition">¶</a></dt> <dd><p>Return the 1-based line number of text where the exception occurred.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseBaseException.markInputline"> <code class="descname">markInputline</code><span class="sig-paren">(</span><em>marker_string: str = None</em>, <em>*</em>, <em>markerString='>!<'</em><span class="sig-paren">)</span> → str<a class="headerlink" href="#pyparsing.ParseBaseException.markInputline" title="Permalink to this definition">¶</a></dt> <dd><p>Extracts the exception line from the input string, and marks the location of the exception with a special symbol.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseBaseException.mark_input_line"> <code class="descname">mark_input_line</code><span class="sig-paren">(</span><em>marker_string: str = None</em>, <em>*</em>, <em>markerString='>!<'</em><span class="sig-paren">)</span> → str<a class="headerlink" href="#pyparsing.ParseBaseException.mark_input_line" title="Permalink to this definition">¶</a></dt> <dd><p>Extracts the exception line from the input string, and marks the location of the exception with a special symbol.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.ParseElementEnhance"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">ParseElementEnhance</code><span class="sig-paren">(</span><em>expr: Union[pyparsing.core.ParserElement, str], savelist: bool = False</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.ParseElementEnhance" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.ParserElement</span></code></p> <p>Abstract subclass of <a class="reference internal" href="#pyparsing.ParserElement" title="pyparsing.ParserElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement</span></code></a>, for combining and post-processing parsed tokens.</p> <dl class="method"> <dt id="pyparsing.ParseElementEnhance.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>expr: Union[pyparsing.core.ParserElement, str], savelist: bool = False</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.ParseElementEnhance.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseElementEnhance.ignore"> <code class="descname">ignore</code><span class="sig-paren">(</span><em>other</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParseElementEnhance.ignore" title="Permalink to this definition">¶</a></dt> <dd><p>Define expression to be ignored (e.g., comments) while doing pattern matching; may be called repeatedly, to define multiple comment or other ignorable patterns.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">patt</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span> <span class="n">patt</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s1">'ablaj /* comment */ lskjd'</span><span class="p">)</span> <span class="c1"># -> ['ablaj']</span> <span class="n">patt</span><span class="o">.</span><span class="n">ignore</span><span class="p">(</span><span class="n">c_style_comment</span><span class="p">)</span> <span class="n">patt</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s1">'ablaj /* comment */ lskjd'</span><span class="p">)</span> <span class="c1"># -> ['ablaj', 'lskjd']</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseElementEnhance.ignoreWhitespace"> <code class="descname">ignoreWhitespace</code><span class="sig-paren">(</span><em>recursive: bool = True</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParseElementEnhance.ignoreWhitespace" title="Permalink to this definition">¶</a></dt> <dd><p>Enables the skipping of whitespace before matching the characters in the <a class="reference internal" href="#pyparsing.ParserElement" title="pyparsing.ParserElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement</span></code></a>’s defined pattern.</p> <table class="docutils field-list" frame="void" rules="none"> <col class="field-name" /> <col class="field-body" /> <tbody valign="top"> <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>recursive</strong> – If <code class="docutils literal notranslate"><span class="pre">True</span></code> (the default), also enable whitespace skipping in child elements (if any)</td> </tr> </tbody> </table> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseElementEnhance.ignore_whitespace"> <code class="descname">ignore_whitespace</code><span class="sig-paren">(</span><em>recursive: bool = True</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParseElementEnhance.ignore_whitespace" title="Permalink to this definition">¶</a></dt> <dd><p>Enables the skipping of whitespace before matching the characters in the <a class="reference internal" href="#pyparsing.ParserElement" title="pyparsing.ParserElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement</span></code></a>’s defined pattern.</p> <table class="docutils field-list" frame="void" rules="none"> <col class="field-name" /> <col class="field-body" /> <tbody valign="top"> <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>recursive</strong> – If <code class="docutils literal notranslate"><span class="pre">True</span></code> (the default), also enable whitespace skipping in child elements (if any)</td> </tr> </tbody> </table> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseElementEnhance.leaveWhitespace"> <code class="descname">leaveWhitespace</code><span class="sig-paren">(</span><em>recursive: bool = True</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParseElementEnhance.leaveWhitespace" title="Permalink to this definition">¶</a></dt> <dd><p>Disables the skipping of whitespace before matching the characters in the <a class="reference internal" href="#pyparsing.ParserElement" title="pyparsing.ParserElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement</span></code></a>’s defined pattern. This is normally only used internally by the pyparsing module, but may be needed in some whitespace-sensitive grammars.</p> <table class="docutils field-list" frame="void" rules="none"> <col class="field-name" /> <col class="field-body" /> <tbody valign="top"> <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>recursive</strong> – If true (the default), also disable whitespace skipping in child elements (if any)</td> </tr> </tbody> </table> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseElementEnhance.leave_whitespace"> <code class="descname">leave_whitespace</code><span class="sig-paren">(</span><em>recursive: bool = True</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParseElementEnhance.leave_whitespace" title="Permalink to this definition">¶</a></dt> <dd><p>Disables the skipping of whitespace before matching the characters in the <a class="reference internal" href="#pyparsing.ParserElement" title="pyparsing.ParserElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement</span></code></a>’s defined pattern. This is normally only used internally by the pyparsing module, but may be needed in some whitespace-sensitive grammars.</p> <table class="docutils field-list" frame="void" rules="none"> <col class="field-name" /> <col class="field-body" /> <tbody valign="top"> <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>recursive</strong> – If true (the default), also disable whitespace skipping in child elements (if any)</td> </tr> </tbody> </table> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseElementEnhance.validate"> <code class="descname">validate</code><span class="sig-paren">(</span><em>validateTrace=None</em><span class="sig-paren">)</span> → None<a class="headerlink" href="#pyparsing.ParseElementEnhance.validate" title="Permalink to this definition">¶</a></dt> <dd><p>Check defined expressions for valid structure, check for infinite recursive definitions.</p> </dd></dl> </dd></dl> <dl class="exception"> <dt id="pyparsing.ParseException"> <em class="property">exception </em><code class="descclassname">pyparsing.</code><code class="descname">ParseException</code><span class="sig-paren">(</span><em>pstr: str</em>, <em>loc: int = 0</em>, <em>msg: Union[str</em>, <em>NoneType] = None</em>, <em>elem=None</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.ParseException" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.exceptions.ParseBaseException</span></code></p> <p>Exception thrown when a parse expression doesn’t match the input string</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">try</span><span class="p">:</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span><span class="o">.</span><span class="n">set_name</span><span class="p">(</span><span class="s2">"integer"</span><span class="p">)</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"ABC"</span><span class="p">)</span> <span class="k">except</span> <span class="n">ParseException</span> <span class="k">as</span> <span class="n">pe</span><span class="p">:</span> <span class="nb">print</span><span class="p">(</span><span class="n">pe</span><span class="p">)</span> <span class="nb">print</span><span class="p">(</span><span class="s2">"column: </span><span class="si">{}</span><span class="s2">"</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">pe</span><span class="o">.</span><span class="n">column</span><span class="p">))</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">Expected</span> <span class="n">integer</span> <span class="p">(</span><span class="n">at</span> <span class="n">char</span> <span class="mi">0</span><span class="p">),</span> <span class="p">(</span><span class="n">line</span><span class="p">:</span><span class="mi">1</span><span class="p">,</span> <span class="n">col</span><span class="p">:</span><span class="mi">1</span><span class="p">)</span> <span class="n">column</span><span class="p">:</span> <span class="mi">1</span> </pre></div> </div> </dd></dl> <dl class="class"> <dt id="pyparsing.ParseExpression"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">ParseExpression</code><span class="sig-paren">(</span><em>exprs: Iterable[pyparsing.core.ParserElement], savelist: bool = False</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.ParseExpression" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.ParserElement</span></code></p> <p>Abstract subclass of ParserElement, for combining and post-processing parsed tokens.</p> <dl class="method"> <dt id="pyparsing.ParseExpression.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>exprs: Iterable[pyparsing.core.ParserElement], savelist: bool = False</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.ParseExpression.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseExpression.copy"> <code class="descname">copy</code><span class="sig-paren">(</span><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParseExpression.copy" title="Permalink to this definition">¶</a></dt> <dd><p>Make a copy of this <a class="reference internal" href="#pyparsing.ParserElement" title="pyparsing.ParserElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement</span></code></a>. Useful for defining different parse actions for the same parsing pattern, using copies of the original parse element.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">integer</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="k">lambda</span> <span class="n">toks</span><span class="p">:</span> <span class="nb">int</span><span class="p">(</span><span class="n">toks</span><span class="p">[</span><span class="mi">0</span><span class="p">]))</span> <span class="n">integerK</span> <span class="o">=</span> <span class="n">integer</span><span class="o">.</span><span class="n">copy</span><span class="p">()</span><span class="o">.</span><span class="n">add_parse_action</span><span class="p">(</span><span class="k">lambda</span> <span class="n">toks</span><span class="p">:</span> <span class="n">toks</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">*</span> <span class="mi">1024</span><span class="p">)</span> <span class="o">+</span> <span class="n">Suppress</span><span class="p">(</span><span class="s2">"K"</span><span class="p">)</span> <span class="n">integerM</span> <span class="o">=</span> <span class="n">integer</span><span class="o">.</span><span class="n">copy</span><span class="p">()</span><span class="o">.</span><span class="n">add_parse_action</span><span class="p">(</span><span class="k">lambda</span> <span class="n">toks</span><span class="p">:</span> <span class="n">toks</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">*</span> <span class="mi">1024</span> <span class="o">*</span> <span class="mi">1024</span><span class="p">)</span> <span class="o">+</span> <span class="n">Suppress</span><span class="p">(</span><span class="s2">"M"</span><span class="p">)</span> <span class="nb">print</span><span class="p">((</span><span class="n">integerK</span> <span class="o">|</span> <span class="n">integerM</span> <span class="o">|</span> <span class="n">integer</span><span class="p">)[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"5K 100 640K 256M"</span><span class="p">))</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="mi">5120</span><span class="p">,</span> <span class="mi">100</span><span class="p">,</span> <span class="mi">655360</span><span class="p">,</span> <span class="mi">268435456</span><span class="p">]</span> </pre></div> </div> <p>Equivalent form of <code class="docutils literal notranslate"><span class="pre">expr.copy()</span></code> is just <code class="docutils literal notranslate"><span class="pre">expr()</span></code>:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">integerM</span> <span class="o">=</span> <span class="n">integer</span><span class="p">()</span><span class="o">.</span><span class="n">add_parse_action</span><span class="p">(</span><span class="k">lambda</span> <span class="n">toks</span><span class="p">:</span> <span class="n">toks</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">*</span> <span class="mi">1024</span> <span class="o">*</span> <span class="mi">1024</span><span class="p">)</span> <span class="o">+</span> <span class="n">Suppress</span><span class="p">(</span><span class="s2">"M"</span><span class="p">)</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseExpression.ignore"> <code class="descname">ignore</code><span class="sig-paren">(</span><em>other</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParseExpression.ignore" title="Permalink to this definition">¶</a></dt> <dd><p>Define expression to be ignored (e.g., comments) while doing pattern matching; may be called repeatedly, to define multiple comment or other ignorable patterns.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">patt</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span> <span class="n">patt</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s1">'ablaj /* comment */ lskjd'</span><span class="p">)</span> <span class="c1"># -> ['ablaj']</span> <span class="n">patt</span><span class="o">.</span><span class="n">ignore</span><span class="p">(</span><span class="n">c_style_comment</span><span class="p">)</span> <span class="n">patt</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s1">'ablaj /* comment */ lskjd'</span><span class="p">)</span> <span class="c1"># -> ['ablaj', 'lskjd']</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseExpression.ignoreWhitespace"> <code class="descname">ignoreWhitespace</code><span class="sig-paren">(</span><em>recursive: bool = True</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParseExpression.ignoreWhitespace" title="Permalink to this definition">¶</a></dt> <dd><dl class="docutils"> <dt>Extends <code class="docutils literal notranslate"><span class="pre">ignore_whitespace</span></code> defined in base class, and also invokes <code class="docutils literal notranslate"><span class="pre">leave_whitespace</span></code> on</dt> <dd>all contained expressions.</dd> </dl> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseExpression.ignore_whitespace"> <code class="descname">ignore_whitespace</code><span class="sig-paren">(</span><em>recursive: bool = True</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParseExpression.ignore_whitespace" title="Permalink to this definition">¶</a></dt> <dd><dl class="docutils"> <dt>Extends <code class="docutils literal notranslate"><span class="pre">ignore_whitespace</span></code> defined in base class, and also invokes <code class="docutils literal notranslate"><span class="pre">leave_whitespace</span></code> on</dt> <dd>all contained expressions.</dd> </dl> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseExpression.leaveWhitespace"> <code class="descname">leaveWhitespace</code><span class="sig-paren">(</span><em>recursive: bool = True</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParseExpression.leaveWhitespace" title="Permalink to this definition">¶</a></dt> <dd><dl class="docutils"> <dt>Extends <code class="docutils literal notranslate"><span class="pre">leave_whitespace</span></code> defined in base class, and also invokes <code class="docutils literal notranslate"><span class="pre">leave_whitespace</span></code> on</dt> <dd>all contained expressions.</dd> </dl> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseExpression.leave_whitespace"> <code class="descname">leave_whitespace</code><span class="sig-paren">(</span><em>recursive: bool = True</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParseExpression.leave_whitespace" title="Permalink to this definition">¶</a></dt> <dd><dl class="docutils"> <dt>Extends <code class="docutils literal notranslate"><span class="pre">leave_whitespace</span></code> defined in base class, and also invokes <code class="docutils literal notranslate"><span class="pre">leave_whitespace</span></code> on</dt> <dd>all contained expressions.</dd> </dl> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseExpression.validate"> <code class="descname">validate</code><span class="sig-paren">(</span><em>validateTrace=None</em><span class="sig-paren">)</span> → None<a class="headerlink" href="#pyparsing.ParseExpression.validate" title="Permalink to this definition">¶</a></dt> <dd><p>Check defined expressions for valid structure, check for infinite recursive definitions.</p> </dd></dl> </dd></dl> <dl class="exception"> <dt id="pyparsing.ParseFatalException"> <em class="property">exception </em><code class="descclassname">pyparsing.</code><code class="descname">ParseFatalException</code><span class="sig-paren">(</span><em>pstr: str</em>, <em>loc: int = 0</em>, <em>msg: Union[str</em>, <em>NoneType] = None</em>, <em>elem=None</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.ParseFatalException" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.exceptions.ParseBaseException</span></code></p> <p>User-throwable exception thrown when inconsistent parse content is found; stops all parsing immediately</p> </dd></dl> <dl class="class"> <dt id="pyparsing.ParseResults"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">ParseResults</code><span class="sig-paren">(</span><em>toklist=None</em>, <em>name=None</em>, <em>asList=True</em>, <em>modal=True</em>, <em>isinstance=<built-in function isinstance></em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.ParseResults" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">object</span></code></p> <p>Structured parse results, to provide multiple means of access to the parsed data:</p> <ul class="simple"> <li>as a list (<code class="docutils literal notranslate"><span class="pre">len(results)</span></code>)</li> <li>by list index (<code class="docutils literal notranslate"><span class="pre">results[0],</span> <span class="pre">results[1]</span></code>, etc.)</li> <li>by attribute (<code class="docutils literal notranslate"><span class="pre">results.<results_name></span></code> - see <a class="reference internal" href="#pyparsing.ParserElement.set_results_name" title="pyparsing.ParserElement.set_results_name"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement.set_results_name</span></code></a>)</li> </ul> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">integer</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="n">date_str</span> <span class="o">=</span> <span class="p">(</span><span class="n">integer</span><span class="o">.</span><span class="n">set_results_name</span><span class="p">(</span><span class="s2">"year"</span><span class="p">)</span> <span class="o">+</span> <span class="s1">'/'</span> <span class="o">+</span> <span class="n">integer</span><span class="o">.</span><span class="n">set_results_name</span><span class="p">(</span><span class="s2">"month"</span><span class="p">)</span> <span class="o">+</span> <span class="s1">'/'</span> <span class="o">+</span> <span class="n">integer</span><span class="o">.</span><span class="n">set_results_name</span><span class="p">(</span><span class="s2">"day"</span><span class="p">))</span> <span class="c1"># equivalent form:</span> <span class="c1"># date_str = (integer("year") + '/'</span> <span class="c1"># + integer("month") + '/'</span> <span class="c1"># + integer("day"))</span> <span class="c1"># parse_string returns a ParseResults object</span> <span class="n">result</span> <span class="o">=</span> <span class="n">date_str</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"1999/12/31"</span><span class="p">)</span> <span class="k">def</span> <span class="nf">test</span><span class="p">(</span><span class="n">s</span><span class="p">,</span> <span class="n">fn</span><span class="o">=</span><span class="nb">repr</span><span class="p">):</span> <span class="nb">print</span><span class="p">(</span><span class="s2">"</span><span class="si">{}</span><span class="s2"> -> </span><span class="si">{}</span><span class="s2">"</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">s</span><span class="p">,</span> <span class="n">fn</span><span class="p">(</span><span class="nb">eval</span><span class="p">(</span><span class="n">s</span><span class="p">))))</span> <span class="n">test</span><span class="p">(</span><span class="s2">"list(result)"</span><span class="p">)</span> <span class="n">test</span><span class="p">(</span><span class="s2">"result[0]"</span><span class="p">)</span> <span class="n">test</span><span class="p">(</span><span class="s2">"result['month']"</span><span class="p">)</span> <span class="n">test</span><span class="p">(</span><span class="s2">"result.day"</span><span class="p">)</span> <span class="n">test</span><span class="p">(</span><span class="s2">"'month' in result"</span><span class="p">)</span> <span class="n">test</span><span class="p">(</span><span class="s2">"'minutes' in result"</span><span class="p">)</span> <span class="n">test</span><span class="p">(</span><span class="s2">"result.dump()"</span><span class="p">,</span> <span class="nb">str</span><span class="p">)</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="nb">list</span><span class="p">(</span><span class="n">result</span><span class="p">)</span> <span class="o">-></span> <span class="p">[</span><span class="s1">'1999'</span><span class="p">,</span> <span class="s1">'/'</span><span class="p">,</span> <span class="s1">'12'</span><span class="p">,</span> <span class="s1">'/'</span><span class="p">,</span> <span class="s1">'31'</span><span class="p">]</span> <span class="n">result</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">-></span> <span class="s1">'1999'</span> <span class="n">result</span><span class="p">[</span><span class="s1">'month'</span><span class="p">]</span> <span class="o">-></span> <span class="s1">'12'</span> <span class="n">result</span><span class="o">.</span><span class="n">day</span> <span class="o">-></span> <span class="s1">'31'</span> <span class="s1">'month'</span> <span class="ow">in</span> <span class="n">result</span> <span class="o">-></span> <span class="kc">True</span> <span class="s1">'minutes'</span> <span class="ow">in</span> <span class="n">result</span> <span class="o">-></span> <span class="kc">False</span> <span class="n">result</span><span class="o">.</span><span class="n">dump</span><span class="p">()</span> <span class="o">-></span> <span class="p">[</span><span class="s1">'1999'</span><span class="p">,</span> <span class="s1">'/'</span><span class="p">,</span> <span class="s1">'12'</span><span class="p">,</span> <span class="s1">'/'</span><span class="p">,</span> <span class="s1">'31'</span><span class="p">]</span> <span class="o">-</span> <span class="n">day</span><span class="p">:</span> <span class="s1">'31'</span> <span class="o">-</span> <span class="n">month</span><span class="p">:</span> <span class="s1">'12'</span> <span class="o">-</span> <span class="n">year</span><span class="p">:</span> <span class="s1">'1999'</span> </pre></div> </div> <dl class="class"> <dt id="pyparsing.ParseResults.List"> <em class="property">class </em><code class="descname">List</code><a class="headerlink" href="#pyparsing.ParseResults.List" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">list</span></code></p> <p>Simple wrapper class to distinguish parsed list results that should be preserved as actual Python lists, instead of being converted to <a class="reference internal" href="#pyparsing.ParseResults" title="pyparsing.ParseResults"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParseResults</span></code></a>:</p> <blockquote> <div><p>LBRACK, RBRACK = map(pp.Suppress, “[]”) element = pp.Forward() item = ppc.integer element_list = LBRACK + pp.delimited_list(element) + RBRACK</p> <p># add parse actions to convert from ParseResults to actual Python collection types def as_python_list(t):</p> <blockquote> <div>return pp.ParseResults.List(t.as_list())</div></blockquote> <p>element_list.add_parse_action(as_python_list)</p> <p>element <<= item | element_list</p> <dl class="docutils"> <dt>element.run_tests(‘’‘</dt> <dd>100 [2,3,4] [[2, 1],3,4] [(2, 1),3,4] (2,3,4) ‘’‘, post_parse=lambda s, r: (r[0], type(r[0])))</dd> </dl> </div></blockquote> <p>prints:</p> <blockquote> <div><p>100 (100, <class ‘int’>)</p> <p>[2,3,4] ([2, 3, 4], <class ‘list’>)</p> <p>[[2, 1],3,4] ([[2, 1], 3, 4], <class ‘list’>)</p> </div></blockquote> <p>(Used internally by <a class="reference internal" href="#pyparsing.Group" title="pyparsing.Group"><code class="xref py py-class docutils literal notranslate"><span class="pre">Group</span></code></a> when <cite>aslist=True</cite>.)</p> <dl class="staticmethod"> <dt id="pyparsing.ParseResults.List.__new__"> <em class="property">static </em><code class="descname">__new__</code><span class="sig-paren">(</span><em>cls</em>, <em>contained=None</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.ParseResults.List.__new__" title="Permalink to this definition">¶</a></dt> <dd><p>Create and return a new object. See help(type) for accurate signature.</p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.ParseResults.List.__weakref__"> <code class="descname">__weakref__</code><a class="headerlink" href="#pyparsing.ParseResults.List.__weakref__" title="Permalink to this definition">¶</a></dt> <dd><p>list of weak references to the object (if defined)</p> </dd></dl> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseResults.__dir__"> <code class="descname">__dir__</code><span class="sig-paren">(</span><span class="sig-paren">)</span> → list<a class="headerlink" href="#pyparsing.ParseResults.__dir__" title="Permalink to this definition">¶</a></dt> <dd><p>default dir() implementation</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseResults.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>toklist=None</em>, <em>name=None</em>, <em>asList=True</em>, <em>modal=True</em>, <em>isinstance=<built-in function isinstance></em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.ParseResults.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> <dl class="staticmethod"> <dt id="pyparsing.ParseResults.__new__"> <em class="property">static </em><code class="descname">__new__</code><span class="sig-paren">(</span><em>cls</em>, <em>toklist=None</em>, <em>name=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.ParseResults.__new__" title="Permalink to this definition">¶</a></dt> <dd><p>Create and return a new object. See help(type) for accurate signature.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseResults.__repr__"> <code class="descname">__repr__</code><span class="sig-paren">(</span><span class="sig-paren">)</span> → str<a class="headerlink" href="#pyparsing.ParseResults.__repr__" title="Permalink to this definition">¶</a></dt> <dd><p>Return repr(self).</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseResults.__str__"> <code class="descname">__str__</code><span class="sig-paren">(</span><span class="sig-paren">)</span> → str<a class="headerlink" href="#pyparsing.ParseResults.__str__" title="Permalink to this definition">¶</a></dt> <dd><p>Return str(self).</p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.ParseResults.__weakref__"> <code class="descname">__weakref__</code><a class="headerlink" href="#pyparsing.ParseResults.__weakref__" title="Permalink to this definition">¶</a></dt> <dd><p>list of weak references to the object (if defined)</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseResults.append"> <code class="descname">append</code><span class="sig-paren">(</span><em>item</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.ParseResults.append" title="Permalink to this definition">¶</a></dt> <dd><p>Add single element to end of <code class="docutils literal notranslate"><span class="pre">ParseResults</span></code> list of elements.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">numlist</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)[</span><span class="o">...</span><span class="p">]</span> <span class="nb">print</span><span class="p">(</span><span class="n">numlist</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"0 123 321"</span><span class="p">))</span> <span class="c1"># -> ['0', '123', '321']</span> <span class="c1"># use a parse action to compute the sum of the parsed integers, and add it to the end</span> <span class="k">def</span> <span class="nf">append_sum</span><span class="p">(</span><span class="n">tokens</span><span class="p">):</span> <span class="n">tokens</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="nb">sum</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="nb">int</span><span class="p">,</span> <span class="n">tokens</span><span class="p">)))</span> <span class="n">numlist</span><span class="o">.</span><span class="n">add_parse_action</span><span class="p">(</span><span class="n">append_sum</span><span class="p">)</span> <span class="nb">print</span><span class="p">(</span><span class="n">numlist</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"0 123 321"</span><span class="p">))</span> <span class="c1"># -> ['0', '123', '321', 444]</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseResults.asDict"> <code class="descname">asDict</code><span class="sig-paren">(</span><span class="sig-paren">)</span> → dict<a class="headerlink" href="#pyparsing.ParseResults.asDict" title="Permalink to this definition">¶</a></dt> <dd><p>Returns the named parse results as a nested dictionary.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">integer</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="n">date_str</span> <span class="o">=</span> <span class="n">integer</span><span class="p">(</span><span class="s2">"year"</span><span class="p">)</span> <span class="o">+</span> <span class="s1">'/'</span> <span class="o">+</span> <span class="n">integer</span><span class="p">(</span><span class="s2">"month"</span><span class="p">)</span> <span class="o">+</span> <span class="s1">'/'</span> <span class="o">+</span> <span class="n">integer</span><span class="p">(</span><span class="s2">"day"</span><span class="p">)</span> <span class="n">result</span> <span class="o">=</span> <span class="n">date_str</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s1">'12/31/1999'</span><span class="p">)</span> <span class="nb">print</span><span class="p">(</span><span class="nb">type</span><span class="p">(</span><span class="n">result</span><span class="p">),</span> <span class="nb">repr</span><span class="p">(</span><span class="n">result</span><span class="p">))</span> <span class="c1"># -> <class 'pyparsing.ParseResults'> (['12', '/', '31', '/', '1999'], {'day': [('1999', 4)], 'year': [('12', 0)], 'month': [('31', 2)]})</span> <span class="n">result_dict</span> <span class="o">=</span> <span class="n">result</span><span class="o">.</span><span class="n">as_dict</span><span class="p">()</span> <span class="nb">print</span><span class="p">(</span><span class="nb">type</span><span class="p">(</span><span class="n">result_dict</span><span class="p">),</span> <span class="nb">repr</span><span class="p">(</span><span class="n">result_dict</span><span class="p">))</span> <span class="c1"># -> <class 'dict'> {'day': '1999', 'year': '12', 'month': '31'}</span> <span class="c1"># even though a ParseResults supports dict-like access, sometime you just need to have a dict</span> <span class="kn">import</span> <span class="nn">json</span> <span class="nb">print</span><span class="p">(</span><span class="n">json</span><span class="o">.</span><span class="n">dumps</span><span class="p">(</span><span class="n">result</span><span class="p">))</span> <span class="c1"># -> Exception: TypeError: ... is not JSON serializable</span> <span class="nb">print</span><span class="p">(</span><span class="n">json</span><span class="o">.</span><span class="n">dumps</span><span class="p">(</span><span class="n">result</span><span class="o">.</span><span class="n">as_dict</span><span class="p">()))</span> <span class="c1"># -> {"month": "31", "day": "1999", "year": "12"}</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseResults.asList"> <code class="descname">asList</code><span class="sig-paren">(</span><span class="sig-paren">)</span> → list<a class="headerlink" href="#pyparsing.ParseResults.asList" title="Permalink to this definition">¶</a></dt> <dd><p>Returns the parse results as a nested list of matching tokens, all converted to strings.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">patt</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span> <span class="n">result</span> <span class="o">=</span> <span class="n">patt</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"sldkj lsdkj sldkj"</span><span class="p">)</span> <span class="c1"># even though the result prints in string-like form, it is actually a pyparsing ParseResults</span> <span class="nb">print</span><span class="p">(</span><span class="nb">type</span><span class="p">(</span><span class="n">result</span><span class="p">),</span> <span class="n">result</span><span class="p">)</span> <span class="c1"># -> <class 'pyparsing.ParseResults'> ['sldkj', 'lsdkj', 'sldkj']</span> <span class="c1"># Use as_list() to create an actual list</span> <span class="n">result_list</span> <span class="o">=</span> <span class="n">result</span><span class="o">.</span><span class="n">as_list</span><span class="p">()</span> <span class="nb">print</span><span class="p">(</span><span class="nb">type</span><span class="p">(</span><span class="n">result_list</span><span class="p">),</span> <span class="n">result_list</span><span class="p">)</span> <span class="c1"># -> <class 'list'> ['sldkj', 'lsdkj', 'sldkj']</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseResults.as_dict"> <code class="descname">as_dict</code><span class="sig-paren">(</span><span class="sig-paren">)</span> → dict<a class="headerlink" href="#pyparsing.ParseResults.as_dict" title="Permalink to this definition">¶</a></dt> <dd><p>Returns the named parse results as a nested dictionary.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">integer</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="n">date_str</span> <span class="o">=</span> <span class="n">integer</span><span class="p">(</span><span class="s2">"year"</span><span class="p">)</span> <span class="o">+</span> <span class="s1">'/'</span> <span class="o">+</span> <span class="n">integer</span><span class="p">(</span><span class="s2">"month"</span><span class="p">)</span> <span class="o">+</span> <span class="s1">'/'</span> <span class="o">+</span> <span class="n">integer</span><span class="p">(</span><span class="s2">"day"</span><span class="p">)</span> <span class="n">result</span> <span class="o">=</span> <span class="n">date_str</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s1">'12/31/1999'</span><span class="p">)</span> <span class="nb">print</span><span class="p">(</span><span class="nb">type</span><span class="p">(</span><span class="n">result</span><span class="p">),</span> <span class="nb">repr</span><span class="p">(</span><span class="n">result</span><span class="p">))</span> <span class="c1"># -> <class 'pyparsing.ParseResults'> (['12', '/', '31', '/', '1999'], {'day': [('1999', 4)], 'year': [('12', 0)], 'month': [('31', 2)]})</span> <span class="n">result_dict</span> <span class="o">=</span> <span class="n">result</span><span class="o">.</span><span class="n">as_dict</span><span class="p">()</span> <span class="nb">print</span><span class="p">(</span><span class="nb">type</span><span class="p">(</span><span class="n">result_dict</span><span class="p">),</span> <span class="nb">repr</span><span class="p">(</span><span class="n">result_dict</span><span class="p">))</span> <span class="c1"># -> <class 'dict'> {'day': '1999', 'year': '12', 'month': '31'}</span> <span class="c1"># even though a ParseResults supports dict-like access, sometime you just need to have a dict</span> <span class="kn">import</span> <span class="nn">json</span> <span class="nb">print</span><span class="p">(</span><span class="n">json</span><span class="o">.</span><span class="n">dumps</span><span class="p">(</span><span class="n">result</span><span class="p">))</span> <span class="c1"># -> Exception: TypeError: ... is not JSON serializable</span> <span class="nb">print</span><span class="p">(</span><span class="n">json</span><span class="o">.</span><span class="n">dumps</span><span class="p">(</span><span class="n">result</span><span class="o">.</span><span class="n">as_dict</span><span class="p">()))</span> <span class="c1"># -> {"month": "31", "day": "1999", "year": "12"}</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseResults.as_list"> <code class="descname">as_list</code><span class="sig-paren">(</span><span class="sig-paren">)</span> → list<a class="headerlink" href="#pyparsing.ParseResults.as_list" title="Permalink to this definition">¶</a></dt> <dd><p>Returns the parse results as a nested list of matching tokens, all converted to strings.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">patt</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span> <span class="n">result</span> <span class="o">=</span> <span class="n">patt</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"sldkj lsdkj sldkj"</span><span class="p">)</span> <span class="c1"># even though the result prints in string-like form, it is actually a pyparsing ParseResults</span> <span class="nb">print</span><span class="p">(</span><span class="nb">type</span><span class="p">(</span><span class="n">result</span><span class="p">),</span> <span class="n">result</span><span class="p">)</span> <span class="c1"># -> <class 'pyparsing.ParseResults'> ['sldkj', 'lsdkj', 'sldkj']</span> <span class="c1"># Use as_list() to create an actual list</span> <span class="n">result_list</span> <span class="o">=</span> <span class="n">result</span><span class="o">.</span><span class="n">as_list</span><span class="p">()</span> <span class="nb">print</span><span class="p">(</span><span class="nb">type</span><span class="p">(</span><span class="n">result_list</span><span class="p">),</span> <span class="n">result_list</span><span class="p">)</span> <span class="c1"># -> <class 'list'> ['sldkj', 'lsdkj', 'sldkj']</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseResults.clear"> <code class="descname">clear</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.ParseResults.clear" title="Permalink to this definition">¶</a></dt> <dd><p>Clear all elements and results names.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseResults.copy"> <code class="descname">copy</code><span class="sig-paren">(</span><span class="sig-paren">)</span> → pyparsing.results.ParseResults<a class="headerlink" href="#pyparsing.ParseResults.copy" title="Permalink to this definition">¶</a></dt> <dd><p>Returns a new copy of a <a class="reference internal" href="#pyparsing.ParseResults" title="pyparsing.ParseResults"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParseResults</span></code></a> object.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseResults.dump"> <code class="descname">dump</code><span class="sig-paren">(</span><em>indent=''</em>, <em>full=True</em>, <em>include_list=True</em>, <em>_depth=0</em><span class="sig-paren">)</span> → str<a class="headerlink" href="#pyparsing.ParseResults.dump" title="Permalink to this definition">¶</a></dt> <dd><p>Diagnostic method for listing out the contents of a <a class="reference internal" href="#pyparsing.ParseResults" title="pyparsing.ParseResults"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParseResults</span></code></a>. Accepts an optional <code class="docutils literal notranslate"><span class="pre">indent</span></code> argument so that this string can be embedded in a nested display of other data.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">integer</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="n">date_str</span> <span class="o">=</span> <span class="n">integer</span><span class="p">(</span><span class="s2">"year"</span><span class="p">)</span> <span class="o">+</span> <span class="s1">'/'</span> <span class="o">+</span> <span class="n">integer</span><span class="p">(</span><span class="s2">"month"</span><span class="p">)</span> <span class="o">+</span> <span class="s1">'/'</span> <span class="o">+</span> <span class="n">integer</span><span class="p">(</span><span class="s2">"day"</span><span class="p">)</span> <span class="n">result</span> <span class="o">=</span> <span class="n">date_str</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s1">'1999/12/31'</span><span class="p">)</span> <span class="nb">print</span><span class="p">(</span><span class="n">result</span><span class="o">.</span><span class="n">dump</span><span class="p">())</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="s1">'1999'</span><span class="p">,</span> <span class="s1">'/'</span><span class="p">,</span> <span class="s1">'12'</span><span class="p">,</span> <span class="s1">'/'</span><span class="p">,</span> <span class="s1">'31'</span><span class="p">]</span> <span class="o">-</span> <span class="n">day</span><span class="p">:</span> <span class="s1">'31'</span> <span class="o">-</span> <span class="n">month</span><span class="p">:</span> <span class="s1">'12'</span> <span class="o">-</span> <span class="n">year</span><span class="p">:</span> <span class="s1">'1999'</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseResults.extend"> <code class="descname">extend</code><span class="sig-paren">(</span><em>itemseq</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.ParseResults.extend" title="Permalink to this definition">¶</a></dt> <dd><p>Add sequence of elements to end of <code class="docutils literal notranslate"><span class="pre">ParseResults</span></code> list of elements.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">patt</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span> <span class="c1"># use a parse action to append the reverse of the matched strings, to make a palindrome</span> <span class="k">def</span> <span class="nf">make_palindrome</span><span class="p">(</span><span class="n">tokens</span><span class="p">):</span> <span class="n">tokens</span><span class="o">.</span><span class="n">extend</span><span class="p">(</span><span class="nb">reversed</span><span class="p">([</span><span class="n">t</span><span class="p">[::</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span> <span class="k">for</span> <span class="n">t</span> <span class="ow">in</span> <span class="n">tokens</span><span class="p">]))</span> <span class="k">return</span> <span class="s1">''</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">tokens</span><span class="p">)</span> <span class="n">patt</span><span class="o">.</span><span class="n">add_parse_action</span><span class="p">(</span><span class="n">make_palindrome</span><span class="p">)</span> <span class="nb">print</span><span class="p">(</span><span class="n">patt</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"lskdj sdlkjf lksd"</span><span class="p">))</span> <span class="c1"># -> 'lskdjsdlkjflksddsklfjkldsjdksl'</span> </pre></div> </div> </dd></dl> <dl class="classmethod"> <dt id="pyparsing.ParseResults.from_dict"> <em class="property">classmethod </em><code class="descname">from_dict</code><span class="sig-paren">(</span><em>other</em>, <em>name=None</em><span class="sig-paren">)</span> → pyparsing.results.ParseResults<a class="headerlink" href="#pyparsing.ParseResults.from_dict" title="Permalink to this definition">¶</a></dt> <dd><p>Helper classmethod to construct a <code class="docutils literal notranslate"><span class="pre">ParseResults</span></code> from a <code class="docutils literal notranslate"><span class="pre">dict</span></code>, preserving the name-value relations as results names. If an optional <code class="docutils literal notranslate"><span class="pre">name</span></code> argument is given, a nested <code class="docutils literal notranslate"><span class="pre">ParseResults</span></code> will be returned.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseResults.get"> <code class="descname">get</code><span class="sig-paren">(</span><em>key</em>, <em>default_value=None</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.ParseResults.get" title="Permalink to this definition">¶</a></dt> <dd><p>Returns named result matching the given key, or if there is no such name, then returns the given <code class="docutils literal notranslate"><span class="pre">default_value</span></code> or <code class="docutils literal notranslate"><span class="pre">None</span></code> if no <code class="docutils literal notranslate"><span class="pre">default_value</span></code> is specified.</p> <p>Similar to <code class="docutils literal notranslate"><span class="pre">dict.get()</span></code>.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">integer</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="n">date_str</span> <span class="o">=</span> <span class="n">integer</span><span class="p">(</span><span class="s2">"year"</span><span class="p">)</span> <span class="o">+</span> <span class="s1">'/'</span> <span class="o">+</span> <span class="n">integer</span><span class="p">(</span><span class="s2">"month"</span><span class="p">)</span> <span class="o">+</span> <span class="s1">'/'</span> <span class="o">+</span> <span class="n">integer</span><span class="p">(</span><span class="s2">"day"</span><span class="p">)</span> <span class="n">result</span> <span class="o">=</span> <span class="n">date_str</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"1999/12/31"</span><span class="p">)</span> <span class="nb">print</span><span class="p">(</span><span class="n">result</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s2">"year"</span><span class="p">))</span> <span class="c1"># -> '1999'</span> <span class="nb">print</span><span class="p">(</span><span class="n">result</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s2">"hour"</span><span class="p">,</span> <span class="s2">"not specified"</span><span class="p">))</span> <span class="c1"># -> 'not specified'</span> <span class="nb">print</span><span class="p">(</span><span class="n">result</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s2">"hour"</span><span class="p">))</span> <span class="c1"># -> None</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseResults.getName"> <code class="descname">getName</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.ParseResults.getName" title="Permalink to this definition">¶</a></dt> <dd><p>Returns the results name for this token expression. Useful when several different expressions might match at a particular location.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">integer</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="n">ssn_expr</span> <span class="o">=</span> <span class="n">Regex</span><span class="p">(</span><span class="sa">r</span><span class="s2">"\d\d\d-\d\d-\d\d\d\d"</span><span class="p">)</span> <span class="n">house_number_expr</span> <span class="o">=</span> <span class="n">Suppress</span><span class="p">(</span><span class="s1">'#'</span><span class="p">)</span> <span class="o">+</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">,</span> <span class="n">alphanums</span><span class="p">)</span> <span class="n">user_data</span> <span class="o">=</span> <span class="p">(</span><span class="n">Group</span><span class="p">(</span><span class="n">house_number_expr</span><span class="p">)(</span><span class="s2">"house_number"</span><span class="p">)</span> <span class="o">|</span> <span class="n">Group</span><span class="p">(</span><span class="n">ssn_expr</span><span class="p">)(</span><span class="s2">"ssn"</span><span class="p">)</span> <span class="o">|</span> <span class="n">Group</span><span class="p">(</span><span class="n">integer</span><span class="p">)(</span><span class="s2">"age"</span><span class="p">))</span> <span class="n">user_info</span> <span class="o">=</span> <span class="n">user_data</span><span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span> <span class="n">result</span> <span class="o">=</span> <span class="n">user_info</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"22 111-22-3333 #221B"</span><span class="p">)</span> <span class="k">for</span> <span class="n">item</span> <span class="ow">in</span> <span class="n">result</span><span class="p">:</span> <span class="nb">print</span><span class="p">(</span><span class="n">item</span><span class="o">.</span><span class="n">get_name</span><span class="p">(),</span> <span class="s1">':'</span><span class="p">,</span> <span class="n">item</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">age</span> <span class="p">:</span> <span class="mi">22</span> <span class="n">ssn</span> <span class="p">:</span> <span class="mi">111</span><span class="o">-</span><span class="mi">22</span><span class="o">-</span><span class="mi">3333</span> <span class="n">house_number</span> <span class="p">:</span> <span class="mi">221</span><span class="n">B</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseResults.get_name"> <code class="descname">get_name</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.ParseResults.get_name" title="Permalink to this definition">¶</a></dt> <dd><p>Returns the results name for this token expression. Useful when several different expressions might match at a particular location.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">integer</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="n">ssn_expr</span> <span class="o">=</span> <span class="n">Regex</span><span class="p">(</span><span class="sa">r</span><span class="s2">"\d\d\d-\d\d-\d\d\d\d"</span><span class="p">)</span> <span class="n">house_number_expr</span> <span class="o">=</span> <span class="n">Suppress</span><span class="p">(</span><span class="s1">'#'</span><span class="p">)</span> <span class="o">+</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">,</span> <span class="n">alphanums</span><span class="p">)</span> <span class="n">user_data</span> <span class="o">=</span> <span class="p">(</span><span class="n">Group</span><span class="p">(</span><span class="n">house_number_expr</span><span class="p">)(</span><span class="s2">"house_number"</span><span class="p">)</span> <span class="o">|</span> <span class="n">Group</span><span class="p">(</span><span class="n">ssn_expr</span><span class="p">)(</span><span class="s2">"ssn"</span><span class="p">)</span> <span class="o">|</span> <span class="n">Group</span><span class="p">(</span><span class="n">integer</span><span class="p">)(</span><span class="s2">"age"</span><span class="p">))</span> <span class="n">user_info</span> <span class="o">=</span> <span class="n">user_data</span><span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span> <span class="n">result</span> <span class="o">=</span> <span class="n">user_info</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"22 111-22-3333 #221B"</span><span class="p">)</span> <span class="k">for</span> <span class="n">item</span> <span class="ow">in</span> <span class="n">result</span><span class="p">:</span> <span class="nb">print</span><span class="p">(</span><span class="n">item</span><span class="o">.</span><span class="n">get_name</span><span class="p">(),</span> <span class="s1">':'</span><span class="p">,</span> <span class="n">item</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">age</span> <span class="p">:</span> <span class="mi">22</span> <span class="n">ssn</span> <span class="p">:</span> <span class="mi">111</span><span class="o">-</span><span class="mi">22</span><span class="o">-</span><span class="mi">3333</span> <span class="n">house_number</span> <span class="p">:</span> <span class="mi">221</span><span class="n">B</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseResults.haskeys"> <code class="descname">haskeys</code><span class="sig-paren">(</span><span class="sig-paren">)</span> → bool<a class="headerlink" href="#pyparsing.ParseResults.haskeys" title="Permalink to this definition">¶</a></dt> <dd><p>Since <code class="docutils literal notranslate"><span class="pre">keys()</span></code> returns an iterator, this method is helpful in bypassing code that looks for the existence of any defined results names.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseResults.insert"> <code class="descname">insert</code><span class="sig-paren">(</span><em>index</em>, <em>ins_string</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.ParseResults.insert" title="Permalink to this definition">¶</a></dt> <dd><p>Inserts new element at location index in the list of parsed tokens.</p> <p>Similar to <code class="docutils literal notranslate"><span class="pre">list.insert()</span></code>.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">numlist</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)[</span><span class="o">...</span><span class="p">]</span> <span class="nb">print</span><span class="p">(</span><span class="n">numlist</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"0 123 321"</span><span class="p">))</span> <span class="c1"># -> ['0', '123', '321']</span> <span class="c1"># use a parse action to insert the parse location in the front of the parsed results</span> <span class="k">def</span> <span class="nf">insert_locn</span><span class="p">(</span><span class="n">locn</span><span class="p">,</span> <span class="n">tokens</span><span class="p">):</span> <span class="n">tokens</span><span class="o">.</span><span class="n">insert</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="n">locn</span><span class="p">)</span> <span class="n">numlist</span><span class="o">.</span><span class="n">add_parse_action</span><span class="p">(</span><span class="n">insert_locn</span><span class="p">)</span> <span class="nb">print</span><span class="p">(</span><span class="n">numlist</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"0 123 321"</span><span class="p">))</span> <span class="c1"># -> [0, '0', '123', '321']</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseResults.pop"> <code class="descname">pop</code><span class="sig-paren">(</span><em>*args</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.ParseResults.pop" title="Permalink to this definition">¶</a></dt> <dd><p>Removes and returns item at specified index (default= <code class="docutils literal notranslate"><span class="pre">last</span></code>). Supports both <code class="docutils literal notranslate"><span class="pre">list</span></code> and <code class="docutils literal notranslate"><span class="pre">dict</span></code> semantics for <code class="docutils literal notranslate"><span class="pre">pop()</span></code>. If passed no argument or an integer argument, it will use <code class="docutils literal notranslate"><span class="pre">list</span></code> semantics and pop tokens from the list of parsed tokens. If passed a non-integer argument (most likely a string), it will use <code class="docutils literal notranslate"><span class="pre">dict</span></code> semantics and pop the corresponding value from any defined results names. A second default return value argument is supported, just as in <code class="docutils literal notranslate"><span class="pre">dict.pop()</span></code>.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">numlist</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)[</span><span class="o">...</span><span class="p">]</span> <span class="nb">print</span><span class="p">(</span><span class="n">numlist</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"0 123 321"</span><span class="p">))</span> <span class="c1"># -> ['0', '123', '321']</span> <span class="k">def</span> <span class="nf">remove_first</span><span class="p">(</span><span class="n">tokens</span><span class="p">):</span> <span class="n">tokens</span><span class="o">.</span><span class="n">pop</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span> <span class="n">numlist</span><span class="o">.</span><span class="n">add_parse_action</span><span class="p">(</span><span class="n">remove_first</span><span class="p">)</span> <span class="nb">print</span><span class="p">(</span><span class="n">numlist</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"0 123 321"</span><span class="p">))</span> <span class="c1"># -> ['123', '321']</span> <span class="n">label</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)</span> <span class="n">patt</span> <span class="o">=</span> <span class="n">label</span><span class="p">(</span><span class="s2">"LABEL"</span><span class="p">)</span> <span class="o">+</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span> <span class="nb">print</span><span class="p">(</span><span class="n">patt</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"AAB 123 321"</span><span class="p">)</span><span class="o">.</span><span class="n">dump</span><span class="p">())</span> <span class="c1"># Use pop() in a parse action to remove named result (note that corresponding value is not</span> <span class="c1"># removed from list form of results)</span> <span class="k">def</span> <span class="nf">remove_LABEL</span><span class="p">(</span><span class="n">tokens</span><span class="p">):</span> <span class="n">tokens</span><span class="o">.</span><span class="n">pop</span><span class="p">(</span><span class="s2">"LABEL"</span><span class="p">)</span> <span class="k">return</span> <span class="n">tokens</span> <span class="n">patt</span><span class="o">.</span><span class="n">add_parse_action</span><span class="p">(</span><span class="n">remove_LABEL</span><span class="p">)</span> <span class="nb">print</span><span class="p">(</span><span class="n">patt</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"AAB 123 321"</span><span class="p">)</span><span class="o">.</span><span class="n">dump</span><span class="p">())</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="s1">'AAB'</span><span class="p">,</span> <span class="s1">'123'</span><span class="p">,</span> <span class="s1">'321'</span><span class="p">]</span> <span class="o">-</span> <span class="n">LABEL</span><span class="p">:</span> <span class="s1">'AAB'</span> <span class="p">[</span><span class="s1">'AAB'</span><span class="p">,</span> <span class="s1">'123'</span><span class="p">,</span> <span class="s1">'321'</span><span class="p">]</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParseResults.pprint"> <code class="descname">pprint</code><span class="sig-paren">(</span><em>*args</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.ParseResults.pprint" title="Permalink to this definition">¶</a></dt> <dd><p>Pretty-printer for parsed results as a list, using the <a class="reference external" href="https://docs.python.org/3/library/pprint.html">pprint</a> module. Accepts additional positional or keyword args as defined for <a class="reference external" href="https://docs.python.org/3/library/pprint.html#pprint.pprint">pprint.pprint</a> .</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">ident</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">,</span> <span class="n">alphanums</span><span class="p">)</span> <span class="n">num</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="n">func</span> <span class="o">=</span> <span class="n">Forward</span><span class="p">()</span> <span class="n">term</span> <span class="o">=</span> <span class="n">ident</span> <span class="o">|</span> <span class="n">num</span> <span class="o">|</span> <span class="n">Group</span><span class="p">(</span><span class="s1">'('</span> <span class="o">+</span> <span class="n">func</span> <span class="o">+</span> <span class="s1">')'</span><span class="p">)</span> <span class="n">func</span> <span class="o"><<=</span> <span class="n">ident</span> <span class="o">+</span> <span class="n">Group</span><span class="p">(</span><span class="n">Optional</span><span class="p">(</span><span class="n">delimited_list</span><span class="p">(</span><span class="n">term</span><span class="p">)))</span> <span class="n">result</span> <span class="o">=</span> <span class="n">func</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"fna a,b,(fnb c,d,200),100"</span><span class="p">)</span> <span class="n">result</span><span class="o">.</span><span class="n">pprint</span><span class="p">(</span><span class="n">width</span><span class="o">=</span><span class="mi">40</span><span class="p">)</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="s1">'fna'</span><span class="p">,</span> <span class="p">[</span><span class="s1">'a'</span><span class="p">,</span> <span class="s1">'b'</span><span class="p">,</span> <span class="p">[</span><span class="s1">'('</span><span class="p">,</span> <span class="s1">'fnb'</span><span class="p">,</span> <span class="p">[</span><span class="s1">'c'</span><span class="p">,</span> <span class="s1">'d'</span><span class="p">,</span> <span class="s1">'200'</span><span class="p">],</span> <span class="s1">')'</span><span class="p">],</span> <span class="s1">'100'</span><span class="p">]]</span> </pre></div> </div> </dd></dl> </dd></dl> <dl class="exception"> <dt id="pyparsing.ParseSyntaxException"> <em class="property">exception </em><code class="descclassname">pyparsing.</code><code class="descname">ParseSyntaxException</code><span class="sig-paren">(</span><em>pstr: str</em>, <em>loc: int = 0</em>, <em>msg: Union[str</em>, <em>NoneType] = None</em>, <em>elem=None</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.ParseSyntaxException" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.exceptions.ParseFatalException</span></code></p> <p>Just like <a class="reference internal" href="#pyparsing.ParseFatalException" title="pyparsing.ParseFatalException"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParseFatalException</span></code></a>, but thrown internally when an <code class="xref py py-class docutils literal notranslate"><span class="pre">ErrorStop</span></code> (‘-‘ operator) indicates that parsing is to stop immediately because an unbacktrackable syntax error has been found.</p> </dd></dl> <dl class="class"> <dt id="pyparsing.ParserElement"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">ParserElement</code><span class="sig-paren">(</span><em>savelist: bool = False</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.ParserElement" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">abc.ABC</span></code></p> <p>Abstract base level parser element class.</p> <dl class="class"> <dt id="pyparsing.ParserElement.DebugActions"> <em class="property">class </em><code class="descname">DebugActions</code><span class="sig-paren">(</span><em>debug_try</em>, <em>debug_match</em>, <em>debug_fail</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.ParserElement.DebugActions" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">tuple</span></code></p> <dl class="method"> <dt id="pyparsing.ParserElement.DebugActions.__getnewargs__"> <code class="descname">__getnewargs__</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.ParserElement.DebugActions.__getnewargs__" title="Permalink to this definition">¶</a></dt> <dd><p>Return self as a plain tuple. Used by copy and pickle.</p> </dd></dl> <dl class="staticmethod"> <dt id="pyparsing.ParserElement.DebugActions.__new__"> <em class="property">static </em><code class="descname">__new__</code><span class="sig-paren">(</span><em>_cls, debug_try: Union[typing.Callable[[str, int, _ForwardRef('ParserElement'), bool], NoneType], NoneType], debug_match: Union[typing.Callable[[str, int, int, _ForwardRef('ParserElement'), pyparsing.results.ParseResults, bool], NoneType], NoneType], debug_fail: Union[typing.Callable[[str, int, _ForwardRef('ParserElement'), Exception, bool], NoneType], NoneType]</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.ParserElement.DebugActions.__new__" title="Permalink to this definition">¶</a></dt> <dd><p>Create new instance of DebugActions(debug_try, debug_match, debug_fail)</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.DebugActions.__repr__"> <code class="descname">__repr__</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.ParserElement.DebugActions.__repr__" title="Permalink to this definition">¶</a></dt> <dd><p>Return a nicely formatted representation string</p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.ParserElement.DebugActions.debug_fail"> <code class="descname">debug_fail</code><a class="headerlink" href="#pyparsing.ParserElement.DebugActions.debug_fail" title="Permalink to this definition">¶</a></dt> <dd><p>Alias for field number 2</p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.ParserElement.DebugActions.debug_match"> <code class="descname">debug_match</code><a class="headerlink" href="#pyparsing.ParserElement.DebugActions.debug_match" title="Permalink to this definition">¶</a></dt> <dd><p>Alias for field number 1</p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.ParserElement.DebugActions.debug_try"> <code class="descname">debug_try</code><a class="headerlink" href="#pyparsing.ParserElement.DebugActions.debug_try" title="Permalink to this definition">¶</a></dt> <dd><p>Alias for field number 0</p> </dd></dl> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.__add__"> <code class="descname">__add__</code><span class="sig-paren">(</span><em>other</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.__add__" title="Permalink to this definition">¶</a></dt> <dd><p>Implementation of <code class="docutils literal notranslate"><span class="pre">+</span></code> operator - returns <a class="reference internal" href="#pyparsing.And" title="pyparsing.And"><code class="xref py py-class docutils literal notranslate"><span class="pre">And</span></code></a>. Adding strings to a <a class="reference internal" href="#pyparsing.ParserElement" title="pyparsing.ParserElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement</span></code></a> converts them to :class:<a href="#id1"><span class="problematic" id="id2">`</span></a>Literal`s by default.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">greet</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)</span> <span class="o">+</span> <span class="s2">","</span> <span class="o">+</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)</span> <span class="o">+</span> <span class="s2">"!"</span> <span class="n">hello</span> <span class="o">=</span> <span class="s2">"Hello, World!"</span> <span class="nb">print</span><span class="p">(</span><span class="n">hello</span><span class="p">,</span> <span class="s2">"->"</span><span class="p">,</span> <span class="n">greet</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="n">hello</span><span class="p">))</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span>Hello, World! -> ['Hello', ',', 'World', '!'] </pre></div> </div> <p><code class="docutils literal notranslate"><span class="pre">...</span></code> may be used as a parse expression as a short form of <a class="reference internal" href="#pyparsing.SkipTo" title="pyparsing.SkipTo"><code class="xref py py-class docutils literal notranslate"><span class="pre">SkipTo</span></code></a>.</p> <blockquote> <div>Literal(‘start’) + … + Literal(‘end’)</div></blockquote> <p>is equivalent to:</p> <blockquote> <div>Literal(‘start’) + SkipTo(‘end’)(“_skipped*”) + Literal(‘end’)</div></blockquote> <p>Note that the skipped text is returned with ‘_skipped’ as a results name, and to support having multiple skips in the same parser, the value returned is a list of all skipped text.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.__and__"> <code class="descname">__and__</code><span class="sig-paren">(</span><em>other</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.__and__" title="Permalink to this definition">¶</a></dt> <dd><p>Implementation of <code class="docutils literal notranslate"><span class="pre">&</span></code> operator - returns <a class="reference internal" href="#pyparsing.Each" title="pyparsing.Each"><code class="xref py py-class docutils literal notranslate"><span class="pre">Each</span></code></a></p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.__call__"> <code class="descname">__call__</code><span class="sig-paren">(</span><em>name: str = None</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.__call__" title="Permalink to this definition">¶</a></dt> <dd><p>Shortcut for <a class="reference internal" href="#pyparsing.ParserElement.set_results_name" title="pyparsing.ParserElement.set_results_name"><code class="xref py py-class docutils literal notranslate"><span class="pre">set_results_name</span></code></a>, with <code class="docutils literal notranslate"><span class="pre">list_all_matches=False</span></code>.</p> <p>If <code class="docutils literal notranslate"><span class="pre">name</span></code> is given with a trailing <code class="docutils literal notranslate"><span class="pre">'*'</span></code> character, then <code class="docutils literal notranslate"><span class="pre">list_all_matches</span></code> will be passed as <code class="docutils literal notranslate"><span class="pre">True</span></code>.</p> <p>If <a href="#id3"><span class="problematic" id="id4">``</span></a>name` is omitted, same as calling <a class="reference internal" href="#pyparsing.ParserElement.copy" title="pyparsing.ParserElement.copy"><code class="xref py py-class docutils literal notranslate"><span class="pre">copy</span></code></a>.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># these are equivalent</span> <span class="n">userdata</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)</span><span class="o">.</span><span class="n">set_results_name</span><span class="p">(</span><span class="s2">"name"</span><span class="p">)</span> <span class="o">+</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span> <span class="o">+</span> <span class="s2">"-"</span><span class="p">)</span><span class="o">.</span><span class="n">set_results_name</span><span class="p">(</span><span class="s2">"socsecno"</span><span class="p">)</span> <span class="n">userdata</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)(</span><span class="s2">"name"</span><span class="p">)</span> <span class="o">+</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span> <span class="o">+</span> <span class="s2">"-"</span><span class="p">)(</span><span class="s2">"socsecno"</span><span class="p">)</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.__eq__"> <code class="descname">__eq__</code><span class="sig-paren">(</span><em>other</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.ParserElement.__eq__" title="Permalink to this definition">¶</a></dt> <dd><p>Return self==value.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.__getitem__"> <code class="descname">__getitem__</code><span class="sig-paren">(</span><em>key</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.ParserElement.__getitem__" title="Permalink to this definition">¶</a></dt> <dd><p>use <code class="docutils literal notranslate"><span class="pre">[]</span></code> indexing notation as a short form for expression repetition:</p> <ul class="simple"> <li><code class="docutils literal notranslate"><span class="pre">expr[n]</span></code> is equivalent to <code class="docutils literal notranslate"><span class="pre">expr*n</span></code></li> <li><code class="docutils literal notranslate"><span class="pre">expr[m,</span> <span class="pre">n]</span></code> is equivalent to <code class="docutils literal notranslate"><span class="pre">expr*(m,</span> <span class="pre">n)</span></code></li> <li><dl class="first docutils"> <dt><code class="docutils literal notranslate"><span class="pre">expr[n,</span> <span class="pre">...]</span></code> or <code class="docutils literal notranslate"><span class="pre">expr[n,]</span></code> is equivalent</dt> <dd>to <code class="docutils literal notranslate"><span class="pre">expr*n</span> <span class="pre">+</span> <span class="pre">ZeroOrMore(expr)</span></code> (read as “at least n instances of <code class="docutils literal notranslate"><span class="pre">expr</span></code>”)</dd> </dl> </li> <li><dl class="first docutils"> <dt><code class="docutils literal notranslate"><span class="pre">expr[...,</span> <span class="pre">n]</span></code> is equivalent to <code class="docutils literal notranslate"><span class="pre">expr*(0,</span> <span class="pre">n)</span></code></dt> <dd>(read as “0 to n instances of <code class="docutils literal notranslate"><span class="pre">expr</span></code>”)</dd> </dl> </li> <li><code class="docutils literal notranslate"><span class="pre">expr[...]</span></code> and <code class="docutils literal notranslate"><span class="pre">expr[0,</span> <span class="pre">...]</span></code> are equivalent to <code class="docutils literal notranslate"><span class="pre">ZeroOrMore(expr)</span></code></li> <li><code class="docutils literal notranslate"><span class="pre">expr[1,</span> <span class="pre">...]</span></code> is equivalent to <code class="docutils literal notranslate"><span class="pre">OneOrMore(expr)</span></code></li> </ul> <p><code class="docutils literal notranslate"><span class="pre">None</span></code> may be used in place of <code class="docutils literal notranslate"><span class="pre">...</span></code>.</p> <p>Note that <code class="docutils literal notranslate"><span class="pre">expr[...,</span> <span class="pre">n]</span></code> and <code class="docutils literal notranslate"><span class="pre">expr[m,</span> <span class="pre">n]``do</span> <span class="pre">not</span> <span class="pre">raise</span> <span class="pre">an</span> <span class="pre">exception</span> <span class="pre">if</span> <span class="pre">more</span> <span class="pre">than</span> <span class="pre">``n</span></code> <code class="docutils literal notranslate"><span class="pre">expr``s</span> <span class="pre">exist</span> <span class="pre">in</span> <span class="pre">the</span> <span class="pre">input</span> <span class="pre">stream.</span>  <span class="pre">If</span> <span class="pre">this</span> <span class="pre">behavior</span> <span class="pre">is</span> <span class="pre">desired,</span> <span class="pre">then</span> <span class="pre">write</span> <span class="pre">``expr[...,</span> <span class="pre">n]</span> <span class="pre">+</span> <span class="pre">~expr</span></code>.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.__hash__"> <code class="descname">__hash__</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.ParserElement.__hash__" title="Permalink to this definition">¶</a></dt> <dd><p>Return hash(self).</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>savelist: bool = False</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.ParserElement.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.__invert__"> <code class="descname">__invert__</code><span class="sig-paren">(</span><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.__invert__" title="Permalink to this definition">¶</a></dt> <dd><p>Implementation of <code class="docutils literal notranslate"><span class="pre">~</span></code> operator - returns <a class="reference internal" href="#pyparsing.NotAny" title="pyparsing.NotAny"><code class="xref py py-class docutils literal notranslate"><span class="pre">NotAny</span></code></a></p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.__mul__"> <code class="descname">__mul__</code><span class="sig-paren">(</span><em>other</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.__mul__" title="Permalink to this definition">¶</a></dt> <dd><p>Implementation of <code class="docutils literal notranslate"><span class="pre">*</span></code> operator, allows use of <code class="docutils literal notranslate"><span class="pre">expr</span> <span class="pre">*</span> <span class="pre">3</span></code> in place of <code class="docutils literal notranslate"><span class="pre">expr</span> <span class="pre">+</span> <span class="pre">expr</span> <span class="pre">+</span> <span class="pre">expr</span></code>. Expressions may also be multiplied by a 2-integer tuple, similar to <code class="docutils literal notranslate"><span class="pre">{min,</span> <span class="pre">max}</span></code> multipliers in regular expressions. Tuples may also include <code class="docutils literal notranslate"><span class="pre">None</span></code> as in: - <code class="docutils literal notranslate"><span class="pre">expr*(n,</span> <span class="pre">None)</span></code> or <code class="docutils literal notranslate"><span class="pre">expr*(n,</span> <span class="pre">)</span></code> is equivalent</p> <blockquote> <div>to <code class="docutils literal notranslate"><span class="pre">expr*n</span> <span class="pre">+</span> <span class="pre">ZeroOrMore(expr)</span></code> (read as “at least n instances of <code class="docutils literal notranslate"><span class="pre">expr</span></code>”)</div></blockquote> <ul class="simple"> <li><dl class="first docutils"> <dt><code class="docutils literal notranslate"><span class="pre">expr*(None,</span> <span class="pre">n)</span></code> is equivalent to <code class="docutils literal notranslate"><span class="pre">expr*(0,</span> <span class="pre">n)</span></code></dt> <dd>(read as “0 to n instances of <code class="docutils literal notranslate"><span class="pre">expr</span></code>”)</dd> </dl> </li> <li><code class="docutils literal notranslate"><span class="pre">expr*(None,</span> <span class="pre">None)</span></code> is equivalent to <code class="docutils literal notranslate"><span class="pre">ZeroOrMore(expr)</span></code></li> <li><code class="docutils literal notranslate"><span class="pre">expr*(1,</span> <span class="pre">None)</span></code> is equivalent to <code class="docutils literal notranslate"><span class="pre">OneOrMore(expr)</span></code></li> </ul> <p>Note that <code class="docutils literal notranslate"><span class="pre">expr*(None,</span> <span class="pre">n)</span></code> does not raise an exception if more than n exprs exist in the input stream; that is, <code class="docutils literal notranslate"><span class="pre">expr*(None,</span> <span class="pre">n)</span></code> does not enforce a maximum number of expr occurrences. If this behavior is desired, then write <code class="docutils literal notranslate"><span class="pre">expr*(None,</span> <span class="pre">n)</span> <span class="pre">+</span> <span class="pre">~expr</span></code></p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.__or__"> <code class="descname">__or__</code><span class="sig-paren">(</span><em>other</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.__or__" title="Permalink to this definition">¶</a></dt> <dd><p>Implementation of <code class="docutils literal notranslate"><span class="pre">|</span></code> operator - returns <a class="reference internal" href="#pyparsing.MatchFirst" title="pyparsing.MatchFirst"><code class="xref py py-class docutils literal notranslate"><span class="pre">MatchFirst</span></code></a></p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.__radd__"> <code class="descname">__radd__</code><span class="sig-paren">(</span><em>other</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.__radd__" title="Permalink to this definition">¶</a></dt> <dd><p>Implementation of <code class="docutils literal notranslate"><span class="pre">+</span></code> operator when left operand is not a <a class="reference internal" href="#pyparsing.ParserElement" title="pyparsing.ParserElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement</span></code></a></p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.__rand__"> <code class="descname">__rand__</code><span class="sig-paren">(</span><em>other</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.__rand__" title="Permalink to this definition">¶</a></dt> <dd><p>Implementation of <code class="docutils literal notranslate"><span class="pre">&</span></code> operator when left operand is not a <a class="reference internal" href="#pyparsing.ParserElement" title="pyparsing.ParserElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement</span></code></a></p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.__repr__"> <code class="descname">__repr__</code><span class="sig-paren">(</span><span class="sig-paren">)</span> → str<a class="headerlink" href="#pyparsing.ParserElement.__repr__" title="Permalink to this definition">¶</a></dt> <dd><p>Return repr(self).</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.__ror__"> <code class="descname">__ror__</code><span class="sig-paren">(</span><em>other</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.__ror__" title="Permalink to this definition">¶</a></dt> <dd><p>Implementation of <code class="docutils literal notranslate"><span class="pre">|</span></code> operator when left operand is not a <a class="reference internal" href="#pyparsing.ParserElement" title="pyparsing.ParserElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement</span></code></a></p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.__rsub__"> <code class="descname">__rsub__</code><span class="sig-paren">(</span><em>other</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.__rsub__" title="Permalink to this definition">¶</a></dt> <dd><p>Implementation of <code class="docutils literal notranslate"><span class="pre">-</span></code> operator when left operand is not a <a class="reference internal" href="#pyparsing.ParserElement" title="pyparsing.ParserElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement</span></code></a></p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.__rxor__"> <code class="descname">__rxor__</code><span class="sig-paren">(</span><em>other</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.__rxor__" title="Permalink to this definition">¶</a></dt> <dd><p>Implementation of <code class="docutils literal notranslate"><span class="pre">^</span></code> operator when left operand is not a <a class="reference internal" href="#pyparsing.ParserElement" title="pyparsing.ParserElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement</span></code></a></p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.__str__"> <code class="descname">__str__</code><span class="sig-paren">(</span><span class="sig-paren">)</span> → str<a class="headerlink" href="#pyparsing.ParserElement.__str__" title="Permalink to this definition">¶</a></dt> <dd><p>Return str(self).</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.__sub__"> <code class="descname">__sub__</code><span class="sig-paren">(</span><em>other</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.__sub__" title="Permalink to this definition">¶</a></dt> <dd><p>Implementation of <code class="docutils literal notranslate"><span class="pre">-</span></code> operator, returns <a class="reference internal" href="#pyparsing.And" title="pyparsing.And"><code class="xref py py-class docutils literal notranslate"><span class="pre">And</span></code></a> with error stop</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.__xor__"> <code class="descname">__xor__</code><span class="sig-paren">(</span><em>other</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.__xor__" title="Permalink to this definition">¶</a></dt> <dd><p>Implementation of <code class="docutils literal notranslate"><span class="pre">^</span></code> operator - returns <a class="reference internal" href="#pyparsing.Or" title="pyparsing.Or"><code class="xref py py-class docutils literal notranslate"><span class="pre">Or</span></code></a></p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.addCondition"> <code class="descname">addCondition</code><span class="sig-paren">(</span><em>*fns</em>, <em>**kwargs</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.addCondition" title="Permalink to this definition">¶</a></dt> <dd><p>Add a boolean predicate function to expression’s list of parse actions. See <a class="reference internal" href="#pyparsing.ParserElement.set_parse_action" title="pyparsing.ParserElement.set_parse_action"><code class="xref py py-class docutils literal notranslate"><span class="pre">set_parse_action</span></code></a> for function call signatures. Unlike <code class="docutils literal notranslate"><span class="pre">set_parse_action</span></code>, functions passed to <code class="docutils literal notranslate"><span class="pre">add_condition</span></code> need to return boolean success/fail of the condition.</p> <p>Optional keyword arguments:</p> <ul class="simple"> <li>message = define a custom message to be used in the raised exception</li> <li>fatal = if True, will raise ParseFatalException to stop parsing immediately; otherwise will raise ParseException</li> <li>call_during_try = boolean to indicate if this method should be called during internal tryParse calls, default=False</li> </ul> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">integer</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="k">lambda</span> <span class="n">toks</span><span class="p">:</span> <span class="nb">int</span><span class="p">(</span><span class="n">toks</span><span class="p">[</span><span class="mi">0</span><span class="p">]))</span> <span class="n">year_int</span> <span class="o">=</span> <span class="n">integer</span><span class="o">.</span><span class="n">copy</span><span class="p">()</span> <span class="n">year_int</span><span class="o">.</span><span class="n">add_condition</span><span class="p">(</span><span class="k">lambda</span> <span class="n">toks</span><span class="p">:</span> <span class="n">toks</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">>=</span> <span class="mi">2000</span><span class="p">,</span> <span class="n">message</span><span class="o">=</span><span class="s2">"Only support years 2000 and later"</span><span class="p">)</span> <span class="n">date_str</span> <span class="o">=</span> <span class="n">year_int</span> <span class="o">+</span> <span class="s1">'/'</span> <span class="o">+</span> <span class="n">integer</span> <span class="o">+</span> <span class="s1">'/'</span> <span class="o">+</span> <span class="n">integer</span> <span class="n">result</span> <span class="o">=</span> <span class="n">date_str</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"1999/12/31"</span><span class="p">)</span> <span class="c1"># -> Exception: Only support years 2000 and later (at char 0),</span> <span class="p">(</span><span class="n">line</span><span class="p">:</span><span class="mi">1</span><span class="p">,</span> <span class="n">col</span><span class="p">:</span><span class="mi">1</span><span class="p">)</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.addParseAction"> <code class="descname">addParseAction</code><span class="sig-paren">(</span><em>*fns</em>, <em>**kwargs</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.addParseAction" title="Permalink to this definition">¶</a></dt> <dd><p>Add one or more parse actions to expression’s list of parse actions. See <a class="reference internal" href="#pyparsing.ParserElement.set_parse_action" title="pyparsing.ParserElement.set_parse_action"><code class="xref py py-class docutils literal notranslate"><span class="pre">set_parse_action</span></code></a>.</p> <p>See examples in <a class="reference internal" href="#pyparsing.ParserElement.copy" title="pyparsing.ParserElement.copy"><code class="xref py py-class docutils literal notranslate"><span class="pre">copy</span></code></a>.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.add_condition"> <code class="descname">add_condition</code><span class="sig-paren">(</span><em>*fns</em>, <em>**kwargs</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.add_condition" title="Permalink to this definition">¶</a></dt> <dd><p>Add a boolean predicate function to expression’s list of parse actions. See <a class="reference internal" href="#pyparsing.ParserElement.set_parse_action" title="pyparsing.ParserElement.set_parse_action"><code class="xref py py-class docutils literal notranslate"><span class="pre">set_parse_action</span></code></a> for function call signatures. Unlike <code class="docutils literal notranslate"><span class="pre">set_parse_action</span></code>, functions passed to <code class="docutils literal notranslate"><span class="pre">add_condition</span></code> need to return boolean success/fail of the condition.</p> <p>Optional keyword arguments:</p> <ul class="simple"> <li>message = define a custom message to be used in the raised exception</li> <li>fatal = if True, will raise ParseFatalException to stop parsing immediately; otherwise will raise ParseException</li> <li>call_during_try = boolean to indicate if this method should be called during internal tryParse calls, default=False</li> </ul> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">integer</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="k">lambda</span> <span class="n">toks</span><span class="p">:</span> <span class="nb">int</span><span class="p">(</span><span class="n">toks</span><span class="p">[</span><span class="mi">0</span><span class="p">]))</span> <span class="n">year_int</span> <span class="o">=</span> <span class="n">integer</span><span class="o">.</span><span class="n">copy</span><span class="p">()</span> <span class="n">year_int</span><span class="o">.</span><span class="n">add_condition</span><span class="p">(</span><span class="k">lambda</span> <span class="n">toks</span><span class="p">:</span> <span class="n">toks</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">>=</span> <span class="mi">2000</span><span class="p">,</span> <span class="n">message</span><span class="o">=</span><span class="s2">"Only support years 2000 and later"</span><span class="p">)</span> <span class="n">date_str</span> <span class="o">=</span> <span class="n">year_int</span> <span class="o">+</span> <span class="s1">'/'</span> <span class="o">+</span> <span class="n">integer</span> <span class="o">+</span> <span class="s1">'/'</span> <span class="o">+</span> <span class="n">integer</span> <span class="n">result</span> <span class="o">=</span> <span class="n">date_str</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"1999/12/31"</span><span class="p">)</span> <span class="c1"># -> Exception: Only support years 2000 and later (at char 0),</span> <span class="p">(</span><span class="n">line</span><span class="p">:</span><span class="mi">1</span><span class="p">,</span> <span class="n">col</span><span class="p">:</span><span class="mi">1</span><span class="p">)</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.add_parse_action"> <code class="descname">add_parse_action</code><span class="sig-paren">(</span><em>*fns</em>, <em>**kwargs</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.add_parse_action" title="Permalink to this definition">¶</a></dt> <dd><p>Add one or more parse actions to expression’s list of parse actions. See <a class="reference internal" href="#pyparsing.ParserElement.set_parse_action" title="pyparsing.ParserElement.set_parse_action"><code class="xref py py-class docutils literal notranslate"><span class="pre">set_parse_action</span></code></a>.</p> <p>See examples in <a class="reference internal" href="#pyparsing.ParserElement.copy" title="pyparsing.ParserElement.copy"><code class="xref py py-class docutils literal notranslate"><span class="pre">copy</span></code></a>.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.copy"> <code class="descname">copy</code><span class="sig-paren">(</span><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.copy" title="Permalink to this definition">¶</a></dt> <dd><p>Make a copy of this <a class="reference internal" href="#pyparsing.ParserElement" title="pyparsing.ParserElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement</span></code></a>. Useful for defining different parse actions for the same parsing pattern, using copies of the original parse element.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">integer</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="k">lambda</span> <span class="n">toks</span><span class="p">:</span> <span class="nb">int</span><span class="p">(</span><span class="n">toks</span><span class="p">[</span><span class="mi">0</span><span class="p">]))</span> <span class="n">integerK</span> <span class="o">=</span> <span class="n">integer</span><span class="o">.</span><span class="n">copy</span><span class="p">()</span><span class="o">.</span><span class="n">add_parse_action</span><span class="p">(</span><span class="k">lambda</span> <span class="n">toks</span><span class="p">:</span> <span class="n">toks</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">*</span> <span class="mi">1024</span><span class="p">)</span> <span class="o">+</span> <span class="n">Suppress</span><span class="p">(</span><span class="s2">"K"</span><span class="p">)</span> <span class="n">integerM</span> <span class="o">=</span> <span class="n">integer</span><span class="o">.</span><span class="n">copy</span><span class="p">()</span><span class="o">.</span><span class="n">add_parse_action</span><span class="p">(</span><span class="k">lambda</span> <span class="n">toks</span><span class="p">:</span> <span class="n">toks</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">*</span> <span class="mi">1024</span> <span class="o">*</span> <span class="mi">1024</span><span class="p">)</span> <span class="o">+</span> <span class="n">Suppress</span><span class="p">(</span><span class="s2">"M"</span><span class="p">)</span> <span class="nb">print</span><span class="p">((</span><span class="n">integerK</span> <span class="o">|</span> <span class="n">integerM</span> <span class="o">|</span> <span class="n">integer</span><span class="p">)[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"5K 100 640K 256M"</span><span class="p">))</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="mi">5120</span><span class="p">,</span> <span class="mi">100</span><span class="p">,</span> <span class="mi">655360</span><span class="p">,</span> <span class="mi">268435456</span><span class="p">]</span> </pre></div> </div> <p>Equivalent form of <code class="docutils literal notranslate"><span class="pre">expr.copy()</span></code> is just <code class="docutils literal notranslate"><span class="pre">expr()</span></code>:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">integerM</span> <span class="o">=</span> <span class="n">integer</span><span class="p">()</span><span class="o">.</span><span class="n">add_parse_action</span><span class="p">(</span><span class="k">lambda</span> <span class="n">toks</span><span class="p">:</span> <span class="n">toks</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">*</span> <span class="mi">1024</span> <span class="o">*</span> <span class="mi">1024</span><span class="p">)</span> <span class="o">+</span> <span class="n">Suppress</span><span class="p">(</span><span class="s2">"M"</span><span class="p">)</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.create_diagram"> <code class="descname">create_diagram</code><span class="sig-paren">(</span><em>output_html: Union[typing.TextIO, pathlib.Path, str], vertical: int = 3, show_results_names: bool = False, show_groups: bool = False, **kwargs</em><span class="sig-paren">)</span> → None<a class="headerlink" href="#pyparsing.ParserElement.create_diagram" title="Permalink to this definition">¶</a></dt> <dd><p>Create a railroad diagram for the parser.</p> <p>Parameters: - output_html (str or file-like object) - output target for generated</p> <blockquote> <div>diagram HTML</div></blockquote> <ul class="simple"> <li>vertical (int) - threshold for formatting multiple alternatives vertically instead of horizontally (default=3)</li> <li>show_results_names - bool flag whether diagram should show annotations for defined results names</li> <li>show_groups - bool flag whether groups should be highlighted with an unlabeled surrounding box</li> </ul> <p>Additional diagram-formatting keyword arguments can also be included; see railroad.Diagram class.</p> </dd></dl> <dl class="staticmethod"> <dt id="pyparsing.ParserElement.disable_memoization"> <em class="property">static </em><code class="descname">disable_memoization</code><span class="sig-paren">(</span><span class="sig-paren">)</span> → None<a class="headerlink" href="#pyparsing.ParserElement.disable_memoization" title="Permalink to this definition">¶</a></dt> <dd><p>Disables active Packrat or Left Recursion parsing and their memoization</p> <p>This method also works if neither Packrat nor Left Recursion are enabled. This makes it safe to call before activating Packrat nor Left Recursion to clear any previous settings.</p> </dd></dl> <dl class="staticmethod"> <dt id="pyparsing.ParserElement.enableLeftRecursion"> <em class="property">static </em><code class="descname">enableLeftRecursion</code><span class="sig-paren">(</span><em>cache_size_limit: Union[int</em>, <em>NoneType] = None</em>, <em>*</em>, <em>force=False</em><span class="sig-paren">)</span> → None<a class="headerlink" href="#pyparsing.ParserElement.enableLeftRecursion" title="Permalink to this definition">¶</a></dt> <dd><p>Enables “bounded recursion” parsing, which allows for both direct and indirect left-recursion. During parsing, left-recursive <a class="reference internal" href="#pyparsing.Forward" title="pyparsing.Forward"><code class="xref py py-class docutils literal notranslate"><span class="pre">Forward</span></code></a> elements are repeatedly matched with a fixed recursion depth that is gradually increased until finding the longest match.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">pyparsing</span> <span class="k">as</span> <span class="nn">pp</span> <span class="n">pp</span><span class="o">.</span><span class="n">ParserElement</span><span class="o">.</span><span class="n">enable_left_recursion</span><span class="p">()</span> <span class="n">E</span> <span class="o">=</span> <span class="n">pp</span><span class="o">.</span><span class="n">Forward</span><span class="p">(</span><span class="s2">"E"</span><span class="p">)</span> <span class="n">num</span> <span class="o">=</span> <span class="n">pp</span><span class="o">.</span><span class="n">Word</span><span class="p">(</span><span class="n">pp</span><span class="o">.</span><span class="n">nums</span><span class="p">)</span> <span class="c1"># match `num`, or `num '+' num`, or `num '+' num '+' num`, ...</span> <span class="n">E</span> <span class="o"><<=</span> <span class="n">E</span> <span class="o">+</span> <span class="s1">'+'</span> <span class="o">-</span> <span class="n">num</span> <span class="o">|</span> <span class="n">num</span> <span class="nb">print</span><span class="p">(</span><span class="n">E</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"1+2+3"</span><span class="p">))</span> </pre></div> </div> <p>Recursion search naturally memoizes matches of <code class="docutils literal notranslate"><span class="pre">Forward</span></code> elements and may thus skip reevaluation of parse actions during backtracking. This may break programs with parse actions which rely on strict ordering of side-effects.</p> <p>Parameters:</p> <ul class="simple"> <li>cache_size_limit - (default=``None``) - memoize at most this many <code class="docutils literal notranslate"><span class="pre">Forward</span></code> elements during matching; if <code class="docutils literal notranslate"><span class="pre">None</span></code> (the default), memoize all <code class="docutils literal notranslate"><span class="pre">Forward</span></code> elements.</li> </ul> <p>Bounded Recursion parsing works similar but not identical to Packrat parsing, thus the two cannot be used together. Use <code class="docutils literal notranslate"><span class="pre">force=True</span></code> to disable any previous, conflicting settings.</p> </dd></dl> <dl class="staticmethod"> <dt id="pyparsing.ParserElement.enablePackrat"> <em class="property">static </em><code class="descname">enablePackrat</code><span class="sig-paren">(</span><em>cache_size_limit: int = 128</em>, <em>*</em>, <em>force: bool = False</em><span class="sig-paren">)</span> → None<a class="headerlink" href="#pyparsing.ParserElement.enablePackrat" title="Permalink to this definition">¶</a></dt> <dd><p>Enables “packrat” parsing, which adds memoizing to the parsing logic. Repeated parse attempts at the same string location (which happens often in many complex grammars) can immediately return a cached value, instead of re-executing parsing/validating code. Memoizing is done of both valid results and parsing exceptions.</p> <p>Parameters:</p> <ul class="simple"> <li>cache_size_limit - (default= <code class="docutils literal notranslate"><span class="pre">128</span></code>) - if an integer value is provided will limit the size of the packrat cache; if None is passed, then the cache size will be unbounded; if 0 is passed, the cache will be effectively disabled.</li> </ul> <p>This speedup may break existing programs that use parse actions that have side-effects. For this reason, packrat parsing is disabled when you first import pyparsing. To activate the packrat feature, your program must call the class method <a class="reference internal" href="#pyparsing.ParserElement.enable_packrat" title="pyparsing.ParserElement.enable_packrat"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement.enable_packrat</span></code></a>. For best results, call <code class="docutils literal notranslate"><span class="pre">enable_packrat()</span></code> immediately after importing pyparsing.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">pyparsing</span> <span class="n">pyparsing</span><span class="o">.</span><span class="n">ParserElement</span><span class="o">.</span><span class="n">enable_packrat</span><span class="p">()</span> </pre></div> </div> <p>Packrat parsing works similar but not identical to Bounded Recursion parsing, thus the two cannot be used together. Use <code class="docutils literal notranslate"><span class="pre">force=True</span></code> to disable any previous, conflicting settings.</p> </dd></dl> <dl class="staticmethod"> <dt id="pyparsing.ParserElement.enable_left_recursion"> <em class="property">static </em><code class="descname">enable_left_recursion</code><span class="sig-paren">(</span><em>cache_size_limit: Union[int</em>, <em>NoneType] = None</em>, <em>*</em>, <em>force=False</em><span class="sig-paren">)</span> → None<a class="headerlink" href="#pyparsing.ParserElement.enable_left_recursion" title="Permalink to this definition">¶</a></dt> <dd><p>Enables “bounded recursion” parsing, which allows for both direct and indirect left-recursion. During parsing, left-recursive <a class="reference internal" href="#pyparsing.Forward" title="pyparsing.Forward"><code class="xref py py-class docutils literal notranslate"><span class="pre">Forward</span></code></a> elements are repeatedly matched with a fixed recursion depth that is gradually increased until finding the longest match.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">pyparsing</span> <span class="k">as</span> <span class="nn">pp</span> <span class="n">pp</span><span class="o">.</span><span class="n">ParserElement</span><span class="o">.</span><span class="n">enable_left_recursion</span><span class="p">()</span> <span class="n">E</span> <span class="o">=</span> <span class="n">pp</span><span class="o">.</span><span class="n">Forward</span><span class="p">(</span><span class="s2">"E"</span><span class="p">)</span> <span class="n">num</span> <span class="o">=</span> <span class="n">pp</span><span class="o">.</span><span class="n">Word</span><span class="p">(</span><span class="n">pp</span><span class="o">.</span><span class="n">nums</span><span class="p">)</span> <span class="c1"># match `num`, or `num '+' num`, or `num '+' num '+' num`, ...</span> <span class="n">E</span> <span class="o"><<=</span> <span class="n">E</span> <span class="o">+</span> <span class="s1">'+'</span> <span class="o">-</span> <span class="n">num</span> <span class="o">|</span> <span class="n">num</span> <span class="nb">print</span><span class="p">(</span><span class="n">E</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"1+2+3"</span><span class="p">))</span> </pre></div> </div> <p>Recursion search naturally memoizes matches of <code class="docutils literal notranslate"><span class="pre">Forward</span></code> elements and may thus skip reevaluation of parse actions during backtracking. This may break programs with parse actions which rely on strict ordering of side-effects.</p> <p>Parameters:</p> <ul class="simple"> <li>cache_size_limit - (default=``None``) - memoize at most this many <code class="docutils literal notranslate"><span class="pre">Forward</span></code> elements during matching; if <code class="docutils literal notranslate"><span class="pre">None</span></code> (the default), memoize all <code class="docutils literal notranslate"><span class="pre">Forward</span></code> elements.</li> </ul> <p>Bounded Recursion parsing works similar but not identical to Packrat parsing, thus the two cannot be used together. Use <code class="docutils literal notranslate"><span class="pre">force=True</span></code> to disable any previous, conflicting settings.</p> </dd></dl> <dl class="staticmethod"> <dt id="pyparsing.ParserElement.enable_packrat"> <em class="property">static </em><code class="descname">enable_packrat</code><span class="sig-paren">(</span><em>cache_size_limit: int = 128</em>, <em>*</em>, <em>force: bool = False</em><span class="sig-paren">)</span> → None<a class="headerlink" href="#pyparsing.ParserElement.enable_packrat" title="Permalink to this definition">¶</a></dt> <dd><p>Enables “packrat” parsing, which adds memoizing to the parsing logic. Repeated parse attempts at the same string location (which happens often in many complex grammars) can immediately return a cached value, instead of re-executing parsing/validating code. Memoizing is done of both valid results and parsing exceptions.</p> <p>Parameters:</p> <ul class="simple"> <li>cache_size_limit - (default= <code class="docutils literal notranslate"><span class="pre">128</span></code>) - if an integer value is provided will limit the size of the packrat cache; if None is passed, then the cache size will be unbounded; if 0 is passed, the cache will be effectively disabled.</li> </ul> <p>This speedup may break existing programs that use parse actions that have side-effects. For this reason, packrat parsing is disabled when you first import pyparsing. To activate the packrat feature, your program must call the class method <a class="reference internal" href="#pyparsing.ParserElement.enable_packrat" title="pyparsing.ParserElement.enable_packrat"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement.enable_packrat</span></code></a>. For best results, call <code class="docutils literal notranslate"><span class="pre">enable_packrat()</span></code> immediately after importing pyparsing.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">pyparsing</span> <span class="n">pyparsing</span><span class="o">.</span><span class="n">ParserElement</span><span class="o">.</span><span class="n">enable_packrat</span><span class="p">()</span> </pre></div> </div> <p>Packrat parsing works similar but not identical to Bounded Recursion parsing, thus the two cannot be used together. Use <code class="docutils literal notranslate"><span class="pre">force=True</span></code> to disable any previous, conflicting settings.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.ignore"> <code class="descname">ignore</code><span class="sig-paren">(</span><em>other: pyparsing.core.ParserElement</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.ignore" title="Permalink to this definition">¶</a></dt> <dd><p>Define expression to be ignored (e.g., comments) while doing pattern matching; may be called repeatedly, to define multiple comment or other ignorable patterns.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">patt</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span> <span class="n">patt</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s1">'ablaj /* comment */ lskjd'</span><span class="p">)</span> <span class="c1"># -> ['ablaj']</span> <span class="n">patt</span><span class="o">.</span><span class="n">ignore</span><span class="p">(</span><span class="n">c_style_comment</span><span class="p">)</span> <span class="n">patt</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s1">'ablaj /* comment */ lskjd'</span><span class="p">)</span> <span class="c1"># -> ['ablaj', 'lskjd']</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.ignoreWhitespace"> <code class="descname">ignoreWhitespace</code><span class="sig-paren">(</span><em>recursive: bool = True</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.ignoreWhitespace" title="Permalink to this definition">¶</a></dt> <dd><p>Enables the skipping of whitespace before matching the characters in the <a class="reference internal" href="#pyparsing.ParserElement" title="pyparsing.ParserElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement</span></code></a>’s defined pattern.</p> <table class="docutils field-list" frame="void" rules="none"> <col class="field-name" /> <col class="field-body" /> <tbody valign="top"> <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>recursive</strong> – If <code class="docutils literal notranslate"><span class="pre">True</span></code> (the default), also enable whitespace skipping in child elements (if any)</td> </tr> </tbody> </table> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.ignore_whitespace"> <code class="descname">ignore_whitespace</code><span class="sig-paren">(</span><em>recursive: bool = True</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.ignore_whitespace" title="Permalink to this definition">¶</a></dt> <dd><p>Enables the skipping of whitespace before matching the characters in the <a class="reference internal" href="#pyparsing.ParserElement" title="pyparsing.ParserElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement</span></code></a>’s defined pattern.</p> <table class="docutils field-list" frame="void" rules="none"> <col class="field-name" /> <col class="field-body" /> <tbody valign="top"> <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>recursive</strong> – If <code class="docutils literal notranslate"><span class="pre">True</span></code> (the default), also enable whitespace skipping in child elements (if any)</td> </tr> </tbody> </table> </dd></dl> <dl class="staticmethod"> <dt id="pyparsing.ParserElement.inlineLiteralsUsing"> <em class="property">static </em><code class="descname">inlineLiteralsUsing</code><span class="sig-paren">(</span><em>cls: type</em><span class="sig-paren">)</span> → None<a class="headerlink" href="#pyparsing.ParserElement.inlineLiteralsUsing" title="Permalink to this definition">¶</a></dt> <dd><p>Set class to be used for inclusion of string literals into a parser.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># default literal class used is Literal</span> <span class="n">integer</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="n">date_str</span> <span class="o">=</span> <span class="n">integer</span><span class="p">(</span><span class="s2">"year"</span><span class="p">)</span> <span class="o">+</span> <span class="s1">'/'</span> <span class="o">+</span> <span class="n">integer</span><span class="p">(</span><span class="s2">"month"</span><span class="p">)</span> <span class="o">+</span> <span class="s1">'/'</span> <span class="o">+</span> <span class="n">integer</span><span class="p">(</span><span class="s2">"day"</span><span class="p">)</span> <span class="n">date_str</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"1999/12/31"</span><span class="p">)</span> <span class="c1"># -> ['1999', '/', '12', '/', '31']</span> <span class="c1"># change to Suppress</span> <span class="n">ParserElement</span><span class="o">.</span><span class="n">inline_literals_using</span><span class="p">(</span><span class="n">Suppress</span><span class="p">)</span> <span class="n">date_str</span> <span class="o">=</span> <span class="n">integer</span><span class="p">(</span><span class="s2">"year"</span><span class="p">)</span> <span class="o">+</span> <span class="s1">'/'</span> <span class="o">+</span> <span class="n">integer</span><span class="p">(</span><span class="s2">"month"</span><span class="p">)</span> <span class="o">+</span> <span class="s1">'/'</span> <span class="o">+</span> <span class="n">integer</span><span class="p">(</span><span class="s2">"day"</span><span class="p">)</span> <span class="n">date_str</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"1999/12/31"</span><span class="p">)</span> <span class="c1"># -> ['1999', '12', '31']</span> </pre></div> </div> </dd></dl> <dl class="staticmethod"> <dt id="pyparsing.ParserElement.inline_literals_using"> <em class="property">static </em><code class="descname">inline_literals_using</code><span class="sig-paren">(</span><em>cls: type</em><span class="sig-paren">)</span> → None<a class="headerlink" href="#pyparsing.ParserElement.inline_literals_using" title="Permalink to this definition">¶</a></dt> <dd><p>Set class to be used for inclusion of string literals into a parser.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># default literal class used is Literal</span> <span class="n">integer</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="n">date_str</span> <span class="o">=</span> <span class="n">integer</span><span class="p">(</span><span class="s2">"year"</span><span class="p">)</span> <span class="o">+</span> <span class="s1">'/'</span> <span class="o">+</span> <span class="n">integer</span><span class="p">(</span><span class="s2">"month"</span><span class="p">)</span> <span class="o">+</span> <span class="s1">'/'</span> <span class="o">+</span> <span class="n">integer</span><span class="p">(</span><span class="s2">"day"</span><span class="p">)</span> <span class="n">date_str</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"1999/12/31"</span><span class="p">)</span> <span class="c1"># -> ['1999', '/', '12', '/', '31']</span> <span class="c1"># change to Suppress</span> <span class="n">ParserElement</span><span class="o">.</span><span class="n">inline_literals_using</span><span class="p">(</span><span class="n">Suppress</span><span class="p">)</span> <span class="n">date_str</span> <span class="o">=</span> <span class="n">integer</span><span class="p">(</span><span class="s2">"year"</span><span class="p">)</span> <span class="o">+</span> <span class="s1">'/'</span> <span class="o">+</span> <span class="n">integer</span><span class="p">(</span><span class="s2">"month"</span><span class="p">)</span> <span class="o">+</span> <span class="s1">'/'</span> <span class="o">+</span> <span class="n">integer</span><span class="p">(</span><span class="s2">"day"</span><span class="p">)</span> <span class="n">date_str</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"1999/12/31"</span><span class="p">)</span> <span class="c1"># -> ['1999', '12', '31']</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.leaveWhitespace"> <code class="descname">leaveWhitespace</code><span class="sig-paren">(</span><em>recursive: bool = True</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.leaveWhitespace" title="Permalink to this definition">¶</a></dt> <dd><p>Disables the skipping of whitespace before matching the characters in the <a class="reference internal" href="#pyparsing.ParserElement" title="pyparsing.ParserElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement</span></code></a>’s defined pattern. This is normally only used internally by the pyparsing module, but may be needed in some whitespace-sensitive grammars.</p> <table class="docutils field-list" frame="void" rules="none"> <col class="field-name" /> <col class="field-body" /> <tbody valign="top"> <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>recursive</strong> – If true (the default), also disable whitespace skipping in child elements (if any)</td> </tr> </tbody> </table> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.leave_whitespace"> <code class="descname">leave_whitespace</code><span class="sig-paren">(</span><em>recursive: bool = True</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.leave_whitespace" title="Permalink to this definition">¶</a></dt> <dd><p>Disables the skipping of whitespace before matching the characters in the <a class="reference internal" href="#pyparsing.ParserElement" title="pyparsing.ParserElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement</span></code></a>’s defined pattern. This is normally only used internally by the pyparsing module, but may be needed in some whitespace-sensitive grammars.</p> <table class="docutils field-list" frame="void" rules="none"> <col class="field-name" /> <col class="field-body" /> <tbody valign="top"> <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>recursive</strong> – If true (the default), also disable whitespace skipping in child elements (if any)</td> </tr> </tbody> </table> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.matches"> <code class="descname">matches</code><span class="sig-paren">(</span><em>test_string: str</em>, <em>parse_all: bool = True</em>, <em>*</em>, <em>parseAll: bool = True</em><span class="sig-paren">)</span> → bool<a class="headerlink" href="#pyparsing.ParserElement.matches" title="Permalink to this definition">¶</a></dt> <dd><p>Method for quick testing of a parser against a test string. Good for simple inline microtests of sub expressions while building up larger parser.</p> <p>Parameters: - <code class="docutils literal notranslate"><span class="pre">test_string</span></code> - to test against this expression for a match - <code class="docutils literal notranslate"><span class="pre">parse_all</span></code> - (default= <code class="docutils literal notranslate"><span class="pre">True</span></code>) - flag to pass to <a class="reference internal" href="#pyparsing.ParserElement.parse_string" title="pyparsing.ParserElement.parse_string"><code class="xref py py-class docutils literal notranslate"><span class="pre">parse_string</span></code></a> when running tests</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">expr</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="k">assert</span> <span class="n">expr</span><span class="o">.</span><span class="n">matches</span><span class="p">(</span><span class="s2">"100"</span><span class="p">)</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.parseFile"> <code class="descname">parseFile</code><span class="sig-paren">(</span><em>file_or_filename: Union[str, pathlib.Path, typing.TextIO], encoding: str = 'utf-8', parse_all: bool = False, *, parseAll: bool = False</em><span class="sig-paren">)</span> → pyparsing.results.ParseResults<a class="headerlink" href="#pyparsing.ParserElement.parseFile" title="Permalink to this definition">¶</a></dt> <dd><p>Execute the parse expression on the given file or filename. If a filename is specified (instead of a file object), the entire file is opened, read, and closed before parsing.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.parseString"> <code class="descname">parseString</code><span class="sig-paren">(</span><em>instring: str</em>, <em>parse_all: bool = False</em>, <em>*</em>, <em>parseAll: bool = False</em><span class="sig-paren">)</span> → pyparsing.results.ParseResults<a class="headerlink" href="#pyparsing.ParserElement.parseString" title="Permalink to this definition">¶</a></dt> <dd><p>Parse a string with respect to the parser definition. This function is intended as the primary interface to the client code.</p> <table class="docutils field-list" frame="void" rules="none"> <col class="field-name" /> <col class="field-body" /> <tbody valign="top"> <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple"> <li><strong>instring</strong> – The input string to be parsed.</li> <li><strong>parse_all</strong> – If set, the entire input string must match the grammar.</li> <li><strong>parseAll</strong> – retained for pre-PEP8 compatibility, will be removed in a future release.</li> </ul> </td> </tr> <tr class="field-even field"><th class="field-name">Raises:</th><td class="field-body"><p class="first"><a class="reference internal" href="#pyparsing.ParseException" title="pyparsing.ParseException"><strong>ParseException</strong></a> – Raised if <code class="docutils literal notranslate"><span class="pre">parse_all</span></code> is set and the input string does not match the whole grammar.</p> </td> </tr> <tr class="field-odd field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last">the parsed data as a <a class="reference internal" href="#pyparsing.ParseResults" title="pyparsing.ParseResults"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParseResults</span></code></a> object, which may be accessed as a <cite>list</cite>, a <cite>dict</cite>, or an object with attributes if the given parser includes results names.</p> </td> </tr> </tbody> </table> <p>If the input string is required to match the entire grammar, <code class="docutils literal notranslate"><span class="pre">parse_all</span></code> flag must be set to <code class="docutils literal notranslate"><span class="pre">True</span></code>. This is also equivalent to ending the grammar with :class:<a href="#id5"><span class="problematic" id="id6">`</span></a>StringEnd`().</p> <p>To report proper column numbers, <code class="docutils literal notranslate"><span class="pre">parse_string</span></code> operates on a copy of the input string where all tabs are converted to spaces (8 spaces per tab, as per the default in <code class="docutils literal notranslate"><span class="pre">string.expandtabs</span></code>). If the input string contains tabs and the grammar uses parse actions that use the <code class="docutils literal notranslate"><span class="pre">loc</span></code> argument to index into the string being parsed, one can ensure a consistent view of the input string by doing one of the following:</p> <ul class="simple"> <li>calling <code class="docutils literal notranslate"><span class="pre">parse_with_tabs</span></code> on your grammar before calling <code class="docutils literal notranslate"><span class="pre">parse_string</span></code> (see <a class="reference internal" href="#pyparsing.ParserElement.parse_with_tabs" title="pyparsing.ParserElement.parse_with_tabs"><code class="xref py py-class docutils literal notranslate"><span class="pre">parse_with_tabs</span></code></a>),</li> <li>define your parse action using the full <code class="docutils literal notranslate"><span class="pre">(s,loc,toks)</span></code> signature, and reference the input string using the parse action’s <code class="docutils literal notranslate"><span class="pre">s</span></code> argument, or</li> <li>explicitly expand the tabs in your input string before calling <code class="docutils literal notranslate"><span class="pre">parse_string</span></code>.</li> </ul> <p>Examples:</p> <p>By default, partial matches are OK.</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">res</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="s1">'a'</span><span class="p">)</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s1">'aaaaabaaa'</span><span class="p">)</span> <span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">res</span><span class="p">)</span> <span class="go">['aaaaa']</span> </pre></div> </div> <p>The parsing behavior varies by the inheriting class of this abstract class. Please refer to the children directly to see more examples.</p> <p>It raises an exception if parse_all flag is set and instring does not match the whole grammar.</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">res</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="s1">'a'</span><span class="p">)</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s1">'aaaaabaaa'</span><span class="p">,</span> <span class="n">parse_all</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span> <span class="gt">Traceback (most recent call last):</span> <span class="c">...</span> <span class="gr">pyparsing.ParseException</span>: <span class="n">Expected end of text, found 'b' (at char 5), (line:1, col:6)</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.parseWithTabs"> <code class="descname">parseWithTabs</code><span class="sig-paren">(</span><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.parseWithTabs" title="Permalink to this definition">¶</a></dt> <dd><p>Overrides default behavior to expand <code class="docutils literal notranslate"><span class="pre"><TAB></span></code> s to spaces before parsing the input string. Must be called before <code class="docutils literal notranslate"><span class="pre">parse_string</span></code> when the input grammar contains elements that match <code class="docutils literal notranslate"><span class="pre"><TAB></span></code> characters.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.parse_file"> <code class="descname">parse_file</code><span class="sig-paren">(</span><em>file_or_filename: Union[str, pathlib.Path, typing.TextIO], encoding: str = 'utf-8', parse_all: bool = False, *, parseAll: bool = False</em><span class="sig-paren">)</span> → pyparsing.results.ParseResults<a class="headerlink" href="#pyparsing.ParserElement.parse_file" title="Permalink to this definition">¶</a></dt> <dd><p>Execute the parse expression on the given file or filename. If a filename is specified (instead of a file object), the entire file is opened, read, and closed before parsing.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.parse_string"> <code class="descname">parse_string</code><span class="sig-paren">(</span><em>instring: str</em>, <em>parse_all: bool = False</em>, <em>*</em>, <em>parseAll: bool = False</em><span class="sig-paren">)</span> → pyparsing.results.ParseResults<a class="headerlink" href="#pyparsing.ParserElement.parse_string" title="Permalink to this definition">¶</a></dt> <dd><p>Parse a string with respect to the parser definition. This function is intended as the primary interface to the client code.</p> <table class="docutils field-list" frame="void" rules="none"> <col class="field-name" /> <col class="field-body" /> <tbody valign="top"> <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple"> <li><strong>instring</strong> – The input string to be parsed.</li> <li><strong>parse_all</strong> – If set, the entire input string must match the grammar.</li> <li><strong>parseAll</strong> – retained for pre-PEP8 compatibility, will be removed in a future release.</li> </ul> </td> </tr> <tr class="field-even field"><th class="field-name">Raises:</th><td class="field-body"><p class="first"><a class="reference internal" href="#pyparsing.ParseException" title="pyparsing.ParseException"><strong>ParseException</strong></a> – Raised if <code class="docutils literal notranslate"><span class="pre">parse_all</span></code> is set and the input string does not match the whole grammar.</p> </td> </tr> <tr class="field-odd field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last">the parsed data as a <a class="reference internal" href="#pyparsing.ParseResults" title="pyparsing.ParseResults"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParseResults</span></code></a> object, which may be accessed as a <cite>list</cite>, a <cite>dict</cite>, or an object with attributes if the given parser includes results names.</p> </td> </tr> </tbody> </table> <p>If the input string is required to match the entire grammar, <code class="docutils literal notranslate"><span class="pre">parse_all</span></code> flag must be set to <code class="docutils literal notranslate"><span class="pre">True</span></code>. This is also equivalent to ending the grammar with :class:<a href="#id7"><span class="problematic" id="id8">`</span></a>StringEnd`().</p> <p>To report proper column numbers, <code class="docutils literal notranslate"><span class="pre">parse_string</span></code> operates on a copy of the input string where all tabs are converted to spaces (8 spaces per tab, as per the default in <code class="docutils literal notranslate"><span class="pre">string.expandtabs</span></code>). If the input string contains tabs and the grammar uses parse actions that use the <code class="docutils literal notranslate"><span class="pre">loc</span></code> argument to index into the string being parsed, one can ensure a consistent view of the input string by doing one of the following:</p> <ul class="simple"> <li>calling <code class="docutils literal notranslate"><span class="pre">parse_with_tabs</span></code> on your grammar before calling <code class="docutils literal notranslate"><span class="pre">parse_string</span></code> (see <a class="reference internal" href="#pyparsing.ParserElement.parse_with_tabs" title="pyparsing.ParserElement.parse_with_tabs"><code class="xref py py-class docutils literal notranslate"><span class="pre">parse_with_tabs</span></code></a>),</li> <li>define your parse action using the full <code class="docutils literal notranslate"><span class="pre">(s,loc,toks)</span></code> signature, and reference the input string using the parse action’s <code class="docutils literal notranslate"><span class="pre">s</span></code> argument, or</li> <li>explicitly expand the tabs in your input string before calling <code class="docutils literal notranslate"><span class="pre">parse_string</span></code>.</li> </ul> <p>Examples:</p> <p>By default, partial matches are OK.</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">res</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="s1">'a'</span><span class="p">)</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s1">'aaaaabaaa'</span><span class="p">)</span> <span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">res</span><span class="p">)</span> <span class="go">['aaaaa']</span> </pre></div> </div> <p>The parsing behavior varies by the inheriting class of this abstract class. Please refer to the children directly to see more examples.</p> <p>It raises an exception if parse_all flag is set and instring does not match the whole grammar.</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">res</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="s1">'a'</span><span class="p">)</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s1">'aaaaabaaa'</span><span class="p">,</span> <span class="n">parse_all</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span> <span class="gt">Traceback (most recent call last):</span> <span class="c">...</span> <span class="gr">pyparsing.ParseException</span>: <span class="n">Expected end of text, found 'b' (at char 5), (line:1, col:6)</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.parse_with_tabs"> <code class="descname">parse_with_tabs</code><span class="sig-paren">(</span><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.parse_with_tabs" title="Permalink to this definition">¶</a></dt> <dd><p>Overrides default behavior to expand <code class="docutils literal notranslate"><span class="pre"><TAB></span></code> s to spaces before parsing the input string. Must be called before <code class="docutils literal notranslate"><span class="pre">parse_string</span></code> when the input grammar contains elements that match <code class="docutils literal notranslate"><span class="pre"><TAB></span></code> characters.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.runTests"> <code class="descname">runTests</code><span class="sig-paren">(</span><em>tests: Union[str, typing.List[str]], parse_all: bool = True, comment: Union[_ForwardRef('ParserElement'), str, NoneType] = '#', full_dump: bool = True, print_results: bool = True, failure_tests: bool = False, post_parse: Callable[[str, pyparsing.results.ParseResults], str] = None, file: Union[typing.TextIO, NoneType] = None, with_line_numbers: bool = False, *, parseAll: bool = True, fullDump: bool = True, printResults: bool = True, failureTests: bool = False, postParse: Callable[[str, pyparsing.results.ParseResults], str] = None</em><span class="sig-paren">)</span> → Tuple[bool, List[Tuple[str, Union[pyparsing.results.ParseResults, Exception]]]]<a class="headerlink" href="#pyparsing.ParserElement.runTests" title="Permalink to this definition">¶</a></dt> <dd><p>Execute the parse expression on a series of test strings, showing each test, the parsed results or where the parse failed. Quick and easy way to run a parse expression against a list of sample strings.</p> <p>Parameters: - <code class="docutils literal notranslate"><span class="pre">tests</span></code> - a list of separate test strings, or a multiline string of test strings - <code class="docutils literal notranslate"><span class="pre">parse_all</span></code> - (default= <code class="docutils literal notranslate"><span class="pre">True</span></code>) - flag to pass to <a class="reference internal" href="#pyparsing.ParserElement.parse_string" title="pyparsing.ParserElement.parse_string"><code class="xref py py-class docutils literal notranslate"><span class="pre">parse_string</span></code></a> when running tests - <code class="docutils literal notranslate"><span class="pre">comment</span></code> - (default= <code class="docutils literal notranslate"><span class="pre">'#'</span></code>) - expression for indicating embedded comments in the test</p> <blockquote> <div>string; pass None to disable comment filtering</div></blockquote> <ul class="simple"> <li><code class="docutils literal notranslate"><span class="pre">full_dump</span></code> - (default= <code class="docutils literal notranslate"><span class="pre">True</span></code>) - dump results as list followed by results names in nested outline; if False, only dump nested list</li> <li><code class="docutils literal notranslate"><span class="pre">print_results</span></code> - (default= <code class="docutils literal notranslate"><span class="pre">True</span></code>) prints test output to stdout</li> <li><code class="docutils literal notranslate"><span class="pre">failure_tests</span></code> - (default= <code class="docutils literal notranslate"><span class="pre">False</span></code>) indicates if these tests are expected to fail parsing</li> <li><code class="docutils literal notranslate"><span class="pre">post_parse</span></code> - (default= <code class="docutils literal notranslate"><span class="pre">None</span></code>) optional callback for successful parse results; called as <cite>fn(test_string, parse_results)</cite> and returns a string to be added to the test output</li> <li><code class="docutils literal notranslate"><span class="pre">file</span></code> - (default= <code class="docutils literal notranslate"><span class="pre">None</span></code>) optional file-like object to which test output will be written; if None, will default to <code class="docutils literal notranslate"><span class="pre">sys.stdout</span></code></li> <li><code class="docutils literal notranslate"><span class="pre">with_line_numbers</span></code> - default= <code class="docutils literal notranslate"><span class="pre">False</span></code>) show test strings with line and column numbers</li> </ul> <p>Returns: a (success, results) tuple, where success indicates that all tests succeeded (or failed if <code class="docutils literal notranslate"><span class="pre">failure_tests</span></code> is True), and the results contain a list of lines of each test’s output</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">number_expr</span> <span class="o">=</span> <span class="n">pyparsing_common</span><span class="o">.</span><span class="n">number</span><span class="o">.</span><span class="n">copy</span><span class="p">()</span> <span class="n">result</span> <span class="o">=</span> <span class="n">number_expr</span><span class="o">.</span><span class="n">run_tests</span><span class="p">(</span><span class="s1">'''</span> <span class="s1"> # unsigned integer</span> <span class="s1"> 100</span> <span class="s1"> # negative integer</span> <span class="s1"> -100</span> <span class="s1"> # float with scientific notation</span> <span class="s1"> 6.02e23</span> <span class="s1"> # integer with scientific notation</span> <span class="s1"> 1e-12</span> <span class="s1"> '''</span><span class="p">)</span> <span class="nb">print</span><span class="p">(</span><span class="s2">"Success"</span> <span class="k">if</span> <span class="n">result</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="k">else</span> <span class="s2">"Failed!"</span><span class="p">)</span> <span class="n">result</span> <span class="o">=</span> <span class="n">number_expr</span><span class="o">.</span><span class="n">run_tests</span><span class="p">(</span><span class="s1">'''</span> <span class="s1"> # stray character</span> <span class="s1"> 100Z</span> <span class="s1"> # missing leading digit before '.'</span> <span class="s1"> -.100</span> <span class="s1"> # too many '.'</span> <span class="s1"> 3.14.159</span> <span class="s1"> '''</span><span class="p">,</span> <span class="n">failure_tests</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span> <span class="nb">print</span><span class="p">(</span><span class="s2">"Success"</span> <span class="k">if</span> <span class="n">result</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="k">else</span> <span class="s2">"Failed!"</span><span class="p">)</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># unsigned integer</span> <span class="mi">100</span> <span class="p">[</span><span class="mi">100</span><span class="p">]</span> <span class="c1"># negative integer</span> <span class="o">-</span><span class="mi">100</span> <span class="p">[</span><span class="o">-</span><span class="mi">100</span><span class="p">]</span> <span class="c1"># float with scientific notation</span> <span class="mf">6.02e23</span> <span class="p">[</span><span class="mf">6.02e+23</span><span class="p">]</span> <span class="c1"># integer with scientific notation</span> <span class="mf">1e-12</span> <span class="p">[</span><span class="mf">1e-12</span><span class="p">]</span> <span class="n">Success</span> <span class="c1"># stray character</span> <span class="mi">100</span><span class="n">Z</span> <span class="o">^</span> <span class="n">FAIL</span><span class="p">:</span> <span class="n">Expected</span> <span class="n">end</span> <span class="n">of</span> <span class="n">text</span> <span class="p">(</span><span class="n">at</span> <span class="n">char</span> <span class="mi">3</span><span class="p">),</span> <span class="p">(</span><span class="n">line</span><span class="p">:</span><span class="mi">1</span><span class="p">,</span> <span class="n">col</span><span class="p">:</span><span class="mi">4</span><span class="p">)</span> <span class="c1"># missing leading digit before '.'</span> <span class="o">-.</span><span class="mi">100</span> <span class="o">^</span> <span class="n">FAIL</span><span class="p">:</span> <span class="n">Expected</span> <span class="p">{</span><span class="n">real</span> <span class="n">number</span> <span class="k">with</span> <span class="n">scientific</span> <span class="n">notation</span> <span class="o">|</span> <span class="n">real</span> <span class="n">number</span> <span class="o">|</span> <span class="n">signed</span> <span class="n">integer</span><span class="p">}</span> <span class="p">(</span><span class="n">at</span> <span class="n">char</span> <span class="mi">0</span><span class="p">),</span> <span class="p">(</span><span class="n">line</span><span class="p">:</span><span class="mi">1</span><span class="p">,</span> <span class="n">col</span><span class="p">:</span><span class="mi">1</span><span class="p">)</span> <span class="c1"># too many '.'</span> <span class="mf">3.14</span><span class="o">.</span><span class="mi">159</span> <span class="o">^</span> <span class="n">FAIL</span><span class="p">:</span> <span class="n">Expected</span> <span class="n">end</span> <span class="n">of</span> <span class="n">text</span> <span class="p">(</span><span class="n">at</span> <span class="n">char</span> <span class="mi">4</span><span class="p">),</span> <span class="p">(</span><span class="n">line</span><span class="p">:</span><span class="mi">1</span><span class="p">,</span> <span class="n">col</span><span class="p">:</span><span class="mi">5</span><span class="p">)</span> <span class="n">Success</span> </pre></div> </div> <p>Each test string must be on a single line. If you want to test a string that spans multiple lines, create a test like this:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">expr</span><span class="o">.</span><span class="n">run_tests</span><span class="p">(</span><span class="sa">r</span><span class="s2">"this is a test\n of strings that spans \n 3 lines"</span><span class="p">)</span> </pre></div> </div> <p>(Note that this is a raw string literal, you must include the leading <code class="docutils literal notranslate"><span class="pre">'r'</span></code>.)</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.run_tests"> <code class="descname">run_tests</code><span class="sig-paren">(</span><em>tests: Union[str, typing.List[str]], parse_all: bool = True, comment: Union[_ForwardRef('ParserElement'), str, NoneType] = '#', full_dump: bool = True, print_results: bool = True, failure_tests: bool = False, post_parse: Callable[[str, pyparsing.results.ParseResults], str] = None, file: Union[typing.TextIO, NoneType] = None, with_line_numbers: bool = False, *, parseAll: bool = True, fullDump: bool = True, printResults: bool = True, failureTests: bool = False, postParse: Callable[[str, pyparsing.results.ParseResults], str] = None</em><span class="sig-paren">)</span> → Tuple[bool, List[Tuple[str, Union[pyparsing.results.ParseResults, Exception]]]]<a class="headerlink" href="#pyparsing.ParserElement.run_tests" title="Permalink to this definition">¶</a></dt> <dd><p>Execute the parse expression on a series of test strings, showing each test, the parsed results or where the parse failed. Quick and easy way to run a parse expression against a list of sample strings.</p> <p>Parameters: - <code class="docutils literal notranslate"><span class="pre">tests</span></code> - a list of separate test strings, or a multiline string of test strings - <code class="docutils literal notranslate"><span class="pre">parse_all</span></code> - (default= <code class="docutils literal notranslate"><span class="pre">True</span></code>) - flag to pass to <a class="reference internal" href="#pyparsing.ParserElement.parse_string" title="pyparsing.ParserElement.parse_string"><code class="xref py py-class docutils literal notranslate"><span class="pre">parse_string</span></code></a> when running tests - <code class="docutils literal notranslate"><span class="pre">comment</span></code> - (default= <code class="docutils literal notranslate"><span class="pre">'#'</span></code>) - expression for indicating embedded comments in the test</p> <blockquote> <div>string; pass None to disable comment filtering</div></blockquote> <ul class="simple"> <li><code class="docutils literal notranslate"><span class="pre">full_dump</span></code> - (default= <code class="docutils literal notranslate"><span class="pre">True</span></code>) - dump results as list followed by results names in nested outline; if False, only dump nested list</li> <li><code class="docutils literal notranslate"><span class="pre">print_results</span></code> - (default= <code class="docutils literal notranslate"><span class="pre">True</span></code>) prints test output to stdout</li> <li><code class="docutils literal notranslate"><span class="pre">failure_tests</span></code> - (default= <code class="docutils literal notranslate"><span class="pre">False</span></code>) indicates if these tests are expected to fail parsing</li> <li><code class="docutils literal notranslate"><span class="pre">post_parse</span></code> - (default= <code class="docutils literal notranslate"><span class="pre">None</span></code>) optional callback for successful parse results; called as <cite>fn(test_string, parse_results)</cite> and returns a string to be added to the test output</li> <li><code class="docutils literal notranslate"><span class="pre">file</span></code> - (default= <code class="docutils literal notranslate"><span class="pre">None</span></code>) optional file-like object to which test output will be written; if None, will default to <code class="docutils literal notranslate"><span class="pre">sys.stdout</span></code></li> <li><code class="docutils literal notranslate"><span class="pre">with_line_numbers</span></code> - default= <code class="docutils literal notranslate"><span class="pre">False</span></code>) show test strings with line and column numbers</li> </ul> <p>Returns: a (success, results) tuple, where success indicates that all tests succeeded (or failed if <code class="docutils literal notranslate"><span class="pre">failure_tests</span></code> is True), and the results contain a list of lines of each test’s output</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">number_expr</span> <span class="o">=</span> <span class="n">pyparsing_common</span><span class="o">.</span><span class="n">number</span><span class="o">.</span><span class="n">copy</span><span class="p">()</span> <span class="n">result</span> <span class="o">=</span> <span class="n">number_expr</span><span class="o">.</span><span class="n">run_tests</span><span class="p">(</span><span class="s1">'''</span> <span class="s1"> # unsigned integer</span> <span class="s1"> 100</span> <span class="s1"> # negative integer</span> <span class="s1"> -100</span> <span class="s1"> # float with scientific notation</span> <span class="s1"> 6.02e23</span> <span class="s1"> # integer with scientific notation</span> <span class="s1"> 1e-12</span> <span class="s1"> '''</span><span class="p">)</span> <span class="nb">print</span><span class="p">(</span><span class="s2">"Success"</span> <span class="k">if</span> <span class="n">result</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="k">else</span> <span class="s2">"Failed!"</span><span class="p">)</span> <span class="n">result</span> <span class="o">=</span> <span class="n">number_expr</span><span class="o">.</span><span class="n">run_tests</span><span class="p">(</span><span class="s1">'''</span> <span class="s1"> # stray character</span> <span class="s1"> 100Z</span> <span class="s1"> # missing leading digit before '.'</span> <span class="s1"> -.100</span> <span class="s1"> # too many '.'</span> <span class="s1"> 3.14.159</span> <span class="s1"> '''</span><span class="p">,</span> <span class="n">failure_tests</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span> <span class="nb">print</span><span class="p">(</span><span class="s2">"Success"</span> <span class="k">if</span> <span class="n">result</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="k">else</span> <span class="s2">"Failed!"</span><span class="p">)</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># unsigned integer</span> <span class="mi">100</span> <span class="p">[</span><span class="mi">100</span><span class="p">]</span> <span class="c1"># negative integer</span> <span class="o">-</span><span class="mi">100</span> <span class="p">[</span><span class="o">-</span><span class="mi">100</span><span class="p">]</span> <span class="c1"># float with scientific notation</span> <span class="mf">6.02e23</span> <span class="p">[</span><span class="mf">6.02e+23</span><span class="p">]</span> <span class="c1"># integer with scientific notation</span> <span class="mf">1e-12</span> <span class="p">[</span><span class="mf">1e-12</span><span class="p">]</span> <span class="n">Success</span> <span class="c1"># stray character</span> <span class="mi">100</span><span class="n">Z</span> <span class="o">^</span> <span class="n">FAIL</span><span class="p">:</span> <span class="n">Expected</span> <span class="n">end</span> <span class="n">of</span> <span class="n">text</span> <span class="p">(</span><span class="n">at</span> <span class="n">char</span> <span class="mi">3</span><span class="p">),</span> <span class="p">(</span><span class="n">line</span><span class="p">:</span><span class="mi">1</span><span class="p">,</span> <span class="n">col</span><span class="p">:</span><span class="mi">4</span><span class="p">)</span> <span class="c1"># missing leading digit before '.'</span> <span class="o">-.</span><span class="mi">100</span> <span class="o">^</span> <span class="n">FAIL</span><span class="p">:</span> <span class="n">Expected</span> <span class="p">{</span><span class="n">real</span> <span class="n">number</span> <span class="k">with</span> <span class="n">scientific</span> <span class="n">notation</span> <span class="o">|</span> <span class="n">real</span> <span class="n">number</span> <span class="o">|</span> <span class="n">signed</span> <span class="n">integer</span><span class="p">}</span> <span class="p">(</span><span class="n">at</span> <span class="n">char</span> <span class="mi">0</span><span class="p">),</span> <span class="p">(</span><span class="n">line</span><span class="p">:</span><span class="mi">1</span><span class="p">,</span> <span class="n">col</span><span class="p">:</span><span class="mi">1</span><span class="p">)</span> <span class="c1"># too many '.'</span> <span class="mf">3.14</span><span class="o">.</span><span class="mi">159</span> <span class="o">^</span> <span class="n">FAIL</span><span class="p">:</span> <span class="n">Expected</span> <span class="n">end</span> <span class="n">of</span> <span class="n">text</span> <span class="p">(</span><span class="n">at</span> <span class="n">char</span> <span class="mi">4</span><span class="p">),</span> <span class="p">(</span><span class="n">line</span><span class="p">:</span><span class="mi">1</span><span class="p">,</span> <span class="n">col</span><span class="p">:</span><span class="mi">5</span><span class="p">)</span> <span class="n">Success</span> </pre></div> </div> <p>Each test string must be on a single line. If you want to test a string that spans multiple lines, create a test like this:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">expr</span><span class="o">.</span><span class="n">run_tests</span><span class="p">(</span><span class="sa">r</span><span class="s2">"this is a test\n of strings that spans \n 3 lines"</span><span class="p">)</span> </pre></div> </div> <p>(Note that this is a raw string literal, you must include the leading <code class="docutils literal notranslate"><span class="pre">'r'</span></code>.)</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.scanString"> <code class="descname">scanString</code><span class="sig-paren">(</span><em>instring: str</em>, <em>max_matches: int = 9223372036854775807</em>, <em>overlap: bool = False</em>, <em>*</em>, <em>debug: bool = False</em>, <em>maxMatches: int = 9223372036854775807</em><span class="sig-paren">)</span> → Generator[[Tuple[pyparsing.results.ParseResults, int, int], NoneType], NoneType]<a class="headerlink" href="#pyparsing.ParserElement.scanString" title="Permalink to this definition">¶</a></dt> <dd><p>Scan the input string for expression matches. Each match will return the matching tokens, start location, and end location. May be called with optional <code class="docutils literal notranslate"><span class="pre">max_matches</span></code> argument, to clip scanning after ‘n’ matches are found. If <code class="docutils literal notranslate"><span class="pre">overlap</span></code> is specified, then overlapping matches will be reported.</p> <p>Note that the start and end locations are reported relative to the string being parsed. See <a class="reference internal" href="#pyparsing.ParserElement.parse_string" title="pyparsing.ParserElement.parse_string"><code class="xref py py-class docutils literal notranslate"><span class="pre">parse_string</span></code></a> for more information on parsing strings with embedded tabs.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">source</span> <span class="o">=</span> <span class="s2">"sldjf123lsdjjkf345sldkjf879lkjsfd987"</span> <span class="nb">print</span><span class="p">(</span><span class="n">source</span><span class="p">)</span> <span class="k">for</span> <span class="n">tokens</span><span class="p">,</span> <span class="n">start</span><span class="p">,</span> <span class="n">end</span> <span class="ow">in</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)</span><span class="o">.</span><span class="n">scan_string</span><span class="p">(</span><span class="n">source</span><span class="p">):</span> <span class="nb">print</span><span class="p">(</span><span class="s1">' '</span><span class="o">*</span><span class="n">start</span> <span class="o">+</span> <span class="s1">'^'</span><span class="o">*</span><span class="p">(</span><span class="n">end</span><span class="o">-</span><span class="n">start</span><span class="p">))</span> <span class="nb">print</span><span class="p">(</span><span class="s1">' '</span><span class="o">*</span><span class="n">start</span> <span class="o">+</span> <span class="n">tokens</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">sldjf123lsdjjkf345sldkjf879lkjsfd987</span> <span class="o">^^^^^</span> <span class="n">sldjf</span> <span class="o">^^^^^^^</span> <span class="n">lsdjjkf</span> <span class="o">^^^^^^</span> <span class="n">sldkjf</span> <span class="o">^^^^^^</span> <span class="n">lkjsfd</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.scan_string"> <code class="descname">scan_string</code><span class="sig-paren">(</span><em>instring: str</em>, <em>max_matches: int = 9223372036854775807</em>, <em>overlap: bool = False</em>, <em>*</em>, <em>debug: bool = False</em>, <em>maxMatches: int = 9223372036854775807</em><span class="sig-paren">)</span> → Generator[[Tuple[pyparsing.results.ParseResults, int, int], NoneType], NoneType]<a class="headerlink" href="#pyparsing.ParserElement.scan_string" title="Permalink to this definition">¶</a></dt> <dd><p>Scan the input string for expression matches. Each match will return the matching tokens, start location, and end location. May be called with optional <code class="docutils literal notranslate"><span class="pre">max_matches</span></code> argument, to clip scanning after ‘n’ matches are found. If <code class="docutils literal notranslate"><span class="pre">overlap</span></code> is specified, then overlapping matches will be reported.</p> <p>Note that the start and end locations are reported relative to the string being parsed. See <a class="reference internal" href="#pyparsing.ParserElement.parse_string" title="pyparsing.ParserElement.parse_string"><code class="xref py py-class docutils literal notranslate"><span class="pre">parse_string</span></code></a> for more information on parsing strings with embedded tabs.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">source</span> <span class="o">=</span> <span class="s2">"sldjf123lsdjjkf345sldkjf879lkjsfd987"</span> <span class="nb">print</span><span class="p">(</span><span class="n">source</span><span class="p">)</span> <span class="k">for</span> <span class="n">tokens</span><span class="p">,</span> <span class="n">start</span><span class="p">,</span> <span class="n">end</span> <span class="ow">in</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)</span><span class="o">.</span><span class="n">scan_string</span><span class="p">(</span><span class="n">source</span><span class="p">):</span> <span class="nb">print</span><span class="p">(</span><span class="s1">' '</span><span class="o">*</span><span class="n">start</span> <span class="o">+</span> <span class="s1">'^'</span><span class="o">*</span><span class="p">(</span><span class="n">end</span><span class="o">-</span><span class="n">start</span><span class="p">))</span> <span class="nb">print</span><span class="p">(</span><span class="s1">' '</span><span class="o">*</span><span class="n">start</span> <span class="o">+</span> <span class="n">tokens</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">sldjf123lsdjjkf345sldkjf879lkjsfd987</span> <span class="o">^^^^^</span> <span class="n">sldjf</span> <span class="o">^^^^^^^</span> <span class="n">lsdjjkf</span> <span class="o">^^^^^^</span> <span class="n">sldkjf</span> <span class="o">^^^^^^</span> <span class="n">lkjsfd</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.searchString"> <code class="descname">searchString</code><span class="sig-paren">(</span><em>instring: str</em>, <em>max_matches: int = 9223372036854775807</em>, <em>*</em>, <em>debug: bool = False</em>, <em>maxMatches: int = 9223372036854775807</em><span class="sig-paren">)</span> → pyparsing.results.ParseResults<a class="headerlink" href="#pyparsing.ParserElement.searchString" title="Permalink to this definition">¶</a></dt> <dd><p>Another extension to <a class="reference internal" href="#pyparsing.ParserElement.scan_string" title="pyparsing.ParserElement.scan_string"><code class="xref py py-class docutils literal notranslate"><span class="pre">scan_string</span></code></a>, simplifying the access to the tokens found to match the given parse expression. May be called with optional <code class="docutils literal notranslate"><span class="pre">max_matches</span></code> argument, to clip searching after ‘n’ matches are found.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># a capitalized word starts with an uppercase letter, followed by zero or more lowercase letters</span> <span class="n">cap_word</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="o">.</span><span class="n">upper</span><span class="p">(),</span> <span class="n">alphas</span><span class="o">.</span><span class="n">lower</span><span class="p">())</span> <span class="nb">print</span><span class="p">(</span><span class="n">cap_word</span><span class="o">.</span><span class="n">search_string</span><span class="p">(</span><span class="s2">"More than Iron, more than Lead, more than Gold I need Electricity"</span><span class="p">))</span> <span class="c1"># the sum() builtin can be used to merge results into a single ParseResults object</span> <span class="nb">print</span><span class="p">(</span><span class="nb">sum</span><span class="p">(</span><span class="n">cap_word</span><span class="o">.</span><span class="n">search_string</span><span class="p">(</span><span class="s2">"More than Iron, more than Lead, more than Gold I need Electricity"</span><span class="p">)))</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[[</span><span class="s1">'More'</span><span class="p">],</span> <span class="p">[</span><span class="s1">'Iron'</span><span class="p">],</span> <span class="p">[</span><span class="s1">'Lead'</span><span class="p">],</span> <span class="p">[</span><span class="s1">'Gold'</span><span class="p">],</span> <span class="p">[</span><span class="s1">'I'</span><span class="p">],</span> <span class="p">[</span><span class="s1">'Electricity'</span><span class="p">]]</span> <span class="p">[</span><span class="s1">'More'</span><span class="p">,</span> <span class="s1">'Iron'</span><span class="p">,</span> <span class="s1">'Lead'</span><span class="p">,</span> <span class="s1">'Gold'</span><span class="p">,</span> <span class="s1">'I'</span><span class="p">,</span> <span class="s1">'Electricity'</span><span class="p">]</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.search_string"> <code class="descname">search_string</code><span class="sig-paren">(</span><em>instring: str</em>, <em>max_matches: int = 9223372036854775807</em>, <em>*</em>, <em>debug: bool = False</em>, <em>maxMatches: int = 9223372036854775807</em><span class="sig-paren">)</span> → pyparsing.results.ParseResults<a class="headerlink" href="#pyparsing.ParserElement.search_string" title="Permalink to this definition">¶</a></dt> <dd><p>Another extension to <a class="reference internal" href="#pyparsing.ParserElement.scan_string" title="pyparsing.ParserElement.scan_string"><code class="xref py py-class docutils literal notranslate"><span class="pre">scan_string</span></code></a>, simplifying the access to the tokens found to match the given parse expression. May be called with optional <code class="docutils literal notranslate"><span class="pre">max_matches</span></code> argument, to clip searching after ‘n’ matches are found.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># a capitalized word starts with an uppercase letter, followed by zero or more lowercase letters</span> <span class="n">cap_word</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="o">.</span><span class="n">upper</span><span class="p">(),</span> <span class="n">alphas</span><span class="o">.</span><span class="n">lower</span><span class="p">())</span> <span class="nb">print</span><span class="p">(</span><span class="n">cap_word</span><span class="o">.</span><span class="n">search_string</span><span class="p">(</span><span class="s2">"More than Iron, more than Lead, more than Gold I need Electricity"</span><span class="p">))</span> <span class="c1"># the sum() builtin can be used to merge results into a single ParseResults object</span> <span class="nb">print</span><span class="p">(</span><span class="nb">sum</span><span class="p">(</span><span class="n">cap_word</span><span class="o">.</span><span class="n">search_string</span><span class="p">(</span><span class="s2">"More than Iron, more than Lead, more than Gold I need Electricity"</span><span class="p">)))</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[[</span><span class="s1">'More'</span><span class="p">],</span> <span class="p">[</span><span class="s1">'Iron'</span><span class="p">],</span> <span class="p">[</span><span class="s1">'Lead'</span><span class="p">],</span> <span class="p">[</span><span class="s1">'Gold'</span><span class="p">],</span> <span class="p">[</span><span class="s1">'I'</span><span class="p">],</span> <span class="p">[</span><span class="s1">'Electricity'</span><span class="p">]]</span> <span class="p">[</span><span class="s1">'More'</span><span class="p">,</span> <span class="s1">'Iron'</span><span class="p">,</span> <span class="s1">'Lead'</span><span class="p">,</span> <span class="s1">'Gold'</span><span class="p">,</span> <span class="s1">'I'</span><span class="p">,</span> <span class="s1">'Electricity'</span><span class="p">]</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.setBreak"> <code class="descname">setBreak</code><span class="sig-paren">(</span><em>break_flag: bool = True</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.setBreak" title="Permalink to this definition">¶</a></dt> <dd><p>Method to invoke the Python pdb debugger when this element is about to be parsed. Set <code class="docutils literal notranslate"><span class="pre">break_flag</span></code> to <code class="docutils literal notranslate"><span class="pre">True</span></code> to enable, <code class="docutils literal notranslate"><span class="pre">False</span></code> to disable.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.setDebug"> <code class="descname">setDebug</code><span class="sig-paren">(</span><em>flag: bool = True</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.setDebug" title="Permalink to this definition">¶</a></dt> <dd><p>Enable display of debugging messages while doing pattern matching. Set <code class="docutils literal notranslate"><span class="pre">flag</span></code> to <code class="docutils literal notranslate"><span class="pre">True</span></code> to enable, <code class="docutils literal notranslate"><span class="pre">False</span></code> to disable.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">wd</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)</span><span class="o">.</span><span class="n">set_name</span><span class="p">(</span><span class="s2">"alphaword"</span><span class="p">)</span> <span class="n">integer</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span><span class="o">.</span><span class="n">set_name</span><span class="p">(</span><span class="s2">"numword"</span><span class="p">)</span> <span class="n">term</span> <span class="o">=</span> <span class="n">wd</span> <span class="o">|</span> <span class="n">integer</span> <span class="c1"># turn on debugging for wd</span> <span class="n">wd</span><span class="o">.</span><span class="n">set_debug</span><span class="p">()</span> <span class="n">term</span><span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"abc 123 xyz 890"</span><span class="p">)</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">Match</span> <span class="n">alphaword</span> <span class="n">at</span> <span class="n">loc</span> <span class="mi">0</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="p">)</span> <span class="n">Matched</span> <span class="n">alphaword</span> <span class="o">-></span> <span class="p">[</span><span class="s1">'abc'</span><span class="p">]</span> <span class="n">Match</span> <span class="n">alphaword</span> <span class="n">at</span> <span class="n">loc</span> <span class="mi">3</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">4</span><span class="p">)</span> <span class="ne">Exception</span> <span class="n">raised</span><span class="p">:</span><span class="n">Expected</span> <span class="n">alphaword</span> <span class="p">(</span><span class="n">at</span> <span class="n">char</span> <span class="mi">4</span><span class="p">),</span> <span class="p">(</span><span class="n">line</span><span class="p">:</span><span class="mi">1</span><span class="p">,</span> <span class="n">col</span><span class="p">:</span><span class="mi">5</span><span class="p">)</span> <span class="n">Match</span> <span class="n">alphaword</span> <span class="n">at</span> <span class="n">loc</span> <span class="mi">7</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">8</span><span class="p">)</span> <span class="n">Matched</span> <span class="n">alphaword</span> <span class="o">-></span> <span class="p">[</span><span class="s1">'xyz'</span><span class="p">]</span> <span class="n">Match</span> <span class="n">alphaword</span> <span class="n">at</span> <span class="n">loc</span> <span class="mi">11</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">12</span><span class="p">)</span> <span class="ne">Exception</span> <span class="n">raised</span><span class="p">:</span><span class="n">Expected</span> <span class="n">alphaword</span> <span class="p">(</span><span class="n">at</span> <span class="n">char</span> <span class="mi">12</span><span class="p">),</span> <span class="p">(</span><span class="n">line</span><span class="p">:</span><span class="mi">1</span><span class="p">,</span> <span class="n">col</span><span class="p">:</span><span class="mi">13</span><span class="p">)</span> <span class="n">Match</span> <span class="n">alphaword</span> <span class="n">at</span> <span class="n">loc</span> <span class="mi">15</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">16</span><span class="p">)</span> <span class="ne">Exception</span> <span class="n">raised</span><span class="p">:</span><span class="n">Expected</span> <span class="n">alphaword</span> <span class="p">(</span><span class="n">at</span> <span class="n">char</span> <span class="mi">15</span><span class="p">),</span> <span class="p">(</span><span class="n">line</span><span class="p">:</span><span class="mi">1</span><span class="p">,</span> <span class="n">col</span><span class="p">:</span><span class="mi">16</span><span class="p">)</span> </pre></div> </div> <p>The output shown is that produced by the default debug actions - custom debug actions can be specified using <a class="reference internal" href="#pyparsing.ParserElement.set_debug_actions" title="pyparsing.ParserElement.set_debug_actions"><code class="xref py py-class docutils literal notranslate"><span class="pre">set_debug_actions</span></code></a>. Prior to attempting to match the <code class="docutils literal notranslate"><span class="pre">wd</span></code> expression, the debugging message <code class="docutils literal notranslate"><span class="pre">"Match</span> <span class="pre"><exprname></span> <span class="pre">at</span> <span class="pre">loc</span> <span class="pre"><n>(<line>,<col>)"</span></code> is shown. Then if the parse succeeds, a <code class="docutils literal notranslate"><span class="pre">"Matched"</span></code> message is shown, or an <code class="docutils literal notranslate"><span class="pre">"Exception</span> <span class="pre">raised"</span></code> message is shown. Also note the use of <a class="reference internal" href="#pyparsing.ParserElement.set_name" title="pyparsing.ParserElement.set_name"><code class="xref py py-class docutils literal notranslate"><span class="pre">set_name</span></code></a> to assign a human-readable name to the expression, which makes debugging and exception messages easier to understand - for instance, the default name created for the <a class="reference internal" href="#pyparsing.Word" title="pyparsing.Word"><code class="xref py py-class docutils literal notranslate"><span class="pre">Word</span></code></a> expression without calling <code class="docutils literal notranslate"><span class="pre">set_name</span></code> is <code class="docutils literal notranslate"><span class="pre">"W:(A-Za-z)"</span></code>.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.setDebugActions"> <code class="descname">setDebugActions</code><span class="sig-paren">(</span><em>start_action: Callable[[str, int, _ForwardRef('ParserElement'), bool], NoneType], success_action: Callable[[str, int, int, _ForwardRef('ParserElement'), pyparsing.results.ParseResults, bool], NoneType], exception_action: Callable[[str, int, _ForwardRef('ParserElement'), Exception, bool], NoneType]</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.setDebugActions" title="Permalink to this definition">¶</a></dt> <dd><p>Customize display of debugging messages while doing pattern matching:</p> <ul class="simple"> <li><code class="docutils literal notranslate"><span class="pre">start_action</span></code> - method to be called when an expression is about to be parsed; should have the signature <code class="docutils literal notranslate"><span class="pre">fn(input_string:</span> <span class="pre">str,</span> <span class="pre">location:</span> <span class="pre">int,</span> <span class="pre">expression:</span> <span class="pre">ParserElement,</span> <span class="pre">cache_hit:</span> <span class="pre">bool)</span></code></li> <li><code class="docutils literal notranslate"><span class="pre">success_action</span></code> - method to be called when an expression has successfully parsed; should have the signature <code class="docutils literal notranslate"><span class="pre">fn(input_string:</span> <span class="pre">str,</span> <span class="pre">start_location:</span> <span class="pre">int,</span> <span class="pre">end_location:</span> <span class="pre">int,</span> <span class="pre">expression:</span> <span class="pre">ParserELement,</span> <span class="pre">parsed_tokens:</span> <span class="pre">ParseResults,</span> <span class="pre">cache_hit:</span> <span class="pre">bool)</span></code></li> <li><code class="docutils literal notranslate"><span class="pre">exception_action</span></code> - method to be called when expression fails to parse; should have the signature <code class="docutils literal notranslate"><span class="pre">fn(input_string:</span> <span class="pre">str,</span> <span class="pre">location:</span> <span class="pre">int,</span> <span class="pre">expression:</span> <span class="pre">ParserElement,</span> <span class="pre">exception:</span> <span class="pre">Exception,</span> <span class="pre">cache_hit:</span> <span class="pre">bool)</span></code></li> </ul> </dd></dl> <dl class="staticmethod"> <dt id="pyparsing.ParserElement.setDefaultWhitespaceChars"> <em class="property">static </em><code class="descname">setDefaultWhitespaceChars</code><span class="sig-paren">(</span><em>chars: str</em><span class="sig-paren">)</span> → None<a class="headerlink" href="#pyparsing.ParserElement.setDefaultWhitespaceChars" title="Permalink to this definition">¶</a></dt> <dd><p>Overrides the default whitespace chars</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># default whitespace chars are space, <TAB> and newline</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"abc def</span><span class="se">\n</span><span class="s2">ghi jkl"</span><span class="p">)</span> <span class="c1"># -> ['abc', 'def', 'ghi', 'jkl']</span> <span class="c1"># change to just treat newline as significant</span> <span class="n">ParserElement</span><span class="o">.</span><span class="n">set_default_whitespace_chars</span><span class="p">(</span><span class="s2">" </span><span class="se">\t</span><span class="s2">"</span><span class="p">)</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"abc def</span><span class="se">\n</span><span class="s2">ghi jkl"</span><span class="p">)</span> <span class="c1"># -> ['abc', 'def']</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.setFailAction"> <code class="descname">setFailAction</code><span class="sig-paren">(</span><em>fn: Callable[[str, int, _ForwardRef('ParserElement'), Exception], NoneType]</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.setFailAction" title="Permalink to this definition">¶</a></dt> <dd><p>Define action to perform if parsing fails at this expression. Fail acton fn is a callable function that takes the arguments <code class="docutils literal notranslate"><span class="pre">fn(s,</span> <span class="pre">loc,</span> <span class="pre">expr,</span> <span class="pre">err)</span></code> where:</p> <ul class="simple"> <li>s = string being parsed</li> <li>loc = location where expression match was attempted and failed</li> <li>expr = the parse expression that failed</li> <li>err = the exception thrown</li> </ul> <p>The function returns no value. It may throw <a class="reference internal" href="#pyparsing.ParseFatalException" title="pyparsing.ParseFatalException"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParseFatalException</span></code></a> if it is desired to stop parsing immediately.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.setName"> <code class="descname">setName</code><span class="sig-paren">(</span><em>name: str</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.setName" title="Permalink to this definition">¶</a></dt> <dd><p>Define name for this expression, makes debugging and exception messages clearer. Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"ABC"</span><span class="p">)</span> <span class="c1"># -> Exception: Expected W:(0-9) (at char 0), (line:1, col:1)</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span><span class="o">.</span><span class="n">set_name</span><span class="p">(</span><span class="s2">"integer"</span><span class="p">)</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"ABC"</span><span class="p">)</span> <span class="c1"># -> Exception: Expected integer (at char 0), (line:1, col:1)</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.setParseAction"> <code class="descname">setParseAction</code><span class="sig-paren">(</span><em>*fns</em>, <em>**kwargs</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.setParseAction" title="Permalink to this definition">¶</a></dt> <dd><p>Define one or more actions to perform when successfully matching parse element definition.</p> <p>Parse actions can be called to perform data conversions, do extra validation, update external data structures, or enhance or replace the parsed tokens. Each parse action <code class="docutils literal notranslate"><span class="pre">fn</span></code> is a callable method with 0-3 arguments, called as <code class="docutils literal notranslate"><span class="pre">fn(s,</span> <span class="pre">loc,</span> <span class="pre">toks)</span></code> , <code class="docutils literal notranslate"><span class="pre">fn(loc,</span> <span class="pre">toks)</span></code> , <code class="docutils literal notranslate"><span class="pre">fn(toks)</span></code> , or just <code class="docutils literal notranslate"><span class="pre">fn()</span></code> , where:</p> <ul class="simple"> <li>s = the original string being parsed (see note below)</li> <li>loc = the location of the matching substring</li> <li>toks = a list of the matched tokens, packaged as a <a class="reference internal" href="#pyparsing.ParseResults" title="pyparsing.ParseResults"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParseResults</span></code></a> object</li> </ul> <p>The parsed tokens are passed to the parse action as ParseResults. They can be modified in place using list-style append, extend, and pop operations to update the parsed list elements; and with dictionary-style item set and del operations to add, update, or remove any named results. If the tokens are modified in place, it is not necessary to return them with a return statement.</p> <p>Parse actions can also completely replace the given tokens, with another <code class="docutils literal notranslate"><span class="pre">ParseResults</span></code> object, or with some entirely different object (common for parse actions that perform data conversions). A convenient way to build a new parse result is to define the values using a dict, and then create the return value using <a class="reference internal" href="#pyparsing.ParseResults.from_dict" title="pyparsing.ParseResults.from_dict"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParseResults.from_dict</span></code></a>.</p> <p>If None is passed as the <code class="docutils literal notranslate"><span class="pre">fn</span></code> parse action, all previously added parse actions for this expression are cleared.</p> <p>Optional keyword arguments:</p> <ul class="simple"> <li>call_during_try = (default= <code class="docutils literal notranslate"><span class="pre">False</span></code>) indicate if parse action should be run during lookaheads and alternate testing. For parse actions that have side effects, it is important to only call the parse action once it is determined that it is being called as part of a successful parse. For parse actions that perform additional validation, then call_during_try should be passed as True, so that the validation code is included in the preliminary “try” parses.</li> </ul> <p>Note: the default parsing behavior is to expand tabs in the input string before starting the parsing process. See <a class="reference internal" href="#pyparsing.ParserElement.parse_string" title="pyparsing.ParserElement.parse_string"><code class="xref py py-class docutils literal notranslate"><span class="pre">parse_string</span></code></a> for more information on parsing strings containing <code class="docutils literal notranslate"><span class="pre"><TAB></span></code> s, and suggested methods to maintain a consistent view of the parsed string, the parse location, and line and column positions within the parsed string.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># parse dates in the form YYYY/MM/DD</span> <span class="c1"># use parse action to convert toks from str to int at parse time</span> <span class="k">def</span> <span class="nf">convert_to_int</span><span class="p">(</span><span class="n">toks</span><span class="p">):</span> <span class="k">return</span> <span class="nb">int</span><span class="p">(</span><span class="n">toks</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span> <span class="c1"># use a parse action to verify that the date is a valid date</span> <span class="k">def</span> <span class="nf">is_valid_date</span><span class="p">(</span><span class="n">instring</span><span class="p">,</span> <span class="n">loc</span><span class="p">,</span> <span class="n">toks</span><span class="p">):</span> <span class="kn">from</span> <span class="nn">datetime</span> <span class="k">import</span> <span class="n">date</span> <span class="n">year</span><span class="p">,</span> <span class="n">month</span><span class="p">,</span> <span class="n">day</span> <span class="o">=</span> <span class="n">toks</span><span class="p">[::</span><span class="mi">2</span><span class="p">]</span> <span class="k">try</span><span class="p">:</span> <span class="n">date</span><span class="p">(</span><span class="n">year</span><span class="p">,</span> <span class="n">month</span><span class="p">,</span> <span class="n">day</span><span class="p">)</span> <span class="k">except</span> <span class="ne">ValueError</span><span class="p">:</span> <span class="k">raise</span> <span class="n">ParseException</span><span class="p">(</span><span class="n">instring</span><span class="p">,</span> <span class="n">loc</span><span class="p">,</span> <span class="s2">"invalid date given"</span><span class="p">)</span> <span class="n">integer</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="n">date_str</span> <span class="o">=</span> <span class="n">integer</span> <span class="o">+</span> <span class="s1">'/'</span> <span class="o">+</span> <span class="n">integer</span> <span class="o">+</span> <span class="s1">'/'</span> <span class="o">+</span> <span class="n">integer</span> <span class="c1"># add parse actions</span> <span class="n">integer</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="n">convert_to_int</span><span class="p">)</span> <span class="n">date_str</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="n">is_valid_date</span><span class="p">)</span> <span class="c1"># note that integer fields are now ints, not strings</span> <span class="n">date_str</span><span class="o">.</span><span class="n">run_tests</span><span class="p">(</span><span class="s1">'''</span> <span class="s1"> # successful parse - note that integer fields were converted to ints</span> <span class="s1"> 1999/12/31</span> <span class="s1"> # fail - invalid date</span> <span class="s1"> 1999/13/31</span> <span class="s1"> '''</span><span class="p">)</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.setResultsName"> <code class="descname">setResultsName</code><span class="sig-paren">(</span><em>name: str</em>, <em>list_all_matches: bool = False</em>, <em>*</em>, <em>listAllMatches: bool = False</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.setResultsName" title="Permalink to this definition">¶</a></dt> <dd><p>Define name for referencing matching tokens as a nested attribute of the returned parse results.</p> <p>Normally, results names are assigned as you would assign keys in a dict: any existing value is overwritten by later values. If it is necessary to keep all values captured for a particular results name, call <code class="docutils literal notranslate"><span class="pre">set_results_name</span></code> with <code class="docutils literal notranslate"><span class="pre">list_all_matches</span></code> = True.</p> <p>NOTE: <code class="docutils literal notranslate"><span class="pre">set_results_name</span></code> returns a <em>copy</em> of the original <a class="reference internal" href="#pyparsing.ParserElement" title="pyparsing.ParserElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement</span></code></a> object; this is so that the client can define a basic element, such as an integer, and reference it in multiple places with different names.</p> <p>You can also set results names using the abbreviated syntax, <code class="docutils literal notranslate"><span class="pre">expr("name")</span></code> in place of <code class="docutils literal notranslate"><span class="pre">expr.set_results_name("name")</span></code> - see <a class="reference internal" href="#pyparsing.ParserElement.__call__" title="pyparsing.ParserElement.__call__"><code class="xref py py-class docutils literal notranslate"><span class="pre">__call__</span></code></a>. If <code class="docutils literal notranslate"><span class="pre">list_all_matches</span></code> is required, use <code class="docutils literal notranslate"><span class="pre">expr("name*")</span></code>.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">date_str</span> <span class="o">=</span> <span class="p">(</span><span class="n">integer</span><span class="o">.</span><span class="n">set_results_name</span><span class="p">(</span><span class="s2">"year"</span><span class="p">)</span> <span class="o">+</span> <span class="s1">'/'</span> <span class="o">+</span> <span class="n">integer</span><span class="o">.</span><span class="n">set_results_name</span><span class="p">(</span><span class="s2">"month"</span><span class="p">)</span> <span class="o">+</span> <span class="s1">'/'</span> <span class="o">+</span> <span class="n">integer</span><span class="o">.</span><span class="n">set_results_name</span><span class="p">(</span><span class="s2">"day"</span><span class="p">))</span> <span class="c1"># equivalent form:</span> <span class="n">date_str</span> <span class="o">=</span> <span class="n">integer</span><span class="p">(</span><span class="s2">"year"</span><span class="p">)</span> <span class="o">+</span> <span class="s1">'/'</span> <span class="o">+</span> <span class="n">integer</span><span class="p">(</span><span class="s2">"month"</span><span class="p">)</span> <span class="o">+</span> <span class="s1">'/'</span> <span class="o">+</span> <span class="n">integer</span><span class="p">(</span><span class="s2">"day"</span><span class="p">)</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.setWhitespaceChars"> <code class="descname">setWhitespaceChars</code><span class="sig-paren">(</span><em>chars: Union[typing.Set[str], str], copy_defaults: bool = False</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.setWhitespaceChars" title="Permalink to this definition">¶</a></dt> <dd><p>Overrides the default whitespace chars</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.set_break"> <code class="descname">set_break</code><span class="sig-paren">(</span><em>break_flag: bool = True</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.set_break" title="Permalink to this definition">¶</a></dt> <dd><p>Method to invoke the Python pdb debugger when this element is about to be parsed. Set <code class="docutils literal notranslate"><span class="pre">break_flag</span></code> to <code class="docutils literal notranslate"><span class="pre">True</span></code> to enable, <code class="docutils literal notranslate"><span class="pre">False</span></code> to disable.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.set_debug"> <code class="descname">set_debug</code><span class="sig-paren">(</span><em>flag: bool = True</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.set_debug" title="Permalink to this definition">¶</a></dt> <dd><p>Enable display of debugging messages while doing pattern matching. Set <code class="docutils literal notranslate"><span class="pre">flag</span></code> to <code class="docutils literal notranslate"><span class="pre">True</span></code> to enable, <code class="docutils literal notranslate"><span class="pre">False</span></code> to disable.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">wd</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)</span><span class="o">.</span><span class="n">set_name</span><span class="p">(</span><span class="s2">"alphaword"</span><span class="p">)</span> <span class="n">integer</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span><span class="o">.</span><span class="n">set_name</span><span class="p">(</span><span class="s2">"numword"</span><span class="p">)</span> <span class="n">term</span> <span class="o">=</span> <span class="n">wd</span> <span class="o">|</span> <span class="n">integer</span> <span class="c1"># turn on debugging for wd</span> <span class="n">wd</span><span class="o">.</span><span class="n">set_debug</span><span class="p">()</span> <span class="n">term</span><span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"abc 123 xyz 890"</span><span class="p">)</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">Match</span> <span class="n">alphaword</span> <span class="n">at</span> <span class="n">loc</span> <span class="mi">0</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="p">)</span> <span class="n">Matched</span> <span class="n">alphaword</span> <span class="o">-></span> <span class="p">[</span><span class="s1">'abc'</span><span class="p">]</span> <span class="n">Match</span> <span class="n">alphaword</span> <span class="n">at</span> <span class="n">loc</span> <span class="mi">3</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">4</span><span class="p">)</span> <span class="ne">Exception</span> <span class="n">raised</span><span class="p">:</span><span class="n">Expected</span> <span class="n">alphaword</span> <span class="p">(</span><span class="n">at</span> <span class="n">char</span> <span class="mi">4</span><span class="p">),</span> <span class="p">(</span><span class="n">line</span><span class="p">:</span><span class="mi">1</span><span class="p">,</span> <span class="n">col</span><span class="p">:</span><span class="mi">5</span><span class="p">)</span> <span class="n">Match</span> <span class="n">alphaword</span> <span class="n">at</span> <span class="n">loc</span> <span class="mi">7</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">8</span><span class="p">)</span> <span class="n">Matched</span> <span class="n">alphaword</span> <span class="o">-></span> <span class="p">[</span><span class="s1">'xyz'</span><span class="p">]</span> <span class="n">Match</span> <span class="n">alphaword</span> <span class="n">at</span> <span class="n">loc</span> <span class="mi">11</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">12</span><span class="p">)</span> <span class="ne">Exception</span> <span class="n">raised</span><span class="p">:</span><span class="n">Expected</span> <span class="n">alphaword</span> <span class="p">(</span><span class="n">at</span> <span class="n">char</span> <span class="mi">12</span><span class="p">),</span> <span class="p">(</span><span class="n">line</span><span class="p">:</span><span class="mi">1</span><span class="p">,</span> <span class="n">col</span><span class="p">:</span><span class="mi">13</span><span class="p">)</span> <span class="n">Match</span> <span class="n">alphaword</span> <span class="n">at</span> <span class="n">loc</span> <span class="mi">15</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">16</span><span class="p">)</span> <span class="ne">Exception</span> <span class="n">raised</span><span class="p">:</span><span class="n">Expected</span> <span class="n">alphaword</span> <span class="p">(</span><span class="n">at</span> <span class="n">char</span> <span class="mi">15</span><span class="p">),</span> <span class="p">(</span><span class="n">line</span><span class="p">:</span><span class="mi">1</span><span class="p">,</span> <span class="n">col</span><span class="p">:</span><span class="mi">16</span><span class="p">)</span> </pre></div> </div> <p>The output shown is that produced by the default debug actions - custom debug actions can be specified using <a class="reference internal" href="#pyparsing.ParserElement.set_debug_actions" title="pyparsing.ParserElement.set_debug_actions"><code class="xref py py-class docutils literal notranslate"><span class="pre">set_debug_actions</span></code></a>. Prior to attempting to match the <code class="docutils literal notranslate"><span class="pre">wd</span></code> expression, the debugging message <code class="docutils literal notranslate"><span class="pre">"Match</span> <span class="pre"><exprname></span> <span class="pre">at</span> <span class="pre">loc</span> <span class="pre"><n>(<line>,<col>)"</span></code> is shown. Then if the parse succeeds, a <code class="docutils literal notranslate"><span class="pre">"Matched"</span></code> message is shown, or an <code class="docutils literal notranslate"><span class="pre">"Exception</span> <span class="pre">raised"</span></code> message is shown. Also note the use of <a class="reference internal" href="#pyparsing.ParserElement.set_name" title="pyparsing.ParserElement.set_name"><code class="xref py py-class docutils literal notranslate"><span class="pre">set_name</span></code></a> to assign a human-readable name to the expression, which makes debugging and exception messages easier to understand - for instance, the default name created for the <a class="reference internal" href="#pyparsing.Word" title="pyparsing.Word"><code class="xref py py-class docutils literal notranslate"><span class="pre">Word</span></code></a> expression without calling <code class="docutils literal notranslate"><span class="pre">set_name</span></code> is <code class="docutils literal notranslate"><span class="pre">"W:(A-Za-z)"</span></code>.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.set_debug_actions"> <code class="descname">set_debug_actions</code><span class="sig-paren">(</span><em>start_action: Callable[[str, int, _ForwardRef('ParserElement'), bool], NoneType], success_action: Callable[[str, int, int, _ForwardRef('ParserElement'), pyparsing.results.ParseResults, bool], NoneType], exception_action: Callable[[str, int, _ForwardRef('ParserElement'), Exception, bool], NoneType]</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.set_debug_actions" title="Permalink to this definition">¶</a></dt> <dd><p>Customize display of debugging messages while doing pattern matching:</p> <ul class="simple"> <li><code class="docutils literal notranslate"><span class="pre">start_action</span></code> - method to be called when an expression is about to be parsed; should have the signature <code class="docutils literal notranslate"><span class="pre">fn(input_string:</span> <span class="pre">str,</span> <span class="pre">location:</span> <span class="pre">int,</span> <span class="pre">expression:</span> <span class="pre">ParserElement,</span> <span class="pre">cache_hit:</span> <span class="pre">bool)</span></code></li> <li><code class="docutils literal notranslate"><span class="pre">success_action</span></code> - method to be called when an expression has successfully parsed; should have the signature <code class="docutils literal notranslate"><span class="pre">fn(input_string:</span> <span class="pre">str,</span> <span class="pre">start_location:</span> <span class="pre">int,</span> <span class="pre">end_location:</span> <span class="pre">int,</span> <span class="pre">expression:</span> <span class="pre">ParserELement,</span> <span class="pre">parsed_tokens:</span> <span class="pre">ParseResults,</span> <span class="pre">cache_hit:</span> <span class="pre">bool)</span></code></li> <li><code class="docutils literal notranslate"><span class="pre">exception_action</span></code> - method to be called when expression fails to parse; should have the signature <code class="docutils literal notranslate"><span class="pre">fn(input_string:</span> <span class="pre">str,</span> <span class="pre">location:</span> <span class="pre">int,</span> <span class="pre">expression:</span> <span class="pre">ParserElement,</span> <span class="pre">exception:</span> <span class="pre">Exception,</span> <span class="pre">cache_hit:</span> <span class="pre">bool)</span></code></li> </ul> </dd></dl> <dl class="staticmethod"> <dt id="pyparsing.ParserElement.set_default_whitespace_chars"> <em class="property">static </em><code class="descname">set_default_whitespace_chars</code><span class="sig-paren">(</span><em>chars: str</em><span class="sig-paren">)</span> → None<a class="headerlink" href="#pyparsing.ParserElement.set_default_whitespace_chars" title="Permalink to this definition">¶</a></dt> <dd><p>Overrides the default whitespace chars</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># default whitespace chars are space, <TAB> and newline</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"abc def</span><span class="se">\n</span><span class="s2">ghi jkl"</span><span class="p">)</span> <span class="c1"># -> ['abc', 'def', 'ghi', 'jkl']</span> <span class="c1"># change to just treat newline as significant</span> <span class="n">ParserElement</span><span class="o">.</span><span class="n">set_default_whitespace_chars</span><span class="p">(</span><span class="s2">" </span><span class="se">\t</span><span class="s2">"</span><span class="p">)</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"abc def</span><span class="se">\n</span><span class="s2">ghi jkl"</span><span class="p">)</span> <span class="c1"># -> ['abc', 'def']</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.set_fail_action"> <code class="descname">set_fail_action</code><span class="sig-paren">(</span><em>fn: Callable[[str, int, _ForwardRef('ParserElement'), Exception], NoneType]</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.set_fail_action" title="Permalink to this definition">¶</a></dt> <dd><p>Define action to perform if parsing fails at this expression. Fail acton fn is a callable function that takes the arguments <code class="docutils literal notranslate"><span class="pre">fn(s,</span> <span class="pre">loc,</span> <span class="pre">expr,</span> <span class="pre">err)</span></code> where:</p> <ul class="simple"> <li>s = string being parsed</li> <li>loc = location where expression match was attempted and failed</li> <li>expr = the parse expression that failed</li> <li>err = the exception thrown</li> </ul> <p>The function returns no value. It may throw <a class="reference internal" href="#pyparsing.ParseFatalException" title="pyparsing.ParseFatalException"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParseFatalException</span></code></a> if it is desired to stop parsing immediately.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.set_name"> <code class="descname">set_name</code><span class="sig-paren">(</span><em>name: str</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.set_name" title="Permalink to this definition">¶</a></dt> <dd><p>Define name for this expression, makes debugging and exception messages clearer. Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"ABC"</span><span class="p">)</span> <span class="c1"># -> Exception: Expected W:(0-9) (at char 0), (line:1, col:1)</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span><span class="o">.</span><span class="n">set_name</span><span class="p">(</span><span class="s2">"integer"</span><span class="p">)</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"ABC"</span><span class="p">)</span> <span class="c1"># -> Exception: Expected integer (at char 0), (line:1, col:1)</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.set_parse_action"> <code class="descname">set_parse_action</code><span class="sig-paren">(</span><em>*fns</em>, <em>**kwargs</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.set_parse_action" title="Permalink to this definition">¶</a></dt> <dd><p>Define one or more actions to perform when successfully matching parse element definition.</p> <p>Parse actions can be called to perform data conversions, do extra validation, update external data structures, or enhance or replace the parsed tokens. Each parse action <code class="docutils literal notranslate"><span class="pre">fn</span></code> is a callable method with 0-3 arguments, called as <code class="docutils literal notranslate"><span class="pre">fn(s,</span> <span class="pre">loc,</span> <span class="pre">toks)</span></code> , <code class="docutils literal notranslate"><span class="pre">fn(loc,</span> <span class="pre">toks)</span></code> , <code class="docutils literal notranslate"><span class="pre">fn(toks)</span></code> , or just <code class="docutils literal notranslate"><span class="pre">fn()</span></code> , where:</p> <ul class="simple"> <li>s = the original string being parsed (see note below)</li> <li>loc = the location of the matching substring</li> <li>toks = a list of the matched tokens, packaged as a <a class="reference internal" href="#pyparsing.ParseResults" title="pyparsing.ParseResults"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParseResults</span></code></a> object</li> </ul> <p>The parsed tokens are passed to the parse action as ParseResults. They can be modified in place using list-style append, extend, and pop operations to update the parsed list elements; and with dictionary-style item set and del operations to add, update, or remove any named results. If the tokens are modified in place, it is not necessary to return them with a return statement.</p> <p>Parse actions can also completely replace the given tokens, with another <code class="docutils literal notranslate"><span class="pre">ParseResults</span></code> object, or with some entirely different object (common for parse actions that perform data conversions). A convenient way to build a new parse result is to define the values using a dict, and then create the return value using <a class="reference internal" href="#pyparsing.ParseResults.from_dict" title="pyparsing.ParseResults.from_dict"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParseResults.from_dict</span></code></a>.</p> <p>If None is passed as the <code class="docutils literal notranslate"><span class="pre">fn</span></code> parse action, all previously added parse actions for this expression are cleared.</p> <p>Optional keyword arguments:</p> <ul class="simple"> <li>call_during_try = (default= <code class="docutils literal notranslate"><span class="pre">False</span></code>) indicate if parse action should be run during lookaheads and alternate testing. For parse actions that have side effects, it is important to only call the parse action once it is determined that it is being called as part of a successful parse. For parse actions that perform additional validation, then call_during_try should be passed as True, so that the validation code is included in the preliminary “try” parses.</li> </ul> <p>Note: the default parsing behavior is to expand tabs in the input string before starting the parsing process. See <a class="reference internal" href="#pyparsing.ParserElement.parse_string" title="pyparsing.ParserElement.parse_string"><code class="xref py py-class docutils literal notranslate"><span class="pre">parse_string</span></code></a> for more information on parsing strings containing <code class="docutils literal notranslate"><span class="pre"><TAB></span></code> s, and suggested methods to maintain a consistent view of the parsed string, the parse location, and line and column positions within the parsed string.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># parse dates in the form YYYY/MM/DD</span> <span class="c1"># use parse action to convert toks from str to int at parse time</span> <span class="k">def</span> <span class="nf">convert_to_int</span><span class="p">(</span><span class="n">toks</span><span class="p">):</span> <span class="k">return</span> <span class="nb">int</span><span class="p">(</span><span class="n">toks</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span> <span class="c1"># use a parse action to verify that the date is a valid date</span> <span class="k">def</span> <span class="nf">is_valid_date</span><span class="p">(</span><span class="n">instring</span><span class="p">,</span> <span class="n">loc</span><span class="p">,</span> <span class="n">toks</span><span class="p">):</span> <span class="kn">from</span> <span class="nn">datetime</span> <span class="k">import</span> <span class="n">date</span> <span class="n">year</span><span class="p">,</span> <span class="n">month</span><span class="p">,</span> <span class="n">day</span> <span class="o">=</span> <span class="n">toks</span><span class="p">[::</span><span class="mi">2</span><span class="p">]</span> <span class="k">try</span><span class="p">:</span> <span class="n">date</span><span class="p">(</span><span class="n">year</span><span class="p">,</span> <span class="n">month</span><span class="p">,</span> <span class="n">day</span><span class="p">)</span> <span class="k">except</span> <span class="ne">ValueError</span><span class="p">:</span> <span class="k">raise</span> <span class="n">ParseException</span><span class="p">(</span><span class="n">instring</span><span class="p">,</span> <span class="n">loc</span><span class="p">,</span> <span class="s2">"invalid date given"</span><span class="p">)</span> <span class="n">integer</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="n">date_str</span> <span class="o">=</span> <span class="n">integer</span> <span class="o">+</span> <span class="s1">'/'</span> <span class="o">+</span> <span class="n">integer</span> <span class="o">+</span> <span class="s1">'/'</span> <span class="o">+</span> <span class="n">integer</span> <span class="c1"># add parse actions</span> <span class="n">integer</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="n">convert_to_int</span><span class="p">)</span> <span class="n">date_str</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="n">is_valid_date</span><span class="p">)</span> <span class="c1"># note that integer fields are now ints, not strings</span> <span class="n">date_str</span><span class="o">.</span><span class="n">run_tests</span><span class="p">(</span><span class="s1">'''</span> <span class="s1"> # successful parse - note that integer fields were converted to ints</span> <span class="s1"> 1999/12/31</span> <span class="s1"> # fail - invalid date</span> <span class="s1"> 1999/13/31</span> <span class="s1"> '''</span><span class="p">)</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.set_results_name"> <code class="descname">set_results_name</code><span class="sig-paren">(</span><em>name: str</em>, <em>list_all_matches: bool = False</em>, <em>*</em>, <em>listAllMatches: bool = False</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.set_results_name" title="Permalink to this definition">¶</a></dt> <dd><p>Define name for referencing matching tokens as a nested attribute of the returned parse results.</p> <p>Normally, results names are assigned as you would assign keys in a dict: any existing value is overwritten by later values. If it is necessary to keep all values captured for a particular results name, call <code class="docutils literal notranslate"><span class="pre">set_results_name</span></code> with <code class="docutils literal notranslate"><span class="pre">list_all_matches</span></code> = True.</p> <p>NOTE: <code class="docutils literal notranslate"><span class="pre">set_results_name</span></code> returns a <em>copy</em> of the original <a class="reference internal" href="#pyparsing.ParserElement" title="pyparsing.ParserElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement</span></code></a> object; this is so that the client can define a basic element, such as an integer, and reference it in multiple places with different names.</p> <p>You can also set results names using the abbreviated syntax, <code class="docutils literal notranslate"><span class="pre">expr("name")</span></code> in place of <code class="docutils literal notranslate"><span class="pre">expr.set_results_name("name")</span></code> - see <a class="reference internal" href="#pyparsing.ParserElement.__call__" title="pyparsing.ParserElement.__call__"><code class="xref py py-class docutils literal notranslate"><span class="pre">__call__</span></code></a>. If <code class="docutils literal notranslate"><span class="pre">list_all_matches</span></code> is required, use <code class="docutils literal notranslate"><span class="pre">expr("name*")</span></code>.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">date_str</span> <span class="o">=</span> <span class="p">(</span><span class="n">integer</span><span class="o">.</span><span class="n">set_results_name</span><span class="p">(</span><span class="s2">"year"</span><span class="p">)</span> <span class="o">+</span> <span class="s1">'/'</span> <span class="o">+</span> <span class="n">integer</span><span class="o">.</span><span class="n">set_results_name</span><span class="p">(</span><span class="s2">"month"</span><span class="p">)</span> <span class="o">+</span> <span class="s1">'/'</span> <span class="o">+</span> <span class="n">integer</span><span class="o">.</span><span class="n">set_results_name</span><span class="p">(</span><span class="s2">"day"</span><span class="p">))</span> <span class="c1"># equivalent form:</span> <span class="n">date_str</span> <span class="o">=</span> <span class="n">integer</span><span class="p">(</span><span class="s2">"year"</span><span class="p">)</span> <span class="o">+</span> <span class="s1">'/'</span> <span class="o">+</span> <span class="n">integer</span><span class="p">(</span><span class="s2">"month"</span><span class="p">)</span> <span class="o">+</span> <span class="s1">'/'</span> <span class="o">+</span> <span class="n">integer</span><span class="p">(</span><span class="s2">"day"</span><span class="p">)</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.set_whitespace_chars"> <code class="descname">set_whitespace_chars</code><span class="sig-paren">(</span><em>chars: Union[typing.Set[str], str], copy_defaults: bool = False</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.set_whitespace_chars" title="Permalink to this definition">¶</a></dt> <dd><p>Overrides the default whitespace chars</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.split"> <code class="descname">split</code><span class="sig-paren">(</span><em>instring: str</em>, <em>maxsplit: int = 9223372036854775807</em>, <em>include_separators: bool = False</em>, <em>*</em>, <em>includeSeparators=False</em><span class="sig-paren">)</span> → Generator[[str, NoneType], NoneType]<a class="headerlink" href="#pyparsing.ParserElement.split" title="Permalink to this definition">¶</a></dt> <dd><p>Generator method to split a string using the given expression as a separator. May be called with optional <code class="docutils literal notranslate"><span class="pre">maxsplit</span></code> argument, to limit the number of splits; and the optional <code class="docutils literal notranslate"><span class="pre">include_separators</span></code> argument (default= <code class="docutils literal notranslate"><span class="pre">False</span></code>), if the separating matching text should be included in the split results.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">punc</span> <span class="o">=</span> <span class="n">one_of</span><span class="p">(</span><span class="nb">list</span><span class="p">(</span><span class="s2">".,;:/-!?"</span><span class="p">))</span> <span class="nb">print</span><span class="p">(</span><span class="nb">list</span><span class="p">(</span><span class="n">punc</span><span class="o">.</span><span class="n">split</span><span class="p">(</span><span class="s2">"This, this?, this sentence, is badly punctuated!"</span><span class="p">)))</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="s1">'This'</span><span class="p">,</span> <span class="s1">' this'</span><span class="p">,</span> <span class="s1">''</span><span class="p">,</span> <span class="s1">' this sentence'</span><span class="p">,</span> <span class="s1">' is badly punctuated'</span><span class="p">,</span> <span class="s1">''</span><span class="p">]</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.suppress"> <code class="descname">suppress</code><span class="sig-paren">(</span><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.suppress" title="Permalink to this definition">¶</a></dt> <dd><p>Suppresses the output of this <a class="reference internal" href="#pyparsing.ParserElement" title="pyparsing.ParserElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement</span></code></a>; useful to keep punctuation from cluttering up returned output.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.suppress_warning"> <code class="descname">suppress_warning</code><span class="sig-paren">(</span><em>warning_type: pyparsing.core.Diagnostics</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ParserElement.suppress_warning" title="Permalink to this definition">¶</a></dt> <dd><p>Suppress warnings emitted for a particular diagnostic on this expression.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">base</span> <span class="o">=</span> <span class="n">pp</span><span class="o">.</span><span class="n">Forward</span><span class="p">()</span> <span class="n">base</span><span class="o">.</span><span class="n">suppress_warning</span><span class="p">(</span><span class="n">Diagnostics</span><span class="o">.</span><span class="n">warn_on_parse_using_empty_Forward</span><span class="p">)</span> <span class="c1"># statement would normally raise a warning, but is now suppressed</span> <span class="nb">print</span><span class="p">(</span><span class="n">base</span><span class="o">.</span><span class="n">parseString</span><span class="p">(</span><span class="s2">"x"</span><span class="p">))</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.transformString"> <code class="descname">transformString</code><span class="sig-paren">(</span><em>instring: str</em>, <em>*</em>, <em>debug: bool = False</em><span class="sig-paren">)</span> → str<a class="headerlink" href="#pyparsing.ParserElement.transformString" title="Permalink to this definition">¶</a></dt> <dd><p>Extension to <a class="reference internal" href="#pyparsing.ParserElement.scan_string" title="pyparsing.ParserElement.scan_string"><code class="xref py py-class docutils literal notranslate"><span class="pre">scan_string</span></code></a>, to modify matching text with modified tokens that may be returned from a parse action. To use <code class="docutils literal notranslate"><span class="pre">transform_string</span></code>, define a grammar and attach a parse action to it that modifies the returned token list. Invoking <code class="docutils literal notranslate"><span class="pre">transform_string()</span></code> on a target string will then scan for matches, and replace the matched text patterns according to the logic in the parse action. <code class="docutils literal notranslate"><span class="pre">transform_string()</span></code> returns the resulting transformed string.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">wd</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)</span> <span class="n">wd</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="k">lambda</span> <span class="n">toks</span><span class="p">:</span> <span class="n">toks</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">title</span><span class="p">())</span> <span class="nb">print</span><span class="p">(</span><span class="n">wd</span><span class="o">.</span><span class="n">transform_string</span><span class="p">(</span><span class="s2">"now is the winter of our discontent made glorious summer by this sun of york."</span><span class="p">))</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">Now</span> <span class="n">Is</span> <span class="n">The</span> <span class="n">Winter</span> <span class="n">Of</span> <span class="n">Our</span> <span class="n">Discontent</span> <span class="n">Made</span> <span class="n">Glorious</span> <span class="n">Summer</span> <span class="n">By</span> <span class="n">This</span> <span class="n">Sun</span> <span class="n">Of</span> <span class="n">York</span><span class="o">.</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.transform_string"> <code class="descname">transform_string</code><span class="sig-paren">(</span><em>instring: str</em>, <em>*</em>, <em>debug: bool = False</em><span class="sig-paren">)</span> → str<a class="headerlink" href="#pyparsing.ParserElement.transform_string" title="Permalink to this definition">¶</a></dt> <dd><p>Extension to <a class="reference internal" href="#pyparsing.ParserElement.scan_string" title="pyparsing.ParserElement.scan_string"><code class="xref py py-class docutils literal notranslate"><span class="pre">scan_string</span></code></a>, to modify matching text with modified tokens that may be returned from a parse action. To use <code class="docutils literal notranslate"><span class="pre">transform_string</span></code>, define a grammar and attach a parse action to it that modifies the returned token list. Invoking <code class="docutils literal notranslate"><span class="pre">transform_string()</span></code> on a target string will then scan for matches, and replace the matched text patterns according to the logic in the parse action. <code class="docutils literal notranslate"><span class="pre">transform_string()</span></code> returns the resulting transformed string.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">wd</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)</span> <span class="n">wd</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="k">lambda</span> <span class="n">toks</span><span class="p">:</span> <span class="n">toks</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">title</span><span class="p">())</span> <span class="nb">print</span><span class="p">(</span><span class="n">wd</span><span class="o">.</span><span class="n">transform_string</span><span class="p">(</span><span class="s2">"now is the winter of our discontent made glorious summer by this sun of york."</span><span class="p">))</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">Now</span> <span class="n">Is</span> <span class="n">The</span> <span class="n">Winter</span> <span class="n">Of</span> <span class="n">Our</span> <span class="n">Discontent</span> <span class="n">Made</span> <span class="n">Glorious</span> <span class="n">Summer</span> <span class="n">By</span> <span class="n">This</span> <span class="n">Sun</span> <span class="n">Of</span> <span class="n">York</span><span class="o">.</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.ParserElement.validate"> <code class="descname">validate</code><span class="sig-paren">(</span><em>validateTrace=None</em><span class="sig-paren">)</span> → None<a class="headerlink" href="#pyparsing.ParserElement.validate" title="Permalink to this definition">¶</a></dt> <dd><p>Check defined expressions for valid structure, check for infinite recursive definitions.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.PositionToken"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">PositionToken</code><a class="headerlink" href="#pyparsing.PositionToken" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.Token</span></code></p> <dl class="method"> <dt id="pyparsing.PositionToken.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.PositionToken.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.QuotedString"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">QuotedString</code><span class="sig-paren">(</span><em>quote_char: str = ''</em>, <em>esc_char: Union[str</em>, <em>NoneType] = None</em>, <em>esc_quote: Union[str</em>, <em>NoneType] = None</em>, <em>multiline: bool = False</em>, <em>unquote_results: bool = True</em>, <em>end_quote_char: Union[str</em>, <em>NoneType] = None</em>, <em>convert_whitespace_escapes: bool = True</em>, <em>*</em>, <em>quoteChar: str = ''</em>, <em>escChar: Union[str</em>, <em>NoneType] = None</em>, <em>escQuote: Union[str</em>, <em>NoneType] = None</em>, <em>unquoteResults: bool = True</em>, <em>endQuoteChar: Union[str</em>, <em>NoneType] = None</em>, <em>convertWhitespaceEscapes: bool = True</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.QuotedString" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.Token</span></code></p> <p>Token for matching strings that are delimited by quoting characters.</p> <p>Defined with the following parameters:</p> <ul class="simple"> <li><code class="docutils literal notranslate"><span class="pre">quote_char</span></code> - string of one or more characters defining the quote delimiting string</li> <li><code class="docutils literal notranslate"><span class="pre">esc_char</span></code> - character to re_escape quotes, typically backslash (default= <code class="docutils literal notranslate"><span class="pre">None</span></code>)</li> <li><code class="docutils literal notranslate"><span class="pre">esc_quote</span></code> - special quote sequence to re_escape an embedded quote string (such as SQL’s <code class="docutils literal notranslate"><span class="pre">""</span></code> to re_escape an embedded <code class="docutils literal notranslate"><span class="pre">"</span></code>) (default= <code class="docutils literal notranslate"><span class="pre">None</span></code>)</li> <li><code class="docutils literal notranslate"><span class="pre">multiline</span></code> - boolean indicating whether quotes can span multiple lines (default= <code class="docutils literal notranslate"><span class="pre">False</span></code>)</li> <li><code class="docutils literal notranslate"><span class="pre">unquote_results</span></code> - boolean indicating whether the matched text should be unquoted (default= <code class="docutils literal notranslate"><span class="pre">True</span></code>)</li> <li><code class="docutils literal notranslate"><span class="pre">end_quote_char</span></code> - string of one or more characters defining the end of the quote delimited string (default= <code class="docutils literal notranslate"><span class="pre">None</span></code> => same as quote_char)</li> <li><code class="docutils literal notranslate"><span class="pre">convert_whitespace_escapes</span></code> - convert escaped whitespace (<code class="docutils literal notranslate"><span class="pre">'\t'</span></code>, <code class="docutils literal notranslate"><span class="pre">'\n'</span></code>, etc.) to actual whitespace (default= <code class="docutils literal notranslate"><span class="pre">True</span></code>)</li> </ul> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">qs</span> <span class="o">=</span> <span class="n">QuotedString</span><span class="p">(</span><span class="s1">'"'</span><span class="p">)</span> <span class="nb">print</span><span class="p">(</span><span class="n">qs</span><span class="o">.</span><span class="n">search_string</span><span class="p">(</span><span class="s1">'lsjdf "This is the quote" sldjf'</span><span class="p">))</span> <span class="n">complex_qs</span> <span class="o">=</span> <span class="n">QuotedString</span><span class="p">(</span><span class="s1">'{{'</span><span class="p">,</span> <span class="n">end_quote_char</span><span class="o">=</span><span class="s1">'}}'</span><span class="p">)</span> <span class="nb">print</span><span class="p">(</span><span class="n">complex_qs</span><span class="o">.</span><span class="n">search_string</span><span class="p">(</span><span class="s1">'lsjdf {{This is the "quote"}} sldjf'</span><span class="p">))</span> <span class="n">sql_qs</span> <span class="o">=</span> <span class="n">QuotedString</span><span class="p">(</span><span class="s1">'"'</span><span class="p">,</span> <span class="n">esc_quote</span><span class="o">=</span><span class="s1">'""'</span><span class="p">)</span> <span class="nb">print</span><span class="p">(</span><span class="n">sql_qs</span><span class="o">.</span><span class="n">search_string</span><span class="p">(</span><span class="s1">'lsjdf "This is the quote with ""embedded"" quotes" sldjf'</span><span class="p">))</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[[</span><span class="s1">'This is the quote'</span><span class="p">]]</span> <span class="p">[[</span><span class="s1">'This is the "quote"'</span><span class="p">]]</span> <span class="p">[[</span><span class="s1">'This is the quote with "embedded" quotes'</span><span class="p">]]</span> </pre></div> </div> <dl class="method"> <dt id="pyparsing.QuotedString.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>quote_char: str = ''</em>, <em>esc_char: Union[str</em>, <em>NoneType] = None</em>, <em>esc_quote: Union[str</em>, <em>NoneType] = None</em>, <em>multiline: bool = False</em>, <em>unquote_results: bool = True</em>, <em>end_quote_char: Union[str</em>, <em>NoneType] = None</em>, <em>convert_whitespace_escapes: bool = True</em>, <em>*</em>, <em>quoteChar: str = ''</em>, <em>escChar: Union[str</em>, <em>NoneType] = None</em>, <em>escQuote: Union[str</em>, <em>NoneType] = None</em>, <em>unquoteResults: bool = True</em>, <em>endQuoteChar: Union[str</em>, <em>NoneType] = None</em>, <em>convertWhitespaceEscapes: bool = True</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.QuotedString.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> </dd></dl> <dl class="exception"> <dt id="pyparsing.RecursiveGrammarException"> <em class="property">exception </em><code class="descclassname">pyparsing.</code><code class="descname">RecursiveGrammarException</code><span class="sig-paren">(</span><em>parseElementList</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.RecursiveGrammarException" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">Exception</span></code></p> <p>Exception thrown by <a class="reference internal" href="#pyparsing.ParserElement.validate" title="pyparsing.ParserElement.validate"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement.validate</span></code></a> if the grammar could be left-recursive; parser may need to enable left recursion using <a class="reference internal" href="#pyparsing.ParserElement.enable_left_recursion" title="pyparsing.ParserElement.enable_left_recursion"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement.enable_left_recursion</span></code></a></p> <dl class="method"> <dt id="pyparsing.RecursiveGrammarException.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>parseElementList</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.RecursiveGrammarException.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.RecursiveGrammarException.__str__"> <code class="descname">__str__</code><span class="sig-paren">(</span><span class="sig-paren">)</span> → str<a class="headerlink" href="#pyparsing.RecursiveGrammarException.__str__" title="Permalink to this definition">¶</a></dt> <dd><p>Return str(self).</p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.RecursiveGrammarException.__weakref__"> <code class="descname">__weakref__</code><a class="headerlink" href="#pyparsing.RecursiveGrammarException.__weakref__" title="Permalink to this definition">¶</a></dt> <dd><p>list of weak references to the object (if defined)</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.Regex"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">Regex</code><span class="sig-paren">(</span><em>pattern: Any</em>, <em>flags: int = 0</em>, <em>as_group_list: bool = False</em>, <em>as_match: bool = False</em>, <em>*</em>, <em>asGroupList: bool = False</em>, <em>asMatch: bool = False</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.Regex" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.Token</span></code></p> <p>Token for matching strings that match a given regular expression. Defined with string specifying the regular expression in a form recognized by the stdlib Python <a class="reference external" href="https://docs.python.org/3/library/re.html">re module</a>. If the given regex contains named groups (defined using <code class="docutils literal notranslate"><span class="pre">(?P<name>...)</span></code>), these will be preserved as named <a class="reference internal" href="#pyparsing.ParseResults" title="pyparsing.ParseResults"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParseResults</span></code></a>.</p> <p>If instead of the Python stdlib <code class="docutils literal notranslate"><span class="pre">re</span></code> module you wish to use a different RE module (such as the <code class="docutils literal notranslate"><span class="pre">regex</span></code> module), you can do so by building your <code class="docutils literal notranslate"><span class="pre">Regex</span></code> object with a compiled RE that was compiled using <code class="docutils literal notranslate"><span class="pre">regex</span></code>.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">realnum</span> <span class="o">=</span> <span class="n">Regex</span><span class="p">(</span><span class="sa">r</span><span class="s2">"[+-]?\d+\.\d*"</span><span class="p">)</span> <span class="c1"># ref: https://stackoverflow.com/questions/267399/how-do-you-match-only-valid-roman-numerals-with-a-regular-expression</span> <span class="n">roman</span> <span class="o">=</span> <span class="n">Regex</span><span class="p">(</span><span class="sa">r</span><span class="s2">"M{0,4}(CM|CD|D?{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})"</span><span class="p">)</span> <span class="c1"># named fields in a regex will be returned as named results</span> <span class="n">date</span> <span class="o">=</span> <span class="n">Regex</span><span class="p">(</span><span class="sa">r</span><span class="s1">'(?P<year>\d</span><span class="si">{4}</span><span class="s1">)-(?P<month>\d\d?)-(?P<day>\d\d?)'</span><span class="p">)</span> <span class="c1"># the Regex class will accept re's compiled using the regex module</span> <span class="kn">import</span> <span class="nn">regex</span> <span class="n">parser</span> <span class="o">=</span> <span class="n">pp</span><span class="o">.</span><span class="n">Regex</span><span class="p">(</span><span class="n">regex</span><span class="o">.</span><span class="n">compile</span><span class="p">(</span><span class="sa">r</span><span class="s1">'[0-9]'</span><span class="p">))</span> </pre></div> </div> <dl class="method"> <dt id="pyparsing.Regex.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>pattern: Any</em>, <em>flags: int = 0</em>, <em>as_group_list: bool = False</em>, <em>as_match: bool = False</em>, <em>*</em>, <em>asGroupList: bool = False</em>, <em>asMatch: bool = False</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.Regex.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>The parameters <code class="docutils literal notranslate"><span class="pre">pattern</span></code> and <code class="docutils literal notranslate"><span class="pre">flags</span></code> are passed to the <code class="docutils literal notranslate"><span class="pre">re.compile()</span></code> function as-is. See the Python <a class="reference external" href="https://docs.python.org/3/library/re.html">re module</a> module for an explanation of the acceptable patterns and flags.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.Regex.sub"> <code class="descname">sub</code><span class="sig-paren">(</span><em>repl: str</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.Regex.sub" title="Permalink to this definition">¶</a></dt> <dd><p>Return <a class="reference internal" href="#pyparsing.Regex" title="pyparsing.Regex"><code class="xref py py-class docutils literal notranslate"><span class="pre">Regex</span></code></a> with an attached parse action to transform the parsed result as if called using <a class="reference external" href="https://docs.python.org/3/library/re.html#re.sub">re.sub(expr, repl, string)</a>.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">make_html</span> <span class="o">=</span> <span class="n">Regex</span><span class="p">(</span><span class="sa">r</span><span class="s2">"(\w+):(.*?):"</span><span class="p">)</span><span class="o">.</span><span class="n">sub</span><span class="p">(</span><span class="sa">r</span><span class="s2">"<\1>\2</\1>"</span><span class="p">)</span> <span class="nb">print</span><span class="p">(</span><span class="n">make_html</span><span class="o">.</span><span class="n">transform_string</span><span class="p">(</span><span class="s2">"h1:main title:"</span><span class="p">))</span> <span class="c1"># prints "<h1>main title</h1>"</span> </pre></div> </div> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.SkipTo"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">SkipTo</code><span class="sig-paren">(</span><em>other: Union[pyparsing.core.ParserElement, str], include: bool = False, ignore: bool = None, fail_on: Union[pyparsing.core.ParserElement, str, NoneType] = None, *, failOn: Union[pyparsing.core.ParserElement, str] = None</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.SkipTo" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.ParseElementEnhance</span></code></p> <p>Token for skipping over all undefined text until the matched expression is found.</p> <p>Parameters: - <code class="docutils literal notranslate"><span class="pre">expr</span></code> - target expression marking the end of the data to be skipped - <code class="docutils literal notranslate"><span class="pre">include</span></code> - if <code class="docutils literal notranslate"><span class="pre">True</span></code>, the target expression is also parsed</p> <blockquote> <div>(the skipped text and target expression are returned as a 2-element list) (default= <code class="docutils literal notranslate"><span class="pre">False</span></code>).</div></blockquote> <ul class="simple"> <li><code class="docutils literal notranslate"><span class="pre">ignore</span></code> - (default= <code class="docutils literal notranslate"><span class="pre">None</span></code>) used to define grammars (typically quoted strings and comments) that might contain false matches to the target expression</li> <li><code class="docutils literal notranslate"><span class="pre">fail_on</span></code> - (default= <code class="docutils literal notranslate"><span class="pre">None</span></code>) define expressions that are not allowed to be included in the skipped test; if found before the target expression is found, the <a class="reference internal" href="#pyparsing.SkipTo" title="pyparsing.SkipTo"><code class="xref py py-class docutils literal notranslate"><span class="pre">SkipTo</span></code></a> is not a match</li> </ul> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">report</span> <span class="o">=</span> <span class="s1">'''</span> <span class="s1"> Outstanding Issues Report - 1 Jan 2000</span> <span class="s1"> # | Severity | Description | Days Open</span> <span class="s1"> -----+----------+-------------------------------------------+-----------</span> <span class="s1"> 101 | Critical | Intermittent system crash | 6</span> <span class="s1"> 94 | Cosmetic | Spelling error on Login ('log|n') | 14</span> <span class="s1"> 79 | Minor | System slow when running too many reports | 47</span> <span class="s1"> '''</span> <span class="n">integer</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="n">SEP</span> <span class="o">=</span> <span class="n">Suppress</span><span class="p">(</span><span class="s1">'|'</span><span class="p">)</span> <span class="c1"># use SkipTo to simply match everything up until the next SEP</span> <span class="c1"># - ignore quoted strings, so that a '|' character inside a quoted string does not match</span> <span class="c1"># - parse action will call token.strip() for each matched token, i.e., the description body</span> <span class="n">string_data</span> <span class="o">=</span> <span class="n">SkipTo</span><span class="p">(</span><span class="n">SEP</span><span class="p">,</span> <span class="n">ignore</span><span class="o">=</span><span class="n">quoted_string</span><span class="p">)</span> <span class="n">string_data</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="n">token_map</span><span class="p">(</span><span class="nb">str</span><span class="o">.</span><span class="n">strip</span><span class="p">))</span> <span class="n">ticket_expr</span> <span class="o">=</span> <span class="p">(</span><span class="n">integer</span><span class="p">(</span><span class="s2">"issue_num"</span><span class="p">)</span> <span class="o">+</span> <span class="n">SEP</span> <span class="o">+</span> <span class="n">string_data</span><span class="p">(</span><span class="s2">"sev"</span><span class="p">)</span> <span class="o">+</span> <span class="n">SEP</span> <span class="o">+</span> <span class="n">string_data</span><span class="p">(</span><span class="s2">"desc"</span><span class="p">)</span> <span class="o">+</span> <span class="n">SEP</span> <span class="o">+</span> <span class="n">integer</span><span class="p">(</span><span class="s2">"days_open"</span><span class="p">))</span> <span class="k">for</span> <span class="n">tkt</span> <span class="ow">in</span> <span class="n">ticket_expr</span><span class="o">.</span><span class="n">search_string</span><span class="p">(</span><span class="n">report</span><span class="p">):</span> <span class="nb">print</span> <span class="n">tkt</span><span class="o">.</span><span class="n">dump</span><span class="p">()</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="s1">'101'</span><span class="p">,</span> <span class="s1">'Critical'</span><span class="p">,</span> <span class="s1">'Intermittent system crash'</span><span class="p">,</span> <span class="s1">'6'</span><span class="p">]</span> <span class="o">-</span> <span class="n">days_open</span><span class="p">:</span> <span class="s1">'6'</span> <span class="o">-</span> <span class="n">desc</span><span class="p">:</span> <span class="s1">'Intermittent system crash'</span> <span class="o">-</span> <span class="n">issue_num</span><span class="p">:</span> <span class="s1">'101'</span> <span class="o">-</span> <span class="n">sev</span><span class="p">:</span> <span class="s1">'Critical'</span> <span class="p">[</span><span class="s1">'94'</span><span class="p">,</span> <span class="s1">'Cosmetic'</span><span class="p">,</span> <span class="s2">"Spelling error on Login ('log|n')"</span><span class="p">,</span> <span class="s1">'14'</span><span class="p">]</span> <span class="o">-</span> <span class="n">days_open</span><span class="p">:</span> <span class="s1">'14'</span> <span class="o">-</span> <span class="n">desc</span><span class="p">:</span> <span class="s2">"Spelling error on Login ('log|n')"</span> <span class="o">-</span> <span class="n">issue_num</span><span class="p">:</span> <span class="s1">'94'</span> <span class="o">-</span> <span class="n">sev</span><span class="p">:</span> <span class="s1">'Cosmetic'</span> <span class="p">[</span><span class="s1">'79'</span><span class="p">,</span> <span class="s1">'Minor'</span><span class="p">,</span> <span class="s1">'System slow when running too many reports'</span><span class="p">,</span> <span class="s1">'47'</span><span class="p">]</span> <span class="o">-</span> <span class="n">days_open</span><span class="p">:</span> <span class="s1">'47'</span> <span class="o">-</span> <span class="n">desc</span><span class="p">:</span> <span class="s1">'System slow when running too many reports'</span> <span class="o">-</span> <span class="n">issue_num</span><span class="p">:</span> <span class="s1">'79'</span> <span class="o">-</span> <span class="n">sev</span><span class="p">:</span> <span class="s1">'Minor'</span> </pre></div> </div> <dl class="method"> <dt id="pyparsing.SkipTo.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>other: Union[pyparsing.core.ParserElement, str], include: bool = False, ignore: bool = None, fail_on: Union[pyparsing.core.ParserElement, str, NoneType] = None, *, failOn: Union[pyparsing.core.ParserElement, str] = None</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.SkipTo.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.StringEnd"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">StringEnd</code><a class="headerlink" href="#pyparsing.StringEnd" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.PositionToken</span></code></p> <p>Matches if current position is at the end of the parse string</p> <dl class="method"> <dt id="pyparsing.StringEnd.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.StringEnd.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.StringStart"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">StringStart</code><a class="headerlink" href="#pyparsing.StringStart" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.PositionToken</span></code></p> <p>Matches if current position is at the beginning of the parse string</p> <dl class="method"> <dt id="pyparsing.StringStart.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.StringStart.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.Suppress"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">Suppress</code><span class="sig-paren">(</span><em>expr: Union[pyparsing.core.ParserElement, str], savelist: bool = False</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.Suppress" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.TokenConverter</span></code></p> <p>Converter for ignoring the results of a parsed expression.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">source</span> <span class="o">=</span> <span class="s2">"a, b, c,d"</span> <span class="n">wd</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)</span> <span class="n">wd_list1</span> <span class="o">=</span> <span class="n">wd</span> <span class="o">+</span> <span class="p">(</span><span class="s1">','</span> <span class="o">+</span> <span class="n">wd</span><span class="p">)[</span><span class="o">...</span><span class="p">]</span> <span class="nb">print</span><span class="p">(</span><span class="n">wd_list1</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="n">source</span><span class="p">))</span> <span class="c1"># often, delimiters that are useful during parsing are just in the</span> <span class="c1"># way afterward - use Suppress to keep them out of the parsed output</span> <span class="n">wd_list2</span> <span class="o">=</span> <span class="n">wd</span> <span class="o">+</span> <span class="p">(</span><span class="n">Suppress</span><span class="p">(</span><span class="s1">','</span><span class="p">)</span> <span class="o">+</span> <span class="n">wd</span><span class="p">)[</span><span class="o">...</span><span class="p">]</span> <span class="nb">print</span><span class="p">(</span><span class="n">wd_list2</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="n">source</span><span class="p">))</span> <span class="c1"># Skipped text (using '...') can be suppressed as well</span> <span class="n">source</span> <span class="o">=</span> <span class="s2">"lead in START relevant text END trailing text"</span> <span class="n">start_marker</span> <span class="o">=</span> <span class="n">Keyword</span><span class="p">(</span><span class="s2">"START"</span><span class="p">)</span> <span class="n">end_marker</span> <span class="o">=</span> <span class="n">Keyword</span><span class="p">(</span><span class="s2">"END"</span><span class="p">)</span> <span class="n">find_body</span> <span class="o">=</span> <span class="n">Suppress</span><span class="p">(</span><span class="o">...</span><span class="p">)</span> <span class="o">+</span> <span class="n">start_marker</span> <span class="o">+</span> <span class="o">...</span> <span class="o">+</span> <span class="n">end_marker</span> <span class="nb">print</span><span class="p">(</span><span class="n">find_body</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="n">source</span><span class="p">)</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="s1">'a'</span><span class="p">,</span> <span class="s1">','</span><span class="p">,</span> <span class="s1">'b'</span><span class="p">,</span> <span class="s1">','</span><span class="p">,</span> <span class="s1">'c'</span><span class="p">,</span> <span class="s1">','</span><span class="p">,</span> <span class="s1">'d'</span><span class="p">]</span> <span class="p">[</span><span class="s1">'a'</span><span class="p">,</span> <span class="s1">'b'</span><span class="p">,</span> <span class="s1">'c'</span><span class="p">,</span> <span class="s1">'d'</span><span class="p">]</span> <span class="p">[</span><span class="s1">'START'</span><span class="p">,</span> <span class="s1">'relevant text '</span><span class="p">,</span> <span class="s1">'END'</span><span class="p">]</span> </pre></div> </div> <p>(See also <a class="reference internal" href="#pyparsing.delimited_list" title="pyparsing.delimited_list"><code class="xref py py-class docutils literal notranslate"><span class="pre">delimited_list</span></code></a>.)</p> <dl class="method"> <dt id="pyparsing.Suppress.__add__"> <code class="descname">__add__</code><span class="sig-paren">(</span><em>other</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.Suppress.__add__" title="Permalink to this definition">¶</a></dt> <dd><p>Implementation of <code class="docutils literal notranslate"><span class="pre">+</span></code> operator - returns <a class="reference internal" href="#pyparsing.And" title="pyparsing.And"><code class="xref py py-class docutils literal notranslate"><span class="pre">And</span></code></a>. Adding strings to a <a class="reference internal" href="#pyparsing.ParserElement" title="pyparsing.ParserElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement</span></code></a> converts them to :class:<a href="#id10"><span class="problematic" id="id11">`</span></a>Literal`s by default.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">greet</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)</span> <span class="o">+</span> <span class="s2">","</span> <span class="o">+</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)</span> <span class="o">+</span> <span class="s2">"!"</span> <span class="n">hello</span> <span class="o">=</span> <span class="s2">"Hello, World!"</span> <span class="nb">print</span><span class="p">(</span><span class="n">hello</span><span class="p">,</span> <span class="s2">"->"</span><span class="p">,</span> <span class="n">greet</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="n">hello</span><span class="p">))</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span>Hello, World! -> ['Hello', ',', 'World', '!'] </pre></div> </div> <p><code class="docutils literal notranslate"><span class="pre">...</span></code> may be used as a parse expression as a short form of <a class="reference internal" href="#pyparsing.SkipTo" title="pyparsing.SkipTo"><code class="xref py py-class docutils literal notranslate"><span class="pre">SkipTo</span></code></a>.</p> <blockquote> <div>Literal(‘start’) + … + Literal(‘end’)</div></blockquote> <p>is equivalent to:</p> <blockquote> <div>Literal(‘start’) + SkipTo(‘end’)(“_skipped*”) + Literal(‘end’)</div></blockquote> <p>Note that the skipped text is returned with ‘_skipped’ as a results name, and to support having multiple skips in the same parser, the value returned is a list of all skipped text.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.Suppress.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>expr: Union[pyparsing.core.ParserElement, str], savelist: bool = False</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.Suppress.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.Suppress.__sub__"> <code class="descname">__sub__</code><span class="sig-paren">(</span><em>other</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.Suppress.__sub__" title="Permalink to this definition">¶</a></dt> <dd><p>Implementation of <code class="docutils literal notranslate"><span class="pre">-</span></code> operator, returns <a class="reference internal" href="#pyparsing.And" title="pyparsing.And"><code class="xref py py-class docutils literal notranslate"><span class="pre">And</span></code></a> with error stop</p> </dd></dl> <dl class="method"> <dt id="pyparsing.Suppress.suppress"> <code class="descname">suppress</code><span class="sig-paren">(</span><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.Suppress.suppress" title="Permalink to this definition">¶</a></dt> <dd><p>Suppresses the output of this <a class="reference internal" href="#pyparsing.ParserElement" title="pyparsing.ParserElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement</span></code></a>; useful to keep punctuation from cluttering up returned output.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.Token"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">Token</code><a class="headerlink" href="#pyparsing.Token" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.ParserElement</span></code></p> <p>Abstract <a class="reference internal" href="#pyparsing.ParserElement" title="pyparsing.ParserElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement</span></code></a> subclass, for defining atomic matching patterns.</p> <dl class="method"> <dt id="pyparsing.Token.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.Token.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.TokenConverter"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">TokenConverter</code><span class="sig-paren">(</span><em>expr: Union[pyparsing.core.ParserElement, str], savelist=False</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.TokenConverter" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.ParseElementEnhance</span></code></p> <p>Abstract subclass of <a class="reference internal" href="#pyparsing.ParseExpression" title="pyparsing.ParseExpression"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParseExpression</span></code></a>, for converting parsed results.</p> <dl class="method"> <dt id="pyparsing.TokenConverter.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>expr: Union[pyparsing.core.ParserElement, str], savelist=False</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.TokenConverter.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.White"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">White</code><span class="sig-paren">(</span><em>ws: str = ' trn'</em>, <em>min: int = 1</em>, <em>max: int = 0</em>, <em>exact: int = 0</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.White" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.Token</span></code></p> <p>Special matching class for matching whitespace. Normally, whitespace is ignored by pyparsing grammars. This class is included when some whitespace structures are significant. Define with a string containing the whitespace characters to be matched; default is <code class="docutils literal notranslate"><span class="pre">"</span> <span class="pre">\t\r\n"</span></code>. Also takes optional <code class="docutils literal notranslate"><span class="pre">min</span></code>, <code class="docutils literal notranslate"><span class="pre">max</span></code>, and <code class="docutils literal notranslate"><span class="pre">exact</span></code> arguments, as defined for the <a class="reference internal" href="#pyparsing.Word" title="pyparsing.Word"><code class="xref py py-class docutils literal notranslate"><span class="pre">Word</span></code></a> class.</p> <dl class="method"> <dt id="pyparsing.White.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>ws: str = ' \t\r\n'</em>, <em>min: int = 1</em>, <em>max: int = 0</em>, <em>exact: int = 0</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.White.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.Word"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">Word</code><span class="sig-paren">(</span><em>init_chars: str = ''</em>, <em>body_chars: Union[str</em>, <em>NoneType] = None</em>, <em>min: int = 1</em>, <em>max: int = 0</em>, <em>exact: int = 0</em>, <em>as_keyword: bool = False</em>, <em>exclude_chars: Union[str</em>, <em>NoneType] = None</em>, <em>*</em>, <em>initChars: Union[str</em>, <em>NoneType] = None</em>, <em>bodyChars: Union[str</em>, <em>NoneType] = None</em>, <em>asKeyword: bool = False</em>, <em>excludeChars: Union[str</em>, <em>NoneType] = None</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.Word" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.Token</span></code></p> <p>Token for matching words composed of allowed character sets. Parameters: - <code class="docutils literal notranslate"><span class="pre">init_chars</span></code> - string of all characters that should be used to</p> <blockquote> <div>match as a word; “ABC” will match “AAA”, “ABAB”, “CBAC”, etc.; if <code class="docutils literal notranslate"><span class="pre">body_chars</span></code> is also specified, then this is the string of initial characters</div></blockquote> <ul class="simple"> <li><code class="docutils literal notranslate"><span class="pre">body_chars</span></code> - string of characters that can be used for matching after a matched initial character as given in <code class="docutils literal notranslate"><span class="pre">init_chars</span></code>; if omitted, same as the initial characters (default=``None``)</li> <li><code class="docutils literal notranslate"><span class="pre">min</span></code> - minimum number of characters to match (default=1)</li> <li><code class="docutils literal notranslate"><span class="pre">max</span></code> - maximum number of characters to match (default=0)</li> <li><code class="docutils literal notranslate"><span class="pre">exact</span></code> - exact number of characters to match (default=0)</li> <li><code class="docutils literal notranslate"><span class="pre">as_keyword</span></code> - match as a keyword (default=``False``)</li> <li><code class="docutils literal notranslate"><span class="pre">exclude_chars</span></code> - characters that might be found in the input <code class="docutils literal notranslate"><span class="pre">body_chars</span></code> string but which should not be accepted for matching ;useful to define a word of all printables except for one or two characters, for instance (default=``None``)</li> </ul> <p><a class="reference internal" href="#pyparsing.srange" title="pyparsing.srange"><code class="xref py py-class docutils literal notranslate"><span class="pre">srange</span></code></a> is useful for defining custom character set strings for defining <a class="reference internal" href="#pyparsing.Word" title="pyparsing.Word"><code class="xref py py-class docutils literal notranslate"><span class="pre">Word</span></code></a> expressions, using range notation from regular expression character sets.</p> <p>A common mistake is to use <a class="reference internal" href="#pyparsing.Word" title="pyparsing.Word"><code class="xref py py-class docutils literal notranslate"><span class="pre">Word</span></code></a> to match a specific literal string, as in <code class="docutils literal notranslate"><span class="pre">Word("Address")</span></code>. Remember that <a class="reference internal" href="#pyparsing.Word" title="pyparsing.Word"><code class="xref py py-class docutils literal notranslate"><span class="pre">Word</span></code></a> uses the string argument to define <em>sets</em> of matchable characters. This expression would match “Add”, “AAA”, “dAred”, or any other word made up of the characters ‘A’, ‘d’, ‘r’, ‘e’, and ‘s’. To match an exact literal string, use <a class="reference internal" href="#pyparsing.Literal" title="pyparsing.Literal"><code class="xref py py-class docutils literal notranslate"><span class="pre">Literal</span></code></a> or <a class="reference internal" href="#pyparsing.Keyword" title="pyparsing.Keyword"><code class="xref py py-class docutils literal notranslate"><span class="pre">Keyword</span></code></a>.</p> <p>pyparsing includes helper strings for building Words:</p> <ul class="simple"> <li><code class="xref py py-class docutils literal notranslate"><span class="pre">alphas</span></code></li> <li><code class="xref py py-class docutils literal notranslate"><span class="pre">nums</span></code></li> <li><code class="xref py py-class docutils literal notranslate"><span class="pre">alphanums</span></code></li> <li><code class="xref py py-class docutils literal notranslate"><span class="pre">hexnums</span></code></li> <li><code class="xref py py-class docutils literal notranslate"><span class="pre">alphas8bit</span></code> (alphabetic characters in ASCII range 128-255 - accented, tilded, umlauted, etc.)</li> <li><code class="xref py py-class docutils literal notranslate"><span class="pre">punc8bit</span></code> (non-alphabetic characters in ASCII range 128-255 - currency, symbols, superscripts, diacriticals, etc.)</li> <li><code class="xref py py-class docutils literal notranslate"><span class="pre">printables</span></code> (any non-whitespace character)</li> </ul> <p><code class="docutils literal notranslate"><span class="pre">alphas</span></code>, <code class="docutils literal notranslate"><span class="pre">nums</span></code>, and <code class="docutils literal notranslate"><span class="pre">printables</span></code> are also defined in several Unicode sets - see <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing_unicode`</span></code>.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># a word composed of digits</span> <span class="n">integer</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="c1"># equivalent to Word("0123456789") or Word(srange("0-9"))</span> <span class="c1"># a word with a leading capital, and zero or more lowercase</span> <span class="n">capital_word</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="o">.</span><span class="n">upper</span><span class="p">(),</span> <span class="n">alphas</span><span class="o">.</span><span class="n">lower</span><span class="p">())</span> <span class="c1"># hostnames are alphanumeric, with leading alpha, and '-'</span> <span class="n">hostname</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">,</span> <span class="n">alphanums</span> <span class="o">+</span> <span class="s1">'-'</span><span class="p">)</span> <span class="c1"># roman numeral (not a strict parser, accepts invalid mix of characters)</span> <span class="n">roman</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="s2">"IVXLCDM"</span><span class="p">)</span> <span class="c1"># any string of non-whitespace characters, except for ','</span> <span class="n">csv_value</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">printables</span><span class="p">,</span> <span class="n">exclude_chars</span><span class="o">=</span><span class="s2">","</span><span class="p">)</span> </pre></div> </div> <dl class="method"> <dt id="pyparsing.Word.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>init_chars: str = ''</em>, <em>body_chars: Union[str</em>, <em>NoneType] = None</em>, <em>min: int = 1</em>, <em>max: int = 0</em>, <em>exact: int = 0</em>, <em>as_keyword: bool = False</em>, <em>exclude_chars: Union[str</em>, <em>NoneType] = None</em>, <em>*</em>, <em>initChars: Union[str</em>, <em>NoneType] = None</em>, <em>bodyChars: Union[str</em>, <em>NoneType] = None</em>, <em>asKeyword: bool = False</em>, <em>excludeChars: Union[str</em>, <em>NoneType] = None</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.Word.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.WordEnd"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">WordEnd</code><span class="sig-paren">(</span><em>word_chars: str = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&'()*+</em>, <em>-./:;<=>?@[\]^_`{|}~'</em>, <em>*</em>, <em>wordChars: str = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&'()*+</em>, <em>-./:;<=>?@[\]^_`{|}~'</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.WordEnd" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.PositionToken</span></code></p> <p>Matches if the current position is at the end of a <a class="reference internal" href="#pyparsing.Word" title="pyparsing.Word"><code class="xref py py-class docutils literal notranslate"><span class="pre">Word</span></code></a>, and is not followed by any character in a given set of <code class="docutils literal notranslate"><span class="pre">word_chars</span></code> (default= <code class="docutils literal notranslate"><span class="pre">printables</span></code>). To emulate the <code class="docutils literal notranslate"><span class="pre"></span></code> behavior of regular expressions, use <code class="docutils literal notranslate"><span class="pre">WordEnd(alphanums)</span></code>. <code class="docutils literal notranslate"><span class="pre">WordEnd</span></code> will also match at the end of the string being parsed, or at the end of a line.</p> <dl class="method"> <dt id="pyparsing.WordEnd.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>word_chars: str = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+</em>, <em>-./:;<=>?@[\\]^_`{|}~'</em>, <em>*</em>, <em>wordChars: str = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+</em>, <em>-./:;<=>?@[\\]^_`{|}~'</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.WordEnd.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.WordStart"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">WordStart</code><span class="sig-paren">(</span><em>word_chars: str = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&'()*+</em>, <em>-./:;<=>?@[\]^_`{|}~'</em>, <em>*</em>, <em>wordChars: str = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&'()*+</em>, <em>-./:;<=>?@[\]^_`{|}~'</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.WordStart" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.PositionToken</span></code></p> <p>Matches if the current position is at the beginning of a <a class="reference internal" href="#pyparsing.Word" title="pyparsing.Word"><code class="xref py py-class docutils literal notranslate"><span class="pre">Word</span></code></a>, and is not preceded by any character in a given set of <code class="docutils literal notranslate"><span class="pre">word_chars</span></code> (default= <code class="docutils literal notranslate"><span class="pre">printables</span></code>). To emulate the <code class="docutils literal notranslate"><span class="pre"></span></code> behavior of regular expressions, use <code class="docutils literal notranslate"><span class="pre">WordStart(alphanums)</span></code>. <code class="docutils literal notranslate"><span class="pre">WordStart</span></code> will also match at the beginning of the string being parsed, or at the beginning of a line.</p> <dl class="method"> <dt id="pyparsing.WordStart.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>word_chars: str = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+</em>, <em>-./:;<=>?@[\\]^_`{|}~'</em>, <em>*</em>, <em>wordChars: str = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+</em>, <em>-./:;<=>?@[\\]^_`{|}~'</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.WordStart.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.ZeroOrMore"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">ZeroOrMore</code><span class="sig-paren">(</span><em>expr: pyparsing.core.ParserElement</em>, <em>stop_on: Union[pyparsing.core.ParserElement</em>, <em>str</em>, <em>NoneType] = None</em>, <em>*</em>, <em>stopOn: Union[pyparsing.core.ParserElement</em>, <em>str</em>, <em>NoneType] = None</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.ZeroOrMore" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core._MultipleMatch</span></code></p> <p>Optional repetition of zero or more of the given expression.</p> <p>Parameters: - <code class="docutils literal notranslate"><span class="pre">expr</span></code> - expression that must match zero or more times - <code class="docutils literal notranslate"><span class="pre">stop_on</span></code> - expression for a terminating sentinel</p> <blockquote> <div>(only required if the sentinel would ordinarily match the repetition expression) - (default= <code class="docutils literal notranslate"><span class="pre">None</span></code>)</div></blockquote> <p>Example: similar to <a class="reference internal" href="#pyparsing.OneOrMore" title="pyparsing.OneOrMore"><code class="xref py py-class docutils literal notranslate"><span class="pre">OneOrMore</span></code></a></p> <dl class="method"> <dt id="pyparsing.ZeroOrMore.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>expr: pyparsing.core.ParserElement</em>, <em>stop_on: Union[pyparsing.core.ParserElement</em>, <em>str</em>, <em>NoneType] = None</em>, <em>*</em>, <em>stopOn: Union[pyparsing.core.ParserElement</em>, <em>str</em>, <em>NoneType] = None</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.ZeroOrMore.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.Char"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">Char</code><span class="sig-paren">(</span><em>charset: str</em>, <em>as_keyword: bool = False</em>, <em>exclude_chars: Union[str</em>, <em>NoneType] = None</em>, <em>*</em>, <em>asKeyword: bool = False</em>, <em>excludeChars: Union[str</em>, <em>NoneType] = None</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.Char" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core._WordRegex</span></code></p> <p>A short-cut class for defining <a class="reference internal" href="#pyparsing.Word" title="pyparsing.Word"><code class="xref py py-class docutils literal notranslate"><span class="pre">Word</span></code></a> <code class="docutils literal notranslate"><span class="pre">(characters,</span> <span class="pre">exact=1)</span></code>, when defining a match of any single character in a string of characters.</p> <dl class="method"> <dt id="pyparsing.Char.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>charset: str</em>, <em>as_keyword: bool = False</em>, <em>exclude_chars: Union[str</em>, <em>NoneType] = None</em>, <em>*</em>, <em>asKeyword: bool = False</em>, <em>excludeChars: Union[str</em>, <em>NoneType] = None</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.Char.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> </dd></dl> <dl class="attribute"> <dt id="pyparsing.col"> <code class="descclassname">pyparsing.</code><code class="descname">col</code><a class="headerlink" href="#pyparsing.col" title="Permalink to this definition">¶</a></dt> <dd><p>Returns current column within a string, counting newlines as line separators. The first column is number 1.</p> <p>Note: the default parsing behavior is to expand tabs in the input string before starting the parsing process. See <a class="reference internal" href="#pyparsing.ParserElement.parseString" title="pyparsing.ParserElement.parseString"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement.parseString</span></code></a> for more information on parsing strings containing <code class="docutils literal notranslate"><span class="pre"><TAB></span></code> s, and suggested methods to maintain a consistent view of the parsed string, the parse location, and line and column positions within the parsed string.</p> </dd></dl> <dl class="function"> <dt id="pyparsing.counted_array"> <code class="descclassname">pyparsing.</code><code class="descname">counted_array</code><span class="sig-paren">(</span><em>expr: pyparsing.core.ParserElement</em>, <em>int_expr: Union[pyparsing.core.ParserElement</em>, <em>NoneType] = None</em>, <em>*</em>, <em>intExpr: Union[pyparsing.core.ParserElement</em>, <em>NoneType] = None</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.counted_array" title="Permalink to this definition">¶</a></dt> <dd><p>Helper to define a counted list of expressions.</p> <p>This helper defines a pattern of the form:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">integer</span> <span class="n">expr</span> <span class="n">expr</span> <span class="n">expr</span><span class="o">...</span> </pre></div> </div> <p>where the leading integer tells how many expr expressions follow. The matched tokens returns the array of expr tokens as a list - the leading count token is suppressed.</p> <p>If <code class="docutils literal notranslate"><span class="pre">int_expr</span></code> is specified, it should be a pyparsing expression that produces an integer value.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">counted_array</span><span class="p">(</span><span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">))</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s1">'2 ab cd ef'</span><span class="p">)</span> <span class="c1"># -> ['ab', 'cd']</span> <span class="c1"># in this parser, the leading integer value is given in binary,</span> <span class="c1"># '10' indicating that 2 values are in the array</span> <span class="n">binary_constant</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="s1">'01'</span><span class="p">)</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="k">lambda</span> <span class="n">t</span><span class="p">:</span> <span class="nb">int</span><span class="p">(</span><span class="n">t</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="mi">2</span><span class="p">))</span> <span class="n">counted_array</span><span class="p">(</span><span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">),</span> <span class="n">int_expr</span><span class="o">=</span><span class="n">binary_constant</span><span class="p">)</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s1">'10 ab cd ef'</span><span class="p">)</span> <span class="c1"># -> ['ab', 'cd']</span> <span class="c1"># if other fields must be parsed after the count but before the</span> <span class="c1"># list items, give the fields results names and they will</span> <span class="c1"># be preserved in the returned ParseResults:</span> <span class="n">count_with_metadata</span> <span class="o">=</span> <span class="n">integer</span> <span class="o">+</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)(</span><span class="s2">"type"</span><span class="p">)</span> <span class="n">typed_array</span> <span class="o">=</span> <span class="n">counted_array</span><span class="p">(</span><span class="n">Word</span><span class="p">(</span><span class="n">alphanums</span><span class="p">),</span> <span class="n">int_expr</span><span class="o">=</span><span class="n">count_with_metadata</span><span class="p">)(</span><span class="s2">"items"</span><span class="p">)</span> <span class="n">result</span> <span class="o">=</span> <span class="n">typed_array</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"3 bool True True False"</span><span class="p">)</span> <span class="nb">print</span><span class="p">(</span><span class="n">result</span><span class="o">.</span><span class="n">dump</span><span class="p">())</span> <span class="c1"># prints</span> <span class="c1"># ['True', 'True', 'False']</span> <span class="c1"># - items: ['True', 'True', 'False']</span> <span class="c1"># - type: 'bool'</span> </pre></div> </div> </dd></dl> <dl class="function"> <dt id="pyparsing.delimited_list"> <code class="descclassname">pyparsing.</code><code class="descname">delimited_list</code><span class="sig-paren">(</span><em>expr: Union[str, pyparsing.core.ParserElement], delim: Union[str, pyparsing.core.ParserElement] = ',', combine: bool = False, min: Union[int, NoneType] = None, max: Union[int, NoneType] = None, *, allow_trailing_delim: bool = False</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.delimited_list" title="Permalink to this definition">¶</a></dt> <dd><p>Helper to define a delimited list of expressions - the delimiter defaults to ‘,’. By default, the list elements and delimiters can have intervening whitespace, and comments, but this can be overridden by passing <code class="docutils literal notranslate"><span class="pre">combine=True</span></code> in the constructor. If <code class="docutils literal notranslate"><span class="pre">combine</span></code> is set to <code class="docutils literal notranslate"><span class="pre">True</span></code>, the matching tokens are returned as a single token string, with the delimiters included; otherwise, the matching tokens are returned as a list of tokens, with the delimiters suppressed.</p> <p>If <code class="docutils literal notranslate"><span class="pre">allow_trailing_delim</span></code> is set to True, then the list may end with a delimiter.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">delimited_list</span><span class="p">(</span><span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">))</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"aa,bb,cc"</span><span class="p">)</span> <span class="c1"># -> ['aa', 'bb', 'cc']</span> <span class="n">delimited_list</span><span class="p">(</span><span class="n">Word</span><span class="p">(</span><span class="n">hexnums</span><span class="p">),</span> <span class="n">delim</span><span class="o">=</span><span class="s1">':'</span><span class="p">,</span> <span class="n">combine</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"AA:BB:CC:DD:EE"</span><span class="p">)</span> <span class="c1"># -> ['AA:BB:CC:DD:EE']</span> </pre></div> </div> </dd></dl> <dl class="function"> <dt id="pyparsing.dict_of"> <code class="descclassname">pyparsing.</code><code class="descname">dict_of</code><span class="sig-paren">(</span><em>key: pyparsing.core.ParserElement</em>, <em>value: pyparsing.core.ParserElement</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.dict_of" title="Permalink to this definition">¶</a></dt> <dd><p>Helper to easily and clearly define a dictionary by specifying the respective patterns for the key and value. Takes care of defining the <a class="reference internal" href="#pyparsing.Dict" title="pyparsing.Dict"><code class="xref py py-class docutils literal notranslate"><span class="pre">Dict</span></code></a>, <a class="reference internal" href="#pyparsing.ZeroOrMore" title="pyparsing.ZeroOrMore"><code class="xref py py-class docutils literal notranslate"><span class="pre">ZeroOrMore</span></code></a>, and <a class="reference internal" href="#pyparsing.Group" title="pyparsing.Group"><code class="xref py py-class docutils literal notranslate"><span class="pre">Group</span></code></a> tokens in the proper order. The key pattern can include delimiting markers or punctuation, as long as they are suppressed, thereby leaving the significant key text. The value pattern can include named results, so that the <a class="reference internal" href="#pyparsing.Dict" title="pyparsing.Dict"><code class="xref py py-class docutils literal notranslate"><span class="pre">Dict</span></code></a> results can include named token fields.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">text</span> <span class="o">=</span> <span class="s2">"shape: SQUARE posn: upper left color: light blue texture: burlap"</span> <span class="n">attr_expr</span> <span class="o">=</span> <span class="p">(</span><span class="n">label</span> <span class="o">+</span> <span class="n">Suppress</span><span class="p">(</span><span class="s1">':'</span><span class="p">)</span> <span class="o">+</span> <span class="n">OneOrMore</span><span class="p">(</span><span class="n">data_word</span><span class="p">,</span> <span class="n">stop_on</span><span class="o">=</span><span class="n">label</span><span class="p">)</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="s1">' '</span><span class="o">.</span><span class="n">join</span><span class="p">))</span> <span class="nb">print</span><span class="p">(</span><span class="n">attr_expr</span><span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="n">text</span><span class="p">)</span><span class="o">.</span><span class="n">dump</span><span class="p">())</span> <span class="n">attr_label</span> <span class="o">=</span> <span class="n">label</span> <span class="n">attr_value</span> <span class="o">=</span> <span class="n">Suppress</span><span class="p">(</span><span class="s1">':'</span><span class="p">)</span> <span class="o">+</span> <span class="n">OneOrMore</span><span class="p">(</span><span class="n">data_word</span><span class="p">,</span> <span class="n">stop_on</span><span class="o">=</span><span class="n">label</span><span class="p">)</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="s1">' '</span><span class="o">.</span><span class="n">join</span><span class="p">)</span> <span class="c1"># similar to Dict, but simpler call format</span> <span class="n">result</span> <span class="o">=</span> <span class="n">dict_of</span><span class="p">(</span><span class="n">attr_label</span><span class="p">,</span> <span class="n">attr_value</span><span class="p">)</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="n">text</span><span class="p">)</span> <span class="nb">print</span><span class="p">(</span><span class="n">result</span><span class="o">.</span><span class="n">dump</span><span class="p">())</span> <span class="nb">print</span><span class="p">(</span><span class="n">result</span><span class="p">[</span><span class="s1">'shape'</span><span class="p">])</span> <span class="nb">print</span><span class="p">(</span><span class="n">result</span><span class="o">.</span><span class="n">shape</span><span class="p">)</span> <span class="c1"># object attribute access works too</span> <span class="nb">print</span><span class="p">(</span><span class="n">result</span><span class="o">.</span><span class="n">as_dict</span><span class="p">())</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[[</span><span class="s1">'shape'</span><span class="p">,</span> <span class="s1">'SQUARE'</span><span class="p">],</span> <span class="p">[</span><span class="s1">'posn'</span><span class="p">,</span> <span class="s1">'upper left'</span><span class="p">],</span> <span class="p">[</span><span class="s1">'color'</span><span class="p">,</span> <span class="s1">'light blue'</span><span class="p">],</span> <span class="p">[</span><span class="s1">'texture'</span><span class="p">,</span> <span class="s1">'burlap'</span><span class="p">]]</span> <span class="o">-</span> <span class="n">color</span><span class="p">:</span> <span class="s1">'light blue'</span> <span class="o">-</span> <span class="n">posn</span><span class="p">:</span> <span class="s1">'upper left'</span> <span class="o">-</span> <span class="n">shape</span><span class="p">:</span> <span class="s1">'SQUARE'</span> <span class="o">-</span> <span class="n">texture</span><span class="p">:</span> <span class="s1">'burlap'</span> <span class="n">SQUARE</span> <span class="n">SQUARE</span> <span class="p">{</span><span class="s1">'color'</span><span class="p">:</span> <span class="s1">'light blue'</span><span class="p">,</span> <span class="s1">'shape'</span><span class="p">:</span> <span class="s1">'SQUARE'</span><span class="p">,</span> <span class="s1">'posn'</span><span class="p">:</span> <span class="s1">'upper left'</span><span class="p">,</span> <span class="s1">'texture'</span><span class="p">:</span> <span class="s1">'burlap'</span><span class="p">}</span> </pre></div> </div> </dd></dl> <dl class="attribute"> <dt id="pyparsing.line"> <code class="descclassname">pyparsing.</code><code class="descname">line</code><a class="headerlink" href="#pyparsing.line" title="Permalink to this definition">¶</a></dt> <dd><p>Returns the line of text containing loc within a string, counting newlines as line separators.</p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.lineno"> <code class="descclassname">pyparsing.</code><code class="descname">lineno</code><a class="headerlink" href="#pyparsing.lineno" title="Permalink to this definition">¶</a></dt> <dd><p>Returns current line number within a string, counting newlines as line separators. The first line is number 1.</p> <p>Note - the default parsing behavior is to expand tabs in the input string before starting the parsing process. See <a class="reference internal" href="#pyparsing.ParserElement.parseString" title="pyparsing.ParserElement.parseString"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement.parseString</span></code></a> for more information on parsing strings containing <code class="docutils literal notranslate"><span class="pre"><TAB></span></code> s, and suggested methods to maintain a consistent view of the parsed string, the parse location, and line and column positions within the parsed string.</p> </dd></dl> <dl class="function"> <dt id="pyparsing.make_html_tags"> <code class="descclassname">pyparsing.</code><code class="descname">make_html_tags</code><span class="sig-paren">(</span><em>tag_str: Union[str, pyparsing.core.ParserElement]</em><span class="sig-paren">)</span> → Tuple[pyparsing.core.ParserElement, pyparsing.core.ParserElement]<a class="headerlink" href="#pyparsing.make_html_tags" title="Permalink to this definition">¶</a></dt> <dd><p>Helper to construct opening and closing tag expressions for HTML, given a tag name. Matches tags in either upper or lower case, attributes with namespaces and with quoted or unquoted values.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">text</span> <span class="o">=</span> <span class="s1">'<td>More info at the <a href="https://github.com/pyparsing/pyparsing/wiki">pyparsing</a> wiki page</td>'</span> <span class="c1"># make_html_tags returns pyparsing expressions for the opening and</span> <span class="c1"># closing tags as a 2-tuple</span> <span class="n">a</span><span class="p">,</span> <span class="n">a_end</span> <span class="o">=</span> <span class="n">make_html_tags</span><span class="p">(</span><span class="s2">"A"</span><span class="p">)</span> <span class="n">link_expr</span> <span class="o">=</span> <span class="n">a</span> <span class="o">+</span> <span class="n">SkipTo</span><span class="p">(</span><span class="n">a_end</span><span class="p">)(</span><span class="s2">"link_text"</span><span class="p">)</span> <span class="o">+</span> <span class="n">a_end</span> <span class="k">for</span> <span class="n">link</span> <span class="ow">in</span> <span class="n">link_expr</span><span class="o">.</span><span class="n">search_string</span><span class="p">(</span><span class="n">text</span><span class="p">):</span> <span class="c1"># attributes in the <A> tag (like "href" shown here) are</span> <span class="c1"># also accessible as named results</span> <span class="nb">print</span><span class="p">(</span><span class="n">link</span><span class="o">.</span><span class="n">link_text</span><span class="p">,</span> <span class="s1">'->'</span><span class="p">,</span> <span class="n">link</span><span class="o">.</span><span class="n">href</span><span class="p">)</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">pyparsing</span> <span class="o">-></span> <span class="n">https</span><span class="p">:</span><span class="o">//</span><span class="n">github</span><span class="o">.</span><span class="n">com</span><span class="o">/</span><span class="n">pyparsing</span><span class="o">/</span><span class="n">pyparsing</span><span class="o">/</span><span class="n">wiki</span> </pre></div> </div> </dd></dl> <dl class="function"> <dt id="pyparsing.make_xml_tags"> <code class="descclassname">pyparsing.</code><code class="descname">make_xml_tags</code><span class="sig-paren">(</span><em>tag_str: Union[str, pyparsing.core.ParserElement]</em><span class="sig-paren">)</span> → Tuple[pyparsing.core.ParserElement, pyparsing.core.ParserElement]<a class="headerlink" href="#pyparsing.make_xml_tags" title="Permalink to this definition">¶</a></dt> <dd><p>Helper to construct opening and closing tag expressions for XML, given a tag name. Matches tags only in the given upper/lower case.</p> <p>Example: similar to <a class="reference internal" href="#pyparsing.make_html_tags" title="pyparsing.make_html_tags"><code class="xref py py-class docutils literal notranslate"><span class="pre">make_html_tags</span></code></a></p> </dd></dl> <dl class="function"> <dt id="pyparsing.match_only_at_col"> <code class="descclassname">pyparsing.</code><code class="descname">match_only_at_col</code><span class="sig-paren">(</span><em>n</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.match_only_at_col" title="Permalink to this definition">¶</a></dt> <dd><p>Helper method for defining parse actions that require matching at a specific column in the input text.</p> </dd></dl> <dl class="function"> <dt id="pyparsing.match_previous_expr"> <code class="descclassname">pyparsing.</code><code class="descname">match_previous_expr</code><span class="sig-paren">(</span><em>expr: pyparsing.core.ParserElement</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.match_previous_expr" title="Permalink to this definition">¶</a></dt> <dd><p>Helper to define an expression that is indirectly defined from the tokens matched in a previous expression, that is, it looks for a ‘repeat’ of a previous expression. For example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">first</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="n">second</span> <span class="o">=</span> <span class="n">match_previous_expr</span><span class="p">(</span><span class="n">first</span><span class="p">)</span> <span class="n">match_expr</span> <span class="o">=</span> <span class="n">first</span> <span class="o">+</span> <span class="s2">":"</span> <span class="o">+</span> <span class="n">second</span> </pre></div> </div> <p>will match <code class="docutils literal notranslate"><span class="pre">"1:1"</span></code>, but not <code class="docutils literal notranslate"><span class="pre">"1:2"</span></code>. Because this matches by expressions, will <em>not</em> match the leading <code class="docutils literal notranslate"><span class="pre">"1:1"</span></code> in <code class="docutils literal notranslate"><span class="pre">"1:10"</span></code>; the expressions are evaluated first, and then compared, so <code class="docutils literal notranslate"><span class="pre">"1"</span></code> is compared with <code class="docutils literal notranslate"><span class="pre">"10"</span></code>. Do <em>not</em> use with packrat parsing enabled.</p> </dd></dl> <dl class="function"> <dt id="pyparsing.match_previous_literal"> <code class="descclassname">pyparsing.</code><code class="descname">match_previous_literal</code><span class="sig-paren">(</span><em>expr: pyparsing.core.ParserElement</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.match_previous_literal" title="Permalink to this definition">¶</a></dt> <dd><p>Helper to define an expression that is indirectly defined from the tokens matched in a previous expression, that is, it looks for a ‘repeat’ of a previous expression. For example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">first</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="n">second</span> <span class="o">=</span> <span class="n">match_previous_literal</span><span class="p">(</span><span class="n">first</span><span class="p">)</span> <span class="n">match_expr</span> <span class="o">=</span> <span class="n">first</span> <span class="o">+</span> <span class="s2">":"</span> <span class="o">+</span> <span class="n">second</span> </pre></div> </div> <p>will match <code class="docutils literal notranslate"><span class="pre">"1:1"</span></code>, but not <code class="docutils literal notranslate"><span class="pre">"1:2"</span></code>. Because this matches a previous literal, will also match the leading <code class="docutils literal notranslate"><span class="pre">"1:1"</span></code> in <code class="docutils literal notranslate"><span class="pre">"1:10"</span></code>. If this is not desired, use <a class="reference internal" href="#pyparsing.match_previous_expr" title="pyparsing.match_previous_expr"><code class="xref py py-class docutils literal notranslate"><span class="pre">match_previous_expr</span></code></a>. Do <em>not</em> use with packrat parsing enabled.</p> </dd></dl> <dl class="function"> <dt id="pyparsing.nested_expr"> <code class="descclassname">pyparsing.</code><code class="descname">nested_expr</code><span class="sig-paren">(</span><em>opener: Union[str</em>, <em>pyparsing.core.ParserElement] = '('</em>, <em>closer: Union[str</em>, <em>pyparsing.core.ParserElement] = ')'</em>, <em>content: Union[pyparsing.core.ParserElement</em>, <em>NoneType] = None</em>, <em>ignore_expr: pyparsing.core.ParserElement = quotedString using single or double quotes</em>, <em>*</em>, <em>ignoreExpr: pyparsing.core.ParserElement = quotedString using single or double quotes</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.nested_expr" title="Permalink to this definition">¶</a></dt> <dd><p>Helper method for defining nested lists enclosed in opening and closing delimiters (<code class="docutils literal notranslate"><span class="pre">"("</span></code> and <code class="docutils literal notranslate"><span class="pre">")"</span></code> are the default).</p> <p>Parameters: - <code class="docutils literal notranslate"><span class="pre">opener</span></code> - opening character for a nested list</p> <blockquote> <div>(default= <code class="docutils literal notranslate"><span class="pre">"("</span></code>); can also be a pyparsing expression</div></blockquote> <ul class="simple"> <li><code class="docutils literal notranslate"><span class="pre">closer</span></code> - closing character for a nested list (default= <code class="docutils literal notranslate"><span class="pre">")"</span></code>); can also be a pyparsing expression</li> <li><code class="docutils literal notranslate"><span class="pre">content</span></code> - expression for items within the nested lists (default= <code class="docutils literal notranslate"><span class="pre">None</span></code>)</li> <li><code class="docutils literal notranslate"><span class="pre">ignore_expr</span></code> - expression for ignoring opening and closing delimiters (default= <code class="xref py py-class docutils literal notranslate"><span class="pre">quoted_string</span></code>)</li> <li><code class="docutils literal notranslate"><span class="pre">ignoreExpr</span></code> - this pre-PEP8 argument is retained for compatibility but will be removed in a future release</li> </ul> <p>If an expression is not provided for the content argument, the nested expression will capture all whitespace-delimited content between delimiters as a list of separate values.</p> <p>Use the <code class="docutils literal notranslate"><span class="pre">ignore_expr</span></code> argument to define expressions that may contain opening or closing characters that should not be treated as opening or closing characters for nesting, such as quoted_string or a comment expression. Specify multiple expressions using an <a class="reference internal" href="#pyparsing.Or" title="pyparsing.Or"><code class="xref py py-class docutils literal notranslate"><span class="pre">Or</span></code></a> or <a class="reference internal" href="#pyparsing.MatchFirst" title="pyparsing.MatchFirst"><code class="xref py py-class docutils literal notranslate"><span class="pre">MatchFirst</span></code></a>. The default is <code class="xref py py-class docutils literal notranslate"><span class="pre">quoted_string</span></code>, but if no expressions are to be ignored, then pass <code class="docutils literal notranslate"><span class="pre">None</span></code> for this argument.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">data_type</span> <span class="o">=</span> <span class="n">one_of</span><span class="p">(</span><span class="s2">"void int short long char float double"</span><span class="p">)</span> <span class="n">decl_data_type</span> <span class="o">=</span> <span class="n">Combine</span><span class="p">(</span><span class="n">data_type</span> <span class="o">+</span> <span class="n">Opt</span><span class="p">(</span><span class="n">Word</span><span class="p">(</span><span class="s1">'*'</span><span class="p">)))</span> <span class="n">ident</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="o">+</span><span class="s1">'_'</span><span class="p">,</span> <span class="n">alphanums</span><span class="o">+</span><span class="s1">'_'</span><span class="p">)</span> <span class="n">number</span> <span class="o">=</span> <span class="n">pyparsing_common</span><span class="o">.</span><span class="n">number</span> <span class="n">arg</span> <span class="o">=</span> <span class="n">Group</span><span class="p">(</span><span class="n">decl_data_type</span> <span class="o">+</span> <span class="n">ident</span><span class="p">)</span> <span class="n">LPAR</span><span class="p">,</span> <span class="n">RPAR</span> <span class="o">=</span> <span class="nb">map</span><span class="p">(</span><span class="n">Suppress</span><span class="p">,</span> <span class="s2">"()"</span><span class="p">)</span> <span class="n">code_body</span> <span class="o">=</span> <span class="n">nested_expr</span><span class="p">(</span><span class="s1">'{'</span><span class="p">,</span> <span class="s1">'}'</span><span class="p">,</span> <span class="n">ignore_expr</span><span class="o">=</span><span class="p">(</span><span class="n">quoted_string</span> <span class="o">|</span> <span class="n">c_style_comment</span><span class="p">))</span> <span class="n">c_function</span> <span class="o">=</span> <span class="p">(</span><span class="n">decl_data_type</span><span class="p">(</span><span class="s2">"type"</span><span class="p">)</span> <span class="o">+</span> <span class="n">ident</span><span class="p">(</span><span class="s2">"name"</span><span class="p">)</span> <span class="o">+</span> <span class="n">LPAR</span> <span class="o">+</span> <span class="n">Opt</span><span class="p">(</span><span class="n">delimited_list</span><span class="p">(</span><span class="n">arg</span><span class="p">),</span> <span class="p">[])(</span><span class="s2">"args"</span><span class="p">)</span> <span class="o">+</span> <span class="n">RPAR</span> <span class="o">+</span> <span class="n">code_body</span><span class="p">(</span><span class="s2">"body"</span><span class="p">))</span> <span class="n">c_function</span><span class="o">.</span><span class="n">ignore</span><span class="p">(</span><span class="n">c_style_comment</span><span class="p">)</span> <span class="n">source_code</span> <span class="o">=</span> <span class="s1">'''</span> <span class="s1"> int is_odd(int x) {</span> <span class="s1"> return (x%2);</span> <span class="s1"> }</span> <span class="s1"> int dec_to_hex(char hchar) {</span> <span class="s1"> if (hchar >= '0' && hchar <= '9') {</span> <span class="s1"> return (ord(hchar)-ord('0'));</span> <span class="s1"> } else {</span> <span class="s1"> return (10+ord(hchar)-ord('A'));</span> <span class="s1"> }</span> <span class="s1"> }</span> <span class="s1">'''</span> <span class="k">for</span> <span class="n">func</span> <span class="ow">in</span> <span class="n">c_function</span><span class="o">.</span><span class="n">search_string</span><span class="p">(</span><span class="n">source_code</span><span class="p">):</span> <span class="nb">print</span><span class="p">(</span><span class="s2">"</span><span class="si">%(name)s</span><span class="s2"> (</span><span class="si">%(type)s</span><span class="s2">) args: </span><span class="si">%(args)s</span><span class="s2">"</span> <span class="o">%</span> <span class="n">func</span><span class="p">)</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">is_odd</span> <span class="p">(</span><span class="nb">int</span><span class="p">)</span> <span class="n">args</span><span class="p">:</span> <span class="p">[[</span><span class="s1">'int'</span><span class="p">,</span> <span class="s1">'x'</span><span class="p">]]</span> <span class="n">dec_to_hex</span> <span class="p">(</span><span class="nb">int</span><span class="p">)</span> <span class="n">args</span><span class="p">:</span> <span class="p">[[</span><span class="s1">'char'</span><span class="p">,</span> <span class="s1">'hchar'</span><span class="p">]]</span> </pre></div> </div> </dd></dl> <dl class="function"> <dt id="pyparsing.null_debug_action"> <code class="descclassname">pyparsing.</code><code class="descname">null_debug_action</code><span class="sig-paren">(</span><em>*args</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.null_debug_action" title="Permalink to this definition">¶</a></dt> <dd><p>‘Do-nothing’ debug action, to suppress debugging output during parsing.</p> </dd></dl> <dl class="function"> <dt id="pyparsing.one_of"> <code class="descclassname">pyparsing.</code><code class="descname">one_of</code><span class="sig-paren">(</span><em>strs: Union[typing.Iterable[str], str], caseless: bool = False, use_regex: bool = True, as_keyword: bool = False, *, useRegex: bool = True, asKeyword: bool = False</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.one_of" title="Permalink to this definition">¶</a></dt> <dd><p>Helper to quickly define a set of alternative <a class="reference internal" href="#pyparsing.Literal" title="pyparsing.Literal"><code class="xref py py-class docutils literal notranslate"><span class="pre">Literal</span></code></a> s, and makes sure to do longest-first testing when there is a conflict, regardless of the input order, but returns a <a class="reference internal" href="#pyparsing.MatchFirst" title="pyparsing.MatchFirst"><code class="xref py py-class docutils literal notranslate"><span class="pre">MatchFirst</span></code></a> for best performance.</p> <p>Parameters:</p> <ul class="simple"> <li><code class="docutils literal notranslate"><span class="pre">strs</span></code> - a string of space-delimited literals, or a collection of string literals</li> <li><code class="docutils literal notranslate"><span class="pre">caseless</span></code> - treat all literals as caseless - (default= <code class="docutils literal notranslate"><span class="pre">False</span></code>)</li> <li><code class="docutils literal notranslate"><span class="pre">use_regex</span></code> - as an optimization, will generate a <a class="reference internal" href="#pyparsing.Regex" title="pyparsing.Regex"><code class="xref py py-class docutils literal notranslate"><span class="pre">Regex</span></code></a> object; otherwise, will generate a <a class="reference internal" href="#pyparsing.MatchFirst" title="pyparsing.MatchFirst"><code class="xref py py-class docutils literal notranslate"><span class="pre">MatchFirst</span></code></a> object (if <code class="docutils literal notranslate"><span class="pre">caseless=True</span></code> or <code class="docutils literal notranslate"><span class="pre">asKeyword=True</span></code>, or if creating a <a class="reference internal" href="#pyparsing.Regex" title="pyparsing.Regex"><code class="xref py py-class docutils literal notranslate"><span class="pre">Regex</span></code></a> raises an exception) - (default= <code class="docutils literal notranslate"><span class="pre">True</span></code>)</li> <li><code class="docutils literal notranslate"><span class="pre">as_keyword</span></code> - enforce <a class="reference internal" href="#pyparsing.Keyword" title="pyparsing.Keyword"><code class="xref py py-class docutils literal notranslate"><span class="pre">Keyword</span></code></a>-style matching on the generated expressions - (default= <code class="docutils literal notranslate"><span class="pre">False</span></code>)</li> <li><code class="docutils literal notranslate"><span class="pre">asKeyword</span></code> and <code class="docutils literal notranslate"><span class="pre">useRegex</span></code> are retained for pre-PEP8 compatibility, but will be removed in a future release</li> </ul> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">comp_oper</span> <span class="o">=</span> <span class="n">one_of</span><span class="p">(</span><span class="s2">"< = > <= >= !="</span><span class="p">)</span> <span class="n">var</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)</span> <span class="n">number</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="n">term</span> <span class="o">=</span> <span class="n">var</span> <span class="o">|</span> <span class="n">number</span> <span class="n">comparison_expr</span> <span class="o">=</span> <span class="n">term</span> <span class="o">+</span> <span class="n">comp_oper</span> <span class="o">+</span> <span class="n">term</span> <span class="nb">print</span><span class="p">(</span><span class="n">comparison_expr</span><span class="o">.</span><span class="n">search_string</span><span class="p">(</span><span class="s2">"B = 12 AA=23 B<=AA AA>12"</span><span class="p">))</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[[</span><span class="s1">'B'</span><span class="p">,</span> <span class="s1">'='</span><span class="p">,</span> <span class="s1">'12'</span><span class="p">],</span> <span class="p">[</span><span class="s1">'AA'</span><span class="p">,</span> <span class="s1">'='</span><span class="p">,</span> <span class="s1">'23'</span><span class="p">],</span> <span class="p">[</span><span class="s1">'B'</span><span class="p">,</span> <span class="s1">'<='</span><span class="p">,</span> <span class="s1">'AA'</span><span class="p">],</span> <span class="p">[</span><span class="s1">'AA'</span><span class="p">,</span> <span class="s1">'>'</span><span class="p">,</span> <span class="s1">'12'</span><span class="p">]]</span> </pre></div> </div> </dd></dl> <dl class="function"> <dt id="pyparsing.remove_quotes"> <code class="descclassname">pyparsing.</code><code class="descname">remove_quotes</code><span class="sig-paren">(</span><em>s</em>, <em>l</em>, <em>t</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.remove_quotes" title="Permalink to this definition">¶</a></dt> <dd><p>Helper parse action for removing quotation marks from parsed quoted strings.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># by default, quotation marks are included in parsed results</span> <span class="n">quoted_string</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"'Now is the Winter of our Discontent'"</span><span class="p">)</span> <span class="c1"># -> ["'Now is the Winter of our Discontent'"]</span> <span class="c1"># use remove_quotes to strip quotation marks from parsed results</span> <span class="n">quoted_string</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="n">remove_quotes</span><span class="p">)</span> <span class="n">quoted_string</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"'Now is the Winter of our Discontent'"</span><span class="p">)</span> <span class="c1"># -> ["Now is the Winter of our Discontent"]</span> </pre></div> </div> </dd></dl> <dl class="function"> <dt id="pyparsing.replace_with"> <code class="descclassname">pyparsing.</code><code class="descname">replace_with</code><span class="sig-paren">(</span><em>repl_str</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.replace_with" title="Permalink to this definition">¶</a></dt> <dd><p>Helper method for common parse actions that simply return a literal value. Especially useful when used with <a class="reference internal" href="#pyparsing.ParserElement.transform_string" title="pyparsing.ParserElement.transform_string"><code class="xref py py-class docutils literal notranslate"><span class="pre">transform_string</span></code></a> ().</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">num</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="k">lambda</span> <span class="n">toks</span><span class="p">:</span> <span class="nb">int</span><span class="p">(</span><span class="n">toks</span><span class="p">[</span><span class="mi">0</span><span class="p">]))</span> <span class="n">na</span> <span class="o">=</span> <span class="n">one_of</span><span class="p">(</span><span class="s2">"N/A NA"</span><span class="p">)</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="n">replace_with</span><span class="p">(</span><span class="n">math</span><span class="o">.</span><span class="n">nan</span><span class="p">))</span> <span class="n">term</span> <span class="o">=</span> <span class="n">na</span> <span class="o">|</span> <span class="n">num</span> <span class="n">term</span><span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"324 234 N/A 234"</span><span class="p">)</span> <span class="c1"># -> [324, 234, nan, 234]</span> </pre></div> </div> </dd></dl> <dl class="function"> <dt id="pyparsing.replace_html_entity"> <code class="descclassname">pyparsing.</code><code class="descname">replace_html_entity</code><span class="sig-paren">(</span><em>t</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.replace_html_entity" title="Permalink to this definition">¶</a></dt> <dd><p>Helper parser action to replace common HTML entities with their special characters</p> </dd></dl> <dl class="function"> <dt id="pyparsing.srange"> <code class="descclassname">pyparsing.</code><code class="descname">srange</code><span class="sig-paren">(</span><em>s: str</em><span class="sig-paren">)</span> → str<a class="headerlink" href="#pyparsing.srange" title="Permalink to this definition">¶</a></dt> <dd><p>Helper to easily define string ranges for use in <a class="reference internal" href="#pyparsing.Word" title="pyparsing.Word"><code class="xref py py-class docutils literal notranslate"><span class="pre">Word</span></code></a> construction. Borrows syntax from regexp <code class="docutils literal notranslate"><span class="pre">'[]'</span></code> string range definitions:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">srange</span><span class="p">(</span><span class="s2">"[0-9]"</span><span class="p">)</span> <span class="o">-></span> <span class="s2">"0123456789"</span> <span class="n">srange</span><span class="p">(</span><span class="s2">"[a-z]"</span><span class="p">)</span> <span class="o">-></span> <span class="s2">"abcdefghijklmnopqrstuvwxyz"</span> <span class="n">srange</span><span class="p">(</span><span class="s2">"[a-z$_]"</span><span class="p">)</span> <span class="o">-></span> <span class="s2">"abcdefghijklmnopqrstuvwxyz$_"</span> </pre></div> </div> <p>The input string must be enclosed in []’s, and the returned string is the expanded character set joined into a single string. The values enclosed in the []’s may be:</p> <ul class="simple"> <li>a single character</li> <li>an escaped character with a leading backslash (such as <code class="docutils literal notranslate"><span class="pre">\-</span></code> or <code class="docutils literal notranslate"><span class="pre">\]</span></code>)</li> <li>an escaped hex character with a leading <code class="docutils literal notranslate"><span class="pre">'\x'</span></code> (<code class="docutils literal notranslate"><span class="pre">\x21</span></code>, which is a <code class="docutils literal notranslate"><span class="pre">'!'</span></code> character) (<code class="docutils literal notranslate"><span class="pre">\0x##</span></code> is also supported for backwards compatibility)</li> <li>an escaped octal character with a leading <code class="docutils literal notranslate"><span class="pre">'\0'</span></code> (<code class="docutils literal notranslate"><span class="pre">\041</span></code>, which is a <code class="docutils literal notranslate"><span class="pre">'!'</span></code> character)</li> <li>a range of any of the above, separated by a dash (<code class="docutils literal notranslate"><span class="pre">'a-z'</span></code>, etc.)</li> <li>any combination of the above (<code class="docutils literal notranslate"><span class="pre">'aeiouy'</span></code>, <code class="docutils literal notranslate"><span class="pre">'a-zA-Z0-9_$'</span></code>, etc.)</li> </ul> </dd></dl> <dl class="function"> <dt id="pyparsing.trace_parse_action"> <code class="descclassname">pyparsing.</code><code class="descname">trace_parse_action</code><span class="sig-paren">(</span><em>f: Union[typing.Callable[[], typing.Any], typing.Callable[[pyparsing.results.ParseResults], typing.Any], typing.Callable[[int, pyparsing.results.ParseResults], typing.Any], typing.Callable[[str, int, pyparsing.results.ParseResults], typing.Any]]</em><span class="sig-paren">)</span> → Union[typing.Callable[[], typing.Any], typing.Callable[[pyparsing.results.ParseResults], typing.Any], typing.Callable[[int, pyparsing.results.ParseResults], typing.Any], typing.Callable[[str, int, pyparsing.results.ParseResults], typing.Any]]<a class="headerlink" href="#pyparsing.trace_parse_action" title="Permalink to this definition">¶</a></dt> <dd><p>Decorator for debugging parse actions.</p> <p>When the parse action is called, this decorator will print <code class="docutils literal notranslate"><span class="pre">">></span> <span class="pre">entering</span> <span class="pre">method-name(line:<current_source_line>,</span> <span class="pre"><parse_location>,</span> <span class="pre"><matched_tokens>)"</span></code>. When the parse action completes, the decorator will print <code class="docutils literal notranslate"><span class="pre">"<<"</span></code> followed by the returned value, or any exception that the parse action raised.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">wd</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)</span> <span class="nd">@trace_parse_action</span> <span class="k">def</span> <span class="nf">remove_duplicate_chars</span><span class="p">(</span><span class="n">tokens</span><span class="p">):</span> <span class="k">return</span> <span class="s1">''</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="nb">sorted</span><span class="p">(</span><span class="nb">set</span><span class="p">(</span><span class="s1">''</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">tokens</span><span class="p">))))</span> <span class="n">wds</span> <span class="o">=</span> <span class="n">wd</span><span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="n">remove_duplicate_chars</span><span class="p">)</span> <span class="nb">print</span><span class="p">(</span><span class="n">wds</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"slkdjs sld sldd sdlf sdljf"</span><span class="p">))</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="o">>></span><span class="n">entering</span> <span class="n">remove_duplicate_chars</span><span class="p">(</span><span class="n">line</span><span class="p">:</span> <span class="s1">'slkdjs sld sldd sdlf sdljf'</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="p">([</span><span class="s1">'slkdjs'</span><span class="p">,</span> <span class="s1">'sld'</span><span class="p">,</span> <span class="s1">'sldd'</span><span class="p">,</span> <span class="s1">'sdlf'</span><span class="p">,</span> <span class="s1">'sdljf'</span><span class="p">],</span> <span class="p">{}))</span> <span class="o"><<</span><span class="n">leaving</span> <span class="n">remove_duplicate_chars</span> <span class="p">(</span><span class="n">ret</span><span class="p">:</span> <span class="s1">'dfjkls'</span><span class="p">)</span> <span class="p">[</span><span class="s1">'dfjkls'</span><span class="p">]</span> </pre></div> </div> </dd></dl> <dl class="function"> <dt id="pyparsing.with_attribute"> <code class="descclassname">pyparsing.</code><code class="descname">with_attribute</code><span class="sig-paren">(</span><em>*args</em>, <em>**attr_dict</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.with_attribute" title="Permalink to this definition">¶</a></dt> <dd><p>Helper to create a validating parse action to be used with start tags created with <a class="reference internal" href="#pyparsing.make_xml_tags" title="pyparsing.make_xml_tags"><code class="xref py py-class docutils literal notranslate"><span class="pre">make_xml_tags</span></code></a> or <a class="reference internal" href="#pyparsing.make_html_tags" title="pyparsing.make_html_tags"><code class="xref py py-class docutils literal notranslate"><span class="pre">make_html_tags</span></code></a>. Use <code class="docutils literal notranslate"><span class="pre">with_attribute</span></code> to qualify a starting tag with a required attribute value, to avoid false matches on common tags such as <code class="docutils literal notranslate"><span class="pre"><TD></span></code> or <code class="docutils literal notranslate"><span class="pre"><DIV></span></code>.</p> <p>Call <code class="docutils literal notranslate"><span class="pre">with_attribute</span></code> with a series of attribute names and values. Specify the list of filter attributes names and values as:</p> <ul class="simple"> <li>keyword arguments, as in <code class="docutils literal notranslate"><span class="pre">(align="right")</span></code>, or</li> <li>as an explicit dict with <code class="docutils literal notranslate"><span class="pre">**</span></code> operator, when an attribute name is also a Python reserved word, as in <code class="docutils literal notranslate"><span class="pre">**{"class":"Customer",</span> <span class="pre">"align":"right"}</span></code></li> <li>a list of name-value tuples, as in <code class="docutils literal notranslate"><span class="pre">(("ns1:class",</span> <span class="pre">"Customer"),</span> <span class="pre">("ns2:align",</span> <span class="pre">"right"))</span></code></li> </ul> <p>For attribute names with a namespace prefix, you must use the second form. Attribute names are matched insensitive to upper/lower case.</p> <p>If just testing for <code class="docutils literal notranslate"><span class="pre">class</span></code> (with or without a namespace), use <a class="reference internal" href="#pyparsing.with_class" title="pyparsing.with_class"><code class="xref py py-class docutils literal notranslate"><span class="pre">with_class</span></code></a>.</p> <p>To verify that the attribute exists, but without specifying a value, pass <code class="docutils literal notranslate"><span class="pre">with_attribute.ANY_VALUE</span></code> as the value.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">html</span> <span class="o">=</span> <span class="s1">'''</span> <span class="s1"> <div></span> <span class="s1"> Some text</span> <span class="s1"> <div type="grid">1 4 0 1 0</div></span> <span class="s1"> <div type="graph">1,3 2,3 1,1</div></span> <span class="s1"> <div>this has no type</div></span> <span class="s1"> </div></span> <span class="s1">'''</span> <span class="n">div</span><span class="p">,</span><span class="n">div_end</span> <span class="o">=</span> <span class="n">make_html_tags</span><span class="p">(</span><span class="s2">"div"</span><span class="p">)</span> <span class="c1"># only match div tag having a type attribute with value "grid"</span> <span class="n">div_grid</span> <span class="o">=</span> <span class="n">div</span><span class="p">()</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="n">with_attribute</span><span class="p">(</span><span class="nb">type</span><span class="o">=</span><span class="s2">"grid"</span><span class="p">))</span> <span class="n">grid_expr</span> <span class="o">=</span> <span class="n">div_grid</span> <span class="o">+</span> <span class="n">SkipTo</span><span class="p">(</span><span class="n">div</span> <span class="o">|</span> <span class="n">div_end</span><span class="p">)(</span><span class="s2">"body"</span><span class="p">)</span> <span class="k">for</span> <span class="n">grid_header</span> <span class="ow">in</span> <span class="n">grid_expr</span><span class="o">.</span><span class="n">search_string</span><span class="p">(</span><span class="n">html</span><span class="p">):</span> <span class="nb">print</span><span class="p">(</span><span class="n">grid_header</span><span class="o">.</span><span class="n">body</span><span class="p">)</span> <span class="c1"># construct a match with any div tag having a type attribute, regardless of the value</span> <span class="n">div_any_type</span> <span class="o">=</span> <span class="n">div</span><span class="p">()</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="n">with_attribute</span><span class="p">(</span><span class="nb">type</span><span class="o">=</span><span class="n">with_attribute</span><span class="o">.</span><span class="n">ANY_VALUE</span><span class="p">))</span> <span class="n">div_expr</span> <span class="o">=</span> <span class="n">div_any_type</span> <span class="o">+</span> <span class="n">SkipTo</span><span class="p">(</span><span class="n">div</span> <span class="o">|</span> <span class="n">div_end</span><span class="p">)(</span><span class="s2">"body"</span><span class="p">)</span> <span class="k">for</span> <span class="n">div_header</span> <span class="ow">in</span> <span class="n">div_expr</span><span class="o">.</span><span class="n">search_string</span><span class="p">(</span><span class="n">html</span><span class="p">):</span> <span class="nb">print</span><span class="p">(</span><span class="n">div_header</span><span class="o">.</span><span class="n">body</span><span class="p">)</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">1</span> <span class="mi">4</span> <span class="mi">0</span> <span class="mi">1</span> <span class="mi">0</span> <span class="mi">1</span> <span class="mi">4</span> <span class="mi">0</span> <span class="mi">1</span> <span class="mi">0</span> <span class="mi">1</span><span class="p">,</span><span class="mi">3</span> <span class="mi">2</span><span class="p">,</span><span class="mi">3</span> <span class="mi">1</span><span class="p">,</span><span class="mi">1</span> </pre></div> </div> </dd></dl> <dl class="function"> <dt id="pyparsing.indentedBlock"> <code class="descclassname">pyparsing.</code><code class="descname">indentedBlock</code><span class="sig-paren">(</span><em>blockStatementExpr</em>, <em>indentStack</em>, <em>indent=True</em>, <em>backup_stacks=[]</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.indentedBlock" title="Permalink to this definition">¶</a></dt> <dd><p>(DEPRECATED - use IndentedBlock class instead) Helper method for defining space-delimited indentation blocks, such as those used to define block statements in Python source code.</p> <p>Parameters:</p> <ul class="simple"> <li><code class="docutils literal notranslate"><span class="pre">blockStatementExpr</span></code> - expression defining syntax of statement that is repeated within the indented block</li> <li><code class="docutils literal notranslate"><span class="pre">indentStack</span></code> - list created by caller to manage indentation stack (multiple <code class="docutils literal notranslate"><span class="pre">statementWithIndentedBlock</span></code> expressions within a single grammar should share a common <code class="docutils literal notranslate"><span class="pre">indentStack</span></code>)</li> <li><code class="docutils literal notranslate"><span class="pre">indent</span></code> - boolean indicating whether block must be indented beyond the current level; set to <code class="docutils literal notranslate"><span class="pre">False</span></code> for block of left-most statements (default= <code class="docutils literal notranslate"><span class="pre">True</span></code>)</li> </ul> <p>A valid block must contain at least one <code class="docutils literal notranslate"><span class="pre">blockStatement</span></code>.</p> <p>(Note that indentedBlock uses internal parse actions which make it incompatible with packrat parsing.)</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">data</span> <span class="o">=</span> <span class="s1">'''</span> <span class="s1">def A(z):</span> <span class="s1"> A1</span> <span class="s1"> B = 100</span> <span class="s1"> G = A2</span> <span class="s1"> A2</span> <span class="s1"> A3</span> <span class="s1">B</span> <span class="s1">def BB(a,b,c):</span> <span class="s1"> BB1</span> <span class="s1"> def BBA():</span> <span class="s1"> bba1</span> <span class="s1"> bba2</span> <span class="s1"> bba3</span> <span class="s1">C</span> <span class="s1">D</span> <span class="s1">def spam(x,y):</span> <span class="s1"> def eggs(z):</span> <span class="s1"> pass</span> <span class="s1">'''</span> <span class="n">indentStack</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="n">stmt</span> <span class="o">=</span> <span class="n">Forward</span><span class="p">()</span> <span class="n">identifier</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">,</span> <span class="n">alphanums</span><span class="p">)</span> <span class="n">funcDecl</span> <span class="o">=</span> <span class="p">(</span><span class="s2">"def"</span> <span class="o">+</span> <span class="n">identifier</span> <span class="o">+</span> <span class="n">Group</span><span class="p">(</span><span class="s2">"("</span> <span class="o">+</span> <span class="n">Opt</span><span class="p">(</span><span class="n">delimitedList</span><span class="p">(</span><span class="n">identifier</span><span class="p">))</span> <span class="o">+</span> <span class="s2">")"</span><span class="p">)</span> <span class="o">+</span> <span class="s2">":"</span><span class="p">)</span> <span class="n">func_body</span> <span class="o">=</span> <span class="n">indentedBlock</span><span class="p">(</span><span class="n">stmt</span><span class="p">,</span> <span class="n">indentStack</span><span class="p">)</span> <span class="n">funcDef</span> <span class="o">=</span> <span class="n">Group</span><span class="p">(</span><span class="n">funcDecl</span> <span class="o">+</span> <span class="n">func_body</span><span class="p">)</span> <span class="n">rvalue</span> <span class="o">=</span> <span class="n">Forward</span><span class="p">()</span> <span class="n">funcCall</span> <span class="o">=</span> <span class="n">Group</span><span class="p">(</span><span class="n">identifier</span> <span class="o">+</span> <span class="s2">"("</span> <span class="o">+</span> <span class="n">Opt</span><span class="p">(</span><span class="n">delimitedList</span><span class="p">(</span><span class="n">rvalue</span><span class="p">))</span> <span class="o">+</span> <span class="s2">")"</span><span class="p">)</span> <span class="n">rvalue</span> <span class="o"><<</span> <span class="p">(</span><span class="n">funcCall</span> <span class="o">|</span> <span class="n">identifier</span> <span class="o">|</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">))</span> <span class="n">assignment</span> <span class="o">=</span> <span class="n">Group</span><span class="p">(</span><span class="n">identifier</span> <span class="o">+</span> <span class="s2">"="</span> <span class="o">+</span> <span class="n">rvalue</span><span class="p">)</span> <span class="n">stmt</span> <span class="o"><<</span> <span class="p">(</span><span class="n">funcDef</span> <span class="o">|</span> <span class="n">assignment</span> <span class="o">|</span> <span class="n">identifier</span><span class="p">)</span> <span class="n">module_body</span> <span class="o">=</span> <span class="n">stmt</span><span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span> <span class="n">parseTree</span> <span class="o">=</span> <span class="n">module_body</span><span class="o">.</span><span class="n">parseString</span><span class="p">(</span><span class="n">data</span><span class="p">)</span> <span class="n">parseTree</span><span class="o">.</span><span class="n">pprint</span><span class="p">()</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[[</span><span class="s1">'def'</span><span class="p">,</span> <span class="s1">'A'</span><span class="p">,</span> <span class="p">[</span><span class="s1">'('</span><span class="p">,</span> <span class="s1">'z'</span><span class="p">,</span> <span class="s1">')'</span><span class="p">],</span> <span class="s1">':'</span><span class="p">,</span> <span class="p">[[</span><span class="s1">'A1'</span><span class="p">],</span> <span class="p">[[</span><span class="s1">'B'</span><span class="p">,</span> <span class="s1">'='</span><span class="p">,</span> <span class="s1">'100'</span><span class="p">]],</span> <span class="p">[[</span><span class="s1">'G'</span><span class="p">,</span> <span class="s1">'='</span><span class="p">,</span> <span class="s1">'A2'</span><span class="p">]],</span> <span class="p">[</span><span class="s1">'A2'</span><span class="p">],</span> <span class="p">[</span><span class="s1">'A3'</span><span class="p">]]],</span> <span class="s1">'B'</span><span class="p">,</span> <span class="p">[</span><span class="s1">'def'</span><span class="p">,</span> <span class="s1">'BB'</span><span class="p">,</span> <span class="p">[</span><span class="s1">'('</span><span class="p">,</span> <span class="s1">'a'</span><span class="p">,</span> <span class="s1">'b'</span><span class="p">,</span> <span class="s1">'c'</span><span class="p">,</span> <span class="s1">')'</span><span class="p">],</span> <span class="s1">':'</span><span class="p">,</span> <span class="p">[[</span><span class="s1">'BB1'</span><span class="p">],</span> <span class="p">[[</span><span class="s1">'def'</span><span class="p">,</span> <span class="s1">'BBA'</span><span class="p">,</span> <span class="p">[</span><span class="s1">'('</span><span class="p">,</span> <span class="s1">')'</span><span class="p">],</span> <span class="s1">':'</span><span class="p">,</span> <span class="p">[[</span><span class="s1">'bba1'</span><span class="p">],</span> <span class="p">[</span><span class="s1">'bba2'</span><span class="p">],</span> <span class="p">[</span><span class="s1">'bba3'</span><span class="p">]]]]]],</span> <span class="s1">'C'</span><span class="p">,</span> <span class="s1">'D'</span><span class="p">,</span> <span class="p">[</span><span class="s1">'def'</span><span class="p">,</span> <span class="s1">'spam'</span><span class="p">,</span> <span class="p">[</span><span class="s1">'('</span><span class="p">,</span> <span class="s1">'x'</span><span class="p">,</span> <span class="s1">'y'</span><span class="p">,</span> <span class="s1">')'</span><span class="p">],</span> <span class="s1">':'</span><span class="p">,</span> <span class="p">[[[</span><span class="s1">'def'</span><span class="p">,</span> <span class="s1">'eggs'</span><span class="p">,</span> <span class="p">[</span><span class="s1">'('</span><span class="p">,</span> <span class="s1">'z'</span><span class="p">,</span> <span class="s1">')'</span><span class="p">],</span> <span class="s1">':'</span><span class="p">,</span> <span class="p">[[</span><span class="s1">'pass'</span><span class="p">]]]]]]]</span> </pre></div> </div> </dd></dl> <dl class="function"> <dt id="pyparsing.original_text_for"> <code class="descclassname">pyparsing.</code><code class="descname">original_text_for</code><span class="sig-paren">(</span><em>expr: pyparsing.core.ParserElement</em>, <em>as_string: bool = True</em>, <em>*</em>, <em>asString: bool = True</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.original_text_for" title="Permalink to this definition">¶</a></dt> <dd><p>Helper to return the original, untokenized text for a given expression. Useful to restore the parsed fields of an HTML start tag into the raw tag text itself, or to revert separate tokens with intervening whitespace back to the original matching input text. By default, returns astring containing the original parsed text.</p> <p>If the optional <code class="docutils literal notranslate"><span class="pre">as_string</span></code> argument is passed as <code class="docutils literal notranslate"><span class="pre">False</span></code>, then the return value is a <a class="reference internal" href="#pyparsing.ParseResults" title="pyparsing.ParseResults"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParseResults</span></code></a> containing any results names that were originally matched, and a single token containing the original matched text from the input string. So if the expression passed to <a class="reference internal" href="#pyparsing.original_text_for" title="pyparsing.original_text_for"><code class="xref py py-class docutils literal notranslate"><span class="pre">original_text_for</span></code></a> contains expressions with defined results names, you must set <code class="docutils literal notranslate"><span class="pre">as_string</span></code> to <code class="docutils literal notranslate"><span class="pre">False</span></code> if you want to preserve those results name values.</p> <p>The <code class="docutils literal notranslate"><span class="pre">asString</span></code> pre-PEP8 argument is retained for compatibility, but will be removed in a future release.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">src</span> <span class="o">=</span> <span class="s2">"this is test <b> bold <i>text</i> </b> normal text "</span> <span class="k">for</span> <span class="n">tag</span> <span class="ow">in</span> <span class="p">(</span><span class="s2">"b"</span><span class="p">,</span> <span class="s2">"i"</span><span class="p">):</span> <span class="n">opener</span><span class="p">,</span> <span class="n">closer</span> <span class="o">=</span> <span class="n">make_html_tags</span><span class="p">(</span><span class="n">tag</span><span class="p">)</span> <span class="n">patt</span> <span class="o">=</span> <span class="n">original_text_for</span><span class="p">(</span><span class="n">opener</span> <span class="o">+</span> <span class="n">SkipTo</span><span class="p">(</span><span class="n">closer</span><span class="p">)</span> <span class="o">+</span> <span class="n">closer</span><span class="p">)</span> <span class="nb">print</span><span class="p">(</span><span class="n">patt</span><span class="o">.</span><span class="n">search_string</span><span class="p">(</span><span class="n">src</span><span class="p">)[</span><span class="mi">0</span><span class="p">])</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="s1">'<b> bold <i>text</i> </b>'</span><span class="p">]</span> <span class="p">[</span><span class="s1">'<i>text</i>'</span><span class="p">]</span> </pre></div> </div> </dd></dl> <dl class="function"> <dt id="pyparsing.ungroup"> <code class="descclassname">pyparsing.</code><code class="descname">ungroup</code><span class="sig-paren">(</span><em>expr: pyparsing.core.ParserElement</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.ungroup" title="Permalink to this definition">¶</a></dt> <dd><p>Helper to undo pyparsing’s default grouping of And expressions, even if all but one are non-empty.</p> </dd></dl> <dl class="function"> <dt id="pyparsing.infix_notation"> <code class="descclassname">pyparsing.</code><code class="descname">infix_notation</code><span class="sig-paren">(</span><em>base_expr: pyparsing.core.ParserElement, op_list: List[Union[typing.Tuple[typing.Union[pyparsing.core.ParserElement, str, typing.Tuple[typing.Union[pyparsing.core.ParserElement, str], typing.Union[pyparsing.core.ParserElement, str]]], int, pyparsing.helpers.OpAssoc, typing.Union[typing.Callable[[], typing.Any], typing.Callable[[pyparsing.results.ParseResults], typing.Any], typing.Callable[[int, pyparsing.results.ParseResults], typing.Any], typing.Callable[[str, int, pyparsing.results.ParseResults], typing.Any], NoneType]], typing.Tuple[typing.Union[pyparsing.core.ParserElement, str, typing.Tuple[typing.Union[pyparsing.core.ParserElement, str], typing.Union[pyparsing.core.ParserElement, str]]], int, pyparsing.helpers.OpAssoc]]], lpar: Union[str, pyparsing.core.ParserElement] = Suppress:('('), rpar: Union[str, pyparsing.core.ParserElement] = Suppress:(')')</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.infix_notation" title="Permalink to this definition">¶</a></dt> <dd><p>Helper method for constructing grammars of expressions made up of operators working in a precedence hierarchy. Operators may be unary or binary, left- or right-associative. Parse actions can also be attached to operator expressions. The generated parser will also recognize the use of parentheses to override operator precedences (see example below).</p> <p>Note: if you define a deep operator list, you may see performance issues when using infix_notation. See <a class="reference internal" href="#pyparsing.ParserElement.enable_packrat" title="pyparsing.ParserElement.enable_packrat"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement.enable_packrat</span></code></a> for a mechanism to potentially improve your parser performance.</p> <p>Parameters: - <code class="docutils literal notranslate"><span class="pre">base_expr</span></code> - expression representing the most basic operand to</p> <blockquote> <div>be used in the expression</div></blockquote> <ul class="simple"> <li><code class="docutils literal notranslate"><span class="pre">op_list</span></code> - list of tuples, one for each operator precedence level in the expression grammar; each tuple is of the form <code class="docutils literal notranslate"><span class="pre">(op_expr,</span> <span class="pre">num_operands,</span> <span class="pre">right_left_assoc,</span> <span class="pre">(optional)parse_action)</span></code>, where:<ul> <li><code class="docutils literal notranslate"><span class="pre">op_expr</span></code> is the pyparsing expression for the operator; may also be a string, which will be converted to a Literal; if <code class="docutils literal notranslate"><span class="pre">num_operands</span></code> is 3, <code class="docutils literal notranslate"><span class="pre">op_expr</span></code> is a tuple of two expressions, for the two operators separating the 3 terms</li> <li><code class="docutils literal notranslate"><span class="pre">num_operands</span></code> is the number of terms for this operator (must be 1, 2, or 3)</li> <li><code class="docutils literal notranslate"><span class="pre">right_left_assoc</span></code> is the indicator whether the operator is right or left associative, using the pyparsing-defined constants <code class="docutils literal notranslate"><span class="pre">OpAssoc.RIGHT</span></code> and <code class="docutils literal notranslate"><span class="pre">OpAssoc.LEFT</span></code>.</li> <li><code class="docutils literal notranslate"><span class="pre">parse_action</span></code> is the parse action to be associated with expressions matching this operator expression (the parse action tuple member may be omitted); if the parse action is passed a tuple or list of functions, this is equivalent to calling <code class="docutils literal notranslate"><span class="pre">set_parse_action(*fn)</span></code> (<a class="reference internal" href="#pyparsing.ParserElement.set_parse_action" title="pyparsing.ParserElement.set_parse_action"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement.set_parse_action</span></code></a>)</li> </ul> </li> <li><code class="docutils literal notranslate"><span class="pre">lpar</span></code> - expression for matching left-parentheses; if passed as a str, then will be parsed as Suppress(lpar). If lpar is passed as an expression (such as <code class="docutils literal notranslate"><span class="pre">Literal('(')</span></code>), then it will be kept in the parsed results, and grouped with them. (default= <code class="docutils literal notranslate"><span class="pre">Suppress('(')</span></code>)</li> <li><code class="docutils literal notranslate"><span class="pre">rpar</span></code> - expression for matching right-parentheses; if passed as a str, then will be parsed as Suppress(rpar). If rpar is passed as an expression (such as <code class="docutils literal notranslate"><span class="pre">Literal(')')</span></code>), then it will be kept in the parsed results, and grouped with them. (default= <code class="docutils literal notranslate"><span class="pre">Suppress(')')</span></code>)</li> </ul> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># simple example of four-function arithmetic with ints and</span> <span class="c1"># variable names</span> <span class="n">integer</span> <span class="o">=</span> <span class="n">pyparsing_common</span><span class="o">.</span><span class="n">signed_integer</span> <span class="n">varname</span> <span class="o">=</span> <span class="n">pyparsing_common</span><span class="o">.</span><span class="n">identifier</span> <span class="n">arith_expr</span> <span class="o">=</span> <span class="n">infix_notation</span><span class="p">(</span><span class="n">integer</span> <span class="o">|</span> <span class="n">varname</span><span class="p">,</span> <span class="p">[</span> <span class="p">(</span><span class="s1">'-'</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="n">OpAssoc</span><span class="o">.</span><span class="n">RIGHT</span><span class="p">),</span> <span class="p">(</span><span class="n">one_of</span><span class="p">(</span><span class="s1">'* /'</span><span class="p">),</span> <span class="mi">2</span><span class="p">,</span> <span class="n">OpAssoc</span><span class="o">.</span><span class="n">LEFT</span><span class="p">),</span> <span class="p">(</span><span class="n">one_of</span><span class="p">(</span><span class="s1">'+ -'</span><span class="p">),</span> <span class="mi">2</span><span class="p">,</span> <span class="n">OpAssoc</span><span class="o">.</span><span class="n">LEFT</span><span class="p">),</span> <span class="p">])</span> <span class="n">arith_expr</span><span class="o">.</span><span class="n">run_tests</span><span class="p">(</span><span class="s1">'''</span> <span class="s1"> 5+3*6</span> <span class="s1"> (5+3)*6</span> <span class="s1"> -2--11</span> <span class="s1"> '''</span><span class="p">,</span> <span class="n">full_dump</span><span class="o">=</span><span class="kc">False</span><span class="p">)</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">5</span><span class="o">+</span><span class="mi">3</span><span class="o">*</span><span class="mi">6</span> <span class="p">[[</span><span class="mi">5</span><span class="p">,</span> <span class="s1">'+'</span><span class="p">,</span> <span class="p">[</span><span class="mi">3</span><span class="p">,</span> <span class="s1">'*'</span><span class="p">,</span> <span class="mi">6</span><span class="p">]]]</span> <span class="p">(</span><span class="mi">5</span><span class="o">+</span><span class="mi">3</span><span class="p">)</span><span class="o">*</span><span class="mi">6</span> <span class="p">[[[</span><span class="mi">5</span><span class="p">,</span> <span class="s1">'+'</span><span class="p">,</span> <span class="mi">3</span><span class="p">],</span> <span class="s1">'*'</span><span class="p">,</span> <span class="mi">6</span><span class="p">]]</span> <span class="o">-</span><span class="mi">2</span><span class="o">--</span><span class="mi">11</span> <span class="p">[[[</span><span class="s1">'-'</span><span class="p">,</span> <span class="mi">2</span><span class="p">],</span> <span class="s1">'-'</span><span class="p">,</span> <span class="p">[</span><span class="s1">'-'</span><span class="p">,</span> <span class="mi">11</span><span class="p">]]]</span> </pre></div> </div> </dd></dl> <dl class="function"> <dt id="pyparsing.locatedExpr"> <code class="descclassname">pyparsing.</code><code class="descname">locatedExpr</code><span class="sig-paren">(</span><em>expr: pyparsing.core.ParserElement</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.locatedExpr" title="Permalink to this definition">¶</a></dt> <dd><p>(DEPRECATED - future code should use the Located class) Helper to decorate a returned token with its starting and ending locations in the input string.</p> <p>This helper adds the following results names:</p> <ul class="simple"> <li><code class="docutils literal notranslate"><span class="pre">locn_start</span></code> - location where matched expression begins</li> <li><code class="docutils literal notranslate"><span class="pre">locn_end</span></code> - location where matched expression ends</li> <li><code class="docutils literal notranslate"><span class="pre">value</span></code> - the actual parsed results</li> </ul> <p>Be careful if the input text contains <code class="docutils literal notranslate"><span class="pre"><TAB></span></code> characters, you may want to call <a class="reference internal" href="#pyparsing.ParserElement.parseWithTabs" title="pyparsing.ParserElement.parseWithTabs"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement.parseWithTabs</span></code></a></p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">wd</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)</span> <span class="k">for</span> <span class="n">match</span> <span class="ow">in</span> <span class="n">locatedExpr</span><span class="p">(</span><span class="n">wd</span><span class="p">)</span><span class="o">.</span><span class="n">searchString</span><span class="p">(</span><span class="s2">"ljsdf123lksdjjf123lkkjj1222"</span><span class="p">):</span> <span class="nb">print</span><span class="p">(</span><span class="n">match</span><span class="p">)</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[[</span><span class="mi">0</span><span class="p">,</span> <span class="s1">'ljsdf'</span><span class="p">,</span> <span class="mi">5</span><span class="p">]]</span> <span class="p">[[</span><span class="mi">8</span><span class="p">,</span> <span class="s1">'lksdjjf'</span><span class="p">,</span> <span class="mi">15</span><span class="p">]]</span> <span class="p">[[</span><span class="mi">18</span><span class="p">,</span> <span class="s1">'lkkjj'</span><span class="p">,</span> <span class="mi">23</span><span class="p">]]</span> </pre></div> </div> </dd></dl> <dl class="function"> <dt id="pyparsing.with_class"> <code class="descclassname">pyparsing.</code><code class="descname">with_class</code><span class="sig-paren">(</span><em>classname</em>, <em>namespace=''</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.with_class" title="Permalink to this definition">¶</a></dt> <dd><p>Simplified version of <a class="reference internal" href="#pyparsing.with_attribute" title="pyparsing.with_attribute"><code class="xref py py-class docutils literal notranslate"><span class="pre">with_attribute</span></code></a> when matching on a div class - made difficult because <code class="docutils literal notranslate"><span class="pre">class</span></code> is a reserved word in Python.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">html</span> <span class="o">=</span> <span class="s1">'''</span> <span class="s1"> <div></span> <span class="s1"> Some text</span> <span class="s1"> <div class="grid">1 4 0 1 0</div></span> <span class="s1"> <div class="graph">1,3 2,3 1,1</div></span> <span class="s1"> <div>this &lt;div&gt; has no class</div></span> <span class="s1"> </div></span> <span class="s1">'''</span> <span class="n">div</span><span class="p">,</span><span class="n">div_end</span> <span class="o">=</span> <span class="n">make_html_tags</span><span class="p">(</span><span class="s2">"div"</span><span class="p">)</span> <span class="n">div_grid</span> <span class="o">=</span> <span class="n">div</span><span class="p">()</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="n">with_class</span><span class="p">(</span><span class="s2">"grid"</span><span class="p">))</span> <span class="n">grid_expr</span> <span class="o">=</span> <span class="n">div_grid</span> <span class="o">+</span> <span class="n">SkipTo</span><span class="p">(</span><span class="n">div</span> <span class="o">|</span> <span class="n">div_end</span><span class="p">)(</span><span class="s2">"body"</span><span class="p">)</span> <span class="k">for</span> <span class="n">grid_header</span> <span class="ow">in</span> <span class="n">grid_expr</span><span class="o">.</span><span class="n">search_string</span><span class="p">(</span><span class="n">html</span><span class="p">):</span> <span class="nb">print</span><span class="p">(</span><span class="n">grid_header</span><span class="o">.</span><span class="n">body</span><span class="p">)</span> <span class="n">div_any_type</span> <span class="o">=</span> <span class="n">div</span><span class="p">()</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="n">with_class</span><span class="p">(</span><span class="n">withAttribute</span><span class="o">.</span><span class="n">ANY_VALUE</span><span class="p">))</span> <span class="n">div_expr</span> <span class="o">=</span> <span class="n">div_any_type</span> <span class="o">+</span> <span class="n">SkipTo</span><span class="p">(</span><span class="n">div</span> <span class="o">|</span> <span class="n">div_end</span><span class="p">)(</span><span class="s2">"body"</span><span class="p">)</span> <span class="k">for</span> <span class="n">div_header</span> <span class="ow">in</span> <span class="n">div_expr</span><span class="o">.</span><span class="n">search_string</span><span class="p">(</span><span class="n">html</span><span class="p">):</span> <span class="nb">print</span><span class="p">(</span><span class="n">div_header</span><span class="o">.</span><span class="n">body</span><span class="p">)</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">1</span> <span class="mi">4</span> <span class="mi">0</span> <span class="mi">1</span> <span class="mi">0</span> <span class="mi">1</span> <span class="mi">4</span> <span class="mi">0</span> <span class="mi">1</span> <span class="mi">0</span> <span class="mi">1</span><span class="p">,</span><span class="mi">3</span> <span class="mi">2</span><span class="p">,</span><span class="mi">3</span> <span class="mi">1</span><span class="p">,</span><span class="mi">1</span> </pre></div> </div> </dd></dl> <dl class="class"> <dt id="pyparsing.CloseMatch"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">CloseMatch</code><span class="sig-paren">(</span><em>match_string: str</em>, <em>max_mismatches: int = None</em>, <em>*</em>, <em>maxMismatches: int = 1</em>, <em>caseless=False</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.CloseMatch" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.core.Token</span></code></p> <p>A variation on <a class="reference internal" href="#pyparsing.Literal" title="pyparsing.Literal"><code class="xref py py-class docutils literal notranslate"><span class="pre">Literal</span></code></a> which matches “close” matches, that is, strings with at most ‘n’ mismatching characters. <a class="reference internal" href="#pyparsing.CloseMatch" title="pyparsing.CloseMatch"><code class="xref py py-class docutils literal notranslate"><span class="pre">CloseMatch</span></code></a> takes parameters:</p> <ul class="simple"> <li><code class="docutils literal notranslate"><span class="pre">match_string</span></code> - string to be matched</li> <li><code class="docutils literal notranslate"><span class="pre">caseless</span></code> - a boolean indicating whether to ignore casing when comparing characters</li> <li><code class="docutils literal notranslate"><span class="pre">max_mismatches</span></code> - (<code class="docutils literal notranslate"><span class="pre">default=1</span></code>) maximum number of mismatches allowed to count as a match</li> </ul> <p>The results from a successful parse will contain the matched text from the input string and the following named results:</p> <ul class="simple"> <li><code class="docutils literal notranslate"><span class="pre">mismatches</span></code> - a list of the positions within the match_string where mismatches were found</li> <li><code class="docutils literal notranslate"><span class="pre">original</span></code> - the original match_string used to compare against the input string</li> </ul> <p>If <code class="docutils literal notranslate"><span class="pre">mismatches</span></code> is an empty list, then the match was an exact match.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">patt</span> <span class="o">=</span> <span class="n">CloseMatch</span><span class="p">(</span><span class="s2">"ATCATCGAATGGA"</span><span class="p">)</span> <span class="n">patt</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"ATCATCGAAXGGA"</span><span class="p">)</span> <span class="c1"># -> (['ATCATCGAAXGGA'], {'mismatches': [[9]], 'original': ['ATCATCGAATGGA']})</span> <span class="n">patt</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"ATCAXCGAAXGGA"</span><span class="p">)</span> <span class="c1"># -> Exception: Expected 'ATCATCGAATGGA' (with up to 1 mismatches) (at char 0), (line:1, col:1)</span> <span class="c1"># exact match</span> <span class="n">patt</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"ATCATCGAATGGA"</span><span class="p">)</span> <span class="c1"># -> (['ATCATCGAATGGA'], {'mismatches': [[]], 'original': ['ATCATCGAATGGA']})</span> <span class="c1"># close match allowing up to 2 mismatches</span> <span class="n">patt</span> <span class="o">=</span> <span class="n">CloseMatch</span><span class="p">(</span><span class="s2">"ATCATCGAATGGA"</span><span class="p">,</span> <span class="n">max_mismatches</span><span class="o">=</span><span class="mi">2</span><span class="p">)</span> <span class="n">patt</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"ATCAXCGAAXGGA"</span><span class="p">)</span> <span class="c1"># -> (['ATCAXCGAAXGGA'], {'mismatches': [[4, 9]], 'original': ['ATCATCGAATGGA']})</span> </pre></div> </div> <dl class="method"> <dt id="pyparsing.CloseMatch.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>match_string: str</em>, <em>max_mismatches: int = None</em>, <em>*</em>, <em>maxMismatches: int = 1</em>, <em>caseless=False</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.CloseMatch.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> </dd></dl> <dl class="function"> <dt id="pyparsing.token_map"> <code class="descclassname">pyparsing.</code><code class="descname">token_map</code><span class="sig-paren">(</span><em>func</em>, <em>*args</em><span class="sig-paren">)</span> → Union[typing.Callable[[], typing.Any], typing.Callable[[pyparsing.results.ParseResults], typing.Any], typing.Callable[[int, pyparsing.results.ParseResults], typing.Any], typing.Callable[[str, int, pyparsing.results.ParseResults], typing.Any]]<a class="headerlink" href="#pyparsing.token_map" title="Permalink to this definition">¶</a></dt> <dd><p>Helper to define a parse action by mapping a function to all elements of a <a class="reference internal" href="#pyparsing.ParseResults" title="pyparsing.ParseResults"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParseResults</span></code></a> list. If any additional args are passed, they are forwarded to the given function as additional arguments after the token, as in <code class="docutils literal notranslate"><span class="pre">hex_integer</span> <span class="pre">=</span> <span class="pre">Word(hexnums).set_parse_action(token_map(int,</span> <span class="pre">16))</span></code>, which will convert the parsed data to an integer using base 16.</p> <p>Example (compare the last to example in <a class="reference internal" href="#pyparsing.ParserElement.transform_string" title="pyparsing.ParserElement.transform_string"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement.transform_string</span></code></a>:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">hex_ints</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">hexnums</span><span class="p">)[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="n">token_map</span><span class="p">(</span><span class="nb">int</span><span class="p">,</span> <span class="mi">16</span><span class="p">))</span> <span class="n">hex_ints</span><span class="o">.</span><span class="n">run_tests</span><span class="p">(</span><span class="s1">'''</span> <span class="s1"> 00 11 22 aa FF 0a 0d 1a</span> <span class="s1"> '''</span><span class="p">)</span> <span class="n">upperword</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="n">token_map</span><span class="p">(</span><span class="nb">str</span><span class="o">.</span><span class="n">upper</span><span class="p">))</span> <span class="n">upperword</span><span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span><span class="o">.</span><span class="n">run_tests</span><span class="p">(</span><span class="s1">'''</span> <span class="s1"> my kingdom for a horse</span> <span class="s1"> '''</span><span class="p">)</span> <span class="n">wd</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="n">token_map</span><span class="p">(</span><span class="nb">str</span><span class="o">.</span><span class="n">title</span><span class="p">))</span> <span class="n">wd</span><span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="s1">' '</span><span class="o">.</span><span class="n">join</span><span class="p">)</span><span class="o">.</span><span class="n">run_tests</span><span class="p">(</span><span class="s1">'''</span> <span class="s1"> now is the winter of our discontent made glorious summer by this sun of york</span> <span class="s1"> '''</span><span class="p">)</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">00</span> <span class="mi">11</span> <span class="mi">22</span> <span class="n">aa</span> <span class="n">FF</span> <span class="mi">0</span><span class="n">a</span> <span class="mi">0</span><span class="n">d</span> <span class="mi">1</span><span class="n">a</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">17</span><span class="p">,</span> <span class="mi">34</span><span class="p">,</span> <span class="mi">170</span><span class="p">,</span> <span class="mi">255</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="mi">13</span><span class="p">,</span> <span class="mi">26</span><span class="p">]</span> <span class="n">my</span> <span class="n">kingdom</span> <span class="k">for</span> <span class="n">a</span> <span class="n">horse</span> <span class="p">[</span><span class="s1">'MY'</span><span class="p">,</span> <span class="s1">'KINGDOM'</span><span class="p">,</span> <span class="s1">'FOR'</span><span class="p">,</span> <span class="s1">'A'</span><span class="p">,</span> <span class="s1">'HORSE'</span><span class="p">]</span> <span class="n">now</span> <span class="ow">is</span> <span class="n">the</span> <span class="n">winter</span> <span class="n">of</span> <span class="n">our</span> <span class="n">discontent</span> <span class="n">made</span> <span class="n">glorious</span> <span class="n">summer</span> <span class="n">by</span> <span class="n">this</span> <span class="n">sun</span> <span class="n">of</span> <span class="n">york</span> <span class="p">[</span><span class="s1">'Now Is The Winter Of Our Discontent Made Glorious Summer By This Sun Of York'</span><span class="p">]</span> </pre></div> </div> </dd></dl> <dl class="class"> <dt id="pyparsing.pyparsing_common"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">pyparsing_common</code><a class="headerlink" href="#pyparsing.pyparsing_common" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">object</span></code></p> <p>Here are some common low-level expressions that may be useful in jump-starting parser development:</p> <ul class="simple"> <li>numeric forms (<a class="reference internal" href="#pyparsing.pyparsing_common.integer" title="pyparsing.pyparsing_common.integer"><code class="xref py py-class docutils literal notranslate"><span class="pre">integers</span></code></a>, <a class="reference internal" href="#pyparsing.pyparsing_common.real" title="pyparsing.pyparsing_common.real"><code class="xref py py-class docutils literal notranslate"><span class="pre">reals</span></code></a>, <a class="reference internal" href="#pyparsing.pyparsing_common.sci_real" title="pyparsing.pyparsing_common.sci_real"><code class="xref py py-class docutils literal notranslate"><span class="pre">scientific</span> <span class="pre">notation</span></code></a>)</li> <li>common <a class="reference internal" href="#pyparsing.pyparsing_common.identifier" title="pyparsing.pyparsing_common.identifier"><code class="xref py py-class docutils literal notranslate"><span class="pre">programming</span> <span class="pre">identifiers</span></code></a></li> <li>network addresses (<a class="reference internal" href="#pyparsing.pyparsing_common.mac_address" title="pyparsing.pyparsing_common.mac_address"><code class="xref py py-class docutils literal notranslate"><span class="pre">MAC</span></code></a>, <a class="reference internal" href="#pyparsing.pyparsing_common.ipv4_address" title="pyparsing.pyparsing_common.ipv4_address"><code class="xref py py-class docutils literal notranslate"><span class="pre">IPv4</span></code></a>, <a class="reference internal" href="#pyparsing.pyparsing_common.ipv6_address" title="pyparsing.pyparsing_common.ipv6_address"><code class="xref py py-class docutils literal notranslate"><span class="pre">IPv6</span></code></a>)</li> <li>ISO8601 <a class="reference internal" href="#pyparsing.pyparsing_common.iso8601_date" title="pyparsing.pyparsing_common.iso8601_date"><code class="xref py py-class docutils literal notranslate"><span class="pre">dates</span></code></a> and <a class="reference internal" href="#pyparsing.pyparsing_common.iso8601_datetime" title="pyparsing.pyparsing_common.iso8601_datetime"><code class="xref py py-class docutils literal notranslate"><span class="pre">datetime</span></code></a></li> <li><a class="reference internal" href="#pyparsing.pyparsing_common.uuid" title="pyparsing.pyparsing_common.uuid"><code class="xref py py-class docutils literal notranslate"><span class="pre">UUID</span></code></a></li> <li><a class="reference internal" href="#pyparsing.pyparsing_common.comma_separated_list" title="pyparsing.pyparsing_common.comma_separated_list"><code class="xref py py-class docutils literal notranslate"><span class="pre">comma-separated</span> <span class="pre">list</span></code></a></li> <li><code class="xref py py-class docutils literal notranslate"><span class="pre">url</span></code></li> </ul> <p>Parse actions:</p> <ul class="simple"> <li><code class="xref py py-class docutils literal notranslate"><span class="pre">convertToInteger</span></code></li> <li><code class="xref py py-class docutils literal notranslate"><span class="pre">convertToFloat</span></code></li> <li><a class="reference internal" href="#pyparsing.pyparsing_common.convertToDate" title="pyparsing.pyparsing_common.convertToDate"><code class="xref py py-class docutils literal notranslate"><span class="pre">convertToDate</span></code></a></li> <li><a class="reference internal" href="#pyparsing.pyparsing_common.convertToDatetime" title="pyparsing.pyparsing_common.convertToDatetime"><code class="xref py py-class docutils literal notranslate"><span class="pre">convertToDatetime</span></code></a></li> <li><a class="reference internal" href="#pyparsing.pyparsing_common.stripHTMLTags" title="pyparsing.pyparsing_common.stripHTMLTags"><code class="xref py py-class docutils literal notranslate"><span class="pre">stripHTMLTags</span></code></a></li> <li><code class="xref py py-class docutils literal notranslate"><span class="pre">upcaseTokens</span></code></li> <li><code class="xref py py-class docutils literal notranslate"><span class="pre">downcaseTokens</span></code></li> </ul> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">pyparsing_common</span><span class="o">.</span><span class="n">number</span><span class="o">.</span><span class="n">runTests</span><span class="p">(</span><span class="s1">'''</span> <span class="s1"> # any int or real number, returned as the appropriate type</span> <span class="s1"> 100</span> <span class="s1"> -100</span> <span class="s1"> +100</span> <span class="s1"> 3.14159</span> <span class="s1"> 6.02e23</span> <span class="s1"> 1e-12</span> <span class="s1"> '''</span><span class="p">)</span> <span class="n">pyparsing_common</span><span class="o">.</span><span class="n">fnumber</span><span class="o">.</span><span class="n">runTests</span><span class="p">(</span><span class="s1">'''</span> <span class="s1"> # any int or real number, returned as float</span> <span class="s1"> 100</span> <span class="s1"> -100</span> <span class="s1"> +100</span> <span class="s1"> 3.14159</span> <span class="s1"> 6.02e23</span> <span class="s1"> 1e-12</span> <span class="s1"> '''</span><span class="p">)</span> <span class="n">pyparsing_common</span><span class="o">.</span><span class="n">hex_integer</span><span class="o">.</span><span class="n">runTests</span><span class="p">(</span><span class="s1">'''</span> <span class="s1"> # hex numbers</span> <span class="s1"> 100</span> <span class="s1"> FF</span> <span class="s1"> '''</span><span class="p">)</span> <span class="n">pyparsing_common</span><span class="o">.</span><span class="n">fraction</span><span class="o">.</span><span class="n">runTests</span><span class="p">(</span><span class="s1">'''</span> <span class="s1"> # fractions</span> <span class="s1"> 1/2</span> <span class="s1"> -3/4</span> <span class="s1"> '''</span><span class="p">)</span> <span class="n">pyparsing_common</span><span class="o">.</span><span class="n">mixed_integer</span><span class="o">.</span><span class="n">runTests</span><span class="p">(</span><span class="s1">'''</span> <span class="s1"> # mixed fractions</span> <span class="s1"> 1</span> <span class="s1"> 1/2</span> <span class="s1"> -3/4</span> <span class="s1"> 1-3/4</span> <span class="s1"> '''</span><span class="p">)</span> <span class="kn">import</span> <span class="nn">uuid</span> <span class="n">pyparsing_common</span><span class="o">.</span><span class="n">uuid</span><span class="o">.</span><span class="n">setParseAction</span><span class="p">(</span><span class="n">tokenMap</span><span class="p">(</span><span class="n">uuid</span><span class="o">.</span><span class="n">UUID</span><span class="p">))</span> <span class="n">pyparsing_common</span><span class="o">.</span><span class="n">uuid</span><span class="o">.</span><span class="n">runTests</span><span class="p">(</span><span class="s1">'''</span> <span class="s1"> # uuid</span> <span class="s1"> 12345678-1234-5678-1234-567812345678</span> <span class="s1"> '''</span><span class="p">)</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># any int or real number, returned as the appropriate type</span> <span class="mi">100</span> <span class="p">[</span><span class="mi">100</span><span class="p">]</span> <span class="o">-</span><span class="mi">100</span> <span class="p">[</span><span class="o">-</span><span class="mi">100</span><span class="p">]</span> <span class="o">+</span><span class="mi">100</span> <span class="p">[</span><span class="mi">100</span><span class="p">]</span> <span class="mf">3.14159</span> <span class="p">[</span><span class="mf">3.14159</span><span class="p">]</span> <span class="mf">6.02e23</span> <span class="p">[</span><span class="mf">6.02e+23</span><span class="p">]</span> <span class="mf">1e-12</span> <span class="p">[</span><span class="mf">1e-12</span><span class="p">]</span> <span class="c1"># any int or real number, returned as float</span> <span class="mi">100</span> <span class="p">[</span><span class="mf">100.0</span><span class="p">]</span> <span class="o">-</span><span class="mi">100</span> <span class="p">[</span><span class="o">-</span><span class="mf">100.0</span><span class="p">]</span> <span class="o">+</span><span class="mi">100</span> <span class="p">[</span><span class="mf">100.0</span><span class="p">]</span> <span class="mf">3.14159</span> <span class="p">[</span><span class="mf">3.14159</span><span class="p">]</span> <span class="mf">6.02e23</span> <span class="p">[</span><span class="mf">6.02e+23</span><span class="p">]</span> <span class="mf">1e-12</span> <span class="p">[</span><span class="mf">1e-12</span><span class="p">]</span> <span class="c1"># hex numbers</span> <span class="mi">100</span> <span class="p">[</span><span class="mi">256</span><span class="p">]</span> <span class="n">FF</span> <span class="p">[</span><span class="mi">255</span><span class="p">]</span> <span class="c1"># fractions</span> <span class="mi">1</span><span class="o">/</span><span class="mi">2</span> <span class="p">[</span><span class="mf">0.5</span><span class="p">]</span> <span class="o">-</span><span class="mi">3</span><span class="o">/</span><span class="mi">4</span> <span class="p">[</span><span class="o">-</span><span class="mf">0.75</span><span class="p">]</span> <span class="c1"># mixed fractions</span> <span class="mi">1</span> <span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="mi">1</span><span class="o">/</span><span class="mi">2</span> <span class="p">[</span><span class="mf">0.5</span><span class="p">]</span> <span class="o">-</span><span class="mi">3</span><span class="o">/</span><span class="mi">4</span> <span class="p">[</span><span class="o">-</span><span class="mf">0.75</span><span class="p">]</span> <span class="mi">1</span><span class="o">-</span><span class="mi">3</span><span class="o">/</span><span class="mi">4</span> <span class="p">[</span><span class="mf">1.75</span><span class="p">]</span> <span class="c1"># uuid</span> <span class="mi">12345678</span><span class="o">-</span><span class="mi">1234</span><span class="o">-</span><span class="mi">5678</span><span class="o">-</span><span class="mi">1234</span><span class="o">-</span><span class="mi">567812345678</span> <span class="p">[</span><span class="n">UUID</span><span class="p">(</span><span class="s1">'12345678-1234-5678-1234-567812345678'</span><span class="p">)]</span> </pre></div> </div> <dl class="attribute"> <dt id="pyparsing.pyparsing_common.__weakref__"> <code class="descname">__weakref__</code><a class="headerlink" href="#pyparsing.pyparsing_common.__weakref__" title="Permalink to this definition">¶</a></dt> <dd><p>list of weak references to the object (if defined)</p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.pyparsing_common.comma_separated_list"> <code class="descname">comma_separated_list</code><em class="property"> = comma separated list</em><a class="headerlink" href="#pyparsing.pyparsing_common.comma_separated_list" title="Permalink to this definition">¶</a></dt> <dd><p>Predefined expression of 1 or more printable words or quoted strings, separated by commas.</p> </dd></dl> <dl class="staticmethod"> <dt id="pyparsing.pyparsing_common.convertToDate"> <em class="property">static </em><code class="descname">convertToDate</code><span class="sig-paren">(</span><em>fmt: str = '%Y-%m-%d'</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.pyparsing_common.convertToDate" title="Permalink to this definition">¶</a></dt> <dd><p>Helper to create a parse action for converting parsed date string to Python datetime.date</p> <p>Params - - fmt - format to be passed to datetime.strptime (default= <code class="docutils literal notranslate"><span class="pre">"%Y-%m-%d"</span></code>)</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">date_expr</span> <span class="o">=</span> <span class="n">pyparsing_common</span><span class="o">.</span><span class="n">iso8601_date</span><span class="o">.</span><span class="n">copy</span><span class="p">()</span> <span class="n">date_expr</span><span class="o">.</span><span class="n">setParseAction</span><span class="p">(</span><span class="n">pyparsing_common</span><span class="o">.</span><span class="n">convertToDate</span><span class="p">())</span> <span class="nb">print</span><span class="p">(</span><span class="n">date_expr</span><span class="o">.</span><span class="n">parseString</span><span class="p">(</span><span class="s2">"1999-12-31"</span><span class="p">))</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">datetime</span><span class="o">.</span><span class="n">date</span><span class="p">(</span><span class="mi">1999</span><span class="p">,</span> <span class="mi">12</span><span class="p">,</span> <span class="mi">31</span><span class="p">)]</span> </pre></div> </div> </dd></dl> <dl class="staticmethod"> <dt id="pyparsing.pyparsing_common.convertToDatetime"> <em class="property">static </em><code class="descname">convertToDatetime</code><span class="sig-paren">(</span><em>fmt: str = '%Y-%m-%dT%H:%M:%S.%f'</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.pyparsing_common.convertToDatetime" title="Permalink to this definition">¶</a></dt> <dd><p>Helper to create a parse action for converting parsed datetime string to Python datetime.datetime</p> <p>Params - - fmt - format to be passed to datetime.strptime (default= <code class="docutils literal notranslate"><span class="pre">"%Y-%m-%dT%H:%M:%S.%f"</span></code>)</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">dt_expr</span> <span class="o">=</span> <span class="n">pyparsing_common</span><span class="o">.</span><span class="n">iso8601_datetime</span><span class="o">.</span><span class="n">copy</span><span class="p">()</span> <span class="n">dt_expr</span><span class="o">.</span><span class="n">setParseAction</span><span class="p">(</span><span class="n">pyparsing_common</span><span class="o">.</span><span class="n">convertToDatetime</span><span class="p">())</span> <span class="nb">print</span><span class="p">(</span><span class="n">dt_expr</span><span class="o">.</span><span class="n">parseString</span><span class="p">(</span><span class="s2">"1999-12-31T23:59:59.999"</span><span class="p">))</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">datetime</span><span class="o">.</span><span class="n">datetime</span><span class="p">(</span><span class="mi">1999</span><span class="p">,</span> <span class="mi">12</span><span class="p">,</span> <span class="mi">31</span><span class="p">,</span> <span class="mi">23</span><span class="p">,</span> <span class="mi">59</span><span class="p">,</span> <span class="mi">59</span><span class="p">,</span> <span class="mi">999000</span><span class="p">)]</span> </pre></div> </div> </dd></dl> <dl class="staticmethod"> <dt id="pyparsing.pyparsing_common.convert_to_date"> <em class="property">static </em><code class="descname">convert_to_date</code><span class="sig-paren">(</span><em>fmt: str = '%Y-%m-%d'</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.pyparsing_common.convert_to_date" title="Permalink to this definition">¶</a></dt> <dd><p>Helper to create a parse action for converting parsed date string to Python datetime.date</p> <p>Params - - fmt - format to be passed to datetime.strptime (default= <code class="docutils literal notranslate"><span class="pre">"%Y-%m-%d"</span></code>)</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">date_expr</span> <span class="o">=</span> <span class="n">pyparsing_common</span><span class="o">.</span><span class="n">iso8601_date</span><span class="o">.</span><span class="n">copy</span><span class="p">()</span> <span class="n">date_expr</span><span class="o">.</span><span class="n">setParseAction</span><span class="p">(</span><span class="n">pyparsing_common</span><span class="o">.</span><span class="n">convertToDate</span><span class="p">())</span> <span class="nb">print</span><span class="p">(</span><span class="n">date_expr</span><span class="o">.</span><span class="n">parseString</span><span class="p">(</span><span class="s2">"1999-12-31"</span><span class="p">))</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">datetime</span><span class="o">.</span><span class="n">date</span><span class="p">(</span><span class="mi">1999</span><span class="p">,</span> <span class="mi">12</span><span class="p">,</span> <span class="mi">31</span><span class="p">)]</span> </pre></div> </div> </dd></dl> <dl class="staticmethod"> <dt id="pyparsing.pyparsing_common.convert_to_datetime"> <em class="property">static </em><code class="descname">convert_to_datetime</code><span class="sig-paren">(</span><em>fmt: str = '%Y-%m-%dT%H:%M:%S.%f'</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.pyparsing_common.convert_to_datetime" title="Permalink to this definition">¶</a></dt> <dd><p>Helper to create a parse action for converting parsed datetime string to Python datetime.datetime</p> <p>Params - - fmt - format to be passed to datetime.strptime (default= <code class="docutils literal notranslate"><span class="pre">"%Y-%m-%dT%H:%M:%S.%f"</span></code>)</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">dt_expr</span> <span class="o">=</span> <span class="n">pyparsing_common</span><span class="o">.</span><span class="n">iso8601_datetime</span><span class="o">.</span><span class="n">copy</span><span class="p">()</span> <span class="n">dt_expr</span><span class="o">.</span><span class="n">setParseAction</span><span class="p">(</span><span class="n">pyparsing_common</span><span class="o">.</span><span class="n">convertToDatetime</span><span class="p">())</span> <span class="nb">print</span><span class="p">(</span><span class="n">dt_expr</span><span class="o">.</span><span class="n">parseString</span><span class="p">(</span><span class="s2">"1999-12-31T23:59:59.999"</span><span class="p">))</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">datetime</span><span class="o">.</span><span class="n">datetime</span><span class="p">(</span><span class="mi">1999</span><span class="p">,</span> <span class="mi">12</span><span class="p">,</span> <span class="mi">31</span><span class="p">,</span> <span class="mi">23</span><span class="p">,</span> <span class="mi">59</span><span class="p">,</span> <span class="mi">59</span><span class="p">,</span> <span class="mi">999000</span><span class="p">)]</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="pyparsing.pyparsing_common.convert_to_float"> <code class="descname">convert_to_float</code><span class="sig-paren">(</span><em>l</em>, <em>t</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.pyparsing_common.convert_to_float" title="Permalink to this definition">¶</a></dt> <dd><p>Parse action for converting parsed numbers to Python float</p> </dd></dl> <dl class="method"> <dt id="pyparsing.pyparsing_common.convert_to_integer"> <code class="descname">convert_to_integer</code><span class="sig-paren">(</span><em>l</em>, <em>t</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.pyparsing_common.convert_to_integer" title="Permalink to this definition">¶</a></dt> <dd><p>Parse action for converting parsed integers to Python int</p> </dd></dl> <dl class="staticmethod"> <dt id="pyparsing.pyparsing_common.downcase_tokens"> <em class="property">static </em><code class="descname">downcase_tokens</code><span class="sig-paren">(</span><em>s</em>, <em>l</em>, <em>t</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.pyparsing_common.downcase_tokens" title="Permalink to this definition">¶</a></dt> <dd><p>Parse action to convert tokens to lower case.</p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.pyparsing_common.fnumber"> <code class="descname">fnumber</code><em class="property"> = fnumber</em><a class="headerlink" href="#pyparsing.pyparsing_common.fnumber" title="Permalink to this definition">¶</a></dt> <dd><p>any int or real number, returned as float</p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.pyparsing_common.fraction"> <code class="descname">fraction</code><em class="property"> = fraction</em><a class="headerlink" href="#pyparsing.pyparsing_common.fraction" title="Permalink to this definition">¶</a></dt> <dd><p>fractional expression of an integer divided by an integer, returns a float</p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.pyparsing_common.hex_integer"> <code class="descname">hex_integer</code><em class="property"> = hex integer</em><a class="headerlink" href="#pyparsing.pyparsing_common.hex_integer" title="Permalink to this definition">¶</a></dt> <dd><p>expression that parses a hexadecimal integer, returns an int</p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.pyparsing_common.identifier"> <code class="descname">identifier</code><em class="property"> = identifier</em><a class="headerlink" href="#pyparsing.pyparsing_common.identifier" title="Permalink to this definition">¶</a></dt> <dd><p>typical code identifier (leading alpha or ‘_’, followed by 0 or more alphas, nums, or ‘_’)</p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.pyparsing_common.integer"> <code class="descname">integer</code><em class="property"> = integer</em><a class="headerlink" href="#pyparsing.pyparsing_common.integer" title="Permalink to this definition">¶</a></dt> <dd><p>expression that parses an unsigned integer, returns an int</p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.pyparsing_common.ipv4_address"> <code class="descname">ipv4_address</code><em class="property"> = IPv4 address</em><a class="headerlink" href="#pyparsing.pyparsing_common.ipv4_address" title="Permalink to this definition">¶</a></dt> <dd><p>IPv4 address (<code class="docutils literal notranslate"><span class="pre">0.0.0.0</span> <span class="pre">-</span> <span class="pre">255.255.255.255</span></code>)</p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.pyparsing_common.ipv6_address"> <code class="descname">ipv6_address</code><em class="property"> = IPv6 address</em><a class="headerlink" href="#pyparsing.pyparsing_common.ipv6_address" title="Permalink to this definition">¶</a></dt> <dd><p>IPv6 address (long, short, or mixed form)</p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.pyparsing_common.iso8601_date"> <code class="descname">iso8601_date</code><em class="property"> = ISO8601 date</em><a class="headerlink" href="#pyparsing.pyparsing_common.iso8601_date" title="Permalink to this definition">¶</a></dt> <dd><p>ISO8601 date (<code class="docutils literal notranslate"><span class="pre">yyyy-mm-dd</span></code>)</p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.pyparsing_common.iso8601_datetime"> <code class="descname">iso8601_datetime</code><em class="property"> = ISO8601 datetime</em><a class="headerlink" href="#pyparsing.pyparsing_common.iso8601_datetime" title="Permalink to this definition">¶</a></dt> <dd><p>ISO8601 datetime (<code class="docutils literal notranslate"><span class="pre">yyyy-mm-ddThh:mm:ss.s(Z|+-00:00)</span></code>) - trailing seconds, milliseconds, and timezone optional; accepts separating <code class="docutils literal notranslate"><span class="pre">'T'</span></code> or <code class="docutils literal notranslate"><span class="pre">'</span> <span class="pre">'</span></code></p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.pyparsing_common.mac_address"> <code class="descname">mac_address</code><em class="property"> = MAC address</em><a class="headerlink" href="#pyparsing.pyparsing_common.mac_address" title="Permalink to this definition">¶</a></dt> <dd><p>MAC address xx:xx:xx:xx:xx (may also have ‘-‘ or ‘.’ delimiters)</p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.pyparsing_common.mixed_integer"> <code class="descname">mixed_integer</code><em class="property"> = fraction or mixed integer-fraction</em><a class="headerlink" href="#pyparsing.pyparsing_common.mixed_integer" title="Permalink to this definition">¶</a></dt> <dd><p>mixed integer of the form ‘integer - fraction’, with optional leading integer, returns float</p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.pyparsing_common.number"> <code class="descname">number</code><em class="property"> = number</em><a class="headerlink" href="#pyparsing.pyparsing_common.number" title="Permalink to this definition">¶</a></dt> <dd><p>any numeric expression, returns the corresponding Python type</p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.pyparsing_common.real"> <code class="descname">real</code><em class="property"> = real number</em><a class="headerlink" href="#pyparsing.pyparsing_common.real" title="Permalink to this definition">¶</a></dt> <dd><p>expression that parses a floating point number and returns a float</p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.pyparsing_common.sci_real"> <code class="descname">sci_real</code><em class="property"> = real number with scientific notation</em><a class="headerlink" href="#pyparsing.pyparsing_common.sci_real" title="Permalink to this definition">¶</a></dt> <dd><p>expression that parses a floating point number with optional scientific notation and returns a float</p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.pyparsing_common.signed_integer"> <code class="descname">signed_integer</code><em class="property"> = signed integer</em><a class="headerlink" href="#pyparsing.pyparsing_common.signed_integer" title="Permalink to this definition">¶</a></dt> <dd><p>expression that parses an integer with optional leading sign, returns an int</p> </dd></dl> <dl class="staticmethod"> <dt id="pyparsing.pyparsing_common.stripHTMLTags"> <em class="property">static </em><code class="descname">stripHTMLTags</code><span class="sig-paren">(</span><em>s: str</em>, <em>l: int</em>, <em>tokens: pyparsing.results.ParseResults</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.pyparsing_common.stripHTMLTags" title="Permalink to this definition">¶</a></dt> <dd><p>Parse action to remove HTML tags from web page HTML source</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># strip HTML links from normal text</span> <span class="n">text</span> <span class="o">=</span> <span class="s1">'<td>More info at the <a href="https://github.com/pyparsing/pyparsing/wiki">pyparsing</a> wiki page</td>'</span> <span class="n">td</span><span class="p">,</span> <span class="n">td_end</span> <span class="o">=</span> <span class="n">makeHTMLTags</span><span class="p">(</span><span class="s2">"TD"</span><span class="p">)</span> <span class="n">table_text</span> <span class="o">=</span> <span class="n">td</span> <span class="o">+</span> <span class="n">SkipTo</span><span class="p">(</span><span class="n">td_end</span><span class="p">)</span><span class="o">.</span><span class="n">setParseAction</span><span class="p">(</span><span class="n">pyparsing_common</span><span class="o">.</span><span class="n">stripHTMLTags</span><span class="p">)(</span><span class="s2">"body"</span><span class="p">)</span> <span class="o">+</span> <span class="n">td_end</span> <span class="nb">print</span><span class="p">(</span><span class="n">table_text</span><span class="o">.</span><span class="n">parseString</span><span class="p">(</span><span class="n">text</span><span class="p">)</span><span class="o">.</span><span class="n">body</span><span class="p">)</span> </pre></div> </div> <p>Prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">More</span> <span class="n">info</span> <span class="n">at</span> <span class="n">the</span> <span class="n">pyparsing</span> <span class="n">wiki</span> <span class="n">page</span> </pre></div> </div> </dd></dl> <dl class="staticmethod"> <dt id="pyparsing.pyparsing_common.strip_html_tags"> <em class="property">static </em><code class="descname">strip_html_tags</code><span class="sig-paren">(</span><em>s: str</em>, <em>l: int</em>, <em>tokens: pyparsing.results.ParseResults</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.pyparsing_common.strip_html_tags" title="Permalink to this definition">¶</a></dt> <dd><p>Parse action to remove HTML tags from web page HTML source</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># strip HTML links from normal text</span> <span class="n">text</span> <span class="o">=</span> <span class="s1">'<td>More info at the <a href="https://github.com/pyparsing/pyparsing/wiki">pyparsing</a> wiki page</td>'</span> <span class="n">td</span><span class="p">,</span> <span class="n">td_end</span> <span class="o">=</span> <span class="n">makeHTMLTags</span><span class="p">(</span><span class="s2">"TD"</span><span class="p">)</span> <span class="n">table_text</span> <span class="o">=</span> <span class="n">td</span> <span class="o">+</span> <span class="n">SkipTo</span><span class="p">(</span><span class="n">td_end</span><span class="p">)</span><span class="o">.</span><span class="n">setParseAction</span><span class="p">(</span><span class="n">pyparsing_common</span><span class="o">.</span><span class="n">stripHTMLTags</span><span class="p">)(</span><span class="s2">"body"</span><span class="p">)</span> <span class="o">+</span> <span class="n">td_end</span> <span class="nb">print</span><span class="p">(</span><span class="n">table_text</span><span class="o">.</span><span class="n">parseString</span><span class="p">(</span><span class="n">text</span><span class="p">)</span><span class="o">.</span><span class="n">body</span><span class="p">)</span> </pre></div> </div> <p>Prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">More</span> <span class="n">info</span> <span class="n">at</span> <span class="n">the</span> <span class="n">pyparsing</span> <span class="n">wiki</span> <span class="n">page</span> </pre></div> </div> </dd></dl> <dl class="staticmethod"> <dt id="pyparsing.pyparsing_common.upcase_tokens"> <em class="property">static </em><code class="descname">upcase_tokens</code><span class="sig-paren">(</span><em>s</em>, <em>l</em>, <em>t</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.pyparsing_common.upcase_tokens" title="Permalink to this definition">¶</a></dt> <dd><p>Parse action to convert tokens to upper case.</p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.pyparsing_common.uuid"> <code class="descname">uuid</code><em class="property"> = UUID</em><a class="headerlink" href="#pyparsing.pyparsing_common.uuid" title="Permalink to this definition">¶</a></dt> <dd><p>UUID (<code class="docutils literal notranslate"><span class="pre">xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx</span></code>)</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.pyparsing_unicode"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">pyparsing_unicode</code><a class="headerlink" href="#pyparsing.pyparsing_unicode" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.unicode.unicode_set</span></code></p> <p>A namespace class for defining common language unicode_sets.</p> <dl class="class"> <dt id="pyparsing.pyparsing_unicode.Arabic"> <em class="property">class </em><code class="descname">Arabic</code><a class="headerlink" href="#pyparsing.pyparsing_unicode.Arabic" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.unicode.unicode_set</span></code></p> <p>Unicode set for Arabic Unicode Character Range</p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.pyparsing_unicode.BMP"> <code class="descname">BMP</code><a class="headerlink" href="#pyparsing.pyparsing_unicode.BMP" title="Permalink to this definition">¶</a></dt> <dd><p>alias of <a class="reference internal" href="#pyparsing.pyparsing_unicode.BasicMultilingualPlane" title="pyparsing.pyparsing_unicode.BasicMultilingualPlane"><code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing_unicode.BasicMultilingualPlane</span></code></a></p> </dd></dl> <dl class="class"> <dt id="pyparsing.pyparsing_unicode.BasicMultilingualPlane"> <em class="property">class </em><code class="descname">BasicMultilingualPlane</code><a class="headerlink" href="#pyparsing.pyparsing_unicode.BasicMultilingualPlane" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.unicode.unicode_set</span></code></p> <p>Unicode set for the Basic Multilingual Plane</p> </dd></dl> <dl class="class"> <dt id="pyparsing.pyparsing_unicode.CJK"> <em class="property">class </em><code class="descname">CJK</code><a class="headerlink" href="#pyparsing.pyparsing_unicode.CJK" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.unicode.Chinese</span></code>, <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.unicode.Japanese</span></code>, <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.unicode.Hangul</span></code></p> <p>Unicode set for combined Chinese, Japanese, and Korean (CJK) Unicode Character Range</p> </dd></dl> <dl class="class"> <dt id="pyparsing.pyparsing_unicode.Chinese"> <em class="property">class </em><code class="descname">Chinese</code><a class="headerlink" href="#pyparsing.pyparsing_unicode.Chinese" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.unicode.unicode_set</span></code></p> <p>Unicode set for Chinese Unicode Character Range</p> </dd></dl> <dl class="class"> <dt id="pyparsing.pyparsing_unicode.Cyrillic"> <em class="property">class </em><code class="descname">Cyrillic</code><a class="headerlink" href="#pyparsing.pyparsing_unicode.Cyrillic" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.unicode.unicode_set</span></code></p> <p>Unicode set for Cyrillic Unicode Character Range</p> </dd></dl> <dl class="class"> <dt id="pyparsing.pyparsing_unicode.Devanagari"> <em class="property">class </em><code class="descname">Devanagari</code><a class="headerlink" href="#pyparsing.pyparsing_unicode.Devanagari" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.unicode.unicode_set</span></code></p> <p>Unicode set for Devanagari Unicode Character Range</p> </dd></dl> <dl class="class"> <dt id="pyparsing.pyparsing_unicode.Greek"> <em class="property">class </em><code class="descname">Greek</code><a class="headerlink" href="#pyparsing.pyparsing_unicode.Greek" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.unicode.unicode_set</span></code></p> <p>Unicode set for Greek Unicode Character Ranges</p> </dd></dl> <dl class="class"> <dt id="pyparsing.pyparsing_unicode.Hangul"> <em class="property">class </em><code class="descname">Hangul</code><a class="headerlink" href="#pyparsing.pyparsing_unicode.Hangul" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.unicode.unicode_set</span></code></p> <p>Unicode set for Hangul (Korean) Unicode Character Range</p> </dd></dl> <dl class="class"> <dt id="pyparsing.pyparsing_unicode.Hebrew"> <em class="property">class </em><code class="descname">Hebrew</code><a class="headerlink" href="#pyparsing.pyparsing_unicode.Hebrew" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.unicode.unicode_set</span></code></p> <p>Unicode set for Hebrew Unicode Character Range</p> </dd></dl> <dl class="class"> <dt id="pyparsing.pyparsing_unicode.Japanese"> <em class="property">class </em><code class="descname">Japanese</code><a class="headerlink" href="#pyparsing.pyparsing_unicode.Japanese" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.unicode.unicode_set</span></code></p> <p>Unicode set for Japanese Unicode Character Range, combining Kanji, Hiragana, and Katakana ranges</p> <dl class="class"> <dt id="pyparsing.pyparsing_unicode.Japanese.Hiragana"> <em class="property">class </em><code class="descname">Hiragana</code><a class="headerlink" href="#pyparsing.pyparsing_unicode.Japanese.Hiragana" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.unicode.unicode_set</span></code></p> <p>Unicode set for Hiragana Unicode Character Range</p> </dd></dl> <dl class="class"> <dt id="pyparsing.pyparsing_unicode.Japanese.Kanji"> <em class="property">class </em><code class="descname">Kanji</code><a class="headerlink" href="#pyparsing.pyparsing_unicode.Japanese.Kanji" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.unicode.unicode_set</span></code></p> <p>Unicode set for Kanji Unicode Character Range</p> </dd></dl> <dl class="class"> <dt id="pyparsing.pyparsing_unicode.Japanese.Katakana"> <em class="property">class </em><code class="descname">Katakana</code><a class="headerlink" href="#pyparsing.pyparsing_unicode.Japanese.Katakana" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.unicode.unicode_set</span></code></p> <p>Unicode set for Katakana Unicode Character Range</p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.pyparsing_unicode.Japanese.ひらがな"> <code class="descname">ひらがな</code><a class="headerlink" href="#pyparsing.pyparsing_unicode.Japanese.ひらがな" title="Permalink to this definition">¶</a></dt> <dd><p>alias of <a class="reference internal" href="#pyparsing.pyparsing_unicode.Japanese.Hiragana" title="pyparsing.pyparsing_unicode.Japanese.Hiragana"><code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing_unicode.Japanese.Hiragana</span></code></a></p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.pyparsing_unicode.Japanese.カタカナ"> <code class="descname">カタカナ</code><a class="headerlink" href="#pyparsing.pyparsing_unicode.Japanese.カタカナ" title="Permalink to this definition">¶</a></dt> <dd><p>alias of <a class="reference internal" href="#pyparsing.pyparsing_unicode.Japanese.Katakana" title="pyparsing.pyparsing_unicode.Japanese.Katakana"><code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing_unicode.Japanese.Katakana</span></code></a></p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.pyparsing_unicode.Japanese.漢字"> <code class="descname">漢字</code><a class="headerlink" href="#pyparsing.pyparsing_unicode.Japanese.漢字" title="Permalink to this definition">¶</a></dt> <dd><p>alias of <a class="reference internal" href="#pyparsing.pyparsing_unicode.Japanese.Kanji" title="pyparsing.pyparsing_unicode.Japanese.Kanji"><code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing_unicode.Japanese.Kanji</span></code></a></p> </dd></dl> </dd></dl> <dl class="attribute"> <dt id="pyparsing.pyparsing_unicode.Korean"> <code class="descname">Korean</code><a class="headerlink" href="#pyparsing.pyparsing_unicode.Korean" title="Permalink to this definition">¶</a></dt> <dd><p>alias of <a class="reference internal" href="#pyparsing.pyparsing_unicode.Hangul" title="pyparsing.pyparsing_unicode.Hangul"><code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing_unicode.Hangul</span></code></a></p> </dd></dl> <dl class="class"> <dt id="pyparsing.pyparsing_unicode.Latin1"> <em class="property">class </em><code class="descname">Latin1</code><a class="headerlink" href="#pyparsing.pyparsing_unicode.Latin1" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.unicode.unicode_set</span></code></p> <p>Unicode set for Latin-1 Unicode Character Range</p> </dd></dl> <dl class="class"> <dt id="pyparsing.pyparsing_unicode.LatinA"> <em class="property">class </em><code class="descname">LatinA</code><a class="headerlink" href="#pyparsing.pyparsing_unicode.LatinA" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.unicode.unicode_set</span></code></p> <p>Unicode set for Latin-A Unicode Character Range</p> </dd></dl> <dl class="class"> <dt id="pyparsing.pyparsing_unicode.LatinB"> <em class="property">class </em><code class="descname">LatinB</code><a class="headerlink" href="#pyparsing.pyparsing_unicode.LatinB" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.unicode.unicode_set</span></code></p> <p>Unicode set for Latin-B Unicode Character Range</p> </dd></dl> <dl class="class"> <dt id="pyparsing.pyparsing_unicode.Thai"> <em class="property">class </em><code class="descname">Thai</code><a class="headerlink" href="#pyparsing.pyparsing_unicode.Thai" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.unicode.unicode_set</span></code></p> <p>Unicode set for Thai Unicode Character Range</p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.pyparsing_unicode.Ελληνικά"> <code class="descname">Ελληνικά</code><a class="headerlink" href="#pyparsing.pyparsing_unicode.Ελληνικά" title="Permalink to this definition">¶</a></dt> <dd><p>alias of <a class="reference internal" href="#pyparsing.pyparsing_unicode.Greek" title="pyparsing.pyparsing_unicode.Greek"><code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing_unicode.Greek</span></code></a></p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.pyparsing_unicode.кириллица"> <code class="descname">кириллица</code><a class="headerlink" href="#pyparsing.pyparsing_unicode.кириллица" title="Permalink to this definition">¶</a></dt> <dd><p>alias of <a class="reference internal" href="#pyparsing.pyparsing_unicode.Cyrillic" title="pyparsing.pyparsing_unicode.Cyrillic"><code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing_unicode.Cyrillic</span></code></a></p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.pyparsing_unicode.العربية"> <code class="descname">العربية</code><a class="headerlink" href="#pyparsing.pyparsing_unicode.العربية" title="Permalink to this definition">¶</a></dt> <dd><p>alias of <a class="reference internal" href="#pyparsing.pyparsing_unicode.Arabic" title="pyparsing.pyparsing_unicode.Arabic"><code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing_unicode.Arabic</span></code></a></p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.pyparsing_unicode.ไทย"> <code class="descname">ไทย</code><a class="headerlink" href="#pyparsing.pyparsing_unicode.ไทย" title="Permalink to this definition">¶</a></dt> <dd><p>alias of <a class="reference internal" href="#pyparsing.pyparsing_unicode.Thai" title="pyparsing.pyparsing_unicode.Thai"><code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing_unicode.Thai</span></code></a></p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.pyparsing_unicode.中文"> <code class="descname">中文</code><a class="headerlink" href="#pyparsing.pyparsing_unicode.中文" title="Permalink to this definition">¶</a></dt> <dd><p>alias of <a class="reference internal" href="#pyparsing.pyparsing_unicode.Chinese" title="pyparsing.pyparsing_unicode.Chinese"><code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing_unicode.Chinese</span></code></a></p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.pyparsing_unicode.日本語"> <code class="descname">日本語</code><a class="headerlink" href="#pyparsing.pyparsing_unicode.日本語" title="Permalink to this definition">¶</a></dt> <dd><p>alias of <a class="reference internal" href="#pyparsing.pyparsing_unicode.Japanese" title="pyparsing.pyparsing_unicode.Japanese"><code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing_unicode.Japanese</span></code></a></p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.pyparsing_unicode.한국어"> <code class="descname">한국어</code><a class="headerlink" href="#pyparsing.pyparsing_unicode.한국어" title="Permalink to this definition">¶</a></dt> <dd><p>alias of <a class="reference internal" href="#pyparsing.pyparsing_unicode.Hangul" title="pyparsing.pyparsing_unicode.Hangul"><code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing_unicode.Hangul</span></code></a></p> </dd></dl> </dd></dl> <dl class="class"> <dt id="pyparsing.unicode_set"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">unicode_set</code><a class="headerlink" href="#pyparsing.unicode_set" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">object</span></code></p> <p>A set of Unicode characters, for language-specific strings for <code class="docutils literal notranslate"><span class="pre">alphas</span></code>, <code class="docutils literal notranslate"><span class="pre">nums</span></code>, <code class="docutils literal notranslate"><span class="pre">alphanums</span></code>, and <code class="docutils literal notranslate"><span class="pre">printables</span></code>. A unicode_set is defined by a list of ranges in the Unicode character set, in a class attribute <code class="docutils literal notranslate"><span class="pre">_ranges</span></code>. Ranges can be specified using 2-tuples or a 1-tuple, such as:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">_ranges</span> <span class="o">=</span> <span class="p">[</span> <span class="p">(</span><span class="mh">0x0020</span><span class="p">,</span> <span class="mh">0x007e</span><span class="p">),</span> <span class="p">(</span><span class="mh">0x00a0</span><span class="p">,</span> <span class="mh">0x00ff</span><span class="p">),</span> <span class="p">(</span><span class="mh">0x0100</span><span class="p">,),</span> <span class="p">]</span> </pre></div> </div> <p>Ranges are left- and right-inclusive. A 1-tuple of (x,) is treated as (x, x).</p> <p>A unicode set can also be defined using multiple inheritance of other unicode sets:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">CJK</span><span class="p">(</span><span class="n">Chinese</span><span class="p">,</span> <span class="n">Japanese</span><span class="p">,</span> <span class="n">Korean</span><span class="p">):</span> <span class="k">pass</span> </pre></div> </div> <dl class="attribute"> <dt id="pyparsing.unicode_set.__weakref__"> <code class="descname">__weakref__</code><a class="headerlink" href="#pyparsing.unicode_set.__weakref__" title="Permalink to this definition">¶</a></dt> <dd><p>list of weak references to the object (if defined)</p> </dd></dl> </dd></dl> <dl class="function"> <dt id="pyparsing.condition_as_parse_action"> <code class="descclassname">pyparsing.</code><code class="descname">condition_as_parse_action</code><span class="sig-paren">(</span><em>fn: Union[typing.Callable[[], bool], typing.Callable[[pyparsing.results.ParseResults], bool], typing.Callable[[int, pyparsing.results.ParseResults], bool], typing.Callable[[str, int, pyparsing.results.ParseResults], bool]], message: str = None, fatal: bool = False</em><span class="sig-paren">)</span> → Union[typing.Callable[[], typing.Any], typing.Callable[[pyparsing.results.ParseResults], typing.Any], typing.Callable[[int, pyparsing.results.ParseResults], typing.Any], typing.Callable[[str, int, pyparsing.results.ParseResults], typing.Any]]<a class="headerlink" href="#pyparsing.condition_as_parse_action" title="Permalink to this definition">¶</a></dt> <dd><p>Function to convert a simple predicate function that returns <code class="docutils literal notranslate"><span class="pre">True</span></code> or <code class="docutils literal notranslate"><span class="pre">False</span></code> into a parse action. Can be used in places when a parse action is required and <a class="reference internal" href="#pyparsing.ParserElement.add_condition" title="pyparsing.ParserElement.add_condition"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement.add_condition</span></code></a> cannot be used (such as when adding a condition to an operator level in <a class="reference internal" href="#pyparsing.infix_notation" title="pyparsing.infix_notation"><code class="xref py py-class docutils literal notranslate"><span class="pre">infix_notation</span></code></a>).</p> <p>Optional keyword arguments:</p> <ul class="simple"> <li><code class="docutils literal notranslate"><span class="pre">message</span></code> - define a custom message to be used in the raised exception</li> <li><code class="docutils literal notranslate"><span class="pre">fatal</span></code> - if True, will raise <a class="reference internal" href="#pyparsing.ParseFatalException" title="pyparsing.ParseFatalException"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParseFatalException</span></code></a> to stop parsing immediately; otherwise will raise <a class="reference internal" href="#pyparsing.ParseException" title="pyparsing.ParseException"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParseException</span></code></a></li> </ul> </dd></dl> <dl class="class"> <dt id="pyparsing.pyparsing_test"> <em class="property">class </em><code class="descclassname">pyparsing.</code><code class="descname">pyparsing_test</code><a class="headerlink" href="#pyparsing.pyparsing_test" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">object</span></code></p> <p>namespace class for classes useful in writing unit tests</p> <dl class="class"> <dt id="pyparsing.pyparsing_test.TestParseResultsAsserts"> <em class="property">class </em><code class="descname">TestParseResultsAsserts</code><a class="headerlink" href="#pyparsing.pyparsing_test.TestParseResultsAsserts" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">object</span></code></p> <p>A mixin class to add parse results assertion methods to normal unittest.TestCase classes.</p> <dl class="attribute"> <dt id="pyparsing.pyparsing_test.TestParseResultsAsserts.__weakref__"> <code class="descname">__weakref__</code><a class="headerlink" href="#pyparsing.pyparsing_test.TestParseResultsAsserts.__weakref__" title="Permalink to this definition">¶</a></dt> <dd><p>list of weak references to the object (if defined)</p> </dd></dl> <dl class="method"> <dt id="pyparsing.pyparsing_test.TestParseResultsAsserts.assertParseAndCheckDict"> <code class="descname">assertParseAndCheckDict</code><span class="sig-paren">(</span><em>expr</em>, <em>test_string</em>, <em>expected_dict</em>, <em>msg=None</em>, <em>verbose=True</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.pyparsing_test.TestParseResultsAsserts.assertParseAndCheckDict" title="Permalink to this definition">¶</a></dt> <dd><p>Convenience wrapper assert to test a parser element and input string, and assert that the resulting <code class="docutils literal notranslate"><span class="pre">ParseResults.asDict()</span></code> is equal to the <code class="docutils literal notranslate"><span class="pre">expected_dict</span></code>.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.pyparsing_test.TestParseResultsAsserts.assertParseAndCheckList"> <code class="descname">assertParseAndCheckList</code><span class="sig-paren">(</span><em>expr</em>, <em>test_string</em>, <em>expected_list</em>, <em>msg=None</em>, <em>verbose=True</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.pyparsing_test.TestParseResultsAsserts.assertParseAndCheckList" title="Permalink to this definition">¶</a></dt> <dd><p>Convenience wrapper assert to test a parser element and input string, and assert that the resulting <code class="docutils literal notranslate"><span class="pre">ParseResults.asList()</span></code> is equal to the <code class="docutils literal notranslate"><span class="pre">expected_list</span></code>.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.pyparsing_test.TestParseResultsAsserts.assertParseResultsEquals"> <code class="descname">assertParseResultsEquals</code><span class="sig-paren">(</span><em>result</em>, <em>expected_list=None</em>, <em>expected_dict=None</em>, <em>msg=None</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.pyparsing_test.TestParseResultsAsserts.assertParseResultsEquals" title="Permalink to this definition">¶</a></dt> <dd><p>Unit test assertion to compare a <a class="reference internal" href="#pyparsing.ParseResults" title="pyparsing.ParseResults"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParseResults</span></code></a> object with an optional <code class="docutils literal notranslate"><span class="pre">expected_list</span></code>, and compare any defined results names with an optional <code class="docutils literal notranslate"><span class="pre">expected_dict</span></code>.</p> </dd></dl> <dl class="method"> <dt id="pyparsing.pyparsing_test.TestParseResultsAsserts.assertRunTestResults"> <code class="descname">assertRunTestResults</code><span class="sig-paren">(</span><em>run_tests_report</em>, <em>expected_parse_results=None</em>, <em>msg=None</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.pyparsing_test.TestParseResultsAsserts.assertRunTestResults" title="Permalink to this definition">¶</a></dt> <dd><p>Unit test assertion to evaluate output of <code class="docutils literal notranslate"><span class="pre">ParserElement.runTests()</span></code>. If a list of list-dict tuples is given as the <code class="docutils literal notranslate"><span class="pre">expected_parse_results</span></code> argument, then these are zipped with the report tuples returned by <code class="docutils literal notranslate"><span class="pre">runTests</span></code> and evaluated using <code class="docutils literal notranslate"><span class="pre">assertParseResultsEquals</span></code>. Finally, asserts that the overall <code class="docutils literal notranslate"><span class="pre">runTests()</span></code> success value is <code class="docutils literal notranslate"><span class="pre">True</span></code>.</p> <table class="docutils field-list" frame="void" rules="none"> <col class="field-name" /> <col class="field-body" /> <tbody valign="top"> <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple"> <li><strong>run_tests_report</strong> – tuple(bool, [tuple(str, ParseResults or Exception)]) returned from runTests</li> <li><strong>(</strong><strong>optional</strong><strong>)</strong> (<em>expected_parse_results</em>) – [tuple(str, list, dict, Exception)]</li> </ul> </td> </tr> </tbody> </table> </dd></dl> </dd></dl> <dl class="attribute"> <dt id="pyparsing.pyparsing_test.__weakref__"> <code class="descname">__weakref__</code><a class="headerlink" href="#pyparsing.pyparsing_test.__weakref__" title="Permalink to this definition">¶</a></dt> <dd><p>list of weak references to the object (if defined)</p> </dd></dl> <dl class="class"> <dt id="pyparsing.pyparsing_test.reset_pyparsing_context"> <em class="property">class </em><code class="descname">reset_pyparsing_context</code><a class="headerlink" href="#pyparsing.pyparsing_test.reset_pyparsing_context" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">object</span></code></p> <p>Context manager to be used when writing unit tests that modify pyparsing config values: - packrat parsing - bounded recursion parsing - default whitespace characters. - default keyword characters - literal string auto-conversion class - __diag__ settings</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">with</span> <span class="n">reset_pyparsing_context</span><span class="p">():</span> <span class="c1"># test that literals used to construct a grammar are automatically suppressed</span> <span class="n">ParserElement</span><span class="o">.</span><span class="n">inlineLiteralsUsing</span><span class="p">(</span><span class="n">Suppress</span><span class="p">)</span> <span class="n">term</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)</span> <span class="o">|</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="n">group</span> <span class="o">=</span> <span class="n">Group</span><span class="p">(</span><span class="s1">'('</span> <span class="o">+</span> <span class="n">term</span><span class="p">[</span><span class="o">...</span><span class="p">]</span> <span class="o">+</span> <span class="s1">')'</span><span class="p">)</span> <span class="c1"># assert that the '()' characters are not included in the parsed tokens</span> <span class="bp">self</span><span class="o">.</span><span class="n">assertParseAndCheckList</span><span class="p">(</span><span class="n">group</span><span class="p">,</span> <span class="s2">"(abc 123 def)"</span><span class="p">,</span> <span class="p">[</span><span class="s1">'abc'</span><span class="p">,</span> <span class="s1">'123'</span><span class="p">,</span> <span class="s1">'def'</span><span class="p">])</span> <span class="c1"># after exiting context manager, literals are converted to Literal expressions again</span> </pre></div> </div> <dl class="method"> <dt id="pyparsing.pyparsing_test.reset_pyparsing_context.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.pyparsing_test.reset_pyparsing_context.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Initialize self. See help(type(self)) for accurate signature.</p> </dd></dl> <dl class="attribute"> <dt id="pyparsing.pyparsing_test.reset_pyparsing_context.__weakref__"> <code class="descname">__weakref__</code><a class="headerlink" href="#pyparsing.pyparsing_test.reset_pyparsing_context.__weakref__" title="Permalink to this definition">¶</a></dt> <dd><p>list of weak references to the object (if defined)</p> </dd></dl> </dd></dl> <dl class="staticmethod"> <dt id="pyparsing.pyparsing_test.with_line_numbers"> <em class="property">static </em><code class="descname">with_line_numbers</code><span class="sig-paren">(</span><em>s: str</em>, <em>start_line: Union[int</em>, <em>NoneType] = None</em>, <em>end_line: Union[int</em>, <em>NoneType] = None</em>, <em>expand_tabs: bool = True</em>, <em>eol_mark: str = '|'</em>, <em>mark_spaces: Union[str</em>, <em>NoneType] = None</em>, <em>mark_control: Union[str</em>, <em>NoneType] = None</em><span class="sig-paren">)</span> → str<a class="headerlink" href="#pyparsing.pyparsing_test.with_line_numbers" title="Permalink to this definition">¶</a></dt> <dd><p>Helpful method for debugging a parser - prints a string with line and column numbers. (Line and column numbers are 1-based.)</p> <table class="docutils field-list" frame="void" rules="none"> <col class="field-name" /> <col class="field-body" /> <tbody valign="top"> <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple"> <li><strong>s</strong> – tuple(bool, str - string to be printed with line and column numbers</li> <li><strong>start_line</strong> – int - (optional) starting line number in s to print (default=1)</li> <li><strong>end_line</strong> – int - (optional) ending line number in s to print (default=len(s))</li> <li><strong>expand_tabs</strong> – bool - (optional) expand tabs to spaces, to match the pyparsing default</li> <li><strong>eol_mark</strong> – str - (optional) string to mark the end of lines, helps visualize trailing spaces (default=”|”)</li> <li><strong>mark_spaces</strong> – str - (optional) special character to display in place of spaces</li> <li><strong>mark_control</strong> – str - (optional) convert non-printing control characters to a placeholding character; valid values: - “unicode” - replaces control chars with Unicode symbols, such as “␍” and “␊” - any single character string - replace control characters with given string - None (default) - string is displayed as-is</li> </ul> </td> </tr> <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last">str - input string with leading line numbers and column number headers</p> </td> </tr> </tbody> </table> </dd></dl> </dd></dl> <dl class="function"> <dt id="pyparsing.countedArray"> <code class="descclassname">pyparsing.</code><code class="descname">countedArray</code><span class="sig-paren">(</span><em>expr: pyparsing.core.ParserElement</em>, <em>int_expr: Union[pyparsing.core.ParserElement</em>, <em>NoneType] = None</em>, <em>*</em>, <em>intExpr: Union[pyparsing.core.ParserElement</em>, <em>NoneType] = None</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.countedArray" title="Permalink to this definition">¶</a></dt> <dd><p>Helper to define a counted list of expressions.</p> <p>This helper defines a pattern of the form:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">integer</span> <span class="n">expr</span> <span class="n">expr</span> <span class="n">expr</span><span class="o">...</span> </pre></div> </div> <p>where the leading integer tells how many expr expressions follow. The matched tokens returns the array of expr tokens as a list - the leading count token is suppressed.</p> <p>If <code class="docutils literal notranslate"><span class="pre">int_expr</span></code> is specified, it should be a pyparsing expression that produces an integer value.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">counted_array</span><span class="p">(</span><span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">))</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s1">'2 ab cd ef'</span><span class="p">)</span> <span class="c1"># -> ['ab', 'cd']</span> <span class="c1"># in this parser, the leading integer value is given in binary,</span> <span class="c1"># '10' indicating that 2 values are in the array</span> <span class="n">binary_constant</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="s1">'01'</span><span class="p">)</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="k">lambda</span> <span class="n">t</span><span class="p">:</span> <span class="nb">int</span><span class="p">(</span><span class="n">t</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="mi">2</span><span class="p">))</span> <span class="n">counted_array</span><span class="p">(</span><span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">),</span> <span class="n">int_expr</span><span class="o">=</span><span class="n">binary_constant</span><span class="p">)</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s1">'10 ab cd ef'</span><span class="p">)</span> <span class="c1"># -> ['ab', 'cd']</span> <span class="c1"># if other fields must be parsed after the count but before the</span> <span class="c1"># list items, give the fields results names and they will</span> <span class="c1"># be preserved in the returned ParseResults:</span> <span class="n">count_with_metadata</span> <span class="o">=</span> <span class="n">integer</span> <span class="o">+</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)(</span><span class="s2">"type"</span><span class="p">)</span> <span class="n">typed_array</span> <span class="o">=</span> <span class="n">counted_array</span><span class="p">(</span><span class="n">Word</span><span class="p">(</span><span class="n">alphanums</span><span class="p">),</span> <span class="n">int_expr</span><span class="o">=</span><span class="n">count_with_metadata</span><span class="p">)(</span><span class="s2">"items"</span><span class="p">)</span> <span class="n">result</span> <span class="o">=</span> <span class="n">typed_array</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"3 bool True True False"</span><span class="p">)</span> <span class="nb">print</span><span class="p">(</span><span class="n">result</span><span class="o">.</span><span class="n">dump</span><span class="p">())</span> <span class="c1"># prints</span> <span class="c1"># ['True', 'True', 'False']</span> <span class="c1"># - items: ['True', 'True', 'False']</span> <span class="c1"># - type: 'bool'</span> </pre></div> </div> </dd></dl> <dl class="function"> <dt id="pyparsing.delimitedList"> <code class="descclassname">pyparsing.</code><code class="descname">delimitedList</code><span class="sig-paren">(</span><em>expr: Union[str, pyparsing.core.ParserElement], delim: Union[str, pyparsing.core.ParserElement] = ',', combine: bool = False, min: Union[int, NoneType] = None, max: Union[int, NoneType] = None, *, allow_trailing_delim: bool = False</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.delimitedList" title="Permalink to this definition">¶</a></dt> <dd><p>Helper to define a delimited list of expressions - the delimiter defaults to ‘,’. By default, the list elements and delimiters can have intervening whitespace, and comments, but this can be overridden by passing <code class="docutils literal notranslate"><span class="pre">combine=True</span></code> in the constructor. If <code class="docutils literal notranslate"><span class="pre">combine</span></code> is set to <code class="docutils literal notranslate"><span class="pre">True</span></code>, the matching tokens are returned as a single token string, with the delimiters included; otherwise, the matching tokens are returned as a list of tokens, with the delimiters suppressed.</p> <p>If <code class="docutils literal notranslate"><span class="pre">allow_trailing_delim</span></code> is set to True, then the list may end with a delimiter.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">delimited_list</span><span class="p">(</span><span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">))</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"aa,bb,cc"</span><span class="p">)</span> <span class="c1"># -> ['aa', 'bb', 'cc']</span> <span class="n">delimited_list</span><span class="p">(</span><span class="n">Word</span><span class="p">(</span><span class="n">hexnums</span><span class="p">),</span> <span class="n">delim</span><span class="o">=</span><span class="s1">':'</span><span class="p">,</span> <span class="n">combine</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"AA:BB:CC:DD:EE"</span><span class="p">)</span> <span class="c1"># -> ['AA:BB:CC:DD:EE']</span> </pre></div> </div> </dd></dl> <dl class="function"> <dt id="pyparsing.dictOf"> <code class="descclassname">pyparsing.</code><code class="descname">dictOf</code><span class="sig-paren">(</span><em>key: pyparsing.core.ParserElement</em>, <em>value: pyparsing.core.ParserElement</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.dictOf" title="Permalink to this definition">¶</a></dt> <dd><p>Helper to easily and clearly define a dictionary by specifying the respective patterns for the key and value. Takes care of defining the <a class="reference internal" href="#pyparsing.Dict" title="pyparsing.Dict"><code class="xref py py-class docutils literal notranslate"><span class="pre">Dict</span></code></a>, <a class="reference internal" href="#pyparsing.ZeroOrMore" title="pyparsing.ZeroOrMore"><code class="xref py py-class docutils literal notranslate"><span class="pre">ZeroOrMore</span></code></a>, and <a class="reference internal" href="#pyparsing.Group" title="pyparsing.Group"><code class="xref py py-class docutils literal notranslate"><span class="pre">Group</span></code></a> tokens in the proper order. The key pattern can include delimiting markers or punctuation, as long as they are suppressed, thereby leaving the significant key text. The value pattern can include named results, so that the <a class="reference internal" href="#pyparsing.Dict" title="pyparsing.Dict"><code class="xref py py-class docutils literal notranslate"><span class="pre">Dict</span></code></a> results can include named token fields.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">text</span> <span class="o">=</span> <span class="s2">"shape: SQUARE posn: upper left color: light blue texture: burlap"</span> <span class="n">attr_expr</span> <span class="o">=</span> <span class="p">(</span><span class="n">label</span> <span class="o">+</span> <span class="n">Suppress</span><span class="p">(</span><span class="s1">':'</span><span class="p">)</span> <span class="o">+</span> <span class="n">OneOrMore</span><span class="p">(</span><span class="n">data_word</span><span class="p">,</span> <span class="n">stop_on</span><span class="o">=</span><span class="n">label</span><span class="p">)</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="s1">' '</span><span class="o">.</span><span class="n">join</span><span class="p">))</span> <span class="nb">print</span><span class="p">(</span><span class="n">attr_expr</span><span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="n">text</span><span class="p">)</span><span class="o">.</span><span class="n">dump</span><span class="p">())</span> <span class="n">attr_label</span> <span class="o">=</span> <span class="n">label</span> <span class="n">attr_value</span> <span class="o">=</span> <span class="n">Suppress</span><span class="p">(</span><span class="s1">':'</span><span class="p">)</span> <span class="o">+</span> <span class="n">OneOrMore</span><span class="p">(</span><span class="n">data_word</span><span class="p">,</span> <span class="n">stop_on</span><span class="o">=</span><span class="n">label</span><span class="p">)</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="s1">' '</span><span class="o">.</span><span class="n">join</span><span class="p">)</span> <span class="c1"># similar to Dict, but simpler call format</span> <span class="n">result</span> <span class="o">=</span> <span class="n">dict_of</span><span class="p">(</span><span class="n">attr_label</span><span class="p">,</span> <span class="n">attr_value</span><span class="p">)</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="n">text</span><span class="p">)</span> <span class="nb">print</span><span class="p">(</span><span class="n">result</span><span class="o">.</span><span class="n">dump</span><span class="p">())</span> <span class="nb">print</span><span class="p">(</span><span class="n">result</span><span class="p">[</span><span class="s1">'shape'</span><span class="p">])</span> <span class="nb">print</span><span class="p">(</span><span class="n">result</span><span class="o">.</span><span class="n">shape</span><span class="p">)</span> <span class="c1"># object attribute access works too</span> <span class="nb">print</span><span class="p">(</span><span class="n">result</span><span class="o">.</span><span class="n">as_dict</span><span class="p">())</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[[</span><span class="s1">'shape'</span><span class="p">,</span> <span class="s1">'SQUARE'</span><span class="p">],</span> <span class="p">[</span><span class="s1">'posn'</span><span class="p">,</span> <span class="s1">'upper left'</span><span class="p">],</span> <span class="p">[</span><span class="s1">'color'</span><span class="p">,</span> <span class="s1">'light blue'</span><span class="p">],</span> <span class="p">[</span><span class="s1">'texture'</span><span class="p">,</span> <span class="s1">'burlap'</span><span class="p">]]</span> <span class="o">-</span> <span class="n">color</span><span class="p">:</span> <span class="s1">'light blue'</span> <span class="o">-</span> <span class="n">posn</span><span class="p">:</span> <span class="s1">'upper left'</span> <span class="o">-</span> <span class="n">shape</span><span class="p">:</span> <span class="s1">'SQUARE'</span> <span class="o">-</span> <span class="n">texture</span><span class="p">:</span> <span class="s1">'burlap'</span> <span class="n">SQUARE</span> <span class="n">SQUARE</span> <span class="p">{</span><span class="s1">'color'</span><span class="p">:</span> <span class="s1">'light blue'</span><span class="p">,</span> <span class="s1">'shape'</span><span class="p">:</span> <span class="s1">'SQUARE'</span><span class="p">,</span> <span class="s1">'posn'</span><span class="p">:</span> <span class="s1">'upper left'</span><span class="p">,</span> <span class="s1">'texture'</span><span class="p">:</span> <span class="s1">'burlap'</span><span class="p">}</span> </pre></div> </div> </dd></dl> <dl class="function"> <dt id="pyparsing.makeHTMLTags"> <code class="descclassname">pyparsing.</code><code class="descname">makeHTMLTags</code><span class="sig-paren">(</span><em>tag_str: Union[str, pyparsing.core.ParserElement]</em><span class="sig-paren">)</span> → Tuple[pyparsing.core.ParserElement, pyparsing.core.ParserElement]<a class="headerlink" href="#pyparsing.makeHTMLTags" title="Permalink to this definition">¶</a></dt> <dd><p>Helper to construct opening and closing tag expressions for HTML, given a tag name. Matches tags in either upper or lower case, attributes with namespaces and with quoted or unquoted values.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">text</span> <span class="o">=</span> <span class="s1">'<td>More info at the <a href="https://github.com/pyparsing/pyparsing/wiki">pyparsing</a> wiki page</td>'</span> <span class="c1"># make_html_tags returns pyparsing expressions for the opening and</span> <span class="c1"># closing tags as a 2-tuple</span> <span class="n">a</span><span class="p">,</span> <span class="n">a_end</span> <span class="o">=</span> <span class="n">make_html_tags</span><span class="p">(</span><span class="s2">"A"</span><span class="p">)</span> <span class="n">link_expr</span> <span class="o">=</span> <span class="n">a</span> <span class="o">+</span> <span class="n">SkipTo</span><span class="p">(</span><span class="n">a_end</span><span class="p">)(</span><span class="s2">"link_text"</span><span class="p">)</span> <span class="o">+</span> <span class="n">a_end</span> <span class="k">for</span> <span class="n">link</span> <span class="ow">in</span> <span class="n">link_expr</span><span class="o">.</span><span class="n">search_string</span><span class="p">(</span><span class="n">text</span><span class="p">):</span> <span class="c1"># attributes in the <A> tag (like "href" shown here) are</span> <span class="c1"># also accessible as named results</span> <span class="nb">print</span><span class="p">(</span><span class="n">link</span><span class="o">.</span><span class="n">link_text</span><span class="p">,</span> <span class="s1">'->'</span><span class="p">,</span> <span class="n">link</span><span class="o">.</span><span class="n">href</span><span class="p">)</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">pyparsing</span> <span class="o">-></span> <span class="n">https</span><span class="p">:</span><span class="o">//</span><span class="n">github</span><span class="o">.</span><span class="n">com</span><span class="o">/</span><span class="n">pyparsing</span><span class="o">/</span><span class="n">pyparsing</span><span class="o">/</span><span class="n">wiki</span> </pre></div> </div> </dd></dl> <dl class="function"> <dt id="pyparsing.makeXMLTags"> <code class="descclassname">pyparsing.</code><code class="descname">makeXMLTags</code><span class="sig-paren">(</span><em>tag_str: Union[str, pyparsing.core.ParserElement]</em><span class="sig-paren">)</span> → Tuple[pyparsing.core.ParserElement, pyparsing.core.ParserElement]<a class="headerlink" href="#pyparsing.makeXMLTags" title="Permalink to this definition">¶</a></dt> <dd><p>Helper to construct opening and closing tag expressions for XML, given a tag name. Matches tags only in the given upper/lower case.</p> <p>Example: similar to <a class="reference internal" href="#pyparsing.make_html_tags" title="pyparsing.make_html_tags"><code class="xref py py-class docutils literal notranslate"><span class="pre">make_html_tags</span></code></a></p> </dd></dl> <dl class="function"> <dt id="pyparsing.matchOnlyAtCol"> <code class="descclassname">pyparsing.</code><code class="descname">matchOnlyAtCol</code><span class="sig-paren">(</span><em>n</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.matchOnlyAtCol" title="Permalink to this definition">¶</a></dt> <dd><p>Helper method for defining parse actions that require matching at a specific column in the input text.</p> </dd></dl> <dl class="function"> <dt id="pyparsing.matchPreviousExpr"> <code class="descclassname">pyparsing.</code><code class="descname">matchPreviousExpr</code><span class="sig-paren">(</span><em>expr: pyparsing.core.ParserElement</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.matchPreviousExpr" title="Permalink to this definition">¶</a></dt> <dd><p>Helper to define an expression that is indirectly defined from the tokens matched in a previous expression, that is, it looks for a ‘repeat’ of a previous expression. For example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">first</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="n">second</span> <span class="o">=</span> <span class="n">match_previous_expr</span><span class="p">(</span><span class="n">first</span><span class="p">)</span> <span class="n">match_expr</span> <span class="o">=</span> <span class="n">first</span> <span class="o">+</span> <span class="s2">":"</span> <span class="o">+</span> <span class="n">second</span> </pre></div> </div> <p>will match <code class="docutils literal notranslate"><span class="pre">"1:1"</span></code>, but not <code class="docutils literal notranslate"><span class="pre">"1:2"</span></code>. Because this matches by expressions, will <em>not</em> match the leading <code class="docutils literal notranslate"><span class="pre">"1:1"</span></code> in <code class="docutils literal notranslate"><span class="pre">"1:10"</span></code>; the expressions are evaluated first, and then compared, so <code class="docutils literal notranslate"><span class="pre">"1"</span></code> is compared with <code class="docutils literal notranslate"><span class="pre">"10"</span></code>. Do <em>not</em> use with packrat parsing enabled.</p> </dd></dl> <dl class="function"> <dt id="pyparsing.matchPreviousLiteral"> <code class="descclassname">pyparsing.</code><code class="descname">matchPreviousLiteral</code><span class="sig-paren">(</span><em>expr: pyparsing.core.ParserElement</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.matchPreviousLiteral" title="Permalink to this definition">¶</a></dt> <dd><p>Helper to define an expression that is indirectly defined from the tokens matched in a previous expression, that is, it looks for a ‘repeat’ of a previous expression. For example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">first</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="n">second</span> <span class="o">=</span> <span class="n">match_previous_literal</span><span class="p">(</span><span class="n">first</span><span class="p">)</span> <span class="n">match_expr</span> <span class="o">=</span> <span class="n">first</span> <span class="o">+</span> <span class="s2">":"</span> <span class="o">+</span> <span class="n">second</span> </pre></div> </div> <p>will match <code class="docutils literal notranslate"><span class="pre">"1:1"</span></code>, but not <code class="docutils literal notranslate"><span class="pre">"1:2"</span></code>. Because this matches a previous literal, will also match the leading <code class="docutils literal notranslate"><span class="pre">"1:1"</span></code> in <code class="docutils literal notranslate"><span class="pre">"1:10"</span></code>. If this is not desired, use <a class="reference internal" href="#pyparsing.match_previous_expr" title="pyparsing.match_previous_expr"><code class="xref py py-class docutils literal notranslate"><span class="pre">match_previous_expr</span></code></a>. Do <em>not</em> use with packrat parsing enabled.</p> </dd></dl> <dl class="function"> <dt id="pyparsing.nestedExpr"> <code class="descclassname">pyparsing.</code><code class="descname">nestedExpr</code><span class="sig-paren">(</span><em>opener: Union[str</em>, <em>pyparsing.core.ParserElement] = '('</em>, <em>closer: Union[str</em>, <em>pyparsing.core.ParserElement] = ')'</em>, <em>content: Union[pyparsing.core.ParserElement</em>, <em>NoneType] = None</em>, <em>ignore_expr: pyparsing.core.ParserElement = quotedString using single or double quotes</em>, <em>*</em>, <em>ignoreExpr: pyparsing.core.ParserElement = quotedString using single or double quotes</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.nestedExpr" title="Permalink to this definition">¶</a></dt> <dd><p>Helper method for defining nested lists enclosed in opening and closing delimiters (<code class="docutils literal notranslate"><span class="pre">"("</span></code> and <code class="docutils literal notranslate"><span class="pre">")"</span></code> are the default).</p> <p>Parameters: - <code class="docutils literal notranslate"><span class="pre">opener</span></code> - opening character for a nested list</p> <blockquote> <div>(default= <code class="docutils literal notranslate"><span class="pre">"("</span></code>); can also be a pyparsing expression</div></blockquote> <ul class="simple"> <li><code class="docutils literal notranslate"><span class="pre">closer</span></code> - closing character for a nested list (default= <code class="docutils literal notranslate"><span class="pre">")"</span></code>); can also be a pyparsing expression</li> <li><code class="docutils literal notranslate"><span class="pre">content</span></code> - expression for items within the nested lists (default= <code class="docutils literal notranslate"><span class="pre">None</span></code>)</li> <li><code class="docutils literal notranslate"><span class="pre">ignore_expr</span></code> - expression for ignoring opening and closing delimiters (default= <code class="xref py py-class docutils literal notranslate"><span class="pre">quoted_string</span></code>)</li> <li><code class="docutils literal notranslate"><span class="pre">ignoreExpr</span></code> - this pre-PEP8 argument is retained for compatibility but will be removed in a future release</li> </ul> <p>If an expression is not provided for the content argument, the nested expression will capture all whitespace-delimited content between delimiters as a list of separate values.</p> <p>Use the <code class="docutils literal notranslate"><span class="pre">ignore_expr</span></code> argument to define expressions that may contain opening or closing characters that should not be treated as opening or closing characters for nesting, such as quoted_string or a comment expression. Specify multiple expressions using an <a class="reference internal" href="#pyparsing.Or" title="pyparsing.Or"><code class="xref py py-class docutils literal notranslate"><span class="pre">Or</span></code></a> or <a class="reference internal" href="#pyparsing.MatchFirst" title="pyparsing.MatchFirst"><code class="xref py py-class docutils literal notranslate"><span class="pre">MatchFirst</span></code></a>. The default is <code class="xref py py-class docutils literal notranslate"><span class="pre">quoted_string</span></code>, but if no expressions are to be ignored, then pass <code class="docutils literal notranslate"><span class="pre">None</span></code> for this argument.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">data_type</span> <span class="o">=</span> <span class="n">one_of</span><span class="p">(</span><span class="s2">"void int short long char float double"</span><span class="p">)</span> <span class="n">decl_data_type</span> <span class="o">=</span> <span class="n">Combine</span><span class="p">(</span><span class="n">data_type</span> <span class="o">+</span> <span class="n">Opt</span><span class="p">(</span><span class="n">Word</span><span class="p">(</span><span class="s1">'*'</span><span class="p">)))</span> <span class="n">ident</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="o">+</span><span class="s1">'_'</span><span class="p">,</span> <span class="n">alphanums</span><span class="o">+</span><span class="s1">'_'</span><span class="p">)</span> <span class="n">number</span> <span class="o">=</span> <span class="n">pyparsing_common</span><span class="o">.</span><span class="n">number</span> <span class="n">arg</span> <span class="o">=</span> <span class="n">Group</span><span class="p">(</span><span class="n">decl_data_type</span> <span class="o">+</span> <span class="n">ident</span><span class="p">)</span> <span class="n">LPAR</span><span class="p">,</span> <span class="n">RPAR</span> <span class="o">=</span> <span class="nb">map</span><span class="p">(</span><span class="n">Suppress</span><span class="p">,</span> <span class="s2">"()"</span><span class="p">)</span> <span class="n">code_body</span> <span class="o">=</span> <span class="n">nested_expr</span><span class="p">(</span><span class="s1">'{'</span><span class="p">,</span> <span class="s1">'}'</span><span class="p">,</span> <span class="n">ignore_expr</span><span class="o">=</span><span class="p">(</span><span class="n">quoted_string</span> <span class="o">|</span> <span class="n">c_style_comment</span><span class="p">))</span> <span class="n">c_function</span> <span class="o">=</span> <span class="p">(</span><span class="n">decl_data_type</span><span class="p">(</span><span class="s2">"type"</span><span class="p">)</span> <span class="o">+</span> <span class="n">ident</span><span class="p">(</span><span class="s2">"name"</span><span class="p">)</span> <span class="o">+</span> <span class="n">LPAR</span> <span class="o">+</span> <span class="n">Opt</span><span class="p">(</span><span class="n">delimited_list</span><span class="p">(</span><span class="n">arg</span><span class="p">),</span> <span class="p">[])(</span><span class="s2">"args"</span><span class="p">)</span> <span class="o">+</span> <span class="n">RPAR</span> <span class="o">+</span> <span class="n">code_body</span><span class="p">(</span><span class="s2">"body"</span><span class="p">))</span> <span class="n">c_function</span><span class="o">.</span><span class="n">ignore</span><span class="p">(</span><span class="n">c_style_comment</span><span class="p">)</span> <span class="n">source_code</span> <span class="o">=</span> <span class="s1">'''</span> <span class="s1"> int is_odd(int x) {</span> <span class="s1"> return (x%2);</span> <span class="s1"> }</span> <span class="s1"> int dec_to_hex(char hchar) {</span> <span class="s1"> if (hchar >= '0' && hchar <= '9') {</span> <span class="s1"> return (ord(hchar)-ord('0'));</span> <span class="s1"> } else {</span> <span class="s1"> return (10+ord(hchar)-ord('A'));</span> <span class="s1"> }</span> <span class="s1"> }</span> <span class="s1">'''</span> <span class="k">for</span> <span class="n">func</span> <span class="ow">in</span> <span class="n">c_function</span><span class="o">.</span><span class="n">search_string</span><span class="p">(</span><span class="n">source_code</span><span class="p">):</span> <span class="nb">print</span><span class="p">(</span><span class="s2">"</span><span class="si">%(name)s</span><span class="s2"> (</span><span class="si">%(type)s</span><span class="s2">) args: </span><span class="si">%(args)s</span><span class="s2">"</span> <span class="o">%</span> <span class="n">func</span><span class="p">)</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">is_odd</span> <span class="p">(</span><span class="nb">int</span><span class="p">)</span> <span class="n">args</span><span class="p">:</span> <span class="p">[[</span><span class="s1">'int'</span><span class="p">,</span> <span class="s1">'x'</span><span class="p">]]</span> <span class="n">dec_to_hex</span> <span class="p">(</span><span class="nb">int</span><span class="p">)</span> <span class="n">args</span><span class="p">:</span> <span class="p">[[</span><span class="s1">'char'</span><span class="p">,</span> <span class="s1">'hchar'</span><span class="p">]]</span> </pre></div> </div> </dd></dl> <dl class="function"> <dt id="pyparsing.nullDebugAction"> <code class="descclassname">pyparsing.</code><code class="descname">nullDebugAction</code><span class="sig-paren">(</span><em>*args</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.nullDebugAction" title="Permalink to this definition">¶</a></dt> <dd><p>‘Do-nothing’ debug action, to suppress debugging output during parsing.</p> </dd></dl> <dl class="function"> <dt id="pyparsing.oneOf"> <code class="descclassname">pyparsing.</code><code class="descname">oneOf</code><span class="sig-paren">(</span><em>strs: Union[typing.Iterable[str], str], caseless: bool = False, use_regex: bool = True, as_keyword: bool = False, *, useRegex: bool = True, asKeyword: bool = False</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.oneOf" title="Permalink to this definition">¶</a></dt> <dd><p>Helper to quickly define a set of alternative <a class="reference internal" href="#pyparsing.Literal" title="pyparsing.Literal"><code class="xref py py-class docutils literal notranslate"><span class="pre">Literal</span></code></a> s, and makes sure to do longest-first testing when there is a conflict, regardless of the input order, but returns a <a class="reference internal" href="#pyparsing.MatchFirst" title="pyparsing.MatchFirst"><code class="xref py py-class docutils literal notranslate"><span class="pre">MatchFirst</span></code></a> for best performance.</p> <p>Parameters:</p> <ul class="simple"> <li><code class="docutils literal notranslate"><span class="pre">strs</span></code> - a string of space-delimited literals, or a collection of string literals</li> <li><code class="docutils literal notranslate"><span class="pre">caseless</span></code> - treat all literals as caseless - (default= <code class="docutils literal notranslate"><span class="pre">False</span></code>)</li> <li><code class="docutils literal notranslate"><span class="pre">use_regex</span></code> - as an optimization, will generate a <a class="reference internal" href="#pyparsing.Regex" title="pyparsing.Regex"><code class="xref py py-class docutils literal notranslate"><span class="pre">Regex</span></code></a> object; otherwise, will generate a <a class="reference internal" href="#pyparsing.MatchFirst" title="pyparsing.MatchFirst"><code class="xref py py-class docutils literal notranslate"><span class="pre">MatchFirst</span></code></a> object (if <code class="docutils literal notranslate"><span class="pre">caseless=True</span></code> or <code class="docutils literal notranslate"><span class="pre">asKeyword=True</span></code>, or if creating a <a class="reference internal" href="#pyparsing.Regex" title="pyparsing.Regex"><code class="xref py py-class docutils literal notranslate"><span class="pre">Regex</span></code></a> raises an exception) - (default= <code class="docutils literal notranslate"><span class="pre">True</span></code>)</li> <li><code class="docutils literal notranslate"><span class="pre">as_keyword</span></code> - enforce <a class="reference internal" href="#pyparsing.Keyword" title="pyparsing.Keyword"><code class="xref py py-class docutils literal notranslate"><span class="pre">Keyword</span></code></a>-style matching on the generated expressions - (default= <code class="docutils literal notranslate"><span class="pre">False</span></code>)</li> <li><code class="docutils literal notranslate"><span class="pre">asKeyword</span></code> and <code class="docutils literal notranslate"><span class="pre">useRegex</span></code> are retained for pre-PEP8 compatibility, but will be removed in a future release</li> </ul> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">comp_oper</span> <span class="o">=</span> <span class="n">one_of</span><span class="p">(</span><span class="s2">"< = > <= >= !="</span><span class="p">)</span> <span class="n">var</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)</span> <span class="n">number</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="n">term</span> <span class="o">=</span> <span class="n">var</span> <span class="o">|</span> <span class="n">number</span> <span class="n">comparison_expr</span> <span class="o">=</span> <span class="n">term</span> <span class="o">+</span> <span class="n">comp_oper</span> <span class="o">+</span> <span class="n">term</span> <span class="nb">print</span><span class="p">(</span><span class="n">comparison_expr</span><span class="o">.</span><span class="n">search_string</span><span class="p">(</span><span class="s2">"B = 12 AA=23 B<=AA AA>12"</span><span class="p">))</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[[</span><span class="s1">'B'</span><span class="p">,</span> <span class="s1">'='</span><span class="p">,</span> <span class="s1">'12'</span><span class="p">],</span> <span class="p">[</span><span class="s1">'AA'</span><span class="p">,</span> <span class="s1">'='</span><span class="p">,</span> <span class="s1">'23'</span><span class="p">],</span> <span class="p">[</span><span class="s1">'B'</span><span class="p">,</span> <span class="s1">'<='</span><span class="p">,</span> <span class="s1">'AA'</span><span class="p">],</span> <span class="p">[</span><span class="s1">'AA'</span><span class="p">,</span> <span class="s1">'>'</span><span class="p">,</span> <span class="s1">'12'</span><span class="p">]]</span> </pre></div> </div> </dd></dl> <dl class="attribute"> <dt id="pyparsing.opAssoc"> <code class="descclassname">pyparsing.</code><code class="descname">opAssoc</code><a class="headerlink" href="#pyparsing.opAssoc" title="Permalink to this definition">¶</a></dt> <dd><p>alias of <code class="xref py py-class docutils literal notranslate"><span class="pre">pyparsing.helpers.OpAssoc</span></code></p> </dd></dl> <dl class="function"> <dt id="pyparsing.removeQuotes"> <code class="descclassname">pyparsing.</code><code class="descname">removeQuotes</code><span class="sig-paren">(</span><em>s</em>, <em>l</em>, <em>t</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.removeQuotes" title="Permalink to this definition">¶</a></dt> <dd><p>Helper parse action for removing quotation marks from parsed quoted strings.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># by default, quotation marks are included in parsed results</span> <span class="n">quoted_string</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"'Now is the Winter of our Discontent'"</span><span class="p">)</span> <span class="c1"># -> ["'Now is the Winter of our Discontent'"]</span> <span class="c1"># use remove_quotes to strip quotation marks from parsed results</span> <span class="n">quoted_string</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="n">remove_quotes</span><span class="p">)</span> <span class="n">quoted_string</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"'Now is the Winter of our Discontent'"</span><span class="p">)</span> <span class="c1"># -> ["Now is the Winter of our Discontent"]</span> </pre></div> </div> </dd></dl> <dl class="function"> <dt id="pyparsing.replaceHTMLEntity"> <code class="descclassname">pyparsing.</code><code class="descname">replaceHTMLEntity</code><span class="sig-paren">(</span><em>t</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.replaceHTMLEntity" title="Permalink to this definition">¶</a></dt> <dd><p>Helper parser action to replace common HTML entities with their special characters</p> </dd></dl> <dl class="function"> <dt id="pyparsing.replaceWith"> <code class="descclassname">pyparsing.</code><code class="descname">replaceWith</code><span class="sig-paren">(</span><em>repl_str</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.replaceWith" title="Permalink to this definition">¶</a></dt> <dd><p>Helper method for common parse actions that simply return a literal value. Especially useful when used with <a class="reference internal" href="#pyparsing.ParserElement.transform_string" title="pyparsing.ParserElement.transform_string"><code class="xref py py-class docutils literal notranslate"><span class="pre">transform_string</span></code></a> ().</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">num</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="k">lambda</span> <span class="n">toks</span><span class="p">:</span> <span class="nb">int</span><span class="p">(</span><span class="n">toks</span><span class="p">[</span><span class="mi">0</span><span class="p">]))</span> <span class="n">na</span> <span class="o">=</span> <span class="n">one_of</span><span class="p">(</span><span class="s2">"N/A NA"</span><span class="p">)</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="n">replace_with</span><span class="p">(</span><span class="n">math</span><span class="o">.</span><span class="n">nan</span><span class="p">))</span> <span class="n">term</span> <span class="o">=</span> <span class="n">na</span> <span class="o">|</span> <span class="n">num</span> <span class="n">term</span><span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"324 234 N/A 234"</span><span class="p">)</span> <span class="c1"># -> [324, 234, nan, 234]</span> </pre></div> </div> </dd></dl> <dl class="function"> <dt id="pyparsing.traceParseAction"> <code class="descclassname">pyparsing.</code><code class="descname">traceParseAction</code><span class="sig-paren">(</span><em>f: Union[typing.Callable[[], typing.Any], typing.Callable[[pyparsing.results.ParseResults], typing.Any], typing.Callable[[int, pyparsing.results.ParseResults], typing.Any], typing.Callable[[str, int, pyparsing.results.ParseResults], typing.Any]]</em><span class="sig-paren">)</span> → Union[typing.Callable[[], typing.Any], typing.Callable[[pyparsing.results.ParseResults], typing.Any], typing.Callable[[int, pyparsing.results.ParseResults], typing.Any], typing.Callable[[str, int, pyparsing.results.ParseResults], typing.Any]]<a class="headerlink" href="#pyparsing.traceParseAction" title="Permalink to this definition">¶</a></dt> <dd><p>Decorator for debugging parse actions.</p> <p>When the parse action is called, this decorator will print <code class="docutils literal notranslate"><span class="pre">">></span> <span class="pre">entering</span> <span class="pre">method-name(line:<current_source_line>,</span> <span class="pre"><parse_location>,</span> <span class="pre"><matched_tokens>)"</span></code>. When the parse action completes, the decorator will print <code class="docutils literal notranslate"><span class="pre">"<<"</span></code> followed by the returned value, or any exception that the parse action raised.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">wd</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)</span> <span class="nd">@trace_parse_action</span> <span class="k">def</span> <span class="nf">remove_duplicate_chars</span><span class="p">(</span><span class="n">tokens</span><span class="p">):</span> <span class="k">return</span> <span class="s1">''</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="nb">sorted</span><span class="p">(</span><span class="nb">set</span><span class="p">(</span><span class="s1">''</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">tokens</span><span class="p">))))</span> <span class="n">wds</span> <span class="o">=</span> <span class="n">wd</span><span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="n">remove_duplicate_chars</span><span class="p">)</span> <span class="nb">print</span><span class="p">(</span><span class="n">wds</span><span class="o">.</span><span class="n">parse_string</span><span class="p">(</span><span class="s2">"slkdjs sld sldd sdlf sdljf"</span><span class="p">))</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="o">>></span><span class="n">entering</span> <span class="n">remove_duplicate_chars</span><span class="p">(</span><span class="n">line</span><span class="p">:</span> <span class="s1">'slkdjs sld sldd sdlf sdljf'</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="p">([</span><span class="s1">'slkdjs'</span><span class="p">,</span> <span class="s1">'sld'</span><span class="p">,</span> <span class="s1">'sldd'</span><span class="p">,</span> <span class="s1">'sdlf'</span><span class="p">,</span> <span class="s1">'sdljf'</span><span class="p">],</span> <span class="p">{}))</span> <span class="o"><<</span><span class="n">leaving</span> <span class="n">remove_duplicate_chars</span> <span class="p">(</span><span class="n">ret</span><span class="p">:</span> <span class="s1">'dfjkls'</span><span class="p">)</span> <span class="p">[</span><span class="s1">'dfjkls'</span><span class="p">]</span> </pre></div> </div> </dd></dl> <dl class="function"> <dt id="pyparsing.withAttribute"> <code class="descclassname">pyparsing.</code><code class="descname">withAttribute</code><span class="sig-paren">(</span><em>*args</em>, <em>**attr_dict</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.withAttribute" title="Permalink to this definition">¶</a></dt> <dd><p>Helper to create a validating parse action to be used with start tags created with <a class="reference internal" href="#pyparsing.make_xml_tags" title="pyparsing.make_xml_tags"><code class="xref py py-class docutils literal notranslate"><span class="pre">make_xml_tags</span></code></a> or <a class="reference internal" href="#pyparsing.make_html_tags" title="pyparsing.make_html_tags"><code class="xref py py-class docutils literal notranslate"><span class="pre">make_html_tags</span></code></a>. Use <code class="docutils literal notranslate"><span class="pre">with_attribute</span></code> to qualify a starting tag with a required attribute value, to avoid false matches on common tags such as <code class="docutils literal notranslate"><span class="pre"><TD></span></code> or <code class="docutils literal notranslate"><span class="pre"><DIV></span></code>.</p> <p>Call <code class="docutils literal notranslate"><span class="pre">with_attribute</span></code> with a series of attribute names and values. Specify the list of filter attributes names and values as:</p> <ul class="simple"> <li>keyword arguments, as in <code class="docutils literal notranslate"><span class="pre">(align="right")</span></code>, or</li> <li>as an explicit dict with <code class="docutils literal notranslate"><span class="pre">**</span></code> operator, when an attribute name is also a Python reserved word, as in <code class="docutils literal notranslate"><span class="pre">**{"class":"Customer",</span> <span class="pre">"align":"right"}</span></code></li> <li>a list of name-value tuples, as in <code class="docutils literal notranslate"><span class="pre">(("ns1:class",</span> <span class="pre">"Customer"),</span> <span class="pre">("ns2:align",</span> <span class="pre">"right"))</span></code></li> </ul> <p>For attribute names with a namespace prefix, you must use the second form. Attribute names are matched insensitive to upper/lower case.</p> <p>If just testing for <code class="docutils literal notranslate"><span class="pre">class</span></code> (with or without a namespace), use <a class="reference internal" href="#pyparsing.with_class" title="pyparsing.with_class"><code class="xref py py-class docutils literal notranslate"><span class="pre">with_class</span></code></a>.</p> <p>To verify that the attribute exists, but without specifying a value, pass <code class="docutils literal notranslate"><span class="pre">with_attribute.ANY_VALUE</span></code> as the value.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">html</span> <span class="o">=</span> <span class="s1">'''</span> <span class="s1"> <div></span> <span class="s1"> Some text</span> <span class="s1"> <div type="grid">1 4 0 1 0</div></span> <span class="s1"> <div type="graph">1,3 2,3 1,1</div></span> <span class="s1"> <div>this has no type</div></span> <span class="s1"> </div></span> <span class="s1">'''</span> <span class="n">div</span><span class="p">,</span><span class="n">div_end</span> <span class="o">=</span> <span class="n">make_html_tags</span><span class="p">(</span><span class="s2">"div"</span><span class="p">)</span> <span class="c1"># only match div tag having a type attribute with value "grid"</span> <span class="n">div_grid</span> <span class="o">=</span> <span class="n">div</span><span class="p">()</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="n">with_attribute</span><span class="p">(</span><span class="nb">type</span><span class="o">=</span><span class="s2">"grid"</span><span class="p">))</span> <span class="n">grid_expr</span> <span class="o">=</span> <span class="n">div_grid</span> <span class="o">+</span> <span class="n">SkipTo</span><span class="p">(</span><span class="n">div</span> <span class="o">|</span> <span class="n">div_end</span><span class="p">)(</span><span class="s2">"body"</span><span class="p">)</span> <span class="k">for</span> <span class="n">grid_header</span> <span class="ow">in</span> <span class="n">grid_expr</span><span class="o">.</span><span class="n">search_string</span><span class="p">(</span><span class="n">html</span><span class="p">):</span> <span class="nb">print</span><span class="p">(</span><span class="n">grid_header</span><span class="o">.</span><span class="n">body</span><span class="p">)</span> <span class="c1"># construct a match with any div tag having a type attribute, regardless of the value</span> <span class="n">div_any_type</span> <span class="o">=</span> <span class="n">div</span><span class="p">()</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="n">with_attribute</span><span class="p">(</span><span class="nb">type</span><span class="o">=</span><span class="n">with_attribute</span><span class="o">.</span><span class="n">ANY_VALUE</span><span class="p">))</span> <span class="n">div_expr</span> <span class="o">=</span> <span class="n">div_any_type</span> <span class="o">+</span> <span class="n">SkipTo</span><span class="p">(</span><span class="n">div</span> <span class="o">|</span> <span class="n">div_end</span><span class="p">)(</span><span class="s2">"body"</span><span class="p">)</span> <span class="k">for</span> <span class="n">div_header</span> <span class="ow">in</span> <span class="n">div_expr</span><span class="o">.</span><span class="n">search_string</span><span class="p">(</span><span class="n">html</span><span class="p">):</span> <span class="nb">print</span><span class="p">(</span><span class="n">div_header</span><span class="o">.</span><span class="n">body</span><span class="p">)</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">1</span> <span class="mi">4</span> <span class="mi">0</span> <span class="mi">1</span> <span class="mi">0</span> <span class="mi">1</span> <span class="mi">4</span> <span class="mi">0</span> <span class="mi">1</span> <span class="mi">0</span> <span class="mi">1</span><span class="p">,</span><span class="mi">3</span> <span class="mi">2</span><span class="p">,</span><span class="mi">3</span> <span class="mi">1</span><span class="p">,</span><span class="mi">1</span> </pre></div> </div> </dd></dl> <dl class="function"> <dt> <code class="descclassname">pyparsing.</code><code class="descname">indentedBlock</code><span class="sig-paren">(</span><em>blockStatementExpr</em>, <em>indentStack</em>, <em>indent=True</em>, <em>backup_stacks=[]</em><span class="sig-paren">)</span></dt> <dd><p>(DEPRECATED - use IndentedBlock class instead) Helper method for defining space-delimited indentation blocks, such as those used to define block statements in Python source code.</p> <p>Parameters:</p> <ul class="simple"> <li><code class="docutils literal notranslate"><span class="pre">blockStatementExpr</span></code> - expression defining syntax of statement that is repeated within the indented block</li> <li><code class="docutils literal notranslate"><span class="pre">indentStack</span></code> - list created by caller to manage indentation stack (multiple <code class="docutils literal notranslate"><span class="pre">statementWithIndentedBlock</span></code> expressions within a single grammar should share a common <code class="docutils literal notranslate"><span class="pre">indentStack</span></code>)</li> <li><code class="docutils literal notranslate"><span class="pre">indent</span></code> - boolean indicating whether block must be indented beyond the current level; set to <code class="docutils literal notranslate"><span class="pre">False</span></code> for block of left-most statements (default= <code class="docutils literal notranslate"><span class="pre">True</span></code>)</li> </ul> <p>A valid block must contain at least one <code class="docutils literal notranslate"><span class="pre">blockStatement</span></code>.</p> <p>(Note that indentedBlock uses internal parse actions which make it incompatible with packrat parsing.)</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">data</span> <span class="o">=</span> <span class="s1">'''</span> <span class="s1">def A(z):</span> <span class="s1"> A1</span> <span class="s1"> B = 100</span> <span class="s1"> G = A2</span> <span class="s1"> A2</span> <span class="s1"> A3</span> <span class="s1">B</span> <span class="s1">def BB(a,b,c):</span> <span class="s1"> BB1</span> <span class="s1"> def BBA():</span> <span class="s1"> bba1</span> <span class="s1"> bba2</span> <span class="s1"> bba3</span> <span class="s1">C</span> <span class="s1">D</span> <span class="s1">def spam(x,y):</span> <span class="s1"> def eggs(z):</span> <span class="s1"> pass</span> <span class="s1">'''</span> <span class="n">indentStack</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="n">stmt</span> <span class="o">=</span> <span class="n">Forward</span><span class="p">()</span> <span class="n">identifier</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">,</span> <span class="n">alphanums</span><span class="p">)</span> <span class="n">funcDecl</span> <span class="o">=</span> <span class="p">(</span><span class="s2">"def"</span> <span class="o">+</span> <span class="n">identifier</span> <span class="o">+</span> <span class="n">Group</span><span class="p">(</span><span class="s2">"("</span> <span class="o">+</span> <span class="n">Opt</span><span class="p">(</span><span class="n">delimitedList</span><span class="p">(</span><span class="n">identifier</span><span class="p">))</span> <span class="o">+</span> <span class="s2">")"</span><span class="p">)</span> <span class="o">+</span> <span class="s2">":"</span><span class="p">)</span> <span class="n">func_body</span> <span class="o">=</span> <span class="n">indentedBlock</span><span class="p">(</span><span class="n">stmt</span><span class="p">,</span> <span class="n">indentStack</span><span class="p">)</span> <span class="n">funcDef</span> <span class="o">=</span> <span class="n">Group</span><span class="p">(</span><span class="n">funcDecl</span> <span class="o">+</span> <span class="n">func_body</span><span class="p">)</span> <span class="n">rvalue</span> <span class="o">=</span> <span class="n">Forward</span><span class="p">()</span> <span class="n">funcCall</span> <span class="o">=</span> <span class="n">Group</span><span class="p">(</span><span class="n">identifier</span> <span class="o">+</span> <span class="s2">"("</span> <span class="o">+</span> <span class="n">Opt</span><span class="p">(</span><span class="n">delimitedList</span><span class="p">(</span><span class="n">rvalue</span><span class="p">))</span> <span class="o">+</span> <span class="s2">")"</span><span class="p">)</span> <span class="n">rvalue</span> <span class="o"><<</span> <span class="p">(</span><span class="n">funcCall</span> <span class="o">|</span> <span class="n">identifier</span> <span class="o">|</span> <span class="n">Word</span><span class="p">(</span><span class="n">nums</span><span class="p">))</span> <span class="n">assignment</span> <span class="o">=</span> <span class="n">Group</span><span class="p">(</span><span class="n">identifier</span> <span class="o">+</span> <span class="s2">"="</span> <span class="o">+</span> <span class="n">rvalue</span><span class="p">)</span> <span class="n">stmt</span> <span class="o"><<</span> <span class="p">(</span><span class="n">funcDef</span> <span class="o">|</span> <span class="n">assignment</span> <span class="o">|</span> <span class="n">identifier</span><span class="p">)</span> <span class="n">module_body</span> <span class="o">=</span> <span class="n">stmt</span><span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span> <span class="n">parseTree</span> <span class="o">=</span> <span class="n">module_body</span><span class="o">.</span><span class="n">parseString</span><span class="p">(</span><span class="n">data</span><span class="p">)</span> <span class="n">parseTree</span><span class="o">.</span><span class="n">pprint</span><span class="p">()</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[[</span><span class="s1">'def'</span><span class="p">,</span> <span class="s1">'A'</span><span class="p">,</span> <span class="p">[</span><span class="s1">'('</span><span class="p">,</span> <span class="s1">'z'</span><span class="p">,</span> <span class="s1">')'</span><span class="p">],</span> <span class="s1">':'</span><span class="p">,</span> <span class="p">[[</span><span class="s1">'A1'</span><span class="p">],</span> <span class="p">[[</span><span class="s1">'B'</span><span class="p">,</span> <span class="s1">'='</span><span class="p">,</span> <span class="s1">'100'</span><span class="p">]],</span> <span class="p">[[</span><span class="s1">'G'</span><span class="p">,</span> <span class="s1">'='</span><span class="p">,</span> <span class="s1">'A2'</span><span class="p">]],</span> <span class="p">[</span><span class="s1">'A2'</span><span class="p">],</span> <span class="p">[</span><span class="s1">'A3'</span><span class="p">]]],</span> <span class="s1">'B'</span><span class="p">,</span> <span class="p">[</span><span class="s1">'def'</span><span class="p">,</span> <span class="s1">'BB'</span><span class="p">,</span> <span class="p">[</span><span class="s1">'('</span><span class="p">,</span> <span class="s1">'a'</span><span class="p">,</span> <span class="s1">'b'</span><span class="p">,</span> <span class="s1">'c'</span><span class="p">,</span> <span class="s1">')'</span><span class="p">],</span> <span class="s1">':'</span><span class="p">,</span> <span class="p">[[</span><span class="s1">'BB1'</span><span class="p">],</span> <span class="p">[[</span><span class="s1">'def'</span><span class="p">,</span> <span class="s1">'BBA'</span><span class="p">,</span> <span class="p">[</span><span class="s1">'('</span><span class="p">,</span> <span class="s1">')'</span><span class="p">],</span> <span class="s1">':'</span><span class="p">,</span> <span class="p">[[</span><span class="s1">'bba1'</span><span class="p">],</span> <span class="p">[</span><span class="s1">'bba2'</span><span class="p">],</span> <span class="p">[</span><span class="s1">'bba3'</span><span class="p">]]]]]],</span> <span class="s1">'C'</span><span class="p">,</span> <span class="s1">'D'</span><span class="p">,</span> <span class="p">[</span><span class="s1">'def'</span><span class="p">,</span> <span class="s1">'spam'</span><span class="p">,</span> <span class="p">[</span><span class="s1">'('</span><span class="p">,</span> <span class="s1">'x'</span><span class="p">,</span> <span class="s1">'y'</span><span class="p">,</span> <span class="s1">')'</span><span class="p">],</span> <span class="s1">':'</span><span class="p">,</span> <span class="p">[[[</span><span class="s1">'def'</span><span class="p">,</span> <span class="s1">'eggs'</span><span class="p">,</span> <span class="p">[</span><span class="s1">'('</span><span class="p">,</span> <span class="s1">'z'</span><span class="p">,</span> <span class="s1">')'</span><span class="p">],</span> <span class="s1">':'</span><span class="p">,</span> <span class="p">[[</span><span class="s1">'pass'</span><span class="p">]]]]]]]</span> </pre></div> </div> </dd></dl> <dl class="function"> <dt id="pyparsing.originalTextFor"> <code class="descclassname">pyparsing.</code><code class="descname">originalTextFor</code><span class="sig-paren">(</span><em>expr: pyparsing.core.ParserElement</em>, <em>as_string: bool = True</em>, <em>*</em>, <em>asString: bool = True</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.originalTextFor" title="Permalink to this definition">¶</a></dt> <dd><p>Helper to return the original, untokenized text for a given expression. Useful to restore the parsed fields of an HTML start tag into the raw tag text itself, or to revert separate tokens with intervening whitespace back to the original matching input text. By default, returns astring containing the original parsed text.</p> <p>If the optional <code class="docutils literal notranslate"><span class="pre">as_string</span></code> argument is passed as <code class="docutils literal notranslate"><span class="pre">False</span></code>, then the return value is a <a class="reference internal" href="#pyparsing.ParseResults" title="pyparsing.ParseResults"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParseResults</span></code></a> containing any results names that were originally matched, and a single token containing the original matched text from the input string. So if the expression passed to <a class="reference internal" href="#pyparsing.original_text_for" title="pyparsing.original_text_for"><code class="xref py py-class docutils literal notranslate"><span class="pre">original_text_for</span></code></a> contains expressions with defined results names, you must set <code class="docutils literal notranslate"><span class="pre">as_string</span></code> to <code class="docutils literal notranslate"><span class="pre">False</span></code> if you want to preserve those results name values.</p> <p>The <code class="docutils literal notranslate"><span class="pre">asString</span></code> pre-PEP8 argument is retained for compatibility, but will be removed in a future release.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">src</span> <span class="o">=</span> <span class="s2">"this is test <b> bold <i>text</i> </b> normal text "</span> <span class="k">for</span> <span class="n">tag</span> <span class="ow">in</span> <span class="p">(</span><span class="s2">"b"</span><span class="p">,</span> <span class="s2">"i"</span><span class="p">):</span> <span class="n">opener</span><span class="p">,</span> <span class="n">closer</span> <span class="o">=</span> <span class="n">make_html_tags</span><span class="p">(</span><span class="n">tag</span><span class="p">)</span> <span class="n">patt</span> <span class="o">=</span> <span class="n">original_text_for</span><span class="p">(</span><span class="n">opener</span> <span class="o">+</span> <span class="n">SkipTo</span><span class="p">(</span><span class="n">closer</span><span class="p">)</span> <span class="o">+</span> <span class="n">closer</span><span class="p">)</span> <span class="nb">print</span><span class="p">(</span><span class="n">patt</span><span class="o">.</span><span class="n">search_string</span><span class="p">(</span><span class="n">src</span><span class="p">)[</span><span class="mi">0</span><span class="p">])</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="s1">'<b> bold <i>text</i> </b>'</span><span class="p">]</span> <span class="p">[</span><span class="s1">'<i>text</i>'</span><span class="p">]</span> </pre></div> </div> </dd></dl> <dl class="function"> <dt id="pyparsing.infixNotation"> <code class="descclassname">pyparsing.</code><code class="descname">infixNotation</code><span class="sig-paren">(</span><em>base_expr: pyparsing.core.ParserElement, op_list: List[Union[typing.Tuple[typing.Union[pyparsing.core.ParserElement, str, typing.Tuple[typing.Union[pyparsing.core.ParserElement, str], typing.Union[pyparsing.core.ParserElement, str]]], int, pyparsing.helpers.OpAssoc, typing.Union[typing.Callable[[], typing.Any], typing.Callable[[pyparsing.results.ParseResults], typing.Any], typing.Callable[[int, pyparsing.results.ParseResults], typing.Any], typing.Callable[[str, int, pyparsing.results.ParseResults], typing.Any], NoneType]], typing.Tuple[typing.Union[pyparsing.core.ParserElement, str, typing.Tuple[typing.Union[pyparsing.core.ParserElement, str], typing.Union[pyparsing.core.ParserElement, str]]], int, pyparsing.helpers.OpAssoc]]], lpar: Union[str, pyparsing.core.ParserElement] = Suppress:('('), rpar: Union[str, pyparsing.core.ParserElement] = Suppress:(')')</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement<a class="headerlink" href="#pyparsing.infixNotation" title="Permalink to this definition">¶</a></dt> <dd><p>Helper method for constructing grammars of expressions made up of operators working in a precedence hierarchy. Operators may be unary or binary, left- or right-associative. Parse actions can also be attached to operator expressions. The generated parser will also recognize the use of parentheses to override operator precedences (see example below).</p> <p>Note: if you define a deep operator list, you may see performance issues when using infix_notation. See <a class="reference internal" href="#pyparsing.ParserElement.enable_packrat" title="pyparsing.ParserElement.enable_packrat"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement.enable_packrat</span></code></a> for a mechanism to potentially improve your parser performance.</p> <p>Parameters: - <code class="docutils literal notranslate"><span class="pre">base_expr</span></code> - expression representing the most basic operand to</p> <blockquote> <div>be used in the expression</div></blockquote> <ul class="simple"> <li><code class="docutils literal notranslate"><span class="pre">op_list</span></code> - list of tuples, one for each operator precedence level in the expression grammar; each tuple is of the form <code class="docutils literal notranslate"><span class="pre">(op_expr,</span> <span class="pre">num_operands,</span> <span class="pre">right_left_assoc,</span> <span class="pre">(optional)parse_action)</span></code>, where:<ul> <li><code class="docutils literal notranslate"><span class="pre">op_expr</span></code> is the pyparsing expression for the operator; may also be a string, which will be converted to a Literal; if <code class="docutils literal notranslate"><span class="pre">num_operands</span></code> is 3, <code class="docutils literal notranslate"><span class="pre">op_expr</span></code> is a tuple of two expressions, for the two operators separating the 3 terms</li> <li><code class="docutils literal notranslate"><span class="pre">num_operands</span></code> is the number of terms for this operator (must be 1, 2, or 3)</li> <li><code class="docutils literal notranslate"><span class="pre">right_left_assoc</span></code> is the indicator whether the operator is right or left associative, using the pyparsing-defined constants <code class="docutils literal notranslate"><span class="pre">OpAssoc.RIGHT</span></code> and <code class="docutils literal notranslate"><span class="pre">OpAssoc.LEFT</span></code>.</li> <li><code class="docutils literal notranslate"><span class="pre">parse_action</span></code> is the parse action to be associated with expressions matching this operator expression (the parse action tuple member may be omitted); if the parse action is passed a tuple or list of functions, this is equivalent to calling <code class="docutils literal notranslate"><span class="pre">set_parse_action(*fn)</span></code> (<a class="reference internal" href="#pyparsing.ParserElement.set_parse_action" title="pyparsing.ParserElement.set_parse_action"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement.set_parse_action</span></code></a>)</li> </ul> </li> <li><code class="docutils literal notranslate"><span class="pre">lpar</span></code> - expression for matching left-parentheses; if passed as a str, then will be parsed as Suppress(lpar). If lpar is passed as an expression (such as <code class="docutils literal notranslate"><span class="pre">Literal('(')</span></code>), then it will be kept in the parsed results, and grouped with them. (default= <code class="docutils literal notranslate"><span class="pre">Suppress('(')</span></code>)</li> <li><code class="docutils literal notranslate"><span class="pre">rpar</span></code> - expression for matching right-parentheses; if passed as a str, then will be parsed as Suppress(rpar). If rpar is passed as an expression (such as <code class="docutils literal notranslate"><span class="pre">Literal(')')</span></code>), then it will be kept in the parsed results, and grouped with them. (default= <code class="docutils literal notranslate"><span class="pre">Suppress(')')</span></code>)</li> </ul> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># simple example of four-function arithmetic with ints and</span> <span class="c1"># variable names</span> <span class="n">integer</span> <span class="o">=</span> <span class="n">pyparsing_common</span><span class="o">.</span><span class="n">signed_integer</span> <span class="n">varname</span> <span class="o">=</span> <span class="n">pyparsing_common</span><span class="o">.</span><span class="n">identifier</span> <span class="n">arith_expr</span> <span class="o">=</span> <span class="n">infix_notation</span><span class="p">(</span><span class="n">integer</span> <span class="o">|</span> <span class="n">varname</span><span class="p">,</span> <span class="p">[</span> <span class="p">(</span><span class="s1">'-'</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="n">OpAssoc</span><span class="o">.</span><span class="n">RIGHT</span><span class="p">),</span> <span class="p">(</span><span class="n">one_of</span><span class="p">(</span><span class="s1">'* /'</span><span class="p">),</span> <span class="mi">2</span><span class="p">,</span> <span class="n">OpAssoc</span><span class="o">.</span><span class="n">LEFT</span><span class="p">),</span> <span class="p">(</span><span class="n">one_of</span><span class="p">(</span><span class="s1">'+ -'</span><span class="p">),</span> <span class="mi">2</span><span class="p">,</span> <span class="n">OpAssoc</span><span class="o">.</span><span class="n">LEFT</span><span class="p">),</span> <span class="p">])</span> <span class="n">arith_expr</span><span class="o">.</span><span class="n">run_tests</span><span class="p">(</span><span class="s1">'''</span> <span class="s1"> 5+3*6</span> <span class="s1"> (5+3)*6</span> <span class="s1"> -2--11</span> <span class="s1"> '''</span><span class="p">,</span> <span class="n">full_dump</span><span class="o">=</span><span class="kc">False</span><span class="p">)</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">5</span><span class="o">+</span><span class="mi">3</span><span class="o">*</span><span class="mi">6</span> <span class="p">[[</span><span class="mi">5</span><span class="p">,</span> <span class="s1">'+'</span><span class="p">,</span> <span class="p">[</span><span class="mi">3</span><span class="p">,</span> <span class="s1">'*'</span><span class="p">,</span> <span class="mi">6</span><span class="p">]]]</span> <span class="p">(</span><span class="mi">5</span><span class="o">+</span><span class="mi">3</span><span class="p">)</span><span class="o">*</span><span class="mi">6</span> <span class="p">[[[</span><span class="mi">5</span><span class="p">,</span> <span class="s1">'+'</span><span class="p">,</span> <span class="mi">3</span><span class="p">],</span> <span class="s1">'*'</span><span class="p">,</span> <span class="mi">6</span><span class="p">]]</span> <span class="o">-</span><span class="mi">2</span><span class="o">--</span><span class="mi">11</span> <span class="p">[[[</span><span class="s1">'-'</span><span class="p">,</span> <span class="mi">2</span><span class="p">],</span> <span class="s1">'-'</span><span class="p">,</span> <span class="p">[</span><span class="s1">'-'</span><span class="p">,</span> <span class="mi">11</span><span class="p">]]]</span> </pre></div> </div> </dd></dl> <dl class="function"> <dt> <code class="descclassname">pyparsing.</code><code class="descname">locatedExpr</code><span class="sig-paren">(</span><em>expr: pyparsing.core.ParserElement</em><span class="sig-paren">)</span> → pyparsing.core.ParserElement</dt> <dd><p>(DEPRECATED - future code should use the Located class) Helper to decorate a returned token with its starting and ending locations in the input string.</p> <p>This helper adds the following results names:</p> <ul class="simple"> <li><code class="docutils literal notranslate"><span class="pre">locn_start</span></code> - location where matched expression begins</li> <li><code class="docutils literal notranslate"><span class="pre">locn_end</span></code> - location where matched expression ends</li> <li><code class="docutils literal notranslate"><span class="pre">value</span></code> - the actual parsed results</li> </ul> <p>Be careful if the input text contains <code class="docutils literal notranslate"><span class="pre"><TAB></span></code> characters, you may want to call <a class="reference internal" href="#pyparsing.ParserElement.parseWithTabs" title="pyparsing.ParserElement.parseWithTabs"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement.parseWithTabs</span></code></a></p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">wd</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)</span> <span class="k">for</span> <span class="n">match</span> <span class="ow">in</span> <span class="n">locatedExpr</span><span class="p">(</span><span class="n">wd</span><span class="p">)</span><span class="o">.</span><span class="n">searchString</span><span class="p">(</span><span class="s2">"ljsdf123lksdjjf123lkkjj1222"</span><span class="p">):</span> <span class="nb">print</span><span class="p">(</span><span class="n">match</span><span class="p">)</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[[</span><span class="mi">0</span><span class="p">,</span> <span class="s1">'ljsdf'</span><span class="p">,</span> <span class="mi">5</span><span class="p">]]</span> <span class="p">[[</span><span class="mi">8</span><span class="p">,</span> <span class="s1">'lksdjjf'</span><span class="p">,</span> <span class="mi">15</span><span class="p">]]</span> <span class="p">[[</span><span class="mi">18</span><span class="p">,</span> <span class="s1">'lkkjj'</span><span class="p">,</span> <span class="mi">23</span><span class="p">]]</span> </pre></div> </div> </dd></dl> <dl class="function"> <dt id="pyparsing.withClass"> <code class="descclassname">pyparsing.</code><code class="descname">withClass</code><span class="sig-paren">(</span><em>classname</em>, <em>namespace=''</em><span class="sig-paren">)</span><a class="headerlink" href="#pyparsing.withClass" title="Permalink to this definition">¶</a></dt> <dd><p>Simplified version of <a class="reference internal" href="#pyparsing.with_attribute" title="pyparsing.with_attribute"><code class="xref py py-class docutils literal notranslate"><span class="pre">with_attribute</span></code></a> when matching on a div class - made difficult because <code class="docutils literal notranslate"><span class="pre">class</span></code> is a reserved word in Python.</p> <p>Example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">html</span> <span class="o">=</span> <span class="s1">'''</span> <span class="s1"> <div></span> <span class="s1"> Some text</span> <span class="s1"> <div class="grid">1 4 0 1 0</div></span> <span class="s1"> <div class="graph">1,3 2,3 1,1</div></span> <span class="s1"> <div>this &lt;div&gt; has no class</div></span> <span class="s1"> </div></span> <span class="s1">'''</span> <span class="n">div</span><span class="p">,</span><span class="n">div_end</span> <span class="o">=</span> <span class="n">make_html_tags</span><span class="p">(</span><span class="s2">"div"</span><span class="p">)</span> <span class="n">div_grid</span> <span class="o">=</span> <span class="n">div</span><span class="p">()</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="n">with_class</span><span class="p">(</span><span class="s2">"grid"</span><span class="p">))</span> <span class="n">grid_expr</span> <span class="o">=</span> <span class="n">div_grid</span> <span class="o">+</span> <span class="n">SkipTo</span><span class="p">(</span><span class="n">div</span> <span class="o">|</span> <span class="n">div_end</span><span class="p">)(</span><span class="s2">"body"</span><span class="p">)</span> <span class="k">for</span> <span class="n">grid_header</span> <span class="ow">in</span> <span class="n">grid_expr</span><span class="o">.</span><span class="n">search_string</span><span class="p">(</span><span class="n">html</span><span class="p">):</span> <span class="nb">print</span><span class="p">(</span><span class="n">grid_header</span><span class="o">.</span><span class="n">body</span><span class="p">)</span> <span class="n">div_any_type</span> <span class="o">=</span> <span class="n">div</span><span class="p">()</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="n">with_class</span><span class="p">(</span><span class="n">withAttribute</span><span class="o">.</span><span class="n">ANY_VALUE</span><span class="p">))</span> <span class="n">div_expr</span> <span class="o">=</span> <span class="n">div_any_type</span> <span class="o">+</span> <span class="n">SkipTo</span><span class="p">(</span><span class="n">div</span> <span class="o">|</span> <span class="n">div_end</span><span class="p">)(</span><span class="s2">"body"</span><span class="p">)</span> <span class="k">for</span> <span class="n">div_header</span> <span class="ow">in</span> <span class="n">div_expr</span><span class="o">.</span><span class="n">search_string</span><span class="p">(</span><span class="n">html</span><span class="p">):</span> <span class="nb">print</span><span class="p">(</span><span class="n">div_header</span><span class="o">.</span><span class="n">body</span><span class="p">)</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">1</span> <span class="mi">4</span> <span class="mi">0</span> <span class="mi">1</span> <span class="mi">0</span> <span class="mi">1</span> <span class="mi">4</span> <span class="mi">0</span> <span class="mi">1</span> <span class="mi">0</span> <span class="mi">1</span><span class="p">,</span><span class="mi">3</span> <span class="mi">2</span><span class="p">,</span><span class="mi">3</span> <span class="mi">1</span><span class="p">,</span><span class="mi">1</span> </pre></div> </div> </dd></dl> <dl class="function"> <dt id="pyparsing.tokenMap"> <code class="descclassname">pyparsing.</code><code class="descname">tokenMap</code><span class="sig-paren">(</span><em>func</em>, <em>*args</em><span class="sig-paren">)</span> → Union[typing.Callable[[], typing.Any], typing.Callable[[pyparsing.results.ParseResults], typing.Any], typing.Callable[[int, pyparsing.results.ParseResults], typing.Any], typing.Callable[[str, int, pyparsing.results.ParseResults], typing.Any]]<a class="headerlink" href="#pyparsing.tokenMap" title="Permalink to this definition">¶</a></dt> <dd><p>Helper to define a parse action by mapping a function to all elements of a <a class="reference internal" href="#pyparsing.ParseResults" title="pyparsing.ParseResults"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParseResults</span></code></a> list. If any additional args are passed, they are forwarded to the given function as additional arguments after the token, as in <code class="docutils literal notranslate"><span class="pre">hex_integer</span> <span class="pre">=</span> <span class="pre">Word(hexnums).set_parse_action(token_map(int,</span> <span class="pre">16))</span></code>, which will convert the parsed data to an integer using base 16.</p> <p>Example (compare the last to example in <a class="reference internal" href="#pyparsing.ParserElement.transform_string" title="pyparsing.ParserElement.transform_string"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement.transform_string</span></code></a>:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">hex_ints</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">hexnums</span><span class="p">)[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="n">token_map</span><span class="p">(</span><span class="nb">int</span><span class="p">,</span> <span class="mi">16</span><span class="p">))</span> <span class="n">hex_ints</span><span class="o">.</span><span class="n">run_tests</span><span class="p">(</span><span class="s1">'''</span> <span class="s1"> 00 11 22 aa FF 0a 0d 1a</span> <span class="s1"> '''</span><span class="p">)</span> <span class="n">upperword</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="n">token_map</span><span class="p">(</span><span class="nb">str</span><span class="o">.</span><span class="n">upper</span><span class="p">))</span> <span class="n">upperword</span><span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span><span class="o">.</span><span class="n">run_tests</span><span class="p">(</span><span class="s1">'''</span> <span class="s1"> my kingdom for a horse</span> <span class="s1"> '''</span><span class="p">)</span> <span class="n">wd</span> <span class="o">=</span> <span class="n">Word</span><span class="p">(</span><span class="n">alphas</span><span class="p">)</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="n">token_map</span><span class="p">(</span><span class="nb">str</span><span class="o">.</span><span class="n">title</span><span class="p">))</span> <span class="n">wd</span><span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="o">...</span><span class="p">]</span><span class="o">.</span><span class="n">set_parse_action</span><span class="p">(</span><span class="s1">' '</span><span class="o">.</span><span class="n">join</span><span class="p">)</span><span class="o">.</span><span class="n">run_tests</span><span class="p">(</span><span class="s1">'''</span> <span class="s1"> now is the winter of our discontent made glorious summer by this sun of york</span> <span class="s1"> '''</span><span class="p">)</span> </pre></div> </div> <p>prints:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">00</span> <span class="mi">11</span> <span class="mi">22</span> <span class="n">aa</span> <span class="n">FF</span> <span class="mi">0</span><span class="n">a</span> <span class="mi">0</span><span class="n">d</span> <span class="mi">1</span><span class="n">a</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">17</span><span class="p">,</span> <span class="mi">34</span><span class="p">,</span> <span class="mi">170</span><span class="p">,</span> <span class="mi">255</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="mi">13</span><span class="p">,</span> <span class="mi">26</span><span class="p">]</span> <span class="n">my</span> <span class="n">kingdom</span> <span class="k">for</span> <span class="n">a</span> <span class="n">horse</span> <span class="p">[</span><span class="s1">'MY'</span><span class="p">,</span> <span class="s1">'KINGDOM'</span><span class="p">,</span> <span class="s1">'FOR'</span><span class="p">,</span> <span class="s1">'A'</span><span class="p">,</span> <span class="s1">'HORSE'</span><span class="p">]</span> <span class="n">now</span> <span class="ow">is</span> <span class="n">the</span> <span class="n">winter</span> <span class="n">of</span> <span class="n">our</span> <span class="n">discontent</span> <span class="n">made</span> <span class="n">glorious</span> <span class="n">summer</span> <span class="n">by</span> <span class="n">this</span> <span class="n">sun</span> <span class="n">of</span> <span class="n">york</span> <span class="p">[</span><span class="s1">'Now Is The Winter Of Our Discontent Made Glorious Summer By This Sun Of York'</span><span class="p">]</span> </pre></div> </div> </dd></dl> <dl class="function"> <dt id="pyparsing.conditionAsParseAction"> <code class="descclassname">pyparsing.</code><code class="descname">conditionAsParseAction</code><span class="sig-paren">(</span><em>fn: Union[typing.Callable[[], bool], typing.Callable[[pyparsing.results.ParseResults], bool], typing.Callable[[int, pyparsing.results.ParseResults], bool], typing.Callable[[str, int, pyparsing.results.ParseResults], bool]], message: str = None, fatal: bool = False</em><span class="sig-paren">)</span> → Union[typing.Callable[[], typing.Any], typing.Callable[[pyparsing.results.ParseResults], typing.Any], typing.Callable[[int, pyparsing.results.ParseResults], typing.Any], typing.Callable[[str, int, pyparsing.results.ParseResults], typing.Any]]<a class="headerlink" href="#pyparsing.conditionAsParseAction" title="Permalink to this definition">¶</a></dt> <dd><p>Function to convert a simple predicate function that returns <code class="docutils literal notranslate"><span class="pre">True</span></code> or <code class="docutils literal notranslate"><span class="pre">False</span></code> into a parse action. Can be used in places when a parse action is required and <a class="reference internal" href="#pyparsing.ParserElement.add_condition" title="pyparsing.ParserElement.add_condition"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParserElement.add_condition</span></code></a> cannot be used (such as when adding a condition to an operator level in <a class="reference internal" href="#pyparsing.infix_notation" title="pyparsing.infix_notation"><code class="xref py py-class docutils literal notranslate"><span class="pre">infix_notation</span></code></a>).</p> <p>Optional keyword arguments:</p> <ul class="simple"> <li><code class="docutils literal notranslate"><span class="pre">message</span></code> - define a custom message to be used in the raised exception</li> <li><code class="docutils literal notranslate"><span class="pre">fatal</span></code> - if True, will raise <a class="reference internal" href="#pyparsing.ParseFatalException" title="pyparsing.ParseFatalException"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParseFatalException</span></code></a> to stop parsing immediately; otherwise will raise <a class="reference internal" href="#pyparsing.ParseException" title="pyparsing.ParseException"><code class="xref py py-class docutils literal notranslate"><span class="pre">ParseException</span></code></a></li> </ul> </dd></dl> <dl class="function"> <dt id="pyparsing.autoname_elements"> <code class="descclassname">pyparsing.</code><code class="descname">autoname_elements</code><span class="sig-paren">(</span><span class="sig-paren">)</span> → None<a class="headerlink" href="#pyparsing.autoname_elements" title="Permalink to this definition">¶</a></dt> <dd><p>Utility to simplify mass-naming of parser elements, for generating railroad diagram with named subdiagrams.</p> </dd></dl> </div> </div> </div> </div> </div> </div> <div class="sphinxsidebar" role="navigation" aria-label="main navigation"> <div class="sphinxsidebarwrapper"> <h1 class="logo"><a href="index.html">PyParsing</a></h1> <h3>Navigation</h3> <p class="caption"><span class="caption-text">Contents:</span></p> <ul class="current"> <li class="toctree-l1"><a class="reference internal" href="whats_new_in_3_0_0.html">1 What’s New in Pyparsing 3.0.0</a></li> <li class="toctree-l1"><a class="reference internal" href="HowToUsePyparsing.html">1 Using the pyparsing module</a></li> <li class="toctree-l1 current"><a class="reference internal" href="modules.html">pyparsing</a><ul class="current"> <li class="toctree-l2 current"><a class="current reference internal" href="#">pyparsing module</a></li> </ul> </li> <li class="toctree-l1"><a class="reference internal" href="CODE_OF_CONDUCT.html">Contributor Covenant Code of Conduct</a></li> </ul> <div class="relations"> <h3>Related Topics</h3> <ul> <li><a href="index.html">Documentation overview</a><ul> <li><a href="modules.html">pyparsing</a><ul> <li>Previous: <a href="modules.html" title="previous chapter">pyparsing</a></li> <li>Next: <a href="CODE_OF_CONDUCT.html" title="next chapter">Contributor Covenant Code of Conduct</a></li> </ul></li> </ul></li> </ul> </div> <div id="searchbox" style="display: none" role="search"> <h3>Quick search</h3> <div class="searchformwrapper"> <form class="search" action="search.html" method="get"> <input type="text" name="q" /> <input type="submit" value="Go" /> <input type="hidden" name="check_keywords" value="yes" /> <input type="hidden" name="area" value="default" /> </form> </div> </div> <script type="text/javascript">$('#searchbox').show(0);</script> </div> </div> <div class="clearer"></div> </div> <div class="footer"> ©2018-2021, Paul T. McGuire. | Powered by <a href="http://sphinx-doc.org/">Sphinx 1.7.6</a> & <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.9</a> | <a href="_sources/pyparsing.rst.txt" rel="nofollow">Page source</a> </div> </body> </html>
💻
System Info
Current path
/opt/alt/python37/share/doc/alt-python37-pyparsing-doc/html
Contents
3 folders, 12 files
Disk free
101.12 GB
PHP version
8.3.30
🚀
Quick Actions
📍 Script location
🌐 Web root
🗑️ Temp
📁 /opt/alt/python37/share/doc/alt-python37-pyparsing-doc/html
⚡ Nexus File Manager • 15 items