Update dependency pyparsing to v2.4.7 by renovate[bot] · Pull Request #53 · sapcc/kubernetes-operators

renovate · 2022-07-21T20:19:12Z

This PR contains the following updates:

Package	Change	Age	Confidence
pyparsing	`==2.1.0` → `==2.4.7`

Warning

Some dependencies could not be looked up. Check the Dependency Dashboard for more information.

Release Notes

pyparsing/pyparsing (pyparsing)

`v2.4.7`

Compare Source

Backport of selected fixes from 3.0.0 work:
. Each bug with Regex expressions
. And expressions not properly constructing with generator
. Traceback abbreviation
. Bug in delta_time example
. Fix regexen in pyparsing_common.real and .sci_real
. Avoid FutureWarning on Python 3.7 or later
. Cleanup output in runTests if comments are embedded in test string

`v2.4.6`

Compare Source

Fixed typos in White mapping of whitespace characters, to use
correct "\u" prefix instead of "u".
Fix bug in left-associative ternary operators defined using
infixNotation. First reported on StackOverflow by user Jeronimo.
Backport of pyparsing_test namespace from 3.0.0, including
TestParseResultsAsserts mixin class defining unittest-helper
methods:
. def assertParseResultsEquals(
self, result, expected_list=None, expected_dict=None, msg=None)
. def assertParseAndCheckList(
self, expr, test_string, expected_list, msg=None, verbose=True)
. def assertParseAndCheckDict(
self, expr, test_string, expected_dict, msg=None, verbose=True)
. def assertRunTestResults(
self, run_tests_report, expected_parse_results=None, msg=None)
. def assertRaisesParseException(self, exc_type=ParseException, msg=None)

To use the methods in this mixin class, declare your unittest classes as:

from pyparsing import pyparsing_test as ppt
class MyParserTest(ppt.TestParseResultsAsserts, unittest.TestCase):
...

`v2.4.5`

Compare Source

NOTE: final release compatible with Python 2.x.
Fixed issue with reading README.rst as part of setup.py's
initialization of the project's long_description, with a
non-ASCII space character causing errors when installing from
source on platforms where UTF-8 is not the default encoding.

`v2.4.4`

Compare Source

Unresolved symbol reference in 2.4.3 release was masked by stdout
buffering in unit tests, thanks for the prompt heads-up, Ned
Batchelder!

`v2.4.3`

Compare Source

Fixed a bug in ParserElement.eq that would for some parsers
create a recursion error at parser definition time. Thanks to
Michael Clerx for the assist. (Addresses issue #123)
Fixed bug in indentedBlock where a block that ended at the end
of the input string could cause pyparsing to loop forever. Raised
as part of discussion on StackOverflow with geckos.
Backports from pyparsing 3.0.0:
. diag.enable_all_warnings()
. Fixed bug in PrecededBy which caused infinite recursion, issue #127
. support for using regex-compiled RE to construct Regex expressions

`v2.4.2`

Compare Source

Updated the shorthand notation that has been added for repetition
expressions: expr[min, max], with '...' valid as a min or max value:
- expr[...] and expr[0, ...] are equivalent to ZeroOrMore(expr)
- expr[1, ...] is equivalent to OneOrMore(expr)
- expr[n, ...] or expr[n,] is equivalent
  to expr*n + ZeroOrMore(expr)
  (read as "n or more instances of expr")
- expr[..., n] is equivalent to expr*(0, n)
- expr[m, n] is equivalent to expr*(m, n)
  Note that expr[..., n] and expr[m, n] do not raise an exception
  if more than n exprs exist in the input stream. If this
  behavior is desired, then write expr[..., n] + ~expr.
Better interpretation of [...] as ZeroOrMore raised by crowsonkb,
thanks for keeping me in line!

If upgrading from 2.4.1 or 2.4.1.1 and you have used expr[...]
for OneOrMore(expr), it must be updated to expr[1, ...].
The defaults on all the __diag__ switches have been set to False,
to avoid getting alarming warnings. To use these diagnostics, set
them to True after importing pyparsing.

Example:
```
import pyparsing as pp
pp.__diag__.warn_multiple_tokens_in_named_alternation = True
```
Fixed bug introduced by the use of getitem for repetition,
overlooking Python's legacy implementation of iteration
by sequentially calling getitem with increasing numbers until
getting an IndexError. Found during investigation of problem
reported by murlock, merci!

`v2.4.1.1`

Compare Source

This is a re-release of version 2.4.1 to restore the release history
in PyPI, since the 2.4.1 release was deleted.

There are 3 known issues in this release, which are fixed in
the upcoming 2.4.2:

API change adding support for expr[...] - the original
code in 2.4.1 incorrectly implemented this as OneOrMore.
Code using this feature under this release should explicitly
use expr[0, ...] for ZeroOrMore and expr[1, ...] for
OneOrMore. In 2.4.2 you will be able to write expr[...]
equivalent to ZeroOrMore(expr).
Bug if composing And, Or, MatchFirst, or Each expressions
using an expression. This only affects code which uses
explicit expression construction using the And, Or, etc.
classes instead of using overloaded operators '+', '^', and
so on. If constructing an And using a single expression,
you may get an error that "cannot multiply ParserElement by
0 or (0, 0)" or a Python IndexError. Change code like

cmd = Or(Word(alphas))

to

cmd = Or([Word(alphas)])

(Note that this is not the recommended style for constructing
Or expressions.)
Some newly-added __diag__ switches are enabled by default,
which may give rise to noisy user warnings for existing parsers.
You can disable them using:

import pyparsing as pp
pp.diag.warn_multiple_tokens_in_named_alternation = False
pp.diag.warn_ungrouped_named_tokens_in_collection = False
pp.diag.warn_name_set_on_empty_Forward = False
pp.diag.warn_on_multiple_string_args_to_oneof = False
pp.diag.enable_debug_on_named_expressions = False

In 2.4.2 these will all be set to False by default.

`v2.4.0`

Compare Source

Well, it looks like the API change that was introduced in 2.3.1 was more
drastic than expected, so for a friendlier forward upgrade path, this
release:
. Bumps the current version number to 2.4.0, to reflect this
incompatible change.
. Adds a pyparsing.compat object for specifying compatibility with
future breaking changes.
. Conditionalizes the API-breaking behavior, based on the value
pyparsing.compat.collect_all_And_tokens. By default, this value
will be set to True, reflecting the new bugfixed behavior. To set this
value to False, add to your code:
```
  import pyparsing
  pyparsing.__compat__.collect_all_And_tokens = False
```
. User code that is dependent on the pre-bugfix behavior can restore
it by setting this value to False.

In 2.5 and later versions, the conditional code will be removed and
setting the flag to True or False in these later versions will have no
effect.
Updated unitTests.py and simple_unit_tests.py to be compatible with
"python setup.py test". To run tests using setup, do:
```
python setup.py test
python setup.py test -s unitTests.suite
python setup.py test -s simple_unit_tests.suite
```
Prompted by issue #83 and PR submitted by bdragon28, thanks.
Fixed bug in runTests handling '\n' literals in quoted strings.

Added tag_body attribute to the start tag expressions generated by
makeHTMLTags, so that you can avoid using SkipTo to roll your own
tag body expression:

a, aEnd = pp.makeHTMLTags('a')
link = a + a.tag_body("displayed_text") + aEnd
for t in s.searchString(html_page):
    print(t.displayed_text, '->', t.startA.href)

indentedBlock failure handling was improved; PR submitted by TMiguelT,
thanks!
Address Py2 incompatibility in simpleUnitTests, plus explain() and
Forward str() cleanup; PRs graciously provided by eswald.
Fixed docstring with embedded '\w', which creates SyntaxWarnings in
Py3.8, issue #80.
Examples:
- Added example parser for rosettacode.org tutorial compiler.
- Added example to show how an HTML table can be parsed into a
  collection of Python lists or dicts, one per row.
- Updated SimpleSQL.py example to handle nested selects, reworked
  'where' expression to use infixNotation.
- Added include_preprocessor.py, similar to macroExpander.py.
- Examples using makeHTMLTags use new tag_body expression when
  retrieving a tag's body text.
- Updated examples that are runnable as unit tests:
```
python setup.py test -s examples.antlr_grammar_tests
python setup.py test -s examples.test_bibparse
```

`v2.3.1`

Compare Source

POSSIBLE API CHANGE: this release fixes a bug when results names were
attached to a MatchFirst or Or object containing an And object.
Previously, a results name on an And object within an enclosing MatchFirst
or Or could return just the first token in the And. Now, all the tokens
matched by the And are correctly returned. This may result in subtle
changes in the tokens returned if you have this condition in your pyparsing
scripts.
New staticmethod ParseException.explain() to help diagnose parse exceptions
by showing the failing input line and the trace of ParserElements in
the parser leading up to the exception. explain() returns a multiline
string listing each element by name. (This is still an experimental
method, and the method signature and format of the returned string may
evolve over the next few releases.)

Example:

define a parser to parse an integer followed by an

alphabetic word

    expr = pp.Word(pp.nums).setName("int")
           + pp.Word(pp.alphas).setName("word")
    try:

parse a string with a numeric second value instead of alpha

        expr.parseString("123 355")
    except pp.ParseException as pe:
        print(pp.ParseException.explain(pe))

Prints:
123 355
^
ParseException: Expected word (at char 4), (line:1, col:5)
main.ExplainExceptionTest
pyparsing.And - {int word}
pyparsing.Word - word

explain() will accept any exception type and will list the function
names and parse expressions in the stack trace. This is especially
useful when an exception is raised in a parse action.

Note: explain() is only supported under Python 3.

Fix bug in dictOf which could match an empty sequence, making it
infinitely loop if wrapped in a OneOrMore.
Added unicode sets to pyparsing_unicode for Latin-A and Latin-B ranges.
Added ability to define custom unicode sets as combinations of other sets
using multiple inheritance.

class Turkish_set(pp.pyparsing_unicode.Latin1, pp.pyparsing_unicode.LatinA):
pass

turkish_word = pp.Word(Turkish_set.alphas)
Updated state machine import examples, with state machine demos for:
. traffic light
. library book checkin/checkout
. document review/approval

In the traffic light example, you can use the custom 'statemachine' keyword
to define the states for a traffic light, and have the state classes
auto-generated for you:
```
statemachine TrafficLightState:
    Red -> Green
    Green -> Yellow
    Yellow -> Red
```
Similar for state machines with named transitions, like the library book
state example:
```
statemachine LibraryBookState:
    New -(shelve)-> Available
    Available -(reserve)-> OnHold
    OnHold -(release)-> Available
    Available -(checkout)-> CheckedOut
    CheckedOut -(checkin)-> Available
```
Once the classes are defined, then additional Python code can reference those
classes to add class attributes, instance methods, etc.

See the examples in examples/statemachine
Added an example parser for the decaf language. This language is used in
CS compiler classes in many colleges and universities.
Fixup of docstrings to Sphinx format, inclusion of test files in the source
package, and convert markdown to rst throughout the distribution, great job
by Matěj Cepl!
Expanded the whitespace characters recognized by the White class to include
all unicode defined spaces. Suggested in Issue #51 by rtkjbillo.
Added optional postParse argument to ParserElement.runTests() to add a
custom callback to be called for test strings that parse successfully. Useful
for running tests that do additional validation or processing on the parsed
results. See updated chemicalFormulas.py example.
Removed distutils fallback in setup.py. If installing the package fails,
please update to the latest version of setuptools. Plus overall project code
cleanup (CRLFs, whitespace, imports, etc.), thanks Jon Dufresne!
Fix bug in CaselessKeyword, to make its behavior consistent with
Keyword(caseless=True). Fixes Issue #65 reported by telesphore.

`v2.3.0`

Compare Source

NEW SUPPORT FOR UNICODE CHARACTER RANGES
This release introduces the pyparsing_unicode namespace class, defining
a series of language character sets to simplify the definition of alphas,
nums, alphanums, and printables in the following language sets:
. Arabic
. Chinese
. Cyrillic
. Devanagari
. Greek
. Hebrew
. Japanese (including Kanji, Katakana, and Hirigana subsets)
. Korean
. Latin1 (includes 7 and 8-bit Latin characters)
. Thai
. CJK (combination of Chinese, Japanese, and Korean sets)

For example, your code can define words using:

korean_word = Word(pyparsing_unicode.Korean.alphas)

See their use in the updated examples greetingInGreek.py and
greetingInKorean.py.

This namespace class also offers access to these sets using their
unicode identifiers.
POSSIBLE API CHANGE: Fixed bug where a parse action that explicitly
returned the input ParseResults could add another nesting level in
the results if the current expression had a results name.
```
  vals = pp.OneOrMore(pp.pyparsing_common.integer)("int_values")

  def add_total(tokens):
      tokens['total'] = sum(tokens)
      return tokens  # this line can be removed

  vals.addParseAction(add_total)
  print(vals.parseString("244 23 13 2343").dump())
```
Before the fix, this code would print (note the extra nesting level):

[244, 23, 13, 2343]
- int_values: [244, 23, 13, 2343]
  - int_values: [244, 23, 13, 2343]
  - total: 2623
- total: 2623
With the fix, this code now prints:

[244, 23, 13, 2343]
- int_values: [244, 23, 13, 2343]
- total: 2623
This fix will change the structure of ParseResults returned if a
program defines a parse action that returns the tokens that were
sent in. This is not necessary, and statements like "return tokens"
in the example above can be safely deleted prior to upgrading to
this release, in order to avoid the bug and get the new behavior.

Reported by seron in Issue #22, nice catch!
POSSIBLE API CHANGE: Fixed a related bug where a results name
erroneously created a second level of hierarchy in the returned
ParseResults. The intent for accumulating results names into ParseResults
is that, in the absence of Group'ing, all names get merged into a
common namespace. This allows us to write:
```
 key_value_expr = (Word(alphas)("key") + '=' + Word(nums)("value"))
 result = key_value_expr.parseString("a = 100")
```
and have result structured as {"key": "a", "value": "100"}
instead of [{"key": "a"}, {"value": "100"}].

However, if a named expression is used in a higher-level non-Group
expression that also has a name, a false sub-level would be created
in the namespace:
```
  num = pp.Word(pp.nums)
  num_pair = ("[" + (num("A") + num("B"))("values") + "]")
  U = num_pair.parseString("[ 10 20 ]")
  print(U.dump())
```
Since there is no grouping, "A", "B", and "values" should all appear
at the same level in the results, as:
```
  ['[', '10', '20', ']']
  - A: '10'
  - B: '20'
  - values: ['10', '20']
```
Instead, an extra level of "A" and "B" show up under "values":
```
  ['[', '10', '20', ']']
  - A: '10'
  - B: '20'
  - values: ['10', '20']
    - A: '10'
    - B: '20'
```
This bug has been fixed. Now, if this hierarchy is desired, then a
Group should be added:
```
  num_pair = ("[" + pp.Group(num("A") + num("B"))("values") + "]")
```
Giving:
```
  ['[', ['10', '20'], ']']
  - values: ['10', '20']
    - A: '10'
    - B: '20'
```
But in no case should "A" and "B" appear in multiple levels. This bug-fix
fixes that.

If you have current code which relies on this behavior, then add or remove
Groups as necessary to get your intended results structure.

Reported by Athanasios Anastasiou.
IndexError's raised in parse actions will get explicitly reraised
as ParseExceptions that wrap the original IndexError. Since
IndexError sometimes occurs as part of pyparsing's normal parsing
logic, IndexErrors that are raised during a parse action may have
gotten silently reinterpreted as parsing errors. To retain the
information from the IndexError, these exceptions will now be
raised as ParseExceptions that reference the original IndexError.
This wrapping will only be visible when run under Python3, since it
emulates "raise ... from ..." syntax.

Addresses Issue #4, reported by guswns0528.
Added Char class to simplify defining expressions of a single
character. (Char("abc") is equivalent to Word("abc", exact=1))
Added class PrecededBy to perform lookbehind tests. PrecededBy is
used in the same way as FollowedBy, passing in an expression that
must occur just prior to the current parse location.

For fixed-length expressions like a Literal, Keyword, Char, or a
Word with an exact or maxLen length given, PrecededBy(expr)
is sufficient. For varying length expressions like a Word with no
given maximum length, PrecededBy must be constructed with an
integer retreat argument, as in
PrecededBy(Word(alphas, nums), retreat=10), to specify the maximum
number of characters pyparsing must look backward to make a match.
pyparsing will check all the values from 1 up to retreat characters
back from the current parse location.

When stepping backwards through the input string, PrecededBy does
not skip over whitespace.

PrecededBy can be created with a results name so that, even though
it always returns an empty parse result, the result can include
named results.

Idea first suggested in Issue #30 by Freakwill.
Updated FollowedBy to accept expressions that contain named results,
so that results names defined in the lookahead expression will be
returned, even though FollowedBy always returns an empty list.
Inspired by the same feature implemented in PrecededBy.

`v2.2.2`

Compare Source

Fixed bug in SkipTo, if a SkipTo expression that was skipping to
an expression that returned a list (such as an And), and the
SkipTo was saved as a named result, the named result could be
saved as a ParseResults - should always be saved as a string.
Issue #28, reported by seron.
Added simple_unit_tests.py, as a collection of easy-to-follow unit
tests for various classes and features of the pyparsing library.
Primary intent is more to be instructional than actually rigorous
testing. Complex tests can still be added in the unitTests.py file.
New features added to the Regex class:
- optional asGroupList parameter, returns all the capture groups as
  a list
- optional asMatch parameter, returns the raw re.match result
- new sub(repl) method, which adds a parse action calling
  re.sub(pattern, repl, parsed_result). Simplifies creating
  Regex expressions to be used with transformString. Like re.sub,
  repl may be an ordinary string (similar to using pyparsing's
  replaceWith), or may contain references to capture groups by group
  number, or may be a callable that takes an re match group and
  returns a string.
  
  For instance:
  expr = pp.Regex(r"([Hh]\d):\s*(.*)").sub(r"<\1>\2</\1>")
  expr.transformString("h1: This is the title")
  
  will return
  This is the title
Fixed omission of LICENSE file in source tarball, also added
CODE_OF_CONDUCT.md per GitHub community standards.

`v2.2.1`

Compare Source

Applied changes necessary to migrate hosting of pyparsing source
over to GitHub. Many thanks for help and contributions from hugovk,
jdufresne, and cngkaygusuz among others through this transition,
sorry it took me so long!
Fixed import of collections.abc to address DeprecationWarnings
in Python 3.7.
Updated oc.py example to support function calls in arithmetic
expressions; fixed regex for '==' operator; and added packrat
parsing. Raised on the pyparsing wiki by Boris Marin, thanks!
Fixed bug in select_parser.py example, group_by_terms was not
reported. Reported on SF bugs by Adam Groszer, thanks Adam!
Added "Getting Started" section to the module docstring, to
guide new users to the most common starting points in pyparsing's
API.
Fixed bug in Literal and Keyword classes, which erroneously
raised IndexError instead of ParseException.

`v2.2.0`

Compare Source

Bumped minor version number to reflect compatibility issues with
OneOrMore and ZeroOrMore bugfixes in 2.1.10. (2.1.10 fixed a bug
that was introduced in 2.1.4, but the fix could break code
written against 2.1.4 - 2.1.9.)
Updated setup.py to address recursive import problems now
that pyparsing is part of 'packaging' (used by setuptools).
Patch submitted by Joshua Root, much thanks!
Fixed KeyError issue reported by Yann Bizeul when using packrat
parsing in the Graphite time series database, thanks Yann!
Fixed incorrect usages of '' in literals, as described in
https://docs.python.org/3/whatsnew/3.6.html#deprecated-python-behavior
Patch submitted by Ville Skyttä - thanks!
Minor internal change when using '-' operator, to be compatible
with ParserElement.streamline() method.
Expanded infixNotation to accept a list or tuple of parse actions
to attach to an operation.
New unit test added for dill support for storing pyparsing parsers.
Ordinary Python pickle can be used to pickle pyparsing parsers as
long as they do not use any parse actions. The 'dill' module is an
extension to pickle which does support pickling of attached
parse actions.

`v2.1.10`

Compare Source

Fixed bug in reporting named parse results for ZeroOrMore
expressions, thanks Ethan Nash for reporting this!
Fixed behavior of LineStart to be much more predictable.
LineStart can now be used to detect if the next parse position
is col 1, factoring in potential leading whitespace (which would
cause LineStart to fail). Also fixed a bug in col, which is
used in LineStart, where '\n's were erroneously considered to
be column 1.
Added support for multiline test strings in runTests.
Fixed bug in ParseResults.dump when keys were not strings.
Also changed display of string values to show them in quotes,
to help distinguish parsed numeric strings from parsed integers
that have been converted to Python ints.

`v2.1.9`

Compare Source

Added class CloseMatch, a variation on Literal which matches
"close" matches, that is, strings with at most 'n' mismatching
characters.
Fixed bug in Keyword.setDefaultKeywordChars(), reported by Kobayashi
Shinji - nice catch, thanks!
Minor API change in pyparsing_common. Renamed some of the common
expressions to PEP8 format (to be consistent with the other
pyparsing_common expressions):
. signedInteger -> signed_integer
. sciReal -> sci_real

Also, in trying to stem the API bloat of pyparsing, I've copied
some of the global expressions and helper parse actions into
pyparsing_common, with the originals to be deprecated and removed
in a future release:
. commaSeparatedList -> pyparsing_common.comma_separated_list
. upcaseTokens -> pyparsing_common.upcaseTokens
. downcaseTokens -> pyparsing_common.downcaseTokens

(I don't expect any other expressions, like the comment expressions,
quotedString, or the Word-helping strings like alphas, nums, etc.
to migrate to pyparsing_common - they are just too pervasive. As for
the PEP8 vs camelCase naming, all the expressions are PEP8, while
the parse actions in pyparsing_common are still camelCase. It's a
small step - when pyparsing 3.0 comes around, everything will change
to PEP8 snake case.)
Fixed Python3 compatibility bug when using dict keys() and values()
in ParseResults.getName().
After some prodding, I've reworked the unitTests.py file for
pyparsing over the past few releases. It uses some variations on
unittest to handle my testing style. The test now:
. auto-discovers its test classes (while maintining their order
of definition)
. suppresses voluminous 'print' output for tests that pass

`v2.1.8`

Compare Source

Fixed issue in the optimization to _trim_arity, when the full
stacktrace is retrieved to determine if a TypeError is raised in
pyparsing or in the caller's parse action. Code was traversing
the full stacktrace, and potentially encountering UnicodeDecodeError.
Fixed bug in ParserElement.inlineLiteralsUsing, causing infinite
loop with Suppress.
Fixed bug in Each, when merging named results from multiple
expressions in a ZeroOrMore or OneOrMore. Also fixed bug when
ZeroOrMore expressions were erroneously treated as required
expressions in an Each expression.
Added a few more inline doc examples.
Improved use of runTests in several example scripts.

`v2.1.7`

Compare Source

Fixed regression reported by Andrea Censi (surfaced in PyContracts
tests) when using ParseSyntaxExceptions (raised when using operator '-')
with packrat parsing.
Minor fix to oneOf, to accept all iterables, not just space-delimited
strings and lists. (If you have a list or set of strings, it is
not necessary to concat them using ' '.join to pass them to oneOf,
oneOf will accept the list or set or generator directly.)

`v2.1.6`

Compare Source

Major packrat upgrade, inspired by patch provided by Tal Einat -
many, many, thanks to Tal for working on this! Tal's tests show
faster parsing performance (2X in some tests), and memory reduction
from 3GB down to ~100MB! Requires no changes to existing code using
packratting. (Uses OrderedDict, available in Python 2.7 and later.
For Python 2.6 users, will attempt to import from ordereddict
backport. If not present, will implement pure-Python Fifo dict.)
Minor API change - to better distinguish between the flexible
numeric types defined in pyparsing_common, I've changed "numeric"
(which parsed numbers of different types and returned int for ints,
float for floats, etc.) and "number" (which parsed numbers of int
or float type, and returned all floats) to "number" and "fnumber"
respectively. I hope the "f" prefix of "fnumber" will be a better
indicator of its internal conversion of parsed values to floats,
while the generic "number" is similar to the flexible number syntax
in other languages. Also fixed a bug in pyparsing_common.numeric
(now renamed to pyparsing_common.number), integers were parsed and
returned as floats instead of being retained as ints.
Fixed bug in upcaseTokens and downcaseTokens introduced in 2.1.5,
when the parse action was used in conjunction with results names.
Reported by Steven Arcangeli from the dql project, thanks for your
patience, Steven!
Major change to docs! After seeing some comments on reddit about
general issue with docs of Python modules, and thinking that I'm a
little overdue in doing some doc tuneup on pyparsing, I decided to
following the suggestions of the redditor and add more inline examples
to the pyparsing reference documentation. I hope this addition
will clarify some of the more common questions people have, especially
when first starting with pyparsing/Python.
Deprecated ParseResults.asXML. I've never been too happy with this
method, and it usually forces some unnatural code in the parsers in
order to get decent tag names. The amount of guesswork that asXML
has to do to try to match names with values should have been a red
flag from day one. If you are using asXML, you will need to implement
your own ParseResults->XML serialization. Or consider migrating to
a more current format such as JSON (which is very easy to do:
results_as_json = json.dumps(parse_result.asDict()) Hopefully, when
I remove this code in a future version, I'll also be able to simplify
some of the craziness in ParseResults, which IIRC was only there to try
to make asXML work.
Updated traceParseAction parse action decorator to show the repr
of the input and output tokens, instead of the str format, since
str has been simplified to just show the token list content.

(The change to ParseResults.str occurred in pyparsing 2.0.4, but
it seems that didn't make it into the release notes - sorry! Too
many users, especially beginners, were confused by the
"([token_list], {names_dict})" str format for ParseResults, thinking
they were getting a tuple containing a list and a dict. The full form
can be seen if using repr().)

For tracing tokens in and out of parse actions, the more complete
repr form provides important information when debugging parse actions.

`v2.1.5`

Compare Source

Added ParserElement.split() generator method, similar to re.split().
Includes optional arguments maxsplit (to limit the number of splits),
and includeSeparators (to include the separating matched text in the
returned output, default=False).

Added a new parse action construction helper tokenMap, which will
apply a function and optional arguments to each element in a
ParseResults. So this parse action:

def lowercase_all(tokens):
    return [str(t).lower() for t in tokens]
OneOrMore(Word(alphas)).setParseAction(lowercase_all)

can now be written:

OneOrMore(Word(alphas)).setParseAction(tokenMap(str.lower))

Also simplifies writing conversion parse actions like:

integer = Word(nums).setParseAction(lambda t: int(t[0]))

to just:

integer = Word(nums).setParseAction(tokenMap(int))

If additional arguments are necessary, they can be included in the
call to tokenMap, as in:

hex_integer = Word(hexnums).setParseAction(tokenMap(int, 16))

Added more expressions to pyparsing_common:
. IPv4 and IPv6 addresses (including long, short, and mixed forms
of IPv6)
. MAC address
. ISO8601 date and date time strings (with named fields for year, month, etc.)
. UUID (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx)
. hex integer (returned as int)
. fraction (integer '/' integer, returned as float)
. mixed integer (integer '-' fraction, or just fraction, returned as float)
. stripHTMLTags (parse action to remove tags from HTML source)
. parse action helpers convertToDate and convertToDatetime to do custom parse
time conversions of parsed ISO8601 strings
runTests now returns a two-tuple: success if all tests succeed,
and an output list of each test and its output lines.
Added failureTests argument (default=False) to runTests, so that
tests can be run that are expected failures, and runTests' success
value will return True only if all tests fail as expected. Also,
parseAll now defaults to True.
New example numerics.py, shows samples of parsing integer and real
numbers using locale-dependent formats:

4.294.967.295,000
4 294 967 295,000
4,294,967,295.000

`v2.1.4`

Compare Source

Split out the '==' behavior in ParserElement, now implemented
as the ParserElement.matches() method. Using '==' for string test
purposes will be removed in a future release.
Expanded capabilities of runTests(). Will now accept embedded
comments (default is Python style, leading '#' character, but
customizable). Comments will be emitted along with the tests and
test output. Useful during test development, to create a test string
consisting only of test case description comments separated by
blank lines, and then fill in the test cases. Will also highlight
ParseFatalExceptions with "(FATAL)".
Added a 'pyparsing_common' class containing common/helpful little
expressions such as integer, float, identifier, etc. I used this
class as a sort of embedded namespace, to contain these helpers
without further adding to pyparsing's namespace bloat.
Minor enhancement to traceParseAction decorator, to retain the
parse action's name for the trace output.
Added optional 'fatal' keyword arg to addCondition, to indicate that
a condition failure should halt parsing immediately.

`v2.1.3`

Compare Source

_trim_arity fix in 2.1.2 was very version-dependent on Py 3.5.0.
Now works for Python 2.x, 3.3, 3.4, 3.5.0, and 3.5.1 (and hopefully
beyond).

`v2.1.2`

Compare Source

Fixed bug in _trim_arity when pyparsing code is included in a
PyInstaller, reported by maluwa.
Fixed catastrophic regex backtracking in implementation of the
quoted string expressions (dblQuotedString, sglQuotedString, and
quotedString). Reported on the pyparsing wiki by webpentest,
good catch! (Also tuned up some other expressions susceptible to the
same backtracking problem, such as cStyleComment, cppStyleComment,
etc.)

`v2.1.1`

Compare Source

Fixed bug in reporting named parse results for ZeroOrMore
expressions, thanks Ethan Nash for reporting this!
Fixed behavior of LineStart to be much more predictable.
LineStart can now be used to detect if the next parse position
is col 1, factoring in potential leading whitespace (which would
cause LineStart to fail). Also fixed a bug in col, which is
used in LineStart, where '\n's were erroneously considered to
be column 1.
Added support for multiline test strings in runTests.
Fixed bug in ParseResults.dump when keys were not strings.
Also changed display of string values to show them in quotes,
to help distinguish parsed numeric strings from parsed integers
that have been converted to Python ints.

Configuration

📅 Schedule: Branch creation - At any time (no schedule defined), Automerge - At any time (no schedule defined).

🚦 Automerge: Disabled by config. Please merge this manually once you are satisfied.

♻ Rebasing: Whenever PR becomes conflicted, or you tick the rebase/retry checkbox.

🔕 Ignore: Close this PR and you won't be reminded about this update again.

If you want to rebase/retry this PR, check this box

This PR was generated by Mend Renovate. View the repository job log.

renovate Bot force-pushed the renovate/pyparsing-2.x branch from 3b5d1c2 to b80b074 Compare January 9, 2023 18:19

Update dependency pyparsing to v2.4.7

d057548

renovate Bot force-pushed the renovate/pyparsing-2.x branch from b80b074 to d057548 Compare September 26, 2025 07:52

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Update dependency pyparsing to v2.4.7#53

Update dependency pyparsing to v2.4.7#53
renovate[bot] wants to merge 1 commit into
masterfrom
renovate/pyparsing-2.x

renovate Bot commented Jul 21, 2022 •

edited

Loading

This is the title

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

0 participants

Uh oh!

Conversation

renovate Bot commented Jul 21, 2022 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Release Notes

define a parser to parse an integer followed by an

alphabetic word

parse a string with a numeric second value instead of alpha

This is the title

Configuration

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

0 participants

renovate Bot commented Jul 21, 2022 •

edited

Loading