pyparsing changelog

Changelog History

Page 9

• v1.0.1 Changes

  December 17, 2003

  • NOTE: Changed API!

    • Renamed 'len' argument on Word.init() to 'exact'

  • 🐎 Performance speed-up, 10-30%

• v1.0.0 Changes

  December 15, 2003

  • 🎉 Initial public release

• v0.1.1 Changes

  • 🎉 initial development iterations:
    • added Dict, Group
    • added helper methods oneOf, delimitedList
    • added helpers quotedString (and double and single), restOfLine, cStyleComment
    • added MatchFirst as an alternative to the slower Or
    • added UML class diagram
    • fixed various logic bugs

• v0.0.b1 Changes

  November 03, 2020

  API CHANGE
  🚚 Diagnostic flags have been moved to an enum, pyparsing.Diagnostics, and they are enabled through module-level methods:

  • pyparsing.enable_diag()
  • pyparsing.disable_diag()

  - pyparsing.enable_all_warnings()

  API CHANGE
  ⚠ Most previous SyntaxWarnings that were warned when using pyparsing classes incorrectly have been converted to TypeError and ValueError exceptions, consistent with Python calling conventions. All warnings warned by diagnostic flags have been converted from SyntaxWarnings to UserWarnings.

  👀 To support parsers that are intended to generate native Python collection types such as lists and dicts, the Group and Dict classes now accept an additional boolean keyword argument aslist and asdict respectively. See the jsonParser.py example in the pyparsing/examples source directory for how to return types as ParseResults and as Python collection types, and the distinctions in working with the different types.

  0️⃣ In addition parse actions that must return a value of list type (which would normally be converted internally to a ParseResults) can override this default behavior by returning their list wrapped in the new ParseResults.List class:

  # this parse action tries to return a list, but pyparsing
  # will convert to a ParseResults
  def return_as_list_but_still_get_parse_results(tokens):
      return tokens.asList()
  
  # this parse action returns the tokens as a list, and pyparsing will
  # maintain its list type in the final parsing results
  def return_as_list(tokens):
      return ParseResults.List(tokens.asList())
  

  This is the mechanism used internally by the Group class when defined using aslist=True.

  A new IndentedBlock class is introduced, to eventually replace the current indentedBlock helper method. The interface is largely the same, however, the new class manages its own internal indentation stack, so it is no longer necessary to maintain an external indentStack variable.

  API CHANGE
  📜 Added cache_hit keyword argument to debug actions. Previously, if packrat parsing was enabled, the debug methods were not called in the event of cache hits. Now these methods will be called, with an added argument cache_hit=True.

  📜 If you are using packrat parsing and enable debug on expressions using a custom debug method, you can add the cache_hit=False keyword argument,
  and your method will be called on packrat cache hits. If you choose not to add this keyword argument, the debug methods will fail silently, behaving as they did previously.

  👀 When using setDebug with packrat parsing enabled, packrat cache hits will now be included in the output, shown with a leading '*'. (Previously, cache hits and responses were not included in debug output.) For those using custom debug actions, see the previous item regarding an optional API change for those methods.

  📜 setDebug output will also show more details about what expression is about to be parsed (the current line of text being parsed, and the current parse position):

    Match integer at loc 0(1,1)
      1 2 3
      ^
    Matched integer -> ['1']
  

  📜 The current debug location will also be indicated after whitespace has been skipped (was previously inconsistent, reported in Issue #244, by Frank Goyens, thanks!).

  📜 Modified the repr() output for ParseResults to include the class name as part of the output. This is to clarify for new pyparsing users who misread the repr output as a tuple of a list and a dict. pyparsing results will now read like:

  ParseResults(['abc', 'def'], {'qty': 100}]
  

  instead of just:

  (['abc', 'def'], {'qty': 100}]
  

  🛠 Fixed bugs in Each when passed OneOrMore or ZeroOrMore expressions:
  . first expression match could be enclosed in an extra nesting level
  . out-of-order expressions now handled correctly if mixed with required expressions
  . results names are maintained correctly for these expressions

  ⏪ Fixed traceback trimming, and added ParserElement.verbose_traceback save/restore to reset_pyparsing_context().

  0️⃣ Default string for Word expressions now also include indications of min and max length specification, if applicable, similar to regex length specifications:

    Word(alphas) -> "W:(A-Za-z)"
    Word(nums) -> "W:(0-9)"
    Word(nums, exact=3) -> "W:(0-9){3}"
    Word(nums, min=2) -> "W:(0-9){2,...}"
    Word(nums, max=3) -> "W:(0-9){1,3}"
    Word(nums, min=2, max=3) -> "W:(0-9){2,3}"
  

  For expressions of the Char class (similar to Word(..., exact=1), the expression is simply the character range in parentheses:

    Char(nums) -> "(0-9)"
    Char(alphas) -> "(A-Za-z)"
  

  ✂ Removed copy() override in Keyword class which did not preserve definition of ident chars from the original expression. PR #233 submitted by jgrey4296, thanks!

  🔖 In addition to pyparsing. __version__, there is now also a pyparsing. __version_info__, following the same structure and field names as in sys.version_info.

• v0.0.a2 Changes

  June 28, 2020

  🔖 Version 3.0.0a2 - June, 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.

• « First
• ‹ Prev
• 5
• 6
• 7
• 8
• 9