From ce7b66256ce1b9e4df30becc34ca789eb8990954b0ff21b041b57f9f55c6f4bf Mon Sep 17 00:00:00 2001 From: Todd R Date: Tue, 1 Nov 2016 20:03:25 +0000 Subject: [PATCH] Accepting request 438174 from home:TheBlackCat:branches:devel:languages:python update to version 2.1.10 OBS-URL: https://build.opensuse.org/request/show/438174 OBS-URL: https://build.opensuse.org/package/show/devel:languages:python/python-pyparsing?expand=0&rev=33 --- pyparsing-2.0.7.tar.gz | 3 - pyparsing-2.1.10.tar.gz | 3 + python-pyparsing.changes | 242 +++++++++++++++++++++++++++++++++++++++ python-pyparsing.spec | 12 +- 4 files changed, 250 insertions(+), 10 deletions(-) delete mode 100644 pyparsing-2.0.7.tar.gz create mode 100644 pyparsing-2.1.10.tar.gz diff --git a/pyparsing-2.0.7.tar.gz b/pyparsing-2.0.7.tar.gz deleted file mode 100644 index 238958b..0000000 --- a/pyparsing-2.0.7.tar.gz +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:2ce0db3c70ec0413603d4aea389e4ece34ff93c265649b1c5c7d56e3c2cf19c4 -size 1141457 diff --git a/pyparsing-2.1.10.tar.gz b/pyparsing-2.1.10.tar.gz new file mode 100644 index 0000000..fae353e --- /dev/null +++ b/pyparsing-2.1.10.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:811c3e7b0031021137fc83e051795025fcb98674d07eb8fe922ba4de53d39188 +size 1230829 diff --git a/python-pyparsing.changes b/python-pyparsing.changes index 6bcf936..b733a50 100644 --- a/python-pyparsing.changes +++ b/python-pyparsing.changes @@ -1,3 +1,245 @@ +------------------------------------------------------------------- +Tue Nov 1 19:46:14 UTC 2016 - toddrme2178@gmail.com + +- 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 "() 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 + ParseResults. In Python 2.x, protocol 0 was the default, and + protocol 2 did not work. In Python 3.x, protocol 3 is the + default, so explicitly naming protocol 0 or 1 was required to + pickle ParseResults. With this release, all protocols 0-4 are + supported. Thanks for reporting this on StackOverflow, Arne + Wolframm, and for providing a nice simple test case! + * Added optional 'stopOn' argument to ZeroOrMore and OneOrMore, to + simplify breaking on stop tokens that would match the repetition + expression. + It is a common problem to fail to look ahead when matching + repetitive tokens if the sentinel at the end also matches the + repetition expression, as when parsing "BEGIN aaa bbb ccc END" + with: + + "BEGIN" + OneOrMore(Word(alphas)) + "END" + + Since "END" matches the repetition expression "Word(alphas)", it + will never get parsed as the terminating sentinel. Up until now, + this has to be resolved by the user inserting their own negative + lookahead: + + "BEGIN" + OneOrMore(~Literal("END") + Word(alphas)) + "END" + + Using stopOn, they can more easily write: + + "BEGIN" + OneOrMore(Word(alphas), stopOn="END") + "END" + + The stopOn argument can be a literal string or a pyparsing + expression. Inspired by a question by Lamakaha on StackOverflow + (and many previous questions with the same negative-lookahead + resolution). + * Added expression names for many internal and builtin expressions, + to reduce name and error message overhead during parsing. + * Converted helper lambdas to functions to refactor and add + docstring support. + * Fixed ParseResults.asDict() to correctly convert nested + ParseResults values to dicts. + * Cleaned up some examples, fixed typo in fourFn.py identified by + aristotle2600 on reddit. + * Removed keepOriginalText helper method, which was deprecated ages + ago. Superceded by originalTextFor. + * Same for the Upcase class, which was long ago deprecated and + replaced with the upcaseTokens method. + ------------------------------------------------------------------- Mon Feb 1 11:11:39 UTC 2016 - toddrme2178@gmail.com diff --git a/python-pyparsing.spec b/python-pyparsing.spec index 3d1b582..11be512 100644 --- a/python-pyparsing.spec +++ b/python-pyparsing.spec @@ -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 @@ This package contains the documentation of %{name} %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}