pax_global_header00006660000000000000000000000064151473335460014525gustar00rootroot0000000000000052 comment=e59ead334ac47618e6d844ad758114b3bfafcc8a jsonpath-ng-1.8.0/000077500000000000000000000000001514733354600137635ustar00rootroot00000000000000jsonpath-ng-1.8.0/.coveragerc000066400000000000000000000001751514733354600161070ustar00rootroot00000000000000[run] parallel = True branch = True source = jsonpath_ng, tests omit = */jsonpath_ng/_ply/*.py [report] fail_under = 82 jsonpath-ng-1.8.0/.devcontainer/000077500000000000000000000000001514733354600165225ustar00rootroot00000000000000jsonpath-ng-1.8.0/.devcontainer/devcontainer.json000066400000000000000000000005101514733354600220720ustar00rootroot00000000000000{ "image": "mcr.microsoft.com/devcontainers/python:3.12", "hostRequirements": { "cpus": 4 }, "waitFor": "onCreateCommand", "updateContentCommand": "pip install -r requirements.txt -r requirements-dev.txt", "customizations": { "vscode": { "extensions": [ "ms-python.python" ] } } } jsonpath-ng-1.8.0/.editorconfig000066400000000000000000000004451514733354600164430ustar00rootroot00000000000000# EditorConfig is awesome: https://EditorConfig.org # top-most EditorConfig file root = true [*] end_of_line = lf insert_final_newline = true [*.{py,ini,toml}] charset = utf-8 indent_style = space indent_size = 4 [Makefile] indent_style = tab [*.yml] indent_style = space indent_size = 2 jsonpath-ng-1.8.0/.github/000077500000000000000000000000001514733354600153235ustar00rootroot00000000000000jsonpath-ng-1.8.0/.github/dependabot.yml000066400000000000000000000001671514733354600201570ustar00rootroot00000000000000version: 2 updates: - package-ecosystem: "github-actions" directory: "/" schedule: interval: "monthly" jsonpath-ng-1.8.0/.github/workflows/000077500000000000000000000000001514733354600173605ustar00rootroot00000000000000jsonpath-ng-1.8.0/.github/workflows/ci.yml000066400000000000000000000014661514733354600205050ustar00rootroot00000000000000name: CI on: push: branches: - '*' tags: - 'v*' pull_request: branches: - master permissions: contents: read jobs: test: runs-on: ubuntu-latest strategy: matrix: python-version: - "3.10" - "3.11" - "3.12" - "3.13" - "3.14" steps: - uses: actions/checkout@v6 with: persist-credentials: false - uses: actions/setup-python@v6 with: allow-prereleases: true python-version: ${{ matrix.python-version }} - name: Install dependencies run: | python -m pip install --upgrade pip setuptools wheel pip install -r requirements.txt pip install -r requirements-dev.txt - name: Run tests run: tox run -e py${{ matrix.python-version }} jsonpath-ng-1.8.0/.github/workflows/codeql.yml000066400000000000000000000012521514733354600213520ustar00rootroot00000000000000name: "CodeQL" on: push: branches: - "master" pull_request: branches: - "master" schedule: - cron: '39 16 * * 5' jobs: analyze: name: Analyze runs-on: ubuntu-latest timeout-minutes: 360 permissions: actions: read contents: read security-events: write steps: - name: Checkout repository uses: actions/checkout@v6 with: persist-credentials: false - name: Initialize CodeQL uses: github/codeql-action/init@v4 with: languages: python - name: Perform CodeQL Analysis uses: github/codeql-action/analyze@v4 with: category: "/language:python" jsonpath-ng-1.8.0/.gitignore000066400000000000000000000002651514733354600157560ustar00rootroot00000000000000*.pyc *.pyo *~ # Emacs \#( .\#* # Build and test artifacts /README.txt /dist /*.egg-info parser.out .cache .coverage .coverage.* .tox/ build /jsonpath_rw/VERSION .idea .vscode/ jsonpath-ng-1.8.0/CHANGELOG.md000066400000000000000000000036701514733354600156020ustar00rootroot00000000000000All notable changes to this project will be documented in this file. Past changes are listed in [History.md](History.md). The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/). ## [Unreleased] ## [1.8.0] - 2026-02-24 ### Added - Support Python 3.13 and 3.14 - Typing for IDE autocomplete - Support for EMOJI and CJK Unicode - Support for `DatumInContext` in-place updating - Support equality checking of `Operation` instances - Support string serialization of `Union` and `Intersect` instances - Support comma-separated indices - Add typings for IDE autocomplete ### Changed - Rename `ExtentedJsonPathParser` - Remove ply dependency ### Fixed - Fix `False` and `None` values - Fix single constant case - Update field filter to resolve wildcard path issue - Vendor copy of ply and remove pickle support from the vendored copy to resolve [CVE-2025-56005](https://nvd.nist.gov/vuln/detail/CVE-2025-56005) - Fix string serialization throughout the library to enforce roundtrip parsing consistency. - Fields are more conservatively enclosed in quotion marks This fixes serialization and re-parsing of `"00"`, `'%'`, `'0@'` and `"&'"`. - `Operation` instances can now be serialized. This fixes serialization of `0-@` and `A -A`. - `SortedThis` instances can now be serialized and re-parsed. This fixes serialization of `0[/0]`. - `Child` precedence is now preserved using parentheses during serialization. This ensures that serialized strings like `a..b[c]` serialize and re-parse identically. - Fix parsing and string serialization of numeric-only identifiers. This fixes parsing of `10`, which was parsed as two separate fields. - Fix equality checks for `SortedThis` instances. - Fix bool filter type to handle None values ### Removed - Python 3.8 and 3.9 no longer supported [Unreleased]: https://github.com/h2non/jsonpath-ng/compare/v1.8.0...HEAD [1.8.0]: https://github.com/h2non/jsonpath-ng/compare/v1.7.0...v1.8.0 jsonpath-ng-1.8.0/CONTRIBUTING.md000066400000000000000000000005301514733354600162120ustar00rootroot00000000000000Before creating a pull request, you are encouraged to create an issue to discuss the proposed changes. When contributing any new code, any new or changed behavior should have corresponding tests. Any changes should also be added to [CHANGELOG.md](CHANGELOG.md) which follows the [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) format. jsonpath-ng-1.8.0/History.md000066400000000000000000000153561514733354600157600ustar00rootroot000000000000001.7.0 / 2024-10-11 =================== * Allow raw numeric values to be used as keys * Add `wherenot` * Added EZRegex pattern for the split extension regex * Added negative and * indecies and quotes to `Split` parameters * Typo: duplicate line removed. * Added `path` extension that exposes datum's path from the jsonpath expression itself. * Remove Python 3.7 support * Only construct the parse table once * updated test for `jsonpath.py` changes * fix for Updating a json object fails if the value of a key is boolean #73 * Add Codespaces configuration * Add `.editorconfig` * Fix a GitHub workflow schema issue 1.6.1 / 2024-01-11 =================== * Bump actions/setup-python from 4 to 5 * Bump github/codeql-action from 2 to 3 * Use tox to run the test suite against all supported Pythons * Fix a typo in the README * Add a test case * Fix issue with lambda based updates * Remove unused code from the test suite * Refactor `tests/test_parser.py` * Refactor `tests/test_lexer.py` * Refactor `tests/test_jsonpath_rw_ext.py` * De-duplicate the parser test cases * Refactor `tests/test_jsonpath.py` * Refactor `tests/test_jsonpath.py` * Refactor `tests/test_exceptions.py` * Remove a test that merely checks exception inheritance * Refactor `tests/test_examples.py` * Add pytest-randomly to shake out auto_id side effects * Bump actions/checkout from 3 to 4 * Include the test suite in coverage reports * Remove tests that don't affect coverage and contribute nothing * Reformat `tests/test_create.py` * Remove `test_doctests`, which is a no-op * Demonstrate that there are no doctests * Remove the `coveralls` dependency * Migrate `tests/bin/test_jsonpath.py` to use pytest * remove Python2 crumbs * Add CodeQL analysis * Remove the `oslotest` dependency * Fix running CI against incoming PRs * Support, and test against, Python 3.12 * Update the currently-tested CPython versions in the README * Remove an unused Travis CI config file * Add a Dependabot config to keep GitHub action versions updated * add a test for the case when root element is a list * Fix issue with assignment in case root element is a list. * Fix typo in README * Fix test commands in Makefile * Fix .coveragerc path * Simplify clean in Makefile * Refactor unit tests for better errors * test case for existing auto id * Add more examples to README (thanks @baynes) * fixed typo * Don't fail when regex match is attempted on non-strings * added step in slice * Add additional tests * Add `keys` keyword 1.6.0 / 2023-09-13 =================== * Enclose field names containing literals in quotes * Add note about extensions * Remove documentation status link * Update supported versions in setup.py * Add LICENSE file * Code cleanup * Remove dependency on six * Update build status badge * (origin/github-actions, github-actions) Remove testscenarios dependency * Remove pytest version constraints * Add testing with GitHub actions * Escape back slashes in tests to avoid DeprecationWarning. * Use raw strings for regular expressions to avoid DeprecationWarning. * refactor(package): remove dependency for decorator * Merge pull request #128 from michaelmior/hashable * Make path instances hashable * Merge pull request #122 from snopoke/snopoke-patch-1 * Add more detail to filter docs. * remove incorrect parenthesis in filter examples * Merge pull request #119 from snopoke/patch-1 * add 'sub' line with function param names * readme formatting fixes * chore(history): update * Update __init__.py 1.5.3 / 2021-07-05 ================== * Update __init__.py * Update setup.py * Merge pull request #72 from kaapstorm/find_or_create * Tests * Add `update_or_create()` method * Merge pull request #68 from kaapstorm/example_tests * Merge pull request #70 from kaapstorm/exceptions * Add/fix `__eq__()` * Add tests based on Stefan Goessner's examples * Tests * Allow callers to catch JSONPathErrors v1.5.2 / 2020-09-07 =================== * Merge pull request #41 from josephwhite13/allow-dictionary-filtering * Merge pull request #48 from back2root/master * Check for null value. * Merge pull request #40 from memborsky/add-regular-expression-contains-support * feat: support regular expression for performing contains (=~) filtering * if datum.value is a dictionary, filter on the list of values 1.5.1 / 2020-03-09 ================== * feat(version): bump * fix(setup): strip extension v1.5.0 / 2020-03-06 =================== * feat(version): bump to 1,5.0 * Merge pull request #13 from dcreemer/master * fix(travis): remove python 3.4 (deprecated) * refactor(docs): delete coverage badge * Merge pull request #25 from rahendatri/patch-1 * Merge pull request #26 from guandalf/contains_operator * Merge pull request #31 from borysvorona/master * refactor(travis): update python versions * Merge pull request #34 from dchourasia/patch-1 * Updated Filter.py to implement update function * added hook for catching null value instead of empty list in path * Ignore vscode folder * Contains operator implementation * Update requirements-dev.txt * setuptools>=18.5 * update setuptools * update cryptography * new version of cryptography requires it * entry point conflict with https://pypi.org/project/jsonpath/ * add str() method * clean up * remove extra print() * refactor(docs): remove codesponsor * feat(docs): add sponsor banner * Update .travis.yml * feat(History): add History file * fix(travis-ci): ignore versions * feat(requirements): add missing pytest-cov dependency * refactor(requirements): use version contraint * fix: remove .cache files * feat: add required files * fix(travis-ci): install proper packages * refactor(setup.py): update description * refactor(docs): remove downloads badge * fix(tests): pass unit tests * feat(docs): add TravisCI and PyPI badges * Merge pull request #2 from tomas-fp/master * feat(docs): update readme notes * feat(setup): increase version * Merge pull request #1 from kmmbvnr/patch-1 * Fix github url on pypi v1.4.3 / 2017-08-24 =================== * fix(travis-ci): ignore versions * feat(requirements): add missing pytest-cov dependency * refactor(requirements): use version contraint * fix: remove .cache files * feat: add required files * fix(travis-ci): install proper packages * refactor(setup.py): update description * refactor(docs): remove downloads badge * fix(tests): pass unit tests * feat(docs): add TravisCI and PyPI badges * Merge pull request #2 from tomas-fp/master * feat(docs): update readme notes * feat(setup): increase version * Merge pull request #1 from kmmbvnr/patch-1 * Fix github url on pypi jsonpath-ng-1.8.0/LICENSE000066400000000000000000000261361514733354600150000ustar00rootroot00000000000000 Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright [yyyy] [name of copyright owner] Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. jsonpath-ng-1.8.0/MANIFEST.in000066400000000000000000000000641514733354600155210ustar00rootroot00000000000000recursive-include tests *.json *.py include LICENSE jsonpath-ng-1.8.0/Makefile000066400000000000000000000025711514733354600154300ustar00rootroot00000000000000OK_COLOR=\033[32;01m NO_COLOR=\033[0m all: lint unit export PYTHONPATH:=${PWD} version=`python -c 'import jsonpath_ng; print(jsonpath_ng.__version__)'` filename=jsonpath_ng-`python -c 'import jsonpath_ng; print(jsonpath_ng.__version__)'`.tar.gz apidocs: @sphinx-apidoc -f --follow-links -H "API documentation" -o docs/source jsonpath_ng htmldocs: @rm -rf docs/_build $(MAKE) -C docs html install: @pip install -r requirements.txt @pip install -r requirements-dev.txt lint: @echo "$(OK_COLOR)==> Linting code ...$(NO_COLOR)" @flake8 --exclude=tests . test: clean @echo "$(OK_COLOR)==> Running tests ...$(NO_COLOR)" @tox tag: @echo "$(OK_COLOR)==> Creating tag $(version) ...$(NO_COLOR)" @git tag -a "v$(version)" -m "Version $(version)" @echo "$(OK_COLOR)==> Pushing tag $(version) to origin ...$(NO_COLOR)" @git push origin "v$(version)" bump: @bumpversion --commit --tag --current-version $(version) patch jsonpath_ng/__init__.py --allow-dirty bump-minor: @bumpversion --commit --tag --current-version $(version) minor jsonpath_ng/__init__.py --allow-dirty history: @git changelog --tag $(version) clean: @echo "$(OK_COLOR)==> Cleaning up files that are already in .gitignore...$(NO_COLOR)" @git clean -Xf publish: @echo "$(OK_COLOR)==> Releasing package ...$(NO_COLOR)" @python setup.py sdist bdist_wheel @twine upload dist/* @rm -fr build dist .egg pook.egg-info jsonpath-ng-1.8.0/README.rst000066400000000000000000000426001514733354600154540ustar00rootroot00000000000000Python JSONPath Next-Generation |Build Status| |PyPI| ===================================================== A final implementation of JSONPath for Python that aims to be standard compliant, including arithmetic and binary comparison operators, as defined in the original `JSONPath proposal`_. This packages merges both `jsonpath-rw`_ and `jsonpath-rw-ext`_ and provides several AST API enhancements, such as the ability to update or remove nodes in the tree. About ----- This library provides a robust and significantly extended implementation of JSONPath for Python. It is tested with CPython 3.10 and higher. This library differs from other JSONPath implementations in that it is a full *language* implementation, meaning the JSONPath expressions are first class objects, easy to analyze, transform, parse, print, and extend. Quick Start ----------- To install, use pip: .. code:: bash $ pip install --upgrade jsonpath-ng Usage ----- Basic examples: .. code:: python $ python >>> from jsonpath_ng import jsonpath, parse # A robust parser, not just a regex. (Makes powerful extensions possible; see below) >>> jsonpath_expr = parse('foo[*].baz') # Extracting values is easy >>> [match.value for match in jsonpath_expr.find({'foo': [{'baz': 1}, {'baz': 2}]})] [1, 2] # Matches remember where they came from >>> [str(match.full_path) for match in jsonpath_expr.find({'foo': [{'baz': 1}, {'baz': 2}]})] ['foo.[0].baz', 'foo.[1].baz'] # Modifying values matching the path >>> jsonpath_expr.update( {'foo': [{'baz': 1}, {'baz': 2}]}, 3) {'foo': [{'baz': 3}, {'baz': 3}]} # Modifying one of the values matching the path >>> matches = jsonpath_expr.find({'foo': [{'baz': 1}, {'baz': 2}]}) >>> matches[0].full_path.update( {'foo': [{'baz': 1}, {'baz': 2}]}, 3) {'foo': [{'baz': 3}, {'baz': 2}]} # Removing all values matching a path >>> jsonpath_expr.filter(lambda d: True, {'foo': [{'baz': 1}, {'baz': 2}]}) {'foo': [{}, {}]} # Removing values containing particular data matching path >>> jsonpath_expr.filter(lambda d: d == 2, {'foo': [{'baz': 1}, {'baz': 2}]}) {'foo': [{'baz': 1}, {}]} # And this can be useful for automatically providing ids for bits of data that do not have them (currently a global switch) >>> jsonpath.auto_id_field = 'id' >>> [match.value for match in parse('foo[*].id').find({'foo': [{'id': 'bizzle'}, {'baz': 3}]})] ['foo.bizzle', 'foo.[1]'] # A handy extension: named operators like `parent` >>> [match.value for match in parse('a.*.b.`parent`.c').find({'a': {'x': {'b': 1, 'c': 'number one'}, 'y': {'b': 2, 'c': 'number two'}}})] ['number two', 'number one'] # You can also build expressions directly quite easily >>> from jsonpath_ng.jsonpath import Fields >>> from jsonpath_ng.jsonpath import Slice >>> jsonpath_expr_direct = Fields('foo').child(Slice('*')).child(Fields('baz')) # This is equivalent Using the extended parser: .. code:: python $ python >>> from jsonpath_ng.ext import parse # A robust parser, not just a regex. (Makes powerful extensions possible; see below) >>> jsonpath_expr = parse('foo[*].baz') JSONPath Syntax --------------- The JSONPath syntax supported by this library includes some additional features and omits some problematic features (those that make it unportable). In particular, some new operators such as ``|`` and ``where`` are available, and parentheses are used for grouping not for callbacks into Python, since with these changes the language is not trivially associative. Also, fields may be quoted whether or not they are contained in brackets. Atomic expressions: +-----------------------+---------------------------------------------------------------------------------------------+ | Syntax | Meaning | +=======================+=============================================================================================+ | ``$`` | The root object | +-----------------------+---------------------------------------------------------------------------------------------+ | ```this``` | The "current" object. | +-----------------------+---------------------------------------------------------------------------------------------+ | ```foo``` | More generally, this syntax allows "named operators" to extend JSONPath is arbitrary ways | +-----------------------+---------------------------------------------------------------------------------------------+ | *field* | Specified field(s), described below | +-----------------------+---------------------------------------------------------------------------------------------+ | ``[`` *field* ``]`` | Same as *field* | +-----------------------+---------------------------------------------------------------------------------------------+ | ``[`` *idx* ``]`` | Array access, described below (this is always unambiguous with field access) | +-----------------------+---------------------------------------------------------------------------------------------+ Jsonpath operators: +--------------------------------------+-----------------------------------------------------------------------------------+ | Syntax | Meaning | +======================================+===================================================================================+ | *jsonpath1* ``.`` *jsonpath2* | All nodes matched by *jsonpath2* starting at any node matching *jsonpath1* | +--------------------------------------+-----------------------------------------------------------------------------------+ | *jsonpath* ``[`` *whatever* ``]`` | Same as *jsonpath*\ ``.``\ *whatever* | +--------------------------------------+-----------------------------------------------------------------------------------+ | *jsonpath1* ``..`` *jsonpath2* | All nodes matched by *jsonpath2* that descend from any node matching *jsonpath1* | +--------------------------------------+-----------------------------------------------------------------------------------+ | *jsonpath1* ``where`` *jsonpath2* | Any nodes matching *jsonpath1* with a child matching *jsonpath2* | +--------------------------------------+-----------------------------------------------------------------------------------+ | *jsonpath1* ``wherenot`` *jsonpath2* | Any nodes matching *jsonpath1* with a child not matching *jsonpath2* | +--------------------------------------+-----------------------------------------------------------------------------------+ | *jsonpath1* ``|`` *jsonpath2* | Any nodes matching the union of *jsonpath1* and *jsonpath2* | +--------------------------------------+-----------------------------------------------------------------------------------+ Field specifiers ( *field* ): +-------------------------+-------------------------------------------------------------------------------------+ | Syntax | Meaning | +=========================+=====================================================================================+ | ``fieldname`` | the field ``fieldname`` (from the "current" object) | +-------------------------+-------------------------------------------------------------------------------------+ | ``"fieldname"`` | same as above, for allowing special characters in the fieldname | +-------------------------+-------------------------------------------------------------------------------------+ | ``'fieldname'`` | ditto | +-------------------------+-------------------------------------------------------------------------------------+ | ``*`` | any field | +-------------------------+-------------------------------------------------------------------------------------+ | *field* ``,`` *field* | either of the named fields (you can always build equivalent jsonpath using ``|``) | +-------------------------+-------------------------------------------------------------------------------------+ Array specifiers ( *idx* ): +-----------------------------------------+---------------------------------------------------------------------------------------+ | Syntax | Meaning | +=========================================+=======================================================================================+ | ``[``\ *n*\ ``]`` | array index (may be comma-separated list) | +-----------------------------------------+---------------------------------------------------------------------------------------+ | ``[``\ *start*\ ``?:``\ *end*\ ``?]`` | array slicing (note that *step* is unimplemented only due to lack of need thus far) | +-----------------------------------------+---------------------------------------------------------------------------------------+ | ``[*]`` | any array index | +-----------------------------------------+---------------------------------------------------------------------------------------+ Programmatic JSONPath --------------------- If you are programming in Python and would like a more robust way to create JSONPath expressions that does not depend on a parser, it is very easy to do so directly, and here are some examples: - ``Root()`` - ``Slice(start=0, end=None, step=None)`` - ``Fields('foo', 'bar')`` - ``Index(42)`` - ``Child(Fields('foo'), Index(42))`` - ``Where(Slice(), Fields('subfield'))`` - ``Descendants(jsonpath, jsonpath)`` Extras ------ - *Path data*: The result of ``JsonPath.find`` provide detailed context and path data so it is easy to traverse to parent objects, print full paths to pieces of data, and generate automatic ids. - *Automatic Ids*: If you set ``jsonpath_ng.auto_id_field`` to a value other than None, then for any piece of data missing that field, it will be replaced by the JSONPath to it, giving automatic unique ids to any piece of data. These ids will take into account any ids already present as well. - *Named operators*: Instead of using ``@`` to reference the current object, this library uses ```this```. In general, any string contained in backquotes can be made to be a new operator, currently by extending the library. Extensions ---------- To use the extensions below you must import from `jsonpath_ng.ext`. +--------------+-----------------------------------------------+ | name | Example | +==============+===============================================+ | len | - ``$.objects.`len``` | +--------------+-----------------------------------------------+ | keys | - ``$.objects.`keys``` | +--------------+-----------------------------------------------+ | str | - ``$.field.`str()``` | +--------------+-----------------------------------------------+ | sub | - ``$.field.`sub(/foo\\\\+(.*)/, \\\\1)``` | | | - ``$.field.`sub(/regex/, replacement)``` | +--------------+-----------------------------------------------+ | split | - ``$.field.`split(+, 2, -1)``` | | | - ``$.field.`split(",", *, -1)``` | | | - ``$.field.`split(' ', -1, -1)``` | | | - ``$.field.`split(sep, segement, maxsplit)```| +--------------+-----------------------------------------------+ | sorted | - ``$.objects.`sorted``` | | | - ``$.objects[\\some_field]`` | | | - ``$.objects[\\some_field,/other_field]`` | +--------------+-----------------------------------------------+ | filter | - ``$.objects[?(@some_field > 5)]`` | | | - ``$.objects[?some_field = "foobar"]`` | | | - ``$.objects[?some_field =~ "foobar"]`` | | | - ``$.objects[?some_field > 5 & other < 2]`` | | | | | | Supported operators: | | | - Equality: ==, =, != | | | - Comparison: >, >=, <, <= | | | - Regex match: =~ | | | | | | Combine multiple criteria with '&'. | | | | | | Properties can only be compared to static | | | values. | +--------------+-----------------------------------------------+ | arithmetic | - ``$.foo + "_" + $.bar`` | | (-+*/) | - ``$.foo * 12`` | | | - ``$.objects[*].cow + $.objects[*].cat`` | +--------------+-----------------------------------------------+ About arithmetic and string --------------------------- Operations are done with python operators and allows types that python allows, and return [] if the operation can't be done due to incompatible types. When operators are used, a jsonpath must be be fully defined otherwise jsonpath-rw-ext can't known if the expression is a string or a jsonpath field, in this case it will choice string as type. Example with data:: { 'cow': 'foo', 'fish': 'bar' } | ``cow + fish`` returns ``cowfish`` | ``$.cow + $.fish`` returns ``foobar`` | ``$.cow + "_" + $.fish`` returns ``foo_bar`` | ``$.cow + "_" + fish`` returns ``foo_fish`` About arithmetic and list ------------------------- Arithmetic can be used against two lists if they have the same size. Example with data:: {'objects': [ {'cow': 2, 'cat': 3}, {'cow': 4, 'cat': 6} ]} | ``$.objects[\*].cow + $.objects[\*].cat`` returns ``[6, 9]`` More to explore --------------- There are way too many JSONPath implementations out there to discuss. Some are robust, some are toy projects that still work fine, some are exercises. There will undoubtedly be many more. This one is made for use in released, maintained code, and in particular for programmatic access to the abstract syntax and extension. But JSONPath at its simplest just isn't that complicated, so you can probably use any of them successfully. Why not this one? The original proposal, as far as I know: - `JSONPath - XPath for JSON `__ by Stefan Goessner. Other examples -------------- Loading json data from file .. code:: python import json d = json.loads('{"foo": [{"baz": 1}, {"baz": 2}]}') # or with open('myfile.json') as f: d = json.load(f) Special note about PLY and docstrings ------------------------------------- The main parsing toolkit underlying this library, `PLY `__, does not work with docstrings removed. For example, ``PYTHONOPTIMIZE=2`` and ``python -OO`` will both cause a failure. Contributors ------------ This package is authored and maintained by: - `Kenn Knowles `__ (`@kennknowles `__) - `Tomas Aparicio ` with the help of patches submitted by `these contributors `__. Copyright and License --------------------- Copyright 2013 - Kenneth Knowles Copyright 2017 - Tomas Aparicio Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at :: http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. .. _`JSONPath proposal`: http://goessner.net/articles/JsonPath/ .. _`jsonpath-rw`: https://github.com/kennknowles/python-jsonpath-rw .. _`jsonpath-rw-ext`: https://pypi.python.org/pypi/jsonpath-rw-ext/ .. |PyPi downloads| image:: https://pypip.in/d/jsonpath-ng/badge.png :target: https://pypi.python.org/pypi/jsonpath-ng .. |Build Status| image:: https://github.com/h2non/jsonpath-ng/actions/workflows/ci.yml/badge.svg :target: https://github.com/h2non/jsonpath-ng/actions/workflows/ci.yml .. |PyPI| image:: https://img.shields.io/pypi/v/jsonpath-ng.svg?maxAge=2592000?style=flat-square :target: https://pypi.python.org/pypi/jsonpath-ng jsonpath-ng-1.8.0/jsonpath_ng/000077500000000000000000000000001514733354600162755ustar00rootroot00000000000000jsonpath-ng-1.8.0/jsonpath_ng/__init__.py000066400000000000000000000001641514733354600204070ustar00rootroot00000000000000from .jsonpath import * # noqa from .parser import parse # noqa # Current package version __version__ = '1.8.0' jsonpath-ng-1.8.0/jsonpath_ng/_ply/000077500000000000000000000000001514733354600172405ustar00rootroot00000000000000jsonpath-ng-1.8.0/jsonpath_ng/_ply/__init__.py000066400000000000000000000001471514733354600213530ustar00rootroot00000000000000# PLY package # Author: David Beazley (dave@dabeaz.com) __version__ = '3.11' __all__ = ['lex','yacc'] jsonpath-ng-1.8.0/jsonpath_ng/_ply/lex.py000066400000000000000000001236311514733354600204100ustar00rootroot00000000000000# ----------------------------------------------------------------------------- # ply: lex.py # # Copyright (C) 2001-2018 # David M. Beazley (Dabeaz LLC) # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are # met: # # * Redistributions of source code must retain the above copyright notice, # this list of conditions and the following disclaimer. # * Redistributions in binary form must reproduce the above copyright notice, # this list of conditions and the following disclaimer in the documentation # and/or other materials provided with the distribution. # * Neither the name of the David Beazley or Dabeaz LLC may be used to # endorse or promote products derived from this software without # specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # ----------------------------------------------------------------------------- __version__ = '3.11' __tabversion__ = '3.10' import re import sys import types import copy import os import inspect # This tuple contains known string types try: # Python 2.6 StringTypes = (types.StringType, types.UnicodeType) except AttributeError: # Python 3.0 StringTypes = (str, bytes) # This regular expression is used to match valid token names _is_identifier = re.compile(r'^[a-zA-Z0-9_]+$') # Exception thrown when invalid token encountered and no default error # handler is defined. class LexError(Exception): def __init__(self, message, s): self.args = (message,) self.text = s # Token class. This class is used to represent the tokens produced. class LexToken(object): def __str__(self): return 'LexToken(%s,%r,%d,%d)' % (self.type, self.value, self.lineno, self.lexpos) def __repr__(self): return str(self) # This object is a stand-in for a logging object created by the # logging module. class PlyLogger(object): def __init__(self, f): self.f = f def critical(self, msg, *args, **kwargs): self.f.write((msg % args) + '\n') def warning(self, msg, *args, **kwargs): self.f.write('WARNING: ' + (msg % args) + '\n') def error(self, msg, *args, **kwargs): self.f.write('ERROR: ' + (msg % args) + '\n') info = critical debug = critical # Null logger is used when no output is generated. Does nothing. class NullLogger(object): def __getattribute__(self, name): return self def __call__(self, *args, **kwargs): return self # ----------------------------------------------------------------------------- # === Lexing Engine === # # The following Lexer class implements the lexer runtime. There are only # a few public methods and attributes: # # input() - Store a new string in the lexer # token() - Get the next token # clone() - Clone the lexer # # lineno - Current line number # lexpos - Current position in the input string # ----------------------------------------------------------------------------- class Lexer: def __init__(self): self.lexre = None # Master regular expression. This is a list of # tuples (re, findex) where re is a compiled # regular expression and findex is a list # mapping regex group numbers to rules self.lexretext = None # Current regular expression strings self.lexstatere = {} # Dictionary mapping lexer states to master regexs self.lexstateretext = {} # Dictionary mapping lexer states to regex strings self.lexstaterenames = {} # Dictionary mapping lexer states to symbol names self.lexstate = 'INITIAL' # Current lexer state self.lexstatestack = [] # Stack of lexer states self.lexstateinfo = None # State information self.lexstateignore = {} # Dictionary of ignored characters for each state self.lexstateerrorf = {} # Dictionary of error functions for each state self.lexstateeoff = {} # Dictionary of eof functions for each state self.lexreflags = 0 # Optional re compile flags self.lexdata = None # Actual input data (as a string) self.lexpos = 0 # Current position in input text self.lexlen = 0 # Length of the input text self.lexerrorf = None # Error rule (if any) self.lexeoff = None # EOF rule (if any) self.lextokens = None # List of valid tokens self.lexignore = '' # Ignored characters self.lexliterals = '' # Literal characters that can be passed through self.lexmodule = None # Module self.lineno = 1 # Current line number self.lexoptimize = False # Optimized mode def clone(self, object=None): c = copy.copy(self) # If the object parameter has been supplied, it means we are attaching the # lexer to a new object. In this case, we have to rebind all methods in # the lexstatere and lexstateerrorf tables. if object: newtab = {} for key, ritem in self.lexstatere.items(): newre = [] for cre, findex in ritem: newfindex = [] for f in findex: if not f or not f[0]: newfindex.append(f) continue newfindex.append((getattr(object, f[0].__name__), f[1])) newre.append((cre, newfindex)) newtab[key] = newre c.lexstatere = newtab c.lexstateerrorf = {} for key, ef in self.lexstateerrorf.items(): c.lexstateerrorf[key] = getattr(object, ef.__name__) c.lexmodule = object return c # ------------------------------------------------------------ # writetab() - Write lexer information to a table file # ------------------------------------------------------------ def writetab(self, lextab, outputdir=''): if isinstance(lextab, types.ModuleType): raise IOError("Won't overwrite existing lextab module") basetabmodule = lextab.split('.')[-1] filename = os.path.join(outputdir, basetabmodule) + '.py' with open(filename, 'w') as tf: tf.write('# %s.py. This file automatically created by PLY (version %s). Don\'t edit!\n' % (basetabmodule, __version__)) tf.write('_tabversion = %s\n' % repr(__tabversion__)) tf.write('_lextokens = set(%s)\n' % repr(tuple(sorted(self.lextokens)))) tf.write('_lexreflags = %s\n' % repr(int(self.lexreflags))) tf.write('_lexliterals = %s\n' % repr(self.lexliterals)) tf.write('_lexstateinfo = %s\n' % repr(self.lexstateinfo)) # Rewrite the lexstatere table, replacing function objects with function names tabre = {} for statename, lre in self.lexstatere.items(): titem = [] for (pat, func), retext, renames in zip(lre, self.lexstateretext[statename], self.lexstaterenames[statename]): titem.append((retext, _funcs_to_names(func, renames))) tabre[statename] = titem tf.write('_lexstatere = %s\n' % repr(tabre)) tf.write('_lexstateignore = %s\n' % repr(self.lexstateignore)) taberr = {} for statename, ef in self.lexstateerrorf.items(): taberr[statename] = ef.__name__ if ef else None tf.write('_lexstateerrorf = %s\n' % repr(taberr)) tabeof = {} for statename, ef in self.lexstateeoff.items(): tabeof[statename] = ef.__name__ if ef else None tf.write('_lexstateeoff = %s\n' % repr(tabeof)) # ------------------------------------------------------------ # readtab() - Read lexer information from a tab file # ------------------------------------------------------------ def readtab(self, tabfile, fdict): if isinstance(tabfile, types.ModuleType): lextab = tabfile else: exec('import %s' % tabfile) lextab = sys.modules[tabfile] if getattr(lextab, '_tabversion', '0.0') != __tabversion__: raise ImportError('Inconsistent PLY version') self.lextokens = lextab._lextokens self.lexreflags = lextab._lexreflags self.lexliterals = lextab._lexliterals self.lextokens_all = self.lextokens | set(self.lexliterals) self.lexstateinfo = lextab._lexstateinfo self.lexstateignore = lextab._lexstateignore self.lexstatere = {} self.lexstateretext = {} for statename, lre in lextab._lexstatere.items(): titem = [] txtitem = [] for pat, func_name in lre: titem.append((re.compile(pat, lextab._lexreflags), _names_to_funcs(func_name, fdict))) self.lexstatere[statename] = titem self.lexstateretext[statename] = txtitem self.lexstateerrorf = {} for statename, ef in lextab._lexstateerrorf.items(): self.lexstateerrorf[statename] = fdict[ef] self.lexstateeoff = {} for statename, ef in lextab._lexstateeoff.items(): self.lexstateeoff[statename] = fdict[ef] self.begin('INITIAL') # ------------------------------------------------------------ # input() - Push a new string into the lexer # ------------------------------------------------------------ def input(self, s): # Pull off the first character to see if s looks like a string c = s[:1] if not isinstance(c, StringTypes): raise ValueError('Expected a string') self.lexdata = s self.lexpos = 0 self.lexlen = len(s) # ------------------------------------------------------------ # begin() - Changes the lexing state # ------------------------------------------------------------ def begin(self, state): if state not in self.lexstatere: raise ValueError('Undefined state') self.lexre = self.lexstatere[state] self.lexretext = self.lexstateretext[state] self.lexignore = self.lexstateignore.get(state, '') self.lexerrorf = self.lexstateerrorf.get(state, None) self.lexeoff = self.lexstateeoff.get(state, None) self.lexstate = state # ------------------------------------------------------------ # push_state() - Changes the lexing state and saves old on stack # ------------------------------------------------------------ def push_state(self, state): self.lexstatestack.append(self.lexstate) self.begin(state) # ------------------------------------------------------------ # pop_state() - Restores the previous state # ------------------------------------------------------------ def pop_state(self): self.begin(self.lexstatestack.pop()) # ------------------------------------------------------------ # current_state() - Returns the current lexing state # ------------------------------------------------------------ def current_state(self): return self.lexstate # ------------------------------------------------------------ # skip() - Skip ahead n characters # ------------------------------------------------------------ def skip(self, n): self.lexpos += n # ------------------------------------------------------------ # opttoken() - Return the next token from the Lexer # # Note: This function has been carefully implemented to be as fast # as possible. Don't make changes unless you really know what # you are doing # ------------------------------------------------------------ def token(self): # Make local copies of frequently referenced attributes lexpos = self.lexpos lexlen = self.lexlen lexignore = self.lexignore lexdata = self.lexdata while lexpos < lexlen: # This code provides some short-circuit code for whitespace, tabs, and other ignored characters if lexdata[lexpos] in lexignore: lexpos += 1 continue # Look for a regular expression match for lexre, lexindexfunc in self.lexre: m = lexre.match(lexdata, lexpos) if not m: continue # Create a token for return tok = LexToken() tok.value = m.group() tok.lineno = self.lineno tok.lexpos = lexpos i = m.lastindex func, tok.type = lexindexfunc[i] if not func: # If no token type was set, it's an ignored token if tok.type: self.lexpos = m.end() return tok else: lexpos = m.end() break lexpos = m.end() # If token is processed by a function, call it tok.lexer = self # Set additional attributes useful in token rules self.lexmatch = m self.lexpos = lexpos newtok = func(tok) # Every function must return a token, if nothing, we just move to next token if not newtok: lexpos = self.lexpos # This is here in case user has updated lexpos. lexignore = self.lexignore # This is here in case there was a state change break # Verify type of the token. If not in the token map, raise an error if not self.lexoptimize: if newtok.type not in self.lextokens_all: raise LexError("%s:%d: Rule '%s' returned an unknown token type '%s'" % ( func.__code__.co_filename, func.__code__.co_firstlineno, func.__name__, newtok.type), lexdata[lexpos:]) return newtok else: # No match, see if in literals if lexdata[lexpos] in self.lexliterals: tok = LexToken() tok.value = lexdata[lexpos] tok.lineno = self.lineno tok.type = tok.value tok.lexpos = lexpos self.lexpos = lexpos + 1 return tok # No match. Call t_error() if defined. if self.lexerrorf: tok = LexToken() tok.value = self.lexdata[lexpos:] tok.lineno = self.lineno tok.type = 'error' tok.lexer = self tok.lexpos = lexpos self.lexpos = lexpos newtok = self.lexerrorf(tok) if lexpos == self.lexpos: # Error method didn't change text position at all. This is an error. raise LexError("Scanning error. Illegal character '%s'" % (lexdata[lexpos]), lexdata[lexpos:]) lexpos = self.lexpos if not newtok: continue return newtok self.lexpos = lexpos raise LexError("Illegal character '%s' at index %d" % (lexdata[lexpos], lexpos), lexdata[lexpos:]) if self.lexeoff: tok = LexToken() tok.type = 'eof' tok.value = '' tok.lineno = self.lineno tok.lexpos = lexpos tok.lexer = self self.lexpos = lexpos newtok = self.lexeoff(tok) return newtok self.lexpos = lexpos + 1 if self.lexdata is None: raise RuntimeError('No input string given with input()') return None # Iterator interface def __iter__(self): return self def next(self): t = self.token() if t is None: raise StopIteration return t __next__ = next # ----------------------------------------------------------------------------- # ==== Lex Builder === # # The functions and classes below are used to collect lexing information # and build a Lexer object from it. # ----------------------------------------------------------------------------- # ----------------------------------------------------------------------------- # _get_regex(func) # # Returns the regular expression assigned to a function either as a doc string # or as a .regex attribute attached by the @TOKEN decorator. # ----------------------------------------------------------------------------- def _get_regex(func): return getattr(func, 'regex', func.__doc__) # ----------------------------------------------------------------------------- # get_caller_module_dict() # # This function returns a dictionary containing all of the symbols defined within # a caller further down the call stack. This is used to get the environment # associated with the yacc() call if none was provided. # ----------------------------------------------------------------------------- def get_caller_module_dict(levels): f = sys._getframe(levels) ldict = f.f_globals.copy() if f.f_globals != f.f_locals: ldict.update(f.f_locals) return ldict # ----------------------------------------------------------------------------- # _funcs_to_names() # # Given a list of regular expression functions, this converts it to a list # suitable for output to a table file # ----------------------------------------------------------------------------- def _funcs_to_names(funclist, namelist): result = [] for f, name in zip(funclist, namelist): if f and f[0]: result.append((name, f[1])) else: result.append(f) return result # ----------------------------------------------------------------------------- # _names_to_funcs() # # Given a list of regular expression function names, this converts it back to # functions. # ----------------------------------------------------------------------------- def _names_to_funcs(namelist, fdict): result = [] for n in namelist: if n and n[0]: result.append((fdict[n[0]], n[1])) else: result.append(n) return result # ----------------------------------------------------------------------------- # _form_master_re() # # This function takes a list of all of the regex components and attempts to # form the master regular expression. Given limitations in the Python re # module, it may be necessary to break the master regex into separate expressions. # ----------------------------------------------------------------------------- def _form_master_re(relist, reflags, ldict, toknames): if not relist: return [] regex = '|'.join(relist) try: lexre = re.compile(regex, reflags) # Build the index to function map for the matching engine lexindexfunc = [None] * (max(lexre.groupindex.values()) + 1) lexindexnames = lexindexfunc[:] for f, i in lexre.groupindex.items(): handle = ldict.get(f, None) if type(handle) in (types.FunctionType, types.MethodType): lexindexfunc[i] = (handle, toknames[f]) lexindexnames[i] = f elif handle is not None: lexindexnames[i] = f if f.find('ignore_') > 0: lexindexfunc[i] = (None, None) else: lexindexfunc[i] = (None, toknames[f]) return [(lexre, lexindexfunc)], [regex], [lexindexnames] except Exception: m = int(len(relist)/2) if m == 0: m = 1 llist, lre, lnames = _form_master_re(relist[:m], reflags, ldict, toknames) rlist, rre, rnames = _form_master_re(relist[m:], reflags, ldict, toknames) return (llist+rlist), (lre+rre), (lnames+rnames) # ----------------------------------------------------------------------------- # def _statetoken(s,names) # # Given a declaration name s of the form "t_" and a dictionary whose keys are # state names, this function returns a tuple (states,tokenname) where states # is a tuple of state names and tokenname is the name of the token. For example, # calling this with s = "t_foo_bar_SPAM" might return (('foo','bar'),'SPAM') # ----------------------------------------------------------------------------- def _statetoken(s, names): parts = s.split('_') for i, part in enumerate(parts[1:], 1): if part not in names and part != 'ANY': break if i > 1: states = tuple(parts[1:i]) else: states = ('INITIAL',) if 'ANY' in states: states = tuple(names) tokenname = '_'.join(parts[i:]) return (states, tokenname) # ----------------------------------------------------------------------------- # LexerReflect() # # This class represents information needed to build a lexer as extracted from a # user's input file. # ----------------------------------------------------------------------------- class LexerReflect(object): def __init__(self, ldict, log=None, reflags=0): self.ldict = ldict self.error_func = None self.tokens = [] self.reflags = reflags self.stateinfo = {'INITIAL': 'inclusive'} self.modules = set() self.error = False self.log = PlyLogger(sys.stderr) if log is None else log # Get all of the basic information def get_all(self): self.get_tokens() self.get_literals() self.get_states() self.get_rules() # Validate all of the information def validate_all(self): self.validate_tokens() self.validate_literals() self.validate_rules() return self.error # Get the tokens map def get_tokens(self): tokens = self.ldict.get('tokens', None) if not tokens: self.log.error('No token list is defined') self.error = True return if not isinstance(tokens, (list, tuple)): self.log.error('tokens must be a list or tuple') self.error = True return if not tokens: self.log.error('tokens is empty') self.error = True return self.tokens = tokens # Validate the tokens def validate_tokens(self): terminals = {} for n in self.tokens: if not _is_identifier.match(n): self.log.error("Bad token name '%s'", n) self.error = True if n in terminals: self.log.warning("Token '%s' multiply defined", n) terminals[n] = 1 # Get the literals specifier def get_literals(self): self.literals = self.ldict.get('literals', '') if not self.literals: self.literals = '' # Validate literals def validate_literals(self): try: for c in self.literals: if not isinstance(c, StringTypes) or len(c) > 1: self.log.error('Invalid literal %s. Must be a single character', repr(c)) self.error = True except TypeError: self.log.error('Invalid literals specification. literals must be a sequence of characters') self.error = True def get_states(self): self.states = self.ldict.get('states', None) # Build statemap if self.states: if not isinstance(self.states, (tuple, list)): self.log.error('states must be defined as a tuple or list') self.error = True else: for s in self.states: if not isinstance(s, tuple) or len(s) != 2: self.log.error("Invalid state specifier %s. Must be a tuple (statename,'exclusive|inclusive')", repr(s)) self.error = True continue name, statetype = s if not isinstance(name, StringTypes): self.log.error('State name %s must be a string', repr(name)) self.error = True continue if not (statetype == 'inclusive' or statetype == 'exclusive'): self.log.error("State type for state %s must be 'inclusive' or 'exclusive'", name) self.error = True continue if name in self.stateinfo: self.log.error("State '%s' already defined", name) self.error = True continue self.stateinfo[name] = statetype # Get all of the symbols with a t_ prefix and sort them into various # categories (functions, strings, error functions, and ignore characters) def get_rules(self): tsymbols = [f for f in self.ldict if f[:2] == 't_'] # Now build up a list of functions and a list of strings self.toknames = {} # Mapping of symbols to token names self.funcsym = {} # Symbols defined as functions self.strsym = {} # Symbols defined as strings self.ignore = {} # Ignore strings by state self.errorf = {} # Error functions by state self.eoff = {} # EOF functions by state for s in self.stateinfo: self.funcsym[s] = [] self.strsym[s] = [] if len(tsymbols) == 0: self.log.error('No rules of the form t_rulename are defined') self.error = True return for f in tsymbols: t = self.ldict[f] states, tokname = _statetoken(f, self.stateinfo) self.toknames[f] = tokname if hasattr(t, '__call__'): if tokname == 'error': for s in states: self.errorf[s] = t elif tokname == 'eof': for s in states: self.eoff[s] = t elif tokname == 'ignore': line = t.__code__.co_firstlineno file = t.__code__.co_filename self.log.error("%s:%d: Rule '%s' must be defined as a string", file, line, t.__name__) self.error = True else: for s in states: self.funcsym[s].append((f, t)) elif isinstance(t, StringTypes): if tokname == 'ignore': for s in states: self.ignore[s] = t if '\\' in t: self.log.warning("%s contains a literal backslash '\\'", f) elif tokname == 'error': self.log.error("Rule '%s' must be defined as a function", f) self.error = True else: for s in states: self.strsym[s].append((f, t)) else: self.log.error('%s not defined as a function or string', f) self.error = True # Sort the functions by line number for f in self.funcsym.values(): f.sort(key=lambda x: x[1].__code__.co_firstlineno) # Sort the strings by regular expression length for s in self.strsym.values(): s.sort(key=lambda x: len(x[1]), reverse=True) # Validate all of the t_rules collected def validate_rules(self): for state in self.stateinfo: # Validate all rules defined by functions for fname, f in self.funcsym[state]: line = f.__code__.co_firstlineno file = f.__code__.co_filename module = inspect.getmodule(f) self.modules.add(module) tokname = self.toknames[fname] if isinstance(f, types.MethodType): reqargs = 2 else: reqargs = 1 nargs = f.__code__.co_argcount if nargs > reqargs: self.log.error("%s:%d: Rule '%s' has too many arguments", file, line, f.__name__) self.error = True continue if nargs < reqargs: self.log.error("%s:%d: Rule '%s' requires an argument", file, line, f.__name__) self.error = True continue if not _get_regex(f): self.log.error("%s:%d: No regular expression defined for rule '%s'", file, line, f.__name__) self.error = True continue try: c = re.compile('(?P<%s>%s)' % (fname, _get_regex(f)), self.reflags) if c.match(''): self.log.error("%s:%d: Regular expression for rule '%s' matches empty string", file, line, f.__name__) self.error = True except re.error as e: self.log.error("%s:%d: Invalid regular expression for rule '%s'. %s", file, line, f.__name__, e) if '#' in _get_regex(f): self.log.error("%s:%d. Make sure '#' in rule '%s' is escaped with '\\#'", file, line, f.__name__) self.error = True # Validate all rules defined by strings for name, r in self.strsym[state]: tokname = self.toknames[name] if tokname == 'error': self.log.error("Rule '%s' must be defined as a function", name) self.error = True continue if tokname not in self.tokens and tokname.find('ignore_') < 0: self.log.error("Rule '%s' defined for an unspecified token %s", name, tokname) self.error = True continue try: c = re.compile('(?P<%s>%s)' % (name, r), self.reflags) if (c.match('')): self.log.error("Regular expression for rule '%s' matches empty string", name) self.error = True except re.error as e: self.log.error("Invalid regular expression for rule '%s'. %s", name, e) if '#' in r: self.log.error("Make sure '#' in rule '%s' is escaped with '\\#'", name) self.error = True if not self.funcsym[state] and not self.strsym[state]: self.log.error("No rules defined for state '%s'", state) self.error = True # Validate the error function efunc = self.errorf.get(state, None) if efunc: f = efunc line = f.__code__.co_firstlineno file = f.__code__.co_filename module = inspect.getmodule(f) self.modules.add(module) if isinstance(f, types.MethodType): reqargs = 2 else: reqargs = 1 nargs = f.__code__.co_argcount if nargs > reqargs: self.log.error("%s:%d: Rule '%s' has too many arguments", file, line, f.__name__) self.error = True if nargs < reqargs: self.log.error("%s:%d: Rule '%s' requires an argument", file, line, f.__name__) self.error = True for module in self.modules: self.validate_module(module) # ----------------------------------------------------------------------------- # validate_module() # # This checks to see if there are duplicated t_rulename() functions or strings # in the parser input file. This is done using a simple regular expression # match on each line in the source code of the given module. # ----------------------------------------------------------------------------- def validate_module(self, module): try: lines, linen = inspect.getsourcelines(module) except IOError: return fre = re.compile(r'\s*def\s+(t_[a-zA-Z_0-9]*)\(') sre = re.compile(r'\s*(t_[a-zA-Z_0-9]*)\s*=') counthash = {} linen += 1 for line in lines: m = fre.match(line) if not m: m = sre.match(line) if m: name = m.group(1) prev = counthash.get(name) if not prev: counthash[name] = linen else: filename = inspect.getsourcefile(module) self.log.error('%s:%d: Rule %s redefined. Previously defined on line %d', filename, linen, name, prev) self.error = True linen += 1 # ----------------------------------------------------------------------------- # lex(module) # # Build all of the regular expression rules from definitions in the supplied module # ----------------------------------------------------------------------------- def lex(module=None, object=None, debug=False, optimize=False, lextab='lextab', reflags=int(re.VERBOSE), nowarn=False, outputdir=None, debuglog=None, errorlog=None): if lextab is None: lextab = 'lextab' global lexer ldict = None stateinfo = {'INITIAL': 'inclusive'} lexobj = Lexer() lexobj.lexoptimize = optimize global token, input if errorlog is None: errorlog = PlyLogger(sys.stderr) if debug: if debuglog is None: debuglog = PlyLogger(sys.stderr) # Get the module dictionary used for the lexer if object: module = object # Get the module dictionary used for the parser if module: _items = [(k, getattr(module, k)) for k in dir(module)] ldict = dict(_items) # If no __file__ attribute is available, try to obtain it from the __module__ instead if '__file__' not in ldict: ldict['__file__'] = sys.modules[ldict['__module__']].__file__ else: ldict = get_caller_module_dict(2) # Determine if the module is package of a package or not. # If so, fix the tabmodule setting so that tables load correctly pkg = ldict.get('__package__') if pkg and isinstance(lextab, str): if '.' not in lextab: lextab = pkg + '.' + lextab # Collect parser information from the dictionary linfo = LexerReflect(ldict, log=errorlog, reflags=reflags) linfo.get_all() if not optimize: if linfo.validate_all(): raise SyntaxError("Can't build lexer") if optimize and lextab: try: lexobj.readtab(lextab, ldict) token = lexobj.token input = lexobj.input lexer = lexobj return lexobj except ImportError: pass # Dump some basic debugging information if debug: debuglog.info('lex: tokens = %r', linfo.tokens) debuglog.info('lex: literals = %r', linfo.literals) debuglog.info('lex: states = %r', linfo.stateinfo) # Build a dictionary of valid token names lexobj.lextokens = set() for n in linfo.tokens: lexobj.lextokens.add(n) # Get literals specification if isinstance(linfo.literals, (list, tuple)): lexobj.lexliterals = type(linfo.literals[0])().join(linfo.literals) else: lexobj.lexliterals = linfo.literals lexobj.lextokens_all = lexobj.lextokens | set(lexobj.lexliterals) # Get the stateinfo dictionary stateinfo = linfo.stateinfo regexs = {} # Build the master regular expressions for state in stateinfo: regex_list = [] # Add rules defined by functions first for fname, f in linfo.funcsym[state]: regex_list.append('(?P<%s>%s)' % (fname, _get_regex(f))) if debug: debuglog.info("lex: Adding rule %s -> '%s' (state '%s')", fname, _get_regex(f), state) # Now add all of the simple rules for name, r in linfo.strsym[state]: regex_list.append('(?P<%s>%s)' % (name, r)) if debug: debuglog.info("lex: Adding rule %s -> '%s' (state '%s')", name, r, state) regexs[state] = regex_list # Build the master regular expressions if debug: debuglog.info('lex: ==== MASTER REGEXS FOLLOW ====') for state in regexs: lexre, re_text, re_names = _form_master_re(regexs[state], reflags, ldict, linfo.toknames) lexobj.lexstatere[state] = lexre lexobj.lexstateretext[state] = re_text lexobj.lexstaterenames[state] = re_names if debug: for i, text in enumerate(re_text): debuglog.info("lex: state '%s' : regex[%d] = '%s'", state, i, text) # For inclusive states, we need to add the regular expressions from the INITIAL state for state, stype in stateinfo.items(): if state != 'INITIAL' and stype == 'inclusive': lexobj.lexstatere[state].extend(lexobj.lexstatere['INITIAL']) lexobj.lexstateretext[state].extend(lexobj.lexstateretext['INITIAL']) lexobj.lexstaterenames[state].extend(lexobj.lexstaterenames['INITIAL']) lexobj.lexstateinfo = stateinfo lexobj.lexre = lexobj.lexstatere['INITIAL'] lexobj.lexretext = lexobj.lexstateretext['INITIAL'] lexobj.lexreflags = reflags # Set up ignore variables lexobj.lexstateignore = linfo.ignore lexobj.lexignore = lexobj.lexstateignore.get('INITIAL', '') # Set up error functions lexobj.lexstateerrorf = linfo.errorf lexobj.lexerrorf = linfo.errorf.get('INITIAL', None) if not lexobj.lexerrorf: errorlog.warning('No t_error rule is defined') # Set up eof functions lexobj.lexstateeoff = linfo.eoff lexobj.lexeoff = linfo.eoff.get('INITIAL', None) # Check state information for ignore and error rules for s, stype in stateinfo.items(): if stype == 'exclusive': if s not in linfo.errorf: errorlog.warning("No error rule is defined for exclusive state '%s'", s) if s not in linfo.ignore and lexobj.lexignore: errorlog.warning("No ignore rule is defined for exclusive state '%s'", s) elif stype == 'inclusive': if s not in linfo.errorf: linfo.errorf[s] = linfo.errorf.get('INITIAL', None) if s not in linfo.ignore: linfo.ignore[s] = linfo.ignore.get('INITIAL', '') # Create global versions of the token() and input() functions token = lexobj.token input = lexobj.input lexer = lexobj # If in optimize mode, we write the lextab if lextab and optimize: if outputdir is None: # If no output directory is set, the location of the output files # is determined according to the following rules: # - If lextab specifies a package, files go into that package directory # - Otherwise, files go in the same directory as the specifying module if isinstance(lextab, types.ModuleType): srcfile = lextab.__file__ else: if '.' not in lextab: srcfile = ldict['__file__'] else: parts = lextab.split('.') pkgname = '.'.join(parts[:-1]) exec('import %s' % pkgname) srcfile = getattr(sys.modules[pkgname], '__file__', '') outputdir = os.path.dirname(srcfile) try: lexobj.writetab(lextab, outputdir) if lextab in sys.modules: del sys.modules[lextab] except IOError as e: errorlog.warning("Couldn't write lextab module %r. %s" % (lextab, e)) return lexobj # ----------------------------------------------------------------------------- # runmain() # # This runs the lexer as a main program # ----------------------------------------------------------------------------- def runmain(lexer=None, data=None): if not data: try: filename = sys.argv[1] f = open(filename) data = f.read() f.close() except IndexError: sys.stdout.write('Reading from standard input (type EOF to end):\n') data = sys.stdin.read() if lexer: _input = lexer.input else: _input = input _input(data) if lexer: _token = lexer.token else: _token = token while True: tok = _token() if not tok: break sys.stdout.write('(%s,%r,%d,%d)\n' % (tok.type, tok.value, tok.lineno, tok.lexpos)) # ----------------------------------------------------------------------------- # @TOKEN(regex) # # This decorator function can be used to set the regex expression on a function # when its docstring might need to be set in an alternative way # ----------------------------------------------------------------------------- def TOKEN(r): def set_regex(f): if hasattr(r, '__call__'): f.regex = _get_regex(r) else: f.regex = r return f return set_regex # Alternative spelling of the TOKEN decorator Token = TOKEN jsonpath-ng-1.8.0/jsonpath_ng/_ply/yacc.py000066400000000000000000004102111514733354600205300ustar00rootroot00000000000000# ----------------------------------------------------------------------------- # ply: yacc.py # # Copyright (C) 2001-2018 # David M. Beazley (Dabeaz LLC) # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are # met: # # * Redistributions of source code must retain the above copyright notice, # this list of conditions and the following disclaimer. # * Redistributions in binary form must reproduce the above copyright notice, # this list of conditions and the following disclaimer in the documentation # and/or other materials provided with the distribution. # * Neither the name of the David Beazley or Dabeaz LLC may be used to # endorse or promote products derived from this software without # specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # ----------------------------------------------------------------------------- # # This implements an LR parser that is constructed from grammar rules defined # as Python functions. The grammar is specified by supplying the BNF inside # Python documentation strings. The inspiration for this technique was borrowed # from John Aycock's Spark parsing system. PLY might be viewed as cross between # Spark and the GNU bison utility. # # The current implementation is only somewhat object-oriented. The # LR parser itself is defined in terms of an object (which allows multiple # parsers to co-exist). However, most of the variables used during table # construction are defined in terms of global variables. Users shouldn't # notice unless they are trying to define multiple parsers at the same # time using threads (in which case they should have their head examined). # # This implementation supports both SLR and LALR(1) parsing. LALR(1) # support was originally implemented by Elias Ioup (ezioup@alumni.uchicago.edu), # using the algorithm found in Aho, Sethi, and Ullman "Compilers: Principles, # Techniques, and Tools" (The Dragon Book). LALR(1) has since been replaced # by the more efficient DeRemer and Pennello algorithm. # # :::::::: WARNING ::::::: # # Construction of LR parsing tables is fairly complicated and expensive. # To make this module run fast, a *LOT* of work has been put into # optimization---often at the expensive of readability and what might # consider to be good Python "coding style." Modify the code at your # own risk! # ---------------------------------------------------------------------------- import re import types import sys import os.path import inspect import warnings __version__ = '3.11' __tabversion__ = '3.10' #----------------------------------------------------------------------------- # === User configurable parameters === # # Change these to modify the default behavior of yacc (if you wish) #----------------------------------------------------------------------------- yaccdebug = True # Debugging mode. If set, yacc generates a # a 'parser.out' file in the current directory debug_file = 'parser.out' # Default name of the debugging file tab_module = 'parsetab' # Default name of the table module default_lr = 'LALR' # Default LR table generation method error_count = 3 # Number of symbols that must be shifted to leave recovery mode yaccdevel = False # Set to True if developing yacc. This turns off optimized # implementations of certain functions. resultlimit = 40 # Size limit of results when running in debug mode. # String type-checking compatibility if sys.version_info[0] < 3: string_types = basestring else: string_types = str MAXINT = sys.maxsize # This object is a stand-in for a logging object created by the # logging module. PLY will use this by default to create things # such as the parser.out file. If a user wants more detailed # information, they can create their own logging object and pass # it into PLY. class PlyLogger(object): def __init__(self, f): self.f = f def debug(self, msg, *args, **kwargs): self.f.write((msg % args) + '\n') info = debug def warning(self, msg, *args, **kwargs): self.f.write('WARNING: ' + (msg % args) + '\n') def error(self, msg, *args, **kwargs): self.f.write('ERROR: ' + (msg % args) + '\n') critical = debug # Null logger is used when no output is generated. Does nothing. class NullLogger(object): def __getattribute__(self, name): return self def __call__(self, *args, **kwargs): return self # Exception raised for yacc-related errors class YaccError(Exception): pass # Format the result message that the parser produces when running in debug mode. def format_result(r): repr_str = repr(r) if '\n' in repr_str: repr_str = repr(repr_str) if len(repr_str) > resultlimit: repr_str = repr_str[:resultlimit] + ' ...' result = '<%s @ 0x%x> (%s)' % (type(r).__name__, id(r), repr_str) return result # Format stack entries when the parser is running in debug mode def format_stack_entry(r): repr_str = repr(r) if '\n' in repr_str: repr_str = repr(repr_str) if len(repr_str) < 16: return repr_str else: return '<%s @ 0x%x>' % (type(r).__name__, id(r)) # Panic mode error recovery support. This feature is being reworked--much of the # code here is to offer a deprecation/backwards compatible transition _errok = None _token = None _restart = None _warnmsg = '''PLY: Don't use global functions errok(), token(), and restart() in p_error(). Instead, invoke the methods on the associated parser instance: def p_error(p): ... # Use parser.errok(), parser.token(), parser.restart() ... parser = yacc.yacc() ''' def errok(): warnings.warn(_warnmsg) return _errok() def restart(): warnings.warn(_warnmsg) return _restart() def token(): warnings.warn(_warnmsg) return _token() # Utility function to call the p_error() function with some deprecation hacks def call_errorfunc(errorfunc, token, parser): global _errok, _token, _restart _errok = parser.errok _token = parser.token _restart = parser.restart r = errorfunc(token) try: del _errok, _token, _restart except NameError: pass return r #----------------------------------------------------------------------------- # === LR Parsing Engine === # # The following classes are used for the LR parser itself. These are not # used during table construction and are independent of the actual LR # table generation algorithm #----------------------------------------------------------------------------- # This class is used to hold non-terminal grammar symbols during parsing. # It normally has the following attributes set: # .type = Grammar symbol type # .value = Symbol value # .lineno = Starting line number # .endlineno = Ending line number (optional, set automatically) # .lexpos = Starting lex position # .endlexpos = Ending lex position (optional, set automatically) class YaccSymbol: def __str__(self): return self.type def __repr__(self): return str(self) # This class is a wrapper around the objects actually passed to each # grammar rule. Index lookup and assignment actually assign the # .value attribute of the underlying YaccSymbol object. # The lineno() method returns the line number of a given # item (or 0 if not defined). The linespan() method returns # a tuple of (startline,endline) representing the range of lines # for a symbol. The lexspan() method returns a tuple (lexpos,endlexpos) # representing the range of positional information for a symbol. class YaccProduction: def __init__(self, s, stack=None): self.slice = s self.stack = stack self.lexer = None self.parser = None def __getitem__(self, n): if isinstance(n, slice): return [s.value for s in self.slice[n]] elif n >= 0: return self.slice[n].value else: return self.stack[n].value def __setitem__(self, n, v): self.slice[n].value = v def __getslice__(self, i, j): return [s.value for s in self.slice[i:j]] def __len__(self): return len(self.slice) def lineno(self, n): return getattr(self.slice[n], 'lineno', 0) def set_lineno(self, n, lineno): self.slice[n].lineno = lineno def linespan(self, n): startline = getattr(self.slice[n], 'lineno', 0) endline = getattr(self.slice[n], 'endlineno', startline) return startline, endline def lexpos(self, n): return getattr(self.slice[n], 'lexpos', 0) def set_lexpos(self, n, lexpos): self.slice[n].lexpos = lexpos def lexspan(self, n): startpos = getattr(self.slice[n], 'lexpos', 0) endpos = getattr(self.slice[n], 'endlexpos', startpos) return startpos, endpos def error(self): raise SyntaxError # ----------------------------------------------------------------------------- # == LRParser == # # The LR Parsing engine. # ----------------------------------------------------------------------------- class LRParser: def __init__(self, lrtab, errorf): self.productions = lrtab.lr_productions self.action = lrtab.lr_action self.goto = lrtab.lr_goto self.errorfunc = errorf self.set_defaulted_states() self.errorok = True def errok(self): self.errorok = True def restart(self): del self.statestack[:] del self.symstack[:] sym = YaccSymbol() sym.type = '$end' self.symstack.append(sym) self.statestack.append(0) # Defaulted state support. # This method identifies parser states where there is only one possible reduction action. # For such states, the parser can make a choose to make a rule reduction without consuming # the next look-ahead token. This delayed invocation of the tokenizer can be useful in # certain kinds of advanced parsing situations where the lexer and parser interact with # each other or change states (i.e., manipulation of scope, lexer states, etc.). # # See: http://www.gnu.org/software/bison/manual/html_node/Default-Reductions.html#Default-Reductions def set_defaulted_states(self): self.defaulted_states = {} for state, actions in self.action.items(): rules = list(actions.values()) if len(rules) == 1 and rules[0] < 0: self.defaulted_states[state] = rules[0] def disable_defaulted_states(self): self.defaulted_states = {} def parse(self, input=None, lexer=None, debug=False, tracking=False, tokenfunc=None): if debug or yaccdevel: if isinstance(debug, int): debug = PlyLogger(sys.stderr) return self.parsedebug(input, lexer, debug, tracking, tokenfunc) elif tracking: return self.parseopt(input, lexer, debug, tracking, tokenfunc) else: return self.parseopt_notrack(input, lexer, debug, tracking, tokenfunc) # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # parsedebug(). # # This is the debugging enabled version of parse(). All changes made to the # parsing engine should be made here. Optimized versions of this function # are automatically created by the ply/ygen.py script. This script cuts out # sections enclosed in markers such as this: # # #--! DEBUG # statements # #--! DEBUG # # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! def parsedebug(self, input=None, lexer=None, debug=False, tracking=False, tokenfunc=None): #--! parsedebug-start lookahead = None # Current lookahead symbol lookaheadstack = [] # Stack of lookahead symbols actions = self.action # Local reference to action table (to avoid lookup on self.) goto = self.goto # Local reference to goto table (to avoid lookup on self.) prod = self.productions # Local reference to production list (to avoid lookup on self.) defaulted_states = self.defaulted_states # Local reference to defaulted states pslice = YaccProduction(None) # Production object passed to grammar rules errorcount = 0 # Used during error recovery #--! DEBUG debug.info('PLY: PARSE DEBUG START') #--! DEBUG # If no lexer was given, we will try to use the lex module if not lexer: from . import lex lexer = lex.lexer # Set up the lexer and parser objects on pslice pslice.lexer = lexer pslice.parser = self # If input was supplied, pass to lexer if input is not None: lexer.input(input) if tokenfunc is None: # Tokenize function get_token = lexer.token else: get_token = tokenfunc # Set the parser() token method (sometimes used in error recovery) self.token = get_token # Set up the state and symbol stacks statestack = [] # Stack of parsing states self.statestack = statestack symstack = [] # Stack of grammar symbols self.symstack = symstack pslice.stack = symstack # Put in the production errtoken = None # Err token # The start state is assumed to be (0,$end) statestack.append(0) sym = YaccSymbol() sym.type = '$end' symstack.append(sym) state = 0 while True: # Get the next symbol on the input. If a lookahead symbol # is already set, we just use that. Otherwise, we'll pull # the next token off of the lookaheadstack or from the lexer #--! DEBUG debug.debug('') debug.debug('State : %s', state) #--! DEBUG if state not in defaulted_states: if not lookahead: if not lookaheadstack: lookahead = get_token() # Get the next token else: lookahead = lookaheadstack.pop() if not lookahead: lookahead = YaccSymbol() lookahead.type = '$end' # Check the action table ltype = lookahead.type t = actions[state].get(ltype) else: t = defaulted_states[state] #--! DEBUG debug.debug('Defaulted state %s: Reduce using %d', state, -t) #--! DEBUG #--! DEBUG debug.debug('Stack : %s', ('%s . %s' % (' '.join([xx.type for xx in symstack][1:]), str(lookahead))).lstrip()) #--! DEBUG if t is not None: if t > 0: # shift a symbol on the stack statestack.append(t) state = t #--! DEBUG debug.debug('Action : Shift and goto state %s', t) #--! DEBUG symstack.append(lookahead) lookahead = None # Decrease error count on successful shift if errorcount: errorcount -= 1 continue if t < 0: # reduce a symbol on the stack, emit a production p = prod[-t] pname = p.name plen = p.len # Get production function sym = YaccSymbol() sym.type = pname # Production name sym.value = None #--! DEBUG if plen: debug.info('Action : Reduce rule [%s] with %s and goto state %d', p.str, '['+','.join([format_stack_entry(_v.value) for _v in symstack[-plen:]])+']', goto[statestack[-1-plen]][pname]) else: debug.info('Action : Reduce rule [%s] with %s and goto state %d', p.str, [], goto[statestack[-1]][pname]) #--! DEBUG if plen: targ = symstack[-plen-1:] targ[0] = sym #--! TRACKING if tracking: t1 = targ[1] sym.lineno = t1.lineno sym.lexpos = t1.lexpos t1 = targ[-1] sym.endlineno = getattr(t1, 'endlineno', t1.lineno) sym.endlexpos = getattr(t1, 'endlexpos', t1.lexpos) #--! TRACKING # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # The code enclosed in this section is duplicated # below as a performance optimization. Make sure # changes get made in both locations. pslice.slice = targ try: # Call the grammar rule with our special slice object del symstack[-plen:] self.state = state p.callable(pslice) del statestack[-plen:] #--! DEBUG debug.info('Result : %s', format_result(pslice[0])) #--! DEBUG symstack.append(sym) state = goto[statestack[-1]][pname] statestack.append(state) except SyntaxError: # If an error was set. Enter error recovery state lookaheadstack.append(lookahead) # Save the current lookahead token symstack.extend(targ[1:-1]) # Put the production slice back on the stack statestack.pop() # Pop back one state (before the reduce) state = statestack[-1] sym.type = 'error' sym.value = 'error' lookahead = sym errorcount = error_count self.errorok = False continue # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! else: #--! TRACKING if tracking: sym.lineno = lexer.lineno sym.lexpos = lexer.lexpos #--! TRACKING targ = [sym] # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # The code enclosed in this section is duplicated # above as a performance optimization. Make sure # changes get made in both locations. pslice.slice = targ try: # Call the grammar rule with our special slice object self.state = state p.callable(pslice) #--! DEBUG debug.info('Result : %s', format_result(pslice[0])) #--! DEBUG symstack.append(sym) state = goto[statestack[-1]][pname] statestack.append(state) except SyntaxError: # If an error was set. Enter error recovery state lookaheadstack.append(lookahead) # Save the current lookahead token statestack.pop() # Pop back one state (before the reduce) state = statestack[-1] sym.type = 'error' sym.value = 'error' lookahead = sym errorcount = error_count self.errorok = False continue # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! if t == 0: n = symstack[-1] result = getattr(n, 'value', None) #--! DEBUG debug.info('Done : Returning %s', format_result(result)) debug.info('PLY: PARSE DEBUG END') #--! DEBUG return result if t is None: #--! DEBUG debug.error('Error : %s', ('%s . %s' % (' '.join([xx.type for xx in symstack][1:]), str(lookahead))).lstrip()) #--! DEBUG # We have some kind of parsing error here. To handle # this, we are going to push the current token onto # the tokenstack and replace it with an 'error' token. # If there are any synchronization rules, they may # catch it. # # In addition to pushing the error token, we call call # the user defined p_error() function if this is the # first syntax error. This function is only called if # errorcount == 0. if errorcount == 0 or self.errorok: errorcount = error_count self.errorok = False errtoken = lookahead if errtoken.type == '$end': errtoken = None # End of file! if self.errorfunc: if errtoken and not hasattr(errtoken, 'lexer'): errtoken.lexer = lexer self.state = state tok = call_errorfunc(self.errorfunc, errtoken, self) if self.errorok: # User must have done some kind of panic # mode recovery on their own. The # returned token is the next lookahead lookahead = tok errtoken = None continue else: if errtoken: if hasattr(errtoken, 'lineno'): lineno = lookahead.lineno else: lineno = 0 if lineno: sys.stderr.write('yacc: Syntax error at line %d, token=%s\n' % (lineno, errtoken.type)) else: sys.stderr.write('yacc: Syntax error, token=%s' % errtoken.type) else: sys.stderr.write('yacc: Parse error in input. EOF\n') return else: errorcount = error_count # case 1: the statestack only has 1 entry on it. If we're in this state, the # entire parse has been rolled back and we're completely hosed. The token is # discarded and we just keep going. if len(statestack) <= 1 and lookahead.type != '$end': lookahead = None errtoken = None state = 0 # Nuke the pushback stack del lookaheadstack[:] continue # case 2: the statestack has a couple of entries on it, but we're # at the end of the file. nuke the top entry and generate an error token # Start nuking entries on the stack if lookahead.type == '$end': # Whoa. We're really hosed here. Bail out return if lookahead.type != 'error': sym = symstack[-1] if sym.type == 'error': # Hmmm. Error is on top of stack, we'll just nuke input # symbol and continue #--! TRACKING if tracking: sym.endlineno = getattr(lookahead, 'lineno', sym.lineno) sym.endlexpos = getattr(lookahead, 'lexpos', sym.lexpos) #--! TRACKING lookahead = None continue # Create the error symbol for the first time and make it the new lookahead symbol t = YaccSymbol() t.type = 'error' if hasattr(lookahead, 'lineno'): t.lineno = t.endlineno = lookahead.lineno if hasattr(lookahead, 'lexpos'): t.lexpos = t.endlexpos = lookahead.lexpos t.value = lookahead lookaheadstack.append(lookahead) lookahead = t else: sym = symstack.pop() #--! TRACKING if tracking: lookahead.lineno = sym.lineno lookahead.lexpos = sym.lexpos #--! TRACKING statestack.pop() state = statestack[-1] continue # Call an error function here raise RuntimeError('yacc: internal parser error!!!\n') #--! parsedebug-end # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # parseopt(). # # Optimized version of parse() method. DO NOT EDIT THIS CODE DIRECTLY! # This code is automatically generated by the ply/ygen.py script. Make # changes to the parsedebug() method instead. # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! def parseopt(self, input=None, lexer=None, debug=False, tracking=False, tokenfunc=None): #--! parseopt-start lookahead = None # Current lookahead symbol lookaheadstack = [] # Stack of lookahead symbols actions = self.action # Local reference to action table (to avoid lookup on self.) goto = self.goto # Local reference to goto table (to avoid lookup on self.) prod = self.productions # Local reference to production list (to avoid lookup on self.) defaulted_states = self.defaulted_states # Local reference to defaulted states pslice = YaccProduction(None) # Production object passed to grammar rules errorcount = 0 # Used during error recovery # If no lexer was given, we will try to use the lex module if not lexer: from . import lex lexer = lex.lexer # Set up the lexer and parser objects on pslice pslice.lexer = lexer pslice.parser = self # If input was supplied, pass to lexer if input is not None: lexer.input(input) if tokenfunc is None: # Tokenize function get_token = lexer.token else: get_token = tokenfunc # Set the parser() token method (sometimes used in error recovery) self.token = get_token # Set up the state and symbol stacks statestack = [] # Stack of parsing states self.statestack = statestack symstack = [] # Stack of grammar symbols self.symstack = symstack pslice.stack = symstack # Put in the production errtoken = None # Err token # The start state is assumed to be (0,$end) statestack.append(0) sym = YaccSymbol() sym.type = '$end' symstack.append(sym) state = 0 while True: # Get the next symbol on the input. If a lookahead symbol # is already set, we just use that. Otherwise, we'll pull # the next token off of the lookaheadstack or from the lexer if state not in defaulted_states: if not lookahead: if not lookaheadstack: lookahead = get_token() # Get the next token else: lookahead = lookaheadstack.pop() if not lookahead: lookahead = YaccSymbol() lookahead.type = '$end' # Check the action table ltype = lookahead.type t = actions[state].get(ltype) else: t = defaulted_states[state] if t is not None: if t > 0: # shift a symbol on the stack statestack.append(t) state = t symstack.append(lookahead) lookahead = None # Decrease error count on successful shift if errorcount: errorcount -= 1 continue if t < 0: # reduce a symbol on the stack, emit a production p = prod[-t] pname = p.name plen = p.len # Get production function sym = YaccSymbol() sym.type = pname # Production name sym.value = None if plen: targ = symstack[-plen-1:] targ[0] = sym #--! TRACKING if tracking: t1 = targ[1] sym.lineno = t1.lineno sym.lexpos = t1.lexpos t1 = targ[-1] sym.endlineno = getattr(t1, 'endlineno', t1.lineno) sym.endlexpos = getattr(t1, 'endlexpos', t1.lexpos) #--! TRACKING # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # The code enclosed in this section is duplicated # below as a performance optimization. Make sure # changes get made in both locations. pslice.slice = targ try: # Call the grammar rule with our special slice object del symstack[-plen:] self.state = state p.callable(pslice) del statestack[-plen:] symstack.append(sym) state = goto[statestack[-1]][pname] statestack.append(state) except SyntaxError: # If an error was set. Enter error recovery state lookaheadstack.append(lookahead) # Save the current lookahead token symstack.extend(targ[1:-1]) # Put the production slice back on the stack statestack.pop() # Pop back one state (before the reduce) state = statestack[-1] sym.type = 'error' sym.value = 'error' lookahead = sym errorcount = error_count self.errorok = False continue # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! else: #--! TRACKING if tracking: sym.lineno = lexer.lineno sym.lexpos = lexer.lexpos #--! TRACKING targ = [sym] # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # The code enclosed in this section is duplicated # above as a performance optimization. Make sure # changes get made in both locations. pslice.slice = targ try: # Call the grammar rule with our special slice object self.state = state p.callable(pslice) symstack.append(sym) state = goto[statestack[-1]][pname] statestack.append(state) except SyntaxError: # If an error was set. Enter error recovery state lookaheadstack.append(lookahead) # Save the current lookahead token statestack.pop() # Pop back one state (before the reduce) state = statestack[-1] sym.type = 'error' sym.value = 'error' lookahead = sym errorcount = error_count self.errorok = False continue # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! if t == 0: n = symstack[-1] result = getattr(n, 'value', None) return result if t is None: # We have some kind of parsing error here. To handle # this, we are going to push the current token onto # the tokenstack and replace it with an 'error' token. # If there are any synchronization rules, they may # catch it. # # In addition to pushing the error token, we call call # the user defined p_error() function if this is the # first syntax error. This function is only called if # errorcount == 0. if errorcount == 0 or self.errorok: errorcount = error_count self.errorok = False errtoken = lookahead if errtoken.type == '$end': errtoken = None # End of file! if self.errorfunc: if errtoken and not hasattr(errtoken, 'lexer'): errtoken.lexer = lexer self.state = state tok = call_errorfunc(self.errorfunc, errtoken, self) if self.errorok: # User must have done some kind of panic # mode recovery on their own. The # returned token is the next lookahead lookahead = tok errtoken = None continue else: if errtoken: if hasattr(errtoken, 'lineno'): lineno = lookahead.lineno else: lineno = 0 if lineno: sys.stderr.write('yacc: Syntax error at line %d, token=%s\n' % (lineno, errtoken.type)) else: sys.stderr.write('yacc: Syntax error, token=%s' % errtoken.type) else: sys.stderr.write('yacc: Parse error in input. EOF\n') return else: errorcount = error_count # case 1: the statestack only has 1 entry on it. If we're in this state, the # entire parse has been rolled back and we're completely hosed. The token is # discarded and we just keep going. if len(statestack) <= 1 and lookahead.type != '$end': lookahead = None errtoken = None state = 0 # Nuke the pushback stack del lookaheadstack[:] continue # case 2: the statestack has a couple of entries on it, but we're # at the end of the file. nuke the top entry and generate an error token # Start nuking entries on the stack if lookahead.type == '$end': # Whoa. We're really hosed here. Bail out return if lookahead.type != 'error': sym = symstack[-1] if sym.type == 'error': # Hmmm. Error is on top of stack, we'll just nuke input # symbol and continue #--! TRACKING if tracking: sym.endlineno = getattr(lookahead, 'lineno', sym.lineno) sym.endlexpos = getattr(lookahead, 'lexpos', sym.lexpos) #--! TRACKING lookahead = None continue # Create the error symbol for the first time and make it the new lookahead symbol t = YaccSymbol() t.type = 'error' if hasattr(lookahead, 'lineno'): t.lineno = t.endlineno = lookahead.lineno if hasattr(lookahead, 'lexpos'): t.lexpos = t.endlexpos = lookahead.lexpos t.value = lookahead lookaheadstack.append(lookahead) lookahead = t else: sym = symstack.pop() #--! TRACKING if tracking: lookahead.lineno = sym.lineno lookahead.lexpos = sym.lexpos #--! TRACKING statestack.pop() state = statestack[-1] continue # Call an error function here raise RuntimeError('yacc: internal parser error!!!\n') #--! parseopt-end # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # parseopt_notrack(). # # Optimized version of parseopt() with line number tracking removed. # DO NOT EDIT THIS CODE DIRECTLY. This code is automatically generated # by the ply/ygen.py script. Make changes to the parsedebug() method instead. # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! def parseopt_notrack(self, input=None, lexer=None, debug=False, tracking=False, tokenfunc=None): #--! parseopt-notrack-start lookahead = None # Current lookahead symbol lookaheadstack = [] # Stack of lookahead symbols actions = self.action # Local reference to action table (to avoid lookup on self.) goto = self.goto # Local reference to goto table (to avoid lookup on self.) prod = self.productions # Local reference to production list (to avoid lookup on self.) defaulted_states = self.defaulted_states # Local reference to defaulted states pslice = YaccProduction(None) # Production object passed to grammar rules errorcount = 0 # Used during error recovery # If no lexer was given, we will try to use the lex module if not lexer: from . import lex lexer = lex.lexer # Set up the lexer and parser objects on pslice pslice.lexer = lexer pslice.parser = self # If input was supplied, pass to lexer if input is not None: lexer.input(input) if tokenfunc is None: # Tokenize function get_token = lexer.token else: get_token = tokenfunc # Set the parser() token method (sometimes used in error recovery) self.token = get_token # Set up the state and symbol stacks statestack = [] # Stack of parsing states self.statestack = statestack symstack = [] # Stack of grammar symbols self.symstack = symstack pslice.stack = symstack # Put in the production errtoken = None # Err token # The start state is assumed to be (0,$end) statestack.append(0) sym = YaccSymbol() sym.type = '$end' symstack.append(sym) state = 0 while True: # Get the next symbol on the input. If a lookahead symbol # is already set, we just use that. Otherwise, we'll pull # the next token off of the lookaheadstack or from the lexer if state not in defaulted_states: if not lookahead: if not lookaheadstack: lookahead = get_token() # Get the next token else: lookahead = lookaheadstack.pop() if not lookahead: lookahead = YaccSymbol() lookahead.type = '$end' # Check the action table ltype = lookahead.type t = actions[state].get(ltype) else: t = defaulted_states[state] if t is not None: if t > 0: # shift a symbol on the stack statestack.append(t) state = t symstack.append(lookahead) lookahead = None # Decrease error count on successful shift if errorcount: errorcount -= 1 continue if t < 0: # reduce a symbol on the stack, emit a production p = prod[-t] pname = p.name plen = p.len # Get production function sym = YaccSymbol() sym.type = pname # Production name sym.value = None if plen: targ = symstack[-plen-1:] targ[0] = sym # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # The code enclosed in this section is duplicated # below as a performance optimization. Make sure # changes get made in both locations. pslice.slice = targ try: # Call the grammar rule with our special slice object del symstack[-plen:] self.state = state p.callable(pslice) del statestack[-plen:] symstack.append(sym) state = goto[statestack[-1]][pname] statestack.append(state) except SyntaxError: # If an error was set. Enter error recovery state lookaheadstack.append(lookahead) # Save the current lookahead token symstack.extend(targ[1:-1]) # Put the production slice back on the stack statestack.pop() # Pop back one state (before the reduce) state = statestack[-1] sym.type = 'error' sym.value = 'error' lookahead = sym errorcount = error_count self.errorok = False continue # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! else: targ = [sym] # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # The code enclosed in this section is duplicated # above as a performance optimization. Make sure # changes get made in both locations. pslice.slice = targ try: # Call the grammar rule with our special slice object self.state = state p.callable(pslice) symstack.append(sym) state = goto[statestack[-1]][pname] statestack.append(state) except SyntaxError: # If an error was set. Enter error recovery state lookaheadstack.append(lookahead) # Save the current lookahead token statestack.pop() # Pop back one state (before the reduce) state = statestack[-1] sym.type = 'error' sym.value = 'error' lookahead = sym errorcount = error_count self.errorok = False continue # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! if t == 0: n = symstack[-1] result = getattr(n, 'value', None) return result if t is None: # We have some kind of parsing error here. To handle # this, we are going to push the current token onto # the tokenstack and replace it with an 'error' token. # If there are any synchronization rules, they may # catch it. # # In addition to pushing the error token, we call call # the user defined p_error() function if this is the # first syntax error. This function is only called if # errorcount == 0. if errorcount == 0 or self.errorok: errorcount = error_count self.errorok = False errtoken = lookahead if errtoken.type == '$end': errtoken = None # End of file! if self.errorfunc: if errtoken and not hasattr(errtoken, 'lexer'): errtoken.lexer = lexer self.state = state tok = call_errorfunc(self.errorfunc, errtoken, self) if self.errorok: # User must have done some kind of panic # mode recovery on their own. The # returned token is the next lookahead lookahead = tok errtoken = None continue else: if errtoken: if hasattr(errtoken, 'lineno'): lineno = lookahead.lineno else: lineno = 0 if lineno: sys.stderr.write('yacc: Syntax error at line %d, token=%s\n' % (lineno, errtoken.type)) else: sys.stderr.write('yacc: Syntax error, token=%s' % errtoken.type) else: sys.stderr.write('yacc: Parse error in input. EOF\n') return else: errorcount = error_count # case 1: the statestack only has 1 entry on it. If we're in this state, the # entire parse has been rolled back and we're completely hosed. The token is # discarded and we just keep going. if len(statestack) <= 1 and lookahead.type != '$end': lookahead = None errtoken = None state = 0 # Nuke the pushback stack del lookaheadstack[:] continue # case 2: the statestack has a couple of entries on it, but we're # at the end of the file. nuke the top entry and generate an error token # Start nuking entries on the stack if lookahead.type == '$end': # Whoa. We're really hosed here. Bail out return if lookahead.type != 'error': sym = symstack[-1] if sym.type == 'error': # Hmmm. Error is on top of stack, we'll just nuke input # symbol and continue lookahead = None continue # Create the error symbol for the first time and make it the new lookahead symbol t = YaccSymbol() t.type = 'error' if hasattr(lookahead, 'lineno'): t.lineno = t.endlineno = lookahead.lineno if hasattr(lookahead, 'lexpos'): t.lexpos = t.endlexpos = lookahead.lexpos t.value = lookahead lookaheadstack.append(lookahead) lookahead = t else: sym = symstack.pop() statestack.pop() state = statestack[-1] continue # Call an error function here raise RuntimeError('yacc: internal parser error!!!\n') #--! parseopt-notrack-end # ----------------------------------------------------------------------------- # === Grammar Representation === # # The following functions, classes, and variables are used to represent and # manipulate the rules that make up a grammar. # ----------------------------------------------------------------------------- # regex matching identifiers _is_identifier = re.compile(r'^[a-zA-Z0-9_-]+$') # ----------------------------------------------------------------------------- # class Production: # # This class stores the raw information about a single production or grammar rule. # A grammar rule refers to a specification such as this: # # expr : expr PLUS term # # Here are the basic attributes defined on all productions # # name - Name of the production. For example 'expr' # prod - A list of symbols on the right side ['expr','PLUS','term'] # prec - Production precedence level # number - Production number. # func - Function that executes on reduce # file - File where production function is defined # lineno - Line number where production function is defined # # The following attributes are defined or optional. # # len - Length of the production (number of symbols on right hand side) # usyms - Set of unique symbols found in the production # ----------------------------------------------------------------------------- class Production(object): reduced = 0 def __init__(self, number, name, prod, precedence=('right', 0), func=None, file='', line=0): self.name = name self.prod = tuple(prod) self.number = number self.func = func self.callable = None self.file = file self.line = line self.prec = precedence # Internal settings used during table construction self.len = len(self.prod) # Length of the production # Create a list of unique production symbols used in the production self.usyms = [] for s in self.prod: if s not in self.usyms: self.usyms.append(s) # List of all LR items for the production self.lr_items = [] self.lr_next = None # Create a string representation if self.prod: self.str = '%s -> %s' % (self.name, ' '.join(self.prod)) else: self.str = '%s -> ' % self.name def __str__(self): return self.str def __repr__(self): return 'Production(' + str(self) + ')' def __len__(self): return len(self.prod) def __nonzero__(self): return 1 def __getitem__(self, index): return self.prod[index] # Return the nth lr_item from the production (or None if at the end) def lr_item(self, n): if n > len(self.prod): return None p = LRItem(self, n) # Precompute the list of productions immediately following. try: p.lr_after = self.Prodnames[p.prod[n+1]] except (IndexError, KeyError): p.lr_after = [] try: p.lr_before = p.prod[n-1] except IndexError: p.lr_before = None return p # Bind the production function name to a callable def bind(self, pdict): if self.func: self.callable = pdict[self.func] # This class serves as a minimal standin for Production objects when # reading table data from files. It only contains information # actually used by the LR parsing engine, plus some additional # debugging information. class MiniProduction(object): def __init__(self, str, name, len, func, file, line): self.name = name self.len = len self.func = func self.callable = None self.file = file self.line = line self.str = str def __str__(self): return self.str def __repr__(self): return 'MiniProduction(%s)' % self.str # Bind the production function name to a callable def bind(self, pdict): if self.func: self.callable = pdict[self.func] # ----------------------------------------------------------------------------- # class LRItem # # This class represents a specific stage of parsing a production rule. For # example: # # expr : expr . PLUS term # # In the above, the "." represents the current location of the parse. Here # basic attributes: # # name - Name of the production. For example 'expr' # prod - A list of symbols on the right side ['expr','.', 'PLUS','term'] # number - Production number. # # lr_next Next LR item. Example, if we are ' expr -> expr . PLUS term' # then lr_next refers to 'expr -> expr PLUS . term' # lr_index - LR item index (location of the ".") in the prod list. # lookaheads - LALR lookahead symbols for this item # len - Length of the production (number of symbols on right hand side) # lr_after - List of all productions that immediately follow # lr_before - Grammar symbol immediately before # ----------------------------------------------------------------------------- class LRItem(object): def __init__(self, p, n): self.name = p.name self.prod = list(p.prod) self.number = p.number self.lr_index = n self.lookaheads = {} self.prod.insert(n, '.') self.prod = tuple(self.prod) self.len = len(self.prod) self.usyms = p.usyms def __str__(self): if self.prod: s = '%s -> %s' % (self.name, ' '.join(self.prod)) else: s = '%s -> ' % self.name return s def __repr__(self): return 'LRItem(' + str(self) + ')' # ----------------------------------------------------------------------------- # rightmost_terminal() # # Return the rightmost terminal from a list of symbols. Used in add_production() # ----------------------------------------------------------------------------- def rightmost_terminal(symbols, terminals): i = len(symbols) - 1 while i >= 0: if symbols[i] in terminals: return symbols[i] i -= 1 return None # ----------------------------------------------------------------------------- # === GRAMMAR CLASS === # # The following class represents the contents of the specified grammar along # with various computed properties such as first sets, follow sets, LR items, etc. # This data is used for critical parts of the table generation process later. # ----------------------------------------------------------------------------- class GrammarError(YaccError): pass class Grammar(object): def __init__(self, terminals): self.Productions = [None] # A list of all of the productions. The first # entry is always reserved for the purpose of # building an augmented grammar self.Prodnames = {} # A dictionary mapping the names of nonterminals to a list of all # productions of that nonterminal. self.Prodmap = {} # A dictionary that is only used to detect duplicate # productions. self.Terminals = {} # A dictionary mapping the names of terminal symbols to a # list of the rules where they are used. for term in terminals: self.Terminals[term] = [] self.Terminals['error'] = [] self.Nonterminals = {} # A dictionary mapping names of nonterminals to a list # of rule numbers where they are used. self.First = {} # A dictionary of precomputed FIRST(x) symbols self.Follow = {} # A dictionary of precomputed FOLLOW(x) symbols self.Precedence = {} # Precedence rules for each terminal. Contains tuples of the # form ('right',level) or ('nonassoc', level) or ('left',level) self.UsedPrecedence = set() # Precedence rules that were actually used by the grammer. # This is only used to provide error checking and to generate # a warning about unused precedence rules. self.Start = None # Starting symbol for the grammar def __len__(self): return len(self.Productions) def __getitem__(self, index): return self.Productions[index] # ----------------------------------------------------------------------------- # set_precedence() # # Sets the precedence for a given terminal. assoc is the associativity such as # 'left','right', or 'nonassoc'. level is a numeric level. # # ----------------------------------------------------------------------------- def set_precedence(self, term, assoc, level): assert self.Productions == [None], 'Must call set_precedence() before add_production()' if term in self.Precedence: raise GrammarError('Precedence already specified for terminal %r' % term) if assoc not in ['left', 'right', 'nonassoc']: raise GrammarError("Associativity must be one of 'left','right', or 'nonassoc'") self.Precedence[term] = (assoc, level) # ----------------------------------------------------------------------------- # add_production() # # Given an action function, this function assembles a production rule and # computes its precedence level. # # The production rule is supplied as a list of symbols. For example, # a rule such as 'expr : expr PLUS term' has a production name of 'expr' and # symbols ['expr','PLUS','term']. # # Precedence is determined by the precedence of the right-most non-terminal # or the precedence of a terminal specified by %prec. # # A variety of error checks are performed to make sure production symbols # are valid and that %prec is used correctly. # ----------------------------------------------------------------------------- def add_production(self, prodname, syms, func=None, file='', line=0): if prodname in self.Terminals: raise GrammarError('%s:%d: Illegal rule name %r. Already defined as a token' % (file, line, prodname)) if prodname == 'error': raise GrammarError('%s:%d: Illegal rule name %r. error is a reserved word' % (file, line, prodname)) if not _is_identifier.match(prodname): raise GrammarError('%s:%d: Illegal rule name %r' % (file, line, prodname)) # Look for literal tokens for n, s in enumerate(syms): if s[0] in "'\"": try: c = eval(s) if (len(c) > 1): raise GrammarError('%s:%d: Literal token %s in rule %r may only be a single character' % (file, line, s, prodname)) if c not in self.Terminals: self.Terminals[c] = [] syms[n] = c continue except SyntaxError: pass if not _is_identifier.match(s) and s != '%prec': raise GrammarError('%s:%d: Illegal name %r in rule %r' % (file, line, s, prodname)) # Determine the precedence level if '%prec' in syms: if syms[-1] == '%prec': raise GrammarError('%s:%d: Syntax error. Nothing follows %%prec' % (file, line)) if syms[-2] != '%prec': raise GrammarError('%s:%d: Syntax error. %%prec can only appear at the end of a grammar rule' % (file, line)) precname = syms[-1] prodprec = self.Precedence.get(precname) if not prodprec: raise GrammarError('%s:%d: Nothing known about the precedence of %r' % (file, line, precname)) else: self.UsedPrecedence.add(precname) del syms[-2:] # Drop %prec from the rule else: # If no %prec, precedence is determined by the rightmost terminal symbol precname = rightmost_terminal(syms, self.Terminals) prodprec = self.Precedence.get(precname, ('right', 0)) # See if the rule is already in the rulemap map = '%s -> %s' % (prodname, syms) if map in self.Prodmap: m = self.Prodmap[map] raise GrammarError('%s:%d: Duplicate rule %s. ' % (file, line, m) + 'Previous definition at %s:%d' % (m.file, m.line)) # From this point on, everything is valid. Create a new Production instance pnumber = len(self.Productions) if prodname not in self.Nonterminals: self.Nonterminals[prodname] = [] # Add the production number to Terminals and Nonterminals for t in syms: if t in self.Terminals: self.Terminals[t].append(pnumber) else: if t not in self.Nonterminals: self.Nonterminals[t] = [] self.Nonterminals[t].append(pnumber) # Create a production and add it to the list of productions p = Production(pnumber, prodname, syms, prodprec, func, file, line) self.Productions.append(p) self.Prodmap[map] = p # Add to the global productions list try: self.Prodnames[prodname].append(p) except KeyError: self.Prodnames[prodname] = [p] # ----------------------------------------------------------------------------- # set_start() # # Sets the starting symbol and creates the augmented grammar. Production # rule 0 is S' -> start where start is the start symbol. # ----------------------------------------------------------------------------- def set_start(self, start=None): if not start: start = self.Productions[1].name if start not in self.Nonterminals: raise GrammarError('start symbol %s undefined' % start) self.Productions[0] = Production(0, "S'", [start]) self.Nonterminals[start].append(0) self.Start = start # ----------------------------------------------------------------------------- # find_unreachable() # # Find all of the nonterminal symbols that can't be reached from the starting # symbol. Returns a list of nonterminals that can't be reached. # ----------------------------------------------------------------------------- def find_unreachable(self): # Mark all symbols that are reachable from a symbol s def mark_reachable_from(s): if s in reachable: return reachable.add(s) for p in self.Prodnames.get(s, []): for r in p.prod: mark_reachable_from(r) reachable = set() mark_reachable_from(self.Productions[0].prod[0]) return [s for s in self.Nonterminals if s not in reachable] # ----------------------------------------------------------------------------- # infinite_cycles() # # This function looks at the various parsing rules and tries to detect # infinite recursion cycles (grammar rules where there is no possible way # to derive a string of only terminals). # ----------------------------------------------------------------------------- def infinite_cycles(self): terminates = {} # Terminals: for t in self.Terminals: terminates[t] = True terminates['$end'] = True # Nonterminals: # Initialize to false: for n in self.Nonterminals: terminates[n] = False # Then propagate termination until no change: while True: some_change = False for (n, pl) in self.Prodnames.items(): # Nonterminal n terminates iff any of its productions terminates. for p in pl: # Production p terminates iff all of its rhs symbols terminate. for s in p.prod: if not terminates[s]: # The symbol s does not terminate, # so production p does not terminate. p_terminates = False break else: # didn't break from the loop, # so every symbol s terminates # so production p terminates. p_terminates = True if p_terminates: # symbol n terminates! if not terminates[n]: terminates[n] = True some_change = True # Don't need to consider any more productions for this n. break if not some_change: break infinite = [] for (s, term) in terminates.items(): if not term: if s not in self.Prodnames and s not in self.Terminals and s != 'error': # s is used-but-not-defined, and we've already warned of that, # so it would be overkill to say that it's also non-terminating. pass else: infinite.append(s) return infinite # ----------------------------------------------------------------------------- # undefined_symbols() # # Find all symbols that were used the grammar, but not defined as tokens or # grammar rules. Returns a list of tuples (sym, prod) where sym in the symbol # and prod is the production where the symbol was used. # ----------------------------------------------------------------------------- def undefined_symbols(self): result = [] for p in self.Productions: if not p: continue for s in p.prod: if s not in self.Prodnames and s not in self.Terminals and s != 'error': result.append((s, p)) return result # ----------------------------------------------------------------------------- # unused_terminals() # # Find all terminals that were defined, but not used by the grammar. Returns # a list of all symbols. # ----------------------------------------------------------------------------- def unused_terminals(self): unused_tok = [] for s, v in self.Terminals.items(): if s != 'error' and not v: unused_tok.append(s) return unused_tok # ------------------------------------------------------------------------------ # unused_rules() # # Find all grammar rules that were defined, but not used (maybe not reachable) # Returns a list of productions. # ------------------------------------------------------------------------------ def unused_rules(self): unused_prod = [] for s, v in self.Nonterminals.items(): if not v: p = self.Prodnames[s][0] unused_prod.append(p) return unused_prod # ----------------------------------------------------------------------------- # unused_precedence() # # Returns a list of tuples (term,precedence) corresponding to precedence # rules that were never used by the grammar. term is the name of the terminal # on which precedence was applied and precedence is a string such as 'left' or # 'right' corresponding to the type of precedence. # ----------------------------------------------------------------------------- def unused_precedence(self): unused = [] for termname in self.Precedence: if not (termname in self.Terminals or termname in self.UsedPrecedence): unused.append((termname, self.Precedence[termname][0])) return unused # ------------------------------------------------------------------------- # _first() # # Compute the value of FIRST1(beta) where beta is a tuple of symbols. # # During execution of compute_first1, the result may be incomplete. # Afterward (e.g., when called from compute_follow()), it will be complete. # ------------------------------------------------------------------------- def _first(self, beta): # We are computing First(x1,x2,x3,...,xn) result = [] for x in beta: x_produces_empty = False # Add all the non- symbols of First[x] to the result. for f in self.First[x]: if f == '': x_produces_empty = True else: if f not in result: result.append(f) if x_produces_empty: # We have to consider the next x in beta, # i.e. stay in the loop. pass else: # We don't have to consider any further symbols in beta. break else: # There was no 'break' from the loop, # so x_produces_empty was true for all x in beta, # so beta produces empty as well. result.append('') return result # ------------------------------------------------------------------------- # compute_first() # # Compute the value of FIRST1(X) for all symbols # ------------------------------------------------------------------------- def compute_first(self): if self.First: return self.First # Terminals: for t in self.Terminals: self.First[t] = [t] self.First['$end'] = ['$end'] # Nonterminals: # Initialize to the empty set: for n in self.Nonterminals: self.First[n] = [] # Then propagate symbols until no change: while True: some_change = False for n in self.Nonterminals: for p in self.Prodnames[n]: for f in self._first(p.prod): if f not in self.First[n]: self.First[n].append(f) some_change = True if not some_change: break return self.First # --------------------------------------------------------------------- # compute_follow() # # Computes all of the follow sets for every non-terminal symbol. The # follow set is the set of all symbols that might follow a given # non-terminal. See the Dragon book, 2nd Ed. p. 189. # --------------------------------------------------------------------- def compute_follow(self, start=None): # If already computed, return the result if self.Follow: return self.Follow # If first sets not computed yet, do that first. if not self.First: self.compute_first() # Add '$end' to the follow list of the start symbol for k in self.Nonterminals: self.Follow[k] = [] if not start: start = self.Productions[1].name self.Follow[start] = ['$end'] while True: didadd = False for p in self.Productions[1:]: # Here is the production set for i, B in enumerate(p.prod): if B in self.Nonterminals: # Okay. We got a non-terminal in a production fst = self._first(p.prod[i+1:]) hasempty = False for f in fst: if f != '' and f not in self.Follow[B]: self.Follow[B].append(f) didadd = True if f == '': hasempty = True if hasempty or i == (len(p.prod)-1): # Add elements of follow(a) to follow(b) for f in self.Follow[p.name]: if f not in self.Follow[B]: self.Follow[B].append(f) didadd = True if not didadd: break return self.Follow # ----------------------------------------------------------------------------- # build_lritems() # # This function walks the list of productions and builds a complete set of the # LR items. The LR items are stored in two ways: First, they are uniquely # numbered and placed in the list _lritems. Second, a linked list of LR items # is built for each production. For example: # # E -> E PLUS E # # Creates the list # # [E -> . E PLUS E, E -> E . PLUS E, E -> E PLUS . E, E -> E PLUS E . ] # ----------------------------------------------------------------------------- def build_lritems(self): for p in self.Productions: lastlri = p i = 0 lr_items = [] while True: if i > len(p): lri = None else: lri = LRItem(p, i) # Precompute the list of productions immediately following try: lri.lr_after = self.Prodnames[lri.prod[i+1]] except (IndexError, KeyError): lri.lr_after = [] try: lri.lr_before = lri.prod[i-1] except IndexError: lri.lr_before = None lastlri.lr_next = lri if not lri: break lr_items.append(lri) lastlri = lri i += 1 p.lr_items = lr_items # ----------------------------------------------------------------------------- # == Class LRTable == # # This basic class represents a basic table of LR parsing information. # Methods for generating the tables are not defined here. They are defined # in the derived class LRGeneratedTable. # ----------------------------------------------------------------------------- class VersionError(YaccError): pass class LRTable(object): def __init__(self): self.lr_action = None self.lr_goto = None self.lr_productions = None self.lr_method = None def read_table(self, module): if isinstance(module, types.ModuleType): parsetab = module else: exec('import %s' % module) parsetab = sys.modules[module] if parsetab._tabversion != __tabversion__: raise VersionError('yacc table file version is out of date') self.lr_action = parsetab._lr_action self.lr_goto = parsetab._lr_goto self.lr_productions = [] for p in parsetab._lr_productions: self.lr_productions.append(MiniProduction(*p)) self.lr_method = parsetab._lr_method return parsetab._lr_signature # Bind all production function names to callable objects in pdict def bind_callables(self, pdict): for p in self.lr_productions: p.bind(pdict) # ----------------------------------------------------------------------------- # === LR Generator === # # The following classes and functions are used to generate LR parsing tables on # a grammar. # ----------------------------------------------------------------------------- # ----------------------------------------------------------------------------- # digraph() # traverse() # # The following two functions are used to compute set valued functions # of the form: # # F(x) = F'(x) U U{F(y) | x R y} # # This is used to compute the values of Read() sets as well as FOLLOW sets # in LALR(1) generation. # # Inputs: X - An input set # R - A relation # FP - Set-valued function # ------------------------------------------------------------------------------ def digraph(X, R, FP): N = {} for x in X: N[x] = 0 stack = [] F = {} for x in X: if N[x] == 0: traverse(x, N, stack, F, X, R, FP) return F def traverse(x, N, stack, F, X, R, FP): stack.append(x) d = len(stack) N[x] = d F[x] = FP(x) # F(X) <- F'(x) rel = R(x) # Get y's related to x for y in rel: if N[y] == 0: traverse(y, N, stack, F, X, R, FP) N[x] = min(N[x], N[y]) for a in F.get(y, []): if a not in F[x]: F[x].append(a) if N[x] == d: N[stack[-1]] = MAXINT F[stack[-1]] = F[x] element = stack.pop() while element != x: N[stack[-1]] = MAXINT F[stack[-1]] = F[x] element = stack.pop() class LALRError(YaccError): pass # ----------------------------------------------------------------------------- # == LRGeneratedTable == # # This class implements the LR table generation algorithm. There are no # public methods except for write() # ----------------------------------------------------------------------------- class LRGeneratedTable(LRTable): def __init__(self, grammar, method='LALR', log=None): if method not in ['SLR', 'LALR']: raise LALRError('Unsupported method %s' % method) self.grammar = grammar self.lr_method = method # Set up the logger if not log: log = NullLogger() self.log = log # Internal attributes self.lr_action = {} # Action table self.lr_goto = {} # Goto table self.lr_productions = grammar.Productions # Copy of grammar Production array self.lr_goto_cache = {} # Cache of computed gotos self.lr0_cidhash = {} # Cache of closures self._add_count = 0 # Internal counter used to detect cycles # Diagonistic information filled in by the table generator self.sr_conflict = 0 self.rr_conflict = 0 self.conflicts = [] # List of conflicts self.sr_conflicts = [] self.rr_conflicts = [] # Build the tables self.grammar.build_lritems() self.grammar.compute_first() self.grammar.compute_follow() self.lr_parse_table() # Compute the LR(0) closure operation on I, where I is a set of LR(0) items. def lr0_closure(self, I): self._add_count += 1 # Add everything in I to J J = I[:] didadd = True while didadd: didadd = False for j in J: for x in j.lr_after: if getattr(x, 'lr0_added', 0) == self._add_count: continue # Add B --> .G to J J.append(x.lr_next) x.lr0_added = self._add_count didadd = True return J # Compute the LR(0) goto function goto(I,X) where I is a set # of LR(0) items and X is a grammar symbol. This function is written # in a way that guarantees uniqueness of the generated goto sets # (i.e. the same goto set will never be returned as two different Python # objects). With uniqueness, we can later do fast set comparisons using # id(obj) instead of element-wise comparison. def lr0_goto(self, I, x): # First we look for a previously cached entry g = self.lr_goto_cache.get((id(I), x)) if g: return g # Now we generate the goto set in a way that guarantees uniqueness # of the result s = self.lr_goto_cache.get(x) if not s: s = {} self.lr_goto_cache[x] = s gs = [] for p in I: n = p.lr_next if n and n.lr_before == x: s1 = s.get(id(n)) if not s1: s1 = {} s[id(n)] = s1 gs.append(n) s = s1 g = s.get('$end') if not g: if gs: g = self.lr0_closure(gs) s['$end'] = g else: s['$end'] = gs self.lr_goto_cache[(id(I), x)] = g return g # Compute the LR(0) sets of item function def lr0_items(self): C = [self.lr0_closure([self.grammar.Productions[0].lr_next])] i = 0 for I in C: self.lr0_cidhash[id(I)] = i i += 1 # Loop over the items in C and each grammar symbols i = 0 while i < len(C): I = C[i] i += 1 # Collect all of the symbols that could possibly be in the goto(I,X) sets asyms = {} for ii in I: for s in ii.usyms: asyms[s] = None for x in asyms: g = self.lr0_goto(I, x) if not g or id(g) in self.lr0_cidhash: continue self.lr0_cidhash[id(g)] = len(C) C.append(g) return C # ----------------------------------------------------------------------------- # ==== LALR(1) Parsing ==== # # LALR(1) parsing is almost exactly the same as SLR except that instead of # relying upon Follow() sets when performing reductions, a more selective # lookahead set that incorporates the state of the LR(0) machine is utilized. # Thus, we mainly just have to focus on calculating the lookahead sets. # # The method used here is due to DeRemer and Pennelo (1982). # # DeRemer, F. L., and T. J. Pennelo: "Efficient Computation of LALR(1) # Lookahead Sets", ACM Transactions on Programming Languages and Systems, # Vol. 4, No. 4, Oct. 1982, pp. 615-649 # # Further details can also be found in: # # J. Tremblay and P. Sorenson, "The Theory and Practice of Compiler Writing", # McGraw-Hill Book Company, (1985). # # ----------------------------------------------------------------------------- # ----------------------------------------------------------------------------- # compute_nullable_nonterminals() # # Creates a dictionary containing all of the non-terminals that might produce # an empty production. # ----------------------------------------------------------------------------- def compute_nullable_nonterminals(self): nullable = set() num_nullable = 0 while True: for p in self.grammar.Productions[1:]: if p.len == 0: nullable.add(p.name) continue for t in p.prod: if t not in nullable: break else: nullable.add(p.name) if len(nullable) == num_nullable: break num_nullable = len(nullable) return nullable # ----------------------------------------------------------------------------- # find_nonterminal_trans(C) # # Given a set of LR(0) items, this functions finds all of the non-terminal # transitions. These are transitions in which a dot appears immediately before # a non-terminal. Returns a list of tuples of the form (state,N) where state # is the state number and N is the nonterminal symbol. # # The input C is the set of LR(0) items. # ----------------------------------------------------------------------------- def find_nonterminal_transitions(self, C): trans = [] for stateno, state in enumerate(C): for p in state: if p.lr_index < p.len - 1: t = (stateno, p.prod[p.lr_index+1]) if t[1] in self.grammar.Nonterminals: if t not in trans: trans.append(t) return trans # ----------------------------------------------------------------------------- # dr_relation() # # Computes the DR(p,A) relationships for non-terminal transitions. The input # is a tuple (state,N) where state is a number and N is a nonterminal symbol. # # Returns a list of terminals. # ----------------------------------------------------------------------------- def dr_relation(self, C, trans, nullable): state, N = trans terms = [] g = self.lr0_goto(C[state], N) for p in g: if p.lr_index < p.len - 1: a = p.prod[p.lr_index+1] if a in self.grammar.Terminals: if a not in terms: terms.append(a) # This extra bit is to handle the start state if state == 0 and N == self.grammar.Productions[0].prod[0]: terms.append('$end') return terms # ----------------------------------------------------------------------------- # reads_relation() # # Computes the READS() relation (p,A) READS (t,C). # ----------------------------------------------------------------------------- def reads_relation(self, C, trans, empty): # Look for empty transitions rel = [] state, N = trans g = self.lr0_goto(C[state], N) j = self.lr0_cidhash.get(id(g), -1) for p in g: if p.lr_index < p.len - 1: a = p.prod[p.lr_index + 1] if a in empty: rel.append((j, a)) return rel # ----------------------------------------------------------------------------- # compute_lookback_includes() # # Determines the lookback and includes relations # # LOOKBACK: # # This relation is determined by running the LR(0) state machine forward. # For example, starting with a production "N : . A B C", we run it forward # to obtain "N : A B C ." We then build a relationship between this final # state and the starting state. These relationships are stored in a dictionary # lookdict. # # INCLUDES: # # Computes the INCLUDE() relation (p,A) INCLUDES (p',B). # # This relation is used to determine non-terminal transitions that occur # inside of other non-terminal transition states. (p,A) INCLUDES (p', B) # if the following holds: # # B -> LAT, where T -> epsilon and p' -L-> p # # L is essentially a prefix (which may be empty), T is a suffix that must be # able to derive an empty string. State p' must lead to state p with the string L. # # ----------------------------------------------------------------------------- def compute_lookback_includes(self, C, trans, nullable): lookdict = {} # Dictionary of lookback relations includedict = {} # Dictionary of include relations # Make a dictionary of non-terminal transitions dtrans = {} for t in trans: dtrans[t] = 1 # Loop over all transitions and compute lookbacks and includes for state, N in trans: lookb = [] includes = [] for p in C[state]: if p.name != N: continue # Okay, we have a name match. We now follow the production all the way # through the state machine until we get the . on the right hand side lr_index = p.lr_index j = state while lr_index < p.len - 1: lr_index = lr_index + 1 t = p.prod[lr_index] # Check to see if this symbol and state are a non-terminal transition if (j, t) in dtrans: # Yes. Okay, there is some chance that this is an includes relation # the only way to know for certain is whether the rest of the # production derives empty li = lr_index + 1 while li < p.len: if p.prod[li] in self.grammar.Terminals: break # No forget it if p.prod[li] not in nullable: break li = li + 1 else: # Appears to be a relation between (j,t) and (state,N) includes.append((j, t)) g = self.lr0_goto(C[j], t) # Go to next set j = self.lr0_cidhash.get(id(g), -1) # Go to next state # When we get here, j is the final state, now we have to locate the production for r in C[j]: if r.name != p.name: continue if r.len != p.len: continue i = 0 # This look is comparing a production ". A B C" with "A B C ." while i < r.lr_index: if r.prod[i] != p.prod[i+1]: break i = i + 1 else: lookb.append((j, r)) for i in includes: if i not in includedict: includedict[i] = [] includedict[i].append((state, N)) lookdict[(state, N)] = lookb return lookdict, includedict # ----------------------------------------------------------------------------- # compute_read_sets() # # Given a set of LR(0) items, this function computes the read sets. # # Inputs: C = Set of LR(0) items # ntrans = Set of nonterminal transitions # nullable = Set of empty transitions # # Returns a set containing the read sets # ----------------------------------------------------------------------------- def compute_read_sets(self, C, ntrans, nullable): FP = lambda x: self.dr_relation(C, x, nullable) R = lambda x: self.reads_relation(C, x, nullable) F = digraph(ntrans, R, FP) return F # ----------------------------------------------------------------------------- # compute_follow_sets() # # Given a set of LR(0) items, a set of non-terminal transitions, a readset, # and an include set, this function computes the follow sets # # Follow(p,A) = Read(p,A) U U {Follow(p',B) | (p,A) INCLUDES (p',B)} # # Inputs: # ntrans = Set of nonterminal transitions # readsets = Readset (previously computed) # inclsets = Include sets (previously computed) # # Returns a set containing the follow sets # ----------------------------------------------------------------------------- def compute_follow_sets(self, ntrans, readsets, inclsets): FP = lambda x: readsets[x] R = lambda x: inclsets.get(x, []) F = digraph(ntrans, R, FP) return F # ----------------------------------------------------------------------------- # add_lookaheads() # # Attaches the lookahead symbols to grammar rules. # # Inputs: lookbacks - Set of lookback relations # followset - Computed follow set # # This function directly attaches the lookaheads to productions contained # in the lookbacks set # ----------------------------------------------------------------------------- def add_lookaheads(self, lookbacks, followset): for trans, lb in lookbacks.items(): # Loop over productions in lookback for state, p in lb: if state not in p.lookaheads: p.lookaheads[state] = [] f = followset.get(trans, []) for a in f: if a not in p.lookaheads[state]: p.lookaheads[state].append(a) # ----------------------------------------------------------------------------- # add_lalr_lookaheads() # # This function does all of the work of adding lookahead information for use # with LALR parsing # ----------------------------------------------------------------------------- def add_lalr_lookaheads(self, C): # Determine all of the nullable nonterminals nullable = self.compute_nullable_nonterminals() # Find all non-terminal transitions trans = self.find_nonterminal_transitions(C) # Compute read sets readsets = self.compute_read_sets(C, trans, nullable) # Compute lookback/includes relations lookd, included = self.compute_lookback_includes(C, trans, nullable) # Compute LALR FOLLOW sets followsets = self.compute_follow_sets(trans, readsets, included) # Add all of the lookaheads self.add_lookaheads(lookd, followsets) # ----------------------------------------------------------------------------- # lr_parse_table() # # This function constructs the parse tables for SLR or LALR # ----------------------------------------------------------------------------- def lr_parse_table(self): Productions = self.grammar.Productions Precedence = self.grammar.Precedence goto = self.lr_goto # Goto array action = self.lr_action # Action array log = self.log # Logger for output actionp = {} # Action production array (temporary) log.info('Parsing method: %s', self.lr_method) # Step 1: Construct C = { I0, I1, ... IN}, collection of LR(0) items # This determines the number of states C = self.lr0_items() if self.lr_method == 'LALR': self.add_lalr_lookaheads(C) # Build the parser table, state by state st = 0 for I in C: # Loop over each production in I actlist = [] # List of actions st_action = {} st_actionp = {} st_goto = {} log.info('') log.info('state %d', st) log.info('') for p in I: log.info(' (%d) %s', p.number, p) log.info('') for p in I: if p.len == p.lr_index + 1: if p.name == "S'": # Start symbol. Accept! st_action['$end'] = 0 st_actionp['$end'] = p else: # We are at the end of a production. Reduce! if self.lr_method == 'LALR': laheads = p.lookaheads[st] else: laheads = self.grammar.Follow[p.name] for a in laheads: actlist.append((a, p, 'reduce using rule %d (%s)' % (p.number, p))) r = st_action.get(a) if r is not None: # Whoa. Have a shift/reduce or reduce/reduce conflict if r > 0: # Need to decide on shift or reduce here # By default we favor shifting. Need to add # some precedence rules here. # Shift precedence comes from the token sprec, slevel = Precedence.get(a, ('right', 0)) # Reduce precedence comes from rule being reduced (p) rprec, rlevel = Productions[p.number].prec if (slevel < rlevel) or ((slevel == rlevel) and (rprec == 'left')): # We really need to reduce here. st_action[a] = -p.number st_actionp[a] = p if not slevel and not rlevel: log.info(' ! shift/reduce conflict for %s resolved as reduce', a) self.sr_conflicts.append((st, a, 'reduce')) Productions[p.number].reduced += 1 elif (slevel == rlevel) and (rprec == 'nonassoc'): st_action[a] = None else: # Hmmm. Guess we'll keep the shift if not rlevel: log.info(' ! shift/reduce conflict for %s resolved as shift', a) self.sr_conflicts.append((st, a, 'shift')) elif r < 0: # Reduce/reduce conflict. In this case, we favor the rule # that was defined first in the grammar file oldp = Productions[-r] pp = Productions[p.number] if oldp.line > pp.line: st_action[a] = -p.number st_actionp[a] = p chosenp, rejectp = pp, oldp Productions[p.number].reduced += 1 Productions[oldp.number].reduced -= 1 else: chosenp, rejectp = oldp, pp self.rr_conflicts.append((st, chosenp, rejectp)) log.info(' ! reduce/reduce conflict for %s resolved using rule %d (%s)', a, st_actionp[a].number, st_actionp[a]) else: raise LALRError('Unknown conflict in state %d' % st) else: st_action[a] = -p.number st_actionp[a] = p Productions[p.number].reduced += 1 else: i = p.lr_index a = p.prod[i+1] # Get symbol right after the "." if a in self.grammar.Terminals: g = self.lr0_goto(I, a) j = self.lr0_cidhash.get(id(g), -1) if j >= 0: # We are in a shift state actlist.append((a, p, 'shift and go to state %d' % j)) r = st_action.get(a) if r is not None: # Whoa have a shift/reduce or shift/shift conflict if r > 0: if r != j: raise LALRError('Shift/shift conflict in state %d' % st) elif r < 0: # Do a precedence check. # - if precedence of reduce rule is higher, we reduce. # - if precedence of reduce is same and left assoc, we reduce. # - otherwise we shift # Shift precedence comes from the token sprec, slevel = Precedence.get(a, ('right', 0)) # Reduce precedence comes from the rule that could have been reduced rprec, rlevel = Productions[st_actionp[a].number].prec if (slevel > rlevel) or ((slevel == rlevel) and (rprec == 'right')): # We decide to shift here... highest precedence to shift Productions[st_actionp[a].number].reduced -= 1 st_action[a] = j st_actionp[a] = p if not rlevel: log.info(' ! shift/reduce conflict for %s resolved as shift', a) self.sr_conflicts.append((st, a, 'shift')) elif (slevel == rlevel) and (rprec == 'nonassoc'): st_action[a] = None else: # Hmmm. Guess we'll keep the reduce if not slevel and not rlevel: log.info(' ! shift/reduce conflict for %s resolved as reduce', a) self.sr_conflicts.append((st, a, 'reduce')) else: raise LALRError('Unknown conflict in state %d' % st) else: st_action[a] = j st_actionp[a] = p # Print the actions associated with each terminal _actprint = {} for a, p, m in actlist: if a in st_action: if p is st_actionp[a]: log.info(' %-15s %s', a, m) _actprint[(a, m)] = 1 log.info('') # Print the actions that were not used. (debugging) not_used = 0 for a, p, m in actlist: if a in st_action: if p is not st_actionp[a]: if not (a, m) in _actprint: log.debug(' ! %-15s [ %s ]', a, m) not_used = 1 _actprint[(a, m)] = 1 if not_used: log.debug('') # Construct the goto table for this state nkeys = {} for ii in I: for s in ii.usyms: if s in self.grammar.Nonterminals: nkeys[s] = None for n in nkeys: g = self.lr0_goto(I, n) j = self.lr0_cidhash.get(id(g), -1) if j >= 0: st_goto[n] = j log.info(' %-30s shift and go to state %d', n, j) action[st] = st_action actionp[st] = st_actionp goto[st] = st_goto st += 1 # ----------------------------------------------------------------------------- # write() # # This function writes the LR parsing tables to a file # ----------------------------------------------------------------------------- def write_table(self, tabmodule, outputdir='', signature=''): if isinstance(tabmodule, types.ModuleType): raise IOError("Won't overwrite existing tabmodule") basemodulename = tabmodule.split('.')[-1] filename = os.path.join(outputdir, basemodulename) + '.py' try: f = open(filename, 'w') f.write(''' # %s # This file is automatically generated. Do not edit. # pylint: disable=W,C,R _tabversion = %r _lr_method = %r _lr_signature = %r ''' % (os.path.basename(filename), __tabversion__, self.lr_method, signature)) # Change smaller to 0 to go back to original tables smaller = 1 # Factor out names to try and make smaller if smaller: items = {} for s, nd in self.lr_action.items(): for name, v in nd.items(): i = items.get(name) if not i: i = ([], []) items[name] = i i[0].append(s) i[1].append(v) f.write('\n_lr_action_items = {') for k, v in items.items(): f.write('%r:([' % k) for i in v[0]: f.write('%r,' % i) f.write('],[') for i in v[1]: f.write('%r,' % i) f.write(']),') f.write('}\n') f.write(''' _lr_action = {} for _k, _v in _lr_action_items.items(): for _x,_y in zip(_v[0],_v[1]): if not _x in _lr_action: _lr_action[_x] = {} _lr_action[_x][_k] = _y del _lr_action_items ''') else: f.write('\n_lr_action = { ') for k, v in self.lr_action.items(): f.write('(%r,%r):%r,' % (k[0], k[1], v)) f.write('}\n') if smaller: # Factor out names to try and make smaller items = {} for s, nd in self.lr_goto.items(): for name, v in nd.items(): i = items.get(name) if not i: i = ([], []) items[name] = i i[0].append(s) i[1].append(v) f.write('\n_lr_goto_items = {') for k, v in items.items(): f.write('%r:([' % k) for i in v[0]: f.write('%r,' % i) f.write('],[') for i in v[1]: f.write('%r,' % i) f.write(']),') f.write('}\n') f.write(''' _lr_goto = {} for _k, _v in _lr_goto_items.items(): for _x, _y in zip(_v[0], _v[1]): if not _x in _lr_goto: _lr_goto[_x] = {} _lr_goto[_x][_k] = _y del _lr_goto_items ''') else: f.write('\n_lr_goto = { ') for k, v in self.lr_goto.items(): f.write('(%r,%r):%r,' % (k[0], k[1], v)) f.write('}\n') # Write production table f.write('_lr_productions = [\n') for p in self.lr_productions: if p.func: f.write(' (%r,%r,%d,%r,%r,%d),\n' % (p.str, p.name, p.len, p.func, os.path.basename(p.file), p.line)) else: f.write(' (%r,%r,%d,None,None,None),\n' % (str(p), p.name, p.len)) f.write(']\n') f.close() except IOError as e: raise # ----------------------------------------------------------------------------- # === INTROSPECTION === # # The following functions and classes are used to implement the PLY # introspection features followed by the yacc() function itself. # ----------------------------------------------------------------------------- # ----------------------------------------------------------------------------- # get_caller_module_dict() # # This function returns a dictionary containing all of the symbols defined within # a caller further down the call stack. This is used to get the environment # associated with the yacc() call if none was provided. # ----------------------------------------------------------------------------- def get_caller_module_dict(levels): f = sys._getframe(levels) ldict = f.f_globals.copy() if f.f_globals != f.f_locals: ldict.update(f.f_locals) return ldict # ----------------------------------------------------------------------------- # parse_grammar() # # This takes a raw grammar rule string and parses it into production data # ----------------------------------------------------------------------------- def parse_grammar(doc, file, line): grammar = [] # Split the doc string into lines pstrings = doc.splitlines() lastp = None dline = line for ps in pstrings: dline += 1 p = ps.split() if not p: continue try: if p[0] == '|': # This is a continuation of a previous rule if not lastp: raise SyntaxError("%s:%d: Misplaced '|'" % (file, dline)) prodname = lastp syms = p[1:] else: prodname = p[0] lastp = prodname syms = p[2:] assign = p[1] if assign != ':' and assign != '::=': raise SyntaxError("%s:%d: Syntax error. Expected ':'" % (file, dline)) grammar.append((file, dline, prodname, syms)) except SyntaxError: raise except Exception: raise SyntaxError('%s:%d: Syntax error in rule %r' % (file, dline, ps.strip())) return grammar # ----------------------------------------------------------------------------- # ParserReflect() # # This class represents information extracted for building a parser including # start symbol, error function, tokens, precedence list, action functions, # etc. # ----------------------------------------------------------------------------- class ParserReflect(object): def __init__(self, pdict, log=None): self.pdict = pdict self.start = None self.error_func = None self.tokens = None self.modules = set() self.grammar = [] self.error = False if log is None: self.log = PlyLogger(sys.stderr) else: self.log = log # Get all of the basic information def get_all(self): self.get_start() self.get_error_func() self.get_tokens() self.get_precedence() self.get_pfunctions() # Validate all of the information def validate_all(self): self.validate_start() self.validate_error_func() self.validate_tokens() self.validate_precedence() self.validate_pfunctions() self.validate_modules() return self.error # Compute a signature over the grammar def signature(self): parts = [] try: if self.start: parts.append(self.start) if self.prec: parts.append(''.join([''.join(p) for p in self.prec])) if self.tokens: parts.append(' '.join(self.tokens)) for f in self.pfuncs: if f[3]: parts.append(f[3]) except (TypeError, ValueError): pass return ''.join(parts) # ----------------------------------------------------------------------------- # validate_modules() # # This method checks to see if there are duplicated p_rulename() functions # in the parser module file. Without this function, it is really easy for # users to make mistakes by cutting and pasting code fragments (and it's a real # bugger to try and figure out why the resulting parser doesn't work). Therefore, # we just do a little regular expression pattern matching of def statements # to try and detect duplicates. # ----------------------------------------------------------------------------- def validate_modules(self): # Match def p_funcname( fre = re.compile(r'\s*def\s+(p_[a-zA-Z_0-9]*)\(') for module in self.modules: try: lines, linen = inspect.getsourcelines(module) except IOError: continue counthash = {} for linen, line in enumerate(lines): linen += 1 m = fre.match(line) if m: name = m.group(1) prev = counthash.get(name) if not prev: counthash[name] = linen else: filename = inspect.getsourcefile(module) self.log.warning('%s:%d: Function %s redefined. Previously defined on line %d', filename, linen, name, prev) # Get the start symbol def get_start(self): self.start = self.pdict.get('start') # Validate the start symbol def validate_start(self): if self.start is not None: if not isinstance(self.start, string_types): self.log.error("'start' must be a string") # Look for error handler def get_error_func(self): self.error_func = self.pdict.get('p_error') # Validate the error function def validate_error_func(self): if self.error_func: if isinstance(self.error_func, types.FunctionType): ismethod = 0 elif isinstance(self.error_func, types.MethodType): ismethod = 1 else: self.log.error("'p_error' defined, but is not a function or method") self.error = True return eline = self.error_func.__code__.co_firstlineno efile = self.error_func.__code__.co_filename module = inspect.getmodule(self.error_func) self.modules.add(module) argcount = self.error_func.__code__.co_argcount - ismethod if argcount != 1: self.log.error('%s:%d: p_error() requires 1 argument', efile, eline) self.error = True # Get the tokens map def get_tokens(self): tokens = self.pdict.get('tokens') if not tokens: self.log.error('No token list is defined') self.error = True return if not isinstance(tokens, (list, tuple)): self.log.error('tokens must be a list or tuple') self.error = True return if not tokens: self.log.error('tokens is empty') self.error = True return self.tokens = sorted(tokens) # Validate the tokens def validate_tokens(self): # Validate the tokens. if 'error' in self.tokens: self.log.error("Illegal token name 'error'. Is a reserved word") self.error = True return terminals = set() for n in self.tokens: if n in terminals: self.log.warning('Token %r multiply defined', n) terminals.add(n) # Get the precedence map (if any) def get_precedence(self): self.prec = self.pdict.get('precedence') # Validate and parse the precedence map def validate_precedence(self): preclist = [] if self.prec: if not isinstance(self.prec, (list, tuple)): self.log.error('precedence must be a list or tuple') self.error = True return for level, p in enumerate(self.prec): if not isinstance(p, (list, tuple)): self.log.error('Bad precedence table') self.error = True return if len(p) < 2: self.log.error('Malformed precedence entry %s. Must be (assoc, term, ..., term)', p) self.error = True return assoc = p[0] if not isinstance(assoc, string_types): self.log.error('precedence associativity must be a string') self.error = True return for term in p[1:]: if not isinstance(term, string_types): self.log.error('precedence items must be strings') self.error = True return preclist.append((term, assoc, level+1)) self.preclist = preclist # Get all p_functions from the grammar def get_pfunctions(self): p_functions = [] for name, item in self.pdict.items(): if not name.startswith('p_') or name == 'p_error': continue if isinstance(item, (types.FunctionType, types.MethodType)): line = getattr(item, 'co_firstlineno', item.__code__.co_firstlineno) module = inspect.getmodule(item) p_functions.append((line, module, name, item.__doc__)) # Sort all of the actions by line number; make sure to stringify # modules to make them sortable, since `line` may not uniquely sort all # p functions p_functions.sort(key=lambda p_function: ( p_function[0], str(p_function[1]), p_function[2], p_function[3])) self.pfuncs = p_functions # Validate all of the p_functions def validate_pfunctions(self): grammar = [] # Check for non-empty symbols if len(self.pfuncs) == 0: self.log.error('no rules of the form p_rulename are defined') self.error = True return for line, module, name, doc in self.pfuncs: file = inspect.getsourcefile(module) func = self.pdict[name] if isinstance(func, types.MethodType): reqargs = 2 else: reqargs = 1 if func.__code__.co_argcount > reqargs: self.log.error('%s:%d: Rule %r has too many arguments', file, line, func.__name__) self.error = True elif func.__code__.co_argcount < reqargs: self.log.error('%s:%d: Rule %r requires an argument', file, line, func.__name__) self.error = True elif not func.__doc__: self.log.warning('%s:%d: No documentation string specified in function %r (ignored)', file, line, func.__name__) else: try: parsed_g = parse_grammar(doc, file, line) for g in parsed_g: grammar.append((name, g)) except SyntaxError as e: self.log.error(str(e)) self.error = True # Looks like a valid grammar rule # Mark the file in which defined. self.modules.add(module) # Secondary validation step that looks for p_ definitions that are not functions # or functions that look like they might be grammar rules. for n, v in self.pdict.items(): if n.startswith('p_') and isinstance(v, (types.FunctionType, types.MethodType)): continue if n.startswith('t_'): continue if n.startswith('p_') and n != 'p_error': self.log.warning('%r not defined as a function', n) if ((isinstance(v, types.FunctionType) and v.__code__.co_argcount == 1) or (isinstance(v, types.MethodType) and v.__func__.__code__.co_argcount == 2)): if v.__doc__: try: doc = v.__doc__.split(' ') if doc[1] == ':': self.log.warning('%s:%d: Possible grammar rule %r defined without p_ prefix', v.__code__.co_filename, v.__code__.co_firstlineno, n) except IndexError: pass self.grammar = grammar # ----------------------------------------------------------------------------- # yacc(module) # # Build a parser # ----------------------------------------------------------------------------- def yacc(method='LALR', debug=yaccdebug, module=None, tabmodule=tab_module, start=None, check_recursion=True, optimize=False, write_tables=True, debugfile=debug_file, outputdir=None, debuglog=None, errorlog=None): if tabmodule is None: tabmodule = tab_module # Reference to the parsing method of the last built parser global parse if errorlog is None: errorlog = PlyLogger(sys.stderr) # Get the module dictionary used for the parser if module: _items = [(k, getattr(module, k)) for k in dir(module)] pdict = dict(_items) # If no __file__ or __package__ attributes are available, try to obtain them # from the __module__ instead if '__file__' not in pdict: pdict['__file__'] = sys.modules[pdict['__module__']].__file__ if '__package__' not in pdict and '__module__' in pdict: if hasattr(sys.modules[pdict['__module__']], '__package__'): pdict['__package__'] = sys.modules[pdict['__module__']].__package__ else: pdict = get_caller_module_dict(2) if outputdir is None: # If no output directory is set, the location of the output files # is determined according to the following rules: # - If tabmodule specifies a package, files go into that package directory # - Otherwise, files go in the same directory as the specifying module if isinstance(tabmodule, types.ModuleType): srcfile = tabmodule.__file__ else: if '.' not in tabmodule: srcfile = pdict['__file__'] else: parts = tabmodule.split('.') pkgname = '.'.join(parts[:-1]) exec('import %s' % pkgname) srcfile = getattr(sys.modules[pkgname], '__file__', '') outputdir = os.path.dirname(srcfile) # Determine if the module is package of a package or not. # If so, fix the tabmodule setting so that tables load correctly pkg = pdict.get('__package__') if pkg and isinstance(tabmodule, str): if '.' not in tabmodule: tabmodule = pkg + '.' + tabmodule # Set start symbol if it's specified directly using an argument if start is not None: pdict['start'] = start # Collect parser information from the dictionary pinfo = ParserReflect(pdict, log=errorlog) pinfo.get_all() if pinfo.error: raise YaccError('Unable to build parser') # Check signature against table files (if any) signature = pinfo.signature() # Read the tables try: lr = LRTable() read_signature = lr.read_table(tabmodule) if optimize or (read_signature == signature): try: lr.bind_callables(pinfo.pdict) parser = LRParser(lr, pinfo.error_func) parse = parser.parse return parser except Exception as e: errorlog.warning('There was a problem loading the table file: %r', e) except VersionError as e: errorlog.warning(str(e)) except ImportError: pass if debuglog is None: if debug: try: debuglog = PlyLogger(open(os.path.join(outputdir, debugfile), 'w')) except IOError as e: errorlog.warning("Couldn't open %r. %s" % (debugfile, e)) debuglog = NullLogger() else: debuglog = NullLogger() debuglog.info('Created by PLY version %s (http://www.dabeaz.com/ply)', __version__) errors = False # Validate the parser information if pinfo.validate_all(): raise YaccError('Unable to build parser') if not pinfo.error_func: errorlog.warning('no p_error() function is defined') # Create a grammar object grammar = Grammar(pinfo.tokens) # Set precedence level for terminals for term, assoc, level in pinfo.preclist: try: grammar.set_precedence(term, assoc, level) except GrammarError as e: errorlog.warning('%s', e) # Add productions to the grammar for funcname, gram in pinfo.grammar: file, line, prodname, syms = gram try: grammar.add_production(prodname, syms, funcname, file, line) except GrammarError as e: errorlog.error('%s', e) errors = True # Set the grammar start symbols try: if start is None: grammar.set_start(pinfo.start) else: grammar.set_start(start) except GrammarError as e: errorlog.error(str(e)) errors = True if errors: raise YaccError('Unable to build parser') # Verify the grammar structure undefined_symbols = grammar.undefined_symbols() for sym, prod in undefined_symbols: errorlog.error('%s:%d: Symbol %r used, but not defined as a token or a rule', prod.file, prod.line, sym) errors = True unused_terminals = grammar.unused_terminals() if unused_terminals: debuglog.info('') debuglog.info('Unused terminals:') debuglog.info('') for term in unused_terminals: errorlog.warning('Token %r defined, but not used', term) debuglog.info(' %s', term) # Print out all productions to the debug log if debug: debuglog.info('') debuglog.info('Grammar') debuglog.info('') for n, p in enumerate(grammar.Productions): debuglog.info('Rule %-5d %s', n, p) # Find unused non-terminals unused_rules = grammar.unused_rules() for prod in unused_rules: errorlog.warning('%s:%d: Rule %r defined, but not used', prod.file, prod.line, prod.name) if len(unused_terminals) == 1: errorlog.warning('There is 1 unused token') if len(unused_terminals) > 1: errorlog.warning('There are %d unused tokens', len(unused_terminals)) if len(unused_rules) == 1: errorlog.warning('There is 1 unused rule') if len(unused_rules) > 1: errorlog.warning('There are %d unused rules', len(unused_rules)) if debug: debuglog.info('') debuglog.info('Terminals, with rules where they appear') debuglog.info('') terms = list(grammar.Terminals) terms.sort() for term in terms: debuglog.info('%-20s : %s', term, ' '.join([str(s) for s in grammar.Terminals[term]])) debuglog.info('') debuglog.info('Nonterminals, with rules where they appear') debuglog.info('') nonterms = list(grammar.Nonterminals) nonterms.sort() for nonterm in nonterms: debuglog.info('%-20s : %s', nonterm, ' '.join([str(s) for s in grammar.Nonterminals[nonterm]])) debuglog.info('') if check_recursion: unreachable = grammar.find_unreachable() for u in unreachable: errorlog.warning('Symbol %r is unreachable', u) infinite = grammar.infinite_cycles() for inf in infinite: errorlog.error('Infinite recursion detected for symbol %r', inf) errors = True unused_prec = grammar.unused_precedence() for term, assoc in unused_prec: errorlog.error('Precedence rule %r defined for unknown symbol %r', assoc, term) errors = True if errors: raise YaccError('Unable to build parser') # Run the LRGeneratedTable on the grammar if debug: errorlog.debug('Generating %s tables', method) lr = LRGeneratedTable(grammar, method, debuglog) if debug: num_sr = len(lr.sr_conflicts) # Report shift/reduce and reduce/reduce conflicts if num_sr == 1: errorlog.warning('1 shift/reduce conflict') elif num_sr > 1: errorlog.warning('%d shift/reduce conflicts', num_sr) num_rr = len(lr.rr_conflicts) if num_rr == 1: errorlog.warning('1 reduce/reduce conflict') elif num_rr > 1: errorlog.warning('%d reduce/reduce conflicts', num_rr) # Write out conflicts to the output file if debug and (lr.sr_conflicts or lr.rr_conflicts): debuglog.warning('') debuglog.warning('Conflicts:') debuglog.warning('') for state, tok, resolution in lr.sr_conflicts: debuglog.warning('shift/reduce conflict for %s in state %d resolved as %s', tok, state, resolution) already_reported = set() for state, rule, rejected in lr.rr_conflicts: if (state, id(rule), id(rejected)) in already_reported: continue debuglog.warning('reduce/reduce conflict in state %d resolved using rule (%s)', state, rule) debuglog.warning('rejected rule (%s) in state %d', rejected, state) errorlog.warning('reduce/reduce conflict in state %d resolved using rule (%s)', state, rule) errorlog.warning('rejected rule (%s) in state %d', rejected, state) already_reported.add((state, id(rule), id(rejected))) warned_never = [] for state, rule, rejected in lr.rr_conflicts: if not rejected.reduced and (rejected not in warned_never): debuglog.warning('Rule (%s) is never reduced', rejected) errorlog.warning('Rule (%s) is never reduced', rejected) warned_never.append(rejected) # Write the table file if requested if write_tables: try: lr.write_table(tabmodule, outputdir, signature) if tabmodule in sys.modules: del sys.modules[tabmodule] except IOError as e: errorlog.warning("Couldn't create %r. %s" % (tabmodule, e)) # Build the parser lr.bind_callables(pinfo.pdict) parser = LRParser(lr, pinfo.error_func) parse = parser.parse return parser jsonpath-ng-1.8.0/jsonpath_ng/bin/000077500000000000000000000000001514733354600170455ustar00rootroot00000000000000jsonpath-ng-1.8.0/jsonpath_ng/bin/__init__.py000066400000000000000000000000001514733354600211440ustar00rootroot00000000000000jsonpath-ng-1.8.0/jsonpath_ng/bin/jsonpath.py000077500000000000000000000040111514733354600212440ustar00rootroot00000000000000#!/usr/bin/python # encoding: utf-8 # Copyright © 2012 Felix Richter # This work is free. You can redistribute it and/or modify it under the # terms of the Do What The Fuck You Want To Public License, Version 2, # as published by Sam Hocevar. See the COPYING file for more details. # Standard Library imports import json import sys import glob import argparse # JsonPath-RW imports from jsonpath_ng import parse def find_matches_for_file(expr, f): return expr.find(json.load(f)) def print_matches(matches): print('\n'.join(['{0}'.format(match.value) for match in matches])) def main(*argv): parser = argparse.ArgumentParser( description='Search JSON files (or stdin) according to a JSONPath expression.', formatter_class=argparse.RawTextHelpFormatter, epilog=""" Quick JSONPath reference (see more at https://github.com/kennknowles/python-jsonpath-rw) atomics: $ - root object `this` - current object operators: path1.path2 - same as xpath / path1|path2 - union path1..path2 - somewhere in between fields: fieldname - field with name * - any field [_start_?:_end_?] - array slice [*] - any array index """) parser.add_argument('expression', help='A JSONPath expression.') parser.add_argument('files', metavar='file', nargs='*', help='Files to search (if none, searches stdin)') args = parser.parse_args(argv[1:]) expr = parse(args.expression) glob_patterns = args.files if len(glob_patterns) == 0: # stdin mode print_matches(find_matches_for_file(expr, sys.stdin)) else: # file paths mode for pattern in glob_patterns: for filename in glob.glob(pattern): with open(filename) as f: print_matches(find_matches_for_file(expr, f)) def entry_point(): main(*sys.argv) jsonpath-ng-1.8.0/jsonpath_ng/exceptions.py000066400000000000000000000002221514733354600210240ustar00rootroot00000000000000class JSONPathError(Exception): pass class JsonPathLexerError(JSONPathError): pass class JsonPathParserError(JSONPathError): pass jsonpath-ng-1.8.0/jsonpath_ng/ext/000077500000000000000000000000001514733354600170755ustar00rootroot00000000000000jsonpath-ng-1.8.0/jsonpath_ng/ext/__init__.py000066400000000000000000000011351514733354600212060ustar00rootroot00000000000000# -*- coding: utf-8 -*- # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. from .parser import parse # noqa jsonpath-ng-1.8.0/jsonpath_ng/ext/arithmetic.py000066400000000000000000000051401514733354600216000ustar00rootroot00000000000000# # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. import operator from .. import JSONPath, DatumInContext OPERATOR_MAP = { '+': operator.add, '-': operator.sub, '*': operator.mul, '/': operator.truediv, } class Operation(JSONPath): def __init__(self, left, op, right): self.left = left self.op_symbol = op self.op = OPERATOR_MAP[op] self.right = right def find(self, datum): result = [] if (isinstance(self.left, JSONPath) and isinstance(self.right, JSONPath)): left = self.left.find(datum) right = self.right.find(datum) if left and right and len(left) == len(right): for l, r in zip(left, right): try: result.append(self.op(l.value, r.value)) except TypeError: return [] else: return [] elif isinstance(self.left, JSONPath): left = self.left.find(datum) for l in left: try: result.append(self.op(l.value, self.right)) except TypeError: return [] elif isinstance(self.right, JSONPath): right = self.right.find(datum) for r in right: try: result.append(self.op(self.left, r.value)) except TypeError: return [] else: try: result.append(self.op(self.left, self.right)) except TypeError: return [] return [DatumInContext.wrap(r) for r in result] def __repr__(self): return '%s(%r%s%r)' % (self.__class__.__name__, self.left, self.op_symbol, self.right) def __str__(self): return '%s %s %s' % (self.left, self.op_symbol, self.right) def __eq__(self, other): return ( isinstance(other, Operation) and self.left == other.left and self.op_symbol == other.op_symbol and self.right == other.right ) jsonpath-ng-1.8.0/jsonpath_ng/ext/filter.py000066400000000000000000000100501514733354600207300ustar00rootroot00000000000000# # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. import operator import re from .. import JSONPath, DatumInContext, Index OPERATOR_MAP = { '!=': operator.ne, '==': operator.eq, '=': operator.eq, '<=': operator.le, '<': operator.lt, '>=': operator.ge, '>': operator.gt, '=~': lambda a, b: True if isinstance(a, str) and re.search(b, a) else False, } class Filter(JSONPath): """The JSONQuery filter""" def __init__(self, expressions): self.expressions = expressions def find(self, datum): if not self.expressions: return datum datum = DatumInContext.wrap(datum) if isinstance(datum.value, dict): datum.value = list(datum.value.values()) if not isinstance(datum.value, list): return [] return [DatumInContext(datum.value[i], path=Index(i), context=datum) for i in range(0, len(datum.value)) if (len(self.expressions) == len(list(filter(lambda x: x.find(datum.value[i]), self.expressions))))] def filter(self, fn, data): # NOTE: We reverse the order just to make sure the indexes are preserved upon # removal. for datum in reversed(self.find(data)): index_obj = datum.path if isinstance(data, dict): index_obj.index = list(data)[index_obj.index] index_obj.filter(fn, data) return data def update(self, data, val): if type(data) is list: for index, item in enumerate(data): shouldUpdate = len(self.expressions) == len(list(filter(lambda x: x.find(item), self.expressions))) if shouldUpdate: if hasattr(val, '__call__'): val.__call__(data[index], data, index) else: data[index] = val return data def __repr__(self): return '%s(%r)' % (self.__class__.__name__, self.expressions) def __str__(self): return '[?%s]' % self.expressions def __eq__(self, other): return (isinstance(other, Filter) and self.expressions == other.expressions) class Expression(JSONPath): """The JSONQuery expression""" def __init__(self, target, op, value): self.target = target self.op = op self.value = value def find(self, datum): datum = self.target.find(DatumInContext.wrap(datum)) if not datum: return [] if self.op is None: return datum found = [] for data in datum: value = data.value if type(self.value) is int: try: value = int(value) except ValueError: continue if OPERATOR_MAP[self.op](value, self.value): found.append(data) return found def __eq__(self, other): return (isinstance(other, Expression) and self.target == other.target and self.op == other.op and self.value == other.value) def __repr__(self): if self.op is None: return '%s(%r)' % (self.__class__.__name__, self.target) else: return '%s(%r %s %r)' % (self.__class__.__name__, self.target, self.op, self.value) def __str__(self): if self.op is None: return '%s' % self.target else: return '%s %s %s' % (self.target, self.op, self.value) jsonpath-ng-1.8.0/jsonpath_ng/ext/iterable.py000066400000000000000000000107351514733354600212440ustar00rootroot00000000000000# # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. import functools from .. import This, DatumInContext, JSONPath class SortedThis(This): """The JSONPath referring to the sorted version of the current object. Concrete syntax is '`sorted`' or [\\field,/field]. """ def __init__(self, expressions=None): self.expressions = expressions def _compare(self, left, right): left = DatumInContext.wrap(left) right = DatumInContext.wrap(right) for expr in self.expressions: field, reverse = expr l_datum = field.find(left) r_datum = field.find(right) if (not l_datum or not r_datum or len(l_datum) > 1 or len(r_datum) > 1 or l_datum[0].value == r_datum[0].value): # NOTE(sileht): should we do something if the expression # match multiple fields, for now ignore them continue elif l_datum[0].value < r_datum[0].value: return 1 if reverse else -1 else: return -1 if reverse else 1 return 0 def find(self, datum): """Return sorted value of This if list or dict.""" if isinstance(datum.value, dict) and self.expressions: return datum if isinstance(datum.value, dict) or isinstance(datum.value, list): key = (functools.cmp_to_key(self._compare) if self.expressions else None) return [DatumInContext.wrap( [value for value in sorted(datum.value, key=key)])] return datum def __eq__(self, other): return ( isinstance(other, SortedThis) and self.expressions == other.expressions ) def __repr__(self): return '%s(%r)' % (self.__class__.__name__, self.expressions) def __str__(self): expressions: list[str] = [] for (field, reverse) in self.expressions: prefix = "\\" if reverse else "/" expressions.append(f"{prefix}{field}") return f"[{', '.join(expressions)}]" class Len(JSONPath): """The JSONPath referring to the len of the current object. Concrete syntax is '`len`'. """ def find(self, datum): datum = DatumInContext.wrap(datum) try: value = len(datum.value) except TypeError: return [] else: return [DatumInContext(value, context=None, path=Len())] def __eq__(self, other): return isinstance(other, Len) def __str__(self): return '`len`' def __repr__(self): return 'Len()' class Keys(JSONPath): """The JSONPath referring to the keys of the current object. Concrete syntax is '`keys`'. """ def find(self, datum): datum = DatumInContext.wrap(datum) try: value = list(datum.value.keys()) except Exception as e: return [] else: return [DatumInContext(value[i], context=None, path=Keys()) for i in range (0, len(datum.value))] def __eq__(self, other): return isinstance(other, Keys) def __str__(self): return '`keys`' def __repr__(self): return 'Keys()' class Path(JSONPath): """The JSONPath referring to the path of the current object. Concrete syntax is 'path`'. """ def find(self, datum): datum = DatumInContext.wrap(datum) try: value = str(datum.path) except Exception as e: return [] else: return [DatumInContext(value, context=datum, path=Path())] def __eq__(self, other): return isinstance(other, Path) def __str__(self): return '`path`' def __repr__(self): return 'Path()' jsonpath-ng-1.8.0/jsonpath_ng/ext/parser.py000066400000000000000000000126061514733354600207500ustar00rootroot00000000000000# # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. from .. import lexer from .. import parser from .. import Fields, This, Child from . import arithmetic as _arithmetic from . import filter as _filter from . import iterable as _iterable from . import string as _string class ExtendedJsonPathLexer(lexer.JsonPathLexer): """Custom LALR-lexer for JsonPath""" literals = lexer.JsonPathLexer.literals + ['?', '@', '+', '*', '/', '-'] tokens = (['BOOL'] + parser.JsonPathLexer.tokens + ['FILTER_OP', 'SORT_DIRECTION', 'FLOAT']) t_FILTER_OP = r'=~|==?|<=|>=|!=|<|>' def t_BOOL(self, t): r'true|false' t.value = True if t.value == 'true' else False return t def t_SORT_DIRECTION(self, t): r',?\s*(/|\\)' t.value = t.value[-1] return t def t_ID(self, t): r'@?[a-zA-Z_][a-zA-Z0-9_@\-]*' # NOTE(sileht): This fixes the ID expression to be # able to use @ for `This` like any json query t.type = self.reserved_words.get(t.value, 'ID') return t def t_FLOAT(self, t): r'-?\d+\.\d+' t.value = float(t.value) return t class ExtendedJsonPathParser(parser.JsonPathParser): """Custom LALR-parser for JsonPath""" tokens = ExtendedJsonPathLexer.tokens def __init__(self, debug=False, lexer_class=None): lexer_class = lexer_class or ExtendedJsonPathLexer super(ExtendedJsonPathParser, self).__init__(debug, lexer_class) def p_jsonpath_operator_jsonpath(self, p): """jsonpath : NUMBER operator NUMBER | FLOAT operator FLOAT | ID operator ID | NUMBER operator jsonpath | FLOAT operator jsonpath | jsonpath operator NUMBER | jsonpath operator FLOAT | jsonpath operator jsonpath """ # NOTE(sileht): If we have choice between a field or a string we # always choice string, because field can be full qualified # like $.foo == foo and where string can't. for i in [1, 3]: if (isinstance(p[i], Fields) and len(p[i].fields) == 1): # noqa p[i] = p[i].fields[0] p[0] = _arithmetic.Operation(p[1], p[2], p[3]) def p_operator(self, p): """operator : '+' | '-' | '*' | '/' """ p[0] = p[1] def p_jsonpath_named_operator(self, p): "jsonpath : NAMED_OPERATOR" if p[1] == 'len': p[0] = _iterable.Len() elif p[1] == 'keys': p[0] = _iterable.Keys() elif p[1] == 'path': p[0] = _iterable.Path() elif p[1] == 'sorted': p[0] = _iterable.SortedThis() elif p[1].startswith("split("): p[0] = _string.Split(p[1]) elif p[1].startswith("sub("): p[0] = _string.Sub(p[1]) elif p[1].startswith("str("): p[0] = _string.Str(p[1]) else: super(ExtendedJsonPathParser, self).p_jsonpath_named_operator(p) def p_expression(self, p): """expression : jsonpath | jsonpath FILTER_OP ID | jsonpath FILTER_OP FLOAT | jsonpath FILTER_OP NUMBER | jsonpath FILTER_OP BOOL """ if len(p) == 2: left, op, right = p[1], None, None else: __, left, op, right = p p[0] = _filter.Expression(left, op, right) def p_expressions_expression(self, p): "expressions : expression" p[0] = [p[1]] def p_expressions_and(self, p): "expressions : expressions '&' expressions" # TODO(sileht): implements '|' p[0] = p[1] + p[3] def p_expressions_parens(self, p): "expressions : '(' expressions ')'" p[0] = p[2] def p_filter(self, p): "filter : '?' expressions " p[0] = _filter.Filter(p[2]) def p_jsonpath_filter(self, p): "jsonpath : jsonpath '[' filter ']'" p[0] = Child(p[1], p[3]) def p_sort(self, p): "sort : SORT_DIRECTION jsonpath" p[0] = (p[2], p[1] != "/") def p_sorts_sort(self, p): "sorts : sort" p[0] = [p[1]] def p_sorts_comma(self, p): "sorts : sorts sorts" p[0] = p[1] + p[2] def p_jsonpath_sort(self, p): "jsonpath : jsonpath '[' sorts ']'" sort = _iterable.SortedThis(p[3]) p[0] = Child(p[1], sort) def p_jsonpath_this(self, p): "jsonpath : '@'" p[0] = This() precedence = [ ('left', '+', '-'), ('left', '*', '/'), ] + parser.JsonPathParser.precedence + [ ('nonassoc', 'ID'), ] # XXX This is here for backward compatibility ExtentedJsonPathParser = ExtendedJsonPathParser def parse(path, debug=False): return ExtendedJsonPathParser(debug=debug).parse(path) jsonpath-ng-1.8.0/jsonpath_ng/ext/string.py000066400000000000000000000077151514733354600207670ustar00rootroot00000000000000# # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. import re from .. import DatumInContext, This SUB = re.compile(r"sub\(/(.*)/,\s+(.*)\)") # Regex generated using the EZRegex package (ezregex.org) # EZRegex code: # param1 = group(optional(either("'", '"')), name='quote') + group(chunk) + earlier_group('quote') # param2 = group(either(optional('-') + number, '*')) # param3 = group(optional('-') + number) # pattern = 'split' + ow + '(' + ow + param1 + ow + ',' + ow + param2 + ow + ',' + ow + param3 + ow + ')' SPLIT = re.compile(r"split(?:\s+)?\((?:\s+)?(?P(?:(?:'|\"))?)(.+)(?P=quote)(?:\s+)?,(?:\s+)?((?:(?:\-)?\d+|\*))(?:\s+)?,(?:\s+)?((?:\-)?\d+)(?:\s+)?\)") STR = re.compile(r"str\(\)") class DefintionInvalid(Exception): pass class Sub(This): """Regex substituor Concrete syntax is '`sub(/regex/, repl)`' """ def __init__(self, method=None): m = SUB.match(method) if m is None: raise DefintionInvalid("%s is not valid" % method) self.expr = m.group(1).strip() self.repl = m.group(2).strip() self.regex = re.compile(self.expr) self.method = method def find(self, datum): datum = DatumInContext.wrap(datum) value = self.regex.sub(self.repl, datum.value) if value == datum.value: return [] else: return [DatumInContext.wrap(value)] def __eq__(self, other): return (isinstance(other, Sub) and self.method == other.method) def __repr__(self): return '%s(%r)' % (self.__class__.__name__, self.method) def __str__(self): return '`sub(/%s/, %s)`' % (self.expr, self.repl) class Split(This): """String splitter Concrete syntax is '`split(chars, segment, max_split)`' `chars` can optionally be surrounded by quotes, to specify things like commas or spaces `segment` can be `*` to select all `max_split` can be negative, to indicate no limit """ def __init__(self, method=None): m = SPLIT.match(method) if m is None: raise DefintionInvalid("%s is not valid" % method) self.chars = m.group(2) self.segment = m.group(3) self.max_split = int(m.group(4)) self.method = method def find(self, datum): datum = DatumInContext.wrap(datum) try: if self.segment == '*': value = datum.value.split(self.chars, self.max_split) else: value = datum.value.split(self.chars, self.max_split)[int(self.segment)] except: return [] return [DatumInContext.wrap(value)] def __eq__(self, other): return (isinstance(other, Split) and self.method == other.method) def __repr__(self): return '%s(%r)' % (self.__class__.__name__, self.method) def __str__(self): return '`%s`' % self.method class Str(This): """String converter Concrete syntax is '`str()`' """ def __init__(self, method=None): m = STR.match(method) if m is None: raise DefintionInvalid("%s is not valid" % method) self.method = method def find(self, datum): datum = DatumInContext.wrap(datum) value = str(datum.value) return [DatumInContext.wrap(value)] def __eq__(self, other): return (isinstance(other, Str) and self.method == other.method) def __repr__(self): return '%s(%r)' % (self.__class__.__name__, self.method) def __str__(self): return '`str()`' jsonpath-ng-1.8.0/jsonpath_ng/jsonpath.py000066400000000000000000000704421514733354600205040ustar00rootroot00000000000000from __future__ import annotations from typing import List, Optional import logging from itertools import * # noqa import re # Get logger name logger = logging.getLogger(__name__) # Turn on/off the automatic creation of id attributes # ... could be a kwarg pervasively but uses are rare and simple today auto_id_field = None NOT_SET = object() LIST_KEY = object() class JSONPath: """ The base class for JSONPath abstract syntax; those methods stubbed here are the interface to supported JSONPath semantics. """ def find(self, data) -> List[DatumInContext]: """ All `JSONPath` types support `find()`, which returns an iterable of `DatumInContext`s. They keep track of the path followed to the current location, so if the calling code has some opinion about that, it can be passed in here as a starting point. """ raise NotImplementedError() def find_or_create(self, data): return self.find(data) def update(self, data, val): """ Returns `data` with the specified path replaced by `val`. Only updates if the specified path exists. """ raise NotImplementedError() def update_or_create(self, data, val): return self.update(data, val) def filter(self, fn, data): """ Returns `data` with the specified path filtering nodes according the filter evaluation result returned by the filter function. Arguments: fn (function): unary function that accepts one argument and returns bool. data (dict|list|tuple): JSON object to filter. """ raise NotImplementedError() def child(self, child): """ Equivalent to Child(self, next) but with some canonicalization """ if isinstance(self, This) or isinstance(self, Root): return child elif isinstance(child, This): return self elif isinstance(child, Root): return child else: return Child(self, child) def make_datum(self, value): if isinstance(value, DatumInContext): return value else: return DatumInContext(value, path=Root(), context=None) class DatumInContext: """ Represents a datum along a path from a context. Essentially a zipper but with a structure represented by JsonPath, and where the context is more of a parent pointer than a proper representation of the context. For quick-and-dirty work, this proxies any non-special attributes to the underlying datum, but the actual datum can (and usually should) be retrieved via the `value` attribute. To place `datum` within another, use `datum.in_context(context=..., path=...)` which extends the path. If the datum already has a context, it places the entire context within that passed in, so an object can be built from the inside out. """ @classmethod def wrap(cls, data): if isinstance(data, cls): return data else: return cls(data) def __init__(self, value, path: Optional[JSONPath]=None, context: Optional[DatumInContext]=None): self.__value__ = value self.path = path or This() self.context = None if context is None else DatumInContext.wrap(context) @property def value(self): return self.__value__ @value.setter def value(self, value): if self.context is not None and self.context.value is not None: self.path.update(self.context.value, value) self.__value__ = value def in_context(self, context, path): context = DatumInContext.wrap(context) if self.context: return DatumInContext(value=self.value, path=self.path, context=context.in_context(path=path, context=context)) else: return DatumInContext(value=self.value, path=path, context=context) @property def full_path(self) -> JSONPath: return self.path if self.context is None else self.context.full_path.child(self.path) @property def id_pseudopath(self): """ Looks like a path, but with ids stuck in when available """ try: pseudopath = Fields(str(self.value[auto_id_field])) except (TypeError, AttributeError, KeyError): # This may not be all the interesting exceptions pseudopath = self.path if self.context: return self.context.id_pseudopath.child(pseudopath) else: return pseudopath def __repr__(self): return '%s(value=%r, path=%r, context=%r)' % (self.__class__.__name__, self.value, self.path, self.context) def __eq__(self, other): return isinstance(other, DatumInContext) and other.value == self.value and other.path == self.path and self.context == other.context class AutoIdForDatum(DatumInContext): """ This behaves like a DatumInContext, but the value is always the path leading up to it, not including the "id", and with any "id" fields along the way replacing the prior segment of the path For example, it will make "foo.bar.id" return a datum that behaves like DatumInContext(value="foo.bar", path="foo.bar.id"). This is disabled by default; it can be turned on by settings the `auto_id_field` global to a value other than `None`. """ def __init__(self, datum, id_field=None): """ Invariant is that datum.path is the path from context to datum. The auto id will either be the id in the datum (if present) or the id of the context followed by the path to the datum. The path to this datum is always the path to the context, the path to the datum, and then the auto id field. """ self.datum = datum self.id_field = id_field or auto_id_field @property def value(self): return str(self.datum.id_pseudopath) @property def path(self): return self.id_field @property def context(self): return self.datum def __repr__(self): return '%s(%r)' % (self.__class__.__name__, self.datum) def in_context(self, context, path): return AutoIdForDatum(self.datum.in_context(context=context, path=path)) def __eq__(self, other): return isinstance(other, AutoIdForDatum) and other.datum == self.datum and self.id_field == other.id_field class Root(JSONPath): """ The JSONPath referring to the "root" object. Concrete syntax is '$'. The root is the topmost datum without any context attached. """ def find(self, data) -> List[DatumInContext]: if not isinstance(data, DatumInContext): return [DatumInContext(data, path=Root(), context=None)] else: if data.context is None: return [DatumInContext(data.value, context=None, path=Root())] else: return Root().find(data.context) def update(self, data, val): return val def filter(self, fn, data): return data if fn(data) else None def __str__(self): return '$' def __repr__(self): return 'Root()' def __eq__(self, other): return isinstance(other, Root) def __hash__(self): return hash('$') class This(JSONPath): """ The JSONPath referring to the current datum. Concrete syntax is '@'. """ def find(self, datum): return [DatumInContext.wrap(datum)] def update(self, data, val): return val def filter(self, fn, data): return data if fn(data) else None def __str__(self): return '`this`' def __repr__(self): return 'This()' def __eq__(self, other): return isinstance(other, This) def __hash__(self): return hash('this') class Child(JSONPath): """ JSONPath that first matches the left, then the right. Concrete syntax is '.' """ def __init__(self, left, right): self.left = left self.right = right def find(self, datum): """ Extra special case: auto ids do not have children, so cut it off right now rather than auto id the auto id """ return [submatch for subdata in self.left.find(datum) if not isinstance(subdata, AutoIdForDatum) for submatch in self.right.find(subdata)] def update(self, data, val): for datum in self.left.find(data): self.right.update(datum.value, val) return data def find_or_create(self, datum): datum = DatumInContext.wrap(datum) submatches = [] for subdata in self.left.find_or_create(datum): if isinstance(subdata, AutoIdForDatum): # Extra special case: auto ids do not have children, # so cut it off right now rather than auto id the auto id continue for submatch in self.right.find_or_create(subdata): submatches.append(submatch) return submatches def update_or_create(self, data, val): for datum in self.left.find_or_create(data): self.right.update_or_create(datum.value, val) return _clean_list_keys(data) def filter(self, fn, data): for datum in self.left.find(data): self.right.filter(fn, datum.value) return data def __eq__(self, other): return isinstance(other, Child) and self.left == other.left and self.right == other.right def __str__(self): # Special case: If the right side is a `SortedThis` instance, # do not inject a period between the left and right sides. # Adding a period would corrupt the syntax and prevent re-parsing. # Current module design creates circular imports, so imports happen here. from .ext.iterable import SortedThis if isinstance(self.right, SortedThis): return f"{self.left}{self.right}" # Parentheses are required to ensure precedence. return f"({self.left}.{self.right})" def __repr__(self): return '%s(%r, %r)' % (self.__class__.__name__, self.left, self.right) def __hash__(self): return hash((self.left, self.right)) class Parent(JSONPath): """ JSONPath that matches the parent node of the current match. Will crash if no such parent exists. Available via named operator `parent`. """ def find(self, datum): datum = DatumInContext.wrap(datum) return [datum.context] def __eq__(self, other): return isinstance(other, Parent) def __str__(self): return '`parent`' def __repr__(self): return 'Parent()' def __hash__(self): return hash('parent') class Where(JSONPath): """ JSONPath that first matches the left, and then filters for only those nodes that have a match on the right. WARNING: Subject to change. May want to have "contains" or some other better word for it. """ def __init__(self, left, right): self.left = left self.right = right def find(self, data): return [subdata for subdata in self.left.find(data) if self.right.find(subdata)] def update(self, data, val): for datum in self.find(data): datum.path.update(data, val) return data def filter(self, fn, data): for datum in self.find(data): datum.path.filter(fn, datum.value) return data def __str__(self): return '%s where %s' % (self.left, self.right) def __eq__(self, other): return isinstance(other, Where) and other.left == self.left and other.right == self.right def __hash__(self): return hash((self.left, self.right)) class WhereNot(Where): """ Identical to ``Where``, but filters for only those nodes that do *not* have a match on the right. >>> jsonpath = WhereNot(Fields('spam'), Fields('spam')) >>> jsonpath.find({"spam": {"spam": 1}}) [] >>> matches = jsonpath.find({"spam": 1}) >>> matches[0].value 1 """ def find(self, data): return [subdata for subdata in self.left.find(data) if not self.right.find(subdata)] def __str__(self): return '%s wherenot %s' % (self.left, self.right) def __eq__(self, other): return (isinstance(other, WhereNot) and other.left == self.left and other.right == self.right) def __hash__(self): return hash((self.left, self.right)) class Descendants(JSONPath): """ JSONPath that matches first the left expression then any descendant of it which matches the right expression. """ def __init__(self, left, right): self.left = left self.right = right def find(self, datum): # .. ==> . ( | *.. | [*]..) # # With with a wonky caveat that since Slice() has funky coercions # we cannot just delegate to that equivalence or we'll hit an # infinite loop. So right here we implement the coercion-free version. # Get all left matches into a list left_matches = self.left.find(datum) if not isinstance(left_matches, list): left_matches = [left_matches] def match_recursively(datum): right_matches = self.right.find(datum) # Manually do the * or [*] to avoid coercion and recurse just the right-hand pattern if isinstance(datum.value, list): recursive_matches = [submatch for i in range(0, len(datum.value)) for submatch in match_recursively(DatumInContext(datum.value[i], context=datum, path=Index(i)))] elif isinstance(datum.value, dict): recursive_matches = [submatch for field in datum.value.keys() for submatch in match_recursively(DatumInContext(datum.value[field], context=datum, path=Fields(field)))] else: recursive_matches = [] return right_matches + list(recursive_matches) # TODO: repeatable iterator instead of list? return [submatch for left_match in left_matches for submatch in match_recursively(left_match)] def is_singular(self): return False def update(self, data, val): # Get all left matches into a list left_matches = self.left.find(data) if not isinstance(left_matches, list): left_matches = [left_matches] def update_recursively(data): # Update only mutable values corresponding to JSON types if not (isinstance(data, list) or isinstance(data, dict)): return self.right.update(data, val) # Manually do the * or [*] to avoid coercion and recurse just the right-hand pattern if isinstance(data, list): for i in range(0, len(data)): update_recursively(data[i]) elif isinstance(data, dict): for field in data.keys(): update_recursively(data[field]) for submatch in left_matches: update_recursively(submatch.value) return data def filter(self, fn, data): # Get all left matches into a list left_matches = self.left.find(data) if not isinstance(left_matches, list): left_matches = [left_matches] def filter_recursively(data): # Update only mutable values corresponding to JSON types if not (isinstance(data, list) or isinstance(data, dict)): return self.right.filter(fn, data) # Manually do the * or [*] to avoid coercion and recurse just the right-hand pattern if isinstance(data, list): for i in range(0, len(data)): filter_recursively(data[i]) elif isinstance(data, dict): for field in data.keys(): filter_recursively(data[field]) for submatch in left_matches: filter_recursively(submatch.value) return data def __str__(self): return f"({self.left}..{self.right})" def __eq__(self, other): return isinstance(other, Descendants) and self.left == other.left and self.right == other.right def __repr__(self): return '%s(%r, %r)' % (self.__class__.__name__, self.left, self.right) def __hash__(self): return hash((self.left, self.right)) class Union(JSONPath): """ JSONPath that returns the union of the results of each match. This is pretty shoddily implemented for now. The nicest semantics in case of mismatched bits (list vs atomic) is to put them all in a list, but I haven't done that yet. WARNING: Any appearance of this being the _concatenation_ is coincidence. It may even be a bug! (or laziness) """ def __init__(self, left, right): self.left = left self.right = right def is_singular(self): return False def find(self, data): return self.left.find(data) + self.right.find(data) def __eq__(self, other): return isinstance(other, Union) and self.left == other.left and self.right == other.right def __hash__(self): return hash((self.left, self.right)) def __repr__(self) -> str: return f"Union({self.left} | {self.right})" def __str__(self) -> str: return f"{self.left} | {self.right}" class Intersect(JSONPath): """ JSONPath for bits that match *both* patterns. This can be accomplished a couple of ways. The most efficient is to actually build the intersected AST as in building a state machine for matching the intersection of regular languages. The next idea is to build a filtered data and match against that. """ def __init__(self, left, right): self.left = left self.right = right def is_singular(self): return False def find(self, data): raise NotImplementedError() def __eq__(self, other): return isinstance(other, Intersect) and self.left == other.left and self.right == other.right def __hash__(self): return hash((self.left, self.right)) def __repr__(self) -> str: return f"Intersect({self.left} & {self.right})" def __str__(self) -> str: return f"{self.left} & {self.right}" class Fields(JSONPath): """ JSONPath referring to some field of the current object. Concrete syntax ix comma-separated field names. WARNING: If '*' is any of the field names, then they will all be returned. """ def __init__(self, *fields): self.fields = fields @staticmethod def get_field_datum(datum, field, create): if field == auto_id_field: return AutoIdForDatum(datum) try: field_value = datum.value.get(field, NOT_SET) if field_value is NOT_SET: if create: datum.value[field] = field_value = {} else: return None return DatumInContext(field_value, path=Fields(field), context=datum) except (TypeError, AttributeError): return None def reified_fields(self, datum): if '*' not in self.fields: return self.fields else: try: fields = tuple(datum.value.keys()) return fields if auto_id_field is None else fields + (auto_id_field,) except AttributeError: return () def find(self, datum): return self._find_base(datum, create=False) def find_or_create(self, datum): return self._find_base(datum, create=True) def _find_base(self, datum, create): datum = DatumInContext.wrap(datum) field_data = [self.get_field_datum(datum, field, create) for field in self.reified_fields(datum)] return [fd for fd in field_data if fd is not None] def update(self, data, val): return self._update_base(data, val, create=False) def update_or_create(self, data, val): return self._update_base(data, val, create=True) def _update_base(self, data, val, create): if data is not None: for field in self.reified_fields(DatumInContext.wrap(data)): if create and field not in data: data[field] = {} if type(data) is not bool and field in data: if hasattr(val, '__call__'): data[field] = val(data[field], data, field) else: data[field] = val return data def filter(self, fn, data): if data is not None and isinstance(data, dict): for field in self.reified_fields(DatumInContext.wrap(data)): if field in data: if fn(data[field]): data.pop(field) return data def __str__(self): # Enclose fields in quotes as needed. # This is a conservative check, and is biased toward quoting fields. rendered_fields: list[str] = [] for field in self.fields: if re.match(r"^[A-Za-z_@][A-Za-z0-9_@-]*$", field): rendered_fields.append(field) else: rendered_fields.append(f"{field!r}") return ','.join(rendered_fields) def __repr__(self): return '%s(%s)' % (self.__class__.__name__, ','.join(map(repr, self.fields))) def __eq__(self, other): return isinstance(other, Fields) and tuple(self.fields) == tuple(other.fields) def __hash__(self): return hash(tuple(self.fields)) class Index(JSONPath): """ JSONPath that matches indices of the current datum, or none if not large enough. Concrete syntax is brackets. WARNING: If the datum is None or not long enough, it will not crash but will not match anything. NOTE: For the concrete syntax of `[*]`, the abstract syntax is a Slice() with no parameters (equiv to `[:]` """ def __init__(self, *indices): self.indices = indices def find(self, datum): return self._find_base(datum, create=False) def find_or_create(self, datum): return self._find_base(datum, create=True) def _find_base(self, datum, create): datum = DatumInContext.wrap(datum) if create: if datum.value == {}: datum.value = _create_list_key(datum.value) self._pad_value(datum.value) rv = [] for index in self.indices: # invalid indices do not crash, return [] instead if datum.value and len(datum.value) > index: rv += [DatumInContext(datum.value[index], path=Index(index), context=datum)] return rv def update(self, data, val): return self._update_base(data, val, create=False) def update_or_create(self, data, val): return self._update_base(data, val, create=True) def _update_base(self, data, val, create): if create: if data == {}: data = _create_list_key(data) self._pad_value(data) if hasattr(val, '__call__'): for index in self.indices: val.__call__(data[index], data, index) else: for index in self.indices: if len(data) > index: try: if isinstance(val, list): # allows somelist[5,1,2] = [some_value, another_value, third_value] data[index] = val.pop(0) else: data[index] = val except Exception as e: raise e return data def filter(self, fn, data): for index in self.indices: if fn(data[index]): data.pop(index) # relies on mutation :( return data def __eq__(self, other): return isinstance(other, Index) and sorted(self.indices) == sorted(other.indices) def __str__(self): return '[%i]' % self.indices def __repr__(self): return '%s(indices=%r)' % (self.__class__.__name__, self.indices) def _pad_value(self, value): _max = max(self.indices) if len(value) <= _max: pad = _max - len(value) + 1 value += [{} for __ in range(pad)] def __hash__(self): return hash(self.index) class Slice(JSONPath): """ JSONPath matching a slice of an array. Because of a mismatch between JSON and XML when schema-unaware, this always returns an iterable; if the incoming data was not a list, then it returns a one element list _containing_ that data. Consider these two docs, and their schema-unaware translation to JSON: hello ==> {"a": {"b": "hello"}} hellogoodbye ==> {"a": {"b": ["hello", "goodbye"]}} If there were a schema, it would be known that "b" should always be an array (unless the schema were wonky, but that is too much to fix here) so when querying with JSON if the one writing the JSON knows that it should be an array, they can write a slice operator and it will coerce a non-array value to an array. This may be a bit unfortunate because it would be nice to always have an iterator, but dictionaries and other objects may also be iterable, so this is the compromise. """ def __init__(self, start=None, end=None, step=None): self.start = start self.end = end self.step = step def find(self, datum): datum = DatumInContext.wrap(datum) # Used for catching null value instead of empty list in path if datum.value is None: return [] # Here's the hack. If it is a dictionary or some kind of constant, # put it in a single-element list if (isinstance(datum.value, dict) or isinstance(datum.value, (int, float, str, bool))): return self.find(DatumInContext([datum.value], path=datum.path, context=datum.context)) # Some iterators do not support slicing but we can still # at least work for '*' if self.start is None and self.end is None and self.step is None: return [DatumInContext(datum.value[i], path=Index(i), context=datum) for i in range(0, len(datum.value))] else: return [DatumInContext(datum.value[i], path=Index(i), context=datum) for i in range(0, len(datum.value))[self.start:self.end:self.step]] def update(self, data, val): for datum in self.find(data): datum.path.update(data, val) return data def filter(self, fn, data): while True: length = len(data) for datum in self.find(data): data = datum.path.filter(fn, data) if len(data) < length: break if length == len(data): break return data def __str__(self): if self.start is None and self.end is None and self.step is None: return '[*]' else: return '[%s%s%s]' % (self.start or '', ':%d'%self.end if self.end else '', ':%d'%self.step if self.step else '') def __repr__(self): return '%s(start=%r,end=%r,step=%r)' % (self.__class__.__name__, self.start, self.end, self.step) def __eq__(self, other): return isinstance(other, Slice) and other.start == self.start and self.end == other.end and other.step == self.step def __hash__(self): return hash((self.start, self.end, self.step)) def _create_list_key(dict_): """ Adds a list to a dictionary by reference and returns the list. See `_clean_list_keys()` """ dict_[LIST_KEY] = new_list = [{}] return new_list def _clean_list_keys(struct_): """ Replace {LIST_KEY: ['foo', 'bar']} with ['foo', 'bar']. >>> _clean_list_keys({LIST_KEY: ['foo', 'bar']}) ['foo', 'bar'] """ if(isinstance(struct_, list)): for ind, value in enumerate(struct_): struct_[ind] = _clean_list_keys(value) elif(isinstance(struct_, dict)): if(LIST_KEY in struct_): return _clean_list_keys(struct_[LIST_KEY]) else: for key, value in struct_.items(): struct_[key] = _clean_list_keys(value) return struct_ jsonpath-ng-1.8.0/jsonpath_ng/lexer.py000066400000000000000000000125221514733354600177700ustar00rootroot00000000000000import sys import logging import jsonpath_ng._ply.lex from jsonpath_ng.exceptions import JsonPathLexerError logger = logging.getLogger(__name__) class JsonPathLexer: ''' A Lexical analyzer for JsonPath. ''' def __init__(self, debug=False): self.debug = debug if self.__doc__ is None: raise JsonPathLexerError('Docstrings have been removed! By design of PLY, jsonpath-rw requires docstrings. You must not use PYTHONOPTIMIZE=2 or python -OO.') def tokenize(self, string): ''' Maps a string to an iterator over tokens. In other words: [char] -> [token] ''' new_lexer = jsonpath_ng._ply.lex.lex(module=self, debug=self.debug, errorlog=logger) new_lexer.latest_newline = 0 new_lexer.string_value = None new_lexer.input(string) while True: t = new_lexer.token() if t is None: break t.col = t.lexpos - new_lexer.latest_newline yield t if new_lexer.string_value is not None: raise JsonPathLexerError('Unexpected EOF in string literal or identifier') # ============== PLY Lexer specification ================== # # This probably should be private but: # - the parser requires access to `tokens` (perhaps they should be defined in a third, shared dependency) # - things like `literals` might be a legitimate part of the public interface. # # Anyhow, it is pythonic to give some rope to hang oneself with :-) literals = ['*', '.', '[', ']', '(', ')', '$', ',', ':', '|', '&', '~'] reserved_words = { 'where': 'WHERE', 'wherenot': 'WHERENOT', } tokens = ['DOUBLEDOT', 'NUMBER', 'ID', 'NAMED_OPERATOR'] + list(reserved_words.values()) states = [ ('singlequote', 'exclusive'), ('doublequote', 'exclusive'), ('backquote', 'exclusive') ] # Normal lexing, rather easy t_DOUBLEDOT = r'\.\.' t_ignore = ' \t' def t_ID(self, t): # CJK: [\u4E00-\u9FA5] # EMOJI: [\U0001F600-\U0001F64F] r'([a-zA-Z_@]|[\u4E00-\u9FA5]|[\U0001F600-\U0001F64F])([a-zA-Z0-9_@\-]|[\u4E00-\u9FA5]|[\U0001F600-\U0001F64F])*' t.type = self.reserved_words.get(t.value, 'ID') return t def t_NUMBER(self, t): r'-?\d+' t.value = int(t.value) return t # Single-quoted strings t_singlequote_ignore = '' def t_singlequote(self, t): r"'" t.lexer.string_start = t.lexer.lexpos t.lexer.string_value = '' t.lexer.push_state('singlequote') def t_singlequote_content(self, t): r"[^'\\]+" t.lexer.string_value += t.value def t_singlequote_escape(self, t): r'\\.' t.lexer.string_value += t.value[1] def t_singlequote_end(self, t): r"'" t.value = t.lexer.string_value t.type = 'ID' t.lexer.string_value = None t.lexer.pop_state() return t def t_singlequote_error(self, t): raise JsonPathLexerError('Error on line %s, col %s while lexing singlequoted field: Unexpected character: %s ' % (t.lexer.lineno, t.lexpos - t.lexer.latest_newline, t.value[0])) # Double-quoted strings t_doublequote_ignore = '' def t_doublequote(self, t): r'"' t.lexer.string_start = t.lexer.lexpos t.lexer.string_value = '' t.lexer.push_state('doublequote') def t_doublequote_content(self, t): r'[^"\\]+' t.lexer.string_value += t.value def t_doublequote_escape(self, t): r'\\.' t.lexer.string_value += t.value[1] def t_doublequote_end(self, t): r'"' t.value = t.lexer.string_value t.type = 'ID' t.lexer.string_value = None t.lexer.pop_state() return t def t_doublequote_error(self, t): raise JsonPathLexerError('Error on line %s, col %s while lexing doublequoted field: Unexpected character: %s ' % (t.lexer.lineno, t.lexpos - t.lexer.latest_newline, t.value[0])) # Back-quoted "magic" operators t_backquote_ignore = '' def t_backquote(self, t): r'`' t.lexer.string_start = t.lexer.lexpos t.lexer.string_value = '' t.lexer.push_state('backquote') def t_backquote_escape(self, t): r'\\.' t.lexer.string_value += t.value[1] def t_backquote_content(self, t): r"[^`\\]+" t.lexer.string_value += t.value def t_backquote_end(self, t): r'`' t.value = t.lexer.string_value t.type = 'NAMED_OPERATOR' t.lexer.string_value = None t.lexer.pop_state() return t def t_backquote_error(self, t): raise JsonPathLexerError('Error on line %s, col %s while lexing backquoted operator: Unexpected character: %s ' % (t.lexer.lineno, t.lexpos - t.lexer.latest_newline, t.value[0])) # Counting lines, handling errors def t_newline(self, t): r'\n' t.lexer.lineno += 1 t.lexer.latest_newline = t.lexpos def t_error(self, t): raise JsonPathLexerError('Error on line %s, col %s: Unexpected character: %s ' % (t.lexer.lineno, t.lexpos - t.lexer.latest_newline, t.value[0])) if __name__ == '__main__': logging.basicConfig() lexer = JsonPathLexer(debug=True) for token in lexer.tokenize(sys.stdin.read()): print('%-20s%s' % (token.value, token.type)) jsonpath-ng-1.8.0/jsonpath_ng/parser.py000066400000000000000000000141071514733354600201460ustar00rootroot00000000000000import logging import sys import os.path import jsonpath_ng._ply.yacc from jsonpath_ng.exceptions import JsonPathParserError from jsonpath_ng.jsonpath import * from jsonpath_ng.lexer import JsonPathLexer logger = logging.getLogger(__name__) def parse(string): return JsonPathParser().parse(string) class JsonPathParser: ''' An LALR-parser for JsonPath ''' tokens = JsonPathLexer.tokens def __init__(self, debug=False, lexer_class=None): if self.__doc__ is None: raise JsonPathParserError( 'Docstrings have been removed! By design of PLY, ' 'jsonpath-rw requires docstrings. You must not use ' 'PYTHONOPTIMIZE=2 or python -OO.' ) self.debug = debug self.lexer_class = lexer_class or JsonPathLexer # Crufty but works around statefulness in PLY # Since PLY has some crufty aspects and dumps files, we try to keep them local # However, we need to derive the name of the output Python file :-/ output_directory = os.path.dirname(__file__) try: module_name = os.path.splitext(os.path.split(__file__)[1])[0] except: module_name = __name__ start_symbol = 'jsonpath' parsing_table_module = '_'.join([module_name, start_symbol, 'parsetab']) # Generate the parse table self.parser = jsonpath_ng._ply.yacc.yacc(module=self, debug=self.debug, tabmodule = parsing_table_module, outputdir = output_directory, write_tables=0, start = start_symbol, errorlog = logger) def parse(self, string, lexer = None) -> JSONPath: lexer = lexer or self.lexer_class() return self.parse_token_stream(lexer.tokenize(string)) def parse_token_stream(self, token_iterator): return self.parser.parse(lexer = IteratorToTokenStream(token_iterator)) # ===================== PLY Parser specification ===================== precedence = [ ('left', ','), ('left', 'DOUBLEDOT'), ('left', '.'), ('left', '|'), ('left', '&'), ('left', 'WHERE'), ('left', 'WHERENOT'), ] def p_error(self, t): if t is None: raise JsonPathParserError('Parse error near the end of string!') raise JsonPathParserError('Parse error at %s:%s near token %s (%s)' % (t.lineno, t.col, t.value, t.type)) def p_jsonpath_binop(self, p): """jsonpath : jsonpath '.' jsonpath | jsonpath DOUBLEDOT jsonpath | jsonpath WHERE jsonpath | jsonpath WHERENOT jsonpath | jsonpath '|' jsonpath | jsonpath '&' jsonpath""" op = p[2] if op == '.': p[0] = Child(p[1], p[3]) elif op == '..': p[0] = Descendants(p[1], p[3]) elif op == 'where': p[0] = Where(p[1], p[3]) elif op == 'wherenot': p[0] = WhereNot(p[1], p[3]) elif op == '|': p[0] = Union(p[1], p[3]) elif op == '&': p[0] = Intersect(p[1], p[3]) def p_jsonpath_fields(self, p): "jsonpath : fields_or_any" p[0] = Fields(*p[1]) def p_jsonpath_named_operator(self, p): "jsonpath : NAMED_OPERATOR" if p[1] == 'this': p[0] = This() elif p[1] == 'parent': p[0] = Parent() else: raise JsonPathParserError('Unknown named operator `%s` at %s:%s' % (p[1], p.lineno(1), p.lexpos(1))) def p_jsonpath_root(self, p): "jsonpath : '$'" p[0] = Root() def p_jsonpath_idx(self, p): "jsonpath : '[' idx ']'" p[0] = Index(*p[2]) def p_jsonpath_slice(self, p): "jsonpath : '[' slice ']'" p[0] = p[2] def p_jsonpath_fieldbrackets(self, p): "jsonpath : '[' fields ']'" p[0] = Fields(*p[2]) def p_jsonpath_child_fieldbrackets(self, p): "jsonpath : jsonpath '[' fields ']'" p[0] = Child(p[1], Fields(*p[3])) def p_jsonpath_child_idxbrackets(self, p): "jsonpath : jsonpath '[' idx ']'" p[0] = Child(p[1], Index(*p[3])) def p_jsonpath_child_slicebrackets(self, p): "jsonpath : jsonpath '[' slice ']'" p[0] = Child(p[1], p[3]) def p_jsonpath_parens(self, p): "jsonpath : '(' jsonpath ')'" p[0] = p[2] # Because fields in brackets cannot be '*' - that is reserved for array indices def p_fields_or_any(self, p): """fields_or_any : fields | '*' | NUMBER""" if p[1] == '*': p[0] = ['*'] elif isinstance(p[1], int): p[0] = [str(p[1])] else: p[0] = p[1] def p_fields_id(self, p): "fields : ID" p[0] = [p[1]] def p_fields_comma(self, p): "fields : fields ',' fields" p[0] = p[1] + p[3] def p_idx(self, p): "idx : NUMBER" p[0] = [p[1]] def p_idx_comma(self, p): "idx : idx ',' idx " p[0] = p[1] + p[3] def p_slice_any(self, p): "slice : '*'" p[0] = Slice() def p_slice(self, p): # Currently does not support `step` """slice : maybe_int ':' maybe_int | maybe_int ':' maybe_int ':' maybe_int """ p[0] = Slice(*p[1::2]) def p_maybe_int(self, p): """maybe_int : NUMBER | empty""" p[0] = p[1] def p_empty(self, p): 'empty :' p[0] = None class IteratorToTokenStream: def __init__(self, iterator): self.iterator = iterator def token(self): try: return next(self.iterator) except StopIteration: return None if __name__ == '__main__': logging.basicConfig() parser = JsonPathParser(debug=True) print(parser.parse(sys.stdin.read())) jsonpath-ng-1.8.0/pyproject.toml000066400000000000000000000003141514733354600166750ustar00rootroot00000000000000[tool.pytest.ini_options] filterwarnings = [ # Escalate warnings to errors. "error", # The ply package doesn't close its debug log file. Ignore this warning. "ignore::ResourceWarning", ] jsonpath-ng-1.8.0/requirements-dev.txt000066400000000000000000000000351514733354600200210ustar00rootroot00000000000000tox flake8 pytest hypothesis jsonpath-ng-1.8.0/requirements.txt000066400000000000000000000000211514733354600172400ustar00rootroot00000000000000setuptools>=18.5 jsonpath-ng-1.8.0/setup.py000066400000000000000000000023601514733354600154760ustar00rootroot00000000000000import io import setuptools setuptools.setup( name='jsonpath-ng', version='1.8.0', description=( 'A final implementation of JSONPath for Python that aims to be ' 'standard compliant, including arithmetic and binary comparison ' 'operators and providing clear AST for metaprogramming.' ), author='Tomas Aparicio', author_email='tomas@aparicio.me', url='https://github.com/h2non/jsonpath-ng', license='Apache 2.0', long_description=io.open('README.rst', encoding='utf-8').read(), packages=['jsonpath_ng', 'jsonpath_ng.bin', 'jsonpath_ng.ext','jsonpath_ng._ply'], entry_points={ 'console_scripts': [ 'jsonpath_ng=jsonpath_ng.bin.jsonpath:entry_point' ], }, test_suite='tests', classifiers=[ 'Development Status :: 5 - Production/Stable', 'Intended Audience :: Developers', 'License :: OSI Approved :: Apache Software License', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: 3.10', 'Programming Language :: Python :: 3.11', 'Programming Language :: Python :: 3.12', 'Programming Language :: Python :: 3.13', 'Programming Language :: Python :: 3.14', ], ) jsonpath-ng-1.8.0/tests/000077500000000000000000000000001514733354600151255ustar00rootroot00000000000000jsonpath-ng-1.8.0/tests/__init__.py000066400000000000000000000000001514733354600172240ustar00rootroot00000000000000jsonpath-ng-1.8.0/tests/bin/000077500000000000000000000000001514733354600156755ustar00rootroot00000000000000jsonpath-ng-1.8.0/tests/bin/test1.json000066400000000000000000000001331514733354600176250ustar00rootroot00000000000000{ "foo": { "baz": 1, "bizzle": { "baz": 2 } } }jsonpath-ng-1.8.0/tests/bin/test2.json000066400000000000000000000002041514733354600176250ustar00rootroot00000000000000{ "foo": { "foo": { "baz": 3, "merp": { "baz": 4 } } } }jsonpath-ng-1.8.0/tests/bin/test_jsonpath.py000066400000000000000000000014411514733354600211340ustar00rootroot00000000000000""" Tests for the jsonpath.py command line interface. """ import io import json import os import sys from jsonpath_ng.bin.jsonpath import main def test_stdin_mode(monkeypatch, capsys): stdin_text = json.dumps( { "foo": { "baz": 1, "bizzle": {"baz": 2}, }, } ) monkeypatch.setattr(sys, "stdin", io.StringIO(stdin_text)) main("jsonpath.py", "foo..baz") stdout, _ = capsys.readouterr() assert stdout == "1\n2\n" def test_filename_mode(capsys): test1 = os.path.join(os.path.dirname(__file__), "test1.json") test2 = os.path.join(os.path.dirname(__file__), "test2.json") main("jsonpath.py", "foo..baz", test1, test2) stdout, _ = capsys.readouterr() assert stdout == "1\n2\n3\n4\n" jsonpath-ng-1.8.0/tests/conftest.py000066400000000000000000000006231514733354600173250ustar00rootroot00000000000000import pytest @pytest.fixture(autouse=True) def disable_auto_id_field(monkeypatch): monkeypatch.setattr("jsonpath_ng.jsonpath.auto_id_field", None) @pytest.fixture() def auto_id_field(monkeypatch, disable_auto_id_field): """Enable `jsonpath_ng.jsonpath.auto_id_field`.""" field_name = "id" monkeypatch.setattr("jsonpath_ng.jsonpath.auto_id_field", field_name) return field_name jsonpath-ng-1.8.0/tests/helpers.py000066400000000000000000000030611514733354600171410ustar00rootroot00000000000000def assert_value_equality(results, expected_values): """Assert equality between two objects. *results* must be a list of results as returned by `.find()` methods. If *expected_values* is a list, then value equality and ordering will be checked. If *expected_values* is a set, value equality and container length will be checked. Otherwise, the value of the results will be compared to the expected values. """ left_values = [result.value for result in results] if isinstance(expected_values, list): assert left_values == expected_values, f"{left_values!r} != {expected_values!r}" elif isinstance(expected_values, set): assert len(left_values) == len(expected_values) assert set(left_values) == expected_values, f"{left_values!r} != {expected_values!r}" else: assert results[0].value == expected_values def assert_full_path_equality(results, expected_full_paths): """Assert equality between two objects. *results* must be a list or set of results as returned by `.find()` methods. If *expected_full_paths* is a list, then path equality and ordering will be checked. If *expected_full_paths* is a set, then path equality and length will be checked. """ full_paths = [str(result.full_path) for result in results] if isinstance(expected_full_paths, list): assert full_paths == expected_full_paths, full_paths else: # isinstance(expected_full_paths, set): assert len(full_paths) == len(expected_full_paths) assert set(full_paths) == expected_full_paths jsonpath-ng-1.8.0/tests/test_create.py000066400000000000000000000042001514733354600177750ustar00rootroot00000000000000import copy from contextlib import nullcontext as does_not_raise import pytest from jsonpath_ng.ext import parse @pytest.mark.parametrize( "string, initial_data, expected_result", ( ("$.foo", {}, {"foo": 42}), ("$.foo.bar", {}, {"foo": {"bar": 42}}), ("$.foo[0]", {}, {"foo": [42]}), ("$.foo[1]", {}, {"foo": [{}, 42]}), ("$.foo[0].bar", {}, {"foo": [{"bar": 42}]}), ("$.foo[1].bar", {}, {"foo": [{}, {"bar": 42}]}), ("$.foo[0][0]", {}, {"foo": [[42]]}), ("$.foo[1][1]", {}, {"foo": [{}, [{}, 42]]}), ("foo[0]", {}, {"foo": [42]}), ("foo[1]", {}, {"foo": [{}, 42]}), ("foo", {}, {"foo": 42}), # # Initial data can be a list if we expect a list back. ("[0]", [], [42]), ("[1]", [], [{}, 42]), # # Convert initial data to a list, if necessary. ("[0]", {}, [42]), ("[1]", {}, [{}, 42]), # ( 'foo[?bar="baz"].qux', { "foo": [ {"bar": "baz"}, {"bar": "bizzle"}, ] }, {"foo": [{"bar": "baz", "qux": 42}, {"bar": "bizzle"}]}, ), ("[1].foo", [{"foo": 1}, {"bar": 2}], [{"foo": 1}, {"foo": 42, "bar": 2}]), ), ) def test_update_or_create(string, initial_data, expected_result): jsonpath = parse(string) result = jsonpath.update_or_create(initial_data, 42) assert result == expected_result @pytest.mark.parametrize( "string, initial_data, expectation", ( # Slice not supported ("foo[0:1]", {}, does_not_raise()), # # Filter does not create items to meet criteria ('foo[?bar="baz"].qux', {}, does_not_raise()), # # Does not convert initial data to a dictionary ("foo", [], pytest.raises(TypeError)), ), ) def test_unsupported_classes(string, initial_data, expectation): copied_initial_data = copy.copy(initial_data) jsonpath = parse(string) with expectation: result = jsonpath.update_or_create(initial_data, 42) assert result != copied_initial_data jsonpath-ng-1.8.0/tests/test_examples.py000066400000000000000000000052311514733354600203550ustar00rootroot00000000000000import pytest from jsonpath_ng.ext import parse from jsonpath_ng.ext.filter import Expression, Filter from jsonpath_ng.jsonpath import Child, Descendants, Fields, Index, Root, Slice, This @pytest.mark.parametrize( "string, parsed", [ # The authors of all books in the store ( "$.store.book[*].author", Child( Child(Child(Child(Root(), Fields("store")), Fields("book")), Slice()), Fields("author"), ), ), # # All authors ("$..author", Descendants(Root(), Fields("author"))), # # All things in the store ("$.store.*", Child(Child(Root(), Fields("store")), Fields("*"))), # # The price of everything in the store ( "$.store..price", Descendants(Child(Root(), Fields("store")), Fields("price")), ), # # The third book ("$..book[2]", Child(Descendants(Root(), Fields("book")), Index(2))), # # The last book in order # "$..book[(@.length-1)]" # Not implemented ("$..book[-1:]", Child(Descendants(Root(), Fields("book")), Slice(start=-1))), # # The first two books ("$..book[0,1]", Child(Descendants(Root(), Fields("book")), Index(0,1))), ("$..book[:2]", Child(Descendants(Root(), Fields("book")), Slice(end=2))), # # Categories and authors of all books ( "$..book[0][category,author]", Child(Child(Descendants(Root(), Fields('book')), Index(0)), Fields('category','author')), ), # # Filter all books with an ISBN ( "$..book[?(@.isbn)]", Child( Descendants(Root(), Fields("book")), Filter([Expression(Child(This(), Fields("isbn")), None, None)]), ), ), # # Filter all books cheaper than 10 ( "$..book[?(@.price<10)]", Child( Descendants(Root(), Fields("book")), Filter([Expression(Child(This(), Fields("price")), "<", 10)]), ), ), # # All members of JSON structure ("$..*", Descendants(Root(), Fields("*"))), ], ) def test_goessner_examples(string, parsed): """ Test Stefan Goessner's `examples`_ .. _examples: https://goessner.net/articles/JsonPath/index.html#e3 """ assert parse(string, debug=True) == parsed def test_attribute_and_dict_syntax(): """Verify that attribute and dict syntax result in identical parse trees.""" assert parse("$.store.book[0].title") == parse("$['store']['book'][0]['title']") jsonpath-ng-1.8.0/tests/test_exceptions.py000066400000000000000000000013311514733354600207150ustar00rootroot00000000000000import pytest from jsonpath_ng import parse as base_parse from jsonpath_ng.exceptions import JsonPathParserError from jsonpath_ng.ext import parse as ext_parse @pytest.mark.parametrize( "path", ( "foo[*.bar.baz", "foo.bar.`grandparent`.baz", "foo[*", # `len` extension not available in the base parser "foo.bar.`len`", ), ) def test_rw_exception_subclass(path): with pytest.raises(JsonPathParserError): base_parse(path) @pytest.mark.parametrize( "path", ( "foo[*.bar.baz", "foo.bar.`grandparent`.baz", "foo[*", ), ) def test_ext_exception_subclass(path): with pytest.raises(JsonPathParserError): ext_parse(path) jsonpath-ng-1.8.0/tests/test_jsonpath.py000066400000000000000000000276711514733354600204010ustar00rootroot00000000000000import copy import pytest from typing import Callable from jsonpath_ng.ext.parser import parse as ext_parse from jsonpath_ng.jsonpath import DatumInContext, Fields, Root, This from jsonpath_ng.lexer import JsonPathLexerError from jsonpath_ng.parser import parse as base_parse from jsonpath_ng import JSONPath from .helpers import assert_full_path_equality, assert_value_equality @pytest.mark.parametrize( "path_arg, context_arg, expected_path, expected_full_path", ( (None, None, This(), This()), (Root(), None, Root(), Root()), (Fields("foo"), "unimportant", Fields("foo"), Fields("foo")), ( Fields("foo"), DatumInContext("unimportant", path=Fields("baz"), context="unimportant"), Fields("foo"), Fields("baz").child(Fields("foo")), ), ), ) def test_datumincontext_init(path_arg, context_arg, expected_path, expected_full_path): datum = DatumInContext(3, path=path_arg, context=context_arg) assert datum.path == expected_path assert datum.full_path == expected_full_path def test_datumincontext_in_context(): d1 = DatumInContext(3, path=Fields("foo"), context=DatumInContext("bar")) d2 = DatumInContext(3).in_context(path=Fields("foo"), context=DatumInContext("bar")) assert d1 == d2 def test_datumincontext_in_context_nested(): sequential_calls = ( DatumInContext(3) .in_context(path=Fields("foo"), context="whatever") .in_context(path=Fields("baz"), context="whatever") ) nested_calls = DatumInContext(3).in_context( path=Fields("foo"), context=DatumInContext("whatever").in_context( path=Fields("baz"), context="whatever" ), ) assert sequential_calls == nested_calls parsers = pytest.mark.parametrize( "parse", ( pytest.param(base_parse, id="parse=jsonpath_ng.parser.parse"), pytest.param(ext_parse, id="parse=jsonpath_ng.ext.parser.parse"), ), ) update_test_cases = ( # # Fields # ------ # ("foo", {"foo": 1}, 5, {"foo": 5}), ("$.*", {"foo": 1, "bar": 2}, 3, {"foo": 3, "bar": 3}), # # Indexes # ------- # ("[0]", ["foo", "bar", "baz"], "test", ["test", "bar", "baz"]), ("[0, 1]", ["foo", "bar", "baz"], "test", ["test", "test", "baz"]), ("[0, 1]", ["foo", "bar", "baz"], ["test", "test 1"], ["test", "test 1", "baz"]), # # Slices # ------ # ("[0:2]", ["foo", "bar", "baz"], "test", ["test", "test", "baz"]), # # Root # ---- # ("$", "foo", "bar", "bar"), # # This # ---- # ("`this`", "foo", "bar", "bar"), # # Children # -------- # ("$.foo", {"foo": "bar"}, "baz", {"foo": "baz"}), ("foo.bar", {"foo": {"bar": 1}}, "baz", {"foo": {"bar": "baz"}}), # # Descendants # ----------- # ("$..somefield", {"somefield": 1}, 42, {"somefield": 42}), ( "$..nestedfield", {"outer": {"nestedfield": 1}}, 42, {"outer": {"nestedfield": 42}}, ), ( "$..bar", {"outs": {"bar": 1, "ins": {"bar": 9}}, "outs2": {"bar": 2}}, 42, {"outs": {"bar": 42, "ins": {"bar": 42}}, "outs2": {"bar": 42}}, ), # # Where # ----- # ( "*.bar where baz", {"foo": {"bar": {"baz": 1}}, "bar": {"baz": 2}}, 5, {"foo": {"bar": 5}, "bar": {"baz": 2}}, ), ( "(* where flag) .. bar", {"foo": {"bar": 1, "flag": 1}, "baz": {"bar": 2}}, 3, {"foo": {"bar": 3, "flag": 1}, "baz": {"bar": 2}}, ), # # WhereNot # -------- # ( '(* wherenot flag) .. bar', {'foo': {'bar': 1, 'flag': 1}, 'baz': {'bar': 2}}, 4, {'foo': {'bar': 1, 'flag': 1}, 'baz': {'bar': 4}}, ), # # Lambdas # ------- # ( "foo[*].baz", {'foo': [{'baz': 1}, {'baz': 2}]}, lambda x, y, z: x + 1, {'foo': [{'baz': 2}, {'baz': 3}]} ), # # Update with Boolean in data # --------------------------- # ( "$.*.number", {'foo': ['abc', 'def'], 'bar': {'number': 123456}, 'boolean': True}, '98765', {'foo': ['abc', 'def'], 'bar': {'number': '98765'}, 'boolean': True}, ), ) @pytest.mark.parametrize( "expression, data, update_value, expected_value", update_test_cases, ) @parsers def test_update(parse: Callable[[str], JSONPath], expression: str, data, update_value, expected_value): data_copy = copy.deepcopy(data) update_value_copy = copy.deepcopy(update_value) result = parse(expression).update(data_copy, update_value_copy) assert result == expected_value # inplace update testing data_copy2 = copy.deepcopy(data) update_value_copy2 = copy.deepcopy(update_value) datums = parse(expression).find(data_copy2) batch_update = isinstance(update_value, list) and len(datums) == len(update_value) for i, datum in enumerate(datums): if batch_update: datum.value = update_value_copy2[i] else: datum.value = update_value_copy2 if isinstance(datum.full_path, (Root, This)): # when the type of `data` is str, int, float etc. data_copy2 = datum.value assert data_copy2 == expected_value filter_test_cases = ( # Docs examples ("foo[*].baz", {'foo': [{'baz': 1}, {'baz': 2}]}, lambda d: True, {'foo': [{}, {}]}), ("foo[*].baz", {'foo': [{'baz': 1}, {'baz': 2}]}, lambda d: d == 2, {'foo': [{'baz': 1}, {}]}), # Wildcard issue fix ("*.baz", {"flag": False, "foo": {"bar": 1, "baz": 2}}, lambda d: True, {"flag": False, "foo": {"bar": 1}}), ) @pytest.mark.parametrize( "expression, data, filter_function, expected_value", filter_test_cases, ) @parsers def test_filter(parse: Callable[[str], JSONPath], expression: str, data, filter_function: Callable, expected_value): data_copy = copy.deepcopy(data) parse(expression).filter(filter_function, data_copy) assert data_copy == expected_value find_test_cases = ( # # * (star) # -------- # ("*", {"foo": 1, "baz": 2}, {1, 2}, {"foo", "baz"}), # # Fields # ------ # ("foo", {"foo": "baz"}, ["baz"], ["foo"]), ("foo,baz", {"foo": 1, "baz": 2}, [1, 2], ["foo", "baz"]), ("@foo", {"@foo": 1}, [1], ["@foo"]), # # Roots # ----- # ("$", {"foo": "baz"}, [{"foo": "baz"}], ["$"]), ("foo.$", {"foo": "baz"}, [{"foo": "baz"}], ["$"]), ("foo.$.foo", {"foo": "baz"}, ["baz"], ["foo"]), # # This # ---- # ("`this`", {"foo": "baz"}, [{"foo": "baz"}], ["`this`"]), ("foo.`this`", {"foo": "baz"}, ["baz"], ["foo"]), ("foo.`this`.baz", {"foo": {"baz": 3}}, [3], ["(foo.baz)"]), # # Indexes # ------- # ("[0]", [42], [42], ["[0]"]), ("[5]", [42], [], []), ("[2]", [34, 65, 29, 59], [29], ["[2]"]), ("[0]", None, [], []), # # Slices # ------ # ("[*]", [1, 2, 3], [1, 2, 3], ["[0]", "[1]", "[2]"]), ("[*]", range(1, 4), [1, 2, 3], ["[0]", "[1]", "[2]"]), ("[1:]", [1, 2, 3, 4], [2, 3, 4], ["[1]", "[2]", "[3]"]), ("[1:3]", [1, 2, 3, 4], [2, 3], ["[1]", "[2]"]), ("[:2]", [1, 2, 3, 4], [1, 2], ["[0]", "[1]"]), ("[:3:2]", [1, 2, 3, 4], [1, 3], ["[0]", "[2]"]), ("[1::2]", [1, 2, 3, 4], [2, 4], ["[1]", "[3]"]), ("[1:6:3]", range(1, 10), [2, 5], ["[1]", "[4]"]), ("[::-2]", [1, 2, 3, 4, 5], [5, 3, 1], ["[4]", "[2]", "[0]"]), # # Slices (funky hacks) # -------------------- # ("[*]", 1, [1], ["[0]"]), ("[*]", 1.2, [1.2], ["[0]"]), ("[*]", True, [True], ["[0]"]), ("[*]", False, [False], ["[0]"]), ("[*]", "test", ["test"], ["[0]"]), ("[*]", None, [], []), ("[0:]", 1, [1], ["[0]"]), ("[*]", {"foo": 1}, [{"foo": 1}], ["[0]"]), ("[*].foo", {"foo": 1}, [1], ["([0].foo)"]), # # Children # -------- # ("foo.baz", {"foo": {"baz": 3}}, [3], ["(foo.baz)"]), ("foo.baz", {"foo": {"baz": [3]}}, [[3]], ["(foo.baz)"]), ("foo.baz.qux", {"foo": {"baz": {"qux": 5}}}, [5], ["((foo.baz).qux)"]), # # Descendants # ----------- # ( "foo..baz", {"foo": {"baz": 1, "bing": {"baz": 2}}}, [1, 2], ["(foo.baz)", "((foo.bing).baz)"], ), ( "foo..baz", {"foo": [{"baz": 1}, {"baz": 2}]}, [1, 2], ["((foo.[0]).baz)", "((foo.[1]).baz)"], ), # # Parents # ------- # ("foo.baz.`parent`", {"foo": {"baz": 3}}, [{"baz": 3}], ["foo"]), ( "foo.`parent`.foo.baz.`parent`.baz.qux", {"foo": {"baz": {"qux": 5}}}, [5], ["((foo.baz).qux)"], ), # # Hyphens # ------- # ("foo.bar-baz", {"foo": {"bar-baz": 3}}, [3], ["(foo.bar-baz)"]), ( "foo.[bar-baz,blah-blah]", {"foo": {"bar-baz": 3, "blah-blah": 5}}, [3, 5], ["(foo.bar-baz)", "(foo.blah-blah)"], ), # # Literals # -------- # ("A.'a.c'", {"A": {"a.c": "d"}}, ["d"], ["(A.'a.c')"]), # # Numeric keys # -------- # ("1", {"1": "foo"}, ["foo"], ["'1'"]), ) @pytest.mark.parametrize( "path, data, expected_values, expected_full_paths", find_test_cases ) @parsers def test_find(parse, path, data, expected_values, expected_full_paths): results = parse(path).find(data) # Verify result values and full paths match expectations. assert_value_equality(results, expected_values) assert_full_path_equality(results, expected_full_paths) find_test_cases_with_auto_id = ( # # * (star) # -------- # ("*", {"foo": 1, "baz": 2}, {1, 2, "`this`"}), # # Fields # ------ # ("foo.id", {"foo": "baz"}, ["foo"]), ("foo.id", {"foo": {"id": "baz"}}, ["baz"]), ("foo,baz.id", {"foo": 1, "baz": 2}, ["foo", "baz"]), ("*.id", {"foo": {"id": 1}, "baz": 2}, {"'1'", "baz"}), # # Roots # ----- # ("$.id", {"foo": "baz"}, ["$"]), ("foo.$.id", {"foo": "baz", "id": "bizzle"}, ["bizzle"]), ("foo.$.baz.id", {"foo": 4, "baz": 3}, ["baz"]), # # This # ---- # ("id", {"foo": "baz"}, ["`this`"]), ("foo.`this`.id", {"foo": "baz"}, ["foo"]), ("foo.`this`.baz.id", {"foo": {"baz": 3}}, ["(foo.baz)"]), # # Indexes # ------- # ("[0].id", [42], ["[0]"]), ("[2].id", [34, 65, 29, 59], ["[2]"]), # # Slices # ------ # ("[*].id", [1, 2, 3], ["[0]", "[1]", "[2]"]), ("[1:].id", [1, 2, 3, 4], ["[1]", "[2]", "[3]"]), # # Children # -------- # ("foo.baz.id", {"foo": {"baz": 3}}, ["(foo.baz)"]), ("foo.baz.id", {"foo": {"baz": [3]}}, ["(foo.baz)"]), ("foo.baz.id", {"foo": {"id": "bizzle", "baz": 3}}, ["(bizzle.baz)"]), ("foo.baz.id", {"foo": {"baz": {"id": "hi"}}}, ["(foo.hi)"]), ("foo.baz.bizzle.id", {"foo": {"baz": {"bizzle": 5}}}, ["((foo.baz).bizzle)"]), # # Descendants # ----------- # ( "foo..baz.id", {"foo": {"baz": 1, "bing": {"baz": 2}}}, ["(foo.baz)", "((foo.bing).baz)"], ), ) @pytest.mark.parametrize("path, data, expected_values", find_test_cases_with_auto_id) @parsers def test_find_values_auto_id(auto_id_field, parse, path, data, expected_values): result = parse(path).find(data) assert_value_equality(result, expected_values) @parsers def test_find_full_paths_auto_id(auto_id_field, parse): results = parse("*").find({"foo": 1, "baz": 2}) assert_full_path_equality(results, {"foo", "baz", "id"}) @pytest.mark.parametrize( "string, target", ( ("m.[1].id", ["(('1'.m).a2id)"]), ("m.[1].$.b.id", ["('1'.bid)"]), ("m.[0].id", ["(('1'.m).[0])"]), ), ) @parsers def test_nested_index_auto_id(auto_id_field, parse, string, target): data = { "id": 1, "b": {"id": "bid", "name": "bob"}, "m": [{"a": "a1"}, {"a": "a2", "id": "a2id"}], } result = parse(string).find(data) assert_value_equality(result, target) def test_invalid_hyphenation_in_key(): with pytest.raises(JsonPathLexerError): base_parse("foo.-baz") jsonpath-ng-1.8.0/tests/test_jsonpath_rw_ext.py000066400000000000000000000345011514733354600217570ustar00rootroot00000000000000""" test_jsonpath_ng_ext ---------------------------------- Tests for `jsonpath_ng_ext` module. """ import pytest from jsonpath_ng.exceptions import JsonPathParserError from jsonpath_ng.ext import parser from .helpers import assert_value_equality test_cases = ( pytest.param( "objects.`sorted`", {"objects": ["alpha", "gamma", "beta"]}, [["alpha", "beta", "gamma"]], id="sorted_list", ), pytest.param( "objects.`sorted`[1]", {"objects": ["alpha", "gamma", "beta"]}, "beta", id="sorted_list_indexed", ), pytest.param( "objects.`sorted`", {"objects": {"cow": "moo", "horse": "neigh", "cat": "meow"}}, [["cat", "cow", "horse"]], id="sorted_dict", ), pytest.param( "objects.`sorted`[0]", {"objects": {"cow": "moo", "horse": "neigh", "cat": "meow"}}, "cat", id="sorted_dict_indexed", ), pytest.param( "objects.`len`", {"objects": ["alpha", "gamma", "beta"]}, 3, id="len_list" ), pytest.param( "objects.`len`", {"objects": {"cow": "moo", "cat": "neigh"}}, 2, id="len_dict" ), pytest.param("objects[0].`len`", {"objects": ["alpha", "gamma"]}, 5, id="len_str"), pytest.param( 'objects[?@="alpha"]', {"objects": ["alpha", "gamma", "beta"]}, ["alpha"], id="filter_list", ), pytest.param( 'objects[?@ =~ "a.+"]', {"objects": ["alpha", "gamma", "beta"]}, ["alpha", "gamma"], id="filter_list_2", ), pytest.param( 'objects[?@ =~ "a.+"]', {"objects": [1, 2, 3]}, [], id="filter_list_3" ), pytest.param( "objects.`keys`", {"objects": ["alpha", "gamma", "beta"]}, [], id="keys_list" ), pytest.param( "objects.`keys`", {"objects": {"cow": "moo", "cat": "neigh"}}, ["cow", "cat"], id="keys_dict", ), pytest.param( "objects.cow.`path`", {"objects": {"cow": "moo", "cat": "neigh"}}, "cow", id="path_dict", ), pytest.param( "objects[?cow]", {"objects": [{"cow": "moo"}, {"cat": "neigh"}]}, [{"cow": "moo"}], id="filter_exists_syntax1", ), pytest.param( "objects[?@.cow]", {"objects": [{"cow": "moo"}, {"cat": "neigh"}]}, [{"cow": "moo"}], id="filter_exists_syntax2", ), pytest.param( "objects[?(@.cow)]", {"objects": [{"cow": "moo"}, {"cat": "neigh"}]}, [{"cow": "moo"}], id="filter_exists_syntax3", ), pytest.param( 'objects[?(@."cow!?cat")]', {"objects": [{"cow!?cat": "moo"}, {"cat": "neigh"}]}, [{"cow!?cat": "moo"}], id="filter_exists_syntax4", ), pytest.param( 'objects[?cow="moo"]', {"objects": [{"cow": "moo"}, {"cow": "neigh"}, {"cat": "neigh"}]}, [{"cow": "moo"}], id="filter_eq1", ), pytest.param( 'objects[?(@.["cow"]="moo")]', {"objects": [{"cow": "moo"}, {"cow": "neigh"}, {"cat": "neigh"}]}, [{"cow": "moo"}], id="filter_eq2", ), pytest.param( 'objects[?cow=="moo"]', {"objects": [{"cow": "moo"}, {"cow": "neigh"}, {"cat": "neigh"}]}, [{"cow": "moo"}], id="filter_eq3", ), pytest.param( "objects[?cow>5]", {"objects": [{"cow": 8}, {"cow": 7}, {"cow": 5}, {"cow": "neigh"}]}, [{"cow": 8}, {"cow": 7}], id="filter_gt", ), pytest.param( "objects[?cow>5&cat=2]", { "objects": [ {"cow": 8, "cat": 2}, {"cow": 7, "cat": 2}, {"cow": 2, "cat": 2}, {"cow": 5, "cat": 3}, {"cow": 8, "cat": 3}, ] }, [{"cow": 8, "cat": 2}, {"cow": 7, "cat": 2}], id="filter_and", ), pytest.param( "objects[?confidence>=0.5].prediction", { "objects": [ {"confidence": 0.42, "prediction": "Good"}, {"confidence": 0.58, "prediction": "Bad"}, ] }, ["Bad"], id="filter_float_gt", ), pytest.param( "objects[/cow]", { "objects": [ {"cat": 1, "cow": 2}, {"cat": 2, "cow": 1}, {"cat": 3, "cow": 3}, ] }, [[{"cat": 2, "cow": 1}, {"cat": 1, "cow": 2}, {"cat": 3, "cow": 3}]], id="sort1", ), pytest.param( "objects[/cow][0].cat", { "objects": [ {"cat": 1, "cow": 2}, {"cat": 2, "cow": 1}, {"cat": 3, "cow": 3}, ] }, 2, id="sort1_indexed", ), pytest.param( "objects[\\cat]", {"objects": [{"cat": 2}, {"cat": 1}, {"cat": 3}]}, [[{"cat": 3}, {"cat": 2}, {"cat": 1}]], id="sort2", ), pytest.param( "objects[\\cat][-1].cat", {"objects": [{"cat": 2}, {"cat": 1}, {"cat": 3}]}, 1, id="sort2_indexed", ), pytest.param( "objects[/cow,\\cat]", { "objects": [ {"cat": 1, "cow": 2}, {"cat": 2, "cow": 1}, {"cat": 3, "cow": 1}, {"cat": 3, "cow": 3}, ] }, [ [ {"cat": 3, "cow": 1}, {"cat": 2, "cow": 1}, {"cat": 1, "cow": 2}, {"cat": 3, "cow": 3}, ] ], id="sort3", ), pytest.param( "objects[/cow,\\cat][0].cat", { "objects": [ {"cat": 1, "cow": 2}, {"cat": 2, "cow": 1}, {"cat": 3, "cow": 1}, {"cat": 3, "cow": 3}, ] }, 3, id="sort3_indexed", ), pytest.param( "objects[/cat.cow]", { "objects": [ {"cat": {"dog": 1, "cow": 2}}, {"cat": {"dog": 2, "cow": 1}}, {"cat": {"dog": 3, "cow": 3}}, ] }, [ [ {"cat": {"dog": 2, "cow": 1}}, {"cat": {"dog": 1, "cow": 2}}, {"cat": {"dog": 3, "cow": 3}}, ] ], id="sort4", ), pytest.param( "objects[/cat.cow][0].cat.dog", { "objects": [ {"cat": {"dog": 1, "cow": 2}}, {"cat": {"dog": 2, "cow": 1}}, {"cat": {"dog": 3, "cow": 3}}, ] }, 2, id="sort4_indexed", ), pytest.param( "objects[/cat.(cow,bow)]", { "objects": [ {"cat": {"dog": 1, "bow": 3}}, {"cat": {"dog": 2, "cow": 1}}, {"cat": {"dog": 2, "bow": 2}}, {"cat": {"dog": 3, "cow": 2}}, ] }, [ [ {"cat": {"dog": 2, "cow": 1}}, {"cat": {"dog": 2, "bow": 2}}, {"cat": {"dog": 3, "cow": 2}}, {"cat": {"dog": 1, "bow": 3}}, ] ], id="sort5_twofields", ), pytest.param( "objects[/cat.(cow,bow)][0].cat.dog", { "objects": [ {"cat": {"dog": 1, "bow": 3}}, {"cat": {"dog": 2, "cow": 1}}, {"cat": {"dog": 2, "bow": 2}}, {"cat": {"dog": 3, "cow": 2}}, ] }, 2, id="sort5_indexed", ), pytest.param("3 * 3", {}, [9], id="arithmetic_number_only"), pytest.param("$.foo * 10", {"foo": 4}, [40], id="arithmetic_mul1"), pytest.param("10 * $.foo", {"foo": 4}, [40], id="arithmetic_mul2"), pytest.param("$.foo * 10", {"foo": 4}, [40], id="arithmetic_mul3"), pytest.param("$.foo * 3", {"foo": "f"}, ["fff"], id="arithmetic_mul4"), pytest.param("foo * 3", {"foo": "f"}, ["foofoofoo"], id="arithmetic_mul5"), pytest.param("($.foo * 10 * $.foo) + 2", {"foo": 4}, [162], id="arithmetic_mul6"), pytest.param("$.foo * 10 * $.foo + 2", {"foo": 4}, [240], id="arithmetic_mul7"), pytest.param( "foo + bar", {"foo": "name", "bar": "node"}, ["foobar"], id="arithmetic_str0" ), pytest.param( 'foo + "_" + bar', {"foo": "name", "bar": "node"}, ["foo_bar"], id="arithmetic_str1", ), pytest.param( '$.foo + "_" + $.bar', {"foo": "name", "bar": "node"}, ["name_node"], id="arithmetic_str2", ), pytest.param( "$.foo + $.bar", {"foo": "name", "bar": "node"}, ["namenode"], id="arithmetic_str3", ), pytest.param( "foo.cow + bar.cow", {"foo": {"cow": "name"}, "bar": {"cow": "node"}}, ["namenode"], id="arithmetic_str4", ), pytest.param( "$.objects[*].cow * 2", {"objects": [{"cow": 1}, {"cow": 2}, {"cow": 3}]}, [2, 4, 6], id="arithmetic_list1", ), pytest.param( "$.objects[*].cow * $.objects[*].cow", {"objects": [{"cow": 1}, {"cow": 2}, {"cow": 3}]}, [1, 4, 9], id="arithmetic_list2", ), pytest.param( "$.objects[*].cow * $.objects2[*].cow", {"objects": [{"cow": 1}, {"cow": 2}, {"cow": 3}], "objects2": [{"cow": 5}]}, [], id="arithmetic_list_err1", ), pytest.param('$.objects * "foo"', {"objects": []}, [], id="arithmetic_err1"), pytest.param('"bar" * "foo"', {}, [], id="arithmetic_err2"), pytest.param( "payload.metrics[?(@.name='cpu.frequency')].value * 100", { "payload": { "metrics": [ { "timestamp": "2013-07-29T06:51:34.472416", "name": "cpu.frequency", "value": 1600, "source": "libvirt.LibvirtDriver", }, { "timestamp": "2013-07-29T06:51:34.472416", "name": "cpu.user.time", "value": 17421440000000, "source": "libvirt.LibvirtDriver", }, ] } }, [160000], id="real_life_example1", ), pytest.param( "payload.(id|(resource.id))", {"payload": {"id": "foobar"}}, ["foobar"], id="real_life_example2", ), pytest.param( "payload.id|(resource.id)", {"payload": {"resource": {"id": "foobar"}}}, ["foobar"], id="real_life_example3", ), pytest.param( "payload.id|(resource.id)", {"payload": {"id": "yes", "resource": {"id": "foobar"}}}, ["yes", "foobar"], id="real_life_example4", ), pytest.param( "payload.`sub(/(foo\\\\d+)\\\\+(\\\\d+bar)/, \\\\2-\\\\1)`", {"payload": "foo5+3bar"}, ["3bar-foo5"], id="sub1", ), pytest.param( "payload.`sub(/foo\\\\+bar/, repl)`", {"payload": "foo+bar"}, ["repl"], id="sub2", ), pytest.param("payload.`str()`", {"payload": 1}, ["1"], id="str1"), pytest.param( "payload.`split(-, 2, -1)`", {"payload": "foo-bar-cat-bow"}, ["cat"], id="split1", ), pytest.param( "payload.`split(-, 2, 2)`", {"payload": "foo-bar-cat-bow"}, ["cat-bow"], id="split2", ), pytest.param( "payload.`split(',', 2, -1)`", {"payload": "foo,bar,baz"}, ["baz"], id="split3", ), pytest.param( 'payload.`split(", ", 2, -1)`', {"payload": "foo, bar, baz"}, ["baz"], id="split4", ), pytest.param( 'payload.`split(", ", *, -1)`', {"payload": "foo, bar, baz"}, [["foo", "bar", "baz"]], id="split5", ), pytest.param( 'payload.`split(", ", -1, -1)`', {"payload": "foo, bar, baz"}, ["baz"], id="split6", ), pytest.param( "payload.`split(|, -1, 1)`", {"payload": "foo|bar|baz"}, ["bar|baz"], id="split7", ), pytest.param( "foo[?(@.baz==1)]", {"foo": [{"baz": 1}, {"baz": 2}]}, [{"baz": 1}], id="bug-#2-correct", ), pytest.param( "foo[*][?(@.baz==1)]", {"foo": [{"baz": 1}, {"baz": 2}]}, [], id="bug-#2-wrong" ), pytest.param( "foo[?flag = true].color", { "foo": [ {"color": "blue", "flag": True}, {"color": "green", "flag": False}, ] }, ["blue"], id="boolean-filter-true", ), pytest.param( "foo[?flag = false].color", { "foo": [ {"color": "blue", "flag": True}, {"color": "green", "flag": False}, ] }, ["green"], id="boolean-filter-false", ), pytest.param( "foo[?flag = true].color", { "foo": [ {"color": "blue", "flag": True}, {"color": "green", "flag": 2}, {"color": "red", "flag": "hi"}, ] }, ["blue"], id="boolean-filter-other-datatypes-involved", ), pytest.param( 'foo[?flag = "true"].color', { "foo": [ {"color": "blue", "flag": True}, {"color": "green", "flag": "true"}, ] }, ["green"], id="boolean-filter-string-true-string-literal", ), pytest.param( "foo[?flag = true].color", { "foo": [ {"color": "blue", "flag": True}, {"color": "green", "flag": 2}, {"color": "red", "flag": "hi"}, {"color": "gray", "flag": None}, ] }, ["blue"], id="boolean-filter-with-null", ), ) @pytest.mark.parametrize("path, data, expected_values", test_cases) def test_values(path, data, expected_values): results = parser.parse(path).find(data) assert_value_equality(results, expected_values) def test_invalid_hyphenation_in_key(): # This test is almost copied-and-pasted directly from `test_jsonpath.py`. # However, the parsers generate different exceptions for this syntax error. # This discrepancy needs to be resolved. with pytest.raises(JsonPathParserError): parser.parse("foo.-baz") jsonpath-ng-1.8.0/tests/test_lexer.py000066400000000000000000000033421514733354600176570ustar00rootroot00000000000000import pytest from jsonpath_ng.lexer import JsonPathLexer, JsonPathLexerError token_test_cases = ( ("$", (("$", "$"),)), ('"hello"', (("hello", "ID"),)), ("'goodbye'", (("goodbye", "ID"),)), ("'doublequote\"'", (('doublequote"', "ID"),)), (r'"doublequote\""', (('doublequote"', "ID"),)), (r"'singlequote\''", (("singlequote'", "ID"),)), ('"singlequote\'"', (("singlequote'", "ID"),)), ("fuzz", (("fuzz", "ID"),)), ("1", ((1, "NUMBER"),)), ("45", ((45, "NUMBER"),)), ("-1", ((-1, "NUMBER"),)), (" -13 ", ((-13, "NUMBER"),)), ('"fuzz.bang"', (("fuzz.bang", "ID"),)), ("fuzz.bang", (("fuzz", "ID"), (".", "."), ("bang", "ID"))), ("fuzz.*", (("fuzz", "ID"), (".", "."), ("*", "*"))), ("fuzz..bang", (("fuzz", "ID"), ("..", "DOUBLEDOT"), ("bang", "ID"))), ("&", (("&", "&"),)), ("@", (("@", "ID"),)), ("`this`", (("this", "NAMED_OPERATOR"),)), ("|", (("|", "|"),)), ("where", (("where", "WHERE"),)), ("wherenot", (("wherenot", "WHERENOT"),)), ) @pytest.mark.parametrize("string, expected_token_info", token_test_cases) def test_lexer(string, expected_token_info): lexer = JsonPathLexer(debug=True) tokens = list(lexer.tokenize(string)) assert len(tokens) == len(expected_token_info) for token, (expected_value, expected_type) in zip(tokens, expected_token_info): assert token.type == expected_type assert token.value == expected_value invalid_token_test_cases = ( "'\"", "\"'", '`"', "`'", '"`', "'`", "?", "$.foo.bar.#", ) @pytest.mark.parametrize("string", invalid_token_test_cases) def test_lexer_errors(string): with pytest.raises(JsonPathLexerError): list(JsonPathLexer().tokenize(string)) jsonpath-ng-1.8.0/tests/test_parser.py000066400000000000000000000025111514733354600200310ustar00rootroot00000000000000import pytest from jsonpath_ng.jsonpath import Child, Descendants, Fields, Index, Slice, Where, WhereNot from jsonpath_ng.lexer import JsonPathLexer from jsonpath_ng.parser import JsonPathParser # Format: (string, expected_object) parser_test_cases = ( # # Atomic # ------ # ("😀", Fields("😀")), ("你好", Fields("你好")), ("foo", Fields("foo")), ("*", Fields("*")), ("1", Fields("1")), ("baz,bizzle", Fields("baz", "bizzle")), ("[1]", Index(1)), ("[1:]", Slice(start=1)), ("[:]", Slice()), ("[*]", Slice()), ("[:2]", Slice(end=2)), ("[1:2]", Slice(start=1, end=2)), ("[5:-2]", Slice(start=5, end=-2)), # # Nested # ------ # ("foo.baz", Child(Fields("foo"), Fields("baz"))), ("foo.baz,bizzle", Child(Fields("foo"), Fields("baz", "bizzle"))), ("foo where baz", Where(Fields("foo"), Fields("baz"))), ("foo wherenot baz", WhereNot(Fields("foo"), Fields("baz"))), ("foo..baz", Descendants(Fields("foo"), Fields("baz"))), ("foo..baz.bing", Descendants(Fields("foo"), Child(Fields("baz"), Fields("bing")))), ) @pytest.mark.parametrize("string, expected_object", parser_test_cases) def test_parser(string, expected_object): parser = JsonPathParser(lexer_class=lambda: JsonPathLexer()) assert parser.parse(string) == expected_object jsonpath-ng-1.8.0/tests/test_roundtrip.py000066400000000000000000000025051514733354600205660ustar00rootroot00000000000000from hypothesis import example, given, settings, strategies as st, assume import jsonpath_ng import jsonpath_ng.exceptions import jsonpath_ng.ext characters = st.characters(min_codepoint=0x20, max_codepoint=0x7e) # space -> tilde ascii_text = st.text(characters) @given(ascii_text) @example("10") @example("0&0") @example("';'") @example('"0@"') @example('"00"') @example(r'"\'"') @example("0..0[0]") @example("(0..0)[0]") @example("0..(0[0])") @example("0..0.[0]") @settings(max_examples=20) def test_roundtrip_basic(string: str): try: parsed_original = jsonpath_ng.parse(string) except jsonpath_ng.exceptions.JSONPathError: assume(False) return reconstituted = str(parsed_original) parsed_reconstituted = jsonpath_ng.parse(reconstituted) assert parsed_original == parsed_reconstituted @given(ascii_text) @example("0-@") @example("0|0") @example("'%'") @example("''") @example("A -A") @example("A -@") @example("0[/0]") @settings(max_examples=20) def test_roundtrip_extended(string: str): try: parsed_original = jsonpath_ng.ext.parse(string) except jsonpath_ng.exceptions.JSONPathError: assume(False) return reconstituted = str(parsed_original) parsed_reconstituted = jsonpath_ng.ext.parse(reconstituted) assert parsed_original == parsed_reconstituted jsonpath-ng-1.8.0/tox.ini000066400000000000000000000014121514733354600152740ustar00rootroot00000000000000[tox] min_version = 4.3.5 envlist = coverage-erase py{3.14, 3.13, 3.12, 3.11, 3.10} coverage-report skip_missing_interpreters = True isolated_build = True [testenv] package = wheel wheel_build_env = build_wheel depends = py{3.14, 3.13, 3.12, 3.11, 3.10}: coverage-erase deps = coverage[toml] hypothesis pytest pytest-randomly commands = coverage run -m pytest [testenv:coverage-erase] no_package = true skip_install = true deps = coverage[toml] commands = coverage erase [testenv:coverage-report] depends = py{3.14, 3.13, 3.12, 3.11, 3.10} no_package = true skip_install = true deps = coverage[toml] commands_pre = - coverage combine commands = coverage report command_post = coverage html --fail-under=0