------------------------------------------------------------------- Tue Sep 17 13:15:51 UTC 2013 - speilicke@suse.com - Update to version 2.0.1: - Removed use of "nonlocal" that prevented using this version of pyparsing with Python 2.6 and 2.7. This will make it easier to install for packages that depend on pyparsing, under Python versions 2.6 and later. Those using older versions of Python will have to manually install pyparsing 1.5.7. - Fixed implementation of <<= operator to return self; reported by Luc J. Bourhis, with patch fix by Mathias Mamsch - thanks, Luc and Mathias! - Changes from version 2.0.0: - Rather than release another combined Python 2.x/3.x release I've decided to start a new major version that is only compatible with Python 3.x (and consequently Python 2.7 as well due to backporting of key features). This version will be the main development path from now on, with little follow-on development on the 1.5.x path. - Operator '<<' is now deprecated, in favor of operator '<<=' for attaching parsing expressions to Forward() expressions. This is being done to address precedence of operations problems with '<<'. Operator '<<' will be removed in a future version of pyparsing. ------------------------------------------------------------------- Tue Sep 17 12:45:24 UTC 2013 - dmueller@suse.com - remove nonsensical tarball ------------------------------------------------------------------- Wed Mar 13 09:04:46 UTC 2013 - dmueller@suse.com - update to 1.5.7: * NOTE: This is the last release of pyparsing that will try to maintain compatibility with Python versions < 2.6. The next release of pyparsing will be version 2.0.0, using new Python syntax that will not be compatible for Python version 2.5 or older. * An awesome new example is included in this release, submitted by Luca DellOlio, for parsing ANTLR grammar definitions, nice work Luca! * Fixed implementation of ParseResults.__str__ to use Pythonic ''.join() instead of repeated string concatenation. This purportedly has been a performance issue under PyPy. * Fixed bug in ParseResults.__dir__ under Python 3, reported by Thomas Kluyver, thank you Thomas! * Added ParserElement.inlineLiteralsUsing static method, to override pyparsing's default behavior of converting string literals to Literal instances, to use other classes (such as Suppress or CaselessLiteral). * Added new operator '<<=', which will eventually replace '<<' for storing the contents of a Forward(). '<<=' does not have the same operator precedence problems that '<<' does. * 'operatorPrecedence' is being renamed 'infixNotation' as a better description of what this helper function creates. 'operatorPrecedence' is deprecated, and will be dropped entirely in a future release. * Added optional arguments lpar and rpar to operatorPrecedence, so that expressions that use it can override the default suppression of the grouping characters. * Added support for using single argument builtin functions as parse actions. Now you can write 'expr.setParseAction(len)' and get back the length of the list of matched tokens. Supported builtins are: sum, len, sorted, reversed, list, tuple, set, any, all, min, and max. A script demonstrating this feature is included in the examples directory. * Fixed a bug in the definition of 'alphas', which was based on the string.uppercase and string.lowercase "constants", which in fact *aren't* constant, but vary with locale settings. This could make parsers locale-sensitive in a subtle way. Thanks to Kef Schecter for his diligence in following through on reporting and monitoring this bugfix! * Fixed a bug in the Py3 version of pyparsing, during exception handling with packrat parsing enabled, reported by Catherine Devlin - thanks Catherine! * Fixed typo in ParseBaseException.__dir__, reported anonymously on the SourceForge bug tracker, thank you Pyparsing User With No Name. * Fixed bug in srange when using '\x###' hex character codes. * Addeed optional 'intExpr' argument to countedArray, so that you can define your own expression that will evaluate to an integer, to be used as the count for the following elements. Allows you to define a countedArray with the count given in hex, for example, by defining intExpr as "Word(hexnums).setParseAction(int(t[0],16))". ------------------------------------------------------------------- Mon Jan 14 11:56:55 UTC 2013 - saschpe@suse.de - Fix license (MIT and GPL-2.0+ and GPL-3.0+) ------------------------------------------------------------------- Wed Jan 9 08:27:28 UTC 2013 - saschpe@suse.de - Don't ship examples twice ------------------------------------------------------------------- Mon Jan 7 20:03:30 UTC 2013 - p.drouand@gmail.com - Initial support of python3 ------------------------------------------------------------------- Fri Nov 23 14:06:29 UTC 2012 - saschpe@suse.de - Package examples - Spec file cleanup ------------------------------------------------------------------- Sun Jul 3 09:40:58 UTC 2011 - saschpe@gmx.de - Add Provides/Obsoletes for python-parsing ------------------------------------------------------------------- Thu Jun 30 08:33:22 UTC 2011 - saschpe@suse.de - Update to version 1.5.6: * Cleanup of parse action normalizing code, to be more version-tolerant, and robust in the face of future Python versions * Removal of exception cacheing, addressing a memory leak condition in Python 3. * Fixed bug when using packrat parsing, where a previously parsed expression would duplicate subsequent tokens * Fixed bug in srange, which accepted escaped hex characters of the form '\0x##', but should be '\x##'. Both forms will be supported for backwards compatibility. * Added the Verilog parser to the provided set of examples, under the MIT license. * Added the excludeChars argument to the Word class, to simplify defining a word composed of all characters in a large range except for one or two. * Added optional overlap parameter to scanString, to return overlapping matches found in the source text. * Updated oneOf internal regular expression generation, with improved parse time performance. * Slight performance improvement in transformString, removing empty strings from the list of string fragments built while scanning the source text, before calling ''.join. Especially useful when using transformString to strip out selected text. * Enhanced form of using the "expr('name')" style of results naming, in lieu of calling setResultsName. If name ends with an '*', then this is equivalent to expr.setResultsName('name',listAllMatches=True). * Fixed up internal list flattener to use iteration instead of recursion, to avoid stack overflow when transforming large files. - Changes from version 1.5.5: * Typo in Python3 version of pyparsing, "builtin" should be "builtins". - Changes from version 1.5.4: * Fixed __builtins__ and file references in Python 3 code, thanks to Greg Watson, saulspatz, sminos, and Mark Summerfield for reporting their Python 3 experiences. - Spec file cleanup: * Regenerated with py2pack, much simpler spec file * Fixed license to MIT, it's not GPLv2+ ------------------------------------------------------------------- Wed Jul 7 00:32:17 UTC 2010 - pascal.bleser@opensuse.org - Initial package (1.5.3)