All Versions
85
Latest Version
4.7
Avg Release Cycle
48 days
Latest Release
904 days ago

Changelog History
Page 1

  • v4.7 Changes

    April 05, 2020

    ๐Ÿ”– Version 2.4.7 - April, 2020

    • ๐Ÿ›  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
  • v4.6 Changes

    December 25, 2019

    ๐Ÿ”– Version 2.4.6 - December, 2019

    ๐Ÿ›  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):
    ...

  • v4.5 Changes

    November 10, 2019

    ๐Ÿ”– Version 2.4.5 - November, 2019

    • ๐Ÿ›  Fixed encoding when setup.py reads README.rst to include the
      project long description when uploading to PyPI. A stray
      unicode space in README.rst prevented the source install on
      0๏ธโƒฃ systems whose default encoding is not 'utf-8'.
  • v4.4 Changes

    November 05, 2019

    โœ… Check-in bug in Pyparsing 2.4.3 that raised UserWarnings was masked by stdout buffering in unit tests - fixed.

  • v4.3 Changes

    November 04, 2019

    ๐Ÿ”– Version 2.4.3 - November, 2019

    ๐Ÿš‘ (Backport of selected critical items from 3.0.0 development branch.)

    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

  • v4.2 Changes

    July 30, 2019

    ๐Ÿ”– Version 2.4.2 - July, 2019

    โšก๏ธ 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!

  • v4.2.a1 Changes

    July 25, 2019

    ๐Ÿš€ Release candidate for 2.4.2:

    • ๐Ÿ›  FIxes incorrect implementation of expr[โ€ฆ] as OneOrMore, changed to ZeroOrMore
    • Fixes __getitem__-induced iterability for ParserElement class
    • __diag__ flags are now all False by default
  • v4.1.1 Changes

    July 25, 2019

    ๐Ÿš€ 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 relase 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
    

    0๏ธโƒฃ In 2.4.2 these will all be set to False by default.

  • v3.0.0.a2 Changes

    June 01, 2020
    • ๐Ÿ“œ Summary of changes for 3.0.0 can be found in "What's New in Pyparsing 3.0.0" documentation.

    • API CHANGE Changed result returned when parsing using countedArray, the array items are no longer returned in a doubly-nested list.

    • An excellent new enhancement is the new railroad diagram generator for documenting pyparsing parsers:

      import pyparsing as pp
      from pyparsing.diagram import to_railroad, railroad_to_html
      from pathlib import Path
      
      # define a simple grammar for parsing street addresses such
      # as "123 Main Street"
      #     number word...
      number = pp.Word(pp.nums).setName("number")
      name = pp.Word(pp.alphas).setName("word")[1, ...]
      
      parser = number("house_number") + name("street")
      parser.setName("street address")
      
      # construct railroad track diagram for this parser and
      # save as HTML
      rr = to_railroad(parser)
      Path('parser_rr_diag.html').write_text(railroad_to_html(rr))
      

    Very nice work provided by Michael Milton, thanks a ton!

    • โœจ Enhanced default strings created for Word expressions, now showing string ranges if possible. Word(alphas) would formerly print as W:(ABCD...), now prints as W:(A-Za-z).

    • โž• Added ignoreWhitespace(recurse:bool = True) and added a recurse argument to leaveWhitespace, both added to provide finer control over pyparsing's whitespace skipping. Also contributed by Michael Milton.

    • The unicode range definitions for the various languages were recalculated by interrogating the unicodedata module by character name, selecting characters that contained that language in their Unicode name. (Issue #227)

    Also, pyparsing_unicode.Korean was renamed to Hangul (Korean is also defined as a synonym for compatibility).

    • โœจ Enhanced ParseResults dump() to show both results names and list subitems. Fixes bug where adding a results name would hide lower-level structures in the ParseResults.

    • Added new diag warnings:

      "warn_on_parse_using_empty_Forward" - warns that a Forward has been included in a grammar, but no expression was attached to it using '<<=' or '<<'

      "warn_on_assignment_to_Forward" - warns that a Forward has been created, but was probably later overwritten by erroneously using '=' instead of '<<=' (this is a common mistake when using Forwards) (currently not working on PyPy)

    • โž• Added ParserElement.recurse() method to make it simpler for grammar utilities to navigate through the tree of expressions in a pyparsing grammar.

    • ๐Ÿ›  Fixed bug in ParseResults repr() which showed all matching entries for a results name, even if listAllMatches was set to False when creating the ParseResults originally. Reported by Nicholas42 on GitHub, good catch! (Issue #205)

    • ๐Ÿ”จ Modified refactored modules to use relative imports, as pointed out by setuptools project member jaraco, thank you!

    • Off-by-one bug found in the roman_numerals.py example, a bug that has been there for about 14 years! PR submitted by Jay Pedersen, nice catch!

    • ๐Ÿ“œ A simplified Lua parser has been added to the examples (lua_parser.py).

    • โž• Added make_diagram.py to the examples directory to demonstrate creation of railroad diagrams for selected pyparsing examples. Also restructured some examples to make their parsers importable without running their embedded tests.

  • v3.0.0.a1 Changes

    April 01, 2020
    • โœ‚ Removed Py2.x support and other deprecated features. Pyparsing now requires Python 3.5 or later. If you are using an earlier version of Python, you must use a Pyparsing 2.4.x version

    Deprecated features removed: . ParseResults.asXML() - if used for debugging, switch to using ParseResults.dump(); if used for data transfer, use ParseResults.asDict() to convert to a nested Python dict, which can then be converted to XML or JSON or other transfer format

    . operatorPrecedence synonym for infixNotation - convert to calling infixNotation

    . commaSeparatedList - convert to using pyparsing_common.comma_separated_list

    . upcaseTokens and downcaseTokens - convert to using pyparsing_common.upcaseTokens and downcaseTokens

    . compat.collect_all_And_tokens will not be settable to False to revert to pre-2.3.1 results name behavior - review use of names for MatchFirst and Or expressions containing And expressions, as they will return the complete list of parsed tokens, not just the first one. Use __diag__.warn_multiple_tokens_in_named_alternation to help identify those expressions in your parsers that will have changed as a result.

    • โœ‚ Removed support for running python setup.py test. The setuptools maintainers consider the test command deprecated (see https://github.com/pypa/setuptools/issues/1684). To run the Pyparsing test, use the command tox.

    • API CHANGE: The staticmethod ParseException.explain has been moved to ParseBaseException.explain_exception, and a new explain instance method added to ParseBaseException. This will make calls to explain much more natural:

      try: expr.parseString("...") except ParseException as pe: print(pe.explain())

    • POTENTIAL API CHANGE: ZeroOrMore expressions that have results names will now include empty lists for their name if no matches are found. Previously, no named result would be present. Code that tested for the presence of any expressions using "if name in results:" will now always return True. This code will need to change to "if name in results and results[name]:" or just "if results[name]:". Also, any parser unit tests that check the asDict() contents will now see additional entries for parsers having named ZeroOrMore expressions, whose values will be [].

    • POTENTIAL API CHANGE: Fixed a bug in which calls to ParserElement.setDefaultWhitespaceChars did not change whitespace definitions on any pyparsing built-in expressions defined at import time (such as quotedString, or those defined in pyparsing_common). This would lead to confusion when built-in expressions would not use updated default whitespace characters. Now a call to ParserElement.setDefaultWhitespaceChars will also go and update all pyparsing built-ins to use the new default whitespace characters. (Note that this will only modify expressions defined within the pyparsing module.) Prompted by work on a StackOverflow question posted by jtiai.

    • Expanded diag and compat to actual classes instead of just namespaces, to add some helpful behavior:

      • enable() and .disable() methods to give extra help when setting or clearing flags (detects invalid flag names, detects when trying to set a compat flag that is no longer settable). Use these methods now to set or clear flags, instead of directly setting to True or False.

        import pyparsing as pp pp.diag.enable("warn_multiple_tokens_in_named_alternation")

      • diag.enable_all_warnings() is another helper that sets all "warn*" diagnostics to True.

        pp.diag.enable_all_warnings()

      • added new warning, "warn_on_match_first_with_lshift_operator" to warn when using '<<' with a '|' MatchFirst operator, which will create an unintended expression due to precedence of operations.

      Example: This statement will erroneously define the fwd expression as just expr_a, even though expr_a | expr_b was intended, since '<<' operator has precedence over '|':

      fwd << expr_a | expr_b
      

      To correct this, use the '<<=' operator (preferred) or parentheses to override operator precedence:

      fwd <<= expr_a | expr_b
               or
      fwd << (expr_a | expr_b)
      
    • ๐Ÿ‘€ Cleaned up default tracebacks when getting a ParseException when calling parseString. Exception traces should now stop at the call in parseString, and not include the internal traceback frames. (If the full traceback is desired, then set ParserElement.verbose_traceback to True.)

    • ๐Ÿ›  Fixed FutureWarnings that sometimes are raised when '[' passed as a character to Word.

    • ๐Ÿ†• New namespace, assert methods and classes added to support writing unit tests.

      • assertParseResultsEquals
      • assertParseAndCheckList
      • assertParseAndCheckDict
      • assertRunTestResults
      • assertRaisesParseException
      • reset_pyparsing_context context manager, to restore pyparsing config settings
    • โœจ Enhanced error messages and error locations when parsing fails on the Keyword or CaselessKeyword classes due to the presence of a preceding or trailing keyword character. Surfaced while working with metaperl on issue #201.

    • โœจ Enhanced the Regex class to be compatible with re's compiled with the re-equivalent regex module. Individual expressions can be built with regex compiled expressions using:

      import pyparsing as pp import regex

      would use regex for this expression

      integer_parser = pp.Regex(regex.compile(r'\d+'))

    Inspired by PR submitted by bjrnfrdnnd on GitHub, very nice!

    • ๐Ÿ›  Fixed handling of ParseSyntaxExceptions raised as part of Each expressions, when sub-expressions contain '-' backtrack suppression. As part of resolution to a question posted by John Greene on StackOverflow.

    • Potentially huge performance enhancement when parsing Word expressions built from pyparsing_unicode character sets. Word now internally converts ranges of consecutive characters to regex character ranges (converting "0123456789" to "0-9" for instance), resulting in as much as 50X improvement in performance! Work inspired by a question posted by Midnighter on StackOverflow.

    • ๐Ÿ‘Œ Improvements in select_parser.py, to include new SQL syntax from SQLite. PR submitted by Robert Coup, nice work!

    • ๐Ÿ›  Fixed bug in PrecededBy which caused infinite recursion, issue #127 submitted by EdwardJB.

    • ๐Ÿ›  Fixed bug in CloseMatch where end location was incorrectly computed; and updated partial_gene_match.py example.

    • ๐Ÿ›  Fixed bug in indentedBlock with a parser using two different types of nested indented blocks with different indent values, but sharing the same indent stack, submitted by renzbagaporo.

    • ๐Ÿ›  Fixed bug in Each when using Regex, when Regex expression would get parsed twice; issue #183 submitted by scauligi, thanks!

    • ๐Ÿ“œ BigQueryViewParser.py added to examples directory, PR submitted by Michael Smedberg, nice work!

    • ๐Ÿ“œ booleansearchparser.py added to examples directory, PR submitted by xecgr. Builds on searchparser.py, adding support for '*' wildcards and non-Western alphabets.

    • ๐Ÿ›  Fixed bug in delta_time.py example, when using a quantity of seconds/minutes/hours/days > 999.

    • ๐Ÿ›  Fixed bug in regex definitions for real and sci_real expressions in pyparsing_common. Issue #194, reported by Michael Wayne Goodman, thanks!

    • ๐Ÿ›  Fixed FutureWarning raised beginning in Python 3.7 for Regex expressions containing '[' within a regex set.

    • โœ… Minor reformatting of output from runTests to make embedded comments more visible.

    • And finally, many thanks to those who helped in the restructuring of the pyparsing code base as part of this release. Pyparsing now has more standard package structure, more standard unit tests, and more standard code formatting (using black). Special thanks to jdufresne, klahnakoski, mattcarmody, and ckeygusuz, to name just a few.