Hello community, here is the log from the commit of package python-pyparsing for openSUSE:Factory checked in at 2016-11-03 12:56:08 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/python-pyparsing (Old) and /work/SRC/openSUSE:Factory/.python-pyparsing.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-pyparsing" Changes: -------- --- /work/SRC/openSUSE:Factory/python-pyparsing/python-pyparsing.changes 2016-02-16 09:27:01.000000000 +0100 +++ /work/SRC/openSUSE:Factory/.python-pyparsing.new/python-pyparsing.changes 2016-11-03 12:56:09.000000000 +0100 @@ -1,0 +2,242 @@ +Tue Nov 1 19:46:14 UTC 2016 - [email protected] + +- update to version 2.1.10: + * 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. +- update to version 2.1.9: + * 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 + * 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 +- update to version 2.1.8: + * 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. +- changes from version 2.1.7: + * 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.) +- changes from version 2.1.6 : + * *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. +- update to version 2.1.5: + * 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. + * 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 +- changes from version 2.1.4: + * 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. +- changes from version 2.1.3: + * _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). +- changes from version 2.1.2: + * 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.) +- update to version 2.1.1: + * Added support for assigning to ParseResults using slices. + * Fixed bug in ParseResults.toDict(), in which dict values were + always converted to dicts, even if they were just unkeyed lists of + tokens. Reported on SO by Gerald Thibault, thanks Gerald! + * Fixed bug in SkipTo when using failOn, reported by robyschek, + thanks! + * Fixed bug in Each introduced in 2.1.0, reported by AND patch and + unit test submitted by robyschek, well done! + * Removed use of functools.partial in replaceWith, as this creates + an ambiguous signature for the generated parse action, which fails + in PyPy. Reported by Evan Hubinger, thanks Evan! + * Added default behavior to QuotedString to convert embedded '\t', + '\n', etc. characters to their whitespace counterparts. Found + during Q&A exchange on SO with Maxim. +- update to version 2.1.0: + * Modified the internal _trim_arity method to distinguish between + TypeError's raised while trying to determine parse action arity + and those raised within the parse action itself. This will clear + up those confusing "<lambda>() takes exactly 1 argument (0 given)" + error messages when there is an actual TypeError in the body of + the parse action. Thanks to all who have raised this issue in the + past, and most recently to Michael Cohen, who sent in a proposed + patch, and got me to finally tackle this problem. + * Added compatibility for pickle protocols 2-4 when pickling ++++ 45 more lines (skipped) ++++ between /work/SRC/openSUSE:Factory/python-pyparsing/python-pyparsing.changes ++++ and /work/SRC/openSUSE:Factory/.python-pyparsing.new/python-pyparsing.changes Old: ---- pyparsing-2.0.7.tar.gz New: ---- pyparsing-2.1.10.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ python-pyparsing.spec ++++++ --- /var/tmp/diff_new_pack.qjBZtd/_old 2016-11-03 12:56:10.000000000 +0100 +++ /var/tmp/diff_new_pack.qjBZtd/_new 2016-11-03 12:56:10.000000000 +0100 @@ -17,23 +17,21 @@ Name: python-pyparsing -Version: 2.0.7 +Version: 2.1.10 Release: 0 Url: http://pyparsing.wikispaces.com/ Summary: Grammar Parser Library for Python License: MIT and GPL-2.0+ and GPL-3.0+ Group: Development/Languages/Python -Source: http://pypi.python.org/packages/source/p/pyparsing/pyparsing-%{version}.tar.gz +Source: https://files.pythonhosted.org/packages/source/p/pyparsing/pyparsing-%{version}.tar.gz BuildRoot: %{_tmppath}/%{name}-%{version}-build +BuildRequires: python BuildRequires: python-devel BuildRequires: python-setuptools +Requires: python Provides: python-parsing = %{version} Obsoletes: python-parsing < %{version} -%if 0%{?suse_version} && 0%{?suse_version} <= 1110 -%{!?python_sitelib: %global python_sitelib %(python -c "from distutils.sysconfig import get_python_lib; print get_python_lib()")} -%else BuildArch: noarch -%endif %description The pyparsing module is an alternative approach to creating and executing @@ -60,7 +58,7 @@ %build python setup.py build # Fix wrong EOL encoding: -sed -i 's/\r$//' CHANGES LICENSE README examples/* +sed -i 's/\r$//' CHANGES LICENSE README examples/*py %install python setup.py install --prefix=%{_prefix} --root=%{buildroot} ++++++ pyparsing-2.0.7.tar.gz -> pyparsing-2.1.10.tar.gz ++++++ ++++ 31772 lines of diff (skipped)
