pax_global_header00006660000000000000000000000064143352266270014524gustar00rootroot0000000000000052 comment=87b8f6d3642dd8731fc7ece523e46cc1ee7b1682 neo4j-python-driver-5.2.1/000077500000000000000000000000001433522662700153605ustar00rootroot00000000000000neo4j-python-driver-5.2.1/.coveragerc000066400000000000000000000004351433522662700175030ustar00rootroot00000000000000[run] branch = True omit = .*/* tests/* neo4j/meta.py *neobolt* *virtualenv* [report] exclude_lines = pragma: no cover def __repr__ if self.debug: raise NotImplementedError if __name__ == .__main__.: except ImportError show_missing = True neo4j-python-driver-5.2.1/.editorconfig000066400000000000000000000006421433522662700200370ustar00rootroot00000000000000# top-most EditorConfig file root = true # Unix-style newlines with a newline ending every file [*] end_of_line = lf insert_final_newline = true charset = utf-8 [*.{py,js,rst,txt,sh,bat}] trim_trailing_whitespace = true [{Makefile,Dockerfile}] trim_trailing_whitespace = true [*.bat] end_of_line = crlf [*{.py,pyi}] indent_style = space indent_size = 4 [*.py] max_line_length = 79 [*.pyi] max_line_length = 130 neo4j-python-driver-5.2.1/.gitignore000066400000000000000000000003641433522662700173530ustar00rootroot00000000000000*~ *.py[co] __pycache__ *.lprof *.class .idea htmlcov .coverage .test .tox .benchmarks .cache .pytest_cache .DS_Store docs/build dist *.egg-info build venv run */run neo4j-community-* neo4j-enterprise-* *.so testkit/CAs testkit/CustomCAs neo4j-python-driver-5.2.1/.gitmodules000066400000000000000000000000001433522662700175230ustar00rootroot00000000000000neo4j-python-driver-5.2.1/.pre-commit-config.yaml000066400000000000000000000024621433522662700216450ustar00rootroot00000000000000# See https://pre-commit.com for more information # See https://pre-commit.com/hooks.html for more hooks repos: - repo: https://github.com/pre-commit/pre-commit-hooks rev: v4.1.0 hooks: - id: check-case-conflict - id: check-docstring-first - id: check-symlinks - id: destroyed-symlinks - id: end-of-file-fixer exclude_types: - image - id: fix-encoding-pragma args: [ --remove ] - id: mixed-line-ending args: [ --fix=lf ] exclude_types: - batch - id: trailing-whitespace args: [ --markdown-linebreak-ext=md ] - repo: https://github.com/pycqa/isort rev: 5.10.1 hooks: - id: isort - repo: https://github.com/sphinx-contrib/sphinx-lint rev: e83a1a42a73284d301c05baaffc176042ffbcf82 hooks: - id: sphinx-lint - repo: local hooks: - id: unasync name: unasync entry: bin/make-unasync language: system files: "^(neo4j/_async|tests/(unit|integration)/async_|testkitbackend/_async)/.*" - id: mypy name: mypy static type check entry: mypy args: [ --show-error-codes, neo4j, tests, testkitbackend ] 'types_or': [ python, pyi ] language: system pass_filenames: false require_serial: true neo4j-python-driver-5.2.1/CHANGELOG.md000066400000000000000000000210541433522662700171730ustar00rootroot00000000000000# Neo4j Driver Change Log (breaking/major changes only) ## Version 5.2 - No breaking or major changes. ## Version 5.1 - No breaking or major changes. ## Version 5.0 - Python 3.10 support added - Python 3.6 support has been dropped. - `Result`, `Session`, and `Transaction` can no longer be imported from `neo4j.work`. They should've been imported from `neo4j` all along. Remark: It's recommended to import everything needed directly from `noe4j` if available, not its submodules or subpackages. - Experimental pipelines feature has been removed. - Async driver (i.e., support for asyncio) has been added. - `ResultSummary.server.version_info` has been removed. Use `ResultSummary.server.agent`, `ResultSummary.server.protocol_version`, or call the `dbms.components` procedure instead. - SSL configuration options have been changed: - `trust` has been deprecated and will be removed in a future release. Use `trusted_certificates` instead. See the API documentation for more details. - `neo4j.time` module: - `Duration` - The constructor does not accept `subseconds` anymore. Use `milliseconds`, `microseconds`, or `nanoseconds` instead. - The property `subseconds` has been removed. Use `nanoseconds` instead. - The property `hours_minutes_seconds` has been removed. Use `hours_minutes_seconds_nanoseconds` instead. - For all math operations holds: they are element-wise on (`months`, `days`, `nanoseconds`). This affects (i.e., changes) the working of `//`, `%`, `/`, and `*`. - Years are equal to 12 months. - Weeks are equal to 7 days. - `seconds`, `milliseconds`, `microseconds`, and `nanoseconds` are implicitly converted to `nanoseconds` or `seconds` as fit. - Multiplication and division allow for floats but will always result in integer values (round to nearest even). - `Time` - The constructor does not accept `float`s for `second` anymore. Use `nanosecond` instead. - Ticks are now nanoseconds since midnight (`int`). - The property `ticks_ns` has been renamed to `ticks`. The old `ticks` is no longer supported. - The property`from_ticks_ns` has been renamed to `from_ticks`. The old `from_ticks` is no longer supported. - The property `second` returns an `int` instead of a `float`. Use `nanosecond` to get the sub-second information. - The property `hour_minute_second` has been removed. Use `hour_minute_second_nanosecond` instead. - `DateTime` - The property `hour_minute_second` has been removed. Use `hour_minute_second_nanosecond` instead. - The property `second` returns an `int` instead of a `float`. Use `nanosecond` to get the sub-second information. - Creation of a driver with `bolt[+s[sc]]://` scheme and a routing context has been deprecated and will raise an error in the Future. The routing context was and will be silently ignored until then. - Bookmarks - `Session.last_bookmark` was deprecated. Its behaviour is partially incorrect and cannot be fixed without breaking its signature. Use `Session.last_bookmarks` instead. - `neo4j.Bookmark` was deprecated. Use `neo4j.Bookmarks` instead. - Deprecated closing of driver and session objects in their destructor. This behaviour is non-deterministic as there is no guarantee that the destructor will ever be called. A `ResourceWarning` is emitted instead. Make sure to configure Python to output those warnings when developing your application locally (it does not by default). - Result scope: - Records of Results cannot be accessed (`peek`, `single`, `iter`, ...) after their owning transaction has been closed, committed, or rolled back. Previously, this would yield undefined behavior. It now raises a `ResultConsumedError`. - Records of Results cannot be accessed (`peek`, `single`, `iter`, ...) after the Result has been consumed (`Result.consume()`). Previously, this would always yield no records. It now raises a `ResultConsumedError`. - New method `Result.closed()` can be used to check for this condition if necessary. - The undocumented return value of `driver.verify_connectivity()` has been removed. If you need information about the remote server, use `driver.get_server_info()` instead. - Transaction functions (a.k.a. managed transactions): The first argument of transaction functions is now a `ManagedTransaction` object. It behaves exactly like a regular `Transaction` object, except it does not offer the `commit`, `rollback`, `close`, and `closed` methods. Those methods would have caused a hard to interpreted error previously. Hence, they have been removed. - Deprecated Nodes' and Relationships' `id` property (`int`) in favor of `element_id` (`str`). This also affects `Graph` objects as indexing `graph.nodes[...]` and `graph.relationships[...]` with integers has been deprecated in favor of indexing them with strings. - `ServerInfo.connection_id` has been deprecated and will be removed in a future release. There is no replacement as this is considered internal information. - Output of logging helper `neo4j.debug.watch` changes - ANSI colour codes for log output are now opt-in - Prepend log format with log-level (if colours are disabled) - Prepend log format with thread name and id - Deprecated `neo4j.exceptions.Neo4jError.is_retriable()`. Use `neo4j.exceptions.Neo4jError.is_retryable()` instead. - Importing submodules from `neo4j.time` (`neo4j.time.xyz`) has been deprecated. Everything needed should be imported from `neo4j.time` directly. - `neo4j.spatial.hydrate_point` and `neo4j.spatial.dehydrate_point` have been deprecated without replacement. They are internal functions. - Importing `neo4j.packstream` has been deprecated. It's internal and should not be used by client code. - Importing `neo4j.routing` has been deprecated. It's internal and should not be used by client code. - Importing `neo4j.config` has been deprecated. It's internal and should not be used by client code. - `neoj4.Config`, `neoj4.PoolConfig`, `neoj4.SessionConfig`, and `neoj4.WorkspaceConfig` have been deprecated without replacement. They are internal classes. - Importing `neo4j.meta` has been deprecated. It's internal and should not be used by client code. `ExperimantalWarning` should be imported directly from `neo4j`. `neo4j.meta.version` is exposed through `neo4j.__vesrion__` - Importing `neo4j.data` has been deprecated. It's internal and should not be used by client code. `Record` should be imported directly from `neo4j` instead. `neo4j.data.DataHydrator` and `neo4j.data.DataDeydrator` have been removed without replacement. - Removed undocumented config options that had no effect: `protocol_version` and `init_size`. - Introduced `neo4j.exceptions.SessionError` that is raised when trying to execute work on a closed or otherwise terminated session. - Removed deprecated config options `update_routing_table_timeout` and `session_connection_timeout`. Server-side keep-alives communicated through configuration hints together with the config option `connection_acquisition_timeout` are sufficient to avoid the driver getting stuck. - Deprecate `Session.read_transaction` and `Session.write_transaction` in favor of `Session.execute_read` and `Session.execute_write` respectively. ## Version 4.4 - Python 3.5 support has been dropped. ## Version 4.3 - Python 3.9 support added ## Version 4.2 - No driver changes have been made for Neo4j 4.2 ## Version 4.1 - Routing context is now forwarded to the server for when required by server-side routing ## Version 4.0 - Breaking Changes - The package version has jumped from `1.7` directly to `4.0`, in order to bring the version in line with Neo4j itself. - The package can now no longer be installed as `neo4j-driver`; use `pip install neo4j` instead. - The `neo4j.v1` subpackage is now no longer available; all imports should be taken from the `neo4j` package instead. - Changed `session(access_mode)` from a positional to a keyword argument - The `bolt+routing` scheme is now named `neo4j` - Connections are now unencrypted by default; to reproduce former behaviour, add `encrypted=True` to Driver configuration - Removed `transaction.success` flag usage pattern. + Python 3.8 supported. + Python 3.7 supported. + Python 3.6 supported. + Python 3.5 supported. + Python 3.4 support has been dropped. + Python 3.3 support has been dropped. + Python 3.2 support has been dropped. + Python 3.1 support has been dropped. + Python 3.0 support has been dropped. + Python 2.7 support has been dropped. neo4j-python-driver-5.2.1/CONTRIBUTING.md000066400000000000000000000077671433522662700176320ustar00rootroot00000000000000# Contributing to the Neo4j Ecosystem At [Neo4j](https://neo4j.com/), we develop our software in the open at GitHub. This provides transparency for you, our users, and allows you to fork the software to make your own additions and enhancements. We also provide areas specifically for community contributions, in particular the [neo4j-contrib](https://github.com/neo4j-contrib) space. There's an active [Neo4j Online Community](https://community.neo4j.com/) where we work directly with the community. If you're not already a member, sign up! We love our community and wouldn't be where we are without you. ## Need to raise an issue? Where you raise an issue depends largely on the nature of the problem. Firstly, if you are an Enterprise customer, you might want to head over to our [Customer Support Portal](https://support.neo4j.com/). There are plenty of public channels available too, though. If you simply want to get started or have a question on how to use a particular feature, ask a question in [Neo4j Online Community](https://community.neo4j.com/). If you think you might have hit a bug in our software (it happens occasionally!) or you have specific feature request then use the issue feature on the relevant GitHub repository. Check first though as someone else may have already raised something similar. [StackOverflow](https://stackoverflow.com/questions/tagged/neo4j) also hosts a ton of questions and might already have a discussion around your problem. Make sure you have a look there too. Include as much information as you can in any request you make: - Which versions of our products are you using? - Which language (and which version of that language) are you developing with? - What operating system are you on? - Are you working with a cluster or on a single machine? - What code are you running? - What errors are you seeing? - What solutions have you tried already? ## Want to contribute? If you want to contribute a pull request, we have a little bit of process you'll need to follow: - Do all your work in a personal fork of the original repository - [Rebase](https://github.com/edx/edx-platform/wiki/How-to-Rebase-a-Pull-Request), don't merge (we prefer to keep our history clean) - Create a branch (with a useful name) for your contribution - Make sure you're familiar with the appropriate coding style (this varies by language so ask if you're in doubt) - Include unit tests if appropriate (obviously not necessary for documentation changes) - Take a moment to read and sign our [CLA](https://neo4j.com/developer/cla) We can't guarantee that we'll accept pull requests and may ask you to make some changes before they go in. Occasionally, we might also have logistical, commercial, or legal reasons why we can't accept your work but we'll try to find an alternative way for you to contribute in that case. Remember that many community members have become regular contributors and some are now even Neo employees! ## Specifically for this project: All code in `_sync` or `sync` folders is auto-generated. Don't change it, but install the pre-commit hooks as described below insted. They will take care of updating the code if necessary. Setting up the development environment: * Install Python 3.7+ * Install the requirements ```bash $ python3 -m pip install -U pip $ python3 -m pip install -Ur requirements-dev.txt ``` * Install the pre-commit hook, that will do some code-format-checking everytime you commit. ```bash $ pre-commit install ``` ## Got an idea for a new project? If you have an idea for a new tool or library, start by talking to other people in the community. Chances are that someone has a similar idea or may have already started working on it. The best software comes from getting like minds together to solve a problem. And we'll do our best to help you promote and co-ordinate your Neo4j ecosystem projects. ## Further reading If you want to find out more about how you can contribute, head over to our website for [more information](https://neo4j.com/developer/contributing-code/). neo4j-python-driver-5.2.1/ISSUE_TEMPLATE.md000066400000000000000000000045521433522662700200730ustar00rootroot00000000000000## Guidelines Firstly, if you are an Enterprise customer, you might want to head over to our [Customer Support Portal](https://support.neo4j.com/). If you think you might have **hit a bug** in our software (it happens occasionally!) or you have specific **feature request** then use the issue feature on the relevant GitHub repository. Check first though as someone else may have already raised something similar. If you simply want to get started or have a question on how to use a particular feature, ask a question in [Neo4j Online Community](https://community.neo4j.com/) instead. [StackOverflow](https://stackoverflow.com/questions/tagged/neo4j) also hosts a ton of questions and might already have a discussion around your problem. Make sure you have a look there too. If you want to make a feature request, please prefix your issue title with `[Feature Request]` so that it is clear to us. If you have a bug report however, please continue reading. To help us understand your issue, please specify important details, primarily: - Neo4j version: Community/Enterprise X.Y.Z - Neo4j Mode: Single instance/HA cluster with X members/Casual cluster with X core Y read-replica - Driver version: X lanaguage driver X.Y.Z (If you use some other library that wraps around this driver, you might want to raise an issue there first) - Operating system: (for example Windows 10/Ubuntu 16.10 on AWS) - **Steps to reproduce** - Expected behavior - Actual behavior Additionally, include (as appropriate) log-files, stacktraces, and other debug output. Always check the server logs to see if there is any stacktrace related to the driver error too. Aslo add any solutions you've tried to solve the problem yourself. ## Example bug report I got connection reset by peer errors. **Neo4j Version:** 3.4.10 Community **Neo4j Mode**: Single instance **Driver version**: Python driver 1.7.1 **Operating System:** Ubuntu 16.10 on AWS ### Steps to reproduce 1. Start Neo4j on a AWS instance 2. Run a query with the driver 3. Put the driver idle for 2h 4. Run another query ### Expected behavior The second query shall run successfully ### Actual behavior The client failed to run the second query with a `connection reset by peer` stacktrace. *attach the stacktrace* Meanwhile, in the server log, I found this stacktrace that happened at the same time when the driver failed. *attach the stacktrace* neo4j-python-driver-5.2.1/LICENSE.txt000066400000000000000000000261401433522662700172060ustar00rootroot00000000000000 Apache License Version 2.0, January 2004 https://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 https://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. neo4j-python-driver-5.2.1/MANIFEST.in000066400000000000000000000001061433522662700171130ustar00rootroot00000000000000global-exclude *.class *.pyc *.pyo *.so *.dll __pycache__ prune tests neo4j-python-driver-5.2.1/NOTICE.txt000066400000000000000000000002401433522662700170760ustar00rootroot00000000000000Neo4j Copyright (c) Neo4j Sweden AB (referred to in this notice as "Neo4j") [https://neo4j.com] This product includes software ("Software") developed by Neo4j neo4j-python-driver-5.2.1/README.rst000066400000000000000000000112441433522662700170510ustar00rootroot00000000000000**************************** Neo4j Bolt Driver for Python **************************** This repository contains the official Neo4j driver for Python. Starting with 5.0, the Neo4j Drivers will be moving to a monthly release cadence. A minor version will be released on the last Friday of each month so as to maintain versioning consistency with the core product (Neo4j DBMS) which has also moved to a monthly cadence. As a policy, patch versions will not be released except on rare occasions. Bug fixes and updates will go into the latest minor version and users should upgrade to that. Driver upgrades within a major version will never contain breaking API changes. See also: https://neo4j.com/developer/kb/neo4j-supported-versions/ + Python 3.10 supported. + Python 3.9 supported. + Python 3.8 supported. + Python 3.7 supported. Installation ============ To install the latest stable version, use: .. code:: bash pip install neo4j Quick Example ============= .. code-block:: python from neo4j import GraphDatabase driver = GraphDatabase.driver("neo4j://localhost:7687", auth=("neo4j", "password")) def add_friend(tx, name, friend_name): tx.run("MERGE (a:Person {name: $name}) " "MERGE (a)-[:KNOWS]->(friend:Person {name: $friend_name})", name=name, friend_name=friend_name) def print_friends(tx, name): query = ("MATCH (a:Person)-[:KNOWS]->(friend) WHERE a.name = $name " "RETURN friend.name ORDER BY friend.name") for record in tx.run(query, name=name): print(record["friend.name"]) with driver.session(database="neo4j") as session: session.execute_write(add_friend, "Arthur", "Guinevere") session.execute_write(add_friend, "Arthur", "Lancelot") session.execute_write(add_friend, "Arthur", "Merlin") session.execute_read(print_friends, "Arthur") driver.close() Connection Settings Breaking Change (4.x) ========================================= + The driver’s default configuration for encrypted is now false (meaning that driver will only attempt plain text connections by default). + Connections to encrypted services (such as Neo4j Aura) should now explicitly be set to encrypted. + When encryption is explicitly enabled, the default trust mode is to trust the CAs that are trusted by operating system and use hostname verification. + This means that encrypted connections to servers holding self-signed certificates will now fail on certificate verification by default. + Using the new ``neo4j+ssc`` scheme will allow to connect to servers holding self-signed certificates and not use hostname verification. + The ``neo4j://`` scheme replaces ``bolt+routing://`` and can be used for both clustered and single-instance configurations with Neo4j 4.0. See, https://neo4j.com/docs/migration-guide/4.0/upgrade-driver/#upgrade-driver-breakingchanges See, https://neo4j.com/docs/driver-manual/current/client-applications/#driver-connection-uris for changes in default security settings between 3.x and 4.x Connecting with Python Driver 4.x to Neo4j 3.5 (EOL) ---------------------------------------------------- Using the Python Driver 4.x and connecting to Neo4j 3.5 with default connection settings for Neo4j 3.5. .. code-block:: python # the preferred form driver = GraphDatabase.driver("neo4j+ssc://localhost:7687", auth=("neo4j", "password")) # is equivalent to driver = GraphDatabase.driver("neo4j://localhost:7687", auth=("neo4j", "password"), encrypted=True, trust=False) Connecting with Python Driver 1.7 (EOL) to Neo4j 4.x ---------------------------------------------------- Using the Python Driver 1.7 and connecting to Neo4j 4.x with default connection settings for Neo4j 4.x. .. code-block:: python driver = GraphDatabase.driver("neo4j://localhost:7687", auth=("neo4j", "password"), encrypted=False) Other Information ================= * `The Neo4j Operations Manual`_ * `The Neo4j Drivers Manual`_ * `Python Driver API Documentation`_ * `Neo4j Cypher Refcard`_ * `Example Project`_ * `Driver Wiki`_ (includes change logs) * `Neo4j 4.0 Migration Guide`_ .. _`The Neo4j Operations Manual`: https://neo4j.com/docs/operations-manual/current/ .. _`The Neo4j Drivers Manual`: https://neo4j.com/docs/driver-manual/current/ .. _`Python Driver API Documentation`: https://neo4j.com/docs/api/python-driver/current/ .. _`Neo4j Cypher Refcard`: https://neo4j.com/docs/cypher-refcard/current/ .. _`Example Project`: https://github.com/neo4j-examples/movies-python-bolt .. _`Driver Wiki`: https://github.com/neo4j/neo4j-python-driver/wiki .. _`Neo4j 4.0 Migration Guide`: https://neo4j.com/docs/migration-guide/4.0/ neo4j-python-driver-5.2.1/TESTING.md000066400000000000000000000043631433522662700170250ustar00rootroot00000000000000# Neo4j Driver Testing To run driver tests, [Tox](https://tox.readthedocs.io) is required as well as at least one version of Python. The versions of Python supported by this driver are CPython 3.7, 3.8, 3.9, and 3.10. ## Unit Tests & Stub Tests Unit tests and stub tests (those which make use of the [boltkit](https://github.com/neo4j-contrib/boltkit) stub server) can be run using: ```bash $ tox ``` ## Integration Tests Each test run can also carry out integration tests against a specific version of Neo4j. To enable integration tests, a server must be made available. This can be either an existing server listening on the default Bolt port (7687) or a temporary installation from a particular package. For example: ```bash $ NEO4J_SERVER_PACKAGE=~/dist/neo4j-enterprise-3.1.1-unix.tar.gz tox ``` A web address can be provided as an alternative to a file path: ```bash $ NEO4J_SERVER_PACKAGE=https://dist.neo4j.org/neo4j-enterprise-3.1.1-unix.tar.gz tox ``` If using an existing server, authentication details can be provided in a similar way: ```bash $ NEO4J_USER=bob NEO4J_PASSWORD=secret tox ``` ## Code Coverage If [Coverage](https://coverage.readthedocs.io/) is installed, test runs automatically add data to a `.coverage` file. To use this data, ensure that `coverage erase` is executed before commencing a test run; a report can be viewed after the run with `coverage report --show-missing`. ## Testing with Testkit Tests **require** the latest [Testkit 4.4](https://github.com/neo4j-drivers/testkit/tree/4.4), Python3 and Docker. Testkit is needed to be cloned and configured to run against the Python Driver. Use the following steps to configure Testkit. 1. Clone the Testkit repository—preferably not inside this project's folder ``` git clone https://github.com/neo4j-drivers/testkit.git ``` 2. Under the Testkit folder, install the requirements. ``` pip3 install -r requirements.txt ``` 3. Define some enviroment variables to configure Testkit ``` export TEST_DRIVER_NAME=python export TEST_DRIVER_REPO= ``` To run test against against some Neo4j version: ``` python3 main.py ``` More details about how to use Teskit could be found on [its repository](https://github.com/neo4j-drivers/testkit/tree/4.4) neo4j-python-driver-5.2.1/bin/000077500000000000000000000000001433522662700161305ustar00rootroot00000000000000neo4j-python-driver-5.2.1/bin/check-dist000077500000000000000000000005561433522662700201020ustar00rootroot00000000000000#!/usr/bin/env bash set -e ROOT=$(dirname "$0")/.. SCRIPT=$(basename "$0") DIST="${ROOT}/dist" STATUS=0 VERSION="$1" if [ "${VERSION}" == "" ] then echo "usage: ${SCRIPT} VERSION" exit 1 else source "${ROOT}/bin/dist-functions" check_file "${DIST}/neo4j-driver-${VERSION}.tar.gz" check_file "${DIST}/neo4j-${VERSION}.tar.gz" fi exit ${STATUS} neo4j-python-driver-5.2.1/bin/clean000077500000000000000000000006651433522662700171470ustar00rootroot00000000000000#!/usr/bin/env bash ROOT=$(dirname "$0") find -name __pycache__ -delete find -name *.py[co] -delete find -name *.so -delete rm -rf ${ROOT}/build ${ROOT}/dist ${ROOT}/docs/build ${ROOT}/*.egg-info ${ROOT}/.coverage ${ROOT}/.tox ${ROOT}/.cache ${ROOT}/.pytest_cache ${ROOT}/.benchmarks # These are removed to avoid name collision problems with snapshot server packages rm -rf ${ROOT}/test/integration/dist ${ROOT}/test/integration/run neo4j-python-driver-5.2.1/bin/dist-functions000066400000000000000000000044631433522662700210330ustar00rootroot00000000000000#!/usr/bin/env bash set -e ROOT=$(dirname "$0")/.. DIST="${ROOT}/dist" function get_package { python -c "from neo4j._meta import package; print(package)" } function set_package { sed -i 's/^package = .*/package = "'$1'"/g' neo4j/_meta.py } function get_version { python -c "from neo4j._meta import version; print(version)" } function set_version { sed -i 's/^version = .*/version = "'$1'"/g' neo4j/_meta.py } function check_file { FILE=$1 echo -n "Checking file $(basename ${FILE})... " if [ -f "${FILE}" ] then echo "OK" else echo "missing" STATUS=1 fi } function set_metadata_and_setup { PACKAGE="$1"; shift VERSION="$1"; shift cd ${ROOT} # Capture original package metadata ORIGINAL_PACKAGE=$(get_package) ORIGINAL_VERSION=$(get_version) echo "Source code originally configured for package ${ORIGINAL_PACKAGE}/${ORIGINAL_VERSION}" echo "----------------------------------------" grep "package\s\+=" neo4j/_meta.py grep "version\s\+=" neo4j/_meta.py echo "----------------------------------------" function cleanup() { # Reset to original package metadata set_package "${ORIGINAL_PACKAGE}" set_version "${ORIGINAL_VERSION}" echo "Source code reconfigured back to original package ${ORIGINAL_PACKAGE}/${ORIGINAL_VERSION}" echo "----------------------------------------" grep "package\s\+=" neo4j/_meta.py grep "version\s\+=" neo4j/_meta.py echo "----------------------------------------" } trap cleanup EXIT # Temporarily override package metadata set_package "${PACKAGE}" set_version "${VERSION}" echo "Source code reconfigured for package ${PACKAGE}/${VERSION}" echo "----------------------------------------" grep "package\s\+=" neo4j/_meta.py grep "version\s\+=" neo4j/_meta.py echo "----------------------------------------" # Create source distribution find . -name *.pyc -delete rm -rf ${ROOT}/*.egg-info 2> /dev/null python setup.py $* check_file "${DIST}/${PACKAGE}-${VERSION}.tar.gz" trap - EXIT cleanup } function setup { ARGS="$*" rm -rf ${DIST} 2> /dev/null set_metadata_and_setup "neo4j-driver" ${ARGS} # Legacy package; can be removed in 2.0 set_metadata_and_setup "neo4j" ${ARGS} } neo4j-python-driver-5.2.1/bin/make-dist000077500000000000000000000003651433522662700177400ustar00rootroot00000000000000#!/usr/bin/env bash set -e ROOT=$(dirname "$0")/.. SCRIPT=$(basename "$0") VERSION="$1" if [ "${VERSION}" == "" ] then echo "usage: ${SCRIPT} VERSION" exit 1 else source "${ROOT}/bin/dist-functions" setup "${VERSION}" sdist fi neo4j-python-driver-5.2.1/bin/make-docs000077500000000000000000000004501433522662700177200ustar00rootroot00000000000000#!/usr/bin/env bash set -e ROOT=$(dirname "$0")/.. pip install --quiet --upgrade sphinx make -C ${ROOT}/docs html echo "" INDEX_FILE="${ROOT}/docs/build/html/index.html" echo "Documentation index file can be found at file://$(cd "$(dirname "${INDEX_FILE}")"; pwd)/$(basename "${INDEX_FILE}")" neo4j-python-driver-5.2.1/bin/make-unasync000077500000000000000000000253521433522662700204600ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 collections import errno import os import re import sys import tokenize as std_tokenize from pathlib import Path import isort import isort.files import unasync ROOT_DIR = Path(__file__).parents[1].absolute() ASYNC_DIR = ROOT_DIR / "neo4j" / "_async" SYNC_DIR = ROOT_DIR / "neo4j" / "_sync" ASYNC_UNIT_TEST_DIR = ROOT_DIR / "tests" / "unit" / "async_" SYNC_UNIT_TEST_DIR = ROOT_DIR / "tests" / "unit" / "sync" ASYNC_INTEGRATION_TEST_DIR = ROOT_DIR / "tests" / "integration" / "async_" SYNC_INTEGRATION_TEST_DIR = ROOT_DIR / "tests" / "integration" / "sync" ASYNC_TESTKIT_BACKEND_DIR = ROOT_DIR / "testkitbackend" / "_async" SYNC_TESTKIT_BACKEND_DIR = ROOT_DIR / "testkitbackend" / "_sync" UNASYNC_SUFFIX = ".unasync" PY_FILE_EXTENSIONS = {".py", ".pyi"} # copy from unasync for customization ----------------------------------------- # https://github.com/python-trio/unasync # License: MIT and Apache2 Token = collections.namedtuple( "Token", ["type", "string", "start", "end", "line"] ) def _makedirs_existok(dir): try: os.makedirs(dir) except OSError as e: if e.errno != errno.EEXIST: raise def _get_tokens(f): if sys.version_info[0] == 2: for tok in std_tokenize.generate_tokens(f.readline): type_, string, start, end, line = tok yield Token(type_, string, start, end, line) else: for tok in std_tokenize.tokenize(f.readline): if tok.type == std_tokenize.ENCODING: continue yield tok def _tokenize(f): last_end = (1, 0) for tok in _get_tokens(f): if last_end[0] < tok.start[0]: yield "", std_tokenize.STRING, " \\\n" last_end = (tok.start[0], 0) space = "" if tok.start > last_end: assert tok.start[0] == last_end[0] space = " " * (tok.start[1] - last_end[1]) yield space, tok.type, tok.string last_end = tok.end if tok.type in [std_tokenize.NEWLINE, std_tokenize.NL]: last_end = (tok.end[0] + 1, 0) def _untokenize(tokens): return "".join(space + tokval for space, tokval in tokens) # end of copy ----------------------------------------------------------------- class CustomRule(unasync.Rule): def __init__(self, *args, **kwargs): super(CustomRule, self).__init__(*args, **kwargs) self.out_files = [] # it's not pretty, but it works # typing.Awaitable[...] -> typing.Union[...] self.token_replacements["Awaitable"] = "Union" def _unasync_tokens(self, tokens): # copy from unasync to hook into string handling # https://github.com/python-trio/unasync # License: MIT and Apache2 # TODO __await__, ...? used_space = None for space, toknum, tokval in tokens: if tokval in ["async", "await"]: # When removing async or await, we want to use the whitespace # that was before async/await before the next token so that # `print(await stuff)` becomes `print(stuff)` and not # `print( stuff)` used_space = space else: if toknum == std_tokenize.NAME: tokval = self._unasync_name(tokval) elif toknum == std_tokenize.STRING: if tokval[0] == tokval[1] and len(tokval) > 2: # multiline string (`"""..."""` or `'''...'''`) left_quote, name, right_quote = \ tokval[:3], tokval[3:-3], tokval[-3:] else: # simple string (`"..."` or `'...'`) left_quote, name, right_quote = \ tokval[:1], tokval[1:-1], tokval[-1:] tokval = \ left_quote + self._unasync_string(name) + right_quote if used_space is None: used_space = space yield (used_space, tokval) used_space = None def _unasync_string(self, name): start = 0 end = 1 out = "" while end < len(name): sub_name = name[start:end] if sub_name.isidentifier(): end += 1 else: if end == start + 1: out += sub_name start += 1 end += 1 else: out += self._unasync_name(name[start:(end - 1)]) start = end - 1 sub_name = name[start:] if sub_name.isidentifier(): out += self._unasync_name(name[start:]) else: out += sub_name # very boiled down unasync version that removes "async" and "await" # substrings. out = re.subn(r"(^|\s+|(?<=\W))(?:async|await)\s+", r"\1", out, flags=re.MULTILINE)[0] # Convert doc-reference names from 'async-xyz' to 'xyz' out = re.subn(r":ref:`async-", ":ref:`", out)[0] return out def _unasync_prefix(self, name): # Convert class names from 'AsyncXyz' to 'Xyz' if len(name) > 5 and name.startswith("Async") and name[5].isupper(): return name[5:] # Convert class names from '_AsyncXyz' to '_Xyz' elif len(name) > 6 and name.startswith("_Async") and name[6].isupper(): return "_" + name[6:] # Convert variable/method/function names from 'async_xyz' to 'xyz' elif len(name) > 6 and name.startswith("async_"): return name[6:] return name def _unasync_name(self, name): # copy from unasync to customize renaming rules # https://github.com/python-trio/unasync # License: MIT and Apache2 if name in self.token_replacements: return self.token_replacements[name] return self._unasync_prefix(name) def _unasync_file(self, filepath): # copy from unasync to append file suffix to out path # https://github.com/python-trio/unasync # License: MIT and Apache2 with open(filepath, "rb") as f: write_kwargs = {} if sys.version_info[0] >= 3: encoding, _ = std_tokenize.detect_encoding(f.readline) write_kwargs["encoding"] = encoding f.seek(0) tokens = _tokenize(f) tokens = self._unasync_tokens(tokens) result = _untokenize(tokens) outfile_path = filepath.replace(self.fromdir, self.todir) outfile_path += UNASYNC_SUFFIX self.out_files.append(outfile_path) _makedirs_existok(os.path.dirname(outfile_path)) with open(outfile_path, "w", **write_kwargs) as f: print(result, file=f, end="") def apply_unasync(files): """Generate sync code from async code.""" additional_main_replacements = {} additional_test_replacements = { "_async": "_sync", "mark_async_test": "mark_sync_test", "assert_awaited_once": "assert_called_once", "assert_awaited_once_with": "assert_called_once_with", "await_count": "call_count", } additional_testkit_backend_replacements = {} rules = [ CustomRule( fromdir=str(ASYNC_DIR), todir=str(SYNC_DIR), additional_replacements=additional_main_replacements, ), CustomRule( fromdir=str(ASYNC_UNIT_TEST_DIR), todir=str(SYNC_UNIT_TEST_DIR), additional_replacements=additional_test_replacements, ), CustomRule( fromdir=str(ASYNC_INTEGRATION_TEST_DIR), todir=str(SYNC_INTEGRATION_TEST_DIR), additional_replacements=additional_test_replacements, ), CustomRule( fromdir=str(ASYNC_TESTKIT_BACKEND_DIR), todir=str(SYNC_TESTKIT_BACKEND_DIR), additional_replacements=additional_testkit_backend_replacements, ), ] if not files: paths = list(ASYNC_DIR.rglob("*")) paths += list(ASYNC_UNIT_TEST_DIR.rglob("*")) paths += list(ASYNC_INTEGRATION_TEST_DIR.rglob("*")) paths += list(ASYNC_TESTKIT_BACKEND_DIR.rglob("*")) else: paths = [ROOT_DIR / Path(f) for f in files] filtered_paths = [] for path in paths: if path.suffix in PY_FILE_EXTENSIONS: filtered_paths.append(path) unasync.unasync_files(map(str, filtered_paths), rules) return [Path(path) for rule in rules for path in rule.out_files] def apply_isort(paths): """Sort imports in generated sync code. Since classes in imports are renamed from AsyncXyz to Xyz, the alphabetical order of the import can change. """ isort_config = isort.Config(settings_path=str(ROOT_DIR), quiet=True) for path in paths: isort.file(str(path), config=isort_config) return paths def apply_changes(paths): def files_equal(path1, path2): with open(path1, "rb") as f1: with open(path2, "rb") as f2: data1 = f1.read(1024) data2 = f2.read(1024) while data1 or data2: if data1 != data2: changed_paths[path1] = path2 return False data1 = f1.read(1024) data2 = f2.read(1024) return True changed_paths = {} for in_path in paths: out_path = Path(str(in_path)[:-len(UNASYNC_SUFFIX)]) if not out_path.is_file(): changed_paths[in_path] = out_path continue if not files_equal(in_path, out_path): changed_paths[in_path] = out_path continue in_path.unlink() for in_path, out_path in changed_paths.items(): in_path.replace(out_path) return list(changed_paths.values()) def main(): files = None if len(sys.argv) >= 1: files = sys.argv[1:] paths = apply_unasync(files) paths = apply_isort(paths) changed_paths = apply_changes(paths) if changed_paths: for path in changed_paths: print("Updated " + str(path)) exit(1) if __name__ == "__main__": main() neo4j-python-driver-5.2.1/bin/release000077500000000000000000000007221433522662700174770ustar00rootroot00000000000000#!/usr/bin/env bash set -e ROOT=$(dirname "$0")/.. SCRIPT=$(basename "$0") TWINE_ARGS="--verbose" if [ "$1" == "--real" ] then shift else TWINE_ARGS="${TWINE_ARGS} --repository testpypi" fi VERSION="$1" if [ "${VERSION}" == "" ] then echo "usage: ${SCRIPT} VERSION" exit 1 else source "${ROOT}/bin/dist-functions" twine upload ${TWINE_ARGS} \ "${DIST}/neo4j-driver-${VERSION}.tar.gz" \ "${DIST}/neo4j-${VERSION}.tar.gz" fi neo4j-python-driver-5.2.1/docs/000077500000000000000000000000001433522662700163105ustar00rootroot00000000000000neo4j-python-driver-5.2.1/docs/Makefile000066400000000000000000000165071433522662700177610ustar00rootroot00000000000000# Makefile for Sphinx documentation # # You can set these variables from the command line. SPHINXOPTS = SPHINXBUILD = sphinx-build PAPER = BUILDDIR = build # User-friendly check for sphinx-build ifeq ($(shell which $(SPHINXBUILD) >/dev/null 2>&1; echo $$?), 1) $(error The '$(SPHINXBUILD)' command was not found. Make sure you have Sphinx installed, then set the SPHINXBUILD environment variable to point to the full path of the '$(SPHINXBUILD)' executable. Alternatively you can add the directory with the executable to your PATH. If you don't have Sphinx installed, grab it from https://www.sphinx-doc.org/) endif # Internal variables. PAPEROPT_a4 = -D latex_paper_size=a4 PAPEROPT_letter = -D latex_paper_size=letter ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source # the i18n builder cannot share the environment and doctrees with the others I18NSPHINXOPTS = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source .PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest coverage gettext help: @echo "Please use \`make ' where is one of" @echo " html to make standalone HTML files" @echo " dirhtml to make HTML files named index.html in directories" @echo " singlehtml to make a single large HTML file" @echo " pickle to make pickle files" @echo " json to make JSON files" @echo " htmlhelp to make HTML files and a HTML help project" @echo " qthelp to make HTML files and a qthelp project" @echo " applehelp to make an Apple Help Book" @echo " devhelp to make HTML files and a Devhelp project" @echo " epub to make an epub" @echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter" @echo " latexpdf to make LaTeX files and run them through pdflatex" @echo " latexpdfja to make LaTeX files and run them through platex/dvipdfmx" @echo " text to make text files" @echo " man to make manual pages" @echo " texinfo to make Texinfo files" @echo " info to make Texinfo files and run them through makeinfo" @echo " gettext to make PO message catalogs" @echo " changes to make an overview of all changed/added/deprecated items" @echo " xml to make Docutils-native XML files" @echo " pseudoxml to make pseudoxml-XML files for display purposes" @echo " linkcheck to check all external links for integrity" @echo " doctest to run all doctests embedded in the documentation (if enabled)" @echo " coverage to run coverage check of the documentation (if enabled)" clean: rm -rf $(BUILDDIR)/* html: $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/html." dirhtml: $(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml." singlehtml: $(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml @echo @echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml." pickle: $(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle @echo @echo "Build finished; now you can process the pickle files." json: $(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json @echo @echo "Build finished; now you can process the JSON files." htmlhelp: $(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp @echo @echo "Build finished; now you can run HTML Help Workshop with the" \ ".hhp project file in $(BUILDDIR)/htmlhelp." qthelp: $(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp @echo @echo "Build finished; now you can run "qcollectiongenerator" with the" \ ".qhcp project file in $(BUILDDIR)/qthelp, like this:" @echo "# qcollectiongenerator $(BUILDDIR)/qthelp/Neo4jBoltDriverforPython.qhcp" @echo "To view the help file:" @echo "# assistant -collectionFile $(BUILDDIR)/qthelp/Neo4jBoltDriverforPython.qhc" applehelp: $(SPHINXBUILD) -b applehelp $(ALLSPHINXOPTS) $(BUILDDIR)/applehelp @echo @echo "Build finished. The help book is in $(BUILDDIR)/applehelp." @echo "N.B. You won't be able to view it unless you put it in" \ "~/Library/Documentation/Help or install it in your application" \ "bundle." devhelp: $(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp @echo @echo "Build finished." @echo "To view the help file:" @echo "# mkdir -p $$HOME/.local/share/devhelp/Neo4jBoltDriverforPython" @echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/Neo4jBoltDriverforPython" @echo "# devhelp" epub: $(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub @echo @echo "Build finished. The epub file is in $(BUILDDIR)/epub." latex: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo @echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex." @echo "Run \`make' in that directory to run these through (pdf)latex" \ "(use \`make latexpdf' here to do that automatically)." latexpdf: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo "Running LaTeX files through pdflatex..." $(MAKE) -C $(BUILDDIR)/latex all-pdf @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." latexpdfja: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo "Running LaTeX files through platex and dvipdfmx..." $(MAKE) -C $(BUILDDIR)/latex all-pdf-ja @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." text: $(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text @echo @echo "Build finished. The text files are in $(BUILDDIR)/text." man: $(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man @echo @echo "Build finished. The manual pages are in $(BUILDDIR)/man." texinfo: $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo @echo @echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo." @echo "Run \`make' in that directory to run these through makeinfo" \ "(use \`make info' here to do that automatically)." info: $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo @echo "Running Texinfo files through makeinfo..." make -C $(BUILDDIR)/texinfo info @echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo." gettext: $(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale @echo @echo "Build finished. The message catalogs are in $(BUILDDIR)/locale." changes: $(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes @echo @echo "The overview file is in $(BUILDDIR)/changes." linkcheck: $(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck @echo @echo "Link check complete; look for any errors in the above output " \ "or in $(BUILDDIR)/linkcheck/output.txt." doctest: $(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest @echo "Testing of doctests in the sources finished, look at the " \ "results in $(BUILDDIR)/doctest/output.txt." coverage: $(SPHINXBUILD) -b coverage $(ALLSPHINXOPTS) $(BUILDDIR)/coverage @echo "Testing of coverage in the sources finished, look at the " \ "results in $(BUILDDIR)/coverage/python.txt." xml: $(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml @echo @echo "Build finished. The XML files are in $(BUILDDIR)/xml." pseudoxml: $(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml @echo @echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml." neo4j-python-driver-5.2.1/docs/README.md000066400000000000000000000002741433522662700175720ustar00rootroot00000000000000==================== Sphinx Documentation ==================== ``` pip install -r requirements.txt ``` ``` make -C docs html ``` ``` python -m sphinx -b html docs/source build/html ``` neo4j-python-driver-5.2.1/docs/make.bat000066400000000000000000000161761433522662700177300ustar00rootroot00000000000000@ECHO OFF REM Command file for Sphinx documentation if "%SPHINXBUILD%" == "" ( set SPHINXBUILD=sphinx-build ) set BUILDDIR=build set ALLSPHINXOPTS=-d %BUILDDIR%/doctrees %SPHINXOPTS% source set I18NSPHINXOPTS=%SPHINXOPTS% source if NOT "%PAPER%" == "" ( set ALLSPHINXOPTS=-D latex_paper_size=%PAPER% %ALLSPHINXOPTS% set I18NSPHINXOPTS=-D latex_paper_size=%PAPER% %I18NSPHINXOPTS% ) if "%1" == "" goto help if "%1" == "help" ( :help echo.Please use `make ^` where ^ is one of echo. html to make standalone HTML files echo. dirhtml to make HTML files named index.html in directories echo. singlehtml to make a single large HTML file echo. pickle to make pickle files echo. json to make JSON files echo. htmlhelp to make HTML files and a HTML help project echo. qthelp to make HTML files and a qthelp project echo. devhelp to make HTML files and a Devhelp project echo. epub to make an epub echo. latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter echo. text to make text files echo. man to make manual pages echo. texinfo to make Texinfo files echo. gettext to make PO message catalogs echo. changes to make an overview over all changed/added/deprecated items echo. xml to make Docutils-native XML files echo. pseudoxml to make pseudoxml-XML files for display purposes echo. linkcheck to check all external links for integrity echo. doctest to run all doctests embedded in the documentation if enabled echo. coverage to run coverage check of the documentation if enabled goto end ) if "%1" == "clean" ( for /d %%i in (%BUILDDIR%\*) do rmdir /q /s %%i del /q /s %BUILDDIR%\* goto end ) REM Check if sphinx-build is available and fallback to Python version if any %SPHINXBUILD% 2> nul if errorlevel 9009 goto sphinx_python goto sphinx_ok :sphinx_python set SPHINXBUILD=python -m sphinx.__init__ %SPHINXBUILD% 2> nul if errorlevel 9009 ( echo. echo.The 'sphinx-build' command was not found. Make sure you have Sphinx echo.installed, then set the SPHINXBUILD environment variable to point echo.to the full path of the 'sphinx-build' executable. Alternatively you echo.may add the Sphinx directory to PATH. echo. echo.If you don't have Sphinx installed, grab it from echo.https://www.sphinx-doc.org/ exit /b 1 ) :sphinx_ok if "%1" == "html" ( %SPHINXBUILD% -b html %ALLSPHINXOPTS% %BUILDDIR%/html if errorlevel 1 exit /b 1 echo. echo.Build finished. The HTML pages are in %BUILDDIR%/html. goto end ) if "%1" == "dirhtml" ( %SPHINXBUILD% -b dirhtml %ALLSPHINXOPTS% %BUILDDIR%/dirhtml if errorlevel 1 exit /b 1 echo. echo.Build finished. The HTML pages are in %BUILDDIR%/dirhtml. goto end ) if "%1" == "singlehtml" ( %SPHINXBUILD% -b singlehtml %ALLSPHINXOPTS% %BUILDDIR%/singlehtml if errorlevel 1 exit /b 1 echo. echo.Build finished. The HTML pages are in %BUILDDIR%/singlehtml. goto end ) if "%1" == "pickle" ( %SPHINXBUILD% -b pickle %ALLSPHINXOPTS% %BUILDDIR%/pickle if errorlevel 1 exit /b 1 echo. echo.Build finished; now you can process the pickle files. goto end ) if "%1" == "json" ( %SPHINXBUILD% -b json %ALLSPHINXOPTS% %BUILDDIR%/json if errorlevel 1 exit /b 1 echo. echo.Build finished; now you can process the JSON files. goto end ) if "%1" == "htmlhelp" ( %SPHINXBUILD% -b htmlhelp %ALLSPHINXOPTS% %BUILDDIR%/htmlhelp if errorlevel 1 exit /b 1 echo. echo.Build finished; now you can run HTML Help Workshop with the ^ .hhp project file in %BUILDDIR%/htmlhelp. goto end ) if "%1" == "qthelp" ( %SPHINXBUILD% -b qthelp %ALLSPHINXOPTS% %BUILDDIR%/qthelp if errorlevel 1 exit /b 1 echo. echo.Build finished; now you can run "qcollectiongenerator" with the ^ .qhcp project file in %BUILDDIR%/qthelp, like this: echo.^> qcollectiongenerator %BUILDDIR%\qthelp\Neo4jBoltDriverforPython.qhcp echo.To view the help file: echo.^> assistant -collectionFile %BUILDDIR%\qthelp\Neo4jBoltDriverforPython.ghc goto end ) if "%1" == "devhelp" ( %SPHINXBUILD% -b devhelp %ALLSPHINXOPTS% %BUILDDIR%/devhelp if errorlevel 1 exit /b 1 echo. echo.Build finished. goto end ) if "%1" == "epub" ( %SPHINXBUILD% -b epub %ALLSPHINXOPTS% %BUILDDIR%/epub if errorlevel 1 exit /b 1 echo. echo.Build finished. The epub file is in %BUILDDIR%/epub. goto end ) if "%1" == "latex" ( %SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex if errorlevel 1 exit /b 1 echo. echo.Build finished; the LaTeX files are in %BUILDDIR%/latex. goto end ) if "%1" == "latexpdf" ( %SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex cd %BUILDDIR%/latex make all-pdf cd %~dp0 echo. echo.Build finished; the PDF files are in %BUILDDIR%/latex. goto end ) if "%1" == "latexpdfja" ( %SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex cd %BUILDDIR%/latex make all-pdf-ja cd %~dp0 echo. echo.Build finished; the PDF files are in %BUILDDIR%/latex. goto end ) if "%1" == "text" ( %SPHINXBUILD% -b text %ALLSPHINXOPTS% %BUILDDIR%/text if errorlevel 1 exit /b 1 echo. echo.Build finished. The text files are in %BUILDDIR%/text. goto end ) if "%1" == "man" ( %SPHINXBUILD% -b man %ALLSPHINXOPTS% %BUILDDIR%/man if errorlevel 1 exit /b 1 echo. echo.Build finished. The manual pages are in %BUILDDIR%/man. goto end ) if "%1" == "texinfo" ( %SPHINXBUILD% -b texinfo %ALLSPHINXOPTS% %BUILDDIR%/texinfo if errorlevel 1 exit /b 1 echo. echo.Build finished. The Texinfo files are in %BUILDDIR%/texinfo. goto end ) if "%1" == "gettext" ( %SPHINXBUILD% -b gettext %I18NSPHINXOPTS% %BUILDDIR%/locale if errorlevel 1 exit /b 1 echo. echo.Build finished. The message catalogs are in %BUILDDIR%/locale. goto end ) if "%1" == "changes" ( %SPHINXBUILD% -b changes %ALLSPHINXOPTS% %BUILDDIR%/changes if errorlevel 1 exit /b 1 echo. echo.The overview file is in %BUILDDIR%/changes. goto end ) if "%1" == "linkcheck" ( %SPHINXBUILD% -b linkcheck %ALLSPHINXOPTS% %BUILDDIR%/linkcheck if errorlevel 1 exit /b 1 echo. echo.Link check complete; look for any errors in the above output ^ or in %BUILDDIR%/linkcheck/output.txt. goto end ) if "%1" == "doctest" ( %SPHINXBUILD% -b doctest %ALLSPHINXOPTS% %BUILDDIR%/doctest if errorlevel 1 exit /b 1 echo. echo.Testing of doctests in the sources finished, look at the ^ results in %BUILDDIR%/doctest/output.txt. goto end ) if "%1" == "coverage" ( %SPHINXBUILD% -b coverage %ALLSPHINXOPTS% %BUILDDIR%/coverage if errorlevel 1 exit /b 1 echo. echo.Testing of coverage in the sources finished, look at the ^ results in %BUILDDIR%/coverage/python.txt. goto end ) if "%1" == "xml" ( %SPHINXBUILD% -b xml %ALLSPHINXOPTS% %BUILDDIR%/xml if errorlevel 1 exit /b 1 echo. echo.Build finished. The XML files are in %BUILDDIR%/xml. goto end ) if "%1" == "pseudoxml" ( %SPHINXBUILD% -b pseudoxml %ALLSPHINXOPTS% %BUILDDIR%/pseudoxml if errorlevel 1 exit /b 1 echo. echo.Build finished. The pseudo-XML files are in %BUILDDIR%/pseudoxml. goto end ) :end neo4j-python-driver-5.2.1/docs/requirements.txt000066400000000000000000000000071433522662700215710ustar00rootroot00000000000000sphinx neo4j-python-driver-5.2.1/docs/source/000077500000000000000000000000001433522662700176105ustar00rootroot00000000000000neo4j-python-driver-5.2.1/docs/source/_images/000077500000000000000000000000001433522662700212145ustar00rootroot00000000000000neo4j-python-driver-5.2.1/docs/source/_images/core_type_mappings.png000066400000000000000000001704161433522662700256220ustar00rootroot00000000000000‰PNG  IHDRÀÐ_w´€IDATxÚì½}TÕ½÷ûü‘ª¤bò˜ªø=ƨQƒ*ô`Ôà_€‘!Ã08  ID` ñ%jÀ€(¾  k,Œ ˆÎˆ`@Ï$!×1%9œ{¹¹<'ëöwÍþµk6»gzÞ{w¾U¿êîµßw¯½Öï³~k­ý?þB!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B•”.\ø•_þò—ǘ-^¼ø3]Ýçüùóï_°`Á¾Ì¾öæµÔÔÔ|*sÜA•9‡ËæÍ›÷9þáž•{§ú·}Ü1Y{wìaÞÇ»cÇgl¿>¹£…­yëkúÏy}úˆ9ë§W_ÓmÏ×Üק¿1çõi{2û<‚»œ>•/núÌÄeCnZ¶sÔÄ_¿?¨¦¾þSÜ•âל7k¾2wýô+3Ïï5ó6Ì8®ûʃi÷dlÿCë§_Æ]N¹ÐTþ™V>‚¬¾¦ÃåCÆ?h–qGû¨îÏøÓ!+d~w¹®düõ½¿úÕ¯žé öÉ÷JñBæzúñ— 2¾‹Ù~¬`2Ÿí3hDf›[CpÎl¿XûÊdªó{ë:”3ÇÜ»–æE‹ǿ܃•Û»c÷e̵²÷*ëÆØÇŒhÛÑïÃÜŽª)î½±C¹Ã…¡¹jNÌ8¹3N© l¿@¸;öÿÐëÓš´ÏÙoÔÃÝN—&<ÝtâÄe;wM¬Ý鲶tçk¶|ÒÒ÷‡N\úþ”[Ÿ~÷0îV‘8Ãõ5ŸË<¯OÆÊ7çõi³»©7G¿Ÿì4ow¾4w¸ï5»¾æ s_›¶«ÅɽcëC¯Ý1~îkwLÌ|ߟ]^»³^˵Œ»U2øU¯L0uîëÓ+殟V—Ik€Q~ÍßQ93ë7ì¬8®û‰pe½OËø Üå^ñ±ëͧÎøٙϗ£ß»òé91†@sqðÆÌ1gfÎe°®Ç XQaþéÒà¦à÷Œ(m•`R™U™$È°ý¢´k¢Væg”¡BŽ@tv¦÷‡]’aÖC”±ç£åÚfPð° QšµEß“!h·¥¨¶®£Ž¹xû8ÿ¿d ø²8¼ª»“Z{Ý»UÏ·TZU‹]ã˜IœYÞ?ó¹*úÝì×%ܧÊï”(ÂÓv{®Éü¯êùÐúi3将ݗÕ%Ò§­¯é?wÃô!þû†ǵ8ËÓêå@‡]& €µnä\×ÏyíŽ[[•Uõ5‡E]#ë3Ž÷ª9¯ßQUu¥8ûc¼>uP´ÎËÀt/píÎ=pý^ÿø²›–½?#³¬ÙG…—í\%H¶e“–63iÙÎûÈ™ô—'ÕîœZýëw>÷É~ïL+‚¬å7Õ6úî°ZGë*­eŸïO¤Ëuïéëkú}õÚ*úc]¢õ,>´núàp¥ùá*3¸zÖ3ë¶<ËÓV…ݳ¬Æ¶×§Ý•¿TЪüÉ”ð~>Z~O¸\ëk{íWåÝ©û€«’VõF^3¿OÌØÜlWùèî;ÕŸKàŒO05êí"aagºU£N°o”ôªÇhµ’³c|!žX±ÀkÑöòí3iýCŽÖw<2G´Ÿ3˃֙B·–eÒÇ+º,‰à<¯™ý|Á˜®Ð%ÀÊXQ†~ÞZl”™‚õg[„8óy Ö 1`ƒã ‹Áâ`?K£ô½êF}?`?ñæx—‹<®éDKtž#ø—{€UYy`ÕïL嬳4Ûíé“ñ«üZð»U×Ü¥zìTîtßIΣwvsD{guÊ'ÛܱYiÞYÎl9ÌÍÑç>ÿùÚ´]ÔY~}ÚÖ]*ïð•XÔår»_î#MÙîØ÷øã½vÇùéÙí3iü{½ÀoD]Ÿ©!Œf v{«®Ñµ;(Ýw›®Ý¹/JÛj=±öýͶ}æwSÏZ–5ÎÖ2­mWFŸù'zGj˜jyƦ¿‘\^L¿&z³ j$‹žÉ‰Ùg5Û«$*2϶°Â2%^èÙÏžÇëÓ¶”Ó_‹ X=T6[£X6Bmûè¦Þ*¨k5rkèÔ×TþŸ¶£j@0œjsä+´nHo À[c~ÂÛêŽæÜÙùÙý­7¨²2Ÿ‡EŒ°'ðç³&ßÜ8Î Ú΂]êb,ß1C«¨qГõ@Œ9.k~?œÛö|‡~¢âà]QFg•"¶QÆ;`Þ ,­«@[] Õâ£Ö•¨uÈî–«•ÆÀÛ¢ÂÞ–©ÃL©(p4X~_[Ý® ‘Íæî%n ¬[m °"½Qz£µæFãv”ör€ýoº@” NsuGT¤ÇœO«Šô¿nTT6‚ÙT§_à¹r`³QçŒcîDGÚW¾™u"zÿâúšÏ¬}V¼•Î¿×󺱶q`B÷Û¨´êù½Ôƒë²÷ý3¯¨®¶kYïý¡kgnþõÎã|ĸöýÑã_¶äq dOªkÂî ŽÀSšèTêy|}Ú^ oÖ|%‚ÑFû<«lOº<·ìÓ~ nÕ³Ä÷$‰æðûósøg}cÐP÷¤õ"1ni˜›öŒÊ;ÔWÖÖäÖëËO„)˜ÍFx?i(§ tað­Š”FQWÏ Ïýtöw[] £à×5ÚOpœñÑv«ŒI"hý‚qŠ ³ €wJt.¨ûeÒµD<²‚æ:‘¹48>|±µ„Ý™'F­<ñ–—¼ÆÛ¾£ï·Æ5È{c<#ØÇkñcÅ®E?#:þþ¶ÔÍüÞØÙÈ~Ò}Y•˜Áì÷­³N?·jK4ÇG|#XUwçVD`¢nÙ´øàÀIöy@Nlôûeß½²ÅAn¶ml}9Ìüc½¯ê_7¡mÂû­m°‡[[GŠºCg¡ØÖiÕ-:¾6ÉVæsqd¾‹uݨçXÀÙî:* "Xµg3þl·­ú*'¶2¦eùôQÖ¨öIyÐÒëĶ1¦!¬`x³¯ë3¾€þ=ŲÑß Šë»5ûu*'ÀÀ­&šµˆo4\ѧEZ‹ç58îû›//ð Öy2ÉY¾ˆdpüX¡¢àžŽsOÐu\šì'ÁR—„ø¬É‚X‹æZÆTËNxF”égÚò þ¾\l`>〣٩ý1»cºvÔGc€£´íQ—§k²p»£2û_G¯Kò]¢àÂW¶ tZsBrÔÅQŸ¾Kbæ»ñMàl—È<ØÎÁŒÞ–1…Óúˆr‚Sz_7.iüŠëÄe;om€÷¶¤5eËh¼ðAî?Þ8{„óôg»@ß±5×:ÑX|M”7Õ`8'gÓZz$°•¹øn—lÌ?V(Œ~¯òʨÎßÞÊÆñFê~‚M¸ xaÄ Câ“_YJ]#pÝ,ë,{?>ìžlÑg›¬7ÀÆ-¹8TëÛ£}ÌåŸ.=njg¦ ›€úØÖE>hl±¦(þÑÏ):‡ËàÞ`?áÕ»c›¢ÖÝË¢™¡ýDŸpå›.|“`íU4'ëäÖ×aãl³Ýž?™-:;VßXQܬA²º+ç ÀsmRœDH€ûzc‘WÍÝ2.÷ý‰¹8Ç»¬qH6mÙÎUÜ^“€—îœé÷U»“yúH­'ÁjÂàI ]&šÊsˆÊ„lwè` °Mœ—…ähŒo»Ü2±•ok£á.T¶´÷Æn~7E>À OÖ±‰²*‡´ ÀïV æ.÷*çì t{nŠ÷òì> ŽóF´ÝÎpœ, LQ8ipû˱ ÿ†¥[æÉ€³ìêÊ H°õé×8€ÎptÌ­jÁ‰Z‡ö&/ê!~¯ò™h¬íÖ²ëšÊ?£±ÀÙ -´¼åÍ!ÎÀ!Þ¯×)e¶a"³>T0•ƒç'¡jyåÉ~E`†ÚOº?‡lÝ å´Ú¾Ìn€?‰(MÛ§}G ûíøpß)‘U÷dƒØÚû,"›ÚÖîܨñ¼JËÀðø(­ÙCíÒ÷ŸŒ¢Æ»Ê7}&k¦éhR¬}Šß´lç(;v õB£Ø'“Tùg.³K´zŽƒç~jøÜ'4V¹è¹Ò—+¾Ü˜~e>Ü2î?;‰Ö/}y9žŽc3AÀ…Àc[Þê _Á×íJóÿoðj¤&ÿ½e–ùD¢¨ðAl]¤ÕµZë3F£¾à¨kñþ€Z½ÙÅzœÚÛeòàˆü$»úÍò¬ß[-*ÜŽŽ¹?ÚÏ=ÁìԭΕ+³nlkË0ñîÏÑöC 6ƒè­^t l±‰ÖÙk¿£‰°¶oOøîáh–éVï#Žf¦ÞŸ4 VÔç{°¿ýó’ôž­Ü6F­·-¦ «eŒOö¾Gam&ÀØ£ÈpvùŽÊ‰áXŸh¿sýD±tÔg|„wrÍQm™Yµ^Ñ ¬cûÉì¯.|ÅÑ'] [Þj³³¶Žݱ5âhÒ›6 V‹œqr?qz["ÒQê9¯Oh3Dóoõ2·ŒËÝL‚µñæ¥ïˆAkS´Ì×ÑäU÷„ÛéµFš:kͽ?~<Í4-PŽ·Ï&ÅB½#? ]æÙ‹fY¶çq»^s”mÓ„WÑ ÏaÏOxúÆ 1ì€ÍèÞò­s°3yAÂòaÎû¿ö¯U¢U·à¤(mÒÄ2ÁD6­Ôâc€µ}MÞÙèg… Þ9Œ C~–æ6fbÎ5F·½íÚÚŸÆsçû¾qlv}ÍÒ?ðVïç÷îhyž;]ÎëØ]-SPøáè•Šð¨ HQT5ç[Xä£ÇÇç#ùôòííÍ1Ý!í/œ\ ¡¤ =žîÄ¡¶”©9šì&#„Š_z‡·ÍÜÞª<`¸BE©(ºÚlï掠bà{ÔG?Ó‹B­Þi«dñè¬Æõùq‚Á„9¡âVÔðU¯÷„‡éÑ„yõa—g„PQ°Â‰b…|f_F!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!T¼ºîºë¶gÌa©±íä¬'òù€|€ååy¼@^ /”B%ç>þøc,%¦ÿ«'ò€ûÏMXʬ»ó‚ö÷îî­Xʬ'Ê„((ðð`ØÆ` Æ`c0c0ŒÀŒÀÆ` Æ`€1€ŒÀŒÀ0c0#€1€` Æ` F0c0“™ÉÄTnTn8¼€1€1˜Ì\²™¸²²rÄرc§VTTGåVº•[gó$/B”Å[à#à#t5/à‹À0Vp™8S˜ÍȘ‹ls>…[±Wn›_ÚÕ¿°À57¾”MÛ¾i¹OkÚ¶¢(+·X>øm¾ù ˜ÃUëW¸'ëõŸ–öê[/ù´ç^}F¨„ʃõÛêzö76nðiËV=U´åAgë†böäÈ_`iò”&ÿ¡X¸³þ"¾8 ÷‘]qÅnåÊ•þûŒ3ÜŽ;ÈÄɚ˧pKcåöØü7aìÕÙŠêÞ;o̹î‹usÝ嗜ﷱ´×^ZäÆŒºÜÕüxl)pÞù mΞœ×s¿=Ƚ½k“ÿ=ªª,çºO?ÿ¸{S…»âÚËZm?¥f²;ëŸÏ€*Ö³lPÛVy°ºáwïÜŸ¶zöÅJë×ÿ¥ÀEë#\/¼à,·÷ÿ{Rõð6×ýÑ-å®|Ä¥Ù´Æ-uî»&¹óÏ=£T8ï¼6¿yùò宬¬Ì/ˆ`”ÊÌ|Ê)§¸ÁƒûïÇw[¶lq»wïv<òˆ›:uª[¿~½_¶víZÿ]™}É’%Ùí_yå7eÊÿP¤íÚõG…V¢UUUÕç(Ðrni¬Ü®'žpŒ¯¸Ôz«Šk_ó:¶ÅaË­ÖØ :ÍÜV^èl>H›³§hÍ?}õh7õ§S²Î¯>Y6?»Nø]ë‡lQ`¡âà#ŽüRö·çZ_››*ÂuÚKK‹á#´˜¢·òüÙ­þ·¬ÄÃÆñpý€-2œf6¿yÞ¼yîðÃw+V¬ð¼ nPú¦M›<Ì™3Ç3„Ármmm«àZss³›5k–›9s¦kll€ླAƒù ,À5ž0a‚Ï°‚[ò¶mÛ<ä0ÀG‹õ©õ´ÍСC]CCƒ$×ÕÕ¥êÚËËË]VGìeÝÃ4ðCÜ殺|p€íÓ*³n‹€»9/ø|FVT·ÿ§ºß}°%븆løF¨ø#À\tžðÚs­g^ÏyÜã#|´wÜ–©N=ÁG dC  ¿#÷T^H#Ož<Ù 6, À‚ÛÓN;-«¬¬ôërÈ!>¦mìZÅ ‚bñ‚ø€û€ÙÈ pmùÝwßí,Xà3µ2±EŠÕú£Œ­‡@Ë”©õY‚à2¶0³îàšššO¥5¬ K¼fÅÃ% ÀÝþ8žÒÀ7þ°ÚMžvs«îŒ0B¥ ÀzÎÕý¹¸›|„Óî#˜ °êúRàžòÓÀ2ùþê *#Üwß}ÙuÃú<úè£ý§¸Â`WÑc±‚Lß`¸OXŸÊÌú®ŒªÌ«n JWKZk’XQbezm#kjj*•1À­*´´ï1–]rñ¹YyÍwýòç–þ¼è¸“c€ÿÚV>H+kò9­q~sÇ:¡`}žñÍÓÝIýNlÀê%rü‰Ç5wÁGøk1ùÀ{wÕ»Ag÷Ï‚¬¾ëSéÅÀ]È {ÛÊ i`õµ¤2i0±ÃÀsðñÇŸe ÷9«ksæ|†Tÿ|E„¿¬þüIl°¬¾üŠ«+tpÎ ­XØ*4U\êæÔïä¯ùnOšüÂàVŸªÄ‰°Ô*¬ßJ·1BE Àÿ™±GóÉi`}¯¨.÷ãõýÂï|ÛÿvÕ%YgVb9ÂrŠm›‡Ÿ˜ã#E_>êÈ,HÀ¥€õlË?Ð÷I?¾Ñ—C¿÷?F8,;Âg_“g…i5.bλnH+ë»|‚cŽ>ÒW½?ù¦2ßX~ñ…çdÃåC¨»´m£FtMœ¥í ¤‹€å/>’O^H+ëûyççy@Á/A¯˜aÈ!îñÇÏ Àb©mÔ»T¬À}fá¬Ï6– hW~û­ ¾k×.ÿ]×-B¬4Á³ºQÛºEÀãóÞ´WnªŒlvG}ßÓ´Æ×çƵO¸7d+,µâšÙ«vm_™MÓ÷"àN僴9{šýÙ Uß×nY“ý®W™èS3»Ú ¯rhÍ,B¦)B#”^¶çÝzwØ÷gW×úçÝ–«Üˆ?ûš(+L³Ùå‹ €KÂG`>€¾[=¯ïo¼²Øšß ¿ ôÌ—ÓäS!w*/¤äó ˆ l"+1X d ͤO±A˜®`™Öe,+¢LÌK{S©8¼¥nTlÆz²<ÀGÀG€`€1€ŒÀŒÀ0c0#€1€` Æ` F0c0ÀŒÀŒ` Æ` €1€1ÀŒÀLf&S¹Q¹áðâð"Dy€á#`0ç¡#FüY7K‡]ýõ{»;”•ü ÷6•ÖLY€é£&C=àè6ó|¥ÏFfêsüD¬§ê†²²2üÅÚðáÃ?¤VC!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B½ ²²²Lž3fL·Oe^^~ý¸·©´íÝ™F–¤,HçkOvR“¡î–Êž¯¾*qÔõè~?‘º!VÖuèQ£ðÓùJ¬÷¨Õ®äxIt‰¿Ìš—Üó’{ËïîÞŠ¥ÌxÁ=ê)߀ç‹òf€` Æ` F0c0ÀŒÀŒ` Æ` €1€1ÀŒÀ c0c0€1€1Æ` Æ`c0c0™™L×رc«26£ººú*·Ò­Ü:›p qx¢<(Þò¡«y_€±BàsÛŸ±…ãÆëGåV’Ü©|€ #DyPÔŒ€Ð¥¼€/ÀyÚ AƒÜñÇï¶mÛÖ*}È!nåÊ•ínŸ´ÎI'ä†Þæöwß}·{üñÇsîsèС¾–ææf÷Ê+¯´Jkhhðçrøᇇ¶ª²²rH±Un/ÖÍML¿øÂsÜƵO´»ýk/-*îP>H£Ã÷ȲùnsSÃAécoªp÷Îýi»Û?öì"¡")ž{õ·ºá…ƒÒgÿê~7²âº¼¶_¿­¾¸è}Õñûš×”^óã±î¡n+i¡+y¡§ýÜyó湸 &´J¯««sÆ kwûM›6¹;v´Ï´Ï¸i\ËtlCG¯gíÚµn×®]­Òf̘áì¦L™{X¼eË–ƒ2sâR×´mÅAé›_Ú5n©+i¡+þbo0Ê+òµó šÉ÷×öqÎÅ¡}ôÑmãt½]Gœìàà+®¸ÂGLÃL:sæL•Õ2¥«ÕDÛzè¡þSé¹`sõêÕî¼óÎóÛ—••¹Ý»wûŒ¥m”¦Ö$A¯íÓ̶×6W_}µß‡Z”¶dÉߤVŸ ¸åË—ûýè¼µí 7ÜÐë¬óŒ ­DËXõ¹ ´ `û(÷QL|íU¹#¾ôEWÿ‚lÚwMrW]>Ø/Ûúæ2ÈÚö ‡~ÞNªžÊëo+/ä“2öqf½;Ã|P,<ªªÌ{üW½3li žšç.¸è<ïà>ðð½>Ê£m?ýéOûOŒPñ°~÷?ãTÿì[šÊŒs¾5ЧUßRåÓ†~ï;î°Ãs'õ;Ñ—jDKÛõw‡Õ 3Óî#$ð½wÞèN<á¶4ù ê9¦õ—,šéš_jå#¤„{Ê_ì –ÿ÷ÛåUUë=Ú§É/ÄžrÊ)~]m— €uäßËÏ7°VoU1ƒ¶5kVvŸú­ý³ˆ9tlm?yòdŸ¦€ž1‡–…¬#vÐ>Ä 0`ŸiCVQ¦êLØWßõ (Ó+cYÆTwƒGy$qŠOš4)Û“yà=@«›uBûàÇæ×´`5‚«¡üÀÇ øyä…¾ŠÇýlë÷Ó󉋬;´@Z ¡ï ¸é·à´ÓN˹_‡1‡gŠ ßwß}~è%`¸Ã¬å‚OeÄ°›C¾lß• ± »@ëÓZsâû°ñ:Ùœ9süxå¤ãö5w¦E/“öß±´=šð “>¸¦¦æSÅÖ:Àêê4fÔånÐÙý[pÚ+·ND€ÿÑ^>(fÖ8aEzúõÿ†»kö0B% Àj›~ïí¾üǧ€;õûG1úù°†LÝq[…xæ)nÑCÓJÂGèJ^(6ÿ]ó …ëæÀq&0Ø »@+Šœ €)6f €u¿ãÇ€à¼ØZSÔõغ3XFÓ²°•'þ¨»ö¥IªìXÊXÊàJÓ²~ýúÄɺ2h=ëÆ`m©»‚Z‚l@½2¹­ou*ð1À­ ±bß# Uå&Û»«>'Û²åOÞçÆU\™Mïwò×Üþݼ•Ðà6óAZøéç÷n8yM€76nðŸoîXç»8Zúß<ÝoÀN'«§‡žiûÍÀ*Á²ãO<®UO ‘Ð÷4– ø­XYÉGP·æ\l>ž¦5¾{´¥_xÁY~Ûbôº’ €åƒË?·h­ùéêñi‘XóÓãlÃ&åË+,xUú‘Gé÷§ãÇ'Ü ؘ#~ íGû 'ýU`Ï&ä5΀K€m†d3Á­ 2LSÄU몲@UýíÃÜ”q´žuSN‚M­¯LÎÒ¦ ®Ì¨mã^)ƒ‡ûP÷hõÛ×8`›åYcâñí•É•¦‡¬À8g!V •Ûä›Ê|'{néÏ}åe¿eÖ’û£[Êýøus +ÁÚÅwûõ4&¨È8ï|F‡wò´›½c+Ów¥UT—gÓôÝ€øÂï|Û§…“á,[õ”ï :Ç0Â7HgyððszöÕãÃÒì9×ìñó;äÒ‹ü6¶½Ñ®uµ_oÕúÅÀEí#È0ÀêùÐoÐwâË/9ß¼æ»­Þ ¡ïê=¦uK€óÎ =íçÊ·Ácñˆ«||ùìòÝÃ!ŽZ&ŽÐz6¬2i °ùýb ƒX ›4Þˆ¹´Ì WÌ¡cˆYl¨¥õ@Õöâ‘OŒ%ÄDp‰E€»Û4h]QÞ|f‘MQ`™Z‡B îŠ©EGçvÃîCŸO!V •ïøk€;•x&ŒåAQ¿¡Ky!Ì øÕD»ñ×±æcµµµžäãwfè$ À`¸Ã&€UÆ gTË÷}\ÚN­4ŠwǹXwëÞÈÈ=‘‰©ÜŠ³rÃáÅáEˆò€ò¡Ô™Á|ÿ¤IªzŠ7Úò¤±Ê0ŒÀŒÀÆ` Æ`23™˜Ê €1ÀŒÀLf&S¹Q¹áðâð"Dy@y€€3`ø df21••//B””øø0ìc0ã@âð"Dy@y€€3ÀŬ²²²¿èÆ`é°1cÆü½»ó@ù¨ëÿƽM¥5wg>Y6’² …¦ÿš õ€£ÛÌó•>»>SŸw¿ŸHÝF+ëºaÔ¨Qø‹iôFŽÜM­†B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„zAÇßÁᩚʼ±»óÀˆÃßãÞ¦Ò¶S`úߨÉPwKå ÏWúLõ9~"ÖSuÈ#ðÉ ESÉñ’è™5/¹ç%÷–ÞݽK™ñ‚{ÔS¾Ïå>>Ì;ÀŒÀŒ` Æ` €1€1ÀŒÀ c0c0€1€1Æ` Æ`c0c0ŒÀŒÀÆ` Æ`23™˜ÊÊ ‡‡—š ÀŒÀLf.ÉL\YY9bìرS+**Ž£r+ÝÊ­³ù‡!ʃâ-ððºšðÅà’à;v¸•+Wf¿òÊ+nÓ¦MÚ×¼yóÜ”)SÜŠ+ú<“èšvíÚ•¸L×·víÚn9Žö£k¾ûî»»5g ³s²ªªª-ùnTnÅW¹…ù c¿Í7à@ÀQoy«ÞÆG(]ÐY¿wùòåYÿº¹¹Ù-Y²¤SûÙ²e‹÷Ÿe}Í ºž…â¦kܽ{w·K¼ kî ‡à'tcf¬><û{„ î‘Giw»Aƒ%¦)C755µ¹íœ9sò:FWLפsIZ¶`Á7iÒ¤NÁntõÐè8G}tpÌ6ç*ÜÒ^¹õ;ùknë›ËÜþÝü÷7^Y çÈm5Š¤ÝávÕ%î‡ïõ߇~ï;îÎû§ãð"T¢<õ§S\Eu¹ÿ>¥frö;ܹº!Íuå˜Q—»EMóßG^ó]÷àÏn€»à/vÖ¿6_ß vàÀyAóÌ™3ân¸!§¯ÚàÁƒ{”t! ÅMטÏy&±HuŽJÓù†¼£4Ý'c%Ý«¤(·Ž ÷ë0`€Ï<ú €•Qã­Êl£Gö`©îÑê Œrä‘Gf€\¬ý2įÓÐÐ=†€XÇQºe²C9Ä?0ÊÔzP:’!Î;ï<Ïê¾pÊ)§ø.º¦+®¸Â÷´ÓNó™TRÇTæ´kÖC`Ñb­¯}h{m£eëׯ÷ÛÊ´µVÅ£Üàòòr—GÕ{YבöÊí’‹ÏõŸª¸~ó̃nû¦ånóëOûÏO8ÆWvªÐËJ¿ü’ó}E—êëîÞ¼àóAš?E}GV\çmú½·{XpûdÝ£zÇÏ®®õ¿¿|Ô‘‚'O»ÙC0ŒPq°Äôl[ypÖ?ŸéÓõÜ«<¨¾¥ÊC°Ò>{Èg}‘OÍsç~{Pª¯!ÙG˜T=ÜM{µ{l~‡Þ½»ê³åòô]ö•/î^¬›ëÐÕXŽpp^èˆÏ*Ÿ]'ÿW~¶>å+Ç#Àòéµ\¾¼ügùüòŸµ}ÜN`ùÿò絞¶µcs(zj`*?]œ¡m:ÒX¾ý°aÃ<׈oî»ï>¿oA¶a‚`«±LÌd¼£hôêÕ«=/ˆq”¦mtOmˆ¥±’mÀ}ÀÊtÖ8Þ:þ§(ƒ)Æ÷‘|qV&Wš2˜àÙÒ•qã|¸¿Ždd=XáçmvVF#¶á5WVVúï:'=DjÕQ¦VzÒ}Ë5V¡"ÀÉØÂ̺ƒkjj>•æÖ]U^¾ã*®ô•›lOÓ¼ZvÄ—¾è×Óo-ÓvúTWâàâù ÍŽŸ\îIýNô®`ExäØê»Ò¿2ý¶hð#T„¼jý wØᇹ7w¬sýÏ8Õ§Ïyt–»nÔÕtÕHfe‡mgë•xø£bñd^p–oøVc¸ù >npó¼ÝWÏ1ù`ý6ßââ Ï!œà/v´Û³±@Ø:îû[d5×AíùÔŠæʧ”†óøÄ}ì#òzš˜Àz† Xåû‡] uÜ8ÏØ5‹9¨î¿øÅl .Œ·Õ3îCàYëF MúSÔÒa-.àhÒöÀ2Ûà\ƒí“L¤Z›ÂóU& X-=j‰J`uuˆà¬'E¡µÖïVZ±Œï±ÊL^uW2Vš"ÁÖE:ÀÜ5)Ûí©”Æglo[ù í¬O9»Àw;ÓwkTº">q^¶ê)!€*.V+¬|xîÕg<øª[´"ÁqVúß<½$Ç·W7¤¹®<ÿÜ3ü§ÆÍg°H°ÒéðƵOø±Ã%:øã¶òBG{Z 2Ù<餓r°"£öΰ¨"Æ!›{ì±98>±o{ñÊ×Nó÷ð X¼ nH`ë!ߧ"ÁIÁ;m—4yÜGl Zizö§ë·Z^dêŽlãcÂW† 3ªZÑVé$¶– m«}Èê´*Ýf]Ë:¶€¹½Ì¬îËzè¬åIQg]—>ãÑÜ€­‹‚ö¡m­«¶2³ÖÑõY¦ÖƒuüñÇûuÃñ½À9+´b©ÜÔª«È¯ýV%&¸ì^{ÕE¾;îØ£²¬–`V—iAs‰ðß2öH>ù ÍŽŸñ³ÈîK/r,›ï[A®";ÀÿôÕ£=kÙê†`„Š¬<£ºö[å‚z‚¨QL k¬(±ÒÍê]BœwÝöyBÂFsEv5Jéê­O`ù òÍ[êJ €óö;ú–˜†Ð’ÿ.?ùðÃ÷ŸòŸ{ZOþxè?k}stJ`m£4ùôŠ‡]£åÏÛú¹XA³O}êSíÎd~¿¸Eç­@Ÿù÷‚ý8̆Qo­cóÙÄ^ºº/qVRo[ݳxTî#6Ö®Ìja{ý¶¾ê‚½øLÇñ®ÐZ?Œ'E€mñkûLŠ2k=TÖRÓÞëœÂs¶}&uIÐÃFrmŒA|û¤}Úºñ¨tðø| ±b©Ü±Ëc¿¶ß»¶¯ô¿Õê«îNªÔÇJ/Y ;•Òìø…“רë³ýVH¦ñÀŠð€Çr†m¡â-Âß7ø‰òôìë»ÒÃ*T>”À,Ð%å#È4ù•}—/`¿åÈä'ÈÀš,K¬õJ`èNå…μ6U¾¯üjùçÆf!#ÈÿŽû϶¾ùÏIll仇~ºÖKêª.Íí|(~Îv~I[ÁmxBgêùEMs—_r¾{ðg·ÀÌ i󛯸âŠNoÛØØè†îN9åî[[±b…›2eŠÛµk—·pÙŽ;\ssóA™7¾Þ¼yóü>J€3Ù?‚ß[«ªª*ÊËË?Sè•[ÍǺÝRîž[úswâ Ǹ=Mk²Ëvm_™Xø¸á }Ô¿° UÚÞ]õn_óºƒÒdñ}&'­ËÛråƒBs枬{Ô]qíeî‘eó=È>öì¢Vpüö®M­ÖsÇ:·¹©á ‡ùÆV·JÓvZ7ž¦}ÆÏAëuÔÑ.pþï|Ê„B¼…ËVºq7ßÞ¥}üdÖü.ï£8­åì¤~'úráºQW»ê[ª²é7x ×UYÎ_}ë%wÖ?ŸyÐ~×nYÓê·žy­_OûŒ—1EÀíæ…B«U·_|á9îź¹þó7Ï<˜]&aÿî íÖýÚ‡ü„0MÛ…þ†¥ÉLjŸCÒqÒ Àùú‹ió› ”e„0]¼OÛ½{·Û¶m[Î}ÀpŸð€Ü!C|‹ÌÊ•+}†:t¨»úê«ÝÀ]mm­_wôèÑnØ°a>ã*ò[ \VVæ¢B+Ñ2V}•›r»Ãq… ÀjÙÕwUn‚Q™¢ºå#.uÏ<ÅG†U¡]xÁYÙ´kŸÈ À?VíÆŒºÜïoÉ¢™>M­¿#¯ù®ß‡–+MÇPÚU—ö-Ä…X¹uG>ÈØ_âù ØàUŸŠàÈ1½ð;ßvîºÄñÍÓ}$È;~‡xÈ¥yçV‘ß\¬õµ½ÀzTU™OXk[E†Úv<}×qŽ?ñ¸ƒ`»¬½|Ð2áÃx^(D2ì*wÁKÜ9çÿ‹[óÖÎld÷[ƒ/öé+Öý6 º¶ÞS¿Y›€U¾ð»—ûu-2ü賫ýþ´í-wÜÕj;¥}ïºQ Àmå…<óÀG…^È ^ç<:ËUT—ûïa=¿z^§ß{»O»óþéî‚‹ÎóϺ­—À«^pç|k / ´¾Ê5„i*#úõÿ†k•EýÏ8Õ§ ³®® ïOOÕ …Àª÷­n¯]|·oW½­ú{ÐÙý³P]u»"¿¹xÍŠ‡}¯ýjK»öª‹¼Éw0ßBßu5ÐÇÁ: >BWüÅ4°X@‘`±‚ÒÄ çwžOOˆ#^yå¿®XBŸMMM0\XlÝ¿‚Ü%K–dV­9äµk×ún Ö¢süñÇ———»<*¯\Ù?bi÷qîS!°*–§ì+UlêÖ¬Ö^-WdX⇸ÍÍðöl·iUrI¬Ö_ƒæÆ-u~¿aôXiª €­KÕqÇUÜ•|`Ù|Pˆü壎ô ûO_=Ú;¦‚`Zý–SúÜ«ÏxgÕ"7ÇÿÕœ¬õW­_áa9²!’“«49¼Àr¢õ]û~vumÁÝŸnέòB!ð7]à÷¸»~±ÈUÞt››÷d»¶¼Ê/è fµX¥½Ø°ÃvæÙ9xÀÙçzÞô{Ýɧžî?µ[~Ü×OöŸÚƶ,¿°á‚»?ݘ ¶<ýÏC?ïö°Ãóåƒ"·Öh%Sc•Ê=Û–&ÀµÞqÖ³­2EéjDSoëbi:ŽõF±¡*W ñþôTÝPˆ|Ä—¾èëëcŽ>Ò×ã^ùa¿õÍe^•&?B~E.ÖúÛ7-÷~‚Ú"ÁÚ—ÒÌoÐ6÷ÞycK]œå×^ZTt>B[þb¸¡¡ÁôŠ,³Þ¡™kuË—/÷p¼iÓ&Ÿ6sæL7kÖ,.¼.Ðú® ­‡Q@Fx»ZoòäÉ­ÒJ8üÇ~ïÑ„™u×ÔÔ|ªÐ#Àã*®ô­»ªhT9ì*š«õ ŠUI)’›Àª¼úü5Ÿ&³q?Úç¤êá>-`w¬Šµˆ"Ào/rxö¯î÷ΨÏ0Â+ØÕzawȶXŽ±~› |µ?Eõ[Àm¬ýš“lß‹!œIûïöòB!w~â¹WýxÞñ?œî¡ÖÖÄ ŽCÈýú7NÍ ÀŸÿŸ‡úýÈ,ª¼`éór•öÅÿõ¥,ëøú®ôBàŽF€óÉ…øêYÖܦ25–%A®ElãË,úkåÓž~þqŸ®ßZ×Øʇ\D࿧ÍG#Àòä'Èg°q™€Uë[Z.}™| EŒÕ°®ßæ„þ‰Î!>Ô*åàýíå…´v¶ñÀ[¶lñliâGyį§€™qÂŒ3`¸°X­5j¹¹á†|¦U·µê(M <5ÜÁº¡Cy!¬¨¯‚f¾Šö*ê+FPš–‹ õKh¹z’jœ°€Y=KõŸS€{Í”YÙUë–à×ÒÕ ZÑ`µØX Ž`Yëi}ë˯ٟÕÚ#KãLÐœà"g!–†ÊÍZa­{‘º/ pUá¨â²uU)M€la…­¸V¡©rT…¨u-Mmû³4íÏ&Å*Ô"{*š3''Õ"3Š‡³¹ J'O»9;A•Ôï¼ÒG‚m29±¶½Í-'XëØöJ“£¬mõÛŽ£ý [É"à¼óB!Î-°U7çÑÕ·øîÊ2°6˜°Ú8^m§´ë«&fÇûê»÷ð œ ¤ÉÚV «tK«]µ>;æ8Í)àÔ–Ö0%ÓX_›ŒJbê¢Æ0ëꬱ½#+®ó¦ïöÇ{¨üÐs¯ò@ÛkŸÚ‡Íô[åž}™5‚©¼Á$X©õ¨VÇÛø_¥:]]”ml®|õ»ã¶Šl·fÕóñaZ¦ul{¥©Ñ\Ûê·ùòOÔ ÍŽ×™7Uà$Xyç…´ùÍâ —œ4iR6ð%–P°Léz»ŒÒ·bqƒàXi‚^c™ €±Âàñùb¼ã¯è_ƒÔ©|À{4‹ò5HÊ ¼[·¨f¦< LÀGÀGè–¼€/ÀXQdd*·â¬Ü:“p ‹€;›€Êâ`ÊÊ||˜n@df22••/Î. SP&à#à#À pŒÀŒÀ@%Ì3F™€€3À 0c0c0c0ÀŒÀŒÀŒÀ c0c0c0cp_jôèÑÿ¥›ƒ¥ÃÊÊÊþÒÝy rÌè¿soÓeåå×ÿµ»óÁ*FïçÞ¦,Œ.ÿ¯ž¨**ÇþîoºìcþÞy`Tù¨ÿ侦Қ»½n= ?1måAæ?뉺a̘1ø‹©óËÿÚE!„B!„B!„B!„B!„B!„B!„B!„B!„B¨4räÈFfIK >|¹!„B!„:!ÞéUÚïóÊìo; ©´í䬻óù¼jÄÈ4§ÌôŸu{>1ü=î-ê…”– #F¼íÀpÂÿÏKãyɽö÷îî­Xʬ§^p¯ýnþã>,EÖyr2??^€` Æ` Æ` Æ` €1€1€1€1Æ` Æ` Æ` Æ`€1€1€1€` Æ` Æ` Æ` &C“‘C;¶*c3ª«« b£bÃÑÅÙ€`ÊÊ?^€PdèM›6¹yóæ¹åË—·Jollt<òH§ö¹eË7eÊo–ßwœãÝwßí±víÚBàsÛŸ±…ãÆëGÅVz[eeåˆÌÿ?µ¢¢â8]œÝÎæ ²¸˜r2¡+ù€z·¸ü„ªªªk26%“N€`¸—lÇŽt tt^}õÕínÿøã» ´J[±b…»á†<[Z|ÿ=Gí3¾mÛ¶¹™3gz8.`mU¦ÂRH[ã–:·§iMATo¼²ØÕ¿°ÀíÝU_4[,lÎÇÙé G÷Õ·^r›› Âi\¶ê)÷dÝ£ncㆢàÎ懾„¹5oíôÖÙíŸxîU·pÙÊ.í#n>»ÚýdÖ|ÿiióž¬óiµ«Ö<§¡\xsÇ:7ûW÷ijõܫϸ{çþÔ=²l~Q• ±|ðÛ|óAo×q/ÖÍuûš×D}ûØüo…r>Ýí'd@¸)ó9;ó9¸¦¦æS…Àò¹e»víj•^WWçýõÎì3ÐÒgg÷žc¸q„ŽÑWÌ`‹Ž@5„K‹à*CÆawøðáÙÈ®2ÑСC½…×2Y¸­ö?kÖ,7zôh×vœ &¸ faY‘çÉ“'ûõ^y啃ö‘+“÷Å}+++sQÁue ¯ú6ÛšY^Q^^þ™ÞªØ&UOLyÍw}eÒÞö?º¥<¯ŠéªË»K.>×Ý{ç>ÇåOÞç.¿ä|ÁE À.§·'ÝQUe‰éC.½ÈÝ5ûÎv·¯¾¥ªÝu䨞õÏgºs¿=ÈMý锟£¶Ñö‚à"à¼óC_Âœ RÖÙíXó37àìs»´¸ ûþwï¼Ç\]ý[Ù4ïèê[ܸ›oO÷i¹0çÑY‰Ï鳫kÝ÷G^™×óªg¾½õNêw¢»âÚËü³­F®Ž6РƵmpÞù §ê²Ag÷OL¿øÂsÜÖ7—µ¹msãKÞŸhï“o*óÇ9ÿÜ3ÜO§Uwøåô?õ×´mEÑû ßø¿2ŸK£ž‡ ËÇúèlšàV™É–YdVXY˜q“øÓŸþ´U=ÚÏîݻ݀\CCƒÝÓN;ͯ§eZG|Ê)§´ja*4άkrÛµL¡öa8N¸'+6U6I­º‚VE-mÿî >í»&¹Í¯?í[YõûĎɶ¼†ûؾiyvk~<6»\æƵOøïÚö÷ÚK‹ZEž•¦s÷§}„¬ãÏðv¿_›ó¡nófÑkí[¢öiõ®í+Ý·U¸7ôhÅÖ…†Dg§'8ÉTTEìꆲi¿û`‹wŒ•¾jý Ö÷cÿªÿŒ;¼Zgò´›ý÷Xí—kç|k Þ(ý7ëê|ºëбUZvµ0íí]›¼¬sÒ~mÛ¾×›E‹u-ë·Õ·º­7éÇ7ö¸³ÛV>h+?dÊ´—ú€§Þó œ –>ŸM_±î·EaåUš¢±á>¥!oú½îùKü>÷ø´v¸»~±ÈÛºmÊFz_ØðŽßö™—Z°Ò“ε¸½¼PHå‚ž=oñˆ«Òâ`¬F2A¬­o]~çÛ>Ížu‹ +]ŸaÙóس‹ü>ô]ÏèÈŠë¼é9UšžßŠêrwݨ«[íOËãå×ô{o÷ûZðÔ<ÿ[åÔØ›*|Ú÷OÏn§åÚ§–©,QºŽ©séË2¡³ù §ê²cŽ>ò 4Õɲ8õ]u«`VßUÇ«‘]Û‡~@Ø8®úZßËG\šÝ—ü }ªŽÖ:ÚÇš·jWš>ãþLx>ò ´žŽaõýožyПŸ Û¢Å:†¥kótÎ= ÀÝà'ÈØkÖUº¯»@+°EpÃ4õÒT@K=BÅ\;ôÐC ²Åý{-Ÿ3gŽßVÁ7KWSÍjkk³iú®´xoTcDÀpN6 Xà{Þyçùžp,n€æŠÇ[z®¸âŠVËõ°Š-MQà°5©ˆ"ÀqÓ8á{ô°ö&«ÒRd7¬¬T‰8¡IA§µ¸ê3„SÁ«@W-¿VQjJ×ñTé¨2³¨®"ê|¿^p–_6fÔåÙŠ1 €µ­ö§s²Öeý–-Y4Óß*ÕqWút«TeZGQéžì.ÕÕ†˜½¬|ÐÛ¬HOµr§ÔLö¢œÐ¶Xët帼j[®ÒµíÓÏ?î#Â:–Òô)ç÷Œožî¿Ëa•3› €åH €µŽW¥=üÄïØÊÑÕr»>íK ¬ˆS踻ê’íæÝÍùÀºÃݯüÐ×|Ô1ÇzXýæ  <”>õ›µ>ª+ ¾`È%f¿§y¶‡ß«FV¸[î¸+'½âZºë ¿{¹OS7é9-÷éÚ·î9çÿ‹O?æk'¤€{ /ôX¹ÀzNŽ_>êÈVC†~ï;¾Êžu}ªW‰ž÷p…ÄÂÆ/™•êm¢g[ Ú¯ÿ7üv*+ô]ë©LÐvJ?þÄã²À`•jØÒr•-*Ot|5´)Me‚ö£céØZ®sµnÝZWe‚rJÊ„—{ÒOH`¦êа^–? ÿAu¹†,©~H<ó¿¾ù‚QùaC´êj5T?ø³[}ýoõ¾@Uû“ï Æsù%ªÓµ¿k¯ºÈ=·ô牬ã+¢¬måKÌZ£¸|ëwܱGù{-3ßA¶è¡iÞ¿H‘ŸàÆŒãþíßþ­`Xþ»`5Î!C†¸Õ«Wûõ0³Ú‘Gé?µM[¬€˜‚dZ¦Ïûî»ÏMš4ÉÈ´o±ˆàW\¢ý‰ÔÓ€»€Ã±Á‚Tëî,øT+M¾¬.`= j[®°Ž“N:)›¦®Õí#îKîd××Ðöh‚,ëÑÛàp<ýV¢ŠA-®aä4¾}íâ»=Іë¨â°ª²S…¤ÊGX V…§ ÈZtUy †“X•¨µ(Ëúüµlº*P¥Y…¶*Ç»q©²S…mälÙýk<ô&›B­"?r ˜qMÚ^ΤœÏ,åLk[E[äÌÊqU4Ǻ=Ê)p+blΨ"¸r˜“XN¶a;G}·“œW­kŽºÎÏ"¿¡ó.ÓþúŸqjÖ¡.”p‚ý¿™õWVVö/”ðŒûæe¿ÿát7¢b|6Ê«nÈC†]å»: h•¦¨îɧžžÀŠî ¨­kõ—þ÷—³é:ŽÖýú7NÍ‚®"ÍúnP\Bà=½Q.$°Yø éÕ³.h #§Öã#\OÛ…=J¬ ´žA5®éùWy`‘`{vã«åÑñe:Á´ÖѾu*‡4LÃÒt{j¬s7僿ô–ŸÀV¿†¬ºWõ¶ÀÑ|Õ¿q?Aà) ¾/Õßò5T/ËЧíÇz  º­wšŽ-_" €ƪóuN:žƒصö£cÆý˜\>MG€e»2õÂ/5—L¡E€“º- Fåïë3ìÍ™ÄIlûÒwEwÃnׂ_¥ zm=ñ‰Î €ó2Áë°aÃÜá‡î3‹Æà.Y²Ä?äCü§Z^¼jeQ 2@VÛ¯_¿ÞwUÖz­Màc=ÖwQôj ¼Òô[Q`®Zv”6cÆ ß²£c©¥Giv>á9¦€[95½5¶'_¶®Ãj ÇóÄ¡R-¥ªXa +EÛ—*0kÁµŠS :aìÕ€m=+¬tâl-Ê2­«t¥iÂ,¥%px­ª\užaëqŒþ[ÆÍ•ú€­{¢œÕ¸“®#gW°«hl’C,ÈÕw°¢ÀIRWËÔ}Ù ÷‚‹ÎË À¡3k -¸Öï0ReNtÜy—c,gÙŽW@c€ÿ¿°lÈ”‰3ã¯N+¤1À\nÀꚬˆïfþÜ›ÒÖoÿ°°ÆXÑ\E|Í”®è±"Ê[}ƒnš¸ c?ÿÒVýЗvE¶È­~+ /;ôŒ†QaÙ¡2CXÚ^kC.´O5N…=7Ô(f]¨ã,‡Sȉ–Y/–¶XÇTD¸'‡Gt!|Ô~B¾,Óð#u%6ÀU}÷3TÿªQ<ìÂÖÕŠìª.LÛp&ùò+ä;h™u…Ç ‡¬ó’_?7AµüAt{¬FzCOŽ+îlÀ$“ÞPxk-”Y ó`™ÀWÃ$åïw€µ­¾‹U,ø& Vjq‚Aibð80Üm&ð »,ÄÇ ·¶.Iû4˜ª‡›ÏLoÀ9¡·7Ø"©ƒê‚¤ÊIf@ªîBjÕU¥V*ZGÛªr²4ëÞdS6pô žµ_}ª[µ*¤§ìÓ¬+´m¯óTeeçhûÓùYšÖQë±Ö³¨p«BÖþy.É-öe çÇóÉ= Àre­ê.¬ˆŒÌfY(šcl]Že‚T9Œawe9’\s<-¬O‹ ~õ]û”S«nŠrŽåôª{²Ö·¨’Ö±²A³7œ VÛ*¬ó¶¨p  uÌŽN¼Ó‹“`m×{Ãã“â+Â«è¬ ´~Ëï}hAª–)MÝ¢5†WQ_­§nÑê2mÛë÷÷®•…fu{®¼é6¿ÌÖÓþÐ×–We»;—”oýÐSlTÉœ*ôý³‡|6›¦çSЩßa¯=˶}8laí–5­†FvøaÙI°lÌ®ž]=ëz¾m>=çÝ5pÕ2ý¶}è|¿êÑ¡òIç¥4• *ô»½°Ê,•}4 ÖÞ¾ö>—ù¿U—Z,ÔwuVÏ0ù6‘•êk5^‡p«z_QXù¡Ÿ ˜µÆríOÒ‚_5²k¹†FÉ??¡:[½µ¥ò¬G™êsÛÕöG|é‹Ù†mm¯mä¯h]¥i{ùڟλ-–ÒÓä:è'hHÜ M”o -^X*¨% 5øTš‚aŠÒZ¯PÁ¨X@ë…=EôÒ2Î¥ †i=Ýì4\õ@ô*˜&VPÔWQf¥iú-~°sÔùØ9Àp›úü+ƒ…]zÂ4ƒ´2w8@¾€x|>•YoUl‚@Ãk“?Øk‡d‰‚Sý¶nËa%¦ŠÂZdã³?Z(;vVäVéáë–ô]iÕµ–Üø9j?vžvµ*Ûþì¼µ¾uq·7^ñÔù '_'bN¡Æé…¯’YwC-““‡FEh´žihrx-Rc‘Ú°»±MFc±Á©Ò Z­«rüÙú-7œ,Ç&½²óÖ§ÓÎ=³X`ürƆú{€5a•½ÊH‘]K€ h¾á$XJ gg#½öŠ"Û§ÆöZgE†õ[ûµõ´›$+|½QpA• ùš¢·IÏR®g,>ÑÖë–âcóuœ|_ƒ¦ò <Ž¶Ëg¬>çÖ \P~‚õ¶’©žUý¦Y}ªO['iIõ®ù¶m8µ¯xVë(ͶU?ÇÐÏ··mC?À|ˆð»öÝÓeæá'TY×æ\ ¡…Ä x™Y+L³–ͺrÙúa + J5T2þ*$E”ã‘g Âir]ýÖgÒ9À0V ™Üß î;›Òôª,Ö žáøÞ|óC_]¡™XÝ°g/ªm¿Š4§€)(ððà…Oìøã÷`N²Ûï/Ö1`€1+`gN6uÃVXŸaôYiö %€1+fn€1€1+€1€1˜ MF¦b£bÃÑÅÙ€`ÊÊüüxn@dh22Ž.Î. S.P&à'à'À pŒÀŒÀÌsF™€Ÿ€Ÿ/À ŧ²²²¿èæ`é°#Fü™Š €1€1€1¡jäÈá»iXHŸé#`ÝL×*ÿ÷7]–ùÏþÚíõCÙHÈÓV&dþ³î”ÒhÇÿ°›¸™ûš>S ÚA!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B!„B¡’ÔªU«–f¬ Ã0 K-í‰za\õÿÏu×]ç°ôØØqÕãA!„òàúŒ9 Ã0,uVßõ‚€jó÷a)2ýgx4!„ŒaÀ0B!„` Ã0€B!Ã0 €1!„€1 Ã0€B!Ã0 €1!„€1 Ã0€B!Ã0 €;euõo¹uÛþ#„BÆ0 €‹€‡}„[¸le^ë>0‰«]µF!„` Ã0 N'Ï{²ÎÝõ‹Eî™—|ÚìEµ®¡qÿþ†wÜS¿Yë×¹`È%ntõ-î'³æ»ë~ë—¯yk§ÿý賫S Àeeenìر3°ü¬ªªê<@„€1 Ã08µ<àìs}t÷ëß8ÕÕoù½»¶¼ÊÿÖòãݜǖ'°ºNŸvæÙ~™öcÛ¤ÉÊËËÀX F!Ã0 €S À –>ï¿ n»ŠkðÅnÓìu§œ~¦ÿÔòq7ßÞª»ô½ós~÷rÄã8Ýï‹pñZeee}Á3ðBÆ0¬ˆíÅ_ôƽ€‹€ j¯¯š˜ý®È®ÀVPlë € –eê6ý½ëFùmdšP‹1ÀÅ«„`„€KÃ6nÜèÞ{ï=÷ïÿþï8ÏX·ØæÍ›}žRÞ*Ôs\·nÛµk—Û»w¯·wß}·(ÿ‹7ÞxÃ}üñÇÞ^{íµ‚=Ï5kÖø󫯯ïjƒ°º9ÿ°ægîœóÿ%íü~öC²c}ml°ÖÑ2E‰5þWݦ§Þó Ÿ–Æ ²`!„PðÎ;³ŽôÿøG÷òË/·Z.Ç®¯œÐ 6øãÚù½óÎ;­–‡Ë€7¬;@ÆòÓ‡~X°çÙÜÜœ=OÙŸþô§^9®ŽWÏŸÎ¥±±Ñýë¿þk·oÓ¦MÙc­_¿¾àþ5¼}ðÁ­îÉž={ÜÛo¿ wÑÖoÿÐGo5‰•Á¯L¿»ñõ¹Z_ð«ß,0Ö8à4¾N €Bõ ËѸmÛ¶µZ.dz/œPER⎾"sá:æ|þùÏ.*³F EùÓÞ³—^zÉíÞ½Ûßû?üáý #¿:gE{ãØá³7Á°"¶ÝgØÀß¾XçÝÖýèd¯¸ SWè“O=½Uô—÷#!„à.°QEÂú€å@Z$. ’_}õÕ¢)ø*ô(d1«Už*Ôó ŸGboÛŽ«†Ý#Á¸zeXzg¢ÚºžBà×_ÝGÄß|óMŸgÔ¡ ;ßN6 ÀmØ‹ ;ZEƒ`#„êçSØ«»ô–-[Üûï¿ï~ÿûß»;väì&-¨V×@­+çPÇÐ8Ë$xÕ~Õ•PÇÔ:¹X˶nÝšè8Z_ÑUëï~÷;ïÀÇ×khhðç¦sÔ¹jÿñ›~+]®ý꺴ÏpܨOÝCµ¯|ƕ꺵_ûOtô[¦û÷Ö[oùïúLê.ªe:ý–c®ßú?äœë›ššü5å:]—€F×¢uÕ TäNÇر´]»å™ð>é?HŠ¾òÊ+>?i¹î™>5&7Þ-ßþw¯î‹Î3×~í¿²{¦ûby@ÛÅ÷­ÿTëk½¶®O÷GûIº—ºVOÿ¹ÖQ^³ÿQÛZž×±í™h+OÆǼÛó”?u~º†ðêwü:5¼@ÛêÚt•çuMm?Ü…e‡ÎÅîaÒsiyXùT–t=–‡ã¬sµÿN÷Mךë9×~íúµnب—”/tL­«{þG1uïb·t€`„B½À‚ër¬(°9Õ¹XË­»hÜ-q¨üè£ו“wd-ª¤1É¡ãà|#¥Ú¿ö•ÔmÓÆ.jÛ_Òz!™c®ã†c¨íürO¦õs9×὎›œ9þIQzíÏÆC :Ã{£ßñ®äIã©õ…cªÍô¿ üÚº¿1º¶¤c%•ŒGütŒ¤ãË´ÏàìÚt IyPÿ¯Ô½hoßö<„×Þõ…ÇÓ‘ë¿7S£‚þ?SÒùäÛ[#þ¼é™LÚ§]ÊvM‚ÎðšÚjLÊÀá3 »þx>ÕsæÓ\Ï›í?à¤{*ðŸ%+>N9W>óExþfzÖ:Z– ¦»81ŒÀ0B¡Þ`9Ä¡Ã)§°-6GSγK9×r¦ÍñµÈ¡> ~+‚9Š¡ó˜öcN²E“» ÀŠ¬Ù>á±èœŽc×v_Ôµë^¨QÀÎEÑX¥ð>ÙuÉ×qB€×¶ŠFé(ªdëçŠÀÊ×yÔé¾é·L÷%0ÂTx¬°klì!ôX£‚Î;ÞMU×kë…÷Ò®-lÀiøyÄuìþ„ -awÕö8Œ†€n >a´8ìn¿^[Oð¿îÎŒ™Õ³eéêÚnÞïøyÐçÓå7„E‡žýpßvÍáód½8ÂH±žw;^¾c€ÃsLºVýŸñóˆ÷( Ë pßú“À¸½‰¬Â†§0Ò®ÿ›Y 1F!”:9IS8¾Qïh²à,~ì v,­BAW8œ­5IðwzCÇÚ"Õ¡“6ÄgcÍì^·QmëºBp±÷ŽZC‚unkáõØý´ÿ(s,˶mS>éa£H|Œ±EBm¬hÒŸëÚ’À¨­‰”¬±G°–/'MÔîÛ \UÖè ãXZ Õ}×s”Ï«„rcyñý„çi^S||pgfÖõ†ÏlyV44lÊ5Ç@¾“`… mö?‡÷3Å ,ÚŸkßáó‘«¼×µý°w] 1F!”ŽG¹‹;Š!˜ä2ƒEë–™s¡Ó.2§Y`’Õ–n{>œÏ¬¹¡3_G燰¶ ª­q¼a7ÜÎp¸9ó¡sÂx®}$]O®±˜ñ1ÈÝÀáj,¨Iê6Ý'!Ê€Ãëî 'í[ç` ¤¼¯ÿÚ~Ç¡HÐB“u]î ‡çoTHÊß¹®)Öyê> zÕȣƊx9lŒP@ø;ŒvvèøÿœTNµµ¹ö>ípÒÌÐáÿÙ‰÷¦÷_?ªüo*,=–ùÏþŠG#„êEÒp¼]+MNcÜâ]q“"Àa”HP›ˆ…çÑQÎåІQïx8„ª¤p[,@Mº7íEÜÚ»®0’lÇ°ûs¾`2[WÿuÒù¶7tw°å„î›îcx/;n/ÒF€í.¶H¤öi0¤ÿF°›4k±®_ùÊf=—µ5éX.` ǹw4ÜQÎç?Ê‹6!—î³±»?w'‡ë¶N_Ü], 'ëêÄkªê©Å€BõÇ'”‰;ŠáØÐöœ¼pr©Ð± \[—`EŠä\Ç-„qý6hÊ€Ãî’ñÈ«"4êžBa|ö×°»wÒøÁ¸c/ì’Ü™÷‡c£s¤u+ÍÕ=<á¶ûáØÙø+Ÿò±î`ˇáøMR[,À óT˜×,þWá>Âÿ<º®°Aµ½¦'ßw ë:òy¦rc¹á¤^aw›¤ª78ÞÃ#©ûsüzâ¯÷ê‡÷/þ,„ùÛ¢²]आ,ýßá,ÜmM(##„*0ÖX¹XŽžE¬ir¾µL‘9ߊ‚ØxÀx4Y9ºa¤¤½Éfº: tصVßåØ Nµñ÷ Çg¤'M”wÌãÀ!°h¦®S ñqÃmÖ5Ë£z¡“žÔ­4×LÉa—[}ÚLµ!<àä¸Û{WuþíMÚÕl„ )º^›­­.ú] á7œ•9>Û¯¶Ïæ¿®p纗ֈ´Í\m3@'MÔÔgòÖ§½‡7é5]½Àa#C®|–3zÆlØCG8œÛ&M‹Ï6€u€µå3=«ZOy*|ÕW<Ò ##„*pŽGÔâ\9é¹ÞíŸM8œô(nùDI» À¹ÞY,ÇXx{ïPÕ¶ad´=–ë­íM(ïÊ›k²­xd<îlÛr9éI×othk\wG^ƒÔYŽƒªý?5I¬üvnëÍvñc¨!&¼w]àöÆ€TÅŸ­|ß?ÛV—á\ïr¶ë »`÷Ç–Â×åZ'×{€Û`ëÑ‘ëÝäú_óy†óàpÌqRyÑÞ»³`„`„B}ÀrääŒ'½ºC³"ºrÕ=9î¼Ê¡Ô2Eêä´*º©ˆK’ó§4EM,"¦ïIð˜ëý§:Çxd,_¶™@\€!SÔÐà×L]u?tv=ºîxWG]·¶—åzߧî S8íKÇÔ5 Rò‰ éZÕ8 ítOãçŽ[Nšq6¼7ºvíCi:Ÿ\F„®IÇ´uuïÛë­ýéâ]o-=–ô„÷BëÛý éÿ±}„ç^›€Åò•½7¤*ë?Ñõ)Ïê¿ŽÿZ®ã…ÝWs]Ÿ¢Ôº_º·ºÇaRyÇÆOëœ,:hcáõ*oY^Óu«a¤½¼¡ü¦ãé¸Iÿ‹Ò,Ÿk¿ÊCIûÕ½Ð5iÝ|Ë {;Òµ7œÙÞ“ôlêštÎaþlë9Óyë\âeö¥ó ï«þÓøõÇÿ»ð¹UšòT{“Xé<µ^ø¼èXùΪ ##„êN«…¯ÿioVåb´°ËlRãEGÒf¹¶ö¢õÝiaWòx#ƒ©Oš ®Tòi'£¢¥d=Àc*«>bfåtÙÆTîÆ£€BÀ­œê°«c®ÈR)À®±†pïp8æUç¦|j=$J1¯†ùTÝŸ\ÞŒñ`!„Ü Ç/ªkiØ…±,ìþ¬.˜mMüUÌÜÞØäÞ`ëB4U‘_q'&FJ­åÓý€1F!ç1žW0£1z¥ñëW—Ò\ׯ±§Z'>ιL‘V][>¯lÒý±Y¸{+¯è8ºïv\òéë%yý0À!„` Ã0 Æ`!„ŒaÀ0 #„€1 Ã`F0B!Ã0 €`!„Œa†À #„€1 Ã0¸pmÈ°«º´ý½ó€`„B0†až­yk§«ßòûìïgŸë÷´J“­Ûö'oñíµÞ¦ÿØ›ý}äWŽ€`„B0†a–]øÝËݵåU„•vÔ1ÇúôSN?Ó=0‰O]}‹ Ÿsþ¿¸Íü¹OöýÞ†^q­_WÛë÷g9$»,-÷¡¬¬ÌE`‡µcUUUõ0BÀ8’†apêø˜¯àžxîÕViÇ}ýdÑ}æå±+ÖýÖ}kðÅ~™Ò¿þS³|×/ùïãn¾= ÐiŒ———»ê°<-ÂÏà"„B!TâJ rGTŒw'Ÿzºÿn] õù†w<ä>úìêVÑÜÓÎ<; À —­1|ø{<Õ¨§ôƒŠ1òœ¥lèT|@΀B¡NðÏ~ö3÷ñÇ·J›0a‚[½zu+€M²… º?þñ­Ò~ñ‹_¸>øÀíرÃ-]º4›þë_ÿÚíÛ·Ï-_¾¼OXŽÓmÚ„¥Ìxç'êIñ`Þ #„B%À!ÄÞyçnË–-Þn½õVŸ6kÖ,Äo¿ý¶kllôQ_Áíûï¿ïáYëê·Ày÷îÝî®»î:(,(nhh€1À #„B}ÀÞxW¦h­uV¤W`+ð}ã7²ßsÏ=~;ArSS“{üñÇ}ºÀwÑ¢E¾«5ŒÀÆ`!„êäæÀŠòê{±qV4ùÃ?ô‘cEÿö·¿¹Ù³gû4­«²úöÛo€1À #„B½ À‚U‹Ôv€zè!ßµY\?ÞïKЫ¨²ÀWQcA±¶‘)*¬±ÁŠÀŒ` €B¡^`ªº,Ûï%K–ø¨®™~ t×­[ç—¯X±Â§é»ft~ë­·üzuuu>M0-ÐÕ>5!Vx¬p[€ŒÀ0B!Ô«œÆ÷gÒª26£ººúF€ŒB.fž-ÛŸ±…ãÆëÀÀ0€BÀÅ À¡­ª¬¬’~gÅ ·jÁ÷‡5küïW/nµÜ~k³÷_z©Ušm+ÛðôÓÙô_¾<{ Û&´[¶Ì½¼h‘ûˆ Þl}Yü7Œà¶ÑÕ·¸GŸ]Ýîzµ«ÖÀ0B!gÀ÷Áﭙʾ¢¼¼ü3… ÀÏÍëÎîßßýâöÛÝ ÇãAõÔNpï®\é— lÏ=ã ÿýŸŽ<ÒÝž¹.™ 7L;ë”S<ð*Më>ܧ×þüç>MßÔÔ´:öôêjwíw¿ë~rã~{ë_Î9§˜k?0€Óaóž¬s/lx§Ýõœ}. #„B©¯Ü®‰`0´bàºø5Z¥Þ–e xw8N¸Xðk‘ÙGfÎt·–—{07mšOÓç}·ÞšÛøö–¦õ´¥ ^Ãõâ¬èîÉ_ûZöwÕÕW»å>è·ýkCƒ{»®Î­{â ¿Œà·ë«&z°}`þ’lÚC.qþ?Â|êénÆ}ó\]ý[þ÷ÿ×—ü§¶Ió5—••¹„zK°L]Ù#„*6øuX»¦qÂ÷ / ¨f¡êŽ<òÒK=|^pÖY>MY‹úùÏ{@•YøK_ü¢ßFëÛzZ~ùàÁ>=WX€¬uì·zÖm·ùýüæᇳe¥ÀN‡»ùv÷“Yó³¿ûúÉîņnýö[E}‹%\^^N½ÖAËø ïð´#„J½,Ú[YYY_‚­ÚõyTú{4AVfÝÁ555Ÿ*¤pÀÎ1W^é¿Ÿ~òÉh „sE€ª‚aE’¹µõ4®WûÕ×çàpßwOšä#ÐÖ}Zp¬Ès¼Û4Œàôp.è-&Ü!ÛpO;B¡¢`}–ðµ· ½qG·P N iQÚ0b«îÌŠþZ÷çöº@O©¨ÈÂj>]  ¾µÞŸ×­Ë÷¥çŸïÏCQàc:ÊQ€\\¬.ÑŠ 3¸tt€BÀEÀ9¡·PX㯺è"ošŒÊÒÕ Z kÝš lÍ Lm’*í§üò˳iñŸ¿¶­Že³K xáÿkÛ>uß}>š,·®Ö0€ Û¸f#*Æû4ûŒ×8a¾jd #„BpÊ®}|>Ð[¨ŒÀÆàªßðFv à–6nܸõÜ%„Bp‰8º%Œ ¹o°¯ù1þÈ]B!ÀŒ` N½ªªªžiçS¸K!„`€ŒÀ©×˜1c¾ÔÆë¸w!„`€ŒÀEåì£û3B!G €€à¢W®nÐtF!ÀŒ` .*åèýî B!¸„ôƒQ£öÉqÂÒe#‡ßMîE=¥ŠÊ±ÿ‡ç,]öƒŠ1'çæå#ì£û3B!!„BE¯x7hº?#„€B!T”Šuƒ¦û3B!!„BEí'ì£û3B!!„úÿÙ{ÿø¨ª;ÿÿŸ>>õQ?]ÛÕUWWÖú[  à‚@¡Æ RD¤ŸÃdB@DE¨¢&Š(¢‚¢qaE…5>âFE$ ]Ð|…±b¡5¶ø kíwýlm{¾ó:Ë™½¹™I†˜IæÞy>÷cfÎœ{oÎœó~Þsî=n4ËŸ€P£eÐq þ Ÿ@RTTôAØî„ÿ7™H$bCx§Ï=]Ý š¹ƒjÀîÿ?ËDP\Rük>߀µ…¢Â_uu;P?Ãg¼È/(øeW·…‚‚ü_†õó*..m[Ðÿ[W·…’’¢¾gìòóÑå¹BqñG|¶ÁŠÒÒÒ±ÞÖ‰Ž9|ø0ÈÄïá­½ÛÌ–]¯ÙØÚ´¹Ýº?Û·Óüü“&ú…m!Þì r®°oÏÓ²»ÞÆ¡–ÍíÖÝßüùBûý‚‹Ñh4/̼råJ³zõêë577#ÀpöŬY³Ìš5k:¬7~üø\`“Žeë 6|èÅæ¼sN·¯Ö=Öî€)¸š­‹ÚB¶%r+×-5—üÓ@óÍo~Ó>¾´å…”u×m|ÖÜpk%‰ní žÜü1þøü‘™  Àu »Liåͦâ¦Ûà£h qz/H}‚bþâ»ÍÐï1ç_xž)«Œ´[wü¤YQ¦_Hk|Ø´\á‘n±y‚ò€—ž¸Ýº§÷:î¸-üÙóü½xÿP‰DŽ ›×ÖÖÚI´Žê 2F€³+jjjÌœ9sÌÖ­[[•Iˆ‹ŠŠÌ¦M›LKK‹­Ó«W/û¨rÖ¿ëHg•4âUCŠA-¥eó °5ïk n+¿ÓTßVnÅ÷ÿxÎ̷̬ƒšÊV-­¶õ¾Ø¿ÍŠwÌ.³g…½e?¹9bëj[•¯Y1Ï–ýôµöµêo®"qm—mŸKGíàë´…lMèN=í”ÄóÛëÍÝÞe Ë&›’X‘y§¥±UB¬„÷‰§—غæ±ÆغÛw7زW¶ÕÙ××^këj6IûоôZ"­zϽ¼ÚAßMï ¯YwÞdû…Q?ü¾™yÛ ¶lô5?4'œx‚éwqßV'ÐTWßuɳû^«lrÉD[O}Ê–=[cûÕuý‡Þ[ðؽö8êw²ñ³é¢¶ð³ ä «Ö/K¼^p÷ æÞ;+m¡¼@3Ãäÿ}ì·ì£;i®ñ}zùD3nÌp»+›R2Îƨ—Ø\Àís¸‘¦¢ìÚD^ m•?¨Þ+/<’•ŸMW´…h4zÀ{pÐxÉ’%vbLÎàʦNjæÎk† f-ZdËòóó͉'žhAž F€C$À{÷î5óæÍkÕ€Ï8ã [&)0`€9xð ijj²Ïõ¨ò—6‰˜4­£‰×õ¥ŠŸpüw¬KdgÍ(²ƒÄuÐÀ>V\Ýò¦I®°³Æo¾ñ”}Ï TµÏ,4ｵΠèßÛnûøC³íÀÙÜTgëi)•Ñ“O:Þf@u¬lû\2Ðm!¬Ä÷Œ³¿g—>*~è‰Ib-}¼øÒ‹ÌÛÍ;lâ«„UåJ†•ÌJp•ØºDYuTW­¤XI®¶W]%ƚζÏ%maÊ”)æ•mÿ'<"oŒY²ªÖ.‹>ëÜÞVˆÇ^W`FŸd…øô3ϱõœü64}dË6ïú pÿöLA`}—%±z®ï°Nj%›^òä¢Ä¬±DYû⦵&ïê+‚+ñÕ÷^2¬¾@}…DXï«lî½slù?~¯WV~6¹–+øX¹ƒ^yp‡ïSÍK^¸þø*{b\ÂëÆý+G]fó å:Ù®2ïûÇó¿lòÙ¾+ÁÙøÙtq[ÐuÂ÷«-}F´¾¾¾Õ¤˜fzµ$ZÞpöÙg3Œgÿ,°W€5Ó›ìyXpÕ=¤¸ëƒ4ì^KvÝ\=÷דÀj@ThÀûêp£=k«Î[_ƒ›5ÕS™Þ× éö­AÍÍ ‡t¸M[Š»ÄW’ªH–k¦W‰°Ê’Y•k¦X í] n7å3Ê ³«'A–\{÷-1v ugzû¢Ñè?뺯0Í÷¹h`â¹ÄW× ëqýŽ÷mÙ€ÁCíó¹÷?j¦Ýz—Ù¶ûcÓ»ïE¦±ùP®Î¦OH&ÀNt%©î¹_€µú•ëQ2+Ù½°ßfÕ‹+ì¶Ze¢ý»% $sûÎö%й–+$àdÏý¬÷4««1_³ÀÚ‡V€)7ÐÉvɳ$Zû2¸Ÿ­§ìn¶8Kª3ÕÂ(Àaö8G¸ÿþ¹~ ðï¼WPn‚ÕYÖµÃm΂ÆëkI´fŽÔjÀÛ³³¶U=¯‡ôàCíµ…  °Z…›ÁñïKe’_mç–?Jzý‚ëÝw¯õÓµŸoj‰c\zû…å.Ð~Ö¬¯w6X²›L€µLº lš™‰™g_ÙšS×ÇãÓ ö G#ÀÞ{è»/éõßk@«<ô}—üºh#®–´ÿñ5À‡‚˜+¤+Àö>Ó ­7/ðz÷õÐü™v†W'Äu\ekŸºÏÎñšâLµ…\`]N‰#ÀYÓ§O7ƒ ²QUUÕ®Ç<“——g&Nœ˜Kœ2©  ¦I3¹zt×ç&`…–/Klݲ$såP;(ºAKË›tWÒ«2 ‚0µ­êi&XKB*À¿K·-á&X©Ø-_ÖRÅÅÿò -Óµ»n¶G‰¯›íÕ¾´$Ú]ë§k†%Áª§ëƒC*Àÿo/é¦&íýæcP¸8v£é?p°9÷‚¾ö¹Ê¢3f›QW3 ËÌ5“K3ÁÉX²|ùÈ+­q ôQ¶…ÃAíÜõºú¾ê»ìffµ¬ÙÝZeî¹ú }ßÕ/Hju¢KËÕ/¨L«òïþíwík•»ï½ú™Ë.d÷§¥Ónß!àß9WÐŒl¿¾çرÜÍ̪Ìû¾{®ëµTY³¾îÒÊ ”(”¨ÎYgœfó ÕÕòg­"ÓeTÚNõœl+§™J·-9—Öõ¾º4²OŸ>‰›äzo–+¯pÏu_!]¬÷¹d¨áý,NÙ´t:¯ jîg î†î_ FÞŸ;ÐkÿO è¹w[ùuϽw‹T™w[‰qG?¥îT[ûÝQ•+Áu¯µìÑÝÜ&¤w{¹¥Íþ;y†M€_mÜkeV¡ç®\2ëZ]ç«›^¹÷ô\³ÃõÛÞµe’á·ÝF¦OHºX7Ðr3¿Þ>"¤ýBhr…®<÷Þ$S'×C~èNµ~[F€‰@7à\ÔtGGwöV‘wwîJîl[{¢«%ÏZꨙÍäÌ©žêD·³í ×~BHÒ«Ù_ÝË+Ãa`ú„Ô¡åÒînÏ · š~!÷r…··>mO’+OÐj± ç ™Êpü&`&`&`&`˜@€ ˜@€ ˜@€ ˜@€`&`&`&`F€ ˜@€ ˜@€ ˜@€ ˜FLfPc@C€ ˜@€ ˜@€ ˜FLfPc@#Ù%ÑE€`úúr&à$ª…Lìïú6Pt˜Ï5XQRRôY&úƒ¢â"úƒ€EAaÁ¡ $7ûùlƒ……E¿ë궟Ÿ€Ï6x¡ÿ·®n ¿å³%o¤-u|(<ˆõ@ ((Èÿ%7 àÍñâÿo´^€̘1ãO Š=]ݦU–Îç¬ÐÿY&úƒi7TÒ,¢åS>ÍD[˜:±!h1%ëò¶ÀÏ ñ3HŽè”ë¹#x ïþ[ÐÜÕm!‹ñ‹‹éÓ§ÿ'ÖëÜø},~˜ßÊãwýHvItýmßÖåw€éèÈÈpü&`&`&`&`˜@€ ˜@€ ˜@€ ˜@€`&`&`&`F€ ˜@€ ˜@€ ˜@€ &`&`&`&`1 ØK4-(//Ÿ[VVvƒZnhm $áKt;ÛÊp 0}ý¹ùBWµrrîdš¨­­µûÛºukÖ7àx'Vs$ÞI§Së‰A­ew=S†¸³m¡;“´ŸíÛi¶ìz„5ÃÜٶͲ×Ðô‘Y¿ã}³m÷Ç]¶Ïµ·›{-55ÏÔ%Êž|q“-ÓcÐØ×ÞÍÆ>A±äÉEæ¥-/ðýÎ`¿àm ±X¬)[s…æ¦:Æü ç z:vþ —ð–ïܹ³MYº±zõj›ïk^WÙ½{w§ö·aû?="Àp"ZZZÌœ9sL¯^½Ú¼wÜqÇ™íÛ··»}ss³Y¸pa›ò³Ï>»«Þرc;ü›-ZÔF”%À3gδkÀؤөejPÛ³³Ö¬xüÎ6åïüÇsæ„ã¿Óáö?}m…Ù\ÿD‡õfÍ(2‘‚«m$;ž7¦—OÌUN»-d"{âé%æ¹—W·)Ÿ¿øn3ê‡ßïpûÝÛaBüÖÞmfü¤%BÇl¯þ ·V檧ݲYö¯XkÆ^W`*nº½Ëö©}•VÞÜF€o¾c¾=VÈؤ#@™àKþi`Òò9ճ̪Wt¸ýÐïé°Žúõ'œx‚}T?‘ªîâyÐö5¹&À=+¸qŒ·!C†´z]__oC³¶^Y^¹r¥Y¶l™}.IÕë‘#GÚºÞFçߟ¾ªÓØؘ(Ós·W¾iÓ&»?•©¾Žãý›²A€‹ŠŠÌ‘Î*iÄ™'FÿÚ^§–©A­aý²6ƒŒ*•¿ùÆSmf„5àÔ>³0!Ï?¹9bCõý3ÆS÷d±}e[­ë„yÝÆgm¢;÷Þ9¶þÛÍ;uþI“©¼9fg’½IµwVYûqÓZ›ÜªÞöÝ v?ç_x^›ã+évõ¼eš‘R]mëýÝkýM:¦þV‰·þ.÷ï~§¥1£‰n&ÛB¶ ßòuÚð²ç_6 jV%f†ëv™Í»>0ó]aŸ»zO¿´Å–išIv¬×þãèý pgƇŽ’ÞîàYwÞdEÕ{ÂlSãzs]áµfÄÃì÷ËìrR«ðîã¡'˜²ÊHÊcißúN0Æ–M¶ßWŒ»øÒ‹lxO é;=úšÚzîû®2ïÉ6ý=zorÉD»Oõ7îÄß²gklYùŒ2[¶µi³íÏܾzª_èl[ÈÔ˜vz¯S’æ å ®Lc¹ò¹*׸¼ö©ûL¿¾çغ~iU®¡÷Så%Ê-Ü>ÜØ®m®u™Í3¼ÇW=×{ W¦“õ.¯qã«uµÊ´ÇåÚ÷+/<’qÎTÞ˜ Ëz•ï{Xy¼?—KhfWþ ¼_ï©ŽDYÚ&•?¨¾ß1t<ço¼ñ†-Óû’Üûî»ÏÖ÷N¤©>Œ§%À:û2hРVzØ°a¶+´AggtVEõT_³´©ö§†é?£çª§¬c÷ÑþT×?ƒœ-‰DLƒVÚïøÔgÑ]ì$r@ÿÞ­¤xÈà~v°Ð{nöwJÉ8Þ3±_n´e÷ÞYÙj¿~såPSø㫬Œj “œj?šyÖ£;ŽíOƒöIú¸1ÃíߣAY›dZûQ™ÞÓßçÎNkVyÁÝ7$þ­®®÷ïéêèêvàm Ý%ÀOÍôxSɦ’CɦG·RI©H¯t*éTBìê¥àïþíwí¶Jˆ%ËJ¦µŸ3Îþž}\¹niâoœyÛ 6yv“þ>m+)>õ´Sì¶úó®¾Ânwa¿ B­ý©®å»¼+‘(k_Ú.S‰n&ÛBÐxBa™}­%˽û^d›Yq0x¨•âÓÏ<Çìüð3³dU­É;ÁÎôžô÷§šg_Ù Î@[x=S}B{3Àú^zû ɯ¾Kzî=¡”l{}Çõ]w'¡’ÕÕ¾Õ§èÄ•¤ÕÉ®ÿ¸:–¶Ó 1}ïõw¨\ßu½§~Á‰¶ú"}ÏÕ¨_p}Êe—²ÇñŠñÆíõ¶\'ÒÔ/¼ž©\!•kœVnàKG¸ÄÊåKÏ?lÇZÉäCógšóÎ9ÝÖ÷J§Ät¸‘‰“ÓÉòåÇ^l·Õ>TWû×qu^åÊ[:¶ö¯üByê*opeªïò‰îw¸àÊpÉIDAT³Ëe:†rýM’u—ÏT”]kó‡L p¦òÆl`—Ç+gwe£G¶9½fhÝä—^»Õ¢Ú&•?È5TÇ[.ÐŒ°„Z­Õ¨rG«Eý3È0œ¶;Aõ6ê¼¼<3kÖ¬VË¢S5ªdûó×Õs·DÂûò7 3ÀIâÿÆë=Fûu÷ ° î¹ :Ûê…õŠª,4iàóïÏ/ÀÚ¿ê빨Tƒ¬* >:Žžk?4Ûþ-n?šAÖ«‹êi©–[n¥eïßëý7i°óžyÎ’àÛBw °›ö&¦Jrû]Ü×J¨7ÑÕ,‹$Ó»’Ìd ¤_€•èºm¼3EþäY‚ë`%¸nFG“þý]ª§Ù ‰²êiù¶’`ým’bw'ÕnÆGÛºä7‹f€;l Aàs/èÛJ†5Ë+qÕ¬°Ê$Â’Ù[«0?™÷°-“(ëzbf€ñi<–Ç뎬®®þFO,ö‹¨äSßc\ò~·ýÛ·wI…_€Ý%Þ¾É\wbËÍôê»ïúÍ"K¶u’Leß:ö[‰zZ]âöíú-I°we‰ú®ü^¯VeY8|ØߺS€­¼ÅÇ]ïØ®qURé…Õ,®7§Pè$¹äÒåí °»ÔJånµ™ÿ¸Ê tR]㼎¯}+_ÑÉnw<÷Z1¦ü.‘T»\ÂÍ0{s…÷z¶Ì§3>d£»<Þ+Àú÷ÇÿîÄlm{®¬Ì_.X»vm›c©Ü{\îÖEèV7kÛìª_€½gn²M€;q-ÇŸ=ÏÅ;y•••'wÇu=é °FwfÔ-9Ö á¿¦7ÙÝTœì¹Õàå–:»¥Nlmã;7@I|]=7H¦´UGBíú,¸øOé´…ž`…ÄSËÏ>ï¬Ä,Ž_€U®ÙVE²™ždIr:¬c¸PbªWI¯foÜ5‰]ý[\=7ì_†éMÊõ^¦ÝL¶…  ðYçön%ÀšÙ•¸:©u¬ÙàˆÿÀÎk¶Ø{ pøk\ë÷™Wtzú`¿ˆz…Ô{ݯ›iõ/¡Ö‰«Žf€S °ú¯¤º[Þ÷i_w-¸Ý®NqÇ‘(ûé`oèd˜f€3¹2$Sm¡§X!aÕØíòƒd,ÙôJg{ìöï`­ ó ðÌÊüD '´µo ˆ ³ð&X¶…L °–z[Í höÄ-Ev ®«£äÖI£$R"ªrͨzYÍø¨žfiÝì­öë®íM%Àl-UvK¨•4k9£^kZeß’X‘ýû5Ó«WI¯[z­¿K3;©XûÔlq–ޫöͲ§å˺aÕˆ¼1æ¡¥kl™»)–fw/2"Qæài·ÞeFŸdëνÿQ³}Ï\à?ÄãÉd¢ÓìBâêVXè;¬ÐwOeú^껨ï¾sn{}·$’~IÕ’f·­VchÿsÜ·í£NX¥`½§Õúô}wßaWÇwK¥O>å$»/ɸ»¶×-«V?à¾óÉXÇÐß›é{e[ø}*éí.ö^ž¤ñÕ]¶ä–"»1W"ªr]zäVji–W'Ï5öz¯©u3´nY´òíËå%í °ö¥<@õÜRko ±V¨LûP^¡mõ·(oQî ¼ÂÍ.'`'Ë™¾gH¦òƞ̅½þà\ÁëZŠìî¼ì~F³ÀÊñÝ>Î?ÿ|{ã[-enïJ¯§è©XûqË­½÷B€à¤wv7¼rëZ\o™S÷SDþ% z_Î[îoÀjˆÞ}º2w‘¼¸÷†[:–® ÈÆ›`eGözakÀ j;“^—£3ÃÝqv6SL²Ûu³× ÿõ}aNtÃ.À ý4’fvÝL±B3Å*Ó{®L7ÈR™»QL„å÷Áɺf¥›rÍõw€q‡ÿ ]ú¨|_K»bºC´ö§G&`&`&`&`˜@€ ˜@€ ˜@€ ˜@€`‚A@€ ˜@€ ˜@€ ˜FLfPc@#Ù%ÑE€`ú‚\@€ ˜FLfPc@#Ù%ÑE€`úúròÜÈuJKK¿Ð‡¦(**2‘HÄ>†íßý]Ý"‘â߇ðs uèÿ,ýAIiÉ|¾ëïg¦-”Ò׊»¼-ü6¬ŸWüßfBüoûmW·…ââ¢OùžÑþ»-æ³ V”””|Žõ†ÏzWñi€—êêêcâ9§|€@¨‰Åb³”'”••äÓÂœ'ì=’'¼Î§0„’#ËŸÿz$Oø’O`%nù³ –Aœc”E"Ÿp‡¼àEaAA3­2& •Óÿ?¾gÁŠë§DÒrÓÊöz˜eЀçJœþ¸s'°à7Ý Óý¿­Ëï‡ ßògÿ—O`˜@€&àPá_þÌ2h@€`@€à°æ{“ 0Ë F€ ` )–?»ø/>!@€`˜@€CAªåÏ,ƒ&` _@*à°å{Û`–A@¢ÑhAüß=·¬¬ì,@€`øob±Øºx4(âãägGò„Ï\Ù”)SžàS8¸ÿvÅ;éÈ0Œ䲯ßñ¾~f_ëÑ_†‡N†%ÁF|€‡G€M:2œm\sç&2nœ©}äûú¾™3[½¿hölûx{üßåbÇsϵ*[V]m~ßØhËôÜ•¯}øa[¶qÙ²Ä6.~»m›¹«²ÒÄ&N4ÿϺuæÿmh0Ï.\˜x_¯Ýö0 ÀÙ̷͇ÿæ8³y×íÖÓûKVÕ¶)?åz™Š›n7Ûvl_ëQ¯U. F€`€@H`4m8òé±ÇÌ”k¯µ3ÂsÊÊl™fhWΛ—[ÿö®L"ífŠU&yõÖó °ÄXòì^ëx«ï»ÏÊ·äZ3Áš5Öv0 ÀÙÉfkõxú™ç˜Ñã'™þÛYßåë6˜±×˜s/èkë/^±6t‰D׎~ |™o;„I‚ÛÌŽ†)¢Ñè?§9ì?Åë­‰oßÏ%ºÙ$Àî¹–!k&WrzQïÞ‰^7Û{Ü·¿måVáfˆO:þx;s¬pK õþ¸‘#í¾Üf¿K']uUâµÞ“@K€%Üçœ~º`É8 pö…WVõxÙðØçËžÙ ¯ž; N¶-3À9»ZŠ_‹€PKqØÎ^—$ù7VµSÿÓ¸ôΫ¬¬<ÙŸèf‹Ôié±›–¬ÞOèô\"ªa‰¬¶×?,ñ•0»åÎéÎ;ÉV踚õ•HKŒµôyZ~~bö8»؉®¤7W˜>á¨ò~.à ð͈G"‘cR%ºÙ"uSÝ„J×þJ\5 ìnŒuÆi§µº •f‹5+«øÕk¯µ’bwã«öXR«m·<õ”-“ìêºaC2,W™nÈ¥ëŠýÖ·l}àìZ-±ÕÒf]ãëîÞœL€_mÜkëÕ5ì2õÛÞE€`à ðëñN¢›-R§Ù[]{«k}üº;0KjÝì°“\TwÝ°Û“e•¹eÓ.´dÚmëîô¬:Zö¬»N;¡Ö¶ÿ§¶Ö>×ßåÊ`@€³ç'Œ$¸.$¼’bw¯ÞW™«¯ëUÏ{7h@€*À±XlN<žr×÷¦›èò»ºü0@¸+B³Â’dýœ’ûY%7«Œ#Àp pg]„ÈU¾gÑRÛ÷°¯õè/C€`€Ð ðœ9sLmmm«²o¼ÑlÛ¶ÍÜrË-nŸN˜@€&` Çø0Ÿþy«²›nºÉ466šÙ³g·»í²eËÌo~ó›Ve÷ß¿inn6Ÿ|ò‰©¯¯O”?õÔSæ‹/¾h#Û0L À0@· °Wbï¾ûnÓÔÔdÃÍî.Z´È¬_¿Þ¼ùæ›æg?û™5~þùçͯ~õ+søða[W¯§M›fW¬XÑêXÞm»[€`€à\ù`F€`@€`@€`Èn¦DcŸrgå`ÅõS¢i¹0€wÀ+ S”••Åÿ*d~˜ßF€&``F€&``F€&``F€F€€à ð«{MqìƯµšgêÚ” <ÔŒ½®À,^±6Q¦ãœ{A_sÏ¢¥0 pæcó®Ìö=ìóõ;Þ·¢ÚØ|ÈlÛýq«z M%êù·÷Ën2Nv슛nG€`@€3—¼Ò”M3yc'$X³²#òƘÞ}/2Ë×m°å×L.±u$² jV%¤vBa™-¿tÈS×°ËÊóñw’}ôÎ$Q€‹ŠŠÌ±#:ˆh4Ú€@V ðégžcÅÕ½–;YÕRf ê“/n²¢«2Í KŒÔºåΓ"±ÐÍG"sDêˆô#Æ·ÎJÉ{ú¥-vv·ÏEíRf·ZïiöW‚ª_=ºm4Cì¤VõÓ‘]f€s"_È^–Àîüð3+½šÍM&À*Ó¬¯®V·\:•«ný¶w[]Ì5Àp†–.KxçÞÿ¨}­_¹;5KnÝ5ÀËžÙÎGgÌNÜKâê¿Q–›UÖ’iï¬1 €çDH€%ÓÞc‰²ä@€CZ:-Ñ]»q{¢ì¡¥kl™–K#À0 À €0L À0tŽÒë˾”PÁ‰Hiéi¹ÐLž››ê¬,+¾Ø¿-0ŸEGm :èþÒQ¿í\×°Ëʪ“Û'_Ü”xÿÕƽ64›{Ùð˜5«ìLî¶Ý'f{Uæ•h‰®"Õñ²]€éˆ¯Ù'´Šx÷‚ž+èù…½ÏL”}¶¯Á>_³bžyå…G̤ W˜“O:Þæ Ç^lÞùçìûÍŸi |•©(»6‘¬ZZmë+ö7¿š\!ͼñ][èi‡=z´ý·;Öú‚rôªªªÄûãÇ·~ ×8î¸ãì£Ê\¾/Ök—çËôZ¡I7•iûûî»ÏGåòm;kÖ,Fí±wîÜiëNœ8ÑîSšq–g¸Yêýû÷•°#À9 ÀyyyV8ûôécˆ“¡Þ×óT,6l˜©««³_·›Ê´_רµo5Hmëι/‚Ž}þùçÛ2m§mÔðGŽiË `åÙmÓӳБHĤÑQM¼®/eµµOÝg" N*›^>Ñdz®I˜f~¯u™aÙÕ 'ÑÕ™`=N)g÷ãGm£Ò2¨ ´‚p‰ïƒê²]€Gä1U k̹ôµË¡%º/¼ÞhßuÕ8;{+Aî?p°¹ùŽù‰™`I¯êê=íÇ-oºÓ'ŒÀå 3+óí ð³ËlÙ‚»o0?4Û>—ì:‰õÏë$ºò =×J3É°žŸÞë”ÄÉö E¦òÆžvˆ^½zÙü|Æ Ö4i¥|^.¡2Ikª`9‚ºààCaËF¸Äž(×sóZ)æ=á­™âWëK¼Öê07kœêþ"nV8ä×·Û²E€%ºn¶×MVy'ÐœWx_ë}ÿŠNùƒÊŽìñX•¬ó ò ¦ÁJr«Ù\·IË”¾sÜ·[•Õu¾Zæ$é•àêì¯Îk`S™Î»kéµÉÍõO À+É®îö‹D"Ǥê²]€çÞÿ¨•ÝËG^™(/­¼Ùœô÷§š†¦e’]Íô.^±Ö.Ö’ç> 4KVÕÚ2]+ŒC÷ Ÿ¦ æ ºÊ{b\¢«k~½K™5K¬\A'Õ%ÊzOÏÝõ¾.WÐl°›VNR>”n[èé|Xy¾»Ž×+³*—Wxëêš]‰¨[®¬YYI©¶Ÿ:ujbŧÊänŧVþáÝ—f‹ìzÕF^¡m5,!vïÉ'¼÷7B€`{1¹Î®¨yåRË“]_ «õöNŒÝM«4k«%Ó®±j¦Ö]'ì.b÷ï+Y™¶Q£u2íÊ5 k÷Óàiét^AÔÜOøo@!ÙuKš½±oÏ;¸¹k{õ¨Yc7ȹÙ_w0w†Hv_Çètú…l–=ÍÚê&V’XïÏ!©L3¾Þºz_õæ?º"q,m/ÙÕ²iW†Cõ ¡ÎÚc¯ó“‰o Ùx—cÉ©»f7þ­LÕd]¶üä+cD7^ÑÒw·æžtÉÑ™ 'Øal¼AÔt6Vgyƒ&°0tñÄfŽ÷úÞtû…l>Dg̶¢šÎO¥ú$ÝXëÖêeZ"­dȃ+h•W–.gs®¡\wóÜlù{4#ì.ïD€àv#.w¡36îÐan¼a8«›‹AG™#‚&ÀϾ²µÕlðцÄY«ŸNòÎ4«ÌÝ)˜@€³Ó!˜ÆKãePcPÈ)Îõ O˜@€ ˜ÆKãePcP@€`rr‡ #£ñÒxÔÔ`€\\‡À!`&`@€ €\\‡À!`&`@€ `&à udûõAÁŠ¢¢¢ßuu[(,Ì?Èg¼(((ø-)dŠHiéùž+J"‘?Ðr!Säççà{¼Ðÿ[W·å|¶Œýôd~ ‹>˜·ï9€ ÀÙ ËÌüGWXù•¸nÛý±yòÅMfìuÚŸäùžEK`8»bÀà¡V~½ezí`ÍK”G]5.!·ª“7v‚-›qÛ=¶Lç^Ð×ô8Øn/‘ÊçPTTdÊËË«ˆŽ#‹ý˜o:F€ëvYI=þïN²«çÝd˜@€CCªeÐÑhôZ>˜@€CE’eп®®®þŸ @ŽRPPð[ɸØOëmÏ2h7ûËoÿ@øð.ƒŽËðñ×ßáS€PâYý(Ÿ„–#Ë ¿ª¨¨8OB‹–AÇ%ø)> €¤´´t7 Nèÿ««Û@QQá|¶Á ý¿uu[(.)þ5Ÿm𢠠ÿ—]Þ/G>â³ VDJK?ÎDž-Ÿò)Ÿo°¢lJÙÁL´…XyÙ!>߀õ ‘â_w}ÞXDÞÀ(..nÁ| äðáÃD@"?q¡}š?ì$™j ¿8ø°ÈT[àg…ø $úúòr܇@€ ˜@€ ˜@€ ˜@€ &`&`&`&`˜@€ ˜@€ ˜@€ ˜@€`&`&`&`F€ ˜@€ ˜@€ ˜@€ ˜FLãõR^^‹GUeeåÉ h¹=¨u¶-<†/Ùíl[@*Ã'Àô ô ä ä ]ÑÈÉ`˜È&®Š‡‰Ç—ñX^QQq!ZÎjj $¡àNµ¤2”L¿@Ÿ@¾@®ðµÛ99ŒwSìݻ׌;ÖLœ8ÑÔÕÕ™­[·š!C†˜Aƒuj---v!`olŒF£yaÐö7¿fÖ/K„Êöì¬5‘‚«Má¯êÔ>¿<¸Ã´ì®ó vTm!( ÞÆíõ智'm¼´å[öÄÓKÌØ cLI¬¨Sûܾ»ÁlmÚf>ª¶ñ›qÛ=¦¡é£´ë«nÕš6åűÍØë Ì“/nÊe¿°à±{±©q½-}ÍÍùžg–<¹¨SûTre¾àÍ>Û×`Ë”+Œ¹r¨Í%:³Oåä Áàýû÷›ÒÒR“ŸŸo–-[fíóaÆuzÛ·oG€àª*³råÊ6å½zõêÔþêëëÍœ9srA€mÄ;³Ý±X¬,‰ÔmÕÒj3¥dœ}Txß>ôâN’Õ·•‡~P‹ÿÿÿÕóú½Tm!( ÞøI?2å3Êl¢»rÝÒDù–]¯™Kþi`§öyí•v9 ÀI§-Eü jÖïx?íúª+ÑMö^ÅM·›{-Í%þK˜ú…ïþíwÛð×ýnw¶?  §Õ‚2FžwÎé‰\Á+¼’àΞôîlž@î0o Rî,w˜;wn—úƒF€3®±Ýwß}ö¹fo“5`Í9ÒÎëÌNss³-=z´Ý¾ÿþ¦©©ÉÊtŸ>}춚E®©© ÄçPTTdŽtVI#ÞQ5¤êÈ<Ú§Þë=‚&À~ñM60}±›Ö™^Å¡–Ͷ|ܘáæÊQ—ÙÐøÒóÛçýúžcÅߘϢ‹ÚÂA[’'›™ñ °fŠGýðûæ²Ë™ë ¯5?ÿ¤ÉÎôæ]}…qÅ0ûÞÏöí4³î¼ÉÎ]|éEvßϽ¼:0ŸEµ…þ¶Í²·}Ï3)³"ûí¿9ÎJ­Ê&–™Ë†ÿÀ¾·óÃÏÌÚÛB[óL ÕU¼±ìcý¶wS ðÓ/m±õFäÉú™áŽÚA.ô §žvJZ'·æTϲßõw?x—-[ü/ÚÙâ¡ßbë«ŸÐûsÜ·ícD¸ ÛÂ æ ©dÕ/À:®<`ÔˆKÌ›oáÝÏêÕ«³ÈÌ#ÀÝj¸jtí-aÐ̯fx]Õš‰¯ÎÜÌš5Ë~‚,À]q&/‡t£ƒxÝ‘ÕÕÕßã °¬æ¦:ûü½·ÖÙ׺H3ÀšÖ tîd[økGm!l3ÀÞ!·4ò•muVŒµü^¯Ä~‚*À™ê²}Ù³fx½ì] íÄ7•;é•k»d¬zÇÿÝI¶®âÒ!#Â:üç°ô é̯Ûø¬ýî{WR\ysÌ®Q]­ ²¶ð§°ä éÌ+Ð q÷Þ }ìãôò‰6W˜0ndà8SãCrgåúÉVzzýAŸ“s y„|A³Âº÷dW³¾Î`8ëXK›UïàÁƒZ²aÏØh&xúôéfß¾}VÝ—@Ë"Ô°UWï…üàVW¯NG€Ü}ƒyü¡Ù‰çàjŸY˜˜5žY™ŸØ–@å:¦÷V½¸Â¾ï¶Õl±êé½^ü×0æ é°ÆI®{>iÂöd¹.‹R™.“òæö>Ó|u¸‘\!„¼hÑ";QæžË'¼¢«Ù_'Àº‰–„F€»%´î^ÎûZ Ӆޓ̪‘z×åKnµ”A³ÁjÔ6lHìÃÕÕ¾B(À);¯ hºGá/Ó@çâÿxÎ^\Qv­Ì´üY–5ÑUHŠÝ~ôžÄXuyà–°ji·… $xUïGWæ–?: V’«eÎ’_—kI´^«\7ÒrûÑ,ÊAºók¦ÚB6ËÞ³¯lµ3·£ÇO²2ûjã^+×¼Ò^³[P6Í lcó!{¯„Y×k‰´î­zn['¸ÚŸ„·wß‹ìö*[¼b­Ý^õÜLrˆ8týBYe$éÉ2î—N„i¶·°l²=i¦2]¡::6ó¶Û¿¸i­­«ñM°B—/èD·ÿW$¼¹‚; ®qßÍôº›eé`—(_ðž„×J2幞+Iü$¿µµµ‰×z®eÑ.ôZþ É2M”éQ¯5,GP™÷J…dY“hZ:#ÀDÏ ð´t:/~×/'~Û¯SmßÐ åïwª-ðÛº¡¼ 4ý}ù¹Â×nääü0Lºñ2 …sPël[ y g²Û™¶€T†O€éèÈÈp¦#À h j$º$»0L¿@Ÿ@¾@®€;à000ß3˜|\wÀ!`&`&`&`F€ ˜@€ ˜@€ ˜@€ &`&`&`&à¤äs} D0Bÿ_]ÝŠ‹‹>å³ ^èÿ­ËûƒÒ’/ølƒ……ù`"SÉÍõS®ÿ/¾gÁŠëËJ¿ÌD[˜Z1…Ï7hm!>®w}ÞXLÞL‡ø=æ ‚‚‚‚ß’0+ò Òr Pü’›‡'ôÿÕÕm ??ÿ|¶¼áM~þÞ®ïòé‚{º¼_`l -áú)×às Ú] #Ÿd"g,**ü€Ï7hyc~&òƽ|¶Ìùßòâ7¼ø]?~ÛÏÛø M~óÓµ~ZˆŸB¢_ O _ WÀp˜@€ ˜@€ ˜@€ ˜@€`&`&`&`F€ ˜@€ ˜@€ ˜@€ &`&`&`&`˜@€ ˜@€ ˜@€ ˜@€iÄ4^45]’]˜@€‰£éb±ØËËË«*++O&_ WÀp˜lãF£ñmnYYÙY h¹=¨u¶-<†/Ùíl[@(Ã'Àô ô Žx;X/ã±¼¢¢âBòrÜF€»8V¯^mjjjÌÎ;[•×××›­[·vjŸK–,Ñ;ÛGoù¦M›ÌܹsM]]}­ã*öíÛ×%ÿ–ææf{\…žgKãÕÙÜ#šbw:Z¶ h ë—™wþ㹌cÕÒj_ìßúAÍ×ÞM·-dCò¶ø_4Ûw7dlÿÚ÷‚Çî5Kž\”ÉngÛB6 Þ“/n2Û÷H»¾êjyÍ3uæžEKMý¶w;ÜGqìF3öº‚VûÑkE]î@ °·-Äb±÷²±_ظ½¾MÙÛÍ;̨~ßüü“¦v·}§¥Ñlj\ŸÖ1ž©{ÒÆK[^°eO<½ÄŒ¾æ‡fÖ7uêïÞÚ´Ù¼µw[f€_öô .6Æ…(/›ó…ýͯ™µOÝ—Ñc¼Z÷˜Íš›êr-Wx?Ý>¡;Å­¶¶Öæð~Wxã7¬CtfŸkÖ¬IêÛ·o7UUUÖY¼þ°wïÞ.û÷8hllD€sA€%¥úWCò–ßwß}‰†Ö^äåå%mDMMM­Êôºÿþö‹á—¾ }úôiS7ÝHvìTÇÏ"6é$½Ý= E ®6-»ëÛ”?þÐl³fż·såÐëhÿ'Ÿt¼>ôbN¬%ÙWŽº,éñÓ‰qc†uP3ž¤·©½¶ÐIÚ©§’´¼°l²yqÓÚ·WBÜQ‰®ŽsÉ? ´á’i%¾ý.îÛ©¿{ÝÆgÍä’‰Aà´ÛB6 °¤sýŽ÷Ó®¯ºÚÆ_¾vãv[. îhMZ^qÓífùº à£#º³=Ÿô£6e?Û·Ó<ôÄ‚·Õ÷ú†[+Sžø’ »cÌ©žeû‡•ë–¶Ú>ÙñÓ WÛû¥8‹g€÷xþÿÿt$Üë÷âýCY$9¦§ò hõmåmÊßÞú´™^>±Ãíyà;æwTïô^§$rSeÊ~rs$ñº3¹BgóŒlÉâñ³öú„î7‰ïÌ™3Íœ9sZ•Ë'.\Øáö£Gn“«k_~ynii±® _q²­:#GŽì´h·çÝ'À%Ðjp^ÖY5‰ñήNŸ>ݖ묛m=ñÄgMÚP5(ÿ—D1dÈVu5;\TTdfÍš•˜^¹r¥ÝçÔ©SíÙž 6´:¶þÞž`ý½G:«¤°Rtd)“ÞlàßiË_zþáDÙgûì¤rí=Ô²Ù>—ØêQáŸAžY™Ÿ`ÿû©Ž¯í¦”Œ³Çr3Ã:žêi:Û¼ggm«cÏšQÔjÛ¯7vû Öm!ïøÛBO pYeÄ& ÞY ÍèHŠU.1Ö{z~‰'ØGmãÝÇüÅw›™·ÝàT ±b¯,»ÄØÍ4ݵàv[¦}( ×,ÑÐï1ÿø½^¶\ÇrǼûÁ»z$ÙÍT[È&±«ZXc…õ¬s{'xîýÚ2=êµfc¯X›˜)V¨îèñ“¬¬”M3›w}ÐJ`½¬÷TgR$Öjf8HÜEmáÝžìüªYU•qö÷Z•_Wx­= 6âŠa‰ï ¾›ç_xž­¯ïª««Y^}ßÝì°Þ߲뵤í=¾úíSÛº“^ÚWÞÕWز±ÆØ2Í븪«íŸ{yµ-/‰¥ìz²O8I‘#|åy½ß{pO ðO_[aÇàwßЪ|é#·Ûò;f—Ù×z¿_ßsì o•k;ï ²Ê•c8noŘ÷ĺr‚Š²kÍ{o­³eÊ $ãÊÜ1\®0aÜHû\¹Ë—wØ×:vs…dycw/ß•;xsûd+@•Ë+§Wù²eËyºrø±cǶZµ™L€•Ï{#•¬j‚­´´ÔºŠ›–¯è³ŽF£v¥«&à¼þ º0œx­†3oÞ¼VZò)=xð =£G5ÊØG¯púT‚ª35:ƒãk¯k‰ƒêéË¢¿GÖ•ïß¿ßÎH«që}ï±ýK º[€#‘ˆI#y9šx]ÿ†ž` ÍŸÙj°“djFXr©ACÚnÐÀ>öÑ» ´'°zoÈà~I—<{¯åMn Ô±œ4kpÓ6r v¼¼ÇÞ·gCb¯¼ðˆ•Ö¿¡[?Ç µ…ž`͘(iôΤ\vù ›¬J@5ƒ£G½Ö ®Ý,‹¤UÛVÞk%µJ’“-yö °–]+ÁÕ¾Ëg”YñuÉ®öëÊ4{¬ºJ€ulï’GI·’òŽ–ivudª-d‹ÔÝ|Ç|3íÖ»ìræyc¬ÔþdÞÃ&:c¶-»fr‰™ÿè +£’Rm#±U¨îñw’•aÉñ„²”|éV|_x½±•ôI€ÃÐ/¤šõöúÞI8õ}ìhX"¬>Àû]Õ1ôö‹²_€/¾ô¢Äv*÷ÏðjÉ´éd3ÀNÌ%Ênö9 }‚®^ÜÓ¬qYc°fkýRìr '¹’UÌV}—hfWÛJ\½3À.Wð.yö °Æåª#¹VN¢\@ÇÒãYgœ–È?TW—ž»äÚNÇÖ vr…ž`‰¬›´ò:€V•º÷Ô*‡×„–žË)’ °DZ’|Æg´k¯¬Ê´?í_ir •Kxå š=ÖŒ³\Âë»wïF€àšvµ–0K„½r)Mg r:3À:¦·q«Á»ë”uöFÇö~©’;¨3Àñønx¯;²ººúÙ²Ú?ؽùÆSf@ÿÞvóÖ÷|N@5Øø—@§#ÀzOgŽÝ{ÔôXûÌB{VWÇöÎ$ûíB¢œê½,Ÿ>äo Ù°ÚŸHJ^•ˆJ0½ ¯WÛi¦Ø?«›ŽK\Ý15Kä’`I¯¤Zûp‰u{Ë$%ßþé€Ì·i Ù"uS7së–@_>òÊÄL°$Tb›J€ÝèÆæC­dÖ+À MYQv×ö~ëØcsiø¯ÙÔ/¤#ÀNl5û+‘u’ê`ŒR}ÿýÇHgØÛGh¿Z†­K ÜL¯V‚t$ÀZz­ý¤sYG7Î?“¦ìì‹çDÿ¬ë‚µ:–@ûÇbÀÖ‰ìÂ_e6×?‘(׶Þ%Ð’ã8õÄV'°Ó`mã=¦Ž¥õ÷ =-À.ß÷æêZ¶,áÔ–&´R­ý:3Àòïßqþùç'V•ê¸zÏë íùŒ'V5&‰°·¹37_W€uÖH7ÉrgstGgst<C_ï—@_¨€_ܪóÊÆk€S vÀœ˜ºE3²þk}¼K‘Ó]-ÑÕÒgwÆXûÖ`êÎîêl¯w?~ÑvŸf€»{iÓ×h ¿k¯-d£»DV2ê½ööÂ~´©£÷½7±Iw ´fx ëš@I¬]‰±›ÅqûÑòÆdIºê¨\³ÈA¸¸£¶-R'ÙÕòæ~fz÷½ÈJ­f}ÝM©Ô¬²³Ä’ÑÒÊ›[É­W€5³«åÐÉXû>÷‚¾¹| ð¡léÒ`}×ÝJ }çÝwWßM÷õÖÕ÷['§Ü6G#À¯l«³ÛIzµŽ§>B'ãÜ*·Ä]§ìŽ#éÕ –tnÌÕÍ}´v–»¾©å®qéíד÷ IW€½'¾5v»±XÛê¹ õ¨—´ÊAÒY­¼@'äÝ{:ÁîÄ[r¬|AríÞ÷ÃåÊÒ¹.9Kr…Ãíõ Ù(ÀÞ%ÊNLÊñý7àí¬k&Ù­ÕŒ¯óƒ^½zÙY_•y¥wРAp® °þ³µ4YÁ]K«5ñz­r·>^K¢UWKœ¤*ô|Ø°afâĉG%ÀÞuøÚ§–E«‘ê ¡}iŸšuV™Xuµ|Áû%ÐvãÇoõ÷@€?KÕyõ´»kcÜuÁ}7Ý÷Õ…^kÆWß}}u²Êt’xêµf}u©‚5ˆdÖ¬òß±Yý†÷8n5ˆ–9+\å®–hë~n?šéu}’»X}Fw.}>Š>Áý’V½ý1þX§›^uô›ÀÝ-ÀÊ ¼÷üиí½‡ÆuÍúº±Zã¸;A®¥Æ’V•{g†•tt °ËI.O‘Pk;I¬+Ó*1ÝðJy[í.ËÒ¶ú»$¾ú›ô·õÄ]¥²Oø}º}BwŠ›×œ?¸Kµ‚Óùƒ–?+/W¾®Õœ^yÖöÊùÝ¥Œé°»‘Ž¡ciå¨&Éä:†ÊÖ®]›˜dÓþUî`ɲêke)Ìï§õ3CÉ~²HeÕ®Ðd·5Oõ³Fº93ÀÓÒ鼂ò»~Ü’É¥ÿ,ð×ýY…tÊÜ™à€ÜÙ±Sm![êGBšìÚZÿ5€]ñIþ»Ï¦:FW;ó=GݲIì$·š¥õ—{ojåfrU·³ÇÑ2i-‡ñ p¨ú¢Ó¿ þÏÞ¥ÍG“3fc® WÚB؉Åbò)¤Oqqѧ|Ç‚–7æ“7Ë D£Ñ~åå妬¬ì,> -±Xlµ8sù4 ”TVVžßÿ:"Àïð‰@(‰F£óŽÈ¯a4@Ž3yòä=Ü4$±‡ÖÛ>‘H䘸ôþîˆü~Å2h˜ŸâgBI\vcÞÙ_–A À%VÞã“߯X €pØäwt’Ùß?³ &à° ðëI˜eÐ0B‰‡‡h4Ú¯ùånÐ0‡ƒX,öTGÌ2h˜@€Ã Àsâ‚[å"þºAÒ{äÑ–E£Ñ>)˜@€CÅéÕ¬oŸœ•±óÃÏÌÓ/m1Ë×m0͇L]Ã.û|ýŽ÷»ìk7n7÷,Zjjž©K”=ùâ&[¦G8ã1)37ÝnªÖ˜m»?¶BZZy³-ëÌþn¾c¾yµqo«2íëÖꬻ2‰ö‚šUfìu0 pæã”èÕ¦L3À^Ö,ñüGWX¹u3à MYižqÛ=æ…×mÙCKטþÛzšÝݼ냄kŸþãh_Ù,ÀEEEÆ{+‘:¢Ñh Y)Àšé•|~ëØcí£WDý¬÷~2ïa³xÅZsÖ¹½Íö=ìlî’UµfÙó/Û2·”ú²á?°3»Ú‡f”ƒ,À‘HĤq§c¢uÄøÆ ÀîÝ÷¢ÄóâØö}IðÜûµõ´73,¡õ_?Ì pÎò €[€O?óœÄók&—˜g_Ùj¯Ö²hIlŸ‹¶`·$:èÌ5À!`]»+)0x¨½q•›õPXf¯÷½|䕉2'ýý© Ö¬°êh[W† À=þ;6ëÆUS…÷=]ó«k|u­¯»1–®#V=ÝË•+4¬÷ô³J0œ3!Öͱ4ƒìÊtéQWC€`@€ &`˜@€`@€`hŸ¢¢âO%SDàb?­2@$ùNEEÅð FeeåÉü/@‡H"ËËËM€£„ÿE@€`@€`@€`¥¥¥û&Ožlˆ`DYYÙ~2M cCPc­ 4`>|˜Hèÿ«;¸©©ÉÜrË-öù²eËÌúõëÍêÕ«m¹‹7ß|Ó<øàƒ‰×­ö1}út³mÛ6ó›ßüƼýöÛ榛nB€06¼ó›/ˆ€Egǘ@€ãñÅ_˜9sæØçµµµVpgÏžmxàóÉ'Ÿ˜5kÖ˜yóæ™åË—Û×*×kï>$Î?ÿùÏÍ´iÓÌÞ½{m]&`˜ÈzvïiFW«ç^¾ûî»[íã®»î2´³Ç---‰e&`˜¤ëïÓû[¶l1‹-²ÿöoÿf…W3¿Zþ¼oß>sÇw À0 ÀDv ð矞ÜM›6Ùë}S °^»÷Ü2i-‡Þ¸q£½XåÛ·o·¯`˜@€`"«¸®®Î._Þ½{·}œ?~ZìÇÜn+y>pà€½a €0Ld•+´úþûï·wsö–k–W7¶Òs=¶wm¯Þ“,ßxãü L À0‘Ìï À €wcÜwß}öÔtêêwh0 ¹-Àk7n7÷,ZŠ@°XËpëëëíÏè¤S·¦¦¦Myss³½Õ[¦»§³O@€ƒË×m07ÝŽ@ðxØ°afüøñfÀ€fÿþý&??ßÞ¤Iï/Y²ÄTUUÙèÓ§4h}Æ öýÒÒRSTTd† bÞxãÄ>µ?ÕÛºuk >ýâ2Xu´‹Åž ¸×uòßýc¾å¹#À3n»Ç <Ô\>òJ;û+¾lø̈¼1¦wß‹ÌúïÛz Ël¹ê>ûÊV[6zü$+Ë—aŠc7òßßÙ1‚ r9Èà¬`ý¶¬žÏœ9Ó¬Y³Æ.‰ž8q¢-9r¤½Sq²`Õ“èê7jõ[¶z®òþýû':(‰DLÀE¶Ûƒ 7X"+ñõÏKtw~ø™™{ÿ£æÖêZ½_óL]b†X2¬úîy˜1‚ È D¬%Ðz®YÞeË–%$V¿-›———r ´êjæWåÞ÷$ĺ³±öáöÖà\Œh4Úpd`«â›~Öµ¾þåÎÞ%ÐîýÆæC&oì3öº+Ç^úhÆ‚ W€ °f}u½®dVòªò… Ú%Ï«W¯NÔÕrh‰­®ïU¨®–Më`-Ö£ê¹c ñÔ©SC} p.rdpcPÈÖ’gI¬W±}ϤüôK[¬»%Óa`Ær‰ëºÝh4j¯åõÞ Z{â‰'Z±uez>kÖ,{m¯»ÞWKuf\áf{%Õª£ºNŠ`5î5À’\]ï+Á­ßön«»@k¹³žk9ô5“Kì5¿ZíÞ/(›†+œ½!=ztb94¿ ñìÏM-Ž\×Óà)+ãS¯ó;ÀŒ_7W8²4úF>)8ëBËŸÝ]ž`82¨=ÓÞM.âÚ<>% Wè óI ÀœõÄb±u Àýø”`€\¡øª¢¢ât>)˜@€³žH$rL\rÿ˜b@û5ŸŒ+Äs‚/Ú9YþŸL À!ÕÒ&–? À0´“+üUS¦LÄ'€p`Hµ´‰åÏ0 íå ñò7ùt`)–6}È'€#ÀÐN® “å×òé„œ’’’Ï5`ÁˆÒÒÒ?Òj;Æ¿´‰åÏG™–^ÿŸô¹Œý´^€Îå ñh©®®þŸ ÿÒ&–?@¹¿ý ÁÄ·´é>h'WøCüõwøT °¸¥M,€ör…x,æÓ€@ã–6±üÚɾª¨¨8OÍ‘¥MïðI@ª\!.ÁOñIäÅÅÅ-Ü538ÿÿú¨«Û@QQáaý¼ BÛJJŠZèˆÿnçù¿ìò~¡8òŸm cOW·…ë§\€Ï5Xq}Yä“L䌱ò²C|¾ÁŠH¤ø×]Ÿ7}ÀgH‡hÁ|Àïó;ÀÚ§ùÃN"`‘©¶ð‹ƒï‹Lµ~W—ߦ_ O _ WÀp˜@€ ˜@€ ˜@€ ˜@€`&`&`&`F€ ˜@€ ˜@€ ˜@€ &`&`&`&`˜@€ ˜@€ ˜@€ ˜@€iÄ4^/ååå±xTUVVžÌ€–ÛƒZgÛÉcø’Ýζ„2|L¿@Ÿ@¾@®Ð퀜F€‰làªx˜x|å2 åì Ö©¶@òJîT[@(C)Àô ô ä ä _»“#Àp–EKK‹Ù»wo® °76F£Ñ¼ h_Üa^­{ÌÆgûlÙW‡MsS]ZÛ¿òÂ#æŽÙe¹:¨U[ÈöÄî­½ÛÌO/1ÏÔ=i~þI“-{§¥ÑlÙõZZÛßµàv³äÉE¹*ÀGÕ²]ö^mÜk–¯Û`ÖnÜž(Û¶ûcél?)kµmŽ p¨ú…—¶¼`û…Ûëez®¾¡£mUgÄÃÌÛÍ;rU€C“/(/øék+옿oφDù{o­Kk{å‘‚«ÉÒha̱›››Cëp4â9s昚šØñÎlw,+‹D"Çi@ûbÿ63 oóøC³ÍÒGn7oo}Ú–·ì®O{ Ò &yÎåA-þÿÿWÏë”m!›“ºW¶Õ™‹/½ÈÌ_|·™{ïœDºà±{Í ·V¦µ‰³’å\`_[x/U[ÈfÑ{hésÙð˜[«0¥•7'Ê+nºÝJq:û¨ZXc%:Çø/é´…lnÿ%±"ê®ü’˜Ö‰1HSŸâN¨å°ÿ9¶Íãâ•£.3 î¾Á¬xüNÓ°~Y¢üô^§¤µý¡–ÍfÍŠypycsì0û"Þ¿¿)**2'N4¥¥¥¶lêÔ©¦W¯^æì³Ï6C† 1µµµ¶|ìرö½‘#Gš•+Wö߬ï‘Î*iÄ;ª†T™§CûÔ{½G¶hÞQ#.±gv]™ÎðN7ÒœuÆiV‚5à©|ÖŒ";Ó;æÊ¡fÒ„+lÙKÏ?lŸë=·ý#Ü’¨7nÌðÄÀ§}N)g÷«4›?—®h ñ8äo ÙœÔ=ôÄS>£¬U™WIñùžgÆOú‘RyÞÕW˜²ÊˆÙ™yÛ ‰ºC¿?ÄʳÛ~ô5?4…e“m¹«÷⦵v{½wa¿ Ìs/¯ÎêÏ¥‹ÚÂoým!›EïšÉ%fAͪVeeÓÌ)ÿÐËœ{A_3`ðPSóL-uÕ8[ÿÒ!#Ì’Uµ¶,oì[ïé—¶$¶¿|ä•mêéqDÞ»?Õ߼냬þ\2Õ²¹ýŸ}ÞYmDW}Á 'ž`¿Çz®•#ë6>k&—L´ßë~÷µ'ÔT®÷Õ¸m·6m¶õFýðûöû¯z*×I¶ë ¯µeêW‚Ü'tÐþêÉ)_ÐØ­“æîõžµ6GøßÇ~Ë>º<@9@õmåvü—4kWwÈà~‰íkŸYhË”+(Q=å"…?¾ÊT”ÅÛBï3ͽwV†>WH–7YåùùùfôèÑ ¨ªª2}úô1ƒ ²ïmØ°Á–çååÙ:Æ 3Ë–-C€àž7Þxà íÁƒ;<ƒóÍo~Ó466ÚF?~üøÀþ›#‘ˆI#yI7t½Çýú¢gûL Tn؉p²`½~hþÌÄóýͯ%­«ýi_–Ji@Ô ³Ê4Ðy—Oecdª-dsR§¥ŠJ^%¼Ëž­I”'›>õ´SâªD6U]͹zJlõ¨$×Í+QÎöÙžLµ…l½º†]¦ÏEÍØë Ì ¯7¶;ü¿=ÞÖ¯ßö®ÜTu¿uì±VpUW2¬²ÓÏ<Ç46jU–Í‘‹ý‚¾¿úîêD–W„ý3ÀZý¡ï³úõºÂ[×=×6ª§a].¡cZmâú‚Åÿò`âdYŽô ÉtâÚI©W„ý3ÀÊt²[ÏuýÍ7žJZwÕÒêD=ɳf•u~få?¹9Òj¦9—r… ‹à¦M›¬ØÊ :ò‡cãã‚üaß¾}ö8dK çÍ›gÏÖLŸ>=!ÂÉ°f…ð|¡ gý–Ç뎬®®þFPnj¡k5¹'•«Ü¿m2vƒ–ÛF¯ ìcÅxøЋ[Í8‡|¸U[Âò>ÍÐhF‰h{œlÛdì®ävì„1öQ³CÙþydª-aÉï²ç_6gÛÛ j*þÿÛ;÷ ¹Ê2ÿC­Ö²«T`QXD` XÖ¨ ‹ˆ,$™dB˜LH;D¹%ÃÝ YÂÕABƒ!1Ñ€)B0@v†5aZTim¹[gç9›·ýæÌé™Ng.Ý=ϯêWÓ}úÜúÌ×ç}Ÿïvh½-Û¶¸.­Çü]øÌË•mhý|éÕùxá‹®œÑð×£ž²Ðµì[á¾Ôî¹÷Ç*ã~˸ÚP‰"Çï>݆–fzpïiö^!½”…?5{¾Àœ!TfS‘Ý·eÛ8Ö‹¼ŠuZš9­ÅQÑ>Ür…fϧo¼ñƼ§hGGÇ°à¸EÇS“³lÙ²J¡¾öÚk[²oÇXŽn7¯fÓC0 %øÐM™×´«Òö05Æ´ÓeºÑáw;ÇõôZ½8^§Ñ•™Ä—.‹ýÀt‡fŸ÷?6»•'Áê³,42èÑ*¯iŽîÎÀêŒ[g÷ÓÊ|ïc‹»µ2·à$X-q_xiêRcn@5ï¿=L¥÷Z„W¬YÚÊ“`5}¾À_zp|Ð>•åûî³G·áíà¹÷]›WÆó7ÝçpËš½ t¼¦'éŠ+ò×° k°ÜÐxé¿OáM[€™Å1¿@ñüùóóeÍÞm¡N~»ÚÍ«™ãrè¦Ì8^Æݤµ­twˆ LÑ•©XË2ZtÃÔ^øÅCݶ¡å ˆén ·PPÛ\kYh䤎ñ½G}úˆ¼K3ã{ÓÄ—nË´Ú2N8Æö·g‰.ŽÏ™<'L'O»`:Æ260ƶ×\ô˜øŠI°0ÐËWÆ÷ÒrKëpŒ .n4³ë2VŒ æ/Ý cøÄSÏÈ×elp Þ-À-q_ˆß+À›`,?÷ ~ëŒõ†ÓI²böè¸'à{¹+ÜK®º°ò9Û°ýßl÷üžÀ>9^‹ðæVÈ«KN€cÂLÌÄVŒ÷eÜnäʼn1Y–æ äñô‰4o »4pM®@+s£¨{B3çҌCˆVßthxå­Æ°Ïòjuž\ËÍËçú•NjwiýŠcb­&ju•Ÿ¡ù«<Ñ%á¬IžIŠ›€ë* Ãý™ºÌ½ÿA‡f«~ýn¾ÀðÒÕo4;{_¨Ã´üRÉƸàÅ+Væ hr6_¨ÃL “dÆ$›Ã1W0'€`ÝÔ…×€öçG%Ñ­‰Z]Æö4z7è* ðÿOªÃ„:$¼1θٓÝzÊÂp`|Åu·æ­ÅLž-ÊÍ ÀÞê3àˤY´3}­Ïo¥{‚ùŸ•D¯3rþ2?ÉpÌÌÉeX ÀZÖ°€µ¬`- ÀZÖ°€µ¬`-kXÖ°€µ¬`-kX À°€µ¬`-kX ÀZ¶[x h5]-kX ÀZÖð¶hܸqïqAtsø¬³ÎúC—1cÚ¶xm›Ïííc~×ßeaìØ1¿óÚ6ŸG¹©¿ËBû¸³þàµmJoìï²pvÇøÿñº6Y®pöYÿ=9ã9Ïöú6[Y7ö½þÏǘ76¡ÇŽû;ÉW)¥”RJ)¥”RJ)¥”RJ)¥”RJ)¥”RJ)¥”RJ)¥”RJ)¥”RJ)¥”RJ©¡R[[ÛkÎŒÖ<îú½Þße`Ô¨‘ÿáµmÆ™G­ë÷²ÐµO¯móyäÈ‘kû»,ŒÝöº×¶)ýj—…1cÚÞðº6—ÇŒ³~ rÆöö1ÿéõm¶¼qôkýŸ7Ž2olʼqô:Éw«|–—Ïðò¹~>Û/- >CÓg~FYð¹º>Øû‚÷ósÙA†€µ¬`-kX ÀZÖ°¬`-kX ÀZÖ°€`-kX ÀZÖ°€µ,kX ÀZÖ°€µ¬`X ÀZÖ°€µ¬`-[ˆ-¼4ƒš‰®É®¬`-kX À⺼lÙ²ÜÍXx;::FM˜0áŠñãÇïe@ÞA­Þ²`òØzÉn½eA l=ö¾à=Á|Á\¡?ʼ {ž2eJîÕ«Ww[~Çwd«V­êsûM›6õXvî¹çf#GŽÌž|òÉüý‚ zì[÷Y«9oÜ_ǘ:ujþ]æÌ™3à…·ë&6µËÙVÿ{-7µ¡ hÜôLvý5_Ëÿöç>7¯_ÒmÙŸÞYYÓ¶ïnXšÝ<ã‚–j…²ðr­ea¨¶e«—d3n¹¦¦u_ysuMë½°~eöܺgêÚvñÊ…Ùm÷Îl‰d7- ¿ªµ,4ÜýxåÚËVýúÝš¶½èÊÙò5¿­ë¸'uTîùKŸÏß/]ýFe¯› € ÷…ý¾Àoð±Åsûý^Sï=åúï~+¿7´Ê ž/Ü~óe=b{™k÷xëOÖ½ýwn¸¸_s—FȺâÃÚZËÁPÃ95ì±xàºX}’¯“·÷¬\¹2߀[€Ó“O>¹G!¼ä’KjjIÝ{ï½{,;úè£{@vqÿ½g-»½|ì±ÇÖ¼OÎï0ÈœzMµ›Ú`´Ïó‰ËÞÛ¸ûÔ}Ù´oLèóߺjRöùŽÊ÷™‚ì¾ûìQÓ9n\÷“ì챧Ôõý¶%è§~©·²0Љ ä×.Ôcù–ÏÏ&]ÔÙçö—\ua¾¾Àø«£¿’øÒ粓O;)»ÿ±Ù•Ä÷¨OQÓy>²èûÙßøZ]ß±Ödz(¸à{+ u·Ìž›vä19pŽ›tQeù—Ï›-|æåšöÁºKž­®ãsìj`\ëñ€³Zh0î Ÿü§Ã³§ŸÿIåS¦]Rùýöæc>{tŸëÒŸøÔ¡Ù©güK~o¨åžR4÷¨ÇŸ~´áï upÍea cÛ»ïZºüÜ §gë×,èhO8î“}ÆéÇþv¾¹Â•—¯|Nüïëa¶%ghá\¡×¼q¨anݺuÙ=÷ÜÓ#·&ßž>}zŸÛ7®WÔÊ‹/Þ&¨-2ÜB] )i¡)¶à¦5!#FŒÈ—ÇûwÜ1ÿË6½0`{â‰'V öµ×^[i~ꩧòëxàÙGÑíøóçÏÏN=õÔìœsÎÉ6lØP)À,cŸœK5^»vmÖÑÑ‘üñyí?:ö½ÓN;u«Ùa|Ίeqœþබ¶lëͪÔK«ÜȪ&½CÀÔä@pº|î}×f'}þ˜ì´SŽÏ×!Pµ´O¾îìÛ¯êУÿõ‹9 —Î8Æ_íø—ÝŽõóŸÌÎæ}ïÆ<ØMÿ•¼÷ÕUóòÏ/9¯­²=ËXcÄz,¿ÿ®i•ýÅú_¿¨½Û¹ ´û£,t­³ºX†€zâ<)?©½Ûò+¾5%OlÇv¶UÕýØ·’IJ]¬»bÍÒnùK"]LˆY—¤÷C;}(ß–}±œVç{¹+ÿ,–ÅùÄ{|烷e7ßy}vÂ>[YNB $Û¬-Ø@wzní~º/¼P, uè‚å/ö€ÏÝöØ3;ዧTZbñÍwÍÉ!™å¼ÅÖZþ^:í†lÔøÉùzѲ<ëá'*ëâfà* CÀüΊ¿sZ_YÆï›ßä/×.ÏßÇï§ûà7÷•ÑãÏÌf}ÿŽÇ(»§°œû¿÷hf?¬³hÅ‚Êöüæôã>wle=>{B¬4³/z¥4Â=a{ÊÂPpÄ[brZ1~ÆiŸËN9é3ùrâ:yÃ.;0_—Þeé>Ý»¾sy%)Â+Ûìµçnù>xMþÀ~çÌžžÇwŽÛÄùD‹4i¾`ÒÈnë-Ypg¾¹Fää8œË`ð@åtÅÜ:Zpo»í¶n-µ4ÈÑh-»ðÆž{î™çõ¬ PÀóæÍË9†>òŽÁvlŸ‹}ì[lD€‡GAJ fÅŠùë7V–ï¾ûî5µSøØŽ¿À+ûŽ‚Ï<`·xÜ5kÖäŸÝ".¸à‚|ù~ûí—­_¿¾ÇùhŽîËézÅsäûßïŠ+®è¶þàööö¬†Õ¶ø§ü¸l9­µ`3ÄÒ…³z´`¨Á%ÀÄ2‚Ë~ôèwz ¨ìa‡ìŸ×ˆ€Ü²óá¸GypÞ5Ðe½u«çWj˜9€žXà`¶* CÕŒ?²Û®ÝZ`£•æ¥ «*ËÙ¶ØZCâI]Sd@4m­!Áf½t[Ô¿ü…ütt,®Ëq9öëÑ=3¾ Ǿ£ë5ëÖÚª´½¨²Ð(P7ãÖÙÙþš}sæ]ÙÊu›«(¯wýèîÙ£?]™]ÇýÝZ‹ÓuùûÁǾ;λ,_¾×?쟭xõ­nËš €›õ¾P­˜ßPú;,¿7ÿÞÊï,ݾ¬µ–ʳhyåž²çÞË5QvOyßûÞ—ÿ¾9'à6]7ŽÙïéÁëÓܸ½é={GÙ÷l‚{ å ÕZ€Hbrš+›cèi½-æT”µi5¯É€Û4^sŒ´˜ã}ô#;e¿úå#ùºô2Ks…X—¿€ws¬Ç1Ø?ËR 'ÜûêýÖȹB#pôJMÏƱÈûÓ¾·—Á(ðC8Ž[¼0`Í1`X®¼Ÿ;wnvÈ!‡ä@ $n+Çþ£‹s2þvØaUKág=Α_Ìrjm8j†¨Õ©ÀÀ6çdÀWàø!ÒúpÝ€-Àowùî®uŸ6mÚCÙºl9  t,z`¶KÁ5L ¢«µ°½0Žà˜¡"Çqcjz j‡–jjÓ}ÓZÌX¥&©ÕÝ\, À) XÞòo7UMVIdwÙuçÒqy´æpF‹m5Ž„–Ö¤H–Ë8Öc>ç=ðLò{ð'ê–T³Ÿ½÷ÝkPZ‚ª,4ØÑš;ñÂËs.àh¹et|n€c½»y²òš}?øøÓ98_qݭùxÐï µ0¿'NóÅß5Û¤àšÎ pÍMWç­¾q¼2N÷[eœ®¯¹oÑ:Í>9Ït¿tçæ^1ÐÝ¡û±xó`ç µp@,ÏÂeL>P6„ŠJt¶eÐe-·¬Ç)àX/ÍØ÷sË,í!FŽSï«!ÈzäÍÀä÷ô<¥e–Úm`´` Ø#ºG¯TzŽ ÀpuÒ€PL7‚m`~Ìñš®É8°Né´ûë²Mµsg} ¼¯1Àt³¦Õ8=Ç´6©7Èm€1À[Ò›W£Œ®¶œ@CТ«PÞ'¬¢5m­DéÖ”Öò¦ÜÛù”ð ¿x(‡k 7…_öOëoZCÜ ãzÞî­,4 ‡RÞèvÌ'Ëâ3’ϲ±y$É1î@e_Õ8u-L"=á¼ñÙÕ×_Þ-ç8‘7øàͽ•…FœåøÓÇ>o¹ ‰©Š`Û¬–0-¿G}柳¯Oÿv>æxŽÞ<”÷…Z¸ØšïÚ"TÒ…-ƒM~·Q±Æ0†â=¥¬E¹Væ¼8gº_§½W€_ <ê¼y(ó…Z8â.ó}˜Ñ™ ôâ:€f±Kt˜õc2,ŽA/¯2.Ëz`r†o‘+üxþw{LèÅ9 Fo±Ê›€ÓÞ Ì9­¸ WL¸·1ÀäúpÂÌ™3+ c§Ÿ~zUv ð0`þ±Œ‡¥•5À‘e´ìRØNc¼lŒ¥íXº(S«€–e€steÀ´Èî°ÃÝj[èËOËn:1Ç¥ö‡³ÃÅùpì´À˜±Æ1V˜×±œc9Nƒð;Õn^CÀøÛ¿Î"1¯c9‚Y –@B7ã.1람³)¶Š±œ¶ÂøØÝ ª0ÇOχó+`‚#]X‡àø–µH7HPÛRkY tI1É ËxM·ÃXF²DÒÂÊßH$]’]–¥‰( LwCþÂ$¡ì àeŒo¬G·h’Иp« €lZiþ¦«,Äù”0€ß…}’”Ç1ê(gøíZËB£@݈“OË!Ÿ6z|eùm÷ÏË[mùœÖÞ2¦å˜íèò|ࡇçݨ˘٤é>ͺŸ:ú¸¼µyðæF¹/ðâ7Çßè±ÁoŸ.Æ8æ\ã7œB+Ûð›O'·Âüöûë°ÿX/ºPӃ〃ÿ1?^üÆ˘eüÞ¹ÿÄ9–pÜwè½Î1¸o ÖDXuðæFÉÞÿþ¿¨Äqb.y¯‰»Ì±;ÆÕÛS0&ÎÓ;+Ü*ò€Ø–\"Ž‘V®S¡N«mÌARÀiîrÄáæû,`ò`žu9Ǩ/v‡n°\¡æ¼q¨a …;`hTƒ7h­…I‚#ht#Og´1 øe{>«6¶ ÷Vˆõbö϶Á°Ïî×ZXfÍšÕkëî@ν½µTÀ“k¹yù\¿ú €„˜ € úhƒºÊ‚ÏЬÝ$´½Àð™cOoÔÇ ÕU†Óóséú|â©gTÞïüwiUö¾0€¦˜Ng§~ô1Hæ hzˆ1yfTÖ3–¸•r…V|Nî¶9Ï]´¢[«2“f•=›¸‘ØûÂÀ›Ù¢¹'ТœÎ$ßì÷ó…m3] #W Å¹Úp­fÍZ€ÉÓÉ×Óa‘Ûc Ë”=îU€µ¬`-kX ÀZÖ°¬`-kX ÀZÖ°€-Ä^šAÍDW ÀZÖ°€µl!¶ðÐ j&º&»°ì}Á{‚ù‚¹‚ì ` ±…×€fP3Ñ5Ù€`ï ÞÌÌdBÖ°€µ, ÀÞ¼'˜/˜+È2D jôèÑ›¸ º9ÜõÿÚÜße`Ô¨Qÿåµm>ó³,hýÛùû„yM îŒ[gW–Ý|לìÞÇçËÙOðÉ_Uz¬ÃŽ<¦)¸­­-+tãÔZ÷⎎Ž¥°RJ)¥”Üðð»ÿA‡f>þt6ëá'* ËŽqRöý-«À.ëŸxêÙ-³çæËöøø>Ù¨ñ“ómn[€ÛÛÛ³&÷ÑZ÷´c~•RJ)¥àÆôyßøf6õÆ;ztŽe´ìF+ðõwÜŸ¿ŠcÙ!‡YÙ`¶XëamáW)¥”RJn\лèÊ•®Ïec€€ïøÞülÄɧe+^}+‡ãø¼ h[€¬”RJ)¥”R-ÀÌöLwçq“.ÊÎhï¬ Àtƒf+Ö㯬”RJ)¥”Rª©3SóÜE+*>¢•Ç#âõW®Íæ/}>ŸÑ9–•=.IVJ)¥”RJ)xXÞm=s^ºú|àÌû~xgX)¥”RJ)¥`-+¥”RJ)¥”¬`¥”RJ)¥”€µ¬”RJ)¥”R°€•RJ)¥”RJÖ°RJ)¥”RJ À°RJ)¥”RJ©ÚÔÖ6f 0¥›Î-½J)¥”RJ)¥”RJ)¥”RJ)¥”RJ)¥”RJ)¥”RJ)¥”RJ)¥”RJ)¥”RJ)¥”RJ)¥”RJ)¥”RJ)¥”RJ)¥”RJ)¥”RJ)¥”RJ)¥”RJ)UMÓ¦MÛ¡££cÔ„ Æj­µÖƒå®Ø3Â(¬”RJ©AWWò•®däO]δÖZëÁrWü9¿Ycg×ùwvyªÖZk=ˆ¾˜L VÖZk-6ïÛåþµÖZrÜ|T‚µÖZ ÁB°ÖZk!X ÁZk­…`!Xk­µ¬„`­µÖB°¬µÖZ‚…`­µÖB°¬µÖZ‚µÖZk!XÖZk- ÁZ×ïÙ³gg¿ùÍo*~饗²ûÇz .Ì?_·n]6yòänŸ=÷ÜsÝö±zõêìÎ;ïì±9sæ䟯_¿>»ì²ËJ÷Ïg·ÜrK·Ï8çÅçk×®­,þùç»?ðÀÙ’%Kz,³ïâwŽsfŸ3gÎì¶üõ×_Ï/^œ]|ñÅ•ã>ôÐCÙ›o¾™½÷Þ{Ù¦M›²yóæ•^[öÉ÷‰÷¯¼òJ¾OÎ/]u~øÃZµ,kÝ#þM™2%;ÿüó‡ä¸çž{nMëÓYâĉþß´¬„`ÝØÞ9ó駟ÎÞzë­ü= ™Â-[¶d¿ÿýïóÏn½õÖnûêXξ€;Öåýu×]×ôb@dYζœKúÙ¬Y³òÏÞyçüoñ¸œwÀ´y½bÅŠüs`5>Ÿ1cFïŒ@ï¾ûîü3·ekÖ¬ÉßÛȼŒ9pÌ:e×6Î/Þó:|à 7t[Î9Xµ,ëÖ1q4½ï_¹×G…ê5×\S‰‰©‰SŸ#ž¦qØä=•Ïéñˆ«,'fò~Ñ¢E=b1¯‹Ç Gœ#öE¼åüØOµïH…ù† *û`;Î3g–¥•Áéy°orŠjçTüŽZ ÁB°ÖýÀ€ï#E Ä·ß~{¾ Øãï³Ï>Û+èÅ>Ó–Q}º´%7àŸýìgù_j’Ó–^ `-àjß}ÌööSǹÿˆÓmËZÉk`ZÐùKk°¬…`!X·~|%fò:âÜÊ•+óÏ©xÈça9ýŒ¸ôðÃWbY­±¸R¬peÛ¨øžL@&ïöȈQìç?øAU à€9?*…9ß"¸òžx˜nßã^yå•=Ή ì8'Ë’‚…`­€£…3 ^ojp©Ñ%ÐÅëj ·|ùòü=]cÙ‚ òe—_~ydy]à›nº)ÿKÐMkºé"ëK@ÇÅnÕ}% ïØ6ºu˜À>ºŒGM>¯‹ÝÁû`Î%¾G´¤ ÀZ‚uëÇWº1§0˜B`µmçÏŸ_wån—U<§ŸÇ>€Ù¾ºH3ˆâ´ÂšÜ öꫯ® €ËÎ)ݧÖBð0±ë‚þÜB¥#@Óå £Ö7íM0x£ÕM»X¥ Çß´ö6 @F«/µØBAm€Ëè.³|úôéU8õ¶$ ©#a&°³¾;¯#Aàü¨½íø¾Å1Ë}p~ºQ³?X7 7¶··@Öºÿ˜X‘ƤˆT8óSéšVFƒ€àtŠ`æïˆáHì¯ÚØcºiÇP¢âgqÜ8X Áªføå"Z˜ô`ètücr^£µ4‚cÚE:‹Ëkg …1Öxfñ>”Â-ãˆcëÄzÕ8‡â˜ã¾’ ?¶ä"¾/°ôÇw-NìArçS¬ï €£U=X7ü‘Í?;;;Ÿðÿ¨%¾R©ók[rS§ñŠ•Ææz3œÆਠN{s…æ{k½ŽJnX#¿×•/ É ¿ºItn±K/ðW61Ðwá…ö=º5ó-£±¯÷[fÆá6ºAÇTD«ð@ŽŽ¢Zw0jî«í«7¦k׉V`X ¿ÆOÝÚc€#–¢Bµ¬8ÃpbÛ¨hŽy;b8±*º36Æ3§Ž˜o °nðÛå£%Yƒ·nÂ.Z©\Ý¢#8ã˜]9j£‹ ŸÓM:º4Ó:ÝGÌNI«pnÙ&ºR§c…û\|döŒ.¶ôÓÖj¾3­¿œ#×'&ü ‹ö¶pšœÀZø5~êÖ¯iÏŸ¾Æ­²lsc0©bºN̵C”¶€Ó9@Êr„ˆ¯Äöb©¨Ø h¦W-Øi{<Ý¡ø@X ¿Â¯ÖC ÀÀ^Yëg´ÐÆØŸ"èÅØ%À9Ö->F¨M'—*ÂmŒ5N1TËàt\ñ¶Œ&8—0Ž–hº|¸§fæêmœ^ƒxÔ„¬…_ã§níøãfc>Œ`*ÓŠ\€’Y•‰ÁÄ Z£²5`•JÙ˜0’mˆ»1)UL™ö`ŠÊçt²È2æ¸tyfŸ´Ç“ Ê*y#6çœ#ŽÖß4ÖEO)ÖãûÄð¦2ø€µð+üj=à&ÀErÙ$|]Ãg–óx$Þ3yV:)VÔîbj€Y·,˜1ž˜ÏØ œîƒóá³è"லNê´›µÍ,c»"|·‹ïÂy÷ß¿ì“ï«(î;uñºðº¸~\ãô{j-ü?ukV0Prï¯öL^ ‰¯ŠËÈtn €·84)}D_:–·¬’¸ €ÓqÇaZ–˾À­½©©üN'í"æ¦Ï îm¿°~…_­µÖZø5~ê&4¹T®¦04RÊ2*Ó¡AáÊC«+OdÀe•¤TNS‘L+0û,Vdó¾¸ïtöÉùçþÎi5æ¸Å±¿Eóh}fýhi.[/*£e;&+«”g½Þ1¨µð+üj­µÖ¯ÖZk-ü¼µÖZkáWk­µ~ ÞZk­…_ã§ÖZk-ü¼µÖZ ¿ÆO­µÖZø5xk­µ~ŸZk­…_¥”RJ©þVggçM] Èz­µÖz½NøUJ)¥”RJ)¥”RJ)¥”RJ)¥”RJ)¥”RJ)¥”RJ)¥”RJ)¥”RJ)¥”RJ)¥”RJ)¥”RJ)¥”RJ)¥”RJ)¥”RJ)¥”RJ)¥”RJ)¥”RJ)¥”RJ)¥”RJ)¥”RJ ±þ m·’D˜ˆIEND®B`‚neo4j-python-driver-5.2.1/docs/source/_images/core_type_mappings.svg000066400000000000000000022122101433522662700256240ustar00rootroot00000000000000neo4j-python-driver-5.2.1/docs/source/_static/000077500000000000000000000000001433522662700212365ustar00rootroot00000000000000neo4j-python-driver-5.2.1/docs/source/_static/anchor_new_target.js000066400000000000000000000002651433522662700252700ustar00rootroot00000000000000 $(document).ready(function () { $('a[href^="http://"], a[href^="https://"]').not('a[class*=internal]').attr('target', '_blank'); }); neo4j-python-driver-5.2.1/docs/source/_static/custom.css000066400000000000000000000002141433522662700232570ustar00rootroot00000000000000body, div.body p { line-height: 1.6em } sup, sub { vertical-align: baseline; position: relative; top: -0.4em; } sub { top: 0.4em; } neo4j-python-driver-5.2.1/docs/source/_static/nature_custom.css_t000066400000000000000000000146601433522662700251720ustar00rootroot00000000000000/* * nature_custom.css_t * ~~~~~~~~~~~~ * * This stylesheet have been customized. * The original Sphinx stylesheet is -- nature theme. * * Copyright (c) 2007-2020 by the Sphinx team. * Copyright (c) Neo4j * 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. * * 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 * HOLDER 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. * */ @import url("basic.css"); /* -- page layout ----------------------------------------------------------- */ body { font-family: Arial, sans-serif; font-size: 100%; background-color: #fff; color: #555; margin: 0; padding: 0; min-width: 600px; /* new */ } div.documentwrapper { /* float: left; */ /* width: 100%; */ min-width: 450px; /* new */ flex: 600px 9999 1; /* new */ } div.bodywrapper { /* margin: 0 0 0 {{ theme_sidebarwidth|todim }}; */ } hr { border: 1px solid #B1B4B6; } div.document { background-color: #eee; display: flex; /* new */ flex-direction: row-reverse; /* new */ align-items: stretch; /* new */ flex-wrap: wrap-reverse; /* new */ justify-content: flex-end; /* new */ } div.body { background-color: #ffffff; color: #3E4349; padding: 0 30px 30px 30px; font-size: 0.9em; } div.footer { color: #555; width: 100%; padding: 13px 0; text-align: center; font-size: 75%; } div.footer a { color: #444; text-decoration: underline; } div.related { background-color: #000000; /*background-color: #6BA81E;*/ line-height: 32px; color: #fff; text-shadow: none; /*text-shadow: 0px 1px 0 #444;*/ font-size: 0.9em; } div.related a { color: #ffffff; /*color: #E2F3CC;*/ } div.sphinxsidebar { flex: {{ theme_sidebarwidth|todim }}; /* new */ font-size: 0.75em; line-height: 1.5em; float: initial; /* new */ width: unset; /* new */ margin-left: 0; /* new */ } div.sphinxsidebarwrapper{ padding: 20px 0; } div.sphinxsidebar h3, div.sphinxsidebar h4 { font-family: Arial, sans-serif; color: #000000; /*color: #222;*/ font-size: 1.2em; font-weight: normal; margin: 0; padding: 5px 10px; background-color: #ffffff; /*background-color: #ddd;*/ text-shadow: none; /*text-shadow: 1px 1px 0 white;*/ } div.sphinxsidebar h4{ font-size: 1.1em; } div.sphinxsidebar h3 a { color: #444; } div.sphinxsidebar p { color: #888; padding: 5px 20px; } div.sphinxsidebar p.topless { } div.sphinxsidebar ul { margin: 10px 20px; padding: 0; color: #000; } div.sphinxsidebar a { color: #444; } div.sphinxsidebar input { border: 1px solid #ccc; font-family: sans-serif; font-size: 1em; } div.sphinxsidebar .searchformwrapper { margin-left: 20px; margin-right: 20px; } /* -- body styles ----------------------------------------------------------- */ a { color: #005B81; text-decoration: none; } a:hover { color: #E32E00; text-decoration: underline; } div.body h1, div.body h2, div.body h3, div.body h4, div.body h5, div.body h6 { font-family: Arial, sans-serif; background-color: #a9d3ff; /*background-color: #BED4EB;*/ font-weight: normal; color: #212224; margin: 30px 0px 10px 0px; padding: 5px 0 5px 10px; text-shadow: none; /*text-shadow: 0px 1px 0 white;*/ } div.body h1 { border-top: 20px solid white; margin-top: 0; font-size: 200%; } div.body h2 { font-size: 150%; background-color: #a9d3ff; } div.body h3 { font-size: 120%; background-color: #a9d3ff; } div.body h4 { font-size: 110%; background-color: #a9d3ff; } div.body h5 { font-size: 100%; background-color: #a9d3ff; } div.body h6 { font-size: 100%; background-color: #a9d3ff; } a.headerlink { color: #c60f0f; font-size: 0.8em; padding: 0 4px 0 4px; text-decoration: none; } a.headerlink:hover { background-color: #c60f0f; color: white; } div.body p, div.body dd, div.body li { line-height: 1.5em; } div.admonition p.admonition-title + p { display: inline; } div.highlight{ background-color: white; } div.note { background-color: #eee; border: 1px solid #ccc; } div.seealso { background-color: #ffc; border: 1px solid #ff6; } div.topic { background-color: #eee; } div.warning { background-color: #ffe4e4; border: 1px solid #f66; } div.note { background-color: #20ff0050; border: 1px solid #000000; } p.admonition-title { display: inline; } p.admonition-title:after { content: ":"; } pre { padding: 10px; background-color: #f0f0f0; /*background-color: white;*/ color: #222; line-height: 1.2em; border: 1px solid #000000; /*border: 1px solid #C6C9CB;*/ font-size: 1.1em; margin: 1.5em 0 1.5em 0; /*-webkit-box-shadow: 1px 1px 1px #d8d8d8;*/ /*-moz-box-shadow: 1px 1px 1px #d8d8d8;*/ } code { background-color: #ecf0f3; color: #222; /* padding: 1px 2px; */ font-size: 1.1em; font-family: monospace; } .viewcode-back { font-family: Arial, sans-serif; } div.viewcode-block:target { background-color: #f4debf; border-top: 1px solid #ac9; border-bottom: 1px solid #ac9; } div.code-block-caption { background-color: #ddd; color: #222; border: 1px solid #C6C9CB; } li > p:first-child { margin-top: 10px; } li > p:last-child { margin-top: 10px; } neo4j-python-driver-5.2.1/docs/source/_templates/000077500000000000000000000000001433522662700217455ustar00rootroot00000000000000neo4j-python-driver-5.2.1/docs/source/_templates/PLACEHOLDER000066400000000000000000000000001433522662700234000ustar00rootroot00000000000000neo4j-python-driver-5.2.1/docs/source/api.rst000066400000000000000000001251271433522662700211230ustar00rootroot00000000000000.. _api-documentation: ################# API Documentation ################# ************* GraphDatabase ************* Driver Construction =================== The :class:`neo4j.Driver` construction is done via a ``classmethod`` on the :class:`neo4j.GraphDatabase` class. .. autoclass:: neo4j.GraphDatabase :members: bookmark_manager .. method:: driver Driver creation example: .. code-block:: python from neo4j import GraphDatabase uri = "neo4j://example.com:7687" driver = GraphDatabase.driver(uri, auth=("neo4j", "password")) driver.close() # close the driver object For basic authentication, ``auth`` can be a simple tuple, for example: .. code-block:: python auth = ("neo4j", "password") This will implicitly create a :class:`neo4j.Auth` with a ``scheme="basic"``. Other authentication methods are described under :ref:`auth-ref`. ``with`` block context example: .. code-block:: python from neo4j import GraphDatabase uri = "neo4j://example.com:7687" with GraphDatabase.driver(uri, auth=("neo4j", "password")) as driver: # use the driver .. _uri-ref: URI === On construction, the ``scheme`` of the URI determines the type of :class:`neo4j.Driver` object created. Available valid URIs: + ``bolt://host[:port]`` + ``bolt+ssc://host[:port]`` + ``bolt+s://host[:port]`` + ``neo4j://host[:port][?routing_context]`` + ``neo4j+ssc://host[:port][?routing_context]`` + ``neo4j+s://host[:port][?routing_context]`` .. code-block:: python uri = "bolt://example.com:7687" .. code-block:: python uri = "neo4j://example.com:7687" Each supported scheme maps to a particular :class:`neo4j.Driver` subclass that implements a specific behaviour. +------------------------+---------------------------------------------------------------------------------------------------------------------------------------+ | URI Scheme | Driver Object and Setting | +========================+=======================================================================================================================================+ | bolt | :ref:`bolt-driver-ref` with no encryption. | +------------------------+---------------------------------------------------------------------------------------------------------------------------------------+ | bolt+ssc | :ref:`bolt-driver-ref` with encryption (accepts self signed certificates). | +------------------------+---------------------------------------------------------------------------------------------------------------------------------------+ | bolt+s | :ref:`bolt-driver-ref` with encryption (accepts only certificates signed by a certificate authority), full certificate checks. | +------------------------+---------------------------------------------------------------------------------------------------------------------------------------+ | neo4j | :ref:`neo4j-driver-ref` with no encryption. | +------------------------+---------------------------------------------------------------------------------------------------------------------------------------+ | neo4j+ssc | :ref:`neo4j-driver-ref` with encryption (accepts self signed certificates). | +------------------------+---------------------------------------------------------------------------------------------------------------------------------------+ | neo4j+s | :ref:`neo4j-driver-ref` with encryption (accepts only certificates signed by a certificate authority), full certificate checks. | +------------------------+---------------------------------------------------------------------------------------------------------------------------------------+ .. note:: See https://neo4j.com/docs/operations-manual/current/configuration/ports/ for Neo4j ports. .. _auth-ref: Auth ==== To authenticate with Neo4j the authentication details are supplied at driver creation. The auth token is an object of the class :class:`neo4j.Auth` containing the details. .. autoclass:: neo4j.Auth Example: .. code-block:: python import neo4j auth = neo4j.Auth("basic", "neo4j", "password") Auth Token Helper Functions --------------------------- Alternatively, one of the auth token helper functions can be used. .. autofunction:: neo4j.basic_auth .. autofunction:: neo4j.kerberos_auth .. autofunction:: neo4j.bearer_auth .. autofunction:: neo4j.custom_auth ****** Driver ****** Every Neo4j-backed application will require a driver object. This object holds the details required to establish connections with a Neo4j database, including server URIs, credentials and other configuration. :class:`neo4j.Driver` objects hold a connection pool from which :class:`neo4j.Session` objects can borrow connections. Closing a driver will immediately shut down all connections in the pool. .. note:: Driver objects only open connections and pool them as needed. To verify that the driver is able to communicate with the database without executing any query, use :meth:`neo4j.Driver.verify_connectivity`. .. autoclass:: neo4j.Driver() :members: session, encrypted, close, verify_connectivity, get_server_info .. _driver-configuration-ref: Driver Configuration ==================== Additional configuration can be provided via the :class:`neo4j.Driver` constructor. + :ref:`connection-acquisition-timeout-ref` + :ref:`connection-timeout-ref` + :ref:`encrypted-ref` + :ref:`keep-alive-ref` + :ref:`max-connection-lifetime-ref` + :ref:`max-connection-pool-size-ref` + :ref:`max-transaction-retry-time-ref` + :ref:`resolver-ref` + :ref:`trust-ref` + :ref:`ssl-context-ref` + :ref:`trusted-certificates-ref` + :ref:`user-agent-ref` .. _connection-acquisition-timeout-ref: ``connection_acquisition_timeout`` ---------------------------------- The maximum amount of time in seconds the driver will wait to either acquire an idle connection from the pool (including potential liveness checks) or create a new connection when the pool is not full and all existing connection are in use. Since this process may involve opening a new connection including handshakes, it should be chosen larger than :ref:`connection-timeout-ref`. :Type: ``float`` :Default: ``60.0`` .. _connection-timeout-ref: ``connection_timeout`` ---------------------- The maximum amount of time in seconds to wait for a TCP connection to be established. This *does not* include any handshake(s), or authentication required before the connection can be used to perform database related work. :Type: ``float`` :Default: ``30.0`` .. _encrypted-ref: ``encrypted`` ------------- Specify whether to use an encrypted connection between the driver and server. This setting does not have any effect if a custom ``ssl_context`` is configured. :Type: ``bool`` :Default: ``False`` .. _keep-alive-ref: ``keep_alive`` -------------- Specify whether TCP keep-alive should be enabled. :Type: ``bool`` :Default: ``True`` **This is experimental.** (See :ref:`filter-warnings-ref`) It might be changed or removed any time even without prior notice. .. _max-connection-lifetime-ref: ``max_connection_lifetime`` --------------------------- The maximum duration in seconds that the driver will keep a connection for before being removed from the pool. :Type: ``float`` :Default: ``3600`` .. _max-connection-pool-size-ref: ``max_connection_pool_size`` ---------------------------- The maximum total number of connections allowed, per host (i.e. cluster nodes), to be managed by the connection pool. :Type: ``int`` :Default: ``100`` .. _max-transaction-retry-time-ref: ``max_transaction_retry_time`` ------------------------------ The maximum amount of time in seconds that a managed transaction will retry before failing. :Type: ``float`` :Default: ``30.0`` .. _resolver-ref: ``resolver`` ------------ A custom resolver function to resolve host and port values ahead of DNS resolution. This function is called with a 2-tuple of (host, port) and should return an iterable of 2-tuples (host, port). If no custom resolver function is supplied, the internal resolver moves straight to regular DNS resolution. For example: .. code-block:: python from neo4j import GraphDatabase def custom_resolver(socket_address): if socket_address == ("example.com", 9999): yield "::1", 7687 yield "127.0.0.1", 7687 else: from socket import gaierror raise gaierror("Unexpected socket address %r" % socket_address) driver = GraphDatabase.driver("neo4j://example.com:9999", auth=("neo4j", "password"), resolver=custom_resolver) :Default: :const:`None` .. _trust-ref: ``trust`` --------- Specify how to determine the authenticity of encryption certificates provided by the Neo4j instance on connection. This setting does not have any effect if ``encrypted`` is set to ``False``. :Type: ``neo4j.TRUST_SYSTEM_CA_SIGNED_CERTIFICATES``, ``neo4j.TRUST_ALL_CERTIFICATES`` .. py:attribute:: neo4j.TRUST_ALL_CERTIFICATES Trust any server certificate (default). This ensures that communication is encrypted but does not verify the server certificate against a certificate authority. This option is primarily intended for use with the default auto-generated server certificate. .. py:attribute:: neo4j.TRUST_SYSTEM_CA_SIGNED_CERTIFICATES Trust server certificates that can be verified against the system certificate authority. This option is primarily intended for use with full certificates. :Default: ``neo4j.TRUST_SYSTEM_CA_SIGNED_CERTIFICATES``. .. deprecated:: 5.0 This configuration option is deprecated and will be removed in a future release. Please use :ref:`trusted-certificates-ref` instead. .. _ssl-context-ref: ``ssl_context`` --------------- Specify a custom SSL context to use for wrapping connections. If given, ``encrypted`` and ``trusted_certificates`` have no effect. .. warning:: This option may compromise your application's security if used improperly. Its usage is strongly discouraged and comes without any guarantees. :Type: :class:`ssl.SSLContext` or :const:`None` :Default: :const:`None` .. versionadded:: 5.0 .. _trusted-certificates-ref: ``trusted_certificates`` ------------------------ Specify how to determine the authenticity of encryption certificates provided by the Neo4j instance on connection. This setting does not have any effect if ``encrypted`` is set to ``False`` or a custom ``ssl_context`` is configured. :Type: :class:`.TrustSystemCAs`, :class:`.TrustAll`, or :class:`.TrustCustomCAs` :Default: :const:`neo4j.TrustSystemCAs()` .. autoclass:: neo4j.TrustSystemCAs .. autoclass:: neo4j.TrustAll .. autoclass:: neo4j.TrustCustomCAs .. versionadded:: 5.0 .. _user-agent-ref: ``user_agent`` -------------- Specify the client agent name. :Type: ``str`` :Default: *The Python Driver will generate a user agent name.* Driver Object Lifetime ====================== For general applications, it is recommended to create one top-level :class:`neo4j.Driver` object that lives for the lifetime of the application. For example: .. code-block:: python from neo4j import GraphDatabase class Application: def __init__(self, uri, user, password) self.driver = GraphDatabase.driver(uri, auth=(user, password)) def close(self): self.driver.close() Connection details held by the :class:`neo4j.Driver` are immutable. Therefore if, for example, a password is changed, a replacement :class:`neo4j.Driver` object must be created. More than one :class:`.Driver` may be required if connections to multiple databases, or connections as multiple users, are required, unless when using impersonation (:ref:`impersonated-user-ref`). :class:`neo4j.Driver` objects are thread-safe but cannot be shared across processes. Therefore, ``multithreading`` should generally be preferred over ``multiprocessing`` for parallel database access. If using ``multiprocessing`` however, each process will require its own :class:`neo4j.Driver` object. .. _bolt-driver-ref: BoltDriver ========== URI schemes: ``bolt``, ``bolt+ssc``, ``bolt+s`` Will result in: .. autoclass:: neo4j.BoltDriver .. _neo4j-driver-ref: Neo4jDriver =========== URI schemes: ``neo4j``, ``neo4j+ssc``, ``neo4j+s`` Will result in: .. autoclass:: neo4j.Neo4jDriver *********************** Sessions & Transactions *********************** All database activity is co-ordinated through two mechanisms: **sessions** (:class:`neo4j.Session`) and **transactions** (:class:`neo4j.Transaction`, :class:`neo4j.ManagedTransaction`). A **session** is a logical container for any number of causally-related transactional units of work. Sessions automatically provide guarantees of causal consistency within a clustered environment but multiple sessions can also be causally chained if required. Sessions provide the top level of containment for database activity. Session creation is a lightweight operation and *sessions are not thread safe*. Connections are drawn from the :class:`neo4j.Driver` connection pool as required. A **transaction** is a unit of work that is either committed in its entirety or is rolled back on failure. .. _session-construction-ref: ******************** Session Construction ******************** To construct a :class:`neo4j.Session` use the :meth:`neo4j.Driver.session` method. .. code-block:: python from neo4j import GraphDatabase driver = GraphDatabase(uri, auth=(user, password)) session = driver.session() result = session.run("MATCH (a:Person) RETURN a.name AS name") names = [record["name"] for record in result] session.close() driver.close() Sessions will often be created and destroyed using a *with block context*. This is the recommended approach as it takes care of closing the session properly even when an exception is raised. .. code-block:: python with driver.session() as session: result = session.run("MATCH (a:Person) RETURN a.name AS name") # do something with the result... Sessions will often be created with some configuration settings, see :ref:`session-configuration-ref`. .. code-block:: python with driver.session(database="example_database", fetch_size=100) as session: result = session.run("MATCH (a:Person) RETURN a.name AS name") # do something with the result... ******* Session ******* .. autoclass:: neo4j.Session() .. automethod:: close .. automethod:: closed .. automethod:: run .. automethod:: last_bookmarks .. automethod:: last_bookmark .. automethod:: begin_transaction .. automethod:: read_transaction .. automethod:: execute_read .. automethod:: write_transaction .. automethod:: execute_write Query ===== .. autoclass:: neo4j.Query .. _session-configuration-ref: Session Configuration ===================== To construct a :class:`neo4j.Session` use the :meth:`neo4j.Driver.session` method. This section describes the session configuration key-word arguments. + :ref:`bookmarks-ref` + :ref:`database-ref` + :ref:`default-access-mode-ref` + :ref:`fetch-size-ref` + :ref:`bookmark-manager-ref` .. _bookmarks-ref: ``bookmarks`` ------------- Optional :class:`neo4j.Bookmarks`. Use this to causally chain sessions. See :meth:`Session.last_bookmarks` or :meth:`AsyncSession.last_bookmarks` for more information. .. deprecated:: 5.0 Alternatively, an iterable of strings can be passed. This usage is deprecated and will be removed in a future release. Please use a :class:`neo4j.Bookmarks` object instead. :Default: ``None`` .. _database-ref: ``database`` ------------ Name of the database to query. :Type: ``str``, ``neo4j.DEFAULT_DATABASE`` .. py:attribute:: neo4j.DEFAULT_DATABASE :noindex: This will use the default database on the Neo4j instance. .. Note:: The default database can be set on the Neo4j instance settings. .. Note:: It is recommended to always specify the database explicitly when possible. This allows the driver to work more efficiently, as it will not have to resolve the home database first. .. code-block:: python from neo4j import GraphDatabase driver = GraphDatabase.driver(uri, auth=(user, password)) session = driver.session(database="system") :Default: ``neo4j.DEFAULT_DATABASE`` .. _impersonated-user-ref: ``impersonated_user`` --------------------- Name of the user to impersonate. This means that all actions in the session will be executed in the security context of the impersonated user. For this, the user for which the :class:`Driver` has been created needs to have the appropriate permissions. :Type: ``str``, None .. py:data:: None :noindex: Will not perform impersonation. .. Note:: The server or all servers of the cluster need to support impersonation. Otherwise, the driver will raise :exc:`.ConfigurationError` as soon as it encounters a server that does not. .. code-block:: python from neo4j import GraphDatabase driver = GraphDatabase.driver(uri, auth=(user, password)) session = driver.session(impersonated_user="alice") :Default: :const:`None` .. _default-access-mode-ref: ``default_access_mode`` ----------------------- The default access mode. A session can be given a default access mode on construction. This applies only in clustered environments and determines whether transactions carried out within that session should be routed to a ``read`` or ``write`` server by default. Transactions (see :ref:`managed-transactions-ref`) within a session override the access mode passed to that session on construction. .. note:: The driver does not parse Cypher queries and cannot determine whether the access mode should be ``neo4j.WRITE_ACCESS`` or ``neo4j.READ_ACCESS``. This setting is only meant to enable the driver to perform correct routing, *not* for enforcing access control. This means that, depending on the server version and settings, the server or cluster might allow a write-statement to be executed even when ``neo4j.READ_ACCESS`` is chosen. This behaviour should not be relied upon as it can change with the server. :Type: ``neo4j.WRITE_ACCESS``, ``neo4j.READ_ACCESS`` :Default: ``neo4j.WRITE_ACCESS`` .. _fetch-size-ref: ``fetch_size`` -------------- The fetch size used for requesting messages from Neo4j. :Type: ``int`` :Default: ``1000`` .. _bookmark-manager-ref: ``bookmark_manager`` -------------------- Specify a bookmark manager for the session to use. If present, the bookmark manager is used to keep all work within the session causally consistent with all work in other sessions using the same bookmark manager. See :class:`.BookmarkManager` for more information. .. warning:: Enabling the BookmarkManager can have a negative impact on performance since all queries will wait for the latest changes to be propagated across the cluster. For simple use-cases, it often suffices that work within a single session is automatically causally consistent. :Type: :const:`None` or :class:`.BookmarkManager` :Default: :const:`None` .. versionadded:: 5.0 **This is experimental.** (See :ref:`filter-warnings-ref`) It might be changed or removed any time even without prior notice. *********** Transaction *********** Neo4j supports three kinds of transaction: + :ref:`auto-commit-transactions-ref` + :ref:`explicit-transactions-ref` + :ref:`managed-transactions-ref` Each has pros and cons but if in doubt, use a managed transaction with a *transaction function*. .. _auto-commit-transactions-ref: Auto-commit Transactions ======================== Auto-commit transactions are the simplest form of transaction, available via :meth:`neo4j.Session.run`. These are easy to use but support only one statement per transaction and are not automatically retried on failure. Auto-commit transactions are also the only way to run ``PERIODIC COMMIT`` (only Neo4j 4.4 and earlier) or ``CALL {...} IN TRANSACTIONS`` (Neo4j 4.4 and newer) statements, since those Cypher clauses manage their own transactions internally. Example: .. code-block:: python import neo4j def create_person(driver, name): with driver.session(default_access_mode=neo4j.WRITE_ACCESS) as session: query = "CREATE (a:Person { name: $name }) RETURN id(a) AS node_id" result = session.run(query, name=name) record = result.single() return record["node_id"] Example: .. code-block:: python import neo4j def get_numbers(driver): numbers = [] with driver.session(default_access_mode=neo4j.READ_ACCESS) as session: result = session.run("UNWIND [1, 2, 3] AS x RETURN x") for record in result: numbers.append(record["x"]) return numbers .. _explicit-transactions-ref: Explicit Transactions ===================== Explicit transactions support multiple statements and must be created with an explicit :meth:`neo4j.Session.begin_transaction` call. This creates a new :class:`neo4j.Transaction` object that can be used to run Cypher. It also gives applications the ability to directly control ``commit`` and ``rollback`` activity. .. autoclass:: neo4j.Transaction() .. automethod:: run .. automethod:: commit .. automethod:: rollback .. automethod:: close .. automethod:: closed Closing an explicit transaction can either happen automatically at the end of a ``with`` block, or can be explicitly controlled through the :meth:`neo4j.Transaction.commit`, :meth:`neo4j.Transaction.rollback` or :meth:`neo4j.Transaction.close` methods. Explicit transactions are most useful for applications that need to distribute Cypher execution across multiple functions for the same transaction. Example: .. code-block:: python import neo4j def create_person(driver, name): with driver.session(default_access_mode=neo4j.WRITE_ACCESS) as session: tx = session.begin_transaction() node_id = create_person_node(tx) set_person_name(tx, node_id, name) tx.commit() def create_person_node(tx): query = "CREATE (a:Person { name: $name }) RETURN id(a) AS node_id" name = "default_name" result = tx.run(query, name=name) record = result.single() return record["node_id"] def set_person_name(tx, node_id, name): query = "MATCH (a:Person) WHERE id(a) = $id SET a.name = $name" result = tx.run(query, id=node_id, name=name) summary = result.consume() # use the summary for logging etc. .. _managed-transactions-ref: Managed Transactions (`transaction functions`) ============================================== Transaction functions are the most powerful form of transaction, providing access mode override and retry capabilities. + :meth:`neo4j.Session.execute_write` + :meth:`neo4j.Session.execute_read` These allow a function object representing the transactional unit of work to be passed as a parameter. This function is called one or more times, within a configurable time limit, until it succeeds. Results should be fully consumed within the function and only aggregate or status values should be returned. Returning a live result object would prevent the driver from correctly managing connections and would break retry guarantees. This function will receive a :class:`neo4j.ManagedTransaction` object as its first parameter. .. autoclass:: neo4j.ManagedTransaction() .. automethod:: run Example: .. code-block:: python def create_person(driver, name) with driver.session() as session: node_id = session.execute_write(create_person_tx, name) def create_person_tx(tx, name): query = "CREATE (a:Person { name: $name }) RETURN id(a) AS node_id" result = tx.run(query, name=name) record = result.single() return record["node_id"] To exert more control over how a transaction function is carried out, the :func:`neo4j.unit_of_work` decorator can be used. .. autofunction:: neo4j.unit_of_work ****** Result ****** Every time a query is executed, a :class:`neo4j.Result` is returned. This provides a handle to the result of the query, giving access to the records within it as well as the result metadata. Results also contain a buffer that automatically stores unconsumed records when results are consumed out of order. A :class:`neo4j.Result` is attached to an active connection, through a :class:`neo4j.Session`, until all its content has been buffered or consumed. .. autoclass:: neo4j.Result() .. describe:: iter(result) .. describe:: next(result) .. automethod:: keys .. automethod:: consume .. automethod:: single .. automethod:: fetch .. automethod:: peek .. automethod:: graph .. automethod:: value .. automethod:: values .. automethod:: data .. automethod:: to_df .. automethod:: closed See https://neo4j.com/docs/python-manual/current/cypher-workflow/#python-driver-type-mapping for more about type mapping. Graph ===== .. autoclass:: neo4j.graph.Graph() A local, self-contained graph object that acts as a container for :class:`.Node` and :class:`neo4j.Relationship` instances. This is typically obtained via the :meth:`neo4j.Result.graph` method. .. autoattribute:: nodes .. autoattribute:: relationships .. automethod:: relationship_type **This is experimental.** (See :ref:`filter-warnings-ref`) It might be changed or removed any time even without prior notice. ****** Record ****** .. autoclass:: neo4j.Record() .. describe:: Record(iterable) Create a new record based on an dictionary-like iterable. This can be a dictionary itself, or may be a sequence of key-value pairs, each represented by a tuple. .. describe:: record == other Compare a record for equality with another value. The ``other`` value may be any ``Sequence`` or ``Mapping`` or both. If comparing with a ``Sequence`` the values are compared in order. If comparing with a ``Mapping`` the values are compared based on their keys. If comparing with a value that exhibits both traits, both comparisons must be true for the values to be considered equal. .. describe:: record != other Compare a record for inequality with another value. See above for comparison rules. .. describe:: hash(record) Create a hash for this record. This will raise a :exc:`TypeError` if any values within the record are unhashable. .. describe:: record[index] Obtain a value from the record by index. This will raise an :exc:`IndexError` if the specified index is out of range. .. describe:: record[i:j] Derive a sub-record based on a start and end index. All keys and values within those bounds will be copied across in the same order as in the original record. .. automethod:: keys .. describe:: record[key] Obtain a value from the record by key. This will raise a :exc:`KeyError` if the specified key does not exist. .. automethod:: get(key, default=None) .. automethod:: index(key) .. automethod:: items .. automethod:: value(key=0, default=None) .. automethod:: values .. automethod:: data ************* ResultSummary ************* .. autoclass:: neo4j.ResultSummary() :members: SummaryCounters =============== .. autoclass:: neo4j.SummaryCounters() :members: ServerInfo ========== .. autoclass:: neo4j.ServerInfo() :members: *************** Core Data Types *************** Cypher supports a set of core data types that all map to built-in types in Python. These include the common ``Boolean`` ``Integer`` ``Float`` and ``String`` types as well as ``List`` and ``Map`` that can hold heterogenous collections of any other type. The core types with their general mappings are listed below: +------------------------+---------------------------------------------------------------------------------------------------------------------------+ | Cypher Type | Python Type | +========================+===========================================================================================================================+ | Null | :const:`None` | +------------------------+---------------------------------------------------------------------------------------------------------------------------+ | Boolean | :class:`bool` | +------------------------+---------------------------------------------------------------------------------------------------------------------------+ | Integer | :class:`int` | +------------------------+---------------------------------------------------------------------------------------------------------------------------+ | Float | :class:`float` | +------------------------+---------------------------------------------------------------------------------------------------------------------------+ | String | :class:`str` | +------------------------+---------------------------------------------------------------------------------------------------------------------------+ | Bytes :sup:`[1]` | :class:`bytearray` | +------------------------+---------------------------------------------------------------------------------------------------------------------------+ | List | :class:`list` | +------------------------+---------------------------------------------------------------------------------------------------------------------------+ | Map | :class:`dict` | +------------------------+---------------------------------------------------------------------------------------------------------------------------+ .. Note:: 1. ``Bytes`` is not an actual Cypher type but is transparently passed through when used in parameters or query results. In reality, the actual conversions and coercions that occur as values are passed through the system are more complex than just a simple mapping. The diagram below illustrates the actual mappings between the various layers, from driver to data store, for the core types. .. image:: ./_images/core_type_mappings.svg :target: ./_images/core_type_mappings.svg **************** Graph Data Types **************** Cypher queries can return entire graph structures as well as individual property values. The graph data types detailed here model graph data returned from a Cypher query. Graph values cannot be passed in as parameters as it would be unclear whether the entity was intended to be passed by reference or by value. The identity or properties of that entity should be passed explicitly instead. The driver contains a corresponding class for each of the graph types that can be returned. ============= ================================= Cypher Type Python Type ============= ================================= Node :class:`neo4j.graph.Node` Relationship :class:`neo4j.graph.Relationship` Path :class:`neo4j.graph.Path` ============= ================================= Node ==== .. autoclass:: neo4j.graph.Node .. describe:: node == other Compares nodes for equality. .. describe:: node != other Compares nodes for inequality. .. describe:: hash(node) Computes the hash of a node. .. describe:: len(node) Returns the number of properties on a node. .. describe:: iter(node) Iterates through all properties on a node. .. describe:: node[key] Returns a node property by key. Raises :exc:`KeyError` if the key does not exist. .. describe:: key in node Checks whether a property key exists for a given node. .. autoattribute:: graph .. autoattribute:: id .. autoattribute:: element_id .. autoattribute:: labels .. automethod:: get .. automethod:: keys .. automethod:: values .. automethod:: items Relationship ============ .. autoclass:: neo4j.graph.Relationship .. describe:: relationship == other Compares relationships for equality. .. describe:: relationship != other Compares relationships for inequality. .. describe:: hash(relationship) Computes the hash of a relationship. .. describe:: len(relationship) Returns the number of properties on a relationship. .. describe:: iter(relationship) Iterates through all properties on a relationship. .. describe:: relationship[key] Returns a relationship property by key. Raises :exc:`KeyError` if the key does not exist. .. describe:: key in relationship Checks whether a property key exists for a given relationship. .. describe:: type(relationship) Returns the type (class) of a relationship. Relationship objects belong to a custom subtype based on the type name in the underlying database. .. autoattribute:: graph .. autoattribute:: id .. autoattribute:: element_id .. autoattribute:: nodes .. autoattribute:: start_node .. autoattribute:: end_node .. autoattribute:: type .. automethod:: get .. automethod:: keys .. automethod:: values .. automethod:: items Path ==== .. autoclass:: neo4j.graph.Path .. describe:: path == other Compares paths for equality. .. describe:: path != other Compares paths for inequality. .. describe:: hash(path) Computes the hash of a path. .. describe:: len(path) Returns the number of relationships in a path. .. describe:: iter(path) Iterates through all the relationships in a path. .. autoattribute:: graph .. autoattribute:: nodes .. autoattribute:: start_node .. autoattribute:: end_node .. autoattribute:: relationships ****************** Spatial Data Types ****************** .. include:: types/_spatial_overview.rst See topic :ref:`spatial-data-types` for more details. ******************* Temporal Data Types ******************* .. include:: types/_temporal_overview.rst See topic :ref:`temporal-data-types` for more details. *************** BookmarkManager *************** .. autoclass:: neo4j.api.BookmarkManager :members: .. _errors-ref: ****** Errors ****** Neo4j Errors ============ Server-side errors * :class:`neo4j.exceptions.Neo4jError` * :class:`neo4j.exceptions.ClientError` * :class:`neo4j.exceptions.CypherSyntaxError` * :class:`neo4j.exceptions.CypherTypeError` * :class:`neo4j.exceptions.ConstraintError` * :class:`neo4j.exceptions.AuthError` * :class:`neo4j.exceptions.TokenExpired` * :class:`neo4j.exceptions.Forbidden` * :class:`neo4j.exceptions.DatabaseError` * :class:`neo4j.exceptions.TransientError` * :class:`neo4j.exceptions.DatabaseUnavailable` * :class:`neo4j.exceptions.NotALeader` * :class:`neo4j.exceptions.ForbiddenOnReadOnlyDatabase` .. autoexception:: neo4j.exceptions.Neo4jError() :show-inheritance: :members: message, code, is_retriable, is_retryable .. autoexception:: neo4j.exceptions.ClientError() :show-inheritance: .. autoexception:: neo4j.exceptions.CypherSyntaxError() :show-inheritance: .. autoexception:: neo4j.exceptions.CypherTypeError() :show-inheritance: .. autoexception:: neo4j.exceptions.ConstraintError() :show-inheritance: .. autoexception:: neo4j.exceptions.AuthError() :show-inheritance: .. autoexception:: neo4j.exceptions.TokenExpired() :show-inheritance: .. autoexception:: neo4j.exceptions.Forbidden() :show-inheritance: .. autoexception:: neo4j.exceptions.DatabaseError() :show-inheritance: .. autoexception:: neo4j.exceptions.TransientError() :show-inheritance: .. autoexception:: neo4j.exceptions.DatabaseUnavailable() :show-inheritance: .. autoexception:: neo4j.exceptions.NotALeader() :show-inheritance: .. autoexception:: neo4j.exceptions.ForbiddenOnReadOnlyDatabase() :show-inheritance: Driver Errors ============= Client-side errors * :class:`neo4j.exceptions.DriverError` * :class:`neo4j.exceptions.SessionError` * :class:`neo4j.exceptions.TransactionError` * :class:`neo4j.exceptions.TransactionNestingError` * :class:`neo4j.exceptions.ResultError` * :class:`neo4j.exceptions.ResultConsumedError` * :class:`neo4j.exceptions.ResultNotSingleError` * :class:`neo4j.exceptions.BrokenRecordError` * :class:`neo4j.exceptions.SessionExpired` * :class:`neo4j.exceptions.ServiceUnavailable` * :class:`neo4j.exceptions.RoutingServiceUnavailable` * :class:`neo4j.exceptions.WriteServiceUnavailable` * :class:`neo4j.exceptions.ReadServiceUnavailable` * :class:`neo4j.exceptions.IncompleteCommit` * :class:`neo4j.exceptions.ConfigurationError` * :class:`neo4j.exceptions.AuthConfigurationError` * :class:`neo4j.exceptions.CertificateConfigurationError` .. autoexception:: neo4j.exceptions.DriverError() :show-inheritance: :members: is_retryable .. autoexception:: neo4j.exceptions.SessionError() :show-inheritance: :members: session .. autoexception:: neo4j.exceptions.TransactionError() :show-inheritance: :members: transaction .. autoexception:: neo4j.exceptions.TransactionNestingError() :show-inheritance: .. autoexception:: neo4j.exceptions.ResultError() :show-inheritance: :members: result .. autoexception:: neo4j.exceptions.ResultConsumedError() :show-inheritance: .. autoexception:: neo4j.exceptions.ResultNotSingleError() :show-inheritance: .. autoexception:: neo4j.exceptions.BrokenRecordError() :show-inheritance: .. autoexception:: neo4j.exceptions.SessionExpired() :show-inheritance: .. autoexception:: neo4j.exceptions.ServiceUnavailable() :show-inheritance: .. autoexception:: neo4j.exceptions.RoutingServiceUnavailable() :show-inheritance: .. autoexception:: neo4j.exceptions.WriteServiceUnavailable() :show-inheritance: .. autoexception:: neo4j.exceptions.ReadServiceUnavailable() :show-inheritance: .. autoexception:: neo4j.exceptions.IncompleteCommit() :show-inheritance: .. autoexception:: neo4j.exceptions.ConfigurationError() :show-inheritance: .. autoexception:: neo4j.exceptions.AuthConfigurationError() :show-inheritance: .. autoexception:: neo4j.exceptions.CertificateConfigurationError() :show-inheritance: Internal Driver Errors ======================= If an internal error (BoltError), in particular a protocol error (BoltProtocolError) is surfaced please open an issue on github. https://github.com/neo4j/neo4j-python-driver/issues Please provide details about your running environment, + Operating System: + Python Version: + Python Driver Version: + Neo4j Version: + The code block with a description that produced the error: + The error message: ******** Warnings ******** The Python Driver uses the built-in :class:`python:DeprecationWarning` class to warn about deprecations. The Python Driver uses the :class:`neo4j.ExperimentalWarning` class to warn about experimental features. .. autoclass:: neo4j.ExperimentalWarning .. _filter-warnings-ref: Filter Warnings =============== This example shows how to suppress the :class:`neo4j.ExperimentalWarning` using the :func:`python:warnings.filterwarnings` function. .. code-block:: python import warnings from neo4j import ExperimentalWarning ... with warnings.catch_warnings(): warnings.filterwarnings("ignore", category=ExperimentalWarning) ... # the call emitting the ExperimentalWarning ... This will only mute the :class:`neo4j.ExperimentalWarning` for everything inside the ``with``-block. This is the preferred way to mute warnings, as warnings triggerd by new code will still be visible. However, should you want to mute it for the entire application, use the following code: .. code-block:: python import warnings from neo4j import ExperimentalWarning warnings.filterwarnings("ignore", category=ExperimentalWarning) ... .. _logging-ref: ******* Logging ******* The driver offers logging for debugging purposes. It is not recommended to enable logging for anything other than debugging. For instance, if the driver is not able to connect to the database server or if undesired behavior is observed. There are different ways of enabling logging as listed below. .. note:: For an improved logging experience with the async driver, please see :ref:`async-logging-ref`. Simple Approach =============== .. autofunction:: neo4j.debug.watch(*logger_names, level=logging.DEBUG, out=sys.stderr, colour=False) Context Manager =============== .. autoclass:: neo4j.debug.Watcher(*logger_names, default_level=logging.DEBUG, default_out=sys.stderr, colour=False) :members: :special-members: __enter__, __exit__ Full Control ============ .. code-block:: python import logging import sys # create a handler, e.g. to log to stdout handler = logging.StreamHandler(sys.stdout) # configure the handler to your liking handler.setFormatter(logging.Formatter( "[%(levelname)-8s] %(threadName)s(%(thread)d) %(asctime)s %(message)s" )) # add the handler to the driver's logger logging.getLogger("neo4j").addHandler(handler) # make sure the logger logs on the desired log level logging.getLogger("neo4j").setLevel(logging.DEBUG) # from now on, DEBUG logging to stdout is enabled in the driver ********* Bookmarks ********* .. autoclass:: neo4j.Bookmarks :members: :special-members: __bool__, __add__, __iter__ .. autoclass:: neo4j.Bookmark :members: neo4j-python-driver-5.2.1/docs/source/async_api.rst000066400000000000000000000563241433522662700223220ustar00rootroot00000000000000.. _async-api-documentation: ####################### Async API Documentation ####################### .. versionadded:: 5.0 .. warning:: There are known issue with Python 3.8 and the async driver where it gradually slows down. Generally, it's recommended to use the latest supported version of Python for best performance, stability, and security. ****************** AsyncGraphDatabase ****************** Async Driver Construction ========================= The :class:`neo4j.AsyncDriver` construction is done via a ``classmethod`` on the :class:`neo4j.AsyncGraphDatabase` class. .. autoclass:: neo4j.AsyncGraphDatabase :members: bookmark_manager .. automethod:: driver Driver creation example: .. code-block:: python import asyncio from neo4j import AsyncGraphDatabase async def main(): uri = "neo4j://example.com:7687" driver = AsyncGraphDatabase.driver(uri, auth=("neo4j", "password")) await driver.close() # close the driver object asyncio.run(main()) For basic authentication, ``auth`` can be a simple tuple, for example: .. code-block:: python auth = ("neo4j", "password") This will implicitly create a :class:`neo4j.Auth` with a ``scheme="basic"``. Other authentication methods are described under :ref:`auth-ref`. ``with`` block context example: .. code-block:: python import asyncio from neo4j import AsyncGraphDatabase async def main(): uri = "neo4j://example.com:7687" auth = ("neo4j", "password") async with AsyncGraphDatabase.driver(uri, auth=auth) as driver: # use the driver ... asyncio.run(main()) .. _async-uri-ref: URI === On construction, the ``scheme`` of the URI determines the type of :class:`neo4j.AsyncDriver` object created. Available valid URIs: + ``bolt://host[:port]`` + ``bolt+ssc://host[:port]`` + ``bolt+s://host[:port]`` + ``neo4j://host[:port][?routing_context]`` + ``neo4j+ssc://host[:port][?routing_context]`` + ``neo4j+s://host[:port][?routing_context]`` .. code-block:: python uri = "bolt://example.com:7687" .. code-block:: python uri = "neo4j://example.com:7687" Each supported scheme maps to a particular :class:`neo4j.AsyncDriver` subclass that implements a specific behaviour. +------------------------+---------------------------------------------------------------------------------------------------------------------------------------------+ | URI Scheme | Driver Object and Setting | +========================+=============================================================================================================================================+ | bolt | :ref:`async-bolt-driver-ref` with no encryption. | +------------------------+---------------------------------------------------------------------------------------------------------------------------------------------+ | bolt+ssc | :ref:`async-bolt-driver-ref` with encryption (accepts self signed certificates). | +------------------------+---------------------------------------------------------------------------------------------------------------------------------------------+ | bolt+s | :ref:`async-bolt-driver-ref` with encryption (accepts only certificates signed by a certificate authority), full certificate checks. | +------------------------+---------------------------------------------------------------------------------------------------------------------------------------------+ | neo4j | :ref:`async-neo4j-driver-ref` with no encryption. | +------------------------+---------------------------------------------------------------------------------------------------------------------------------------------+ | neo4j+ssc | :ref:`async-neo4j-driver-ref` with encryption (accepts self signed certificates). | +------------------------+---------------------------------------------------------------------------------------------------------------------------------------------+ | neo4j+s | :ref:`async-neo4j-driver-ref` with encryption (accepts only certificates signed by a certificate authority), full certificate checks. | +------------------------+---------------------------------------------------------------------------------------------------------------------------------------------+ .. note:: See https://neo4j.com/docs/operations-manual/current/configuration/ports/ for Neo4j ports. *********** AsyncDriver *********** Every Neo4j-backed application will require a driver object. This object holds the details required to establish connections with a Neo4j database, including server URIs, credentials and other configuration. :class:`neo4j.AsyncDriver` objects hold a connection pool from which :class:`neo4j.AsyncSession` objects can borrow connections. Closing a driver will immediately shut down all connections in the pool. .. note:: Driver objects only open connections and pool them as needed. To verify that the driver is able to communicate with the database without executing any query, use :meth:`neo4j.AsyncDriver.verify_connectivity`. .. autoclass:: neo4j.AsyncDriver() :members: session, encrypted, close, verify_connectivity, get_server_info .. _async-driver-configuration-ref: Async Driver Configuration ========================== :class:`neo4j.AsyncDriver` is configured exactly like :class:`neo4j.Driver` (see :ref:`driver-configuration-ref`). The only difference is that the async driver accepts an async custom resolver function: .. _async-resolver-ref: ``resolver`` ------------ A custom resolver function to resolve host and port values ahead of DNS resolution. This function is called with a 2-tuple of (host, port) and should return an iterable of 2-tuples (host, port). If no custom resolver function is supplied, the internal resolver moves straight to regular DNS resolution. The custom resolver function can but does not have to be a coroutine. For example: .. code-block:: python from neo4j import AsyncGraphDatabase async def custom_resolver(socket_address): if socket_address == ("example.com", 9999): yield "::1", 7687 yield "127.0.0.1", 7687 else: from socket import gaierror raise gaierror("Unexpected socket address %r" % socket_address) # alternatively def custom_resolver(socket_address): ... driver = AsyncGraphDatabase.driver("neo4j://example.com:9999", auth=("neo4j", "password"), resolver=custom_resolver) :Default: ``None`` Driver Object Lifetime ====================== For general applications, it is recommended to create one top-level :class:`neo4j.AsyncDriver` object that lives for the lifetime of the application. For example: .. code-block:: python from neo4j import AsyncGraphDatabase class Application: def __init__(self, uri, user, password) self.driver = AsyncGraphDatabase.driver(uri, auth=(user, password)) async def close(self): await self.driver.close() Connection details held by the :class:`neo4j.AsyncDriver` are immutable. Therefore if, for example, a password is changed, a replacement :class:`neo4j.AsyncDriver` object must be created. More than one :class:`.AsyncDriver` may be required if connections to multiple databases, or connections as multiple users, are required, unless when using impersonation (:ref:`impersonated-user-ref`). :class:`neo4j.AsyncDriver` objects are safe to be used in concurrent coroutines. They are not thread-safe. .. _async-bolt-driver-ref: AsyncBoltDriver =============== URI schemes: ``bolt``, ``bolt+ssc``, ``bolt+s`` Will result in: .. autoclass:: neo4j.AsyncBoltDriver .. _async-neo4j-driver-ref: AsyncNeo4jDriver ================ URI schemes: ``neo4j``, ``neo4j+ssc``, ``neo4j+s`` Will result in: .. autoclass:: neo4j.AsyncNeo4jDriver ********************************* AsyncSessions & AsyncTransactions ********************************* All database activity is co-ordinated through two mechanisms: **sessions** (:class:`neo4j.AsyncSession`) and **transactions** (:class:`neo4j.AsyncTransaction`, :class:`neo4j.AsyncManagedTransaction`). A **session** is a logical container for any number of causally-related transactional units of work. Sessions automatically provide guarantees of causal consistency within a clustered environment but multiple sessions can also be causally chained if required. Sessions provide the top level of containment for database activity. Session creation is a lightweight operation and *sessions are not thread safe*. Connections are drawn from the :class:`neo4j.AsyncDriver` connection pool as required. A **transaction** is a unit of work that is either committed in its entirety or is rolled back on failure. .. _async-session-construction-ref: ************************* AsyncSession Construction ************************* To construct a :class:`neo4j.AsyncSession` use the :meth:`neo4j.AsyncDriver.session` method. .. code-block:: python import asyncio from neo4j import AsyncGraphDatabase async def main(): driver = AsyncGraphDatabase(uri, auth=(user, password)) session = driver.session() result = await session.run("MATCH (a:Person) RETURN a.name AS name") names = [record["name"] async for record in result] await session.close() await driver.close() asyncio.run(main()) Sessions will often be created and destroyed using a *with block context*. This is the recommended approach as it takes care of closing the session properly even when an exception is raised. .. code-block:: python async with driver.session() as session: result = await session.run("MATCH (a:Person) RETURN a.name AS name") # do something with the result... Sessions will often be created with some configuration settings, see :ref:`async-session-configuration-ref`. .. code-block:: python async with driver.session(database="example_database", fetch_size=100) as session: result = await session.run("MATCH (a:Person) RETURN a.name AS name") # do something with the result... ************ AsyncSession ************ .. autoclass:: neo4j.AsyncSession() .. note:: Some asyncio utility functions (e.g., :func:`asyncio.wait_for` and :func:`asyncio.shield`) will wrap work in a :class:`asyncio.Task`. This introduces concurrency and can lead to undefined behavior as :class:`AsyncSession` is not concurrency-safe. Consider this **wrong** example:: async def dont_do_this(driver): async with driver.session() as session: await asyncio.shield(session.run("RETURN 1")) If ``dont_do_this`` gets cancelled while waiting for ``session.run``, ``session.run`` itself won't get cancelled (it's shielded) so it will continue to use the session in another Task. Concurrently, will the async context manager (``async with driver.session()``) on exit clean up the session. That's two Tasks handling the session concurrently. Therefore, this yields undefined behavior. In this particular example, the problem could be solved by shielding the whole coroutine ``dont_do_this`` instead of only the ``session.run``. Like so:: async def thats_better(driver): async def inner() async with driver.session() as session: await session.run("RETURN 1") await asyncio.shield(inner()) .. automethod:: close .. automethod:: cancel .. automethod:: closed .. automethod:: run .. automethod:: last_bookmarks .. automethod:: last_bookmark .. automethod:: begin_transaction .. automethod:: read_transaction .. automethod:: execute_read .. automethod:: write_transaction .. automethod:: execute_write .. _async-session-configuration-ref: Session Configuration ===================== :class:`neo4j.AsyncSession` is configured exactly like :class:`neo4j.Session` (see :ref:`session-configuration-ref`). The only difference is the async session accepts either a :class:`neo4j.api.BookmarkManager` object or a :class:`neo4j.api.AsyncBookmarkManager` as bookmark manager: .. _async-bookmark-manager-ref: ``bookmark_manager`` -------------------- Specify a bookmark manager for the driver to use. If present, the bookmark manager is used to keep all work on the driver causally consistent. See :class:`BookmarkManager` for more information. .. warning:: Enabling the BookmarkManager can have a negative impact on performance since all queries will wait for the latest changes to be propagated across the cluster. For simpler use-cases, sessions (:class:`.AsyncSession`) can be used to group a series of queries together that will be causally chained automatically. :Type: :const:`None`, :class:`BookmarkManager`, or :class:`AsyncBookmarkManager` :Default: :const:`None` **This is experimental.** (See :ref:`filter-warnings-ref`) It might be changed or removed any time even without prior notice. **************** AsyncTransaction **************** Neo4j supports three kinds of async transaction: + :ref:`async-auto-commit-transactions-ref` + :ref:`async-explicit-transactions-ref` + :ref:`async-managed-transactions-ref` Each has pros and cons but if in doubt, use a managed transaction with a *transaction function*. .. _async-auto-commit-transactions-ref: Auto-commit Transactions ======================== Auto-commit transactions are the simplest form of transaction, available via :meth:`neo4j.Session.run`. These are easy to use but support only one statement per transaction and are not automatically retried on failure. Auto-commit transactions are also the only way to run ``PERIODIC COMMIT`` (only Neo4j 4.4 and earlier) or ``CALL {...} IN TRANSACTIONS`` (Neo4j 4.4 and newer) statements, since those Cypher clauses manage their own transactions internally. Example: .. code-block:: python import neo4j async def create_person(driver, name): async with driver.session( default_access_mode=neo4j.WRITE_ACCESS ) as session: query = "CREATE (a:Person { name: $name }) RETURN id(a) AS node_id" result = await session.run(query, name=name) record = await result.single() return record["node_id"] Example: .. code-block:: python import neo4j async def get_numbers(driver): numbers = [] async with driver.session( default_access_mode=neo4j.READ_ACCESS ) as session: result = await session.run("UNWIND [1, 2, 3] AS x RETURN x") async for record in result: numbers.append(record["x"]) return numbers .. _async-explicit-transactions-ref: Explicit Async Transactions =========================== Explicit transactions support multiple statements and must be created with an explicit :meth:`neo4j.AsyncSession.begin_transaction` call. This creates a new :class:`neo4j.AsyncTransaction` object that can be used to run Cypher. It also gives applications the ability to directly control ``commit`` and ``rollback`` activity. .. autoclass:: neo4j.AsyncTransaction() .. automethod:: run .. automethod:: commit .. automethod:: rollback .. automethod:: close .. automethod:: cancel .. automethod:: closed Closing an explicit transaction can either happen automatically at the end of a ``async with`` block, or can be explicitly controlled through the :meth:`neo4j.AsyncTransaction.commit`, :meth:`neo4j.AsyncTransaction.rollback`, :meth:`neo4j.AsyncTransaction.close` or :meth:`neo4j.AsyncTransaction.cancel` methods. Explicit transactions are most useful for applications that need to distribute Cypher execution across multiple functions for the same transaction. Example: .. code-block:: python import neo4j async def create_person(driver, name): async with driver.session( default_access_mode=neo4j.WRITE_ACCESS ) as session: tx = await session.begin_transaction() node_id = await create_person_node(tx) await set_person_name(tx, node_id, name) await tx.commit() async def create_person_node(tx): query = "CREATE (a:Person { name: $name }) RETURN id(a) AS node_id" name = "default_name" result = await tx.run(query, name=name) record = await result.single() return record["node_id"] async def set_person_name(tx, node_id, name): query = "MATCH (a:Person) WHERE id(a) = $id SET a.name = $name" result = await tx.run(query, id=node_id, name=name) summary = await result.consume() # use the summary for logging etc. .. _async-managed-transactions-ref: Managed Async Transactions (`transaction functions`) ==================================================== Transaction functions are the most powerful form of transaction, providing access mode override and retry capabilities. + :meth:`neo4j.AsyncSession.execute_write` + :meth:`neo4j.AsyncSession.execute_read` These allow a function object representing the transactional unit of work to be passed as a parameter. This function is called one or more times, within a configurable time limit, until it succeeds. Results should be fully consumed within the function and only aggregate or status values should be returned. Returning a live result object would prevent the driver from correctly managing connections and would break retry guarantees. This function will receive a :class:`neo4j.AsyncManagedTransaction` object as its first parameter. .. autoclass:: neo4j.AsyncManagedTransaction() .. automethod:: run Example: .. code-block:: python async def create_person(driver, name) async with driver.session() as session: node_id = await session.execute_write(create_person_tx, name) async def create_person_tx(tx, name): query = "CREATE (a:Person { name: $name }) RETURN id(a) AS node_id" result = await tx.run(query, name=name) record = await result.single() return record["node_id"] To exert more control over how a transaction function is carried out, the :func:`neo4j.unit_of_work` decorator can be used. *********** AsyncResult *********** Every time a query is executed, a :class:`neo4j.AsyncResult` is returned. This provides a handle to the result of the query, giving access to the records within it as well as the result metadata. Results also contain a buffer that automatically stores unconsumed records when results are consumed out of order. A :class:`neo4j.AsyncResult` is attached to an active connection, through a :class:`neo4j.AsyncSession`, until all its content has been buffered or consumed. .. autoclass:: neo4j.AsyncResult() .. method:: result.__aiter__() :async: .. method:: result.__anext__() :async: .. automethod:: keys .. automethod:: consume .. automethod:: single .. automethod:: fetch .. automethod:: peek .. automethod:: graph .. automethod:: value .. automethod:: values .. automethod:: data .. automethod:: to_df .. automethod:: closed See https://neo4j.com/docs/python-manual/current/cypher-workflow/#python-driver-type-mapping for more about type mapping. ******************** AsyncBookmarkManager ******************** .. autoclass:: neo4j.api.AsyncBookmarkManager :members: ****************** Async Cancellation ****************** Async Python provides a mechanism for cancelling futures (:meth:`asyncio.Future.cancel`). The driver and its components can handle this. However, generally, it's not advised to rely on cancellation as it forces the driver to close affected connections to avoid leaving them in an undefined state. This makes the driver less efficient. The easiest way to make sure your application code's interaction with the driver is playing nicely with cancellation is to always use the async context manager provided by :class:`neo4j.AsyncSession` like so: :: async with driver.session() as session: ... # do what you need to do with the session If, for whatever reason, you need handle the session manually, you can it like so: :: session = await with driver.session() try: ... # do what you need to do with the session except asyncio.CancelledError: session.cancel() raise finally: # this becomes a no-op if the session has been cancelled before await session.close() As mentioned above, any cancellation of I/O work will cause the driver to close the affected connection. This will kill any :class:`neo4j.AsyncTransaction` and :class:`neo4j.AsyncResult` objects that are attached to that connection. Hence, after catching a :class:`asyncio.CancelledError`, you should not try to use transactions or results created earlier. They are likely to not be valid anymore. Furthermore, there is no guarantee as to whether a piece of ongoing work got successfully executed on the server side or not, when a cancellation happens: ``await transaction.commit()`` and other methods can throw :exc:`asyncio.CancelledError` but still have managed to complete from the server's perspective. .. _async-logging-ref: ************* Async Logging ************* For the most parts, logging works the same way as in the synchronous driver. See :ref:`logging-ref` for more information. However, when following the manual approach to logging, it is recommended to include information about the current async task in the log record. Like so: .. code-block:: python import asyncio import logging import sys class TaskIdFilter(logging.Filter): """Injecting async task id into log records.""" def filter(self, record): try: record.taskId = id(asyncio.current_task()) except RuntimeError: record.taskId = None return True # create a handler, e.g. to log to stdout handler = logging.StreamHandler(sys.stdout) # configure the handler to your liking handler.setFormatter(logging.Formatter( "[%(levelname)-8s] [Task %(taskId)-15s] %(asctime)s %(message)s" # or when using threading AND asyncio # "[%(levelname)-8s] [Thread %(thread)d] [Task %(taskId)-15s] " # "%(asctime)s %(message)s" )) # attache the filter injecting the task id to the handler handler.addFilter(TaskIdFilter()) # add the handler to the driver's logger logging.getLogger("neo4j").addHandler(handler) # make sure the logger logs on the desired log level logging.getLogger("neo4j").setLevel(logging.DEBUG) # from now on, DEBUG logging to stdout is enabled in the driver neo4j-python-driver-5.2.1/docs/source/breaking_changes.rst000066400000000000000000000076631433522662700236300ustar00rootroot00000000000000.. _breaking-changes: **************** Breaking Changes **************** This describes the breaking changes between Python Driver 1.7 and Python Driver 4.0 Version Scheme Changes ====================== The version number has jumped from **Python Driver 1.7** to **Python Driver 4.0** to align with the Neo4j Database version scheme. Python Versions =============== Python 2.7 is no longer supported. Namespace Changes ================= .. code-block:: python import neo4j.v1 Has changed to .. code-block:: python import neo4j Secure Connection ================= **Neo4j 4.0** is by default configured to use a **unsecured connection**. The driver configuration argument :code:`encrypted` is by default set to :code:`False`. **Note:** To be able to connect to **Neo4j 3.5** set :code:`encrypted=True` to have it configured as the default for that setup. .. code-block:: python from neo4j import GraphDatabase driver = GraphDatabase("bolt://localhost:7687", auth=("neo4j", "password"), encrypted=True) driver.close() Bookmark Changes ================ Introduced :class:`neo4j.Bookmark` Exceptions Changes ================== The exceptions in :code:`neo4j.exceptions` has been updated and there are internal exceptions starting with the naming :code:`Bolt` that should be propagated into the exceptions API. See :ref:`errors-ref` for more about errors. URI Scheme Changes ================== **bolt+routing** has been renamed to **neo4j**. Class Renaming Changes ====================== * :code:`BoltStatementResult` is now :code:`Result` * :code:`StatementResultSummary` is now :code:`ResultSummary` * :code:`Statement` is now :code:`Query` Argument Renaming Changes ========================= * :code:`statement` is now :code:`query` * :code:`cypher` is now :code:`query` * :code:`Session.run(cypher, ...` is now :code:`Session.run(query, ...` * :code:`Transaction.run(statement, ...` is now :code:`Transaction.run(query, ...` * :code:`StatementResultSummary.statement` is now :code:`ResultSummary.query` * :code:`StatementResultSummary.statement_type` is now :code:`ResultSummary.query_type` * :code:`StatementResultSummary.protocol_version` is now :code:`ResultSummary.server.protocol_version` API Changes ========================= * :code:`Result.summary()` has been replaced with :code:`Result.consume()`, this behaviour is to consume all remaining records in the buffer and returns the ResultSummary. * :code:`Result.data(*items)` has been changed to :code:`Result.data(*keys)` for alignment with :code:`Record.data(*keys)`. * :code:`Result.value(item=0, default=None)` has been changed to :code:`Result.value(key=0, default=None)` for alignment with :code:`Record.value(key=0, default=None)`. * :code:`Result.values(*items)` has been changed to :code:`Result.values(*keys)` for alignment with :code:`Record.values(*keys)`. * :code:`Transaction.sync()` has been removed. Use :code:`Result.consume()` if the behaviour is to exhaust the result object. * :code:`Transaction.success` has been removed. * :code:`Transaction.close()` behaviour changed. Will now only perform rollback if no commit have been performed. * :code:`Session.sync()` has been removed. Use :code:`Result.consume()` if the behaviour is to exhaust the result object. * :code:`Session.detach()` has been removed. Use :code:`Result.consume()` if the behaviour is to exhaust the result object. * :code:`Session.next_bookmarks()` has been removed. * :code:`Session.has_transaction()` has been removed. * :code:`Session.closed()` has been removed. * :code:`Session.write_transaction` and :code:`Session.read_transaction` will start the retry timer after the first failed attempt. Dependency Changes ================== * The dependency :code:`neobolt` has been removed. * The dependency :code:`neotime` has been removed. * The :code:`pytz` is now a dependency. Configuration Name Changes ========================== * :code:`max_retry_time` is now :code:`max_transaction_retry_time` neo4j-python-driver-5.2.1/docs/source/conf.py000066400000000000000000000235761433522662700211240ustar00rootroot00000000000000# Neo4j Bolt Driver for Python documentation build configuration file, created by # sphinx-quickstart on Mon Sep 21 11:48:02 2015. # # This file is execfile()d with the current directory set to its # containing dir. # # Note that not all possible configuration values are present in this # autogenerated file. # # All configuration values have a default; values that are commented out # serve to show the default. import os import sys # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. sys.path.insert(0, os.path.abspath(os.path.join("..", ".."))) from neo4j import __version__ as project_version # -- General configuration ------------------------------------------------ # If your documentation needs a minimal Sphinx version, state it here. #needs_sphinx = '1.0' # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # ones. extensions = [ 'sphinx.ext.autodoc', 'sphinx.ext.doctest', 'sphinx.ext.todo', 'sphinx.ext.coverage', 'sphinx.ext.ifconfig', 'sphinx.ext.intersphinx', ] # Add any paths that contain templates here, relative to this directory. templates_path = ['_templates'] # The suffix(es) of source filenames. # You can specify multiple suffix as a list of string: # source_suffix = ['.rst', '.md'] source_suffix = '.rst' # The encoding of source files. #source_encoding = 'utf-8-sig' # The master toctree document. master_doc = 'index' # General information about the project. project = 'Neo4j Python Driver' copyright = 'Neo4j, Inc.' author = 'Neo4j, Inc.' # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the # built documents. # # The short X.Y version. version = ".".join(project_version.split(".")[0:2]) # The full version, including alpha/beta/rc tags. release = ".".join(project_version.split(".")[0:3]) # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. # # This is also used if you do content translation via gettext catalogs. # Usually you set "language" from the command line for these cases. language = None # There are two options for replacing |today|: either, you set today to some # non-false value, then it is used: #today = '' # Else, today_fmt is used as the format for a strftime call. #today_fmt = '%B %d, %Y' # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. exclude_patterns = [] # The reST default role (used for this markup: `text`) to use for all # documents. #default_role = None # If true, '()' will be appended to :func: etc. cross-reference text. #add_function_parentheses = True # If true, the current module name will be prepended to all description # unit titles (such as .. function::). #add_module_names = True # If true, sectionauthor and moduleauthor directives will be shown in the # output. They are ignored by default. #show_authors = False # The name of the Pygments (syntax highlighting) style to use. # pygments_style = 'sphinx' pygments_style = 'friendly' # A list of ignored prefixes for module index sorting. #modindex_common_prefix = [] # If true, keep warnings as "system message" paragraphs in the built documents. #keep_warnings = False # If true, `todo` and `todoList` produce output, else they produce nothing. todo_include_todos = True # Don't include type hints in function signatures autodoc_typehints = "description" # -- Options for HTML output ---------------------------------------------- # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". html_static_path = ['_static'] # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. html_theme = 'nature' # _static/nature_custom.css_t html_style = 'nature_custom.css' html_js_files = [ 'anchor_new_target.js', ] # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. #html_theme_options = {} # Add any paths that contain custom themes here, relative to this directory. #html_theme_path = [] # The name for this set of Sphinx documents. If None, it defaults to # " v documentation". html_title = "Neo4j Python Driver {}".format(version) # A shorter title for the navigation bar. Default is the same as html_title. #html_short_title = None # The name of an image file (relative to this directory) to place at the top # of the sidebar. #html_logo = None # The name of an image file (within the static path) to use as favicon of the # docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 # pixels large. #html_favicon = None # Add any extra paths that contain custom files (such as robots.txt or # .htaccess) here, relative to this directory. These files are copied # directly to the root of the documentation. #html_extra_path = [] # If not '', a 'Last updated on:' timestamp is inserted at every page bottom, # using the given strftime format. #html_last_updated_fmt = '%b %d, %Y' # If true, SmartyPants will be used to convert quotes and dashes to # typographically correct entities. #html_use_smartypants = True # Custom sidebar templates, maps document names to template names. #html_sidebars = {} # Additional templates that should be rendered to pages, maps page names to # template names. #html_additional_pages = {} # If false, no module index is generated. #html_domain_indices = True # If false, no index is generated. #html_use_index = True # If true, the index is split into individual pages for each letter. #html_split_index = False # If true, links to the reST sources are added to the pages. #html_show_sourcelink = True # If true, "Created using Sphinx" is shown in the HTML footer. Default is True. #html_show_sphinx = True # If true, "(C) Copyright ..." is shown in the HTML footer. Default is True. #html_show_copyright = True # If true, an OpenSearch description file will be output, and all pages will # contain a tag referring to it. The value of this option must be the # base URL from which the finished HTML is served. #html_use_opensearch = '' # This is the file name suffix for HTML files (e.g. ".xhtml"). #html_file_suffix = None # Language to be used for generating the HTML full-text search index. # Sphinx supports the following languages: # 'da', 'de', 'en', 'es', 'fi', 'fr', 'h', 'it', 'ja' # 'nl', 'no', 'pt', 'ro', 'r', 'sv', 'tr' #html_search_language = 'en' # A dictionary with options for the search language support, empty by default. # Now only 'ja' uses this config value #html_search_options = {'type': 'default'} # The name of a javascript file (relative to the configuration directory) that # implements a search results scorer. If empty, the default will be used. #html_search_scorer = 'scorer.js' # Output file base name for HTML help builder. htmlhelp_basename = 'Neo4jBoltDriverforPythondoc' # -- Options for LaTeX output --------------------------------------------- latex_elements = { # The paper size ('letterpaper' or 'a4paper'). #'papersize': 'letterpaper', # The font size ('10pt', '11pt' or '12pt'). #'pointsize': '10pt', # Additional stuff for the LaTeX preamble. #'preamble': '', # Latex figure (float) alignment #'figure_align': 'htbp', } # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, # author, documentclass [howto, manual, or own class]). latex_documents = [ (master_doc, 'Neo4jBoltDriverforPython.tex', 'Neo4j Bolt Driver for Python Documentation', 'Neo4j', 'manual'), ] # The name of an image file (relative to this directory) to place at the top of # the title page. #latex_logo = None # For "manual" documents, if this is true, then toplevel headings are parts, # not chapters. #latex_use_parts = False # If true, show page references after internal links. #latex_show_pagerefs = False # If true, show URL addresses after external links. #latex_show_urls = False # Documents to append as an appendix to all manuals. #latex_appendices = [] # If false, no module index is generated. #latex_domain_indices = True # -- Options for manual page output --------------------------------------- # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). man_pages = [ (master_doc, 'neo4jboltdriverforpython', 'Neo4j Bolt Driver for Python Documentation', [author], 1) ] # If true, show URL addresses after external links. #man_show_urls = False # -- Options for Texinfo output ------------------------------------------- # Grouping the document tree into Texinfo files. List of tuples # (source start file, target name, title, author, # dir menu entry, description, category) texinfo_documents = [ (master_doc, 'Neo4jBoltDriverforPython', 'Neo4j Bolt Driver for Python Documentation', author, 'Neo4jBoltDriverforPython', 'One line description of project.', 'Miscellaneous'), ] # Documents to append as an appendix to all manuals. #texinfo_appendices = [] # If false, no module index is generated. #texinfo_domain_indices = True # How to display URL addresses: 'footnote', 'no', or 'inline'. #texinfo_show_urls = 'footnote' # If true, do not generate a @detailmenu in the "Top" node's menu. #texinfo_no_detailmenu = False # -- Options for Intersphinx intersphinx_mapping = { 'python': ('https://docs.python.org/3', None), } autodoc_default_options = { 'member-order': 'bysource', # 'special-members': '__init__', 'undoc-members': True, 'exclude-members': '__weakref__', } neo4j-python-driver-5.2.1/docs/source/index.rst000066400000000000000000000154241433522662700214570ustar00rootroot00000000000000############################# Neo4j Python Driver |version| ############################# The Official Neo4j Driver for Python. Neo4j versions supported: * Neo4j 5.2 * Neo4j 5.1 * Neo4j 5.0 * Neo4j 4.4 Python versions supported: * Python 3.10 * Python 3.9 * Python 3.8 * Python 3.7 ****** Topics ****** + :ref:`api-documentation` + :ref:`async-api-documentation` + :ref:`spatial-data-types` + :ref:`temporal-data-types` + :ref:`breaking-changes` .. toctree:: :hidden: api.rst async_api.rst types/spatial.rst types/temporal.rst breaking_changes.rst ************ Installation ************ To install the latest stable release, use: .. code:: bash python -m pip install neo4j To install the latest pre-release, use: .. code:: bash python -m pip install --pre neo4j .. note:: It is always recommended to install python packages for user space in a virtual environment. Virtual Environment =================== To create a virtual environment named sandbox, use: .. code:: bash python -m venv sandbox To activate the virtual environment named sandbox, use: .. code:: bash source sandbox/bin/activate To deactivate the current active virtual environment, use: .. code:: bash deactivate ************* Quick Example ************* Creating nodes and relationships. .. code-block:: python from neo4j import GraphDatabase uri = "neo4j://localhost:7687" driver = GraphDatabase.driver(uri, auth=("neo4j", "password")) def create_person(tx, name): tx.run("CREATE (a:Person {name: $name})", name=name) def create_friend_of(tx, name, friend): tx.run("MATCH (a:Person) WHERE a.name = $name " "CREATE (a)-[:KNOWS]->(:Person {name: $friend})", name=name, friend=friend) with driver.session() as session: session.execute_write(create_person, "Alice") session.execute_write(create_friend_of, "Alice", "Bob") session.execute_write(create_friend_of, "Alice", "Carl") driver.close() Finding nodes. .. code-block:: python from neo4j import GraphDatabase uri = "neo4j://localhost:7687" driver = GraphDatabase.driver(uri, auth=("neo4j", "password")) def get_friends_of(tx, name): friends = [] result = tx.run("MATCH (a:Person)-[:KNOWS]->(f) " "WHERE a.name = $name " "RETURN f.name AS friend", name=name) for record in result: friends.append(record["friend"]) return friends with driver.session() as session: friends = session.execute_read(get_friends_of, "Alice") for friend in friends: print(friend) driver.close() ******************* Example Application ******************* .. code-block:: python import logging from neo4j import GraphDatabase from neo4j.exceptions import ServiceUnavailable class App: def __init__(self, uri, user, password): self.driver = GraphDatabase.driver(uri, auth=(user, password)) def close(self): # Don't forget to close the driver connection when you are finished with it self.driver.close() def create_friendship(self, person1_name, person2_name): with self.driver.session() as session: # Write transactions allow the driver to handle retries and transient errors result = session.execute_write( self._create_and_return_friendship, person1_name, person2_name) for record in result: print("Created friendship between: {p1}, {p2}".format( p1=record['p1'], p2=record['p2'])) @staticmethod def _create_and_return_friendship(tx, person1_name, person2_name): # To learn more about the Cypher syntax, # see https://neo4j.com/docs/cypher-manual/current/ # The Reference Card is also a good resource for keywords, # see https://neo4j.com/docs/cypher-refcard/current/ query = ( "CREATE (p1:Person { name: $person1_name }) " "CREATE (p2:Person { name: $person2_name }) " "CREATE (p1)-[:KNOWS]->(p2) " "RETURN p1, p2" ) result = tx.run(query, person1_name=person1_name, person2_name=person2_name) try: return [{"p1": record["p1"]["name"], "p2": record["p2"]["name"]} for record in result] # Capture any errors along with the query and data for traceability except ServiceUnavailable as exception: logging.error("{query} raised an error: \n {exception}".format( query=query, exception=exception)) raise def find_person(self, person_name): with self.driver.session() as session: result = session.execute_read(self._find_and_return_person, person_name) for record in result: print("Found person: {record}".format(record=record)) @staticmethod def _find_and_return_person(tx, person_name): query = ( "MATCH (p:Person) " "WHERE p.name = $person_name " "RETURN p.name AS name" ) result = tx.run(query, person_name=person_name) return [record["name"] for record in result] if __name__ == "__main__": # See https://neo4j.com/developer/aura-connect-driver/ for Aura specific connection URL. scheme = "neo4j" # Connecting to Aura, use the "neo4j+s" URI scheme host_name = "example.com" port = 7687 url = "{scheme}://{host_name}:{port}".format(scheme=scheme, host_name=host_name, port=port) user = "" password = "" app = App(url, user, password) app.create_friendship("Alice", "David") app.find_person("Alice") app.close() ***************** Other Information ***************** * `Neo4j Documentation`_ * `The Neo4j Drivers Manual`_ * `Neo4j Quick Reference Card`_ * `Example Project`_ * `Driver Wiki`_ (includes change logs) * `Migration Guide - Upgrade Neo4j drivers`_ * `Neo4j Aura`_ .. _`Python Driver 1.7`: https://neo4j.com/docs/api/python-driver/1.7/ .. _`Neo4j Documentation`: https://neo4j.com/docs/ .. _`The Neo4j Drivers Manual`: https://neo4j.com/docs/driver-manual/current/ .. _`Neo4j Quick Reference Card`: https://neo4j.com/docs/cypher-refcard/current/ .. _`Example Project`: https://github.com/neo4j-examples/movies-python-bolt .. _`Driver Wiki`: https://github.com/neo4j/neo4j-python-driver/wiki .. _`Migration Guide - Upgrade Neo4j drivers`: https://neo4j.com/docs/migration-guide/4.0/upgrade-driver/ .. _`Neo4j Aura`: https://neo4j.com/neo4j-aura/ neo4j-python-driver-5.2.1/docs/source/types/000077500000000000000000000000001433522662700207545ustar00rootroot00000000000000neo4j-python-driver-5.2.1/docs/source/types/_spatial_overview.rst000066400000000000000000000011251433522662700252270ustar00rootroot00000000000000Cypher has built-in support for handling spatial values (points), and the underlying database supports storing these point values as properties on nodes and relationships. https://neo4j.com/docs/cypher-manual/current/syntax/spatial/ ================= ===================================== Cypher Type Python Type ================= ===================================== Point :class:`neo4j.spatial.Point` Point (Cartesian) :class:`neo4j.spatial.CartesianPoint` Point (WGS-84) :class:`neo4j.spatial.WGS84Point` ================= ===================================== neo4j-python-driver-5.2.1/docs/source/types/_temporal_overview.rst000066400000000000000000000036111433522662700254170ustar00rootroot00000000000000Temporal data types are implemented by the ``neo4j.time`` module. It provides a set of types compliant with ISO-8601 and Cypher, which are similar to those found in the built-in ``datetime`` module. Sub-second values are measured to nanosecond precision and the types are compatible with `pytz `_. The table below shows the general mappings between Cypher and the temporal types provided by the driver. In addition, the built-in temporal types can be passed as parameters and will be mapped appropriately. ============= ============================ ================================== ============ Cypher Python driver type Python built-in type ``tzinfo`` ============= ============================ ================================== ============ Date :class:`neo4j.time.Date` :class:`python:datetime.date` Time :class:`neo4j.time.Time` :class:`python:datetime.time` ``not None`` LocalTime :class:`neo4j.time.Time` :class:`python:datetime.time` ``None`` DateTime :class:`neo4j.time.DateTime` :class:`python:datetime.datetime` ``not None`` LocalDateTime :class:`neo4j.time.DateTime` :class:`python:datetime.datetime` ``None`` Duration :class:`neo4j.time.Duration` :class:`python:datetime.timedelta` ============= ============================ ================================== ============ Sub-second values are measured to nanosecond precision and the types are mostly compatible with `pytz `_. Some timezones (e.g., ``pytz.utc``) work exclusively with the built-in ``datetime.datetime``. .. Note:: Cypher has built-in support for handling temporal values, and the underlying database supports storing these temporal values as properties on nodes and relationships, see https://neo4j.com/docs/cypher-manual/current/syntax/temporal/ neo4j-python-driver-5.2.1/docs/source/types/spatial.rst000066400000000000000000000040131433522662700231410ustar00rootroot00000000000000.. _spatial-data-types: ******************* Spatial Data Types ******************* .. include:: _spatial_overview.rst Point ===== .. autoclass:: neo4j.spatial.Point :show-inheritance: :members: CartesianPoint ============== .. autoclass:: neo4j.spatial.CartesianPoint :show-inheritance: .. property:: x :type: float Same value as ``point[0]``. .. property:: y :type: float Same value as ``point[1]``. .. property:: z :type: float Same value as ``point[2]``. Only available if the point is in 3D space. Examples -------- .. code-block:: python from neo4j.spatial import CartesianPoint point = CartesianPoint((1.23, 4.56)) print(point.x, point.y, point.srid) # 1.23 4.56 7203 .. code-block:: python from neo4j.spatial import CartesianPoint point = CartesianPoint((1.23, 4.56, 7.89)) print(point.x, point.y, point.z, point.srid) # 1.23 4.56 7.8 9157 WGS84Point ========== .. autoclass:: neo4j.spatial.WGS84Point :show-inheritance: .. property:: x :type: float Same value as ``point[0]``. .. property:: y :type: float Same value as ``point[1]``. .. property:: z :type: float Same value as ``point[2]``. Only available if the point is in 3D space. .. property:: longitude :type: float Alias for :attr:`.x`. .. property:: latitude :type: float Alias for :attr:`.y`. .. property:: height :type: float Alias for :attr:`.z`. Only available if the point is in 3D space. Examples -------- .. code-block:: python from neo4j.spatial import WGS84Point point = WGS84Point((1.23, 4.56)) print(point.longitude, point.latitude, point.srid) # 1.23 4.56 4326 .. code-block:: python from neo4j.spatial import WGS84Point point = WGS84Point((1.23, 4.56, 7.89)) print(point.longitude, point.latitude, point.height, point.srid) # 1.23 4.56 7.89 4979 neo4j-python-driver-5.2.1/docs/source/types/temporal.rst000066400000000000000000000173321433522662700233370ustar00rootroot00000000000000.. _temporal-data-types: ******************* Temporal Data Types ******************* .. include:: _temporal_overview.rst Constants ========= .. autodata:: neo4j.time.MIN_YEAR .. autodata:: neo4j.time.MAX_YEAR Date ==== .. autoclass:: neo4j.time.Date Class methods ------------- .. automethod:: neo4j.time.Date.today .. automethod:: neo4j.time.Date.utc_today .. automethod:: neo4j.time.Date.from_timestamp .. automethod:: neo4j.time.Date.utc_from_timestamp .. automethod:: neo4j.time.Date.from_ordinal .. automethod:: neo4j.time.Date.parse .. automethod:: neo4j.time.Date.from_native .. automethod:: neo4j.time.Date.from_clock_time .. automethod:: neo4j.time.Date.is_leap_year .. automethod:: neo4j.time.Date.days_in_year .. automethod:: neo4j.time.Date.days_in_month Class attributes ---------------- .. autoattribute:: neo4j.time.Date.min .. autoattribute:: neo4j.time.Date.max .. autoattribute:: neo4j.time.Date.resolution Instance attributes ------------------- .. autoattribute:: neo4j.time.Date.year .. autoattribute:: neo4j.time.Date.month .. autoattribute:: neo4j.time.Date.day .. autoattribute:: neo4j.time.Date.year_month_day .. autoattribute:: neo4j.time.Date.year_week_day .. autoattribute:: neo4j.time.Date.year_day Operations ---------- .. automethod:: neo4j.time.Date.__hash__ .. automethod:: neo4j.time.Date.__eq__ .. automethod:: neo4j.time.Date.__ne__ .. automethod:: neo4j.time.Date.__lt__ .. automethod:: neo4j.time.Date.__gt__ .. automethod:: neo4j.time.Date.__le__ .. automethod:: neo4j.time.Date.__ge__ .. automethod:: neo4j.time.Date.__add__ .. automethod:: neo4j.time.Date.__sub__ Instance methods ---------------- .. automethod:: neo4j.time.Date.replace .. automethod:: neo4j.time.Date.time_tuple .. automethod:: neo4j.time.Date.to_ordinal .. automethod:: neo4j.time.Date.to_clock_time .. automethod:: neo4j.time.Date.to_native .. automethod:: neo4j.time.Date.weekday .. automethod:: neo4j.time.Date.iso_weekday .. automethod:: neo4j.time.Date.iso_calendar .. automethod:: neo4j.time.Date.iso_format .. automethod:: neo4j.time.Date.__repr__ .. automethod:: neo4j.time.Date.__str__ .. automethod:: neo4j.time.Date.__format__ Special values -------------- .. autodata:: neo4j.time.ZeroDate Time ==== .. autoclass:: neo4j.time.Time Class methods ------------- .. automethod:: neo4j.time.Time.now .. automethod:: neo4j.time.Time.utc_now .. automethod:: neo4j.time.Time.from_ticks .. automethod:: neo4j.time.Time.from_native .. automethod:: neo4j.time.Time.from_clock_time Class attributes ---------------- .. autoattribute:: neo4j.time.Time.min .. autoattribute:: neo4j.time.Time.max .. autoattribute:: neo4j.time.Time.resolution Instance attributes ------------------- .. autoattribute:: neo4j.time.Time.ticks .. autoattribute:: neo4j.time.Time.hour .. autoattribute:: neo4j.time.Time.minute .. autoattribute:: neo4j.time.Time.second .. autoattribute:: neo4j.time.Time.nanosecond .. autoattribute:: neo4j.time.Time.hour_minute_second_nanosecond .. autoattribute:: neo4j.time.Time.tzinfo Operations ---------- .. automethod:: neo4j.time.Time.__hash__ .. automethod:: neo4j.time.Time.__eq__ .. automethod:: neo4j.time.Time.__ne__ .. automethod:: neo4j.time.Time.__lt__ .. automethod:: neo4j.time.Time.__gt__ .. automethod:: neo4j.time.Time.__le__ .. automethod:: neo4j.time.Time.__ge__ Instance methods ---------------- .. automethod:: neo4j.time.Time.replace .. automethod:: neo4j.time.Time.utc_offset .. automethod:: neo4j.time.Time.dst .. automethod:: neo4j.time.Time.tzname .. automethod:: neo4j.time.Time.to_clock_time .. automethod:: neo4j.time.Time.to_native .. automethod:: neo4j.time.Time.iso_format .. automethod:: neo4j.time.Time.__repr__ .. automethod:: neo4j.time.Time.__str__ .. automethod:: neo4j.time.Time.__format__ Special values -------------- .. autodata:: neo4j.time.Midnight .. autodata:: neo4j.time.Midday DateTime ======== .. autoclass:: neo4j.time.DateTime Class methods ------------- .. automethod:: neo4j.time.DateTime.now .. automethod:: neo4j.time.DateTime.utc_now .. automethod:: neo4j.time.DateTime.from_timestamp .. automethod:: neo4j.time.DateTime.utc_from_timestamp .. automethod:: neo4j.time.DateTime.from_ordinal .. automethod:: neo4j.time.DateTime.combine .. automethod:: neo4j.time.DateTime.from_native .. automethod:: neo4j.time.DateTime.from_clock_time Class attributes ---------------- .. autoattribute:: neo4j.time.DateTime.min .. autoattribute:: neo4j.time.DateTime.max .. autoattribute:: neo4j.time.DateTime.resolution Instance attributes ------------------- .. autoattribute:: neo4j.time.DateTime.year .. autoattribute:: neo4j.time.DateTime.month .. autoattribute:: neo4j.time.DateTime.day .. autoattribute:: neo4j.time.DateTime.year_month_day .. autoattribute:: neo4j.time.DateTime.year_week_day .. autoattribute:: neo4j.time.DateTime.year_day .. autoattribute:: neo4j.time.DateTime.hour .. autoattribute:: neo4j.time.DateTime.minute .. autoattribute:: neo4j.time.DateTime.second .. autoattribute:: neo4j.time.DateTime.nanosecond .. autoattribute:: neo4j.time.DateTime.tzinfo .. autoattribute:: neo4j.time.DateTime.hour_minute_second_nanosecond Operations ---------- .. automethod:: neo4j.time.DateTime.__hash__ .. automethod:: neo4j.time.DateTime.__eq__ .. automethod:: neo4j.time.DateTime.__ne__ .. automethod:: neo4j.time.DateTime.__lt__ .. automethod:: neo4j.time.DateTime.__gt__ .. automethod:: neo4j.time.DateTime.__le__ .. automethod:: neo4j.time.DateTime.__ge__ .. automethod:: neo4j.time.DateTime.__add__ .. automethod:: neo4j.time.DateTime.__sub__ Instance methods ---------------- .. automethod:: neo4j.time.DateTime.date .. automethod:: neo4j.time.DateTime.time .. automethod:: neo4j.time.DateTime.timetz .. automethod:: neo4j.time.DateTime.replace .. automethod:: neo4j.time.DateTime.as_timezone .. automethod:: neo4j.time.DateTime.utc_offset .. automethod:: neo4j.time.DateTime.dst .. automethod:: neo4j.time.DateTime.tzname .. automethod:: neo4j.time.DateTime.to_ordinal .. automethod:: neo4j.time.DateTime.to_clock_time .. automethod:: neo4j.time.DateTime.to_native .. automethod:: neo4j.time.DateTime.weekday .. automethod:: neo4j.time.DateTime.iso_weekday .. automethod:: neo4j.time.DateTime.iso_calendar .. automethod:: neo4j.time.DateTime.iso_format .. automethod:: neo4j.time.DateTime.__repr__ .. automethod:: neo4j.time.DateTime.__str__ .. automethod:: neo4j.time.DateTime.__format__ Special values -------------- .. autodata:: neo4j.time.Never .. autodata:: neo4j.time.UnixEpoch Duration ======== .. autoclass:: neo4j.time.Duration Class attributes ---------------- .. autoattribute:: neo4j.time.Duration.min .. autoattribute:: neo4j.time.Duration.max Instance attributes ------------------- .. autoattribute:: neo4j.time.Duration.months .. autoattribute:: neo4j.time.Duration.days .. autoattribute:: neo4j.time.Duration.seconds .. autoattribute:: neo4j.time.Duration.nanoseconds .. autoattribute:: neo4j.time.Duration.years_months_days .. autoattribute:: neo4j.time.Duration.hours_minutes_seconds_nanoseconds Operations ---------- .. automethod:: neo4j.time.Duration.__bool__ .. automethod:: neo4j.time.Duration.__add__ .. automethod:: neo4j.time.Duration.__sub__ .. automethod:: neo4j.time.Duration.__mul__ .. automethod:: neo4j.time.Duration.__truediv__ .. automethod:: neo4j.time.Duration.__floordiv__ .. automethod:: neo4j.time.Duration.__mod__ .. automethod:: neo4j.time.Duration.__divmod__ .. automethod:: neo4j.time.Duration.__pos__ .. automethod:: neo4j.time.Duration.__neg__ .. automethod:: neo4j.time.Duration.__abs__ .. automethod:: neo4j.time.Duration.__repr__ .. automethod:: neo4j.time.Duration.__str__ Instance methods ---------------- .. automethod:: neo4j.time.Duration.iso_format neo4j-python-driver-5.2.1/neo4j/000077500000000000000000000000001433522662700163775ustar00rootroot00000000000000neo4j-python-driver-5.2.1/neo4j/__init__.py000066400000000000000000000070451433522662700205160ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 logging import getLogger as _getLogger from ._async.driver import ( AsyncBoltDriver, AsyncDriver, AsyncGraphDatabase, AsyncNeo4jDriver, ) from ._async.work import ( AsyncManagedTransaction, AsyncResult, AsyncSession, AsyncTransaction, ) from ._conf import ( Config as _Config, PoolConfig as _PoolConfig, SessionConfig as _SessionConfig, TrustAll, TrustCustomCAs, TrustSystemCAs, WorkspaceConfig as _WorkspaceConfig, ) from ._data import Record from ._meta import ( ExperimentalWarning, get_user_agent, version as __version__, ) from ._sync.driver import ( BoltDriver, Driver, GraphDatabase, Neo4jDriver, ) from ._sync.work import ( ManagedTransaction, Result, Session, Transaction, ) from .addressing import ( Address, IPv4Address, IPv6Address, ) from .api import ( Auth, # TODO: Validate naming for Auth compared to other drivers. ) from .api import ( AuthToken, basic_auth, bearer_auth, Bookmark, Bookmarks, custom_auth, DEFAULT_DATABASE, kerberos_auth, READ_ACCESS, ServerInfo, SYSTEM_DATABASE, TRUST_ALL_CERTIFICATES, TRUST_SYSTEM_CA_SIGNED_CERTIFICATES, Version, WRITE_ACCESS, ) from .work import ( Query, ResultSummary, SummaryCounters, unit_of_work, ) __all__ = [ "__version__", "Address", "AsyncBoltDriver", "AsyncDriver", "AsyncGraphDatabase", "AsyncManagedTransaction", "AsyncNeo4jDriver", "AsyncResult", "AsyncSession", "AsyncTransaction", "Auth", "AuthToken", "basic_auth", "bearer_auth", "BoltDriver", "Bookmark", "Bookmarks", "Config", "custom_auth", "DEFAULT_DATABASE", "Driver", "ExperimentalWarning", "get_user_agent", "GraphDatabase", "IPv4Address", "IPv6Address", "kerberos_auth", "log", "ManagedTransaction", "Neo4jDriver", "PoolConfig", "Query", "READ_ACCESS", "Record", "Result", "ResultSummary", "ServerInfo", "Session", "SessionConfig", "SummaryCounters", "Transaction", "TRUST_ALL_CERTIFICATES", "TRUST_SYSTEM_CA_SIGNED_CERTIFICATES", "TrustAll", "TrustCustomCAs", "TrustSystemCAs", "unit_of_work", "Version", "WorkspaceConfig", "WRITE_ACCESS", ] _log = _getLogger("neo4j") def __getattr__(name): # TODO 6.0 - remove this if name in ( "log", "Config", "PoolConfig", "SessionConfig", "WorkspaceConfig" ): from ._meta import deprecation_warn deprecation_warn( "Importing {} from neo4j is deprecated without replacement. It's " "internal and will be removed in a future version." .format(name), stack_level=2 ) return globals()[f"_{name}"] raise AttributeError(f"module {__name__} has no attribute {name}") def __dir__(): return __all__ neo4j-python-driver-5.2.1/neo4j/_async/000077500000000000000000000000001433522662700176535ustar00rootroot00000000000000neo4j-python-driver-5.2.1/neo4j/_async/__init__.py000066400000000000000000000012011433522662700217560ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. neo4j-python-driver-5.2.1/neo4j/_async/bookmark_manager.py000066400000000000000000000071651433522662700235350ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations import typing as t from collections import defaultdict from .._async_compat.concurrency import AsyncCooperativeLock from .._async_compat.util import AsyncUtil from ..api import ( AsyncBookmarkManager, Bookmarks, ) T_BmSupplier = t.Callable[[t.Optional[str]], t.Union[Bookmarks, t.Awaitable[Bookmarks]]] T_BmConsumer = t.Callable[[str, Bookmarks], t.Union[None, t.Awaitable[None]]] def _bookmarks_to_set( bookmarks: t.Union[Bookmarks, t.Iterable[str]] ) -> t.Set[str]: if isinstance(bookmarks, Bookmarks): return set(bookmarks.raw_values) return set(map(str, bookmarks)) class AsyncNeo4jBookmarkManager(AsyncBookmarkManager): def __init__( self, initial_bookmarks: t.Optional[t.Mapping[str, t.Union[Bookmarks, t.Iterable[str]]]] = None, bookmarks_supplier: t.Optional[T_BmSupplier] = None, bookmarks_consumer: t.Optional[T_BmConsumer] = None ) -> None: super().__init__() self._bookmarks_supplier = bookmarks_supplier self._bookmarks_consumer = bookmarks_consumer if initial_bookmarks is None: initial_bookmarks = {} self._bookmarks = defaultdict( set, ((k, _bookmarks_to_set(v)) for k, v in initial_bookmarks.items()) ) self._lock = AsyncCooperativeLock() async def update_bookmarks( self, database: str, previous_bookmarks: t.Collection[str], new_bookmarks: t.Collection[str] ) -> None: if not new_bookmarks: return with self._lock: curr_bms = self._bookmarks[database] curr_bms.difference_update(previous_bookmarks) curr_bms.update(new_bookmarks) if self._bookmarks_consumer: curr_bms_snapshot = Bookmarks.from_raw_values(curr_bms) if self._bookmarks_consumer: await AsyncUtil.callback( self._bookmarks_consumer, database, curr_bms_snapshot ) async def get_bookmarks(self, database: str) -> t.Set[str]: with self._lock: bms = set(self._bookmarks[database]) if self._bookmarks_supplier: extra_bms = await AsyncUtil.callback( self._bookmarks_supplier, database ) bms.update(extra_bms.raw_values) return bms async def get_all_bookmarks(self) -> t.Set[str]: bms: t.Set[str] = set() with self._lock: for database in self._bookmarks.keys(): bms.update(self._bookmarks[database]) if self._bookmarks_supplier: extra_bms = await AsyncUtil.callback( self._bookmarks_supplier, None ) bms.update(extra_bms.raw_values) return bms async def forget(self, databases: t.Iterable[str]) -> None: with self._lock: for database in databases: self._bookmarks.pop(database, None) neo4j-python-driver-5.2.1/neo4j/_async/driver.py000066400000000000000000000637011433522662700215270ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations import typing as t if t.TYPE_CHECKING: import typing_extensions as te import ssl from .._async_compat.util import AsyncUtil from .._conf import ( Config, PoolConfig, SessionConfig, TrustAll, TrustStore, WorkspaceConfig, ) from .._meta import ( deprecation_warn, experimental, experimental_warn, unclosed_resource_warn, ) from ..addressing import Address from ..api import ( AsyncBookmarkManager, Auth, BookmarkManager, Bookmarks, DRIVER_BOLT, DRIVER_NEO4J, parse_neo4j_uri, parse_routing_context, READ_ACCESS, SECURITY_TYPE_SECURE, SECURITY_TYPE_SELF_SIGNED_CERTIFICATE, ServerInfo, TRUST_ALL_CERTIFICATES, TRUST_SYSTEM_CA_SIGNED_CERTIFICATES, URI_SCHEME_BOLT, URI_SCHEME_BOLT_SECURE, URI_SCHEME_BOLT_SELF_SIGNED_CERTIFICATE, URI_SCHEME_NEO4J, URI_SCHEME_NEO4J_SECURE, URI_SCHEME_NEO4J_SELF_SIGNED_CERTIFICATE, ) from .bookmark_manager import ( AsyncNeo4jBookmarkManager, T_BmConsumer as _T_BmConsumer, T_BmSupplier as _T_BmSupplier, ) from .work import AsyncSession class AsyncGraphDatabase: """Accessor for :class:`neo4j.AsyncDriver` construction. """ if t.TYPE_CHECKING: @classmethod def driver( cls, uri: str, *, auth: t.Union[t.Tuple[t.Any, t.Any], Auth, None] = ..., max_connection_lifetime: float = ..., max_connection_pool_size: int = ..., connection_timeout: float = ..., trust: t.Union[ te.Literal["TRUST_ALL_CERTIFICATES"], te.Literal["TRUST_SYSTEM_CA_SIGNED_CERTIFICATES"] ] = ..., resolver: t.Union[ t.Callable[[Address], t.Iterable[Address]], t.Callable[[Address], t.Awaitable[t.Iterable[Address]]], ] = ..., encrypted: bool = ..., trusted_certificates: TrustStore = ..., ssl_context: ssl.SSLContext = ..., user_agent: str = ..., keep_alive: bool = ..., # undocumented/unsupported options # they may be change or removed any time without prior notice connection_acquisition_timeout: float = ..., max_transaction_retry_time: float = ..., initial_retry_delay: float = ..., retry_delay_multiplier: float = ..., retry_delay_jitter_factor: float = ..., database: t.Optional[str] = ..., fetch_size: int = ..., impersonated_user: t.Optional[str] = ..., bookmark_manager: t.Union[AsyncBookmarkManager, BookmarkManager, None] = ... ) -> AsyncDriver: ... else: @classmethod def driver(cls, uri, *, auth=None, **config) -> AsyncDriver: """Create a driver. :param uri: the connection URI for the driver, see :ref:`async-uri-ref` for available URIs. :param auth: the authentication details, see :ref:`auth-ref` for available authentication details. :param config: driver configuration key-word arguments, see :ref:`async-driver-configuration-ref` for available key-word arguments. """ driver_type, security_type, parsed = parse_neo4j_uri(uri) # TODO: 6.0 remove "trust" config option if "trust" in config.keys(): if config["trust"] not in ( TRUST_ALL_CERTIFICATES, TRUST_SYSTEM_CA_SIGNED_CERTIFICATES ): from neo4j.exceptions import ConfigurationError raise ConfigurationError( "The config setting `trust` values are {!r}" .format( [ TRUST_ALL_CERTIFICATES, TRUST_SYSTEM_CA_SIGNED_CERTIFICATES, ] ) ) if ("trusted_certificates" in config.keys() and not isinstance(config["trusted_certificates"], TrustStore)): raise ConnectionError( "The config setting `trusted_certificates` must be of " "type neo4j.TrustAll, neo4j.TrustCustomCAs, or" "neo4j.TrustSystemCAs but was {}".format( type(config["trusted_certificates"]) ) ) if (security_type in [SECURITY_TYPE_SELF_SIGNED_CERTIFICATE, SECURITY_TYPE_SECURE] and ("encrypted" in config.keys() or "trust" in config.keys() or "trusted_certificates" in config.keys() or "ssl_context" in config.keys())): from neo4j.exceptions import ConfigurationError # TODO: 6.0 remove "trust" from error message raise ConfigurationError( 'The config settings "encrypted", "trust", ' '"trusted_certificates", and "ssl_context" can only be ' "used with the URI schemes {!r}. Use the other URI " "schemes {!r} for setting encryption settings." .format( [ URI_SCHEME_BOLT, URI_SCHEME_NEO4J, ], [ URI_SCHEME_BOLT_SELF_SIGNED_CERTIFICATE, URI_SCHEME_BOLT_SECURE, URI_SCHEME_NEO4J_SELF_SIGNED_CERTIFICATE, URI_SCHEME_NEO4J_SECURE, ] ) ) if security_type == SECURITY_TYPE_SECURE: config["encrypted"] = True elif security_type == SECURITY_TYPE_SELF_SIGNED_CERTIFICATE: config["encrypted"] = True config["trusted_certificates"] = TrustAll() assert driver_type in (DRIVER_BOLT, DRIVER_NEO4J) if driver_type == DRIVER_BOLT: if parse_routing_context(parsed.query): deprecation_warn( "Creating a direct driver (`bolt://` scheme) with " "routing context (URI parameters) is deprecated. They " "will be ignored. This will raise an error in a " 'future release. Given URI "{}"'.format(uri), stack_level=2 ) # TODO: 6.0 - raise instead of warning # raise ValueError( # 'Routing parameters are not supported with scheme ' # '"bolt". Given URI "{}".'.format(uri) # ) return cls.bolt_driver(parsed.netloc, auth=auth, **config) # else driver_type == DRIVER_NEO4J routing_context = parse_routing_context(parsed.query) return cls.neo4j_driver(parsed.netloc, auth=auth, routing_context=routing_context, **config) @classmethod @experimental( "The bookmark manager feature is experimental. " "It might be changed or removed any time even without prior notice." ) def bookmark_manager( cls, initial_bookmarks: t.Optional[t.Mapping[str, t.Union[Bookmarks, t.Iterable[str]]]] = None, bookmarks_supplier: t.Optional[_T_BmSupplier] = None, bookmarks_consumer: t.Optional[_T_BmConsumer] = None ) -> AsyncBookmarkManager: """Create a :class:`.AsyncBookmarkManager` with default implementation. Basic usage example to configure sessions with the built-in bookmark manager implementation so that all work is automatically causally chained (i.e., all reads can observe all previous writes even in a clustered setup):: import neo4j driver = neo4j.AsyncGraphDatabase.driver(...) bookmark_manager = neo4j.AsyncGraphDatabase.bookmark_manager(...) async with driver.session( bookmark_manager=bookmark_manager ) as session1: async with driver.session( bookmark_manager=bookmark_manager, access_mode=neo4j.READ_ACCESS ) as session2: result1 = await session1.run("") await result1.consume() # READ_QUERY is guaranteed to see what WRITE_QUERY wrote. result2 = await session2.run("") await result2.consume() This is a very contrived example, and in this particular case, having both queries in the same session has the exact same effect and might even be more performant. However, when dealing with sessions spanning multiple threads, async Tasks, processes, or even hosts, the bookmark manager can come in handy as sessions are not safe to be used concurrently. :param initial_bookmarks: The initial set of bookmarks. The returned bookmark manager will use this to initialize its internal bookmarks per database. If present, this parameter must be a mapping of database names to :class:`.Bookmarks` or an iterable of raw bookmark values (str). :param bookmarks_supplier: Function which will be called every time the default bookmark manager's method :meth:`.AsyncBookmarkManager.get_bookmarks` or :meth:`.AsyncBookmarkManager.get_all_bookmarks` gets called. The function will be passed the name of the database (``str``) if ``.get_bookmarks`` is called or ``None`` if ``.get_all_bookmarks`` is called. The function must return a :class:`.Bookmarks` object. The result of ``bookmarks_supplier`` will then be concatenated with the internal set of bookmarks and used to configure the session in creation. :param bookmarks_consumer: Function which will be called whenever the set of bookmarks handled by the bookmark manager gets updated with the new internal bookmark set. It will receive the name of the database and the new set of bookmarks. :returns: A default implementation of :class:`AsyncBookmarkManager`. **This is experimental.** (See :ref:`filter-warnings-ref`) It might be changed or removed any time even without prior notice. .. versionadded:: 5.0 """ return AsyncNeo4jBookmarkManager( initial_bookmarks=initial_bookmarks, bookmarks_supplier=bookmarks_supplier, bookmarks_consumer=bookmarks_consumer ) @classmethod def bolt_driver(cls, target, *, auth=None, **config): """ Create a driver for direct Bolt server access that uses socket I/O and thread-based concurrency. """ from .._exceptions import ( BoltHandshakeError, BoltSecurityError, ) try: return AsyncBoltDriver.open(target, auth=auth, **config) except (BoltHandshakeError, BoltSecurityError) as error: from neo4j.exceptions import ServiceUnavailable raise ServiceUnavailable(str(error)) from error @classmethod def neo4j_driver(cls, *targets, auth=None, routing_context=None, **config): """ Create a driver for routing-capable Neo4j service access that uses socket I/O and thread-based concurrency. """ from neo4j._exceptions import ( BoltHandshakeError, BoltSecurityError, ) try: return AsyncNeo4jDriver.open(*targets, auth=auth, routing_context=routing_context, **config) except (BoltHandshakeError, BoltSecurityError) as error: from neo4j.exceptions import ServiceUnavailable raise ServiceUnavailable(str(error)) from error class _Direct: default_host = "localhost" default_port = 7687 default_target = ":" def __init__(self, address): self._address = address @property def address(self): return self._address @classmethod def parse_target(cls, target): """ Parse a target string to produce an address. """ if not target: target = cls.default_target address = Address.parse(target, default_host=cls.default_host, default_port=cls.default_port) return address class _Routing: default_host = "localhost" default_port = 7687 default_targets = ": :17601 :17687" def __init__(self, initial_addresses): self._initial_addresses = initial_addresses @property def initial_addresses(self): return self._initial_addresses @classmethod def parse_targets(cls, *targets): """ Parse a sequence of target strings to produce an address list. """ targets = " ".join(targets) if not targets: targets = cls.default_targets addresses = Address.parse_list(targets, default_host=cls.default_host, default_port=cls.default_port) return addresses class AsyncDriver: """ Base class for all types of :class:`neo4j.AsyncDriver`, instances of which are used as the primary access point to Neo4j. """ #: Connection pool _pool: t.Any = None #: Flag if the driver has been closed _closed = False def __init__(self, pool, default_workspace_config): assert pool is not None assert default_workspace_config is not None self._pool = pool self._default_workspace_config = default_workspace_config async def __aenter__(self) -> AsyncDriver: return self async def __aexit__(self, exc_type, exc_value, traceback): await self.close() def __del__(self): if not self._closed: unclosed_resource_warn(self) # TODO: 6.0 - remove this if not self._closed: if not AsyncUtil.is_async_code: deprecation_warn( "Relying on AsyncDriver's destructor to close the session " "is deprecated. Please make sure to close the session. " "Use it as a context (`with` statement) or make sure to " "call `.close()` explicitly. Future versions of the " "driver will not close drivers automatically." ) self.close() @property def encrypted(self) -> bool: """Indicate whether the driver was configured to use encryption.""" return bool(self._pool.pool_config.encrypted) if t.TYPE_CHECKING: def session( self, connection_acquisition_timeout: float = ..., max_transaction_retry_time: float = ..., database: t.Optional[str] = ..., fetch_size: int = ..., impersonated_user: t.Optional[str] = ..., bookmarks: t.Union[t.Iterable[str], Bookmarks, None] = ..., default_access_mode: str = ..., bookmark_manager: t.Union[AsyncBookmarkManager, BookmarkManager, None] = ..., # undocumented/unsupported options # they may be change or removed any time without prior notice initial_retry_delay: float = ..., retry_delay_multiplier: float = ..., retry_delay_jitter_factor: float = ... ) -> AsyncSession: ... else: def session(self, **config) -> AsyncSession: """Create a session, see :ref:`async-session-construction-ref` :param config: session configuration key-word arguments, see :ref:`async-session-configuration-ref` for available key-word arguments. :returns: new :class:`neo4j.AsyncSession` object """ raise NotImplementedError async def close(self) -> None: """ Shut down, closing any open connections in the pool. """ await self._pool.close() self._closed = True if t.TYPE_CHECKING: async def verify_connectivity( self, # all arguments are experimental # they may be change or removed any time without prior notice session_connection_timeout: float = ..., connection_acquisition_timeout: float = ..., max_transaction_retry_time: float = ..., database: t.Optional[str] = ..., fetch_size: int = ..., impersonated_user: t.Optional[str] = ..., bookmarks: t.Union[t.Iterable[str], Bookmarks, None] = ..., default_access_mode: str = ..., bookmark_manager: t.Union[AsyncBookmarkManager, BookmarkManager, None] = ..., # undocumented/unsupported options initial_retry_delay: float = ..., retry_delay_multiplier: float = ..., retry_delay_jitter_factor: float = ... ) -> None: ... else: # TODO: 6.0 - remove config argument async def verify_connectivity(self, **config) -> None: """Verify that the driver can establish a connection to the server. This verifies if the driver can establish a reading connection to a remote server or a cluster. Some data will be exchanged. .. note:: Even if this method raises an exception, the driver still needs to be closed via :meth:`close` to free up all resources. :param config: accepts the same configuration key-word arguments as :meth:`session`. .. warning:: All configuration key-word arguments are experimental. They might be changed or removed in any future version without prior notice. :raises DriverError: if the driver cannot connect to the remote. Use the exception to further understand the cause of the connectivity problem. .. versionchanged:: 5.0 The undocumented return value has been removed. If you need information about the remote server, use :meth:`get_server_info` instead. """ if config: experimental_warn( "All configuration key-word arguments to " "verify_connectivity() are experimental. They might be " "changed or removed in any future version without prior " "notice." ) async with self.session(**config) as session: await session._get_server_info() if t.TYPE_CHECKING: async def get_server_info( self, # all arguments are experimental # they may be change or removed any time without prior notice session_connection_timeout: float = ..., connection_acquisition_timeout: float = ..., max_transaction_retry_time: float = ..., database: t.Optional[str] = ..., fetch_size: int = ..., impersonated_user: t.Optional[str] = ..., bookmarks: t.Union[t.Iterable[str], Bookmarks, None] = ..., default_access_mode: str = ..., bookmark_manager: t.Union[AsyncBookmarkManager, BookmarkManager, None] = ..., # undocumented/unsupported options initial_retry_delay: float = ..., retry_delay_multiplier: float = ..., retry_delay_jitter_factor: float = ... ) -> ServerInfo: ... else: async def get_server_info(self, **config) -> ServerInfo: """Get information about the connected Neo4j server. Try to establish a working read connection to the remote server or a member of a cluster and exchange some data. Then return the contacted server's information. In a cluster, there is no guarantee about which server will be contacted. .. note:: Even if this method raises an exception, the driver still needs to be closed via :meth:`close` to free up all resources. :param config: accepts the same configuration key-word arguments as :meth:`session`. .. warning:: All configuration key-word arguments are experimental. They might be changed or removed in any future version without prior notice. :raises DriverError: if the driver cannot connect to the remote. Use the exception to further understand the cause of the connectivity problem. .. versionadded:: 5.0 """ if config: experimental_warn( "All configuration key-word arguments to " "verify_connectivity() are experimental. They might be " "changed or removed in any future version without prior " "notice." ) async with self.session(**config) as session: return await session._get_server_info() @experimental("Feature support query, based on Bolt protocol version and Neo4j server version will change in the future.") async def supports_multi_db(self) -> bool: """ Check if the server or cluster supports multi-databases. :return: Returns true if the server or cluster the driver connects to supports multi-databases, otherwise false. .. note:: Feature support query, based on Bolt Protocol Version and Neo4j server version will change in the future. """ async with self.session() as session: await session._connect(READ_ACCESS) assert session._connection return session._connection.supports_multiple_databases class AsyncBoltDriver(_Direct, AsyncDriver): """:class:`.AsyncBoltDriver` is instantiated for ``bolt`` URIs and addresses a single database machine. This may be a standalone server or could be a specific member of a cluster. Connections established by a :class:`.AsyncBoltDriver` are always made to the exact host and port detailed in the URI. This class is not supposed to be instantiated externally. Use :meth:`AsyncGraphDatabase.driver` instead. """ @classmethod def open(cls, target, *, auth=None, **config): """ :param target: :param auth: :param config: The values that can be specified are found in :class: `neo4j.PoolConfig` and :class: `neo4j.WorkspaceConfig` :return: :rtype: :class: `neo4j.BoltDriver` """ from .io import AsyncBoltPool address = cls.parse_target(target) pool_config, default_workspace_config = Config.consume_chain(config, PoolConfig, WorkspaceConfig) pool = AsyncBoltPool.open(address, auth=auth, pool_config=pool_config, workspace_config=default_workspace_config) return cls(pool, default_workspace_config) def __init__(self, pool, default_workspace_config): _Direct.__init__(self, pool.address) AsyncDriver.__init__(self, pool, default_workspace_config) self._default_workspace_config = default_workspace_config if not t.TYPE_CHECKING: def session(self, **config) -> AsyncSession: """ :param config: The values that can be specified are found in :class: `neo4j.SessionConfig` :return: :rtype: :class: `neo4j.AsyncSession` """ session_config = SessionConfig(self._default_workspace_config, config) return AsyncSession(self._pool, session_config) class AsyncNeo4jDriver(_Routing, AsyncDriver): """:class:`.AsyncNeo4jDriver` is instantiated for ``neo4j`` URIs. The routing behaviour works in tandem with Neo4j's `Causal Clustering `_ feature by directing read and write behaviour to appropriate cluster members. This class is not supposed to be instantiated externally. Use :meth:`AsyncGraphDatabase.driver` instead. """ @classmethod def open(cls, *targets, auth=None, routing_context=None, **config): from .io import AsyncNeo4jPool addresses = cls.parse_targets(*targets) pool_config, default_workspace_config = Config.consume_chain(config, PoolConfig, WorkspaceConfig) pool = AsyncNeo4jPool.open(*addresses, auth=auth, routing_context=routing_context, pool_config=pool_config, workspace_config=default_workspace_config) return cls(pool, default_workspace_config) def __init__(self, pool, default_workspace_config): _Routing.__init__(self, [pool.address]) AsyncDriver.__init__(self, pool, default_workspace_config) if not t.TYPE_CHECKING: def session(self, **config) -> AsyncSession: session_config = SessionConfig(self._default_workspace_config, config) return AsyncSession(self._pool, session_config) neo4j-python-driver-5.2.1/neo4j/_async/io/000077500000000000000000000000001433522662700202625ustar00rootroot00000000000000neo4j-python-driver-5.2.1/neo4j/_async/io/__init__.py000066400000000000000000000022401433522662700223710ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. """ This module contains the low-level functionality required for speaking Bolt. It is not intended to be used directly by driver users. Instead, the `session` module provides the main user-facing abstractions. """ __all__ = [ "AsyncBolt", "AsyncBoltPool", "AsyncNeo4jPool", "check_supported_server_product", "ConnectionErrorHandler", ] from ._bolt import AsyncBolt from ._common import ( check_supported_server_product, ConnectionErrorHandler, ) from ._pool import ( AsyncBoltPool, AsyncNeo4jPool, ) neo4j-python-driver-5.2.1/neo4j/_async/io/_bolt.py000066400000000000000000000737751433522662700217560ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations import abc import asyncio import socket from collections import deque from logging import getLogger from time import perf_counter from ..._async_compat.network import AsyncBoltSocket from ..._codec.hydration import v1 as hydration_v1 from ..._codec.packstream import v1 as packstream_v1 from ..._conf import PoolConfig from ..._exceptions import ( BoltError, BoltHandshakeError, ) from ..._meta import get_user_agent from ...addressing import Address from ...api import ( ServerInfo, Version, ) from ...exceptions import ( AuthError, DriverError, IncompleteCommit, ServiceUnavailable, SessionExpired, ) from ._common import ( AsyncInbox, AsyncOutbox, CommitResponse, ) # Set up logger log = getLogger("neo4j") class AsyncBolt: """ Server connection for Bolt protocol. A :class:`.Bolt` should be constructed following a successful .open() Bolt handshake and takes the socket over which the handshake was carried out. """ # TODO: let packer/unpacker know of hydration (give them hooks?) # TODO: make sure query parameter dehydration gets clear error message. PACKER_CLS = packstream_v1.Packer UNPACKER_CLS = packstream_v1.Unpacker HYDRATION_HANDLER_CLS = hydration_v1.HydrationHandler MAGIC_PREAMBLE = b"\x60\x60\xB0\x17" PROTOCOL_VERSION: Version = None # type: ignore[assignment] # flag if connection needs RESET to go back to READY state is_reset = False # The socket in_use = False # When the connection was last put back into the pool idle_since = float("-inf") # The socket _closing = False _closed = False # The socket _defunct = False #: The pool of which this connection is a member pool = None # Store the id of the most recent ran query to be able to reduce sent bits by # using the default (-1) to refer to the most recent query when pulling # results for it. most_recent_qid = None def __init__(self, unresolved_address, sock, max_connection_lifetime, *, auth=None, user_agent=None, routing_context=None): self.unresolved_address = unresolved_address self.socket = sock self.local_port = self.socket.getsockname()[1] self.server_info = ServerInfo(Address(sock.getpeername()), self.PROTOCOL_VERSION) # so far `connection.recv_timeout_seconds` is the only available # configuration hint that exists. Therefore, all hints can be stored at # connection level. This might change in the future. self.configuration_hints = {} self.patch = {} self.outbox = AsyncOutbox( self.socket, on_error=self._set_defunct_write, packer_cls=self.PACKER_CLS ) self.inbox = AsyncInbox( self.socket, on_error=self._set_defunct_read, unpacker_cls=self.UNPACKER_CLS ) self.hydration_handler = self.HYDRATION_HANDLER_CLS() self.responses = deque() self._max_connection_lifetime = max_connection_lifetime self._creation_timestamp = perf_counter() self.routing_context = routing_context self.idle_since = perf_counter() # Determine the user agent if user_agent: self.user_agent = user_agent else: self.user_agent = get_user_agent() # Determine auth details if not auth: self.auth_dict = {} elif isinstance(auth, tuple) and 2 <= len(auth) <= 3: from neo4j import Auth self.auth_dict = vars(Auth("basic", *auth)) else: try: self.auth_dict = vars(auth) except (KeyError, TypeError): raise AuthError("Cannot determine auth details from %r" % auth) # Check for missing password try: credentials = self.auth_dict["credentials"] except KeyError: pass else: if credentials is None: raise AuthError("Password cannot be None") def __del__(self): if not asyncio.iscoroutinefunction(self.close): self.close() @property def connection_id(self): return self.server_info._metadata.get("connection_id", "") @property @abc.abstractmethod def supports_multiple_results(self): """ Boolean flag to indicate if the connection version supports multiple queries to be buffered on the server side (True) or if all results need to be eagerly pulled before sending the next RUN (False). """ pass @property @abc.abstractmethod def supports_multiple_databases(self): """ Boolean flag to indicate if the connection version supports multiple databases. """ pass @classmethod def protocol_handlers(cls, protocol_version=None): """ Return a dictionary of available Bolt protocol handlers, keyed by version tuple. If an explicit protocol version is provided, the dictionary will contain either zero or one items, depending on whether that version is supported. If no protocol version is provided, all available versions will be returned. :param protocol_version: tuple identifying a specific protocol version (e.g. (3, 5)) or None :return: dictionary of version tuple to handler class for all relevant and supported protocol versions :raise TypeError: if protocol version is not passed in a tuple """ # Carry out Bolt subclass imports locally to avoid circular dependency issues. from ._bolt3 import AsyncBolt3 from ._bolt4 import ( AsyncBolt4x1, AsyncBolt4x2, AsyncBolt4x3, AsyncBolt4x4, ) from ._bolt5 import AsyncBolt5x0 handlers = { AsyncBolt3.PROTOCOL_VERSION: AsyncBolt3, # 4.0 unsupported because no space left in the handshake AsyncBolt4x1.PROTOCOL_VERSION: AsyncBolt4x1, AsyncBolt4x2.PROTOCOL_VERSION: AsyncBolt4x2, AsyncBolt4x3.PROTOCOL_VERSION: AsyncBolt4x3, AsyncBolt4x4.PROTOCOL_VERSION: AsyncBolt4x4, AsyncBolt5x0.PROTOCOL_VERSION: AsyncBolt5x0, } if protocol_version is None: return handlers if not isinstance(protocol_version, tuple): raise TypeError("Protocol version must be specified as a tuple") if protocol_version in handlers: return {protocol_version: handlers[protocol_version]} return {} @classmethod def version_list(cls, versions, limit=4): """ Return a list of supported protocol versions in order of preference. The number of protocol versions (or ranges) returned is limited to four. """ # In fact, 4.3 is the fist version to support ranges. However, the # range support got backported to 4.2. But even if the server is too # old to have the backport, negotiating BOLT 4.1 is no problem as it's # equivalent to 4.2 first_with_range_support = Version(4, 2) result = [] for version in versions: if (result and version >= first_with_range_support and result[-1][0] == version[0] and result[-1][1][1] == version[1] + 1): # can use range to encompass this version result[-1][1][1] = version[1] continue result.append(Version(version[0], [version[1], version[1]])) if len(result) == 4: break return result @classmethod def get_handshake(cls): """ Return the supported Bolt versions as bytes. The length is 16 bytes as specified in the Bolt version negotiation. :return: bytes """ supported_versions = sorted(cls.protocol_handlers().keys(), reverse=True) offered_versions = cls.version_list(supported_versions) return b"".join(version.to_bytes() for version in offered_versions).ljust(16, b"\x00") @classmethod async def ping(cls, address, *, timeout=None, pool_config=None): """ Attempt to establish a Bolt connection, returning the agreed Bolt protocol version if successful. """ if pool_config is None: pool_config = PoolConfig() try: s, protocol_version, handshake, data = \ await AsyncBoltSocket.connect( address, timeout=timeout, custom_resolver=pool_config.resolver, ssl_context=pool_config.get_ssl_context(), keep_alive=pool_config.keep_alive, ) except (ServiceUnavailable, SessionExpired, BoltHandshakeError): return None else: await AsyncBoltSocket.close_socket(s) return protocol_version @classmethod async def open( cls, address, *, auth=None, timeout=None, routing_context=None, pool_config=None ): """Open a new Bolt connection to a given server address. :param address: :param auth: :param timeout: the connection timeout in seconds :param routing_context: dict containing routing context :param pool_config: :return: connected AsyncBolt instance :raise BoltHandshakeError: raised if the Bolt Protocol can not negotiate a protocol version. :raise ServiceUnavailable: raised if there was a connection issue. """ def time_remaining(): if timeout is None: return None t = timeout - (perf_counter() - t0) return t if t > 0 else 0 t0 = perf_counter() if pool_config is None: pool_config = PoolConfig() socket_connection_timeout = pool_config.connection_timeout if socket_connection_timeout is None: socket_connection_timeout = time_remaining() elif timeout is not None: socket_connection_timeout = min(pool_config.connection_timeout, time_remaining()) s, pool_config.protocol_version, handshake, data = \ await AsyncBoltSocket.connect( address, timeout=socket_connection_timeout, custom_resolver=pool_config.resolver, ssl_context=pool_config.get_ssl_context(), keep_alive=pool_config.keep_alive, ) # Carry out Bolt subclass imports locally to avoid circular dependency # issues. if pool_config.protocol_version == (3, 0): from ._bolt3 import AsyncBolt3 bolt_cls = AsyncBolt3 # Implementation for 4.0 exists, but there was no space left in the # handshake to offer this version to the server. Hence, the server # should never request us to speak bolt 4.0. # elif pool_config.protocol_version == (4, 0): # from ._bolt4 import AsyncBolt4x0 # bolt_cls = AsyncBolt4x0 elif pool_config.protocol_version == (4, 1): from ._bolt4 import AsyncBolt4x1 bolt_cls = AsyncBolt4x1 elif pool_config.protocol_version == (4, 2): from ._bolt4 import AsyncBolt4x2 bolt_cls = AsyncBolt4x2 elif pool_config.protocol_version == (4, 3): from ._bolt4 import AsyncBolt4x3 bolt_cls = AsyncBolt4x3 elif pool_config.protocol_version == (4, 4): from ._bolt4 import AsyncBolt4x4 bolt_cls = AsyncBolt4x4 elif pool_config.protocol_version == (5, 0): from ._bolt5 import AsyncBolt5x0 bolt_cls = AsyncBolt5x0 else: log.debug("[#%04X] S: ", s.getsockname()[1]) await AsyncBoltSocket.close_socket(s) supported_versions = cls.protocol_handlers().keys() raise BoltHandshakeError( "The Neo4J server does not support communication with this " "driver. This driver has support for Bolt protocols " "{}".format(tuple(map(str, supported_versions))), address=address, request_data=handshake, response_data=data ) connection = bolt_cls( address, s, pool_config.max_connection_lifetime, auth=auth, user_agent=pool_config.user_agent, routing_context=routing_context ) try: connection.socket.set_deadline(time_remaining()) try: await connection.hello() finally: connection.socket.set_deadline(None) except ( Exception, # Python 3.8+: CancelledError is a subclass of BaseException asyncio.CancelledError, ) as e: log.debug("[#%04X] C: %r", connection.local_port, e) connection.kill() raise return connection @property @abc.abstractmethod def encrypted(self): pass @property @abc.abstractmethod def der_encoded_server_certificate(self): pass @abc.abstractmethod async def hello(self, dehydration_hooks=None, hydration_hooks=None): """ Appends a HELLO message to the outgoing queue, sends it and consumes all remaining messages. """ pass @abc.abstractmethod async def route( self, database=None, imp_user=None, bookmarks=None, dehydration_hooks=None, hydration_hooks=None ): """ Fetch a routing table from the server for the given `database`. For Bolt 4.3 and above, this appends a ROUTE message; for earlier versions, a procedure call is made via the regular Cypher execution mechanism. In all cases, this is sent to the network, and a response is fetched. :param database: database for which to fetch a routing table Requires Bolt 4.0+. :param imp_user: the user to impersonate Requires Bolt 4.4+. :param bookmarks: iterable of bookmark values after which this transaction should begin :param dehydration_hooks: Hooks to dehydrate types (dict from type (class) to dehydration function). Dehydration functions receive the value and returns an object of type understood by packstream. :param hydration_hooks: Hooks to hydrate types (mapping from type (class) to dehydration function). Dehydration functions receive the value of type understood by packstream and are free to return anything. """ pass @abc.abstractmethod def run(self, query, parameters=None, mode=None, bookmarks=None, metadata=None, timeout=None, db=None, imp_user=None, dehydration_hooks=None, hydration_hooks=None, **handlers): """ Appends a RUN message to the output queue. :param query: Cypher query string :param parameters: dictionary of Cypher parameters :param mode: access mode for routing - "READ" or "WRITE" (default) :param bookmarks: iterable of bookmark values after which this transaction should begin :param metadata: custom metadata dictionary to attach to the transaction :param timeout: timeout for transaction execution (seconds) :param db: name of the database against which to begin the transaction Requires Bolt 4.0+. :param imp_user: the user to impersonate Requires Bolt 4.4+. :param dehydration_hooks: Hooks to dehydrate types (dict from type (class) to dehydration function). Dehydration functions receive the value and returns an object of type understood by packstream. :param hydration_hooks: Hooks to hydrate types (mapping from type (class) to dehydration function). Dehydration functions receive the value of type understood by packstream and are free to return anything. :param handlers: handler functions passed into the returned Response object """ pass @abc.abstractmethod def discard(self, n=-1, qid=-1, dehydration_hooks=None, hydration_hooks=None, **handlers): """ Appends a DISCARD message to the output queue. :param n: number of records to discard, default = -1 (ALL) :param qid: query ID to discard for, default = -1 (last query) :param dehydration_hooks: Hooks to dehydrate types (dict from type (class) to dehydration function). Dehydration functions receive the value and returns an object of type understood by packstream. :param hydration_hooks: Hooks to hydrate types (mapping from type (class) to dehydration function). Dehydration functions receive the value of type understood by packstream and are free to return anything. :param handlers: handler functions passed into the returned Response object """ pass @abc.abstractmethod def pull(self, n=-1, qid=-1, dehydration_hooks=None, hydration_hooks=None, **handlers): """ Appends a PULL message to the output queue. :param n: number of records to pull, default = -1 (ALL) :param qid: query ID to pull for, default = -1 (last query) :param dehydration_hooks: Hooks to dehydrate types (dict from type (class) to dehydration function). Dehydration functions receive the value and returns an object of type understood by packstream. :param hydration_hooks: Hooks to hydrate types (mapping from type (class) to dehydration function). Dehydration functions receive the value of type understood by packstream and are free to return anything. :param handlers: handler functions passed into the returned Response object """ pass @abc.abstractmethod def begin(self, mode=None, bookmarks=None, metadata=None, timeout=None, db=None, imp_user=None, dehydration_hooks=None, hydration_hooks=None, **handlers): """ Appends a BEGIN message to the output queue. :param mode: access mode for routing - "READ" or "WRITE" (default) :param bookmarks: iterable of bookmark values after which this transaction should begin :param metadata: custom metadata dictionary to attach to the transaction :param timeout: timeout for transaction execution (seconds) :param db: name of the database against which to begin the transaction Requires Bolt 4.0+. :param imp_user: the user to impersonate Requires Bolt 4.4+ :param dehydration_hooks: Hooks to dehydrate types (dict from type (class) to dehydration function). Dehydration functions receive the value and returns an object of type understood by packstream. :param hydration_hooks: Hooks to hydrate types (mapping from type (class) to dehydration function). Dehydration functions receive the value of type understood by packstream and are free to return anything. :param handlers: handler functions passed into the returned Response object :return: Response object """ pass @abc.abstractmethod def commit(self, dehydration_hooks=None, hydration_hooks=None, **handlers): """ Appends a COMMIT message to the output queue. :param dehydration_hooks: Hooks to dehydrate types (dict from type (class) to dehydration function). Dehydration functions receive the value and returns an object of type understood by packstream. :param hydration_hooks: Hooks to hydrate types (mapping from type (class) to dehydration function). Dehydration functions receive the value of type understood by packstream and are free to return anything. """ pass @abc.abstractmethod def rollback(self, dehydration_hooks=None, hydration_hooks=None, **handlers): """ Appends a ROLLBACK message to the output queue. :param dehydration_hooks: Hooks to dehydrate types (dict from type (class) to dehydration function). Dehydration functions receive the value and returns an object of type understood by packstream. :param hydration_hooks: Hooks to hydrate types (mapping from type (class) to dehydration function). Dehydration functions receive the value of type understood by packstream and are free to return anything.""" pass @abc.abstractmethod async def reset(self, dehydration_hooks=None, hydration_hooks=None): """ Appends a RESET message to the outgoing queue, sends it and consumes all remaining messages. :param dehydration_hooks: Hooks to dehydrate types (dict from type (class) to dehydration function). Dehydration functions receive the value and returns an object of type understood by packstream. :param hydration_hooks: Hooks to hydrate types (mapping from type (class) to dehydration function). Dehydration functions receive the value of type understood by packstream and are free to return anything. """ pass @abc.abstractmethod def goodbye(self, dehydration_hooks=None, hydration_hooks=None): """Append a GOODBYE message to the outgoing queue. :param dehydration_hooks: Hooks to dehydrate types (dict from type (class) to dehydration function). Dehydration functions receive the value and returns an object of type understood by packstream. :param hydration_hooks: Hooks to hydrate types (mapping from type (class) to dehydration function). Dehydration functions receive the value of type understood by packstream and are free to return anything. """ pass def new_hydration_scope(self): return self.hydration_handler.new_hydration_scope() def _append(self, signature, fields=(), response=None, dehydration_hooks=None): """ Appends a message to the outgoing queue. :param signature: the signature of the message :param fields: the fields of the message as a tuple :param response: a response object to handle callbacks :param dehydration_hooks: Hooks to dehydrate types (dict from type (class) to dehydration function). Dehydration functions receive the value and returns an object of type understood by packstream. """ self.outbox.append_message(signature, fields, dehydration_hooks) self.responses.append(response) async def _send_all(self): if await self.outbox.flush(): self.idle_since = perf_counter() async def send_all(self): """ Send all queued messages to the server. """ if self.closed(): raise ServiceUnavailable( "Failed to write to closed connection {!r} ({!r})".format( self.unresolved_address, self.server_info.address ) ) if self.defunct(): raise ServiceUnavailable( "Failed to write to defunct connection {!r} ({!r})".format( self.unresolved_address, self.server_info.address ) ) await self._send_all() @abc.abstractmethod async def _process_message(self, tag, fields): """ Receive at most one message from the server, if available. :return: 2-tuple of number of detail messages and number of summary messages fetched """ pass async def fetch_message(self): if self._closed: raise ServiceUnavailable( "Failed to read from closed connection {!r} ({!r})".format( self.unresolved_address, self.server_info.address ) ) if self._defunct: raise ServiceUnavailable( "Failed to read from defunct connection {!r} ({!r})".format( self.unresolved_address, self.server_info.address ) ) if not self.responses: return 0, 0 # Receive exactly one message tag, fields = await self.inbox.pop( hydration_hooks=self.responses[0].hydration_hooks ) res = await self._process_message(tag, fields) self.idle_since = perf_counter() return res async def fetch_all(self): """ Fetch all outstanding messages. :return: 2-tuple of number of detail messages and number of summary messages fetched """ detail_count = summary_count = 0 while self.responses: response = self.responses[0] while not response.complete: detail_delta, summary_delta = await self.fetch_message() detail_count += detail_delta summary_count += summary_delta return detail_count, summary_count async def _set_defunct_read(self, error=None, silent=False): message = "Failed to read from defunct connection {!r} ({!r})".format( self.unresolved_address, self.server_info.address ) await self._set_defunct(message, error=error, silent=silent) async def _set_defunct_write(self, error=None, silent=False): message = "Failed to write data to connection {!r} ({!r})".format( self.unresolved_address, self.server_info.address ) await self._set_defunct(message, error=error, silent=silent) async def _set_defunct(self, message, error=None, silent=False): from ._pool import AsyncBoltPool direct_driver = isinstance(self.pool, AsyncBoltPool) user_cancelled = isinstance(error, asyncio.CancelledError) if error: log.debug("[#%04X] _: error: %r", self.local_port, error) if not user_cancelled: log.error(message) # We were attempting to receive data but the connection # has unexpectedly terminated. So, we need to close the # connection from the client side, and remove the address # from the connection pool. self._defunct = True if user_cancelled: self.kill() raise error # cancellation error should not be re-written if not self._closing: # If we fail while closing the connection, there is no need to # remove the connection from the pool, nor to try to close the # connection again. await self.close() if self.pool: await self.pool.deactivate(address=self.unresolved_address) # Iterate through the outstanding responses, and if any correspond # to COMMIT requests then raise an error to signal that we are # unable to confirm that the COMMIT completed successfully. if silent: return for response in self.responses: if isinstance(response, CommitResponse): if error: raise IncompleteCommit(message) from error else: raise IncompleteCommit(message) if direct_driver: if error: raise ServiceUnavailable(message) from error else: raise ServiceUnavailable(message) else: if error: raise SessionExpired(message) from error else: raise SessionExpired(message) def stale(self): return (self._stale or (0 <= self._max_connection_lifetime <= perf_counter() - self._creation_timestamp)) _stale = False def set_stale(self): self._stale = True async def close(self): """Close the connection.""" if self._closed or self._closing: return self._closing = True if not self._defunct: self.goodbye() try: await self._send_all() except (OSError, BoltError, DriverError) as exc: log.debug("[#%04X] _: ignoring failed close %r", self.local_port, exc) log.debug("[#%04X] C: ", self.local_port) try: await self.socket.close() except OSError: pass finally: self._closed = True def kill(self): """Close the socket most violently. No flush, no goodbye, no mercy.""" if self._closed: return log.debug("[#%04X] C: ", self.local_port) self._closing = True try: self.socket.kill() except OSError as exc: log.debug("[#%04X] _: ignoring failed kill %r", self.local_port, exc) finally: self._closed = True def closed(self): return self._closed def defunct(self): return self._defunct def is_idle_for(self, timeout): """Check if connection has been idle for at least the given timeout. :param timeout: timeout in seconds :type timeout: float :rtype: bool """ return perf_counter() - self.idle_since > timeout AsyncBoltSocket.Bolt = AsyncBolt # type: ignore neo4j-python-driver-5.2.1/neo4j/_async/io/_bolt3.py000066400000000000000000000356711433522662700220320ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 enum import Enum from logging import getLogger from ssl import SSLSocket from ..._exceptions import BoltProtocolError from ...api import ( READ_ACCESS, Version, ) from ...exceptions import ( ConfigurationError, DatabaseUnavailable, ForbiddenOnReadOnlyDatabase, Neo4jError, NotALeader, ServiceUnavailable, ) from ._bolt import AsyncBolt from ._common import ( check_supported_server_product, CommitResponse, InitResponse, Response, ) log = getLogger("neo4j") class ServerStates(Enum): CONNECTED = "CONNECTED" READY = "READY" STREAMING = "STREAMING" TX_READY_OR_TX_STREAMING = "TX_READY||TX_STREAMING" FAILED = "FAILED" class ServerStateManager: _STATE_TRANSITIONS = { ServerStates.CONNECTED: { "hello": ServerStates.READY, }, ServerStates.READY: { "run": ServerStates.STREAMING, "begin": ServerStates.TX_READY_OR_TX_STREAMING, }, ServerStates.STREAMING: { "pull": ServerStates.READY, "discard": ServerStates.READY, "reset": ServerStates.READY, }, ServerStates.TX_READY_OR_TX_STREAMING: { "commit": ServerStates.READY, "rollback": ServerStates.READY, "reset": ServerStates.READY, }, ServerStates.FAILED: { "reset": ServerStates.READY, } } def __init__(self, init_state, on_change=None): self.state = init_state self._on_change = on_change def transition(self, message, metadata): if metadata.get("has_more"): return state_before = self.state self.state = self._STATE_TRANSITIONS\ .get(self.state, {})\ .get(message, self.state) if state_before != self.state and callable(self._on_change): self._on_change(state_before, self.state) class AsyncBolt3(AsyncBolt): """ Protocol handler for Bolt 3. This is supported by Neo4j versions 3.5, 4.0, 4.1, 4.2, 4.3, and 4.4. """ PROTOCOL_VERSION = Version(3, 0) supports_multiple_results = False supports_multiple_databases = False def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self._server_state_manager = ServerStateManager( ServerStates.CONNECTED, on_change=self._on_server_state_change ) def _on_server_state_change(self, old_state, new_state): log.debug("[#%04X] _: state: %s > %s", self.local_port, old_state.name, new_state.name) @property def is_reset(self): # We can't be sure of the server's state if there are still pending # responses. Unless the last message we sent was RESET. In that case # the server state will always be READY when we're done. if (self.responses and self.responses[-1] and self.responses[-1].message == "reset"): return True return self._server_state_manager.state == ServerStates.READY @property def encrypted(self): return isinstance(self.socket, SSLSocket) @property def der_encoded_server_certificate(self): return self.socket.getpeercert(binary_form=True) def get_base_headers(self): return { "user_agent": self.user_agent, } async def hello(self, dehydration_hooks=None, hydration_hooks=None): headers = self.get_base_headers() headers.update(self.auth_dict) logged_headers = dict(headers) if "credentials" in logged_headers: logged_headers["credentials"] = "*******" log.debug("[#%04X] C: HELLO %r", self.local_port, logged_headers) self._append(b"\x01", (headers,), response=InitResponse(self, "hello", hydration_hooks, on_success=self.server_info.update), dehydration_hooks=dehydration_hooks) await self.send_all() await self.fetch_all() check_supported_server_product(self.server_info.agent) async def route( self, database=None, imp_user=None, bookmarks=None, dehydration_hooks=None, hydration_hooks=None ): if database is not None: raise ConfigurationError( "Database name parameter for selecting database is not " "supported in Bolt Protocol {!r}. Database name {!r}. " "Server Agent {!r}".format( self.PROTOCOL_VERSION, database, self.server_info.agent ) ) if imp_user is not None: raise ConfigurationError( "Impersonation is not supported in Bolt Protocol {!r}. " "Trying to impersonate {!r}.".format( self.PROTOCOL_VERSION, imp_user ) ) metadata = {} records = [] # Ignoring database and bookmarks because there is no multi-db support. # The bookmarks are only relevant for making sure a previously created # db exists before querying a routing table for it. self.run( "CALL dbms.cluster.routing.getRoutingTable($context)", # This is an internal procedure call. Only available if the Neo4j 3.5 is setup with clustering. {"context": self.routing_context}, mode="r", # Bolt Protocol Version(3, 0) supports mode="r" dehydration_hooks=dehydration_hooks, hydration_hooks=hydration_hooks, on_success=metadata.update ) self.pull(dehydration_hooks = None, hydration_hooks = None, on_success=metadata.update, on_records=records.extend) await self.send_all() await self.fetch_all() routing_info = [dict(zip(metadata.get("fields", ()), values)) for values in records] return routing_info def run(self, query, parameters=None, mode=None, bookmarks=None, metadata=None, timeout=None, db=None, imp_user=None, dehydration_hooks=None, hydration_hooks=None, **handlers): if db is not None: raise ConfigurationError( "Database name parameter for selecting database is not " "supported in Bolt Protocol {!r}. Database name {!r}.".format( self.PROTOCOL_VERSION, db ) ) if imp_user is not None: raise ConfigurationError( "Impersonation is not supported in Bolt Protocol {!r}. " "Trying to impersonate {!r}.".format( self.PROTOCOL_VERSION, imp_user ) ) if not parameters: parameters = {} extra = {} if mode in (READ_ACCESS, "r"): extra["mode"] = "r" # It will default to mode "w" if nothing is specified if bookmarks: try: extra["bookmarks"] = list(bookmarks) except TypeError: raise TypeError("Bookmarks must be provided within an iterable") if metadata: try: extra["tx_metadata"] = dict(metadata) except TypeError: raise TypeError("Metadata must be coercible to a dict") if timeout is not None: try: extra["tx_timeout"] = int(1000 * float(timeout)) except TypeError: raise TypeError("Timeout must be specified as a number of seconds") if extra["tx_timeout"] < 0: raise ValueError("Timeout must be a positive number or 0.") fields = (query, parameters, extra) log.debug("[#%04X] C: RUN %s", self.local_port, " ".join(map(repr, fields))) self._append(b"\x10", fields, Response(self, "run", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) def discard(self, n=-1, qid=-1, dehydration_hooks=None, hydration_hooks=None, **handlers): # Just ignore n and qid, it is not supported in the Bolt 3 Protocol. log.debug("[#%04X] C: DISCARD_ALL", self.local_port) self._append(b"\x2F", (), Response(self, "discard", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) def pull(self, n=-1, qid=-1, dehydration_hooks=None, hydration_hooks=None, **handlers): # Just ignore n and qid, it is not supported in the Bolt 3 Protocol. log.debug("[#%04X] C: PULL_ALL", self.local_port) self._append(b"\x3F", (), Response(self, "pull", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) def begin(self, mode=None, bookmarks=None, metadata=None, timeout=None, db=None, imp_user=None, dehydration_hooks=None, hydration_hooks=None, **handlers): if db is not None: raise ConfigurationError( "Database name parameter for selecting database is not " "supported in Bolt Protocol {!r}. Database name {!r}.".format( self.PROTOCOL_VERSION, db ) ) if imp_user is not None: raise ConfigurationError( "Impersonation is not supported in Bolt Protocol {!r}. " "Trying to impersonate {!r}.".format( self.PROTOCOL_VERSION, imp_user ) ) extra = {} if mode in (READ_ACCESS, "r"): extra["mode"] = "r" # It will default to mode "w" if nothing is specified if bookmarks: try: extra["bookmarks"] = list(bookmarks) except TypeError: raise TypeError("Bookmarks must be provided within an iterable") if metadata: try: extra["tx_metadata"] = dict(metadata) except TypeError: raise TypeError("Metadata must be coercible to a dict") if timeout is not None: try: extra["tx_timeout"] = int(1000 * float(timeout)) except TypeError: raise TypeError("Timeout must be specified as a number of seconds") if extra["tx_timeout"] < 0: raise ValueError("Timeout must be a positive number or 0.") log.debug("[#%04X] C: BEGIN %r", self.local_port, extra) self._append(b"\x11", (extra,), Response(self, "begin", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) def commit(self, dehydration_hooks=None, hydration_hooks=None, **handlers): log.debug("[#%04X] C: COMMIT", self.local_port) self._append(b"\x12", (), CommitResponse(self, "commit", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) def rollback(self, dehydration_hooks=None, hydration_hooks=None, **handlers): log.debug("[#%04X] C: ROLLBACK", self.local_port) self._append(b"\x13", (), Response(self, "rollback", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) async def reset(self, dehydration_hooks=None, hydration_hooks=None): """ Add a RESET message to the outgoing queue, send it and consume all remaining messages. """ def fail(metadata): raise BoltProtocolError("RESET failed %r" % metadata, address=self.unresolved_address) log.debug("[#%04X] C: RESET", self.local_port) self._append(b"\x0F", response=Response(self, "reset", hydration_hooks, on_failure=fail), dehydration_hooks=dehydration_hooks) await self.send_all() await self.fetch_all() def goodbye(self, dehydration_hooks=None, hydration_hooks=None): log.debug("[#%04X] C: GOODBYE", self.local_port) self._append(b"\x02", (), dehydration_hooks=dehydration_hooks) async def _process_message(self, tag, fields): """ Process at most one message from the server, if available. :return: 2-tuple of number of detail messages and number of summary messages fetched """ details = [] summary_signature = summary_metadata = None if tag == b"\x71": # RECORD details = fields elif fields: summary_signature = tag summary_metadata = fields[0] else: summary_signature = tag if details: log.debug("[#%04X] S: RECORD * %d", self.local_port, len(details)) # Do not log any data await self.responses[0].on_records(details) if summary_signature is None: return len(details), 0 response = self.responses.popleft() response.complete = True if summary_signature == b"\x70": log.debug("[#%04X] S: SUCCESS %r", self.local_port, summary_metadata) self._server_state_manager.transition(response.message, summary_metadata) await response.on_success(summary_metadata or {}) elif summary_signature == b"\x7E": log.debug("[#%04X] S: IGNORED", self.local_port) await response.on_ignored(summary_metadata or {}) elif summary_signature == b"\x7F": log.debug("[#%04X] S: FAILURE %r", self.local_port, summary_metadata) self._server_state_manager.state = ServerStates.FAILED try: await response.on_failure(summary_metadata or {}) except (ServiceUnavailable, DatabaseUnavailable): if self.pool: await self.pool.deactivate(address=self.unresolved_address) raise except (NotALeader, ForbiddenOnReadOnlyDatabase): if self.pool: self.pool.on_write_failure(address=self.unresolved_address) raise except Neo4jError as e: if self.pool and e.invalidates_all_connections(): await self.pool.mark_all_stale() raise else: raise BoltProtocolError("Unexpected response message with signature %02X" % summary_signature, address=self.unresolved_address) return len(details), 1 neo4j-python-driver-5.2.1/neo4j/_async/io/_bolt4.py000066400000000000000000000515431433522662700220270ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 logging import getLogger from ssl import SSLSocket from ..._async_compat.util import AsyncUtil from ..._exceptions import BoltProtocolError from ...api import ( READ_ACCESS, SYSTEM_DATABASE, Version, ) from ...exceptions import ( ConfigurationError, DatabaseUnavailable, ForbiddenOnReadOnlyDatabase, Neo4jError, NotALeader, ServiceUnavailable, ) from ._bolt import AsyncBolt from ._bolt3 import ( ServerStateManager, ServerStates, ) from ._common import ( check_supported_server_product, CommitResponse, InitResponse, Response, ) log = getLogger("neo4j") class AsyncBolt4x0(AsyncBolt): """ Protocol handler for Bolt 4.0. This is supported by Neo4j versions 4.0-4.4. """ PROTOCOL_VERSION = Version(4, 0) supports_multiple_results = True supports_multiple_databases = True def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self._server_state_manager = ServerStateManager( ServerStates.CONNECTED, on_change=self._on_server_state_change ) def _on_server_state_change(self, old_state, new_state): log.debug("[#%04X] _: state: %s > %s", self.local_port, old_state.name, new_state.name) @property def is_reset(self): # We can't be sure of the server's state if there are still pending # responses. Unless the last message we sent was RESET. In that case # the server state will always be READY when we're done. if (self.responses and self.responses[-1] and self.responses[-1].message == "reset"): return True return self._server_state_manager.state == ServerStates.READY @property def encrypted(self): return isinstance(self.socket, SSLSocket) @property def der_encoded_server_certificate(self): return self.socket.getpeercert(binary_form=True) def get_base_headers(self): return { "user_agent": self.user_agent, } async def hello(self, dehydration_hooks=None, hydration_hooks=None): headers = self.get_base_headers() headers.update(self.auth_dict) logged_headers = dict(headers) if "credentials" in logged_headers: logged_headers["credentials"] = "*******" log.debug("[#%04X] C: HELLO %r", self.local_port, logged_headers) self._append(b"\x01", (headers,), response=InitResponse( self, "hello", hydration_hooks, on_success=self.server_info.update ), dehydration_hooks=dehydration_hooks) await self.send_all() await self.fetch_all() check_supported_server_product(self.server_info.agent) async def route( self, database=None, imp_user=None, bookmarks=None, dehydration_hooks=None, hydration_hooks=None ): if imp_user is not None: raise ConfigurationError( "Impersonation is not supported in Bolt Protocol {!r}. " "Trying to impersonate {!r}.".format( self.PROTOCOL_VERSION, imp_user ) ) metadata = {} records = [] if database is None: # default database self.run( "CALL dbms.routing.getRoutingTable($context)", {"context": self.routing_context}, mode="r", bookmarks=bookmarks, db=SYSTEM_DATABASE, on_success=metadata.update ) else: self.run( "CALL dbms.routing.getRoutingTable($context, $database)", {"context": self.routing_context, "database": database}, mode="r", bookmarks=bookmarks, db=SYSTEM_DATABASE, on_success=metadata.update ) self.pull( dehydration_hooks=dehydration_hooks, hydration_hooks=hydration_hooks, on_success=metadata.update, on_records=records.extend ) await self.send_all() await self.fetch_all() routing_info = [dict(zip(metadata.get("fields", ()), values)) for values in records] return routing_info def run(self, query, parameters=None, mode=None, bookmarks=None, metadata=None, timeout=None, db=None, imp_user=None, dehydration_hooks=None, hydration_hooks=None, **handlers): if imp_user is not None: raise ConfigurationError( "Impersonation is not supported in Bolt Protocol {!r}. " "Trying to impersonate {!r}.".format( self.PROTOCOL_VERSION, imp_user ) ) if not parameters: parameters = {} extra = {} if mode in (READ_ACCESS, "r"): extra["mode"] = "r" # It will default to mode "w" if nothing is specified if db: extra["db"] = db if bookmarks: try: extra["bookmarks"] = list(bookmarks) except TypeError: raise TypeError("Bookmarks must be provided within an iterable") if metadata: try: extra["tx_metadata"] = dict(metadata) except TypeError: raise TypeError("Metadata must be coercible to a dict") if timeout is not None: try: extra["tx_timeout"] = int(1000 * float(timeout)) except TypeError: raise TypeError("Timeout must be specified as a number of seconds") if extra["tx_timeout"] < 0: raise ValueError("Timeout must be a positive number or 0.") fields = (query, parameters, extra) log.debug("[#%04X] C: RUN %s", self.local_port, " ".join(map(repr, fields))) self._append(b"\x10", fields, Response(self, "run", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) def discard(self, n=-1, qid=-1, dehydration_hooks=None, hydration_hooks=None, **handlers): extra = {"n": n} if qid != -1: extra["qid"] = qid log.debug("[#%04X] C: DISCARD %r", self.local_port, extra) self._append(b"\x2F", (extra,), Response(self, "discard", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) def pull(self, n=-1, qid=-1, dehydration_hooks=None, hydration_hooks=None, **handlers): extra = {"n": n} if qid != -1: extra["qid"] = qid log.debug("[#%04X] C: PULL %r", self.local_port, extra) self._append(b"\x3F", (extra,), Response(self, "pull", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) def begin(self, mode=None, bookmarks=None, metadata=None, timeout=None, db=None, imp_user=None, dehydration_hooks=None, hydration_hooks=None, **handlers): if imp_user is not None: raise ConfigurationError( "Impersonation is not supported in Bolt Protocol {!r}. " "Trying to impersonate {!r}.".format( self.PROTOCOL_VERSION, imp_user ) ) extra = {} if mode in (READ_ACCESS, "r"): extra["mode"] = "r" # It will default to mode "w" if nothing is specified if db: extra["db"] = db if bookmarks: try: extra["bookmarks"] = list(bookmarks) except TypeError: raise TypeError("Bookmarks must be provided within an iterable") if metadata: try: extra["tx_metadata"] = dict(metadata) except TypeError: raise TypeError("Metadata must be coercible to a dict") if timeout is not None: try: extra["tx_timeout"] = int(1000 * float(timeout)) except TypeError: raise TypeError("Timeout must be specified as a number of seconds") if extra["tx_timeout"] < 0: raise ValueError("Timeout must be a positive number or 0.") log.debug("[#%04X] C: BEGIN %r", self.local_port, extra) self._append(b"\x11", (extra,), Response(self, "begin", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) def commit(self, dehydration_hooks=None, hydration_hooks=None, **handlers): log.debug("[#%04X] C: COMMIT", self.local_port) self._append(b"\x12", (), CommitResponse(self, "commit", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) def rollback(self, dehydration_hooks=None, hydration_hooks=None, **handlers): log.debug("[#%04X] C: ROLLBACK", self.local_port) self._append(b"\x13", (), Response(self, "rollback", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) async def reset(self, dehydration_hooks=None, hydration_hooks=None): """ Add a RESET message to the outgoing queue, send it and consume all remaining messages. """ def fail(metadata): raise BoltProtocolError("RESET failed %r" % metadata, self.unresolved_address) log.debug("[#%04X] C: RESET", self.local_port) self._append(b"\x0F", response=Response(self, "reset", hydration_hooks, on_failure=fail), dehydration_hooks=dehydration_hooks) await self.send_all() await self.fetch_all() def goodbye(self, dehydration_hooks=None, hydration_hooks=None): log.debug("[#%04X] C: GOODBYE", self.local_port) self._append(b"\x02", (), dehydration_hooks=dehydration_hooks) async def _process_message(self, tag, fields): """ Process at most one message from the server, if available. :return: 2-tuple of number of detail messages and number of summary messages fetched """ details = [] summary_signature = summary_metadata = None if tag == b"\x71": # RECORD details = fields elif fields: summary_signature = tag summary_metadata = fields[0] else: summary_signature = tag if details: log.debug("[#%04X] S: RECORD * %d", self.local_port, len(details)) # Do not log any data await self.responses[0].on_records(details) if summary_signature is None: return len(details), 0 response = self.responses.popleft() response.complete = True if summary_signature == b"\x70": log.debug("[#%04X] S: SUCCESS %r", self.local_port, summary_metadata) self._server_state_manager.transition(response.message, summary_metadata) await response.on_success(summary_metadata or {}) elif summary_signature == b"\x7E": log.debug("[#%04X] S: IGNORED", self.local_port) await response.on_ignored(summary_metadata or {}) elif summary_signature == b"\x7F": log.debug("[#%04X] S: FAILURE %r", self.local_port, summary_metadata) self._server_state_manager.state = ServerStates.FAILED try: await response.on_failure(summary_metadata or {}) except (ServiceUnavailable, DatabaseUnavailable): if self.pool: await self.pool.deactivate(address=self.unresolved_address) raise except (NotALeader, ForbiddenOnReadOnlyDatabase): if self.pool: self.pool.on_write_failure(address=self.unresolved_address) raise except Neo4jError as e: if self.pool and e.invalidates_all_connections(): await self.pool.mark_all_stale() raise else: raise BoltProtocolError("Unexpected response message with signature " "%02X" % ord(summary_signature), self.unresolved_address) return len(details), 1 class AsyncBolt4x1(AsyncBolt4x0): """ Protocol handler for Bolt 4.1. This is supported by Neo4j versions 4.1 - 4.4. """ PROTOCOL_VERSION = Version(4, 1) def get_base_headers(self): """ Bolt 4.1 passes the routing context, originally taken from the URI, into the connection initialisation message. This enables server-side routing to propagate the same behaviour through its driver. """ headers = { "user_agent": self.user_agent, } if self.routing_context is not None: headers["routing"] = self.routing_context return headers class AsyncBolt4x2(AsyncBolt4x1): """ Protocol handler for Bolt 4.2. This is supported by Neo4j version 4.2 - 4.4. """ PROTOCOL_VERSION = Version(4, 2) class AsyncBolt4x3(AsyncBolt4x2): """ Protocol handler for Bolt 4.3. This is supported by Neo4j version 4.3 - 4.4. """ PROTOCOL_VERSION = Version(4, 3) def get_base_headers(self): headers = super().get_base_headers() headers["patch_bolt"] = ["utc"] return headers async def route( self, database=None, imp_user=None, bookmarks=None, dehydration_hooks=None, hydration_hooks=None ): if imp_user is not None: raise ConfigurationError( "Impersonation is not supported in Bolt Protocol {!r}. " "Trying to impersonate {!r}.".format( self.PROTOCOL_VERSION, imp_user ) ) routing_context = self.routing_context or {} log.debug("[#%04X] C: ROUTE %r %r %r", self.local_port, routing_context, bookmarks, database) metadata = {} if bookmarks is None: bookmarks = [] else: bookmarks = list(bookmarks) self._append(b"\x66", (routing_context, bookmarks, database), response=Response(self, "route", hydration_hooks, on_success=metadata.update), dehydration_hooks=dehydration_hooks) await self.send_all() await self.fetch_all() return [metadata.get("rt")] async def hello(self, dehydration_hooks=None, hydration_hooks=None): def on_success(metadata): self.configuration_hints.update(metadata.pop("hints", {})) self.server_info.update(metadata) if "connection.recv_timeout_seconds" in self.configuration_hints: recv_timeout = self.configuration_hints[ "connection.recv_timeout_seconds" ] if isinstance(recv_timeout, int) and recv_timeout > 0: self.socket.settimeout(recv_timeout) else: log.info("[#%04X] _: Server supplied an " "invalid value for " "connection.recv_timeout_seconds (%r). Make sure " "the server and network is set up correctly.", self.local_port, recv_timeout) self.patch = set(metadata.pop("patch_bolt", [])) if "utc" in self.patch: self.hydration_handler.patch_utc() headers = self.get_base_headers() headers.update(self.auth_dict) logged_headers = dict(headers) if "credentials" in logged_headers: logged_headers["credentials"] = "*******" log.debug("[#%04X] C: HELLO %r", self.local_port, logged_headers) self._append(b"\x01", (headers,), response=InitResponse(self, "hello", hydration_hooks, on_success=on_success), dehydration_hooks=dehydration_hooks) await self.send_all() await self.fetch_all() check_supported_server_product(self.server_info.agent) class AsyncBolt4x4(AsyncBolt4x3): """ Protocol handler for Bolt 4.4. This is supported by Neo4j version 4.4. """ PROTOCOL_VERSION = Version(4, 4) async def route( self, database=None, imp_user=None, bookmarks=None, dehydration_hooks=None, hydration_hooks=None ): routing_context = self.routing_context or {} db_context = {} if database is not None: db_context.update(db=database) if imp_user is not None: db_context.update(imp_user=imp_user) log.debug("[#%04X] C: ROUTE %r %r %r", self.local_port, routing_context, bookmarks, db_context) metadata = {} if bookmarks is None: bookmarks = [] else: bookmarks = list(bookmarks) self._append(b"\x66", (routing_context, bookmarks, db_context), response=Response(self, "route", hydration_hooks, on_success=metadata.update), dehydration_hooks=dehydration_hooks) await self.send_all() await self.fetch_all() return [metadata.get("rt")] def run(self, query, parameters=None, mode=None, bookmarks=None, metadata=None, timeout=None, db=None, imp_user=None, dehydration_hooks=None, hydration_hooks=None, **handlers): if not parameters: parameters = {} extra = {} if mode in (READ_ACCESS, "r"): # It will default to mode "w" if nothing is specified extra["mode"] = "r" if db: extra["db"] = db if imp_user: extra["imp_user"] = imp_user if bookmarks: try: extra["bookmarks"] = list(bookmarks) except TypeError: raise TypeError("Bookmarks must be provided within an iterable") if metadata: try: extra["tx_metadata"] = dict(metadata) except TypeError: raise TypeError("Metadata must be coercible to a dict") if timeout is not None: try: extra["tx_timeout"] = int(1000 * float(timeout)) except TypeError: raise TypeError("Timeout must be specified as a number of seconds") if extra["tx_timeout"] < 0: raise ValueError("Timeout must be a positive number or 0.") fields = (query, parameters, extra) log.debug("[#%04X] C: RUN %s", self.local_port, " ".join(map(repr, fields))) self._append(b"\x10", fields, Response(self, "run", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) def begin(self, mode=None, bookmarks=None, metadata=None, timeout=None, db=None, imp_user=None, dehydration_hooks=None, hydration_hooks=None, **handlers): extra = {} if mode in (READ_ACCESS, "r"): # It will default to mode "w" if nothing is specified extra["mode"] = "r" if db: extra["db"] = db if imp_user: extra["imp_user"] = imp_user if bookmarks: try: extra["bookmarks"] = list(bookmarks) except TypeError: raise TypeError("Bookmarks must be provided within an iterable") if metadata: try: extra["tx_metadata"] = dict(metadata) except TypeError: raise TypeError("Metadata must be coercible to a dict") if timeout is not None: try: extra["tx_timeout"] = int(1000 * float(timeout)) except TypeError: raise TypeError("Timeout must be specified as a number of seconds") if extra["tx_timeout"] < 0: raise ValueError("Timeout must be a positive number or 0.") log.debug("[#%04X] C: BEGIN %r", self.local_port, extra) self._append(b"\x11", (extra,), Response(self, "begin", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) neo4j-python-driver-5.2.1/neo4j/_async/io/_bolt5.py000066400000000000000000000316751433522662700220340ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 logging import getLogger from ssl import SSLSocket from ..._codec.hydration import v2 as hydration_v2 from ..._exceptions import BoltProtocolError from ...api import ( READ_ACCESS, Version, ) from ...exceptions import ( DatabaseUnavailable, ForbiddenOnReadOnlyDatabase, Neo4jError, NotALeader, ServiceUnavailable, ) from ._bolt import AsyncBolt from ._bolt3 import ( ServerStateManager, ServerStates, ) from ._common import ( check_supported_server_product, CommitResponse, InitResponse, Response, ) log = getLogger("neo4j") class AsyncBolt5x0(AsyncBolt): """Protocol handler for Bolt 5.0. """ PROTOCOL_VERSION = Version(5, 0) HYDRATION_HANDLER_CLS = hydration_v2.HydrationHandler supports_multiple_results = True supports_multiple_databases = True def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self._server_state_manager = ServerStateManager( ServerStates.CONNECTED, on_change=self._on_server_state_change ) def _on_server_state_change(self, old_state, new_state): log.debug("[#%04X] _: state: %s > %s", self.local_port, old_state.name, new_state.name) @property def is_reset(self): # We can't be sure of the server's state if there are still pending # responses. Unless the last message we sent was RESET. In that case # the server state will always be READY when we're done. if (self.responses and self.responses[-1] and self.responses[-1].message == "reset"): return True return self._server_state_manager.state == ServerStates.READY @property def encrypted(self): return isinstance(self.socket, SSLSocket) @property def der_encoded_server_certificate(self): return self.socket.getpeercert(binary_form=True) def get_base_headers(self): headers = {"user_agent": self.user_agent} if self.routing_context is not None: headers["routing"] = self.routing_context return headers async def hello(self, dehydration_hooks=None, hydration_hooks=None): def on_success(metadata): self.configuration_hints.update(metadata.pop("hints", {})) self.server_info.update(metadata) if "connection.recv_timeout_seconds" in self.configuration_hints: recv_timeout = self.configuration_hints[ "connection.recv_timeout_seconds" ] if isinstance(recv_timeout, int) and recv_timeout > 0: self.socket.settimeout(recv_timeout) else: log.info("[#%04X] _: Server supplied an " "invalid value for " "connection.recv_timeout_seconds (%r). Make sure " "the server and network is set up correctly.", self.local_port, recv_timeout) headers = self.get_base_headers() headers.update(self.auth_dict) logged_headers = dict(headers) if "credentials" in logged_headers: logged_headers["credentials"] = "*******" log.debug("[#%04X] C: HELLO %r", self.local_port, logged_headers) self._append(b"\x01", (headers,), response=InitResponse(self, "hello", hydration_hooks, on_success=on_success), dehydration_hooks=dehydration_hooks) await self.send_all() await self.fetch_all() check_supported_server_product(self.server_info.agent) async def route(self, database=None, imp_user=None, bookmarks=None, dehydration_hooks=None, hydration_hooks=None): routing_context = self.routing_context or {} db_context = {} if database is not None: db_context.update(db=database) if imp_user is not None: db_context.update(imp_user=imp_user) log.debug("[#%04X] C: ROUTE %r %r %r", self.local_port, routing_context, bookmarks, db_context) metadata = {} if bookmarks is None: bookmarks = [] else: bookmarks = list(bookmarks) self._append(b"\x66", (routing_context, bookmarks, db_context), response=Response(self, "route", hydration_hooks, on_success=metadata.update), dehydration_hooks=hydration_hooks) await self.send_all() await self.fetch_all() return [metadata.get("rt")] def run(self, query, parameters=None, mode=None, bookmarks=None, metadata=None, timeout=None, db=None, imp_user=None, dehydration_hooks=None, hydration_hooks=None, **handlers): if not parameters: parameters = {} extra = {} if mode in (READ_ACCESS, "r"): # It will default to mode "w" if nothing is specified extra["mode"] = "r" if db: extra["db"] = db if imp_user: extra["imp_user"] = imp_user if bookmarks: try: extra["bookmarks"] = list(bookmarks) except TypeError: raise TypeError("Bookmarks must be provided as iterable") if metadata: try: extra["tx_metadata"] = dict(metadata) except TypeError: raise TypeError("Metadata must be coercible to a dict") if timeout is not None: try: extra["tx_timeout"] = int(1000 * float(timeout)) except TypeError: raise TypeError("Timeout must be a number (in seconds)") if extra["tx_timeout"] < 0: raise ValueError("Timeout must be a number <= 0") fields = (query, parameters, extra) log.debug("[#%04X] C: RUN %s", self.local_port, " ".join(map(repr, fields))) self._append(b"\x10", fields, Response(self, "run", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) def discard(self, n=-1, qid=-1, dehydration_hooks=None, hydration_hooks=None, **handlers): extra = {"n": n} if qid != -1: extra["qid"] = qid log.debug("[#%04X] C: DISCARD %r", self.local_port, extra) self._append(b"\x2F", (extra,), Response(self, "discard", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) def pull(self, n=-1, qid=-1, dehydration_hooks=None, hydration_hooks=None, **handlers): extra = {"n": n} if qid != -1: extra["qid"] = qid log.debug("[#%04X] C: PULL %r", self.local_port, extra) self._append(b"\x3F", (extra,), Response(self, "pull", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) def begin(self, mode=None, bookmarks=None, metadata=None, timeout=None, db=None, imp_user=None, dehydration_hooks=None, hydration_hooks=None, **handlers): extra = {} if mode in (READ_ACCESS, "r"): # It will default to mode "w" if nothing is specified extra["mode"] = "r" if db: extra["db"] = db if imp_user: extra["imp_user"] = imp_user if bookmarks: try: extra["bookmarks"] = list(bookmarks) except TypeError: raise TypeError("Bookmarks must be provided as iterable") if metadata: try: extra["tx_metadata"] = dict(metadata) except TypeError: raise TypeError("Metadata must be coercible to a dict") if timeout is not None: try: extra["tx_timeout"] = int(1000 * float(timeout)) except TypeError: raise TypeError("Timeout must be a number (in seconds)") if extra["tx_timeout"] < 0: raise ValueError("Timeout must be a number <= 0") log.debug("[#%04X] C: BEGIN %r", self.local_port, extra) self._append(b"\x11", (extra,), Response(self, "begin", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) def commit(self, dehydration_hooks=None, hydration_hooks=None, **handlers): log.debug("[#%04X] C: COMMIT", self.local_port) self._append(b"\x12", (), CommitResponse(self, "commit", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) def rollback(self, dehydration_hooks=None, hydration_hooks=None, **handlers): log.debug("[#%04X] C: ROLLBACK", self.local_port) self._append(b"\x13", (), Response(self, "rollback", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) async def reset(self, dehydration_hooks=None, hydration_hooks=None): """Reset the connection. Add a RESET message to the outgoing queue, send it and consume all remaining messages. """ def fail(metadata): raise BoltProtocolError("RESET failed %r" % metadata, self.unresolved_address) log.debug("[#%04X] C: RESET", self.local_port) self._append(b"\x0F", response=Response(self, "reset", hydration_hooks, on_failure=fail), dehydration_hooks=dehydration_hooks) await self.send_all() await self.fetch_all() def goodbye(self, dehydration_hooks=None, hydration_hooks=None): log.debug("[#%04X] C: GOODBYE", self.local_port) self._append(b"\x02", (), dehydration_hooks=dehydration_hooks) async def _process_message(self, tag, fields): """Process at most one message from the server, if available. :return: 2-tuple of number of detail messages and number of summary messages fetched """ details = [] summary_signature = summary_metadata = None if tag == b"\x71": # RECORD details = fields elif fields: summary_signature = tag summary_metadata = fields[0] else: summary_signature = tag if details: # Do not log any data log.debug("[#%04X] S: RECORD * %d", self.local_port, len(details)) await self.responses[0].on_records(details) if summary_signature is None: return len(details), 0 response = self.responses.popleft() response.complete = True if summary_signature == b"\x70": log.debug("[#%04X] S: SUCCESS %r", self.local_port, summary_metadata) self._server_state_manager.transition(response.message, summary_metadata) await response.on_success(summary_metadata or {}) elif summary_signature == b"\x7E": log.debug("[#%04X] S: IGNORED", self.local_port) await response.on_ignored(summary_metadata or {}) elif summary_signature == b"\x7F": log.debug("[#%04X] S: FAILURE %r", self.local_port, summary_metadata) self._server_state_manager.state = ServerStates.FAILED try: await response.on_failure(summary_metadata or {}) except (ServiceUnavailable, DatabaseUnavailable): if self.pool: await self.pool.deactivate(address=self.unresolved_address) raise except (NotALeader, ForbiddenOnReadOnlyDatabase): if self.pool: self.pool.on_write_failure(address=self.unresolved_address) raise except Neo4jError as e: if self.pool and e.invalidates_all_connections(): await self.pool.mark_all_stale() raise else: raise BoltProtocolError( "Unexpected response message with signature %02X" % ord( summary_signature ), self.unresolved_address ) return len(details), 1 neo4j-python-driver-5.2.1/neo4j/_async/io/_common.py000066400000000000000000000234131433522662700222660ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 asyncio import logging from struct import pack as struct_pack from ..._async_compat.util import AsyncUtil from ..._exceptions import SocketDeadlineExceeded from ...exceptions import ( Neo4jError, ServiceUnavailable, SessionExpired, UnsupportedServerProduct, ) log = logging.getLogger("neo4j") class AsyncInbox: def __init__(self, sock, on_error, unpacker_cls): self.on_error = on_error self._local_port = sock.getsockname()[1] self._socket = sock self._buffer = unpacker_cls.new_unpackable_buffer() self._unpacker = unpacker_cls(self._buffer) self._broken = False async def _buffer_one_chunk(self): assert not self._broken try: chunk_size = 0 while True: while chunk_size == 0: # Determine the chunk size and skip noop await receive_into_buffer(self._socket, self._buffer, 2) chunk_size = self._buffer.pop_u16() if chunk_size == 0: log.debug("[#%04X] S: ", self._local_port) await receive_into_buffer( self._socket, self._buffer, chunk_size + 2 ) chunk_size = self._buffer.pop_u16() if chunk_size == 0: # chunk_size was the end marker for the message return except ( OSError, SocketDeadlineExceeded, asyncio.CancelledError ) as error: self._broken = True await AsyncUtil.callback(self.on_error, error) raise async def pop(self, hydration_hooks): await self._buffer_one_chunk() try: size, tag = self._unpacker.unpack_structure_header() fields = [self._unpacker.unpack(hydration_hooks) for _ in range(size)] return tag, fields finally: # Reset for new message self._unpacker.reset() class AsyncOutbox: def __init__(self, sock, on_error, packer_cls, max_chunk_size=16384): self._max_chunk_size = max_chunk_size self._chunked_data = bytearray() self._buffer = packer_cls.new_packable_buffer() self._packer = packer_cls(self._buffer) self.socket = sock self.on_error = on_error def max_chunk_size(self): return self._max_chunk_size def _clear(self): assert not self._buffer.is_tmp_buffering() self._chunked_data = bytearray() self._buffer.clear() def _chunk_data(self): data_len = len(self._buffer.data) num_full_chunks, chunk_rest = divmod( data_len, self._max_chunk_size ) num_chunks = num_full_chunks + bool(chunk_rest) with memoryview(self._buffer.data) as data_view: header_start = len(self._chunked_data) data_start = header_start + 2 raw_data_start = 0 for i in range(num_chunks): chunk_size = min(data_len - raw_data_start, self._max_chunk_size) self._chunked_data[header_start:data_start] = struct_pack( ">H", chunk_size ) self._chunked_data[data_start:(data_start + chunk_size)] = \ data_view[raw_data_start:(raw_data_start + chunk_size)] header_start += chunk_size + 2 data_start = header_start + 2 raw_data_start += chunk_size self._buffer.clear() def _wrap_message(self): assert not self._buffer.is_tmp_buffering() self._chunk_data() self._chunked_data += b"\x00\x00" def append_message(self, tag, fields, dehydration_hooks): with self._buffer.tmp_buffer(): self._packer.pack_struct(tag, fields, dehydration_hooks) self._wrap_message() async def flush(self): data = self._chunked_data if data: try: await self.socket.sendall(data) except ( OSError, SocketDeadlineExceeded, asyncio.CancelledError ) as error: await AsyncUtil.callback(self.on_error, error) return False self._clear() return True return False class ConnectionErrorHandler: """ Wrapper class for handling connection errors. The class will wrap each method to invoke a callback if the method raises Neo4jError, SessionExpired, or ServiceUnavailable. The error will be re-raised after the callback. """ def __init__(self, connection, on_error): """ :param connection the connection object to warp :type connection Bolt :param on_error the function to be called when a method of connection raises of of the caught errors. :type on_error callable """ self.__connection = connection self.__on_error = on_error def __getattr__(self, name): connection_attr = getattr(self.__connection, name) if not callable(connection_attr): return connection_attr def outer(func): def inner(*args, **kwargs): try: func(*args, **kwargs) except (Neo4jError, ServiceUnavailable, SessionExpired) as exc: assert not asyncio.iscoroutinefunction(self.__on_error) self.__on_error(exc) raise return inner def outer_async(coroutine_func): async def inner(*args, **kwargs): try: await coroutine_func(*args, **kwargs) except (Neo4jError, ServiceUnavailable, SessionExpired, asyncio.CancelledError) as exc: await AsyncUtil.callback(self.__on_error, exc) raise return inner if asyncio.iscoroutinefunction(connection_attr): return outer_async(connection_attr) return outer(connection_attr) def __setattr__(self, name, value): if name.startswith("_" + self.__class__.__name__ + "__"): super().__setattr__(name, value) else: setattr(self.__connection, name, value) class Response: """ Subscriber object for a full response (zero or more detail messages followed by one summary message). """ def __init__(self, connection, message, hydration_hooks, **handlers): self.connection = connection self.hydration_hooks = hydration_hooks self.handlers = handlers self.message = message self.complete = False async def on_records(self, records): """ Called when one or more RECORD messages have been received. """ handler = self.handlers.get("on_records") await AsyncUtil.callback(handler, records) async def on_success(self, metadata): """ Called when a SUCCESS message has been received. """ handler = self.handlers.get("on_success") await AsyncUtil.callback(handler, metadata) if not metadata.get("has_more"): handler = self.handlers.get("on_summary") await AsyncUtil.callback(handler) async def on_failure(self, metadata): """ Called when a FAILURE message has been received. """ try: await self.connection.reset() except (SessionExpired, ServiceUnavailable): pass handler = self.handlers.get("on_failure") await AsyncUtil.callback(handler, metadata) handler = self.handlers.get("on_summary") await AsyncUtil.callback(handler) raise Neo4jError.hydrate(**metadata) async def on_ignored(self, metadata=None): """ Called when an IGNORED message has been received. """ handler = self.handlers.get("on_ignored") await AsyncUtil.callback(handler, metadata) handler = self.handlers.get("on_summary") await AsyncUtil.callback(handler) class InitResponse(Response): async def on_failure(self, metadata): code = metadata.get("code") if code == "Neo.ClientError.Security.Unauthorized": raise Neo4jError.hydrate(**metadata) else: raise ServiceUnavailable( metadata.get("message", "Connection initialisation failed") ) class CommitResponse(Response): pass def check_supported_server_product(agent): """ Checks that a server product is supported by the driver by looking at the server agent string. :param agent: server agent string to check for validity :raises UnsupportedServerProduct: if the product is not supported """ if not agent.startswith("Neo4j/"): raise UnsupportedServerProduct(agent) async def receive_into_buffer(sock, buffer, n_bytes): end = buffer.used + n_bytes if end > len(buffer.data): buffer.data += bytearray(end - len(buffer.data)) with memoryview(buffer.data) as view: while buffer.used < end: n = await sock.recv_into(view[buffer.used:end], end - buffer.used) if n == 0: raise OSError("No data") buffer.used += n neo4j-python-driver-5.2.1/neo4j/_async/io/_pool.py000066400000000000000000001007621433522662700217520ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 abc import asyncio import logging from collections import ( defaultdict, deque, ) from logging import getLogger from random import choice from ..._async_compat.concurrency import ( AsyncCondition, AsyncCooperativeRLock, AsyncRLock, ) from ..._async_compat.network import AsyncNetworkUtil from ..._conf import ( PoolConfig, WorkspaceConfig, ) from ..._deadline import ( connection_deadline, Deadline, ) from ..._exceptions import BoltError from ..._routing import RoutingTable from ...api import ( READ_ACCESS, WRITE_ACCESS, ) from ...exceptions import ( ClientError, ConfigurationError, DriverError, Neo4jError, ReadServiceUnavailable, ServiceUnavailable, SessionExpired, WriteServiceUnavailable, ) from ._bolt import AsyncBolt # Set up logger log = getLogger("neo4j") class AsyncIOPool(abc.ABC): """ A collection of connections to one or more server addresses. """ def __init__(self, opener, pool_config, workspace_config): assert callable(opener) assert isinstance(pool_config, PoolConfig) assert isinstance(workspace_config, WorkspaceConfig) self.opener = opener self.pool_config = pool_config self.workspace_config = workspace_config self.connections = defaultdict(deque) self.connections_reservations = defaultdict(lambda: 0) self.lock = AsyncCooperativeRLock() self.cond = AsyncCondition(self.lock) async def __aenter__(self): return self async def __aexit__(self, exc_type, exc_value, traceback): await self.close() async def _acquire_from_pool(self, address): with self.lock: for connection in list(self.connections.get(address, [])): if connection.in_use: continue connection.pool = self connection.in_use = True return connection return None # no free connection available async def _acquire_from_pool_checked( self, address, health_check, deadline ): while not deadline.expired(): connection = await self._acquire_from_pool(address) if not connection: return None # no free connection available if not await health_check(connection, deadline): # `close` is a noop on already closed connections. # This is to make sure that the connection is # gracefully closed, e.g. if it's just marked as # `stale` but still alive. if log.isEnabledFor(logging.DEBUG): log.debug( "[#%04X] _: removing old connection %s " "(closed=%s, defunct=%s, stale=%s, in_use=%s)", connection.local_port, connection.connection_id, connection.closed(), connection.defunct(), connection.stale(), connection.in_use ) await connection.close() with self.lock: try: self.connections.get(address, []).remove(connection) except ValueError: # If closure fails (e.g. because the server went # down), all connections to the same address will # be removed. Therefore, we silently ignore if the # connection isn't in the pool anymore. pass continue # try again with a new connection else: return connection def _acquire_new_later(self, address, deadline): async def connection_creator(): released_reservation = False try: try: connection = await self.opener( address, deadline.to_timeout() ) except ServiceUnavailable: await self.deactivate(address) raise connection.pool = self connection.in_use = True with self.lock: self.connections_reservations[address] -= 1 released_reservation = True self.connections[address].append(connection) return connection finally: if not released_reservation: with self.lock: self.connections_reservations[address] -= 1 max_pool_size = self.pool_config.max_connection_pool_size infinite_pool_size = (max_pool_size < 0 or max_pool_size == float("inf")) with self.lock: connections = self.connections[address] pool_size = (len(connections) + self.connections_reservations[address]) if infinite_pool_size or pool_size < max_pool_size: # there's room for a new connection self.connections_reservations[address] += 1 return connection_creator return None async def _acquire(self, address, deadline, liveness_check_timeout): """ Acquire a connection to a given address from the pool. The address supplied should always be an IP address, not a host name. This method is thread safe. """ async def health_check(connection_, deadline_): if (connection_.closed() or connection_.defunct() or connection_.stale()): return False if liveness_check_timeout is not None: if connection_.is_idle_for(liveness_check_timeout): with connection_deadline(connection_, deadline_): try: log.debug("[#%04X] _: liveness check", connection_.local_port) await connection_.reset() except (OSError, ServiceUnavailable, SessionExpired): return False return True while True: # try to find a free connection in the pool connection = await self._acquire_from_pool_checked( address, health_check, deadline ) if connection: log.debug("[#%04X] _: handing out existing connection " "%s", connection.local_port, connection.connection_id) return connection # all connections in pool are in-use with self.lock: connection_creator = self._acquire_new_later(address, deadline) if connection_creator: break # failed to obtain a connection from pool because the # pool is full and no free connection in the pool timeout = deadline.to_timeout() if ( timeout == 0 # deadline expired or not await self.cond.wait(timeout) ): log.debug("[#0000] _: acquisition timed out") raise ClientError( "failed to obtain a connection from the pool within " "{!r}s (timeout)".format(deadline.original_timeout) ) log.debug("[#0000] _: trying to hand out new connection") return await connection_creator() @abc.abstractmethod async def acquire( self, access_mode, timeout, database, bookmarks, liveness_check_timeout ): """ Acquire a connection to a server that can satisfy a set of parameters. :param access_mode: :param timeout: timeout for the core acquisition (excluding potential preparation like fetching routing tables). :param database: :param bookmarks: :param liveness_check_timeout: """ ... def kill_and_release(self, *connections): """ Release connections back into the pool after closing them. This method is thread safe. """ for connection in connections: if not (connection.defunct() or connection.closed()): log.debug( "[#%04X] _: killing connection on release %s", connection.local_port, connection.connection_id ) connection.kill() with self.lock: for connection in connections: connection.in_use = False self.cond.notify_all() async def release(self, *connections): """ Release connections back into the pool. This method is thread safe. """ cancelled = None for connection in connections: if not (connection.defunct() or connection.closed() or connection.is_reset): if cancelled is not None: log.debug( "[#%04X] _: released unclean connection %s", connection.local_port, connection.connection_id ) connection.kill() continue try: log.debug( "[#%04X] _: released unclean connection %s", connection.local_port, connection.connection_id ) await connection.reset() except (Neo4jError, DriverError, BoltError) as e: log.debug("[#%04X] _: failed to reset connection " "on release: %r", connection.local_port, e) except asyncio.CancelledError as e: log.debug("[#%04X] _: cancelled reset connection " "on release: %r", connection.local_port, e) cancelled = e connection.kill() with self.lock: for connection in connections: connection.in_use = False log.debug( "[#%04X] _: released %s", connection.local_port, connection.connection_id ) self.cond.notify_all() if cancelled is not None: raise cancelled def in_use_connection_count(self, address): """ Count the number of connections currently in use to a given address. """ with self.lock: connections = self.connections.get(address, ()) return sum(connection.in_use for connection in connections) async def mark_all_stale(self): with self.lock: for address in self.connections: for connection in self.connections[address]: connection.set_stale() @classmethod async def _close_connections(cls, connections): cancelled = None for connection in connections: if cancelled is not None: connection.kill() continue try: await connection.close() except asyncio.CancelledError as e: # We've got cancelled: no more time to gracefully close these # connections. Time to burn down the place. cancelled = e connection.kill() if cancelled is not None: raise cancelled async def deactivate(self, address): """ Deactivate an address from the connection pool, if present, closing all idle connection to that address """ with self.lock: try: connections = self.connections[address] except KeyError: # already removed from the connection pool return closable_connections = [ conn for conn in connections if not conn.in_use ] # First remove all connections in question, then try to close them. # If closing of a connection fails, we will end up in this method # again. for conn in closable_connections: connections.remove(conn) if not self.connections[address]: del self.connections[address] await self._close_connections(closable_connections) def on_write_failure(self, address): raise WriteServiceUnavailable( "No write service available for pool {}".format(self) ) async def close(self): """ Close all connections and empty the pool. This method is thread safe. """ log.debug("[#0000] _: close") try: connections = [] with self.lock: for address in list(self.connections): for connection in self.connections.pop(address, ()): connections.append(connection) await self._close_connections(connections) except TypeError: pass class AsyncBoltPool(AsyncIOPool): @classmethod def open(cls, address, *, auth, pool_config, workspace_config): """Create a new BoltPool :param address: :param auth: :param pool_config: :param workspace_config: :return: BoltPool """ async def opener(addr, timeout): return await AsyncBolt.open( addr, auth=auth, timeout=timeout, routing_context=None, pool_config=pool_config ) pool = cls(opener, pool_config, workspace_config, address) log.debug("[#0000] _: created, direct address %r", address) return pool def __init__(self, opener, pool_config, workspace_config, address): super().__init__(opener, pool_config, workspace_config) self.address = address def __repr__(self): return "<{} address={!r}>".format(self.__class__.__name__, self.address) async def acquire( self, access_mode, timeout, database, bookmarks, liveness_check_timeout ): # The access_mode and database is not needed for a direct connection, # it's just there for consistency. log.debug("[#0000] _: acquire direct connection, " "access_mode=%r, database=%r", access_mode, database) deadline = Deadline.from_timeout_or_deadline(timeout) return await self._acquire( self.address, deadline, liveness_check_timeout ) class AsyncNeo4jPool(AsyncIOPool): """ Connection pool with routing table. """ @classmethod def open(cls, *addresses, auth, pool_config, workspace_config, routing_context=None): """Create a new Neo4jPool :param addresses: one or more address as positional argument :param auth: :param pool_config: :param workspace_config: :param routing_context: :return: Neo4jPool """ address = addresses[0] if routing_context is None: routing_context = {} elif "address" in routing_context: raise ConfigurationError("The key 'address' is reserved for routing context.") routing_context["address"] = str(address) async def opener(addr, timeout): return await AsyncBolt.open( addr, auth=auth, timeout=timeout, routing_context=routing_context, pool_config=pool_config ) pool = cls(opener, pool_config, workspace_config, address) log.debug("[#0000] _: created, routing address %r", address) return pool def __init__(self, opener, pool_config, workspace_config, address): """ :param opener: :param pool_config: :param workspace_config: :param address: """ super().__init__(opener, pool_config, workspace_config) # Each database have a routing table, the default database is a special case. self.address = address self.routing_tables = {} self.refresh_lock = AsyncRLock() def __repr__(self): """ The representation shows the initial routing addresses. :return: The representation :rtype: str """ return "<{} address={!r}>".format(self.__class__.__name__, self.address) async def get_or_create_routing_table(self, database): async with self.refresh_lock: if database not in self.routing_tables: self.routing_tables[database] = RoutingTable( database=database, routers=[self.address] ) return self.routing_tables[database] async def fetch_routing_info( self, address, database, imp_user, bookmarks, acquisition_timeout ): """ Fetch raw routing info from a given router address. :param address: router address :param database: the database name to get routing table for :param imp_user: the user to impersonate while fetching the routing table :type imp_user: str or None :param bookmarks: iterable of bookmark values after which the routing info should be fetched :param acquisition_timeout: connection acquisition timeout :return: list of routing records, or None if no connection could be established or if no readers or writers are present :raise ServiceUnavailable: if the server does not support routing, or if routing support is broken or outdated """ deadline = Deadline.from_timeout_or_deadline(acquisition_timeout) log.debug("[#0000] _: _acquire router connection, " "database=%r, address=%r", database, address) cx = await self._acquire(address, deadline, None) try: routing_table = await cx.route( database=database or self.workspace_config.database, imp_user=imp_user or self.workspace_config.impersonated_user, bookmarks=bookmarks ) finally: await self.release(cx) return routing_table async def fetch_routing_table( self, *, address, acquisition_timeout, database, imp_user, bookmarks ): """ Fetch a routing table from a given router address. :param address: router address :param acquisition_timeout: connection acquisition timeout :param database: the database name :type: str :param imp_user: the user to impersonate while fetching the routing table :type imp_user: str or None :param bookmarks: bookmarks used when fetching routing table :return: a new RoutingTable instance or None if the given router is currently unable to provide routing information """ new_routing_info = None try: new_routing_info = await self.fetch_routing_info( address, database, imp_user, bookmarks, acquisition_timeout ) except Neo4jError as e: # checks if the code is an error that is caused by the client. In # this case there is no sense in trying to fetch a RT from another # router. Hence, the driver should fail fast during discovery. if e.is_fatal_during_discovery(): raise except (ServiceUnavailable, SessionExpired): pass if not new_routing_info: log.debug("[#0000] _: failed to fetch routing info " "from %r", address) return None else: servers = new_routing_info[0]["servers"] ttl = new_routing_info[0]["ttl"] database = new_routing_info[0].get("db", database) new_routing_table = RoutingTable.parse_routing_info( database=database, servers=servers, ttl=ttl ) # Parse routing info and count the number of each type of server num_routers = len(new_routing_table.routers) num_readers = len(new_routing_table.readers) # num_writers = len(new_routing_table.writers) # If no writers are available. This likely indicates a temporary state, # such as leader switching, so we should not signal an error. # No routers if num_routers == 0: log.debug("[#0000] _: no routing servers returned from " "server %s", address) return None # No readers if num_readers == 0: log.debug("[#0000] _: no read servers returned from " "server %s", address) return None # At least one of each is fine, so return this table return new_routing_table async def _update_routing_table_from( self, *routers, database, imp_user, bookmarks, acquisition_timeout, database_callback ): """ Try to update routing tables with the given routers. :return: True if the routing table is successfully updated, otherwise False """ if routers: log.debug("[#0000] _: attempting to update routing " "table from {}".format(", ".join(map(repr, routers)))) for router in routers: async for address in AsyncNetworkUtil.resolve_address( router, resolver=self.pool_config.resolver ): new_routing_table = await self.fetch_routing_table( address=address, acquisition_timeout=acquisition_timeout, database=database, imp_user=imp_user, bookmarks=bookmarks ) if new_routing_table is not None: new_database = new_routing_table.database old_routing_table = await self.get_or_create_routing_table( new_database ) old_routing_table.update(new_routing_table) log.debug( "[#0000] _: update routing table from " "address=%r (%r)", address, self.routing_tables[new_database] ) if callable(database_callback): database_callback(new_database) return True await self.deactivate(router) return False async def update_routing_table( self, *, database, imp_user, bookmarks, acquisition_timeout=None, database_callback=None ): """ Update the routing table from the first router able to provide valid routing information. :param database: The database name :param imp_user: the user to impersonate while fetching the routing table :type imp_user: str or None :param bookmarks: bookmarks used when fetching routing table :param acquisition_timeout: connection acquisition timeout :param database_callback: A callback function that will be called with the database name as only argument when a new routing table has been acquired. This database name might different from `database` if that was None and the underlying protocol supports reporting back the actual database. :raise neo4j.exceptions.ServiceUnavailable: """ async with self.refresh_lock: routing_table = await self.get_or_create_routing_table(database) # copied because it can be modified existing_routers = set(routing_table.routers) prefer_initial_routing_address = \ self.routing_tables[database].initialized_without_writers if prefer_initial_routing_address: # TODO: Test this state if await self._update_routing_table_from( self.address, database=database, imp_user=imp_user, bookmarks=bookmarks, acquisition_timeout=acquisition_timeout, database_callback=database_callback ): # Why is only the first initial routing address used? return if await self._update_routing_table_from( *(existing_routers - {self.address}), database=database, imp_user=imp_user, bookmarks=bookmarks, acquisition_timeout=acquisition_timeout, database_callback=database_callback ): return if not prefer_initial_routing_address: if await self._update_routing_table_from( self.address, database=database, imp_user=imp_user, bookmarks=bookmarks, acquisition_timeout=acquisition_timeout, database_callback=database_callback ): # Why is only the first initial routing address used? return # None of the routers have been successful, so just fail log.error("Unable to retrieve routing information") raise ServiceUnavailable("Unable to retrieve routing information") async def update_connection_pool(self, *, database): routing_table = await self.get_or_create_routing_table(database) servers = routing_table.servers() for address in list(self.connections): if address.unresolved not in servers: await super(AsyncNeo4jPool, self).deactivate(address) async def ensure_routing_table_is_fresh( self, *, access_mode, database, imp_user, bookmarks, acquisition_timeout=None, database_callback=None ): """ Update the routing table if stale. This method performs two freshness checks, before and after acquiring the refresh lock. If the routing table is already fresh on entry, the method exits immediately; otherwise, the refresh lock is acquired and the second freshness check that follows determines whether an update is still required. This method is thread-safe. :return: `True` if an update was required, `False` otherwise. """ from neo4j.api import READ_ACCESS async with self.refresh_lock: for database_ in list(self.routing_tables.keys()): # Remove unused databases in the routing table # Remove the routing table after a timeout = TTL + 30s log.debug("[#0000] _: routing aged?, database=%s", database) routing_table = self.routing_tables[database_] if routing_table.should_be_purged_from_memory(): log.debug("[#0000] _: dropping routing table for " "database=%s", database) del self.routing_tables[database_] routing_table = await self.get_or_create_routing_table(database) if routing_table.is_fresh(readonly=(access_mode == READ_ACCESS)): # table is still valid log.debug("[#0000] _: using existing routing table %r", routing_table) return False await self.update_routing_table( database=database, imp_user=imp_user, bookmarks=bookmarks, acquisition_timeout=acquisition_timeout, database_callback=database_callback ) await self.update_connection_pool(database=database) return True async def _select_address(self, *, access_mode, database): from ...api import READ_ACCESS """ Selects the address with the fewest in-use connections. """ async with self.refresh_lock: routing_table = self.routing_tables.get(database) if routing_table: if access_mode == READ_ACCESS: addresses = routing_table.readers else: addresses = routing_table.writers else: addresses = () addresses_by_usage = {} for address in addresses: addresses_by_usage.setdefault( self.in_use_connection_count(address), [] ).append(address) if not addresses_by_usage: if access_mode == READ_ACCESS: raise ReadServiceUnavailable( "No read service currently available" ) else: raise WriteServiceUnavailable( "No write service currently available" ) return choice(addresses_by_usage[min(addresses_by_usage)]) async def acquire( self, access_mode, timeout, database, bookmarks, liveness_check_timeout ): if access_mode not in (WRITE_ACCESS, READ_ACCESS): raise ClientError("Non valid 'access_mode'; {}".format(access_mode)) if not timeout: raise ClientError("'timeout' must be a float larger than 0; {}" .format(timeout)) from neo4j.api import check_access_mode access_mode = check_access_mode(access_mode) # await self.ensure_routing_table_is_fresh( # access_mode=access_mode, database=database, imp_user=None, # bookmarks=bookmarks, acquisition_timeout=timeout # ) log.debug("[#0000] _: acquire routing connection, " "access_mode=%r, database=%r", access_mode, database) await self.ensure_routing_table_is_fresh( access_mode=access_mode, database=database, imp_user=None, bookmarks=bookmarks, acquisition_timeout=timeout ) while True: try: # Get an address for a connection that have the fewest in-use # connections. address = await self._select_address( access_mode=access_mode, database=database ) except (ReadServiceUnavailable, WriteServiceUnavailable) as err: raise SessionExpired("Failed to obtain connection towards '%s' server." % access_mode) from err try: log.debug("[#0000] _: acquire address, database=%r " "address=%r", database, address) deadline = Deadline.from_timeout_or_deadline(timeout) # should always be a resolved address connection = await self._acquire( address, deadline, liveness_check_timeout ) except (ServiceUnavailable, SessionExpired): await self.deactivate(address=address) else: return connection async def deactivate(self, address): """ Deactivate an address from the connection pool, if present, remove from the routing table and also closing all idle connections to that address. """ log.debug("[#0000] _: deactivating address %r", address) # We use `discard` instead of `remove` here since the former # will not fail if the address has already been removed. for database in self.routing_tables.keys(): self.routing_tables[database].routers.discard(address) self.routing_tables[database].readers.discard(address) self.routing_tables[database].writers.discard(address) log.debug("[#0000] _: table=%r", self.routing_tables) await super(AsyncNeo4jPool, self).deactivate(address) def on_write_failure(self, address): """ Remove a writer address from the routing table, if present. """ log.debug("[#0000] _: removing writer %r", address) for database in self.routing_tables.keys(): self.routing_tables[database].writers.discard(address) log.debug("[#0000] _: table=%r", self.routing_tables) neo4j-python-driver-5.2.1/neo4j/_async/work/000077500000000000000000000000001433522662700206355ustar00rootroot00000000000000neo4j-python-driver-5.2.1/neo4j/_async/work/__init__.py000066400000000000000000000017351433522662700227540ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 .session import ( AsyncResult, AsyncSession, AsyncWorkspace, ) from .transaction import ( AsyncManagedTransaction, AsyncTransaction, AsyncTransactionBase, ) __all__ = [ "AsyncResult", "AsyncSession", "AsyncManagedTransaction", "AsyncTransaction", "AsyncTransactionBase", "AsyncWorkspace", ] neo4j-python-driver-5.2.1/neo4j/_async/work/result.py000066400000000000000000000625041433522662700225340ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations import typing as t from collections import deque from warnings import warn if t.TYPE_CHECKING: import typing_extensions as te from ..._async_compat.util import AsyncUtil from ..._codec.hydration import BrokenHydrationObject from ..._data import ( Record, RecordTableRowExporter, ) from ..._meta import experimental from ...exceptions import ( ResultConsumedError, ResultNotSingleError, ) from ...time import ( Date, DateTime, ) from ...work import ResultSummary from ..io import ConnectionErrorHandler if t.TYPE_CHECKING: import pandas # type: ignore[import] from ...graph import Graph _T = t.TypeVar("_T") _T_ResultKey = t.Union[int, str] _RESULT_OUT_OF_SCOPE_ERROR = ( "The result is out of scope. The associated transaction " "has been closed. Results can only be used while the " "transaction is open." ) _RESULT_CONSUMED_ERROR = ( "The result has been consumed. Fetch all needed records before calling " "Result.consume()." ) class AsyncResult: """A handler for the result of Cypher query execution. Instances of this class are typically constructed and returned by :meth:`.AyncSession.run` and :meth:`.AsyncTransaction.run`. """ def __init__(self, connection, fetch_size, on_closed, on_error): self._connection = ConnectionErrorHandler(connection, on_error) self._hydration_scope = connection.new_hydration_scope() self._on_closed = on_closed self._metadata = None self._keys = None self._record_buffer = deque() self._summary = None self._database = None self._bookmark = None self._raw_qid = -1 self._fetch_size = fetch_size # states self._discarding = False # discard the remainder of records self._attached = False # attached to a connection # there are still more response messages we wait for self._streaming = False # there ar more records available to pull from the server self._has_more = False # the result has been fully iterated or consumed self._exhausted = False # the result has been consumed self._consumed = False # the result has been closed as a result of closing the transaction self._out_of_scope = False @property def _qid(self): if self._raw_qid == self._connection.most_recent_qid: return -1 else: return self._raw_qid async def _tx_ready_run(self, query, parameters): # BEGIN+RUN does not carry any extra on the RUN message. # BEGIN {extra} # RUN "query" {parameters} {extra} await self._run(query, parameters, None, None, None, None) async def _run( self, query, parameters, db, imp_user, access_mode, bookmarks ): query_text = str(query) # Query or string object query_metadata = getattr(query, "metadata", None) query_timeout = getattr(query, "timeout", None) self._metadata = { "query": query_text, "parameters": parameters, "server": self._connection.server_info, "database": db, } self._database = db def on_attached(metadata): self._metadata.update(metadata) # For auto-commit there is no qid and Bolt 3 does not support qid self._raw_qid = metadata.get("qid", -1) if self._raw_qid != -1: self._connection.most_recent_qid = self._raw_qid self._keys = metadata.get("fields") self._attached = True async def on_failed_attach(metadata): self._metadata.update(metadata) self._attached = False await AsyncUtil.callback(self._on_closed) self._connection.run( query_text, parameters=parameters, mode=access_mode, bookmarks=bookmarks, metadata=query_metadata, timeout=query_timeout, db=db, imp_user=imp_user, dehydration_hooks=self._hydration_scope.dehydration_hooks, on_success=on_attached, on_failure=on_failed_attach, ) self._pull() await self._connection.send_all() await self._attach() def _pull(self): def on_records(records): if not self._discarding: records = ( record.raw_data if isinstance(record, BrokenHydrationObject) else record for record in records ) self._record_buffer.extend(( Record(zip(self._keys, record)) for record in records )) async def on_summary(): self._attached = False await AsyncUtil.callback(self._on_closed) async def on_failure(metadata): self._attached = False await AsyncUtil.callback(self._on_closed) def on_success(summary_metadata): self._streaming = False has_more = summary_metadata.get("has_more") self._has_more = bool(has_more) if has_more: return self._metadata.update(summary_metadata) self._bookmark = summary_metadata.get("bookmark") self._database = summary_metadata.get("db", self._database) self._connection.pull( n=self._fetch_size, qid=self._qid, hydration_hooks=self._hydration_scope.hydration_hooks, on_records=on_records, on_success=on_success, on_failure=on_failure, on_summary=on_summary, ) self._streaming = True def _discard(self): async def on_summary(): self._attached = False await AsyncUtil.callback(self._on_closed) async def on_failure(metadata): self._metadata.update(metadata) self._attached = False await AsyncUtil.callback(self._on_closed) def on_success(summary_metadata): self._streaming = False has_more = summary_metadata.get("has_more") self._has_more = bool(has_more) if has_more: return self._discarding = False self._metadata.update(summary_metadata) self._bookmark = summary_metadata.get("bookmark") self._database = summary_metadata.get("db", self._database) # This was the last page received, discard the rest self._connection.discard( n=-1, qid=self._qid, on_success=on_success, on_failure=on_failure, on_summary=on_summary, ) self._streaming = True async def __aiter__(self) -> t.AsyncIterator[Record]: """Iterator returning Records. :returns: Record, it is an immutable ordered collection of key-value pairs. :rtype: :class:`neo4j.Record` """ while self._record_buffer or self._attached: if self._record_buffer: yield self._record_buffer.popleft() elif self._streaming: await self._connection.fetch_message() elif self._discarding: self._discard() await self._connection.send_all() elif self._has_more: self._pull() await self._connection.send_all() self._exhausted = True if self._out_of_scope: raise ResultConsumedError(self, _RESULT_OUT_OF_SCOPE_ERROR) if self._consumed: raise ResultConsumedError(self, _RESULT_CONSUMED_ERROR) async def __anext__(self) -> Record: return await self.__aiter__().__anext__() async def _attach(self): """Sets the Result object in an attached state by fetching messages from the connection to the buffer. """ if self._exhausted is False: while self._attached is False: await self._connection.fetch_message() async def _buffer(self, n=None): """Try to fill `self._record_buffer` with n records. Might end up with more records in the buffer if the fetch size makes it overshoot. Might ent up with fewer records in the buffer if there are not enough records available. """ if self._out_of_scope: raise ResultConsumedError(self, _RESULT_OUT_OF_SCOPE_ERROR) if self._consumed: raise ResultConsumedError(self, _RESULT_CONSUMED_ERROR) if n is not None and len(self._record_buffer) >= n: return record_buffer = deque() async for record in self: record_buffer.append(record) if n is not None and len(record_buffer) >= n: break if n is None: self._record_buffer = record_buffer else: self._record_buffer.extend(record_buffer) self._exhausted = not self._record_buffer async def _buffer_all(self): """Sets the Result object in an detached state by fetching all records from the connection to the buffer. """ await self._buffer() def _obtain_summary(self): """Obtain the summary of this result, buffering any remaining records. :returns: The :class:`neo4j.ResultSummary` for this result """ if self._summary is None: if self._metadata: self._summary = ResultSummary( self._connection.unresolved_address, **self._metadata ) elif self._connection: self._summary = ResultSummary( self._connection.unresolved_address, server=self._connection.server_info ) return self._summary def keys(self) -> t.Tuple[str, ...]: """The keys for the records in this result. :returns: tuple of key names :rtype: tuple """ return self._keys async def _exhaust(self): # Exhaust the result, ditching all remaining records. if not self._exhausted: self._discarding = True self._record_buffer.clear() async for _ in self: pass async def _tx_end(self): # Handle closure of the associated transaction. # # This will consume the result and mark it at out of scope. # Subsequent calls to `next` will raise a ResultConsumedError. await self._exhaust() self._out_of_scope = True async def consume(self) -> ResultSummary: """Consume the remainder of this result and return a :class:`neo4j.ResultSummary`. Example:: async def create_node_tx(tx, name): result = await tx.run( "CREATE (n:ExampleNode { name: $name }) RETURN n", name=name ) record = await result.single() value = record.value() summary = await result.consume() return value, summary async with driver.session() as session: node_id, summary = await session.execute_write( create_node_tx, "example" ) Example:: async def get_two_tx(tx): result = await tx.run("UNWIND [1,2,3,4] AS x RETURN x") values = [] async for record in result: if len(values) >= 2: break values.append(record.values()) # or shorter: values = [record.values() # for record in await result.fetch(2)] # discard the remaining records if there are any summary = await result.consume() # use the summary for logging etc. return values, summary async with driver.session() as session: values, summary = await session.execute_read(get_two_tx) :returns: The :class:`neo4j.ResultSummary` for this result :raises ResultConsumedError: if the transaction from which this result was obtained has been closed. .. versionchanged:: 5.0 Can raise :exc:`ResultConsumedError`. """ if self._out_of_scope: raise ResultConsumedError(self, _RESULT_OUT_OF_SCOPE_ERROR) if self._consumed: return self._obtain_summary() await self._exhaust() summary = self._obtain_summary() self._consumed = True return summary @t.overload async def single( self, strict: te.Literal[False] = False ) -> t.Optional[Record]: ... @t.overload async def single(self, strict: te.Literal[True]) -> Record: ... async def single(self, strict: bool = False) -> t.Optional[Record]: """Obtain the next and only remaining record or None. Calling this method always exhausts the result. A warning is generated if more than one record is available but the first of these is still returned. :param strict: If :const:`True`, raise a :class:`neo4j.ResultNotSingleError` instead of returning None if there is more than one record or warning if there are more than 1 record. :const:`False` by default. :warns: if more than one record is available :raises ResultNotSingleError: If ``strict=True`` and not exactly one record is available. :raises ResultConsumedError: if the transaction from which this result was obtained has been closed or the Result has been explicitly consumed. :returns: the next :class:`neo4j.Record` or :const:`None` if none remain .. versionchanged:: 5.0 Added ``strict`` parameter. .. versionchanged:: 5.0 Can raise :exc:`ResultConsumedError`. """ await self._buffer(2) buffer = self._record_buffer self._record_buffer = deque() await self._exhaust() if not buffer: if not strict: return None raise ResultNotSingleError( self, "No records found. " "Make sure your query returns exactly one record." ) elif len(buffer) > 1: res = buffer.popleft() if not strict: warn("Expected a result with a single record, " "but found multiple.") return res else: raise ResultNotSingleError( self, "More than one record found. " "Make sure your query returns exactly one record." ) return buffer.popleft() async def fetch(self, n: int) -> t.List[Record]: """Obtain up to n records from this result. :param n: the maximum number of records to fetch. :returns: list of :class:`neo4j.Record` :raises ResultConsumedError: if the transaction from which this result was obtained has been closed or the Result has been explicitly consumed. .. versionadded:: 5.0 """ await self._buffer(n) return [ self._record_buffer.popleft() for _ in range(min(n, len(self._record_buffer))) ] async def peek(self) -> t.Optional[Record]: """Obtain the next record from this result without consuming it. This leaves the record in the buffer for further processing. :returns: the next :class:`neo4j.Record` or :const:`None` if none remain. :raises ResultConsumedError: if the transaction from which this result was obtained has been closed or the Result has been explicitly consumed. .. versionchanged:: 5.0 Can raise :exc:`ResultConsumedError`. """ await self._buffer(1) if self._record_buffer: return self._record_buffer[0] return None async def graph(self) -> Graph: """Return a :class:`neo4j.graph.Graph` instance containing all the graph objects in the result. After calling this method, the result becomes detached, buffering all remaining records. :raises ResultConsumedError: if the transaction from which this result was obtained has been closed or the Result has been explicitly consumed. :returns: a result graph .. versionchanged:: 5.0 Can raise :exc:`ResultConsumedError`. """ await self._buffer_all() return self._hydration_scope.get_graph() async def value( self, key: _T_ResultKey = 0, default: t.Optional[object] = None ) -> t.List[t.Any]: """Helper function that return the remainder of the result as a list of values. See :class:`neo4j.Record.value` :param key: field to return for each remaining record. Obtain a single value from the record by index or key. :param default: default value, used if the index of key is unavailable :raises ResultConsumedError: if the transaction from which this result was obtained has been closed or the Result has been explicitly consumed. :returns: list of individual values .. versionchanged:: 5.0 Can raise :exc:`ResultConsumedError`. """ return [record.value(key, default) async for record in self] async def values( self, *keys: _T_ResultKey ) -> t.List[t.List[t.Any]]: """Helper function that return the remainder of the result as a list of values lists. See :class:`neo4j.Record.values` :param keys: fields to return for each remaining record. Optionally filtering to include only certain values by index or key. :raises ResultConsumedError: if the transaction from which this result was obtained has been closed or the Result has been explicitly consumed. :returns: list of values lists .. versionchanged:: 5.0 Can raise :exc:`ResultConsumedError`. """ return [record.values(*keys) async for record in self] async def data(self, *keys: _T_ResultKey) -> t.List[t.Any]: """Helper function that return the remainder of the result as a list of dictionaries. See :class:`neo4j.Record.data` :param keys: fields to return for each remaining record. Optionally filtering to include only certain values by index or key. :returns: list of dictionaries :rtype: list :raises ResultConsumedError: if the transaction from which this result was obtained has been closed or the Result has been explicitly consumed. .. versionchanged:: 5.0 Can raise :exc:`ResultConsumedError`. """ return [record.data(*keys) async for record in self] async def to_df( self, expand: bool = False, parse_dates: bool = False ) -> pandas.DataFrame: r"""Convert (the rest of) the result to a pandas DataFrame. This method is only available if the `pandas` library is installed. :: res = await tx.run("UNWIND range(1, 10) AS n RETURN n, n+1 as m") df = await res.to_df() for instance will return a DataFrame with two columns: ``n`` and ``m`` and 10 rows. :param expand: If :const:`True`, some structures in the result will be recursively expanded (flattened out into multiple columns) like so (everything inside ``<...>`` is a placeholder): * :class:`.Node` objects under any variable ```` will be expanded into columns (the recursion stops here) * ``().prop.`` (any) for each property of the node. * ``().element_id`` (str) the node's element id. See :attr:`.Node.element_id`. * ``().labels`` (frozenset of str) the node's labels. See :attr:`.Node.labels`. * :class:`.Relationship` objects under any variable ```` will be expanded into columns (the recursion stops here) * ``->.prop.`` (any) for each property of the relationship. * ``->.element_id`` (str) the relationship's element id. See :attr:`.Relationship.element_id`. * ``->.start.element_id`` (str) the relationship's start node's element id. See :attr:`.Relationship.start_node`. * ``->.end.element_id`` (str) the relationship's end node's element id. See :attr:`.Relationship.end_node`. * ``->.type`` (str) the relationship's type. See :attr:`.Relationship.type`. * :const:`list` objects under any variable ```` will be expanded into * ``[].0`` (any) the 1st list element * ``[].1`` (any) the 2nd list element * ... * :const:`dict` objects under any variable ```` will be expanded into * ``{}.`` (any) the 1st key of the dict * ``{}.`` (any) the 2nd key of the dict * ... * :const:`list` and :const:`dict` objects are expanded recursively. Example:: variable x: [{"foo": "bar", "baz": [42, 0]}, "foobar"] will be expanded to:: { "x[].0{}.foo": "bar", "x[].0{}.baz[].0": 42, "n[].0{}.baz[].1": 0, "n[].1": "foobar" } * Everything else (including :class:`.Path` objects) will not be flattened. :const:`dict` keys and variable names that contain ``.`` or ``\`` will be escaped with a backslash (``\.`` and ``\\`` respectively). :param parse_dates: If :const:`True`, columns that exclusively contain :class:`time.DateTime` objects, :class:`time.Date` objects, or :const:`None`, will be converted to :class:`pandas.Timestamp`. :raises ImportError: if `pandas` library is not available. :raises ResultConsumedError: if the transaction from which this result was obtained has been closed or the Result has been explicitly consumed. """ import pandas as pd # type: ignore[import] if not expand: df = pd.DataFrame(await self.values(), columns=self._keys) else: df_keys = None rows = [] async for record in self: row = RecordTableRowExporter().transform(dict(record.items())) if df_keys == row.keys(): rows.append(row.values()) elif df_keys is None: df_keys = row.keys() rows.append(row.values()) elif df_keys is False: rows.append(row) else: # The rows have different keys. We need to pass a list # of dicts to pandas rows = [{k: v for k, v in zip(df_keys, r)} for r in rows] df_keys = False rows.append(row) if df_keys is False: df = pd.DataFrame(rows) else: columns = df_keys or [ k.replace(".", "\\.").replace("\\", "\\\\") for k in self._keys ] df = pd.DataFrame(rows, columns=columns) if not parse_dates: return df dt_columns = df.columns[df.apply( lambda col: pd.api.types.infer_dtype(col) == "mixed" and col.map( lambda x: isinstance(x, (DateTime, Date, type(None))) ).all() )] df[dt_columns] = df[dt_columns].apply( lambda col: col.map( lambda x: pd.Timestamp(x.iso_format()) .replace(tzinfo=getattr(x, "tzinfo", None)) if x else pd.NaT ) ) return df def closed(self) -> bool: """Return True if the result has been closed. When a result gets consumed :meth:`consume` or the transaction that owns the result gets closed (committed, rolled back, closed), the result cannot be used to acquire further records. In such case, all methods that need to access the Result's records, will raise a :exc:`ResultConsumedError` when called. :returns: whether the result is closed. .. versionadded:: 5.0 """ return self._out_of_scope or self._consumed neo4j-python-driver-5.2.1/neo4j/_async/work/session.py000066400000000000000000000711651433522662700227040ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations import asyncio import typing as t from logging import getLogger from random import random from time import perf_counter if t.TYPE_CHECKING: import typing_extensions as te from ..io import AsyncBolt _R = t.TypeVar("_R") _P = te.ParamSpec("_P") from ..._async_compat import async_sleep from ..._async_compat.util import AsyncUtil from ..._conf import SessionConfig from ..._meta import deprecated from ...api import ( Bookmarks, READ_ACCESS, WRITE_ACCESS, ) from ...exceptions import ( ClientError, DriverError, Neo4jError, ServiceUnavailable, SessionExpired, TransactionError, ) from ...work import Query from .result import AsyncResult from .transaction import ( AsyncManagedTransaction, AsyncTransaction, ) from .workspace import AsyncWorkspace log = getLogger("neo4j") class AsyncSession(AsyncWorkspace): """A :class:`.AsyncSession` is a logical context for transactional units of work. Connections are drawn from the :class:`.AsyncDriver` connection pool as required. Session creation is a lightweight operation and sessions are not safe to be used in concurrent contexts (multiple threads/coroutines). Therefore, a session should generally be short-lived, and must not span multiple threads/asynchronous Tasks. In general, sessions will be created and destroyed within a `with` context. For example:: async with driver.session() as session: result = await session.run("MATCH (n:Person) RETURN n.name AS name") # do something with the result... :param pool: connection pool instance :param config: session config instance """ # The current connection. _connection: t.Optional[AsyncBolt] = None # The current transaction instance, if any. _transaction: t.Union[AsyncTransaction, AsyncManagedTransaction, None] = \ None # The current auto-transaction result, if any. _auto_result = None # The state this session is in. _state_failed = False def __init__(self, pool, session_config): assert isinstance(session_config, SessionConfig) super().__init__(pool, session_config) self._initialize_bookmarks(session_config.bookmarks) self._bookmark_manager = session_config.bookmark_manager async def __aenter__(self) -> AsyncSession: return self async def __aexit__(self, exception_type, exception_value, traceback): if exception_type: if issubclass(exception_type, asyncio.CancelledError): self._handle_cancellation(message="__aexit__") self._closed = True return self._state_failed = True await self.close() async def _connect(self, access_mode, **access_kwargs): if access_mode is None: access_mode = self._config.default_access_mode try: await super()._connect(access_mode, **access_kwargs) except asyncio.CancelledError: self._handle_cancellation(message="_connect") raise async def _disconnect(self, sync=False): try: return await super()._disconnect(sync=sync) except asyncio.CancelledError: self._handle_cancellation(message="_disconnect") raise def _handle_cancellation(self, message="General"): self._transaction = None self._auto_result = None connection = self._connection self._connection = None if connection: log.debug("[#%04X] _: %s cancellation clean-up", connection.local_port, message) self._pool.kill_and_release(connection) else: log.debug("[#0000] _: %s cancellation clean-up", message) async def _result_closed(self): if self._auto_result: await self._update_bookmark(self._auto_result._database, self._auto_result._bookmark) self._auto_result = None await self._disconnect() async def _result_error(self, error): if isinstance(error, asyncio.CancelledError): return self._handle_cancellation(message="_result_error") if self._auto_result: self._auto_result = None await self._disconnect() async def _get_server_info(self): assert not self._connection await self._connect(READ_ACCESS, liveness_check_timeout=0) server_info = self._connection.server_info await self._disconnect() return server_info async def close(self) -> None: """Close the session. This will release any borrowed resources, such as connections, and will roll back any outstanding transactions. """ if self._closed: return if self._connection: if self._auto_result: if self._state_failed is False: try: await self._auto_result.consume() await self._update_bookmark( self._auto_result._database, self._auto_result._bookmark ) except Exception as error: # TODO: Investigate potential non graceful close states self._auto_result = None self._state_failed = True if self._transaction: if self._transaction._closed() is False: # roll back the transaction if it is not closed await self._transaction._rollback() self._transaction = None try: if self._connection: await self._connection.send_all() await self._connection.fetch_all() # TODO: Investigate potential non graceful close states except Neo4jError: pass except TransactionError: pass except ServiceUnavailable: pass except SessionExpired: pass finally: await self._disconnect() self._state_failed = False self._closed = True if AsyncUtil.is_async_code: def cancel(self) -> None: """Cancel this session. If the session is already closed, this method does nothing. Else, it will if present, forcefully close the connection the session holds. This will violently kill all work in flight. The primary purpose of this function is to handle :class:`asyncio.CancelledError`. :: session = await driver.session() try: ... # do some work except asyncio.CancelledError: session.cancel() raise """ self._handle_cancellation(message="manual cancel") async def run( self, query: t.Union[str, Query], parameters: t.Optional[t.Dict[str, t.Any]] = None, **kwargs: t.Any ) -> AsyncResult: """Run a Cypher query within an auto-commit transaction. The query is sent and the result header received immediately but the :class:`neo4j.Result` content is fetched lazily as consumed by the client application. If a query is executed before a previous :class:`neo4j.AsyncResult` in the same :class:`.AsyncSession` has been fully consumed, the first result will be fully fetched and buffered. Note therefore that the generally recommended pattern of usage is to fully consume one result before executing a subsequent query. If two results need to be consumed in parallel, multiple :class:`.AsyncSession` objects can be used as an alternative to result buffering. For more usage details, see :meth:`.AsyncTransaction.run`. :param query: cypher query :param parameters: dictionary of parameters :param kwargs: additional keyword parameters. These take precedence over parameters passed as ``parameters``. :raises SessionError: if the session has been closed. :returns: a new :class:`neo4j.AsyncResult` object """ self._check_state() if not query: raise ValueError("Cannot run an empty query") if not isinstance(query, (str, Query)): raise TypeError("query must be a string or a Query instance") if self._transaction: raise ClientError("Explicit Transaction must be handled explicitly") if self._auto_result: # This will buffer upp all records for the previous auto-transaction await self._auto_result._buffer_all() if not self._connection: await self._connect(self._config.default_access_mode) cx = self._connection self._auto_result = AsyncResult( cx, self._config.fetch_size, self._result_closed, self._result_error ) bookmarks = await self._get_all_bookmarks() parameters = dict(parameters or {}, **kwargs) await self._auto_result._run( query, parameters, self._config.database, self._config.impersonated_user, self._config.default_access_mode, bookmarks ) return self._auto_result @deprecated( "`last_bookmark` has been deprecated in favor of `last_bookmarks`. " "This method can lead to unexpected behaviour." ) async def last_bookmark(self) -> t.Optional[str]: """Return the bookmark received following the last completed transaction. Note: For auto-transactions (:meth:`Session.run`), this will trigger :meth:`Result.consume` for the current result. .. warning:: This method can lead to unexpected behaviour if the session has not yet successfully completed a transaction. .. deprecated:: 5.0 :meth:`last_bookmark` will be removed in version 6.0. Use :meth:`last_bookmarks` instead. :returns: last bookmark """ # The set of bookmarks to be passed into the next transaction. if self._auto_result: await self._auto_result.consume() if self._transaction and self._transaction._closed(): await self._update_bookmark(self._transaction._database, self._transaction._bookmark) self._transaction = None if self._bookmarks: return self._bookmarks[-1] return None async def last_bookmarks(self) -> Bookmarks: """Return most recent bookmarks of the session. Bookmarks can be used to causally chain sessions. For example, if a session (``session1``) wrote something, that another session (``session2``) needs to read, use ``session2 = driver.session(bookmarks=session1.last_bookmarks())`` to achieve this. Combine the bookmarks of multiple sessions like so:: bookmarks1 = await session1.last_bookmarks() bookmarks2 = await session2.last_bookmarks() session3 = driver.session(bookmarks=bookmarks1 + bookmarks2) A session automatically manages bookmarks, so this method is rarely needed. If you need causal consistency, try to run the relevant queries in the same session. "Most recent bookmarks" are either the bookmarks passed to the session or creation, or the last bookmark the session received after committing a transaction to the server. Note: For auto-transactions (:meth:`Session.run`), this will trigger :meth:`Result.consume` for the current result. :returns: the session's last known bookmarks """ # The set of bookmarks to be passed into the next transaction. if self._auto_result: await self._auto_result.consume() if self._transaction and self._transaction._closed(): await self._update_bookmark(self._transaction._database, self._transaction._bookmark) self._transaction = None return Bookmarks.from_raw_values(self._bookmarks) async def _transaction_closed_handler(self): if self._transaction: await self._update_bookmark(self._transaction._database, self._transaction._bookmark) self._transaction = None await self._disconnect() async def _transaction_error_handler(self, error): if self._transaction: self._transaction = None await self._disconnect() def _transaction_cancel_handler(self): return self._handle_cancellation( message="_transaction_cancel_handler" ) async def _open_transaction( self, *, tx_cls, access_mode, metadata=None, timeout=None ): await self._connect(access_mode=access_mode) self._transaction = tx_cls( self._connection, self._config.fetch_size, self._transaction_closed_handler, self._transaction_error_handler, self._transaction_cancel_handler ) bookmarks = await self._get_all_bookmarks() await self._transaction._begin( self._config.database, self._config.impersonated_user, bookmarks, access_mode, metadata, timeout ) async def begin_transaction( self, metadata: t.Optional[t.Dict[str, t.Any]] = None, timeout: t.Optional[float] = None ) -> AsyncTransaction: """ Begin a new unmanaged transaction. Creates a new :class:`.AsyncTransaction` within this session. At most one transaction may exist in a session at any point in time. To maintain multiple concurrent transactions, use multiple concurrent sessions. Note: For auto-transaction (AsyncSession.run) this will trigger a consume for the current result. :param metadata: a dictionary with metadata. Specified metadata will be attached to the executing transaction and visible in the output of ``SHOW TRANSACTIONS YIELD *`` It will also get logged to the ``query.log``. This functionality makes it easier to tag transactions and is equivalent to the ``dbms.setTXMetaData`` procedure, see https://neo4j.com/docs/cypher-manual/current/clauses/transaction-clauses/#query-listing-transactions and https://neo4j.com/docs/operations-manual/current/reference/procedures/ for reference. :param timeout: the transaction timeout in seconds. Transactions that execute longer than the configured timeout will be terminated by the database. This functionality allows to limit query/transaction execution time. Specified timeout overrides the default timeout configured in the database using ``dbms.transaction.timeout`` setting. Value should not represent a duration of zero or negative duration. :raises TransactionError: if a transaction is already open. :raises SessionError: if the session has been closed. :returns: A new transaction instance. """ self._check_state() # TODO: Implement TransactionConfig consumption if self._auto_result: await self._auto_result.consume() if self._transaction: raise TransactionError( self._transaction, "Explicit transaction already open" ) await self._open_transaction( tx_cls=AsyncTransaction, access_mode=self._config.default_access_mode, metadata=metadata, timeout=timeout ) return t.cast(AsyncTransaction, self._transaction) async def _run_transaction( self, access_mode, transaction_function, *args, **kwargs ): self._check_state() if not callable(transaction_function): raise TypeError("Unit of work is not callable") metadata = getattr(transaction_function, "metadata", None) timeout = getattr(transaction_function, "timeout", None) retry_delay = retry_delay_generator( self._config.initial_retry_delay, self._config.retry_delay_multiplier, self._config.retry_delay_jitter_factor ) errors = [] t0 = -1 # Timer while True: try: await self._open_transaction( tx_cls=AsyncManagedTransaction, access_mode=access_mode, metadata=metadata, timeout=timeout ) tx = self._transaction try: result = await transaction_function(tx, *args, **kwargs) except asyncio.CancelledError: # if cancellation callback has not been called yet: if self._transaction is not None: self._handle_cancellation( message="transaction function" ) raise except Exception: await tx._close() raise else: await tx._commit() except (DriverError, Neo4jError) as error: await self._disconnect() if not error.is_retryable(): raise errors.append(error) else: return result if t0 == -1: # The timer should be started after the first attempt t0 = perf_counter() t1 = perf_counter() if t1 - t0 > self._config.max_transaction_retry_time: break delay = next(retry_delay) log.warning("Transaction failed and will be retried in {}s ({})" "".format(delay, "; ".join(errors[-1].args))) try: await async_sleep(delay) except asyncio.CancelledError: log.debug("[#0000] _: retry cancelled") raise if errors: raise errors[-1] else: raise ServiceUnavailable("Transaction failed") async def execute_read( self, transaction_function: t.Callable[ te.Concatenate[AsyncManagedTransaction, _P], t.Awaitable[_R] ], *args: _P.args, **kwargs: _P.kwargs ) -> _R: """Execute a unit of work in a managed read transaction. .. note:: This does not necessarily imply access control, see the session configuration option :ref:`default-access-mode-ref`. This transaction will automatically be committed when the function returns, unless an exception is thrown during query execution or by the user code. Note, that this function performs retries and that the supplied `transaction_function` might get invoked more than once. Therefore, it needs to be idempotent (i.e., have the same effect, regardless if called once or many times). Example:: async def do_cypher_tx(tx, cypher): result = await tx.run(cypher) values = [record.values() async for record in result] return values async with driver.session() as session: values = await session.execute_read(do_cypher_tx, "RETURN 1 AS x") Example:: async def get_two_tx(tx): result = await tx.run("UNWIND [1,2,3,4] AS x RETURN x") values = [] async for record in result: if len(values) >= 2: break values.append(record.values()) # or shorter: values = [record.values() # for record in await result.fetch(2)] # discard the remaining records if there are any summary = await result.consume() # use the summary for logging etc. return values async with driver.session() as session: values = await session.execute_read(get_two_tx) :param transaction_function: a function that takes a transaction as an argument and does work with the transaction. `transaction_function(tx, *args, **kwargs)` where `tx` is a :class:`.AsyncManagedTransaction`. :param args: additional arguments for the `transaction_function` :param kwargs: key word arguments for the `transaction_function` :raises SessionError: if the session has been closed. :return: a result as returned by the given unit of work .. versionadded:: 5.0 """ return await self._run_transaction( READ_ACCESS, transaction_function, *args, **kwargs ) # TODO 6.0: Remove this method @deprecated("read_transaction has been renamed to execute_read") async def read_transaction( self, transaction_function: t.Callable[ te.Concatenate[AsyncManagedTransaction, _P], t.Awaitable[_R] ], *args: _P.args, **kwargs: _P.kwargs ) -> _R: """Execute a unit of work in a managed read transaction. .. note:: This does not necessarily imply access control, see the session configuration option :ref:`default-access-mode-ref`. This transaction will automatically be committed when the function returns, unless an exception is thrown during query execution or by the user code. Note, that this function performs retries and that the supplied `transaction_function` might get invoked more than once. Therefore, it needs to be idempotent (i.e., have the same effect, regardless if called once or many times). Example:: async def do_cypher_tx(tx, cypher): result = await tx.run(cypher) values = [record.values() async for record in result] return values async with driver.session() as session: values = await session.read_transaction(do_cypher_tx, "RETURN 1 AS x") Example:: async def get_two_tx(tx): result = await tx.run("UNWIND [1,2,3,4] AS x RETURN x") values = [] async for record in result: if len(values) >= 2: break values.append(record.values()) # or shorter: values = [record.values() # for record in await result.fetch(2)] # discard the remaining records if there are any summary = await result.consume() # use the summary for logging etc. return values async with driver.session() as session: values = await session.read_transaction(get_two_tx) :param transaction_function: a function that takes a transaction as an argument and does work with the transaction. `transaction_function(tx, *args, **kwargs)` where `tx` is a :class:`.AsyncManagedTransaction`. :param args: additional arguments for the `transaction_function` :param kwargs: key word arguments for the `transaction_function` :raises SessionError: if the session has been closed. :return: a result as returned by the given unit of work .. deprecated:: 5.0 Method was renamed to :meth:`.execute_read`. """ return await self._run_transaction( READ_ACCESS, transaction_function, *args, **kwargs ) async def execute_write( self, transaction_function: t.Callable[ te.Concatenate[AsyncManagedTransaction, _P], t.Awaitable[_R] ], *args: _P.args, **kwargs: _P.kwargs ) -> _R: """Execute a unit of work in a managed write transaction. .. note:: This does not necessarily imply access control, see the session configuration option :ref:`default-access-mode-ref`. This transaction will automatically be committed when the function returns unless, an exception is thrown during query execution or by the user code. Note, that this function performs retries and that the supplied `transaction_function` might get invoked more than once. Therefore, it needs to be idempotent (i.e., have the same effect, regardless if called once or many times). Example:: async def create_node_tx(tx, name): query = "CREATE (n:NodeExample { name: $name }) RETURN id(n) AS node_id" result = await tx.run(query, name=name) record = await result.single() return record["node_id"] async with driver.session() as session: node_id = await session.execute_write(create_node_tx, "example") :param transaction_function: a function that takes a transaction as an argument and does work with the transaction. `transaction_function(tx, *args, **kwargs)` where `tx` is a :class:`.AsyncManagedTransaction`. :param args: additional arguments for the `transaction_function` :param kwargs: key word arguments for the `transaction_function` :raises SessionError: if the session has been closed. :return: a result as returned by the given unit of work .. versionadded:: 5.0 """ return await self._run_transaction( WRITE_ACCESS, transaction_function, *args, **kwargs ) # TODO 6.0: Remove this method @deprecated("write_transaction has been renamed to execute_write") async def write_transaction( self, transaction_function: t.Callable[ te.Concatenate[AsyncManagedTransaction, _P], t.Awaitable[_R] ], *args: _P.args, **kwargs: _P.kwargs ) -> _R: """Execute a unit of work in a managed write transaction. .. note:: This does not necessarily imply access control, see the session configuration option :ref:`default-access-mode-ref`. This transaction will automatically be committed when the function returns unless, an exception is thrown during query execution or by the user code. Note, that this function performs retries and that the supplied `transaction_function` might get invoked more than once. Therefore, it needs to be idempotent (i.e., have the same effect, regardless if called once or many times). Example:: async def create_node_tx(tx, name): query = "CREATE (n:NodeExample { name: $name }) RETURN id(n) AS node_id" result = await tx.run(query, name=name) record = await result.single() return record["node_id"] async with driver.session() as session: node_id = await session.write_transaction(create_node_tx, "example") :param transaction_function: a function that takes a transaction as an argument and does work with the transaction. `transaction_function(tx, *args, **kwargs)` where `tx` is a :class:`.AsyncManagedTransaction`. :param args: additional arguments for the `transaction_function` :param kwargs: key word arguments for the `transaction_function` :raises SessionError: if the session has been closed. :return: a result as returned by the given unit of work .. deprecated:: 5.0 Method was renamed to :meth:`.execute_write`. """ return await self._run_transaction( WRITE_ACCESS, transaction_function, *args, **kwargs ) def retry_delay_generator(initial_delay, multiplier, jitter_factor): delay = initial_delay while True: jitter = jitter_factor * delay yield delay - jitter + (2 * jitter * random()) delay *= multiplier neo4j-python-driver-5.2.1/neo4j/_async/work/transaction.py000066400000000000000000000254051433522662700235420ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations import asyncio import typing as t from functools import wraps from ..._async_compat.util import AsyncUtil from ...exceptions import TransactionError from ...work import Query from ..io import ConnectionErrorHandler from .result import AsyncResult __all__ = ( "AsyncManagedTransaction", "AsyncTransaction", "AsyncTransactionBase", ) class AsyncTransactionBase: def __init__(self, connection, fetch_size, on_closed, on_error, on_cancel): self._connection = connection self._error_handling_connection = ConnectionErrorHandler( connection, self._error_handler ) self._bookmark = None self._database = None self._results = [] self._closed_flag = False self._last_error = None self._fetch_size = fetch_size self._on_closed = on_closed self._on_error = on_error self._on_cancel = on_cancel async def _enter(self): return self async def _exit(self, exception_type, exception_value, traceback): if self._closed_flag: return success = not bool(exception_type) if success: await self._commit() elif issubclass(exception_type, asyncio.CancelledError): self._cancel() return await self._close() async def _begin( self, database, imp_user, bookmarks, access_mode, metadata, timeout ): self._database = database self._connection.begin( bookmarks=bookmarks, metadata=metadata, timeout=timeout, mode=access_mode, db=database, imp_user=imp_user ) await self._error_handling_connection.send_all() await self._error_handling_connection.fetch_all() async def _result_on_closed_handler(self): pass async def _error_handler(self, exc): self._last_error = exc if isinstance(exc, asyncio.CancelledError): self._cancel() return await AsyncUtil.callback(self._on_error, exc) async def _consume_results(self): for result in self._results: await result._tx_end() self._results = [] async def run( self, query: str, parameters: t.Optional[t.Dict[str, t.Any]] = None, **kwparameters: t.Any ) -> AsyncResult: """ Run a Cypher query within the context of this transaction. Cypher is typically expressed as a query template plus a set of named parameters. In Python, parameters may be expressed through a dictionary of parameters, through individual parameter arguments, or as a mixture of both. For example, the `run` queries below are all equivalent:: >>> query = "CREATE (a:Person { name: $name, age: $age })" >>> result = await tx.run(query, {"name": "Alice", "age": 33}) >>> result = await tx.run(query, {"name": "Alice"}, age=33) >>> result = await tx.run(query, name="Alice", age=33) Parameter values can be of any type supported by the Neo4j type system. In Python, this includes :class:`bool`, :class:`int`, :class:`str`, :class:`list` and :class:`dict`. Note however that :class:`list` properties must be homogenous. :param query: cypher query :param parameters: dictionary of parameters :param kwparameters: additional keyword parameters. These take precedence over parameters passed as ``parameters``. :raise TransactionError: if the transaction is already closed :returns: a new :class:`neo4j.AsyncResult` object """ if isinstance(query, Query): raise ValueError("Query object is only supported for session.run") if self._closed_flag: raise TransactionError(self, "Transaction closed") if self._last_error: raise TransactionError(self, "Transaction failed") from self._last_error if (self._results and self._connection.supports_multiple_results is False): # Bolt 3 Support # Buffer up all records for the previous Result because it does not # have any qid to fetch in batches. await self._results[-1]._buffer_all() result = AsyncResult( self._connection, self._fetch_size, self._result_on_closed_handler, self._error_handler ) self._results.append(result) parameters = dict(parameters or {}, **kwparameters) await result._tx_ready_run(query, parameters) return result async def _commit(self): """Mark this transaction as successful and close in order to trigger a COMMIT. :raise TransactionError: if the transaction is already closed """ if self._closed_flag: raise TransactionError(self, "Transaction closed") if self._last_error: raise TransactionError(self, "Transaction failed") from self._last_error metadata = {} try: # DISCARD pending records then do a commit. await self._consume_results() self._connection.commit(on_success=metadata.update) await self._connection.send_all() await self._connection.fetch_all() self._bookmark = metadata.get("bookmark") self._database = metadata.get("db", self._database) except asyncio.CancelledError: self._on_cancel() raise finally: self._closed_flag = True await AsyncUtil.callback(self._on_closed) return self._bookmark async def _rollback(self): """Mark this transaction as unsuccessful and close in order to trigger a ROLLBACK. :raise TransactionError: if the transaction is already closed """ if self._closed_flag: raise TransactionError(self, "Transaction closed") metadata = {} try: if not (self._connection.defunct() or self._connection.closed() or self._connection.is_reset): # DISCARD pending records then do a rollback. await self._consume_results() self._connection.rollback(on_success=metadata.update) await self._connection.send_all() await self._connection.fetch_all() except asyncio.CancelledError: self._on_cancel() raise finally: self._closed_flag = True await AsyncUtil.callback(self._on_closed) async def _close(self): """Close this transaction, triggering a ROLLBACK if not closed. """ if self._closed_flag: return await self._rollback() if AsyncUtil.is_async_code: def _cancel(self) -> None: """Cancel this transaction. If the transaction is already closed, this method does nothing. Else, it will close the connection without ROLLBACK or COMMIT in a non-blocking manner. The primary purpose of this function is to handle :class:`asyncio.CancelledError`. :: tx = await session.begin_transaction() try: ... # do some work except asyncio.CancelledError: tx.cancel() raise """ if self._closed_flag: return try: self._on_cancel() finally: self._closed_flag = True def _closed(self): """Indicate whether the transaction has been closed or cancelled. :return: :const:`True` if closed or cancelled, :const:`False` otherwise. :rtype: bool """ return self._closed_flag class AsyncTransaction(AsyncTransactionBase): """ Container for multiple Cypher queries to be executed within a single context. :class:`AsyncTransaction` objects can be used as a context managers (:py:const:`async with` block) where the transaction is committed or rolled back on based on whether an exception is raised:: async with await session.begin_transaction() as tx: ... """ @wraps(AsyncTransactionBase._enter) async def __aenter__(self) -> AsyncTransaction: return await self._enter() @wraps(AsyncTransactionBase._exit) async def __aexit__(self, exception_type, exception_value, traceback): await self._exit(exception_type, exception_value, traceback) @wraps(AsyncTransactionBase._commit) async def commit(self) -> None: return await self._commit() @wraps(AsyncTransactionBase._rollback) async def rollback(self) -> None: return await self._rollback() @wraps(AsyncTransactionBase._close) async def close(self) -> None: return await self._close() @wraps(AsyncTransactionBase._closed) def closed(self) -> bool: return self._closed() if AsyncUtil.is_async_code: @wraps(AsyncTransactionBase._cancel) def cancel(self) -> None: return self._cancel() class AsyncManagedTransaction(AsyncTransactionBase): """Transaction object provided to transaction functions. Inside a transaction function, the driver is responsible for managing (committing / rolling back) the transaction. Therefore, AsyncManagedTransactions don't offer such methods. Otherwise, they behave like :class:`.AsyncTransaction`. * To commit the transaction, return anything from the transaction function. * To rollback the transaction, raise any exception. Note that transaction functions have to be idempotent (i.e., the result of running the function once has to be the same as running it any number of times). This is, because the driver will retry the transaction function if the error is classified as retryable. .. versionadded:: 5.0 Prior, transaction functions used :class:`AsyncTransaction` objects, but would cause hard to interpret errors when managed explicitly (committed or rolled back by user code). """ pass neo4j-python-driver-5.2.1/neo4j/_async/work/workspace.py000066400000000000000000000206451433522662700232140ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations import asyncio import logging from ..._async_compat.util import AsyncUtil from ..._conf import WorkspaceConfig from ..._meta import ( deprecation_warn, unclosed_resource_warn, ) from ...api import Bookmarks from ...exceptions import ( ServiceUnavailable, SessionError, SessionExpired, ) from ..io import AsyncNeo4jPool log = logging.getLogger("neo4j") class AsyncWorkspace: def __init__(self, pool, config): assert isinstance(config, WorkspaceConfig) self._pool = pool self._config = config self._connection = None self._connection_access_mode = None # Sessions are supposed to cache the database on which to operate. self._cached_database = False self._bookmarks = () self._initial_bookmarks = () self._bookmark_manager = None self._last_from_bookmark_manager = None # Workspace has been closed. self._closed = False def __del__(self): if self._closed: return unclosed_resource_warn(self) # TODO: 6.0 - remove this if asyncio.iscoroutinefunction(self.close): return try: deprecation_warn( "Relying on AsyncSession's destructor to close the session " "is deprecated. Please make sure to close the session. Use it " "as a context (`with` statement) or make sure to call " "`.close()` explicitly. Future versions of the driver will " "not close sessions automatically." ) self.close() except (OSError, ServiceUnavailable, SessionExpired): pass async def __aenter__(self) -> AsyncWorkspace: return self async def __aexit__(self, exc_type, exc_value, traceback): await self.close() def _set_cached_database(self, database): self._cached_database = True self._config.database = database def _initialize_bookmarks(self, bookmarks): if isinstance(bookmarks, Bookmarks): prepared_bookmarks = tuple(bookmarks.raw_values) elif hasattr(bookmarks, "__iter__"): deprecation_warn( "Passing an iterable as `bookmarks` to `Session` is " "deprecated. Please use a `Bookmarks` instance.", stack_level=5 ) prepared_bookmarks = tuple(bookmarks) elif not bookmarks: prepared_bookmarks = () else: raise TypeError("Bookmarks must be an instance of Bookmarks or an " "iterable of raw bookmarks (deprecated).") self._initial_bookmarks = self._bookmarks = prepared_bookmarks async def _get_bookmarks(self, database): if self._bookmark_manager is None: return self._bookmarks # For 4.3- support: the server will not send the resolved home # database back. To avoid confusion between `None` as in "all # database" and `None` as in "home database" we re-write the # home database to `""`, which otherwise is an invalid database # name. It will not work properly either way, as the home database # can change (server config change or client side user change). if database is None: database = "" self._last_from_bookmark_manager = tuple({ *await AsyncUtil.callback( self._bookmark_manager.get_bookmarks, database ), *self._initial_bookmarks }) return self._last_from_bookmark_manager async def _get_all_bookmarks(self): if self._bookmark_manager is None: return self._bookmarks self._last_from_bookmark_manager = tuple({ *await AsyncUtil.callback( self._bookmark_manager.get_all_bookmarks, ), *self._initial_bookmarks }) return self._last_from_bookmark_manager async def _update_bookmarks(self, database, new_bookmarks): if not new_bookmarks: return self._initial_bookmarks = () self._bookmarks = new_bookmarks if self._bookmark_manager is None: return previous_bookmarks = self._last_from_bookmark_manager # For 4.3- support: the server will not send the resolved home # database back. To avoid confusion between `None` as in "all # database" and `None` as in "home database" we re-write the home # database to `""`, which otherwise is an invalid database name. if database is None: database = "" await AsyncUtil.callback( self._bookmark_manager.update_bookmarks, database, previous_bookmarks, new_bookmarks ) async def _update_bookmark(self, database, bookmark): if not bookmark: return if not database: database = self._config.database await self._update_bookmarks(database, (bookmark,)) async def _connect(self, access_mode, **acquire_kwargs): acquisition_timeout = self._config.connection_acquisition_timeout if self._connection: # TODO: Investigate this # log.warning("FIXME: should always disconnect before connect") await self._connection.send_all() await self._connection.fetch_all() await self._disconnect() if not self._cached_database: if (self._config.database is not None or not isinstance(self._pool, AsyncNeo4jPool)): self._set_cached_database(self._config.database) else: # This is the first time we open a connection to a server in a # cluster environment for this session without explicitly # configured database. Hence, we request a routing table update # to try to fetch the home database. If provided by the server, # we shall use this database explicitly for all subsequent # actions within this session. log.debug("[#0000] _: resolve home database") await self._pool.update_routing_table( database=self._config.database, imp_user=self._config.impersonated_user, bookmarks=await self._get_bookmarks("system"), acquisition_timeout=acquisition_timeout, database_callback=self._set_cached_database ) acquire_kwargs_ = { "access_mode": access_mode, "timeout": acquisition_timeout, "database": self._config.database, "bookmarks": await self._get_bookmarks("system"), "liveness_check_timeout": None, } acquire_kwargs_.update(acquire_kwargs) self._connection = await self._pool.acquire(**acquire_kwargs_) self._connection_access_mode = access_mode async def _disconnect(self, sync=False): if self._connection: if sync: try: await self._connection.send_all() await self._connection.fetch_all() except ServiceUnavailable: pass if self._connection: await self._pool.release(self._connection) self._connection = None self._connection_access_mode = None async def close(self) -> None: if self._closed: return await self._disconnect(sync=True) self._closed = True def closed(self) -> bool: """Indicate whether the session has been closed. :return: :const:`True` if closed, :const:`False` otherwise. """ return self._closed def _check_state(self): if self._closed: raise SessionError(self, "Session closed") neo4j-python-driver-5.2.1/neo4j/_async_compat/000077500000000000000000000000001433522662700212165ustar00rootroot00000000000000neo4j-python-driver-5.2.1/neo4j/_async_compat/__init__.py000066400000000000000000000013631433522662700233320ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 asyncio import sleep as async_sleep from time import sleep __all__ = [ "async_sleep", "sleep", ] neo4j-python-driver-5.2.1/neo4j/_async_compat/concurrency.py000066400000000000000000000334301433522662700241250ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations import asyncio import collections import re import threading import typing as t if t.TYPE_CHECKING: import typing_extensions as te from neo4j._async_compat.shims import wait_for __all__ = [ "AsyncCondition", "AsyncCooperativeLock", "AsyncCooperativeRLock", "AsyncLock", "AsyncRLock", "Condition", "CooperativeLock", "CooperativeRLock", "Lock", "RLock", ] AsyncLock = asyncio.Lock class AsyncRLock(asyncio.Lock): """Reentrant asyncio.lock Inspired by Python's RLock implementation .. warning:: In async Python there are no threads. This implementation uses :meth:`asyncio.current_task()` to determine the owner of the lock. This means that the owner changes when using :meth:`asyncio.wait_for` or any other method that wraps the work in a new :class:`asyncio.Task`. """ _WAITERS_RE = re.compile(r"(?:\W|^)waiters[:=](\d+)(?:\W|$)") def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self._owner = None self._count = 0 def __repr__(self): res = object.__repr__(self) lock_repr = super().__repr__() extra = "locked" if self._count > 0 else "unlocked" extra += f" count={self._count}" waiters_match = self._WAITERS_RE.search(lock_repr) if waiters_match: extra += f" waiters={waiters_match.group(1)}" if self._owner: extra += f" owner={self._owner}" return f'<{res[1:-1]} [{extra}]>' def is_owner(self, task=None): if task is None: task = asyncio.current_task() return self._owner == task async def _acquire_non_blocking(self, me): if self.is_owner(task=me): self._count += 1 return True acquire_coro = super().acquire() task = asyncio.ensure_future(acquire_coro) # yielding one cycle is as close to non-blocking as it gets # (at least without implementing the lock from the ground up) try: await asyncio.sleep(0) except asyncio.CancelledError: # This is emulating non-blocking. There is no cancelling this! # Still, we don't want to silently swallow the cancellation. # Hence, we flag this task as cancelled again, so that the next # `await` will raise the CancelledError. asyncio.current_task().cancel() if task.done() and task.exception() is None: self._owner = me self._count = 1 return True task.cancel() return False async def _acquire(self, me): if self.is_owner(task=me): self._count += 1 return await super().acquire() self._owner = me self._count = 1 async def acquire(self, blocking=True, timeout=-1): """Acquire the lock.""" me = asyncio.current_task() if timeout < 0 and timeout != -1: raise ValueError("timeout value must be positive") if not blocking and timeout != -1: raise ValueError("can't specify a timeout for a non-blocking call") if not blocking: return await self._acquire_non_blocking(me) if blocking and timeout == -1: await self._acquire(me) return True try: fut = asyncio.ensure_future(self._acquire(me)) try: await wait_for(fut, timeout) except asyncio.CancelledError: already_finished = not fut.cancel() if already_finished: # Too late to cancel the acquisition. # This can only happen in Python 3.7's asyncio # as well as in our wait_for shim. self._release(me) raise return True except asyncio.TimeoutError: return False __aenter__ = acquire def _release(self, me): if not self.is_owner(task=me): if self._owner is None: raise RuntimeError("Cannot release un-acquired lock.") raise RuntimeError("Cannot release foreign lock.") self._count -= 1 if not self._count: self._owner = None super().release() def release(self): """Release the lock""" me = asyncio.current_task() return self._release(me) async def __aexit__(self, t, v, tb): self.release() class AsyncCooperativeLock: """Lock placeholder for asyncio Python when working fully cooperatively. This lock doesn't do anything in async Python. It's threaded counterpart, however, is an ordinary :class:`threading.Lock`. The AsyncCooperativeLock only works if there is no await being used while the lock is acquired. """ def __init__(self): self._locked = False def __repr__(self): res = super().__repr__() extra = "locked" if self._locked else "unlocked" return f"<{res[1:-1]} [{extra}]>" def locked(self): """Return True if lock is acquired.""" return self._locked def acquire(self): """Acquire a lock. This method will raise a RuntimeError where an ordinary (non-placeholder) lock would need to block. I.e., when the lock is already taken. Returns True if the lock was successfully acquired. """ if self._locked: raise RuntimeError("Cannot acquire a locked cooperative lock.") self._locked = True return True def release(self): """Release a lock. When the lock is locked, reset it to unlocked, and return. When invoked on an unlocked lock, a RuntimeError is raised. There is no return value. """ if self._locked: self._locked = False else: raise RuntimeError("Lock is not acquired.") __enter__ = acquire def __exit__(self, t, v, tb): self.release() async def __aenter__(self): return self.__enter__() async def __aexit__(self, t, v, tb): self.__exit__(t, v, tb) class AsyncCooperativeRLock: """Reentrant lock placeholder for cooperative asyncio Python. This lock doesn't do anything in async Python. It's threaded counterpart, however, is an ordinary :class:`threading.Lock`. The AsyncCooperativeLock only works if there is no await being used while the lock is acquired. """ def __init__(self): self._owner = None self._count = 0 def __repr__(self): res = super().__repr__() if self._owner is not None: extra = f"locked {self._count} times by owner:{self._owner}" else: extra = "unlocked" return f'<{res[1:-1]} [{extra}]>' def locked(self): """Return True if lock is acquired.""" return self._owner is not None def acquire(self): """Acquire a lock. This method will raise a RuntimeError where an ordinary (non-placeholder) lock would need to block. I.e., when the lock is already taken by another Task. Returns True if the lock was successfully acquired. """ me = asyncio.current_task() if self._owner is None: self._owner = me self._count = 1 return True if self._owner is me: self._count += 1 return True raise RuntimeError( "Cannot acquire a foreign locked cooperative lock." ) def release(self): """Release a lock. When the lock is locked, reset it to unlocked, and return. When invoked on an unlocked or foreign lock, a RuntimeError is raised. There is no return value. """ me = asyncio.current_task() if self._owner is None: raise RuntimeError("Lock is not acquired.") if self._owner is not me: raise RuntimeError("Cannot release a foreign lock.") self._count -= 1 if not self._count: self._owner = None __enter__ = acquire def __exit__(self, t, v, tb): self.release() # copied and modified from asyncio.locks (3.7) # to add support for `.wait(timeout)` class AsyncCondition: """Asynchronous equivalent to threading.Condition. This class implements condition variable objects. A condition variable allows one or more coroutines to wait until they are notified by another coroutine. A new Lock object is created and used as the underlying lock. """ def __init__(self, lock=None, *, loop=None): if loop is not None: self._loop = loop else: self._loop = asyncio.get_event_loop() if lock is None: lock = asyncio.Lock(loop=self._loop) elif (hasattr(lock, "_loop") and lock._loop is not None and lock._loop is not self._loop): raise ValueError("loop argument must agree with lock") self._lock = lock # Export the lock's locked(), acquire() and release() methods. self.locked = lock.locked self.acquire = lock.acquire self.release = lock.release self._waiters = collections.deque() async def __aenter__(self): if isinstance(self._lock, (AsyncCooperativeLock, AsyncCooperativeRLock)): self._lock.acquire() else: await self.acquire() # We have no use for the "as ..." clause in the with # statement for locks. return None async def __aexit__(self, exc_type, exc, tb): self.release() def __repr__(self): res = super().__repr__() extra = 'locked' if self.locked() else 'unlocked' if self._waiters: extra = f'{extra}, waiters:{len(self._waiters)}' return f'<{res[1:-1]} [{extra}]>' async def _wait(self, timeout=None, me=None): """Wait until notified. If the calling coroutine has not acquired the lock when this method is called, a RuntimeError is raised. This method releases the underlying lock, and then blocks until it is awakened by a notify() or notify_all() call for the same condition variable in another coroutine. Once awakened, it re-acquires the lock and returns True. """ if not self.locked(): raise RuntimeError('cannot wait on un-acquired lock') cancelled = False if isinstance(self._lock, AsyncRLock): self._lock._release(me) else: self._lock.release() try: fut = self._loop.create_future() self._waiters.append(fut) try: await wait_for(fut, timeout) return True except asyncio.TimeoutError: return False except asyncio.CancelledError: cancelled = True raise finally: self._waiters.remove(fut) finally: # Must reacquire lock even if wait is cancelled if isinstance(self._lock, (AsyncCooperativeLock, AsyncCooperativeRLock)): self._lock.acquire() else: while True: try: if isinstance(self._lock, AsyncRLock): await self._lock._acquire(me) else: await self._lock.acquire() break except asyncio.CancelledError: cancelled = True if cancelled: raise asyncio.CancelledError async def wait(self, timeout=None): me = asyncio.current_task() return await self._wait(timeout=timeout, me=me) def notify(self, n=1): """By default, wake up one coroutine waiting on this condition, if any. If the calling coroutine has not acquired the lock when this method is called, a RuntimeError is raised. This method wakes up at most n of the coroutines waiting for the condition variable; it is a no-op if no coroutines are waiting. Note: an awakened coroutine does not actually return from its wait() call until it can reacquire the lock. Since notify() does not release the lock, its caller should. """ if not self.locked(): raise RuntimeError('cannot notify on un-acquired lock') idx = 0 for fut in self._waiters: if idx >= n: break if not fut.done(): idx += 1 fut.set_result(False) def notify_all(self): """Wake up all threads waiting on this condition. This method acts like notify(), but wakes up all waiting threads instead of one. If the calling thread has not acquired the lock when this method is called, a RuntimeError is raised. """ self.notify(len(self._waiters)) Condition: te.TypeAlias = threading.Condition CooperativeLock: te.TypeAlias = threading.Lock Lock: te.TypeAlias = threading.Lock CooperativeRLock: te.TypeAlias = threading.RLock RLock: te.TypeAlias = threading.RLock neo4j-python-driver-5.2.1/neo4j/_async_compat/network/000077500000000000000000000000001433522662700227075ustar00rootroot00000000000000neo4j-python-driver-5.2.1/neo4j/_async_compat/network/__init__.py000066400000000000000000000015501433522662700250210ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 ._bolt_socket import ( AsyncBoltSocket, BoltSocket, ) from ._util import ( AsyncNetworkUtil, NetworkUtil, ) __all__ = [ "AsyncBoltSocket", "AsyncNetworkUtil", "BoltSocket", "NetworkUtil", ] neo4j-python-driver-5.2.1/neo4j/_async_compat/network/_bolt_socket.py000066400000000000000000000577711433522662700257510ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations import asyncio import logging import selectors import struct import typing as t from socket import ( AF_INET, AF_INET6, SHUT_RDWR, SO_KEEPALIVE, socket, SOL_SOCKET, timeout as SocketTimeout, ) from ssl import ( CertificateError, HAS_SNI, SSLError, SSLSocket, ) if t.TYPE_CHECKING: import typing_extensions as te from ..._async.io import AsyncBolt from ..._sync.io import Bolt from ... import addressing from ..._deadline import Deadline from ..._exceptions import ( BoltError, BoltProtocolError, BoltSecurityError, SocketDeadlineExceeded, ) from ...exceptions import ( DriverError, ServiceUnavailable, ) from ..shims import wait_for from ._util import ( AsyncNetworkUtil, NetworkUtil, ) log = logging.getLogger("neo4j") def _sanitize_deadline(deadline): if deadline is None: return None deadline = Deadline.from_timeout_or_deadline(deadline) if deadline.to_timeout() is None: return None return deadline class AsyncBoltSocket: Bolt: te.Final[t.Type[AsyncBolt]] = None # type: ignore[assignment] def __init__(self, reader, protocol, writer): self._reader = reader # type: asyncio.StreamReader self._protocol = protocol # type: asyncio.StreamReaderProtocol self._writer = writer # type: asyncio.StreamWriter # 0 - non-blocking # None infinitely blocking # int - seconds to wait for data self._timeout = None self._deadline = None async def _wait_for_io(self, io_fut): timeout = self._timeout to_raise = SocketTimeout if self._deadline is not None: deadline_timeout = self._deadline.to_timeout() if deadline_timeout <= 0: raise SocketDeadlineExceeded("timed out") if timeout is None or deadline_timeout <= timeout: timeout = deadline_timeout to_raise = SocketDeadlineExceeded if timeout is not None and timeout <= 0: # give the io-operation time for one loop cycle to do its thing io_fut = asyncio.create_task(io_fut) try: await asyncio.sleep(0) except asyncio.CancelledError: # This is emulating non-blocking. There is no cancelling this! # Still, we don't want to silently swallow the cancellation. # Hence, we flag this task as cancelled again, so that the next # `await` will raise the CancelledError. asyncio.current_task().cancel() try: return await wait_for(io_fut, timeout) except asyncio.TimeoutError as e: raise to_raise("timed out") from e def get_deadline(self): return self._deadline def set_deadline(self, deadline): self._deadline = _sanitize_deadline(deadline) @property def _socket(self) -> socket: return self._writer.transport.get_extra_info("socket") def getsockname(self): return self._writer.transport.get_extra_info("sockname") def getpeername(self): return self._writer.transport.get_extra_info("peername") def getpeercert(self, *args, **kwargs): return self._writer.transport.get_extra_info("ssl_object")\ .getpeercert(*args, **kwargs) def gettimeout(self): return self._timeout def settimeout(self, timeout): if timeout is None: self._timeout = timeout else: assert timeout >= 0 self._timeout = timeout async def recv(self, n): io_fut = self._reader.read(n) return await self._wait_for_io(io_fut) async def recv_into(self, buffer, nbytes): # FIXME: not particularly memory or time efficient io_fut = self._reader.read(nbytes) res = await self._wait_for_io(io_fut) buffer[:len(res)] = res return len(res) async def sendall(self, data): self._writer.write(data) io_fut = self._writer.drain() return await self._wait_for_io(io_fut) async def close(self): self._writer.close() await self._writer.wait_closed() def kill(self): self._writer.close() @classmethod async def _connect_secure(cls, resolved_address, timeout, keep_alive, ssl): """ :param resolved_address: :param timeout: seconds :param keep_alive: True or False :param ssl: SSLContext or None :return: AsyncBoltSocket object """ loop = asyncio.get_event_loop() s = None # TODO: tomorrow me: fix this mess try: if len(resolved_address) == 2: s = socket(AF_INET) elif len(resolved_address) == 4: s = socket(AF_INET6) else: raise ValueError( "Unsupported address {!r}".format(resolved_address)) s.setblocking(False) # asyncio + blocking = no-no! log.debug("[#0000] C: %s", resolved_address) await wait_for( loop.sock_connect(s, resolved_address), timeout ) keep_alive = 1 if keep_alive else 0 s.setsockopt(SOL_SOCKET, SO_KEEPALIVE, keep_alive) ssl_kwargs = {} if ssl is not None: hostname = resolved_address.host_name or None ssl_kwargs.update( ssl=ssl, server_hostname=hostname if HAS_SNI else None ) reader = asyncio.StreamReader( limit=2 ** 16, # 64 KiB, loop=loop ) protocol = asyncio.StreamReaderProtocol(reader, loop=loop) transport, _ = await loop.create_connection( lambda: protocol, sock=s, **ssl_kwargs ) writer = asyncio.StreamWriter(transport, protocol, reader, loop) if ssl is not None: # Check that the server provides a certificate der_encoded_server_certificate = \ transport.get_extra_info("ssl_object").getpeercert( binary_form=True) if der_encoded_server_certificate is None: local_port = s.getsockname()[1] raise BoltProtocolError( "When using an encrypted socket, the server should " "always provide a certificate", address=(resolved_address.host_name, local_port) ) return cls(reader, protocol, writer) except asyncio.TimeoutError: log.debug("[#0000] S: %s", resolved_address) log.debug("[#0000] C: %s", resolved_address) if s: await cls.close_socket(s) raise ServiceUnavailable( "Timed out trying to establish connection to {!r}".format( resolved_address)) except asyncio.CancelledError: log.debug("[#0000] S: %s", resolved_address) log.debug("[#0000] C: %s", resolved_address) if s: await cls.close_socket(s) raise except (SSLError, CertificateError) as error: local_port = s.getsockname()[1] if s: await cls.close_socket(s) raise BoltSecurityError( message="Failed to establish encrypted connection.", address=(resolved_address.host_name, local_port) ) from error except OSError as error: log.debug("[#0000] S: %s %s", type(error).__name__, " ".join(map(repr, error.args))) log.debug("[#0000] C: %s", resolved_address) if s: await cls.close_socket(s) raise ServiceUnavailable( "Failed to establish connection to {!r} (reason {})".format( resolved_address, error)) async def _handshake(self, resolved_address): """ :param s: Socket :param resolved_address: :return: (socket, version, client_handshake, server_response_data) """ local_port = self.getsockname()[1] # TODO: Optimize logging code handshake = self.Bolt.get_handshake() handshake = struct.unpack(">16B", handshake) handshake = [handshake[i:i + 4] for i in range(0, len(handshake), 4)] supported_versions = [ ("0x%02X%02X%02X%02X" % (vx[0], vx[1], vx[2], vx[3])) for vx in handshake] log.debug("[#%04X] C: 0x%08X", local_port, int.from_bytes(self.Bolt.MAGIC_PREAMBLE, byteorder="big")) log.debug("[#%04X] C: %s %s %s %s", local_port, *supported_versions) data = self.Bolt.MAGIC_PREAMBLE + self.Bolt.get_handshake() await self.sendall(data) # Handle the handshake response original_timeout = self.gettimeout() if original_timeout is not None: self.settimeout(original_timeout + 1) try: data = await self.recv(4) except OSError: raise ServiceUnavailable( "Failed to read any data from server {!r} " "after connected".format(resolved_address)) finally: self.settimeout(original_timeout) data_size = len(data) if data_size == 0: # If no data is returned after a successful select # response, the server has closed the connection log.debug("[#%04X] S: ", local_port) await self.close() raise ServiceUnavailable( "Connection to {address} closed without handshake response".format( address=resolved_address)) if data_size != 4: # Some garbled data has been received log.debug("[#%04X] S: @*#!", local_port) await self.close() raise BoltProtocolError( "Expected four byte Bolt handshake response from %r, received %r instead; check for incorrect port number" % ( resolved_address, data), address=resolved_address) elif data == b"HTTP": log.debug("[#%04X] S: ", local_port) await self.close() raise ServiceUnavailable( "Cannot to connect to Bolt service on {!r} " "(looks like HTTP)".format(resolved_address)) agreed_version = data[-1], data[-2] log.debug("[#%04X] S: 0x%06X%02X", local_port, agreed_version[1], agreed_version[0]) return self, agreed_version, handshake, data @classmethod async def close_socket(cls, socket_): if isinstance(socket_, AsyncBoltSocket): try: await socket_.close() except OSError: pass else: try: socket_.shutdown(SHUT_RDWR) except OSError: pass try: socket_.close() except OSError: pass @classmethod async def connect(cls, address, *, timeout, custom_resolver, ssl_context, keep_alive): """ Connect and perform a handshake and return a valid Connection object, assuming a protocol version can be agreed. """ errors = [] failed_addresses = [] # Establish a connection to the host and port specified # Catches refused connections see: # https://docs.python.org/2/library/errno.html resolved_addresses = AsyncNetworkUtil.resolve_address( addressing.Address(address), resolver=custom_resolver ) async for resolved_address in resolved_addresses: s = None try: s = await cls._connect_secure( resolved_address, timeout, keep_alive, ssl_context ) return await s._handshake(resolved_address) except (BoltError, DriverError, OSError) as error: try: local_port = s.getsockname()[1] except (OSError, AttributeError, TypeError): local_port = 0 err_str = error.__class__.__name__ if str(error): err_str += ": " + str(error) log.debug("[#%04X] C: %s %s", local_port, resolved_address, err_str) if s: await cls.close_socket(s) errors.append(error) failed_addresses.append(resolved_address) except asyncio.CancelledError: try: local_port = s.getsockname()[1] except (OSError, AttributeError, TypeError): local_port = 0 log.debug("[#%04X] C: %s", local_port, resolved_address) if s: await cls.close_socket(s) raise except Exception: if s: await cls.close_socket(s) raise if not errors: raise ServiceUnavailable( "Couldn't connect to %s (resolved to %s)" % ( str(address), tuple(map(str, failed_addresses))) ) else: raise ServiceUnavailable( "Couldn't connect to %s (resolved to %s):\n%s" % ( str(address), tuple(map(str, failed_addresses)), "\n".join(map(str, errors)) ) ) from errors[0] class BoltSocket: Bolt: te.Final[t.Type[Bolt]] = None # type: ignore[assignment] def __init__(self, socket_: socket): self._socket = socket_ self._deadline = None @property def _socket(self): return self.__socket @_socket.setter def _socket(self, socket_: t.Union[socket, SSLSocket]): self.__socket = socket_ self.getsockname = socket_.getsockname self.getpeername = socket_.getpeername if hasattr(socket, "getpeercert"): self.getpeercert = socket_.getpeercert # type: ignore elif hasattr(self, "getpeercert"): del self.getpeercert self.gettimeout = socket_.gettimeout self.settimeout = socket_.settimeout def _wait_for_io(self, func, *args, **kwargs): if self._deadline is None: return func(*args, **kwargs) timeout = self._socket.gettimeout() deadline_timeout = self._deadline.to_timeout() if deadline_timeout <= 0: raise SocketDeadlineExceeded("timed out") if timeout is None or deadline_timeout <= timeout: self._socket.settimeout(deadline_timeout) try: return func(*args, **kwargs) except SocketTimeout as e: raise SocketDeadlineExceeded("timed out") from e finally: self._socket.settimeout(timeout) return func(*args, **kwargs) def get_deadline(self): return self._deadline def set_deadline(self, deadline): self._deadline = _sanitize_deadline(deadline) def recv(self, n): return self._wait_for_io(self._socket.recv, n) def recv_into(self, buffer, nbytes): return self._wait_for_io(self._socket.recv_into, buffer, nbytes) def sendall(self, data): return self._wait_for_io(self._socket.sendall, data) def close(self): self.close_socket(self._socket) def kill(self): self._socket.close() @classmethod def _connect(cls, resolved_address, timeout, keep_alive): """ :param resolved_address: :param timeout: seconds :param keep_alive: True or False :return: socket object """ s = None # The socket try: if len(resolved_address) == 2: s = socket(AF_INET) elif len(resolved_address) == 4: s = socket(AF_INET6) else: raise ValueError( "Unsupported address {!r}".format(resolved_address)) t = s.gettimeout() if timeout: s.settimeout(timeout) log.debug("[#0000] C: %s", resolved_address) s.connect(resolved_address) s.settimeout(t) keep_alive = 1 if keep_alive else 0 s.setsockopt(SOL_SOCKET, SO_KEEPALIVE, keep_alive) return s except SocketTimeout: log.debug("[#0000] S: %s", resolved_address) log.debug("[#0000] C: %s", resolved_address) cls.close_socket(s) raise ServiceUnavailable( "Timed out trying to establish connection to {!r}".format( resolved_address)) except OSError as error: log.debug("[#0000] S: %s %s", type(error).__name__, " ".join(map(repr, error.args))) log.debug("[#0000] C: %s", resolved_address) cls.close_socket(s) raise ServiceUnavailable( "Failed to establish connection to {!r} (reason {})".format( resolved_address, error)) @classmethod def _secure(cls, s, host, ssl_context): local_port = s.getsockname()[1] # Secure the connection if an SSL context has been provided if ssl_context: log.debug("[#%04X] C: %s", local_port, host) try: sni_host = host if HAS_SNI and host else None s = ssl_context.wrap_socket(s, server_hostname=sni_host) except (OSError, SSLError, CertificateError) as cause: cls.close_socket(s) raise BoltSecurityError( message="Failed to establish encrypted connection.", address=(host, local_port) ) from cause # Check that the server provides a certificate der_encoded_server_certificate = s.getpeercert(binary_form=True) if der_encoded_server_certificate is None: raise BoltProtocolError( "When using an encrypted socket, the server should always " "provide a certificate", address=(host, local_port) ) return s return s @classmethod def _handshake(cls, s, resolved_address): """ :param s: Socket :param resolved_address: :return: (socket, version, client_handshake, server_response_data) """ local_port = s.getsockname()[1] # TODO: Optimize logging code handshake = cls.Bolt.get_handshake() handshake = struct.unpack(">16B", handshake) handshake = [handshake[i:i + 4] for i in range(0, len(handshake), 4)] supported_versions = [ ("0x%02X%02X%02X%02X" % (vx[0], vx[1], vx[2], vx[3])) for vx in handshake] log.debug("[#%04X] C: 0x%08X", local_port, int.from_bytes(cls.Bolt.MAGIC_PREAMBLE, byteorder="big")) log.debug("[#%04X] C: %s %s %s %s", local_port, *supported_versions) data = cls.Bolt.MAGIC_PREAMBLE + cls.Bolt.get_handshake() s.sendall(data) # Handle the handshake response ready_to_read = False with selectors.DefaultSelector() as selector: selector.register(s, selectors.EVENT_READ) selector.select(1) try: data = s.recv(4) except OSError: raise ServiceUnavailable( "Failed to read any data from server {!r} " "after connected".format(resolved_address)) data_size = len(data) if data_size == 0: # If no data is returned after a successful select # response, the server has closed the connection log.debug("[#%04X] S: ", local_port) cls.close_socket(s) raise ServiceUnavailable( "Connection to {address} closed without handshake response".format( address=resolved_address)) if data_size != 4: # Some garbled data has been received log.debug("[#%04X] S: @*#!", local_port) cls.close_socket(s) raise BoltProtocolError( "Expected four byte Bolt handshake response from %r, received %r instead; check for incorrect port number" % ( resolved_address, data), address=resolved_address) elif data == b"HTTP": log.debug("[#%04X] S: ", local_port) cls.close_socket(s) raise ServiceUnavailable( "Cannot to connect to Bolt service on {!r} " "(looks like HTTP)".format(resolved_address)) agreed_version = data[-1], data[-2] log.debug("[#%04X] S: 0x%06X%02X", local_port, agreed_version[1], agreed_version[0]) return cls(s), agreed_version, handshake, data @classmethod def close_socket(cls, socket_): if isinstance(socket_, BoltSocket): socket_ = socket_._socket try: socket_.shutdown(SHUT_RDWR) except OSError: pass try: socket_.close() except OSError: pass @classmethod def connect(cls, address, *, timeout, custom_resolver, ssl_context, keep_alive): """ Connect and perform a handshake and return a valid Connection object, assuming a protocol version can be agreed. """ errors = [] # Establish a connection to the host and port specified # Catches refused connections see: # https://docs.python.org/2/library/errno.html resolved_addresses = NetworkUtil.resolve_address( addressing.Address(address), resolver=custom_resolver ) for resolved_address in resolved_addresses: s = None try: s = BoltSocket._connect(resolved_address, timeout, keep_alive) s = BoltSocket._secure(s, resolved_address.host_name, ssl_context) return BoltSocket._handshake(s, resolved_address) except (BoltError, DriverError, OSError) as error: try: local_port = s.getsockname()[1] except (OSError, AttributeError): local_port = 0 err_str = error.__class__.__name__ if str(error): err_str += ": " + str(error) log.debug("[#%04X] S: %s", local_port, err_str) if s: cls.close_socket(s) errors.append(error) except Exception: if s: cls.close_socket(s) raise if not errors: raise ServiceUnavailable( "Couldn't connect to %s (resolved to %s)" % ( str(address), tuple(map(str, resolved_addresses))) ) else: raise ServiceUnavailable( "Couldn't connect to %s (resolved to %s):\n%s" % ( str(address), tuple(map(str, resolved_addresses)), "\n".join(map(str, errors)) ) ) from errors[0] neo4j-python-driver-5.2.1/neo4j/_async_compat/network/_util.py000066400000000000000000000141131433522662700243750ustar00rootroot00000000000000import asyncio import logging import socket from ... import addressing log = logging.getLogger("neo4j") def _resolved_addresses_from_info(info, host_name): resolved = [] for fam, _, _, _, addr in info: if fam == socket.AF_INET6 and addr[3] != 0: # skip any IPv6 addresses with a non-zero scope id # as these appear to cause problems on some platforms continue if addr not in resolved: resolved.append(addr) yield addressing.ResolvedAddress( addr, host_name=host_name ) class AsyncNetworkUtil: @staticmethod async def get_address_info(host, port, *, family=0, type=0, proto=0, flags=0): loop = asyncio.get_event_loop() return await loop.getaddrinfo( host, port, family=family, type=type, proto=proto, flags=flags ) @staticmethod async def _dns_resolver(address, family=0): """ Regular DNS resolver. Takes an address object and optional address family for filtering. :param address: :param family: :return: """ try: info = await AsyncNetworkUtil.get_address_info( address.host, address.port, family=family, type=socket.SOCK_STREAM ) except OSError: raise ValueError("Cannot resolve address {}".format(address)) return list(_resolved_addresses_from_info(info, address.host_name)) @staticmethod async def resolve_address(address, family=0, resolver=None): """ Carry out domain name resolution on this Address object. If a resolver function is supplied, and is callable, this is called first, with this object as its argument. This may yield multiple output addresses, which are chained into a subsequent regular DNS resolution call. If no resolver function is passed, the DNS resolution is carried out on the original Address object. This function returns a list of resolved Address objects. :param address: the Address to resolve :param family: optional address family to filter resolved addresses by (e.g. `socket.AF_INET6`) :param resolver: optional customer resolver function to be called before regular DNS resolution """ if isinstance(address, addressing.ResolvedAddress): yield address return log.debug("[#0000] _: in: %s", address) if resolver: if asyncio.iscoroutinefunction(resolver): resolved_addresses = await resolver(address) else: resolved_addresses = resolver(address) for address in map(addressing.Address, resolved_addresses): log.debug("[#0000] _: custom resolver out: %s", address) for resolved_address in await AsyncNetworkUtil._dns_resolver( address, family=family ): log.debug("[#0000] _: dns resolver out: %s", resolved_address) yield resolved_address else: for resolved_address in await AsyncNetworkUtil._dns_resolver( address, family=family ): log.debug("[#0000] _: dns resolver out: %s", resolved_address) yield resolved_address class NetworkUtil: @staticmethod def get_address_info(host, port, *, family=0, type=0, proto=0, flags=0): return socket.getaddrinfo(host, port, family, type, proto, flags) @staticmethod def _dns_resolver(address, family=0): """ Regular DNS resolver. Takes an address object and optional address family for filtering. :param address: :param family: :return: """ try: info = NetworkUtil.get_address_info( address.host, address.port, family=family, type=socket.SOCK_STREAM ) except OSError: raise ValueError("Cannot resolve address {}".format(address)) return _resolved_addresses_from_info(info, address.host_name) @staticmethod def resolve_address(address, family=0, resolver=None): """ Carry out domain name resolution on this Address object. If a resolver function is supplied, and is callable, this is called first, with this object as its argument. This may yield multiple output addresses, which are chained into a subsequent regular DNS resolution call. If no resolver function is passed, the DNS resolution is carried out on the original Address object. This function returns a list of resolved Address objects. :param address: the Address to resolve :param family: optional address family to filter resolved addresses by (e.g. `socket.AF_INET6`) :param resolver: optional customer resolver function to be called before regular DNS resolution """ if isinstance(address, addressing.ResolvedAddress): yield address return addressing.log.debug("[#0000] _: in: %s", address) if resolver: for address in map(addressing.Address, resolver(address)): log.debug("[#0000] _: custom resolver out: %s", address) for resolved_address in NetworkUtil._dns_resolver( address, family=family ): log.debug("[#0000] _: dns resolver out: %s", resolved_address) yield resolved_address else: for resolved_address in NetworkUtil._dns_resolver( address, family=family ): log.debug("[#0000] _: dns resolver out: %s", resolved_address) yield resolved_address neo4j-python-driver-5.2.1/neo4j/_async_compat/shims/000077500000000000000000000000001433522662700223415ustar00rootroot00000000000000neo4j-python-driver-5.2.1/neo4j/_async_compat/shims/__init__.py000066400000000000000000000111371433522662700244550ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 asyncio import functools import sys # === patch asyncio.wait_for === # The shipped wait_for can swallow cancellation errors (starting with 3.8). # See: https://github.com/python/cpython/pull/26097 # and https://github.com/python/cpython/pull/28149 # Since 3.8 and 3.9 already received their final maintenance release, there # will be now fix for this. So this patch needs to stick around at least until # we remove support for Python 3.9. if sys.version_info >= (3, 8): # copied from asyncio 3.10 with applied patch def _release_waiter(waiter, *args): if not waiter.done(): waiter.set_result(None) async def _cancel_and_wait(fut, loop): """Cancel the *fut* future or task and wait until it completes.""" waiter = loop.create_future() cb = functools.partial(_release_waiter, waiter) fut.add_done_callback(cb) try: fut.cancel() # We cannot wait on *fut* directly to make # sure _cancel_and_wait itself is reliably cancellable. await waiter finally: fut.remove_done_callback(cb) async def wait_for(fut, timeout): """Wait for the single Future or coroutine to complete, with timeout. Coroutine will be wrapped in Task. Returns result of the Future or coroutine. When a timeout occurs, it cancels the task and raises TimeoutError. To avoid the task cancellation, wrap it in shield(). If the wait is cancelled, the task is also cancelled. This function is a coroutine. """ loop = asyncio.get_running_loop() if timeout is None: return await fut if timeout <= 0: fut = asyncio.ensure_future(fut, loop=loop) if fut.done(): return fut.result() await _cancel_and_wait(fut, loop=loop) try: return fut.result() except asyncio.CancelledError as exc: raise asyncio.TimeoutError() from exc waiter = loop.create_future() timeout_handle = loop.call_later(timeout, _release_waiter, waiter) cb = functools.partial(_release_waiter, waiter) fut = asyncio.ensure_future(fut, loop=loop) fut.add_done_callback(cb) try: # wait until the future completes or the timeout try: await waiter except asyncio.CancelledError: if fut.done(): # [PATCH] # Applied patch to not swallow the outer cancellation. # See: https://github.com/python/cpython/pull/26097 # and https://github.com/python/cpython/pull/28149 # Even though the future we're waiting for is already done, # we should not swallow the cancellation. raise # [/PATCH] else: fut.remove_done_callback(cb) # We must ensure that the task is not running # after wait_for() returns. # See https://bugs.python.org/issue32751 await _cancel_and_wait(fut, loop=loop) raise if fut.done(): return fut.result() else: fut.remove_done_callback(cb) # We must ensure that the task is not running # after wait_for() returns. # See https://bugs.python.org/issue32751 await _cancel_and_wait(fut, loop=loop) # In case task cancellation failed with some # exception, we should re-raise it # See https://bugs.python.org/issue40607 try: return fut.result() except asyncio.CancelledError as exc: raise asyncio.TimeoutError() from exc finally: timeout_handle.cancel() else: wait_for = asyncio.wait_for neo4j-python-driver-5.2.1/neo4j/_async_compat/util.py000066400000000000000000000053561433522662700225560ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations import asyncio import inspect import typing as t from functools import wraps from .._meta import experimental if t.TYPE_CHECKING: import typing_extensions as te _T = t.TypeVar("_T") _P = te.ParamSpec("_P") __all__ = [ "AsyncUtil", "Util", ] class AsyncUtil: @staticmethod async def iter(it): async for x in it: yield x @staticmethod async def next(it): return await it.__anext__() @staticmethod async def list(it): return [x async for x in it] @staticmethod @t.overload async def callback(cb: None, *args: object, **kwargs: object) -> None: ... @staticmethod @t.overload async def callback( cb: t.Union[ t.Callable[_P, t.Union[_T, t.Awaitable[_T]]], t.Callable[_P, t.Awaitable[_T]], t.Callable[_P, _T], ], *args: _P.args, **kwargs: _P.kwargs ) -> _T: ... @staticmethod async def callback(cb, *args, **kwargs): if callable(cb): res = cb(*args, **kwargs) if inspect.isawaitable(res): return await res return res @staticmethod def shielded(coro_function): assert asyncio.iscoroutinefunction(coro_function) @wraps(coro_function) async def shielded_function(*args, **kwargs): return await asyncio.shield(coro_function(*args, **kwargs)) return shielded_function is_async_code: t.ClassVar = True class Util: iter: t.ClassVar = iter next: t.ClassVar = next list: t.ClassVar = list @staticmethod @t.overload def callback(cb: None, *args: object, **kwargs: object) -> None: ... @staticmethod @t.overload def callback(cb: t.Callable[_P, _T], *args: _P.args, **kwargs: _P.kwargs) -> _T: ... @staticmethod def callback(cb, *args, **kwargs): if callable(cb): return cb(*args, **kwargs) @staticmethod def shielded(coro_function): return coro_function is_async_code: t.ClassVar = False neo4j-python-driver-5.2.1/neo4j/_codec/000077500000000000000000000000001433522662700176135ustar00rootroot00000000000000neo4j-python-driver-5.2.1/neo4j/_codec/__init__.py000066400000000000000000000012011433522662700217160ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. neo4j-python-driver-5.2.1/neo4j/_codec/hydration/000077500000000000000000000000001433522662700216145ustar00rootroot00000000000000neo4j-python-driver-5.2.1/neo4j/_codec/hydration/__init__.py000066400000000000000000000015241433522662700237270ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 ._common import ( BrokenHydrationObject, HydrationScope, ) from ._interface import HydrationHandlerABC __all__ = [ "BrokenHydrationObject", "HydrationHandlerABC", "HydrationScope", ] neo4j-python-driver-5.2.1/neo4j/_codec/hydration/_common.py000066400000000000000000000063761433522662700236310ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 copy import copy from ...graph import Graph from ..packstream import Structure class BrokenHydrationObject: """ Represents an object from the server, not understood by the driver. A :class:`neo4j.Record` might contain a ``BrokenHydrationObject`` object if the driver received data from the server that it did not understand. This can for instance happen if the server sends a zoned datetime with a zone name unknown to the driver. There is no need to explicitly check for this type. Any method on the :class:`neo4j.Record` that would return a ``BrokenHydrationObject``, will raise a :exc:`neo4j.exceptions.BrokenRecordError` with the original exception as cause. """ def __init__(self, error, raw_data): self.error = error "The exception raised while decoding the received object." self.raw_data = raw_data """The raw data that caused the exception.""" def exception_copy(self): exc_copy = copy(self.error) exc_copy.with_traceback(self.error.__traceback__) return exc_copy class GraphHydrator: def __init__(self): self.graph = Graph() self.struct_hydration_functions = {} class HydrationScope: def __init__(self, hydration_handler, graph_hydrator): self._hydration_handler = hydration_handler self._graph_hydrator = graph_hydrator self._struct_hydration_functions = { **hydration_handler.struct_hydration_functions, **graph_hydrator.struct_hydration_functions, } self.hydration_hooks = { Structure: self._hydrate_structure, list: self._hydrate_list, dict: self._hydrate_dict, } self.dehydration_hooks = hydration_handler.dehydration_functions def _hydrate_structure(self, value): f = self._struct_hydration_functions.get(value.tag) try: if not f: raise ValueError( f"Protocol error: unknown Structure tag: {value.tag!r}" ) return f(*value.fields) except Exception as e: return BrokenHydrationObject(e, value) @staticmethod def _hydrate_list(value): for v in value: if isinstance(v, BrokenHydrationObject): return BrokenHydrationObject(v.error, value) return value @staticmethod def _hydrate_dict(value): for v in value.values(): if isinstance(v, BrokenHydrationObject): return BrokenHydrationObject(v.error, value) return value def get_graph(self): return self._graph_hydrator.graph neo4j-python-driver-5.2.1/neo4j/_codec/hydration/_interface/000077500000000000000000000000001433522662700237135ustar00rootroot00000000000000neo4j-python-driver-5.2.1/neo4j/_codec/hydration/_interface/__init__.py000066400000000000000000000015511433522662700260260ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 abc class HydrationHandlerABC(abc.ABC): def __init__(self): self.struct_hydration_functions = {} self.dehydration_functions = {} @abc.abstractmethod def new_hydration_scope(self): ... neo4j-python-driver-5.2.1/neo4j/_codec/hydration/v1/000077500000000000000000000000001433522662700221425ustar00rootroot00000000000000neo4j-python-driver-5.2.1/neo4j/_codec/hydration/v1/__init__.py000066400000000000000000000013331433522662700242530ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 .hydration_handler import HydrationHandler __all__ = [ "HydrationHandler", ] neo4j-python-driver-5.2.1/neo4j/_codec/hydration/v1/hydration_handler.py000066400000000000000000000150261433522662700262160ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 datetime import ( date, datetime, time, timedelta, ) from ....graph import ( Graph, Node, Path, ) from ....spatial import ( CartesianPoint, Point, WGS84Point, ) from ....time import ( Date, DateTime, Duration, Time, ) from .._common import ( GraphHydrator, HydrationScope, ) from .._interface import HydrationHandlerABC from . import ( spatial, temporal, ) class _GraphHydrator(GraphHydrator): def __init__(self): super().__init__() self.struct_hydration_functions = { **self.struct_hydration_functions, b"N": self.hydrate_node, b"R": self.hydrate_relationship, b"r": self.hydrate_unbound_relationship, b"P": self.hydrate_path, } def hydrate_node(self, id_, labels=None, properties=None, element_id=None): assert isinstance(self.graph, Graph) # backwards compatibility with Neo4j < 5.0 if element_id is None: element_id = str(id_) try: inst = self.graph._nodes[element_id] except KeyError: inst = Node(self.graph, element_id, id_, labels, properties) self.graph._nodes[element_id] = inst self.graph._legacy_nodes[id_] = inst else: # If we have already hydrated this node as the endpoint of # a relationship, it won't have any labels or properties. # Therefore, we need to add the ones we have here. if labels: inst._labels = inst._labels.union(labels) # frozen_set if properties: inst._properties.update(properties) return inst def hydrate_relationship(self, id_, n0_id, n1_id, type_, properties=None, element_id=None, n0_element_id=None, n1_element_id=None): # backwards compatibility with Neo4j < 5.0 if element_id is None: element_id = str(id_) if n0_element_id is None: n0_element_id = str(n0_id) if n1_element_id is None: n1_element_id = str(n1_id) inst = self.hydrate_unbound_relationship(id_, type_, properties, element_id) inst._start_node = self.hydrate_node(n0_id, element_id=n0_element_id) inst._end_node = self.hydrate_node(n1_id, element_id=n1_element_id) return inst def hydrate_unbound_relationship(self, id_, type_, properties=None, element_id=None): assert isinstance(self.graph, Graph) # backwards compatibility with Neo4j < 5.0 if element_id is None: element_id = str(id_) try: inst = self.graph._relationships[element_id] except KeyError: r = self.graph.relationship_type(type_) inst = r( self.graph, element_id, id_, properties ) self.graph._relationships[element_id] = inst self.graph._legacy_relationships[id_] = inst return inst def hydrate_path(self, nodes, relationships, sequence): assert isinstance(self.graph, Graph) assert len(nodes) >= 1 assert len(sequence) % 2 == 0 last_node = nodes[0] entities = [last_node] for i, rel_index in enumerate(sequence[::2]): assert rel_index != 0 next_node = nodes[sequence[2 * i + 1]] if rel_index > 0: r = relationships[rel_index - 1] r._start_node = last_node r._end_node = next_node entities.append(r) else: r = relationships[-rel_index - 1] r._start_node = next_node r._end_node = last_node entities.append(r) last_node = next_node return Path(*entities) class HydrationHandler(HydrationHandlerABC): def __init__(self): super().__init__() self._created_scope = False self.struct_hydration_functions = { **self.struct_hydration_functions, b"X": spatial.hydrate_point, b"Y": spatial.hydrate_point, b"D": temporal.hydrate_date, b"T": temporal.hydrate_time, # time zone offset b"t": temporal.hydrate_time, # no time zone b"F": temporal.hydrate_datetime, # time zone offset b"f": temporal.hydrate_datetime, # time zone name b"d": temporal.hydrate_datetime, # no time zone b"E": temporal.hydrate_duration, } self.dehydration_functions = { **self.dehydration_functions, Point: spatial.dehydrate_point, CartesianPoint: spatial.dehydrate_point, WGS84Point: spatial.dehydrate_point, Date: temporal.dehydrate_date, date: temporal.dehydrate_date, Time: temporal.dehydrate_time, time: temporal.dehydrate_time, DateTime: temporal.dehydrate_datetime, datetime: temporal.dehydrate_datetime, Duration: temporal.dehydrate_duration, timedelta: temporal.dehydrate_timedelta, } def patch_utc(self): from ..v2 import temporal as temporal_v2 assert not self._created_scope del self.struct_hydration_functions[b"F"] del self.struct_hydration_functions[b"f"] self.struct_hydration_functions.update({ b"I": temporal_v2.hydrate_datetime, b"i": temporal_v2.hydrate_datetime, }) self.dehydration_functions.update({ DateTime: temporal_v2.dehydrate_datetime, datetime: temporal_v2.dehydrate_datetime, }) def new_hydration_scope(self): self._created_scope = True return HydrationScope(self, _GraphHydrator()) neo4j-python-driver-5.2.1/neo4j/_codec/hydration/v1/spatial.py000066400000000000000000000033541433522662700241560ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 ...._spatial import ( Point, srid_table, ) from ...packstream import Structure def hydrate_point(srid, *coordinates): """ Create a new instance of a Point subclass from a raw set of fields. The subclass chosen is determined by the given SRID; a ValueError will be raised if no such subclass can be found. """ try: point_class, dim = srid_table[srid] except KeyError: point = Point(coordinates) point.srid = srid return point else: if len(coordinates) != dim: raise ValueError("SRID %d requires %d coordinates (%d provided)" % (srid, dim, len(coordinates))) return point_class(coordinates) def dehydrate_point(value): """ Dehydrator for Point data. :param value: :type value: Point :return: """ dim = len(value) if dim == 2: return Structure(b"X", value.srid, *value) elif dim == 3: return Structure(b"Y", value.srid, *value) else: raise ValueError("Cannot dehydrate Point with %d dimensions" % dim) __all__ = [ "hydrate_point", "dehydrate_point", ] neo4j-python-driver-5.2.1/neo4j/_codec/hydration/v1/temporal.py000066400000000000000000000133111433522662700243360ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 datetime import ( datetime, time, timedelta, ) from ....time import ( Date, DateTime, Duration, Time, ) from ...packstream import Structure def get_date_unix_epoch(): return Date(1970, 1, 1) def get_date_unix_epoch_ordinal(): return get_date_unix_epoch().to_ordinal() def get_datetime_unix_epoch_utc(): from pytz import utc return DateTime(1970, 1, 1, 0, 0, 0, utc) def hydrate_date(days): """ Hydrator for `Date` values. :param days: :return: Date """ return Date.from_ordinal(get_date_unix_epoch_ordinal() + days) def dehydrate_date(value): """ Dehydrator for `date` values. :param value: :type value: Date :return: """ return Structure(b"D", value.toordinal() - get_date_unix_epoch().toordinal()) def hydrate_time(nanoseconds, tz=None): """ Hydrator for `Time` and `LocalTime` values. :param nanoseconds: :param tz: :return: Time """ from pytz import FixedOffset seconds, nanoseconds = map(int, divmod(nanoseconds, 1000000000)) minutes, seconds = map(int, divmod(seconds, 60)) hours, minutes = map(int, divmod(minutes, 60)) t = Time(hours, minutes, seconds, nanoseconds) if tz is None: return t tz_offset_minutes, tz_offset_seconds = divmod(tz, 60) zone = FixedOffset(tz_offset_minutes) return zone.localize(t) def dehydrate_time(value): """ Dehydrator for `time` values. :param value: :type value: Time :return: """ if isinstance(value, Time): nanoseconds = value.ticks elif isinstance(value, time): nanoseconds = (3600000000000 * value.hour + 60000000000 * value.minute + 1000000000 * value.second + 1000 * value.microsecond) else: raise TypeError("Value must be a neo4j.time.Time or a datetime.time") if value.tzinfo: return Structure(b"T", nanoseconds, int(value.tzinfo.utcoffset(value).total_seconds())) else: return Structure(b"t", nanoseconds) def hydrate_datetime(seconds, nanoseconds, tz=None): """ Hydrator for `DateTime` and `LocalDateTime` values. :param seconds: :param nanoseconds: :param tz: :return: datetime """ from pytz import ( FixedOffset, timezone, ) minutes, seconds = map(int, divmod(seconds, 60)) hours, minutes = map(int, divmod(minutes, 60)) days, hours = map(int, divmod(hours, 24)) t = DateTime.combine( Date.from_ordinal(get_date_unix_epoch_ordinal() + days), Time(hours, minutes, seconds, nanoseconds) ) if tz is None: return t if isinstance(tz, int): tz_offset_minutes, tz_offset_seconds = divmod(tz, 60) zone = FixedOffset(tz_offset_minutes) else: zone = timezone(tz) return zone.localize(t) def dehydrate_datetime(value): """ Dehydrator for `datetime` values. :param value: :type value: datetime or DateTime :return: """ def seconds_and_nanoseconds(dt): if isinstance(dt, datetime): dt = DateTime.from_native(dt) zone_epoch = DateTime(1970, 1, 1, tzinfo=dt.tzinfo) dt_clock_time = dt.to_clock_time() zone_epoch_clock_time = zone_epoch.to_clock_time() t = dt_clock_time - zone_epoch_clock_time return t.seconds, t.nanoseconds tz = value.tzinfo if tz is None: # without time zone from pytz import utc value = utc.localize(value) seconds, nanoseconds = seconds_and_nanoseconds(value) return Structure(b"d", seconds, nanoseconds) elif hasattr(tz, "zone") and tz.zone and isinstance(tz.zone, str): # with named pytz time zone seconds, nanoseconds = seconds_and_nanoseconds(value) return Structure(b"f", seconds, nanoseconds, tz.zone) elif hasattr(tz, "key") and tz.key and isinstance(tz.key, str): # with named zoneinfo (Python 3.9+) time zone seconds, nanoseconds = seconds_and_nanoseconds(value) return Structure(b"f", seconds, nanoseconds, tz.key) else: # with time offset seconds, nanoseconds = seconds_and_nanoseconds(value) return Structure(b"F", seconds, nanoseconds, int(tz.utcoffset(value).total_seconds())) def hydrate_duration(months, days, seconds, nanoseconds): """ Hydrator for `Duration` values. :param months: :param days: :param seconds: :param nanoseconds: :return: `duration` namedtuple """ return Duration(months=months, days=days, seconds=seconds, nanoseconds=nanoseconds) def dehydrate_duration(value): """ Dehydrator for `duration` values. :param value: :type value: Duration :return: """ return Structure(b"E", value.months, value.days, value.seconds, value.nanoseconds) def dehydrate_timedelta(value): """ Dehydrator for `timedelta` values. :param value: :type value: timedelta :return: """ months = 0 days = value.days seconds = value.seconds nanoseconds = 1000 * value.microseconds return Structure(b"E", months, days, seconds, nanoseconds) neo4j-python-driver-5.2.1/neo4j/_codec/hydration/v2/000077500000000000000000000000001433522662700221435ustar00rootroot00000000000000neo4j-python-driver-5.2.1/neo4j/_codec/hydration/v2/__init__.py000066400000000000000000000013321433522662700242530ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 .hydration_handler import HydrationHandler __all__ = [ "HydrationHandler", ] neo4j-python-driver-5.2.1/neo4j/_codec/hydration/v2/hydration_handler.py000066400000000000000000000043461433522662700262220ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 ..v1.hydration_handler import * from ..v1.hydration_handler import _GraphHydrator from . import temporal # type: ignore[no-redef] class HydrationHandler(HydrationHandlerABC): # type: ignore[no-redef] def __init__(self): super().__init__() self._created_scope = False self.struct_hydration_functions = { **self.struct_hydration_functions, b"X": spatial.hydrate_point, b"Y": spatial.hydrate_point, b"D": temporal.hydrate_date, b"T": temporal.hydrate_time, # time zone offset b"t": temporal.hydrate_time, # no time zone b"I": temporal.hydrate_datetime, # time zone offset b"i": temporal.hydrate_datetime, # time zone name b"d": temporal.hydrate_datetime, # no time zone b"E": temporal.hydrate_duration, } self.dehydration_functions = { **self.dehydration_functions, Point: spatial.dehydrate_point, CartesianPoint: spatial.dehydrate_point, WGS84Point: spatial.dehydrate_point, Date: temporal.dehydrate_date, date: temporal.dehydrate_date, Time: temporal.dehydrate_time, time: temporal.dehydrate_time, DateTime: temporal.dehydrate_datetime, datetime: temporal.dehydrate_datetime, Duration: temporal.dehydrate_duration, timedelta: temporal.dehydrate_timedelta, } def new_hydration_scope(self): self._created_scope = True return HydrationScope(self, _GraphHydrator()) neo4j-python-driver-5.2.1/neo4j/_codec/hydration/v2/temporal.py000066400000000000000000000062101433522662700243370ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 ..v1.temporal import * def hydrate_datetime(seconds, nanoseconds, tz=None): # type: ignore[no-redef] """ Hydrator for `DateTime` and `LocalDateTime` values. :param seconds: :param nanoseconds: :param tz: :return: datetime """ import pytz minutes, seconds = map(int, divmod(seconds, 60)) hours, minutes = map(int, divmod(minutes, 60)) days, hours = map(int, divmod(hours, 24)) t = DateTime.combine( Date.from_ordinal(get_date_unix_epoch_ordinal() + days), Time(hours, minutes, seconds, nanoseconds) ) if tz is None: return t if isinstance(tz, int): tz_offset_minutes, tz_offset_seconds = divmod(tz, 60) zone = pytz.FixedOffset(tz_offset_minutes) else: zone = pytz.timezone(tz) t = t.replace(tzinfo=pytz.UTC) return t.as_timezone(zone) def dehydrate_datetime(value): # type: ignore[no-redef] """ Dehydrator for `datetime` values. :param value: :type value: datetime :return: """ import pytz def seconds_and_nanoseconds(dt): if isinstance(dt, datetime): dt = DateTime.from_native(dt) dt = dt.astimezone(pytz.UTC) utc_epoch = DateTime(1970, 1, 1, tzinfo=pytz.UTC) dt_clock_time = dt.to_clock_time() utc_epoch_clock_time = utc_epoch.to_clock_time() t = dt_clock_time - utc_epoch_clock_time return t.seconds, t.nanoseconds tz = value.tzinfo if tz is None: # without time zone value = pytz.UTC.localize(value) seconds, nanoseconds = seconds_and_nanoseconds(value) return Structure(b"d", seconds, nanoseconds) elif hasattr(tz, "zone") and tz.zone and isinstance(tz.zone, str): # with named pytz time zone seconds, nanoseconds = seconds_and_nanoseconds(value) return Structure(b"i", seconds, nanoseconds, tz.zone) elif hasattr(tz, "key") and tz.key and isinstance(tz.key, str): # with named zoneinfo (Python 3.9+) time zone seconds, nanoseconds = seconds_and_nanoseconds(value) return Structure(b"i", seconds, nanoseconds, tz.key) else: # with time offset seconds, nanoseconds = seconds_and_nanoseconds(value) offset = tz.utcoffset(value) if offset.microseconds: raise ValueError("Bolt protocol does not support sub-second " "UTC offsets.") offset_seconds = offset.days * 86400 + offset.seconds return Structure(b"I", seconds, nanoseconds, offset_seconds) neo4j-python-driver-5.2.1/neo4j/_codec/packstream/000077500000000000000000000000001433522662700217455ustar00rootroot00000000000000neo4j-python-driver-5.2.1/neo4j/_codec/packstream/__init__.py000066400000000000000000000013031433522662700240530ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 ._common import Structure __all__ = [ "Structure", ] neo4j-python-driver-5.2.1/neo4j/_codec/packstream/_common.py000066400000000000000000000024341433522662700237510ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. class Structure: def __init__(self, tag, *fields): self.tag = tag self.fields = list(fields) def __repr__(self): return "Structure[0x%02X](%s)" % (ord(self.tag), ", ".join(map(repr, self.fields))) def __eq__(self, other): try: return self.tag == other.tag and self.fields == other.fields except AttributeError: return False def __ne__(self, other): return not self.__eq__(other) def __len__(self): return len(self.fields) def __getitem__(self, key): return self.fields[key] def __setitem__(self, key, value): self.fields[key] = value neo4j-python-driver-5.2.1/neo4j/_codec/packstream/v1/000077500000000000000000000000001433522662700222735ustar00rootroot00000000000000neo4j-python-driver-5.2.1/neo4j/_codec/packstream/v1/__init__.py000066400000000000000000000346131433522662700244130ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 codecs import decode from contextlib import contextmanager from struct import ( pack as struct_pack, unpack as struct_unpack, ) from .._common import Structure PACKED_UINT_8 = [struct_pack(">B", value) for value in range(0x100)] PACKED_UINT_16 = [struct_pack(">H", value) for value in range(0x10000)] UNPACKED_UINT_8 = {bytes(bytearray([x])): x for x in range(0x100)} UNPACKED_UINT_16 = {struct_pack(">H", x): x for x in range(0x10000)} INT64_MIN = -(2 ** 63) INT64_MAX = 2 ** 63 class Packer: def __init__(self, stream): self.stream = stream self._write = self.stream.write def pack_raw(self, data): self._write(data) def pack(self, value, dehydration_hooks=None): write = self._write # None if value is None: write(b"\xC0") # NULL # Boolean elif value is True: write(b"\xC3") elif value is False: write(b"\xC2") # Float (only double precision is supported) elif isinstance(value, float): write(b"\xC1") write(struct_pack(">d", value)) # Integer elif isinstance(value, int): if -0x10 <= value < 0x80: write(PACKED_UINT_8[value % 0x100]) elif -0x80 <= value < -0x10: write(b"\xC8") write(PACKED_UINT_8[value % 0x100]) elif -0x8000 <= value < 0x8000: write(b"\xC9") write(PACKED_UINT_16[value % 0x10000]) elif -0x80000000 <= value < 0x80000000: write(b"\xCA") write(struct_pack(">i", value)) elif INT64_MIN <= value < INT64_MAX: write(b"\xCB") write(struct_pack(">q", value)) else: raise OverflowError("Integer %s out of range" % value) # String elif isinstance(value, str): encoded = value.encode("utf-8") self.pack_string_header(len(encoded)) self.pack_raw(encoded) # Bytes elif isinstance(value, (bytes, bytearray)): self.pack_bytes_header(len(value)) self.pack_raw(value) # List elif isinstance(value, list): self.pack_list_header(len(value)) for item in value: self.pack(item, dehydration_hooks=dehydration_hooks) # Map elif isinstance(value, dict): self.pack_map_header(len(value)) for key, item in value.items(): if not isinstance(key, str): raise TypeError( "Map keys must be strings, not {}".format(type(key)) ) self.pack(key, dehydration_hooks=dehydration_hooks) self.pack(item, dehydration_hooks=dehydration_hooks) # Structure elif isinstance(value, Structure): self.pack_struct(value.tag, value.fields) # Other elif dehydration_hooks and type(value) in dehydration_hooks: self.pack(dehydration_hooks[type(value)](value)) else: raise ValueError("Values of type %s are not supported" % type(value)) def pack_bytes_header(self, size): write = self._write if size < 0x100: write(b"\xCC") write(PACKED_UINT_8[size]) elif size < 0x10000: write(b"\xCD") write(PACKED_UINT_16[size]) elif size < 0x100000000: write(b"\xCE") write(struct_pack(">I", size)) else: raise OverflowError("Bytes header size out of range") def pack_string_header(self, size): write = self._write if size <= 0x0F: write(bytes((0x80 | size,))) elif size < 0x100: write(b"\xD0") write(PACKED_UINT_8[size]) elif size < 0x10000: write(b"\xD1") write(PACKED_UINT_16[size]) elif size < 0x100000000: write(b"\xD2") write(struct_pack(">I", size)) else: raise OverflowError("String header size out of range") def pack_list_header(self, size): write = self._write if size <= 0x0F: write(bytes((0x90 | size,))) elif size < 0x100: write(b"\xD4") write(PACKED_UINT_8[size]) elif size < 0x10000: write(b"\xD5") write(PACKED_UINT_16[size]) elif size < 0x100000000: write(b"\xD6") write(struct_pack(">I", size)) else: raise OverflowError("List header size out of range") def pack_map_header(self, size): write = self._write if size <= 0x0F: write(bytes((0xA0 | size,))) elif size < 0x100: write(b"\xD8") write(PACKED_UINT_8[size]) elif size < 0x10000: write(b"\xD9") write(PACKED_UINT_16[size]) elif size < 0x100000000: write(b"\xDA") write(struct_pack(">I", size)) else: raise OverflowError("Map header size out of range") def pack_struct(self, signature, fields, dehydration_hooks=None): if len(signature) != 1 or not isinstance(signature, bytes): raise ValueError("Structure signature must be a single byte value") write = self._write size = len(fields) if size <= 0x0F: write(bytes((0xB0 | size,))) else: raise OverflowError("Structure size out of range") write(signature) for field in fields: self.pack(field, dehydration_hooks=dehydration_hooks) @staticmethod def new_packable_buffer(): return PackableBuffer() class PackableBuffer: def __init__(self): self.data = bytearray() # export write method for packer; "inline" for performance self.write = self.data.extend self.clear = self.data.clear self._tmp_buffering = 0 @contextmanager def tmp_buffer(self): self._tmp_buffering += 1 old_len = len(self.data) try: yield except Exception: del self.data[old_len:] raise finally: self._tmp_buffering -= 1 def is_tmp_buffering(self): return bool(self._tmp_buffering) class Unpacker: def __init__(self, unpackable): self.unpackable = unpackable def reset(self): self.unpackable.reset() def read(self, n=1): return self.unpackable.read(n) def read_u8(self): return self.unpackable.read_u8() def unpack(self, hydration_hooks=None): value = self._unpack(hydration_hooks=hydration_hooks) if hydration_hooks and type(value) in hydration_hooks: return hydration_hooks[type(value)](value) return value def _unpack(self, hydration_hooks=None): marker = self.read_u8() if marker == -1: raise ValueError("Nothing to unpack") # Tiny Integer if 0x00 <= marker <= 0x7F: return marker elif 0xF0 <= marker <= 0xFF: return marker - 0x100 # Null elif marker == 0xC0: return None # Float elif marker == 0xC1: value, = struct_unpack(">d", self.read(8)) return value # Boolean elif marker == 0xC2: return False elif marker == 0xC3: return True # Integer elif marker == 0xC8: return struct_unpack(">b", self.read(1))[0] elif marker == 0xC9: return struct_unpack(">h", self.read(2))[0] elif marker == 0xCA: return struct_unpack(">i", self.read(4))[0] elif marker == 0xCB: return struct_unpack(">q", self.read(8))[0] # Bytes elif marker == 0xCC: size, = struct_unpack(">B", self.read(1)) return self.read(size).tobytes() elif marker == 0xCD: size, = struct_unpack(">H", self.read(2)) return self.read(size).tobytes() elif marker == 0xCE: size, = struct_unpack(">I", self.read(4)) return self.read(size).tobytes() else: marker_high = marker & 0xF0 # String if marker_high == 0x80: # TINY_STRING return decode(self.read(marker & 0x0F), "utf-8") elif marker == 0xD0: # STRING_8: size, = struct_unpack(">B", self.read(1)) return decode(self.read(size), "utf-8") elif marker == 0xD1: # STRING_16: size, = struct_unpack(">H", self.read(2)) return decode(self.read(size), "utf-8") elif marker == 0xD2: # STRING_32: size, = struct_unpack(">I", self.read(4)) return decode(self.read(size), "utf-8") # List elif 0x90 <= marker <= 0x9F or 0xD4 <= marker <= 0xD6: return list(self._unpack_list_items( marker, hydration_hooks=hydration_hooks) ) # Map elif 0xA0 <= marker <= 0xAF or 0xD8 <= marker <= 0xDA: return self._unpack_map( marker, hydration_hooks=hydration_hooks ) # Structure elif 0xB0 <= marker <= 0xBF: size, tag = self._unpack_structure_header(marker) value = Structure(tag, *([None] * size)) for i in range(len(value)): value[i] = self.unpack(hydration_hooks=hydration_hooks) return value else: raise ValueError("Unknown PackStream marker %02X" % marker) def _unpack_list_items(self, marker, hydration_hooks=None): marker_high = marker & 0xF0 if marker_high == 0x90: size = marker & 0x0F if size == 0: return elif size == 1: yield self.unpack(hydration_hooks=hydration_hooks) else: for _ in range(size): yield self.unpack(hydration_hooks=hydration_hooks) elif marker == 0xD4: # LIST_8: size, = struct_unpack(">B", self.read(1)) for _ in range(size): yield self.unpack(hydration_hooks=hydration_hooks) elif marker == 0xD5: # LIST_16: size, = struct_unpack(">H", self.read(2)) for _ in range(size): yield self.unpack(hydration_hooks=hydration_hooks) elif marker == 0xD6: # LIST_32: size, = struct_unpack(">I", self.read(4)) for _ in range(size): yield self.unpack(hydration_hooks=hydration_hooks) else: return def unpack_map(self, hydration_hooks=None): marker = self.read_u8() return self._unpack_map(marker, hydration_hooks=hydration_hooks) def _unpack_map(self, marker, hydration_hooks=None): marker_high = marker & 0xF0 if marker_high == 0xA0: size = marker & 0x0F value = {} for _ in range(size): key = self.unpack(hydration_hooks=hydration_hooks) value[key] = self.unpack(hydration_hooks=hydration_hooks) return value elif marker == 0xD8: # MAP_8: size, = struct_unpack(">B", self.read(1)) value = {} for _ in range(size): key = self.unpack(hydration_hooks=hydration_hooks) value[key] = self.unpack(hydration_hooks=hydration_hooks) return value elif marker == 0xD9: # MAP_16: size, = struct_unpack(">H", self.read(2)) value = {} for _ in range(size): key = self.unpack(hydration_hooks=hydration_hooks) value[key] = self.unpack(hydration_hooks=hydration_hooks) return value elif marker == 0xDA: # MAP_32: size, = struct_unpack(">I", self.read(4)) value = {} for _ in range(size): key = self.unpack(hydration_hooks=hydration_hooks) value[key] = self.unpack(hydration_hooks=hydration_hooks) return value else: return None def unpack_structure_header(self): marker = self.read_u8() if marker == -1: return None, None else: return self._unpack_structure_header(marker) def _unpack_structure_header(self, marker): marker_high = marker & 0xF0 if marker_high == 0xB0: # TINY_STRUCT signature = self.read(1).tobytes() return marker & 0x0F, signature else: raise ValueError("Expected structure, found marker %02X" % marker) @staticmethod def new_unpackable_buffer(): return UnpackableBuffer() class UnpackableBuffer: initial_capacity = 8192 def __init__(self, data=None): if data is None: self.data = bytearray(self.initial_capacity) self.used = 0 else: self.data = bytearray(data) self.used = len(self.data) self.p = 0 def reset(self): self.used = 0 self.p = 0 def read(self, n=1): view = memoryview(self.data) q = self.p + n subview = view[self.p:q] self.p = q return subview def read_u8(self): if self.used - self.p >= 1: value = self.data[self.p] self.p += 1 return value else: return -1 def pop_u16(self): """ Remove the last two bytes of data, returning them as a big-endian 16-bit unsigned integer. """ if self.used >= 2: value = 0x100 * self.data[self.used - 2] + self.data[self.used - 1] self.used -= 2 return value else: return -1 neo4j-python-driver-5.2.1/neo4j/_conf.py000066400000000000000000000422041433522662700200370ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 warnings from abc import ABCMeta from collections.abc import Mapping from ._meta import ( deprecation_warn, experimental_warn, ExperimentalWarning, get_user_agent, ) from .api import ( DEFAULT_DATABASE, TRUST_ALL_CERTIFICATES, TRUST_SYSTEM_CA_SIGNED_CERTIFICATES, WRITE_ACCESS, ) from .exceptions import ConfigurationError def iter_items(iterable): """ Iterate through all items (key-value pairs) within an iterable dictionary-like object. If the object has a `keys` method, this is used along with `__getitem__` to yield each pair in turn. If no `keys` method exists, each iterable element is assumed to be a 2-tuple of key and value. """ if hasattr(iterable, "keys"): for key in iterable.keys(): yield key, iterable[key] else: for key, value in iterable: yield key, value class TrustStore: # Base class for trust stores. For internal type-checking only. pass class TrustSystemCAs(TrustStore): """Used to configure the driver to trust system CAs (default). Trust server certificates that can be verified against the system certificate authority. This option is primarily intended for use with full certificates. For example:: import neo4j driver = neo4j.GraphDatabase.driver( url, auth=auth, trusted_certificates=neo4j.TrustSystemCAs() ) """ pass class TrustAll(TrustStore): """Used to configure the driver to trust all certificates. Trust any server certificate. This ensures that communication is encrypted but does not verify the server certificate against a certificate authority. This option is primarily intended for use with the default auto-generated server certificate. For example:: import neo4j driver = neo4j.GraphDatabase.driver( url, auth=auth, trusted_certificates=neo4j.TrustAll() ) """ pass class TrustCustomCAs(TrustStore): """Used to configure the driver to trust custom CAs. Trust server certificates that can be verified against the certificate authority at the specified paths. This option is primarily intended for self-signed and custom certificates. :param certificates (str): paths to the certificates to trust. Those are not the certificates you expect to see from the server but the CA certificates you expect to be used to sign the server's certificate. For example:: import neo4j driver = neo4j.GraphDatabase.driver( url, auth=auth, trusted_certificates=neo4j.TrustCustomCAs( "/path/to/ca1.crt", "/path/to/ca2.crt", ) ) """ def __init__(self, *certificates): self.certs = certificates class DeprecatedAlias: """Used when a config option has been renamed.""" def __init__(self, new): self.new = new class DeprecatedAlternative: """Used for deprecated config options that have a similar alternative.""" def __init__(self, new, converter=None): self.new = new self.converter = converter class DeprecatedOption: """Used for deprecated config options without alternative.""" def __init__(self, value): self.value = value class ExperimentalOption: """Used for experimental config options.""" def __init__(self, value): self.value = value class ConfigType(ABCMeta): def __new__(mcs, name, bases, attributes): fields = [] deprecated_aliases = {} deprecated_alternatives = {} deprecated_options = {} experimental_options = {} for base in bases: if type(base) is mcs: fields += base.keys() deprecated_aliases.update(base._deprecated_aliases()) deprecated_alternatives.update(base._deprecated_alternatives()) deprecated_options.update(base._deprecated_options()) experimental_options.update(base._experimental_options()) for k, v in attributes.items(): if ( k.startswith("_") or callable(v) or isinstance(v, (staticmethod, classmethod)) ): continue if isinstance(v, DeprecatedAlias): deprecated_aliases[k] = v.new continue if isinstance(v, DeprecatedAlternative): deprecated_alternatives[k] = v.new, v.converter continue fields.append(k) if isinstance(v, DeprecatedOption): deprecated_options[k] = v.value attributes[k] = v.value continue if isinstance(v, ExperimentalOption): experimental_options[k] = v.value attributes[k] = v.value continue def keys(_): return set(fields) def _deprecated_keys(_): return (set(deprecated_aliases.keys()) | set(deprecated_alternatives.keys())) def _get_new(_, key): return deprecated_aliases.get( key, deprecated_alternatives.get(key, (None,))[0] ) def _deprecated_aliases(_): return deprecated_aliases def _deprecated_alternatives(_): return deprecated_alternatives def _deprecated_options(_): return deprecated_options def _experimental_options(_): return experimental_options attributes.setdefault("keys", classmethod(keys)) attributes.setdefault("_get_new", classmethod(_get_new)) attributes.setdefault("_deprecated_keys", classmethod(_deprecated_keys)) attributes.setdefault("_deprecated_aliases", classmethod(_deprecated_aliases)) attributes.setdefault("_deprecated_alternatives", classmethod(_deprecated_alternatives)) attributes.setdefault("_deprecated_options", classmethod(_deprecated_options)) attributes.setdefault("_experimental_options", classmethod(_experimental_options)) return super(ConfigType, mcs).__new__( mcs, name, bases, {k: v for k, v in attributes.items() if k not in _deprecated_keys(None)} ) class Config(Mapping, metaclass=ConfigType): """ Base class for all configuration containers. """ @staticmethod def consume_chain(data, *config_classes): values = [] for config_class in config_classes: if not issubclass(config_class, Config): raise TypeError("%r is not a Config subclass" % config_class) values.append(config_class._consume(data)) if data: raise ConfigurationError("Unexpected config keys: %s" % ", ".join(data.keys())) return values @classmethod def consume(cls, data): config, = cls.consume_chain(data, cls) return config @classmethod def _consume(cls, data): config = {} if data: for key in cls.keys() | cls._deprecated_keys(): try: value = data.pop(key) except KeyError: pass else: config[key] = value return cls(config) def __update(self, data): data_dict = dict(iter_items(data)) def set_attr(k, v): if k in self.keys(): if k in self._deprecated_options(): deprecation_warn("The '{}' config key is " "deprecated.".format(k)) if k in self._experimental_options(): experimental_warn( "The '{}' config key is experimental. " "It might be changed or removed any time even without " "prior notice.".format(k) ) setattr(self, k, v) elif k in self._deprecated_keys(): k0 = self._get_new(k) if k0 in data_dict: raise ConfigurationError( "Cannot specify both '{}' and '{}' in config" .format(k0, k) ) deprecation_warn( "The '{}' config key is deprecated, please use '{}' " "instead".format(k, k0) ) if k in self._deprecated_aliases(): set_attr(k0, v) else: # k in self._deprecated_alternatives: _, converter = self._deprecated_alternatives()[k] converter(self, v) else: raise AttributeError(k) rejected_keys = [] for key, value in data_dict.items(): if value is not None: try: set_attr(key, value) except AttributeError as exc: if not exc.args == (key,): raise rejected_keys.append(key) if rejected_keys: raise ConfigurationError("Unexpected config keys: " + ", ".join(rejected_keys)) def __init__(self, *args, **kwargs): for arg in args: if isinstance(arg, Config): with warnings.catch_warnings(): for cat in (DeprecationWarning, ExperimentalWarning): warnings.filterwarnings("ignore", category=cat) self.__update(arg) else: self.__update(arg) self.__update(kwargs) def __repr__(self): attrs = [] for key in self: attrs.append(" %s=%r" % (key, getattr(self, key))) return "<%s%s>" % (self.__class__.__name__, "".join(attrs)) def __len__(self): return len(self.keys()) def __getitem__(self, key): return getattr(self, key) def __iter__(self): return iter(self.keys()) def _trust_to_trusted_certificates(pool_config, trust): if trust == TRUST_SYSTEM_CA_SIGNED_CERTIFICATES: pool_config.trusted_certificates = TrustSystemCAs() elif trust == TRUST_ALL_CERTIFICATES: pool_config.trusted_certificates = TrustAll() class PoolConfig(Config): """ Connection pool configuration. """ #: Max Connection Lifetime max_connection_lifetime = 3600 # seconds # The maximum duration the driver will keep a connection for before being removed from the pool. #: Max Connection Pool Size max_connection_pool_size = 100 # The maximum total number of connections allowed, per host (i.e. cluster nodes), to be managed by the connection pool. #: Connection Timeout connection_timeout = 30.0 # seconds # The maximum amount of time to wait for a TCP connection to be established. #: Trust trust = DeprecatedAlternative( "trusted_certificates", _trust_to_trusted_certificates ) # Specify how to determine the authenticity of encryption certificates provided by the Neo4j instance on connection. #: Custom Resolver resolver = None # Custom resolver function, returning list of resolved addresses. #: Encrypted encrypted = False # Specify whether to use an encrypted connection between the driver and server. #: SSL Certificates to Trust trusted_certificates = TrustSystemCAs() # Specify how to determine the authenticity of encryption certificates # provided by the Neo4j instance on connection. # * `neo4j.TrustSystemCAs()`: Use system trust store. (default) # * `neo4j.TrustAll()`: Trust any certificate. # * `neo4j.TrustCustomCAs("", ...)`: # Trust the specified certificate(s). #: Custom SSL context to use for wrapping sockets ssl_context = None # Use any custom SSL context to wrap sockets. # Overwrites `trusted_certificates` and `encrypted`. # The use of this option is strongly discouraged. #: User Agent (Python Driver Specific) user_agent = get_user_agent() # Specify the client agent name. #: Socket Keep Alive (Python and .NET Driver Specific) keep_alive = True # Specify whether TCP keep-alive should be enabled. def get_ssl_context(self): if self.ssl_context is not None: return self.ssl_context if not self.encrypted: return None import ssl # SSL stands for Secure Sockets Layer and was originally created by Netscape. # SSLv2 and SSLv3 are the 2 versions of this protocol (SSLv1 was never publicly released). # After SSLv3, SSL was renamed to TLS. # TLS stands for Transport Layer Security and started with TLSv1.0 which is an upgraded version of SSLv3. # SSLv2 - (Disabled) # SSLv3 - (Disabled) # TLS 1.0 - Released in 1999, published as RFC 2246. (Disabled) # TLS 1.1 - Released in 2006, published as RFC 4346. (Disabled) # TLS 1.2 - Released in 2008, published as RFC 5246. # https://docs.python.org/3.7/library/ssl.html#ssl.PROTOCOL_TLS_CLIENT ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT) # For recommended security options see # https://docs.python.org/3.10/library/ssl.html#protocol-versions ssl_context.minimum_version = ssl.TLSVersion.TLSv1_2 if isinstance(self.trusted_certificates, TrustAll): # trust any certificate ssl_context.check_hostname = False # https://docs.python.org/3.7/library/ssl.html#ssl.CERT_NONE ssl_context.verify_mode = ssl.CERT_NONE elif isinstance(self.trusted_certificates, TrustCustomCAs): # trust the specified certificate(s) ssl_context.check_hostname = True ssl_context.verify_mode = ssl.CERT_REQUIRED for cert in self.trusted_certificates.certs: ssl_context.load_verify_locations(cert) else: # default # trust system CA certificates ssl_context.check_hostname = True ssl_context.verify_mode = ssl.CERT_REQUIRED # Must be load_default_certs, not set_default_verify_paths to # work on Windows with system CAs. ssl_context.load_default_certs() return ssl_context class WorkspaceConfig(Config): """ WorkSpace configuration. """ #: Connection Acquisition Timeout connection_acquisition_timeout = 60.0 # seconds # The maximum amount of time a session will wait when requesting a connection from the connection pool. # Since the process of acquiring a connection may involve creating a new connection, ensure that the value # of this configuration is higher than the configured Connection Timeout. #: Max Transaction Retry Time max_transaction_retry_time = 30.0 # seconds # The maximum amount of time that a managed transaction will retry before failing. #: Initial Retry Delay initial_retry_delay = 1.0 # seconds #: Retry Delay Multiplier retry_delay_multiplier = 2.0 # seconds #: Retry Delay Jitter Factor retry_delay_jitter_factor = 0.2 # seconds #: Database Name database = DEFAULT_DATABASE # Name of the database to query. # Note: The default database can be set on the Neo4j instance settings. #: Fetch Size fetch_size = 1000 #: User to impersonate impersonated_user = None # Note that you need appropriate permissions to do so. #: Bookmark Manager bookmark_manager = ExperimentalOption(None) # Specify the bookmark manager to be used for sessions by default. class SessionConfig(WorkspaceConfig): """ Session configuration. """ #: Bookmarks bookmarks = None #: Default AccessMode default_access_mode = WRITE_ACCESS class TransactionConfig(Config): """ Transaction configuration. This is internal for now. neo4j.session.begin_transaction neo4j.Query neo4j.unit_of_work are both using the same settings. """ #: Metadata metadata = None # dictionary #: Timeout timeout = None # seconds class RoutingConfig(Config): """ Neo4jDriver routing settings. This is internal for now. """ #: Routing Table Purge_Delay routing_table_purge_delay = 30.0 # seconds # The TTL + routing_table_purge_delay should be used to check if the database routing table should be removed. #: Max Routing Failures # max_routing_failures = 1 #: Retry Timeout Delay # retry_timeout_delay = 5.0 # seconds neo4j-python-driver-5.2.1/neo4j/_data.py000066400000000000000000000265611433522662700200330ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations import typing as t from abc import ( ABCMeta, abstractmethod, ) from collections.abc import ( Mapping, Sequence, Set, ) from functools import reduce from operator import xor as xor_operator from ._codec.hydration import BrokenHydrationObject from ._conf import iter_items from ._meta import deprecated from .exceptions import BrokenRecordError from .graph import ( Node, Path, Relationship, ) _T = t.TypeVar("_T") _T_K = t.Union[int, str] class Record(tuple, Mapping): """ A :class:`.Record` is an immutable ordered collection of key-value pairs. It is generally closer to a :py:class:`namedtuple` than to a :py:class:`OrderedDict` in as much as iteration of the collection will yield values rather than keys. """ __keys: t.Tuple[str] def __new__(cls, iterable=()): keys = [] values = [] for key, value in iter_items(iterable): keys.append(key) values.append(value) inst = tuple.__new__(cls, values) inst.__keys = tuple(keys) return inst def _broken_record_error(self, index): return BrokenRecordError( f"Record contains broken data at {index} ('{self.__keys[index]}')" ) def _super_getitem_single(self, index): value = super().__getitem__(index) if isinstance(value, BrokenHydrationObject): raise self._broken_record_error(index) from value.error return value def __repr__(self) -> str: return "<%s %s>" % ( self.__class__.__name__, " ".join("%s=%r" % (field, value) for field, value in zip(self.__keys, super().__iter__())) ) __str__ = __repr__ def __eq__(self, other: object) -> bool: """ In order to be flexible regarding comparison, the equality rules for a record permit comparison with any other Sequence or Mapping. :param other: :return: """ compare_as_sequence = isinstance(other, Sequence) compare_as_mapping = isinstance(other, Mapping) if compare_as_sequence and compare_as_mapping: other = t.cast(t.Mapping, other) return list(self) == list(other) and dict(self) == dict(other) elif compare_as_sequence: other = t.cast(t.Sequence, other) return list(self) == list(other) elif compare_as_mapping: other = t.cast(t.Mapping, other) return dict(self) == dict(other) else: return False def __ne__(self, other: object) -> bool: return not self.__eq__(other) def __hash__(self): return reduce(xor_operator, map(hash, self.items())) def __iter__(self) -> t.Iterator[t.Any]: for i, v in enumerate(super().__iter__()): if isinstance(v, BrokenHydrationObject): raise self._broken_record_error(i) from v.error yield v def __getitem__( # type: ignore[override] self, key: t.Union[_T_K, slice] ) -> t.Any: if isinstance(key, slice): keys = self.__keys[key] values = super().__getitem__(key) return self.__class__(zip(keys, values)) try: index = self.index(key) except IndexError: return None else: return self._super_getitem_single(index) # TODO: 6.0 - remove @deprecated("This method is deprecated and will be removed in the future.") def __getslice__(self, start, stop): key = slice(start, stop) keys = self.__keys[key] values = tuple(self)[key] return self.__class__(zip(keys, values)) def get(self, key: str, default: t.Optional[object] = None) -> t.Any: """ Obtain a value from the record by key, returning a default value if the key does not exist. :param key: a key :param default: default value :return: a value """ try: index = self.__keys.index(str(key)) except ValueError: return default if 0 <= index < len(self): return self._super_getitem_single(index) else: return default def index(self, key: _T_K) -> int: # type: ignore[override] """ Return the index of the given item. :param key: a key :return: index """ if isinstance(key, int): if 0 <= key < len(self.__keys): return key raise IndexError(key) elif isinstance(key, str): try: return self.__keys.index(key) except ValueError: raise KeyError(key) else: raise TypeError(key) def value( self, key: _T_K = 0, default: t.Optional[object] = None ) -> t.Any: """ Obtain a single value from the record by index or key. If no index or key is specified, the first value is returned. If the specified item does not exist, the default value is returned. :param key: an index or key :param default: default value :return: a single value """ try: index = self.index(key) except (IndexError, KeyError): return default else: return self[index] def keys(self) -> t.List[str]: # type: ignore[override] """ Return the keys of the record. :return: list of key names """ return list(self.__keys) def values(self, *keys: _T_K) -> t.List[t.Any]: # type: ignore[override] """ Return the values of the record, optionally filtering to include only certain values by index or key. :param keys: indexes or keys of the items to include; if none are provided, all values will be included :return: list of values """ if keys: d: t.List[t.Any] = [] for key in keys: try: i = self.index(key) except KeyError: d.append(None) else: d.append(self[i]) return d return list(self) def items(self, *keys): """ Return the fields of the record as a list of key and value tuples :return: a list of value tuples """ if keys: d = [] for key in keys: try: i = self.index(key) except KeyError: d.append((key, None)) else: d.append((self.__keys[i], self[i])) return d return list((self.__keys[i], self._super_getitem_single(i)) for i in range(len(self))) def data(self, *keys: _T_K) -> t.Dict[str, t.Any]: """ Return the keys and values of this record as a dictionary, optionally including only certain values by index or key. Keys provided in the items that are not in the record will be inserted with a value of :const:`None`; indexes provided that are out of bounds will trigger an :exc:`IndexError`. :param keys: indexes or keys of the items to include; if none are provided, all values will be included :raises: :exc:`IndexError` if an out-of-bounds index is specified :return: dictionary of values, keyed by field name """ return RecordExporter().transform(dict(self.items(*keys))) class DataTransformer(metaclass=ABCMeta): """ Abstract base class for transforming data from one form into another. """ @abstractmethod def transform(self, x): """ Transform a value, or collection of values. :param x: input value :return: output value """ class RecordExporter(DataTransformer): """ Transformer class used by the :meth:`.Record.data` method. """ def transform(self, x): if isinstance(x, Node): return self.transform(dict(x)) elif isinstance(x, Relationship): return (self.transform(dict(x.start_node)), x.__class__.__name__, self.transform(dict(x.end_node))) elif isinstance(x, Path): path = [self.transform(x.start_node)] for i, relationship in enumerate(x.relationships): path.append(self.transform(relationship.__class__.__name__)) path.append(self.transform(x.nodes[i + 1])) return path elif isinstance(x, str): return x elif isinstance(x, Sequence): t = type(x) return t(map(self.transform, x)) elif isinstance(x, Set): t = type(x) return t(map(self.transform, x)) elif isinstance(x, Mapping): t = type(x) return t((k, self.transform(v)) for k, v in x.items()) else: return x class RecordTableRowExporter(DataTransformer): """Transformer class used by the :meth:`.Result.to_df` method.""" def transform(self, x): assert isinstance(x, Mapping) t = type(x) return t(item for k, v in x.items() for item in self._transform( v, prefix=k.replace("\\", "\\\\").replace(".", "\\.") ).items()) def _transform(self, x, prefix): if isinstance(x, Node): res = { "%s().element_id" % prefix: x.element_id, "%s().labels" % prefix: x.labels, } res.update(("%s().prop.%s" % (prefix, k), v) for k, v in x.items()) return res elif isinstance(x, Relationship): res = { "%s->.element_id" % prefix: x.element_id, "%s->.start.element_id" % prefix: x.start_node.element_id, "%s->.end.element_id" % prefix: x.end_node.element_id, "%s->.type" % prefix: x.__class__.__name__, } res.update(("%s->.prop.%s" % (prefix, k), v) for k, v in x.items()) return res elif isinstance(x, Path) or isinstance(x, str): return {prefix: x} elif isinstance(x, Sequence): return dict( item for i, v in enumerate(x) for item in self._transform( v, prefix="%s[].%i" % (prefix, i) ).items() ) elif isinstance(x, Mapping): t = type(x) return t( item for k, v in x.items() for item in self._transform( v, prefix="%s{}.%s" % (prefix, k.replace("\\", "\\\\") .replace(".", "\\.")) ).items() ) else: return {prefix: x} neo4j-python-driver-5.2.1/neo4j/_deadline.py000066400000000000000000000055031433522662700206600ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 contextlib import contextmanager from time import perf_counter class Deadline: def __init__(self, timeout): if timeout is None or timeout == float("inf"): self._deadline = float("inf") else: self._deadline = perf_counter() + timeout self._original_timeout = timeout @property def original_timeout(self): return self._original_timeout def expired(self): return self.to_timeout() == 0 def to_timeout(self): if self._deadline == float("inf"): return None timeout = self._deadline - perf_counter() return timeout if timeout > 0 else 0 def __eq__(self, other): if isinstance(other, Deadline): return self._deadline == other._deadline return NotImplemented def __gt__(self, other): if isinstance(other, Deadline): return self._deadline > other._deadline return NotImplemented def __ge__(self, other): if isinstance(other, Deadline): return self._deadline >= other._deadline return NotImplemented def __lt__(self, other): if isinstance(other, Deadline): return self._deadline < other._deadline return NotImplemented def __le__(self, other): if isinstance(other, Deadline): return self._deadline <= other._deadline return NotImplemented @classmethod def from_timeout_or_deadline(cls, timeout): if isinstance(timeout, cls): return timeout return cls(timeout) merge_deadlines = min def merge_deadlines_and_timeouts(*deadline): deadlines = map(Deadline.from_timeout_or_deadline, deadline) return merge_deadlines(deadlines) @contextmanager def connection_deadline(connection, deadline): original_deadline = connection.socket.get_deadline() if deadline is None and original_deadline is not None: # nothing to do here yield return deadline = merge_deadlines( (d for d in (deadline, original_deadline) if d is not None) ) connection.socket.set_deadline(deadline) try: yield finally: connection.socket.set_deadline(original_deadline) neo4j-python-driver-5.2.1/neo4j/_exceptions.py000066400000000000000000000115751433522662700213020ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. """ Internal module for all Bolt exception classes. """ from os import strerror class BoltError(Exception): """ Base class for all Bolt protocol errors. """ def __init__(self, message, address): super().__init__(message) self.address = address class BoltConnectionError(BoltError): """ Raised when a connection fails. """ def __init__(self, message, address): msg = ( "Connection Failed. " "Please ensure that your database is listening on the correct host and port and that you have enabled encryption if required. " "Note that the default encryption setting has changed in Neo4j 4.0. See the docs for more information. " "{}") super().__init__(msg.format(message), address) def __str__(self): s = super().__str__() errno = self.errno if errno: s += " (code {}: {})".format(errno, strerror(errno)) return s @property def errno(self): try: return self.__cause__.errno except AttributeError: return None class BoltSecurityError(BoltConnectionError): """ Raised when a connection fails for security reasons. """ def __str__(self): return "[{}] {}".format(self.__cause__.__class__.__name__, super().__str__()) class BoltConnectionBroken(BoltConnectionError): """ Raised when an established connection is lost or when an attempt is made to use a connection that has previously broken. """ # TODO: add details of outstanding commits (if any), plus maybe other requests outstanding class BoltConnectionClosed(BoltConnectionError): """ Raised when an attempt is made to use a connection that has been closed locally. """ class BoltHandshakeError(BoltError): """ Raised when a handshake completes unsuccessfully. """ def __init__(self, message, address, request_data, response_data): super().__init__(message, address) self.request_data = request_data self.response_data = response_data class BoltTransactionError(BoltError): """ Raised when a fault occurs with a transaction, or when a transaction is used incorrectly. """ # TODO: pass the transaction object in as an argument class BoltFailure(BoltError): """ Holds a Cypher failure. """ #: code = None #: classification = None #: category = None #: title = None #: Flag to indicate whether an error is safe to retry or not. False #: (not retryable) by default. This can be overridden by instances #: or subclasses. transient = False @classmethod def _find_subclass(cls, predicate, default=None): if hasattr(cls, "__subclasses__"): for subclass in cls.__subclasses__(): if predicate(subclass): return subclass return default def __new__(cls, message, address, code, response): code_parts = code.split(".") classification = code_parts[1] c1 = cls._find_subclass(lambda k: k.__name__ == classification, cls) assert issubclass(c1, cls) c2 = c1._find_subclass(lambda k: k.code == code, c1) assert issubclass(c2, c1) return super().__new__(c2, message, address) def __init__(self, message, address, code, response): super().__init__(message, address) self.code = code code_parts = self.code.split(".") self.classification = code_parts[1] self.category = code_parts[2] self.title = code_parts[3] self.response = response def __str__(self): return "[{}.{}] {}".format(self.category, self.title, super().__str__()) @property def result(self): """ The Result object to which this failure is attached (if any). """ try: return self.response.result except AttributeError: return None @property def transaction(self): try: return self.result.transaction except AttributeError: return None class BoltProtocolError(BoltError): """ Raised when an unexpected or unsupported protocol event occurs. """ class SocketDeadlineExceeded(RuntimeError): """Raised from sockets with deadlines when a timeout occurs.""" neo4j-python-driver-5.2.1/neo4j/_meta.py000066400000000000000000000072611433522662700200440ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 asyncio import tracemalloc import typing as t from functools import wraps from warnings import warn _FuncT = t.TypeVar("_FuncT", bound=t.Callable) # Can be automatically overridden in builds package = "neo4j" version = "5.2.dev0" def get_user_agent(): """ Obtain the default user agent string sent to the server after a successful handshake. """ from sys import ( platform, version_info, ) template = "neo4j-python/{} Python/{}.{}.{}-{}-{} ({})" fields = (version,) + tuple(version_info) + (platform,) return template.format(*fields) def _id(x): return x def copy_signature(_: _FuncT) -> t.Callable[[t.Callable], _FuncT]: return _id def deprecation_warn(message, stack_level=1): warn(message, category=DeprecationWarning, stacklevel=stack_level + 1) def deprecated(message: str) -> t.Callable[[_FuncT], _FuncT]: """ Decorator for deprecating functions and methods. :: @deprecated("'foo' has been deprecated in favour of 'bar'") def foo(x): pass """ def decorator(f): if asyncio.iscoroutinefunction(f): @wraps(f) async def inner(*args, **kwargs): deprecation_warn(message, stack_level=2) return await f(*args, **kwargs) return inner else: @wraps(f) def inner(*args, **kwargs): deprecation_warn(message, stack_level=2) return f(*args, **kwargs) return inner return decorator def deprecated_property(message: str): def decorator(f): return property(deprecated(message)(f)) return t.cast(property, decorator) class ExperimentalWarning(Warning): """ Base class for warnings about experimental features. """ def experimental_warn(message, stack_level=1): warn(message, category=ExperimentalWarning, stacklevel=stack_level + 1) def experimental(message) -> t.Callable[[_FuncT], _FuncT]: """ Decorator for tagging experimental functions and methods. :: @experimental("'foo' is an experimental function and may be " "removed in a future release") def foo(x): pass """ def decorator(f): if asyncio.iscoroutinefunction(f): @wraps(f) async def inner(*args, **kwargs): experimental_warn(message, stack_level=2) return await f(*args, **kwargs) return inner else: @wraps(f) def inner(*args, **kwargs): experimental_warn(message, stack_level=2) return f(*args, **kwargs) return inner return decorator def unclosed_resource_warn(obj): msg = f"Unclosed {obj!r}." trace = tracemalloc.get_object_traceback(obj) if trace: msg += "\nObject allocated at (most recent call last):\n" msg += "\n".join(trace.format()) else: msg += "\nEnable tracemalloc to get the object allocation traceback." warn(msg, ResourceWarning, stacklevel=2, source=obj) neo4j-python-driver-5.2.1/neo4j/_routing.py000066400000000000000000000133751433522662700206100ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 collections.abc import MutableSet from logging import getLogger from time import perf_counter from .addressing import Address log = getLogger("neo4j") class OrderedSet(MutableSet): def __init__(self, elements=()): # dicts keep insertion order starting with Python 3.7 self._elements = dict.fromkeys(elements) self._current = None def __repr__(self): return "{%s}" % ", ".join(map(repr, self._elements)) def __contains__(self, element): return element in self._elements def __iter__(self): return iter(self._elements) def __len__(self): return len(self._elements) def __getitem__(self, index): return list(self._elements.keys())[index] def add(self, element): self._elements[element] = None def clear(self): self._elements.clear() def discard(self, element): try: del self._elements[element] except KeyError: pass def remove(self, element): try: del self._elements[element] except KeyError: raise ValueError(element) def update(self, elements=()): self._elements.update(dict.fromkeys(elements)) def replace(self, elements=()): e = self._elements e.clear() e.update(dict.fromkeys(elements)) class RoutingTable: @classmethod def parse_routing_info(cls, *, database, servers, ttl): """ Parse the records returned from the procedure call and return a new RoutingTable instance. """ routers = [] readers = [] writers = [] try: for server in servers: role = server["role"] addresses = [] for address in server["addresses"]: addresses.append(Address.parse(address, default_port=7687)) if role == "ROUTE": routers.extend(addresses) elif role == "READ": readers.extend(addresses) elif role == "WRITE": writers.extend(addresses) except (KeyError, TypeError): raise ValueError("Cannot parse routing info") else: return cls(database=database, routers=routers, readers=readers, writers=writers, ttl=ttl) def __init__(self, *, database, routers=(), readers=(), writers=(), ttl=0): self.initial_routers = OrderedSet(routers) self.routers = OrderedSet(routers) self.readers = OrderedSet(readers) self.writers = OrderedSet(writers) self.initialized_without_writers = not self.writers self.last_updated_time = perf_counter() self.ttl = ttl self.database = database def __repr__(self): return "RoutingTable(database=%r routers=%r, readers=%r, writers=%r, last_updated_time=%r, ttl=%r)" % ( self.database, self.routers, self.readers, self.writers, self.last_updated_time, self.ttl, ) def __contains__(self, address): return address in self.routers or address in self.readers or address in self.writers def is_fresh(self, readonly=False): """ Indicator for whether routing information is still usable. """ assert isinstance(readonly, bool) expired = self.last_updated_time + self.ttl <= perf_counter() if readonly: has_server_for_mode = bool(self.readers) else: has_server_for_mode = bool(self.writers) res = not expired and self.routers and has_server_for_mode log.debug("[#0000] _: checking table freshness " "(readonly=%r): table expired=%r, " "has_server_for_mode=%r, table routers=%r => %r", readonly, expired, has_server_for_mode, self.routers, res) return res def should_be_purged_from_memory(self): """ Check if the routing table is stale and not used for a long time and should be removed from memory. :return: Returns true if it is old and not used for a while. :rtype: bool """ from neo4j._conf import RoutingConfig perf_time = perf_counter() res = self.last_updated_time + self.ttl + RoutingConfig.routing_table_purge_delay <= perf_time log.debug("[#0000] _: purge check: " "last_updated_time=%r, ttl=%r, perf_time=%r => %r", self.last_updated_time, self.ttl, perf_time, res) return res def update(self, new_routing_table): """ Update the current routing table with new routing information from a replacement table. """ self.routers.replace(new_routing_table.routers) self.readers.replace(new_routing_table.readers) self.writers.replace(new_routing_table.writers) self.initialized_without_writers = not self.writers self.last_updated_time = perf_counter() self.ttl = new_routing_table.ttl log.debug("[#0000] _: updated table=%r", self) def servers(self): return set(self.routers) | set(self.writers) | set(self.readers) neo4j-python-driver-5.2.1/neo4j/_spatial/000077500000000000000000000000001433522662700201735ustar00rootroot00000000000000neo4j-python-driver-5.2.1/neo4j/_spatial/__init__.py000066400000000000000000000072561433522662700223160ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. """ This module defines spatial data types. """ from __future__ import annotations import typing as t from threading import Lock # SRID to subclass mappings srid_table: t.Dict[int, t.Tuple[t.Type[Point], int]] = {} srid_table_lock = Lock() class Point(t.Tuple[float, ...]): """Base-class for spatial data. A point within a geometric space. This type is generally used via its subclasses and should not be instantiated directly unless there is no subclass defined for the required SRID. :param iterable: An iterable of coordinates. All items will be converted to :class:`float`. :type iterable: Iterable[float] """ #: The SRID (spatial reference identifier) of the spatial data. #: A number that identifies the coordinate system the spatial type is to #: be interpreted in. srid: t.Optional[int] if t.TYPE_CHECKING: @property def x(self) -> float: ... @property def y(self) -> float: ... @property def z(self) -> float: ... def __new__(cls, iterable: t.Iterable[float]) -> Point: return tuple.__new__(cls, map(float, iterable)) def __repr__(self) -> str: return "POINT(%s)" % " ".join(map(str, self)) def __eq__(self, other: object) -> bool: try: return (type(self) is type(other) and tuple(self) == tuple(t.cast(Point, other))) except (AttributeError, TypeError): return False def __ne__(self, other: object) -> bool: return not self.__eq__(other) def __hash__(self): return hash(type(self)) ^ hash(tuple(self)) def point_type( name: str, fields: t.Tuple[str, str, str], srid_map: t.Dict[int, int] ) -> t.Type[Point]: """ Dynamically create a Point subclass. """ def srid(self): try: return srid_map[len(self)] except KeyError: return None attributes = {"srid": property(srid)} for index, subclass_field in enumerate(fields): def accessor(self, i=index, f=subclass_field): try: return self[i] except IndexError: raise AttributeError(f) for field_alias in {subclass_field, "xyz"[index]}: attributes[field_alias] = property(accessor) cls = t.cast(t.Type[Point], type(name, (Point,), attributes)) with srid_table_lock: for dim, srid_ in srid_map.items(): srid_table[srid_] = (cls, dim) return cls # Point subclass definitions if t.TYPE_CHECKING: class CartesianPoint(Point): ... else: CartesianPoint = point_type("CartesianPoint", ("x", "y", "z"), {2: 7203, 3: 9157}) if t.TYPE_CHECKING: class WGS84Point(Point): @property def longitude(self) -> float: ... @property def latitude(self) -> float: ... @property def height(self) -> float: ... else: WGS84Point = point_type("WGS84Point", ("longitude", "latitude", "height"), {2: 4326, 3: 4979}) neo4j-python-driver-5.2.1/neo4j/_sync/000077500000000000000000000000001433522662700175125ustar00rootroot00000000000000neo4j-python-driver-5.2.1/neo4j/_sync/__init__.py000066400000000000000000000012011433522662700216150ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. neo4j-python-driver-5.2.1/neo4j/_sync/bookmark_manager.py000066400000000000000000000070261433522662700233700ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations import typing as t from collections import defaultdict from .._async_compat.concurrency import CooperativeLock from .._async_compat.util import Util from ..api import ( BookmarkManager, Bookmarks, ) T_BmSupplier = t.Callable[[t.Optional[str]], t.Union[Bookmarks, t.Union[Bookmarks]]] T_BmConsumer = t.Callable[[str, Bookmarks], t.Union[None, t.Union[None]]] def _bookmarks_to_set( bookmarks: t.Union[Bookmarks, t.Iterable[str]] ) -> t.Set[str]: if isinstance(bookmarks, Bookmarks): return set(bookmarks.raw_values) return set(map(str, bookmarks)) class Neo4jBookmarkManager(BookmarkManager): def __init__( self, initial_bookmarks: t.Optional[t.Mapping[str, t.Union[Bookmarks, t.Iterable[str]]]] = None, bookmarks_supplier: t.Optional[T_BmSupplier] = None, bookmarks_consumer: t.Optional[T_BmConsumer] = None ) -> None: super().__init__() self._bookmarks_supplier = bookmarks_supplier self._bookmarks_consumer = bookmarks_consumer if initial_bookmarks is None: initial_bookmarks = {} self._bookmarks = defaultdict( set, ((k, _bookmarks_to_set(v)) for k, v in initial_bookmarks.items()) ) self._lock = CooperativeLock() def update_bookmarks( self, database: str, previous_bookmarks: t.Collection[str], new_bookmarks: t.Collection[str] ) -> None: if not new_bookmarks: return with self._lock: curr_bms = self._bookmarks[database] curr_bms.difference_update(previous_bookmarks) curr_bms.update(new_bookmarks) if self._bookmarks_consumer: curr_bms_snapshot = Bookmarks.from_raw_values(curr_bms) if self._bookmarks_consumer: Util.callback( self._bookmarks_consumer, database, curr_bms_snapshot ) def get_bookmarks(self, database: str) -> t.Set[str]: with self._lock: bms = set(self._bookmarks[database]) if self._bookmarks_supplier: extra_bms = Util.callback( self._bookmarks_supplier, database ) bms.update(extra_bms.raw_values) return bms def get_all_bookmarks(self) -> t.Set[str]: bms: t.Set[str] = set() with self._lock: for database in self._bookmarks.keys(): bms.update(self._bookmarks[database]) if self._bookmarks_supplier: extra_bms = Util.callback( self._bookmarks_supplier, None ) bms.update(extra_bms.raw_values) return bms def forget(self, databases: t.Iterable[str]) -> None: with self._lock: for database in databases: self._bookmarks.pop(database, None) neo4j-python-driver-5.2.1/neo4j/_sync/driver.py000066400000000000000000000630101433522662700213570ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations import typing as t if t.TYPE_CHECKING: import typing_extensions as te import ssl from .._async_compat.util import Util from .._conf import ( Config, PoolConfig, SessionConfig, TrustAll, TrustStore, WorkspaceConfig, ) from .._meta import ( deprecation_warn, experimental, experimental_warn, unclosed_resource_warn, ) from ..addressing import Address from ..api import ( Auth, BookmarkManager, Bookmarks, DRIVER_BOLT, DRIVER_NEO4J, parse_neo4j_uri, parse_routing_context, READ_ACCESS, SECURITY_TYPE_SECURE, SECURITY_TYPE_SELF_SIGNED_CERTIFICATE, ServerInfo, TRUST_ALL_CERTIFICATES, TRUST_SYSTEM_CA_SIGNED_CERTIFICATES, URI_SCHEME_BOLT, URI_SCHEME_BOLT_SECURE, URI_SCHEME_BOLT_SELF_SIGNED_CERTIFICATE, URI_SCHEME_NEO4J, URI_SCHEME_NEO4J_SECURE, URI_SCHEME_NEO4J_SELF_SIGNED_CERTIFICATE, ) from .bookmark_manager import ( Neo4jBookmarkManager, T_BmConsumer as _T_BmConsumer, T_BmSupplier as _T_BmSupplier, ) from .work import Session class GraphDatabase: """Accessor for :class:`neo4j.Driver` construction. """ if t.TYPE_CHECKING: @classmethod def driver( cls, uri: str, *, auth: t.Union[t.Tuple[t.Any, t.Any], Auth, None] = ..., max_connection_lifetime: float = ..., max_connection_pool_size: int = ..., connection_timeout: float = ..., trust: t.Union[ te.Literal["TRUST_ALL_CERTIFICATES"], te.Literal["TRUST_SYSTEM_CA_SIGNED_CERTIFICATES"] ] = ..., resolver: t.Union[ t.Callable[[Address], t.Iterable[Address]], t.Callable[[Address], t.Union[t.Iterable[Address]]], ] = ..., encrypted: bool = ..., trusted_certificates: TrustStore = ..., ssl_context: ssl.SSLContext = ..., user_agent: str = ..., keep_alive: bool = ..., # undocumented/unsupported options # they may be change or removed any time without prior notice connection_acquisition_timeout: float = ..., max_transaction_retry_time: float = ..., initial_retry_delay: float = ..., retry_delay_multiplier: float = ..., retry_delay_jitter_factor: float = ..., database: t.Optional[str] = ..., fetch_size: int = ..., impersonated_user: t.Optional[str] = ..., bookmark_manager: t.Union[BookmarkManager, BookmarkManager, None] = ... ) -> Driver: ... else: @classmethod def driver(cls, uri, *, auth=None, **config) -> Driver: """Create a driver. :param uri: the connection URI for the driver, see :ref:`uri-ref` for available URIs. :param auth: the authentication details, see :ref:`auth-ref` for available authentication details. :param config: driver configuration key-word arguments, see :ref:`driver-configuration-ref` for available key-word arguments. """ driver_type, security_type, parsed = parse_neo4j_uri(uri) # TODO: 6.0 remove "trust" config option if "trust" in config.keys(): if config["trust"] not in ( TRUST_ALL_CERTIFICATES, TRUST_SYSTEM_CA_SIGNED_CERTIFICATES ): from neo4j.exceptions import ConfigurationError raise ConfigurationError( "The config setting `trust` values are {!r}" .format( [ TRUST_ALL_CERTIFICATES, TRUST_SYSTEM_CA_SIGNED_CERTIFICATES, ] ) ) if ("trusted_certificates" in config.keys() and not isinstance(config["trusted_certificates"], TrustStore)): raise ConnectionError( "The config setting `trusted_certificates` must be of " "type neo4j.TrustAll, neo4j.TrustCustomCAs, or" "neo4j.TrustSystemCAs but was {}".format( type(config["trusted_certificates"]) ) ) if (security_type in [SECURITY_TYPE_SELF_SIGNED_CERTIFICATE, SECURITY_TYPE_SECURE] and ("encrypted" in config.keys() or "trust" in config.keys() or "trusted_certificates" in config.keys() or "ssl_context" in config.keys())): from neo4j.exceptions import ConfigurationError # TODO: 6.0 remove "trust" from error message raise ConfigurationError( 'The config settings "encrypted", "trust", ' '"trusted_certificates", and "ssl_context" can only be ' "used with the URI schemes {!r}. Use the other URI " "schemes {!r} for setting encryption settings." .format( [ URI_SCHEME_BOLT, URI_SCHEME_NEO4J, ], [ URI_SCHEME_BOLT_SELF_SIGNED_CERTIFICATE, URI_SCHEME_BOLT_SECURE, URI_SCHEME_NEO4J_SELF_SIGNED_CERTIFICATE, URI_SCHEME_NEO4J_SECURE, ] ) ) if security_type == SECURITY_TYPE_SECURE: config["encrypted"] = True elif security_type == SECURITY_TYPE_SELF_SIGNED_CERTIFICATE: config["encrypted"] = True config["trusted_certificates"] = TrustAll() assert driver_type in (DRIVER_BOLT, DRIVER_NEO4J) if driver_type == DRIVER_BOLT: if parse_routing_context(parsed.query): deprecation_warn( "Creating a direct driver (`bolt://` scheme) with " "routing context (URI parameters) is deprecated. They " "will be ignored. This will raise an error in a " 'future release. Given URI "{}"'.format(uri), stack_level=2 ) # TODO: 6.0 - raise instead of warning # raise ValueError( # 'Routing parameters are not supported with scheme ' # '"bolt". Given URI "{}".'.format(uri) # ) return cls.bolt_driver(parsed.netloc, auth=auth, **config) # else driver_type == DRIVER_NEO4J routing_context = parse_routing_context(parsed.query) return cls.neo4j_driver(parsed.netloc, auth=auth, routing_context=routing_context, **config) @classmethod @experimental( "The bookmark manager feature is experimental. " "It might be changed or removed any time even without prior notice." ) def bookmark_manager( cls, initial_bookmarks: t.Optional[t.Mapping[str, t.Union[Bookmarks, t.Iterable[str]]]] = None, bookmarks_supplier: t.Optional[_T_BmSupplier] = None, bookmarks_consumer: t.Optional[_T_BmConsumer] = None ) -> BookmarkManager: """Create a :class:`.BookmarkManager` with default implementation. Basic usage example to configure sessions with the built-in bookmark manager implementation so that all work is automatically causally chained (i.e., all reads can observe all previous writes even in a clustered setup):: import neo4j driver = neo4j.GraphDatabase.driver(...) bookmark_manager = neo4j.GraphDatabase.bookmark_manager(...) with driver.session( bookmark_manager=bookmark_manager ) as session1: with driver.session( bookmark_manager=bookmark_manager, access_mode=neo4j.READ_ACCESS ) as session2: result1 = session1.run("") result1.consume() # READ_QUERY is guaranteed to see what WRITE_QUERY wrote. result2 = session2.run("") result2.consume() This is a very contrived example, and in this particular case, having both queries in the same session has the exact same effect and might even be more performant. However, when dealing with sessions spanning multiple threads, Tasks, processes, or even hosts, the bookmark manager can come in handy as sessions are not safe to be used concurrently. :param initial_bookmarks: The initial set of bookmarks. The returned bookmark manager will use this to initialize its internal bookmarks per database. If present, this parameter must be a mapping of database names to :class:`.Bookmarks` or an iterable of raw bookmark values (str). :param bookmarks_supplier: Function which will be called every time the default bookmark manager's method :meth:`.BookmarkManager.get_bookmarks` or :meth:`.BookmarkManager.get_all_bookmarks` gets called. The function will be passed the name of the database (``str``) if ``.get_bookmarks`` is called or ``None`` if ``.get_all_bookmarks`` is called. The function must return a :class:`.Bookmarks` object. The result of ``bookmarks_supplier`` will then be concatenated with the internal set of bookmarks and used to configure the session in creation. :param bookmarks_consumer: Function which will be called whenever the set of bookmarks handled by the bookmark manager gets updated with the new internal bookmark set. It will receive the name of the database and the new set of bookmarks. :returns: A default implementation of :class:`BookmarkManager`. **This is experimental.** (See :ref:`filter-warnings-ref`) It might be changed or removed any time even without prior notice. .. versionadded:: 5.0 """ return Neo4jBookmarkManager( initial_bookmarks=initial_bookmarks, bookmarks_supplier=bookmarks_supplier, bookmarks_consumer=bookmarks_consumer ) @classmethod def bolt_driver(cls, target, *, auth=None, **config): """ Create a driver for direct Bolt server access that uses socket I/O and thread-based concurrency. """ from .._exceptions import ( BoltHandshakeError, BoltSecurityError, ) try: return BoltDriver.open(target, auth=auth, **config) except (BoltHandshakeError, BoltSecurityError) as error: from neo4j.exceptions import ServiceUnavailable raise ServiceUnavailable(str(error)) from error @classmethod def neo4j_driver(cls, *targets, auth=None, routing_context=None, **config): """ Create a driver for routing-capable Neo4j service access that uses socket I/O and thread-based concurrency. """ from neo4j._exceptions import ( BoltHandshakeError, BoltSecurityError, ) try: return Neo4jDriver.open(*targets, auth=auth, routing_context=routing_context, **config) except (BoltHandshakeError, BoltSecurityError) as error: from neo4j.exceptions import ServiceUnavailable raise ServiceUnavailable(str(error)) from error class _Direct: default_host = "localhost" default_port = 7687 default_target = ":" def __init__(self, address): self._address = address @property def address(self): return self._address @classmethod def parse_target(cls, target): """ Parse a target string to produce an address. """ if not target: target = cls.default_target address = Address.parse(target, default_host=cls.default_host, default_port=cls.default_port) return address class _Routing: default_host = "localhost" default_port = 7687 default_targets = ": :17601 :17687" def __init__(self, initial_addresses): self._initial_addresses = initial_addresses @property def initial_addresses(self): return self._initial_addresses @classmethod def parse_targets(cls, *targets): """ Parse a sequence of target strings to produce an address list. """ targets = " ".join(targets) if not targets: targets = cls.default_targets addresses = Address.parse_list(targets, default_host=cls.default_host, default_port=cls.default_port) return addresses class Driver: """ Base class for all types of :class:`neo4j.Driver`, instances of which are used as the primary access point to Neo4j. """ #: Connection pool _pool: t.Any = None #: Flag if the driver has been closed _closed = False def __init__(self, pool, default_workspace_config): assert pool is not None assert default_workspace_config is not None self._pool = pool self._default_workspace_config = default_workspace_config def __enter__(self) -> Driver: return self def __exit__(self, exc_type, exc_value, traceback): self.close() def __del__(self): if not self._closed: unclosed_resource_warn(self) # TODO: 6.0 - remove this if not self._closed: if not Util.is_async_code: deprecation_warn( "Relying on Driver's destructor to close the session " "is deprecated. Please make sure to close the session. " "Use it as a context (`with` statement) or make sure to " "call `.close()` explicitly. Future versions of the " "driver will not close drivers automatically." ) self.close() @property def encrypted(self) -> bool: """Indicate whether the driver was configured to use encryption.""" return bool(self._pool.pool_config.encrypted) if t.TYPE_CHECKING: def session( self, connection_acquisition_timeout: float = ..., max_transaction_retry_time: float = ..., database: t.Optional[str] = ..., fetch_size: int = ..., impersonated_user: t.Optional[str] = ..., bookmarks: t.Union[t.Iterable[str], Bookmarks, None] = ..., default_access_mode: str = ..., bookmark_manager: t.Union[BookmarkManager, BookmarkManager, None] = ..., # undocumented/unsupported options # they may be change or removed any time without prior notice initial_retry_delay: float = ..., retry_delay_multiplier: float = ..., retry_delay_jitter_factor: float = ... ) -> Session: ... else: def session(self, **config) -> Session: """Create a session, see :ref:`session-construction-ref` :param config: session configuration key-word arguments, see :ref:`session-configuration-ref` for available key-word arguments. :returns: new :class:`neo4j.Session` object """ raise NotImplementedError def close(self) -> None: """ Shut down, closing any open connections in the pool. """ self._pool.close() self._closed = True if t.TYPE_CHECKING: def verify_connectivity( self, # all arguments are experimental # they may be change or removed any time without prior notice session_connection_timeout: float = ..., connection_acquisition_timeout: float = ..., max_transaction_retry_time: float = ..., database: t.Optional[str] = ..., fetch_size: int = ..., impersonated_user: t.Optional[str] = ..., bookmarks: t.Union[t.Iterable[str], Bookmarks, None] = ..., default_access_mode: str = ..., bookmark_manager: t.Union[BookmarkManager, BookmarkManager, None] = ..., # undocumented/unsupported options initial_retry_delay: float = ..., retry_delay_multiplier: float = ..., retry_delay_jitter_factor: float = ... ) -> None: ... else: # TODO: 6.0 - remove config argument def verify_connectivity(self, **config) -> None: """Verify that the driver can establish a connection to the server. This verifies if the driver can establish a reading connection to a remote server or a cluster. Some data will be exchanged. .. note:: Even if this method raises an exception, the driver still needs to be closed via :meth:`close` to free up all resources. :param config: accepts the same configuration key-word arguments as :meth:`session`. .. warning:: All configuration key-word arguments are experimental. They might be changed or removed in any future version without prior notice. :raises DriverError: if the driver cannot connect to the remote. Use the exception to further understand the cause of the connectivity problem. .. versionchanged:: 5.0 The undocumented return value has been removed. If you need information about the remote server, use :meth:`get_server_info` instead. """ if config: experimental_warn( "All configuration key-word arguments to " "verify_connectivity() are experimental. They might be " "changed or removed in any future version without prior " "notice." ) with self.session(**config) as session: session._get_server_info() if t.TYPE_CHECKING: def get_server_info( self, # all arguments are experimental # they may be change or removed any time without prior notice session_connection_timeout: float = ..., connection_acquisition_timeout: float = ..., max_transaction_retry_time: float = ..., database: t.Optional[str] = ..., fetch_size: int = ..., impersonated_user: t.Optional[str] = ..., bookmarks: t.Union[t.Iterable[str], Bookmarks, None] = ..., default_access_mode: str = ..., bookmark_manager: t.Union[BookmarkManager, BookmarkManager, None] = ..., # undocumented/unsupported options initial_retry_delay: float = ..., retry_delay_multiplier: float = ..., retry_delay_jitter_factor: float = ... ) -> ServerInfo: ... else: def get_server_info(self, **config) -> ServerInfo: """Get information about the connected Neo4j server. Try to establish a working read connection to the remote server or a member of a cluster and exchange some data. Then return the contacted server's information. In a cluster, there is no guarantee about which server will be contacted. .. note:: Even if this method raises an exception, the driver still needs to be closed via :meth:`close` to free up all resources. :param config: accepts the same configuration key-word arguments as :meth:`session`. .. warning:: All configuration key-word arguments are experimental. They might be changed or removed in any future version without prior notice. :raises DriverError: if the driver cannot connect to the remote. Use the exception to further understand the cause of the connectivity problem. .. versionadded:: 5.0 """ if config: experimental_warn( "All configuration key-word arguments to " "verify_connectivity() are experimental. They might be " "changed or removed in any future version without prior " "notice." ) with self.session(**config) as session: return session._get_server_info() @experimental("Feature support query, based on Bolt protocol version and Neo4j server version will change in the future.") def supports_multi_db(self) -> bool: """ Check if the server or cluster supports multi-databases. :return: Returns true if the server or cluster the driver connects to supports multi-databases, otherwise false. .. note:: Feature support query, based on Bolt Protocol Version and Neo4j server version will change in the future. """ with self.session() as session: session._connect(READ_ACCESS) assert session._connection return session._connection.supports_multiple_databases class BoltDriver(_Direct, Driver): """:class:`.BoltDriver` is instantiated for ``bolt`` URIs and addresses a single database machine. This may be a standalone server or could be a specific member of a cluster. Connections established by a :class:`.BoltDriver` are always made to the exact host and port detailed in the URI. This class is not supposed to be instantiated externally. Use :meth:`GraphDatabase.driver` instead. """ @classmethod def open(cls, target, *, auth=None, **config): """ :param target: :param auth: :param config: The values that can be specified are found in :class: `neo4j.PoolConfig` and :class: `neo4j.WorkspaceConfig` :return: :rtype: :class: `neo4j.BoltDriver` """ from .io import BoltPool address = cls.parse_target(target) pool_config, default_workspace_config = Config.consume_chain(config, PoolConfig, WorkspaceConfig) pool = BoltPool.open(address, auth=auth, pool_config=pool_config, workspace_config=default_workspace_config) return cls(pool, default_workspace_config) def __init__(self, pool, default_workspace_config): _Direct.__init__(self, pool.address) Driver.__init__(self, pool, default_workspace_config) self._default_workspace_config = default_workspace_config if not t.TYPE_CHECKING: def session(self, **config) -> Session: """ :param config: The values that can be specified are found in :class: `neo4j.SessionConfig` :return: :rtype: :class: `neo4j.Session` """ session_config = SessionConfig(self._default_workspace_config, config) return Session(self._pool, session_config) class Neo4jDriver(_Routing, Driver): """:class:`.Neo4jDriver` is instantiated for ``neo4j`` URIs. The routing behaviour works in tandem with Neo4j's `Causal Clustering `_ feature by directing read and write behaviour to appropriate cluster members. This class is not supposed to be instantiated externally. Use :meth:`GraphDatabase.driver` instead. """ @classmethod def open(cls, *targets, auth=None, routing_context=None, **config): from .io import Neo4jPool addresses = cls.parse_targets(*targets) pool_config, default_workspace_config = Config.consume_chain(config, PoolConfig, WorkspaceConfig) pool = Neo4jPool.open(*addresses, auth=auth, routing_context=routing_context, pool_config=pool_config, workspace_config=default_workspace_config) return cls(pool, default_workspace_config) def __init__(self, pool, default_workspace_config): _Routing.__init__(self, [pool.address]) Driver.__init__(self, pool, default_workspace_config) if not t.TYPE_CHECKING: def session(self, **config) -> Session: session_config = SessionConfig(self._default_workspace_config, config) return Session(self._pool, session_config) neo4j-python-driver-5.2.1/neo4j/_sync/io/000077500000000000000000000000001433522662700201215ustar00rootroot00000000000000neo4j-python-driver-5.2.1/neo4j/_sync/io/__init__.py000066400000000000000000000022021433522662700222260ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. """ This module contains the low-level functionality required for speaking Bolt. It is not intended to be used directly by driver users. Instead, the `session` module provides the main user-facing abstractions. """ __all__ = [ "Bolt", "BoltPool", "Neo4jPool", "check_supported_server_product", "ConnectionErrorHandler", ] from ._bolt import Bolt from ._common import ( check_supported_server_product, ConnectionErrorHandler, ) from ._pool import ( BoltPool, Neo4jPool, ) neo4j-python-driver-5.2.1/neo4j/_sync/io/_bolt.py000066400000000000000000000731501433522662700216000ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations import abc import asyncio import socket from collections import deque from logging import getLogger from time import perf_counter from ..._async_compat.network import BoltSocket from ..._codec.hydration import v1 as hydration_v1 from ..._codec.packstream import v1 as packstream_v1 from ..._conf import PoolConfig from ..._exceptions import ( BoltError, BoltHandshakeError, ) from ..._meta import get_user_agent from ...addressing import Address from ...api import ( ServerInfo, Version, ) from ...exceptions import ( AuthError, DriverError, IncompleteCommit, ServiceUnavailable, SessionExpired, ) from ._common import ( CommitResponse, Inbox, Outbox, ) # Set up logger log = getLogger("neo4j") class Bolt: """ Server connection for Bolt protocol. A :class:`.Bolt` should be constructed following a successful .open() Bolt handshake and takes the socket over which the handshake was carried out. """ # TODO: let packer/unpacker know of hydration (give them hooks?) # TODO: make sure query parameter dehydration gets clear error message. PACKER_CLS = packstream_v1.Packer UNPACKER_CLS = packstream_v1.Unpacker HYDRATION_HANDLER_CLS = hydration_v1.HydrationHandler MAGIC_PREAMBLE = b"\x60\x60\xB0\x17" PROTOCOL_VERSION: Version = None # type: ignore[assignment] # flag if connection needs RESET to go back to READY state is_reset = False # The socket in_use = False # When the connection was last put back into the pool idle_since = float("-inf") # The socket _closing = False _closed = False # The socket _defunct = False #: The pool of which this connection is a member pool = None # Store the id of the most recent ran query to be able to reduce sent bits by # using the default (-1) to refer to the most recent query when pulling # results for it. most_recent_qid = None def __init__(self, unresolved_address, sock, max_connection_lifetime, *, auth=None, user_agent=None, routing_context=None): self.unresolved_address = unresolved_address self.socket = sock self.local_port = self.socket.getsockname()[1] self.server_info = ServerInfo(Address(sock.getpeername()), self.PROTOCOL_VERSION) # so far `connection.recv_timeout_seconds` is the only available # configuration hint that exists. Therefore, all hints can be stored at # connection level. This might change in the future. self.configuration_hints = {} self.patch = {} self.outbox = Outbox( self.socket, on_error=self._set_defunct_write, packer_cls=self.PACKER_CLS ) self.inbox = Inbox( self.socket, on_error=self._set_defunct_read, unpacker_cls=self.UNPACKER_CLS ) self.hydration_handler = self.HYDRATION_HANDLER_CLS() self.responses = deque() self._max_connection_lifetime = max_connection_lifetime self._creation_timestamp = perf_counter() self.routing_context = routing_context self.idle_since = perf_counter() # Determine the user agent if user_agent: self.user_agent = user_agent else: self.user_agent = get_user_agent() # Determine auth details if not auth: self.auth_dict = {} elif isinstance(auth, tuple) and 2 <= len(auth) <= 3: from neo4j import Auth self.auth_dict = vars(Auth("basic", *auth)) else: try: self.auth_dict = vars(auth) except (KeyError, TypeError): raise AuthError("Cannot determine auth details from %r" % auth) # Check for missing password try: credentials = self.auth_dict["credentials"] except KeyError: pass else: if credentials is None: raise AuthError("Password cannot be None") def __del__(self): if not asyncio.iscoroutinefunction(self.close): self.close() @property def connection_id(self): return self.server_info._metadata.get("connection_id", "") @property @abc.abstractmethod def supports_multiple_results(self): """ Boolean flag to indicate if the connection version supports multiple queries to be buffered on the server side (True) or if all results need to be eagerly pulled before sending the next RUN (False). """ pass @property @abc.abstractmethod def supports_multiple_databases(self): """ Boolean flag to indicate if the connection version supports multiple databases. """ pass @classmethod def protocol_handlers(cls, protocol_version=None): """ Return a dictionary of available Bolt protocol handlers, keyed by version tuple. If an explicit protocol version is provided, the dictionary will contain either zero or one items, depending on whether that version is supported. If no protocol version is provided, all available versions will be returned. :param protocol_version: tuple identifying a specific protocol version (e.g. (3, 5)) or None :return: dictionary of version tuple to handler class for all relevant and supported protocol versions :raise TypeError: if protocol version is not passed in a tuple """ # Carry out Bolt subclass imports locally to avoid circular dependency issues. from ._bolt3 import Bolt3 from ._bolt4 import ( Bolt4x1, Bolt4x2, Bolt4x3, Bolt4x4, ) from ._bolt5 import Bolt5x0 handlers = { Bolt3.PROTOCOL_VERSION: Bolt3, # 4.0 unsupported because no space left in the handshake Bolt4x1.PROTOCOL_VERSION: Bolt4x1, Bolt4x2.PROTOCOL_VERSION: Bolt4x2, Bolt4x3.PROTOCOL_VERSION: Bolt4x3, Bolt4x4.PROTOCOL_VERSION: Bolt4x4, Bolt5x0.PROTOCOL_VERSION: Bolt5x0, } if protocol_version is None: return handlers if not isinstance(protocol_version, tuple): raise TypeError("Protocol version must be specified as a tuple") if protocol_version in handlers: return {protocol_version: handlers[protocol_version]} return {} @classmethod def version_list(cls, versions, limit=4): """ Return a list of supported protocol versions in order of preference. The number of protocol versions (or ranges) returned is limited to four. """ # In fact, 4.3 is the fist version to support ranges. However, the # range support got backported to 4.2. But even if the server is too # old to have the backport, negotiating BOLT 4.1 is no problem as it's # equivalent to 4.2 first_with_range_support = Version(4, 2) result = [] for version in versions: if (result and version >= first_with_range_support and result[-1][0] == version[0] and result[-1][1][1] == version[1] + 1): # can use range to encompass this version result[-1][1][1] = version[1] continue result.append(Version(version[0], [version[1], version[1]])) if len(result) == 4: break return result @classmethod def get_handshake(cls): """ Return the supported Bolt versions as bytes. The length is 16 bytes as specified in the Bolt version negotiation. :return: bytes """ supported_versions = sorted(cls.protocol_handlers().keys(), reverse=True) offered_versions = cls.version_list(supported_versions) return b"".join(version.to_bytes() for version in offered_versions).ljust(16, b"\x00") @classmethod def ping(cls, address, *, timeout=None, pool_config=None): """ Attempt to establish a Bolt connection, returning the agreed Bolt protocol version if successful. """ if pool_config is None: pool_config = PoolConfig() try: s, protocol_version, handshake, data = \ BoltSocket.connect( address, timeout=timeout, custom_resolver=pool_config.resolver, ssl_context=pool_config.get_ssl_context(), keep_alive=pool_config.keep_alive, ) except (ServiceUnavailable, SessionExpired, BoltHandshakeError): return None else: BoltSocket.close_socket(s) return protocol_version @classmethod def open( cls, address, *, auth=None, timeout=None, routing_context=None, pool_config=None ): """Open a new Bolt connection to a given server address. :param address: :param auth: :param timeout: the connection timeout in seconds :param routing_context: dict containing routing context :param pool_config: :return: connected Bolt instance :raise BoltHandshakeError: raised if the Bolt Protocol can not negotiate a protocol version. :raise ServiceUnavailable: raised if there was a connection issue. """ def time_remaining(): if timeout is None: return None t = timeout - (perf_counter() - t0) return t if t > 0 else 0 t0 = perf_counter() if pool_config is None: pool_config = PoolConfig() socket_connection_timeout = pool_config.connection_timeout if socket_connection_timeout is None: socket_connection_timeout = time_remaining() elif timeout is not None: socket_connection_timeout = min(pool_config.connection_timeout, time_remaining()) s, pool_config.protocol_version, handshake, data = \ BoltSocket.connect( address, timeout=socket_connection_timeout, custom_resolver=pool_config.resolver, ssl_context=pool_config.get_ssl_context(), keep_alive=pool_config.keep_alive, ) # Carry out Bolt subclass imports locally to avoid circular dependency # issues. if pool_config.protocol_version == (3, 0): from ._bolt3 import Bolt3 bolt_cls = Bolt3 # Implementation for 4.0 exists, but there was no space left in the # handshake to offer this version to the server. Hence, the server # should never request us to speak bolt 4.0. # elif pool_config.protocol_version == (4, 0): # from ._bolt4 import AsyncBolt4x0 # bolt_cls = AsyncBolt4x0 elif pool_config.protocol_version == (4, 1): from ._bolt4 import Bolt4x1 bolt_cls = Bolt4x1 elif pool_config.protocol_version == (4, 2): from ._bolt4 import Bolt4x2 bolt_cls = Bolt4x2 elif pool_config.protocol_version == (4, 3): from ._bolt4 import Bolt4x3 bolt_cls = Bolt4x3 elif pool_config.protocol_version == (4, 4): from ._bolt4 import Bolt4x4 bolt_cls = Bolt4x4 elif pool_config.protocol_version == (5, 0): from ._bolt5 import Bolt5x0 bolt_cls = Bolt5x0 else: log.debug("[#%04X] S: ", s.getsockname()[1]) BoltSocket.close_socket(s) supported_versions = cls.protocol_handlers().keys() raise BoltHandshakeError( "The Neo4J server does not support communication with this " "driver. This driver has support for Bolt protocols " "{}".format(tuple(map(str, supported_versions))), address=address, request_data=handshake, response_data=data ) connection = bolt_cls( address, s, pool_config.max_connection_lifetime, auth=auth, user_agent=pool_config.user_agent, routing_context=routing_context ) try: connection.socket.set_deadline(time_remaining()) try: connection.hello() finally: connection.socket.set_deadline(None) except ( Exception, # Python 3.8+: CancelledError is a subclass of BaseException asyncio.CancelledError, ) as e: log.debug("[#%04X] C: %r", connection.local_port, e) connection.kill() raise return connection @property @abc.abstractmethod def encrypted(self): pass @property @abc.abstractmethod def der_encoded_server_certificate(self): pass @abc.abstractmethod def hello(self, dehydration_hooks=None, hydration_hooks=None): """ Appends a HELLO message to the outgoing queue, sends it and consumes all remaining messages. """ pass @abc.abstractmethod def route( self, database=None, imp_user=None, bookmarks=None, dehydration_hooks=None, hydration_hooks=None ): """ Fetch a routing table from the server for the given `database`. For Bolt 4.3 and above, this appends a ROUTE message; for earlier versions, a procedure call is made via the regular Cypher execution mechanism. In all cases, this is sent to the network, and a response is fetched. :param database: database for which to fetch a routing table Requires Bolt 4.0+. :param imp_user: the user to impersonate Requires Bolt 4.4+. :param bookmarks: iterable of bookmark values after which this transaction should begin :param dehydration_hooks: Hooks to dehydrate types (dict from type (class) to dehydration function). Dehydration functions receive the value and returns an object of type understood by packstream. :param hydration_hooks: Hooks to hydrate types (mapping from type (class) to dehydration function). Dehydration functions receive the value of type understood by packstream and are free to return anything. """ pass @abc.abstractmethod def run(self, query, parameters=None, mode=None, bookmarks=None, metadata=None, timeout=None, db=None, imp_user=None, dehydration_hooks=None, hydration_hooks=None, **handlers): """ Appends a RUN message to the output queue. :param query: Cypher query string :param parameters: dictionary of Cypher parameters :param mode: access mode for routing - "READ" or "WRITE" (default) :param bookmarks: iterable of bookmark values after which this transaction should begin :param metadata: custom metadata dictionary to attach to the transaction :param timeout: timeout for transaction execution (seconds) :param db: name of the database against which to begin the transaction Requires Bolt 4.0+. :param imp_user: the user to impersonate Requires Bolt 4.4+. :param dehydration_hooks: Hooks to dehydrate types (dict from type (class) to dehydration function). Dehydration functions receive the value and returns an object of type understood by packstream. :param hydration_hooks: Hooks to hydrate types (mapping from type (class) to dehydration function). Dehydration functions receive the value of type understood by packstream and are free to return anything. :param handlers: handler functions passed into the returned Response object """ pass @abc.abstractmethod def discard(self, n=-1, qid=-1, dehydration_hooks=None, hydration_hooks=None, **handlers): """ Appends a DISCARD message to the output queue. :param n: number of records to discard, default = -1 (ALL) :param qid: query ID to discard for, default = -1 (last query) :param dehydration_hooks: Hooks to dehydrate types (dict from type (class) to dehydration function). Dehydration functions receive the value and returns an object of type understood by packstream. :param hydration_hooks: Hooks to hydrate types (mapping from type (class) to dehydration function). Dehydration functions receive the value of type understood by packstream and are free to return anything. :param handlers: handler functions passed into the returned Response object """ pass @abc.abstractmethod def pull(self, n=-1, qid=-1, dehydration_hooks=None, hydration_hooks=None, **handlers): """ Appends a PULL message to the output queue. :param n: number of records to pull, default = -1 (ALL) :param qid: query ID to pull for, default = -1 (last query) :param dehydration_hooks: Hooks to dehydrate types (dict from type (class) to dehydration function). Dehydration functions receive the value and returns an object of type understood by packstream. :param hydration_hooks: Hooks to hydrate types (mapping from type (class) to dehydration function). Dehydration functions receive the value of type understood by packstream and are free to return anything. :param handlers: handler functions passed into the returned Response object """ pass @abc.abstractmethod def begin(self, mode=None, bookmarks=None, metadata=None, timeout=None, db=None, imp_user=None, dehydration_hooks=None, hydration_hooks=None, **handlers): """ Appends a BEGIN message to the output queue. :param mode: access mode for routing - "READ" or "WRITE" (default) :param bookmarks: iterable of bookmark values after which this transaction should begin :param metadata: custom metadata dictionary to attach to the transaction :param timeout: timeout for transaction execution (seconds) :param db: name of the database against which to begin the transaction Requires Bolt 4.0+. :param imp_user: the user to impersonate Requires Bolt 4.4+ :param dehydration_hooks: Hooks to dehydrate types (dict from type (class) to dehydration function). Dehydration functions receive the value and returns an object of type understood by packstream. :param hydration_hooks: Hooks to hydrate types (mapping from type (class) to dehydration function). Dehydration functions receive the value of type understood by packstream and are free to return anything. :param handlers: handler functions passed into the returned Response object :return: Response object """ pass @abc.abstractmethod def commit(self, dehydration_hooks=None, hydration_hooks=None, **handlers): """ Appends a COMMIT message to the output queue. :param dehydration_hooks: Hooks to dehydrate types (dict from type (class) to dehydration function). Dehydration functions receive the value and returns an object of type understood by packstream. :param hydration_hooks: Hooks to hydrate types (mapping from type (class) to dehydration function). Dehydration functions receive the value of type understood by packstream and are free to return anything. """ pass @abc.abstractmethod def rollback(self, dehydration_hooks=None, hydration_hooks=None, **handlers): """ Appends a ROLLBACK message to the output queue. :param dehydration_hooks: Hooks to dehydrate types (dict from type (class) to dehydration function). Dehydration functions receive the value and returns an object of type understood by packstream. :param hydration_hooks: Hooks to hydrate types (mapping from type (class) to dehydration function). Dehydration functions receive the value of type understood by packstream and are free to return anything.""" pass @abc.abstractmethod def reset(self, dehydration_hooks=None, hydration_hooks=None): """ Appends a RESET message to the outgoing queue, sends it and consumes all remaining messages. :param dehydration_hooks: Hooks to dehydrate types (dict from type (class) to dehydration function). Dehydration functions receive the value and returns an object of type understood by packstream. :param hydration_hooks: Hooks to hydrate types (mapping from type (class) to dehydration function). Dehydration functions receive the value of type understood by packstream and are free to return anything. """ pass @abc.abstractmethod def goodbye(self, dehydration_hooks=None, hydration_hooks=None): """Append a GOODBYE message to the outgoing queue. :param dehydration_hooks: Hooks to dehydrate types (dict from type (class) to dehydration function). Dehydration functions receive the value and returns an object of type understood by packstream. :param hydration_hooks: Hooks to hydrate types (mapping from type (class) to dehydration function). Dehydration functions receive the value of type understood by packstream and are free to return anything. """ pass def new_hydration_scope(self): return self.hydration_handler.new_hydration_scope() def _append(self, signature, fields=(), response=None, dehydration_hooks=None): """ Appends a message to the outgoing queue. :param signature: the signature of the message :param fields: the fields of the message as a tuple :param response: a response object to handle callbacks :param dehydration_hooks: Hooks to dehydrate types (dict from type (class) to dehydration function). Dehydration functions receive the value and returns an object of type understood by packstream. """ self.outbox.append_message(signature, fields, dehydration_hooks) self.responses.append(response) def _send_all(self): if self.outbox.flush(): self.idle_since = perf_counter() def send_all(self): """ Send all queued messages to the server. """ if self.closed(): raise ServiceUnavailable( "Failed to write to closed connection {!r} ({!r})".format( self.unresolved_address, self.server_info.address ) ) if self.defunct(): raise ServiceUnavailable( "Failed to write to defunct connection {!r} ({!r})".format( self.unresolved_address, self.server_info.address ) ) self._send_all() @abc.abstractmethod def _process_message(self, tag, fields): """ Receive at most one message from the server, if available. :return: 2-tuple of number of detail messages and number of summary messages fetched """ pass def fetch_message(self): if self._closed: raise ServiceUnavailable( "Failed to read from closed connection {!r} ({!r})".format( self.unresolved_address, self.server_info.address ) ) if self._defunct: raise ServiceUnavailable( "Failed to read from defunct connection {!r} ({!r})".format( self.unresolved_address, self.server_info.address ) ) if not self.responses: return 0, 0 # Receive exactly one message tag, fields = self.inbox.pop( hydration_hooks=self.responses[0].hydration_hooks ) res = self._process_message(tag, fields) self.idle_since = perf_counter() return res def fetch_all(self): """ Fetch all outstanding messages. :return: 2-tuple of number of detail messages and number of summary messages fetched """ detail_count = summary_count = 0 while self.responses: response = self.responses[0] while not response.complete: detail_delta, summary_delta = self.fetch_message() detail_count += detail_delta summary_count += summary_delta return detail_count, summary_count def _set_defunct_read(self, error=None, silent=False): message = "Failed to read from defunct connection {!r} ({!r})".format( self.unresolved_address, self.server_info.address ) self._set_defunct(message, error=error, silent=silent) def _set_defunct_write(self, error=None, silent=False): message = "Failed to write data to connection {!r} ({!r})".format( self.unresolved_address, self.server_info.address ) self._set_defunct(message, error=error, silent=silent) def _set_defunct(self, message, error=None, silent=False): from ._pool import BoltPool direct_driver = isinstance(self.pool, BoltPool) user_cancelled = isinstance(error, asyncio.CancelledError) if error: log.debug("[#%04X] _: error: %r", self.local_port, error) if not user_cancelled: log.error(message) # We were attempting to receive data but the connection # has unexpectedly terminated. So, we need to close the # connection from the client side, and remove the address # from the connection pool. self._defunct = True if user_cancelled: self.kill() raise error # cancellation error should not be re-written if not self._closing: # If we fail while closing the connection, there is no need to # remove the connection from the pool, nor to try to close the # connection again. self.close() if self.pool: self.pool.deactivate(address=self.unresolved_address) # Iterate through the outstanding responses, and if any correspond # to COMMIT requests then raise an error to signal that we are # unable to confirm that the COMMIT completed successfully. if silent: return for response in self.responses: if isinstance(response, CommitResponse): if error: raise IncompleteCommit(message) from error else: raise IncompleteCommit(message) if direct_driver: if error: raise ServiceUnavailable(message) from error else: raise ServiceUnavailable(message) else: if error: raise SessionExpired(message) from error else: raise SessionExpired(message) def stale(self): return (self._stale or (0 <= self._max_connection_lifetime <= perf_counter() - self._creation_timestamp)) _stale = False def set_stale(self): self._stale = True def close(self): """Close the connection.""" if self._closed or self._closing: return self._closing = True if not self._defunct: self.goodbye() try: self._send_all() except (OSError, BoltError, DriverError) as exc: log.debug("[#%04X] _: ignoring failed close %r", self.local_port, exc) log.debug("[#%04X] C: ", self.local_port) try: self.socket.close() except OSError: pass finally: self._closed = True def kill(self): """Close the socket most violently. No flush, no goodbye, no mercy.""" if self._closed: return log.debug("[#%04X] C: ", self.local_port) self._closing = True try: self.socket.kill() except OSError as exc: log.debug("[#%04X] _: ignoring failed kill %r", self.local_port, exc) finally: self._closed = True def closed(self): return self._closed def defunct(self): return self._defunct def is_idle_for(self, timeout): """Check if connection has been idle for at least the given timeout. :param timeout: timeout in seconds :type timeout: float :rtype: bool """ return perf_counter() - self.idle_since > timeout BoltSocket.Bolt = Bolt # type: ignore neo4j-python-driver-5.2.1/neo4j/_sync/io/_bolt3.py000066400000000000000000000355141433522662700216650ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 enum import Enum from logging import getLogger from ssl import SSLSocket from ..._exceptions import BoltProtocolError from ...api import ( READ_ACCESS, Version, ) from ...exceptions import ( ConfigurationError, DatabaseUnavailable, ForbiddenOnReadOnlyDatabase, Neo4jError, NotALeader, ServiceUnavailable, ) from ._bolt import Bolt from ._common import ( check_supported_server_product, CommitResponse, InitResponse, Response, ) log = getLogger("neo4j") class ServerStates(Enum): CONNECTED = "CONNECTED" READY = "READY" STREAMING = "STREAMING" TX_READY_OR_TX_STREAMING = "TX_READY||TX_STREAMING" FAILED = "FAILED" class ServerStateManager: _STATE_TRANSITIONS = { ServerStates.CONNECTED: { "hello": ServerStates.READY, }, ServerStates.READY: { "run": ServerStates.STREAMING, "begin": ServerStates.TX_READY_OR_TX_STREAMING, }, ServerStates.STREAMING: { "pull": ServerStates.READY, "discard": ServerStates.READY, "reset": ServerStates.READY, }, ServerStates.TX_READY_OR_TX_STREAMING: { "commit": ServerStates.READY, "rollback": ServerStates.READY, "reset": ServerStates.READY, }, ServerStates.FAILED: { "reset": ServerStates.READY, } } def __init__(self, init_state, on_change=None): self.state = init_state self._on_change = on_change def transition(self, message, metadata): if metadata.get("has_more"): return state_before = self.state self.state = self._STATE_TRANSITIONS \ .get(self.state, {}) \ .get(message, self.state) if state_before != self.state and callable(self._on_change): self._on_change(state_before, self.state) class Bolt3(Bolt): """ Protocol handler for Bolt 3. This is supported by Neo4j versions 3.5, 4.0, 4.1, 4.2, 4.3, and 4.4. """ PROTOCOL_VERSION = Version(3, 0) supports_multiple_results = False supports_multiple_databases = False def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self._server_state_manager = ServerStateManager( ServerStates.CONNECTED, on_change=self._on_server_state_change ) def _on_server_state_change(self, old_state, new_state): log.debug("[#%04X] _: state: %s > %s", self.local_port, old_state.name, new_state.name) @property def is_reset(self): # We can't be sure of the server's state if there are still pending # responses. Unless the last message we sent was RESET. In that case # the server state will always be READY when we're done. if (self.responses and self.responses[-1] and self.responses[-1].message == "reset"): return True return self._server_state_manager.state == ServerStates.READY @property def encrypted(self): return isinstance(self.socket, SSLSocket) @property def der_encoded_server_certificate(self): return self.socket.getpeercert(binary_form=True) def get_base_headers(self): return { "user_agent": self.user_agent, } def hello(self, dehydration_hooks=None, hydration_hooks=None): headers = self.get_base_headers() headers.update(self.auth_dict) logged_headers = dict(headers) if "credentials" in logged_headers: logged_headers["credentials"] = "*******" log.debug("[#%04X] C: HELLO %r", self.local_port, logged_headers) self._append(b"\x01", (headers,), response=InitResponse(self, "hello", hydration_hooks, on_success=self.server_info.update), dehydration_hooks=dehydration_hooks) self.send_all() self.fetch_all() check_supported_server_product(self.server_info.agent) def route( self, database=None, imp_user=None, bookmarks=None, dehydration_hooks=None, hydration_hooks=None ): if database is not None: raise ConfigurationError( "Database name parameter for selecting database is not " "supported in Bolt Protocol {!r}. Database name {!r}. " "Server Agent {!r}".format( self.PROTOCOL_VERSION, database, self.server_info.agent ) ) if imp_user is not None: raise ConfigurationError( "Impersonation is not supported in Bolt Protocol {!r}. " "Trying to impersonate {!r}.".format( self.PROTOCOL_VERSION, imp_user ) ) metadata = {} records = [] # Ignoring database and bookmarks because there is no multi-db support. # The bookmarks are only relevant for making sure a previously created # db exists before querying a routing table for it. self.run( "CALL dbms.cluster.routing.getRoutingTable($context)", # This is an internal procedure call. Only available if the Neo4j 3.5 is setup with clustering. {"context": self.routing_context}, mode="r", # Bolt Protocol Version(3, 0) supports mode="r" dehydration_hooks=dehydration_hooks, hydration_hooks=hydration_hooks, on_success=metadata.update ) self.pull(dehydration_hooks = None, hydration_hooks = None, on_success=metadata.update, on_records=records.extend) self.send_all() self.fetch_all() routing_info = [dict(zip(metadata.get("fields", ()), values)) for values in records] return routing_info def run(self, query, parameters=None, mode=None, bookmarks=None, metadata=None, timeout=None, db=None, imp_user=None, dehydration_hooks=None, hydration_hooks=None, **handlers): if db is not None: raise ConfigurationError( "Database name parameter for selecting database is not " "supported in Bolt Protocol {!r}. Database name {!r}.".format( self.PROTOCOL_VERSION, db ) ) if imp_user is not None: raise ConfigurationError( "Impersonation is not supported in Bolt Protocol {!r}. " "Trying to impersonate {!r}.".format( self.PROTOCOL_VERSION, imp_user ) ) if not parameters: parameters = {} extra = {} if mode in (READ_ACCESS, "r"): extra["mode"] = "r" # It will default to mode "w" if nothing is specified if bookmarks: try: extra["bookmarks"] = list(bookmarks) except TypeError: raise TypeError("Bookmarks must be provided within an iterable") if metadata: try: extra["tx_metadata"] = dict(metadata) except TypeError: raise TypeError("Metadata must be coercible to a dict") if timeout is not None: try: extra["tx_timeout"] = int(1000 * float(timeout)) except TypeError: raise TypeError("Timeout must be specified as a number of seconds") if extra["tx_timeout"] < 0: raise ValueError("Timeout must be a positive number or 0.") fields = (query, parameters, extra) log.debug("[#%04X] C: RUN %s", self.local_port, " ".join(map(repr, fields))) self._append(b"\x10", fields, Response(self, "run", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) def discard(self, n=-1, qid=-1, dehydration_hooks=None, hydration_hooks=None, **handlers): # Just ignore n and qid, it is not supported in the Bolt 3 Protocol. log.debug("[#%04X] C: DISCARD_ALL", self.local_port) self._append(b"\x2F", (), Response(self, "discard", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) def pull(self, n=-1, qid=-1, dehydration_hooks=None, hydration_hooks=None, **handlers): # Just ignore n and qid, it is not supported in the Bolt 3 Protocol. log.debug("[#%04X] C: PULL_ALL", self.local_port) self._append(b"\x3F", (), Response(self, "pull", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) def begin(self, mode=None, bookmarks=None, metadata=None, timeout=None, db=None, imp_user=None, dehydration_hooks=None, hydration_hooks=None, **handlers): if db is not None: raise ConfigurationError( "Database name parameter for selecting database is not " "supported in Bolt Protocol {!r}. Database name {!r}.".format( self.PROTOCOL_VERSION, db ) ) if imp_user is not None: raise ConfigurationError( "Impersonation is not supported in Bolt Protocol {!r}. " "Trying to impersonate {!r}.".format( self.PROTOCOL_VERSION, imp_user ) ) extra = {} if mode in (READ_ACCESS, "r"): extra["mode"] = "r" # It will default to mode "w" if nothing is specified if bookmarks: try: extra["bookmarks"] = list(bookmarks) except TypeError: raise TypeError("Bookmarks must be provided within an iterable") if metadata: try: extra["tx_metadata"] = dict(metadata) except TypeError: raise TypeError("Metadata must be coercible to a dict") if timeout is not None: try: extra["tx_timeout"] = int(1000 * float(timeout)) except TypeError: raise TypeError("Timeout must be specified as a number of seconds") if extra["tx_timeout"] < 0: raise ValueError("Timeout must be a positive number or 0.") log.debug("[#%04X] C: BEGIN %r", self.local_port, extra) self._append(b"\x11", (extra,), Response(self, "begin", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) def commit(self, dehydration_hooks=None, hydration_hooks=None, **handlers): log.debug("[#%04X] C: COMMIT", self.local_port) self._append(b"\x12", (), CommitResponse(self, "commit", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) def rollback(self, dehydration_hooks=None, hydration_hooks=None, **handlers): log.debug("[#%04X] C: ROLLBACK", self.local_port) self._append(b"\x13", (), Response(self, "rollback", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) def reset(self, dehydration_hooks=None, hydration_hooks=None): """ Add a RESET message to the outgoing queue, send it and consume all remaining messages. """ def fail(metadata): raise BoltProtocolError("RESET failed %r" % metadata, address=self.unresolved_address) log.debug("[#%04X] C: RESET", self.local_port) self._append(b"\x0F", response=Response(self, "reset", hydration_hooks, on_failure=fail), dehydration_hooks=dehydration_hooks) self.send_all() self.fetch_all() def goodbye(self, dehydration_hooks=None, hydration_hooks=None): log.debug("[#%04X] C: GOODBYE", self.local_port) self._append(b"\x02", (), dehydration_hooks=dehydration_hooks) def _process_message(self, tag, fields): """ Process at most one message from the server, if available. :return: 2-tuple of number of detail messages and number of summary messages fetched """ details = [] summary_signature = summary_metadata = None if tag == b"\x71": # RECORD details = fields elif fields: summary_signature = tag summary_metadata = fields[0] else: summary_signature = tag if details: log.debug("[#%04X] S: RECORD * %d", self.local_port, len(details)) # Do not log any data self.responses[0].on_records(details) if summary_signature is None: return len(details), 0 response = self.responses.popleft() response.complete = True if summary_signature == b"\x70": log.debug("[#%04X] S: SUCCESS %r", self.local_port, summary_metadata) self._server_state_manager.transition(response.message, summary_metadata) response.on_success(summary_metadata or {}) elif summary_signature == b"\x7E": log.debug("[#%04X] S: IGNORED", self.local_port) response.on_ignored(summary_metadata or {}) elif summary_signature == b"\x7F": log.debug("[#%04X] S: FAILURE %r", self.local_port, summary_metadata) self._server_state_manager.state = ServerStates.FAILED try: response.on_failure(summary_metadata or {}) except (ServiceUnavailable, DatabaseUnavailable): if self.pool: self.pool.deactivate(address=self.unresolved_address) raise except (NotALeader, ForbiddenOnReadOnlyDatabase): if self.pool: self.pool.on_write_failure(address=self.unresolved_address) raise except Neo4jError as e: if self.pool and e.invalidates_all_connections(): self.pool.mark_all_stale() raise else: raise BoltProtocolError("Unexpected response message with signature %02X" % summary_signature, address=self.unresolved_address) return len(details), 1 neo4j-python-driver-5.2.1/neo4j/_sync/io/_bolt4.py000066400000000000000000000512211433522662700216570ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 logging import getLogger from ssl import SSLSocket from ..._async_compat.util import Util from ..._exceptions import BoltProtocolError from ...api import ( READ_ACCESS, SYSTEM_DATABASE, Version, ) from ...exceptions import ( ConfigurationError, DatabaseUnavailable, ForbiddenOnReadOnlyDatabase, Neo4jError, NotALeader, ServiceUnavailable, ) from ._bolt import Bolt from ._bolt3 import ( ServerStateManager, ServerStates, ) from ._common import ( check_supported_server_product, CommitResponse, InitResponse, Response, ) log = getLogger("neo4j") class Bolt4x0(Bolt): """ Protocol handler for Bolt 4.0. This is supported by Neo4j versions 4.0-4.4. """ PROTOCOL_VERSION = Version(4, 0) supports_multiple_results = True supports_multiple_databases = True def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self._server_state_manager = ServerStateManager( ServerStates.CONNECTED, on_change=self._on_server_state_change ) def _on_server_state_change(self, old_state, new_state): log.debug("[#%04X] _: state: %s > %s", self.local_port, old_state.name, new_state.name) @property def is_reset(self): # We can't be sure of the server's state if there are still pending # responses. Unless the last message we sent was RESET. In that case # the server state will always be READY when we're done. if (self.responses and self.responses[-1] and self.responses[-1].message == "reset"): return True return self._server_state_manager.state == ServerStates.READY @property def encrypted(self): return isinstance(self.socket, SSLSocket) @property def der_encoded_server_certificate(self): return self.socket.getpeercert(binary_form=True) def get_base_headers(self): return { "user_agent": self.user_agent, } def hello(self, dehydration_hooks=None, hydration_hooks=None): headers = self.get_base_headers() headers.update(self.auth_dict) logged_headers = dict(headers) if "credentials" in logged_headers: logged_headers["credentials"] = "*******" log.debug("[#%04X] C: HELLO %r", self.local_port, logged_headers) self._append(b"\x01", (headers,), response=InitResponse( self, "hello", hydration_hooks, on_success=self.server_info.update ), dehydration_hooks=dehydration_hooks) self.send_all() self.fetch_all() check_supported_server_product(self.server_info.agent) def route( self, database=None, imp_user=None, bookmarks=None, dehydration_hooks=None, hydration_hooks=None ): if imp_user is not None: raise ConfigurationError( "Impersonation is not supported in Bolt Protocol {!r}. " "Trying to impersonate {!r}.".format( self.PROTOCOL_VERSION, imp_user ) ) metadata = {} records = [] if database is None: # default database self.run( "CALL dbms.routing.getRoutingTable($context)", {"context": self.routing_context}, mode="r", bookmarks=bookmarks, db=SYSTEM_DATABASE, on_success=metadata.update ) else: self.run( "CALL dbms.routing.getRoutingTable($context, $database)", {"context": self.routing_context, "database": database}, mode="r", bookmarks=bookmarks, db=SYSTEM_DATABASE, on_success=metadata.update ) self.pull( dehydration_hooks=dehydration_hooks, hydration_hooks=hydration_hooks, on_success=metadata.update, on_records=records.extend ) self.send_all() self.fetch_all() routing_info = [dict(zip(metadata.get("fields", ()), values)) for values in records] return routing_info def run(self, query, parameters=None, mode=None, bookmarks=None, metadata=None, timeout=None, db=None, imp_user=None, dehydration_hooks=None, hydration_hooks=None, **handlers): if imp_user is not None: raise ConfigurationError( "Impersonation is not supported in Bolt Protocol {!r}. " "Trying to impersonate {!r}.".format( self.PROTOCOL_VERSION, imp_user ) ) if not parameters: parameters = {} extra = {} if mode in (READ_ACCESS, "r"): extra["mode"] = "r" # It will default to mode "w" if nothing is specified if db: extra["db"] = db if bookmarks: try: extra["bookmarks"] = list(bookmarks) except TypeError: raise TypeError("Bookmarks must be provided within an iterable") if metadata: try: extra["tx_metadata"] = dict(metadata) except TypeError: raise TypeError("Metadata must be coercible to a dict") if timeout is not None: try: extra["tx_timeout"] = int(1000 * float(timeout)) except TypeError: raise TypeError("Timeout must be specified as a number of seconds") if extra["tx_timeout"] < 0: raise ValueError("Timeout must be a positive number or 0.") fields = (query, parameters, extra) log.debug("[#%04X] C: RUN %s", self.local_port, " ".join(map(repr, fields))) self._append(b"\x10", fields, Response(self, "run", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) def discard(self, n=-1, qid=-1, dehydration_hooks=None, hydration_hooks=None, **handlers): extra = {"n": n} if qid != -1: extra["qid"] = qid log.debug("[#%04X] C: DISCARD %r", self.local_port, extra) self._append(b"\x2F", (extra,), Response(self, "discard", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) def pull(self, n=-1, qid=-1, dehydration_hooks=None, hydration_hooks=None, **handlers): extra = {"n": n} if qid != -1: extra["qid"] = qid log.debug("[#%04X] C: PULL %r", self.local_port, extra) self._append(b"\x3F", (extra,), Response(self, "pull", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) def begin(self, mode=None, bookmarks=None, metadata=None, timeout=None, db=None, imp_user=None, dehydration_hooks=None, hydration_hooks=None, **handlers): if imp_user is not None: raise ConfigurationError( "Impersonation is not supported in Bolt Protocol {!r}. " "Trying to impersonate {!r}.".format( self.PROTOCOL_VERSION, imp_user ) ) extra = {} if mode in (READ_ACCESS, "r"): extra["mode"] = "r" # It will default to mode "w" if nothing is specified if db: extra["db"] = db if bookmarks: try: extra["bookmarks"] = list(bookmarks) except TypeError: raise TypeError("Bookmarks must be provided within an iterable") if metadata: try: extra["tx_metadata"] = dict(metadata) except TypeError: raise TypeError("Metadata must be coercible to a dict") if timeout is not None: try: extra["tx_timeout"] = int(1000 * float(timeout)) except TypeError: raise TypeError("Timeout must be specified as a number of seconds") if extra["tx_timeout"] < 0: raise ValueError("Timeout must be a positive number or 0.") log.debug("[#%04X] C: BEGIN %r", self.local_port, extra) self._append(b"\x11", (extra,), Response(self, "begin", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) def commit(self, dehydration_hooks=None, hydration_hooks=None, **handlers): log.debug("[#%04X] C: COMMIT", self.local_port) self._append(b"\x12", (), CommitResponse(self, "commit", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) def rollback(self, dehydration_hooks=None, hydration_hooks=None, **handlers): log.debug("[#%04X] C: ROLLBACK", self.local_port) self._append(b"\x13", (), Response(self, "rollback", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) def reset(self, dehydration_hooks=None, hydration_hooks=None): """ Add a RESET message to the outgoing queue, send it and consume all remaining messages. """ def fail(metadata): raise BoltProtocolError("RESET failed %r" % metadata, self.unresolved_address) log.debug("[#%04X] C: RESET", self.local_port) self._append(b"\x0F", response=Response(self, "reset", hydration_hooks, on_failure=fail), dehydration_hooks=dehydration_hooks) self.send_all() self.fetch_all() def goodbye(self, dehydration_hooks=None, hydration_hooks=None): log.debug("[#%04X] C: GOODBYE", self.local_port) self._append(b"\x02", (), dehydration_hooks=dehydration_hooks) def _process_message(self, tag, fields): """ Process at most one message from the server, if available. :return: 2-tuple of number of detail messages and number of summary messages fetched """ details = [] summary_signature = summary_metadata = None if tag == b"\x71": # RECORD details = fields elif fields: summary_signature = tag summary_metadata = fields[0] else: summary_signature = tag if details: log.debug("[#%04X] S: RECORD * %d", self.local_port, len(details)) # Do not log any data self.responses[0].on_records(details) if summary_signature is None: return len(details), 0 response = self.responses.popleft() response.complete = True if summary_signature == b"\x70": log.debug("[#%04X] S: SUCCESS %r", self.local_port, summary_metadata) self._server_state_manager.transition(response.message, summary_metadata) response.on_success(summary_metadata or {}) elif summary_signature == b"\x7E": log.debug("[#%04X] S: IGNORED", self.local_port) response.on_ignored(summary_metadata or {}) elif summary_signature == b"\x7F": log.debug("[#%04X] S: FAILURE %r", self.local_port, summary_metadata) self._server_state_manager.state = ServerStates.FAILED try: response.on_failure(summary_metadata or {}) except (ServiceUnavailable, DatabaseUnavailable): if self.pool: self.pool.deactivate(address=self.unresolved_address) raise except (NotALeader, ForbiddenOnReadOnlyDatabase): if self.pool: self.pool.on_write_failure(address=self.unresolved_address) raise except Neo4jError as e: if self.pool and e.invalidates_all_connections(): self.pool.mark_all_stale() raise else: raise BoltProtocolError("Unexpected response message with signature " "%02X" % ord(summary_signature), self.unresolved_address) return len(details), 1 class Bolt4x1(Bolt4x0): """ Protocol handler for Bolt 4.1. This is supported by Neo4j versions 4.1 - 4.4. """ PROTOCOL_VERSION = Version(4, 1) def get_base_headers(self): """ Bolt 4.1 passes the routing context, originally taken from the URI, into the connection initialisation message. This enables server-side routing to propagate the same behaviour through its driver. """ headers = { "user_agent": self.user_agent, } if self.routing_context is not None: headers["routing"] = self.routing_context return headers class Bolt4x2(Bolt4x1): """ Protocol handler for Bolt 4.2. This is supported by Neo4j version 4.2 - 4.4. """ PROTOCOL_VERSION = Version(4, 2) class Bolt4x3(Bolt4x2): """ Protocol handler for Bolt 4.3. This is supported by Neo4j version 4.3 - 4.4. """ PROTOCOL_VERSION = Version(4, 3) def get_base_headers(self): headers = super().get_base_headers() headers["patch_bolt"] = ["utc"] return headers def route( self, database=None, imp_user=None, bookmarks=None, dehydration_hooks=None, hydration_hooks=None ): if imp_user is not None: raise ConfigurationError( "Impersonation is not supported in Bolt Protocol {!r}. " "Trying to impersonate {!r}.".format( self.PROTOCOL_VERSION, imp_user ) ) routing_context = self.routing_context or {} log.debug("[#%04X] C: ROUTE %r %r %r", self.local_port, routing_context, bookmarks, database) metadata = {} if bookmarks is None: bookmarks = [] else: bookmarks = list(bookmarks) self._append(b"\x66", (routing_context, bookmarks, database), response=Response(self, "route", hydration_hooks, on_success=metadata.update), dehydration_hooks=dehydration_hooks) self.send_all() self.fetch_all() return [metadata.get("rt")] def hello(self, dehydration_hooks=None, hydration_hooks=None): def on_success(metadata): self.configuration_hints.update(metadata.pop("hints", {})) self.server_info.update(metadata) if "connection.recv_timeout_seconds" in self.configuration_hints: recv_timeout = self.configuration_hints[ "connection.recv_timeout_seconds" ] if isinstance(recv_timeout, int) and recv_timeout > 0: self.socket.settimeout(recv_timeout) else: log.info("[#%04X] _: Server supplied an " "invalid value for " "connection.recv_timeout_seconds (%r). Make sure " "the server and network is set up correctly.", self.local_port, recv_timeout) self.patch = set(metadata.pop("patch_bolt", [])) if "utc" in self.patch: self.hydration_handler.patch_utc() headers = self.get_base_headers() headers.update(self.auth_dict) logged_headers = dict(headers) if "credentials" in logged_headers: logged_headers["credentials"] = "*******" log.debug("[#%04X] C: HELLO %r", self.local_port, logged_headers) self._append(b"\x01", (headers,), response=InitResponse(self, "hello", hydration_hooks, on_success=on_success), dehydration_hooks=dehydration_hooks) self.send_all() self.fetch_all() check_supported_server_product(self.server_info.agent) class Bolt4x4(Bolt4x3): """ Protocol handler for Bolt 4.4. This is supported by Neo4j version 4.4. """ PROTOCOL_VERSION = Version(4, 4) def route( self, database=None, imp_user=None, bookmarks=None, dehydration_hooks=None, hydration_hooks=None ): routing_context = self.routing_context or {} db_context = {} if database is not None: db_context.update(db=database) if imp_user is not None: db_context.update(imp_user=imp_user) log.debug("[#%04X] C: ROUTE %r %r %r", self.local_port, routing_context, bookmarks, db_context) metadata = {} if bookmarks is None: bookmarks = [] else: bookmarks = list(bookmarks) self._append(b"\x66", (routing_context, bookmarks, db_context), response=Response(self, "route", hydration_hooks, on_success=metadata.update), dehydration_hooks=dehydration_hooks) self.send_all() self.fetch_all() return [metadata.get("rt")] def run(self, query, parameters=None, mode=None, bookmarks=None, metadata=None, timeout=None, db=None, imp_user=None, dehydration_hooks=None, hydration_hooks=None, **handlers): if not parameters: parameters = {} extra = {} if mode in (READ_ACCESS, "r"): # It will default to mode "w" if nothing is specified extra["mode"] = "r" if db: extra["db"] = db if imp_user: extra["imp_user"] = imp_user if bookmarks: try: extra["bookmarks"] = list(bookmarks) except TypeError: raise TypeError("Bookmarks must be provided within an iterable") if metadata: try: extra["tx_metadata"] = dict(metadata) except TypeError: raise TypeError("Metadata must be coercible to a dict") if timeout is not None: try: extra["tx_timeout"] = int(1000 * float(timeout)) except TypeError: raise TypeError("Timeout must be specified as a number of seconds") if extra["tx_timeout"] < 0: raise ValueError("Timeout must be a positive number or 0.") fields = (query, parameters, extra) log.debug("[#%04X] C: RUN %s", self.local_port, " ".join(map(repr, fields))) self._append(b"\x10", fields, Response(self, "run", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) def begin(self, mode=None, bookmarks=None, metadata=None, timeout=None, db=None, imp_user=None, dehydration_hooks=None, hydration_hooks=None, **handlers): extra = {} if mode in (READ_ACCESS, "r"): # It will default to mode "w" if nothing is specified extra["mode"] = "r" if db: extra["db"] = db if imp_user: extra["imp_user"] = imp_user if bookmarks: try: extra["bookmarks"] = list(bookmarks) except TypeError: raise TypeError("Bookmarks must be provided within an iterable") if metadata: try: extra["tx_metadata"] = dict(metadata) except TypeError: raise TypeError("Metadata must be coercible to a dict") if timeout is not None: try: extra["tx_timeout"] = int(1000 * float(timeout)) except TypeError: raise TypeError("Timeout must be specified as a number of seconds") if extra["tx_timeout"] < 0: raise ValueError("Timeout must be a positive number or 0.") log.debug("[#%04X] C: BEGIN %r", self.local_port, extra) self._append(b"\x11", (extra,), Response(self, "begin", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) neo4j-python-driver-5.2.1/neo4j/_sync/io/_bolt5.py000066400000000000000000000315161433522662700216650ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 logging import getLogger from ssl import SSLSocket from ..._codec.hydration import v2 as hydration_v2 from ..._exceptions import BoltProtocolError from ...api import ( READ_ACCESS, Version, ) from ...exceptions import ( DatabaseUnavailable, ForbiddenOnReadOnlyDatabase, Neo4jError, NotALeader, ServiceUnavailable, ) from ._bolt import Bolt from ._bolt3 import ( ServerStateManager, ServerStates, ) from ._common import ( check_supported_server_product, CommitResponse, InitResponse, Response, ) log = getLogger("neo4j") class Bolt5x0(Bolt): """Protocol handler for Bolt 5.0. """ PROTOCOL_VERSION = Version(5, 0) HYDRATION_HANDLER_CLS = hydration_v2.HydrationHandler supports_multiple_results = True supports_multiple_databases = True def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self._server_state_manager = ServerStateManager( ServerStates.CONNECTED, on_change=self._on_server_state_change ) def _on_server_state_change(self, old_state, new_state): log.debug("[#%04X] _: state: %s > %s", self.local_port, old_state.name, new_state.name) @property def is_reset(self): # We can't be sure of the server's state if there are still pending # responses. Unless the last message we sent was RESET. In that case # the server state will always be READY when we're done. if (self.responses and self.responses[-1] and self.responses[-1].message == "reset"): return True return self._server_state_manager.state == ServerStates.READY @property def encrypted(self): return isinstance(self.socket, SSLSocket) @property def der_encoded_server_certificate(self): return self.socket.getpeercert(binary_form=True) def get_base_headers(self): headers = {"user_agent": self.user_agent} if self.routing_context is not None: headers["routing"] = self.routing_context return headers def hello(self, dehydration_hooks=None, hydration_hooks=None): def on_success(metadata): self.configuration_hints.update(metadata.pop("hints", {})) self.server_info.update(metadata) if "connection.recv_timeout_seconds" in self.configuration_hints: recv_timeout = self.configuration_hints[ "connection.recv_timeout_seconds" ] if isinstance(recv_timeout, int) and recv_timeout > 0: self.socket.settimeout(recv_timeout) else: log.info("[#%04X] _: Server supplied an " "invalid value for " "connection.recv_timeout_seconds (%r). Make sure " "the server and network is set up correctly.", self.local_port, recv_timeout) headers = self.get_base_headers() headers.update(self.auth_dict) logged_headers = dict(headers) if "credentials" in logged_headers: logged_headers["credentials"] = "*******" log.debug("[#%04X] C: HELLO %r", self.local_port, logged_headers) self._append(b"\x01", (headers,), response=InitResponse(self, "hello", hydration_hooks, on_success=on_success), dehydration_hooks=dehydration_hooks) self.send_all() self.fetch_all() check_supported_server_product(self.server_info.agent) def route(self, database=None, imp_user=None, bookmarks=None, dehydration_hooks=None, hydration_hooks=None): routing_context = self.routing_context or {} db_context = {} if database is not None: db_context.update(db=database) if imp_user is not None: db_context.update(imp_user=imp_user) log.debug("[#%04X] C: ROUTE %r %r %r", self.local_port, routing_context, bookmarks, db_context) metadata = {} if bookmarks is None: bookmarks = [] else: bookmarks = list(bookmarks) self._append(b"\x66", (routing_context, bookmarks, db_context), response=Response(self, "route", hydration_hooks, on_success=metadata.update), dehydration_hooks=hydration_hooks) self.send_all() self.fetch_all() return [metadata.get("rt")] def run(self, query, parameters=None, mode=None, bookmarks=None, metadata=None, timeout=None, db=None, imp_user=None, dehydration_hooks=None, hydration_hooks=None, **handlers): if not parameters: parameters = {} extra = {} if mode in (READ_ACCESS, "r"): # It will default to mode "w" if nothing is specified extra["mode"] = "r" if db: extra["db"] = db if imp_user: extra["imp_user"] = imp_user if bookmarks: try: extra["bookmarks"] = list(bookmarks) except TypeError: raise TypeError("Bookmarks must be provided as iterable") if metadata: try: extra["tx_metadata"] = dict(metadata) except TypeError: raise TypeError("Metadata must be coercible to a dict") if timeout is not None: try: extra["tx_timeout"] = int(1000 * float(timeout)) except TypeError: raise TypeError("Timeout must be a number (in seconds)") if extra["tx_timeout"] < 0: raise ValueError("Timeout must be a number <= 0") fields = (query, parameters, extra) log.debug("[#%04X] C: RUN %s", self.local_port, " ".join(map(repr, fields))) self._append(b"\x10", fields, Response(self, "run", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) def discard(self, n=-1, qid=-1, dehydration_hooks=None, hydration_hooks=None, **handlers): extra = {"n": n} if qid != -1: extra["qid"] = qid log.debug("[#%04X] C: DISCARD %r", self.local_port, extra) self._append(b"\x2F", (extra,), Response(self, "discard", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) def pull(self, n=-1, qid=-1, dehydration_hooks=None, hydration_hooks=None, **handlers): extra = {"n": n} if qid != -1: extra["qid"] = qid log.debug("[#%04X] C: PULL %r", self.local_port, extra) self._append(b"\x3F", (extra,), Response(self, "pull", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) def begin(self, mode=None, bookmarks=None, metadata=None, timeout=None, db=None, imp_user=None, dehydration_hooks=None, hydration_hooks=None, **handlers): extra = {} if mode in (READ_ACCESS, "r"): # It will default to mode "w" if nothing is specified extra["mode"] = "r" if db: extra["db"] = db if imp_user: extra["imp_user"] = imp_user if bookmarks: try: extra["bookmarks"] = list(bookmarks) except TypeError: raise TypeError("Bookmarks must be provided as iterable") if metadata: try: extra["tx_metadata"] = dict(metadata) except TypeError: raise TypeError("Metadata must be coercible to a dict") if timeout is not None: try: extra["tx_timeout"] = int(1000 * float(timeout)) except TypeError: raise TypeError("Timeout must be a number (in seconds)") if extra["tx_timeout"] < 0: raise ValueError("Timeout must be a number <= 0") log.debug("[#%04X] C: BEGIN %r", self.local_port, extra) self._append(b"\x11", (extra,), Response(self, "begin", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) def commit(self, dehydration_hooks=None, hydration_hooks=None, **handlers): log.debug("[#%04X] C: COMMIT", self.local_port) self._append(b"\x12", (), CommitResponse(self, "commit", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) def rollback(self, dehydration_hooks=None, hydration_hooks=None, **handlers): log.debug("[#%04X] C: ROLLBACK", self.local_port) self._append(b"\x13", (), Response(self, "rollback", hydration_hooks, **handlers), dehydration_hooks=dehydration_hooks) def reset(self, dehydration_hooks=None, hydration_hooks=None): """Reset the connection. Add a RESET message to the outgoing queue, send it and consume all remaining messages. """ def fail(metadata): raise BoltProtocolError("RESET failed %r" % metadata, self.unresolved_address) log.debug("[#%04X] C: RESET", self.local_port) self._append(b"\x0F", response=Response(self, "reset", hydration_hooks, on_failure=fail), dehydration_hooks=dehydration_hooks) self.send_all() self.fetch_all() def goodbye(self, dehydration_hooks=None, hydration_hooks=None): log.debug("[#%04X] C: GOODBYE", self.local_port) self._append(b"\x02", (), dehydration_hooks=dehydration_hooks) def _process_message(self, tag, fields): """Process at most one message from the server, if available. :return: 2-tuple of number of detail messages and number of summary messages fetched """ details = [] summary_signature = summary_metadata = None if tag == b"\x71": # RECORD details = fields elif fields: summary_signature = tag summary_metadata = fields[0] else: summary_signature = tag if details: # Do not log any data log.debug("[#%04X] S: RECORD * %d", self.local_port, len(details)) self.responses[0].on_records(details) if summary_signature is None: return len(details), 0 response = self.responses.popleft() response.complete = True if summary_signature == b"\x70": log.debug("[#%04X] S: SUCCESS %r", self.local_port, summary_metadata) self._server_state_manager.transition(response.message, summary_metadata) response.on_success(summary_metadata or {}) elif summary_signature == b"\x7E": log.debug("[#%04X] S: IGNORED", self.local_port) response.on_ignored(summary_metadata or {}) elif summary_signature == b"\x7F": log.debug("[#%04X] S: FAILURE %r", self.local_port, summary_metadata) self._server_state_manager.state = ServerStates.FAILED try: response.on_failure(summary_metadata or {}) except (ServiceUnavailable, DatabaseUnavailable): if self.pool: self.pool.deactivate(address=self.unresolved_address) raise except (NotALeader, ForbiddenOnReadOnlyDatabase): if self.pool: self.pool.on_write_failure(address=self.unresolved_address) raise except Neo4jError as e: if self.pool and e.invalidates_all_connections(): self.pool.mark_all_stale() raise else: raise BoltProtocolError( "Unexpected response message with signature %02X" % ord( summary_signature ), self.unresolved_address ) return len(details), 1 neo4j-python-driver-5.2.1/neo4j/_sync/io/_common.py000066400000000000000000000230501433522662700221220ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 asyncio import logging from struct import pack as struct_pack from ..._async_compat.util import Util from ..._exceptions import SocketDeadlineExceeded from ...exceptions import ( Neo4jError, ServiceUnavailable, SessionExpired, UnsupportedServerProduct, ) log = logging.getLogger("neo4j") class Inbox: def __init__(self, sock, on_error, unpacker_cls): self.on_error = on_error self._local_port = sock.getsockname()[1] self._socket = sock self._buffer = unpacker_cls.new_unpackable_buffer() self._unpacker = unpacker_cls(self._buffer) self._broken = False def _buffer_one_chunk(self): assert not self._broken try: chunk_size = 0 while True: while chunk_size == 0: # Determine the chunk size and skip noop receive_into_buffer(self._socket, self._buffer, 2) chunk_size = self._buffer.pop_u16() if chunk_size == 0: log.debug("[#%04X] S: ", self._local_port) receive_into_buffer( self._socket, self._buffer, chunk_size + 2 ) chunk_size = self._buffer.pop_u16() if chunk_size == 0: # chunk_size was the end marker for the message return except ( OSError, SocketDeadlineExceeded, asyncio.CancelledError ) as error: self._broken = True Util.callback(self.on_error, error) raise def pop(self, hydration_hooks): self._buffer_one_chunk() try: size, tag = self._unpacker.unpack_structure_header() fields = [self._unpacker.unpack(hydration_hooks) for _ in range(size)] return tag, fields finally: # Reset for new message self._unpacker.reset() class Outbox: def __init__(self, sock, on_error, packer_cls, max_chunk_size=16384): self._max_chunk_size = max_chunk_size self._chunked_data = bytearray() self._buffer = packer_cls.new_packable_buffer() self._packer = packer_cls(self._buffer) self.socket = sock self.on_error = on_error def max_chunk_size(self): return self._max_chunk_size def _clear(self): assert not self._buffer.is_tmp_buffering() self._chunked_data = bytearray() self._buffer.clear() def _chunk_data(self): data_len = len(self._buffer.data) num_full_chunks, chunk_rest = divmod( data_len, self._max_chunk_size ) num_chunks = num_full_chunks + bool(chunk_rest) with memoryview(self._buffer.data) as data_view: header_start = len(self._chunked_data) data_start = header_start + 2 raw_data_start = 0 for i in range(num_chunks): chunk_size = min(data_len - raw_data_start, self._max_chunk_size) self._chunked_data[header_start:data_start] = struct_pack( ">H", chunk_size ) self._chunked_data[data_start:(data_start + chunk_size)] = \ data_view[raw_data_start:(raw_data_start + chunk_size)] header_start += chunk_size + 2 data_start = header_start + 2 raw_data_start += chunk_size self._buffer.clear() def _wrap_message(self): assert not self._buffer.is_tmp_buffering() self._chunk_data() self._chunked_data += b"\x00\x00" def append_message(self, tag, fields, dehydration_hooks): with self._buffer.tmp_buffer(): self._packer.pack_struct(tag, fields, dehydration_hooks) self._wrap_message() def flush(self): data = self._chunked_data if data: try: self.socket.sendall(data) except ( OSError, SocketDeadlineExceeded, asyncio.CancelledError ) as error: Util.callback(self.on_error, error) return False self._clear() return True return False class ConnectionErrorHandler: """ Wrapper class for handling connection errors. The class will wrap each method to invoke a callback if the method raises Neo4jError, SessionExpired, or ServiceUnavailable. The error will be re-raised after the callback. """ def __init__(self, connection, on_error): """ :param connection the connection object to warp :type connection Bolt :param on_error the function to be called when a method of connection raises of of the caught errors. :type on_error callable """ self.__connection = connection self.__on_error = on_error def __getattr__(self, name): connection_attr = getattr(self.__connection, name) if not callable(connection_attr): return connection_attr def outer(func): def inner(*args, **kwargs): try: func(*args, **kwargs) except (Neo4jError, ServiceUnavailable, SessionExpired) as exc: assert not asyncio.iscoroutinefunction(self.__on_error) self.__on_error(exc) raise return inner def outer_async(coroutine_func): def inner(*args, **kwargs): try: coroutine_func(*args, **kwargs) except (Neo4jError, ServiceUnavailable, SessionExpired, asyncio.CancelledError) as exc: Util.callback(self.__on_error, exc) raise return inner if asyncio.iscoroutinefunction(connection_attr): return outer_async(connection_attr) return outer(connection_attr) def __setattr__(self, name, value): if name.startswith("_" + self.__class__.__name__ + "__"): super().__setattr__(name, value) else: setattr(self.__connection, name, value) class Response: """ Subscriber object for a full response (zero or more detail messages followed by one summary message). """ def __init__(self, connection, message, hydration_hooks, **handlers): self.connection = connection self.hydration_hooks = hydration_hooks self.handlers = handlers self.message = message self.complete = False def on_records(self, records): """ Called when one or more RECORD messages have been received. """ handler = self.handlers.get("on_records") Util.callback(handler, records) def on_success(self, metadata): """ Called when a SUCCESS message has been received. """ handler = self.handlers.get("on_success") Util.callback(handler, metadata) if not metadata.get("has_more"): handler = self.handlers.get("on_summary") Util.callback(handler) def on_failure(self, metadata): """ Called when a FAILURE message has been received. """ try: self.connection.reset() except (SessionExpired, ServiceUnavailable): pass handler = self.handlers.get("on_failure") Util.callback(handler, metadata) handler = self.handlers.get("on_summary") Util.callback(handler) raise Neo4jError.hydrate(**metadata) def on_ignored(self, metadata=None): """ Called when an IGNORED message has been received. """ handler = self.handlers.get("on_ignored") Util.callback(handler, metadata) handler = self.handlers.get("on_summary") Util.callback(handler) class InitResponse(Response): def on_failure(self, metadata): code = metadata.get("code") if code == "Neo.ClientError.Security.Unauthorized": raise Neo4jError.hydrate(**metadata) else: raise ServiceUnavailable( metadata.get("message", "Connection initialisation failed") ) class CommitResponse(Response): pass def check_supported_server_product(agent): """ Checks that a server product is supported by the driver by looking at the server agent string. :param agent: server agent string to check for validity :raises UnsupportedServerProduct: if the product is not supported """ if not agent.startswith("Neo4j/"): raise UnsupportedServerProduct(agent) def receive_into_buffer(sock, buffer, n_bytes): end = buffer.used + n_bytes if end > len(buffer.data): buffer.data += bytearray(end - len(buffer.data)) with memoryview(buffer.data) as view: while buffer.used < end: n = sock.recv_into(view[buffer.used:end], end - buffer.used) if n == 0: raise OSError("No data") buffer.used += n neo4j-python-driver-5.2.1/neo4j/_sync/io/_pool.py000066400000000000000000000777701433522662700216250ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 abc import asyncio import logging from collections import ( defaultdict, deque, ) from logging import getLogger from random import choice from ..._async_compat.concurrency import ( Condition, CooperativeRLock, RLock, ) from ..._async_compat.network import NetworkUtil from ..._conf import ( PoolConfig, WorkspaceConfig, ) from ..._deadline import ( connection_deadline, Deadline, ) from ..._exceptions import BoltError from ..._routing import RoutingTable from ...api import ( READ_ACCESS, WRITE_ACCESS, ) from ...exceptions import ( ClientError, ConfigurationError, DriverError, Neo4jError, ReadServiceUnavailable, ServiceUnavailable, SessionExpired, WriteServiceUnavailable, ) from ._bolt import Bolt # Set up logger log = getLogger("neo4j") class IOPool(abc.ABC): """ A collection of connections to one or more server addresses. """ def __init__(self, opener, pool_config, workspace_config): assert callable(opener) assert isinstance(pool_config, PoolConfig) assert isinstance(workspace_config, WorkspaceConfig) self.opener = opener self.pool_config = pool_config self.workspace_config = workspace_config self.connections = defaultdict(deque) self.connections_reservations = defaultdict(lambda: 0) self.lock = CooperativeRLock() self.cond = Condition(self.lock) def __enter__(self): return self def __exit__(self, exc_type, exc_value, traceback): self.close() def _acquire_from_pool(self, address): with self.lock: for connection in list(self.connections.get(address, [])): if connection.in_use: continue connection.pool = self connection.in_use = True return connection return None # no free connection available def _acquire_from_pool_checked( self, address, health_check, deadline ): while not deadline.expired(): connection = self._acquire_from_pool(address) if not connection: return None # no free connection available if not health_check(connection, deadline): # `close` is a noop on already closed connections. # This is to make sure that the connection is # gracefully closed, e.g. if it's just marked as # `stale` but still alive. if log.isEnabledFor(logging.DEBUG): log.debug( "[#%04X] _: removing old connection %s " "(closed=%s, defunct=%s, stale=%s, in_use=%s)", connection.local_port, connection.connection_id, connection.closed(), connection.defunct(), connection.stale(), connection.in_use ) connection.close() with self.lock: try: self.connections.get(address, []).remove(connection) except ValueError: # If closure fails (e.g. because the server went # down), all connections to the same address will # be removed. Therefore, we silently ignore if the # connection isn't in the pool anymore. pass continue # try again with a new connection else: return connection def _acquire_new_later(self, address, deadline): def connection_creator(): released_reservation = False try: try: connection = self.opener( address, deadline.to_timeout() ) except ServiceUnavailable: self.deactivate(address) raise connection.pool = self connection.in_use = True with self.lock: self.connections_reservations[address] -= 1 released_reservation = True self.connections[address].append(connection) return connection finally: if not released_reservation: with self.lock: self.connections_reservations[address] -= 1 max_pool_size = self.pool_config.max_connection_pool_size infinite_pool_size = (max_pool_size < 0 or max_pool_size == float("inf")) with self.lock: connections = self.connections[address] pool_size = (len(connections) + self.connections_reservations[address]) if infinite_pool_size or pool_size < max_pool_size: # there's room for a new connection self.connections_reservations[address] += 1 return connection_creator return None def _acquire(self, address, deadline, liveness_check_timeout): """ Acquire a connection to a given address from the pool. The address supplied should always be an IP address, not a host name. This method is thread safe. """ def health_check(connection_, deadline_): if (connection_.closed() or connection_.defunct() or connection_.stale()): return False if liveness_check_timeout is not None: if connection_.is_idle_for(liveness_check_timeout): with connection_deadline(connection_, deadline_): try: log.debug("[#%04X] _: liveness check", connection_.local_port) connection_.reset() except (OSError, ServiceUnavailable, SessionExpired): return False return True while True: # try to find a free connection in the pool connection = self._acquire_from_pool_checked( address, health_check, deadline ) if connection: log.debug("[#%04X] _: handing out existing connection " "%s", connection.local_port, connection.connection_id) return connection # all connections in pool are in-use with self.lock: connection_creator = self._acquire_new_later(address, deadline) if connection_creator: break # failed to obtain a connection from pool because the # pool is full and no free connection in the pool timeout = deadline.to_timeout() if ( timeout == 0 # deadline expired or not self.cond.wait(timeout) ): log.debug("[#0000] _: acquisition timed out") raise ClientError( "failed to obtain a connection from the pool within " "{!r}s (timeout)".format(deadline.original_timeout) ) log.debug("[#0000] _: trying to hand out new connection") return connection_creator() @abc.abstractmethod def acquire( self, access_mode, timeout, database, bookmarks, liveness_check_timeout ): """ Acquire a connection to a server that can satisfy a set of parameters. :param access_mode: :param timeout: timeout for the core acquisition (excluding potential preparation like fetching routing tables). :param database: :param bookmarks: :param liveness_check_timeout: """ ... def kill_and_release(self, *connections): """ Release connections back into the pool after closing them. This method is thread safe. """ for connection in connections: if not (connection.defunct() or connection.closed()): log.debug( "[#%04X] _: killing connection on release %s", connection.local_port, connection.connection_id ) connection.kill() with self.lock: for connection in connections: connection.in_use = False self.cond.notify_all() def release(self, *connections): """ Release connections back into the pool. This method is thread safe. """ cancelled = None for connection in connections: if not (connection.defunct() or connection.closed() or connection.is_reset): if cancelled is not None: log.debug( "[#%04X] _: released unclean connection %s", connection.local_port, connection.connection_id ) connection.kill() continue try: log.debug( "[#%04X] _: released unclean connection %s", connection.local_port, connection.connection_id ) connection.reset() except (Neo4jError, DriverError, BoltError) as e: log.debug("[#%04X] _: failed to reset connection " "on release: %r", connection.local_port, e) except asyncio.CancelledError as e: log.debug("[#%04X] _: cancelled reset connection " "on release: %r", connection.local_port, e) cancelled = e connection.kill() with self.lock: for connection in connections: connection.in_use = False log.debug( "[#%04X] _: released %s", connection.local_port, connection.connection_id ) self.cond.notify_all() if cancelled is not None: raise cancelled def in_use_connection_count(self, address): """ Count the number of connections currently in use to a given address. """ with self.lock: connections = self.connections.get(address, ()) return sum(connection.in_use for connection in connections) def mark_all_stale(self): with self.lock: for address in self.connections: for connection in self.connections[address]: connection.set_stale() @classmethod def _close_connections(cls, connections): cancelled = None for connection in connections: if cancelled is not None: connection.kill() continue try: connection.close() except asyncio.CancelledError as e: # We've got cancelled: no more time to gracefully close these # connections. Time to burn down the place. cancelled = e connection.kill() if cancelled is not None: raise cancelled def deactivate(self, address): """ Deactivate an address from the connection pool, if present, closing all idle connection to that address """ with self.lock: try: connections = self.connections[address] except KeyError: # already removed from the connection pool return closable_connections = [ conn for conn in connections if not conn.in_use ] # First remove all connections in question, then try to close them. # If closing of a connection fails, we will end up in this method # again. for conn in closable_connections: connections.remove(conn) if not self.connections[address]: del self.connections[address] self._close_connections(closable_connections) def on_write_failure(self, address): raise WriteServiceUnavailable( "No write service available for pool {}".format(self) ) def close(self): """ Close all connections and empty the pool. This method is thread safe. """ log.debug("[#0000] _: close") try: connections = [] with self.lock: for address in list(self.connections): for connection in self.connections.pop(address, ()): connections.append(connection) self._close_connections(connections) except TypeError: pass class BoltPool(IOPool): @classmethod def open(cls, address, *, auth, pool_config, workspace_config): """Create a new BoltPool :param address: :param auth: :param pool_config: :param workspace_config: :return: BoltPool """ def opener(addr, timeout): return Bolt.open( addr, auth=auth, timeout=timeout, routing_context=None, pool_config=pool_config ) pool = cls(opener, pool_config, workspace_config, address) log.debug("[#0000] _: created, direct address %r", address) return pool def __init__(self, opener, pool_config, workspace_config, address): super().__init__(opener, pool_config, workspace_config) self.address = address def __repr__(self): return "<{} address={!r}>".format(self.__class__.__name__, self.address) def acquire( self, access_mode, timeout, database, bookmarks, liveness_check_timeout ): # The access_mode and database is not needed for a direct connection, # it's just there for consistency. log.debug("[#0000] _: acquire direct connection, " "access_mode=%r, database=%r", access_mode, database) deadline = Deadline.from_timeout_or_deadline(timeout) return self._acquire( self.address, deadline, liveness_check_timeout ) class Neo4jPool(IOPool): """ Connection pool with routing table. """ @classmethod def open(cls, *addresses, auth, pool_config, workspace_config, routing_context=None): """Create a new Neo4jPool :param addresses: one or more address as positional argument :param auth: :param pool_config: :param workspace_config: :param routing_context: :return: Neo4jPool """ address = addresses[0] if routing_context is None: routing_context = {} elif "address" in routing_context: raise ConfigurationError("The key 'address' is reserved for routing context.") routing_context["address"] = str(address) def opener(addr, timeout): return Bolt.open( addr, auth=auth, timeout=timeout, routing_context=routing_context, pool_config=pool_config ) pool = cls(opener, pool_config, workspace_config, address) log.debug("[#0000] _: created, routing address %r", address) return pool def __init__(self, opener, pool_config, workspace_config, address): """ :param opener: :param pool_config: :param workspace_config: :param address: """ super().__init__(opener, pool_config, workspace_config) # Each database have a routing table, the default database is a special case. self.address = address self.routing_tables = {} self.refresh_lock = RLock() def __repr__(self): """ The representation shows the initial routing addresses. :return: The representation :rtype: str """ return "<{} address={!r}>".format(self.__class__.__name__, self.address) def get_or_create_routing_table(self, database): with self.refresh_lock: if database not in self.routing_tables: self.routing_tables[database] = RoutingTable( database=database, routers=[self.address] ) return self.routing_tables[database] def fetch_routing_info( self, address, database, imp_user, bookmarks, acquisition_timeout ): """ Fetch raw routing info from a given router address. :param address: router address :param database: the database name to get routing table for :param imp_user: the user to impersonate while fetching the routing table :type imp_user: str or None :param bookmarks: iterable of bookmark values after which the routing info should be fetched :param acquisition_timeout: connection acquisition timeout :return: list of routing records, or None if no connection could be established or if no readers or writers are present :raise ServiceUnavailable: if the server does not support routing, or if routing support is broken or outdated """ deadline = Deadline.from_timeout_or_deadline(acquisition_timeout) log.debug("[#0000] _: _acquire router connection, " "database=%r, address=%r", database, address) cx = self._acquire(address, deadline, None) try: routing_table = cx.route( database=database or self.workspace_config.database, imp_user=imp_user or self.workspace_config.impersonated_user, bookmarks=bookmarks ) finally: self.release(cx) return routing_table def fetch_routing_table( self, *, address, acquisition_timeout, database, imp_user, bookmarks ): """ Fetch a routing table from a given router address. :param address: router address :param acquisition_timeout: connection acquisition timeout :param database: the database name :type: str :param imp_user: the user to impersonate while fetching the routing table :type imp_user: str or None :param bookmarks: bookmarks used when fetching routing table :return: a new RoutingTable instance or None if the given router is currently unable to provide routing information """ new_routing_info = None try: new_routing_info = self.fetch_routing_info( address, database, imp_user, bookmarks, acquisition_timeout ) except Neo4jError as e: # checks if the code is an error that is caused by the client. In # this case there is no sense in trying to fetch a RT from another # router. Hence, the driver should fail fast during discovery. if e.is_fatal_during_discovery(): raise except (ServiceUnavailable, SessionExpired): pass if not new_routing_info: log.debug("[#0000] _: failed to fetch routing info " "from %r", address) return None else: servers = new_routing_info[0]["servers"] ttl = new_routing_info[0]["ttl"] database = new_routing_info[0].get("db", database) new_routing_table = RoutingTable.parse_routing_info( database=database, servers=servers, ttl=ttl ) # Parse routing info and count the number of each type of server num_routers = len(new_routing_table.routers) num_readers = len(new_routing_table.readers) # num_writers = len(new_routing_table.writers) # If no writers are available. This likely indicates a temporary state, # such as leader switching, so we should not signal an error. # No routers if num_routers == 0: log.debug("[#0000] _: no routing servers returned from " "server %s", address) return None # No readers if num_readers == 0: log.debug("[#0000] _: no read servers returned from " "server %s", address) return None # At least one of each is fine, so return this table return new_routing_table def _update_routing_table_from( self, *routers, database, imp_user, bookmarks, acquisition_timeout, database_callback ): """ Try to update routing tables with the given routers. :return: True if the routing table is successfully updated, otherwise False """ if routers: log.debug("[#0000] _: attempting to update routing " "table from {}".format(", ".join(map(repr, routers)))) for router in routers: for address in NetworkUtil.resolve_address( router, resolver=self.pool_config.resolver ): new_routing_table = self.fetch_routing_table( address=address, acquisition_timeout=acquisition_timeout, database=database, imp_user=imp_user, bookmarks=bookmarks ) if new_routing_table is not None: new_database = new_routing_table.database old_routing_table = self.get_or_create_routing_table( new_database ) old_routing_table.update(new_routing_table) log.debug( "[#0000] _: update routing table from " "address=%r (%r)", address, self.routing_tables[new_database] ) if callable(database_callback): database_callback(new_database) return True self.deactivate(router) return False def update_routing_table( self, *, database, imp_user, bookmarks, acquisition_timeout=None, database_callback=None ): """ Update the routing table from the first router able to provide valid routing information. :param database: The database name :param imp_user: the user to impersonate while fetching the routing table :type imp_user: str or None :param bookmarks: bookmarks used when fetching routing table :param acquisition_timeout: connection acquisition timeout :param database_callback: A callback function that will be called with the database name as only argument when a new routing table has been acquired. This database name might different from `database` if that was None and the underlying protocol supports reporting back the actual database. :raise neo4j.exceptions.ServiceUnavailable: """ with self.refresh_lock: routing_table = self.get_or_create_routing_table(database) # copied because it can be modified existing_routers = set(routing_table.routers) prefer_initial_routing_address = \ self.routing_tables[database].initialized_without_writers if prefer_initial_routing_address: # TODO: Test this state if self._update_routing_table_from( self.address, database=database, imp_user=imp_user, bookmarks=bookmarks, acquisition_timeout=acquisition_timeout, database_callback=database_callback ): # Why is only the first initial routing address used? return if self._update_routing_table_from( *(existing_routers - {self.address}), database=database, imp_user=imp_user, bookmarks=bookmarks, acquisition_timeout=acquisition_timeout, database_callback=database_callback ): return if not prefer_initial_routing_address: if self._update_routing_table_from( self.address, database=database, imp_user=imp_user, bookmarks=bookmarks, acquisition_timeout=acquisition_timeout, database_callback=database_callback ): # Why is only the first initial routing address used? return # None of the routers have been successful, so just fail log.error("Unable to retrieve routing information") raise ServiceUnavailable("Unable to retrieve routing information") def update_connection_pool(self, *, database): routing_table = self.get_or_create_routing_table(database) servers = routing_table.servers() for address in list(self.connections): if address.unresolved not in servers: super(Neo4jPool, self).deactivate(address) def ensure_routing_table_is_fresh( self, *, access_mode, database, imp_user, bookmarks, acquisition_timeout=None, database_callback=None ): """ Update the routing table if stale. This method performs two freshness checks, before and after acquiring the refresh lock. If the routing table is already fresh on entry, the method exits immediately; otherwise, the refresh lock is acquired and the second freshness check that follows determines whether an update is still required. This method is thread-safe. :return: `True` if an update was required, `False` otherwise. """ from neo4j.api import READ_ACCESS with self.refresh_lock: for database_ in list(self.routing_tables.keys()): # Remove unused databases in the routing table # Remove the routing table after a timeout = TTL + 30s log.debug("[#0000] _: routing aged?, database=%s", database) routing_table = self.routing_tables[database_] if routing_table.should_be_purged_from_memory(): log.debug("[#0000] _: dropping routing table for " "database=%s", database) del self.routing_tables[database_] routing_table = self.get_or_create_routing_table(database) if routing_table.is_fresh(readonly=(access_mode == READ_ACCESS)): # table is still valid log.debug("[#0000] _: using existing routing table %r", routing_table) return False self.update_routing_table( database=database, imp_user=imp_user, bookmarks=bookmarks, acquisition_timeout=acquisition_timeout, database_callback=database_callback ) self.update_connection_pool(database=database) return True def _select_address(self, *, access_mode, database): from ...api import READ_ACCESS """ Selects the address with the fewest in-use connections. """ with self.refresh_lock: routing_table = self.routing_tables.get(database) if routing_table: if access_mode == READ_ACCESS: addresses = routing_table.readers else: addresses = routing_table.writers else: addresses = () addresses_by_usage = {} for address in addresses: addresses_by_usage.setdefault( self.in_use_connection_count(address), [] ).append(address) if not addresses_by_usage: if access_mode == READ_ACCESS: raise ReadServiceUnavailable( "No read service currently available" ) else: raise WriteServiceUnavailable( "No write service currently available" ) return choice(addresses_by_usage[min(addresses_by_usage)]) def acquire( self, access_mode, timeout, database, bookmarks, liveness_check_timeout ): if access_mode not in (WRITE_ACCESS, READ_ACCESS): raise ClientError("Non valid 'access_mode'; {}".format(access_mode)) if not timeout: raise ClientError("'timeout' must be a float larger than 0; {}" .format(timeout)) from neo4j.api import check_access_mode access_mode = check_access_mode(access_mode) # await self.ensure_routing_table_is_fresh( # access_mode=access_mode, database=database, imp_user=None, # bookmarks=bookmarks, acquisition_timeout=timeout # ) log.debug("[#0000] _: acquire routing connection, " "access_mode=%r, database=%r", access_mode, database) self.ensure_routing_table_is_fresh( access_mode=access_mode, database=database, imp_user=None, bookmarks=bookmarks, acquisition_timeout=timeout ) while True: try: # Get an address for a connection that have the fewest in-use # connections. address = self._select_address( access_mode=access_mode, database=database ) except (ReadServiceUnavailable, WriteServiceUnavailable) as err: raise SessionExpired("Failed to obtain connection towards '%s' server." % access_mode) from err try: log.debug("[#0000] _: acquire address, database=%r " "address=%r", database, address) deadline = Deadline.from_timeout_or_deadline(timeout) # should always be a resolved address connection = self._acquire( address, deadline, liveness_check_timeout ) except (ServiceUnavailable, SessionExpired): self.deactivate(address=address) else: return connection def deactivate(self, address): """ Deactivate an address from the connection pool, if present, remove from the routing table and also closing all idle connections to that address. """ log.debug("[#0000] _: deactivating address %r", address) # We use `discard` instead of `remove` here since the former # will not fail if the address has already been removed. for database in self.routing_tables.keys(): self.routing_tables[database].routers.discard(address) self.routing_tables[database].readers.discard(address) self.routing_tables[database].writers.discard(address) log.debug("[#0000] _: table=%r", self.routing_tables) super(Neo4jPool, self).deactivate(address) def on_write_failure(self, address): """ Remove a writer address from the routing table, if present. """ log.debug("[#0000] _: removing writer %r", address) for database in self.routing_tables.keys(): self.routing_tables[database].writers.discard(address) log.debug("[#0000] _: table=%r", self.routing_tables) neo4j-python-driver-5.2.1/neo4j/_sync/work/000077500000000000000000000000001433522662700204745ustar00rootroot00000000000000neo4j-python-driver-5.2.1/neo4j/_sync/work/__init__.py000066400000000000000000000016411433522662700226070ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 .session import ( Result, Session, Workspace, ) from .transaction import ( ManagedTransaction, Transaction, TransactionBase, ) __all__ = [ "Result", "Session", "ManagedTransaction", "Transaction", "TransactionBase", "Workspace", ] neo4j-python-driver-5.2.1/neo4j/_sync/work/result.py000066400000000000000000000615731433522662700224000ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations import typing as t from collections import deque from warnings import warn if t.TYPE_CHECKING: import typing_extensions as te from ..._async_compat.util import Util from ..._codec.hydration import BrokenHydrationObject from ..._data import ( Record, RecordTableRowExporter, ) from ..._meta import experimental from ...exceptions import ( ResultConsumedError, ResultNotSingleError, ) from ...time import ( Date, DateTime, ) from ...work import ResultSummary from ..io import ConnectionErrorHandler if t.TYPE_CHECKING: import pandas # type: ignore[import] from ...graph import Graph _T = t.TypeVar("_T") _T_ResultKey = t.Union[int, str] _RESULT_OUT_OF_SCOPE_ERROR = ( "The result is out of scope. The associated transaction " "has been closed. Results can only be used while the " "transaction is open." ) _RESULT_CONSUMED_ERROR = ( "The result has been consumed. Fetch all needed records before calling " "Result.consume()." ) class Result: """A handler for the result of Cypher query execution. Instances of this class are typically constructed and returned by :meth:`.AyncSession.run` and :meth:`.Transaction.run`. """ def __init__(self, connection, fetch_size, on_closed, on_error): self._connection = ConnectionErrorHandler(connection, on_error) self._hydration_scope = connection.new_hydration_scope() self._on_closed = on_closed self._metadata = None self._keys = None self._record_buffer = deque() self._summary = None self._database = None self._bookmark = None self._raw_qid = -1 self._fetch_size = fetch_size # states self._discarding = False # discard the remainder of records self._attached = False # attached to a connection # there are still more response messages we wait for self._streaming = False # there ar more records available to pull from the server self._has_more = False # the result has been fully iterated or consumed self._exhausted = False # the result has been consumed self._consumed = False # the result has been closed as a result of closing the transaction self._out_of_scope = False @property def _qid(self): if self._raw_qid == self._connection.most_recent_qid: return -1 else: return self._raw_qid def _tx_ready_run(self, query, parameters): # BEGIN+RUN does not carry any extra on the RUN message. # BEGIN {extra} # RUN "query" {parameters} {extra} self._run(query, parameters, None, None, None, None) def _run( self, query, parameters, db, imp_user, access_mode, bookmarks ): query_text = str(query) # Query or string object query_metadata = getattr(query, "metadata", None) query_timeout = getattr(query, "timeout", None) self._metadata = { "query": query_text, "parameters": parameters, "server": self._connection.server_info, "database": db, } self._database = db def on_attached(metadata): self._metadata.update(metadata) # For auto-commit there is no qid and Bolt 3 does not support qid self._raw_qid = metadata.get("qid", -1) if self._raw_qid != -1: self._connection.most_recent_qid = self._raw_qid self._keys = metadata.get("fields") self._attached = True def on_failed_attach(metadata): self._metadata.update(metadata) self._attached = False Util.callback(self._on_closed) self._connection.run( query_text, parameters=parameters, mode=access_mode, bookmarks=bookmarks, metadata=query_metadata, timeout=query_timeout, db=db, imp_user=imp_user, dehydration_hooks=self._hydration_scope.dehydration_hooks, on_success=on_attached, on_failure=on_failed_attach, ) self._pull() self._connection.send_all() self._attach() def _pull(self): def on_records(records): if not self._discarding: records = ( record.raw_data if isinstance(record, BrokenHydrationObject) else record for record in records ) self._record_buffer.extend(( Record(zip(self._keys, record)) for record in records )) def on_summary(): self._attached = False Util.callback(self._on_closed) def on_failure(metadata): self._attached = False Util.callback(self._on_closed) def on_success(summary_metadata): self._streaming = False has_more = summary_metadata.get("has_more") self._has_more = bool(has_more) if has_more: return self._metadata.update(summary_metadata) self._bookmark = summary_metadata.get("bookmark") self._database = summary_metadata.get("db", self._database) self._connection.pull( n=self._fetch_size, qid=self._qid, hydration_hooks=self._hydration_scope.hydration_hooks, on_records=on_records, on_success=on_success, on_failure=on_failure, on_summary=on_summary, ) self._streaming = True def _discard(self): def on_summary(): self._attached = False Util.callback(self._on_closed) def on_failure(metadata): self._metadata.update(metadata) self._attached = False Util.callback(self._on_closed) def on_success(summary_metadata): self._streaming = False has_more = summary_metadata.get("has_more") self._has_more = bool(has_more) if has_more: return self._discarding = False self._metadata.update(summary_metadata) self._bookmark = summary_metadata.get("bookmark") self._database = summary_metadata.get("db", self._database) # This was the last page received, discard the rest self._connection.discard( n=-1, qid=self._qid, on_success=on_success, on_failure=on_failure, on_summary=on_summary, ) self._streaming = True def __iter__(self) -> t.Iterator[Record]: """Iterator returning Records. :returns: Record, it is an immutable ordered collection of key-value pairs. :rtype: :class:`neo4j.Record` """ while self._record_buffer or self._attached: if self._record_buffer: yield self._record_buffer.popleft() elif self._streaming: self._connection.fetch_message() elif self._discarding: self._discard() self._connection.send_all() elif self._has_more: self._pull() self._connection.send_all() self._exhausted = True if self._out_of_scope: raise ResultConsumedError(self, _RESULT_OUT_OF_SCOPE_ERROR) if self._consumed: raise ResultConsumedError(self, _RESULT_CONSUMED_ERROR) def __next__(self) -> Record: return self.__iter__().__next__() def _attach(self): """Sets the Result object in an attached state by fetching messages from the connection to the buffer. """ if self._exhausted is False: while self._attached is False: self._connection.fetch_message() def _buffer(self, n=None): """Try to fill `self._record_buffer` with n records. Might end up with more records in the buffer if the fetch size makes it overshoot. Might ent up with fewer records in the buffer if there are not enough records available. """ if self._out_of_scope: raise ResultConsumedError(self, _RESULT_OUT_OF_SCOPE_ERROR) if self._consumed: raise ResultConsumedError(self, _RESULT_CONSUMED_ERROR) if n is not None and len(self._record_buffer) >= n: return record_buffer = deque() for record in self: record_buffer.append(record) if n is not None and len(record_buffer) >= n: break if n is None: self._record_buffer = record_buffer else: self._record_buffer.extend(record_buffer) self._exhausted = not self._record_buffer def _buffer_all(self): """Sets the Result object in an detached state by fetching all records from the connection to the buffer. """ self._buffer() def _obtain_summary(self): """Obtain the summary of this result, buffering any remaining records. :returns: The :class:`neo4j.ResultSummary` for this result """ if self._summary is None: if self._metadata: self._summary = ResultSummary( self._connection.unresolved_address, **self._metadata ) elif self._connection: self._summary = ResultSummary( self._connection.unresolved_address, server=self._connection.server_info ) return self._summary def keys(self) -> t.Tuple[str, ...]: """The keys for the records in this result. :returns: tuple of key names :rtype: tuple """ return self._keys def _exhaust(self): # Exhaust the result, ditching all remaining records. if not self._exhausted: self._discarding = True self._record_buffer.clear() for _ in self: pass def _tx_end(self): # Handle closure of the associated transaction. # # This will consume the result and mark it at out of scope. # Subsequent calls to `next` will raise a ResultConsumedError. self._exhaust() self._out_of_scope = True def consume(self) -> ResultSummary: """Consume the remainder of this result and return a :class:`neo4j.ResultSummary`. Example:: def create_node_tx(tx, name): result = tx.run( "CREATE (n:ExampleNode { name: $name }) RETURN n", name=name ) record = result.single() value = record.value() summary = result.consume() return value, summary with driver.session() as session: node_id, summary = session.execute_write( create_node_tx, "example" ) Example:: def get_two_tx(tx): result = tx.run("UNWIND [1,2,3,4] AS x RETURN x") values = [] for record in result: if len(values) >= 2: break values.append(record.values()) # or shorter: values = [record.values() # for record in result.fetch(2)] # discard the remaining records if there are any summary = result.consume() # use the summary for logging etc. return values, summary with driver.session() as session: values, summary = session.execute_read(get_two_tx) :returns: The :class:`neo4j.ResultSummary` for this result :raises ResultConsumedError: if the transaction from which this result was obtained has been closed. .. versionchanged:: 5.0 Can raise :exc:`ResultConsumedError`. """ if self._out_of_scope: raise ResultConsumedError(self, _RESULT_OUT_OF_SCOPE_ERROR) if self._consumed: return self._obtain_summary() self._exhaust() summary = self._obtain_summary() self._consumed = True return summary @t.overload def single( self, strict: te.Literal[False] = False ) -> t.Optional[Record]: ... @t.overload def single(self, strict: te.Literal[True]) -> Record: ... def single(self, strict: bool = False) -> t.Optional[Record]: """Obtain the next and only remaining record or None. Calling this method always exhausts the result. A warning is generated if more than one record is available but the first of these is still returned. :param strict: If :const:`True`, raise a :class:`neo4j.ResultNotSingleError` instead of returning None if there is more than one record or warning if there are more than 1 record. :const:`False` by default. :warns: if more than one record is available :raises ResultNotSingleError: If ``strict=True`` and not exactly one record is available. :raises ResultConsumedError: if the transaction from which this result was obtained has been closed or the Result has been explicitly consumed. :returns: the next :class:`neo4j.Record` or :const:`None` if none remain .. versionchanged:: 5.0 Added ``strict`` parameter. .. versionchanged:: 5.0 Can raise :exc:`ResultConsumedError`. """ self._buffer(2) buffer = self._record_buffer self._record_buffer = deque() self._exhaust() if not buffer: if not strict: return None raise ResultNotSingleError( self, "No records found. " "Make sure your query returns exactly one record." ) elif len(buffer) > 1: res = buffer.popleft() if not strict: warn("Expected a result with a single record, " "but found multiple.") return res else: raise ResultNotSingleError( self, "More than one record found. " "Make sure your query returns exactly one record." ) return buffer.popleft() def fetch(self, n: int) -> t.List[Record]: """Obtain up to n records from this result. :param n: the maximum number of records to fetch. :returns: list of :class:`neo4j.Record` :raises ResultConsumedError: if the transaction from which this result was obtained has been closed or the Result has been explicitly consumed. .. versionadded:: 5.0 """ self._buffer(n) return [ self._record_buffer.popleft() for _ in range(min(n, len(self._record_buffer))) ] def peek(self) -> t.Optional[Record]: """Obtain the next record from this result without consuming it. This leaves the record in the buffer for further processing. :returns: the next :class:`neo4j.Record` or :const:`None` if none remain. :raises ResultConsumedError: if the transaction from which this result was obtained has been closed or the Result has been explicitly consumed. .. versionchanged:: 5.0 Can raise :exc:`ResultConsumedError`. """ self._buffer(1) if self._record_buffer: return self._record_buffer[0] return None def graph(self) -> Graph: """Return a :class:`neo4j.graph.Graph` instance containing all the graph objects in the result. After calling this method, the result becomes detached, buffering all remaining records. :raises ResultConsumedError: if the transaction from which this result was obtained has been closed or the Result has been explicitly consumed. :returns: a result graph .. versionchanged:: 5.0 Can raise :exc:`ResultConsumedError`. """ self._buffer_all() return self._hydration_scope.get_graph() def value( self, key: _T_ResultKey = 0, default: t.Optional[object] = None ) -> t.List[t.Any]: """Helper function that return the remainder of the result as a list of values. See :class:`neo4j.Record.value` :param key: field to return for each remaining record. Obtain a single value from the record by index or key. :param default: default value, used if the index of key is unavailable :raises ResultConsumedError: if the transaction from which this result was obtained has been closed or the Result has been explicitly consumed. :returns: list of individual values .. versionchanged:: 5.0 Can raise :exc:`ResultConsumedError`. """ return [record.value(key, default) for record in self] def values( self, *keys: _T_ResultKey ) -> t.List[t.List[t.Any]]: """Helper function that return the remainder of the result as a list of values lists. See :class:`neo4j.Record.values` :param keys: fields to return for each remaining record. Optionally filtering to include only certain values by index or key. :raises ResultConsumedError: if the transaction from which this result was obtained has been closed or the Result has been explicitly consumed. :returns: list of values lists .. versionchanged:: 5.0 Can raise :exc:`ResultConsumedError`. """ return [record.values(*keys) for record in self] def data(self, *keys: _T_ResultKey) -> t.List[t.Any]: """Helper function that return the remainder of the result as a list of dictionaries. See :class:`neo4j.Record.data` :param keys: fields to return for each remaining record. Optionally filtering to include only certain values by index or key. :returns: list of dictionaries :rtype: list :raises ResultConsumedError: if the transaction from which this result was obtained has been closed or the Result has been explicitly consumed. .. versionchanged:: 5.0 Can raise :exc:`ResultConsumedError`. """ return [record.data(*keys) for record in self] def to_df( self, expand: bool = False, parse_dates: bool = False ) -> pandas.DataFrame: r"""Convert (the rest of) the result to a pandas DataFrame. This method is only available if the `pandas` library is installed. :: res = tx.run("UNWIND range(1, 10) AS n RETURN n, n+1 as m") df = res.to_df() for instance will return a DataFrame with two columns: ``n`` and ``m`` and 10 rows. :param expand: If :const:`True`, some structures in the result will be recursively expanded (flattened out into multiple columns) like so (everything inside ``<...>`` is a placeholder): * :class:`.Node` objects under any variable ```` will be expanded into columns (the recursion stops here) * ``().prop.`` (any) for each property of the node. * ``().element_id`` (str) the node's element id. See :attr:`.Node.element_id`. * ``().labels`` (frozenset of str) the node's labels. See :attr:`.Node.labels`. * :class:`.Relationship` objects under any variable ```` will be expanded into columns (the recursion stops here) * ``->.prop.`` (any) for each property of the relationship. * ``->.element_id`` (str) the relationship's element id. See :attr:`.Relationship.element_id`. * ``->.start.element_id`` (str) the relationship's start node's element id. See :attr:`.Relationship.start_node`. * ``->.end.element_id`` (str) the relationship's end node's element id. See :attr:`.Relationship.end_node`. * ``->.type`` (str) the relationship's type. See :attr:`.Relationship.type`. * :const:`list` objects under any variable ```` will be expanded into * ``[].0`` (any) the 1st list element * ``[].1`` (any) the 2nd list element * ... * :const:`dict` objects under any variable ```` will be expanded into * ``{}.`` (any) the 1st key of the dict * ``{}.`` (any) the 2nd key of the dict * ... * :const:`list` and :const:`dict` objects are expanded recursively. Example:: variable x: [{"foo": "bar", "baz": [42, 0]}, "foobar"] will be expanded to:: { "x[].0{}.foo": "bar", "x[].0{}.baz[].0": 42, "n[].0{}.baz[].1": 0, "n[].1": "foobar" } * Everything else (including :class:`.Path` objects) will not be flattened. :const:`dict` keys and variable names that contain ``.`` or ``\`` will be escaped with a backslash (``\.`` and ``\\`` respectively). :param parse_dates: If :const:`True`, columns that exclusively contain :class:`time.DateTime` objects, :class:`time.Date` objects, or :const:`None`, will be converted to :class:`pandas.Timestamp`. :raises ImportError: if `pandas` library is not available. :raises ResultConsumedError: if the transaction from which this result was obtained has been closed or the Result has been explicitly consumed. """ import pandas as pd # type: ignore[import] if not expand: df = pd.DataFrame(self.values(), columns=self._keys) else: df_keys = None rows = [] for record in self: row = RecordTableRowExporter().transform(dict(record.items())) if df_keys == row.keys(): rows.append(row.values()) elif df_keys is None: df_keys = row.keys() rows.append(row.values()) elif df_keys is False: rows.append(row) else: # The rows have different keys. We need to pass a list # of dicts to pandas rows = [{k: v for k, v in zip(df_keys, r)} for r in rows] df_keys = False rows.append(row) if df_keys is False: df = pd.DataFrame(rows) else: columns = df_keys or [ k.replace(".", "\\.").replace("\\", "\\\\") for k in self._keys ] df = pd.DataFrame(rows, columns=columns) if not parse_dates: return df dt_columns = df.columns[df.apply( lambda col: pd.api.types.infer_dtype(col) == "mixed" and col.map( lambda x: isinstance(x, (DateTime, Date, type(None))) ).all() )] df[dt_columns] = df[dt_columns].apply( lambda col: col.map( lambda x: pd.Timestamp(x.iso_format()) .replace(tzinfo=getattr(x, "tzinfo", None)) if x else pd.NaT ) ) return df def closed(self) -> bool: """Return True if the result has been closed. When a result gets consumed :meth:`consume` or the transaction that owns the result gets closed (committed, rolled back, closed), the result cannot be used to acquire further records. In such case, all methods that need to access the Result's records, will raise a :exc:`ResultConsumedError` when called. :returns: whether the result is closed. .. versionadded:: 5.0 """ return self._out_of_scope or self._consumed neo4j-python-driver-5.2.1/neo4j/_sync/work/session.py000066400000000000000000000675201433522662700225430ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations import asyncio import typing as t from logging import getLogger from random import random from time import perf_counter if t.TYPE_CHECKING: import typing_extensions as te from ..io import Bolt _R = t.TypeVar("_R") _P = te.ParamSpec("_P") from ..._async_compat import sleep from ..._async_compat.util import Util from ..._conf import SessionConfig from ..._meta import deprecated from ...api import ( Bookmarks, READ_ACCESS, WRITE_ACCESS, ) from ...exceptions import ( ClientError, DriverError, Neo4jError, ServiceUnavailable, SessionExpired, TransactionError, ) from ...work import Query from .result import Result from .transaction import ( ManagedTransaction, Transaction, ) from .workspace import Workspace log = getLogger("neo4j") class Session(Workspace): """A :class:`.Session` is a logical context for transactional units of work. Connections are drawn from the :class:`.Driver` connection pool as required. Session creation is a lightweight operation and sessions are not safe to be used in concurrent contexts (multiple threads/coroutines). Therefore, a session should generally be short-lived, and must not span multiple threads/asynchronous Tasks. In general, sessions will be created and destroyed within a `with` context. For example:: with driver.session() as session: result = session.run("MATCH (n:Person) RETURN n.name AS name") # do something with the result... :param pool: connection pool instance :param config: session config instance """ # The current connection. _connection: t.Optional[Bolt] = None # The current transaction instance, if any. _transaction: t.Union[Transaction, ManagedTransaction, None] = \ None # The current auto-transaction result, if any. _auto_result = None # The state this session is in. _state_failed = False def __init__(self, pool, session_config): assert isinstance(session_config, SessionConfig) super().__init__(pool, session_config) self._initialize_bookmarks(session_config.bookmarks) self._bookmark_manager = session_config.bookmark_manager def __enter__(self) -> Session: return self def __exit__(self, exception_type, exception_value, traceback): if exception_type: if issubclass(exception_type, asyncio.CancelledError): self._handle_cancellation(message="__exit__") self._closed = True return self._state_failed = True self.close() def _connect(self, access_mode, **access_kwargs): if access_mode is None: access_mode = self._config.default_access_mode try: super()._connect(access_mode, **access_kwargs) except asyncio.CancelledError: self._handle_cancellation(message="_connect") raise def _disconnect(self, sync=False): try: return super()._disconnect(sync=sync) except asyncio.CancelledError: self._handle_cancellation(message="_disconnect") raise def _handle_cancellation(self, message="General"): self._transaction = None self._auto_result = None connection = self._connection self._connection = None if connection: log.debug("[#%04X] _: %s cancellation clean-up", connection.local_port, message) self._pool.kill_and_release(connection) else: log.debug("[#0000] _: %s cancellation clean-up", message) def _result_closed(self): if self._auto_result: self._update_bookmark(self._auto_result._database, self._auto_result._bookmark) self._auto_result = None self._disconnect() def _result_error(self, error): if isinstance(error, asyncio.CancelledError): return self._handle_cancellation(message="_result_error") if self._auto_result: self._auto_result = None self._disconnect() def _get_server_info(self): assert not self._connection self._connect(READ_ACCESS, liveness_check_timeout=0) server_info = self._connection.server_info self._disconnect() return server_info def close(self) -> None: """Close the session. This will release any borrowed resources, such as connections, and will roll back any outstanding transactions. """ if self._closed: return if self._connection: if self._auto_result: if self._state_failed is False: try: self._auto_result.consume() self._update_bookmark( self._auto_result._database, self._auto_result._bookmark ) except Exception as error: # TODO: Investigate potential non graceful close states self._auto_result = None self._state_failed = True if self._transaction: if self._transaction._closed() is False: # roll back the transaction if it is not closed self._transaction._rollback() self._transaction = None try: if self._connection: self._connection.send_all() self._connection.fetch_all() # TODO: Investigate potential non graceful close states except Neo4jError: pass except TransactionError: pass except ServiceUnavailable: pass except SessionExpired: pass finally: self._disconnect() self._state_failed = False self._closed = True if Util.is_async_code: def cancel(self) -> None: """Cancel this session. If the session is already closed, this method does nothing. Else, it will if present, forcefully close the connection the session holds. This will violently kill all work in flight. The primary purpose of this function is to handle :class:`asyncio.CancelledError`. :: session = driver.session() try: ... # do some work except asyncio.CancelledError: session.cancel() raise """ self._handle_cancellation(message="manual cancel") def run( self, query: t.Union[str, Query], parameters: t.Optional[t.Dict[str, t.Any]] = None, **kwargs: t.Any ) -> Result: """Run a Cypher query within an auto-commit transaction. The query is sent and the result header received immediately but the :class:`neo4j.Result` content is fetched lazily as consumed by the client application. If a query is executed before a previous :class:`neo4j.Result` in the same :class:`.Session` has been fully consumed, the first result will be fully fetched and buffered. Note therefore that the generally recommended pattern of usage is to fully consume one result before executing a subsequent query. If two results need to be consumed in parallel, multiple :class:`.Session` objects can be used as an alternative to result buffering. For more usage details, see :meth:`.Transaction.run`. :param query: cypher query :param parameters: dictionary of parameters :param kwargs: additional keyword parameters. These take precedence over parameters passed as ``parameters``. :raises SessionError: if the session has been closed. :returns: a new :class:`neo4j.Result` object """ self._check_state() if not query: raise ValueError("Cannot run an empty query") if not isinstance(query, (str, Query)): raise TypeError("query must be a string or a Query instance") if self._transaction: raise ClientError("Explicit Transaction must be handled explicitly") if self._auto_result: # This will buffer upp all records for the previous auto-transaction self._auto_result._buffer_all() if not self._connection: self._connect(self._config.default_access_mode) cx = self._connection self._auto_result = Result( cx, self._config.fetch_size, self._result_closed, self._result_error ) bookmarks = self._get_all_bookmarks() parameters = dict(parameters or {}, **kwargs) self._auto_result._run( query, parameters, self._config.database, self._config.impersonated_user, self._config.default_access_mode, bookmarks ) return self._auto_result @deprecated( "`last_bookmark` has been deprecated in favor of `last_bookmarks`. " "This method can lead to unexpected behaviour." ) def last_bookmark(self) -> t.Optional[str]: """Return the bookmark received following the last completed transaction. Note: For auto-transactions (:meth:`Session.run`), this will trigger :meth:`Result.consume` for the current result. .. warning:: This method can lead to unexpected behaviour if the session has not yet successfully completed a transaction. .. deprecated:: 5.0 :meth:`last_bookmark` will be removed in version 6.0. Use :meth:`last_bookmarks` instead. :returns: last bookmark """ # The set of bookmarks to be passed into the next transaction. if self._auto_result: self._auto_result.consume() if self._transaction and self._transaction._closed(): self._update_bookmark(self._transaction._database, self._transaction._bookmark) self._transaction = None if self._bookmarks: return self._bookmarks[-1] return None def last_bookmarks(self) -> Bookmarks: """Return most recent bookmarks of the session. Bookmarks can be used to causally chain sessions. For example, if a session (``session1``) wrote something, that another session (``session2``) needs to read, use ``session2 = driver.session(bookmarks=session1.last_bookmarks())`` to achieve this. Combine the bookmarks of multiple sessions like so:: bookmarks1 = session1.last_bookmarks() bookmarks2 = session2.last_bookmarks() session3 = driver.session(bookmarks=bookmarks1 + bookmarks2) A session automatically manages bookmarks, so this method is rarely needed. If you need causal consistency, try to run the relevant queries in the same session. "Most recent bookmarks" are either the bookmarks passed to the session or creation, or the last bookmark the session received after committing a transaction to the server. Note: For auto-transactions (:meth:`Session.run`), this will trigger :meth:`Result.consume` for the current result. :returns: the session's last known bookmarks """ # The set of bookmarks to be passed into the next transaction. if self._auto_result: self._auto_result.consume() if self._transaction and self._transaction._closed(): self._update_bookmark(self._transaction._database, self._transaction._bookmark) self._transaction = None return Bookmarks.from_raw_values(self._bookmarks) def _transaction_closed_handler(self): if self._transaction: self._update_bookmark(self._transaction._database, self._transaction._bookmark) self._transaction = None self._disconnect() def _transaction_error_handler(self, error): if self._transaction: self._transaction = None self._disconnect() def _transaction_cancel_handler(self): return self._handle_cancellation( message="_transaction_cancel_handler" ) def _open_transaction( self, *, tx_cls, access_mode, metadata=None, timeout=None ): self._connect(access_mode=access_mode) self._transaction = tx_cls( self._connection, self._config.fetch_size, self._transaction_closed_handler, self._transaction_error_handler, self._transaction_cancel_handler ) bookmarks = self._get_all_bookmarks() self._transaction._begin( self._config.database, self._config.impersonated_user, bookmarks, access_mode, metadata, timeout ) def begin_transaction( self, metadata: t.Optional[t.Dict[str, t.Any]] = None, timeout: t.Optional[float] = None ) -> Transaction: """ Begin a new unmanaged transaction. Creates a new :class:`.Transaction` within this session. At most one transaction may exist in a session at any point in time. To maintain multiple concurrent transactions, use multiple concurrent sessions. Note: For auto-transaction (Session.run) this will trigger a consume for the current result. :param metadata: a dictionary with metadata. Specified metadata will be attached to the executing transaction and visible in the output of ``SHOW TRANSACTIONS YIELD *`` It will also get logged to the ``query.log``. This functionality makes it easier to tag transactions and is equivalent to the ``dbms.setTXMetaData`` procedure, see https://neo4j.com/docs/cypher-manual/current/clauses/transaction-clauses/#query-listing-transactions and https://neo4j.com/docs/operations-manual/current/reference/procedures/ for reference. :param timeout: the transaction timeout in seconds. Transactions that execute longer than the configured timeout will be terminated by the database. This functionality allows to limit query/transaction execution time. Specified timeout overrides the default timeout configured in the database using ``dbms.transaction.timeout`` setting. Value should not represent a duration of zero or negative duration. :raises TransactionError: if a transaction is already open. :raises SessionError: if the session has been closed. :returns: A new transaction instance. """ self._check_state() # TODO: Implement TransactionConfig consumption if self._auto_result: self._auto_result.consume() if self._transaction: raise TransactionError( self._transaction, "Explicit transaction already open" ) self._open_transaction( tx_cls=Transaction, access_mode=self._config.default_access_mode, metadata=metadata, timeout=timeout ) return t.cast(Transaction, self._transaction) def _run_transaction( self, access_mode, transaction_function, *args, **kwargs ): self._check_state() if not callable(transaction_function): raise TypeError("Unit of work is not callable") metadata = getattr(transaction_function, "metadata", None) timeout = getattr(transaction_function, "timeout", None) retry_delay = retry_delay_generator( self._config.initial_retry_delay, self._config.retry_delay_multiplier, self._config.retry_delay_jitter_factor ) errors = [] t0 = -1 # Timer while True: try: self._open_transaction( tx_cls=ManagedTransaction, access_mode=access_mode, metadata=metadata, timeout=timeout ) tx = self._transaction try: result = transaction_function(tx, *args, **kwargs) except asyncio.CancelledError: # if cancellation callback has not been called yet: if self._transaction is not None: self._handle_cancellation( message="transaction function" ) raise except Exception: tx._close() raise else: tx._commit() except (DriverError, Neo4jError) as error: self._disconnect() if not error.is_retryable(): raise errors.append(error) else: return result if t0 == -1: # The timer should be started after the first attempt t0 = perf_counter() t1 = perf_counter() if t1 - t0 > self._config.max_transaction_retry_time: break delay = next(retry_delay) log.warning("Transaction failed and will be retried in {}s ({})" "".format(delay, "; ".join(errors[-1].args))) try: sleep(delay) except asyncio.CancelledError: log.debug("[#0000] _: retry cancelled") raise if errors: raise errors[-1] else: raise ServiceUnavailable("Transaction failed") def execute_read( self, transaction_function: t.Callable[ te.Concatenate[ManagedTransaction, _P], t.Union[_R] ], *args: _P.args, **kwargs: _P.kwargs ) -> _R: """Execute a unit of work in a managed read transaction. .. note:: This does not necessarily imply access control, see the session configuration option :ref:`default-access-mode-ref`. This transaction will automatically be committed when the function returns, unless an exception is thrown during query execution or by the user code. Note, that this function performs retries and that the supplied `transaction_function` might get invoked more than once. Therefore, it needs to be idempotent (i.e., have the same effect, regardless if called once or many times). Example:: def do_cypher_tx(tx, cypher): result = tx.run(cypher) values = [record.values() for record in result] return values with driver.session() as session: values = session.execute_read(do_cypher_tx, "RETURN 1 AS x") Example:: def get_two_tx(tx): result = tx.run("UNWIND [1,2,3,4] AS x RETURN x") values = [] for record in result: if len(values) >= 2: break values.append(record.values()) # or shorter: values = [record.values() # for record in result.fetch(2)] # discard the remaining records if there are any summary = result.consume() # use the summary for logging etc. return values with driver.session() as session: values = session.execute_read(get_two_tx) :param transaction_function: a function that takes a transaction as an argument and does work with the transaction. `transaction_function(tx, *args, **kwargs)` where `tx` is a :class:`.ManagedTransaction`. :param args: additional arguments for the `transaction_function` :param kwargs: key word arguments for the `transaction_function` :raises SessionError: if the session has been closed. :return: a result as returned by the given unit of work .. versionadded:: 5.0 """ return self._run_transaction( READ_ACCESS, transaction_function, *args, **kwargs ) # TODO 6.0: Remove this method @deprecated("read_transaction has been renamed to execute_read") def read_transaction( self, transaction_function: t.Callable[ te.Concatenate[ManagedTransaction, _P], t.Union[_R] ], *args: _P.args, **kwargs: _P.kwargs ) -> _R: """Execute a unit of work in a managed read transaction. .. note:: This does not necessarily imply access control, see the session configuration option :ref:`default-access-mode-ref`. This transaction will automatically be committed when the function returns, unless an exception is thrown during query execution or by the user code. Note, that this function performs retries and that the supplied `transaction_function` might get invoked more than once. Therefore, it needs to be idempotent (i.e., have the same effect, regardless if called once or many times). Example:: def do_cypher_tx(tx, cypher): result = tx.run(cypher) values = [record.values() for record in result] return values with driver.session() as session: values = session.read_transaction(do_cypher_tx, "RETURN 1 AS x") Example:: def get_two_tx(tx): result = tx.run("UNWIND [1,2,3,4] AS x RETURN x") values = [] for record in result: if len(values) >= 2: break values.append(record.values()) # or shorter: values = [record.values() # for record in result.fetch(2)] # discard the remaining records if there are any summary = result.consume() # use the summary for logging etc. return values with driver.session() as session: values = session.read_transaction(get_two_tx) :param transaction_function: a function that takes a transaction as an argument and does work with the transaction. `transaction_function(tx, *args, **kwargs)` where `tx` is a :class:`.ManagedTransaction`. :param args: additional arguments for the `transaction_function` :param kwargs: key word arguments for the `transaction_function` :raises SessionError: if the session has been closed. :return: a result as returned by the given unit of work .. deprecated:: 5.0 Method was renamed to :meth:`.execute_read`. """ return self._run_transaction( READ_ACCESS, transaction_function, *args, **kwargs ) def execute_write( self, transaction_function: t.Callable[ te.Concatenate[ManagedTransaction, _P], t.Union[_R] ], *args: _P.args, **kwargs: _P.kwargs ) -> _R: """Execute a unit of work in a managed write transaction. .. note:: This does not necessarily imply access control, see the session configuration option :ref:`default-access-mode-ref`. This transaction will automatically be committed when the function returns unless, an exception is thrown during query execution or by the user code. Note, that this function performs retries and that the supplied `transaction_function` might get invoked more than once. Therefore, it needs to be idempotent (i.e., have the same effect, regardless if called once or many times). Example:: def create_node_tx(tx, name): query = "CREATE (n:NodeExample { name: $name }) RETURN id(n) AS node_id" result = tx.run(query, name=name) record = result.single() return record["node_id"] with driver.session() as session: node_id = session.execute_write(create_node_tx, "example") :param transaction_function: a function that takes a transaction as an argument and does work with the transaction. `transaction_function(tx, *args, **kwargs)` where `tx` is a :class:`.ManagedTransaction`. :param args: additional arguments for the `transaction_function` :param kwargs: key word arguments for the `transaction_function` :raises SessionError: if the session has been closed. :return: a result as returned by the given unit of work .. versionadded:: 5.0 """ return self._run_transaction( WRITE_ACCESS, transaction_function, *args, **kwargs ) # TODO 6.0: Remove this method @deprecated("write_transaction has been renamed to execute_write") def write_transaction( self, transaction_function: t.Callable[ te.Concatenate[ManagedTransaction, _P], t.Union[_R] ], *args: _P.args, **kwargs: _P.kwargs ) -> _R: """Execute a unit of work in a managed write transaction. .. note:: This does not necessarily imply access control, see the session configuration option :ref:`default-access-mode-ref`. This transaction will automatically be committed when the function returns unless, an exception is thrown during query execution or by the user code. Note, that this function performs retries and that the supplied `transaction_function` might get invoked more than once. Therefore, it needs to be idempotent (i.e., have the same effect, regardless if called once or many times). Example:: def create_node_tx(tx, name): query = "CREATE (n:NodeExample { name: $name }) RETURN id(n) AS node_id" result = tx.run(query, name=name) record = result.single() return record["node_id"] with driver.session() as session: node_id = session.write_transaction(create_node_tx, "example") :param transaction_function: a function that takes a transaction as an argument and does work with the transaction. `transaction_function(tx, *args, **kwargs)` where `tx` is a :class:`.ManagedTransaction`. :param args: additional arguments for the `transaction_function` :param kwargs: key word arguments for the `transaction_function` :raises SessionError: if the session has been closed. :return: a result as returned by the given unit of work .. deprecated:: 5.0 Method was renamed to :meth:`.execute_write`. """ return self._run_transaction( WRITE_ACCESS, transaction_function, *args, **kwargs ) def retry_delay_generator(initial_delay, multiplier, jitter_factor): delay = initial_delay while True: jitter = jitter_factor * delay yield delay - jitter + (2 * jitter * random()) delay *= multiplier neo4j-python-driver-5.2.1/neo4j/_sync/work/transaction.py000066400000000000000000000245451433522662700234050ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations import asyncio import typing as t from functools import wraps from ..._async_compat.util import Util from ...exceptions import TransactionError from ...work import Query from ..io import ConnectionErrorHandler from .result import Result __all__ = ( "ManagedTransaction", "Transaction", "TransactionBase", ) class TransactionBase: def __init__(self, connection, fetch_size, on_closed, on_error, on_cancel): self._connection = connection self._error_handling_connection = ConnectionErrorHandler( connection, self._error_handler ) self._bookmark = None self._database = None self._results = [] self._closed_flag = False self._last_error = None self._fetch_size = fetch_size self._on_closed = on_closed self._on_error = on_error self._on_cancel = on_cancel def _enter(self): return self def _exit(self, exception_type, exception_value, traceback): if self._closed_flag: return success = not bool(exception_type) if success: self._commit() elif issubclass(exception_type, asyncio.CancelledError): self._cancel() return self._close() def _begin( self, database, imp_user, bookmarks, access_mode, metadata, timeout ): self._database = database self._connection.begin( bookmarks=bookmarks, metadata=metadata, timeout=timeout, mode=access_mode, db=database, imp_user=imp_user ) self._error_handling_connection.send_all() self._error_handling_connection.fetch_all() def _result_on_closed_handler(self): pass def _error_handler(self, exc): self._last_error = exc if isinstance(exc, asyncio.CancelledError): self._cancel() return Util.callback(self._on_error, exc) def _consume_results(self): for result in self._results: result._tx_end() self._results = [] def run( self, query: str, parameters: t.Optional[t.Dict[str, t.Any]] = None, **kwparameters: t.Any ) -> Result: """ Run a Cypher query within the context of this transaction. Cypher is typically expressed as a query template plus a set of named parameters. In Python, parameters may be expressed through a dictionary of parameters, through individual parameter arguments, or as a mixture of both. For example, the `run` queries below are all equivalent:: >>> query = "CREATE (a:Person { name: $name, age: $age })" >>> result = tx.run(query, {"name": "Alice", "age": 33}) >>> result = tx.run(query, {"name": "Alice"}, age=33) >>> result = tx.run(query, name="Alice", age=33) Parameter values can be of any type supported by the Neo4j type system. In Python, this includes :class:`bool`, :class:`int`, :class:`str`, :class:`list` and :class:`dict`. Note however that :class:`list` properties must be homogenous. :param query: cypher query :param parameters: dictionary of parameters :param kwparameters: additional keyword parameters. These take precedence over parameters passed as ``parameters``. :raise TransactionError: if the transaction is already closed :returns: a new :class:`neo4j.Result` object """ if isinstance(query, Query): raise ValueError("Query object is only supported for session.run") if self._closed_flag: raise TransactionError(self, "Transaction closed") if self._last_error: raise TransactionError(self, "Transaction failed") from self._last_error if (self._results and self._connection.supports_multiple_results is False): # Bolt 3 Support # Buffer up all records for the previous Result because it does not # have any qid to fetch in batches. self._results[-1]._buffer_all() result = Result( self._connection, self._fetch_size, self._result_on_closed_handler, self._error_handler ) self._results.append(result) parameters = dict(parameters or {}, **kwparameters) result._tx_ready_run(query, parameters) return result def _commit(self): """Mark this transaction as successful and close in order to trigger a COMMIT. :raise TransactionError: if the transaction is already closed """ if self._closed_flag: raise TransactionError(self, "Transaction closed") if self._last_error: raise TransactionError(self, "Transaction failed") from self._last_error metadata = {} try: # DISCARD pending records then do a commit. self._consume_results() self._connection.commit(on_success=metadata.update) self._connection.send_all() self._connection.fetch_all() self._bookmark = metadata.get("bookmark") self._database = metadata.get("db", self._database) except asyncio.CancelledError: self._on_cancel() raise finally: self._closed_flag = True Util.callback(self._on_closed) return self._bookmark def _rollback(self): """Mark this transaction as unsuccessful and close in order to trigger a ROLLBACK. :raise TransactionError: if the transaction is already closed """ if self._closed_flag: raise TransactionError(self, "Transaction closed") metadata = {} try: if not (self._connection.defunct() or self._connection.closed() or self._connection.is_reset): # DISCARD pending records then do a rollback. self._consume_results() self._connection.rollback(on_success=metadata.update) self._connection.send_all() self._connection.fetch_all() except asyncio.CancelledError: self._on_cancel() raise finally: self._closed_flag = True Util.callback(self._on_closed) def _close(self): """Close this transaction, triggering a ROLLBACK if not closed. """ if self._closed_flag: return self._rollback() if Util.is_async_code: def _cancel(self) -> None: """Cancel this transaction. If the transaction is already closed, this method does nothing. Else, it will close the connection without ROLLBACK or COMMIT in a non-blocking manner. The primary purpose of this function is to handle :class:`asyncio.CancelledError`. :: tx = session.begin_transaction() try: ... # do some work except asyncio.CancelledError: tx.cancel() raise """ if self._closed_flag: return try: self._on_cancel() finally: self._closed_flag = True def _closed(self): """Indicate whether the transaction has been closed or cancelled. :return: :const:`True` if closed or cancelled, :const:`False` otherwise. :rtype: bool """ return self._closed_flag class Transaction(TransactionBase): """ Container for multiple Cypher queries to be executed within a single context. :class:`Transaction` objects can be used as a context managers (:py:const:`with` block) where the transaction is committed or rolled back on based on whether an exception is raised:: with session.begin_transaction() as tx: ... """ @wraps(TransactionBase._enter) def __enter__(self) -> Transaction: return self._enter() @wraps(TransactionBase._exit) def __exit__(self, exception_type, exception_value, traceback): self._exit(exception_type, exception_value, traceback) @wraps(TransactionBase._commit) def commit(self) -> None: return self._commit() @wraps(TransactionBase._rollback) def rollback(self) -> None: return self._rollback() @wraps(TransactionBase._close) def close(self) -> None: return self._close() @wraps(TransactionBase._closed) def closed(self) -> bool: return self._closed() if Util.is_async_code: @wraps(TransactionBase._cancel) def cancel(self) -> None: return self._cancel() class ManagedTransaction(TransactionBase): """Transaction object provided to transaction functions. Inside a transaction function, the driver is responsible for managing (committing / rolling back) the transaction. Therefore, ManagedTransactions don't offer such methods. Otherwise, they behave like :class:`.Transaction`. * To commit the transaction, return anything from the transaction function. * To rollback the transaction, raise any exception. Note that transaction functions have to be idempotent (i.e., the result of running the function once has to be the same as running it any number of times). This is, because the driver will retry the transaction function if the error is classified as retryable. .. versionadded:: 5.0 Prior, transaction functions used :class:`Transaction` objects, but would cause hard to interpret errors when managed explicitly (committed or rolled back by user code). """ pass neo4j-python-driver-5.2.1/neo4j/_sync/work/workspace.py000066400000000000000000000203401433522662700230430ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations import asyncio import logging from ..._async_compat.util import Util from ..._conf import WorkspaceConfig from ..._meta import ( deprecation_warn, unclosed_resource_warn, ) from ...api import Bookmarks from ...exceptions import ( ServiceUnavailable, SessionError, SessionExpired, ) from ..io import Neo4jPool log = logging.getLogger("neo4j") class Workspace: def __init__(self, pool, config): assert isinstance(config, WorkspaceConfig) self._pool = pool self._config = config self._connection = None self._connection_access_mode = None # Sessions are supposed to cache the database on which to operate. self._cached_database = False self._bookmarks = () self._initial_bookmarks = () self._bookmark_manager = None self._last_from_bookmark_manager = None # Workspace has been closed. self._closed = False def __del__(self): if self._closed: return unclosed_resource_warn(self) # TODO: 6.0 - remove this if asyncio.iscoroutinefunction(self.close): return try: deprecation_warn( "Relying on Session's destructor to close the session " "is deprecated. Please make sure to close the session. Use it " "as a context (`with` statement) or make sure to call " "`.close()` explicitly. Future versions of the driver will " "not close sessions automatically." ) self.close() except (OSError, ServiceUnavailable, SessionExpired): pass def __enter__(self) -> Workspace: return self def __exit__(self, exc_type, exc_value, traceback): self.close() def _set_cached_database(self, database): self._cached_database = True self._config.database = database def _initialize_bookmarks(self, bookmarks): if isinstance(bookmarks, Bookmarks): prepared_bookmarks = tuple(bookmarks.raw_values) elif hasattr(bookmarks, "__iter__"): deprecation_warn( "Passing an iterable as `bookmarks` to `Session` is " "deprecated. Please use a `Bookmarks` instance.", stack_level=5 ) prepared_bookmarks = tuple(bookmarks) elif not bookmarks: prepared_bookmarks = () else: raise TypeError("Bookmarks must be an instance of Bookmarks or an " "iterable of raw bookmarks (deprecated).") self._initial_bookmarks = self._bookmarks = prepared_bookmarks def _get_bookmarks(self, database): if self._bookmark_manager is None: return self._bookmarks # For 4.3- support: the server will not send the resolved home # database back. To avoid confusion between `None` as in "all # database" and `None` as in "home database" we re-write the # home database to `""`, which otherwise is an invalid database # name. It will not work properly either way, as the home database # can change (server config change or client side user change). if database is None: database = "" self._last_from_bookmark_manager = tuple({ *Util.callback( self._bookmark_manager.get_bookmarks, database ), *self._initial_bookmarks }) return self._last_from_bookmark_manager def _get_all_bookmarks(self): if self._bookmark_manager is None: return self._bookmarks self._last_from_bookmark_manager = tuple({ *Util.callback( self._bookmark_manager.get_all_bookmarks, ), *self._initial_bookmarks }) return self._last_from_bookmark_manager def _update_bookmarks(self, database, new_bookmarks): if not new_bookmarks: return self._initial_bookmarks = () self._bookmarks = new_bookmarks if self._bookmark_manager is None: return previous_bookmarks = self._last_from_bookmark_manager # For 4.3- support: the server will not send the resolved home # database back. To avoid confusion between `None` as in "all # database" and `None` as in "home database" we re-write the home # database to `""`, which otherwise is an invalid database name. if database is None: database = "" Util.callback( self._bookmark_manager.update_bookmarks, database, previous_bookmarks, new_bookmarks ) def _update_bookmark(self, database, bookmark): if not bookmark: return if not database: database = self._config.database self._update_bookmarks(database, (bookmark,)) def _connect(self, access_mode, **acquire_kwargs): acquisition_timeout = self._config.connection_acquisition_timeout if self._connection: # TODO: Investigate this # log.warning("FIXME: should always disconnect before connect") self._connection.send_all() self._connection.fetch_all() self._disconnect() if not self._cached_database: if (self._config.database is not None or not isinstance(self._pool, Neo4jPool)): self._set_cached_database(self._config.database) else: # This is the first time we open a connection to a server in a # cluster environment for this session without explicitly # configured database. Hence, we request a routing table update # to try to fetch the home database. If provided by the server, # we shall use this database explicitly for all subsequent # actions within this session. log.debug("[#0000] _: resolve home database") self._pool.update_routing_table( database=self._config.database, imp_user=self._config.impersonated_user, bookmarks=self._get_bookmarks("system"), acquisition_timeout=acquisition_timeout, database_callback=self._set_cached_database ) acquire_kwargs_ = { "access_mode": access_mode, "timeout": acquisition_timeout, "database": self._config.database, "bookmarks": self._get_bookmarks("system"), "liveness_check_timeout": None, } acquire_kwargs_.update(acquire_kwargs) self._connection = self._pool.acquire(**acquire_kwargs_) self._connection_access_mode = access_mode def _disconnect(self, sync=False): if self._connection: if sync: try: self._connection.send_all() self._connection.fetch_all() except ServiceUnavailable: pass if self._connection: self._pool.release(self._connection) self._connection = None self._connection_access_mode = None def close(self) -> None: if self._closed: return self._disconnect(sync=True) self._closed = True def closed(self) -> bool: """Indicate whether the session has been closed. :return: :const:`True` if closed, :const:`False` otherwise. """ return self._closed def _check_state(self): if self._closed: raise SessionError(self, "Session closed") neo4j-python-driver-5.2.1/neo4j/addressing.py000066400000000000000000000140471433522662700211020ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations import logging import typing as t from socket import ( AddressFamily, AF_INET, AF_INET6, getservbyname, ) if t.TYPE_CHECKING: import typing_extensions as te log = logging.getLogger("neo4j") _T = t.TypeVar("_T") if t.TYPE_CHECKING: class _WithPeerName(te.Protocol): def getpeername(self) -> tuple: ... class _AddressMeta(type(tuple)): # type: ignore[misc] def __init__(cls, *args, **kwargs): super().__init__(*args, **kwargs) cls._ipv4_cls = None cls._ipv6_cls = None def _subclass_by_family(self, family): subclasses = [ sc for sc in self.__subclasses__() if (sc.__module__ == self.__module__ and getattr(sc, "family", None) == family) ] if len(subclasses) != 1: raise ValueError( "Class {} needs exactly one direct subclass with attribute " "`family == {}` within this module. " "Found: {}".format(self, family, subclasses) ) return subclasses[0] @property def ipv4_cls(self): if self._ipv4_cls is None: self._ipv4_cls = self._subclass_by_family(AF_INET) return self._ipv4_cls @property def ipv6_cls(self): if self._ipv6_cls is None: self._ipv6_cls = self._subclass_by_family(AF_INET6) return self._ipv6_cls class Address(tuple, metaclass=_AddressMeta): @classmethod def from_socket( cls: t.Type[_T_Address], socket: _WithPeerName ) -> _T_Address: address = socket.getpeername() return cls(address) @classmethod def parse( cls: t.Type[_T_Address], s: str, default_host: t.Optional[str] = None, default_port: t.Optional[int] = None ) -> _T_Address: if not isinstance(s, str): raise TypeError("Address.parse requires a string argument") if s.startswith("["): # IPv6 port: t.Union[str, int] host, _, port = s[1:].rpartition("]") port = port.lstrip(":") try: port = int(port) except (TypeError, ValueError): pass return cls((host or default_host or "localhost", port or default_port or 0, 0, 0)) else: # IPv4 host, _, port = s.partition(":") try: port = int(port) except (TypeError, ValueError): pass return cls((host or default_host or "localhost", port or default_port or 0)) @classmethod def parse_list( cls: t.Type[_T_Address], *s: str, default_host: t.Optional[str] = None, default_port: t.Optional[int] = None ) -> t.List[_T_Address]: """ Parse a string containing one or more socket addresses, each separated by whitespace. """ if not all(isinstance(s0, str) for s0 in s): raise TypeError("Address.parse_list requires a string argument") return [cls.parse(a, default_host, default_port) for a in " ".join(s).split()] def __new__(cls, iterable: t.Collection) -> Address: if isinstance(iterable, cls): return iterable n_parts = len(iterable) inst = tuple.__new__(cls, iterable) if n_parts == 2: inst.__class__ = cls.ipv4_cls elif n_parts == 4: inst.__class__ = cls.ipv6_cls else: raise ValueError("Addresses must consist of either " "two parts (IPv4) or four parts (IPv6)") return inst #: Address family (AF_INET or AF_INET6) family: t.Optional[AddressFamily] = None def __repr__(self): return "{}({!r})".format(self.__class__.__name__, tuple(self)) @property def host_name(self) -> str: return self[0] @property def host(self) -> str: return self[0] @property def port(self) -> int: return self[1] @property def unresolved(self) -> Address: return self @property def port_number(self) -> int: try: return getservbyname(self[1]) except (OSError, TypeError): # OSError: service/proto not found # TypeError: getservbyname() argument 1 must be str, not X try: return int(self[1]) except (TypeError, ValueError) as e: raise type(e)("Unknown port value %r" % self[1]) _T_Address = t.TypeVar("_T_Address", bound=Address) class IPv4Address(Address): family = AF_INET def __str__(self) -> str: return "{}:{}".format(*self) class IPv6Address(Address): family = AF_INET6 def __str__(self) -> str: return "[{}]:{}".format(*self) class ResolvedAddress(Address): _host_name: str @property def host_name(self) -> str: return self._host_name @property def unresolved(self) -> Address: return super().__new__(Address, (self._host_name, *self[1:])) def __new__(cls, iterable, *, host_name: str) -> ResolvedAddress: new = super().__new__(cls, iterable) new = t.cast(ResolvedAddress, new) new._host_name = host_name return new class ResolvedIPv4Address(IPv4Address, ResolvedAddress): pass class ResolvedIPv6Address(IPv6Address, ResolvedAddress): pass neo4j-python-driver-5.2.1/neo4j/api.py000066400000000000000000000440561433522662700175330ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. """ Base classes and helpers. """ from __future__ import annotations import abc import typing as t from urllib.parse import ( parse_qs, urlparse, ) if t.TYPE_CHECKING: import typing_extensions as te from .addressing import Address from ._meta import deprecated from .exceptions import ConfigurationError if t.TYPE_CHECKING: from typing_extensions import Protocol as _Protocol else: _Protocol = object READ_ACCESS: te.Final[str] = "READ" WRITE_ACCESS: te.Final[str] = "WRITE" DRIVER_BOLT: te.Final[str] = "DRIVER_BOLT" DRIVER_NEO4J: te.Final[str] = "DRIVER_NEO4J" SECURITY_TYPE_NOT_SECURE: te.Final[str] = "SECURITY_TYPE_NOT_SECURE" SECURITY_TYPE_SELF_SIGNED_CERTIFICATE: te.Final[str] = \ "SECURITY_TYPE_SELF_SIGNED_CERTIFICATE" SECURITY_TYPE_SECURE: te.Final[str] = "SECURITY_TYPE_SECURE" URI_SCHEME_BOLT: te.Final[str] = "bolt" URI_SCHEME_BOLT_SELF_SIGNED_CERTIFICATE: te.Final[str] = "bolt+ssc" URI_SCHEME_BOLT_SECURE: te.Final[str] = "bolt+s" URI_SCHEME_NEO4J: te.Final[str] = "neo4j" URI_SCHEME_NEO4J_SELF_SIGNED_CERTIFICATE: te.Final[str] = "neo4j+ssc" URI_SCHEME_NEO4J_SECURE: te.Final[str] = "neo4j+s" URI_SCHEME_BOLT_ROUTING: te.Final[str] = "bolt+routing" # TODO: 6.0 - remove TRUST constants TRUST_SYSTEM_CA_SIGNED_CERTIFICATES: te.Final[str] = \ "TRUST_SYSTEM_CA_SIGNED_CERTIFICATES" # Default TRUST_ALL_CERTIFICATES: te.Final[str] = "TRUST_ALL_CERTIFICATES" SYSTEM_DATABASE: te.Final[str] = "system" DEFAULT_DATABASE: te.Final[None] = None # Must be a non string hashable value # TODO: This class is not tested class Auth: """Container for auth details. :param scheme: specifies the type of authentication, examples: "basic", "kerberos" :param principal: specifies who is being authenticated :param credentials: authenticates the principal :param realm: specifies the authentication provider :param parameters: extra key word parameters passed along to the authentication provider """ def __init__( self, scheme: t.Optional[str], principal: t.Optional[str], credentials: t.Optional[str], realm: t.Optional[str] = None, **parameters: t.Any ) -> None: self.scheme = scheme # Neo4j servers pre 4.4 require the principal field to always be # present. Therefore, we transmit it even if it's an empty sting. if principal is not None: self.principal = principal if credentials: self.credentials = credentials if realm: self.realm = realm if parameters: self.parameters = parameters # For backwards compatibility AuthToken = Auth def basic_auth( user: str, password: str, realm: t.Optional[str] = None ) -> Auth: """Generate a basic auth token for a given user and password. This will set the scheme to "basic" for the auth token. :param user: user name, this will set the :param password: current password, this will set the credentials :param realm: specifies the authentication provider :return: auth token for use with :meth:`GraphDatabase.driver` or :meth:`AsyncGraphDatabase.driver` """ return Auth("basic", user, password, realm) def kerberos_auth(base64_encoded_ticket: str) -> Auth: """Generate a kerberos auth token with the base64 encoded ticket. This will set the scheme to "kerberos" for the auth token. :param base64_encoded_ticket: a base64 encoded service ticket, this will set the credentials :return: auth token for use with :meth:`GraphDatabase.driver` or :meth:`AsyncGraphDatabase.driver` """ return Auth("kerberos", "", base64_encoded_ticket) def bearer_auth(base64_encoded_token: str) -> Auth: """Generate an auth token for Single-Sign-On providers. This will set the scheme to "bearer" for the auth token. :param base64_encoded_token: a base64 encoded authentication token generated by a Single-Sign-On provider. :return: auth token for use with :meth:`GraphDatabase.driver` or :meth:`AsyncGraphDatabase.driver` """ return Auth("bearer", None, base64_encoded_token) def custom_auth( principal: t.Optional[str], credentials: t.Optional[str], realm: t.Optional[str], scheme: t.Optional[str], **parameters: t.Any ) -> Auth: """Generate a custom auth token. :param principal: specifies who is being authenticated :param credentials: authenticates the principal :param realm: specifies the authentication provider :param scheme: specifies the type of authentication :param parameters: extra key word parameters passed along to the authentication provider :return: auth token for use with :meth:`GraphDatabase.driver` or :meth:`AsyncGraphDatabase.driver` """ return Auth(scheme, principal, credentials, realm, **parameters) # TODO 6.0 - remove this class class Bookmark: """A Bookmark object contains an immutable list of bookmark string values. .. deprecated:: 5.0 `Bookmark` will be removed in version 6.0. Use :class:`Bookmarks` instead. :param values: ASCII string values """ @deprecated("Use the `Bookmarks`` class instead.") def __init__(self, *values: str) -> None: if values: bookmarks = [] for ix in values: try: if ix: ix.encode("ascii") bookmarks.append(ix) except UnicodeEncodeError as e: raise ValueError("The value {} is not ASCII".format(ix)) self._values = frozenset(bookmarks) else: self._values = frozenset() def __repr__(self) -> str: """ :return: repr string with sorted values """ return "".format(", ".join(["'{}'".format(ix) for ix in sorted(self._values)])) def __bool__(self) -> bool: return bool(self._values) @property def values(self) -> frozenset: """ :return: immutable list of bookmark string values """ return self._values class Bookmarks: """Container for an immutable set of bookmark string values. Bookmarks are used to causally chain session. See :meth:`Session.last_bookmarks` or :meth:`AsyncSession.last_bookmarks` for more information. Use addition to combine multiple Bookmarks objects:: bookmarks3 = bookmarks1 + bookmarks2 """ def __init__(self): self._raw_values = frozenset() def __repr__(self) -> str: """ :return: repr string with sorted values """ return "".format( ", ".join(map(repr, sorted(self._raw_values))) ) def __bool__(self) -> bool: """True if there are bookmarks in the container.""" return bool(self._raw_values) def __add__(self, other: Bookmarks) -> Bookmarks: """Add multiple containers together.""" if isinstance(other, Bookmarks): if not other: return self ret = self.__class__() ret._raw_values = self._raw_values | other._raw_values return ret return NotImplemented @property def raw_values(self) -> t.FrozenSet[str]: """The raw bookmark values. You should not need to access them unless you want to serialize bookmarks. :return: immutable list of bookmark string values :rtype: frozenset[str] """ return self._raw_values @classmethod def from_raw_values(cls, values: t.Iterable[str]) -> Bookmarks: """Create a Bookmarks object from a list of raw bookmark string values. You should not need to use this method unless you want to deserialize bookmarks. :param values: ASCII string values (raw bookmarks) :type values: Iterable[str] """ obj = cls() bookmarks = [] for value in values: if not isinstance(value, str): raise TypeError("Raw bookmark values must be str. " "Found {}".format(type(value))) try: value.encode("ascii") except UnicodeEncodeError as e: raise ValueError(f"The value {value} is not ASCII") from e bookmarks.append(value) obj._raw_values = frozenset(bookmarks) return obj class ServerInfo: """ Represents a package of information relating to a Neo4j server. """ def __init__(self, address: Address, protocol_version: Version): self._address = address self._protocol_version = protocol_version self._metadata: dict = {} @property def address(self) -> Address: """ Network address of the remote server. """ return self._address @property def protocol_version(self) -> Version: """ Bolt protocol version with which the remote server communicates. This is returned as a :class:`.Version` object, which itself extends a simple 2-tuple of (major, minor) integers. """ return self._protocol_version @property def agent(self) -> str: """ Server agent string by which the remote server identifies itself. """ return str(self._metadata.get("server")) @property # type: ignore @deprecated("The connection id is considered internal information " "and will no longer be exposed in future versions.") def connection_id(self): """ Unique identifier for the remote server connection. """ return self._metadata.get("connection_id") def update(self, metadata: dict) -> None: """ Update server information with extra metadata. This is typically drawn from the metadata received after successful connection initialisation. """ self._metadata.update(metadata) class Version(tuple): def __new__(cls, *v): return super().__new__(cls, v) def __repr__(self): return "{}{}".format(self.__class__.__name__, super().__repr__()) def __str__(self): return ".".join(map(str, self)) def to_bytes(self) -> bytes: b = bytearray(4) for i, v in enumerate(self): if not 0 <= i < 2: raise ValueError("Too many version components") if isinstance(v, list): b[-i - 1] = int(v[0] % 0x100) b[-i - 2] = int((v[0] - v[-1]) % 0x100) else: b[-i - 1] = int(v % 0x100) return bytes(b) @classmethod def from_bytes(cls, b: bytes) -> Version: b = bytearray(b) if len(b) != 4: raise ValueError("Byte representation must be exactly four bytes") if b[0] != 0 or b[1] != 0: raise ValueError("First two bytes must contain zero") return Version(b[-1], b[-2]) class BookmarkManager(_Protocol, metaclass=abc.ABCMeta): """Class to manage bookmarks throughout the driver's lifetime. Neo4j clusters are eventually consistent, meaning that there is no guarantee a query will be able to read changes made by a previous query. For cases where such a guarantee is necessary, the server provides bookmarks to the client. A bookmark is an abstract token that represents some state of the database. By passing one or multiple bookmarks along with a query, the server will make sure that the query will not get executed before the represented state(s) (or a later state) have been established. The bookmark manager is an interface used by the driver for keeping track of the bookmarks and this way keeping sessions automatically consistent. Configure the driver to use a specific bookmark manager with :ref:`bookmark-manager-ref`. This class is just an abstract base class that defines the required interface. Create a child class to implement a specific bookmark manager or make use of the default implementation provided by the driver through :meth:`.GraphDatabase.bookmark_manager()`. .. note:: All methods must be concurrency safe. Generally, all methods need to be able to cope with getting passed a ``database`` parameter that is (until then) unknown to the manager. .. versionadded:: 5.0 """ @abc.abstractmethod def update_bookmarks( self, database: str, previous_bookmarks: t.Collection[str], new_bookmarks: t.Collection[str] ) -> None: """Handle bookmark updates. :param database: The database which the bookmarks belong to :param previous_bookmarks: The bookmarks used at the start of a transaction :param new_bookmarks: The new bookmarks retrieved at the end of a transaction """ ... @abc.abstractmethod def get_bookmarks(self, database: str) -> t.Collection[str]: """Return the bookmarks for a given database. :param database: The database which the bookmarks belong to :returns: The bookmarks for the given database """ ... @abc.abstractmethod def get_all_bookmarks(self) -> t.Collection[str]: """Return all bookmarks for all known databases. :returns: The collected bookmarks. """ ... @abc.abstractmethod def forget(self, databases: t.Iterable[str]) -> None: """Forget the bookmarks for the given databases. This method is not called by the driver. Forgetting unused databases is the user's responsibility. :param databases: The databases which the bookmarks will be removed for. """ ... class AsyncBookmarkManager(_Protocol, metaclass=abc.ABCMeta): """Same as :class:`.BookmarkManager` but with async methods. The driver comes with a default implementation of the async bookmark manager accessible through :attr:`.AsyncGraphDatabase.bookmark_manager()`. .. versionadded:: 5.0 """ @abc.abstractmethod async def update_bookmarks( self, database: str, previous_bookmarks: t.Collection[str], new_bookmarks: t.Collection[str] ) -> None: ... update_bookmarks.__doc__ = BookmarkManager.update_bookmarks.__doc__ @abc.abstractmethod async def get_bookmarks(self, database: str) -> t.Collection[str]: ... get_bookmarks.__doc__ = BookmarkManager.get_bookmarks.__doc__ @abc.abstractmethod async def get_all_bookmarks(self) -> t.Collection[str]: ... get_all_bookmarks.__doc__ = BookmarkManager.get_all_bookmarks.__doc__ @abc.abstractmethod async def forget(self, databases: t.Iterable[str]) -> None: ... forget.__doc__ = BookmarkManager.forget.__doc__ def parse_neo4j_uri(uri): parsed = urlparse(uri) if parsed.username: raise ConfigurationError("Username is not supported in the URI") if parsed.password: raise ConfigurationError("Password is not supported in the URI") if parsed.scheme == URI_SCHEME_BOLT_ROUTING: raise ConfigurationError("Uri scheme {!r} have been renamed. Use {!r}".format(parsed.scheme, URI_SCHEME_NEO4J)) elif parsed.scheme == URI_SCHEME_BOLT: driver_type = DRIVER_BOLT security_type = SECURITY_TYPE_NOT_SECURE elif parsed.scheme == URI_SCHEME_BOLT_SELF_SIGNED_CERTIFICATE: driver_type = DRIVER_BOLT security_type = SECURITY_TYPE_SELF_SIGNED_CERTIFICATE elif parsed.scheme == URI_SCHEME_BOLT_SECURE: driver_type = DRIVER_BOLT security_type = SECURITY_TYPE_SECURE elif parsed.scheme == URI_SCHEME_NEO4J: driver_type = DRIVER_NEO4J security_type = SECURITY_TYPE_NOT_SECURE elif parsed.scheme == URI_SCHEME_NEO4J_SELF_SIGNED_CERTIFICATE: driver_type = DRIVER_NEO4J security_type = SECURITY_TYPE_SELF_SIGNED_CERTIFICATE elif parsed.scheme == URI_SCHEME_NEO4J_SECURE: driver_type = DRIVER_NEO4J security_type = SECURITY_TYPE_SECURE else: raise ConfigurationError("URI scheme {!r} is not supported. Supported URI schemes are {}. Examples: bolt://host[:port] or neo4j://host[:port][?routing_context]".format( parsed.scheme, [ URI_SCHEME_BOLT, URI_SCHEME_BOLT_SELF_SIGNED_CERTIFICATE, URI_SCHEME_BOLT_SECURE, URI_SCHEME_NEO4J, URI_SCHEME_NEO4J_SELF_SIGNED_CERTIFICATE, URI_SCHEME_NEO4J_SECURE ] )) return driver_type, security_type, parsed def check_access_mode(access_mode): if access_mode is None: return WRITE_ACCESS if access_mode not in (READ_ACCESS, WRITE_ACCESS): msg = "Unsupported access mode {}".format(access_mode) raise ConfigurationError(msg) return access_mode def parse_routing_context(query): """ Parse the query portion of a URI to generate a routing context dictionary. """ if not query: return {} context = {} parameters = parse_qs(query, True) for key in parameters: value_list = parameters[key] if len(value_list) != 1: raise ConfigurationError("Duplicated query parameters with key '%s', value '%s' found in query string '%s'" % (key, value_list, query)) value = value_list[0] if not value: raise ConfigurationError("Invalid parameters:'%s=%s' in query string '%s'." % (key, value, query)) context[key] = value return context neo4j-python-driver-5.2.1/neo4j/conf.py000066400000000000000000000024621433522662700177020ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. # TODO: 6.0 - remove this file from ._conf import ( Config, ConfigType, DeprecatedAlias, DeprecatedAlternative, iter_items, PoolConfig, RoutingConfig, SessionConfig, TransactionConfig, WorkspaceConfig, ) from ._meta import deprecation_warn as _deprecation_warn __all__ = [ "Config", "ConfigType", "DeprecatedAlias", "DeprecatedAlternative", "iter_items", "PoolConfig", "RoutingConfig", "SessionConfig", "TransactionConfig", "WorkspaceConfig", ] _deprecation_warn( "The module 'neo4j.conf' was made internal and will " "no longer be available for import in future versions.", stack_level=2 ) neo4j-python-driver-5.2.1/neo4j/data.py000066400000000000000000000022601433522662700176620ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. # TODO: 6.0 - remove this file from ._data import ( DataTransformer, Record, RecordExporter, RecordTableRowExporter, ) from ._meta import deprecation_warn map_type = type(map(str, range(0))) __all__ = [ "map_type", "Record", "DataTransformer", "RecordExporter", "RecordTableRowExporter", ] deprecation_warn( "The module 'neo4j.data' was made internal and will " "no longer be available for import in future versions. " "`neo4j.data.Record` should be imported directly from `neo4j`.", stack_level=2 ) neo4j-python-driver-5.2.1/neo4j/debug.py000066400000000000000000000171311433522662700200420ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations import asyncio import typing as t from logging import ( CRITICAL, DEBUG, ERROR, Filter, Formatter, getLogger, INFO, StreamHandler, WARNING, ) from sys import stderr __all__ = [ "Watcher", "watch" ] class ColourFormatter(Formatter): """ Colour formatter for pretty log output. """ def format(self, record): s = super().format(record) if record.levelno == CRITICAL: return "\x1b[31;1m%s\x1b[0m" % s # bright red elif record.levelno == ERROR: return "\x1b[33;1m%s\x1b[0m" % s # bright yellow elif record.levelno == WARNING: return "\x1b[33m%s\x1b[0m" % s # yellow elif record.levelno == INFO: return "\x1b[37m%s\x1b[0m" % s # white elif record.levelno == DEBUG: return "\x1b[36m%s\x1b[0m" % s # cyan else: return s class TaskIdFilter(Filter): """Injecting async task id into log records.""" def filter(self, record): try: record.task = id(asyncio.current_task()) except RuntimeError: record.task = None return True class Watcher: """Log watcher for easier logging setup. Example:: from neo4j.debug import Watcher with Watcher("neo4j"): # DEBUG logging to stderr enabled within this context ... # do something .. note:: The Watcher class is not thread-safe. Having Watchers in multiple threads can lead to duplicate log messages as the context manager will enable logging for all threads. .. note:: The exact logging format is not part of the API contract and might change at any time without notice. It is meant for debugging purposes and human consumption only. :param logger_names: Names of loggers to watch. :param default_level: Default minimum log level to show. The level can be overridden by setting ``level`` when calling :meth:`.watch`. :param default_out: Default output stream for all loggers. The level can be overridden by setting ``out`` when calling :meth:`.watch`. :type default_out: stream or file-like object :param colour: Whether the log levels should be indicated with ANSI colour codes. :param thread_info: whether to include information about the current thread in the log message. Defaults to :const:`True`. :param task_info: whether to include information about the current async task in the log message. Defaults to :const:`True`. .. versionchanged:: 5.3 * Added ``thread_info`` and ``task_info`` parameters. * Logging format around thread and task information changed. """ def __init__( self, *logger_names: t.Optional[str], default_level: int = DEBUG, default_out: t.TextIO = stderr, colour: bool = False, thread_info: bool = True, task_info: bool = True, ) -> None: super(Watcher, self).__init__() self.logger_names = logger_names self._loggers = [getLogger(name) for name in self.logger_names] self.default_level = default_level self.default_out = default_out self._handlers: t.Dict[str, StreamHandler] = {} self._task_info = task_info format_ = "%(asctime)s %(message)s" if task_info: format_ = "[Task %(task)-15s] " + format_ if thread_info: format_ = "[Thread %(thread)d] " + format_ if not colour: format_ = "[%(levelname)-8s] " + format_ formatter_cls = ColourFormatter if colour else Formatter self.formatter = formatter_cls(format_) def __enter__(self) -> Watcher: """Enable logging for all loggers.""" self.watch() return self def __exit__(self, exc_type, exc_val, exc_tb): """Disable logging for all loggers.""" self.stop() def watch( self, level: t.Optional[int] = None, out: t.Optional[t.TextIO] = None ) -> None: """Enable logging for all loggers. :param level: Minimum log level to show. If :const:`None`, the ``default_level`` is used. :param out: Output stream for all loggers. If :const:`None`, the ``default_out`` is used. :type out: stream or file-like object """ if level is None: level = self.default_level if out is None: out = self.default_out self.stop() handler = StreamHandler(out) handler.setFormatter(self.formatter) if self._task_info: handler.addFilter(TaskIdFilter()) for logger in self. _loggers: self._handlers[logger.name] = handler logger.addHandler(handler) logger.setLevel(level) def stop(self) -> None: """Disable logging for all loggers.""" for logger in self._loggers: try: logger.removeHandler(self._handlers.pop(logger.name)) except KeyError: pass def watch( *logger_names: t.Optional[str], level: int = DEBUG, out: t.TextIO = stderr, colour: bool = False, thread_info: bool = True, task_info: bool = True, ) -> Watcher: """Quick wrapper for using :class:`.Watcher`. Create a Watcher with the given configuration, enable watching and return it. Example:: from neo4j.debug import watch watch("neo4j") # from now on, DEBUG logging to stderr is enabled in the driver .. note:: The exact logging format is not part of the API contract and might change at any time without notice. It is meant for debugging purposes and human consumption only. :param logger_names: Names of loggers to watch. :param level: see ``default_level`` of :class:`.Watcher`. :param out: see ``default_out`` of :class:`.Watcher`. :type out: stream or file-like object :param colour: see ``colour`` of :class:`.Watcher`. :param thread_info: see ``thread_info`` of :class:`.Watcher`. :param task_info: see ``task_info`` of :class:`.Watcher`. :return: Watcher instance :rtype: :class:`.Watcher` .. versionchanged:: 5.3 * Added ``thread_info`` and ``task_info`` parameters. * Logging format around thread and task information changed. """ watcher = Watcher(*logger_names, default_level=level, default_out=out, colour=colour, thread_info=thread_info, task_info=task_info) watcher.watch() return watcher class Connection: def connect(self): self.hello() # buffer HELLO message self.logon() # buffer LOGON message self.send_and_receive() # send HELLO and LOGON, receive 2x SUCCESS def reauth(self): self.logoff() # buffer LOGOFF message self.logon() # buffer LOGON message self.send_and_receive() # send LOGOFF and LOGON, receive 2x SUCCESS neo4j-python-driver-5.2.1/neo4j/exceptions.py000066400000000000000000000365031433522662700211410ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. """ This module contains the core driver exceptions. Driver API Errors ================= + Neo4jError + ClientError + CypherSyntaxError + CypherTypeError + ConstraintError + AuthError + TokenExpired + Forbidden + DatabaseError + TransientError + DatabaseUnavailable + NotALeader + ForbiddenOnReadOnlyDatabase + DriverError + SessionError + TransactionError + TransactionNestingError + ResultError + ResultConsumedError + ResultNotSingleError + BrokenRecordError + SessionExpired + ServiceUnavailable + RoutingServiceUnavailable + WriteServiceUnavailable + ReadServiceUnavailable + IncompleteCommit + ConfigurationError + AuthConfigurationError + CertificateConfigurationError Connector API Errors ==================== + BoltError + BoltHandshakeError + BoltRoutingError + BoltConnectionError + BoltSecurityError + BoltConnectionBroken + BoltConnectionClosed + BoltFailure + BoltProtocolError + Bolt* """ from __future__ import annotations import typing as t if t.TYPE_CHECKING: import typing_extensions as te from ._async.work import ( AsyncManagedTransaction, AsyncResult, AsyncSession, AsyncTransaction, ) from ._sync.work import ( ManagedTransaction, Result, Session, Transaction, ) _T_Transaction = t.Union[AsyncManagedTransaction, AsyncTransaction, ManagedTransaction, Transaction] _T_Result = t.Union[AsyncResult, Result] _T_Session = t.Union[AsyncSession, Session] else: _T_Transaction = t.Union["AsyncManagedTransaction", "AsyncTransaction", "ManagedTransaction", "Transaction"] _T_Result = t.Union["AsyncResult", "Result"] _T_Session = t.Union["AsyncSession", "Session"] from ._meta import deprecated CLASSIFICATION_CLIENT: te.Final[str] = "ClientError" CLASSIFICATION_TRANSIENT: te.Final[str] = "TransientError" CLASSIFICATION_DATABASE: te.Final[str] = "DatabaseError" ERROR_REWRITE_MAP: t.Dict[str, t.Tuple[str, t.Optional[str]]] = { # This error can be retried ed. The driver just needs to re-authenticate # with the same credentials. "Neo.ClientError.Security.AuthorizationExpired": ( CLASSIFICATION_TRANSIENT, None ), # In 5.0, this error has been re-classified as ClientError. # For backwards compatibility with Neo4j 4.4 and earlier, we re-map it in # the driver, too. "Neo.TransientError.Transaction.Terminated": ( CLASSIFICATION_CLIENT, "Neo.ClientError.Transaction.Terminated" ), # In 5.0, this error has been re-classified as ClientError. # For backwards compatibility with Neo4j 4.4 and earlier, we re-map it in # the driver, too. "Neo.TransientError.Transaction.LockClientStopped": ( CLASSIFICATION_CLIENT, "Neo.ClientError.Transaction.LockClientStopped" ), } # Neo4jError class Neo4jError(Exception): """ Raised when the Cypher engine returns an error to the client. """ #: (str or None) The error message returned by the server. message = None #: (str or None) The error code returned by the server. #: There are many Neo4j status codes, see #: `status codes `_. code = None classification = None category = None title = None #: (dict) Any additional information returned by the server. metadata = None @classmethod def hydrate( cls, message: t.Optional[str] = None, code: t.Optional[str] = None, **metadata: t.Any ) -> Neo4jError: message = message or "An unknown error occurred" code = code or "Neo.DatabaseError.General.UnknownError" try: _, classification, category, title = code.split(".") except ValueError: classification = CLASSIFICATION_DATABASE category = "General" title = "UnknownError" else: classification_override, code_override = \ ERROR_REWRITE_MAP.get(code, (None, None)) if classification_override is not None: classification = classification_override if code_override is not None: code = code_override error_class = cls._extract_error_class(classification, code) inst = error_class(message) inst.message = message inst.code = code inst.classification = classification inst.category = category inst.title = title inst.metadata = metadata return inst @classmethod def _extract_error_class(cls, classification, code): if classification == CLASSIFICATION_CLIENT: try: return client_errors[code] except KeyError: return ClientError elif classification == CLASSIFICATION_TRANSIENT: try: return transient_errors[code] except KeyError: return TransientError elif classification == CLASSIFICATION_DATABASE: return DatabaseError else: return cls # TODO 6.0: Remove this alias @deprecated( "Neo4jError.is_retriable is deprecated and will be removed in a " "future version. Please use Neo4jError.is_retryable instead." ) def is_retriable(self) -> bool: """Whether the error is retryable. See :meth:`.is_retryable`. :return: :const:`True` if the error is retryable, :const:`False` otherwise. .. deprecated:: 5.0 This method will be removed in a future version. Please use :meth:`.is_retryable` instead. """ return self.is_retryable() def is_retryable(self) -> bool: """Whether the error is retryable. Indicates whether a transaction that yielded this error makes sense to retry. This method makes mostly sense when implementing a custom retry policy in conjunction with :ref:`explicit-transactions-ref`. :return: :const:`True` if the error is retryable, :const:`False` otherwise. """ return False def invalidates_all_connections(self): return self.code == "Neo.ClientError.Security.AuthorizationExpired" def is_fatal_during_discovery(self) -> bool: # checks if the code is an error that is caused by the client. In this # case the driver should fail fast during discovery. if not isinstance(self.code, str): return False if self.code in ("Neo.ClientError.Database.DatabaseNotFound", "Neo.ClientError.Transaction.InvalidBookmark", "Neo.ClientError.Transaction.InvalidBookmarkMixture"): return True if (self.code.startswith("Neo.ClientError.Security.") and self.code != "Neo.ClientError.Security." "AuthorizationExpired"): return True return False def __str__(self): if self.code or self.message: return "{{code: {code}}} {{message: {message}}}".format( code=self.code, message=self.message ) return super().__str__() # Neo4jError > ClientError class ClientError(Neo4jError): """ The Client sent a bad request - changing the request might yield a successful outcome. """ # Neo4jError > ClientError > CypherSyntaxError class CypherSyntaxError(ClientError): """ """ # Neo4jError > ClientError > CypherTypeError class CypherTypeError(ClientError): """ """ # Neo4jError > ClientError > ConstraintError class ConstraintError(ClientError): """ """ # Neo4jError > ClientError > AuthError class AuthError(ClientError): """ Raised when authentication failure occurs. """ # Neo4jError > ClientError > AuthError > TokenExpired class TokenExpired(AuthError): """ Raised when the authentication token has expired. A new driver instance with a fresh authentication token needs to be created. """ # Neo4jError > ClientError > Forbidden class Forbidden(ClientError): """ """ # Neo4jError > DatabaseError class DatabaseError(Neo4jError): """ The database failed to service the request. """ # Neo4jError > TransientError class TransientError(Neo4jError): """ The database cannot service the request right now, retrying later might yield a successful outcome. """ def is_retryable(self) -> bool: return True # Neo4jError > TransientError > DatabaseUnavailable class DatabaseUnavailable(TransientError): """ """ # Neo4jError > TransientError > NotALeader class NotALeader(TransientError): """ """ # Neo4jError > TransientError > ForbiddenOnReadOnlyDatabase class ForbiddenOnReadOnlyDatabase(TransientError): """ """ client_errors: t.Dict[str, t.Type[Neo4jError]] = { # ConstraintError "Neo.ClientError.Schema.ConstraintValidationFailed": ConstraintError, "Neo.ClientError.Schema.ConstraintViolation": ConstraintError, "Neo.ClientError.Statement.ConstraintVerificationFailed": ConstraintError, "Neo.ClientError.Statement.ConstraintViolation": ConstraintError, # CypherSyntaxError "Neo.ClientError.Statement.InvalidSyntax": CypherSyntaxError, "Neo.ClientError.Statement.SyntaxError": CypherSyntaxError, # CypherTypeError "Neo.ClientError.Procedure.TypeError": CypherTypeError, "Neo.ClientError.Statement.InvalidType": CypherTypeError, "Neo.ClientError.Statement.TypeError": CypherTypeError, # Forbidden "Neo.ClientError.General.ForbiddenOnReadOnlyDatabase": ForbiddenOnReadOnlyDatabase, "Neo.ClientError.General.ReadOnly": Forbidden, "Neo.ClientError.Schema.ForbiddenOnConstraintIndex": Forbidden, "Neo.ClientError.Schema.IndexBelongsToConstraint": Forbidden, "Neo.ClientError.Security.Forbidden": Forbidden, "Neo.ClientError.Transaction.ForbiddenDueToTransactionType": Forbidden, # AuthError "Neo.ClientError.Security.AuthorizationFailed": AuthError, "Neo.ClientError.Security.Unauthorized": AuthError, # TokenExpired "Neo.ClientError.Security.TokenExpired": TokenExpired, # NotALeader "Neo.ClientError.Cluster.NotALeader": NotALeader, } transient_errors: t.Dict[str, t.Type[Neo4jError]] = { # DatabaseUnavailableError "Neo.TransientError.General.DatabaseUnavailable": DatabaseUnavailable } # DriverError class DriverError(Exception): """ Raised when the Driver raises an error. """ def is_retryable(self) -> bool: """Whether the error is retryable. Indicates whether a transaction that yielded this error makes sense to retry. This method makes mostly sense when implementing a custom retry policy in conjunction with :ref:`explicit-transactions-ref`. :return: :const:`True` if the error is retryable, :const:`False` otherwise. """ return False # DriverError > SessionError class SessionError(DriverError): """ Raised when an error occurs while using a session. """ session: _T_Session def __init__(self, session_, *args, **kwargs): super().__init__(*args, **kwargs) self.session = session_ # DriverError > TransactionError class TransactionError(DriverError): """ Raised when an error occurs while using a transaction. """ transaction: _T_Transaction def __init__(self, transaction_, *args, **kwargs): super().__init__(*args, **kwargs) self.transaction = transaction_ # DriverError > TransactionError > TransactionNestingError class TransactionNestingError(TransactionError): """ Raised when transactions are nested incorrectly. """ # DriverError > ResultError class ResultError(DriverError): """Raised when an error occurs while using a result object.""" result: _T_Result def __init__(self, result_, *args, **kwargs): super().__init__(*args, **kwargs) self.result = result_ # DriverError > ResultError > ResultConsumedError class ResultConsumedError(ResultError): """Raised when trying to access records of a consumed result.""" # DriverError > ResultError > ResultNotSingleError class ResultNotSingleError(ResultError): """Raised when a result should have exactly one record but does not.""" # DriverError > BrokenRecordError class BrokenRecordError(DriverError): """ Raised when accessing a Record's field that couldn't be decoded. This can for instance happen when the server sends a zoned datetime with a zone id unknown to the client. """ # DriverError > SessionExpired class SessionExpired(DriverError): """ Raised when a session is no longer able to fulfil the purpose described by its original parameters. """ def is_retryable(self) -> bool: return True # DriverError > ServiceUnavailable class ServiceUnavailable(DriverError): """ Raised when no database service is available. This may be due to incorrect configuration or could indicate a runtime failure of a database service that the driver is unable to route around. """ def is_retryable(self) -> bool: return True # DriverError > ServiceUnavailable > RoutingServiceUnavailable class RoutingServiceUnavailable(ServiceUnavailable): """ Raised when no routing service is available. """ # DriverError > ServiceUnavailable > WriteServiceUnavailable class WriteServiceUnavailable(ServiceUnavailable): """ Raised when no write service is available. """ # DriverError > ServiceUnavailable > ReadServiceUnavailable class ReadServiceUnavailable(ServiceUnavailable): """ Raised when no read service is available. """ # DriverError > ServiceUnavailable > IncompleteCommit class IncompleteCommit(ServiceUnavailable): """ Raised when the client looses connection while committing a transaction Raised when a disconnection occurs while still waiting for a commit response. For non-idempotent write transactions, this leaves the data in an unknown state with regard to whether the transaction completed successfully or not. """ def is_retryable(self) -> bool: return False # DriverError > ConfigurationError class ConfigurationError(DriverError): """ Raised when there is an error concerning a configuration. """ # DriverError > ConfigurationError > AuthConfigurationError class AuthConfigurationError(ConfigurationError): """ Raised when there is an error with the authentication configuration. """ # DriverError > ConfigurationError > CertificateConfigurationError class CertificateConfigurationError(ConfigurationError): """ Raised when there is an error with the certificate configuration. """ class UnsupportedServerProduct(Exception): """ Raised when an unsupported server product is detected. """ neo4j-python-driver-5.2.1/neo4j/graph/000077500000000000000000000000001433522662700175005ustar00rootroot00000000000000neo4j-python-driver-5.2.1/neo4j/graph/__init__.py000066400000000000000000000252441433522662700216200ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. """ Graph data types """ from __future__ import annotations import typing as t from collections.abc import Mapping from .._meta import ( deprecated, deprecation_warn, ) __all__ = [ "Graph", "Node", "Path", "Relationship", ] _T = t.TypeVar("_T") class Graph: """ Local, self-contained graph object that acts as a container for :class:`.Node` and :class:`.Relationship` instances. """ def __init__(self) -> None: self._nodes: t.Dict[str, Node] = {} self._legacy_nodes: t.Dict[int, Node] = {} # TODO: 6.0 - remove self._relationships: t.Dict[str, Relationship] = {} # TODO: 6.0 - remove self._legacy_relationships: t.Dict[int, Relationship] = {} self._relationship_types: t.Dict[str, t.Type[Relationship]] = {} self._node_set_view = EntitySetView(self._nodes, self._legacy_nodes) self._relationship_set_view = EntitySetView(self._relationships, self._legacy_relationships) @property def nodes(self) -> EntitySetView[Node]: """ Access a set view of the nodes in this graph. """ return self._node_set_view @property def relationships(self) -> EntitySetView[Relationship]: """ Access a set view of the relationships in this graph. """ return self._relationship_set_view def relationship_type(self, name: str) -> t.Type[Relationship]: """ Obtain a :class:`.Relationship` subclass for a given relationship type name. """ try: cls = self._relationship_types[name] except KeyError: cls = self._relationship_types[name] = t.cast( t.Type[Relationship], type(str(name), (Relationship,), {}) ) return cls class Entity(t.Mapping[str, t.Any]): """ Base class for :class:`.Node` and :class:`.Relationship` that provides :class:`.Graph` membership and property containment functionality. """ def __init__( self, graph: Graph, element_id: str, id_: int, properties: t.Optional[t.Dict[str, t.Any]] ) -> None: self._graph = graph self._element_id = element_id self._id = id_ self._properties = { k: v for k, v in (properties or {}).items() if v is not None } def __eq__(self, other: t.Any) -> bool: try: return (type(self) == type(other) and self.graph == other.graph and self.element_id == other.element_id) except AttributeError: return False def __ne__(self, other: object) -> bool: return not self.__eq__(other) def __hash__(self): return hash(self._element_id) def __len__(self) -> int: return len(self._properties) def __getitem__(self, name: str) -> t.Any: return self._properties.get(name) def __contains__(self, name: object) -> bool: return name in self._properties def __iter__(self) -> t.Iterator[str]: return iter(self._properties) @property def graph(self) -> Graph: """ The :class:`.Graph` to which this entity belongs. """ return self._graph @property # type: ignore @deprecated("`id` is deprecated, use `element_id` instead") def id(self) -> int: """The legacy identity of this entity in its container :class:`.Graph`. Depending on the version of the server this entity was retrieved from, this may be empty (None). .. Warning:: This value can change for the same entity across multiple queries. Don't rely on it for cross-query computations. .. deprecated:: 5.0 Use :attr:`.element_id` instead. """ return self._id @property def element_id(self) -> str: """The identity of this entity in its container :class:`.Graph`. .. Warning:: This value can change for the same entity across multiple queries. Don't rely on it for cross-query computations. .. versionadded:: 5.0 """ return self._element_id def get(self, name: str, default: t.Optional[object] = None) -> t.Any: """ Get a property value by name, optionally with a default. """ return self._properties.get(name, default) def keys(self) -> t.KeysView[str]: """ Return an iterable of all property names. """ return self._properties.keys() def values(self) -> t.ValuesView[t.Any]: """ Return an iterable of all property values. """ return self._properties.values() def items(self) -> t.ItemsView[str, t.Any]: """ Return an iterable of all property name-value pairs. """ return self._properties.items() class EntitySetView(Mapping, t.Generic[_T]): """ View of a set of :class:`.Entity` instances within a :class:`.Graph`. """ def __init__( self, entity_dict: t.Dict[str, _T], legacy_entity_dict: t.Dict[int, _T], ) -> None: self._entity_dict = entity_dict self._legacy_entity_dict = legacy_entity_dict # TODO: 6.0 - remove def __getitem__(self, e_id: t.Union[int, str]) -> _T: # TODO: 6.0 - remove this compatibility shim if isinstance(e_id, (int, float, complex)): deprecation_warn( "Accessing entities by an integer id is deprecated, " "use the new style element_id (str) instead" ) return self._legacy_entity_dict[e_id] return self._entity_dict[e_id] def __len__(self) -> int: return len(self._entity_dict) def __iter__(self) -> t.Iterator[_T]: return iter(self._entity_dict.values()) class Node(Entity): """ Self-contained graph node. """ def __init__( self, graph: Graph, element_id: str, id_: int, n_labels: t.Optional[t.Iterable[str]] = None, properties: t.Optional[t.Dict[str, t.Any]] = None ) -> None: Entity.__init__(self, graph, element_id, id_, properties) self._labels = frozenset(n_labels or ()) def __repr__(self) -> str: return (f"") @property def labels(self) -> t.FrozenSet[str]: """ The set of labels attached to this node. """ return self._labels class Relationship(Entity): """ Self-contained graph relationship. """ def __init__( self, graph: Graph, element_id: str, id_: int, properties: t.Dict[str, t.Any], ) -> None: Entity.__init__(self, graph, element_id, id_, properties) self._start_node: t.Optional[Node] = None self._end_node: t.Optional[Node] = None def __repr__(self) -> str: return (f"") @property def nodes(self) -> t.Tuple[t.Optional[Node], t.Optional[Node]]: """ The pair of nodes which this relationship connects. """ return self._start_node, self._end_node @property def start_node(self) -> t.Optional[Node]: """ The start node of this relationship. """ return self._start_node @property def end_node(self) -> t.Optional[Node]: """ The end node of this relationship. """ return self._end_node @property def type(self) -> str: """ The type name of this relationship. This is functionally equivalent to ``type(relationship).__name__``. """ return type(self).__name__ class Path: """ Self-contained graph path. """ def __init__(self, start_node: Node, *relationships: Relationship) -> None: assert isinstance(start_node, Node) nodes = [start_node] for i, relationship in enumerate(relationships, start=1): assert isinstance(relationship, Relationship) if relationship.start_node == nodes[-1]: nodes.append(t.cast(Node, relationship.end_node)) elif relationship.end_node == nodes[-1]: nodes.append(t.cast(Node, relationship.start_node)) else: raise ValueError("Relationship %d does not connect to the last node" % i) self._nodes = tuple(nodes) self._relationships = relationships def __repr__(self) -> str: return "" % \ (self.start_node, self.end_node, len(self)) def __eq__(self, other: t.Any) -> bool: try: return self.start_node == other.start_node and self.relationships == other.relationships except AttributeError: return False def __ne__(self, other: object) -> bool: return not self.__eq__(other) def __hash__(self): value = hash(self._nodes[0]) for relationship in self._relationships: value ^= hash(relationship) return value def __len__(self) -> int: return len(self._relationships) def __iter__(self) -> t.Iterator[Relationship]: return iter(self._relationships) @property def graph(self) -> Graph: """ The :class:`.Graph` to which this path belongs. """ return self._nodes[0].graph @property def nodes(self) -> t.Tuple[Node, ...]: """ The sequence of :class:`.Node` objects in this path. """ return self._nodes @property def start_node(self) -> Node: """ The first :class:`.Node` in this path. """ return self._nodes[0] @property def end_node(self) -> Node: """ The last :class:`.Node` in this path. """ return self._nodes[-1] @property def relationships(self) -> t.Tuple[Relationship, ...]: """ The sequence of :class:`.Relationship` objects in this path. """ return self._relationships neo4j-python-driver-5.2.1/neo4j/meta.py000066400000000000000000000023711433522662700177020ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. # TODO: 6.0 - remove this file from ._meta import ( deprecated, deprecation_warn, experimental, ExperimentalWarning, get_user_agent, package, version, ) __all__ = [ "package", "version", "get_user_agent", "deprecation_warn", "deprecated", "ExperimentalWarning", "experimental", ] deprecation_warn( "The module 'neo4j.meta' was made internal and will " "no longer be available for import in future versions." "`ExperimentalWarning` can be imported from `neo4j` directly and " "`neo4j.meta.version` is exposed as `neo4j.__version__`.", stack_level=2 ) neo4j-python-driver-5.2.1/neo4j/packstream.py000066400000000000000000000024241433522662700211050ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. # TODO: 6.0 - remove this file from ._codec.packstream.v1 import ( INT64_MAX, INT64_MIN, PACKED_UINT_8, PACKED_UINT_16, Packer, Structure, UnpackableBuffer, UNPACKED_UINT_8, UNPACKED_UINT_16, Unpacker, ) from ._meta import deprecation_warn __all__ = [ "PACKED_UINT_8", "PACKED_UINT_16", "UNPACKED_UINT_8", "UNPACKED_UINT_16", "INT64_MIN", "INT64_MAX", "Structure", "Packer", "Unpacker", "UnpackableBuffer", ] deprecation_warn( "The module 'neo4j.packstream' was made internal and will " "no longer be available for import in future versions.", stack_level=2 ) neo4j-python-driver-5.2.1/neo4j/py.typed000066400000000000000000000000001433522662700200640ustar00rootroot00000000000000neo4j-python-driver-5.2.1/neo4j/routing.py000066400000000000000000000017601433522662700204440ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. # TODO: 6.0 - remove this file from ._meta import deprecation_warn as _deprecation_warn from ._routing import ( OrderedSet, RoutingTable, ) __all__ = [ "OrderedSet", "RoutingTable", ] _deprecation_warn( "The module 'neo4j.routing' was made internal and will " "no longer be available for import in future versions.", stack_level=2 ) neo4j-python-driver-5.2.1/neo4j/spatial/000077500000000000000000000000001433522662700200345ustar00rootroot00000000000000neo4j-python-driver-5.2.1/neo4j/spatial/__init__.py000066400000000000000000000040321433522662700221440ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. """ This module defines spatial data types. """ __all__ = [ "CartesianPoint", "dehydrate_point", "hydrate_point", "Point", "point_type", "WGS84Point", ] from functools import wraps from .._codec.hydration.v1 import spatial as _hydration from .._meta import deprecated from .._spatial import ( CartesianPoint, Point, point_type as _point_type, WGS84Point, ) # TODO: 6.0 remove @deprecated( "hydrate_point is considered an internal function and will be removed in " "a future version" ) def hydrate_point(srid, *coordinates): """ Create a new instance of a Point subclass from a raw set of fields. The subclass chosen is determined by the given SRID; a ValueError will be raised if no such subclass can be found. """ return _hydration.hydrate_point(srid, *coordinates) # TODO: 6.0 remove @deprecated( "hydrate_point is considered an internal function and will be removed in " "a future version" ) @wraps(_hydration.dehydrate_point) def dehydrate_point(value): """ Dehydrator for Point data. :param value: :type value: Point :return: """ return _hydration.dehydrate_point(value) # TODO: 6.0 remove @deprecated( "point_type is considered an internal function and will be removed in " "a future version" ) @wraps(_point_type) def point_type(name, fields, srid_map): return _point_type(name, fields, srid_map) neo4j-python-driver-5.2.1/neo4j/time/000077500000000000000000000000001433522662700173355ustar00rootroot00000000000000neo4j-python-driver-5.2.1/neo4j/time/__init__.py000066400000000000000000002713201433522662700214530ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. """ This module contains the fundamental types used for temporal accounting as well as a number of utility functions. """ from __future__ import annotations import re import typing as t from datetime import ( date, datetime, time, timedelta, timezone, tzinfo as _tzinfo, ) from functools import total_ordering from re import compile as re_compile from time import ( gmtime, mktime, struct_time, ) if t.TYPE_CHECKING: import typing_extensions as te from ._arithmetic import ( nano_add, nano_div, round_half_to_even, symmetric_divmod, ) from ._metaclasses import ( DateTimeType, DateType, TimeType, ) __all__ = [ "MIN_INT64", "MAX_INT64", "MIN_YEAR", "MAX_YEAR", "Duration", "Date", "ZeroDate", "Time", "Midnight", "Midday", "DateTime", "Never", "UnixEpoch", ] MIN_INT64 = -(2 ** 63) MAX_INT64 = (2 ** 63) - 1 #: The smallest year number allowed in a :class:`.Date` or :class:`.DateTime` #: object to be compatible with :class:`datetime.date` and #: :class:`datetime.datetime`. MIN_YEAR: te.Final[int] = 1 #: The largest year number allowed in a :class:`.Date` or :class:`.DateTime` #: object to be compatible with :class:`datetime.date` and #: :class:`datetime.datetime`. MAX_YEAR: te.Final[int] = 9999 DATE_ISO_PATTERN = re_compile(r"^(\d{4})-(\d{2})-(\d{2})$") TIME_ISO_PATTERN = re_compile( r"^(\d{2})(:(\d{2})(:((\d{2})" r"(\.\d*)?))?)?(([+-])(\d{2}):(\d{2})(:((\d{2})(\.\d*)?))?)?$" ) DURATION_ISO_PATTERN = re_compile( r"^P((\d+)Y)?((\d+)M)?((\d+)D)?" r"(T((\d+)H)?((\d+)M)?(((\d+)(\.\d+)?)?S)?)?$" ) NANO_SECONDS = 1000000000 AVERAGE_SECONDS_IN_MONTH = 2629746 AVERAGE_SECONDS_IN_DAY = 86400 FORMAT_F_REPLACE = re.compile(r"(? MAX_YEAR: raise ValueError("Year out of range (%d..%d)" % (MIN_YEAR, MAX_YEAR)) if month < 1 or month > 12: raise ValueError("Month out of range (1..12)") days_in_month = DAYS_IN_MONTH[(year, month)] if day in (days_in_month, -1): return year, month, -1 if day in (days_in_month - 1, -2): return year, month, -2 if day in (days_in_month - 2, -3): return year, month, -3 if 1 <= day <= days_in_month - 3: return year, month, int(day) # TODO improve this error message raise ValueError("Day %d out of range (1..%d, -1, -2 ,-3)" % (day, days_in_month)) class ClockTime(tuple): """ A count of `seconds` and `nanoseconds`. This class can be used to mark a particular point in time, relative to an externally-specified epoch. The `seconds` and `nanoseconds` values provided to the constructor can can have any sign but will be normalized internally into a positive or negative `seconds` value along with a positive `nanoseconds` value between `0` and `999,999,999`. Therefore ``ClockTime(-1, -1)`` is normalized to ``ClockTime(-2, 999999999)``. Note that the structure of a :class:`.ClockTime` object is similar to the ``timespec`` struct in C. """ def __new__(cls, seconds: float = 0, nanoseconds: int = 0) -> ClockTime: seconds, nanoseconds = divmod( int(NANO_SECONDS * seconds) + int(nanoseconds), NANO_SECONDS ) return tuple.__new__(cls, (seconds, nanoseconds)) def __add__(self, other): if isinstance(other, (int, float)): other = ClockTime(other) if isinstance(other, ClockTime): return ClockTime(self.seconds + other.seconds, self.nanoseconds + other.nanoseconds) if isinstance(other, Duration): if other.months or other.days: raise ValueError("Cannot add Duration with months or days") return ClockTime(self.seconds + other.seconds, self.nanoseconds + int(other.nanoseconds)) return NotImplemented def __sub__(self, other): if isinstance(other, (int, float)): other = ClockTime(other) if isinstance(other, ClockTime): return ClockTime(self.seconds - other.seconds, self.nanoseconds - other.nanoseconds) if isinstance(other, Duration): if other.months or other.days: raise ValueError("Cannot subtract Duration with months or days") return ClockTime(self.seconds - other.seconds, self.nanoseconds - int(other.nanoseconds)) return NotImplemented def __repr__(self): return "ClockTime(seconds=%r, nanoseconds=%r)" % self @property def seconds(self): return self[0] @property def nanoseconds(self): return self[1] class Clock: """ Accessor for time values. This class is fulfilled by implementations that subclass :class:`.Clock`. These implementations are contained within the ``neo4j.time.clock_implementations`` module, and are not intended to be accessed directly. Creating a new :class:`.Clock` instance will produce the highest precision clock implementation available. >>> clock = Clock() >>> type(clock) # doctest: +SKIP neo4j.time.clock_implementations.LibCClock >>> clock.local_time() # doctest: +SKIP ClockTime(seconds=1525265942, nanoseconds=506844026) """ __implementations = None def __new__(cls): if cls.__implementations is None: # Find an available clock with the best precision import neo4j.time._clock_implementations cls.__implementations = sorted((clock for clock in Clock.__subclasses__() if clock.available()), key=lambda clock: clock.precision(), reverse=True) if not cls.__implementations: raise RuntimeError("No clock implementations available") instance = object.__new__(cls.__implementations[0]) return instance @classmethod def precision(cls): """ The precision of this clock implementation, represented as a number of decimal places. Therefore, for a nanosecond precision clock, this function returns `9`. """ raise NotImplementedError("No clock implementation selected") @classmethod def available(cls): """ A boolean flag to indicate whether or not this clock implementation is available on this platform. """ raise NotImplementedError("No clock implementation selected") @classmethod def local_offset(cls): """The offset from UTC for local time read from this clock. This may raise OverflowError if not supported, because of platform depending C libraries. :returns: :rtype: :raises OverflowError: """ # Adding and subtracting two days to avoid passing a pre-epoch time to # `mktime`, which can cause a `OverflowError` on some platforms (e.g., # Windows). return ClockTime(-int(mktime(gmtime(172800))) + 172800) def local_time(self): """ Read and return the current local time from this clock, measured relative to the Unix Epoch. This may raise OverflowError if not supported, because of platform depending C libraries. :returns: :rtype: :raises OverflowError: """ return self.utc_time() + self.local_offset() def utc_time(self): """ Read and return the current UTC time from this clock, measured relative to the Unix Epoch. """ raise NotImplementedError("No clock implementation selected") if t.TYPE_CHECKING: # make typechecker believe that Duration subclasses datetime.timedelta # https://github.com/python/typeshed/issues/8409#issuecomment-1197704527 duration_base_class = timedelta else: duration_base_class = object class Duration(t.Tuple[int, int, int, int], # type: ignore[misc] duration_base_class): """A difference between two points in time. A :class:`.Duration` represents the difference between two points in time. Duration objects store a composite value of `months`, `days`, `seconds`, and `nanoseconds`. Unlike :class:`datetime.timedelta` however, days, and seconds/nanoseconds are never interchanged. All values except seconds and nanoseconds are applied separately in calculations (element-wise). A :class:`.Duration` stores four primary instance attributes internally: `months`, `days`, `seconds` and `nanoseconds`. These are maintained as individual values and are immutable. Each of these four attributes can carry its own sign, with the exception of `nanoseconds`, which always has the same sign as `seconds`. The constructor will establish this state, should the duration be initialized with conflicting `seconds` and `nanoseconds` signs. This structure allows the modelling of durations such as `3 months minus 2 days`. To determine if a :class:`Duration` `d` is overflowing the accepted values of the database, first, all `nanoseconds` outside the range -999_999_999 and 999_999_999 are transferred into the seconds field. Then, `months`, `days`, and `seconds` are summed up like so: `months * 2629746 + days * 86400 + d.seconds + d.nanoseconds // 1000000000`. (Like the integer division in Python, this one is to be understood as rounding down rather than towards 0.) This value must be between -(2\\ :sup:`63`) and (2\\ :sup:`63` - 1) inclusive. :param years: will be added times 12 to `months` :param months: will be truncated to :class:`int` (`int(months)`) :param weeks: will be added times 7 to `days` :param days: will be truncated to :class:`int` (`int(days)`) :param hours: will be added times 3,600,000,000,000 to `nanoseconds` :param minutes: will be added times 60,000,000,000 to `nanoseconds` :param seconds: will be added times 1,000,000,000 to `nanoseconds`` :param milliseconds: will be added times 1,000,000 to `nanoseconds` :param microseconds: will be added times 1,000 to `nanoseconds` :param nanoseconds: will be truncated to :class:`int` (`int(nanoseconds)`) :raises ValueError: the components exceed the limits as described above. """ # i64: i64:i64: i32 min: te.Final[Duration] = None # type: ignore """The lowest duration value possible.""" max: te.Final[Duration] = None # type: ignore """The highest duration value possible.""" def __new__( cls, years: float = 0, months: float = 0, weeks: float = 0, days: float = 0, hours: float = 0, minutes: float = 0, seconds: float = 0, milliseconds: float = 0, microseconds: float = 0, nanoseconds: float = 0 ) -> Duration: mo = int(12 * years + months) if mo < MIN_INT64 or mo > MAX_INT64: raise ValueError("Months value out of range") d = int(7 * weeks + days) ns = (int(3600000000000 * hours) + int(60000000000 * minutes) + int(1000000000 * seconds) + int(1000000 * milliseconds) + int(1000 * microseconds) + int(nanoseconds)) s, ns = symmetric_divmod(ns, NANO_SECONDS) avg_total_seconds = (mo * AVERAGE_SECONDS_IN_MONTH + d * AVERAGE_SECONDS_IN_DAY + s - (1 if ns < 0 else 0)) if avg_total_seconds < MIN_INT64 or avg_total_seconds > MAX_INT64: raise ValueError("Duration value out of range: %r", tuple.__repr__((mo, d, s, ns))) return tuple.__new__(cls, (mo, d, s, ns)) def __bool__(self) -> bool: """Falsy if all primary instance attributes are.""" return any(map(bool, self)) __nonzero__ = __bool__ def __add__( # type: ignore[override] self, other: t.Union[Duration, timedelta] ) -> Duration: """Add a :class:`.Duration` or :class:`datetime.timedelta`.""" if isinstance(other, Duration): return Duration( months=self[0] + int(other.months), days=self[1] + int(other.days), seconds=self[2] + int(other.seconds), nanoseconds=self[3] + int(other.nanoseconds) ) if isinstance(other, timedelta): return Duration( months=self[0], days=self[1] + other.days, seconds=self[2] + other.seconds, nanoseconds=self[3] + other.microseconds * 1000 ) return NotImplemented def __sub__(self, other: t.Union[Duration, timedelta]) -> Duration: """Subtract a :class:`.Duration` or :class:`datetime.timedelta`.""" if isinstance(other, Duration): return Duration( months=self[0] - int(other.months), days=self[1] - int(other.days), seconds=self[2] - int(other.seconds), nanoseconds=self[3] - int(other.nanoseconds) ) if isinstance(other, timedelta): return Duration( months=self[0], days=self[1] - other.days, seconds=self[2] - other.seconds, nanoseconds=self[3] - other.microseconds * 1000 ) return NotImplemented def __mul__(self, other: float) -> Duration: # type: ignore[override] """Multiply by an :class:`int` or :class:`float`. The operation is performed element-wise on ``(months, days, nanaoseconds)`` where * years go into months, * weeks go into days, * seconds and all sub-second units go into nanoseconds. Each element will be rounded to the nearest integer (.5 towards even). """ if isinstance(other, (int, float)): return Duration( months=round_half_to_even(self[0] * other), days=round_half_to_even(self[1] * other), nanoseconds=round_half_to_even( self[2] * NANO_SECONDS * other + self[3] * other ) ) return NotImplemented def __floordiv__(self, other: int) -> Duration: # type: ignore[override] """Integer division by an :class:`int`. The operation is performed element-wise on ``(months, days, nanaoseconds)`` where * years go into months, * weeks go into days, * seconds and all sub-second units go into nanoseconds. Each element will be rounded towards -inf. """ if isinstance(other, int): return Duration( months=self[0] // other, days=self[1] // other, nanoseconds=(self[2] * NANO_SECONDS + self[3]) // other ) return NotImplemented def __mod__(self, other: int) -> Duration: # type: ignore[override] """Modulo operation by an :class:`int`. The operation is performed element-wise on ``(months, days, nanaoseconds)`` where * years go into months, * weeks go into days, * seconds and all sub-second units go into nanoseconds. """ if isinstance(other, int): return Duration( months=self[0] % other, days=self[1] % other, nanoseconds=(self[2] * NANO_SECONDS + self[3]) % other ) return NotImplemented def __divmod__( # type: ignore[override] self, other: int ) -> t.Tuple[Duration, Duration]: """Division and modulo operation by an :class:`int`. See :meth:`__floordiv__` and :meth:`__mod__`. """ if isinstance(other, int): return self.__floordiv__(other), self.__mod__(other) return NotImplemented def __truediv__(self, other: float) -> Duration: # type: ignore[override] """Division by an :class:`int` or :class:`float`. The operation is performed element-wise on ``(months, days, nanaoseconds)`` where * years go into months, * weeks go into days, * seconds and all sub-second units go into nanoseconds. Each element will be rounded to the nearest integer (.5 towards even). """ if isinstance(other, (int, float)): return Duration( months=round_half_to_even(self[0] / other), days=round_half_to_even(self[1] / other), nanoseconds=round_half_to_even( self[2] * NANO_SECONDS / other + self[3] / other ) ) return NotImplemented def __pos__(self) -> Duration: """""" return self def __neg__(self) -> Duration: """""" return Duration(months=-self[0], days=-self[1], seconds=-self[2], nanoseconds=-self[3]) def __abs__(self) -> Duration: """""" return Duration(months=abs(self[0]), days=abs(self[1]), seconds=abs(self[2]), nanoseconds=abs(self[3])) def __repr__(self) -> str: """""" return "Duration(months=%r, days=%r, seconds=%r, nanoseconds=%r)" % self def __str__(self) -> str: """""" return self.iso_format() def __copy__(self) -> Duration: return self.__new__(self.__class__, months=self[0], days=self[1], seconds=self[2], nanoseconds=self[3]) def __deepcopy__(self, memo) -> Duration: return self.__copy__() @classmethod def from_iso_format(cls, s: str) -> Duration: """Parse a ISO formatted duration string. Accepted formats (all lowercase letters are placeholders): 'P', a zero length duration 'PyY', y being a number of years 'PmM', m being a number of months 'PdD', d being a number of days Any combination of the above, e.g., 'P25Y1D' for 25 years and 1 day. 'PThH', h being a number of hours 'PTmM', h being a number of minutes 'PTsS', h being a number of seconds 'PTs.sss...S', h being a fractional number of seconds Any combination of the above, e.g. 'PT5H1.2S' for 5 hours and 1.2 seconds. Any combination of all options, e.g. 'P13MT100M' for 13 months and 100 minutes. :param s: String to parse :raises ValueError: if the string does not match the required format. """ match = DURATION_ISO_PATTERN.match(s) if match: ns = 0 if match.group(15): ns = int(match.group(15)[1:10].ljust(9, "0")) return cls( years=int(match.group(2) or 0), months=int(match.group(4) or 0), days=int(match.group(6) or 0), hours=int(match.group(9) or 0), minutes=int(match.group(11) or 0), seconds=int(match.group(14) or 0), nanoseconds=ns ) raise ValueError("Duration string must be in ISO format") fromisoformat = from_iso_format def iso_format(self, sep: str = "T") -> str: """Return the :class:`Duration` as ISO formatted string. :param sep: the separator before the time components. """ parts = [] hours, minutes, seconds, nanoseconds = \ self.hours_minutes_seconds_nanoseconds if hours: parts.append("%dH" % hours) if minutes: parts.append("%dM" % minutes) if nanoseconds: if seconds >= 0 and nanoseconds >= 0: parts.append("%d.%sS" % (seconds, str(nanoseconds).rjust(9, "0").rstrip("0"))) elif seconds <= 0 and nanoseconds <= 0: parts.append("-%d.%sS" % (abs(seconds), str(abs(nanoseconds)).rjust(9, "0").rstrip("0"))) else: assert False and "Please report this issue" elif seconds: parts.append("%dS" % seconds) if parts: parts.insert(0, sep) years, months, days = self.years_months_days if days: parts.insert(0, "%dD" % days) if months: parts.insert(0, "%dM" % months) if years: parts.insert(0, "%dY" % years) if parts: parts.insert(0, "P") return "".join(parts) else: return "PT0S" @property def months(self) -> int: """The months of the :class:`Duration`.""" return self[0] @property def days(self) -> int: """The days of the :class:`Duration`.""" return self[1] @property def seconds(self) -> int: """The seconds of the :class:`Duration`.""" return self[2] @property def nanoseconds(self) -> int: """The nanoseconds of the :class:`Duration`.""" return self[3] @property def years_months_days(self) -> t.Tuple[int, int, int]: """Months and days components as a 3-tuple. t.Tuple of years, months and days. """ years, months = symmetric_divmod(self[0], 12) return years, months, self[1] @property def hours_minutes_seconds_nanoseconds(self) -> t.Tuple[int, int, int, int]: """Seconds and nanoseconds components as a 4-tuple. t.Tuple of hours, minutes, seconds and nanoseconds. """ minutes, seconds = symmetric_divmod(self[2], 60) hours, minutes = symmetric_divmod(minutes, 60) return hours, minutes, seconds, self[3] Duration.min = Duration( # type: ignore seconds=MIN_INT64, nanoseconds=0 ) Duration.max = Duration( # type: ignore seconds=MAX_INT64, nanoseconds=999999999 ) if t.TYPE_CHECKING: # make typechecker believe that Date subclasses datetime.date # https://github.com/python/typeshed/issues/8409#issuecomment-1197704527 date_base_class = date else: date_base_class = object class Date(date_base_class, metaclass=DateType): """Idealized date representation. A :class:`.Date` object represents a date (year, month, and day) in the `proleptic Gregorian Calendar `_. Years between `0001` and `9999` are supported, with additional support for the "zero date" used in some contexts. Each date is based on a proleptic Gregorian ordinal, which models 1 Jan 0001 as `day 1` and counts each subsequent day up to, and including, 31 Dec 9999. The standard `year`, `month` and `day` value of each date is also available. Internally, the day of the month is always stored as-is, with the exception of the last three days of that month. These are always stored as -1, -2 and -3 (counting from the last day). This system allows some temporal arithmetic (particularly adding or subtracting months) to produce a more desirable outcome than would otherwise be produced. Externally, the day number is always the same as would be written on a calendar. :param year: the year. Minimum :attr:`.MIN_YEAR` (0001), maximum :attr:`.MAX_YEAR` (9999). :type year: int :param month: the month. Minimum 1, maximum 12. :type month: int :param day: the day. Minimum 1, maximum :attr:`Date.days_in_month(year, month) `. :type day: int A zero date can also be acquired by passing all zeroes to the :class:`neo4j.time.Date` constructor or by using the :attr:`ZeroDate` constant. """ # CONSTRUCTOR # def __new__(cls, year: int, month: int, day: int) -> Date: if year == month == day == 0: return ZeroDate year, month, day = _normalize_day(year, month, day) ordinal = cls.__calc_ordinal(year, month, day) return cls.__new(ordinal, year, month, day) @classmethod def __new(cls, ordinal: int, year: int, month: int, day: int) -> Date: instance = object.__new__(cls) instance.__ordinal = int(ordinal) instance.__year = int(year) instance.__month = int(month) instance.__day = int(day) return instance # CLASS METHODS # @classmethod def today(cls, tz: t.Optional[_tzinfo] = None) -> Date: """Get the current date. :param tz: timezone or None to get the local :class:`.Date`. :raises OverflowError: if the timestamp is out of the range of values supported by the platform C localtime() function. It’s common for this to be restricted to years from 1970 through 2038. """ if tz is None: return cls.from_clock_time(Clock().local_time(), UnixEpoch) else: return ( DateTime.utc_now() .replace(tzinfo=timezone.utc).astimezone(tz) .date() ) @classmethod def utc_today(cls) -> Date: """Get the current date as UTC local date.""" return cls.from_clock_time(Clock().utc_time(), UnixEpoch) @classmethod def from_timestamp( cls, timestamp: float, tz: t.Optional[_tzinfo] = None ) -> Date: """:class:`.Date` from a time stamp (seconds since unix epoch). :param timestamp: the unix timestamp (seconds since unix epoch). :param tz: timezone. Set to None to create a local :class:`.Date`. :raises OverflowError: if the timestamp is out of the range of values supported by the platform C localtime() function. It’s common for this to be restricted to years from 1970 through 2038. """ return cls.from_native(datetime.fromtimestamp(timestamp, tz)) @classmethod def utc_from_timestamp(cls, timestamp: float) -> Date: """:class:`.Date` from a time stamp (seconds since unix epoch). :returns: the `Date` as local date `Date` in UTC. """ return cls.from_clock_time((timestamp, 0), UnixEpoch) @classmethod def from_ordinal(cls, ordinal: int) -> Date: """ The :class:`.Date` that corresponds to the proleptic Gregorian ordinal. `0001-01-01` has ordinal 1 and `9999-12-31` has ordinal 3,652,059. Values outside of this range trigger a :exc:`ValueError`. The corresponding instance method for the reverse date-to-ordinal transformation is :meth:`.to_ordinal`. The ordinal 0 has a special semantic and will return :attr:`ZeroDate`. :raises ValueError: if the ordinal is outside the range [0, 3652059] (both values included). """ if ordinal == 0: return ZeroDate if ordinal >= 736695: year = 2018 # Project release year month = 1 day = int(ordinal - 736694) elif ordinal >= 719163: year = 1970 # Unix epoch month = 1 day = int(ordinal - 719162) else: year = 1 month = 1 day = int(ordinal) if day < 1 or day > 3652059: # Note: this requires a maximum of 22 bits for storage # Could be transferred in 3 bytes. raise ValueError("Ordinal out of range (1..3652059)") if year < MIN_YEAR or year > MAX_YEAR: raise ValueError("Year out of range (%d..%d)" % (MIN_YEAR, MAX_YEAR)) days_in_year = DAYS_IN_YEAR[year] while day > days_in_year: day -= days_in_year year += 1 days_in_year = DAYS_IN_YEAR[year] days_in_month = DAYS_IN_MONTH[(year, month)] while day > days_in_month: day -= days_in_month month += 1 days_in_month = DAYS_IN_MONTH[(year, month)] year, month, day = _normalize_day(year, month, day) return cls.__new(ordinal, year, month, day) @classmethod def parse(cls, s: str) -> Date: """Parse a string to produce a :class:`.Date`. Accepted formats: 'Y-M-D' :param s: the string to be parsed. :raises ValueError: if the string could not be parsed. """ try: numbers = list(map(int, s.split("-"))) except (ValueError, AttributeError): raise ValueError("Date string must be in format YYYY-MM-DD") else: if len(numbers) == 3: return cls(*numbers) raise ValueError("Date string must be in format YYYY-MM-DD") @classmethod def from_iso_format(cls, s: str) -> Date: """Parse a ISO formatted Date string. Accepted formats: 'YYYY-MM-DD' :param s: the string to be parsed. :raises ValueError: if the string could not be parsed. """ m = DATE_ISO_PATTERN.match(s) if m: year = int(m.group(1)) month = int(m.group(2)) day = int(m.group(3)) return cls(year, month, day) raise ValueError("Date string must be in format YYYY-MM-DD") @classmethod def from_native(cls, d: date) -> Date: """Convert from a native Python `datetime.date` value. :param d: the date to convert. """ return Date.from_ordinal(d.toordinal()) @classmethod def from_clock_time( cls, clock_time: t.Union[ClockTime, t.Tuple[float, int]], epoch: DateTime ) -> Date: """Convert from a ClockTime relative to a given epoch. :param clock_time: the clock time as :class:`.ClockTime` or as tuple of (seconds, nanoseconds) :param epoch: the epoch to which `clock_time` is relative """ try: clock_time = ClockTime(*clock_time) except (TypeError, ValueError): raise ValueError("Clock time must be a 2-tuple of (s, ns)") else: ordinal = clock_time.seconds // 86400 return Date.from_ordinal(ordinal + epoch.date().to_ordinal()) @classmethod def is_leap_year(cls, year: int) -> bool: """Indicates whether or not `year` is a leap year. :param year: the year to look up :raises ValueError: if `year` is out of range: :attr:`MIN_YEAR` <= year <= :attr:`MAX_YEAR` """ if year < MIN_YEAR or year > MAX_YEAR: raise ValueError("Year out of range (%d..%d)" % (MIN_YEAR, MAX_YEAR)) return IS_LEAP_YEAR[year] @classmethod def days_in_year(cls, year: int) -> int: """Return the number of days in `year`. :param year: the year to look up :raises ValueError: if `year` is out of range: :attr:`MIN_YEAR` <= year <= :attr:`MAX_YEAR` """ if year < MIN_YEAR or year > MAX_YEAR: raise ValueError("Year out of range (%d..%d)" % (MIN_YEAR, MAX_YEAR)) return DAYS_IN_YEAR[year] @classmethod def days_in_month(cls, year: int, month: int) -> int: """Return the number of days in `month` of `year`. :param year: the year to look up :param month: the month to look up :raises ValueError: if `year` or `month` is out of range: :attr:`MIN_YEAR` <= year <= :attr:`MAX_YEAR`; 1 <= year <= 12 """ if year < MIN_YEAR or year > MAX_YEAR: raise ValueError("Year out of range (%d..%d)" % (MIN_YEAR, MAX_YEAR)) if month < 1 or month > 12: raise ValueError("Month out of range (1..12)") return DAYS_IN_MONTH[(year, month)] @classmethod def __calc_ordinal(cls, year, month, day): if day < 0: day = cls.days_in_month(year, month) + int(day) + 1 # The built-in date class does this faster than a # long-hand pure Python algorithm could return date(year, month, day).toordinal() # CLASS METHOD ALIASES # if t.TYPE_CHECKING: @classmethod def fromisoformat(cls, s: str) -> Date: ... @classmethod def fromordinal(cls, ordinal: int) -> Date: ... @classmethod def fromtimestamp( cls, timestamp: float, tz: t.Optional[_tzinfo] = None ) -> Date: ... @classmethod def utcfromtimestamp(cls, timestamp: float) -> Date: ... # CLASS ATTRIBUTES # min: te.Final[Date] = None # type: ignore """The earliest date value possible.""" max: te.Final[Date] = None # type: ignore """The latest date value possible.""" resolution: te.Final[Duration] = None # type: ignore """The minimum resolution supported.""" # INSTANCE ATTRIBUTES # __ordinal = 0 __year = 0 __month = 0 __day = 0 @property def year(self) -> int: """The year of the date. :type: int """ return self.__year @property def month(self) -> int: """The month of the date. :type: int """ return self.__month @property def day(self) -> int: """The day of the date. :type: int """ if self.__day == 0: return 0 if self.__day >= 1: return self.__day return self.days_in_month(self.__year, self.__month) + self.__day + 1 @property def year_month_day(self) -> t.Tuple[int, int, int]: """3-tuple of (year, month, day) describing the date. """ return self.year, self.month, self.day @property def year_week_day(self) -> t.Tuple[int, int, int]: """3-tuple of (year, week_of_year, day_of_week) describing the date. `day_of_week` will be 1 for Monday and 7 for Sunday. """ ordinal = self.__ordinal year = self.__year def day_of_week(o): return ((o - 1) % 7) + 1 def iso_week_1(y): j4 = Date(y, 1, 4) return j4 + Duration(days=(1 - day_of_week(j4.to_ordinal()))) if ordinal >= Date(year, 12, 29).to_ordinal(): week1 = iso_week_1(year + 1) if ordinal < week1.to_ordinal(): week1 = iso_week_1(year) else: year += 1 else: week1 = iso_week_1(year) if ordinal < week1.to_ordinal(): year -= 1 week1 = iso_week_1(year) return (year, int((ordinal - week1.to_ordinal()) / 7 + 1), day_of_week(ordinal)) @property def year_day(self) -> t.Tuple[int, int]: """2-tuple of (year, day_of_the_year) describing the date. This is the number of the day relative to the start of the year, with `1 Jan` corresponding to `1`. """ return (self.__year, self.toordinal() - Date(self.__year, 1, 1).toordinal() + 1) # OPERATIONS # def __hash__(self): """""" return hash(self.toordinal()) def __eq__(self, other: object) -> bool: """``==`` comparison with :class:`.Date` or :class:`datetime.date`.""" if isinstance(other, (Date, date)): return self.toordinal() == other.toordinal() return False def __ne__(self, other: object) -> bool: """``!=`` comparison with :class:`.Date` or :class:`datetime.date`.""" return not self.__eq__(other) def __lt__(self, other: t.Union[Date, date]) -> bool: """``<`` comparison with :class:`.Date` or :class:`datetime.date`.""" if isinstance(other, (Date, date)): return self.toordinal() < other.toordinal() raise TypeError("'<' not supported between instances of 'Date' and %r" % type(other).__name__) def __le__(self, other: t.Union[Date, date]) -> bool: """``<=`` comparison with :class:`.Date` or :class:`datetime.date`.""" if isinstance(other, (Date, date)): return self.toordinal() <= other.toordinal() raise TypeError("'<=' not supported between instances of 'Date' and %r" % type(other).__name__) def __ge__(self, other: t.Union[Date, date]) -> bool: """``>=`` comparison with :class:`.Date` or :class:`datetime.date`.""" if isinstance(other, (Date, date)): return self.toordinal() >= other.toordinal() raise TypeError("'>=' not supported between instances of 'Date' and %r" % type(other).__name__) def __gt__(self, other: t.Union[Date, date]) -> bool: """``>`` comparison with :class:`.Date` or :class:`datetime.date`.""" if isinstance(other, (Date, date)): return self.toordinal() > other.toordinal() raise TypeError("'>' not supported between instances of 'Date' and %r" % type(other).__name__) def __add__(self, other: Duration) -> Date: # type: ignore[override] """Add a :class:`.Duration`. :raises ValueError: if the added duration has a time component. """ def add_months(d, months): years, months = symmetric_divmod(months, 12) year = d.__year + years month = d.__month + months while month > 12: year += 1 month -= 12 while month < 1: year -= 1 month += 12 d.__year = year d.__month = month def add_days(d, days): assert 1 <= d.__day <= 28 or -28 <= d.__day <= -1 if d.__day >= 1: new_days = d.__day + days if 1 <= new_days <= 27: d.__day = new_days return d0 = Date.from_ordinal(d.__ordinal + days) d.__year, d.__month, d.__day = d0.__year, d0.__month, d0.__day if isinstance(other, Duration): if other.seconds or other.nanoseconds: raise ValueError("Cannot add a Duration with seconds or " "nanoseconds to a Date") if other.months == other.days == 0: return self new_date = self.replace() # Add days before months as the former sometimes # requires the current ordinal to be correct. if other.days: add_days(new_date, other.days) if other.months: add_months(new_date, other.months) new_date.__ordinal = self.__calc_ordinal(new_date.year, new_date.month, new_date.day) return new_date return NotImplemented @t.overload # type: ignore[override] def __sub__(self, other: t.Union[Date, date]) -> Duration: ... @t.overload def __sub__(self, other: Duration) -> Date: ... def __sub__(self, other): """Subtract a :class:`.Date` or :class:`.Duration`. :returns: If a :class:`.Date` is subtracted, the time between the two dates is returned as :class:`.Duration`. If a :class:`.Duration` is subtracted, a new :class:`.Date` is returned. :rtype: Date or Duration :raises ValueError: if the added duration has a time component. """ if isinstance(other, (Date, date)): return Duration(days=(self.toordinal() - other.toordinal())) try: return self.__add__(-other) except TypeError: return NotImplemented def __copy__(self) -> Date: return self.__new(self.__ordinal, self.__year, self.__month, self.__day) def __deepcopy__(self, *args, **kwargs) -> Date: return self.__copy__() # INSTANCE METHODS # if t.TYPE_CHECKING: def replace( self, year: int = ..., month: int = ..., day: int = ..., **kwargs: object ) -> Date: ... else: def replace(self, **kwargs) -> Date: """Return a :class:`.Date` with one or more components replaced. :Keyword Arguments: * **year** (`int`): overwrite the year - default: `self.year` * **month** (`int`): overwrite the month - default: `self.month` * **day** (`int`): overwrite the day - default: `self.day` """ return Date(kwargs.get("year", self.__year), kwargs.get("month", self.__month), kwargs.get("day", self.__day)) def time_tuple(self) -> struct_time: """Convert the date to :class:`time.struct_time`.""" _, _, day_of_week = self.year_week_day _, day_of_year = self.year_day return struct_time((self.year, self.month, self.day, 0, 0, 0, day_of_week - 1, day_of_year, -1)) def to_ordinal(self) -> int: """The date's proleptic Gregorian ordinal. The corresponding class method for the reverse ordinal-to-date transformation is :meth:`.Date.from_ordinal`. """ return self.__ordinal def to_clock_time(self, epoch: t.Union[Date, DateTime]) -> ClockTime: """Convert the date to :class:`ClockTime` relative to `epoch`. :param epoch: the epoch to which the date is relative """ try: return ClockTime(86400 * (self.to_ordinal() - epoch.to_ordinal())) except AttributeError: raise TypeError("Epoch has no ordinal value") def to_native(self) -> date: """Convert to a native Python :class:`datetime.date` value. """ return date.fromordinal(self.to_ordinal()) def weekday(self) -> int: """The day of the week where Monday is 0 and Sunday is 6.""" return self.year_week_day[2] - 1 def iso_weekday(self) -> int: """The day of the week where Monday is 1 and Sunday is 7.""" return self.year_week_day[2] def iso_calendar(self) -> t.Tuple[int, int, int]: """Alias for :attr:`.year_week_day`""" return self.year_week_day def iso_format(self) -> str: """Return the :class:`.Date` as ISO formatted string.""" if self.__ordinal == 0: return "0000-00-00" return "%04d-%02d-%02d" % self.year_month_day def __repr__(self) -> str: """""" if self.__ordinal == 0: return "neo4j.time.ZeroDate" return "neo4j.time.Date(%r, %r, %r)" % self.year_month_day def __str__(self) -> str: """""" return self.iso_format() def __format__(self, format_spec): """""" if not format_spec: return self.iso_format() format_spec = FORMAT_F_REPLACE.sub("000000000", format_spec) return self.to_native().__format__(format_spec) # INSTANCE METHOD ALIASES # def __getattr__(self, name): """ Map standard library attribute names to local attribute names, for compatibility. """ try: return { "isocalendar": self.iso_calendar, "isoformat": self.iso_format, "isoweekday": self.iso_weekday, "strftime": self.__format__, "toordinal": self.to_ordinal, "timetuple": self.time_tuple, }[name] except KeyError: raise AttributeError("Date has no attribute %r" % name) if t.TYPE_CHECKING: def iso_calendar(self) -> t.Tuple[int, int, int]: ... isoformat = iso_format isoweekday = iso_weekday strftime = __format__ toordinal = to_ordinal timetuple = time_tuple Date.min = Date.from_ordinal(1) # type: ignore Date.max = Date.from_ordinal(3652059) # type: ignore Date.resolution = Duration(days=1) # type: ignore #: A :class:`neo4j.time.Date` instance set to `0000-00-00`. #: This has an ordinal value of `0`. ZeroDate = object.__new__(Date) if t.TYPE_CHECKING: # make typechecker believe that Time subclasses datetime.time # https://github.com/python/typeshed/issues/8409#issuecomment-1197704527 time_base_class = time else: time_base_class = object class Time(time_base_class, metaclass=TimeType): """Time of day. The :class:`.Time` class is a nanosecond-precision drop-in replacement for the standard library :class:`datetime.time` class. A high degree of API compatibility with the standard library classes is provided. :class:`neo4j.time.Time` objects introduce the concept of ``ticks``. This is simply a count of the number of nanoseconds since midnight, in many ways analogous to the :class:`neo4j.time.Date` ordinal. `ticks` values are integers, with a minimum value of `0` and a maximum of `86_399_999_999_999`. Local times are represented by :class:`.Time` with no ``tzinfo``. :param hour: the hour of the time. Must be in range 0 <= hour < 24. :param minute: the minute of the time. Must be in range 0 <= minute < 60. :param second: the second of the time. Must be in range 0 <= second < 60. :param nanosecond: the nanosecond of the time. Must be in range 0 <= nanosecond < 999999999. :param tzinfo: timezone or None to get a local :class:`.Time`. :raises ValueError: if one of the parameters is out of range. ..versionchanged:: 5.0 The parameter ``second`` no longer accepts :class:`float` values. """ # CONSTRUCTOR # def __new__( cls, hour: int = 0, minute: int = 0, second: int = 0, nanosecond: int = 0, tzinfo: t.Optional[_tzinfo] = None ) -> Time: hour, minute, second, nanosecond = cls.__normalize_nanosecond( hour, minute, second, nanosecond ) ticks = (3600000000000 * hour + 60000000000 * minute + 1000000000 * second + nanosecond) return cls.__new(ticks, hour, minute, second, nanosecond, tzinfo) @classmethod def __new(cls, ticks, hour, minute, second, nanosecond, tzinfo): instance = object.__new__(cls) instance.__ticks = int(ticks) instance.__hour = int(hour) instance.__minute = int(minute) instance.__second = int(second) instance.__nanosecond = int(nanosecond) instance.__tzinfo = tzinfo return instance # CLASS METHODS # @classmethod def now(cls, tz: t.Optional[_tzinfo] = None) -> Time: """Get the current time. :param tz: optional timezone :raises OverflowError: if the timestamp is out of the range of values supported by the platform C localtime() function. It’s common for this to be restricted to years from 1970 through 2038. """ if tz is None: return cls.from_clock_time(Clock().local_time(), UnixEpoch) else: return ( DateTime.utc_now() .replace(tzinfo=timezone.utc).astimezone(tz) .timetz() ) @classmethod def utc_now(cls) -> Time: """Get the current time as UTC local time.""" return cls.from_clock_time(Clock().utc_time(), UnixEpoch) @classmethod def from_iso_format(cls, s: str) -> Time: """Parse a ISO formatted time string. Accepted formats: Local times: 'hh' 'hh:mm' 'hh:mm:ss' 'hh:mm:ss.ssss...' Times with timezones (UTC offset): '+hh:mm' '+hh:mm:ss' '+hh:mm:ss.ssss....' '-hh:mm' '-hh:mm:ss' '-hh:mm:ss.ssss....' Where the UTC offset will only respect hours and minutes. Seconds and sub-seconds are ignored. :param s: String to parse :raises ValueError: if the string does not match the required format. """ from pytz import FixedOffset # type: ignore m = TIME_ISO_PATTERN.match(s) if m: hour = int(m.group(1)) minute = int(m.group(3) or 0) second = int(m.group(6) or 0) nanosecond = m.group(7) if nanosecond: nanosecond = int(nanosecond[1:10].ljust(9, "0")) else: nanosecond = 0 if m.group(8) is None: return cls(hour, minute, second, nanosecond) else: offset_multiplier = 1 if m.group(9) == "+" else -1 offset_hour = int(m.group(10)) offset_minute = int(m.group(11)) # pytz only supports offsets of minute resolution # so we can ignore this part # offset_second = float(m.group(13) or 0.0) offset = 60 * offset_hour + offset_minute return cls(hour, minute, second, nanosecond, tzinfo=FixedOffset(offset_multiplier * offset)) raise ValueError("Time string is not in ISO format") @classmethod def from_ticks(cls, ticks: int, tz: t.Optional[_tzinfo] = None) -> Time: """Create a time from ticks (nanoseconds since midnight). :param ticks: nanoseconds since midnight :param tz: optional timezone :raises ValueError: if ticks is out of bounds (0 <= ticks < 86400000000000) ..versionchanged:: 5.0 The parameter ``ticks`` no longer accepts :class:`float` values but only :class:`int`. It's now nanoseconds since midnight instead of seconds. """ if not isinstance(ticks, int): raise TypeError("Ticks must be int") if 0 <= ticks < 86400000000000: second, nanosecond = divmod(ticks, NANO_SECONDS) minute, second = divmod(second, 60) hour, minute = divmod(minute, 60) return cls.__new(ticks, hour, minute, second, nanosecond, tz) raise ValueError("Ticks out of range (0..86400000000000)") @classmethod def from_native(cls, t: time) -> Time: """Convert from a native Python :class:`datetime.time` value. :param t: time to convert from """ nanosecond = t.microsecond * 1000 return Time(t.hour, t.minute, t.second, nanosecond, t.tzinfo) @classmethod def from_clock_time( cls, clock_time: t.Union[ClockTime, t.Tuple[float, int]], epoch: DateTime ) -> Time: """Convert from a :class:`.ClockTime` relative to a given epoch. This method, in contrast to most others of this package, assumes days of exactly 24 hours. :param clock_time: the clock time as :class:`.ClockTime` or as tuple of (seconds, nanoseconds) :param epoch: the epoch to which `clock_time` is relative """ clock_time = ClockTime(*clock_time) ts = clock_time.seconds % 86400 nanoseconds = int(NANO_SECONDS * ts + clock_time.nanoseconds) ticks = (epoch.time().ticks + nanoseconds) % (86400 * NANO_SECONDS) return Time.from_ticks(ticks) @classmethod def __normalize_hour(cls, hour): hour = int(hour) if 0 <= hour < 24: return hour raise ValueError("Hour out of range (0..23)") @classmethod def __normalize_minute(cls, hour, minute): hour = cls.__normalize_hour(hour) minute = int(minute) if 0 <= minute < 60: return hour, minute raise ValueError("Minute out of range (0..59)") @classmethod def __normalize_second(cls, hour, minute, second): hour, minute = cls.__normalize_minute(hour, minute) second = int(second) if 0 <= second < 60: return hour, minute, second raise ValueError("Second out of range (0..59)") @classmethod def __normalize_nanosecond(cls, hour, minute, second, nanosecond): hour, minute, second = cls.__normalize_second(hour, minute, second) if 0 <= nanosecond < NANO_SECONDS: return hour, minute, second, nanosecond raise ValueError("Nanosecond out of range (0..%s)" % (NANO_SECONDS - 1)) # CLASS METHOD ALIASES # if t.TYPE_CHECKING: @classmethod def from_iso_format(cls, s: str) -> Time: ... @classmethod def utc_now(cls) -> Time: ... # CLASS ATTRIBUTES # min: te.Final[Time] = None # type: ignore """The earliest time value possible.""" max: te.Final[Time] = None # type: ignore """The latest time value possible.""" resolution: te.Final[Duration] = None # type: ignore """The minimum resolution supported.""" # INSTANCE ATTRIBUTES # __ticks = 0 __hour = 0 __minute = 0 __second = 0 __nanosecond = 0 __tzinfo = None @property def ticks(self) -> int: """The total number of nanoseconds since midnight. .. versionchanged:: 5.0 The property's type changed from :class:`float` to :class:`int`. It's now nanoseconds since midnight instead of seconds. """ return self.__ticks @property def hour(self) -> int: """The hours of the time.""" return self.__hour @property def minute(self) -> int: """The minutes of the time.""" return self.__minute @property def second(self) -> int: """The seconds of the time. .. versionchanged:: 4.4 The property's type changed from :class:`float` to :class:`decimal.Decimal` to mitigate rounding issues. .. versionchanged:: 5.0 The property's type changed from :class:`decimal.Decimal` to :class:`int`. It does not longer cary sub-second information. Use `attr:`nanosecond` instead. """ return self.__second @property def nanosecond(self) -> int: """The nanoseconds of the time.""" return self.__nanosecond @property def hour_minute_second_nanosecond(self) -> t.Tuple[int, int, int, int]: """The time as a tuple of (hour, minute, second, nanosecond).""" return self.__hour, self.__minute, self.__second, self.__nanosecond @property def tzinfo(self) -> t.Optional[_tzinfo]: """The timezone of this time.""" return self.__tzinfo # OPERATIONS # def _get_both_normalized_ticks(self, other: object, strict=True): if (isinstance(other, (time, Time)) and ((self.utc_offset() is None) ^ (other.utcoffset() is None))): if strict: raise TypeError("can't compare offset-naive and offset-aware " "times") else: return None, None other_ticks: int if isinstance(other, Time): other_ticks = other.__ticks elif isinstance(other, time): other_ticks = int(3600000000000 * other.hour + 60000000000 * other.minute + NANO_SECONDS * other.second + 1000 * other.microsecond) else: return None, None assert isinstance(other, (Time, time)) utc_offset: t.Optional[timedelta] = other.utcoffset() if utc_offset is not None: other_ticks -= int(utc_offset.total_seconds() * NANO_SECONDS) self_ticks = self.__ticks utc_offset = self.utc_offset() if utc_offset is not None: self_ticks -= int(utc_offset.total_seconds() * NANO_SECONDS) return self_ticks, other_ticks def __hash__(self): """""" if self.__nanosecond % 1000 == 0: return hash(self.to_native()) self_ticks = self.__ticks if self.utc_offset() is not None: self_ticks -= self.utc_offset().total_seconds() * NANO_SECONDS return hash(self_ticks) def __eq__(self, other: object) -> bool: """`==` comparison with :class:`.Time` or :class:`datetime.time`.""" self_ticks, other_ticks = self._get_both_normalized_ticks(other, strict=False) if self_ticks is None: return False return self_ticks == other_ticks def __ne__(self, other: object) -> bool: """`!=` comparison with :class:`.Time` or :class:`datetime.time`.""" return not self.__eq__(other) def __lt__(self, other: t.Union[Time, time]) -> bool: """`<` comparison with :class:`.Time` or :class:`datetime.time`.""" self_ticks, other_ticks = self._get_both_normalized_ticks(other) if self_ticks is None: return NotImplemented return self_ticks < other_ticks def __le__(self, other: t.Union[Time, time]) -> bool: """`<=` comparison with :class:`.Time` or :class:`datetime.time`.""" self_ticks, other_ticks = self._get_both_normalized_ticks(other) if self_ticks is None: return NotImplemented return self_ticks <= other_ticks def __ge__(self, other: t.Union[Time, time]) -> bool: """`>=` comparison with :class:`.Time` or :class:`datetime.time`.""" self_ticks, other_ticks = self._get_both_normalized_ticks(other) if self_ticks is None: return NotImplemented return self_ticks >= other_ticks def __gt__(self, other: t.Union[Time, time]) -> bool: """`>` comparison with :class:`.Time` or :class:`datetime.time`.""" self_ticks, other_ticks = self._get_both_normalized_ticks(other) if self_ticks is None: return NotImplemented return self_ticks > other_ticks def __copy__(self) -> Time: return self.__new(self.__ticks, self.__hour, self.__minute, self.__second, self.__nanosecond, self.__tzinfo) def __deepcopy__(self, *args, **kwargs) -> Time: return self.__copy__() # INSTANCE METHODS # if t.TYPE_CHECKING: def replace( # type: ignore[override] self, hour: int = ..., minute: int = ..., second: int = ..., nanosecond: int = ..., tzinfo: t.Optional[_tzinfo] = ..., **kwargs: object ) -> Time: ... else: def replace(self, **kwargs) -> Time: """Return a :class:`.Time` with one or more components replaced. :Keyword Arguments: * **hour** (`int`): overwrite the hour - default: `self.hour` * **minute** (`int`): overwrite the minute - default: `self.minute` * **second** (`int`): overwrite the second - default: `int(self.second)` * **nanosecond** (`int`): overwrite the nanosecond - default: `self.nanosecond` * **tzinfo** (`datetime.tzinfo` or `None`): overwrite the timezone - default: `self.tzinfo` """ return Time(hour=kwargs.get("hour", self.__hour), minute=kwargs.get("minute", self.__minute), second=kwargs.get("second", self.__second), nanosecond=kwargs.get("nanosecond", self.__nanosecond), tzinfo=kwargs.get("tzinfo", self.__tzinfo)) def _utc_offset(self, dt=None): if self.tzinfo is None: return None try: value = self.tzinfo.utcoffset(dt) except TypeError: # For timezone implementations not compatible with the custom # datetime implementations, we can't do better than this. value = self.tzinfo.utcoffset(dt.to_native()) if value is None: return None if isinstance(value, timedelta): s = value.total_seconds() if not (-86400 < s < 86400): raise ValueError("utcoffset must be less than a day") if s % 60 != 0 or value.microseconds != 0: raise ValueError("utcoffset must be a whole number of minutes") return value raise TypeError("utcoffset must be a timedelta") def utc_offset(self) -> t.Optional[timedelta]: """Return the UTC offset of this time. :return: None if this is a local time (:attr:`.tzinfo` is None), else returns `self.tzinfo.utcoffset(self)`. :raises ValueError: if `self.tzinfo.utcoffset(self)` is not None and a :class:`timedelta` with a magnitude greater equal 1 day or that is not a whole number of minutes. :raises TypeError: if `self.tzinfo.utcoffset(self)` does return anything but None or a :class:`datetime.timedelta`. """ return self._utc_offset() def dst(self) -> t.Optional[timedelta]: """Get the daylight saving time adjustment (DST). :return: None if this is a local time (:attr:`.tzinfo` is None), else returns `self.tzinfo.dst(self)`. :raises ValueError: if `self.tzinfo.dst(self)` is not None and a :class:`timedelta` with a magnitude greater equal 1 day or that is not a whole number of minutes. :raises TypeError: if `self.tzinfo.dst(self)` does return anything but None or a :class:`datetime.timedelta`. """ if self.tzinfo is None: return None try: value = self.tzinfo.dst(self) # type: ignore except TypeError: # For timezone implementations not compatible with the custom # datetime implementations, we can't do better than this. value = self.tzinfo.dst(self.to_native()) # type: ignore if value is None: return None if isinstance(value, timedelta): if value.days != 0: raise ValueError("dst must be less than a day") if value.seconds % 60 != 0 or value.microseconds != 0: raise ValueError("dst must be a whole number of minutes") return value raise TypeError("dst must be a timedelta") def tzname(self) -> t.Optional[str]: """Get the name of the :class:`.Time`'s timezone. :returns: None if the time is local (i.e., has no timezone), else return `self.tzinfo.tzname(self)` """ if self.tzinfo is None: return None try: return self.tzinfo.tzname(self) # type: ignore except TypeError: # For timezone implementations not compatible with the custom # datetime implementations, we can't do better than this. return self.tzinfo.tzname(self.to_native()) # type: ignore def to_clock_time(self) -> ClockTime: """Convert to :class:`.ClockTime`.""" seconds, nanoseconds = divmod(self.ticks, NANO_SECONDS) return ClockTime(seconds, nanoseconds) def to_native(self) -> time: """Convert to a native Python `datetime.time` value. This conversion is lossy as the native time implementation only supports a resolution of microseconds instead of nanoseconds. """ h, m, s, ns = self.hour_minute_second_nanosecond µs = round_half_to_even(ns / 1000) tz = self.tzinfo return time(h, m, s, µs, tz) def iso_format(self) -> str: """Return the :class:`.Time` as ISO formatted string.""" s = "%02d:%02d:%02d.%09d" % self.hour_minute_second_nanosecond offset = self.utc_offset() if offset is not None: s += "%+03d:%02d" % divmod(offset.total_seconds() // 60, 60) return s def __repr__(self) -> str: """""" if self.tzinfo is None: return "neo4j.time.Time(%r, %r, %r, %r)" % \ self.hour_minute_second_nanosecond else: return "neo4j.time.Time(%r, %r, %r, %r, tzinfo=%r)" % \ (self.hour_minute_second_nanosecond + (self.tzinfo,)) def __str__(self) -> str: """""" return self.iso_format() def __format__(self, format_spec): """""" if not format_spec: return self.iso_format() format_spec = FORMAT_F_REPLACE.sub(f"{self.__nanosecond:09}", format_spec) return self.to_native().__format__(format_spec) # INSTANCE METHOD ALIASES # def __getattr__(self, name): """Map standard library attribute names to local attribute names, for compatibility. """ try: return { "isoformat": self.iso_format, "utcoffset": self.utc_offset, }[name] except KeyError: raise AttributeError("Date has no attribute %r" % name) if t.TYPE_CHECKING: def isoformat(self) -> str: # type: ignore[override] ... utcoffset = utc_offset Time.min = Time( # type: ignore hour=0, minute=0, second=0, nanosecond=0 ) Time.max = Time( # type: ignore hour=23, minute=59, second=59, nanosecond=999999999 ) Time.resolution = Duration( # type: ignore nanoseconds=1 ) #: A :class:`.Time` instance set to `00:00:00`. #: This has a :attr:`.ticks` value of `0`. Midnight: te.Final[Time] = Time.min #: A :class:`.Time` instance set to `12:00:00`. #: This has a :attr:`.ticks` value of `43200000000000`. Midday: te.Final[Time] = Time(hour=12) if t.TYPE_CHECKING: # make typechecker believe that DateTime subclasses datetime.datetime # https://github.com/python/typeshed/issues/8409#issuecomment-1197704527 date_time_base_class = datetime else: date_time_base_class = object @total_ordering class DateTime(date_time_base_class, metaclass=DateTimeType): """A point in time represented as a date and a time. The :class:`.DateTime` class is a nanosecond-precision drop-in replacement for the standard library :class:`datetime.datetime` class. As such, it contains both :class:`.Date` and :class:`.Time` information and draws functionality from those individual classes. A :class:`.DateTime` object is fully compatible with the Python time zone library `pytz `_. Functions such as `normalize` and `localize` can be used in the same way as they are with the standard library classes. Regular construction of a :class:`.DateTime` object requires at least the `year`, `month` and `day` arguments to be supplied. The optional `hour`, `minute` and `second` arguments default to zero and `tzinfo` defaults to :const:`None`. `year`, `month`, and `day` are passed to the constructor of :class:`.Date`. `hour`, `minute`, `second`, `nanosecond`, and `tzinfo` are passed to the constructor of :class:`.Time`. See their documentation for more details. >>> dt = DateTime(2018, 4, 30, 12, 34, 56, 789123456); dt neo4j.time.DateTime(2018, 4, 30, 12, 34, 56, 789123456) >>> dt.second 56.789123456 """ __date: Date __time: Time # CONSTRUCTOR # def __new__( cls, year: int, month: int, day: int, hour: int = 0, minute: int = 0, second: int = 0, nanosecond: int = 0, tzinfo: t.Optional[_tzinfo] = None ) -> DateTime: return cls.combine(Date(year, month, day), Time(hour, minute, second, nanosecond, tzinfo)) # CLASS METHODS # @classmethod def now(cls, tz: t.Optional[_tzinfo] = None) -> DateTime: """Get the current date and time. :param tz: timezone. Set to None to create a local :class:`.DateTime`. :raises OverflowError: if the timestamp is out of the range of values supported by the platform C localtime() function. It’s common for this to be restricted to years from 1970 through 2038. """ if tz is None: return cls.from_clock_time(Clock().local_time(), UnixEpoch) else: try: return tz.fromutc( # type: ignore cls.from_clock_time( # type: ignore Clock().utc_time(), UnixEpoch ).replace(tzinfo=tz) ) except TypeError: # For timezone implementations not compatible with the custom # datetime implementations, we can't do better than this. utc_now = cls.from_clock_time( Clock().utc_time(), UnixEpoch ) utc_now_native = utc_now.to_native() now_native = tz.fromutc(utc_now_native) now = cls.from_native(now_native) return now.replace( nanosecond=(now.nanosecond + utc_now.nanosecond - utc_now_native.microsecond * 1000) ) @classmethod def utc_now(cls) -> DateTime: """Get the current date and time in UTC.""" return cls.from_clock_time(Clock().utc_time(), UnixEpoch) @classmethod def from_iso_format(cls, s) -> DateTime: """Parse a ISO formatted date with time string. :param s: String to parse :raises ValueError: if the string does not match the ISO format. """ try: return cls.combine(Date.from_iso_format(s[0:10]), Time.from_iso_format(s[11:])) except ValueError: raise ValueError("DateTime string is not in ISO format") @classmethod def from_timestamp( cls, timestamp: float, tz: t.Optional[_tzinfo] = None ) -> DateTime: """:class:`.DateTime` from a time stamp (seconds since unix epoch). :param timestamp: the unix timestamp (seconds since unix epoch). :param tz: timezone. Set to None to create a local :class:`.DateTime`. :raises OverflowError: if the timestamp is out of the range of values supported by the platform C localtime() function. It’s common for this to be restricted to years from 1970 through 2038. """ if tz is None: return cls.from_clock_time( ClockTime(timestamp) + Clock().local_offset(), UnixEpoch ) else: return ( cls.utc_from_timestamp(timestamp) .replace(tzinfo=timezone.utc).astimezone(tz) ) @classmethod def utc_from_timestamp(cls, timestamp: float) -> DateTime: """:class:`.DateTime` from a time stamp (seconds since unix epoch). Returns the `DateTime` as local date `DateTime` in UTC. """ return cls.from_clock_time((timestamp, 0), UnixEpoch) @classmethod def from_ordinal(cls, ordinal: int) -> DateTime: """:class:`.DateTime` from an ordinal. For more info about ordinals see :meth:`.Date.from_ordinal`. """ return cls.combine(Date.from_ordinal(ordinal), Midnight) @classmethod def combine( # type: ignore[override] cls, date: Date, time: Time ) -> DateTime: """Combine a :class:`.Date` and a :class:`.Time` to a :class:`DateTime`. :param date: the date :param time: the time :raises AssertionError: if the parameter types don't match. """ assert isinstance(date, Date) assert isinstance(time, Time) instance = object.__new__(cls) instance.__date = date instance.__time = time return instance @classmethod def parse(cls, date_string, format): raise NotImplementedError() @classmethod def from_native(cls, dt: datetime) -> DateTime: """Convert from a native Python :class:`datetime.datetime` value. :param dt: the datetime to convert """ return cls.combine(Date.from_native(dt.date()), Time.from_native(dt.timetz())) @classmethod def from_clock_time( cls, clock_time: t.Union[ClockTime, t.Tuple[float, int]], epoch: DateTime ) -> DateTime: """Convert from a :class:`ClockTime` relative to a given epoch. :param clock_time: the clock time as :class:`.ClockTime` or as tuple of (seconds, nanoseconds) :param epoch: the epoch to which `clock_time` is relative :raises ValueError: if `clock_time` is invalid. """ try: seconds, nanoseconds = ClockTime(*clock_time) except (TypeError, ValueError): raise ValueError("Clock time must be a 2-tuple of (s, ns)") else: ordinal, seconds = divmod(seconds, 86400) ticks = epoch.time().ticks + seconds * NANO_SECONDS + nanoseconds days, ticks = divmod(ticks, 86400 * NANO_SECONDS) ordinal += days date_ = Date.from_ordinal(ordinal + epoch.date().to_ordinal()) time_ = Time.from_ticks(ticks) return cls.combine(date_, time_) # CLASS METHOD ALIASES # if t.TYPE_CHECKING: @classmethod def fromisoformat(cls, s) -> DateTime: ... @classmethod def fromordinal(cls, ordinal: int) -> DateTime: ... @classmethod def fromtimestamp( cls, timestamp: float, tz: t.Optional[_tzinfo] = None ) -> DateTime: ... # alias of parse @classmethod def strptime(cls, date_string, format): ... # alias of now @classmethod def today(cls, tz: t.Optional[_tzinfo] = None) -> DateTime: ... @classmethod def utcfromtimestamp(cls, timestamp: float) -> DateTime: ... @classmethod def utcnow(cls) -> DateTime: ... # CLASS ATTRIBUTES # min: te.Final[DateTime] = None # type: ignore """The earliest date time value possible.""" max: te.Final[DateTime] = None # type: ignore """The latest date time value possible.""" resolution: te.Final[Duration] = None # type: ignore """The minimum resolution supported.""" # INSTANCE ATTRIBUTES # @property def year(self) -> int: """The year of the :class:`.DateTime`. See :attr:`.Date.year`. """ return self.__date.year @property def month(self) -> int: """The year of the :class:`.DateTime`. See :attr:`.Date.year`.""" return self.__date.month @property def day(self) -> int: """The day of the :class:`.DateTime`'s date. See :attr:`.Date.day`.""" return self.__date.day @property def year_month_day(self) -> t.Tuple[int, int, int]: """The year_month_day of the :class:`.DateTime`'s date. See :attr:`.Date.year_month_day`.""" return self.__date.year_month_day @property def year_week_day(self) -> t.Tuple[int, int, int]: """The year_week_day of the :class:`.DateTime`'s date. See :attr:`.Date.year_week_day`.""" return self.__date.year_week_day @property def year_day(self) -> t.Tuple[int, int]: """The year_day of the :class:`.DateTime`'s date. See :attr:`.Date.year_day`.""" return self.__date.year_day @property def hour(self) -> int: """The hour of the :class:`.DateTime`'s time. See :attr:`.Time.hour`.""" return self.__time.hour @property def minute(self) -> int: """The minute of the :class:`.DateTime`'s time. See :attr:`.Time.minute`.""" return self.__time.minute @property def second(self) -> int: """The second of the :class:`.DateTime`'s time. See :attr:`.Time.second`.""" return self.__time.second @property def nanosecond(self) -> int: """The nanosecond of the :class:`.DateTime`'s time. See :attr:`.Time.nanosecond`.""" return self.__time.nanosecond @property def tzinfo(self) -> t.Optional[_tzinfo]: """The tzinfo of the :class:`.DateTime`'s time. See :attr:`.Time.tzinfo`.""" return self.__time.tzinfo @property def hour_minute_second_nanosecond(self) -> t.Tuple[int, int, int, int]: """The hour_minute_second_nanosecond of the :class:`.DateTime`'s time. See :attr:`.Time.hour_minute_second_nanosecond`.""" return self.__time.hour_minute_second_nanosecond # OPERATIONS # def _get_both_normalized(self, other, strict=True): if (isinstance(other, (datetime, DateTime)) and ((self.utc_offset() is None) ^ (other.utcoffset() is None))): if strict: raise TypeError("can't compare offset-naive and offset-aware " "datetimes") else: return None, None self_norm = self utc_offset = self.utc_offset() if utc_offset is not None: self_norm -= utc_offset self_norm = self_norm.replace(tzinfo=None) other_norm = other if isinstance(other, (datetime, DateTime)): utc_offset = other.utcoffset() if utc_offset is not None: other_norm -= utc_offset other_norm = other_norm.replace(tzinfo=None) else: return None, None return self_norm, other_norm def __hash__(self): """""" if self.nanosecond % 1000 == 0: return hash(self.to_native()) self_norm = self utc_offset = self.utc_offset() if utc_offset is not None: self_norm -= utc_offset return hash(self_norm.date()) ^ hash(self_norm.time()) def __eq__(self, other: object) -> bool: """ ``==`` comparison with :class:`.DateTime` or :class:`datetime.datetime`. """ if not isinstance(other, (datetime, DateTime)): return NotImplemented if self.utc_offset() == other.utcoffset(): return self.date() == other.date() and self.time() == other.time() self_norm, other_norm = self._get_both_normalized(other, strict=False) if self_norm is None: return False return self_norm == other_norm def __ne__(self, other: object) -> bool: """ ``!=`` comparison with :class:`.DateTime` or :class:`datetime.datetime`. """ return not self.__eq__(other) def __lt__( # type: ignore[override] self, other: datetime ) -> bool: """ ``<`` comparison with :class:`.DateTime` or :class:`datetime.datetime`. """ if not isinstance(other, (datetime, DateTime)): return NotImplemented if self.utc_offset() == other.utcoffset(): if self.date() == other.date(): return self.time() < other.time() return self.date() < other.date() self_norm, other_norm = self._get_both_normalized(other) return (self_norm.date() < other_norm.date() or self_norm.time() < other_norm.time()) def __le__( # type: ignore[override] self, other: t.Union[datetime, DateTime] ) -> bool: """ ``<=`` comparison with :class:`.DateTime` or :class:`datetime.datetime`. """ if not isinstance(other, (datetime, DateTime)): return NotImplemented if self.utc_offset() == other.utcoffset(): if self.date() == other.date(): return self.time() <= other.time() return self.date() <= other.date() self_norm, other_norm = self._get_both_normalized(other) return self_norm <= other_norm def __ge__( # type: ignore[override] self, other: t.Union[datetime, DateTime] ) -> bool: """ ``>=`` comparison with :class:`.DateTime` or :class:`datetime.datetime`. """ if not isinstance(other, (datetime, DateTime)): return NotImplemented if self.utc_offset() == other.utcoffset(): if self.date() == other.date(): return self.time() >= other.time() return self.date() >= other.date() self_norm, other_norm = self._get_both_normalized(other) return self_norm >= other_norm def __gt__( # type: ignore[override] self, other: t.Union[datetime, DateTime] ) -> bool: """ ``>`` comparison with :class:`.DateTime` or :class:`datetime.datetime`. """ if not isinstance(other, (datetime, DateTime)): return NotImplemented if self.utc_offset() == other.utcoffset(): if self.date() == other.date(): return self.time() > other.time() return self.date() > other.date() self_norm, other_norm = self._get_both_normalized(other) return (self_norm.date() > other_norm.date() or self_norm.time() > other_norm.time()) def __add__(self, other: t.Union[timedelta, Duration]) -> DateTime: """Add a :class:`datetime.timedelta`.""" if isinstance(other, Duration): t = (self.to_clock_time() + ClockTime(other.seconds, other.nanoseconds)) days, seconds = symmetric_divmod(t.seconds, 86400) date_ = self.date() + Duration(months=other.months, days=days + other.days) time_ = Time.from_ticks(seconds * NANO_SECONDS + t.nanoseconds) return self.combine(date_, time_).replace(tzinfo=self.tzinfo) if isinstance(other, timedelta): t = (self.to_clock_time() + ClockTime(86400 * other.days + other.seconds, other.microseconds * 1000)) days, seconds = symmetric_divmod(t.seconds, 86400) date_ = Date.from_ordinal(days + 1) time_ = Time.from_ticks(round_half_to_even( seconds * NANO_SECONDS + t.nanoseconds )) return self.combine(date_, time_).replace(tzinfo=self.tzinfo) return NotImplemented @t.overload # type: ignore[override] def __sub__(self, other: DateTime) -> Duration: ... @t.overload def __sub__(self, other: datetime) -> timedelta: ... @t.overload def __sub__(self, other: t.Union[Duration, timedelta]) -> DateTime: ... def __sub__(self, other): """Subtract a datetime/DateTime or a timedelta/Duration. Subtracting a :class:`.DateTime` yields the duration between the two as a :class:`.Duration`. Subtracting a :class:`datetime.datetime` yields the duration between the two as a :class:`datetime.timedelta`. Subtracting a :class:`datetime.timedelta` or a :class:`.Duration` yields the :class:`.DateTime` that's the given duration away. """ if isinstance(other, DateTime): self_month_ordinal = 12 * (self.year - 1) + self.month other_month_ordinal = 12 * (other.year - 1) + other.month months = self_month_ordinal - other_month_ordinal days = self.day - other.day t = self.time().to_clock_time() - other.time().to_clock_time() return Duration(months=months, days=days, seconds=t.seconds, nanoseconds=t.nanoseconds) if isinstance(other, datetime): days = self.to_ordinal() - other.toordinal() t = (self.time().to_clock_time() - ClockTime( 3600 * other.hour + 60 * other.minute + other.second, other.microsecond * 1000 )) return timedelta(days=days, seconds=t.seconds, microseconds=(t.nanoseconds // 1000)) if isinstance(other, Duration): return self.__add__(-other) if isinstance(other, timedelta): return self.__add__(-other) return NotImplemented def __copy__(self) -> DateTime: return self.combine(self.__date, self.__time) def __deepcopy__(self, memo) -> DateTime: return self.__copy__() # INSTANCE METHODS # def date(self) -> Date: """The date.""" return self.__date def time(self) -> Time: """The time without timezone info.""" return self.__time.replace(tzinfo=None) def timetz(self) -> Time: """The time with timezone info.""" return self.__time if t.TYPE_CHECKING: def replace( # type: ignore[override] self, year: int = ..., month: int = ..., day: int = ..., hour: int = ..., minute: int = ..., second: int = ..., nanosecond: int = ..., tzinfo: t.Optional[_tzinfo] = ..., **kwargs: object ) -> DateTime: ... else: def replace(self, **kwargs) -> DateTime: """Return a ``DateTime`` with one or more components replaced. See :meth:`.Date.replace` and :meth:`.Time.replace` for available arguments. """ date_ = self.__date.replace(**kwargs) time_ = self.__time.replace(**kwargs) return self.combine(date_, time_) def as_timezone(self, tz: _tzinfo) -> DateTime: """Convert this :class:`.DateTime` to another timezone. :param tz: the new timezone :return: the same object if ``tz`` is :const:``None``. Else, a new :class:`.DateTime` that's the same point in time but in a different timezone. """ if self.tzinfo is None: return self offset = t.cast(timedelta, self.utcoffset()) utc = (self - offset).replace(tzinfo=tz) try: return tz.fromutc(utc) # type: ignore except TypeError: # For timezone implementations not compatible with the custom # datetime implementations, we can't do better than this. native_utc = utc.to_native() native_res = tz.fromutc(native_utc) res = self.from_native(native_res) return res.replace( nanosecond=(native_res.microsecond * 1000 + self.nanosecond % 1000) ) def utc_offset(self) -> t.Optional[timedelta]: """Get the date times utc offset. See :meth:`.Time.utc_offset`. """ return self.__time._utc_offset(self) def dst(self) -> t.Optional[timedelta]: """Get the daylight saving time adjustment (DST). See :meth:`.Time.dst`. """ return self.__time.dst() def tzname(self) -> t.Optional[str]: """Get the timezone name. See :meth:`.Time.tzname`. """ return self.__time.tzname() def time_tuple(self): raise NotImplementedError() def utc_time_tuple(self): raise NotImplementedError() def to_ordinal(self) -> int: """Get the ordinal of the :class:`.DateTime`'s date. See :meth:`.Date.to_ordinal` """ return self.__date.to_ordinal() def to_clock_time(self) -> ClockTime: """Convert to :class:`.ClockTime`.""" ordinal_seconds = 86400 * (self.__date.to_ordinal() - 1) time_seconds, nanoseconds = divmod(self.__time.ticks, NANO_SECONDS) return ClockTime(ordinal_seconds + time_seconds, nanoseconds) def to_native(self) -> datetime: """Convert to a native Python :class:`datetime.datetime` value. This conversion is lossy as the native time implementation only supports a resolution of microseconds instead of nanoseconds. """ y, mo, d = self.year_month_day h, m, s, ns = self.hour_minute_second_nanosecond ms = int(ns / 1000) tz = self.tzinfo return datetime(y, mo, d, h, m, s, ms, tz) def weekday(self) -> int: """Get the weekday. See :meth:`.Date.weekday` """ return self.__date.weekday() def iso_weekday(self) -> int: """Get the ISO weekday. See :meth:`.Date.iso_weekday` """ return self.__date.iso_weekday() def iso_calendar(self) -> t.Tuple[int, int, int]: """Get date as ISO tuple. See :meth:`.Date.iso_calendar` """ return self.__date.iso_calendar() def iso_format(self, sep: str = "T") -> str: """Return the :class:`.DateTime` as ISO formatted string. This method joins `self.date().iso_format()` (see :meth:`.Date.iso_format`) and `self.timetz().iso_format()` (see :meth:`.Time.iso_format`) with `sep` in between. :param sep: the separator between the formatted date and time. """ s = "%s%s%s" % (self.date().iso_format(), sep, self.timetz().iso_format()) time_tz = self.timetz() offset = time_tz.utc_offset() if offset is not None: # the time component will have taken care of formatting the offset return s offset = self.utc_offset() if offset is not None: s += "%+03d:%02d" % divmod(offset.total_seconds() // 60, 60) return s def __repr__(self) -> str: """""" fields: tuple if self.tzinfo is None: fields = (*self.year_month_day, *self.hour_minute_second_nanosecond) return "neo4j.time.DateTime(%r, %r, %r, %r, %r, %r, %r)" % fields else: fields = (*self.year_month_day, *self.hour_minute_second_nanosecond, self.tzinfo) return ("neo4j.time.DateTime(%r, %r, %r, %r, %r, %r, %r, tzinfo=%r)" % fields) def __str__(self) -> str: """""" return self.iso_format() def __format__(self, format_spec): """""" if not format_spec: return self.iso_format() format_spec = FORMAT_F_REPLACE.sub(f"{self.__time.nanosecond:09}", format_spec) return self.to_native().__format__(format_spec) # INSTANCE METHOD ALIASES # def __getattr__(self, name): """ Map standard library attribute names to local attribute names, for compatibility. """ try: return { "astimezone": self.as_timezone, "isocalendar": self.iso_calendar, "isoformat": self.iso_format, "isoweekday": self.iso_weekday, "strftime": self.__format__, "toordinal": self.to_ordinal, "timetuple": self.time_tuple, "utcoffset": self.utc_offset, "utctimetuple": self.utc_time_tuple, }[name] except KeyError: raise AttributeError("DateTime has no attribute %r" % name) if t.TYPE_CHECKING: def astimezone( # type: ignore[override] self, tz: _tzinfo ) -> DateTime: ... def isocalendar( # type: ignore[override] self ) -> t.Tuple[int, int, int]: ... def iso_format(self, sep: str = "T") -> str: # type: ignore[override] ... isoweekday = iso_weekday strftime = __format__ toordinal = to_ordinal timetuple = time_tuple utcoffset = utc_offset utctimetuple = utc_time_tuple DateTime.min = DateTime.combine(Date.min, Time.min) # type: ignore DateTime.max = DateTime.combine(Date.max, Time.max) # type: ignore DateTime.resolution = Time.resolution # type: ignore #: A :class:`.DateTime` instance set to `0000-00-00T00:00:00`. #: This has a :class:`.Date` component equal to :attr:`ZeroDate` and a Never = DateTime.combine(ZeroDate, Midnight) #: A :class:`.DateTime` instance set to `1970-01-01T00:00:00`. UnixEpoch = DateTime(1970, 1, 1, 0, 0, 0) neo4j-python-driver-5.2.1/neo4j/time/__main__.py000066400000000000000000000017141433522662700214320ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. def main(): from neo4j.time import ( Clock, DateTime, UnixEpoch, ) clock = Clock() time = clock.utc_time() print("Using %s" % type(clock).__name__) print("%s -> %s" % (time, DateTime.from_clock_time(time, UnixEpoch))) if __name__ == "__main__": main() neo4j-python-driver-5.2.1/neo4j/time/_arithmetic.py000066400000000000000000000054721433522662700222070ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 typing import ( Tuple, TypeVar, ) __all__ = [ "nano_add", "nano_div", "nano_divmod", "symmetric_divmod", "round_half_to_even", ] def nano_add(x, y): """ >>> 0.7 + 0.2 0.8999999999999999 >>> -0.7 + 0.2 -0.49999999999999994 >>> nano_add(0.7, 0.2) 0.9 >>> nano_add(-0.7, 0.2) -0.5 :param x: :param y: :return: """ return (int(1000000000 * x) + int(1000000000 * y)) / 1000000000 def nano_div(x, y): """ >>> 0.7 / 0.2 3.4999999999999996 >>> -0.7 / 0.2 -3.4999999999999996 >>> nano_div(0.7, 0.2) 3.5 >>> nano_div(-0.7, 0.2) -3.5 :param x: :param y: :return: """ return float(1000000000 * x) / int(1000000000 * y) def nano_divmod(x, y): """ >>> divmod(0.7, 0.2) (3.0, 0.09999999999999992) >>> nano_divmod(0.7, 0.2) (3, 0.1) :param x: :param y: :return: """ number = type(x) nx = int(1000000000 * x) ny = int(1000000000 * y) q, r = divmod(nx, ny) return int(q), number(r / 1000000000) _T_dividend = TypeVar("_T_dividend", int, float) def symmetric_divmod( dividend: _T_dividend, divisor: float ) -> Tuple[int, _T_dividend]: number = type(dividend) if dividend >= 0: quotient, remainder = divmod(dividend, divisor) return int(quotient), number(remainder) else: quotient, remainder = divmod(-dividend, divisor) return -int(quotient), -number(remainder) def round_half_to_even(n): """ >>> round_half_to_even(3) 3 >>> round_half_to_even(3.2) 3 >>> round_half_to_even(3.5) 4 >>> round_half_to_even(3.7) 4 >>> round_half_to_even(4) 4 >>> round_half_to_even(4.2) 4 >>> round_half_to_even(4.5) 4 >>> round_half_to_even(4.7) 5 :param n: :return: """ ten_n = 10 * n if ten_n == int(ten_n) and ten_n % 10 == 5: up = int(n + 0.5) down = int(n - 0.5) return up if up % 2 == 0 else down else: return int(round(n)) neo4j-python-driver-5.2.1/neo4j/time/_clock_implementations.py000066400000000000000000000054671433522662700244450ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 ctypes import ( byref, c_long, c_longlong, CDLL, Structure, ) from platform import uname from . import ( Clock, ClockTime, ) from ._arithmetic import nano_divmod __all__ = [ "SafeClock", "PEP564Clock", "LibCClock", ] class SafeClock(Clock): """ Clock implementation that should work for any variant of Python. This clock is guaranteed microsecond precision. """ @classmethod def precision(cls): return 6 @classmethod def available(cls): return True def utc_time(self): from time import time seconds, nanoseconds = nano_divmod(int(time() * 1000000), 1000000) return ClockTime(seconds, nanoseconds * 1000) class PEP564Clock(Clock): """ Clock implementation based on the PEP564 additions to Python 3.7. This clock is guaranteed nanosecond precision. """ @classmethod def precision(cls): return 9 @classmethod def available(cls): try: from time import time_ns except ImportError: return False else: return True def utc_time(self): from time import time_ns t = time_ns() seconds, nanoseconds = divmod(t, 1000000000) return ClockTime(seconds, nanoseconds) class LibCClock(Clock): """ Clock implementation that works only on platforms that provide libc. This clock is guaranteed nanosecond precision. """ __libc = "libc.dylib" if uname()[0] == "Darwin" else "libc.so.6" class _TimeSpec(Structure): _fields_ = [ ("seconds", c_longlong), ("nanoseconds", c_long), ] @classmethod def precision(cls): return 9 @classmethod def available(cls): try: _ = CDLL(cls.__libc) except OSError: return False else: return True def utc_time(self): libc = CDLL(self.__libc) ts = self._TimeSpec() status = libc.clock_gettime(0, byref(ts)) if status == 0: return ClockTime(ts.seconds, ts.nanoseconds) else: raise RuntimeError("clock_gettime failed with status %d" % status) neo4j-python-driver-5.2.1/neo4j/time/_metaclasses.py000066400000000000000000000037241433522662700223600ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. __all__ = [ "DateType", "TimeType", "DateTimeType", ] class DateType(type): def __getattr__(cls, name): try: return { "fromisoformat": cls.from_iso_format, "fromordinal": cls.from_ordinal, "fromtimestamp": cls.from_timestamp, "utcfromtimestamp": cls.utc_from_timestamp, }[name] except KeyError: raise AttributeError("%s has no attribute %r" % (cls.__name__, name)) class TimeType(type): def __getattr__(cls, name): try: return { "fromisoformat": cls.from_iso_format, "utcnow": cls.utc_now, }[name] except KeyError: raise AttributeError("%s has no attribute %r" % (cls.__name__, name)) class DateTimeType(type): def __getattr__(cls, name): try: return { "fromisoformat": cls.from_iso_format, "fromordinal": cls.from_ordinal, "fromtimestamp": cls.from_timestamp, "strptime": cls.parse, "today": cls.now, "utcfromtimestamp": cls.utc_from_timestamp, "utcnow": cls.utc_now, }[name] except KeyError: raise AttributeError("%s has no attribute %r" % (cls.__name__, name)) neo4j-python-driver-5.2.1/neo4j/time/arithmetic.py000066400000000000000000000021361433522662700220420ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. # TODO: 6.0 - remove this file from .._meta import deprecation_warn from ._arithmetic import ( nano_add, nano_div, nano_divmod, round_half_to_even, symmetric_divmod, ) __all__ = [ "nano_add", "nano_div", "nano_divmod", "symmetric_divmod", "round_half_to_even", ] deprecation_warn( "The module 'neo4j.time.arithmetic' was made internal and will " "no longer be available for import in future versions.", stack_level=2 ) neo4j-python-driver-5.2.1/neo4j/time/clock_implementations.py000066400000000000000000000020301433522662700242650ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. # TODO: 6.0 - remove this file from .._meta import deprecation_warn from ._clock_implementations import ( LibCClock, PEP564Clock, SafeClock, ) __all__ = [ "SafeClock", "PEP564Clock", "LibCClock", ] deprecation_warn( "The module 'neo4j.time.clock_implementations' was made internal and will " "no longer be available for import in future versions.", stack_level=2 ) neo4j-python-driver-5.2.1/neo4j/time/hydration.py000066400000000000000000000027771433522662700217250ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. # TODO: 6.0 - remove this file from .._codec.hydration.v1.temporal import ( dehydrate_date, dehydrate_datetime, dehydrate_duration, dehydrate_time, dehydrate_timedelta, get_date_unix_epoch, get_date_unix_epoch_ordinal, get_datetime_unix_epoch_utc, hydrate_date, hydrate_datetime, hydrate_duration, hydrate_time, ) from .._meta import deprecation_warn __all__ = [ "get_date_unix_epoch", "get_date_unix_epoch_ordinal", "get_datetime_unix_epoch_utc", "hydrate_date", "dehydrate_date", "hydrate_time", "dehydrate_time", "hydrate_datetime", "dehydrate_datetime", "hydrate_duration", "dehydrate_duration", "dehydrate_timedelta", ] deprecation_warn( "The module 'neo4j.time.hydration' was made internal and will " "no longer be available for import in future versions.", stack_level=2 ) neo4j-python-driver-5.2.1/neo4j/time/metaclasses.py000066400000000000000000000017421433522662700222170ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 .._meta import deprecation_warn from ._metaclasses import ( DateTimeType, DateType, TimeType, ) __all__ = [ "DateType", "TimeType", "DateTimeType", ] deprecation_warn( "The module 'neo4j.time.metaclasses' was made internal and will " "no longer be available for import in future versions.", stack_level=2 ) neo4j-python-driver-5.2.1/neo4j/work/000077500000000000000000000000001433522662700173615ustar00rootroot00000000000000neo4j-python-driver-5.2.1/neo4j/work/__init__.py000066400000000000000000000015251433522662700214750ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 .query import ( Query, unit_of_work, ) from .summary import ( ResultSummary, SummaryCounters, ) __all__ = [ "Query", "ResultSummary", "SummaryCounters", "unit_of_work", ] neo4j-python-driver-5.2.1/neo4j/work/query.py000066400000000000000000000065421433522662700211070ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations import typing as t if t.TYPE_CHECKING: _T = t.TypeVar("_T") class Query: """ Create a new query. :param text: The query text. :param metadata: metadata attached to the query. :param timeout: seconds. """ def __init__( self, text: str, metadata: t.Optional[t.Dict[str, t.Any]] = None, timeout: t.Optional[float] = None ) -> None: self.text = text self.metadata = metadata self.timeout = timeout def __str__(self) -> str: return str(self.text) def unit_of_work( metadata: t.Optional[t.Dict[str, t.Any]] = None, timeout: t.Optional[float] = None ) -> t.Callable[[_T], _T]: """Decorator giving extra control over transaction function configuration. This function is a decorator for transaction functions that allows extra control over how the transaction is carried out. For example, a timeout may be applied:: from neo4j import unit_of_work @unit_of_work(timeout=100) def count_people_tx(tx): result = tx.run("MATCH (a:Person) RETURN count(a) AS persons") record = result.single() return record["persons"] :param metadata: a dictionary with metadata. Specified metadata will be attached to the executing transaction and visible in the output of ``SHOW TRANSACTIONS YIELD *`` It will also get logged to the ``query.log``. This functionality makes it easier to tag transactions and is equivalent to the ``dbms.setTXMetaData`` procedure, see https://neo4j.com/docs/cypher-manual/current/clauses/transaction-clauses/#query-listing-transactions and https://neo4j.com/docs/operations-manual/current/reference/procedures/ for reference. :param timeout: the transaction timeout in seconds. Transactions that execute longer than the configured timeout will be terminated by the database. This functionality allows to limit query/transaction execution time. Specified timeout overrides the default timeout configured in the database using ``dbms.transaction.timeout`` setting. Values higher than ``dbms.transaction.timeout`` will be ignored and will fall back to default (unless using Neo4j < 4.2). Value should not represent a negative duration. A zero duration will make the transaction execute indefinitely. None will use the default timeout configured in the database. """ def wrapper(f): def wrapped(*args, **kwargs): return f(*args, **kwargs) wrapped.metadata = metadata wrapped.timeout = timeout return wrapped return wrapper neo4j-python-driver-5.2.1/neo4j/work/summary.py000066400000000000000000000147331433522662700214400ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations import typing as t if t.TYPE_CHECKING: import typing_extensions as te from .._exceptions import BoltProtocolError from ..addressing import Address from ..api import ServerInfo BOLT_VERSION_1 = 1 BOLT_VERSION_2 = 2 BOLT_VERSION_3 = 3 BOLT_VERSION_4 = 4 # TODO: This logic should be inside the Bolt subclasses, because it can change depending on Bolt Protocol Version. class ResultSummary: """ A summary of execution returned with a :class:`.Result` object. """ #: A :class:`neo4j.ServerInfo` instance. Provides some basic information of the server where the result is obtained from. server: ServerInfo #: The database name where this summary is obtained from. database: t.Optional[str] #: The query that was executed to produce this result. query: t.Optional[str] #: Dictionary of parameters passed with the statement. parameters: t.Optional[t.Dict[str, t.Any]] #: A string that describes the type of query # ``'r'`` = read-only, ``'rw'`` = read/write, ``'w'`` = write-onlye, # ``'s'`` = schema. query_type: t.Union[te.Literal["r", "rw", "w", "s"], None] #: A :class:`neo4j.SummaryCounters` instance. Counters for operations the query triggered. counters: SummaryCounters #: Dictionary that describes how the database will execute the query. plan: t.Optional[dict] #: Dictionary that describes how the database executed the query. profile: t.Optional[dict] #: The time it took for the server to have the result available. (milliseconds) result_available_after: t.Optional[int] #: The time it took for the server to consume the result. (milliseconds) result_consumed_after: t.Optional[int] #: A list of Dictionaries containing notification information. #: Notifications provide extra information for a user executing a statement. #: They can be warnings about problematic queries or other valuable information that can be #: presented in a client. #: Unlike failures or errors, notifications do not affect the execution of a statement. notifications: t.Optional[t.List[dict]] def __init__(self, address: Address, **metadata: t.Any) -> None: self.metadata = metadata self.server = metadata["server"] self.database = metadata.get("db") self.query = metadata.get("query") self.parameters = metadata.get("parameters") if "type" in metadata: self.query_type = metadata["type"] if self.query_type not in ["r", "w", "rw", "s"]: raise BoltProtocolError( "Unexpected query type '%s' received from server. Consider " "updating the driver.", address ) self.query_type = metadata.get("type") self.plan = metadata.get("plan") self.profile = metadata.get("profile") self.notifications = metadata.get("notifications") self.counters = SummaryCounters(metadata.get("stats", {})) if self.server.protocol_version[0] < BOLT_VERSION_3: self.result_available_after = metadata.get("result_available_after") self.result_consumed_after = metadata.get("result_consumed_after") else: self.result_available_after = metadata.get("t_first") self.result_consumed_after = metadata.get("t_last") class SummaryCounters: """ Contains counters for various operations that a query triggered. """ #: nodes_created: int = 0 #: nodes_deleted: int = 0 #: relationships_created: int = 0 #: relationships_deleted: int = 0 #: properties_set: int = 0 #: labels_added: int = 0 #: labels_removed: int = 0 #: indexes_added: int = 0 #: indexes_removed: int = 0 #: constraints_added: int = 0 #: constraints_removed: int = 0 #: system_updates: int = 0 _contains_updates = None _contains_system_updates = None def __init__(self, statistics) -> None: key_to_attr_name = { "nodes-created": "nodes_created", "nodes-deleted": "nodes_deleted", "relationships-created": "relationships_created", "relationships-deleted": "relationships_deleted", "properties-set": "properties_set", "labels-added": "labels_added", "labels-removed": "labels_removed", "indexes-added": "indexes_added", "indexes-removed": "indexes_removed", "constraints-added": "constraints_added", "constraints-removed": "constraints_removed", "system-updates": "system_updates", "contains-updates": "_contains_updates", "contains-system-updates": "_contains_system_updates", } for key, value in dict(statistics).items(): attr_name = key_to_attr_name.get(key) if attr_name: setattr(self, attr_name, value) def __repr__(self) -> str: return repr(vars(self)) @property def contains_updates(self) -> bool: """True if any of the counters except for system_updates, are greater than 0. Otherwise False.""" if self._contains_updates is not None: return self._contains_updates return bool( self.nodes_created or self.nodes_deleted or self.relationships_created or self.relationships_deleted or self.properties_set or self.labels_added or self.labels_removed or self.indexes_added or self.indexes_removed or self.constraints_added or self.constraints_removed ) @property def contains_system_updates(self) -> bool: """True if the system database was updated, otherwise False.""" if self._contains_system_updates is not None: return self._contains_system_updates return self.system_updates > 0 neo4j-python-driver-5.2.1/requirements-dev.txt000066400000000000000000000003731433522662700214230ustar00rootroot00000000000000# auto-generate sync driver from async code unasync>=0.5.0 pre-commit>=2.15.0 isort>=5.10.0 mypy>=0.971 typing-extensions>=4.3.0 types-pytz>=2022.1.2 # needed for running tests -r tests/requirements.txt # production dependencies -r requirements.txt neo4j-python-driver-5.2.1/requirements.txt000066400000000000000000000000051433522662700206370ustar00rootroot00000000000000pytz neo4j-python-driver-5.2.1/setup.cfg000066400000000000000000000011011433522662700171720ustar00rootroot00000000000000[isort] combine_as_imports=true ensure_newline_before_comments=true force_grid_wrap=2 # breaks order of relative imports # https://github.com/PyCQA/isort/issues/1944 #force_sort_within_sections=true include_trailing_comma=true # currently broken # https://github.com/PyCQA/isort/issues/1855 #lines_before_imports=2 lines_after_imports=2 lines_between_sections=1 multi_line_output=3 order_by_type=false remove_redundant_aliases=true use_parentheses=true [tool:pytest] mock_use_standalone_module = true asyncio_mode = auto [mypy] [mypy-pandas.*] ignore_missing_imports = True neo4j-python-driver-5.2.1/setup.py000066400000000000000000000043421433522662700170750ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 os from setuptools import ( find_packages, setup, ) from neo4j._meta import ( package, version, ) install_requires = [ "pytz", ] extras_require = { "pandas": ["pandas>=1.0.0"], } classifiers = [ "Intended Audience :: Developers", "License :: OSI Approved :: Apache Software License", "Operating System :: OS Independent", "Topic :: Database", "Topic :: Software Development", "Programming Language :: Python :: 3.7", "Programming Language :: Python :: 3.8", "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", ] entry_points = { "console_scripts": [ ], } packages = find_packages(exclude=["tests"]) package_data = { package: ["py.typed"] for package in packages } readme_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "README.rst")) with open(readme_path, mode="r", encoding="utf-8") as fr: readme = fr.read() setup_args = { "name": package, "version": version, "description": "Neo4j Bolt driver for Python", "license": "Apache License, Version 2.0", "long_description": readme, "author": "Neo4j, Inc.", "author_email": "drivers@neo4j.com", "keywords": "neo4j graph database", "url": "https://github.com/neo4j/neo4j-python-driver", "install_requires": install_requires, "extras_require": extras_require, "classifiers": classifiers, "packages": packages, "package_data": package_data, "entry_points": entry_points, "python_requires": ">=3.7", } setup(**setup_args) neo4j-python-driver-5.2.1/testkit/000077500000000000000000000000001433522662700170475ustar00rootroot00000000000000neo4j-python-driver-5.2.1/testkit/.dockerignore000066400000000000000000000000051433522662700215160ustar00rootroot00000000000000*.py neo4j-python-driver-5.2.1/testkit/Dockerfile000066400000000000000000000040171433522662700210430ustar00rootroot00000000000000FROM ubuntu:20.04 ENV DEBIAN_FRONTEND noninteractive RUN apt-get update && \ apt-get install -y locales && \ apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/* && \ localedef -i en_US -c -f UTF-8 -A /usr/share/locale/locale.alias en_US.UTF-8 \ && rm -rf /var/lib/apt/lists/* ENV LANG en_US.UTF-8 # Using apt-get update alone in a RUN statement causes caching issues and subsequent apt-get install instructions fail. RUN apt-get --quiet update && apt-get --quiet install -y \ software-properties-common \ bash \ python3 \ python3-pip \ git \ curl \ tar \ wget \ && rm -rf /var/lib/apt/lists/* # Install Build Tools RUN apt-get update && \ apt-get install -y --no-install-recommends \ make build-essential libssl-dev zlib1g-dev libbz2-dev libreadline-dev \ libsqlite3-dev wget curl llvm libncurses5-dev xz-utils tk-dev \ libxml2-dev libxmlsec1-dev libffi-dev liblzma-dev \ ca-certificates && \ apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/* # Install our own CAs on the image. # Assumes Linux Debian based image. COPY CAs/* /usr/local/share/ca-certificates/ # Store custom CAs somewhere where the backend can find them later. COPY CustomCAs/* /usr/local/share/custom-ca-certificates/ RUN update-ca-certificates # Install pyenv RUN git clone https://github.com/pyenv/pyenv.git .pyenv ENV PYENV_ROOT /.pyenv ENV PATH $PYENV_ROOT/shims:$PYENV_ROOT/bin:$PATH # Setup python version ENV PYTHON_VERSIONS 3.7 3.8 3.9 3.10 RUN for version in $PYTHON_VERSIONS; do \ pyenv install $version:latest; \ done RUN pyenv rehash RUN pyenv global $(pyenv versions --bare --skip-aliases) # Install Latest pip and setuptools for each environment # + tox and tools for starting the tests # https://pip.pypa.io/en/stable/news/ RUN for version in 3.7 3.8 3.9 3.10; do \ python$version -m pip install -U pip && \ python$version -m pip install -U setuptools && \ python$version -m pip install -U coverage tox tox-factor; \ done neo4j-python-driver-5.2.1/testkit/_common.py000066400000000000000000000005701433522662700210520ustar00rootroot00000000000000import os import subprocess import sys TEST_BACKEND_VERSION = os.getenv("TEST_BACKEND_VERSION", "python") def run(args, env=None): return subprocess.run( args, universal_newlines=True, stdout=sys.stdout, stderr=sys.stderr, check=True, env=env ) def run_python(args, env=None): run([TEST_BACKEND_VERSION, "-u", "-W", "error", *args], env=env) neo4j-python-driver-5.2.1/testkit/backend.py000066400000000000000000000015721433522662700210150ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 os from _common import run_python if __name__ == "__main__": cmd = ["-m", "testkitbackend"] if "TEST_BACKEND_SERVER" in os.environ: cmd.append(os.environ["TEST_BACKEND_SERVER"]) run_python(cmd) neo4j-python-driver-5.2.1/testkit/build.py000066400000000000000000000017571433522662700205320ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. """ Executed in driver container. Responsible for building driver and test backend. """ from _common import run_python if __name__ == "__main__": run_python(["setup.py", "build"]) run_python(["-m", "pip", "install", "-U", "pip"]) run_python(["-m", "pip", "install", "-Ur", "testkitbackend/requirements.txt"]) neo4j-python-driver-5.2.1/testkit/integration.py000066400000000000000000000014111433522662700217410ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 _common import run_python if __name__ == "__main__": run_python(["-m", "tox", "-f", "integration"]) neo4j-python-driver-5.2.1/testkit/stress.py000066400000000000000000000023341433522662700207460ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 sys if __name__ == "__main__": # Until below works sys.exit(0) cmd = ["python", "-m", "tox", "-c", "tox-performance.ini"] uri = "%s://%s:%s" % ( os.environ["TEST_NEO4J_SCHEME"], os.environ["TEST_NEO4J_HOST"], os.environ["TEST_NEO4J_PORT"]) env = { "NEO4J_USER": os.environ["TEST_NEO4J_USER"], "NEO4J_PASSWORD": os.environ["TEST_NEO4J_PASS"], "NEO4J_URI": uri} subprocess.check_call(cmd, universal_newlines=True, stderr=subprocess.STDOUT, env=env) neo4j-python-driver-5.2.1/testkit/testkit.json000066400000000000000000000001431433522662700214270ustar00rootroot00000000000000{ "testkit": { "uri": "https://github.com/neo4j-drivers/testkit.git", "ref": "5.0" } } neo4j-python-driver-5.2.1/testkit/unittests.py000066400000000000000000000014021433522662700214600ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 _common import run_python if __name__ == "__main__": run_python(["-m", "tox", "-f", "unit"]) neo4j-python-driver-5.2.1/testkitbackend/000077500000000000000000000000001433522662700203575ustar00rootroot00000000000000neo4j-python-driver-5.2.1/testkitbackend/__init__.py000066400000000000000000000012011433522662700224620ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. neo4j-python-driver-5.2.1/testkitbackend/__main__.py000066400000000000000000000024161433522662700224540ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 asyncio import sys import warnings from .server import ( AsyncServer, Server, ) def sync_main(): server = Server(("0.0.0.0", 9876)) while True: server.handle_request() def async_main(): async def main(): server = AsyncServer(("0.0.0.0", 9876)) await server.start() try: await server.serve_forever() finally: server.stop() asyncio.run(main()) if __name__ == "__main__": warnings.simplefilter("error") if len(sys.argv) == 2 and sys.argv[1].lower().strip() == "async": async_main() else: sync_main() neo4j-python-driver-5.2.1/testkitbackend/_async/000077500000000000000000000000001433522662700216335ustar00rootroot00000000000000neo4j-python-driver-5.2.1/testkitbackend/_async/__init__.py000066400000000000000000000012011433522662700237360ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. neo4j-python-driver-5.2.1/testkitbackend/_async/backend.py000066400000000000000000000156561433522662700236110ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 asyncio import traceback from inspect import ( getmembers, isfunction, ) from json import ( dumps, loads, ) from pathlib import Path from neo4j._exceptions import BoltError from neo4j.exceptions import ( DriverError, Neo4jError, UnsupportedServerProduct, ) from .._driver_logger import ( buffer_handler, log, ) from ..backend import Request from ..exceptions import MarkdAsDriverException from . import requests TESTKIT_BACKEND_PATH = Path(__file__).absolute().resolve().parents[1] DRIVER_PATH = TESTKIT_BACKEND_PATH.parent / "neo4j" class AsyncBackend: def __init__(self, rd, wr): self._rd = rd self._wr = wr self.drivers = {} self.custom_resolutions = {} self.dns_resolutions = {} self.bookmark_managers = {} self.bookmarks_consumptions = {} self.bookmarks_supplies = {} self.sessions = {} self.results = {} self.errors = {} self.transactions = {} self.errors = {} self.key = 0 # Collect all request handlers self._requestHandlers = dict( [m for m in getmembers(requests, isfunction)]) async def close(self): for dict_of_closables in ( self.transactions, {key: tracker.session for key, tracker in self.sessions.items()}, self.drivers, ): for key, closable in dict_of_closables.items(): if not hasattr(closable, "close"): # e.g., ManagedTransaction continue try: await closable.close() except (Neo4jError, DriverError, OSError): log.error( "Error during TestKit backend garbage collection. " "While collecting: (key: %s) %s\n%s", key, closable, traceback.format_exc() ) dict_of_closables.clear() def next_key(self): self.key = self.key + 1 return self.key async def process_request(self): """ Reads next request from the stream and processes it. """ in_request = False request = "" async for line in self._rd: # Remove trailing newline line = line.decode('UTF-8').rstrip() if line == "#request begin": in_request = True elif line == "#request end": await self._process(request) return True else: if in_request: request = request + line return False @staticmethod def _exc_stems_from_driver(exc): stack = traceback.extract_tb(exc.__traceback__) for frame in stack[-1:1:-1]: p = Path(frame.filename) if TESTKIT_BACKEND_PATH in p.parents: return False if DRIVER_PATH in p.parents: return True @staticmethod def _exc_msg(exc, max_depth=10): if isinstance(exc, Neo4jError) and exc.message is not None: return str(exc.message) depth = 0 res = str(exc) while getattr(exc, "__cause__", None) is not None: depth += 1 if depth >= max_depth: break res += f"\nCaused by: {exc.__cause__!r}" exc = exc.__cause__ return res async def write_driver_exc(self, exc): log.debug(traceback.format_exc()) key = self.next_key() self.errors[key] = exc payload = {"id": key, "msg": ""} if isinstance(exc, MarkdAsDriverException): wrapped_exc = exc.wrapped_exc payload["errorType"] = str(type(wrapped_exc)) if wrapped_exc.args: payload["msg"] = self._exc_msg(wrapped_exc.args[0]) else: payload["errorType"] = str(type(exc)) payload["msg"] = self._exc_msg(exc) if isinstance(exc, Neo4jError): payload["code"] = exc.code await self.send_response("DriverError", payload) async def _process(self, request): """ Process a received request by retrieving handler that corresponds to the request name. """ try: request = loads(request, object_pairs_hook=Request) if not isinstance(request, Request): raise Exception("Request is not an object") name = request.get('name', 'invalid') handler = self._requestHandlers.get(name) if not handler: raise Exception("No request handler for " + name) data = request["data"] log.info("<<< " + name + dumps(data)) await handler(self, data) unsused_keys = request.unseen_keys if unsused_keys: raise NotImplementedError( "Backend does not support some properties of the " + name + " request: " + ", ".join(unsused_keys) ) except (Neo4jError, DriverError, UnsupportedServerProduct, BoltError, MarkdAsDriverException) as e: await self.write_driver_exc(e) except requests.FrontendError as e: await self.send_response("FrontendError", {"msg": str(e)}) except Exception as e: if self._exc_stems_from_driver(e): await self.write_driver_exc(e) else: tb = traceback.format_exc() log.error(tb) await self.send_response("BackendError", {"msg": tb}) async def send_response(self, name, data): """ Sends a response to backend. """ with buffer_handler.lock: log_output = buffer_handler.stream.getvalue() buffer_handler.stream.truncate(0) buffer_handler.stream.seek(0) if not log_output.endswith("\n"): log_output += "\n" self._wr.write(log_output.encode("utf-8")) response = {"name": name, "data": data} response = dumps(response) log.info(">>> " + name + dumps(data)) self._wr.write(b"#response begin\n") self._wr.write(bytes(response+"\n", "utf-8")) self._wr.write(b"#response end\n") if isinstance(self._wr, asyncio.StreamWriter): await self._wr.drain() else: self._wr.flush() neo4j-python-driver-5.2.1/testkitbackend/_async/requests.py000066400000000000000000000546141433522662700240720ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 json import re import warnings from os import path import neo4j import neo4j.api from neo4j._async_compat.util import AsyncUtil from .. import ( fromtestkit, test_subtest_skips, totestkit, ) from .._warning_check import warning_check from ..exceptions import MarkdAsDriverException class FrontendError(Exception): pass def load_config(): config_path = path.join(path.dirname(__file__), "..", "test_config.json") with open(config_path, "r") as fd: config = json.load(fd) skips = config["skips"] features = [k for k, v in config["features"].items() if v is True] import ssl if ssl.HAS_TLSv1_3: features += ["Feature:TLS:1.3"] return skips, features SKIPPED_TESTS, FEATURES = load_config() def _get_skip_reason(test_name): for skip_pattern, reason in SKIPPED_TESTS.items(): if skip_pattern[0] == skip_pattern[-1] == "'": match = skip_pattern[1:-1] == test_name else: match = re.match(skip_pattern, test_name) if match: return reason async def StartTest(backend, data): test_name = data["testName"] reason = _get_skip_reason(test_name) if reason is not None: if reason.startswith("test_subtest_skips."): await backend.send_response("RunSubTests", {}) else: await backend.send_response("SkipTest", {"reason": reason}) else: await backend.send_response("RunTest", {}) async def StartSubTest(backend, data): test_name = data["testName"] subtest_args = data["subtestArguments"] subtest_args.mark_all_as_read(recursive=True) reason = _get_skip_reason(test_name) assert reason and reason.startswith("test_subtest_skips.") or print(reason) func = getattr(test_subtest_skips, reason[19:]) reason = func(**subtest_args) if reason is not None: await backend.send_response("SkipTest", {"reason": reason}) else: await backend.send_response("RunTest", {}) async def GetFeatures(backend, data): await backend.send_response("FeatureList", {"features": FEATURES}) async def NewDriver(backend, data): auth_token = data["authorizationToken"]["data"] data["authorizationToken"].mark_item_as_read_if_equals( "name", "AuthorizationToken" ) scheme = auth_token["scheme"] if scheme == "basic": auth = neo4j.basic_auth( auth_token["principal"], auth_token["credentials"], realm=auth_token.get("realm", None) ) elif scheme == "kerberos": auth = neo4j.kerberos_auth(auth_token["credentials"]) elif scheme == "bearer": auth = neo4j.bearer_auth(auth_token["credentials"]) else: auth = neo4j.custom_auth( auth_token["principal"], auth_token["credentials"], auth_token["realm"], auth_token["scheme"], **auth_token.get("parameters", {}) ) auth_token.mark_item_as_read("parameters", recursive=True) kwargs = {} if data["resolverRegistered"] or data["domainNameResolverRegistered"]: kwargs["resolver"] = resolution_func( backend, data["resolverRegistered"], data["domainNameResolverRegistered"] ) for timeout_testkit, timeout_driver in ( ("connectionTimeoutMs", "connection_timeout"), ("maxTxRetryTimeMs", "max_transaction_retry_time"), ("connectionAcquisitionTimeoutMs", "connection_acquisition_timeout"), ): if data.get(timeout_testkit) is not None: kwargs[timeout_driver] = data[timeout_testkit] / 1000 for k in ("sessionConnectionTimeoutMs", "updateRoutingTableTimeoutMs"): if k in data: data.mark_item_as_read_if_equals(k, None) if data.get("maxConnectionPoolSize"): kwargs["max_connection_pool_size"] = data["maxConnectionPoolSize"] if data.get("fetchSize"): kwargs["fetch_size"] = data["fetchSize"] if "encrypted" in data: kwargs["encrypted"] = data["encrypted"] if "trustedCertificates" in data: if data["trustedCertificates"] is None: kwargs["trusted_certificates"] = neo4j.TrustSystemCAs() elif not data["trustedCertificates"]: kwargs["trusted_certificates"] = neo4j.TrustAll() else: cert_paths = ("/usr/local/share/custom-ca-certificates/" + cert for cert in data["trustedCertificates"]) kwargs["trusted_certificates"] = neo4j.TrustCustomCAs(*cert_paths) data.mark_item_as_read_if_equals("livenessCheckTimeoutMs", None) driver = neo4j.AsyncGraphDatabase.driver( data["uri"], auth=auth, user_agent=data["userAgent"], **kwargs ) key = backend.next_key() backend.drivers[key] = driver await backend.send_response("Driver", {"id": key}) async def VerifyConnectivity(backend, data): driver_id = data["driverId"] driver = backend.drivers[driver_id] await driver.verify_connectivity() await backend.send_response("Driver", {"id": driver_id}) async def GetServerInfo(backend, data): driver_id = data["driverId"] driver = backend.drivers[driver_id] server_info = await driver.get_server_info() await backend.send_response("ServerInfo", { "address": ":".join(map(str, server_info.address)), "agent": server_info.agent, "protocolVersion": ".".join(map(str, server_info.protocol_version)), }) async def CheckMultiDBSupport(backend, data): driver_id = data["driverId"] driver = backend.drivers[driver_id] with warning_check( neo4j.ExperimentalWarning, "Feature support query, based on Bolt protocol version and Neo4j " "server version will change in the future." ): available = await driver.supports_multi_db() await backend.send_response("MultiDBSupport", { "id": backend.next_key(), "available": available }) def resolution_func(backend, custom_resolver=False, custom_dns_resolver=False): # This solution (putting custom resolution together with DNS resolution # into one function only works because the Python driver calls the custom # resolver function for every connection, which is not true for all # drivers. Properly exposing a way to change the DNS lookup behavior is not # possible without changing the driver's code. assert custom_resolver or custom_dns_resolver async def resolve(address): addresses = [":".join(map(str, address))] if custom_resolver: key = backend.next_key() await backend.send_response("ResolverResolutionRequired", { "id": key, "address": addresses[0] }) if not await backend.process_request(): # connection was closed before end of next message return [] if key not in backend.custom_resolutions: raise RuntimeError( "Backend did not receive expected " "ResolverResolutionCompleted message for id %s" % key ) addresses = backend.custom_resolutions.pop(key) if custom_dns_resolver: dns_resolved_addresses = [] for address in addresses: key = backend.next_key() address = address.rsplit(":", 1) await backend.send_response("DomainNameResolutionRequired", { "id": key, "name": address[0] }) if not await backend.process_request(): # connection was closed before end of next message return [] if key not in backend.dns_resolutions: raise RuntimeError( "Backend did not receive expected " "DomainNameResolutionCompleted message for id %s" % key ) dns_resolved_addresses += list(map( lambda a: ":".join((a, *address[1:])), backend.dns_resolutions.pop(key) )) addresses = dns_resolved_addresses return list(map(neo4j.Address.parse, addresses)) return resolve async def ResolverResolutionCompleted(backend, data): backend.custom_resolutions[data["requestId"]] = data["addresses"] async def DomainNameResolutionCompleted(backend, data): backend.dns_resolutions[data["requestId"]] = data["addresses"] async def NewBookmarkManager(backend, data): bookmark_manager_id = backend.next_key() bmm_kwargs = {} data.mark_item_as_read("initialBookmarks", recursive=True) bmm_kwargs["initial_bookmarks"] = data.get("initialBookmarks") if data.get("bookmarksSupplierRegistered"): bmm_kwargs["bookmarks_supplier"] = bookmarks_supplier( backend, bookmark_manager_id ) if data.get("bookmarksConsumerRegistered"): bmm_kwargs["bookmarks_consumer"] = bookmarks_consumer( backend, bookmark_manager_id ) with warning_check( neo4j.ExperimentalWarning, "The bookmark manager feature is experimental. It might be changed or " "removed any time even without prior notice." ): bookmark_manager = neo4j.AsyncGraphDatabase.bookmark_manager( **bmm_kwargs ) backend.bookmark_managers[bookmark_manager_id] = bookmark_manager await backend.send_response("BookmarkManager", {"id": bookmark_manager_id}) async def BookmarkManagerClose(backend, data): bookmark_manager_id = data["id"] del backend.bookmark_managers[bookmark_manager_id] await backend.send_response("BookmarkManager", {"id": bookmark_manager_id}) def bookmarks_supplier(backend, bookmark_manager_id): async def supplier(database): key = backend.next_key() await backend.send_response("BookmarksSupplierRequest", { "id": key, "bookmarkManagerId": bookmark_manager_id, "database": database }) if not await backend.process_request(): # connection was closed before end of next message return [] if key not in backend.bookmarks_supplies: raise RuntimeError( "Backend did not receive expected " "BookmarksSupplierCompleted message for id %s" % key ) return backend.bookmarks_supplies.pop(key) return supplier async def BookmarksSupplierCompleted(backend, data): backend.bookmarks_supplies[data["requestId"]] = \ neo4j.Bookmarks.from_raw_values(data["bookmarks"]) def bookmarks_consumer(backend, bookmark_manager_id): async def consumer(database, bookmarks): key = backend.next_key() await backend.send_response("BookmarksConsumerRequest", { "id": key, "bookmarkManagerId": bookmark_manager_id, "database": database, "bookmarks": list(bookmarks.raw_values) }) if not await backend.process_request(): # connection was closed before end of next message return [] if key not in backend.bookmarks_consumptions: raise RuntimeError( "Backend did not receive expected " "BookmarksConsumerCompleted message for id %s" % key ) del backend.bookmarks_consumptions[key] return consumer async def BookmarksConsumerCompleted(backend, data): backend.bookmarks_consumptions[data["requestId"]] = True async def DriverClose(backend, data): key = data["driverId"] driver = backend.drivers[key] await driver.close() await backend.send_response("Driver", {"id": key}) async def CheckDriverIsEncrypted(backend, data): key = data["driverId"] driver = backend.drivers[key] await backend.send_response("DriverIsEncrypted", { "encrypted": driver.encrypted }) class SessionTracker: """ Keeps some extra state about the tracked session """ def __init__(self, session): self.session = session self.state = "" self.error_id = "" async def NewSession(backend, data): driver = backend.drivers[data["driverId"]] access_mode = data["accessMode"] if access_mode == "r": access_mode = neo4j.READ_ACCESS elif access_mode == "w": access_mode = neo4j.WRITE_ACCESS else: raise ValueError("Unknown access mode:" + access_mode) config = { "default_access_mode": access_mode, "database": data["database"], } if data.get("bookmarks") is not None: config["bookmarks"] = neo4j.Bookmarks.from_raw_values( data["bookmarks"] ) if data.get("bookmarkManagerId") is not None: config["bookmark_manager"] = backend.bookmark_managers[ data["bookmarkManagerId"] ] for (conf_name, data_name) in ( ("fetch_size", "fetchSize"), ("impersonated_user", "impersonatedUser"), ): if data_name in data: config[conf_name] = data[data_name] if "bookmark_manager" in config: with warning_check( neo4j.ExperimentalWarning, "The 'bookmark_manager' config key is experimental. It might be " "changed or removed any time even without prior notice." ): session = driver.session(**config) else: session = driver.session(**config) key = backend.next_key() backend.sessions[key] = SessionTracker(session) await backend.send_response("Session", {"id": key}) async def SessionRun(backend, data): session = backend.sessions[data["sessionId"]].session query, params = fromtestkit.to_query_and_params(data) result = await session.run(query, parameters=params) key = backend.next_key() backend.results[key] = result await backend.send_response("Result", {"id": key, "keys": result.keys()}) async def SessionClose(backend, data): key = data["sessionId"] session = backend.sessions[key].session await session.close() del backend.sessions[key] await backend.send_response("Session", {"id": key}) async def SessionBeginTransaction(backend, data): key = data["sessionId"] session = backend.sessions[key].session tx_kwargs = fromtestkit.to_tx_kwargs(data) tx = await session.begin_transaction(**tx_kwargs) key = backend.next_key() backend.transactions[key] = tx await backend.send_response("Transaction", {"id": key}) async def SessionReadTransaction(backend, data): await transactionFunc(backend, data, True) async def SessionWriteTransaction(backend, data): await transactionFunc(backend, data, False) async def transactionFunc(backend, data, is_read): key = data["sessionId"] session_tracker = backend.sessions[key] session = session_tracker.session tx_kwargs = fromtestkit.to_tx_kwargs(data) @neo4j.unit_of_work(**tx_kwargs) async def func(tx): txkey = backend.next_key() backend.transactions[txkey] = tx session_tracker.state = '' await backend.send_response("RetryableTry", {"id": txkey}) cont = True while cont: cont = await backend.process_request() if session_tracker.state == '+': cont = False elif session_tracker.state == '-': if session_tracker.error_id: raise backend.errors[session_tracker.error_id] else: raise FrontendError("Client said no") if is_read: await session.execute_read(func) else: await session.execute_write(func) await backend.send_response("RetryableDone", {}) async def RetryablePositive(backend, data): key = data["sessionId"] session_tracker = backend.sessions[key] session_tracker.state = '+' async def RetryableNegative(backend, data): key = data["sessionId"] session_tracker = backend.sessions[key] session_tracker.state = '-' session_tracker.error_id = data.get('errorId', '') async def SessionLastBookmarks(backend, data): key = data["sessionId"] session = backend.sessions[key].session bookmarks = await session.last_bookmarks() await backend.send_response("Bookmarks", {"bookmarks": list(bookmarks.raw_values)}) async def TransactionRun(backend, data): key = data["txId"] tx = backend.transactions[key] cypher, params = fromtestkit.to_cypher_and_params(data) result = await tx.run(cypher, parameters=params) key = backend.next_key() backend.results[key] = result await backend.send_response("Result", {"id": key, "keys": result.keys()}) async def TransactionCommit(backend, data): key = data["txId"] tx = backend.transactions[key] try: commit = tx.commit except AttributeError as e: raise MarkdAsDriverException(e) # raise DriverError("Type does not support commit %s" % type(tx)) await commit() await backend.send_response("Transaction", {"id": key}) async def TransactionRollback(backend, data): key = data["txId"] tx = backend.transactions[key] try: rollback = tx.rollback except AttributeError as e: raise MarkdAsDriverException(e) # raise DriverError("Type does not support rollback %s" % type(tx)) await rollback() await backend.send_response("Transaction", {"id": key}) async def TransactionClose(backend, data): key = data["txId"] tx = backend.transactions[key] try: close = tx.close except AttributeError as e: raise MarkdAsDriverException(e) # raise DriverError("Type does not support close %s" % type(tx)) await close() await backend.send_response("Transaction", {"id": key}) async def ResultNext(backend, data): result = backend.results[data["resultId"]] try: record = await AsyncUtil.next(AsyncUtil.iter(result)) except StopAsyncIteration: await backend.send_response("NullRecord", {}) return await backend.send_response("Record", totestkit.record(record)) async def ResultSingle(backend, data): result = backend.results[data["resultId"]] await backend.send_response("Record", totestkit.record( await result.single(strict=True) )) async def ResultSingleOptional(backend, data): result = backend.results[data["resultId"]] with warnings.catch_warnings(record=True) as warning_list: warnings.simplefilter("always") record = await result.single(strict=False) if record: record = totestkit.record(record) await backend.send_response("RecordOptional", { "record": record, "warnings": list(map(str, warning_list)) }) async def ResultPeek(backend, data): result = backend.results[data["resultId"]] record = await result.peek() if record is not None: await backend.send_response("Record", totestkit.record(record)) else: await backend.send_response("NullRecord", {}) async def ResultList(backend, data): result = backend.results[data["resultId"]] records = await AsyncUtil.list(result) await backend.send_response("RecordList", { "records": [totestkit.record(r) for r in records] }) async def ResultConsume(backend, data): result = backend.results[data["resultId"]] summary = await result.consume() from neo4j import ResultSummary assert isinstance(summary, ResultSummary) await backend.send_response("Summary", { "serverInfo": { "address": ":".join(map(str, summary.server.address)), "agent": summary.server.agent, "protocolVersion": ".".join(map(str, summary.server.protocol_version)), }, "counters": None if not summary.counters else { "constraintsAdded": summary.counters.constraints_added, "constraintsRemoved": summary.counters.constraints_removed, "containsSystemUpdates": summary.counters.contains_system_updates, "containsUpdates": summary.counters.contains_updates, "indexesAdded": summary.counters.indexes_added, "indexesRemoved": summary.counters.indexes_removed, "labelsAdded": summary.counters.labels_added, "labelsRemoved": summary.counters.labels_removed, "nodesCreated": summary.counters.nodes_created, "nodesDeleted": summary.counters.nodes_deleted, "propertiesSet": summary.counters.properties_set, "relationshipsCreated": summary.counters.relationships_created, "relationshipsDeleted": summary.counters.relationships_deleted, "systemUpdates": summary.counters.system_updates, }, "database": summary.database, "notifications": summary.notifications, "plan": summary.plan, "profile": summary.profile, "query": { "text": summary.query, "parameters": {k: totestkit.field(v) for k, v in summary.parameters.items()}, }, "queryType": summary.query_type, "resultAvailableAfter": summary.result_available_after, "resultConsumedAfter": summary.result_consumed_after, }) async def ForcedRoutingTableUpdate(backend, data): driver_id = data["driverId"] driver = backend.drivers[driver_id] database = data["database"] bookmarks = data["bookmarks"] async with driver._pool.refresh_lock: await driver._pool.update_routing_table( database=database, imp_user=None, bookmarks=bookmarks ) await backend.send_response("Driver", {"id": driver_id}) async def GetRoutingTable(backend, data): driver_id = data["driverId"] database = data["database"] driver = backend.drivers[driver_id] routing_table = driver._pool.routing_tables[database] response_data = { "database": routing_table.database, "ttl": routing_table.ttl, } for role in ("routers", "readers", "writers"): addresses = routing_table.__getattribute__(role) response_data[role] = list(map(str, addresses)) await backend.send_response("RoutingTable", response_data) neo4j-python-driver-5.2.1/testkitbackend/_driver_logger.py000066400000000000000000000024161433522662700237250ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 io import logging import sys formatter = logging.Formatter("%(asctime)s [%(levelname)-8s] %(message)s") buffer_handler = logging.StreamHandler(io.StringIO()) buffer_handler.setLevel(logging.DEBUG) buffer_handler.setFormatter(formatter) handler = logging.StreamHandler(sys.stdout) handler.setLevel(logging.DEBUG) handler.setFormatter(formatter) logging.getLogger("neo4j").addHandler(handler) logging.getLogger("neo4j").addHandler(buffer_handler) logging.getLogger("neo4j").setLevel(logging.DEBUG) log = logging.getLogger("testkitbackend") log.addHandler(handler) log.setLevel(logging.DEBUG) __all__ = [ "buffer_handler", "log", ] neo4j-python-driver-5.2.1/testkitbackend/_sync/000077500000000000000000000000001433522662700214725ustar00rootroot00000000000000neo4j-python-driver-5.2.1/testkitbackend/_sync/__init__.py000066400000000000000000000012011433522662700235750ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. neo4j-python-driver-5.2.1/testkitbackend/_sync/backend.py000066400000000000000000000155171433522662700234440ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 asyncio import traceback from inspect import ( getmembers, isfunction, ) from json import ( dumps, loads, ) from pathlib import Path from neo4j._exceptions import BoltError from neo4j.exceptions import ( DriverError, Neo4jError, UnsupportedServerProduct, ) from .._driver_logger import ( buffer_handler, log, ) from ..backend import Request from ..exceptions import MarkdAsDriverException from . import requests TESTKIT_BACKEND_PATH = Path(__file__).absolute().resolve().parents[1] DRIVER_PATH = TESTKIT_BACKEND_PATH.parent / "neo4j" class Backend: def __init__(self, rd, wr): self._rd = rd self._wr = wr self.drivers = {} self.custom_resolutions = {} self.dns_resolutions = {} self.bookmark_managers = {} self.bookmarks_consumptions = {} self.bookmarks_supplies = {} self.sessions = {} self.results = {} self.errors = {} self.transactions = {} self.errors = {} self.key = 0 # Collect all request handlers self._requestHandlers = dict( [m for m in getmembers(requests, isfunction)]) def close(self): for dict_of_closables in ( self.transactions, {key: tracker.session for key, tracker in self.sessions.items()}, self.drivers, ): for key, closable in dict_of_closables.items(): if not hasattr(closable, "close"): # e.g., ManagedTransaction continue try: closable.close() except (Neo4jError, DriverError, OSError): log.error( "Error during TestKit backend garbage collection. " "While collecting: (key: %s) %s\n%s", key, closable, traceback.format_exc() ) dict_of_closables.clear() def next_key(self): self.key = self.key + 1 return self.key def process_request(self): """ Reads next request from the stream and processes it. """ in_request = False request = "" for line in self._rd: # Remove trailing newline line = line.decode('UTF-8').rstrip() if line == "#request begin": in_request = True elif line == "#request end": self._process(request) return True else: if in_request: request = request + line return False @staticmethod def _exc_stems_from_driver(exc): stack = traceback.extract_tb(exc.__traceback__) for frame in stack[-1:1:-1]: p = Path(frame.filename) if TESTKIT_BACKEND_PATH in p.parents: return False if DRIVER_PATH in p.parents: return True @staticmethod def _exc_msg(exc, max_depth=10): if isinstance(exc, Neo4jError) and exc.message is not None: return str(exc.message) depth = 0 res = str(exc) while getattr(exc, "__cause__", None) is not None: depth += 1 if depth >= max_depth: break res += f"\nCaused by: {exc.__cause__!r}" exc = exc.__cause__ return res def write_driver_exc(self, exc): log.debug(traceback.format_exc()) key = self.next_key() self.errors[key] = exc payload = {"id": key, "msg": ""} if isinstance(exc, MarkdAsDriverException): wrapped_exc = exc.wrapped_exc payload["errorType"] = str(type(wrapped_exc)) if wrapped_exc.args: payload["msg"] = self._exc_msg(wrapped_exc.args[0]) else: payload["errorType"] = str(type(exc)) payload["msg"] = self._exc_msg(exc) if isinstance(exc, Neo4jError): payload["code"] = exc.code self.send_response("DriverError", payload) def _process(self, request): """ Process a received request by retrieving handler that corresponds to the request name. """ try: request = loads(request, object_pairs_hook=Request) if not isinstance(request, Request): raise Exception("Request is not an object") name = request.get('name', 'invalid') handler = self._requestHandlers.get(name) if not handler: raise Exception("No request handler for " + name) data = request["data"] log.info("<<< " + name + dumps(data)) handler(self, data) unsused_keys = request.unseen_keys if unsused_keys: raise NotImplementedError( "Backend does not support some properties of the " + name + " request: " + ", ".join(unsused_keys) ) except (Neo4jError, DriverError, UnsupportedServerProduct, BoltError, MarkdAsDriverException) as e: self.write_driver_exc(e) except requests.FrontendError as e: self.send_response("FrontendError", {"msg": str(e)}) except Exception as e: if self._exc_stems_from_driver(e): self.write_driver_exc(e) else: tb = traceback.format_exc() log.error(tb) self.send_response("BackendError", {"msg": tb}) def send_response(self, name, data): """ Sends a response to backend. """ with buffer_handler.lock: log_output = buffer_handler.stream.getvalue() buffer_handler.stream.truncate(0) buffer_handler.stream.seek(0) if not log_output.endswith("\n"): log_output += "\n" self._wr.write(log_output.encode("utf-8")) response = {"name": name, "data": data} response = dumps(response) log.info(">>> " + name + dumps(data)) self._wr.write(b"#response begin\n") self._wr.write(bytes(response+"\n", "utf-8")) self._wr.write(b"#response end\n") if isinstance(self._wr, asyncio.StreamWriter): self._wr.drain() else: self._wr.flush() neo4j-python-driver-5.2.1/testkitbackend/_sync/requests.py000066400000000000000000000533331433522662700237260ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 json import re import warnings from os import path import neo4j import neo4j.api from neo4j._async_compat.util import Util from .. import ( fromtestkit, test_subtest_skips, totestkit, ) from .._warning_check import warning_check from ..exceptions import MarkdAsDriverException class FrontendError(Exception): pass def load_config(): config_path = path.join(path.dirname(__file__), "..", "test_config.json") with open(config_path, "r") as fd: config = json.load(fd) skips = config["skips"] features = [k for k, v in config["features"].items() if v is True] import ssl if ssl.HAS_TLSv1_3: features += ["Feature:TLS:1.3"] return skips, features SKIPPED_TESTS, FEATURES = load_config() def _get_skip_reason(test_name): for skip_pattern, reason in SKIPPED_TESTS.items(): if skip_pattern[0] == skip_pattern[-1] == "'": match = skip_pattern[1:-1] == test_name else: match = re.match(skip_pattern, test_name) if match: return reason def StartTest(backend, data): test_name = data["testName"] reason = _get_skip_reason(test_name) if reason is not None: if reason.startswith("test_subtest_skips."): backend.send_response("RunSubTests", {}) else: backend.send_response("SkipTest", {"reason": reason}) else: backend.send_response("RunTest", {}) def StartSubTest(backend, data): test_name = data["testName"] subtest_args = data["subtestArguments"] subtest_args.mark_all_as_read(recursive=True) reason = _get_skip_reason(test_name) assert reason and reason.startswith("test_subtest_skips.") or print(reason) func = getattr(test_subtest_skips, reason[19:]) reason = func(**subtest_args) if reason is not None: backend.send_response("SkipTest", {"reason": reason}) else: backend.send_response("RunTest", {}) def GetFeatures(backend, data): backend.send_response("FeatureList", {"features": FEATURES}) def NewDriver(backend, data): auth_token = data["authorizationToken"]["data"] data["authorizationToken"].mark_item_as_read_if_equals( "name", "AuthorizationToken" ) scheme = auth_token["scheme"] if scheme == "basic": auth = neo4j.basic_auth( auth_token["principal"], auth_token["credentials"], realm=auth_token.get("realm", None) ) elif scheme == "kerberos": auth = neo4j.kerberos_auth(auth_token["credentials"]) elif scheme == "bearer": auth = neo4j.bearer_auth(auth_token["credentials"]) else: auth = neo4j.custom_auth( auth_token["principal"], auth_token["credentials"], auth_token["realm"], auth_token["scheme"], **auth_token.get("parameters", {}) ) auth_token.mark_item_as_read("parameters", recursive=True) kwargs = {} if data["resolverRegistered"] or data["domainNameResolverRegistered"]: kwargs["resolver"] = resolution_func( backend, data["resolverRegistered"], data["domainNameResolverRegistered"] ) for timeout_testkit, timeout_driver in ( ("connectionTimeoutMs", "connection_timeout"), ("maxTxRetryTimeMs", "max_transaction_retry_time"), ("connectionAcquisitionTimeoutMs", "connection_acquisition_timeout"), ): if data.get(timeout_testkit) is not None: kwargs[timeout_driver] = data[timeout_testkit] / 1000 for k in ("sessionConnectionTimeoutMs", "updateRoutingTableTimeoutMs"): if k in data: data.mark_item_as_read_if_equals(k, None) if data.get("maxConnectionPoolSize"): kwargs["max_connection_pool_size"] = data["maxConnectionPoolSize"] if data.get("fetchSize"): kwargs["fetch_size"] = data["fetchSize"] if "encrypted" in data: kwargs["encrypted"] = data["encrypted"] if "trustedCertificates" in data: if data["trustedCertificates"] is None: kwargs["trusted_certificates"] = neo4j.TrustSystemCAs() elif not data["trustedCertificates"]: kwargs["trusted_certificates"] = neo4j.TrustAll() else: cert_paths = ("/usr/local/share/custom-ca-certificates/" + cert for cert in data["trustedCertificates"]) kwargs["trusted_certificates"] = neo4j.TrustCustomCAs(*cert_paths) data.mark_item_as_read_if_equals("livenessCheckTimeoutMs", None) driver = neo4j.GraphDatabase.driver( data["uri"], auth=auth, user_agent=data["userAgent"], **kwargs ) key = backend.next_key() backend.drivers[key] = driver backend.send_response("Driver", {"id": key}) def VerifyConnectivity(backend, data): driver_id = data["driverId"] driver = backend.drivers[driver_id] driver.verify_connectivity() backend.send_response("Driver", {"id": driver_id}) def GetServerInfo(backend, data): driver_id = data["driverId"] driver = backend.drivers[driver_id] server_info = driver.get_server_info() backend.send_response("ServerInfo", { "address": ":".join(map(str, server_info.address)), "agent": server_info.agent, "protocolVersion": ".".join(map(str, server_info.protocol_version)), }) def CheckMultiDBSupport(backend, data): driver_id = data["driverId"] driver = backend.drivers[driver_id] with warning_check( neo4j.ExperimentalWarning, "Feature support query, based on Bolt protocol version and Neo4j " "server version will change in the future." ): available = driver.supports_multi_db() backend.send_response("MultiDBSupport", { "id": backend.next_key(), "available": available }) def resolution_func(backend, custom_resolver=False, custom_dns_resolver=False): # This solution (putting custom resolution together with DNS resolution # into one function only works because the Python driver calls the custom # resolver function for every connection, which is not true for all # drivers. Properly exposing a way to change the DNS lookup behavior is not # possible without changing the driver's code. assert custom_resolver or custom_dns_resolver def resolve(address): addresses = [":".join(map(str, address))] if custom_resolver: key = backend.next_key() backend.send_response("ResolverResolutionRequired", { "id": key, "address": addresses[0] }) if not backend.process_request(): # connection was closed before end of next message return [] if key not in backend.custom_resolutions: raise RuntimeError( "Backend did not receive expected " "ResolverResolutionCompleted message for id %s" % key ) addresses = backend.custom_resolutions.pop(key) if custom_dns_resolver: dns_resolved_addresses = [] for address in addresses: key = backend.next_key() address = address.rsplit(":", 1) backend.send_response("DomainNameResolutionRequired", { "id": key, "name": address[0] }) if not backend.process_request(): # connection was closed before end of next message return [] if key not in backend.dns_resolutions: raise RuntimeError( "Backend did not receive expected " "DomainNameResolutionCompleted message for id %s" % key ) dns_resolved_addresses += list(map( lambda a: ":".join((a, *address[1:])), backend.dns_resolutions.pop(key) )) addresses = dns_resolved_addresses return list(map(neo4j.Address.parse, addresses)) return resolve def ResolverResolutionCompleted(backend, data): backend.custom_resolutions[data["requestId"]] = data["addresses"] def DomainNameResolutionCompleted(backend, data): backend.dns_resolutions[data["requestId"]] = data["addresses"] def NewBookmarkManager(backend, data): bookmark_manager_id = backend.next_key() bmm_kwargs = {} data.mark_item_as_read("initialBookmarks", recursive=True) bmm_kwargs["initial_bookmarks"] = data.get("initialBookmarks") if data.get("bookmarksSupplierRegistered"): bmm_kwargs["bookmarks_supplier"] = bookmarks_supplier( backend, bookmark_manager_id ) if data.get("bookmarksConsumerRegistered"): bmm_kwargs["bookmarks_consumer"] = bookmarks_consumer( backend, bookmark_manager_id ) with warning_check( neo4j.ExperimentalWarning, "The bookmark manager feature is experimental. It might be changed or " "removed any time even without prior notice." ): bookmark_manager = neo4j.GraphDatabase.bookmark_manager( **bmm_kwargs ) backend.bookmark_managers[bookmark_manager_id] = bookmark_manager backend.send_response("BookmarkManager", {"id": bookmark_manager_id}) def BookmarkManagerClose(backend, data): bookmark_manager_id = data["id"] del backend.bookmark_managers[bookmark_manager_id] backend.send_response("BookmarkManager", {"id": bookmark_manager_id}) def bookmarks_supplier(backend, bookmark_manager_id): def supplier(database): key = backend.next_key() backend.send_response("BookmarksSupplierRequest", { "id": key, "bookmarkManagerId": bookmark_manager_id, "database": database }) if not backend.process_request(): # connection was closed before end of next message return [] if key not in backend.bookmarks_supplies: raise RuntimeError( "Backend did not receive expected " "BookmarksSupplierCompleted message for id %s" % key ) return backend.bookmarks_supplies.pop(key) return supplier def BookmarksSupplierCompleted(backend, data): backend.bookmarks_supplies[data["requestId"]] = \ neo4j.Bookmarks.from_raw_values(data["bookmarks"]) def bookmarks_consumer(backend, bookmark_manager_id): def consumer(database, bookmarks): key = backend.next_key() backend.send_response("BookmarksConsumerRequest", { "id": key, "bookmarkManagerId": bookmark_manager_id, "database": database, "bookmarks": list(bookmarks.raw_values) }) if not backend.process_request(): # connection was closed before end of next message return [] if key not in backend.bookmarks_consumptions: raise RuntimeError( "Backend did not receive expected " "BookmarksConsumerCompleted message for id %s" % key ) del backend.bookmarks_consumptions[key] return consumer def BookmarksConsumerCompleted(backend, data): backend.bookmarks_consumptions[data["requestId"]] = True def DriverClose(backend, data): key = data["driverId"] driver = backend.drivers[key] driver.close() backend.send_response("Driver", {"id": key}) def CheckDriverIsEncrypted(backend, data): key = data["driverId"] driver = backend.drivers[key] backend.send_response("DriverIsEncrypted", { "encrypted": driver.encrypted }) class SessionTracker: """ Keeps some extra state about the tracked session """ def __init__(self, session): self.session = session self.state = "" self.error_id = "" def NewSession(backend, data): driver = backend.drivers[data["driverId"]] access_mode = data["accessMode"] if access_mode == "r": access_mode = neo4j.READ_ACCESS elif access_mode == "w": access_mode = neo4j.WRITE_ACCESS else: raise ValueError("Unknown access mode:" + access_mode) config = { "default_access_mode": access_mode, "database": data["database"], } if data.get("bookmarks") is not None: config["bookmarks"] = neo4j.Bookmarks.from_raw_values( data["bookmarks"] ) if data.get("bookmarkManagerId") is not None: config["bookmark_manager"] = backend.bookmark_managers[ data["bookmarkManagerId"] ] for (conf_name, data_name) in ( ("fetch_size", "fetchSize"), ("impersonated_user", "impersonatedUser"), ): if data_name in data: config[conf_name] = data[data_name] if "bookmark_manager" in config: with warning_check( neo4j.ExperimentalWarning, "The 'bookmark_manager' config key is experimental. It might be " "changed or removed any time even without prior notice." ): session = driver.session(**config) else: session = driver.session(**config) key = backend.next_key() backend.sessions[key] = SessionTracker(session) backend.send_response("Session", {"id": key}) def SessionRun(backend, data): session = backend.sessions[data["sessionId"]].session query, params = fromtestkit.to_query_and_params(data) result = session.run(query, parameters=params) key = backend.next_key() backend.results[key] = result backend.send_response("Result", {"id": key, "keys": result.keys()}) def SessionClose(backend, data): key = data["sessionId"] session = backend.sessions[key].session session.close() del backend.sessions[key] backend.send_response("Session", {"id": key}) def SessionBeginTransaction(backend, data): key = data["sessionId"] session = backend.sessions[key].session tx_kwargs = fromtestkit.to_tx_kwargs(data) tx = session.begin_transaction(**tx_kwargs) key = backend.next_key() backend.transactions[key] = tx backend.send_response("Transaction", {"id": key}) def SessionReadTransaction(backend, data): transactionFunc(backend, data, True) def SessionWriteTransaction(backend, data): transactionFunc(backend, data, False) def transactionFunc(backend, data, is_read): key = data["sessionId"] session_tracker = backend.sessions[key] session = session_tracker.session tx_kwargs = fromtestkit.to_tx_kwargs(data) @neo4j.unit_of_work(**tx_kwargs) def func(tx): txkey = backend.next_key() backend.transactions[txkey] = tx session_tracker.state = '' backend.send_response("RetryableTry", {"id": txkey}) cont = True while cont: cont = backend.process_request() if session_tracker.state == '+': cont = False elif session_tracker.state == '-': if session_tracker.error_id: raise backend.errors[session_tracker.error_id] else: raise FrontendError("Client said no") if is_read: session.execute_read(func) else: session.execute_write(func) backend.send_response("RetryableDone", {}) def RetryablePositive(backend, data): key = data["sessionId"] session_tracker = backend.sessions[key] session_tracker.state = '+' def RetryableNegative(backend, data): key = data["sessionId"] session_tracker = backend.sessions[key] session_tracker.state = '-' session_tracker.error_id = data.get('errorId', '') def SessionLastBookmarks(backend, data): key = data["sessionId"] session = backend.sessions[key].session bookmarks = session.last_bookmarks() backend.send_response("Bookmarks", {"bookmarks": list(bookmarks.raw_values)}) def TransactionRun(backend, data): key = data["txId"] tx = backend.transactions[key] cypher, params = fromtestkit.to_cypher_and_params(data) result = tx.run(cypher, parameters=params) key = backend.next_key() backend.results[key] = result backend.send_response("Result", {"id": key, "keys": result.keys()}) def TransactionCommit(backend, data): key = data["txId"] tx = backend.transactions[key] try: commit = tx.commit except AttributeError as e: raise MarkdAsDriverException(e) # raise DriverError("Type does not support commit %s" % type(tx)) commit() backend.send_response("Transaction", {"id": key}) def TransactionRollback(backend, data): key = data["txId"] tx = backend.transactions[key] try: rollback = tx.rollback except AttributeError as e: raise MarkdAsDriverException(e) # raise DriverError("Type does not support rollback %s" % type(tx)) rollback() backend.send_response("Transaction", {"id": key}) def TransactionClose(backend, data): key = data["txId"] tx = backend.transactions[key] try: close = tx.close except AttributeError as e: raise MarkdAsDriverException(e) # raise DriverError("Type does not support close %s" % type(tx)) close() backend.send_response("Transaction", {"id": key}) def ResultNext(backend, data): result = backend.results[data["resultId"]] try: record = Util.next(Util.iter(result)) except StopIteration: backend.send_response("NullRecord", {}) return backend.send_response("Record", totestkit.record(record)) def ResultSingle(backend, data): result = backend.results[data["resultId"]] backend.send_response("Record", totestkit.record( result.single(strict=True) )) def ResultSingleOptional(backend, data): result = backend.results[data["resultId"]] with warnings.catch_warnings(record=True) as warning_list: warnings.simplefilter("always") record = result.single(strict=False) if record: record = totestkit.record(record) backend.send_response("RecordOptional", { "record": record, "warnings": list(map(str, warning_list)) }) def ResultPeek(backend, data): result = backend.results[data["resultId"]] record = result.peek() if record is not None: backend.send_response("Record", totestkit.record(record)) else: backend.send_response("NullRecord", {}) def ResultList(backend, data): result = backend.results[data["resultId"]] records = Util.list(result) backend.send_response("RecordList", { "records": [totestkit.record(r) for r in records] }) def ResultConsume(backend, data): result = backend.results[data["resultId"]] summary = result.consume() from neo4j import ResultSummary assert isinstance(summary, ResultSummary) backend.send_response("Summary", { "serverInfo": { "address": ":".join(map(str, summary.server.address)), "agent": summary.server.agent, "protocolVersion": ".".join(map(str, summary.server.protocol_version)), }, "counters": None if not summary.counters else { "constraintsAdded": summary.counters.constraints_added, "constraintsRemoved": summary.counters.constraints_removed, "containsSystemUpdates": summary.counters.contains_system_updates, "containsUpdates": summary.counters.contains_updates, "indexesAdded": summary.counters.indexes_added, "indexesRemoved": summary.counters.indexes_removed, "labelsAdded": summary.counters.labels_added, "labelsRemoved": summary.counters.labels_removed, "nodesCreated": summary.counters.nodes_created, "nodesDeleted": summary.counters.nodes_deleted, "propertiesSet": summary.counters.properties_set, "relationshipsCreated": summary.counters.relationships_created, "relationshipsDeleted": summary.counters.relationships_deleted, "systemUpdates": summary.counters.system_updates, }, "database": summary.database, "notifications": summary.notifications, "plan": summary.plan, "profile": summary.profile, "query": { "text": summary.query, "parameters": {k: totestkit.field(v) for k, v in summary.parameters.items()}, }, "queryType": summary.query_type, "resultAvailableAfter": summary.result_available_after, "resultConsumedAfter": summary.result_consumed_after, }) def ForcedRoutingTableUpdate(backend, data): driver_id = data["driverId"] driver = backend.drivers[driver_id] database = data["database"] bookmarks = data["bookmarks"] with driver._pool.refresh_lock: driver._pool.update_routing_table( database=database, imp_user=None, bookmarks=bookmarks ) backend.send_response("Driver", {"id": driver_id}) def GetRoutingTable(backend, data): driver_id = data["driverId"] database = data["database"] driver = backend.drivers[driver_id] routing_table = driver._pool.routing_tables[database] response_data = { "database": routing_table.database, "ttl": routing_table.ttl, } for role in ("routers", "readers", "writers"): addresses = routing_table.__getattribute__(role) response_data[role] = list(map(str, addresses)) backend.send_response("RoutingTable", response_data) neo4j-python-driver-5.2.1/testkitbackend/_warning_check.py000066400000000000000000000042641433522662700237000ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 import warnings from contextlib import contextmanager @contextmanager def warning_check(category, message): with warnings.catch_warnings(record=True) as warn_log: warnings.filterwarnings("always", category=category, message=message) yield if len(warn_log) != 1: raise AssertionError("Expected 1 warning, found %d: %s" % (len(warn_log), warn_log)) @contextmanager def warnings_check(category_message_pairs): with warnings.catch_warnings(record=True) as warn_log: for category, message in category_message_pairs: warnings.filterwarnings("always", category=category, message=message) yield if len(warn_log) != len(category_message_pairs): raise AssertionError( "Expected %d warnings, found %d: %s" % (len(category_message_pairs), len(warn_log), warn_log) ) category_message_pairs = [ (category, re.compile(message, re.I)) for category, message in category_message_pairs ] for category, matcher in category_message_pairs: match = None for i, warning in enumerate(warn_log): if ( warning.category == category and matcher.match(warning.message.args[0]) ): match = i break if match is None: raise AssertionError( "Expected warning not found: %r %r" % (category, matcher.pattern) ) warn_log.pop(match) neo4j-python-driver-5.2.1/testkitbackend/backend.py000066400000000000000000000041701433522662700223220ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. class Request(dict): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self._seen_keys = set() def __getitem__(self, item): self._seen_keys.add(item) return super().__getitem__(item) def get(self, item, default=None): self._seen_keys.add(item) return super(Request, self).get(item, default) def mark_all_as_read(self, recursive=False): self._seen_keys = set(self.keys()) if recursive: for val in self.values(): if isinstance(val, Request): val.mark_all_as_read(recursive=True) def mark_item_as_read(self, item, recursive=False): self._seen_keys.add(item) if recursive: value = super().__getitem__(item) if isinstance(value, Request): value.mark_all_as_read(recursive=True) def mark_item_as_read_if_equals(self, item, value, recursive=False): if super().__getitem__(item) == value: self.mark_item_as_read(item, recursive=recursive) @property def unseen_keys(self): assert not any(isinstance(v, dict) and not isinstance(v, Request) for v in self.values()) unseen = set(self.keys()) - self._seen_keys for k, v in self.items(): if isinstance(v, Request): unseen.update(k + "." + u for u in v.unseen_keys) return unseen @property def seen_all_keys(self): return not self.unseen_keys neo4j-python-driver-5.2.1/testkitbackend/exceptions.py000066400000000000000000000015111433522662700231100ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. class MarkdAsDriverException(Exception): """ Wrap any error as DriverException """ def __init__(self, wrapped_exc): super().__init__() self.wrapped_exc = wrapped_exc neo4j-python-driver-5.2.1/testkitbackend/fromtestkit.py000066400000000000000000000121471433522662700233110ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 datetime import timedelta import pytz from neo4j import Query from neo4j.spatial import ( CartesianPoint, WGS84Point, ) from neo4j.time import ( Date, DateTime, Duration, Time, ) def to_cypher_and_params(data): from .backend import Request params = data["params"] # Optional if params is None: return data["cypher"], None # Transform the params to Python native params_dict = {p: to_param(params[p]) for p in params} return data["cypher"], params_dict def to_tx_kwargs(data): from .backend import Request kwargs = {} if "txMeta" in data: kwargs["metadata"] = data["txMeta"] if isinstance(kwargs["metadata"], Request): kwargs["metadata"].mark_all_as_read() if "timeout" in data: kwargs["timeout"] = data["timeout"] if kwargs["timeout"] is not None: kwargs["timeout"] /= 1000 return kwargs def to_query_and_params(data): cypher, param = to_cypher_and_params(data) tx_kwargs = to_tx_kwargs(data) query = Query(cypher, **tx_kwargs) return query, param def to_param(m): """ Converts testkit parameter format to driver (python) parameter """ data = m["data"] name = m["name"] if name == "CypherNull": if data["value"] is not None: raise ValueError("CypherNull should be None") return None if name == "CypherString": return str(data["value"]) if name == "CypherBool": return bool(data["value"]) if name == "CypherInt": return int(data["value"]) if name == "CypherFloat": return float(data["value"]) if name == "CypherString": return str(data["value"]) if name == "CypherBytes": return bytearray([int(byte, 16) for byte in data["value"].split()]) if name == "CypherList": return [to_param(v) for v in data["value"]] if name == "CypherMap": return {k: to_param(data["value"][k]) for k in data["value"]} if name == "CypherPoint": coords = [data["x"], data["y"]] if data.get("z") is not None: coords.append(data["z"]) if data["system"] == "cartesian": return CartesianPoint(coords) if data["system"] == "wgs84": return WGS84Point(coords) raise ValueError("Unknown point system: {}".format(data["system"])) if name == "CypherDate": return Date(data["year"], data["month"], data["day"]) if name == "CypherTime": tz = None utc_offset_s = data.get("utc_offset_s") if utc_offset_s is not None: utc_offset_m = utc_offset_s // 60 if utc_offset_m * 60 != utc_offset_s: raise ValueError("the used timezone library only supports " "UTC offsets by minutes") tz = pytz.FixedOffset(utc_offset_m) return Time(data["hour"], data["minute"], data["second"], data["nanosecond"], tzinfo=tz) if name == "CypherDateTime": datetime = DateTime( data["year"], data["month"], data["day"], data["hour"], data["minute"], data["second"], data["nanosecond"] ) utc_offset_s = data["utc_offset_s"] timezone_id = data["timezone_id"] if timezone_id is not None: utc_offset = timedelta(seconds=utc_offset_s) tz = pytz.timezone(timezone_id) localized_datetime = tz.localize(datetime, is_dst=False) if localized_datetime.utcoffset() == utc_offset: return localized_datetime localized_datetime = tz.localize(datetime, is_dst=True) if localized_datetime.utcoffset() == utc_offset: return localized_datetime raise ValueError( "cannot localize datetime %s to timezone %s with UTC " "offset %s" % (datetime, timezone_id, utc_offset) ) elif utc_offset_s is not None: utc_offset_m = utc_offset_s // 60 if utc_offset_m * 60 != utc_offset_s: raise ValueError("the used timezone library only supports " "UTC offsets by minutes") tz = pytz.FixedOffset(utc_offset_m) return tz.localize(datetime) return datetime if name == "CypherDuration": return Duration( months=data["months"], days=data["days"], seconds=data["seconds"], nanoseconds=data["nanoseconds"] ) raise ValueError("Unknown param type " + name) neo4j-python-driver-5.2.1/testkitbackend/requirements.txt000066400000000000000000000000271433522662700236420ustar00rootroot00000000000000-r ../requirements.txt neo4j-python-driver-5.2.1/testkitbackend/server.py000066400000000000000000000043121433522662700222370ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 asyncio from socketserver import ( StreamRequestHandler, TCPServer, ) from ._async.backend import AsyncBackend from ._sync.backend import Backend class Server(TCPServer): allow_reuse_address = True def __init__(self, address): class Handler(StreamRequestHandler): def handle(self): backend = Backend(self.rfile, self.wfile) try: while backend.process_request(): pass finally: backend.close() print("Disconnected") super(Server, self).__init__(address, Handler) class AsyncServer: def __init__(self, address): self._address = address self._server = None @staticmethod async def _handler(reader, writer): backend = AsyncBackend(reader, writer) try: while await backend.process_request(): pass finally: writer.close() await backend.close() print("Disconnected") async def start(self): self._server = await asyncio.start_server( self._handler, host=self._address[0], port=self._address[1], limit=float("inf") # this is dirty but works (for now) ) async def serve_forever(self): if not self._server: raise RuntimeError("Server not started") await self._server.serve_forever() def stop(self): if not self._server: raise RuntimeError("Try starting the server before stopping it ;)") self._server.close() neo4j-python-driver-5.2.1/testkitbackend/test_config.json000066400000000000000000000056621433522662700235670ustar00rootroot00000000000000{ "skips": { "stub\\.retry\\.test_retry_clustering\\.TestRetryClustering\\.test_retry_ForbiddenOnReadOnlyDatabase_ChangingWriter": "Test makes assumptions about how verify_connectivity is implemented", "stub\\.authorization\\.test_authorization\\.TestAuthorizationV[0-9x]+\\.test_should_retry_on_auth_expired_on_begin_using_tx_function": "Flaky: test requires the driver to contact servers in a specific order", "stub\\.authorization\\.test_authorization\\.TestAuthorizationV[0-9x]+\\.test_should_fail_on_token_expired_on_begin_using_tx_function": "Flaky: test requires the driver to contact servers in a specific order", "'stub.session_run_parameters.test_session_run_parameters.TestSessionRunParameters.test_empty_query'": "Driver rejects empty queries before sending it to the server", "'stub.server_side_routing.test_server_side_routing.TestServerSideRouting.test_direct_connection_with_url_params'": "Driver emits deprecation warning. Behavior will be unified in 6.0.", "neo4j.datatypes.test_temporal_types.TestDataTypes.test_should_echo_all_timezone_ids": "test_subtest_skips.dt_conversion", "neo4j.datatypes.test_temporal_types.TestDataTypes.test_date_time_cypher_created_tz_id": "test_subtest_skips.tz_id" }, "features": { "Feature:API:BookmarkManager": true, "Feature:API:ConnectionAcquisitionTimeout": true, "Feature:API:Driver:GetServerInfo": true, "Feature:API:Driver.IsEncrypted": true, "Feature:API:Driver.VerifyConnectivity": true, "Feature:API:Liveness.Check": false, "Feature:API:Result.List": true, "Feature:API:Result.Peek": true, "Feature:API:Result.Single": true, "Feature:API:Result.SingleOptional": true, "Feature:API:SSLConfig": true, "Feature:API:SSLSchemes": true, "Feature:API:Type.Spatial": true, "Feature:API:Type.Temporal": true, "Feature:Auth:Bearer": true, "Feature:Auth:Custom": true, "Feature:Auth:Kerberos": true, "Feature:Bolt:3.0": true, "Feature:Bolt:4.1": true, "Feature:Bolt:4.2": true, "Feature:Bolt:4.3": true, "Feature:Bolt:4.4": true, "Feature:Bolt:5.0": true, "Feature:Bolt:Patch:UTC": true, "Feature:Impersonation": true, "Feature:TLS:1.1": "Driver blocks TLS 1.1 for security reasons.", "Feature:TLS:1.2": true, "Feature:TLS:1.3": "Depends on the machine (will be calculated dynamically).", "AuthorizationExpiredTreatment": true, "Optimization:ConnectionReuse": true, "Optimization:EagerTransactionBegin": true, "Optimization:ImplicitDefaultArguments": true, "Optimization:MinimalBookmarksSet": true, "Optimization:MinimalResets": true, "Optimization:PullPipelining": true, "Optimization:ResultListFetchAll": "The idiomatic way to cast to list is indistinguishable from iterating over the result.", "ConfHint:connection.recv_timeout_seconds": true, "Backend:RTFetch": true, "Backend:RTForceUpdate": true } } neo4j-python-driver-5.2.1/testkitbackend/test_subtest_skips.py000066400000000000000000000035761433522662700247050ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. """ Functions to decide whether to run a subtest or not. They take the subtest parameters as arguments and return - a string with describing the reason why the subtest should be skipped - None if the subtest should be run """ import pytz from . import fromtestkit def tz_id(**params): # We could do this automatically, but with an explicit black list we # make sure we know what we test and what we don't. # if params["tz_id"] not in pytz.common_timezones_set: # return ( # "timezone id %s is not supported by the system" % params["tz_id"] # ) if params["tz_id"] in { "SystemV/AST4", "SystemV/AST4ADT", "SystemV/CST6", "SystemV/CST6CDT", "SystemV/EST5", "SystemV/EST5EDT", "SystemV/HST10", "SystemV/MST7", "SystemV/MST7MDT", "SystemV/PST8", "SystemV/PST8PDT", "SystemV/YST9", "SystemV/YST9YDT", }: return ( "timezone id %s is not supported by the system" % params["tz_id"] ) def dt_conversion(**params): dt = params["dt"] try: fromtestkit.to_param(dt) except (pytz.UnknownTimeZoneError, ValueError) as e: return "cannot create desired dt %s: %r" % (dt, e) neo4j-python-driver-5.2.1/testkitbackend/totestkit.py000066400000000000000000000131331433522662700227640ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 math from neo4j.graph import ( Node, Path, Relationship, ) from neo4j.spatial import ( CartesianPoint, WGS84Point, ) from neo4j.time import ( Date, DateTime, Duration, Time, ) from ._warning_check import warning_check def record(rec): fields = [] for f in rec: fields.append(field(f)) return {"values": fields} def field(v): def to(name, val): return {"name": name, "data": {"value": val}} if v is None: return {"name": "CypherNull"} if isinstance(v, bool): return to("CypherBool", v) if isinstance(v, int): return to("CypherInt", v) if isinstance(v, float): if math.isinf(v): return to("CypherFloat", "+Infinity" if v > 0 else "-Infinity") if math.isnan(v): return to("CypherFloat", "NaN") return to("CypherFloat", v) if isinstance(v, str): return to("CypherString", v) if isinstance(v, list) or isinstance(v, frozenset) or isinstance(v, set): ls = [] for x in v: ls.append(field(x)) return to("CypherList", ls) if isinstance(v, dict): mp = {} for k, v in v.items(): mp[k] = field(v) return to("CypherMap", mp) if isinstance(v, (bytes, bytearray)): return to("CypherBytes", " ".join("{:02x}".format(byte) for byte in v)) if isinstance(v, Node): with warning_check( DeprecationWarning, "`id` is deprecated, use `element_id` instead" ): id_ = v.id node = { "id": field(id_), "labels": field(v.labels), "props": field(v._properties), "elementId": field(v.element_id), } return {"name": "Node", "data": node} if isinstance(v, Relationship): with warning_check( DeprecationWarning, "`id` is deprecated, use `element_id` instead" ): id_ = v.id with warning_check( DeprecationWarning, "`id` is deprecated, use `element_id` instead" ): start_id = v.start_node.id with warning_check( DeprecationWarning, "`id` is deprecated, use `element_id` instead" ): end_id = v.end_node.id rel = { "id": field(id_), "startNodeId": field(start_id), "endNodeId": field(end_id), "type": field(v.type), "props": field(v._properties), "elementId": field(v.element_id), "startNodeElementId": field(v.start_node.element_id), "endNodeElementId": field(v.end_node.element_id), } return {"name": "Relationship", "data": rel} if isinstance(v, Path): path = { "nodes": field(list(v.nodes)), "relationships": field(list(v.relationships)), } return {"name": "Path", "data": path} if isinstance(v, CartesianPoint): return { "name": "CypherPoint", "data": { "system": "cartesian", "x": v.x, "y": v.y, "z": getattr(v, "z", None) }, } if isinstance(v, WGS84Point): return { "name": "CypherPoint", "data": { "system": "wgs84", "x": v.x, "y": v.y, "z": getattr(v, "z", None) }, } if isinstance(v, Date): return { "name": "CypherDate", "data": { "year": v.year, "month": v.month, "day": v.day } } if isinstance(v, Time): data = { "hour": v.hour, "minute": v.minute, "second": v.second, "nanosecond": v.nanosecond } if v.tzinfo is not None: data["utc_offset_s"] = v.tzinfo.utcoffset(v).total_seconds() return { "name": "CypherTime", "data": data } if isinstance(v, DateTime): data = { "year": v.year, "month": v.month, "day": v.day, "hour": v.hour, "minute": v.minute, "second": v.second, "nanosecond": v.nanosecond } if v.tzinfo is not None: data["utc_offset_s"] = v.tzinfo.utcoffset(v).total_seconds() for attr in ("zone", "key"): timezone_id = getattr(v.tzinfo, attr, None) if isinstance(timezone_id, str): data["timezone_id"] = timezone_id return { "name": "CypherDateTime", "data": data, } if isinstance(v, Duration): return { "name": "CypherDuration", "data": { "months": v.months, "days": v.days, "seconds": v.seconds, "nanoseconds": v.nanoseconds }, } raise ValueError("Unhandled type:" + str(type(v))) neo4j-python-driver-5.2.1/tests/000077500000000000000000000000001433522662700165225ustar00rootroot00000000000000neo4j-python-driver-5.2.1/tests/__init__.py000066400000000000000000000012011433522662700206250ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. neo4j-python-driver-5.2.1/tests/_async_compat/000077500000000000000000000000001433522662700213415ustar00rootroot00000000000000neo4j-python-driver-5.2.1/tests/_async_compat/__init__.py000066400000000000000000000015471433522662700234610ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 .mark_decorator import ( AsyncTestDecorators, mark_async_test, mark_sync_test, TestDecorators, ) __all__ = [ "AsyncTestDecorators", "mark_async_test", "mark_sync_test", "TestDecorators", ] neo4j-python-driver-5.2.1/tests/_async_compat/mark_decorator.py000066400000000000000000000017201433522662700247070ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest mark_async_test = pytest.mark.asyncio def mark_sync_test(f): return f class AsyncTestDecorators: mark_async_only_test = mark_async_test class TestDecorators: @staticmethod def mark_async_only_test(f): skip_decorator = pytest.mark.skip("Async only test") return skip_decorator(f) neo4j-python-driver-5.2.1/tests/conftest.py000066400000000000000000000110711433522662700207210ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 asyncio import warnings from functools import wraps from os import environ import pytest import pytest_asyncio from neo4j import ( AsyncGraphDatabase, ExperimentalWarning, GraphDatabase, ) from neo4j._exceptions import BoltHandshakeError from neo4j._sync.io import Bolt from neo4j.exceptions import ServiceUnavailable from . import env # from neo4j.debug import watch # # watch("neo4j") @pytest.fixture(scope="session") def uri(): return env.NEO4J_SERVER_URI @pytest.fixture(scope="session") def bolt_uri(uri): if env.NEO4J_SCHEME != "bolt": pytest.skip("Test requires bolt scheme") return uri @pytest.fixture(scope="session") def _forced_bolt_uri(): return f"bolt://{env.NEO4J_HOST}:{env.NEO4J_PORT}" @pytest.fixture(scope="session") def neo4j_uri(): if env.NEO4J_SCHEME != "neo4j": pytest.skip("Test requires neo4j scheme") return uri @pytest.fixture(scope="session") def _forced_neo4j_uri(): return f"neo4j://{env.NEO4J_HOST}:{env.NEO4J_PORT}" @pytest.fixture(scope="session") def auth(): return env.NEO4J_USER, env.NEO4J_PASS @pytest.fixture def driver(uri, auth): with GraphDatabase.driver(uri, auth=auth) as driver: yield driver @pytest.fixture def bolt_driver(bolt_uri, auth): with GraphDatabase.driver(bolt_uri, auth=auth) as driver: yield driver @pytest.fixture def neo4j_driver(neo4j_uri, auth): with GraphDatabase.driver(neo4j_uri, auth=auth) as driver: yield driver @wraps(AsyncGraphDatabase.driver) def get_async_driver(*args, **kwargs): return AsyncGraphDatabase.driver(*args, **kwargs) @pytest_asyncio.fixture async def async_driver(uri, auth): async with get_async_driver(uri, auth=auth) as driver: yield driver @pytest_asyncio.fixture async def async_bolt_driver(bolt_uri, auth): async with get_async_driver(bolt_uri, auth=auth) as driver: yield driver @pytest_asyncio.fixture async def async_neo4j_driver(neo4j_uri, auth): async with get_async_driver(neo4j_uri, auth=auth) as driver: yield driver @pytest.fixture def _forced_bolt_driver(_forced_bolt_uri): with GraphDatabase.driver(_forced_bolt_uri, auth=auth) as driver: yield driver @pytest.fixture def _forced_neo4j_driver(_forced_neo4j_uri): with GraphDatabase.driver(_forced_neo4j_uri, auth=auth) as driver: yield driver @pytest.fixture(scope="session") def server_info(_forced_bolt_driver): return _forced_bolt_driver.get_server_info() @pytest.fixture(scope="session") def bolt_protocol_version(server_info): return server_info.protocol_version def mark_requires_min_bolt_version(version="3.5"): return pytest.mark.skipif( env.NEO4J_VERSION < version, reason=f"requires server version '{version}' or higher, " f"found '{env.NEO4J_VERSION}'" ) def mark_requires_edition(edition): return pytest.mark.skipif( env.NEO4J_EDITION != edition, reason=f"requires server edition '{edition}', " f"found '{env.NEO4J_EDITION}'" ) @pytest.fixture def session(driver): with driver.session() as session: yield session @pytest.fixture def bolt_session(bolt_driver): with bolt_driver.session() as session: yield session @pytest.fixture def neo4j_session(neo4j_driver): with neo4j_driver.session() as session: yield session # async support for pytest-benchmark # https://github.com/ionelmc/pytest-benchmark/issues/66 @pytest_asyncio.fixture async def aio_benchmark(benchmark, event_loop): def _wrapper(func, *args, **kwargs): if asyncio.iscoroutinefunction(func): @benchmark def _(): return event_loop.run_until_complete(func(*args, **kwargs)) else: benchmark(func, *args, **kwargs) return _wrapper @pytest.fixture def watcher(): import sys from neo4j.debug import watch with watch("neo4j", out=sys.stdout, colour=True): yield neo4j-python-driver-5.2.1/tests/env.py000066400000000000000000000053431433522662700176710ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 abc import sys import types import typing as t from os import environ class _LazyEval(abc.ABC): @abc.abstractmethod def eval(self): pass class _LazyEvalEnv(_LazyEval): def __init__(self, env_key, type_: t.Type = str, default=...): self.env_key = env_key self.type_ = type_ self.default = default def eval(self): if self.default is not ...: value = environ.get(self.env_key, default=self.default) else: try: value = environ[self.env_key] except KeyError as e: raise Exception( f"Missing environment variable {self.env_key}" ) from e if self.type_ is bool: return value.lower() in ("yes", "y", "1", "on", "true") if self.type_ is not None: return self.type_(value) class _LazyEvalFunc(_LazyEval): def __init__(self, func): self.func = func def eval(self): return self.func() class _Module: def __init__(self, module): self._module = module def __getattr__(self, item): val = getattr(self._module, item) if isinstance(val, _LazyEval): val = val.eval() setattr(self._module, item, val) return val _module = _Module(sys.modules[__name__]) sys.modules[__name__] = _module # type: ignore[assignment] NEO4J_HOST = _LazyEvalEnv("TEST_NEO4J_HOST") NEO4J_PORT = _LazyEvalEnv("TEST_NEO4J_PORT", int) NEO4J_USER = _LazyEvalEnv("TEST_NEO4J_USER") NEO4J_PASS = _LazyEvalEnv("TEST_NEO4J_PASS") NEO4J_SCHEME = _LazyEvalEnv("TEST_NEO4J_SCHEME") NEO4J_EDITION = _LazyEvalEnv("TEST_NEO4J_EDITION") NEO4J_VERSION = _LazyEvalEnv("TEST_NEO4J_VERSION") NEO4J_IS_CLUSTER = _LazyEvalEnv("TEST_NEO4J_IS_CLUSTER", bool) NEO4J_SERVER_URI = _LazyEvalFunc( lambda: f"{_module.NEO4J_SCHEME}://{_module.NEO4J_HOST}:" f"{_module.NEO4J_PORT}" ) __all__ = ( "NEO4J_HOST", "NEO4J_PORT", "NEO4J_USER", "NEO4J_PASS", "NEO4J_SCHEME", "NEO4J_EDITION", "NEO4J_VERSION", "NEO4J_IS_CLUSTER", "NEO4J_SERVER_URI", ) neo4j-python-driver-5.2.1/tests/integration/000077500000000000000000000000001433522662700210455ustar00rootroot00000000000000neo4j-python-driver-5.2.1/tests/integration/__init__.py000066400000000000000000000000001433522662700231440ustar00rootroot00000000000000neo4j-python-driver-5.2.1/tests/integration/async_/000077500000000000000000000000001433522662700223215ustar00rootroot00000000000000neo4j-python-driver-5.2.1/tests/integration/async_/__init__.py000066400000000000000000000012011433522662700244240ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. neo4j-python-driver-5.2.1/tests/integration/async_/test_custom_ssl_context.py000066400000000000000000000031441433522662700276730ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 ssl import SSLContext import pytest import neo4j from ..._async_compat import mark_async_test @mark_async_test async def test_custom_ssl_context_wraps_connection(uri, auth, mocker): # Test that the driver calls either `.wrap_socket` or `.wrap_bio` on the # provided custom SSL context. class NoNeedToGoFurtherException(Exception): pass def wrap_fail(*_, **__): raise NoNeedToGoFurtherException() fake_ssl_context = mocker.create_autospec(SSLContext) fake_ssl_context.wrap_socket.side_effect = wrap_fail fake_ssl_context.wrap_bio.side_effect = wrap_fail async with neo4j.AsyncGraphDatabase.driver( uri, auth=auth, ssl_context=fake_ssl_context ) as driver: async with driver.session() as session: with pytest.raises(NoNeedToGoFurtherException): await session.run("RETURN 1") assert (fake_ssl_context.wrap_socket.call_count + fake_ssl_context.wrap_bio.call_count) == 1 neo4j-python-driver-5.2.1/tests/integration/conftest.py000066400000000000000000000024661433522662700232540ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest class ForcedRollback(Exception): def __init__(self, return_value): super().__init__() self.return_value = return_value @pytest.fixture def cypher_eval(driver): def run_and_rollback(tx, cypher, **parameters): result = tx.run(cypher, **parameters) value = result.single().value() raise ForcedRollback(value) def f(cypher, **parameters): with driver.session() as session: try: session.execute_write(run_and_rollback, cypher, **parameters) raise RuntimeError("Expected rollback") except ForcedRollback as e: return e.return_value return f neo4j-python-driver-5.2.1/tests/integration/examples/000077500000000000000000000000001433522662700226635ustar00rootroot00000000000000neo4j-python-driver-5.2.1/tests/integration/examples/__init__.py000066400000000000000000000073001433522662700247740ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. # List of example tags used in the drivers manual version 4.0 # hello-world, hello-world-import - Example 1.6. Hello World # driver-lifecycle, driver-lifecycle-import - Example 2.1. The driver lifecycle # custom-resolver, custom-resolver-import - Example 2.2. Custom Address Resolver # basic-auth, basic-auth-import - Example 2.5. Basic authentication # kerberos-auth, kerberos-auth-import - Example 2.6. Kerberos authentication # custom-auth, custom-auth-import - Example 2.7. Custom authentication # config-connection-pool, config-connection-pool-import - Example 2.8. Configure connection pool # config-connection-timeout, config-connection-timeout-import - Example 2.9. Configure connection timeout # config-unencrypted, config-unencrypted-import - Example 2.10. Unencrypted configuration # config-max-retry-time, config-max-retry-time-import - Example 2.11. Configure maximum transaction retry time # config-trust, config-trust-import - Example 2.12. Configure trusted certificates # pass-bookmarks, pass-bookmarks-import - Example 3.1. Pass bookmarks # read-write-transaction - Example 3.2. Read-write transaction # database-selection, database-selection-import - Example 3.3. Database selection on session creation # Hard coded (session) - Example 4.1. Session construction and closure # transaction-function, transaction-function-import - Example 4.2. Transaction function # autocommit-transaction, autocommit-transaction-import - Example 4.3. Simple auto-commit transactions # result-consume - Example 4.4. Consuming results # result-retain - Example 4.5. Retain results for further processing # - Example 4.6. Asynchronous transaction functions # - Example 4.7. Asynchronous auto-commit transactions # - Example 4.8. Asynchronous consuming results # - Example 4.9. Reactive transaction functions # - Example 4.10.Reactive auto-commit transactions # - Example 4.11.Reactive consuming results class DriverSetupExample: driver = None def close(self): if self.driver: self.driver.close() @classmethod def test(cls, *args, **kwargs): example = cls(*args, **kwargs) try: with example.driver.session() as session: assert session.run("RETURN 1").single().value() == 1 finally: example.close() neo4j-python-driver-5.2.1/tests/integration/examples/test_autocommit_transaction_example.py000066400000000000000000000032741433522662700326030ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. # isort: off # tag::autocommit-transaction-import[] from neo4j import Query # end::autocommit-transaction-import[] # isort: on # python -m pytest tests/integration/examples/test_autocommit_transaction_example.py -s -v class AutocommitTransactionExample: def __init__(self, driver): self.driver = driver # tag::autocommit-transaction[] def add_person(self, name): with self.driver.session() as session: session.run("CREATE (a:Person {name: $name})", name=name) # Alternative implementation, with a one second timeout def add_person_within_a_second(self, name): with self.driver.session() as session: session.run(Query("CREATE (a:Person {name: $name})", timeout=1.0), name=name) # end::autocommit-transaction[] def test_example(driver): eg = AutocommitTransactionExample(driver) with eg.driver.session() as session: session.run("MATCH (_) DETACH DELETE _") eg.add_person("Alice") n = session.run("MATCH (a:Person) RETURN count(a)").single().value() assert n == 1 neo4j-python-driver-5.2.1/tests/integration/examples/test_basic_auth_example.py000066400000000000000000000026371433522662700301210ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j._exceptions import BoltHandshakeError from neo4j.exceptions import ServiceUnavailable from . import DriverSetupExample # isort: off # tag::basic-auth-import[] from neo4j import GraphDatabase # end::basic-auth-import[] # isort: on # python -m pytest tests/integration/examples/test_basic_auth_example.py -s -v class BasicAuthExample(DriverSetupExample): # tag::basic-auth[] def __init__(self, uri, user, password): self.driver = GraphDatabase.driver(uri, auth=(user, password)) # end::basic-auth[] def test_example(uri, auth): try: BasicAuthExample.test(uri, user=auth[0], password=auth[1]) except ServiceUnavailable as error: if isinstance(error.__cause__, BoltHandshakeError): pytest.skip(error.args[0]) neo4j-python-driver-5.2.1/tests/integration/examples/test_bearer_auth_example.py000066400000000000000000000034251433522662700302740ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 neo4j from . import DriverSetupExample # isort: off # tag::bearer-auth-import[] from neo4j import ( bearer_auth, GraphDatabase, ) # end::bearer-auth-import[] # isort: on # python -m pytest tests/integration/examples/test_bearer_auth_example.py -s -v class BearerAuthExample(DriverSetupExample): # tag::bearer-auth[] def __init__(self, uri, token): self.driver = GraphDatabase.driver(uri, auth=bearer_auth(token)) # end::bearer-auth[] def test_example(uri, mocker): # Currently, there is no way of running the test against a server with SSO # setup. mocker.patch("neo4j.GraphDatabase.bolt_driver") mocker.patch("neo4j.GraphDatabase.neo4j_driver") token = "myToken" BearerAuthExample(uri, token) calls = (neo4j.GraphDatabase.bolt_driver.call_args_list + neo4j.GraphDatabase.neo4j_driver.call_args_list) assert len(calls) == 1 args_, kwargs = calls[0] auth = kwargs.get("auth") assert isinstance(auth, neo4j.Auth) assert auth.scheme == "bearer" assert not hasattr(auth, "principal") assert auth.credentials == token assert not hasattr(auth, "parameters") neo4j-python-driver-5.2.1/tests/integration/examples/test_config_connection_pool_example.py000066400000000000000000000032371433522662700325310ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j._exceptions import BoltHandshakeError from neo4j.exceptions import ServiceUnavailable from . import DriverSetupExample # isort: off # tag::config-connection-pool-import[] from neo4j import GraphDatabase # end::config-connection-pool-import[] # isort: on # python -m pytest tests/integration/examples/test_config_connection_pool_example.py -s -v class ConfigConnectionPoolExample(DriverSetupExample): # tag::config-connection-pool[] def __init__(self, uri, auth): self.driver = GraphDatabase.driver(uri, auth=auth, max_connection_lifetime=30 * 60, max_connection_pool_size=50, connection_acquisition_timeout=2 * 60) # end::config-connection-pool[] def test(uri, auth): try: ConfigConnectionPoolExample.test(uri, auth) except ServiceUnavailable as error: if isinstance(error.__cause__, BoltHandshakeError): pytest.skip(error.args[0]) neo4j-python-driver-5.2.1/tests/integration/examples/test_config_connection_timeout_example.py000066400000000000000000000027451433522662700332510ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j._exceptions import BoltHandshakeError from neo4j.exceptions import ServiceUnavailable from . import DriverSetupExample # isort: off # tag::config-connection-timeout-import[] from neo4j import GraphDatabase # end::config-connection-timeout-import[] # isort: on # python -m pytest tests/integration/examples/test_config_connection_timeout_example.py -s -v class ConfigConnectionTimeoutExample(DriverSetupExample): # tag::config-connection-timeout[] def __init__(self, uri, auth): self.driver = GraphDatabase.driver(uri, auth=auth, connection_timeout=15) # end::config-connection-timeout[] def test(uri, auth): try: ConfigConnectionTimeoutExample.test(uri, auth) except ServiceUnavailable as error: if isinstance(error.__cause__, BoltHandshakeError): pytest.skip(error.args[0]) neo4j-python-driver-5.2.1/tests/integration/examples/test_config_max_retry_time_example.py000066400000000000000000000027171433522662700323730ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j._exceptions import BoltHandshakeError from neo4j.exceptions import ServiceUnavailable from . import DriverSetupExample # isort: off # tag::config-max-retry-time-import[] from neo4j import GraphDatabase # end::config-max-retry-time-import[] # isort: on # python -m pytest tests/integration/examples/test_config_max_retry_time_example.py -s -v class ConfigMaxRetryTimeExample(DriverSetupExample): # tag::config-max-retry-time[] def __init__(self, uri, auth): self.driver = GraphDatabase.driver(uri, auth=auth, max_transaction_retry_time=15) # end::config-max-retry-time[] def test(uri, auth): try: ConfigMaxRetryTimeExample.test(uri, auth) except ServiceUnavailable as error: if isinstance(error.__cause__, BoltHandshakeError): pytest.skip(error.args[0]) neo4j-python-driver-5.2.1/tests/integration/examples/test_config_secure_example.py000066400000000000000000000036471433522662700306340ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j._exceptions import BoltHandshakeError from neo4j.exceptions import ServiceUnavailable from . import DriverSetupExample # isort: off # tag::config-secure-import[] import neo4j from neo4j import GraphDatabase # end::config-secure-import[] # isort: off # python -m pytest tests/integration/examples/test_config_secure_example.py -s -v class ConfigSecureExample(DriverSetupExample): # tag::config-secure[] def __init__(self, uri, auth): # trusted_certificates: # neo4j.TrustSystemCAs() # (default) trust certificates from system store # neo4j.TrustAll() # trust all certificates # neo4j.TrustCustomCAs("", ...) # specify a list of paths to certificates to trust self.driver = GraphDatabase.driver( uri, auth=auth, encrypted=True, trusted_certificates=neo4j.TrustSystemCAs(), ) # or omit trusted_certificates as None is the default # end::config-secure[] def test_example(uri, auth): pytest.skip("re-enable when we can test with encrypted=True on Docker") try: ConfigSecureExample.test(uri, auth) except ServiceUnavailable as error: if isinstance(error.__cause__, BoltHandshakeError): pytest.skip(error.args[0]) neo4j-python-driver-5.2.1/tests/integration/examples/test_config_trust_example.py000066400000000000000000000031261433522662700305170ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from . import DriverSetupExample # isort: off # tag::config-trust-import[] import neo4j from neo4j import GraphDatabase # end::config-trust-import[] # isort: on class ConfigTrustExample(DriverSetupExample): # tag::config-trust[] def __init__(self, uri, auth): # trusted_certificates: # neo4j.TrustSystemCAs() # (default) trust certificates from system store) # neo4j.TrustAll() # trust all certificates # neo4j.TrustCustomCAs("", ...) # specify a list of paths to certificates to trust self.driver = GraphDatabase.driver( uri, auth=auth, encrypted=True, trusted_certificates=neo4j.TrustAll() ) # end::config-trust[] def test_example(uri, auth): # TODO: re-enable when we can test with encrypted=True on Docker # ConfigTrustExample.test(uri, auth) pytest.skip("re-enable when we can test with encrypted=True on Docker") neo4j-python-driver-5.2.1/tests/integration/examples/test_config_unencrypted_example.py000066400000000000000000000026701433522662700317010ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j._exceptions import BoltHandshakeError from neo4j.exceptions import ServiceUnavailable from . import DriverSetupExample # isort: off # tag::config-unencrypted-import[] from neo4j import GraphDatabase # end::config-unencrypted-import[] # isort: on # python -m pytest tests/integration/examples/test_config_unencrypted_example.py -s -v class ConfigUnencryptedExample(DriverSetupExample): # tag::config-unencrypted[] def __init__(self, uri, auth): self.driver = GraphDatabase.driver(uri, auth=auth, encrypted=False) # end::config-unencrypted[] def test_example(uri, auth): try: ConfigUnencryptedExample.test(uri, auth) except ServiceUnavailable as error: if isinstance(error.__cause__, BoltHandshakeError): pytest.skip(error.args[0]) neo4j-python-driver-5.2.1/tests/integration/examples/test_custom_auth_example.py000066400000000000000000000030671433522662700303500ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j._exceptions import BoltHandshakeError from neo4j.exceptions import ServiceUnavailable from . import DriverSetupExample # isort: off # tag::custom-auth-import[] from neo4j import ( GraphDatabase, custom_auth, ) # end::custom-auth-import[] # isort: on # python -m pytest tests/integration/examples/test_custom_auth_example.py -s -v class CustomAuthExample(DriverSetupExample): # tag::custom-auth[] def __init__(self, uri, principal, credentials, realm, scheme, **parameters): auth = custom_auth(principal, credentials, realm, scheme, **parameters) self.driver = GraphDatabase.driver(uri, auth=auth) # end::custom-auth[] def test_example(uri, auth): try: CustomAuthExample.test(uri, auth[0], auth[1], None, "basic", key="value") except ServiceUnavailable as error: if isinstance(error.__cause__, BoltHandshakeError): pytest.skip(error.args[0]) neo4j-python-driver-5.2.1/tests/integration/examples/test_custom_resolver_example.py000066400000000000000000000040341433522662700312430ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j._exceptions import BoltHandshakeError from neo4j.exceptions import ServiceUnavailable # isort: off # tag::custom-resolver-import[] from neo4j import ( GraphDatabase, WRITE_ACCESS, ) # end::custom-resolver-import[] # isort: on # python -m pytest tests/integration/examples/test_custom_resolver_example.py -s -v # tag::custom-resolver[] def create_driver(uri, user, password): def resolver(address): host, port = address if host == "x.example.com": yield "a.example.com", port yield "b.example.com", port yield "c.example.com", port else: yield host, port return GraphDatabase.driver(uri, auth=(user, password), resolver=resolver) def add_person(name): driver = create_driver("neo4j://x.example.com", user="neo4j", password="password") try: with driver.session(default_access_mode=WRITE_ACCESS) as session: session.run("CREATE (a:Person {name: $name})", {"name", name}) finally: driver.close() # end::custom-resolver[] def test_example(uri, auth): try: add_person("testing_resolver") except ServiceUnavailable as error: if isinstance(error.__cause__, BoltHandshakeError): pytest.skip(error.args[0]) except ValueError as error: assert error.args[0] == "Cannot resolve address a.example.com:7687" neo4j-python-driver-5.2.1/tests/integration/examples/test_cypher_error_example.py000066400000000000000000000031661433522662700305200ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 contextlib import redirect_stdout from io import StringIO # isort: off # tag::cypher-error-import[] from neo4j.exceptions import ClientError # end::cypher-error-import[] # isort: on class Neo4jErrorExample: def __init__(self, driver): self.driver = driver # tag::cypher-error[] def get_employee_number(self, name): with self.driver.session() as session: try: session.execute_read(self.select_employee, name) except ClientError as error: print(error.message) return -1 @staticmethod def select_employee(tx, name): result = tx.run("SELECT * FROM Employees WHERE name = $name", name=name) return result.single()["employee_number"] # end::cypher-error[] def test_example(driver): s = StringIO() with redirect_stdout(s): example = Neo4jErrorExample(driver) example.get_employee_number('Alice') assert s.getvalue().startswith("Invalid input") neo4j-python-driver-5.2.1/tests/integration/examples/test_database_selection_example.py000066400000000000000000000046241433522662700316260ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 contextlib import redirect_stdout from io import StringIO from ...conftest import ( mark_requires_edition, mark_requires_min_bolt_version, ) # isort: off # tag::database-selection-import[] from neo4j import ( GraphDatabase, READ_ACCESS, ) # end::database-selection-import[] # isort: on # python -m pytest tests/integration/examples/test_database_selection_example.py -s -v class DatabaseSelectionExample: def __init__(self, uri, user, password): self.driver = GraphDatabase.driver(uri, auth=(user, password)) with self.driver.session(database="system") as session: session.run("DROP DATABASE example IF EXISTS WAIT").consume() session.run("CREATE DATABASE example WAIT").consume() def close(self): with self.driver.session(database="system") as session: session.run("DROP DATABASE example WAIT").consume() self.driver.close() def run_example_code(self): driver = self.driver # tag::database-selection[] with driver.session(database="example") as session: session.run("CREATE (a:Greeting {message: 'Hello, Example-Database'}) RETURN a").consume() with driver.session(database="example", default_access_mode=READ_ACCESS) as session: message = session.run("MATCH (a:Greeting) RETURN a.message as msg").single().get("msg") print(message) # end::database-selection[] @mark_requires_min_bolt_version("4") @mark_requires_edition("enterprise") def test_database_selection_example(uri, auth): s = StringIO() with redirect_stdout(s): example = DatabaseSelectionExample(uri, auth[0], auth[1]) example.run_example_code() example.close() assert s.getvalue().startswith("Hello, Example-Database") neo4j-python-driver-5.2.1/tests/integration/examples/test_driver_introduction_example.py000066400000000000000000000115321433522662700321050ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 contextlib import redirect_stdout from io import StringIO import pytest from neo4j._exceptions import BoltHandshakeError # isort: off # tag::driver-introduction-example-import[] import logging import sys from neo4j import GraphDatabase from neo4j.exceptions import ServiceUnavailable # end::driver-introduction-example-import[] # isort: on # python -m pytest tests/integration/examples/test_driver_introduction_example.py -s -v # tag::driver-introduction-example[] class App: def __init__(self, uri, user, password): self.driver = GraphDatabase.driver(uri, auth=(user, password)) def close(self): # Don't forget to close the driver connection when you are finished with it self.driver.close() @staticmethod def enable_log(level, output_stream): handler = logging.StreamHandler(output_stream) handler.setLevel(level) logging.getLogger("neo4j").addHandler(handler) logging.getLogger("neo4j").setLevel(level) def create_friendship(self, person1_name, person2_name, knows_from): with self.driver.session() as session: # Write transactions allow the driver to handle retries and transient errors result = session.execute_write( self._create_and_return_friendship, person1_name, person2_name, knows_from) for row in result: print("Created friendship between: {p1}, {p2} from {knows_from}" .format( p1=row['p1'], p2=row['p2'], knows_from=row["knows_from"])) @staticmethod def _create_and_return_friendship(tx, person1_name, person2_name, knows_from): # To learn more about the Cypher syntax, see https://neo4j.com/docs/cypher-manual/current/ # The Reference Card is also a good resource for keywords https://neo4j.com/docs/cypher-refcard/current/ query = ( "CREATE (p1:Person { name: $person1_name }) " "CREATE (p2:Person { name: $person2_name }) " "CREATE (p1)-[k:KNOWS { from: $knows_from }]->(p2) " "RETURN p1, p2, k" ) result = tx.run(query, person1_name=person1_name, person2_name=person2_name, knows_from=knows_from) try: return [{ "p1": row["p1"]["name"], "p2": row["p2"]["name"], "knows_from": row["k"]["from"] } for row in result] # Capture any errors along with the query and data for traceability except ServiceUnavailable as exception: logging.error("{query} raised an error: \n {exception}".format( query=query, exception=exception)) raise def find_person(self, person_name): with self.driver.session() as session: result = session.execute_read(self._find_and_return_person, person_name) for row in result: print("Found person: {row}".format(row=row)) @staticmethod def _find_and_return_person(tx, person_name): query = ( "MATCH (p:Person) " "WHERE p.name = $person_name " "RETURN p.name AS name" ) result = tx.run(query, person_name=person_name) return [row["name"] for row in result] if __name__ == "__main__": bolt_url = "%%BOLT_URL_PLACEHOLDER%%" user = "" password = "" App.enable_log(logging.INFO, sys.stdout) app = App(bolt_url, user, password) app.create_friendship("Alice", "David", "School") app.find_person("Alice") app.close() # end::driver-introduction-example[] def test_driver_introduction_example(uri, auth): try: s = StringIO() with redirect_stdout(s): App.enable_log(logging.INFO, sys.stdout) app = App(uri, auth[0], auth[1]) app.create_friendship("Alice", "David", "School") app.find_person("Alice") app.close() # assert s.getvalue().startswith("Found person: Alice") except ServiceUnavailable as error: if isinstance(error.__cause__, BoltHandshakeError): pytest.skip(error.args[0]) neo4j-python-driver-5.2.1/tests/integration/examples/test_driver_lifecycle_example.py000066400000000000000000000026371433522662700313310ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j._exceptions import BoltHandshakeError from neo4j.exceptions import ServiceUnavailable # isort: off # tag::driver-lifecycle-import[] from neo4j import GraphDatabase # end::driver-lifecycle-import[] # isort: on # python -m pytest tests/integration/examples/test_driver_lifecycle_example.py -s -v # tag::driver-lifecycle[] class DriverLifecycleExample: def __init__(self, uri, auth): self.driver = GraphDatabase.driver(uri, auth=auth) def close(self): self.driver.close() # end::driver-lifecycle[] def test_example(uri, auth): try: eg = DriverLifecycleExample(uri, auth) eg.close() except ServiceUnavailable as error: if isinstance(error.__cause__, BoltHandshakeError): pytest.skip(error.args[0]) neo4j-python-driver-5.2.1/tests/integration/examples/test_geospatial_types_example.py000066400000000000000000000124321433522662700313650ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest # python -m pytest tests/integration/examples/test_geospatial_types_example.py -s -v def _echo(tx, x): return tx.run("RETURN $x AS fieldName", x=x).single() def test_cartesian_point(driver): # isort: off # tag::geospatial-types-cartesian-import[] from neo4j.spatial import CartesianPoint # end::geospatial-types-cartesian-import[] # isort: on # tag::geospatial-types-cartesian[] # Creating a 2D point in Cartesian space point2d = CartesianPoint((1, 5.1)) # Or in 3D point3d = CartesianPoint((1, -2., 3.1)) # end::geospatial-types-cartesian[] # storing points for later assertions in_point2d = point2d in_point3d = point3d with driver.session() as session: record_with_2d_point = session.execute_read(_echo, point2d) record_with_3d_point = session.execute_read(_echo, point3d) # tag::geospatial-types-cartesian[] # Reading a 2D point from a record point2d = record_with_2d_point.get("fieldName") # type: CartesianPoint str(point2d) # POINT(1.0 5.1) point2d.x # 1.0 point2d.y # 5.1 # point2d.z raises AttributeError point2d.srid # 7203 len(point2d) # 2 # Reading a 3D point from a record point3d = record_with_3d_point.get("fieldName") # type: CartesianPoint str(point3d) # POINT(1.0 -2.0 3.1) point3d.x # 1.0 point3d.y # -2.0 point3d.z # 3.1 point3d.srid # 9157 len(point2d) # 3 # end::geospatial-types-cartesian[] assert str(point2d) == "POINT(1.0 5.1)" assert isinstance(point2d.x, float) and point2d.x == 1.0 assert isinstance(point2d.y, float) and point2d.y == 5.1 with pytest.raises(AttributeError): point2d.z assert point2d.srid == 7203 assert len(point2d) == 2 assert point2d == in_point2d assert str(point3d) == "POINT(1.0 -2.0 3.1)" assert isinstance(point3d.x, float) and point3d.x == 1.0 assert isinstance(point3d.y, float) and point3d.y == -2.0 assert isinstance(point3d.z, float) and point3d.z == 3.1 assert point3d.srid == 9157 assert len(point3d) == 3 assert point3d == in_point3d def test_wgs84_point(driver): # isort: off # tag::geospatial-types-wgs84-import[] from neo4j.spatial import WGS84Point # end::geospatial-types-wgs84-import[] # isort: on # tag::geospatial-types-wgs84[] # Creating a 2D point in WSG84 space point2d = WGS84Point((1, 5.1)) # Or in 3D point3d = WGS84Point((1, -2., 3.1)) # end::geospatial-types-wgs84[] # storing points for later assertions in_point2d = point2d in_point3d = point3d with driver.session() as session: record_with_2d_point = session.execute_read(_echo, point2d) record_with_3d_point = session.execute_read(_echo, point3d) # tag::geospatial-types-wgs84[] # Reading a 2D point from a record point2d = record_with_2d_point.get("fieldName") # type: WGS84Point str(point2d) # POINT(1.0 5.1) point2d.longitude # 1.0 (point2d.x is an alias for longitude) point2d.latitude # 5.1 (point2d.y is an alias for latitude) # point2d.height raises AttributeError (same with point2d.z) point2d.srid # 4326 len(point2d) # 2 # Reading a 3D point from a record point3d = record_with_3d_point.get("fieldName") # type: WGS84Point str(point3d) # POINT(1.0 -2.0 3.1) point3d.longitude # 1.0 (point3d.x is an alias for longitude) point3d.latitude # -2.0 (point3d.y is an alias for latitude) point3d.height # 3.1 (point3d.z is an alias for height) point3d.srid # 4979 len(point2d) # 3 # end::geospatial-types-wgs84[] assert str(point2d) == "POINT(1.0 5.1)" assert isinstance(point2d.longitude, float) and point2d.longitude == 1.0 assert isinstance(point2d.x, float) and point2d.x == 1.0 assert isinstance(point2d.latitude, float) and point2d.latitude == 5.1 assert isinstance(point2d.y, float) and point2d.y == 5.1 with pytest.raises(AttributeError): point2d.height with pytest.raises(AttributeError): point2d.z assert point2d.srid == 4326 assert len(point2d) == 2 assert point2d == in_point2d assert str(point3d) == "POINT(1.0 -2.0 3.1)" assert isinstance(point3d.longitude, float) and point3d.longitude == 1.0 assert isinstance(point3d.x, float) and point3d.x == 1.0 assert isinstance(point3d.latitude, float) and point3d.latitude == -2.0 assert isinstance(point3d.y, float) and point3d.y == -2.0 assert isinstance(point3d.height, float) and point3d.height == 3.1 assert isinstance(point3d.z, float) and point3d.z == 3.1 assert point3d.srid == 4979 assert len(point3d) == 3 assert point3d == in_point3d neo4j-python-driver-5.2.1/tests/integration/examples/test_hello_world_example.py000066400000000000000000000046311433522662700303250ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 contextlib import redirect_stdout from io import StringIO import pytest from neo4j._exceptions import BoltHandshakeError from neo4j.exceptions import ServiceUnavailable # isort: off # tag::hello-world-import[] from neo4j import GraphDatabase # end::hello-world-import[] # isort: on # python -m pytest tests/integration/examples/test_hello_world_example.py -s -v # tag::hello-world[] class HelloWorldExample: def __init__(self, uri, user, password): self.driver = GraphDatabase.driver(uri, auth=(user, password)) def close(self): self.driver.close() def print_greeting(self, message): with self.driver.session() as session: greeting = session.execute_write(self._create_and_return_greeting, message) print(greeting) @staticmethod def _create_and_return_greeting(tx, message): result = tx.run("CREATE (a:Greeting) " "SET a.message = $message " "RETURN a.message + ', from node ' + id(a)", message=message) return result.single()[0] if __name__ == "__main__": greeter = HelloWorldExample("bolt://localhost:7687", "neo4j", "password") greeter.print_greeting("hello, world") greeter.close() # end::hello-world[] # tag::hello-world-output[] # hello, world, from node 1234 # end::hello-world-output[] def test_hello_world_example(uri, auth): try: s = StringIO() with redirect_stdout(s): example = HelloWorldExample(uri, auth[0], auth[1]) example.print_greeting("hello, world") example.close() assert s.getvalue().startswith("hello, world, from node ") except ServiceUnavailable as error: if isinstance(error.__cause__, BoltHandshakeError): pytest.skip(error.args[0]) neo4j-python-driver-5.2.1/tests/integration/examples/test_kerberos_auth_example.py000066400000000000000000000023011433522662700306400ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from . import DriverSetupExample # isort: off # tag::kerberos-auth-import[] from neo4j import ( GraphDatabase, kerberos_auth, ) # end::kerberos-auth-import[] # isort: on # python -m pytest tests/integration/examples/test_kerberos_auth_example.py -s -v class KerberosAuthExample(DriverSetupExample): # tag::kerberos-auth[] def __init__(self, uri, ticket): self._driver = GraphDatabase.driver(uri, auth=kerberos_auth(ticket)) # end::kerberos-auth[] def test_example(): pytest.skip("Currently no way to test Kerberos auth") neo4j-python-driver-5.2.1/tests/integration/examples/test_pass_bookmarks_example.py000066400000000000000000000073561433522662700310400ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j._exceptions import BoltHandshakeError from neo4j.exceptions import ServiceUnavailable # isort: off # tag::pass-bookmarks-import[] from neo4j import ( Bookmarks, GraphDatabase, ) # end::pass-bookmarks-import[] # isort: on # python -m pytest tests/integration/examples/test_pass_bookmarks_example.py -s -v # tag::pass-bookmarks[] class BookmarksExample: def __init__(self, uri, auth): self.driver = GraphDatabase.driver(uri, auth=auth) def close(self): self.driver.close() # Create a person node. @classmethod def create_person(cls, tx, name): tx.run("CREATE (:Person {name: $name})", name=name) # Create an employment relationship to a pre-existing company node. # This relies on the person first having been created. @classmethod def employ(cls, tx, person_name, company_name): tx.run("MATCH (person:Person {name: $person_name}) " "MATCH (company:Company {name: $company_name}) " "CREATE (person)-[:WORKS_FOR]->(company)", person_name=person_name, company_name=company_name) # Create a friendship between two people. @classmethod def create_friendship(cls, tx, name_a, name_b): tx.run("MATCH (a:Person {name: $name_a}) " "MATCH (b:Person {name: $name_b}) " "MERGE (a)-[:KNOWS]->(b)", name_a=name_a, name_b=name_b) # Match and display all friendships. @classmethod def print_friendships(cls, tx): result = tx.run("MATCH (a)-[:KNOWS]->(b) RETURN a.name, b.name") for record in result: print("{} knows {}".format(record["a.name"], record["b.name"])) def main(self): saved_bookmarks = Bookmarks() # To collect the session bookmarks # Create the first person and employment relationship. with self.driver.session() as session_a: session_a.execute_write(self.create_person, "Alice") session_a.execute_write(self.employ, "Alice", "Wayne Enterprises") saved_bookmarks += session_a.last_bookmarks() # Create the second person and employment relationship. with self.driver.session() as session_b: session_b.execute_write(self.create_person, "Bob") session_b.execute_write(self.employ, "Bob", "LexCorp") saved_bookmarks += session_a.last_bookmarks() # Create a friendship between the two people created above. with self.driver.session(bookmarks=saved_bookmarks) as session_c: session_c.execute_write(self.create_friendship, "Alice", "Bob") session_c.execute_read(self.print_friendships) # end::pass-bookmarks[] def test(uri, auth): eg = BookmarksExample(uri, auth) try: with eg.driver.session() as session: session.run("MATCH (_) DETACH DELETE _") eg.main() with eg.driver.session() as session: session.run("MATCH (_) DETACH DELETE _") except ServiceUnavailable as error: if isinstance(error.__cause__, BoltHandshakeError): pytest.skip(error.args[0]) finally: eg.close() neo4j-python-driver-5.2.1/tests/integration/examples/test_read_write_transaction_example.py000066400000000000000000000033571433522662700325510ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. # tag::read-write-transaction-import[] # end::read-write-transaction-import[] # python -m pytest tests/integration/examples/test_read_write_transaction_example.py -s -v def read_write_transaction_example(driver): with driver.session() as session: session.run("MATCH (_) DETACH DELETE _") # tag::read-write-transaction[] def create_person_node(tx, name): tx.run("CREATE (a:Person {name: $name})", name=name) def match_person_node(tx, name): result = tx.run("MATCH (a:Person {name: $name}) RETURN count(a)", name=name) return result.single()[0] def add_person(name): with driver.session() as session: session.execute_write(create_person_node, name) persons = session.execute_read(match_person_node, name) return persons # end::read-write-transaction[] result = add_person("Alice") result = add_person("Alice") with driver.session() as session: session.run("MATCH (_) DETACH DELETE _") return result def test_example(driver): result = read_write_transaction_example(driver) assert result == 2 neo4j-python-driver-5.2.1/tests/integration/examples/test_result_consume_example.py000066400000000000000000000032341433522662700310600ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. # tag::result-consume-import[] # end::result-consume-import[] # python -m pytest tests/integration/examples/test_result_consume_example.py -s -v def result_consume_example(driver): with driver.session() as session: session.run("MATCH (_) DETACH DELETE _").consume() with driver.session() as session: session.run("CREATE (a:Person {name: $name}) RETURN a", name="Alice").single().value() session.run("CREATE (a:Person {name: $name}) RETURN a", name="Bob").single().value() # tag::result-consume[] def match_person_nodes(tx): result = tx.run("MATCH (a:Person) RETURN a.name ORDER BY a.name") return [record["a.name"] for record in result] with driver.session() as session: people = session.execute_read(match_person_nodes) # end::result-consume[] with driver.session() as session: session.run("MATCH (_) DETACH DELETE _").consume() return people def test_example(driver): people = result_consume_example(driver) assert people == ['Alice', 'Bob'] neo4j-python-driver-5.2.1/tests/integration/examples/test_result_retain_example.py000066400000000000000000000051741433522662700306760ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. # tag::result-retain-import[] # end::result-retain-import[] # python -m pytest tests/integration/examples/test_result_retain_example.py -s -v def result_retain_example(driver): with driver.session() as session: session.run("MATCH (_) DETACH DELETE _").consume() with driver.session() as session: session.run("CREATE (a:Person {name: $name}) RETURN a", name="Alice").single().value() session.run("CREATE (a:Person {name: $name}) RETURN a", name="Bob").single().value() # tag::result-retain[] def add_employee_to_company(tx, person, company_name): tx.run("MATCH (emp:Person {name: $person_name}) " "MERGE (com:Company {name: $company_name}) " "MERGE (emp)-[:WORKS_FOR]->(com)", person_name=person["name"], company_name=company_name) return 1 def match_person_nodes(tx): return list(tx.run("MATCH (a:Person) RETURN a.name AS name")) def add_employees(company_name): employees = 0 with driver.session() as session: persons = session.execute_read(match_person_nodes) for person in persons: employees += session.execute_write(add_employee_to_company, person, company_name) return employees # end::result-retain[] employees = add_employees(company_name="Neo4j") def count_employees(company_name): with driver.session() as session: head_count = session.run( "MATCH (emp:Person)-[:WORKS_FOR]->(com:Company) " "WHERE com.name = $company_name " "RETURN count(emp)", company_name=company_name).single().value() return head_count head_count = count_employees(company_name="Neo4j") with driver.session() as session: session.run("MATCH (_) DETACH DELETE _").consume() return employees, head_count def test_example(driver): employees, head_count = result_retain_example(driver) assert employees == 2 assert head_count == 2 neo4j-python-driver-5.2.1/tests/integration/examples/test_service_unavailable_example.py000066400000000000000000000031231433522662700320110ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest # isort: off # tag::service-unavailable-import[] from neo4j.exceptions import ServiceUnavailable # end::service-unavailable-import[] # isort: on def service_unavailable_example(driver): with driver.session() as session: session.run("MATCH (_) DETACH DELETE _") # tag::service-unavailable[] def add_item(): try: with driver.session() as session: session.execute_write(lambda tx: tx.run("CREATE (a:Item)")) return True except ServiceUnavailable: return False # end::service-unavailable[] add_item() add_item() add_item() with driver.session() as session: items = session.run("MATCH (a:Item) RETURN count(a)").single().value() with driver.session() as session: session.run("MATCH (_) DETACH DELETE _") return items def test_example(): pytest.skip("Fix better error messages for the user. Be able to kill the server.") neo4j-python-driver-5.2.1/tests/integration/examples/test_session_example.py000066400000000000000000000026311433522662700274740ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. # tag::session-import[] # end::session-import[] # python -m pytest tests/integration/examples/test_session_example.py -s -v def session_example(driver): with driver.session() as session: session.run("MATCH (_) DETACH DELETE _") # tag::session[] def add_person(name): with driver.session() as session: session.run("CREATE (a:Person {name: $name})", name=name) # end::session[] add_person("Alice") add_person("Bob") with driver.session() as session: persons = session.run("MATCH (a:Person) RETURN count(a)").single().value() with driver.session() as session: session.run("MATCH (_) DETACH DELETE _") return persons def test_example(driver): persons = session_example(driver) assert persons == 2 neo4j-python-driver-5.2.1/tests/integration/examples/test_temporal_types_example.py000066400000000000000000000233121433522662700310570ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. # python -m pytest tests/integration/examples/test_temporal_types_example.py -s -v def _echo(tx, x): return tx.run("RETURN $x AS fieldName", x=x).single() def test_datetime(driver): # isort: off # tag::temporal-types-datetime-import[] from datetime import datetime from neo4j.time import DateTime import pytz # end::temporal-types-datetime-import[] # isort: on # tag::temporal-types-datetime[] # Create datetimes to be used as query parameters # Python's builtin datetimes works as well. However, they don't support # the full feature-set of Neo4j's durations: it has no nanosecond precision. py_dt = datetime(2021, month=11, day=2, hour=7, minute=47, microsecond=4) py_dt = pytz.timezone("US/Eastern").localize(py_dt) # A DateTime can be created from a native datetime dt = DateTime.from_native(py_dt) # or directly dt = DateTime(year=2021, month=11, day=2, hour=7, minute=47, nanosecond=4123) dt = pytz.timezone("US/Eastern").localize(dt) # end::temporal-types-datetime[] in_dt = dt # stored for later assertions with driver.session() as session: record = session.execute_read(_echo, dt) # tag::temporal-types-datetime[] # Reading a DateTime from a record dt = record.get("fieldName") # type: DateTime str(dt) # '2021-11-02T07:47:09.232260000-04:00' # converting DateTime to native datetime (lossy) native = dt.to_native() # type: datetime # end::temporal-types-datetime[] assert isinstance(dt, DateTime) assert str(dt) == "2021-11-02T07:47:00.000004123-04:00" assert dt == in_dt assert isinstance(native, datetime) assert native == py_dt with driver.session() as session: record = session.execute_read(_echo, py_dt) dt = record.get("fieldName") assert isinstance(dt, DateTime) assert dt == in_dt.to_native() def test_date(driver): # isort: off # tag::temporal-types-date-import[] from datetime import date from neo4j.time import Date # end::temporal-types-date-import[] # isort: on # tag::temporal-types-date[] # Create dates to be used as query parameters # Python's builtin dates works as well. py_d = date(year=2021, month=11, day=2) # A Date can be created from a native date d = Date.from_native(py_d) # or directly d = Date(year=2021, month=11, day=2) # end::temporal-types-date[] assert d == Date.from_native(py_d) in_d = d # stored for later assertions with driver.session() as session: record = session.execute_read(_echo, d) # tag::temporal-types-date[] # Reading a Date from a record d = record.get("fieldName") # type: Date str(d) # '2021-11-02' # converting Date to native date native = d.to_native() # type: date # end::temporal-types-date[] assert isinstance(d, Date) assert str(d) == "2021-11-02" assert d == in_d assert isinstance(native, date) assert native == py_d with driver.session() as session: record = session.execute_read(_echo, py_d) d = record.get("fieldName") assert isinstance(d, Date) assert d == in_d.to_native() def test_time(driver): # isort: off # tag::temporal-types-time-import[] from datetime import time from neo4j.time import Time import pytz # end::temporal-types-time-import[] # isort: on # tag::temporal-types-time[] # Create datetimes to be used as query parameters # Python's builtin datetimes works as well. However, they don't support # the full feature-set of Neo4j's durations: it has no nanosecond precision. py_t = time(hour=7, minute=47, microsecond=4, tzinfo=pytz.FixedOffset(-240)) # A Time can be created from a native time t = Time.from_native(py_t) # or directly t = Time(hour=7, minute=47, nanosecond=4123, tzinfo=pytz.FixedOffset(-240)) # end::temporal-types-time[] in_t = t # stored for later assertions with driver.session() as session: record = session.execute_read(_echo, t) # tag::temporal-types-time[] # Reading a Time from a record t = record.get("fieldName") # type: Time str(t) # 'T07:47:09.232260000-04:00' # converting Time to native time (lossy) native = t.to_native() # type: time # end::temporal-types-time[] assert isinstance(t, Time) assert str(t) == "07:47:00.000004123-04:00" assert t == in_t assert isinstance(native, time) assert native == py_t with driver.session() as session: record = session.execute_read(_echo, py_t) t = record.get("fieldName") assert isinstance(t, Time) assert t == in_t.to_native() def test_local_datetime(driver): # isort: off # tag::temporal-types-local-datetime-import[] from datetime import datetime from neo4j.time import DateTime # end::temporal-types-local-datetime-import[] # isort: on # tag::temporal-types-local-datetime[] # Create datetimes to be used as query parameters # Python's builtin datetimes works as well. However, they don't support # the full feature-set of Neo4j's durations: it has no nanosecond precision. py_dt = datetime(2021, month=11, day=2, hour=7, minute=47, microsecond=4) # A DateTime can be created from a native datetime dt = DateTime.from_native(py_dt) # or directly dt = DateTime(year=2021, month=11, day=2, hour=7, minute=47, nanosecond=4123) # end::temporal-types-local-datetime[] in_dt = dt # stored for later assertions with driver.session() as session: record = session.execute_read(_echo, dt) # tag::temporal-types-local-datetime[] # Reading a DateTime from a record dt = record.get("fieldName") # type: DateTime str(dt) # '2021-11-02T07:47:09.232260000' # converting DateTime to native datetime (lossy) native = dt.to_native() # type: datetime # end::temporal-types-local-datetime[] assert isinstance(dt, DateTime) assert str(dt) == "2021-11-02T07:47:00.000004123" assert dt == in_dt assert isinstance(native, datetime) assert native == py_dt with driver.session() as session: record = session.execute_read(_echo, py_dt) dt = record.get("fieldName") assert isinstance(dt, DateTime) assert dt == in_dt.to_native() def test_local_time(driver): # isort: off # tag::temporal-types-local-time-import[] from datetime import time from neo4j.time import Time # end::temporal-types-local-time-import[] # isort: on # tag::temporal-types-local-time[] # Create datetimes to be used as query parameters # Python's builtin datetimes works as well. However, they don't support # the full feature-set of Neo4j's durations: it has no nanosecond precision. py_t = time(hour=7, minute=47, microsecond=4) # A Time can be created from a native time t = Time.from_native(py_t) # or directly t = Time(hour=7, minute=47, nanosecond=4123) # end::temporal-types-local-time[] in_t = t # stored for later assertions with driver.session() as session: record = session.execute_read(_echo, t) # tag::temporal-types-local-time[] # Reading a Time from a record t = record.get("fieldName") # type: Time str(t) # 'T07:47:09.232260000' # converting Time to native time (lossy) native = t.to_native() # type: time # end::temporal-types-local-time[] assert isinstance(t, Time) assert str(t) == "07:47:00.000004123" assert t == in_t assert isinstance(native, time) assert native == py_t with driver.session() as session: record = session.execute_read(_echo, py_t) t = record.get("fieldName") assert isinstance(t, Time) assert t == in_t.to_native() def test_duration_example(driver): # isort: off # tag::temporal-types-duration-import[] from datetime import timedelta from neo4j.time import Duration # end::temporal-types-duration-import[] # isort: on # tag::temporal-types-duration[] # Creating durations to be used as query parameters duration = Duration(years=1, days=2, seconds=3, nanoseconds=4) # Python's builtin timedeltas works as well. However, they don't support # the full feature-set of Neo4j's durations, # e.g., no nanoseconds and no months. py_duration = timedelta(days=2, seconds=3, microseconds=4) # end::temporal-types-duration[] in_duration = duration # stored for later assertions with driver.session() as session: record = session.execute_read(_echo, duration) # tag::temporal-types-duration[] # Reading a Duration from a record duration = record.get("fieldName") # type: Duration str(duration) # 'P1Y2DT3.000000004S' # end::temporal-types-duration[] assert isinstance(duration, Duration) assert str(duration) == 'P1Y2DT3.000000004S' assert duration == in_duration with driver.session() as session: record = session.execute_read(_echo, py_duration) duration = record.get("fieldName") assert isinstance(duration, Duration) assert str(duration) == 'P2DT3.000004S' assert Duration() + py_duration == duration neo4j-python-driver-5.2.1/tests/integration/examples/test_transaction_function_example.py000066400000000000000000000034771433522662700322540ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. # isort: off # tag::transaction-function-import[] from neo4j import unit_of_work # end::transaction-function-import[] # isort: on # python -m pytest tests/integration/examples/test_transaction_function_example.py -s -v # tag::transaction-function[] @unit_of_work(timeout=5) def create_person(tx, name): return tx.run("CREATE (a:Person {name: $name}) RETURN id(a)", name=name).single().value() def add_person(driver, name): with driver.session() as session: return session.execute_write(create_person, name) # end::transaction-function[] class TransactionFunctionExample: def __init__(self, driver): self.driver = driver def add_person(self, name): return add_person(self.driver, name) def work(tx, query, **parameters): res = tx.run(query, **parameters) return [rec.values() for rec in res], res.consume() def test_example(driver): eg = TransactionFunctionExample(driver) with eg.driver.session() as session: session.execute_write(work, "MATCH (_) DETACH DELETE _") eg.add_person("Alice") records, _ = session.execute_read( work, "MATCH (a:Person) RETURN count(a)" ) assert records == [[1]] neo4j-python-driver-5.2.1/tests/integration/examples/test_transaction_metadata_config_example.py000066400000000000000000000034561433522662700335310ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 neo4j import unit_of_work # python -m pytest tests/integration/examples/test_transaction_metadata_config_example.py -s -v # tag::transaction-metadata-config[] @unit_of_work(timeout=5, metadata={"applicationId": "123"}) def create_person(tx, name): return tx.run( "CREATE (a:Person {name: $name}) RETURN id(a)", name=name ).single().value() def add_person(driver, name): with driver.session() as session: return session.execute_write(create_person, name) # end::transaction-metadata-config[] class TransactionMetadataConfigExample: def __init__(self, driver): self.driver = driver def add_person(self, name): return add_person(self.driver, name) def work(tx, query, **parameters): res = tx.run(query, **parameters) return [rec.values() for rec in res], res.consume() def test_example(driver): eg = TransactionMetadataConfigExample(driver) with eg.driver.session() as session: session.execute_write(work, "MATCH (_) DETACH DELETE _") eg.add_person("Alice") records, _ = session.execute_read( work, "MATCH (a:Person) RETURN count(a)" ) assert records == [[1]] neo4j-python-driver-5.2.1/tests/integration/examples/test_transaction_timeout_config_example.py000066400000000000000000000034021433522662700334260ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 neo4j import unit_of_work # python -m pytest tests/integration/examples/execute_test_timeout_config_example.py -s -v # tag::transaction-timeout-config[] @unit_of_work(timeout=5) def create_person(tx, name): return tx.run( "CREATE (a:Person {name: $name}) RETURN id(a)", name=name ).single().value() def add_person(driver, name): with driver.session() as session: return session.execute_write(create_person, name) # end::transaction-timeout-config[] class TransactionTimeoutConfigExample: def __init__(self, driver): self.driver = driver def add_person(self, name): return add_person(self.driver, name) def work(tx, query, **parameters): res = tx.run(query, **parameters) return [rec.values() for rec in res], res.consume() def test_example(driver): eg = TransactionTimeoutConfigExample(driver) with eg.driver.session() as session: session.execute_write(work, "MATCH (_) DETACH DELETE _") eg.add_person("Alice") records, _ = session.execute_read( work, "MATCH (a:Person) RETURN count(a)" ) assert records == [[1]] neo4j-python-driver-5.2.1/tests/integration/mixed/000077500000000000000000000000001433522662700221535ustar00rootroot00000000000000neo4j-python-driver-5.2.1/tests/integration/mixed/__init__.py000066400000000000000000000012011433522662700242560ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. neo4j-python-driver-5.2.1/tests/integration/mixed/test_async_cancellation.py000066400000000000000000000161241433522662700274210ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 asyncio import random from functools import wraps import pytest import neo4j from neo4j import exceptions as neo4j_exceptions from ..._async_compat import mark_async_test from ...conftest import get_async_driver def _get_work(): work_cancelled = False async def work(tx, i=1): nonlocal work_cancelled assert not work_cancelled # no retries after cancellation! try: result = await tx.run(f"RETURN {i}") try: for _ in range(3): await asyncio.sleep(0) except asyncio.CancelledError as e: e.during_sleep = True raise records = [record async for record in result] summary = await result.consume() assert isinstance(summary, neo4j.ResultSummary) assert len(records) == 1 assert list(records[0]) == [i] except asyncio.CancelledError: work_cancelled = True raise return work async def _do_the_read_tx_func(session_, i=1): await session_.execute_read(_get_work(), i=i) def _with_retry(outer): @wraps(outer) async def inner(*args, **kwargs): for _ in range(15): # super simple retry-mechanism try: return await outer(*args, **kwargs) except (neo4j_exceptions.DriverError, neo4j_exceptions.Neo4jError) as e: if not e.is_retryable(): raise await asyncio.sleep(1.5) return inner @_with_retry async def _do_the_read_tx_context(session_, i=1): async with await session_.begin_transaction() as tx: await _get_work()(tx, i=i) @_with_retry async def _do_the_read_explicit_tx(session_, i=1): tx = await session_.begin_transaction() try: await _get_work()(tx, i=i) except asyncio.CancelledError: tx.cancel() raise await tx.commit() @_with_retry async def _do_the_read(session_, i=1): try: return await _get_work()(session_, i=i) except asyncio.CancelledError: session_.cancel() raise REPETITIONS = 1000 @mark_async_test @pytest.mark.parametrize(("i", "read_func", "waits", "cancel_count"), ( ( f"{i + 1:0{len(str(REPETITIONS))}}/{REPETITIONS}", random.choice(( _do_the_read, _do_the_read_tx_context, _do_the_read_explicit_tx, _do_the_read_tx_func )), random.randint(0, 1000), random.randint(1, 20), ) for i in range(REPETITIONS) )) async def test_async_cancellation( uri, auth, mocker, read_func, waits, cancel_count, i ): async with get_async_driver( uri, auth=auth, connection_acquisition_timeout=10 ) as driver: async with driver.session() as session: session._handle_cancellation = mocker.Mock( wraps=session._handle_cancellation ) fut = asyncio.ensure_future(read_func(session)) for _ in range(waits): await asyncio.sleep(0) # time for crazy abuse! was_done = fut.done() and not fut.cancelled() for _ in range(cancel_count): fut.cancel() await asyncio.sleep(0) cancelled_error = None if not was_done: with pytest.raises(asyncio.CancelledError) as exc: await fut cancelled_error = exc.value else: await fut bookmarks = await session.last_bookmarks() if not waits: assert not bookmarks session._handle_cancellation.assert_not_called() elif cancelled_error is not None: assert not bookmarks if ( read_func is _do_the_read and not getattr(cancelled_error, "during_sleep", False) ): # manually handling the session can lead to calling # `session.cancel` twice, but that's ok, it's a noop if # already cancelled. assert len(session._handle_cancellation.call_args) == 2 else: session._handle_cancellation.assert_called_once() else: assert bookmarks session._handle_cancellation.assert_not_called() for read_func in ( _do_the_read, _do_the_read_tx_context, _do_the_read_explicit_tx, _do_the_read_tx_func ): await read_func(session, i=2) # test driver is still working async with driver.session() as session: await _do_the_read_tx_func(session, i=3) new_bookmarks = await session.last_bookmarks() assert new_bookmarks assert bookmarks != new_bookmarks SESSION_REPETITIONS = 100 READS_PER_SESSION = 20 @mark_async_test async def test_async_cancellation_does_not_leak(uri, auth): async with get_async_driver( uri, auth=auth, connection_acquisition_timeout=10, # driver needs to cope with a single connection in the pool! max_connection_pool_size=1, ) as driver: for session_number in range(SESSION_REPETITIONS): async with driver.session() as session: for read_number in range(READS_PER_SESSION): read_func = random.choice(( _do_the_read, _do_the_read_tx_context, _do_the_read_explicit_tx, _do_the_read_tx_func )) waits = random.randint(0, 1000) cancel_count = random.randint(1, 20) fut = asyncio.ensure_future(read_func(session)) for _ in range(waits): await asyncio.sleep(0) # time for crazy abuse! was_done = fut.done() and not fut.cancelled() for _ in range(cancel_count): fut.cancel() await asyncio.sleep(0) if not was_done: with pytest.raises(asyncio.CancelledError): await fut else: await fut await _do_the_read_tx_func(session, i=2) pool_connections = driver._pool.connections for connections in pool_connections.values(): assert len(connections) <= 1 neo4j-python-driver-5.2.1/tests/integration/sync/000077500000000000000000000000001433522662700220215ustar00rootroot00000000000000neo4j-python-driver-5.2.1/tests/integration/sync/__init__.py000066400000000000000000000012011433522662700241240ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. neo4j-python-driver-5.2.1/tests/integration/sync/test_custom_ssl_context.py000066400000000000000000000031051433522662700273700ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 ssl import SSLContext import pytest import neo4j from ..._async_compat import mark_sync_test @mark_sync_test def test_custom_ssl_context_wraps_connection(uri, auth, mocker): # Test that the driver calls either `.wrap_socket` or `.wrap_bio` on the # provided custom SSL context. class NoNeedToGoFurtherException(Exception): pass def wrap_fail(*_, **__): raise NoNeedToGoFurtherException() fake_ssl_context = mocker.create_autospec(SSLContext) fake_ssl_context.wrap_socket.side_effect = wrap_fail fake_ssl_context.wrap_bio.side_effect = wrap_fail with neo4j.GraphDatabase.driver( uri, auth=auth, ssl_context=fake_ssl_context ) as driver: with driver.session() as session: with pytest.raises(NoNeedToGoFurtherException): session.run("RETURN 1") assert (fake_ssl_context.wrap_socket.call_count + fake_ssl_context.wrap_bio.call_count) == 1 neo4j-python-driver-5.2.1/tests/integration/test_bolt_driver.py000066400000000000000000000024121433522662700247700ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest @pytest.fixture def server_info(driver): """ Simple fixture to provide quick and easy access to a :class:`.ServerInfo` object. """ with driver.session() as session: summary = session.run("RETURN 1").consume() yield summary.server # TODO: 6.0 - # This test will stay as python is currently the only driver exposing # the connection id. This will be removed in 6.0 def test_server_connection_id(driver): server_info = driver.get_server_info() with pytest.warns(DeprecationWarning): cid = server_info.connection_id assert cid.startswith("bolt-") and cid[5:].isdigit() neo4j-python-driver-5.2.1/tests/integration/test_readme.py000066400000000000000000000055411433522662700237200ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pathlib import Path # python -m pytest tests/integration/test_readme.py -s -v def test_should_run_readme(uri, auth): names = set() print = names.add # === START: README === from neo4j import GraphDatabase driver = GraphDatabase.driver("neo4j://localhost:7687", auth=("neo4j", "password")) # === END: README === driver.close() driver = GraphDatabase.driver(uri, auth=auth) # === START: README === def add_friend(tx, name, friend_name): tx.run("MERGE (a:Person {name: $name}) " "MERGE (a)-[:KNOWS]->(friend:Person {name: $friend_name})", name=name, friend_name=friend_name) def print_friends(tx, name): query = ("MATCH (a:Person)-[:KNOWS]->(friend) WHERE a.name = $name " "RETURN friend.name ORDER BY friend.name") for record in tx.run(query, name=name): print(record["friend.name"]) with driver.session(database="neo4j") as session: # === END: README === session.run("MATCH (a) DETACH DELETE a") # === START: README === session.execute_write(add_friend, "Arthur", "Guinevere") session.execute_write(add_friend, "Arthur", "Lancelot") session.execute_write(add_friend, "Arthur", "Merlin") session.execute_read(print_friends, "Arthur") # === END: README === session.run("MATCH (a) DETACH DELETE a") # === START: README === driver.close() # === END: README === assert names == {"Guinevere", "Lancelot", "Merlin"} def test_readme_contains_example(): test_path = Path(__file__) readme_path = test_path.parents[2] / "README.rst" with test_path.open("r") as fd: test_content = fd.read() with readme_path.open("r") as fd: readme_content = fd.read() stripped_test_content = "" adding = False for line in test_content.splitlines(keepends=True): if line.strip() == "# === START: README ===": adding = True continue elif line.strip() == "# === END: README ===": adding = False continue if adding: stripped_test_content += line assert stripped_test_content in readme_content neo4j-python-driver-5.2.1/tests/integration/test_tx_functions.py000066400000000000000000000112571433522662700252070ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 uuid import uuid4 import pytest from neo4j import unit_of_work from neo4j.exceptions import ( ClientError, Neo4jError, ) # python -m pytest tests/integration/test_tx_functions.py -s -v @pytest.fixture(params=["read_transaction", "execute_read"]) def read_transaction(request): def executor(session, *args, **kwargs): if request.param == "read_transaction": with pytest.warns( DeprecationWarning, match="^read_transaction has been renamed to execute_read$" ): return session.read_transaction(*args, **kwargs) elif request.param == "execute_read": return session.execute_read(*args, **kwargs) raise ValueError(request.param) return executor @pytest.fixture(params=["write_transaction", "execute_write"]) def write_transaction(request): def executor(session, *args, **kwargs): if request.param == "write_transaction": with pytest.warns( DeprecationWarning, match="^write_transaction has been renamed to execute_write$" ): return session.write_transaction(*args, **kwargs) elif request.param == "execute_write": return session.execute_write(*args, **kwargs) raise ValueError(request.param) return executor def test_simple_read(session, read_transaction): def work(tx): return tx.run("RETURN 1").single().value() value = read_transaction(session, work) assert value == 1 def test_read_with_arg(session, read_transaction): def work(tx, x): return tx.run("RETURN $x", x=x).single().value() value = read_transaction(session, work, x=1) assert value == 1 def test_read_with_arg_and_metadata(session, read_transaction): @unit_of_work(timeout=25, metadata={"foo": "bar"}) def work(tx): return tx.run("CALL dbms.getTXMetaData").single().value() try: value = read_transaction(session, work) except ClientError: pytest.skip("Transaction metadata and timeout only supported in Neo4j EE 3.5+") else: assert value == {"foo": "bar"} def test_simple_write(session, write_transaction): def work(tx): return tx.run("CREATE (a {x: 1}) RETURN a.x").single().value() value = write_transaction(session, work) assert value == 1 def test_write_with_arg(session, write_transaction): def work(tx, x): return tx.run("CREATE (a {x: $x}) RETURN a.x", x=x).single().value() value = write_transaction(session, work, x=1) assert value == 1 def test_write_with_arg_and_metadata(session, write_transaction): @unit_of_work(timeout=25, metadata={"foo": "bar"}) def work(tx, x): return tx.run("CREATE (a {x: $x}) RETURN a.x", x=x).single().value() try: value = write_transaction(session, work, x=1) except ClientError: pytest.skip("Transaction metadata and timeout only supported in Neo4j EE 3.5+") else: assert value == 1 def test_error_on_write_transaction(session, write_transaction): def f(tx, uuid): tx.run("CREATE (a:Thing {uuid:$uuid})", uuid=uuid), uuid4() with pytest.raises(TypeError): write_transaction(session, f) def test_retry_logic(driver, read_transaction): # python -m pytest tests/integration/test_tx_functions.py -s -v -k test_retry_logic pytest.global_counter = 0 def get_one(tx): result = tx.run("UNWIND [1,2,3,4] AS x RETURN x") records = list(result) pytest.global_counter += 1 if pytest.global_counter < 3: database_unavailable = Neo4jError.hydrate(message="The database is not currently available to serve your request, refer to the database logs for more details. Retrying your request at a later time may succeed.", code="Neo.TransientError.Database.DatabaseUnavailable") raise database_unavailable return records with driver.session() as session: records = read_transaction(session, get_one) assert pytest.global_counter == 3 del pytest.global_counter neo4j-python-driver-5.2.1/tests/performance/000077500000000000000000000000001433522662700210235ustar00rootroot00000000000000neo4j-python-driver-5.2.1/tests/performance/__init__.py000066400000000000000000000000001433522662700231220ustar00rootroot00000000000000neo4j-python-driver-5.2.1/tests/performance/test_async_results.py000066400000000000000000000033131433522662700253320ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j import GraphDatabase def work(async_driver, *units_of_work): async def runner(): async with async_driver.session() as session: for unit_of_work in units_of_work: await session.execute_read(unit_of_work) return runner def unit_of_work_generator(record_count, record_width, value): async def transaction_function(tx): s = "UNWIND range(1, $record_count) AS _ RETURN {}".format( ", ".join("$x AS x{}".format(i) for i in range(record_width))) p = {"record_count": record_count, "x": value} async for record in await tx.run(s, p): assert all(x == value for x in record.values()) return transaction_function @pytest.mark.parametrize("record_count", [1, 1000]) @pytest.mark.parametrize("record_width", [1, 10]) @pytest.mark.parametrize("value", [1, u'hello, world']) def test_async_1x1(async_driver, aio_benchmark, record_count, record_width, value): aio_benchmark(work( async_driver, unit_of_work_generator(record_count, record_width, value) )) neo4j-python-driver-5.2.1/tests/performance/test_results.py000066400000000000000000000031271433522662700241400ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j import GraphDatabase def work(driver, *units_of_work): def runner(): with driver.session() as session: for unit_of_work in units_of_work: session.execute_read(unit_of_work) return runner def unit_of_work(record_count, record_width, value): def transaction_function(tx): s = "UNWIND range(1, $record_count) AS _ RETURN {}".format( ", ".join("$x AS x{}".format(i) for i in range(record_width))) p = {"record_count": record_count, "x": value} for record in tx.run(s, p): assert all(x == value for x in record.values()) return transaction_function @pytest.mark.parametrize("record_count", [1, 1000]) @pytest.mark.parametrize("record_width", [1, 10]) @pytest.mark.parametrize("value", [1, u'hello, world']) def test_1x1(driver, benchmark, record_count, record_width, value): benchmark(work(driver, unit_of_work(record_count, record_width, value))) neo4j-python-driver-5.2.1/tests/requirements.txt000066400000000000000000000002421433522662700220040ustar00rootroot00000000000000coverage>=5.5 pytest>=6.2.5 pytest-asyncio>=0.16.0 pytest-benchmark>=3.4.1 pytest-cov>=3.0.0 pytest-mock>=3.6.1 mock>=4.0.3 teamcity-messages>=1.29 pandas>=1.0.0 neo4j-python-driver-5.2.1/tests/unit/000077500000000000000000000000001433522662700175015ustar00rootroot00000000000000neo4j-python-driver-5.2.1/tests/unit/README.md000066400000000000000000000007071433522662700207640ustar00rootroot00000000000000Structure: ``` . ├── _async_compat # utility code to allow auto-converting async tests to sync tests ├── async # tests that are specifit to async classes, methods, or functions ├── common # tests of classes, methods, and functions that only exist in sync ├── mixed # tests that cannot be auto converted from async to sync └── sync # auto-genereated sync versions of tetst in async ``` neo4j-python-driver-5.2.1/tests/unit/__init__.py000066400000000000000000000012011433522662700216040ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. neo4j-python-driver-5.2.1/tests/unit/async_/000077500000000000000000000000001433522662700207555ustar00rootroot00000000000000neo4j-python-driver-5.2.1/tests/unit/async_/__init__.py000066400000000000000000000012011433522662700230600ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. neo4j-python-driver-5.2.1/tests/unit/async_/conftest.py000066400000000000000000000013141433522662700231530ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 .fixtures import * # necessary for pytest to discover the fixtures neo4j-python-driver-5.2.1/tests/unit/async_/fixtures/000077500000000000000000000000001433522662700226265ustar00rootroot00000000000000neo4j-python-driver-5.2.1/tests/unit/async_/fixtures/__init__.py000066400000000000000000000012731433522662700247420ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 .fake_connection import * from .fake_pool import * neo4j-python-driver-5.2.1/tests/unit/async_/fixtures/fake_connection.py000066400000000000000000000174501433522662700263340ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 inspect import pytest from neo4j import ServerInfo from neo4j._async.io import AsyncBolt from neo4j._deadline import Deadline __all__ = [ "async_fake_connection_generator", "async_fake_connection", "async_scripted_connection_generator", "async_scripted_connection", ] @pytest.fixture def async_fake_connection_generator(session_mocker): mock = session_mocker.mock_module class AsyncFakeConnection(mock.NonCallableMagicMock): callbacks = [] server_info = ServerInfo("127.0.0.1", (4, 3)) local_port = 1234 def __init__(self, *args, **kwargs): kwargs["spec"] = AsyncBolt super().__init__(*args, **kwargs) self.attach_mock(mock.Mock(return_value=True), "is_reset_mock") self.attach_mock(mock.Mock(return_value=False), "defunct") self.attach_mock(mock.Mock(return_value=False), "stale") self.attach_mock(mock.Mock(return_value=False), "closed") self.attach_mock(mock.Mock(return_value=False), "socket") self.attach_mock(mock.Mock(), "unresolved_address") def close_side_effect(): self.closed.return_value = True self.attach_mock(mock.AsyncMock(side_effect=close_side_effect), "close") self.socket.attach_mock( mock.Mock(return_value=None), "get_deadline" ) def set_deadline_side_effect(deadline): deadline = Deadline.from_timeout_or_deadline(deadline) self.socket.get_deadline.return_value = deadline self.socket.attach_mock( mock.Mock(side_effect=set_deadline_side_effect), "set_deadline" ) @property def is_reset(self): if self.closed.return_value or self.defunct.return_value: raise AssertionError( "is_reset should not be called on a closed or defunct " "connection." ) return self.is_reset_mock() async def fetch_message(self, *args, **kwargs): if self.callbacks: cb = self.callbacks.pop(0) await cb() return await super().__getattr__("fetch_message")(*args, **kwargs) async def fetch_all(self, *args, **kwargs): while self.callbacks: cb = self.callbacks.pop(0) await cb() return await super().__getattr__("fetch_all")(*args, **kwargs) def __getattr__(self, name): parent = super() def build_message_handler(name): def func(*args, **kwargs): async def callback(): for cb_name, param_count in ( ("on_success", 1), ("on_summary", 0) ): cb = kwargs.get(cb_name, None) if callable(cb): try: param_count = \ len(inspect.signature(cb).parameters) except ValueError: # e.g. built-in method as cb pass if param_count == 1: res = cb({}) else: res = cb() try: await res # maybe the callback is async except TypeError: pass # or maybe it wasn't ;) self.callbacks.append(callback) return func method_mock = parent.__getattr__(name) if name in ("run", "commit", "pull", "rollback", "discard"): method_mock.side_effect = build_message_handler(name) return method_mock return AsyncFakeConnection @pytest.fixture def async_fake_connection(async_fake_connection_generator): return async_fake_connection_generator() @pytest.fixture def async_scripted_connection_generator(async_fake_connection_generator): class AsyncScriptedConnection(async_fake_connection_generator): _script = [] _script_pos = 0 def set_script(self, callbacks): """Set a scripted sequence of callbacks. :param callbacks: The callbacks. They should be a list of 2-tuples. `("name_of_message", {"callback_name": arguments})`. E.g., ``` [ ("run", {"on_success": ({},), "on_summary": None}), ("pull", { "on_success": None, "on_summary": None, "on_records": }) ] ``` Note that arguments can be `None`. In this case, ScriptedConnection will make a guess on best-suited default arguments. """ self._script = callbacks self._script_pos = 0 def __getattr__(self, name): parent = super() def build_message_handler(name): def func(*args, **kwargs): try: expected_message, scripted_callbacks = \ self._script[self._script_pos] except IndexError: pytest.fail("End of scripted connection reached.") assert name == expected_message self._script_pos += 1 async def callback(): for cb_name, default_cb_args in ( ("on_ignored", ({},)), ("on_failure", ({},)), ("on_records", ([],)), ("on_success", ({},)), ("on_summary", ()), ): cb = kwargs.get(cb_name, None) if ( not callable(cb) or cb_name not in scripted_callbacks ): continue cb_args = scripted_callbacks[cb_name] if cb_args is None: cb_args = default_cb_args res = cb(*cb_args) try: await res # maybe the callback is async except TypeError: pass # or maybe it wasn't ;) self.callbacks.append(callback) return func method_mock = parent.__getattr__(name) if name in ("run", "commit", "pull", "rollback", "discard"): method_mock.side_effect = build_message_handler(name) return method_mock return AsyncScriptedConnection @pytest.fixture def async_scripted_connection(async_scripted_connection_generator): return async_scripted_connection_generator() neo4j-python-driver-5.2.1/tests/unit/async_/fixtures/fake_pool.py000066400000000000000000000025251433522662700251430ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j._async.io._pool import AsyncIOPool __all__ = [ "fake_pool", ] @pytest.fixture def fake_pool(async_fake_connection_generator, mocker): pool = mocker.AsyncMock(spec=AsyncIOPool) assert not hasattr(pool, "acquired_connection_mocks") pool.buffered_connection_mocks = [] pool.acquired_connection_mocks = [] def acquire_side_effect(*_, **__): if pool.buffered_connection_mocks: connection = pool.buffered_connection_mocks.pop() else: connection = async_fake_connection_generator() pool.acquired_connection_mocks.append(connection) return connection pool.acquire.side_effect = acquire_side_effect return pool neo4j-python-driver-5.2.1/tests/unit/async_/io/000077500000000000000000000000001433522662700213645ustar00rootroot00000000000000neo4j-python-driver-5.2.1/tests/unit/async_/io/__init__.py000066400000000000000000000012011433522662700234670ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. neo4j-python-driver-5.2.1/tests/unit/async_/io/conftest.py000066400000000000000000000072741433522662700235750ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 io import BytesIO from struct import ( pack as struct_pack, unpack as struct_unpack, ) import pytest from neo4j._async.io._common import ( AsyncInbox, AsyncOutbox, ) class AsyncFakeSocket: def __init__(self, address, unpacker_cls=None): self.address = address self.captured = b"" self.messages = None if unpacker_cls is not None: self.messages = AsyncInbox( self, on_error=print, unpacker_cls=unpacker_cls ) def getsockname(self): return "127.0.0.1", 0xFFFF def getpeername(self): return self.address async def recv_into(self, buffer, nbytes): data = self.captured[:nbytes] actual = len(data) buffer[:actual] = data self.captured = self.captured[actual:] return actual async def sendall(self, data): self.captured += data def close(self): return async def pop_message(self): assert self.messages return await self.messages.pop(None) class AsyncFakeSocket2: def __init__(self, address=None, on_send=None, packer_cls=None, unpacker_cls=None): self.address = address self.recv_buffer = bytearray() # self.messages = AsyncMessageInbox(self, on_error=print) self.on_send = on_send self._outbox = self._messages = None if packer_cls: self._outbox = AsyncOutbox( self, on_error=print, packer_cls=packer_cls ) if unpacker_cls: self._messages = AsyncInbox( self, on_error=print, unpacker_cls=unpacker_cls ) def getsockname(self): return "127.0.0.1", 0xFFFF def getpeername(self): return self.address async def recv_into(self, buffer, nbytes): data = self.recv_buffer[:nbytes] actual = len(data) buffer[:actual] = data self.recv_buffer = self.recv_buffer[actual:] return actual async def sendall(self, data): if callable(self.on_send): self.on_send(data) def close(self): return def inject(self, data): self.recv_buffer += data async def pop_message(self): assert self._messages return await self._messages.pop(None) async def send_message(self, tag, *fields): assert self._outbox self._outbox.append_message(tag, fields, None) await self._outbox.flush() class AsyncFakeSocketPair: def __init__(self, address, packer_cls=None, unpacker_cls=None): self.client = AsyncFakeSocket2( address, packer_cls=packer_cls, unpacker_cls=unpacker_cls ) self.server = AsyncFakeSocket2( packer_cls=packer_cls, unpacker_cls=unpacker_cls ) self.client.on_send = self.server.inject self.server.on_send = self.client.inject @pytest.fixture def fake_socket(): return AsyncFakeSocket @pytest.fixture def fake_socket_2(): return AsyncFakeSocket2 @pytest.fixture def fake_socket_pair(): return AsyncFakeSocketPair neo4j-python-driver-5.2.1/tests/unit/async_/io/test__common.py000066400000000000000000000035331433522662700244300ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j._async.io._common import AsyncOutbox from neo4j._codec.packstream.v1 import PackableBuffer from ...._async_compat import mark_async_test @pytest.mark.parametrize(("chunk_size", "data", "result"), ( ( 2, bytes(range(10, 15)), bytes((0, 2, 10, 11, 0, 2, 12, 13, 0, 1, 14)) ), ( 2, bytes(range(10, 14)), bytes((0, 2, 10, 11, 0, 2, 12, 13)) ), ( 2, bytes((5,)), bytes((0, 1, 5)) ), )) @mark_async_test async def test_async_outbox_chunking(chunk_size, data, result, mocker): buffer = PackableBuffer() socket_mock = mocker.AsyncMock() packer_mock = mocker.Mock() packer_mock.return_value = packer_mock packer_mock.new_packable_buffer.return_value = buffer packer_mock.pack_struct.side_effect = \ lambda *args, **kwargs: buffer.write(data) outbox = AsyncOutbox(socket_mock, pytest.fail, packer_mock, chunk_size) outbox.append_message(None, None, None) socket_mock.sendall.assert_not_called() assert await outbox.flush() socket_mock.sendall.assert_awaited_once_with(result + b"\x00\x00") assert not await outbox.flush() socket_mock.sendall.assert_awaited_once() neo4j-python-driver-5.2.1/tests/unit/async_/io/test_class_bolt.py000066400000000000000000000061041433522662700251230ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 asyncio import pytest from neo4j._async.io import AsyncBolt from neo4j._async_compat.network import AsyncBoltSocket from ...._async_compat import AsyncTestDecorators # python -m pytest tests/unit/io/test_class_bolt.py -s -v def test_class_method_protocol_handlers(): protocol_handlers = AsyncBolt.protocol_handlers() assert len(protocol_handlers) == 6 assert protocol_handlers.keys() == { (3, 0), (4, 1), (4, 2), (4, 3), (4, 4), (5, 0), } @pytest.mark.parametrize( "test_input, expected", [ ((0, 0), 0), ((1, 0), 0), ((2, 0), 0), ((3, 0), 1), ((4, 0), 0), ((4, 1), 1), ((4, 2), 1), ((4, 3), 1), ((4, 4), 1), ((5, 0), 1), ((5, 1), 0), ((6, 0), 0), ] ) def test_class_method_protocol_handlers_with_protocol_version(test_input, expected): protocol_handlers = AsyncBolt.protocol_handlers( protocol_version=test_input ) assert len(protocol_handlers) == expected def test_class_method_protocol_handlers_with_invalid_protocol_version(): with pytest.raises(TypeError): AsyncBolt.protocol_handlers(protocol_version=2) def test_class_method_get_handshake(): handshake = AsyncBolt.get_handshake() assert (b"\x00\x00\x00\x05\x00\x02\x04\x04\x00\x00\x01\x04\x00\x00\x00\x03" == handshake) def test_magic_preamble(): preamble = 0x6060B017 preamble_bytes = preamble.to_bytes(4, byteorder="big") assert AsyncBolt.MAGIC_PREAMBLE == preamble_bytes @AsyncTestDecorators.mark_async_only_test async def test_cancel_hello_in_open(mocker): address = ("localhost", 7687) socket_mock = mocker.AsyncMock(spec=AsyncBoltSocket) socket_cls_mock = mocker.patch("neo4j._async.io._bolt.AsyncBoltSocket", autospec=True) socket_cls_mock.connect.return_value = ( socket_mock, (5, 0), None, None ) socket_mock.getpeername.return_value = address bolt_cls_mock = mocker.patch("neo4j._async.io._bolt5.AsyncBolt5x0", autospec=True) bolt_mock = bolt_cls_mock.return_value bolt_mock.socket = socket_mock bolt_mock.hello.side_effect = asyncio.CancelledError() bolt_mock.local_port = 1234 with pytest.raises(asyncio.CancelledError): await AsyncBolt.open(address) bolt_mock.kill.assert_called_once_with() neo4j-python-driver-5.2.1/tests/unit/async_/io/test_class_bolt3.py000066400000000000000000000075121433522662700252120ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j._async.io._bolt3 import AsyncBolt3 from neo4j._conf import PoolConfig from neo4j.exceptions import ConfigurationError from ...._async_compat import mark_async_test @pytest.mark.parametrize("set_stale", (True, False)) def test_conn_is_stale(fake_socket, set_stale): address = ("127.0.0.1", 7687) max_connection_lifetime = 0 connection = AsyncBolt3(address, fake_socket(address), max_connection_lifetime) if set_stale: connection.set_stale() assert connection.stale() is True @pytest.mark.parametrize("set_stale", (True, False)) def test_conn_is_not_stale_if_not_enabled(fake_socket, set_stale): address = ("127.0.0.1", 7687) max_connection_lifetime = -1 connection = AsyncBolt3(address, fake_socket(address), max_connection_lifetime) if set_stale: connection.set_stale() assert connection.stale() is set_stale @pytest.mark.parametrize("set_stale", (True, False)) def test_conn_is_not_stale(fake_socket, set_stale): address = ("127.0.0.1", 7687) max_connection_lifetime = 999999999 connection = AsyncBolt3(address, fake_socket(address), max_connection_lifetime) if set_stale: connection.set_stale() assert connection.stale() is set_stale def test_db_extra_not_supported_in_begin(fake_socket): address = ("127.0.0.1", 7687) connection = AsyncBolt3(address, fake_socket(address), PoolConfig.max_connection_lifetime) with pytest.raises(ConfigurationError): connection.begin(db="something") def test_db_extra_not_supported_in_run(fake_socket): address = ("127.0.0.1", 7687) connection = AsyncBolt3(address, fake_socket(address), PoolConfig.max_connection_lifetime) with pytest.raises(ConfigurationError): connection.run("", db="something") @mark_async_test async def test_simple_discard(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt3.UNPACKER_CLS) connection = AsyncBolt3(address, socket, PoolConfig.max_connection_lifetime) connection.discard() await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x2F" assert len(fields) == 0 @mark_async_test async def test_simple_pull(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt3.UNPACKER_CLS) connection = AsyncBolt3(address, socket, PoolConfig.max_connection_lifetime) connection.pull() await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x3F" assert len(fields) == 0 @pytest.mark.parametrize("recv_timeout", (1, -1)) @mark_async_test async def test_hint_recv_timeout_seconds_gets_ignored( fake_socket_pair, recv_timeout, mocker ): address = ("127.0.0.1", 7687) sockets = fake_socket_pair( address, AsyncBolt3.PACKER_CLS, AsyncBolt3.UNPACKER_CLS ) sockets.client.settimeout = mocker.AsyncMock() await sockets.server.send_message(b"\x70", { "server": "Neo4j/3.5.0", "hints": {"connection.recv_timeout_seconds": recv_timeout}, }) connection = AsyncBolt3( address, sockets.client, PoolConfig.max_connection_lifetime ) await connection.hello() sockets.client.settimeout.assert_not_called() neo4j-python-driver-5.2.1/tests/unit/async_/io/test_class_bolt4x0.py000066400000000000000000000153731433522662700254670ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j._async.io._bolt4 import AsyncBolt4x0 from neo4j._conf import PoolConfig from ...._async_compat import mark_async_test @pytest.mark.parametrize("set_stale", (True, False)) def test_conn_is_stale(fake_socket, set_stale): address = ("127.0.0.1", 7687) max_connection_lifetime = 0 connection = AsyncBolt4x0(address, fake_socket(address), max_connection_lifetime) if set_stale: connection.set_stale() assert connection.stale() is True @pytest.mark.parametrize("set_stale", (True, False)) def test_conn_is_not_stale_if_not_enabled(fake_socket, set_stale): address = ("127.0.0.1", 7687) max_connection_lifetime = -1 connection = AsyncBolt4x0(address, fake_socket(address), max_connection_lifetime) if set_stale: connection.set_stale() assert connection.stale() is set_stale @pytest.mark.parametrize("set_stale", (True, False)) def test_conn_is_not_stale(fake_socket, set_stale): address = ("127.0.0.1", 7687) max_connection_lifetime = 999999999 connection = AsyncBolt4x0(address, fake_socket(address), max_connection_lifetime) if set_stale: connection.set_stale() assert connection.stale() is set_stale @mark_async_test async def test_db_extra_in_begin(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x0.UNPACKER_CLS) connection = AsyncBolt4x0(address, socket, PoolConfig.max_connection_lifetime) connection.begin(db="something") await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x11" assert len(fields) == 1 assert fields[0] == {"db": "something"} @mark_async_test async def test_db_extra_in_run(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x0.UNPACKER_CLS) connection = AsyncBolt4x0(address, socket, PoolConfig.max_connection_lifetime) connection.run("", {}, db="something") await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x10" assert len(fields) == 3 assert fields[0] == "" assert fields[1] == {} assert fields[2] == {"db": "something"} @mark_async_test async def test_n_extra_in_discard(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x0.UNPACKER_CLS) connection = AsyncBolt4x0(address, socket, PoolConfig.max_connection_lifetime) connection.discard(n=666) await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x2F" assert len(fields) == 1 assert fields[0] == {"n": 666} @pytest.mark.parametrize( "test_input, expected", [ (666, {"n": -1, "qid": 666}), (-1, {"n": -1}), ] ) @mark_async_test async def test_qid_extra_in_discard(fake_socket, test_input, expected): address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x0.UNPACKER_CLS) connection = AsyncBolt4x0(address, socket, PoolConfig.max_connection_lifetime) connection.discard(qid=test_input) await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x2F" assert len(fields) == 1 assert fields[0] == expected @pytest.mark.parametrize( "test_input, expected", [ (777, {"n": 666, "qid": 777}), (-1, {"n": 666}), ] ) @mark_async_test async def test_n_and_qid_extras_in_discard(fake_socket, test_input, expected): address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x0.UNPACKER_CLS) connection = AsyncBolt4x0(address, socket, PoolConfig.max_connection_lifetime) connection.discard(n=666, qid=test_input) await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x2F" assert len(fields) == 1 assert fields[0] == expected @pytest.mark.parametrize( "test_input, expected", [ (666, {"n": 666}), (-1, {"n": -1}), ] ) @mark_async_test async def test_n_extra_in_pull(fake_socket, test_input, expected): address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x0.UNPACKER_CLS) connection = AsyncBolt4x0(address, socket, PoolConfig.max_connection_lifetime) connection.pull(n=test_input) await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x3F" assert len(fields) == 1 assert fields[0] == expected @pytest.mark.parametrize( "test_input, expected", [ (777, {"n": -1, "qid": 777}), (-1, {"n": -1}), ] ) @mark_async_test async def test_qid_extra_in_pull(fake_socket, test_input, expected): address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x0.UNPACKER_CLS) connection = AsyncBolt4x0(address, socket, PoolConfig.max_connection_lifetime) connection.pull(qid=test_input) await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x3F" assert len(fields) == 1 assert fields[0] == expected @mark_async_test async def test_n_and_qid_extras_in_pull(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x0.UNPACKER_CLS) connection = AsyncBolt4x0(address, socket, PoolConfig.max_connection_lifetime) connection.pull(n=666, qid=777) await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x3F" assert len(fields) == 1 assert fields[0] == {"n": 666, "qid": 777} @pytest.mark.parametrize("recv_timeout", (1, -1)) @mark_async_test async def test_hint_recv_timeout_seconds_gets_ignored( fake_socket_pair, recv_timeout, mocker ): address = ("127.0.0.1", 7687) sockets = fake_socket_pair(address, packer_cls=AsyncBolt4x0.PACKER_CLS, unpacker_cls=AsyncBolt4x0.UNPACKER_CLS) sockets.client.settimeout = mocker.MagicMock() await sockets.server.send_message(b"\x70", { "server": "Neo4j/4.0.0", "hints": {"connection.recv_timeout_seconds": recv_timeout}, }) connection = AsyncBolt4x0( address, sockets.client, PoolConfig.max_connection_lifetime ) await connection.hello() sockets.client.settimeout.assert_not_called() neo4j-python-driver-5.2.1/tests/unit/async_/io/test_class_bolt4x1.py000066400000000000000000000171741433522662700254710ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j._async.io._bolt4 import AsyncBolt4x1 from neo4j._conf import PoolConfig from ...._async_compat import mark_async_test @pytest.mark.parametrize("set_stale", (True, False)) def test_conn_is_stale(fake_socket, set_stale): address = ("127.0.0.1", 7687) max_connection_lifetime = 0 connection = AsyncBolt4x1(address, fake_socket(address), max_connection_lifetime) if set_stale: connection.set_stale() assert connection.stale() is True @pytest.mark.parametrize("set_stale", (True, False)) def test_conn_is_not_stale_if_not_enabled(fake_socket, set_stale): address = ("127.0.0.1", 7687) max_connection_lifetime = -1 connection = AsyncBolt4x1(address, fake_socket(address), max_connection_lifetime) if set_stale: connection.set_stale() assert connection.stale() is set_stale @pytest.mark.parametrize("set_stale", (True, False)) def test_conn_is_not_stale(fake_socket, set_stale): address = ("127.0.0.1", 7687) max_connection_lifetime = 999999999 connection = AsyncBolt4x1(address, fake_socket(address), max_connection_lifetime) if set_stale: connection.set_stale() assert connection.stale() is set_stale @mark_async_test async def test_db_extra_in_begin(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x1.UNPACKER_CLS) connection = AsyncBolt4x1(address, socket, PoolConfig.max_connection_lifetime) connection.begin(db="something") await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x11" assert len(fields) == 1 assert fields[0] == {"db": "something"} @mark_async_test async def test_db_extra_in_run(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x1.UNPACKER_CLS) connection = AsyncBolt4x1(address, socket, PoolConfig.max_connection_lifetime) connection.run("", {}, db="something") await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x10" assert len(fields) == 3 assert fields[0] == "" assert fields[1] == {} assert fields[2] == {"db": "something"} @mark_async_test async def test_n_extra_in_discard(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x1.UNPACKER_CLS) connection = AsyncBolt4x1(address, socket, PoolConfig.max_connection_lifetime) connection.discard(n=666) await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x2F" assert len(fields) == 1 assert fields[0] == {"n": 666} @pytest.mark.parametrize( "test_input, expected", [ (666, {"n": -1, "qid": 666}), (-1, {"n": -1}), ] ) @mark_async_test async def test_qid_extra_in_discard(fake_socket, test_input, expected): address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x1.UNPACKER_CLS) connection = AsyncBolt4x1(address, socket, PoolConfig.max_connection_lifetime) connection.discard(qid=test_input) await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x2F" assert len(fields) == 1 assert fields[0] == expected @pytest.mark.parametrize( "test_input, expected", [ (777, {"n": 666, "qid": 777}), (-1, {"n": 666}), ] ) @mark_async_test async def test_n_and_qid_extras_in_discard(fake_socket, test_input, expected): # python -m pytest tests/unit/io/test_class_bolt4x0.py -s -k test_n_and_qid_extras_in_discard address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x1.UNPACKER_CLS) connection = AsyncBolt4x1(address, socket, PoolConfig.max_connection_lifetime) connection.discard(n=666, qid=test_input) await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x2F" assert len(fields) == 1 assert fields[0] == expected @pytest.mark.parametrize( "test_input, expected", [ (666, {"n": 666}), (-1, {"n": -1}), ] ) @mark_async_test async def test_n_extra_in_pull(fake_socket, test_input, expected): address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x1.UNPACKER_CLS) connection = AsyncBolt4x1(address, socket, PoolConfig.max_connection_lifetime) connection.pull(n=test_input) await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x3F" assert len(fields) == 1 assert fields[0] == expected @pytest.mark.parametrize( "test_input, expected", [ (777, {"n": -1, "qid": 777}), (-1, {"n": -1}), ] ) @mark_async_test async def test_qid_extra_in_pull(fake_socket, test_input, expected): # python -m pytest tests/unit/io/test_class_bolt4x0.py -s -k test_qid_extra_in_pull address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x1.UNPACKER_CLS) connection = AsyncBolt4x1(address, socket, PoolConfig.max_connection_lifetime) connection.pull(qid=test_input) await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x3F" assert len(fields) == 1 assert fields[0] == expected @mark_async_test async def test_n_and_qid_extras_in_pull(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x1.UNPACKER_CLS) connection = AsyncBolt4x1(address, socket, PoolConfig.max_connection_lifetime) connection.pull(n=666, qid=777) await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x3F" assert len(fields) == 1 assert fields[0] == {"n": 666, "qid": 777} @mark_async_test async def test_hello_passes_routing_metadata(fake_socket_pair): address = ("127.0.0.1", 7687) sockets = fake_socket_pair(address, packer_cls=AsyncBolt4x1.PACKER_CLS, unpacker_cls=AsyncBolt4x1.UNPACKER_CLS) await sockets.server.send_message(b"\x70", {"server": "Neo4j/4.1.0"}) connection = AsyncBolt4x1( address, sockets.client, PoolConfig.max_connection_lifetime, routing_context={"foo": "bar"} ) await connection.hello() tag, fields = await sockets.server.pop_message() assert tag == b"\x01" assert len(fields) == 1 assert fields[0]["routing"] == {"foo": "bar"} @pytest.mark.parametrize("recv_timeout", (1, -1)) @mark_async_test async def test_hint_recv_timeout_seconds_gets_ignored( fake_socket_pair, recv_timeout, mocker ): address = ("127.0.0.1", 7687) sockets = fake_socket_pair(address, packer_cls=AsyncBolt4x1.PACKER_CLS, unpacker_cls=AsyncBolt4x1.UNPACKER_CLS) sockets.client.settimeout = mocker.AsyncMock() await sockets.server.send_message(b"\x70", { "server": "Neo4j/4.1.0", "hints": {"connection.recv_timeout_seconds": recv_timeout}, }) connection = AsyncBolt4x1(address, sockets.client, PoolConfig.max_connection_lifetime) await connection.hello() sockets.client.settimeout.assert_not_called() neo4j-python-driver-5.2.1/tests/unit/async_/io/test_class_bolt4x2.py000066400000000000000000000171611433522662700254660ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j._async.io._bolt4 import AsyncBolt4x2 from neo4j._conf import PoolConfig from ...._async_compat import mark_async_test @pytest.mark.parametrize("set_stale", (True, False)) def test_conn_is_stale(fake_socket, set_stale): address = ("127.0.0.1", 7687) max_connection_lifetime = 0 connection = AsyncBolt4x2(address, fake_socket(address), max_connection_lifetime) if set_stale: connection.set_stale() assert connection.stale() is True @pytest.mark.parametrize("set_stale", (True, False)) def test_conn_is_not_stale_if_not_enabled(fake_socket, set_stale): address = ("127.0.0.1", 7687) max_connection_lifetime = -1 connection = AsyncBolt4x2(address, fake_socket(address), max_connection_lifetime) if set_stale: connection.set_stale() assert connection.stale() is set_stale @pytest.mark.parametrize("set_stale", (True, False)) def test_conn_is_not_stale(fake_socket, set_stale): address = ("127.0.0.1", 7687) max_connection_lifetime = 999999999 connection = AsyncBolt4x2(address, fake_socket(address), max_connection_lifetime) if set_stale: connection.set_stale() assert connection.stale() is set_stale @mark_async_test async def test_db_extra_in_begin(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x2.UNPACKER_CLS) connection = AsyncBolt4x2(address, socket, PoolConfig.max_connection_lifetime) connection.begin(db="something") await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x11" assert len(fields) == 1 assert fields[0] == {"db": "something"} @mark_async_test async def test_db_extra_in_run(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x2.UNPACKER_CLS) connection = AsyncBolt4x2(address, socket, PoolConfig.max_connection_lifetime) connection.run("", {}, db="something") await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x10" assert len(fields) == 3 assert fields[0] == "" assert fields[1] == {} assert fields[2] == {"db": "something"} @mark_async_test async def test_n_extra_in_discard(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x2.UNPACKER_CLS) connection = AsyncBolt4x2(address, socket, PoolConfig.max_connection_lifetime) connection.discard(n=666) await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x2F" assert len(fields) == 1 assert fields[0] == {"n": 666} @pytest.mark.parametrize( "test_input, expected", [ (666, {"n": -1, "qid": 666}), (-1, {"n": -1}), ] ) @mark_async_test async def test_qid_extra_in_discard(fake_socket, test_input, expected): address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x2.UNPACKER_CLS) connection = AsyncBolt4x2(address, socket, PoolConfig.max_connection_lifetime) connection.discard(qid=test_input) await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x2F" assert len(fields) == 1 assert fields[0] == expected @pytest.mark.parametrize( "test_input, expected", [ (777, {"n": 666, "qid": 777}), (-1, {"n": 666}), ] ) @mark_async_test async def test_n_and_qid_extras_in_discard(fake_socket, test_input, expected): # python -m pytest tests/unit/io/test_class_bolt4x0.py -s -k test_n_and_qid_extras_in_discard address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x2.UNPACKER_CLS) connection = AsyncBolt4x2(address, socket, PoolConfig.max_connection_lifetime) connection.discard(n=666, qid=test_input) await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x2F" assert len(fields) == 1 assert fields[0] == expected @pytest.mark.parametrize( "test_input, expected", [ (666, {"n": 666}), (-1, {"n": -1}), ] ) @mark_async_test async def test_n_extra_in_pull(fake_socket, test_input, expected): address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x2.UNPACKER_CLS) connection = AsyncBolt4x2(address, socket, PoolConfig.max_connection_lifetime) connection.pull(n=test_input) await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x3F" assert len(fields) == 1 assert fields[0] == expected @pytest.mark.parametrize( "test_input, expected", [ (777, {"n": -1, "qid": 777}), (-1, {"n": -1}), ] ) @mark_async_test async def test_qid_extra_in_pull(fake_socket, test_input, expected): # python -m pytest tests/unit/io/test_class_bolt4x0.py -s -k test_qid_extra_in_pull address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x2.UNPACKER_CLS) connection = AsyncBolt4x2(address, socket, PoolConfig.max_connection_lifetime) connection.pull(qid=test_input) await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x3F" assert len(fields) == 1 assert fields[0] == expected @mark_async_test async def test_n_and_qid_extras_in_pull(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x2.UNPACKER_CLS) connection = AsyncBolt4x2(address, socket, PoolConfig.max_connection_lifetime) connection.pull(n=666, qid=777) await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x3F" assert len(fields) == 1 assert fields[0] == {"n": 666, "qid": 777} @mark_async_test async def test_hello_passes_routing_metadata(fake_socket_pair): address = ("127.0.0.1", 7687) sockets = fake_socket_pair(address, packer_cls=AsyncBolt4x2.PACKER_CLS, unpacker_cls=AsyncBolt4x2.UNPACKER_CLS) await sockets.server.send_message(b"\x70", {"server": "Neo4j/4.2.0"}) connection = AsyncBolt4x2( address, sockets.client, PoolConfig.max_connection_lifetime, routing_context={"foo": "bar"} ) await connection.hello() tag, fields = await sockets.server.pop_message() assert tag == b"\x01" assert len(fields) == 1 assert fields[0]["routing"] == {"foo": "bar"} @pytest.mark.parametrize("recv_timeout", (1, -1)) @mark_async_test async def test_hint_recv_timeout_seconds_gets_ignored( fake_socket_pair, recv_timeout, mocker ): address = ("127.0.0.1", 7687) sockets = fake_socket_pair(address, packer_cls=AsyncBolt4x2.PACKER_CLS, unpacker_cls=AsyncBolt4x2.UNPACKER_CLS) sockets.client.settimeout = mocker.AsyncMock() await sockets.server.send_message(b"\x70", { "server": "Neo4j/4.2.0", "hints": {"connection.recv_timeout_seconds": recv_timeout}, }) connection = AsyncBolt4x2( address, sockets.client, PoolConfig.max_connection_lifetime ) await connection.hello() sockets.client.settimeout.assert_not_called() neo4j-python-driver-5.2.1/tests/unit/async_/io/test_class_bolt4x3.py000066400000000000000000000213531433522662700254650ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 logging import pytest from neo4j._async.io._bolt4 import AsyncBolt4x3 from neo4j._conf import PoolConfig from ...._async_compat import mark_async_test @pytest.mark.parametrize("set_stale", (True, False)) def test_conn_is_stale(fake_socket, set_stale): address = ("127.0.0.1", 7687) max_connection_lifetime = 0 connection = AsyncBolt4x3(address, fake_socket(address), max_connection_lifetime) if set_stale: connection.set_stale() assert connection.stale() is True @pytest.mark.parametrize("set_stale", (True, False)) def test_conn_is_not_stale_if_not_enabled(fake_socket, set_stale): address = ("127.0.0.1", 7687) max_connection_lifetime = -1 connection = AsyncBolt4x3(address, fake_socket(address), max_connection_lifetime) if set_stale: connection.set_stale() assert connection.stale() is set_stale @pytest.mark.parametrize("set_stale", (True, False)) def test_conn_is_not_stale(fake_socket, set_stale): address = ("127.0.0.1", 7687) max_connection_lifetime = 999999999 connection = AsyncBolt4x3(address, fake_socket(address), max_connection_lifetime) if set_stale: connection.set_stale() assert connection.stale() is set_stale @mark_async_test async def test_db_extra_in_begin(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x3.UNPACKER_CLS) connection = AsyncBolt4x3(address, socket, PoolConfig.max_connection_lifetime) connection.begin(db="something") await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x11" assert len(fields) == 1 assert fields[0] == {"db": "something"} @mark_async_test async def test_db_extra_in_run(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x3.UNPACKER_CLS) connection = AsyncBolt4x3(address, socket, PoolConfig.max_connection_lifetime) connection.run("", {}, db="something") await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x10" assert len(fields) == 3 assert fields[0] == "" assert fields[1] == {} assert fields[2] == {"db": "something"} @mark_async_test async def test_n_extra_in_discard(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x3.UNPACKER_CLS) connection = AsyncBolt4x3(address, socket, PoolConfig.max_connection_lifetime) connection.discard(n=666) await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x2F" assert len(fields) == 1 assert fields[0] == {"n": 666} @pytest.mark.parametrize( "test_input, expected", [ (666, {"n": -1, "qid": 666}), (-1, {"n": -1}), ] ) @mark_async_test async def test_qid_extra_in_discard(fake_socket, test_input, expected): address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x3.UNPACKER_CLS) connection = AsyncBolt4x3(address, socket, PoolConfig.max_connection_lifetime) connection.discard(qid=test_input) await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x2F" assert len(fields) == 1 assert fields[0] == expected @pytest.mark.parametrize( "test_input, expected", [ (777, {"n": 666, "qid": 777}), (-1, {"n": 666}), ] ) @mark_async_test async def test_n_and_qid_extras_in_discard(fake_socket, test_input, expected): # python -m pytest tests/unit/io/test_class_bolt4x0.py -s -k test_n_and_qid_extras_in_discard address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x3.UNPACKER_CLS) connection = AsyncBolt4x3(address, socket, PoolConfig.max_connection_lifetime) connection.discard(n=666, qid=test_input) await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x2F" assert len(fields) == 1 assert fields[0] == expected @pytest.mark.parametrize( "test_input, expected", [ (666, {"n": 666}), (-1, {"n": -1}), ] ) @mark_async_test async def test_n_extra_in_pull(fake_socket, test_input, expected): address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x3.UNPACKER_CLS) connection = AsyncBolt4x3(address, socket, PoolConfig.max_connection_lifetime) connection.pull(n=test_input) await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x3F" assert len(fields) == 1 assert fields[0] == expected @pytest.mark.parametrize( "test_input, expected", [ (777, {"n": -1, "qid": 777}), (-1, {"n": -1}), ] ) @mark_async_test async def test_qid_extra_in_pull(fake_socket, test_input, expected): # python -m pytest tests/unit/io/test_class_bolt4x0.py -s -k test_qid_extra_in_pull address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x3.UNPACKER_CLS) connection = AsyncBolt4x3(address, socket, PoolConfig.max_connection_lifetime) connection.pull(qid=test_input) await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x3F" assert len(fields) == 1 assert fields[0] == expected @mark_async_test async def test_n_and_qid_extras_in_pull(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x3.UNPACKER_CLS) connection = AsyncBolt4x3(address, socket, PoolConfig.max_connection_lifetime) connection.pull(n=666, qid=777) await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x3F" assert len(fields) == 1 assert fields[0] == {"n": 666, "qid": 777} @mark_async_test async def test_hello_passes_routing_metadata(fake_socket_pair): address = ("127.0.0.1", 7687) sockets = fake_socket_pair(address, packer_cls=AsyncBolt4x3.PACKER_CLS, unpacker_cls=AsyncBolt4x3.UNPACKER_CLS) await sockets.server.send_message(b"\x70", {"server": "Neo4j/4.3.0"}) connection = AsyncBolt4x3( address, sockets.client, PoolConfig.max_connection_lifetime, routing_context={"foo": "bar"} ) await connection.hello() tag, fields = await sockets.server.pop_message() assert tag == b"\x01" assert len(fields) == 1 assert fields[0]["routing"] == {"foo": "bar"} @pytest.mark.parametrize(("hints", "valid"), ( ({"connection.recv_timeout_seconds": 1}, True), ({"connection.recv_timeout_seconds": 42}, True), ({}, True), ({"whatever_this_is": "ignore me!"}, True), ({"connection.recv_timeout_seconds": -1}, False), ({"connection.recv_timeout_seconds": 0}, False), ({"connection.recv_timeout_seconds": 2.5}, False), ({"connection.recv_timeout_seconds": None}, False), ({"connection.recv_timeout_seconds": False}, False), ({"connection.recv_timeout_seconds": "1"}, False), )) @mark_async_test async def test_hint_recv_timeout_seconds( fake_socket_pair, hints, valid, caplog, mocker ): address = ("127.0.0.1", 7687) sockets = fake_socket_pair(address, packer_cls=AsyncBolt4x3.PACKER_CLS, unpacker_cls=AsyncBolt4x3.UNPACKER_CLS) sockets.client.settimeout = mocker.Mock() await sockets.server.send_message( b"\x70", {"server": "Neo4j/4.3.0", "hints": hints} ) connection = AsyncBolt4x3( address, sockets.client, PoolConfig.max_connection_lifetime ) with caplog.at_level(logging.INFO): await connection.hello() if valid: if "connection.recv_timeout_seconds" in hints: sockets.client.settimeout.assert_called_once_with( hints["connection.recv_timeout_seconds"] ) else: sockets.client.settimeout.assert_not_called() assert not any("recv_timeout_seconds" in msg and "invalid" in msg for msg in caplog.messages) else: sockets.client.settimeout.assert_not_called() assert any(repr(hints["connection.recv_timeout_seconds"]) in msg and "recv_timeout_seconds" in msg and "invalid" in msg for msg in caplog.messages) neo4j-python-driver-5.2.1/tests/unit/async_/io/test_class_bolt4x4.py000066400000000000000000000225701433522662700254700ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 logging import pytest from neo4j._async.io._bolt4 import AsyncBolt4x4 from neo4j._conf import PoolConfig from ...._async_compat import mark_async_test @pytest.mark.parametrize("set_stale", (True, False)) def test_conn_is_stale(fake_socket, set_stale): address = ("127.0.0.1", 7687) max_connection_lifetime = 0 connection = AsyncBolt4x4(address, fake_socket(address), max_connection_lifetime) if set_stale: connection.set_stale() assert connection.stale() is True @pytest.mark.parametrize("set_stale", (True, False)) def test_conn_is_not_stale_if_not_enabled(fake_socket, set_stale): address = ("127.0.0.1", 7687) max_connection_lifetime = -1 connection = AsyncBolt4x4(address, fake_socket(address), max_connection_lifetime) if set_stale: connection.set_stale() assert connection.stale() is set_stale @pytest.mark.parametrize("set_stale", (True, False)) def test_conn_is_not_stale(fake_socket, set_stale): address = ("127.0.0.1", 7687) max_connection_lifetime = 999999999 connection = AsyncBolt4x4(address, fake_socket(address), max_connection_lifetime) if set_stale: connection.set_stale() assert connection.stale() is set_stale @pytest.mark.parametrize(("args", "kwargs", "expected_fields"), ( (("", {}), {"db": "something"}, ({"db": "something"},)), (("", {}), {"imp_user": "imposter"}, ({"imp_user": "imposter"},)), ( ("", {}), {"db": "something", "imp_user": "imposter"}, ({"db": "something", "imp_user": "imposter"},) ), )) @mark_async_test async def test_extra_in_begin(fake_socket, args, kwargs, expected_fields): address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x4.UNPACKER_CLS) connection = AsyncBolt4x4(address, socket, PoolConfig.max_connection_lifetime) connection.begin(*args, **kwargs) await connection.send_all() tag, is_fields = await socket.pop_message() assert tag == b"\x11" assert tuple(is_fields) == expected_fields @pytest.mark.parametrize(("args", "kwargs", "expected_fields"), ( (("", {}), {"db": "something"}, ("", {}, {"db": "something"})), (("", {}), {"imp_user": "imposter"}, ("", {}, {"imp_user": "imposter"})), ( ("", {}), {"db": "something", "imp_user": "imposter"}, ("", {}, {"db": "something", "imp_user": "imposter"}) ), )) @mark_async_test async def test_extra_in_run(fake_socket, args, kwargs, expected_fields): address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x4.UNPACKER_CLS) connection = AsyncBolt4x4(address, socket, PoolConfig.max_connection_lifetime) connection.run(*args, **kwargs) await connection.send_all() tag, is_fields = await socket.pop_message() assert tag == b"\x10" assert tuple(is_fields) == expected_fields @mark_async_test async def test_n_extra_in_discard(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x4.UNPACKER_CLS) connection = AsyncBolt4x4(address, socket, PoolConfig.max_connection_lifetime) connection.discard(n=666) await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x2F" assert len(fields) == 1 assert fields[0] == {"n": 666} @pytest.mark.parametrize( "test_input, expected", [ (666, {"n": -1, "qid": 666}), (-1, {"n": -1}), ] ) @mark_async_test async def test_qid_extra_in_discard(fake_socket, test_input, expected): address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x4.UNPACKER_CLS) connection = AsyncBolt4x4(address, socket, PoolConfig.max_connection_lifetime) connection.discard(qid=test_input) await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x2F" assert len(fields) == 1 assert fields[0] == expected @pytest.mark.parametrize( "test_input, expected", [ (777, {"n": 666, "qid": 777}), (-1, {"n": 666}), ] ) @mark_async_test async def test_n_and_qid_extras_in_discard(fake_socket, test_input, expected): # python -m pytest tests/unit/io/test_class_bolt4x0.py -s -k test_n_and_qid_extras_in_discard address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x4.UNPACKER_CLS) connection = AsyncBolt4x4(address, socket, PoolConfig.max_connection_lifetime) connection.discard(n=666, qid=test_input) await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x2F" assert len(fields) == 1 assert fields[0] == expected @pytest.mark.parametrize( "test_input, expected", [ (666, {"n": 666}), (-1, {"n": -1}), ] ) @mark_async_test async def test_n_extra_in_pull(fake_socket, test_input, expected): address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x4.UNPACKER_CLS) connection = AsyncBolt4x4(address, socket, PoolConfig.max_connection_lifetime) connection.pull(n=test_input) await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x3F" assert len(fields) == 1 assert fields[0] == expected @pytest.mark.parametrize( "test_input, expected", [ (777, {"n": -1, "qid": 777}), (-1, {"n": -1}), ] ) @mark_async_test async def test_qid_extra_in_pull(fake_socket, test_input, expected): # python -m pytest tests/unit/io/test_class_bolt4x0.py -s -k test_qid_extra_in_pull address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x4.UNPACKER_CLS) connection = AsyncBolt4x4(address, socket, PoolConfig.max_connection_lifetime) connection.pull(qid=test_input) await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x3F" assert len(fields) == 1 assert fields[0] == expected @mark_async_test async def test_n_and_qid_extras_in_pull(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, AsyncBolt4x4.UNPACKER_CLS) connection = AsyncBolt4x4(address, socket, PoolConfig.max_connection_lifetime) connection.pull(n=666, qid=777) await connection.send_all() tag, fields = await socket.pop_message() assert tag == b"\x3F" assert len(fields) == 1 assert fields[0] == {"n": 666, "qid": 777} @mark_async_test async def test_hello_passes_routing_metadata(fake_socket_pair): address = ("127.0.0.1", 7687) sockets = fake_socket_pair(address, packer_cls=AsyncBolt4x4.PACKER_CLS, unpacker_cls=AsyncBolt4x4.UNPACKER_CLS) await sockets.server.send_message(b"\x70", {"server": "Neo4j/4.4.0"}) connection = AsyncBolt4x4( address, sockets.client, PoolConfig.max_connection_lifetime, routing_context={"foo": "bar"} ) await connection.hello() tag, fields = await sockets.server.pop_message() assert tag == b"\x01" assert len(fields) == 1 assert fields[0]["routing"] == {"foo": "bar"} @pytest.mark.parametrize(("hints", "valid"), ( ({"connection.recv_timeout_seconds": 1}, True), ({"connection.recv_timeout_seconds": 42}, True), ({}, True), ({"whatever_this_is": "ignore me!"}, True), ({"connection.recv_timeout_seconds": -1}, False), ({"connection.recv_timeout_seconds": 0}, False), ({"connection.recv_timeout_seconds": 2.5}, False), ({"connection.recv_timeout_seconds": None}, False), ({"connection.recv_timeout_seconds": False}, False), ({"connection.recv_timeout_seconds": "1"}, False), )) @mark_async_test async def test_hint_recv_timeout_seconds( fake_socket_pair, hints, valid, caplog, mocker ): address = ("127.0.0.1", 7687) sockets = fake_socket_pair(address, packer_cls=AsyncBolt4x4.PACKER_CLS, unpacker_cls=AsyncBolt4x4.UNPACKER_CLS) sockets.client.settimeout = mocker.Mock() await sockets.server.send_message( b"\x70", {"server": "Neo4j/4.3.4", "hints": hints} ) connection = AsyncBolt4x4( address, sockets.client, PoolConfig.max_connection_lifetime ) with caplog.at_level(logging.INFO): await connection.hello() if valid: if "connection.recv_timeout_seconds" in hints: sockets.client.settimeout.assert_called_once_with( hints["connection.recv_timeout_seconds"] ) else: sockets.client.settimeout.assert_not_called() assert not any("recv_timeout_seconds" in msg and "invalid" in msg for msg in caplog.messages) else: sockets.client.settimeout.assert_not_called() assert any(repr(hints["connection.recv_timeout_seconds"]) in msg and "recv_timeout_seconds" in msg and "invalid" in msg for msg in caplog.messages) neo4j-python-driver-5.2.1/tests/unit/async_/io/test_direct.py000066400000000000000000000157471433522662700242650ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j._async.io import AsyncBolt from neo4j._async.io._pool import AsyncIOPool from neo4j._conf import ( Config, PoolConfig, WorkspaceConfig, ) from neo4j._deadline import Deadline from neo4j.exceptions import ( ClientError, ServiceUnavailable, ) from ...._async_compat import mark_async_test class AsyncFakeSocket: def __init__(self, address): self.address = address def getpeername(self): return self.address async def sendall(self, data): return def close(self): return class AsyncQuickConnection: def __init__(self, socket): self.socket = socket self.address = socket.getpeername() self.local_port = self.address[1] self.connection_id = "bolt-1234" @property def is_reset(self): return True def stale(self): return False async def reset(self): pass def close(self): self.socket.close() def closed(self): return False def defunct(self): return False def timedout(self): return False class AsyncFakeBoltPool(AsyncIOPool): def __init__(self, address, *, auth=None, **config): self.pool_config, self.workspace_config = Config.consume_chain(config, PoolConfig, WorkspaceConfig) if config: raise ValueError("Unexpected config keys: %s" % ", ".join(config.keys())) async def opener(addr, timeout): return AsyncQuickConnection(AsyncFakeSocket(addr)) super().__init__(opener, self.pool_config, self.workspace_config) self.address = address async def acquire( self, access_mode, timeout, database, bookmarks, liveness_check_timeout ): return await self._acquire( self.address, timeout, liveness_check_timeout ) @mark_async_test async def test_bolt_connection_open(): with pytest.raises(ServiceUnavailable): await AsyncBolt.open(("localhost", 9999), auth=("test", "test")) @mark_async_test async def test_bolt_connection_open_timeout(): with pytest.raises(ServiceUnavailable): await AsyncBolt.open(("localhost", 9999), auth=("test", "test"), timeout=1) @mark_async_test async def test_bolt_connection_ping(): protocol_version = await AsyncBolt.ping(("localhost", 9999)) assert protocol_version is None @mark_async_test async def test_bolt_connection_ping_timeout(): protocol_version = await AsyncBolt.ping(("localhost", 9999), timeout=1) assert protocol_version is None @pytest.fixture async def pool(): async with AsyncFakeBoltPool(("127.0.0.1", 7687)) as pool: yield pool def assert_pool_size( address, expected_active, expected_inactive, pool): try: connections = pool.connections[address] except KeyError: assert 0 == expected_active assert 0 == expected_inactive else: assert expected_active == len([cx for cx in connections if cx.in_use]) assert (expected_inactive == len([cx for cx in connections if not cx.in_use])) @mark_async_test async def test_pool_can_acquire(pool): address = ("127.0.0.1", 7687) connection = await pool._acquire(address, Deadline(3), None) assert connection.address == address assert_pool_size(address, 1, 0, pool) @mark_async_test async def test_pool_can_acquire_twice(pool): address = ("127.0.0.1", 7687) connection_1 = await pool._acquire(address, Deadline(3), None) connection_2 = await pool._acquire(address, Deadline(3), None) assert connection_1.address == address assert connection_2.address == address assert connection_1 is not connection_2 assert_pool_size(address, 2, 0, pool) @mark_async_test async def test_pool_can_acquire_two_addresses(pool): address_1 = ("127.0.0.1", 7687) address_2 = ("127.0.0.1", 7474) connection_1 = await pool._acquire(address_1, Deadline(3), None) connection_2 = await pool._acquire(address_2, Deadline(3), None) assert connection_1.address == address_1 assert connection_2.address == address_2 assert_pool_size(address_1, 1, 0, pool) assert_pool_size(address_2, 1, 0, pool) @mark_async_test async def test_pool_can_acquire_and_release(pool): address = ("127.0.0.1", 7687) connection = await pool._acquire(address, Deadline(3), None) assert_pool_size(address, 1, 0, pool) await pool.release(connection) assert_pool_size(address, 0, 1, pool) @mark_async_test async def test_pool_releasing_twice(pool): address = ("127.0.0.1", 7687) connection = await pool._acquire(address, Deadline(3), None) await pool.release(connection) assert_pool_size(address, 0, 1, pool) await pool.release(connection) assert_pool_size(address, 0, 1, pool) @mark_async_test async def test_pool_in_use_count(pool): address = ("127.0.0.1", 7687) assert pool.in_use_connection_count(address) == 0 connection = await pool._acquire(address, Deadline(3), None) assert pool.in_use_connection_count(address) == 1 await pool.release(connection) assert pool.in_use_connection_count(address) == 0 @mark_async_test async def test_pool_max_conn_pool_size(pool): async with AsyncFakeBoltPool((), max_connection_pool_size=1) as pool: address = ("127.0.0.1", 7687) await pool._acquire(address, Deadline(0), None) assert pool.in_use_connection_count(address) == 1 with pytest.raises(ClientError): await pool._acquire(address, Deadline(0), None) assert pool.in_use_connection_count(address) == 1 @pytest.mark.parametrize("is_reset", (True, False)) @mark_async_test async def test_pool_reset_when_released(is_reset, pool, mocker): address = ("127.0.0.1", 7687) quick_connection_name = AsyncQuickConnection.__name__ is_reset_mock = mocker.patch( f"{__name__}.{quick_connection_name}.is_reset", new_callable=mocker.PropertyMock ) reset_mock = mocker.patch( f"{__name__}.{quick_connection_name}.reset", new_callable=mocker.AsyncMock ) is_reset_mock.return_value = is_reset connection = await pool._acquire(address, Deadline(3), None) assert isinstance(connection, AsyncQuickConnection) assert is_reset_mock.call_count == 0 assert reset_mock.call_count == 0 await pool.release(connection) assert is_reset_mock.call_count == 1 assert reset_mock.call_count == int(not is_reset) neo4j-python-driver-5.2.1/tests/unit/async_/io/test_neo4j_pool.py000066400000000000000000000370611433522662700250540ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 inspect import pytest from neo4j import ( READ_ACCESS, WRITE_ACCESS, ) from neo4j._async.io import AsyncNeo4jPool from neo4j._async_compat.util import AsyncUtil from neo4j._conf import ( PoolConfig, RoutingConfig, WorkspaceConfig, ) from neo4j._deadline import Deadline from neo4j.addressing import ResolvedAddress from neo4j.exceptions import ( ServiceUnavailable, SessionExpired, ) from ...._async_compat import mark_async_test ROUTER_ADDRESS = ResolvedAddress(("1.2.3.1", 9001), host_name="host") READER_ADDRESS = ResolvedAddress(("1.2.3.1", 9002), host_name="host") WRITER_ADDRESS = ResolvedAddress(("1.2.3.1", 9003), host_name="host") @pytest.fixture def opener(async_fake_connection_generator, mocker): async def open_(addr, timeout): connection = async_fake_connection_generator() connection.addr = addr connection.timeout = timeout route_mock = mocker.AsyncMock() route_mock.return_value = [{ "ttl": 1000, "servers": [ {"addresses": [str(ROUTER_ADDRESS)], "role": "ROUTE"}, {"addresses": [str(READER_ADDRESS)], "role": "READ"}, {"addresses": [str(WRITER_ADDRESS)], "role": "WRITE"}, ], }] connection.attach_mock(route_mock, "route") opener_.connections.append(connection) return connection opener_ = mocker.AsyncMock() opener_.connections = [] opener_.side_effect = open_ return opener_ @mark_async_test async def test_acquires_new_routing_table_if_deleted(opener): pool = AsyncNeo4jPool( opener, PoolConfig(), WorkspaceConfig(), ROUTER_ADDRESS ) cx = await pool.acquire(READ_ACCESS, 30, "test_db", None, None) await pool.release(cx) assert pool.routing_tables.get("test_db") del pool.routing_tables["test_db"] cx = await pool.acquire(READ_ACCESS, 30, "test_db", None, None) await pool.release(cx) assert pool.routing_tables.get("test_db") @mark_async_test async def test_acquires_new_routing_table_if_stale(opener): pool = AsyncNeo4jPool( opener, PoolConfig(), WorkspaceConfig(), ROUTER_ADDRESS ) cx = await pool.acquire(READ_ACCESS, 30, "test_db", None, None) await pool.release(cx) assert pool.routing_tables.get("test_db") old_value = pool.routing_tables["test_db"].last_updated_time pool.routing_tables["test_db"].ttl = 0 cx = await pool.acquire(READ_ACCESS, 30, "test_db", None, None) await pool.release(cx) assert pool.routing_tables["test_db"].last_updated_time > old_value @mark_async_test async def test_removes_old_routing_table(opener): pool = AsyncNeo4jPool( opener, PoolConfig(), WorkspaceConfig(), ROUTER_ADDRESS ) cx = await pool.acquire(READ_ACCESS, 30, "test_db1", None, None) await pool.release(cx) assert pool.routing_tables.get("test_db1") cx = await pool.acquire(READ_ACCESS, 30, "test_db2", None, None) await pool.release(cx) assert pool.routing_tables.get("test_db2") old_value = pool.routing_tables["test_db1"].last_updated_time pool.routing_tables["test_db1"].ttl = 0 pool.routing_tables["test_db2"].ttl = \ -RoutingConfig.routing_table_purge_delay cx = await pool.acquire(READ_ACCESS, 30, "test_db1", None, None) await pool.release(cx) assert pool.routing_tables["test_db1"].last_updated_time > old_value assert "test_db2" not in pool.routing_tables @pytest.mark.parametrize("type_", ("r", "w")) @mark_async_test async def test_chooses_right_connection_type(opener, type_): pool = AsyncNeo4jPool( opener, PoolConfig(), WorkspaceConfig(), ROUTER_ADDRESS ) cx1 = await pool.acquire( READ_ACCESS if type_ == "r" else WRITE_ACCESS, 30, "test_db", None, None ) await pool.release(cx1) if type_ == "r": assert cx1.addr == READER_ADDRESS else: assert cx1.addr == WRITER_ADDRESS @mark_async_test async def test_reuses_connection(opener): pool = AsyncNeo4jPool( opener, PoolConfig(), WorkspaceConfig(), ROUTER_ADDRESS ) cx1 = await pool.acquire(READ_ACCESS, 30, "test_db", None, None) await pool.release(cx1) cx2 = await pool.acquire(READ_ACCESS, 30, "test_db", None, None) assert cx1 is cx2 @pytest.mark.parametrize("break_on_close", (True, False)) @mark_async_test async def test_closes_stale_connections(opener, break_on_close): async def break_connection(): await pool.deactivate(cx1.addr) if cx_close_mock_side_effect: res = cx_close_mock_side_effect() if inspect.isawaitable(res): return await res pool = AsyncNeo4jPool( opener, PoolConfig(), WorkspaceConfig(), ROUTER_ADDRESS ) cx1 = await pool.acquire(READ_ACCESS, 30, "test_db", None, None) await pool.release(cx1) assert cx1 in pool.connections[cx1.addr] # simulate connection going stale (e.g. exceeding) and then breaking when # the pool tries to close the connection cx1.stale.return_value = True cx_close_mock = cx1.close if break_on_close: cx_close_mock_side_effect = cx_close_mock.side_effect cx_close_mock.side_effect = break_connection cx2 = await pool.acquire(READ_ACCESS, 30, "test_db", None, None) await pool.release(cx2) if break_on_close: cx1.close.assert_called() else: cx1.close.assert_called_once() assert cx2 is not cx1 assert cx2.addr == cx1.addr assert cx1 not in pool.connections[cx1.addr] assert cx2 in pool.connections[cx2.addr] @mark_async_test async def test_does_not_close_stale_connections_in_use(opener): pool = AsyncNeo4jPool( opener, PoolConfig(), WorkspaceConfig(), ROUTER_ADDRESS ) cx1 = await pool.acquire(READ_ACCESS, 30, "test_db", None, None) assert cx1 in pool.connections[cx1.addr] # simulate connection going stale (e.g. exceeding) while being in use cx1.stale.return_value = True cx2 = await pool.acquire(READ_ACCESS, 30, "test_db", None, None) await pool.release(cx2) cx1.close.assert_not_called() assert cx2 is not cx1 assert cx2.addr == cx1.addr assert cx1 in pool.connections[cx1.addr] assert cx2 in pool.connections[cx2.addr] await pool.release(cx1) # now that cx1 is back in the pool and still stale, # it should be closed when trying to acquire the next connection cx1.close.assert_not_called() cx3 = await pool.acquire(READ_ACCESS, 30, "test_db", None, None) await pool.release(cx3) cx1.close.assert_called_once() assert cx2 is cx3 assert cx3.addr == cx1.addr assert cx1 not in pool.connections[cx1.addr] assert cx3 in pool.connections[cx2.addr] @mark_async_test async def test_release_resets_connections(opener): pool = AsyncNeo4jPool( opener, PoolConfig(), WorkspaceConfig(), ROUTER_ADDRESS ) cx1 = await pool.acquire(READ_ACCESS, 30, "test_db", None, None) cx1.is_reset_mock.return_value = False cx1.is_reset_mock.reset_mock() await pool.release(cx1) cx1.is_reset_mock.assert_called_once() cx1.reset.assert_called_once() @mark_async_test async def test_release_does_not_resets_closed_connections(opener): pool = AsyncNeo4jPool( opener, PoolConfig(), WorkspaceConfig(), ROUTER_ADDRESS ) cx1 = await pool.acquire(READ_ACCESS, 30, "test_db", None, None) cx1.closed.return_value = True cx1.closed.reset_mock() cx1.is_reset_mock.reset_mock() await pool.release(cx1) cx1.closed.assert_called_once() cx1.is_reset_mock.assert_not_called() cx1.reset.assert_not_called() @mark_async_test async def test_release_does_not_resets_defunct_connections(opener): pool = AsyncNeo4jPool( opener, PoolConfig(), WorkspaceConfig(), ROUTER_ADDRESS ) cx1 = await pool.acquire(READ_ACCESS, 30, "test_db", None, None) cx1.defunct.return_value = True cx1.defunct.reset_mock() cx1.is_reset_mock.reset_mock() await pool.release(cx1) cx1.defunct.assert_called_once() cx1.is_reset_mock.assert_not_called() cx1.reset.assert_not_called() @pytest.mark.parametrize("liveness_timeout", (0, 1, 2)) @mark_async_test async def test_acquire_performs_no_liveness_check_on_fresh_connection( opener, liveness_timeout ): pool = AsyncNeo4jPool( opener, PoolConfig(), WorkspaceConfig(), ROUTER_ADDRESS ) cx1 = await pool._acquire(READER_ADDRESS, Deadline(30), liveness_timeout) assert cx1.addr == READER_ADDRESS cx1.reset.assert_not_called() @pytest.mark.parametrize("liveness_timeout", (0, 1, 2)) @mark_async_test async def test_acquire_performs_liveness_check_on_existing_connection( opener, liveness_timeout ): pool = AsyncNeo4jPool( opener, PoolConfig(), WorkspaceConfig(), ROUTER_ADDRESS ) # populate the pool with a connection cx1 = await pool._acquire(READER_ADDRESS, Deadline(30), liveness_timeout) # make sure we assume the right state assert cx1.addr == READER_ADDRESS cx1.is_idle_for.assert_not_called() cx1.reset.assert_not_called() cx1.is_idle_for.return_value = True # release the connection await pool.release(cx1) cx1.reset.assert_not_called() # then acquire it again and assert the liveness check was performed cx2 = await pool._acquire(READER_ADDRESS, Deadline(30), liveness_timeout) assert cx1 is cx2 cx1.is_idle_for.assert_called_once_with(liveness_timeout) cx2.reset.assert_awaited_once() @pytest.mark.parametrize("liveness_error", (OSError, ServiceUnavailable, SessionExpired)) @mark_async_test async def test_acquire_creates_connection_on_failed_liveness_check( opener, liveness_error ): def liveness_side_effect(*args, **kwargs): raise liveness_error("liveness check failed") liveness_timeout = 1 pool = AsyncNeo4jPool( opener, PoolConfig(), WorkspaceConfig(), ROUTER_ADDRESS ) # populate the pool with a connection cx1 = await pool._acquire(READER_ADDRESS, Deadline(30), liveness_timeout) # make sure we assume the right state assert cx1.addr == READER_ADDRESS cx1.is_idle_for.assert_not_called() cx1.reset.assert_not_called() cx1.is_idle_for.return_value = True # simulate cx1 failing liveness check cx1.reset.side_effect = liveness_side_effect # release the connection await pool.release(cx1) cx1.reset.assert_not_called() # then acquire it again and assert the liveness check was performed cx2 = await pool._acquire(READER_ADDRESS, Deadline(30), liveness_timeout) assert cx1 is not cx2 assert cx1.addr == cx2.addr cx1.is_idle_for.assert_called_once_with(liveness_timeout) cx2.reset.assert_not_called() assert cx1 not in pool.connections[cx1.addr] assert cx2 in pool.connections[cx1.addr] @pytest.mark.parametrize("liveness_error", (OSError, ServiceUnavailable, SessionExpired)) @mark_async_test async def test_acquire_returns_other_connection_on_failed_liveness_check( opener, liveness_error ): def liveness_side_effect(*args, **kwargs): raise liveness_error("liveness check failed") liveness_timeout = 1 pool = AsyncNeo4jPool( opener, PoolConfig(), WorkspaceConfig(), ROUTER_ADDRESS ) # populate the pool with a connection cx1 = await pool._acquire(READER_ADDRESS, Deadline(30), liveness_timeout) cx2 = await pool._acquire(READER_ADDRESS, Deadline(30), liveness_timeout) # make sure we assume the right state assert cx1.addr == READER_ADDRESS assert cx2.addr == READER_ADDRESS assert cx1 is not cx2 cx1.is_idle_for.assert_not_called() cx2.is_idle_for.assert_not_called() cx1.reset.assert_not_called() cx1.is_idle_for.return_value = True cx2.is_idle_for.return_value = True # simulate cx1 failing liveness check cx1.reset.side_effect = liveness_side_effect # release the connection await pool.release(cx1) await pool.release(cx2) cx1.reset.assert_not_called() cx2.reset.assert_not_called() # then acquire it again and assert the liveness check was performed cx3 = await pool._acquire(READER_ADDRESS, Deadline(30), liveness_timeout) assert cx3 is cx2 cx1.is_idle_for.assert_called_once_with(liveness_timeout) cx1.reset.assert_awaited_once() cx3.is_idle_for.assert_called_once_with(liveness_timeout) cx3.reset.assert_awaited_once() assert cx1 not in pool.connections[cx1.addr] assert cx3 in pool.connections[cx1.addr] @mark_async_test async def test_multiple_broken_connections_on_close(opener, mocker): def mock_connection_breaks_on_close(cx): async def close_side_effect(): cx.closed.return_value = True cx.defunct.return_value = True await pool.deactivate(READER_ADDRESS) cx.attach_mock(mocker.AsyncMock(side_effect=close_side_effect), "close") # create pool with 2 idle connections pool = AsyncNeo4jPool( opener, PoolConfig(), WorkspaceConfig(), ROUTER_ADDRESS ) cx1 = await pool.acquire(READ_ACCESS, 30, "test_db", None, None) cx2 = await pool.acquire(READ_ACCESS, 30, "test_db", None, None) await pool.release(cx1) await pool.release(cx2) # both will loose connection mock_connection_breaks_on_close(cx1) mock_connection_breaks_on_close(cx2) # force pool to close cx1, which will make it realize that the server is # unreachable cx1.stale.return_value = True cx3 = await pool.acquire(READ_ACCESS, 30, "test_db", None, None) assert cx3 is not cx1 assert cx3 is not cx2 @mark_async_test async def test_failing_opener_leaves_connections_in_use_alone(opener): pool = AsyncNeo4jPool( opener, PoolConfig(), WorkspaceConfig(), ROUTER_ADDRESS ) cx1 = await pool.acquire(READ_ACCESS, 30, "test_db", None, None) opener.side_effect = ServiceUnavailable("Server overloaded") with pytest.raises((ServiceUnavailable, SessionExpired)): await pool.acquire(READ_ACCESS, 30, "test_db", None, None) assert not cx1.closed() @mark_async_test async def test__acquire_new_later_with_room(opener): config = PoolConfig() config.max_connection_pool_size = 1 pool = AsyncNeo4jPool( opener, config, WorkspaceConfig(), ROUTER_ADDRESS ) assert pool.connections_reservations[READER_ADDRESS] == 0 creator = pool._acquire_new_later(READER_ADDRESS, Deadline(1)) assert pool.connections_reservations[READER_ADDRESS] == 1 assert callable(creator) if AsyncUtil.is_async_code: assert inspect.iscoroutinefunction(creator) @mark_async_test async def test__acquire_new_later_without_room(opener): config = PoolConfig() config.max_connection_pool_size = 1 pool = AsyncNeo4jPool( opener, config, WorkspaceConfig(), ROUTER_ADDRESS ) _ = await pool.acquire(READ_ACCESS, 30, "test_db", None, None) # pool is full now assert pool.connections_reservations[READER_ADDRESS] == 0 creator = pool._acquire_new_later(READER_ADDRESS, Deadline(1)) assert pool.connections_reservations[READER_ADDRESS] == 0 assert creator is None neo4j-python-driver-5.2.1/tests/unit/async_/test_addressing.py000066400000000000000000000075661433522662700245270ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 socket import ( AF_INET, AF_INET6, ) import pytest from neo4j import ( Address, IPv4Address, ) from neo4j._async_compat.network import AsyncNetworkUtil from neo4j._async_compat.util import AsyncUtil from ..._async_compat import mark_async_test @mark_async_test async def test_address_resolve() -> None: address = Address(("127.0.0.1", 7687)) resolved = AsyncNetworkUtil.resolve_address(address) resolved = await AsyncUtil.list(resolved) assert isinstance(resolved, Address) is False assert isinstance(resolved, list) is True assert len(resolved) == 1 assert resolved[0] == IPv4Address(('127.0.0.1', 7687)) @mark_async_test async def test_address_resolve_with_custom_resolver_none() -> None: address = Address(("127.0.0.1", 7687)) resolved = AsyncNetworkUtil.resolve_address(address, resolver=None) resolved = await AsyncUtil.list(resolved) assert isinstance(resolved, Address) is False assert isinstance(resolved, list) is True assert len(resolved) == 1 assert resolved[0] == IPv4Address(('127.0.0.1', 7687)) @pytest.mark.parametrize( "test_input, expected", [ (Address(("127.0.0.1", "abcd")), ValueError), (Address((None, None)), ValueError), ] ) @mark_async_test async def test_address_resolve_with_unresolvable_address( test_input, expected ) -> None: with pytest.raises(expected): await AsyncUtil.list( AsyncNetworkUtil.resolve_address(test_input, resolver=None) ) @mark_async_test @pytest.mark.parametrize("resolver_type", ("sync", "async")) async def test_address_resolve_with_custom_resolver(resolver_type) -> None: def custom_resolver_sync(_): return [("127.0.0.1", 7687), ("localhost", 1234)] async def custom_resolver_async(_): return [("127.0.0.1", 7687), ("localhost", 1234)] if resolver_type == "sync": custom_resolver = custom_resolver_sync else: custom_resolver = custom_resolver_async address = Address(("127.0.0.1", 7687)) resolved = AsyncNetworkUtil.resolve_address( address, family=AF_INET, resolver=custom_resolver ) resolved = await AsyncUtil.list(resolved) assert isinstance(resolved, Address) is False assert isinstance(resolved, list) is True assert len(resolved) == 2 # IPv4 only assert resolved[0] == IPv4Address(('127.0.0.1', 7687)) assert resolved[1] == IPv4Address(('127.0.0.1', 1234)) @mark_async_test async def test_address_unresolve() -> None: def custom_resolver(_): return custom_resolved custom_resolved = [("127.0.0.1", 7687), ("localhost", 4321)] address = Address(("foobar", 1234)) unresolved = address.unresolved assert address.__class__ == unresolved.__class__ assert address == unresolved resolved = AsyncNetworkUtil.resolve_address( address, family=AF_INET, resolver=custom_resolver ) resolved_list = await AsyncUtil.list(resolved) custom_resolved_addresses = sorted(Address(a) for a in custom_resolved) unresolved_list = sorted(a.unresolved for a in resolved_list) assert custom_resolved_addresses == unresolved_list assert (list(map(lambda a: a.__class__, custom_resolved_addresses)) == list(map(lambda a: a.__class__, unresolved_list))) neo4j-python-driver-5.2.1/tests/unit/async_/test_bookmark_manager.py000066400000000000000000000224451433522662700256740ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations import itertools import typing as t import pytest import neo4j from neo4j._async.bookmark_manager import AsyncNeo4jBookmarkManager from neo4j._async_compat.util import AsyncUtil from neo4j._meta import copy_signature from neo4j.api import Bookmarks from ..._async_compat import mark_async_test supplier_async_options = (True, False) if AsyncUtil.is_async_code else (False,) consumer_async_options = supplier_async_options @copy_signature(neo4j.AsyncGraphDatabase.bookmark_manager) def bookmark_manager(*args, **kwargs): with pytest.warns(neo4j.ExperimentalWarning, match="bookmark manager"): return neo4j.AsyncGraphDatabase.bookmark_manager(*args, **kwargs) @pytest.mark.parametrize("db", ("foobar", "system")) @mark_async_test async def test_return_empty_if_db_doesnt_exists(db) -> None: bmm = bookmark_manager() assert set(await bmm.get_bookmarks(db)) == set() @pytest.mark.parametrize("db", ("db1", "db2", "db3")) @mark_async_test async def test_return_initial_bookmarks_for_the_given_db(db) -> None: initial_bookmarks: t.Dict[str, t.List[str]] = { "db1": ["db1:bm1", "db1:bm1"], "db2": [], "db3": ["db3:bm1", "db3:bm2"], "db4": ["db4:bm4"] } bmm = bookmark_manager(initial_bookmarks=initial_bookmarks) assert set(await bmm.get_bookmarks(db)) == set(initial_bookmarks[db]) @pytest.mark.parametrize("db", ("db1", "db2", "db3")) @pytest.mark.parametrize("supplier_async", supplier_async_options) @mark_async_test async def test_return_get_bookmarks_from_bookmarks_supplier( db, mocker, supplier_async ) -> None: extra_bookmarks = ["foo:bm1", "bar:bm2", "foo:bm1"] initial_bookmarks: t.Dict[str, t.List[str]] = { "db1": ["db1:bm1", "db1:bm1"], "db2": [], "db3": ["db3:bm1", "db3:bm2"], "db4": ["db4:bm4"] } mock_cls = mocker.AsyncMock if supplier_async else mocker.Mock supplier = mock_cls( return_value=Bookmarks.from_raw_values(extra_bookmarks) ) bmm = bookmark_manager(initial_bookmarks=initial_bookmarks, bookmarks_supplier=supplier) assert set(await bmm.get_bookmarks(db)) == { *extra_bookmarks, *initial_bookmarks.get(db, []) } if supplier_async: supplier.assert_awaited_once_with(db) else: supplier.assert_called_once_with(db) @pytest.mark.parametrize("with_initial_bookmarks", (True, False)) @mark_async_test async def test_return_all_bookmarks(with_initial_bookmarks) -> None: initial_bookmarks: t.Dict[str, t.List[str]] = { "db1": ["db1:bm1", "db1:bm1"], "db2": [], "db3": ["db3:bm1", "db3:bm2"], "db4": ["db4:bm4"], "db5": ["db3:bm1"] } bmm = bookmark_manager( initial_bookmarks=initial_bookmarks if with_initial_bookmarks else None ) all_bookmarks = await bmm.get_all_bookmarks() if with_initial_bookmarks: assert all_bookmarks == set( itertools.chain.from_iterable(initial_bookmarks.values()) ) else: assert all_bookmarks == set() @pytest.mark.parametrize("with_initial_bookmarks", (True, False)) @pytest.mark.parametrize("supplier_async", supplier_async_options) @mark_async_test async def test_return_enriched_bookmarks_list_with_supplied_bookmarks( with_initial_bookmarks, supplier_async, mocker ) -> None: initial_bookmarks: t.Dict[str, t.List[str]] = { "db1": ["db1:bm1", "db1:bm1"], "db2": [], "db3": ["db3:bm1", "db3:bm2"], "db4": ["db4:bm4"], } extra_bookmarks = ["foo:bm1", "bar:bm2", "db3:bm1", "foo:bm1"] mock_cls = mocker.AsyncMock if supplier_async else mocker.Mock supplier = mock_cls( return_value=Bookmarks.from_raw_values(extra_bookmarks) ) bmm = bookmark_manager( initial_bookmarks=(initial_bookmarks if with_initial_bookmarks else None), bookmarks_supplier=supplier ) all_bookmarks = await bmm.get_all_bookmarks() if with_initial_bookmarks: assert all_bookmarks == set( itertools.chain(*initial_bookmarks.values(), extra_bookmarks) ) else: assert all_bookmarks == set(extra_bookmarks) if supplier_async: supplier.assert_awaited_once_with(None) else: supplier.assert_called_once_with(None) @mark_async_test async def test_chains_bookmarks_for_existing_db() -> None: initial_bookmarks: t.Dict[str, t.List[str]] = { "db1": ["db1:bm1", "db1:bm1"], "db2": [], "db3": ["db3:bm1", "db3:bm2"], "db4": ["db4:bm4"], } bmm = bookmark_manager(initial_bookmarks=initial_bookmarks) await bmm.update_bookmarks("db3", ["db3:bm1"], ["db3:bm3"]) new_bookmarks = await bmm.get_bookmarks("db3") all_bookmarks = await bmm.get_all_bookmarks() assert new_bookmarks == {"db3:bm2", "db3:bm3"} assert all_bookmarks == set( itertools.chain.from_iterable(initial_bookmarks.values()) ) - {"db3:bm1"} | {"db3:bm2", "db3:bm3"} @mark_async_test async def test_add_bookmarks_for_a_non_existing_database() -> None: initial_bookmarks: t.Dict[str, t.List[str]] = { "db1": ["db1:bm1", "db1:bm1"], "db2": [], "db3": ["db3:bm1", "db3:bm2"], "db4": ["db4:bm4"], } bmm = bookmark_manager(initial_bookmarks=initial_bookmarks) await bmm.update_bookmarks( "db5", ["db3:bm1", "db5:bm1"], ["db3:bm3", "db3:bm5"] ) new_bookmarks = await bmm.get_bookmarks("db5") all_bookmarks = await bmm.get_all_bookmarks() assert new_bookmarks == {"db3:bm3", "db3:bm5"} assert all_bookmarks == set( itertools.chain.from_iterable(initial_bookmarks.values()) ) | {"db3:bm3", "db3:bm5"} @pytest.mark.parametrize("with_initial_bookmarks", (True, False)) @pytest.mark.parametrize("consumer_async", consumer_async_options) @pytest.mark.parametrize("db", ("db1", "db2", "db3")) @mark_async_test async def test_notify_on_new_bookmarks( with_initial_bookmarks, consumer_async, db, mocker ) -> None: initial_bookmarks: t.Dict[str, t.List[str]] = { "db1": ["db1:bm1", "db1:bm1", "db1:bm2"], "db2": ["db2:bm1"], } mock_cls = mocker.AsyncMock if consumer_async else mocker.Mock consumer = mock_cls() bmm = bookmark_manager( initial_bookmarks=(initial_bookmarks if with_initial_bookmarks else None), bookmarks_consumer=consumer ) bookmarks_old = {"db1:bm1", "db3:bm1"} bookmarks_new = {"db1:bm4"} await bmm.update_bookmarks(db, bookmarks_old, bookmarks_new) if consumer_async: consumer.assert_awaited_once() args = consumer.await_args.args else: consumer.assert_called_once() args = consumer.call_args.args assert args[0] == db assert isinstance(args[1], Bookmarks) if with_initial_bookmarks: expected_bms = ( set(initial_bookmarks.get(db, [])) - bookmarks_old | bookmarks_new ) else: expected_bms = bookmarks_new assert args[1].raw_values == expected_bms @pytest.mark.parametrize("consumer_async", consumer_async_options) @pytest.mark.parametrize("with_initial_bookmarks", (True, False)) @pytest.mark.parametrize("db", ("db1", "db2")) @mark_async_test async def test_does_not_notify_on_empty_new_bookmark_set( with_initial_bookmarks, consumer_async, db, mocker ) -> None: initial_bookmarks: t.Dict[str, t.List[str]] = { "db1": ["db1:bm1", "db1:bm2"] } mock_cls = mocker.AsyncMock if consumer_async else mocker.Mock consumer = mock_cls() bmm = bookmark_manager( initial_bookmarks=(initial_bookmarks if with_initial_bookmarks else None), bookmarks_consumer=consumer ) await bmm.update_bookmarks(db, ["db1:bm1"], []) consumer.assert_not_called() @pytest.mark.parametrize("dbs", ( ["db1"], ["db2"], ["db1", "db2"], ["db1", "db3"], ["db1", "db2", "db3"] )) @mark_async_test async def test_forget_database(dbs) -> None: initial_bookmarks: t.Dict[str, t.List[str]] = { "db1": ["db1:bm1", "db1:bm1", "db1:bm2"], "db2": ["db2:bm1"], } bmm = bookmark_manager(initial_bookmarks=initial_bookmarks) for db in dbs: assert (await bmm.get_bookmarks(db) == set(initial_bookmarks.get(db, []))) await bmm.forget(dbs) # assert the key has been removed (memory optimization) assert isinstance(bmm, AsyncNeo4jBookmarkManager) assert (set(bmm._bookmarks.keys()) == set(initial_bookmarks.keys()) - set(dbs)) for db in dbs: assert await bmm.get_bookmarks(db) == set() assert await bmm.get_all_bookmarks() == set( bm for k, v in initial_bookmarks.items() if k not in dbs for bm in v ) neo4j-python-driver-5.2.1/tests/unit/async_/test_driver.py000066400000000000000000000342411433522662700236650ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations import ssl import typing as t import pytest from neo4j import ( AsyncBoltDriver, AsyncGraphDatabase, AsyncNeo4jDriver, ExperimentalWarning, TRUST_ALL_CERTIFICATES, TRUST_SYSTEM_CA_SIGNED_CERTIFICATES, TrustAll, TrustCustomCAs, TrustSystemCAs, ) from neo4j.api import ( AsyncBookmarkManager, BookmarkManager, READ_ACCESS, WRITE_ACCESS, ) from neo4j.exceptions import ConfigurationError from ..._async_compat import ( AsyncTestDecorators, mark_async_test, ) @pytest.mark.parametrize("protocol", ("bolt://", "bolt+s://", "bolt+ssc://")) @pytest.mark.parametrize("host", ("localhost", "127.0.0.1", "[::1]", "[0:0:0:0:0:0:0:1]")) @pytest.mark.parametrize("port", (":1234", "", ":7687")) @pytest.mark.parametrize("params", ("", "?routing_context=test")) @pytest.mark.parametrize("auth_token", (("test", "test"), None)) @mark_async_test async def test_direct_driver_constructor(protocol, host, port, params, auth_token): uri = protocol + host + port + params if params: with pytest.warns(DeprecationWarning, match="routing context"): driver = AsyncGraphDatabase.driver(uri, auth=auth_token) else: driver = AsyncGraphDatabase.driver(uri, auth=auth_token) assert isinstance(driver, AsyncBoltDriver) await driver.close() @pytest.mark.parametrize("protocol", ("neo4j://", "neo4j+s://", "neo4j+ssc://")) @pytest.mark.parametrize("host", ("localhost", "127.0.0.1", "[::1]", "[0:0:0:0:0:0:0:1]")) @pytest.mark.parametrize("port", (":1234", "", ":7687")) @pytest.mark.parametrize("params", ("", "?routing_context=test")) @pytest.mark.parametrize("auth_token", (("test", "test"), None)) @mark_async_test async def test_routing_driver_constructor(protocol, host, port, params, auth_token): uri = protocol + host + port + params driver = AsyncGraphDatabase.driver(uri, auth=auth_token) assert isinstance(driver, AsyncNeo4jDriver) await driver.close() @pytest.mark.parametrize("test_uri", ( "bolt+ssc://127.0.0.1:9001", "bolt+s://127.0.0.1:9001", "bolt://127.0.0.1:9001", "neo4j+ssc://127.0.0.1:9001", "neo4j+s://127.0.0.1:9001", "neo4j://127.0.0.1:9001", )) @pytest.mark.parametrize( ("test_config", "expected_failure", "expected_failure_message"), ( ({"encrypted": False}, ConfigurationError, "The config settings"), ({"encrypted": True}, ConfigurationError, "The config settings"), ( {"encrypted": True, "trust": TRUST_ALL_CERTIFICATES}, ConfigurationError, "The config settings" ), ( {"trust": TRUST_ALL_CERTIFICATES}, ConfigurationError, "The config settings" ), ( {"trust": TRUST_SYSTEM_CA_SIGNED_CERTIFICATES}, ConfigurationError, "The config settings" ), ( {"encrypted": True, "trusted_certificates": TrustAll()}, ConfigurationError, "The config settings" ), ( {"trusted_certificates": TrustAll()}, ConfigurationError, "The config settings" ), ( {"trusted_certificates": TrustSystemCAs()}, ConfigurationError, "The config settings" ), ( {"trusted_certificates": TrustCustomCAs("foo", "bar")}, ConfigurationError, "The config settings" ), ( {"ssl_context": None}, ConfigurationError, "The config settings" ), ( {"ssl_context": ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)}, ConfigurationError, "The config settings" ), ) ) @mark_async_test async def test_driver_config_error( test_uri, test_config, expected_failure, expected_failure_message ): def driver_builder(): if "trust" in test_config: with pytest.warns(DeprecationWarning, match="trust"): return AsyncGraphDatabase.driver(test_uri, **test_config) else: return AsyncGraphDatabase.driver(test_uri, **test_config) if "+" in test_uri: # `+s` and `+ssc` are short hand syntax for not having to configure the # encryption behavior of the driver. Specifying both is invalid. with pytest.raises(expected_failure, match=expected_failure_message): driver_builder() else: driver = driver_builder() await driver.close() @pytest.mark.parametrize("test_uri", ( "http://localhost:9001", "ftp://localhost:9001", "x://localhost:9001", )) def test_invalid_protocol(test_uri): with pytest.raises(ConfigurationError, match="scheme"): AsyncGraphDatabase.driver(test_uri) @pytest.mark.parametrize( ("test_config", "expected_failure", "expected_failure_message"), ( ({"trust": 1}, ConfigurationError, "The config setting `trust`"), ({"trust": True}, ConfigurationError, "The config setting `trust`"), ({"trust": None}, ConfigurationError, "The config setting `trust`"), ) ) def test_driver_trust_config_error( test_config, expected_failure, expected_failure_message ): with pytest.raises(expected_failure, match=expected_failure_message): AsyncGraphDatabase.driver("bolt://127.0.0.1:9001", **test_config) @pytest.mark.parametrize("uri", ( "bolt://127.0.0.1:9000", "neo4j://127.0.0.1:9000", )) @mark_async_test async def test_driver_opens_write_session_by_default(uri, fake_pool, mocker): driver = AsyncGraphDatabase.driver(uri) # we set a specific db, because else the driver would try to fetch a RT # to get hold of the actual home database (which won't work in this # unittest) driver._pool = fake_pool async with driver.session(database="foobar") as session: mocker.patch("neo4j._async.work.session.AsyncTransaction", autospec=True) tx = await session.begin_transaction() fake_pool.acquire.assert_awaited_once_with( access_mode=WRITE_ACCESS, timeout=mocker.ANY, database=mocker.ANY, bookmarks=mocker.ANY, liveness_check_timeout=mocker.ANY ) tx._begin.assert_awaited_once_with( mocker.ANY, mocker.ANY, mocker.ANY, WRITE_ACCESS, mocker.ANY, mocker.ANY ) await driver.close() @pytest.mark.parametrize("uri", ( "bolt://127.0.0.1:9000", "neo4j://127.0.0.1:9000", )) @mark_async_test async def test_verify_connectivity(uri, mocker): driver = AsyncGraphDatabase.driver(uri) pool_mock = mocker.patch.object(driver, "_pool", autospec=True) try: ret = await driver.verify_connectivity() finally: await driver.close() assert ret is None pool_mock.acquire.assert_awaited_once() assert pool_mock.acquire.call_args.kwargs["liveness_check_timeout"] == 0 pool_mock.release.assert_awaited_once() @pytest.mark.parametrize("uri", ( "bolt://127.0.0.1:9000", "neo4j://127.0.0.1:9000", )) @pytest.mark.parametrize("kwargs", ( {"default_access_mode": WRITE_ACCESS}, {"default_access_mode": READ_ACCESS}, {"fetch_size": 69}, )) @mark_async_test async def test_verify_connectivity_parameters_are_deprecated( uri, kwargs, mocker ): driver = AsyncGraphDatabase.driver(uri) mocker.patch.object(driver, "_pool", autospec=True) try: with pytest.warns(ExperimentalWarning, match="configuration"): await driver.verify_connectivity(**kwargs) finally: await driver.close() @pytest.mark.parametrize("uri", ( "bolt://127.0.0.1:9000", "neo4j://127.0.0.1:9000", )) @pytest.mark.parametrize("kwargs", ( {"default_access_mode": WRITE_ACCESS}, {"default_access_mode": READ_ACCESS}, {"fetch_size": 69}, )) @mark_async_test async def test_get_server_info_parameters_are_experimental( uri, kwargs, mocker ): driver = AsyncGraphDatabase.driver(uri) mocker.patch.object(driver, "_pool", autospec=True) try: with pytest.warns(ExperimentalWarning, match="configuration"): await driver.get_server_info(**kwargs) finally: await driver.close() @mark_async_test async def test_with_builtin_bookmark_manager(mocker) -> None: with pytest.warns(ExperimentalWarning, match="bookmark manager"): bmm = AsyncGraphDatabase.bookmark_manager() # could be one line, but want to make sure the type checker assigns # bmm whatever type AsyncGraphDatabase.bookmark_manager() returns session_cls_mock = mocker.patch("neo4j._async.driver.AsyncSession", autospec=True) driver = AsyncGraphDatabase.driver("bolt://localhost") async with driver as driver: with pytest.warns(ExperimentalWarning, match="bookmark_manager"): _ = driver.session(bookmark_manager=bmm) session_cls_mock.assert_called_once() assert session_cls_mock.call_args[0][1].bookmark_manager is bmm @AsyncTestDecorators.mark_async_only_test async def test_with_custom_inherited_async_bookmark_manager(mocker) -> None: class BMM(AsyncBookmarkManager): async def update_bookmarks( self, database: str, previous_bookmarks: t.Iterable[str], new_bookmarks: t.Iterable[str] ) -> None: ... async def get_bookmarks(self, database: str) -> t.Collection[str]: return [] async def get_all_bookmarks(self) -> t.Collection[str]: return [] async def forget(self, databases: t.Iterable[str]) -> None: ... bmm = BMM() # could be one line, but want to make sure the type checker assigns # bmm whatever type AsyncGraphDatabase.bookmark_manager() returns session_cls_mock = mocker.patch("neo4j._async.driver.AsyncSession", autospec=True) driver = AsyncGraphDatabase.driver("bolt://localhost") async with driver as driver: with pytest.warns(ExperimentalWarning, match="bookmark_manager"): _ = driver.session(bookmark_manager=bmm) session_cls_mock.assert_called_once() assert session_cls_mock.call_args[0][1].bookmark_manager is bmm @mark_async_test async def test_with_custom_inherited_sync_bookmark_manager(mocker) -> None: class BMM(BookmarkManager): def update_bookmarks( self, database: str, previous_bookmarks: t.Iterable[str], new_bookmarks: t.Iterable[str] ) -> None: ... def get_bookmarks(self, database: str) -> t.Collection[str]: return [] def get_all_bookmarks(self) -> t.Collection[str]: return [] def forget(self, databases: t.Iterable[str]) -> None: ... bmm = BMM() # could be one line, but want to make sure the type checker assigns # bmm whatever type AsyncGraphDatabase.bookmark_manager() returns session_cls_mock = mocker.patch("neo4j._async.driver.AsyncSession", autospec=True) driver = AsyncGraphDatabase.driver("bolt://localhost") async with driver as driver: with pytest.warns(ExperimentalWarning, match="bookmark_manager"): _ = driver.session(bookmark_manager=bmm) session_cls_mock.assert_called_once() assert session_cls_mock.call_args[0][1].bookmark_manager is bmm @AsyncTestDecorators.mark_async_only_test async def test_with_custom_ducktype_async_bookmark_manager(mocker) -> None: class BMM: async def update_bookmarks( self, database: str, previous_bookmarks: t.Iterable[str], new_bookmarks: t.Iterable[str] ) -> None: ... async def get_bookmarks(self, database: str) -> t.Collection[str]: return [] async def get_all_bookmarks(self) -> t.Collection[str]: return [] async def forget(self, databases: t.Iterable[str]) -> None: ... bmm = BMM() # could be one line, but want to make sure the type checker assigns # bmm whatever type AsyncGraphDatabase.bookmark_manager() returns session_cls_mock = mocker.patch("neo4j._async.driver.AsyncSession", autospec=True) driver = AsyncGraphDatabase.driver("bolt://localhost") async with driver as driver: with pytest.warns(ExperimentalWarning, match="bookmark_manager"): _ = driver.session(bookmark_manager=bmm) session_cls_mock.assert_called_once() assert session_cls_mock.call_args[0][1].bookmark_manager is bmm @mark_async_test async def test_with_custom_ducktype_sync_bookmark_manager(mocker) -> None: class BMM: def update_bookmarks( self, database: str, previous_bookmarks: t.Iterable[str], new_bookmarks: t.Iterable[str] ) -> None: ... def get_bookmarks(self, database: str) -> t.Collection[str]: return [] def get_all_bookmarks(self) -> t.Collection[str]: return [] def forget(self, databases: t.Iterable[str]) -> None: ... bmm = BMM() # could be one line, but want to make sure the type checker assigns # bmm whatever type AsyncGraphDatabase.bookmark_manager() returns session_cls_mock = mocker.patch("neo4j._async.driver.AsyncSession", autospec=True) driver = AsyncGraphDatabase.driver("bolt://localhost") async with driver as driver: with pytest.warns(ExperimentalWarning, match="bookmark_manager"): _ = driver.session(bookmark_manager=bmm) session_cls_mock.assert_called_once() assert session_cls_mock.call_args[0][1].bookmark_manager is bmm neo4j-python-driver-5.2.1/tests/unit/async_/work/000077500000000000000000000000001433522662700217375ustar00rootroot00000000000000neo4j-python-driver-5.2.1/tests/unit/async_/work/__init__.py000066400000000000000000000012011433522662700240420ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. neo4j-python-driver-5.2.1/tests/unit/async_/work/test_result.py000066400000000000000000001140421433522662700246700ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 warnings from unittest import mock import pandas as pd import pytest import pytz from neo4j import ( Address, AsyncResult, ExperimentalWarning, Record, ResultSummary, ServerInfo, SummaryCounters, time as neo4j_time, Version, ) from neo4j._async_compat.util import AsyncUtil from neo4j._codec.hydration.v1 import HydrationHandler from neo4j._codec.packstream import Structure from neo4j._data import ( Node, Relationship, ) from neo4j.exceptions import ( BrokenRecordError, ResultNotSingleError, ) from neo4j.graph import ( EntitySetView, Graph, ) from ...._async_compat import mark_async_test class Records: def __init__(self, fields, records): self.fields = tuple(fields) self.hydration_scope = HydrationHandler().new_hydration_scope() self.records = tuple(records) assert all(len(self.fields) == len(r) for r in self.records) self._hydrate_records() def _hydrate_records(self): def _hydrate(value): if isinstance(value, (list, tuple)): value = type(value)(_hydrate(v) for v in value) elif isinstance(value, dict): value = {k: _hydrate(v) for k, v in value.items()} if type(value) in self.hydration_scope.hydration_hooks: return self.hydration_scope.hydration_hooks[type(value)](value) return value self.records = tuple(_hydrate(r) for r in self.records) def __len__(self): return self.records.__len__() def __iter__(self): return self.records.__iter__() def __getitem__(self, item): return self.records.__getitem__(item) class AsyncConnectionStub: class Message: def __init__(self, message, *args, **kwargs): self.message = message self.args = args self.kwargs = kwargs async def _cb(self, cb_name, *args, **kwargs): # print(self.message, cb_name.upper(), args, kwargs) cb = self.kwargs.get(cb_name) await AsyncUtil.callback(cb, *args, **kwargs) async def on_success(self, metadata): await self._cb("on_success", metadata) async def on_summary(self): await self._cb("on_summary") async def on_records(self, records): await self._cb("on_records", records) def __eq__(self, other): return self.message == other def __repr__(self): return "Message(%s)" % self.message def __init__(self, records=None, run_meta=None, summary_meta=None, force_qid=False): self._multi_result = isinstance(records, (list, tuple)) if self._multi_result: self._records = records self._use_qid = True else: self._records = records, self._use_qid = force_qid self.fetch_idx = 0 self._qid = -1 self.most_recent_qid = None self.record_idxs = [0] * len(self._records) self.to_pull = [None] * len(self._records) self._exhausted = [False] * len(self._records) self.queued = [] self.sent = [] self.run_meta = run_meta self.summary_meta = summary_meta AsyncConnectionStub.server_info.update({"server": "Neo4j/4.3.0"}) self.unresolved_address = None self._new_hydration_scope_called = False async def send_all(self): self.sent += self.queued self.queued = [] async def fetch_message(self): if self.fetch_idx >= len(self.sent): pytest.fail("Waits for reply to never sent message") msg = self.sent[self.fetch_idx] if msg == "RUN": self.fetch_idx += 1 self._qid += 1 meta = {"fields": self._records[self._qid].fields, **(self.run_meta or {})} if self._use_qid: meta.update(qid=self._qid) await msg.on_success(meta) elif msg == "DISCARD": self.fetch_idx += 1 qid = msg.kwargs.get("qid", -1) if qid < 0: qid = self._qid self.record_idxs[qid] = len(self._records[qid]) await msg.on_success(self.summary_meta or {}) await msg.on_summary() elif msg == "PULL": qid = msg.kwargs.get("qid", -1) if qid < 0: qid = self._qid if self._exhausted[qid]: pytest.fail("PULLing exhausted result") if self.to_pull[qid] is None: n = msg.kwargs.get("n", -1) if n < 0: n = len(self._records[qid]) self.to_pull[qid] = \ min(n, len(self._records[qid]) - self.record_idxs[qid]) # if to == len(self._records): # self.fetch_idx += 1 if self.to_pull[qid] > 0: record = self._records[qid][self.record_idxs[qid]] self.record_idxs[qid] += 1 self.to_pull[qid] -= 1 await msg.on_records([record]) elif self.to_pull[qid] == 0: self.to_pull[qid] = None self.fetch_idx += 1 if self.record_idxs[qid] < len(self._records[qid]): await msg.on_success({"has_more": True}) else: await msg.on_success( {"bookmark": "foo", **(self.summary_meta or {})} ) self._exhausted[qid] = True await msg.on_summary() async def fetch_all(self): while self.fetch_idx < len(self.sent): await self.fetch_message() def run(self, *args, **kwargs): self.queued.append(AsyncConnectionStub.Message("RUN", *args, **kwargs)) def discard(self, *args, **kwargs): self.queued.append(AsyncConnectionStub.Message("DISCARD", *args, **kwargs)) def pull(self, *args, **kwargs): self.queued.append(AsyncConnectionStub.Message("PULL", *args, **kwargs)) server_info = ServerInfo(Address(("bolt://localhost", 7687)), Version(4, 3)) def defunct(self): return False def new_hydration_scope(self): class FakeHydrationScope: hydration_hooks = None dehydration_hooks = None def get_graph(self): return Graph() if len(self._records) > 1: return FakeHydrationScope() assert not self._new_hydration_scope_called assert self._records self._new_hydration_scope_called = True return self._records[0].hydration_scope def noop(*_, **__): pass async def fetch_and_compare_all_records( result, key, expected_records, method, limit=None ): received_records = [] if method == "for loop": async for record in result: assert isinstance(record, Record) received_records.append([record.data().get(key, None)]) if limit is not None and len(received_records) == limit: break if limit is None: assert result._exhausted elif method == "next": n = len(expected_records) if limit is None else limit for _ in range(n): record = await AsyncUtil.next(result) received_records.append([record.get(key, None)]) if limit is None: with pytest.raises(StopAsyncIteration): await AsyncUtil.next(result) assert result._exhausted elif method == "one iter": iter_ = AsyncUtil.iter(result) n = len(expected_records) if limit is None else limit for _ in range(n): record = await AsyncUtil.next(iter_) received_records.append([record.get(key, None)]) if limit is None: with pytest.raises(StopAsyncIteration): await AsyncUtil.next(iter_) assert result._exhausted elif method == "new iter": n = len(expected_records) if limit is None else limit for _ in range(n): iter_ = AsyncUtil.iter(result) record = await AsyncUtil.next(iter_) received_records.append([record.get(key, None)]) if limit is None: iter_ = AsyncUtil.iter(result) with pytest.raises(StopAsyncIteration): await AsyncUtil.next(iter_) assert result._exhausted else: raise ValueError() assert received_records == expected_records @pytest.mark.parametrize("method", ("for loop", "next", "one iter", "new iter")) @pytest.mark.parametrize("records", ( [], [[42]], [[1], [2], [3], [4], [5]], )) @mark_async_test async def test_result_iteration(method, records): connection = AsyncConnectionStub(records=Records(["x"], records)) result = AsyncResult(connection, 2, noop, noop) await result._run("CYPHER", {}, None, None, "r", None) await fetch_and_compare_all_records(result, "x", records, method) @mark_async_test async def test_result_iteration_mixed_methods(): records = [[i] for i in range(10)] connection = AsyncConnectionStub(records=Records(["x"], records)) result = AsyncResult(connection, 4, noop, noop) await result._run("CYPHER", {}, None, None, "r", None) iter1 = AsyncUtil.iter(result) iter2 = AsyncUtil.iter(result) assert (await AsyncUtil.next(iter1)).get("x") == records[0][0] assert (await AsyncUtil.next(iter2)).get("x") == records[1][0] assert (await AsyncUtil.next(iter2)).get("x") == records[2][0] assert (await AsyncUtil.next(iter1)).get("x") == records[3][0] assert (await AsyncUtil.next(iter1)).get("x") == records[4][0] assert (await AsyncUtil.next(result)).get("x") == records[5][0] assert (await AsyncUtil.next(iter2)).get("x") == records[6][0] assert (await AsyncUtil.next(iter1)).get("x") == records[7][0] assert ((await AsyncUtil.next(AsyncUtil.iter(result))).get("x") == records[8][0]) assert [r.get("x") async for r in result] == [records[9][0]] with pytest.raises(StopAsyncIteration): await AsyncUtil.next(iter1) with pytest.raises(StopAsyncIteration): await AsyncUtil.next(iter2) with pytest.raises(StopAsyncIteration): await AsyncUtil.next(result) with pytest.raises(StopAsyncIteration): await AsyncUtil.next(AsyncUtil.iter(result)) assert [r.get("x") async for r in result] == [] @pytest.mark.parametrize("method", ("for loop", "next", "one iter", "new iter")) @pytest.mark.parametrize("invert_fetch", (True, False)) @mark_async_test async def test_parallel_result_iteration(method, invert_fetch): records1 = [[i] for i in range(1, 6)] records2 = [[i] for i in range(6, 11)] connection = AsyncConnectionStub( records=(Records(["x"], records1), Records(["x"], records2)) ) result1 = AsyncResult(connection, 2, noop, noop) await result1._run("CYPHER1", {}, None, None, "r", None) result2 = AsyncResult(connection, 2, noop, noop) await result2._run("CYPHER2", {}, None, None, "r", None) if invert_fetch: await fetch_and_compare_all_records( result2, "x", records2, method ) await fetch_and_compare_all_records( result1, "x", records1, method ) else: await fetch_and_compare_all_records( result1, "x", records1, method ) await fetch_and_compare_all_records( result2, "x", records2, method ) @pytest.mark.parametrize("method", ("for loop", "next", "one iter", "new iter")) @pytest.mark.parametrize("invert_fetch", (True, False)) @mark_async_test async def test_interwoven_result_iteration(method, invert_fetch): records1 = [[i] for i in range(1, 10)] records2 = [[i] for i in range(11, 20)] connection = AsyncConnectionStub( records=(Records(["x"], records1), Records(["y"], records2)) ) result1 = AsyncResult(connection, 2, noop, noop) await result1._run("CYPHER1", {}, None, None, "r", None) result2 = AsyncResult(connection, 2, noop, noop) await result2._run("CYPHER2", {}, None, None, "r", None) start = 0 for n in (1, 2, 3, 1, None): end = n if n is None else start + n if invert_fetch: await fetch_and_compare_all_records( result2, "y", records2[start:end], method, n ) await fetch_and_compare_all_records( result1, "x", records1[start:end], method, n ) else: await fetch_and_compare_all_records( result1, "x", records1[start:end], method, n ) await fetch_and_compare_all_records( result2, "y", records2[start:end], method, n ) start = end @pytest.mark.parametrize("records", ([[1], [2]], [[1]], [])) @pytest.mark.parametrize("fetch_size", (1, 2)) @mark_async_test async def test_result_peek(records, fetch_size): connection = AsyncConnectionStub(records=Records(["x"], records)) result = AsyncResult(connection, fetch_size, noop, noop) await result._run("CYPHER", {}, None, None, "r", None) for i in range(len(records) + 1): record = await result.peek() if i == len(records): assert record is None else: assert isinstance(record, Record) assert record.get("x") == records[i][0] iter_ = AsyncUtil.iter(result) await AsyncUtil.next(iter_) # consume the record @pytest.mark.parametrize("records", ([[1], [2]], [[1]], [])) @pytest.mark.parametrize("fetch_size", (1, 2)) @pytest.mark.parametrize("default", (True, False)) @mark_async_test async def test_result_single_non_strict(records, fetch_size, default): kwargs = {} if not default: kwargs["strict"] = False connection = AsyncConnectionStub(records=Records(["x"], records)) result = AsyncResult(connection, fetch_size, noop, noop) await result._run("CYPHER", {}, None, None, "r", None) if len(records) == 0: assert await result.single(**kwargs) is None else: if len(records) == 1: record = await result.single(**kwargs) else: with pytest.warns(Warning, match="multiple"): record = await result.single(**kwargs) assert isinstance(record, Record) assert record.get("x") == records[0][0] @pytest.mark.parametrize("records", ([[1], [2]], [[1]], [])) @pytest.mark.parametrize("fetch_size", (1, 2)) @mark_async_test async def test_result_single_strict(records, fetch_size): connection = AsyncConnectionStub(records=Records(["x"], records)) result = AsyncResult(connection, fetch_size, noop, noop) await result._run("CYPHER", {}, None, None, "r", None) try: record = await result.single(strict=True) except ResultNotSingleError as exc: assert len(records) != 1 if len(records) == 0: assert exc is not None assert "no records" in str(exc).lower() elif len(records) > 1: assert exc is not None assert "more than one record" in str(exc).lower() else: assert len(records) == 1 assert isinstance(record, Record) assert record.get("x") == records[0][0] @pytest.mark.parametrize("records", ( [[1], [2], [3]], [[1]], [], [[i] for i in range(100)] )) @pytest.mark.parametrize("fetch_size", (1, 2)) @pytest.mark.parametrize("strict", (True, False)) @mark_async_test async def test_result_single_exhausts_records(records, fetch_size, strict): connection = AsyncConnectionStub(records=Records(["x"], records)) result = AsyncResult(connection, fetch_size, noop, noop) await result._run("CYPHER", {}, None, None, "r", None) try: with warnings.catch_warnings(): warnings.simplefilter("ignore") await result.single(strict=strict) except ResultNotSingleError: pass assert not result.closed() # close has nothing to do with being exhausted assert [r async for r in result] == [] assert not result.closed() @pytest.mark.parametrize("records", ( [[1], [2], [3]], [[1]], [], [[i] for i in range(100)] )) @pytest.mark.parametrize("fetch_size", (1, 2)) @pytest.mark.parametrize("strict", (True, False)) @mark_async_test async def test_result_fetch(records, fetch_size, strict): connection = AsyncConnectionStub(records=Records(["x"], records)) result = AsyncResult(connection, fetch_size, noop, noop) await result._run("CYPHER", {}, None, None, "r", None) assert await result.fetch(0) == [] assert await result.fetch(-1) == [] assert [[r.get("x")] for r in await result.fetch(2)] == records[:2] assert [[r.get("x")] for r in await result.fetch(1)] == records[2:3] assert [[r.get("x")] async for r in result] == records[3:] @mark_async_test async def test_keys_are_available_before_and_after_stream(): connection = AsyncConnectionStub(records=Records(["x"], [[1], [2]])) result = AsyncResult(connection, 1, noop, noop) await result._run("CYPHER", {}, None, None, "r", None) assert list(result.keys()) == ["x"] await AsyncUtil.list(result) assert list(result.keys()) == ["x"] @pytest.mark.parametrize("records", ([[1], [2]], [[1]], [])) @pytest.mark.parametrize("consume_one", (True, False)) @pytest.mark.parametrize("summary_meta", (None, {"database": "foobar"})) @pytest.mark.parametrize("consume_times", (1, 2)) @mark_async_test async def test_consume(records, consume_one, summary_meta, consume_times): connection = AsyncConnectionStub( records=Records(["x"], records), summary_meta=summary_meta ) result = AsyncResult(connection, 1, noop, noop) await result._run("CYPHER", {}, None, None, "r", None) if consume_one: try: await AsyncUtil.next(AsyncUtil.iter(result)) except StopAsyncIteration: pass for _ in range(consume_times): summary = await result.consume() assert isinstance(summary, ResultSummary) if summary_meta and "db" in summary_meta: assert summary.database == summary_meta["db"] else: assert summary.database is None server_info = summary.server assert isinstance(server_info, ServerInfo) assert server_info.protocol_version == Version(4, 3) assert isinstance(summary.counters, SummaryCounters) @pytest.mark.parametrize("t_first", (None, 0, 1, 123456789)) @pytest.mark.parametrize("t_last", (None, 0, 1, 123456789)) @mark_async_test async def test_time_in_summary(t_first, t_last): run_meta = None if t_first is not None: run_meta = {"t_first": t_first} summary_meta = None if t_last is not None: summary_meta = {"t_last": t_last} connection = AsyncConnectionStub( records=Records(["n"], [[i] for i in range(100)]), run_meta=run_meta, summary_meta=summary_meta ) result = AsyncResult(connection, 1, noop, noop) await result._run("CYPHER", {}, None, None, "r", None) summary = await result.consume() if t_first is not None: assert isinstance(summary.result_available_after, int) assert summary.result_available_after == t_first else: assert summary.result_available_after is None if t_last is not None: assert isinstance(summary.result_consumed_after, int) assert summary.result_consumed_after == t_last else: assert summary.result_consumed_after is None assert not hasattr(summary, "t_first") assert not hasattr(summary, "t_last") @mark_async_test async def test_counts_in_summary(): connection = AsyncConnectionStub(records=Records(["n"], [[1], [2]])) result = AsyncResult(connection, 1, noop, noop) await result._run("CYPHER", {}, None, None, "r", None) summary = await result.consume() assert isinstance(summary.counters, SummaryCounters) @pytest.mark.parametrize("query_type", ("r", "w", "rw", "s")) @mark_async_test async def test_query_type(query_type): connection = AsyncConnectionStub( records=Records(["n"], [[1], [2]]), summary_meta={"type": query_type} ) result = AsyncResult(connection, 1, noop, noop) await result._run("CYPHER", {}, None, None, "r", None) summary = await result.consume() assert isinstance(summary.query_type, str) assert summary.query_type == query_type @pytest.mark.parametrize("num_records", range(0, 5)) @mark_async_test async def test_data(num_records): connection = AsyncConnectionStub( records=Records(["n"], [[i + 1] for i in range(num_records)]) ) result = AsyncResult(connection, 1, noop, noop) await result._run("CYPHER", {}, None, None, "r", None) await result._buffer_all() records = result._record_buffer.copy() assert len(records) == num_records expected_data = [] for i, record in enumerate(records): record.data = mock.Mock() expected_data.append("magic_return_%s" % i) record.data.return_value = expected_data[-1] assert await result.data("hello", "world") == expected_data for record in records: assert record.data.called_once_with("hello", "world") @pytest.mark.parametrize("records", ( Records(["n"], []), Records(["n"], [[42], [69], [420], [1337]]), Records(["n1", "r", "n2"], [ [ # Node Structure(b"N", 0, ["Person", "LabelTest1"], {"name": "Alice"}), # Relationship Structure(b"R", 0, 0, 1, "KNOWS", {"since": 1999}), # Node Structure(b"N", 1, ["Person", "LabelTest2"], {"name": "Bob"}), ] ]), )) @mark_async_test async def test_result_graph(records): connection = AsyncConnectionStub(records=records) result = AsyncResult(connection, 1, noop, noop) await result._run("CYPHER", {}, None, None, "r", None) graph = await result.graph() assert isinstance(graph, Graph) if records.fields == ("n",): assert len(graph.relationships) == 0 assert len(graph.nodes) == 0 else: # EntitySetView is a little broken. It's a weird mixture of set, dict, # and iterable. Let's just test the underlying raw dict assert isinstance(graph.nodes, EntitySetView) nodes = graph.nodes assert set(nodes._entity_dict) == {"0", "1"} for key in ( "0", 0, 0.0, # I pray to god that no-one actually accessed nodes with complex # numbers, but theoretically it would have worked with the legacy # number IDs 0+0j, ): if not isinstance(key, str): with pytest.warns(DeprecationWarning, match="element_id"): alice = nodes[key] else: alice = nodes[key] assert isinstance(alice, Node) isinstance(alice.labels, frozenset) assert alice.labels == {"Person", "LabelTest1"} assert set(alice.keys()) == {"name"} assert alice["name"] == "Alice" for key in ("1", 1, 1.0, 1+0j): if not isinstance(key, str): with pytest.warns(DeprecationWarning, match="element_id"): bob = nodes[key] else: bob = nodes[key] assert isinstance(bob, Node) isinstance(bob.labels, frozenset) assert bob.labels == {"Person", "LabelTest2"} assert set(bob.keys()) == {"name"} assert bob["name"] == "Bob" assert isinstance(graph.relationships, EntitySetView) rels = graph.relationships assert set(rels._entity_dict) == {"0"} for key in ("0", 0, 0.0, 0+0j): if not isinstance(key, str): with pytest.warns(DeprecationWarning, match="element_id"): rel = rels[key] else: rel = rels[key] assert isinstance(rel, Relationship) assert rel.nodes == (alice, bob) assert rel.type == "KNOWS" assert set(rel.keys()) == {"since"} assert rel["since"] == 1999 @pytest.mark.parametrize( ("keys", "values", "types", "instances"), ( (["i"], list(zip(range(5))), ["int64"], None), (["x"], list(zip((n - .5) / 5 for n in range(5))), ["float64"], None), (["s"], list(zip(("foo", "bar", "baz", "foobar"))), ["object"], None), (["l"], list(zip(([1, 2], [3, 4]))), ["object"], None), ( ["n"], list(zip(( Structure(b"N", 0, ["LABEL_A"], {"a": 1, "b": 2}), Structure(b"N", 2, ["LABEL_B"], {"a": 1, "c": 1.2}), Structure(b"N", 1, ["LABEL_A", "LABEL_B"], {"a": [1, "a"]}), Structure(b"N", None, ["LABEL_A", "LABEL_B"], {"a": [1, "a"]}, "cool_id"), ))), ["object"], [Node] ), ( ["r"], list(zip(( Structure(b"R", 0, 1, 2, "TYPE", {"a": 1, "b": 2}), Structure(b"R", 420, 1337, 69, "HYPE", {"all memes": True}), Structure(b"R", None, None, None, "HYPE", {"all memes": True}, "420", "1337", "69"), ))), ["object"], [Relationship] ), ) ) @pytest.mark.parametrize("test_default_expand", (True, False)) @mark_async_test async def test_to_df(keys, values, types, instances, test_default_expand): connection = AsyncConnectionStub(records=Records(keys, values)) result = AsyncResult(connection, 1, noop, noop) await result._run("CYPHER", {}, None, None, "r", None) if test_default_expand: df = await result.to_df() else: df = await result.to_df(expand=False) assert isinstance(df, pd.DataFrame) assert df.keys().to_list() == keys assert len(df) == len(values) assert df.dtypes.to_list() == types expected_df = pd.DataFrame( {k: [v[i] for v in values] for i, k in enumerate(keys)} ) if instances: for i, k in enumerate(keys): assert all(isinstance(v, instances[i]) for v in df[k]) else: assert df.equals(expected_df) @pytest.mark.parametrize( ("keys", "values", "expected_columns", "expected_rows", "expected_types"), ( ( ["i"], list(zip(range(5))), ["i"], [[0], [1], [2], [3], [4]], ["int64"], ), # test variable name escaping ( ["i.[]->.().{}.\\"], list(zip(range(5))), ["i\\.[]->\\.()\\.{}\\.\\\\"], [[0], [1], [2], [3], [4]], ["int64"], ), ( ["x"], list(zip((n - .5) / 5 for n in range(5))), ["x"], [[-0.1], [0.1], [0.3], [0.5], [0.7]], ["float64"], ), ( ["s"], list(zip(("foo", "bar", "baz", "foobar"))), ["s"], [["foo"], ["bar"], ["baz"], ["foobar"]], ["object"], ), ( ["l"], list(zip(([1, 2], [3, 4]))), ["l[].0", "l[].1"], [[1, 2], [3, 4]], ["int64", "int64"], ), ( ["l"], list(zip(([1, 2], [3, 4, 5], [6]))), ["l[].0", "l[].1", "l[].2"], [[1, 2, None], [3, 4, 5], [6, None, None]], # pandas turns None in int columns into NaN # which requires the column to become a float column ["int64", "float64", "float64"], ), ( ["d"], list(zip(({"a": 1, "b": 2}, {"a": 3, "b": 4, "": 0}))), ["d{}.a", "d{}.b", "d{}."], [[1, 2, None], [3, 4, 0]], ["int64", "int64", "float64"], ), # test key escaping ( ["d"], list(zip(({"a.[]\\{}->.().{}.": 1, "b": 2},))), ["d{}.a\\.[]\\\\{}->\\.()\\.{}\\.", "d{}.b"], [[1, 2]], ["int64", "int64"], ), ( ["d"], list(zip(({"a": 1, "b": 2}, {"a": 3, "c": 4}))), ["d{}.a", "d{}.b", "d{}.c"], [[1, 2, None], [3, None, 4]], # pandas turns None in int columns into NaN # which requires the column to become a float column ["int64", "float64", "float64"], ), ( ["x"], list(zip(([{"foo": "bar", "baz": [42, 0.1]}, "foobar"],))), ["x[].0{}.foo", "x[].0{}.baz[].0", "x[].0{}.baz[].1", "x[].1"], [["bar", 42, 0.1, "foobar"]], ["object", "int64", "float64", "object"], ), ( ["n"], list(zip(( Node(None, # type: ignore[arg-type] "00", 0, ["LABEL_A"], {"a": 1, "b": 2, "d": 1}), Node(None, # type: ignore[arg-type] "02", 2, ["LABEL_B"], {"a": 1, "c": 1.2, "d": 2}), Node(None, # type: ignore[arg-type] "01", 1, ["LABEL_A", "LABEL_B"], {"a": [1, "a"], "d": 3}), ))), [ "n().element_id", "n().labels", "n().prop.a", "n().prop.b", "n().prop.c", "n().prop.d" ], [ ["00", frozenset(("LABEL_A",)), 1, 2, None, 1], ["02", frozenset(("LABEL_B",)), 1, None, 1.2, 2], [ "01", frozenset(("LABEL_A", "LABEL_B")), [1, "a"], None, None, 3 ], ], ["object", "object", "object", "float64", "float64", "int64"], ), ( ["r"], list(zip(( Structure(b"R", 0, 1, 2, "TYPE", {"a": 1, "all memes": False}, "r-0", "r-1", "r-2"), Structure(b"R", 420, 1337, 69, "HYPE", {"all memes": True}, "r-420", "r-1337", "r-69"), ))), [ "r->.element_id", "r->.start.element_id", "r->.end.element_id", "r->.type", "r->.prop.a", "r->.prop.all memes" ], [ ["r-0", "r-1", "r-2", "TYPE", 1, False], ["r-420", "r-1337", "r-69", "HYPE", None, True], ], ["object", "object", "object", "object", "float64", "bool"], ), ( ["dt"], [[neo4j_time.DateTime(2022, 1, 2, 3, 4, 5, 6)]], ["dt"], [[neo4j_time.DateTime(2022, 1, 2, 3, 4, 5, 6)]], ["object"], ), ) ) @mark_async_test async def test_to_df_expand(keys, values, expected_columns, expected_rows, expected_types): connection = AsyncConnectionStub(records=Records(keys, values)) result = AsyncResult(connection, 1, noop, noop) await result._run("CYPHER", {}, None, None, "r", None) df = await result.to_df(expand=True) assert isinstance(df, pd.DataFrame) assert len(set(expected_columns)) == len(expected_columns) assert set(df.keys().to_list()) == set(expected_columns) # We don't expect the columns to be in a specific order. # Hence, we need to sort them before comparing. new_order = [df.keys().get_loc(ex_c) for ex_c in expected_columns] expected_rows = [ [row[i] for i in new_order] for row in expected_rows ] expected_types = [expected_types[i] for i in new_order] expected_columns = [expected_columns[i] for i in new_order] assert len(df) == len(values) assert df.dtypes.to_list() == expected_types expected_df = pd.DataFrame(expected_rows, columns=expected_columns) assert df.equals(expected_df) @pytest.mark.parametrize( ("keys", "values", "expected_df"), ( # DateTime ( ["dt"], [ [neo4j_time.DateTime(2022, 1, 2, 3, 4, 5, 6)], ], pd.DataFrame( [[pd.Timestamp("2022-01-02 03:04:05.000000006")]], columns=["dt"], ) ), # Date ( ["d"], [ [neo4j_time.Date(2222, 2, 22)], ], pd.DataFrame( [[pd.Timestamp("2222-02-22")]], columns=["d"], ) ), # DateTime with timezone ( ["dt_tz"], [ [ pytz.timezone("Europe/Stockholm").localize( neo4j_time.DateTime(1970, 1, 1, 0, 0, 0, 0) ), ], ], pd.DataFrame( [[ pytz.timezone("Europe/Stockholm").localize( pd.Timestamp("1970-01-01") ) ]], columns=["dt_tz"], ) ), # DateTime, Date, DateTime with timezone, and None ( ["mixed"], [ [None], [neo4j_time.DateTime(2022, 1, 2, 3, 4, 5, 6)], [neo4j_time.Date(2222, 2, 22)], [ pytz.timezone("Europe/Stockholm").localize( neo4j_time.DateTime(1970, 1, 1, 0, 0, 0, 0) ), ], ], pd.DataFrame( [ [pd.NaT], [pd.Timestamp("2022-01-02 03:04:05.000000006")], [pd.Timestamp("2222-02-22")], [ pytz.timezone("Europe/Stockholm").localize( pd.Timestamp("1970-01-01") ) ], ], columns=["mixed"], ) ), # DateTime, Date, DateTime with timezone, and None in the middle ( ["mixed"], [ [neo4j_time.DateTime(2022, 1, 2, 3, 4, 5, 6)], [neo4j_time.Date(2222, 2, 22)], [None], [ pytz.timezone("Europe/Stockholm").localize( neo4j_time.DateTime(1970, 1, 1, 0, 0, 0, 0) ), ], ], pd.DataFrame( [ [pd.Timestamp("2022-01-02 03:04:05.000000006")], [pd.Timestamp("2222-02-22")], [pd.NaT], [ pytz.timezone("Europe/Stockholm").localize( pd.Timestamp("1970-01-01") ) ], ], columns=["mixed"], ) ), # DateTime, Date, DateTime with timezone, and None at the end ( ["mixed"], [ [neo4j_time.DateTime(2022, 1, 2, 3, 4, 5, 6)], [neo4j_time.Date(2222, 2, 22)], [ pytz.timezone("Europe/Stockholm").localize( neo4j_time.DateTime(1970, 1, 1, 0, 0, 0, 0) ), ], [None], ], pd.DataFrame( [ [pd.Timestamp("2022-01-02 03:04:05.000000006")], [pd.Timestamp("2222-02-22")], [ pytz.timezone("Europe/Stockholm").localize( pd.Timestamp("1970-01-01") ) ], [pd.NaT], ], columns=["mixed"], ) ), # Column with only None (should not be transfomred to NaT) ( ["all_none"], [ [None], [None], ], pd.DataFrame( [[None], [None]], columns=["all_none"], ) ), # Multiple columns ( ["all_none", "mixed", "n"], [ [ None, None, 1, ], [ None, neo4j_time.DateTime(2022, 1, 2, 3, 4, 5, 6), 1.234, ], ], pd.DataFrame( [ [ None, pd.NaT, 1.0, ], [ None, pd.Timestamp("2022-01-02 03:04:05.000000006"), 1.234 ], ], columns=["all_none", "mixed", "n"], ) ), ), ) @pytest.mark.parametrize("expand", [True, False]) @mark_async_test async def test_to_df_parse_dates(keys, values, expected_df, expand): connection = AsyncConnectionStub(records=Records(keys, values)) result = AsyncResult(connection, 1, noop, noop) await result._run("CYPHER", {}, None, None, "r", None) df = await result.to_df(expand=expand, parse_dates=True) pd.testing.assert_frame_equal(df, expected_df) @pytest.mark.parametrize("nested", [True, False]) @mark_async_test async def test_broken_hydration(nested): value_in = Structure(b"a", "broken") if nested: value_in = [value_in] records_in = Records(["foo", "bar"], [["foobar", value_in]]) connection = AsyncConnectionStub(records=records_in) result = AsyncResult(connection, 1, noop, noop) await result._run("CYPHER", {}, None, None, "r", None) records_out = await AsyncUtil.list(result) assert len(records_out) == 1 record_out = records_out[0] assert len(record_out) == 2 assert record_out[0] == "foobar" with pytest.raises(BrokenRecordError) as exc: _ = record_out[1] cause = exc.value.__cause__ assert isinstance(cause, ValueError) assert repr(b"a") in str(cause) neo4j-python-driver-5.2.1/tests/unit/async_/work/test_session.py000066400000000000000000000446011433522662700250400ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 contextlib import contextmanager import pytest from neo4j import ( AsyncManagedTransaction, AsyncSession, AsyncTransaction, Bookmarks, unit_of_work, ) from neo4j._async.io import ( AsyncBoltPool, AsyncNeo4jPool, ) from neo4j._conf import SessionConfig from neo4j.api import AsyncBookmarkManager from ...._async_compat import mark_async_test @contextmanager def assert_warns_tx_func_deprecation(tx_func_name): if tx_func_name.endswith("_transaction"): with pytest.warns(DeprecationWarning, match=f"{tx_func_name}.*execute_"): yield else: yield @mark_async_test async def test_session_context_calls_close(mocker): s = AsyncSession(None, SessionConfig()) mock_close = mocker.patch.object(s, 'close', autospec=True, side_effect=s.close) async with s: pass mock_close.assert_called_once_with() @pytest.mark.parametrize("test_run_args", ( ("RETURN $x", {"x": 1}), ("RETURN 1",) )) @pytest.mark.parametrize(("repetitions", "consume"), ( (1, False), (2, False), (2, True) )) @mark_async_test async def test_opens_connection_on_run( fake_pool, test_run_args, repetitions, consume ): async with AsyncSession(fake_pool, SessionConfig()) as session: assert session._connection is None result = await session.run(*test_run_args) assert session._connection is not None if consume: await result.consume() @pytest.mark.parametrize("test_run_args", ( ("RETURN $x", {"x": 1}), ("RETURN 1",) )) @pytest.mark.parametrize("repetitions", range(1, 3)) @mark_async_test async def test_closes_connection_after_consume( fake_pool, test_run_args, repetitions ): async with AsyncSession(fake_pool, SessionConfig()) as session: result = await session.run(*test_run_args) await result.consume() assert session._connection is None assert session._connection is None @pytest.mark.parametrize("test_run_args", ( ("RETURN $x", {"x": 1}), ("RETURN 1",) )) @mark_async_test async def test_keeps_connection_until_last_result_consumed( fake_pool, test_run_args ): async with AsyncSession(fake_pool, SessionConfig()) as session: result1 = await session.run(*test_run_args) result2 = await session.run(*test_run_args) assert session._connection is not None await result1.consume() assert session._connection is not None await result2.consume() assert session._connection is None @mark_async_test async def test_opens_connection_on_tx_begin(fake_pool): async with AsyncSession(fake_pool, SessionConfig()) as session: assert session._connection is None async with await session.begin_transaction() as _: assert session._connection is not None @pytest.mark.parametrize("test_run_args", ( ("RETURN $x", {"x": 1}), ("RETURN 1",) )) @pytest.mark.parametrize("repetitions", range(1, 3)) @mark_async_test async def test_keeps_connection_on_tx_run( fake_pool, test_run_args, repetitions ): async with AsyncSession(fake_pool, SessionConfig()) as session: async with await session.begin_transaction() as tx: for _ in range(repetitions): await tx.run(*test_run_args) assert session._connection is not None @pytest.mark.parametrize("test_run_args", ( ("RETURN $x", {"x": 1}), ("RETURN 1",) )) @pytest.mark.parametrize("repetitions", range(1, 3)) @mark_async_test async def test_keeps_connection_on_tx_consume( fake_pool, test_run_args, repetitions ): async with AsyncSession(fake_pool, SessionConfig()) as session: async with await session.begin_transaction() as tx: for _ in range(repetitions): result = await tx.run(*test_run_args) await result.consume() assert session._connection is not None @pytest.mark.parametrize("test_run_args", ( ("RETURN $x", {"x": 1}), ("RETURN 1",) )) @mark_async_test async def test_closes_connection_after_tx_close(fake_pool, test_run_args): async with AsyncSession(fake_pool, SessionConfig()) as session: async with await session.begin_transaction() as tx: for _ in range(2): result = await tx.run(*test_run_args) await result.consume() await tx.close() assert session._connection is None assert session._connection is None @pytest.mark.parametrize("test_run_args", ( ("RETURN $x", {"x": 1}), ("RETURN 1",) )) @mark_async_test async def test_closes_connection_after_tx_commit(fake_pool, test_run_args): async with AsyncSession(fake_pool, SessionConfig()) as session: async with await session.begin_transaction() as tx: for _ in range(2): result = await tx.run(*test_run_args) await result.consume() await tx.commit() assert session._connection is None assert session._connection is None @pytest.mark.parametrize( "bookmark_values", (None, [], ["abc"], ["foo", "bar"], {"a", "b"}, ("1", "two")) ) @mark_async_test async def test_session_returns_bookmarks_directly(fake_pool, bookmark_values): if bookmark_values is not None: bookmarks = Bookmarks.from_raw_values(bookmark_values) else: bookmarks = Bookmarks() async with AsyncSession( fake_pool, SessionConfig(bookmarks=bookmarks) ) as session: ret_bookmarks = (await session.last_bookmarks()) assert isinstance(ret_bookmarks, Bookmarks) ret_bookmarks = ret_bookmarks.raw_values if bookmark_values is None: assert ret_bookmarks == frozenset() else: assert ret_bookmarks == frozenset(bookmark_values) @pytest.mark.parametrize( "bookmarks", (None, [], ["abc"], ["foo", "bar"], ("1", "two")) ) @mark_async_test async def test_session_last_bookmark_is_deprecated(fake_pool, bookmarks): if bookmarks is not None: with pytest.warns(DeprecationWarning): session = AsyncSession(fake_pool, SessionConfig(bookmarks=bookmarks)) else: session = AsyncSession(fake_pool, SessionConfig(bookmarks=bookmarks)) async with session: with pytest.warns(DeprecationWarning): if bookmarks: assert (await session.last_bookmark()) == bookmarks[-1] else: assert (await session.last_bookmark()) is None @pytest.mark.parametrize( "bookmarks", (("foo",), ("foo", "bar"), (), ["foo", "bar"], {"a", "b"}) ) @mark_async_test async def test_session_bookmarks_as_iterable_is_deprecated( fake_pool, bookmarks ): with pytest.warns(DeprecationWarning): async with AsyncSession(fake_pool, SessionConfig( bookmarks=bookmarks )) as session: ret_bookmarks = (await session.last_bookmarks()).raw_values assert ret_bookmarks == frozenset(bookmarks) @pytest.mark.parametrize(("query", "error_type"), ( (None, ValueError), (1234, TypeError), ({"how about": "no?"}, TypeError), (["I don't", "think so"], TypeError), )) @mark_async_test async def test_session_run_wrong_types(fake_pool, query, error_type): async with AsyncSession(fake_pool, SessionConfig()) as session: with pytest.raises(error_type): await session.run(query) @pytest.mark.parametrize("tx_type", ("write_transaction", "read_transaction", "execute_write", "execute_read",)) @mark_async_test async def test_tx_function_argument_type(fake_pool, tx_type): called = False async def work(tx): nonlocal called called = True assert isinstance(tx, AsyncManagedTransaction) async with AsyncSession(fake_pool, SessionConfig()) as session: with assert_warns_tx_func_deprecation(tx_type): await getattr(session, tx_type)(work) assert called @pytest.mark.parametrize("tx_type", ("write_transaction", "read_transaction", "execute_write", "execute_read")) @pytest.mark.parametrize("decorator_kwargs", ( {}, {"timeout": 5}, {"metadata": {"foo": "bar"}}, {"timeout": 5, "metadata": {"foo": "bar"}}, )) @mark_async_test async def test_decorated_tx_function_argument_type( fake_pool, tx_type, decorator_kwargs ): called = False @unit_of_work(**decorator_kwargs) async def work(tx): nonlocal called called = True assert isinstance(tx, AsyncManagedTransaction) async with AsyncSession(fake_pool, SessionConfig()) as session: with assert_warns_tx_func_deprecation(tx_type): await getattr(session, tx_type)(work) assert called @mark_async_test async def test_session_tx_type(fake_pool): async with AsyncSession(fake_pool, SessionConfig()) as session: tx = await session.begin_transaction() assert isinstance(tx, AsyncTransaction) @pytest.mark.parametrize("parameters", ( {"x": None}, {"x": True}, {"x": False}, {"x": 123456789}, {"x": 3.1415926}, {"x": float("nan")}, {"x": float("inf")}, {"x": float("-inf")}, {"x": "foo"}, {"x": bytearray([0x00, 0x33, 0x66, 0x99, 0xCC, 0xFF])}, {"x": b"\x00\x33\x66\x99\xcc\xff"}, {"x": [1, 2, 3]}, {"x": ["a", "b", "c"]}, {"x": ["a", 2, 1.234]}, {"x": ["a", 2, ["c"]]}, {"x": {"one": "eins", "two": "zwei", "three": "drei"}}, {"x": {"one": ["eins", "uno", 1], "two": ["zwei", "dos", 2]}}, )) @pytest.mark.parametrize("run_type", ("auto", "unmanaged", "managed")) @mark_async_test async def test_session_run_with_parameters(fake_pool, parameters, run_type): async with AsyncSession(fake_pool, SessionConfig()) as session: if run_type == "auto": await session.run("RETURN $x", **parameters) elif run_type == "unmanaged": tx = await session.begin_transaction() await tx.run("RETURN $x", **parameters) elif run_type == "managed": async def work(tx): await tx.run("RETURN $x", **parameters) await session.execute_write(work) else: raise ValueError(run_type) assert len(fake_pool.acquired_connection_mocks) == 1 connection_mock = fake_pool.acquired_connection_mocks[0] connection_mock.run.assert_called_once() call = connection_mock.run.call_args assert call.args[0] == "RETURN $x" assert call.kwargs["parameters"] == parameters @pytest.mark.parametrize( ("params", "kw_params", "expected_params"), ( ({"x": 1}, {}, {"x": 1}), ({}, {"x": 1}, {"x": 1}), ({"x": 1}, {"y": 2}, {"x": 1, "y": 2}), ({"x": 1}, {"x": 2}, {"x": 2}), ({"x": 1}, {"x": 2}, {"x": 2}), ({"x": 1, "y": 3}, {"x": 2}, {"x": 2, "y": 3}), ({"x": 1}, {"x": 2, "y": 3}, {"x": 2, "y": 3}), # potentially internally used keyword arguments ({}, {"timeout": 2}, {"timeout": 2}), ({"timeout": 2}, {}, {"timeout": 2}), ({}, {"imp_user": "hans"}, {"imp_user": "hans"}), ({"imp_user": "hans"}, {}, {"imp_user": "hans"}), ({}, {"db": "neo4j"}, {"db": "neo4j"}), ({"db": "neo4j"}, {}, {"db": "neo4j"}), ({}, {"database": "neo4j"}, {"database": "neo4j"}), ({"database": "neo4j"}, {}, {"database": "neo4j"}), ) ) @pytest.mark.parametrize("run_type", ("auto", "unmanaged", "managed")) @mark_async_test async def test_session_run_parameter_precedence( fake_pool, params, kw_params, expected_params, run_type ): async with AsyncSession(fake_pool, SessionConfig()) as session: if run_type == "auto": await session.run("RETURN $x", params, **kw_params) elif run_type == "unmanaged": tx = await session.begin_transaction() await tx.run("RETURN $x", params, **kw_params) elif run_type == "managed": async def work(tx): await tx.run("RETURN $x", params, **kw_params) await session.execute_write(work) else: raise ValueError(run_type) assert len(fake_pool.acquired_connection_mocks) == 1 connection_mock = fake_pool.acquired_connection_mocks[0] connection_mock.run.assert_called_once() call = connection_mock.run.call_args assert call.args[0] == "RETURN $x" assert call.kwargs["parameters"] == expected_params @pytest.mark.parametrize("db", (None, "adb")) @pytest.mark.parametrize("routing", (True, False)) # no home db resolution when connected to Neo4j 4.3 or earlier @pytest.mark.parametrize("home_db_gets_resolved", (True, False)) @pytest.mark.parametrize("additional_session_bookmarks", (None, ["session", "bookmarks"])) @mark_async_test async def test_with_bookmark_manager( fake_pool, db, routing, async_scripted_connection, home_db_gets_resolved, additional_session_bookmarks, mocker ): async def update_routing_table_side_effect( database, imp_user, bookmarks, acquisition_timeout=None, database_callback=None ): if home_db_gets_resolved: database_callback("homedb") async def bmm_get_bookmarks(database): return [f"{database}:bm1"] async def bmm_gat_all_bookmarks(): return ["all", "bookmarks"] async_scripted_connection.set_script([ ("run", {"on_success": None, "on_summary": None}), ("pull", { "on_success": ({"bookmark": "res:bm1", "has_more": False},), "on_summary": None, "on_records": None, }) ]) fake_pool.buffered_connection_mocks.append(async_scripted_connection) bmm = mocker.Mock(spec=AsyncBookmarkManager) bmm.get_bookmarks.side_effect = bmm_get_bookmarks bmm.get_all_bookmarks.side_effect = bmm_gat_all_bookmarks if routing: fake_pool.mock_add_spec(AsyncNeo4jPool) fake_pool.update_routing_table.side_effect = \ update_routing_table_side_effect else: fake_pool.mock_add_spec(AsyncBoltPool) config = SessionConfig() config.bookmark_manager = bmm if db is not None: config.database = db if additional_session_bookmarks: config.bookmarks = Bookmarks.from_raw_values( additional_session_bookmarks ) async with AsyncSession(fake_pool, config) as session: assert not bmm.method_calls await session.run("RETURN 1") # assert called bmm accordingly expected_bmm_method_calls = [mocker.call.get_bookmarks("system"), mocker.call.get_all_bookmarks()] if routing and db is None: expected_bmm_method_calls = [ # extra call for resolving the home database mocker.call.get_bookmarks("system"), *expected_bmm_method_calls ] assert bmm.method_calls == expected_bmm_method_calls assert (bmm.get_bookmarks.await_count == len(expected_bmm_method_calls) - 1) bmm.get_all_bookmarks.assert_awaited_once() bmm.method_calls.clear() expected_update_for_db = db if not db: if home_db_gets_resolved and routing: expected_update_for_db = "homedb" else: expected_update_for_db = "" assert [call[0] for call in bmm.method_calls] == ["update_bookmarks"] assert bmm.method_calls[0].kwargs == {} assert len(bmm.method_calls[0].args) == 3 assert bmm.method_calls[0].args[0] == expected_update_for_db assert (set(bmm.method_calls[0].args[1]) == {"all", "bookmarks", *(additional_session_bookmarks or [])}) assert set(bmm.method_calls[0].args[2]) == {"res:bm1"} expected_pool_method_calls = ["acquire", "release"] if routing and db is None: expected_pool_method_calls = ["update_routing_table", *expected_pool_method_calls] assert ([call[0] for call in fake_pool.method_calls] == expected_pool_method_calls) assert (set(fake_pool.acquire.call_args.kwargs["bookmarks"]) == {"system:bm1", *(additional_session_bookmarks or [])}) if routing and db is None: assert ( set(fake_pool.update_routing_table.call_args.kwargs["bookmarks"]) == {"system:bm1", *(additional_session_bookmarks or [])} ) assert len(fake_pool.acquired_connection_mocks) == 1 connection_mock = fake_pool.acquired_connection_mocks[0] connection_mock.run.assert_called_once() connection_run_call_kwargs = connection_mock.run.call_args.kwargs assert (set(connection_run_call_kwargs["bookmarks"]) == {"all", "bookmarks", *(additional_session_bookmarks or [])}) @pytest.mark.parametrize("routing", (True, False)) @pytest.mark.parametrize("session_method", ("run", "get_server_info")) @mark_async_test async def test_last_bookmarks_do_not_leak_bookmark_managers_bookmarks( fake_pool, routing, session_method, mocker ): async def bmm_get_bookmarks(database): return [f"bmm:{database}"] async def bmm_gat_all_bookmarks(): return ["bmm:all", "bookmarks"] fake_pool.mock_add_spec(AsyncNeo4jPool if routing else AsyncBoltPool) bmm = mocker.Mock(spec=AsyncBookmarkManager) bmm.get_bookmarks.side_effect = bmm_get_bookmarks bmm.get_all_bookmarks.side_effect = bmm_gat_all_bookmarks config = SessionConfig() config.bookmark_manager = bmm config.bookmarks = Bookmarks.from_raw_values(["session", "bookmarks"]) async with AsyncSession(fake_pool, config) as session: if session_method == "run": await session.run("RETURN 1") elif session_method == "get_server_info": await session._get_server_info() else: assert False last_bookmarks = await session.last_bookmarks() assert last_bookmarks.raw_values == {"session", "bookmarks"} assert last_bookmarks.raw_values == {"session", "bookmarks"} neo4j-python-driver-5.2.1/tests/unit/async_/work/test_transaction.py000066400000000000000000000154221433522662700257010ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 unittest.mock import MagicMock from uuid import uuid4 import pytest from neo4j import ( AsyncTransaction, Query, ) from ...._async_compat import mark_async_test @pytest.mark.parametrize(("explicit_commit", "close"), ( (False, False), (True, False), (True, True), )) @mark_async_test async def test_transaction_context_when_committing( mocker, async_fake_connection, explicit_commit, close ): on_closed = mocker.AsyncMock() on_error = mocker.AsyncMock() on_cancel = mocker.Mock() tx = AsyncTransaction(async_fake_connection, 2, on_closed, on_error, on_cancel) mock_commit = mocker.patch.object(tx, "_commit", wraps=tx._commit) mock_rollback = mocker.patch.object(tx, "_rollback", wraps=tx._rollback) async with tx as tx_: assert mock_commit.call_count == 0 assert mock_rollback.call_count == 0 assert tx is tx_ if explicit_commit: await tx_.commit() mock_commit.assert_awaited_once_with() assert tx_.closed() if close: await tx_.close() assert tx_.closed() mock_commit.assert_awaited_once_with() assert mock_rollback.call_count == 0 assert tx_.closed() @pytest.mark.parametrize(("rollback", "close"), ( (True, False), (False, True), (True, True), )) @mark_async_test async def test_transaction_context_with_explicit_rollback( mocker, async_fake_connection, rollback, close ): on_closed = mocker.AsyncMock() on_error = mocker.AsyncMock() on_cancel = mocker.Mock() tx = AsyncTransaction(async_fake_connection, 2, on_closed, on_error, on_cancel) mock_commit = mocker.patch.object(tx, "_commit", wraps=tx._commit) mock_rollback = mocker.patch.object(tx, "_rollback", wraps=tx._rollback) async with tx as tx_: assert mock_commit.call_count == 0 assert mock_rollback.call_count == 0 assert tx is tx_ if rollback: await tx_.rollback() mock_rollback.assert_awaited_once_with() assert tx_.closed() if close: await tx_.close() mock_rollback.assert_awaited_once_with() assert tx_.closed() assert mock_commit.call_count == 0 mock_rollback.assert_awaited_once_with() assert tx_.closed() @mark_async_test async def test_transaction_context_calls_rollback_on_error( mocker, async_fake_connection ): class OopsError(RuntimeError): pass on_closed = MagicMock() on_error = MagicMock() on_cancel = MagicMock() tx = AsyncTransaction(async_fake_connection, 2, on_closed, on_error, on_cancel) mock_commit = mocker.patch.object(tx, "_commit", wraps=tx._commit) mock_rollback = mocker.patch.object(tx, "_rollback", wraps=tx._rollback) with pytest.raises(OopsError): async with tx as tx_: assert mock_commit.call_count == 0 assert mock_rollback.call_count == 0 assert tx is tx_ raise OopsError assert mock_commit.call_count == 0 mock_rollback.assert_awaited_once_with() assert tx_.closed() @mark_async_test async def test_transaction_run_takes_no_query_object(async_fake_connection): on_closed = MagicMock() on_error = MagicMock() on_cancel = MagicMock() tx = AsyncTransaction(async_fake_connection, 2, on_closed, on_error, on_cancel) with pytest.raises(ValueError): await tx.run(Query("RETURN 1")) @mark_async_test async def test_transaction_rollbacks_on_open_connections( async_fake_connection ): tx = AsyncTransaction( async_fake_connection, 2, lambda *args, **kwargs: None, lambda *args, **kwargs: None, lambda *args, **kwargs: None ) async with tx as tx_: async_fake_connection.is_reset_mock.return_value = False async_fake_connection.is_reset_mock.reset_mock() await tx_.rollback() async_fake_connection.is_reset_mock.assert_called_once() async_fake_connection.reset.assert_not_called() async_fake_connection.rollback.assert_called_once() @mark_async_test async def test_transaction_no_rollback_on_reset_connections( async_fake_connection ): tx = AsyncTransaction( async_fake_connection, 2, lambda *args, **kwargs: None, lambda *args, **kwargs: None, lambda *args, **kwargs: None ) async with tx as tx_: async_fake_connection.is_reset_mock.return_value = True async_fake_connection.is_reset_mock.reset_mock() await tx_.rollback() async_fake_connection.is_reset_mock.assert_called_once() async_fake_connection.reset.assert_not_called() async_fake_connection.rollback.assert_not_called() @mark_async_test async def test_transaction_no_rollback_on_closed_connections( async_fake_connection ): tx = AsyncTransaction( async_fake_connection, 2, lambda *args, **kwargs: None, lambda *args, **kwargs: None, lambda *args, **kwargs: None ) async with tx as tx_: async_fake_connection.closed.return_value = True async_fake_connection.closed.reset_mock() async_fake_connection.is_reset_mock.reset_mock() await tx_.rollback() async_fake_connection.closed.assert_called_once() async_fake_connection.is_reset_mock.assert_not_called() async_fake_connection.reset.assert_not_called() async_fake_connection.rollback.assert_not_called() @mark_async_test async def test_transaction_no_rollback_on_defunct_connections( async_fake_connection ): tx = AsyncTransaction( async_fake_connection, 2, lambda *args, **kwargs: None, lambda *args, **kwargs: None, lambda *args, **kwargs: None ) async with tx as tx_: async_fake_connection.defunct.return_value = True async_fake_connection.defunct.reset_mock() async_fake_connection.is_reset_mock.reset_mock() await tx_.rollback() async_fake_connection.defunct.assert_called_once() async_fake_connection.is_reset_mock.assert_not_called() async_fake_connection.reset.assert_not_called() async_fake_connection.rollback.assert_not_called() neo4j-python-driver-5.2.1/tests/unit/common/000077500000000000000000000000001433522662700207715ustar00rootroot00000000000000neo4j-python-driver-5.2.1/tests/unit/common/__init__.py000066400000000000000000000012011433522662700230740ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. neo4j-python-driver-5.2.1/tests/unit/common/codec/000077500000000000000000000000001433522662700220465ustar00rootroot00000000000000neo4j-python-driver-5.2.1/tests/unit/common/codec/__init__.py000066400000000000000000000012011433522662700241510ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. neo4j-python-driver-5.2.1/tests/unit/common/codec/hydration/000077500000000000000000000000001433522662700240475ustar00rootroot00000000000000neo4j-python-driver-5.2.1/tests/unit/common/codec/hydration/__init__.py000066400000000000000000000012011433522662700261520ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. neo4j-python-driver-5.2.1/tests/unit/common/codec/hydration/_common.py000066400000000000000000000041261433522662700260530ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 datetime import ( date, datetime, time, timedelta, ) import pytest from neo4j._codec.hydration import HydrationScope from neo4j._codec.hydration.v1 import HydrationHandler as HydrationHandlerV1 from neo4j._codec.hydration.v2 import HydrationHandler as HydrationHandlerV2 from neo4j._codec.packstream import Structure from neo4j.spatial import ( CartesianPoint, Point, WGS84Point, ) from neo4j.time import ( Date, DateTime, Duration, Time, ) class HydrationHandlerTestBase: @pytest.fixture(params=[HydrationHandlerV1, HydrationHandlerV2]) def hydration_handler(self, request): return request.param() def test_handler_hydration_scope(self, hydration_handler): scope = hydration_handler.new_hydration_scope() assert isinstance(scope, HydrationScope) @pytest.fixture def hydration_scope(self, hydration_handler): return hydration_handler.new_hydration_scope() def test_scope_hydration_keys(self, hydration_scope): hooks = hydration_scope.hydration_hooks assert isinstance(hooks, dict) assert set(hooks.keys()) == {Structure} def test_scope_dehydration_keys(self, hydration_scope): hooks = hydration_scope.dehydration_hooks assert isinstance(hooks, dict) assert set(hooks.keys()) == { date, datetime, time, timedelta, Date, DateTime, Duration, Time, CartesianPoint, Point, WGS84Point } neo4j-python-driver-5.2.1/tests/unit/common/codec/hydration/v1/000077500000000000000000000000001433522662700243755ustar00rootroot00000000000000neo4j-python-driver-5.2.1/tests/unit/common/codec/hydration/v1/__init__.py000066400000000000000000000012011433522662700265000ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. neo4j-python-driver-5.2.1/tests/unit/common/codec/hydration/v1/_base.py000066400000000000000000000016141433522662700260220ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest class HydrationHandlerTestBase: @pytest.fixture() def hydration_handler(self): raise NotImplementedError() @pytest.fixture def hydration_scope(self, hydration_handler): return hydration_handler.new_hydration_scope() neo4j-python-driver-5.2.1/tests/unit/common/codec/hydration/v1/test_graph_hydration.py000066400000000000000000000047311433522662700311750ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j._codec.hydration.v1 import HydrationHandler from neo4j._codec.packstream import Structure from neo4j.graph import ( Graph, Node, Relationship, ) from ._base import HydrationHandlerTestBase class TestGraphHydration(HydrationHandlerTestBase): @pytest.fixture def hydration_handler(self): return HydrationHandler() def test_can_hydrate_node_structure(self, hydration_scope): struct = Structure(b'N', 123, ["Person"], {"name": "Alice"}) alice = hydration_scope.hydration_hooks[Structure](struct) assert isinstance(alice, Node) with pytest.warns(DeprecationWarning, match="element_id"): assert alice.id == 123 # for backwards compatibility, the driver should compute the element_id assert alice.element_id == "123" assert alice.labels == {"Person"} assert set(alice.keys()) == {"name"} assert alice.get("name") == "Alice" def test_can_hydrate_relationship_structure(self, hydration_scope): struct = Structure(b'R', 123, 456, 789, "KNOWS", {"since": 1999}) rel = hydration_scope.hydration_hooks[Structure](struct) assert isinstance(rel, Relationship) with pytest.warns(DeprecationWarning, match="element_id"): assert rel.id == 123 with pytest.warns(DeprecationWarning, match="element_id"): assert rel.start_node.id == 456 with pytest.warns(DeprecationWarning, match="element_id"): assert rel.end_node.id == 789 # for backwards compatibility, the driver should compute the element_id assert rel.element_id == "123" assert rel.start_node.element_id == "456" assert rel.end_node.element_id == "789" assert rel.type == "KNOWS" assert set(rel.keys()) == {"since"} assert rel.get("since") == 1999 neo4j-python-driver-5.2.1/tests/unit/common/codec/hydration/v1/test_hydration_handler.py000066400000000000000000000056241433522662700315130ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 datetime import ( date, datetime, time, timedelta, ) import pytest from neo4j._codec.hydration import HydrationScope from neo4j._codec.hydration.v1 import HydrationHandler from neo4j._codec.packstream import Structure from neo4j.graph import Graph from neo4j.spatial import ( CartesianPoint, Point, WGS84Point, ) from neo4j.time import ( Date, DateTime, Duration, Time, ) from ._base import HydrationHandlerTestBase class TestHydrationHandler(HydrationHandlerTestBase): @pytest.fixture def hydration_handler(self): return HydrationHandler() def test_handler_hydration_scope(self, hydration_handler): scope = hydration_handler.new_hydration_scope() assert isinstance(scope, HydrationScope) @pytest.fixture def hydration_scope(self, hydration_handler): return hydration_handler.new_hydration_scope() def test_scope_hydration_keys(self, hydration_scope): hooks = hydration_scope.hydration_hooks assert isinstance(hooks, dict) assert set(hooks.keys()) == {Structure, list, dict} def test_scope_dehydration_keys(self, hydration_scope): hooks = hydration_scope.dehydration_hooks assert isinstance(hooks, dict) assert set(hooks.keys()) == { date, datetime, time, timedelta, Date, DateTime, Duration, Time, CartesianPoint, Point, WGS84Point } def test_scope_get_graph(self, hydration_scope): graph = hydration_scope.get_graph() assert isinstance(graph, Graph) assert not graph.nodes assert not graph.relationships @pytest.mark.parametrize("data", ( [1, 2, 3], ["a", "b", "c"], [object(), object()], [ValueError(), 42, {}, b"foo"], )) def test_list_hydration(self, hydration_scope, data): res = hydration_scope.hydration_hooks[list](data) assert res == data @pytest.mark.parametrize("data", ( {"a": 1, "b": 2, "c": 3}, {"a": "a", "b": "b", "c": "c"}, {"a": object(), "b": object()}, {"a": ValueError(), "b": 42, "c": {}, "d": b"foo"}, )) def test_dict_hydration(self, hydration_scope, data): res = hydration_scope.hydration_hooks[dict](data) assert res == data neo4j-python-driver-5.2.1/tests/unit/common/codec/hydration/v1/test_spacial_dehydration.py000066400000000000000000000053741433522662700320250ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j._codec.hydration.v1 import HydrationHandler from neo4j._codec.packstream import Structure from neo4j.spatial import ( CartesianPoint, Point, WGS84Point, ) from ._base import HydrationHandlerTestBase class TestSpatialDehydration(HydrationHandlerTestBase): @pytest.fixture def hydration_handler(self): return HydrationHandler() def test_cartesian_2d(self, hydration_scope): point = CartesianPoint((1, 3.1)) struct = hydration_scope.dehydration_hooks[type(point)](point) assert struct == Structure(b"X", 7203, 1.0, 3.1) assert all(isinstance(f, float) for f in struct.fields[1:]) def test_cartesian_3d(self, hydration_scope): point = CartesianPoint((1, -2, 3.1)) struct = hydration_scope.dehydration_hooks[type(point)](point) assert struct == Structure(b"Y", 9157, 1.0, -2.0, 3.1) assert all(isinstance(f, float) for f in struct.fields[1:]) def test_wgs84_2d(self, hydration_scope): point = WGS84Point((1, 3.1)) struct = hydration_scope.dehydration_hooks[type(point)](point) assert struct == Structure(b"X", 4326, 1.0, 3.1) assert all(isinstance(f, float) for f in struct.fields[1:]) def test_wgs84_3d(self, hydration_scope): point = WGS84Point((1, -2, 3.1)) struct = hydration_scope.dehydration_hooks[type(point)](point) assert struct == Structure(b"Y", 4979, 1.0, -2.0, 3.1) assert all(isinstance(f, float) for f in struct.fields[1:]) def test_custom_point_2d(self, hydration_scope): point = Point((1, 3.1)) point.srid = 12345 struct = hydration_scope.dehydration_hooks[type(point)](point) assert struct == Structure(b"X", 12345, 1.0, 3.1) assert all(isinstance(f, float) for f in struct.fields[1:]) def test_custom_point_3d(self, hydration_scope): point = Point((1, -2, 3.1)) point.srid = 12345 struct = hydration_scope.dehydration_hooks[type(point)](point) assert struct == Structure(b"Y", 12345, 1.0, -2.0, 3.1) assert all(isinstance(f, float) for f in struct.fields[1:]) neo4j-python-driver-5.2.1/tests/unit/common/codec/hydration/v1/test_spacial_hydration.py000066400000000000000000000053441433522662700315110ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j._codec.hydration.v1 import HydrationHandler from neo4j._codec.packstream import Structure from neo4j.spatial import ( CartesianPoint, Point, WGS84Point, ) from ._base import HydrationHandlerTestBase class TestSpatialHydration(HydrationHandlerTestBase): @pytest.fixture def hydration_handler(self): return HydrationHandler() def test_cartesian_2d(self, hydration_scope): struct = Structure(b"X", 7203, 1.0, 3.1) point = hydration_scope.hydration_hooks[Structure](struct) assert isinstance(point, CartesianPoint) assert point.srid == 7203 assert tuple(point) == (1.0, 3.1) def test_cartesian_3d(self, hydration_scope): struct = Structure(b"Y", 9157, 1.0, -2.0, 3.1) point = hydration_scope.hydration_hooks[Structure](struct) assert isinstance(point, CartesianPoint) assert point.srid == 9157 assert tuple(point) == (1.0, -2.0, 3.1) def test_wgs84_2d(self, hydration_scope): struct = Structure(b"X", 4326, 1.0, 3.1) point = hydration_scope.hydration_hooks[Structure](struct) assert isinstance(point, WGS84Point) assert point.srid == 4326 assert tuple(point) == (1.0, 3.1) def test_wgs84_3d(self, hydration_scope): struct = Structure(b"Y", 4979, 1.0, -2.0, 3.1) point = hydration_scope.hydration_hooks[Structure](struct) assert isinstance(point, WGS84Point) assert point.srid == 4979 assert tuple(point) == (1.0, -2.0, 3.1) def test_custom_point_2d(self, hydration_scope): struct = Structure(b"X", 12345, 1.0, 3.1) point = hydration_scope.hydration_hooks[Structure](struct) assert isinstance(point, Point) assert point.srid == 12345 assert tuple(point) == (1.0, 3.1) def test_custom_point_3d(self, hydration_scope): struct = Structure(b"Y", 12345, 1.0, -2.0, 3.1) point = hydration_scope.hydration_hooks[Structure](struct) assert isinstance(point, Point) assert point.srid == 12345 assert tuple(point) == (1.0, -2.0, 3.1) neo4j-python-driver-5.2.1/tests/unit/common/codec/hydration/v1/test_temporal_dehydration.py000066400000000000000000000170461433522662700322330ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 datetime import pytest import pytz from neo4j._codec.hydration.v1 import HydrationHandler from neo4j._codec.packstream import Structure from neo4j.time import ( Date, DateTime, Duration, Time, ) from ._base import HydrationHandlerTestBase class TestTimeDehydration(HydrationHandlerTestBase): @pytest.fixture def hydration_handler(self): return HydrationHandler() def test_date(self, hydration_scope): date = Date(1991, 8, 24) struct = hydration_scope.dehydration_hooks[type(date)](date) assert struct == Structure(b"D", 7905) def test_native_date(self, hydration_scope): date = datetime.date(1991, 8, 24) struct = hydration_scope.dehydration_hooks[type(date)](date) assert struct == Structure(b"D", 7905) def test_time(self, hydration_scope): time = Time(1, 2, 3, 4, pytz.FixedOffset(60)) struct = hydration_scope.dehydration_hooks[type(time)](time) assert struct == Structure(b"T", 3723000000004, 3600) def test_native_time(self, hydration_scope): time = datetime.time(1, 2, 3, 4, pytz.FixedOffset(60)) struct = hydration_scope.dehydration_hooks[type(time)](time) assert struct == Structure(b"T", 3723000004000, 3600) def test_local_time(self, hydration_scope): time = Time(1, 2, 3, 4) struct = hydration_scope.dehydration_hooks[type(time)](time) assert struct == Structure(b"t", 3723000000004) def test_local_native_time(self, hydration_scope): time = datetime.time(1, 2, 3, 4) struct = hydration_scope.dehydration_hooks[type(time)](time) assert struct == Structure(b"t", 3723000004000) def test_date_time(self, hydration_scope): dt = DateTime(2018, 10, 12, 11, 37, 41, 474716862, pytz.FixedOffset(60)) struct = hydration_scope.dehydration_hooks[type(dt)](dt) assert struct == Structure(b"F", 1539344261, 474716862, 3600) def test_native_date_time(self, hydration_scope): dt = datetime.datetime(2018, 10, 12, 11, 37, 41, 474716, pytz.FixedOffset(60)) struct = hydration_scope.dehydration_hooks[type(dt)](dt) assert struct == Structure(b"F", 1539344261, 474716000, 3600) def test_date_time_negative_offset(self, hydration_scope): dt = DateTime(2018, 10, 12, 11, 37, 41, 474716862, pytz.FixedOffset(-60)) struct = hydration_scope.dehydration_hooks[type(dt)](dt) assert struct == Structure(b"F", 1539344261, 474716862, -3600) def test_native_date_time_negative_offset(self, hydration_scope): dt = datetime.datetime(2018, 10, 12, 11, 37, 41, 474716, pytz.FixedOffset(-60)) struct = hydration_scope.dehydration_hooks[type(dt)](dt) assert struct == Structure(b"F", 1539344261, 474716000, -3600) def test_date_time_zone_id(self, hydration_scope): dt = DateTime(2018, 10, 12, 11, 37, 41, 474716862, pytz.timezone("Europe/Stockholm")) struct = hydration_scope.dehydration_hooks[type(dt)](dt) assert struct == Structure(b"f", 1539344261, 474716862, "Europe/Stockholm") def test_native_date_time_zone_id(self, hydration_scope): dt = datetime.datetime(2018, 10, 12, 11, 37, 41, 474716, pytz.timezone("Europe/Stockholm")) struct = hydration_scope.dehydration_hooks[type(dt)](dt) assert struct == Structure(b"f", 1539344261, 474716000, "Europe/Stockholm") def test_local_date_time(self, hydration_scope): dt = DateTime(2018, 10, 12, 11, 37, 41, 474716862) struct = hydration_scope.dehydration_hooks[type(dt)](dt) assert struct == Structure(b"d", 1539344261, 474716862) def test_native_local_date_time(self, hydration_scope): dt = datetime.datetime(2018, 10, 12, 11, 37, 41, 474716) struct = hydration_scope.dehydration_hooks[type(dt)](dt) assert struct == Structure(b"d", 1539344261, 474716000) def test_duration(self, hydration_scope): duration = Duration(months=1, days=2, seconds=3, nanoseconds=4) struct = hydration_scope.dehydration_hooks[type(duration)](duration) assert struct == Structure(b"E", 1, 2, 3, 4) def test_native_duration(self, hydration_scope): duration = datetime.timedelta(days=1, seconds=2, microseconds=3) struct = hydration_scope.dehydration_hooks[type(duration)](duration) assert struct == Structure(b"E", 0, 1, 2, 3000) def test_duration_mixed_sign(self, hydration_scope): duration = Duration(months=1, days=-2, seconds=3, nanoseconds=4) struct = hydration_scope.dehydration_hooks[type(duration)](duration) assert struct == Structure(b"E", 1, -2, 3, 4) def test_native_duration_mixed_sign(self, hydration_scope): duration = datetime.timedelta(days=-1, seconds=2, microseconds=3) struct = hydration_scope.dehydration_hooks[type(duration)](duration) assert struct == Structure(b"E", 0, -1, 2, 3000) class TestUTCPatchedTimeDehydration(TestTimeDehydration): @pytest.fixture def hydration_handler(self): handler = HydrationHandler() handler.patch_utc() return handler def test_date_time(self, hydration_scope): from ..v2.test_temporal_dehydration import ( TestTimeDehydration as TestTimeDehydrationV2, ) TestTimeDehydrationV2().test_date_time( hydration_scope ) def test_native_date_time(self, hydration_scope): from ..v2.test_temporal_dehydration import ( TestTimeDehydration as TestTimeDehydrationV2, ) TestTimeDehydrationV2().test_native_date_time( hydration_scope ) def test_date_time_negative_offset(self, hydration_scope): from ..v2.test_temporal_dehydration import ( TestTimeDehydration as TestTimeDehydrationV2, ) TestTimeDehydrationV2().test_date_time_negative_offset( hydration_scope ) def test_native_date_time_negative_offset(self, hydration_scope): from ..v2.test_temporal_dehydration import ( TestTimeDehydration as TestTimeDehydrationV2, ) TestTimeDehydrationV2().test_native_date_time_negative_offset( hydration_scope ) def test_date_time_zone_id(self, hydration_scope): from ..v2.test_temporal_dehydration import ( TestTimeDehydration as TestTimeDehydrationV2, ) TestTimeDehydrationV2().test_date_time_zone_id( hydration_scope ) def test_native_date_time_zone_id(self, hydration_scope): from ..v2.test_temporal_dehydration import ( TestTimeDehydration as TestTimeDehydrationV2, ) TestTimeDehydrationV2().test_native_date_time_zone_id( hydration_scope ) neo4j-python-driver-5.2.1/tests/unit/common/codec/hydration/v1/test_temporal_hydration.py000066400000000000000000000155221433522662700317170ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest import pytz from neo4j._codec.hydration import BrokenHydrationObject from neo4j._codec.hydration.v1 import HydrationHandler from neo4j._codec.packstream import Structure from neo4j.time import ( Date, DateTime, Duration, Time, ) from ._base import HydrationHandlerTestBase class TestTemporalHydration(HydrationHandlerTestBase): @pytest.fixture def hydration_handler(self): return HydrationHandler() def test_hydrate_date_structure(self, hydration_scope): struct = Structure(b"D", 7905) d = hydration_scope.hydration_hooks[Structure](struct) assert isinstance(d, Date) assert d.year == 1991 assert d.month == 8 assert d.day == 24 def test_hydrate_time_structure(self, hydration_scope): struct = Structure(b"T", 3723000000004, 3600) t = hydration_scope.hydration_hooks[Structure](struct) assert isinstance(t, Time) assert t.hour == 1 assert t.minute == 2 assert t.second == 3 assert t.nanosecond == 4 assert t.tzinfo == pytz.FixedOffset(60) def test_hydrate_local_time_structure(self, hydration_scope): struct = Structure(b"t", 3723000000004) t = hydration_scope.hydration_hooks[Structure](struct) assert isinstance(t, Time) assert t.hour == 1 assert t.minute == 2 assert t.second == 3 assert t.nanosecond == 4 assert t.tzinfo is None def test_hydrate_date_time_structure_v1(self, hydration_scope): struct = Structure(b"F", 1539344261, 474716862, 3600) dt = hydration_scope.hydration_hooks[Structure](struct) assert isinstance(dt, DateTime) assert dt.year == 2018 assert dt.month == 10 assert dt.day == 12 assert dt.hour == 11 assert dt.minute == 37 assert dt.second == 41 assert dt.nanosecond == 474716862 assert dt.tzinfo == pytz.FixedOffset(60) def test_hydrate_date_time_structure_v2(self, hydration_scope): struct = Structure(b"I", 1539344261, 474716862, 3600) dt = hydration_scope.hydration_hooks[Structure](struct) assert isinstance(dt, BrokenHydrationObject) assert repr(b"I") in str(dt.error) def test_hydrate_date_time_zone_id_structure_v1(self, hydration_scope): struct = Structure(b"f", 1539344261, 474716862, "Europe/Stockholm") dt = hydration_scope.hydration_hooks[Structure](struct) assert isinstance(dt, DateTime) assert dt.year == 2018 assert dt.month == 10 assert dt.day == 12 assert dt.hour == 11 assert dt.minute == 37 assert dt.second == 41 assert dt.nanosecond == 474716862 tz = pytz.timezone("Europe/Stockholm") \ .localize(dt.replace(tzinfo=None)).tzinfo assert dt.tzinfo == tz def test_hydrate_date_time_unknown_zone_id_structure(self, hydration_scope): struct = Structure(b"f", 1539344261, 474716862, "Europe/Neo4j") res = hydration_scope.hydration_hooks[Structure](struct) assert isinstance(res, BrokenHydrationObject) exc = None try: pytz.timezone("Europe/Neo4j") except Exception as e: exc = e assert exc.__class__ == res.error.__class__ assert str(exc) == str(res.error) def test_hydrate_date_time_zone_id_structure_v2(self, hydration_scope): struct = Structure(b"i", 1539344261, 474716862, "Europe/Stockholm") dt = hydration_scope.hydration_hooks[Structure](struct) assert isinstance(dt, BrokenHydrationObject) assert repr(b"i") in str(dt.error) def test_hydrate_local_date_time_structure(self, hydration_scope): struct = Structure(b"d", 1539344261, 474716862) dt = hydration_scope.hydration_hooks[Structure](struct) assert isinstance(dt, DateTime) assert dt.year == 2018 assert dt.month == 10 assert dt.day == 12 assert dt.hour == 11 assert dt.minute == 37 assert dt.second == 41 assert dt.nanosecond == 474716862 assert dt.tzinfo is None def test_hydrate_duration_structure(self, hydration_scope): struct = Structure(b"E", 1, 2, 3, 4) d = hydration_scope.hydration_hooks[Structure](struct) assert isinstance(d, Duration) assert d.months == 1 assert d.days == 2 assert d.seconds == 3 assert d.nanoseconds == 4 class TestUTCPatchedTemporalHydration(TestTemporalHydration): @pytest.fixture def hydration_handler(self): handler = HydrationHandler() handler.patch_utc() return handler def test_hydrate_date_time_structure_v1(self, hydration_scope): from ..v2.test_temporal_hydration import ( TestTemporalHydration as TestTimeHydrationV2, ) TestTimeHydrationV2().test_hydrate_date_time_structure_v1( hydration_scope ) def test_hydrate_date_time_structure_v2(self, hydration_scope): from ..v2.test_temporal_hydration import ( TestTemporalHydration as TestTimeHydrationV2, ) TestTimeHydrationV2().test_hydrate_date_time_structure_v2( hydration_scope ) def test_hydrate_date_time_zone_id_structure_v1(self, hydration_scope): from ..v2.test_temporal_hydration import ( TestTemporalHydration as TestTimeHydrationV2, ) TestTimeHydrationV2().test_hydrate_date_time_zone_id_structure_v1( hydration_scope ) def test_hydrate_date_time_zone_id_structure_v2(self, hydration_scope): from ..v2.test_temporal_hydration import ( TestTemporalHydration as TestTimeHydrationV2, ) TestTimeHydrationV2().test_hydrate_date_time_zone_id_structure_v2( hydration_scope ) def test_hydrate_date_time_unknown_zone_id_structure(self, hydration_scope): from ..v2.test_temporal_hydration import ( TestTemporalHydration as TestTimeHydrationV2, ) TestTimeHydrationV2().test_hydrate_date_time_unknown_zone_id_structure( hydration_scope ) neo4j-python-driver-5.2.1/tests/unit/common/codec/hydration/v1/test_unknown_hydration.py000066400000000000000000000040601433522662700315660ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j._codec.hydration import BrokenHydrationObject from neo4j._codec.hydration.v1 import HydrationHandler from neo4j._codec.packstream import Structure from ._base import HydrationHandlerTestBase class TestUnknownHydration(HydrationHandlerTestBase): @pytest.fixture def hydration_handler(self): return HydrationHandler() def test_unknown_structure_tag(self, hydration_scope): struct = Structure(b"a", "lol wut?") res = hydration_scope.hydration_hooks[Structure](struct) assert isinstance(res, BrokenHydrationObject) error = res.error assert isinstance(error, ValueError) assert repr(b"a") in str(error) def test_broken_object_propagates_through_lists(self, hydration_scope): broken_obj = BrokenHydrationObject(Exception("test"), "b") data = [1, broken_obj, 3] res = hydration_scope.hydration_hooks[list](data) assert isinstance(res, BrokenHydrationObject) assert res.raw_data == data assert res.error is broken_obj.error def test_broken_object_propagates_through_dicts(self, hydration_scope): broken_obj = BrokenHydrationObject(Exception("test"), "b") data = {"a": 1, "b": broken_obj, "c": 3} res = hydration_scope.hydration_hooks[dict](data) assert isinstance(res, BrokenHydrationObject) assert res.raw_data == data assert res.error is broken_obj.error neo4j-python-driver-5.2.1/tests/unit/common/codec/hydration/v2/000077500000000000000000000000001433522662700243765ustar00rootroot00000000000000neo4j-python-driver-5.2.1/tests/unit/common/codec/hydration/v2/__init__.py000066400000000000000000000012011433522662700265010ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. neo4j-python-driver-5.2.1/tests/unit/common/codec/hydration/v2/test_graph_hydration.py000066400000000000000000000047241433522662700312000ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j._codec.hydration.v2 import HydrationHandler from neo4j._codec.packstream import Structure from neo4j.graph import ( Node, Relationship, ) from ..v1.test_graph_hydration import TestGraphHydration as _TestGraphHydration class TestGraphHydration(_TestGraphHydration): @pytest.fixture def hydration_handler(self): return HydrationHandler() def test_can_hydrate_node_structure(self, hydration_scope): struct = Structure(b'N', 123, ["Person"], {"name": "Alice"}, "abc") alice = hydration_scope.hydration_hooks[Structure](struct) assert isinstance(alice, Node) with pytest.warns(DeprecationWarning, match="element_id"): assert alice.id == 123 assert alice.element_id == "abc" assert alice.labels == {"Person"} assert set(alice.keys()) == {"name"} assert alice.get("name") == "Alice" def test_can_hydrate_relationship_structure(self, hydration_scope): struct = Structure(b'R', 123, 456, 789, "KNOWS", {"since": 1999}, "abc", "def", "ghi") rel = hydration_scope.hydration_hooks[Structure](struct) assert isinstance(rel, Relationship) with pytest.warns(DeprecationWarning, match="element_id"): assert rel.id == 123 with pytest.warns(DeprecationWarning, match="element_id"): assert rel.start_node.id == 456 with pytest.warns(DeprecationWarning, match="element_id"): assert rel.end_node.id == 789 # for backwards compatibility, the driver should compute the element_id assert rel.element_id == "abc" assert rel.start_node.element_id == "def" assert rel.end_node.element_id == "ghi" assert rel.type == "KNOWS" assert set(rel.keys()) == {"since"} assert rel.get("since") == 1999 neo4j-python-driver-5.2.1/tests/unit/common/codec/hydration/v2/test_hydration_handler.py000066400000000000000000000016671433522662700315170ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j._codec.hydration.v2 import HydrationHandler from ..v1.test_hydration_handler import ( TestHydrationHandler as TestHydrationHandlerV1, ) class TestHydrationHandler(TestHydrationHandlerV1): @pytest.fixture def hydration_handler(self): return HydrationHandler() neo4j-python-driver-5.2.1/tests/unit/common/codec/hydration/v2/test_spacial_dehydration.py000066400000000000000000000017031433522662700320160ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j._codec.hydration.v2 import HydrationHandler from ..v1.test_spacial_dehydration import ( TestSpatialDehydration as _TestSpatialDehydrationV1, ) class TestSpatialDehydration(_TestSpatialDehydrationV1): @pytest.fixture def hydration_handler(self): return HydrationHandler() neo4j-python-driver-5.2.1/tests/unit/common/codec/hydration/v2/test_spacial_hydration.py000066400000000000000000000016711433522662700315110ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j._codec.hydration.v2 import HydrationHandler from ..v1.test_spacial_hydration import ( TestSpatialHydration as _TestSpatialHydrationV1, ) class TestSpatialHydration(_TestSpatialHydrationV1): @pytest.fixture def hydration_handler(self): return HydrationHandler() neo4j-python-driver-5.2.1/tests/unit/common/codec/hydration/v2/test_temporal_dehydration.py000066400000000000000000000060561433522662700322330ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 datetime import pytest import pytz from neo4j._codec.hydration.v2 import HydrationHandler from neo4j._codec.packstream import Structure from neo4j.time import DateTime from ..v1.test_temporal_dehydration import ( TestTimeDehydration as _TestTemporalDehydrationV1, ) class TestTimeDehydration(_TestTemporalDehydrationV1): @pytest.fixture def hydration_handler(self): return HydrationHandler() def test_date_time(self, hydration_scope): dt = DateTime(2018, 10, 12, 11, 37, 41, 474716862, pytz.FixedOffset(60)) struct = hydration_scope.dehydration_hooks[type(dt)](dt) assert struct == Structure(b"I", 1539340661, 474716862, 3600) def test_native_date_time(self, hydration_scope): dt = datetime.datetime(2018, 10, 12, 11, 37, 41, 474716, pytz.FixedOffset(60)) struct = hydration_scope.dehydration_hooks[type(dt)](dt) assert struct == Structure(b"I", 1539340661, 474716000, 3600) def test_date_time_negative_offset(self, hydration_scope): dt = DateTime(2018, 10, 12, 11, 37, 41, 474716862, pytz.FixedOffset(-60)) struct = hydration_scope.dehydration_hooks[type(dt)](dt) assert struct == Structure(b"I", 1539347861, 474716862, -3600) def test_native_date_time_negative_offset(self, hydration_scope): dt = datetime.datetime(2018, 10, 12, 11, 37, 41, 474716, pytz.FixedOffset(-60)) struct = hydration_scope.dehydration_hooks[type(dt)](dt) assert struct == Structure(b"I", 1539347861, 474716000, -3600) def test_date_time_zone_id(self, hydration_scope): dt = DateTime(2018, 10, 12, 11, 37, 41, 474716862) dt = pytz.timezone("Europe/Stockholm").localize(dt) # offset should be UTC+2 (7200 seconds) struct = hydration_scope.dehydration_hooks[type(dt)](dt) assert struct == Structure(b"i", 1539337061, 474716862, "Europe/Stockholm") def test_native_date_time_zone_id(self, hydration_scope): dt = datetime.datetime(2018, 10, 12, 11, 37, 41, 474716) dt = pytz.timezone("Europe/Stockholm").localize(dt) # offset should be UTC+2 (7200 seconds) struct = hydration_scope.dehydration_hooks[type(dt)](dt) assert struct == Structure(b"i", 1539337061, 474716000, "Europe/Stockholm") neo4j-python-driver-5.2.1/tests/unit/common/codec/hydration/v2/test_temporal_hydration.py000066400000000000000000000065021433522662700317160ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 datetime import pytest import pytz from neo4j._codec.hydration import BrokenHydrationObject from neo4j._codec.hydration.v2 import HydrationHandler from neo4j._codec.packstream import Structure from neo4j.time import DateTime from ..v1.test_temporal_hydration import ( TestTemporalHydration as _TestTemporalHydrationV1, ) class TestTemporalHydration(_TestTemporalHydrationV1): @pytest.fixture def hydration_handler(self): return HydrationHandler() def test_hydrate_date_time_structure_v1(self, hydration_scope): struct = Structure(b"F", 1539344261, 474716862, 3600) dt = hydration_scope.hydration_hooks[Structure](struct) assert isinstance(dt, BrokenHydrationObject) assert repr(b"F") in str(dt.error) def test_hydrate_date_time_structure_v2(self, hydration_scope): struct = Structure(b"I", 1539344261, 474716862, 3600) dt = hydration_scope.hydration_hooks[Structure](struct) assert isinstance(dt, DateTime) assert dt.year == 2018 assert dt.month == 10 assert dt.day == 12 assert dt.hour == 12 assert dt.minute == 37 assert dt.second == 41 assert dt.nanosecond == 474716862 assert dt.tzinfo == pytz.FixedOffset(60) def test_hydrate_date_time_zone_id_structure_v1(self, hydration_scope): struct = Structure(b"f", 1539344261, 474716862, "Europe/Stockholm") dt = hydration_scope.hydration_hooks[Structure](struct) assert isinstance(dt, BrokenHydrationObject) assert repr(b"f") in str(dt.error) def test_hydrate_date_time_zone_id_structure_v2(self, hydration_scope): struct = Structure(b"i", 1539344261, 474716862, "Europe/Stockholm") dt = hydration_scope.hydration_hooks[Structure](struct) assert isinstance(dt, DateTime) assert dt.year == 2018 assert dt.month == 10 assert dt.day == 12 assert dt.hour == 13 assert dt.minute == 37 assert dt.second == 41 assert dt.nanosecond == 474716862 tz = pytz.timezone("Europe/Stockholm") \ .localize(dt.replace(tzinfo=None)).tzinfo assert dt.tzinfo == tz def test_hydrate_date_time_unknown_zone_id_structure(self, hydration_scope): struct = Structure(b"i", 1539344261, 474716862, "Europe/Neo4j") res = hydration_scope.hydration_hooks[Structure](struct) assert isinstance(res, BrokenHydrationObject) exc = None try: pytz.timezone("Europe/Neo4j") except Exception as e: exc = e assert exc.__class__ == res.error.__class__ assert str(exc) == str(res.error) neo4j-python-driver-5.2.1/tests/unit/common/codec/hydration/v2/test_unknown_hydration.py000066400000000000000000000016651433522662700315770ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j._codec.hydration.v2 import HydrationHandler from ..v1.test_unknown_hydration import ( TestUnknownHydration as _TestUnknownHydration, ) class TestUnknownHydration(_TestUnknownHydration): @pytest.fixture def hydration_handler(self): return HydrationHandler() neo4j-python-driver-5.2.1/tests/unit/common/codec/packstream/000077500000000000000000000000001433522662700242005ustar00rootroot00000000000000neo4j-python-driver-5.2.1/tests/unit/common/codec/packstream/__init__.py000066400000000000000000000012011433522662700263030ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. neo4j-python-driver-5.2.1/tests/unit/common/codec/packstream/v1/000077500000000000000000000000001433522662700245265ustar00rootroot00000000000000neo4j-python-driver-5.2.1/tests/unit/common/codec/packstream/v1/__init__.py000066400000000000000000000012011433522662700266310ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. neo4j-python-driver-5.2.1/tests/unit/common/codec/packstream/v1/test_packstream.py000066400000000000000000000260521433522662700302760ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 struct from io import BytesIO from math import pi from uuid import uuid4 import pytest from neo4j._codec.packstream import Structure from neo4j._codec.packstream.v1 import ( PackableBuffer, Packer, UnpackableBuffer, Unpacker, ) standard_ascii = [chr(i) for i in range(128)] not_ascii = "♥O◘♦♥O◘♦" class TestPackStream: @pytest.fixture def packer_with_buffer(self): packable_buffer = Packer.new_packable_buffer() return Packer(packable_buffer), packable_buffer @pytest.fixture def unpacker_with_buffer(self): unpackable_buffer = Unpacker.new_unpackable_buffer() return Unpacker(unpackable_buffer), unpackable_buffer def test_packable_buffer(self, packer_with_buffer): packer, packable_buffer = packer_with_buffer assert isinstance(packable_buffer, PackableBuffer) assert packable_buffer is packer.stream def test_unpackable_buffer(self, unpacker_with_buffer): unpacker, unpackable_buffer = unpacker_with_buffer assert isinstance(unpackable_buffer, UnpackableBuffer) assert unpackable_buffer is unpacker.unpackable @pytest.fixture def pack(self, packer_with_buffer): packer, packable_buffer = packer_with_buffer def _pack(*values, dehydration_hooks=None): for value in values: packer.pack(value, dehydration_hooks=dehydration_hooks) data = bytearray(packable_buffer.data) packable_buffer.clear() return data return _pack @pytest.fixture def assert_packable(self, packer_with_buffer, unpacker_with_buffer): def _assert(value, packed_value): nonlocal packer_with_buffer, unpacker_with_buffer packer, packable_buffer = packer_with_buffer unpacker, unpackable_buffer = unpacker_with_buffer packable_buffer.clear() unpackable_buffer.reset() packer.pack(value) packed_data = packable_buffer.data assert packed_data == packed_value unpackable_buffer.data = bytearray(packed_data) unpackable_buffer.used = len(packed_data) unpacked_data = unpacker.unpack() assert unpacked_data == value return _assert def test_none(self, assert_packable): assert_packable(None, b"\xC0") def test_boolean(self, assert_packable): assert_packable(True, b"\xC3") assert_packable(False, b"\xC2") def test_negative_tiny_int(self, assert_packable): for z in range(-16, 0): assert_packable(z, bytes(bytearray([z + 0x100]))) def test_positive_tiny_int(self, assert_packable): for z in range(0, 128): assert_packable(z, bytes(bytearray([z]))) def test_negative_int8(self, assert_packable): for z in range(-128, -16): assert_packable(z, bytes(bytearray([0xC8, z + 0x100]))) def test_positive_int16(self, assert_packable): for z in range(128, 32768): expected = b"\xC9" + struct.pack(">h", z) assert_packable(z, expected) def test_negative_int16(self, assert_packable): for z in range(-32768, -128): expected = b"\xC9" + struct.pack(">h", z) assert_packable(z, expected) def test_positive_int32(self, assert_packable): for e in range(15, 31): z = 2 ** e expected = b"\xCA" + struct.pack(">i", z) assert_packable(z, expected) def test_negative_int32(self, assert_packable): for e in range(15, 31): z = -(2 ** e + 1) expected = b"\xCA" + struct.pack(">i", z) assert_packable(z, expected) def test_positive_int64(self, assert_packable): for e in range(31, 63): z = 2 ** e expected = b"\xCB" + struct.pack(">q", z) assert_packable(z, expected) def test_negative_int64(self, assert_packable): for e in range(31, 63): z = -(2 ** e + 1) expected = b"\xCB" + struct.pack(">q", z) assert_packable(z, expected) def test_integer_positive_overflow(self, pack, assert_packable): with pytest.raises(OverflowError): pack(2 ** 63 + 1) def test_integer_negative_overflow(self, pack, assert_packable): with pytest.raises(OverflowError): pack(-(2 ** 63) - 1) def test_zero_float64(self, assert_packable): zero = 0.0 expected = b"\xC1" + struct.pack(">d", zero) assert_packable(zero, expected) def test_tau_float64(self, assert_packable): tau = 2 * pi expected = b"\xC1" + struct.pack(">d", tau) assert_packable(tau, expected) def test_positive_float64(self, assert_packable): for e in range(0, 100): r = float(2 ** e) + 0.5 expected = b"\xC1" + struct.pack(">d", r) assert_packable(r, expected) def test_negative_float64(self, assert_packable): for e in range(0, 100): r = -(float(2 ** e) + 0.5) expected = b"\xC1" + struct.pack(">d", r) assert_packable(r, expected) def test_empty_bytes(self, assert_packable): assert_packable(b"", b"\xCC\x00") def test_empty_bytearray(self, assert_packable): assert_packable(bytearray(), b"\xCC\x00") def test_bytes_8(self, assert_packable): assert_packable(bytearray(b"hello"), b"\xCC\x05hello") def test_bytes_16(self, assert_packable): b = bytearray(40000) assert_packable(b, b"\xCD\x9C\x40" + b) def test_bytes_32(self, assert_packable): b = bytearray(80000) assert_packable(b, b"\xCE\x00\x01\x38\x80" + b) def test_bytearray_size_overflow(self, assert_packable): stream_out = BytesIO() packer = Packer(stream_out) with pytest.raises(OverflowError): packer.pack_bytes_header(2 ** 32) def test_empty_string(self, assert_packable): assert_packable(u"", b"\x80") def test_tiny_strings(self, assert_packable): for size in range(0x10): assert_packable(u"A" * size, bytes(bytearray([0x80 + size]) + (b"A" * size))) def test_string_8(self, assert_packable): t = u"A" * 40 b = t.encode("utf-8") assert_packable(t, b"\xD0\x28" + b) def test_string_16(self, assert_packable): t = u"A" * 40000 b = t.encode("utf-8") assert_packable(t, b"\xD1\x9C\x40" + b) def test_string_32(self, assert_packable): t = u"A" * 80000 b = t.encode("utf-8") assert_packable(t, b"\xD2\x00\x01\x38\x80" + b) def test_unicode_string(self, assert_packable): t = u"héllö" b = t.encode("utf-8") assert_packable(t, bytes(bytearray([0x80 + len(b)])) + b) def test_string_size_overflow(self): stream_out = BytesIO() packer = Packer(stream_out) with pytest.raises(OverflowError): packer.pack_string_header(2 ** 32) def test_empty_list(self, assert_packable): assert_packable([], b"\x90") def test_tiny_lists(self, assert_packable): for size in range(0x10): data_out = bytearray([0x90 + size]) + bytearray([1] * size) assert_packable([1] * size, bytes(data_out)) def test_list_8(self, assert_packable): l = [1] * 40 assert_packable(l, b"\xD4\x28" + (b"\x01" * 40)) def test_list_16(self, assert_packable): l = [1] * 40000 assert_packable(l, b"\xD5\x9C\x40" + (b"\x01" * 40000)) def test_list_32(self, assert_packable): l = [1] * 80000 assert_packable(l, b"\xD6\x00\x01\x38\x80" + (b"\x01" * 80000)) def test_nested_lists(self, assert_packable): assert_packable([[[]]], b"\x91\x91\x90") def test_list_size_overflow(self): stream_out = BytesIO() packer = Packer(stream_out) with pytest.raises(OverflowError): packer.pack_list_header(2 ** 32) def test_empty_map(self, assert_packable): assert_packable({}, b"\xA0") @pytest.mark.parametrize("size", range(0x10)) def test_tiny_maps(self, assert_packable, size): data_in = dict() data_out = bytearray([0xA0 + size]) for el in range(1, size + 1): data_in[chr(64 + el)] = el data_out += bytearray([0x81, 64 + el, el]) assert_packable(data_in, bytes(data_out)) def test_map_8(self, pack, assert_packable): d = dict([(u"A%s" % i, 1) for i in range(40)]) b = b"".join(pack(u"A%s" % i, 1) for i in range(40)) assert_packable(d, b"\xD8\x28" + b) def test_map_16(self, pack, assert_packable): d = dict([(u"A%s" % i, 1) for i in range(40000)]) b = b"".join(pack(u"A%s" % i, 1) for i in range(40000)) assert_packable(d, b"\xD9\x9C\x40" + b) def test_map_32(self, pack, assert_packable): d = dict([(u"A%s" % i, 1) for i in range(80000)]) b = b"".join(pack(u"A%s" % i, 1) for i in range(80000)) assert_packable(d, b"\xDA\x00\x01\x38\x80" + b) def test_map_size_overflow(self): stream_out = BytesIO() packer = Packer(stream_out) with pytest.raises(OverflowError): packer.pack_map_header(2 ** 32) @pytest.mark.parametrize(("map_", "exc_type"), ( ({1: "1"}, TypeError), ({"x": {1: 'eins', 2: 'zwei', 3: 'drei'}}, TypeError), ({"x": {(1, 2): '1+2i', (2, 0): '2'}}, TypeError), )) def test_map_key_type(self, packer_with_buffer, map_, exc_type): # maps must have string keys packer, packable_buffer = packer_with_buffer with pytest.raises(exc_type, match="strings"): packer.pack(map_) def test_illegal_signature(self, assert_packable): with pytest.raises(ValueError): assert_packable(Structure(b"XXX"), b"\xB0XXX") def test_empty_struct(self, assert_packable): assert_packable(Structure(b"X"), b"\xB0X") def test_tiny_structs(self, assert_packable): for size in range(0x10): fields = [1] * size data_in = Structure(b"A", *fields) data_out = bytearray([0xB0 + size, 0x41] + fields) assert_packable(data_in, bytes(data_out)) def test_struct_size_overflow(self, pack): with pytest.raises(OverflowError): fields = [1] * 16 pack(Structure(b"X", *fields)) def test_illegal_uuid(self, assert_packable): with pytest.raises(ValueError): assert_packable(uuid4(), b"\xB0XXX") neo4j-python-driver-5.2.1/tests/unit/common/io/000077500000000000000000000000001433522662700214005ustar00rootroot00000000000000neo4j-python-driver-5.2.1/tests/unit/common/io/__init__.py000066400000000000000000000012011433522662700235030ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. neo4j-python-driver-5.2.1/tests/unit/common/io/test_routing.py000066400000000000000000000205651433522662700245100ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j._routing import ( OrderedSet, RoutingTable, ) from neo4j.api import DEFAULT_DATABASE VALID_ROUTING_RECORD = { "ttl": 300, "servers": [ {"role": "ROUTE", "addresses": ["127.0.0.1:9001", "127.0.0.1:9002", "127.0.0.1:9003"]}, {"role": "READ", "addresses": ["127.0.0.1:9004", "127.0.0.1:9005"]}, {"role": "WRITE", "addresses": ["127.0.0.1:9006"]}, ], } VALID_ROUTING_RECORD_WITH_EXTRA_ROLE = { "ttl": 300, "servers": [ {"role": "ROUTE", "addresses": ["127.0.0.1:9001", "127.0.0.1:9002", "127.0.0.1:9003"]}, {"role": "READ", "addresses": ["127.0.0.1:9004", "127.0.0.1:9005"]}, {"role": "WRITE", "addresses": ["127.0.0.1:9006"]}, {"role": "MAGIC", "addresses": ["127.0.0.1:9007"]}, ], } class TestOrderedSet: def test_should_repr_as_set(self): s = OrderedSet([1, 2, 3]) assert repr(s) == "{1, 2, 3}" def test_should_contain_element(self): s = OrderedSet([1, 2, 3]) assert 2 in s def test_should_not_contain_non_element(self): s = OrderedSet([1, 2, 3]) assert 4 not in s def test_should_be_able_to_get_item_if_empty(self): s = OrderedSet([]) with pytest.raises(IndexError): _ = s[0] def test_should_be_able_to_get_items_by_index(self): s = OrderedSet([1, 2, 3]) assert s[0] == 1 assert s[1] == 2 assert s[2] == 3 def test_should_be_iterable(self): s = OrderedSet([1, 2, 3]) assert list(iter(s)) == [1, 2, 3] def test_should_have_length(self): s = OrderedSet([1, 2, 3]) assert len(s) == 3 def test_should_be_able_to_add_new(self): s = OrderedSet([1, 2, 3]) s.add(4) assert list(s) == [1, 2, 3, 4] def test_should_be_able_to_add_existing(self): s = OrderedSet([1, 2, 3]) s.add(2) assert list(s) == [1, 2, 3] def test_should_be_able_to_clear(self): s = OrderedSet([1, 2, 3]) s.clear() assert list(s) == [] def test_should_be_able_to_discard_existing(self): s = OrderedSet([1, 2, 3]) s.discard(2) assert list(s) == [1, 3] def test_should_be_able_to_discard_non_existing(self): s = OrderedSet([1, 2, 3]) s.discard(4) assert list(s) == [1, 2, 3] def test_should_be_able_to_remove_existing(self): s = OrderedSet([1, 2, 3]) s.remove(2) assert list(s) == [1, 3] def test_should_not_be_able_to_remove_non_existing(self): s = OrderedSet([1, 2, 3]) with pytest.raises(ValueError): s.remove(4) def test_should_be_able_to_update(self): s = OrderedSet([1, 2, 3]) s.update([3, 4, 5]) assert list(s) == [1, 2, 3, 4, 5] def test_should_be_able_to_replace(self): s = OrderedSet([1, 2, 3]) s.replace([3, 4, 5]) assert list(s) == [3, 4, 5] class TestRoutingTableConstruction: def test_should_be_initially_stale(self): table = RoutingTable(database=DEFAULT_DATABASE) assert not table.is_fresh(readonly=True) assert not table.is_fresh(readonly=False) class TestRoutingTableParseRoutingInfo: def test_should_return_routing_table_on_valid_record(self): table = RoutingTable.parse_routing_info( database=DEFAULT_DATABASE, servers=VALID_ROUTING_RECORD["servers"], ttl=VALID_ROUTING_RECORD["ttl"], ) assert table.routers == {('127.0.0.1', 9001), ('127.0.0.1', 9002), ('127.0.0.1', 9003)} assert table.readers == {('127.0.0.1', 9004), ('127.0.0.1', 9005)} assert table.writers == {('127.0.0.1', 9006)} assert table.ttl == 300 def test_should_return_routing_table_on_valid_record_with_extra_role(self): table = RoutingTable.parse_routing_info( database=DEFAULT_DATABASE, servers=VALID_ROUTING_RECORD_WITH_EXTRA_ROLE["servers"], ttl=VALID_ROUTING_RECORD_WITH_EXTRA_ROLE["ttl"], ) assert table.routers == {('127.0.0.1', 9001), ('127.0.0.1', 9002), ('127.0.0.1', 9003)} assert table.readers == {('127.0.0.1', 9004), ('127.0.0.1', 9005)} assert table.writers == {('127.0.0.1', 9006)} assert table.ttl == 300 class TestRoutingTableServers: def test_should_return_all_distinct_servers_in_routing_table(self): routing_table = { "ttl": 300, "servers": [ {"role": "ROUTE", "addresses": ["127.0.0.1:9001", "127.0.0.1:9002", "127.0.0.1:9003"]}, {"role": "READ", "addresses": ["127.0.0.1:9001", "127.0.0.1:9005"]}, {"role": "WRITE", "addresses": ["127.0.0.1:9002"]}, ], } table = RoutingTable.parse_routing_info( database=DEFAULT_DATABASE, servers=routing_table["servers"], ttl=routing_table["ttl"], ) assert table.servers() == {('127.0.0.1', 9001), ('127.0.0.1', 9002), ('127.0.0.1', 9003), ('127.0.0.1', 9005)} class TestRoutingTableFreshness: def test_should_be_fresh_after_update(self): table = RoutingTable.parse_routing_info( database=DEFAULT_DATABASE, servers=VALID_ROUTING_RECORD["servers"], ttl=VALID_ROUTING_RECORD["ttl"], ) assert table.is_fresh(readonly=True) assert table.is_fresh(readonly=False) def test_should_become_stale_on_expiry(self): table = RoutingTable.parse_routing_info( database=DEFAULT_DATABASE, servers=VALID_ROUTING_RECORD["servers"], ttl=VALID_ROUTING_RECORD["ttl"], ) table.ttl = 0 assert not table.is_fresh(readonly=True) assert not table.is_fresh(readonly=False) def test_should_become_stale_if_no_readers(self): table = RoutingTable.parse_routing_info( database=DEFAULT_DATABASE, servers=VALID_ROUTING_RECORD["servers"], ttl=VALID_ROUTING_RECORD["ttl"], ) table.readers.clear() assert not table.is_fresh(readonly=True) assert table.is_fresh(readonly=False) def test_should_become_stale_if_no_writers(self): table = RoutingTable.parse_routing_info( database=DEFAULT_DATABASE, servers=VALID_ROUTING_RECORD["servers"], ttl=VALID_ROUTING_RECORD["ttl"], ) table.writers.clear() assert table.is_fresh(readonly=True) assert not table.is_fresh(readonly=False) class TestRoutingTableUpdate: @pytest.fixture def table(self): return RoutingTable( database=DEFAULT_DATABASE, routers=[("192.168.1.1", 7687), ("192.168.1.2", 7687)], readers=[("192.168.1.3", 7687)], writers=[], ttl=0, ) @pytest.fixture def new_table(self): return RoutingTable( database=DEFAULT_DATABASE, routers=[("127.0.0.1", 9001), ("127.0.0.1", 9002), ("127.0.0.1", 9003)], readers=[("127.0.0.1", 9004), ("127.0.0.1", 9005)], writers=[("127.0.0.1", 9006)], ttl=300, ) def test_update_should_replace_routers(self, table, new_table): table.update(new_table) assert table.routers == {("127.0.0.1", 9001), ("127.0.0.1", 9002), ("127.0.0.1", 9003)} def test_update_should_replace_readers(self, table, new_table): table.update(new_table) assert table.readers == {("127.0.0.1", 9004), ("127.0.0.1", 9005)} def test_update_should_replace_writers(self, table, new_table): table.update(new_table) assert table.writers == {("127.0.0.1", 9006)} def test_update_should_replace_ttl(self, table, new_table): table.update(new_table) assert table.ttl == 300 neo4j-python-driver-5.2.1/tests/unit/common/spatial/000077500000000000000000000000001433522662700224265ustar00rootroot00000000000000neo4j-python-driver-5.2.1/tests/unit/common/spatial/__init__.py000066400000000000000000000012011433522662700245310ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. neo4j-python-driver-5.2.1/tests/unit/common/spatial/test_cartesian_point.py000066400000000000000000000024341433522662700272240ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations import pytest from neo4j.spatial import CartesianPoint class TestCartesianPoint: def test_alias_3d(self) -> None: x, y, z = 3.2, 4.0, -1.2 p = CartesianPoint((x, y, z)) assert hasattr(p, "x") assert p.x == x assert hasattr(p, "y") assert p.y == y assert hasattr(p, "z") assert p.z == z def test_alias_2d(self) -> None: x, y = 3.2, 4.0 p = CartesianPoint((x, y)) assert hasattr(p, "x") assert p.x == x assert hasattr(p, "y") assert p.y == y with pytest.raises(AttributeError): _ = p.z neo4j-python-driver-5.2.1/tests/unit/common/spatial/test_point.py000066400000000000000000000036501433522662700251740ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations import typing as t import pytest from neo4j._spatial import ( Point, point_type, ) class TestPoint: @pytest.mark.parametrize("argument", ( ("a", "b"), {"x": 1.0, "y": 2.0} )) def test_wrong_type_arguments(self, argument) -> None: with pytest.raises(ValueError): Point(argument) @pytest.mark.parametrize("argument", ( (1, 2), (1.2, 2.1) )) def test_number_arguments(self, argument: t.Iterable[float]) -> None: print(argument) p = Point(argument) assert tuple(p) == argument def test_immutable_coordinates(self) -> None: MyPoint = point_type("MyPoint", ("x", "y", "z"), {2: 1234, 3: 5678}) coordinates = (.1, 0) p = MyPoint(coordinates) with pytest.raises(AttributeError): p.x = 2.0 # type: ignore[misc] with pytest.raises(AttributeError): p.y = 2.0 # type: ignore[misc] with pytest.raises(AttributeError): p.z = 2.0 # type: ignore[misc] with pytest.raises(TypeError): p[0] = 2.0 # type: ignore[index] with pytest.raises(TypeError): p[1] = 2.0 # type: ignore[index] with pytest.raises(TypeError): p[2] = 2.0 # type: ignore[index] neo4j-python-driver-5.2.1/tests/unit/common/spatial/test_wgs84_point.py000066400000000000000000000032501433522662700262240ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations import pytest from neo4j.spatial import WGS84Point class TestWGS84Point: def test_alias_3d(self) -> None: x, y, z = 3.2, 4.0, -1.2 p = WGS84Point((x, y, z)) assert hasattr(p, "longitude") assert p.longitude == x assert hasattr(p, "x") assert p.x == x assert hasattr(p, "latitude") assert p.latitude == y assert hasattr(p, "y") assert p.y == y assert hasattr(p, "height") assert p.height == z assert hasattr(p, "z") assert p.z == z def test_alias_2d(self) -> None: x, y = 3.2, 4.0 p = WGS84Point((x, y)) assert hasattr(p, "longitude") assert p.longitude == x assert hasattr(p, "x") assert p.x == x assert hasattr(p, "latitude") assert p.latitude == y assert hasattr(p, "y") assert p.y == y with pytest.raises(AttributeError): p.height with pytest.raises(AttributeError): p.z neo4j-python-driver-5.2.1/tests/unit/common/test_addressing.py000066400000000000000000000143661433522662700245370ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations import typing as t from socket import ( AF_INET, AF_INET6, ) from unittest import mock import pytest from neo4j import ( Address, IPv4Address, ) mock_socket_ipv4 = mock.Mock() mock_socket_ipv4.getpeername = lambda: ("127.0.0.1", 7687) # (address, port) mock_socket_ipv6 = mock.Mock() mock_socket_ipv6.getpeername = lambda: ("[::1]", 7687, 0, 0) # (address, port, flow info, scope id) @pytest.mark.parametrize( "test_input, expected", [ (("127.0.0.1", 7687), {"family": AF_INET, "host": "127.0.0.1", "port": 7687, "str": "127.0.0.1:7687", "repr": "IPv4Address(('127.0.0.1', 7687))"}), (("localhost", 7687), {"family": AF_INET, "host": "localhost", "port": 7687, "str": "localhost:7687", "repr": "IPv4Address(('localhost', 7687))"}), ((None, None), {"family": AF_INET, "host": None, "port": None, "str": "None:None", "repr": "IPv4Address((None, None))"}), (("::1", 7687), {"family": AF_INET, "host": "::1", "port": 7687, "str": "::1:7687", "repr": "IPv4Address(('::1', 7687))"}), (("::1", 7687, 0, 0), {"family": AF_INET6, "host": "::1", "port": 7687, "str": "[::1]:7687", "repr": "IPv6Address(('::1', 7687, 0, 0))"}), (("::1", 7687, 1, 2), {"family": AF_INET6, "host": "::1", "port": 7687, "str": "[::1]:7687", "repr": "IPv6Address(('::1', 7687, 1, 2))"}), ((None, None, None, None), {"family": AF_INET6, "host": None, "port": None, "str": "[None]:None", "repr": "IPv6Address((None, None, None, None))"}), (Address(("127.0.0.1", 7687)), {"family": AF_INET, "host": "127.0.0.1", "port": 7687, "str": "127.0.0.1:7687", "repr": "IPv4Address(('127.0.0.1', 7687))"}), (Address(("::1", 7687, 1, 2)), {"family": AF_INET6, "host": "::1", "port": 7687, "str": "[::1]:7687", "repr": "IPv6Address(('::1', 7687, 1, 2))"}), ] ) def test_address_initialization( test_input: t.Union[tuple, Address], expected: dict ) -> None: address = Address(test_input) assert address.family == expected["family"] assert address.host == expected["host"] assert address.port == expected["port"] assert str(address) == expected["str"] assert repr(address) == expected["repr"] @pytest.mark.parametrize( "test_input", [ Address(("127.0.0.1", 7687)), Address(("127.0.0.1", 7687, 1, 2)), ] ) def test_address_init_with_address_object_returns_same_instance( test_input: Address ) -> None: address = Address(test_input) assert address is test_input assert id(address) == id(test_input) @pytest.mark.parametrize( "test_input, expected", [ (("127.0.0.1",), ValueError), (("127.0.0.1", 7687, 0), ValueError), (("[::1]", 7687, 0), ValueError), (("[::1]", 7687, 0, 0, 0), ValueError), ] ) def test_address_initialization_with_incorrect_input( test_input: tuple, expected ) -> None: with pytest.raises(expected): _ = Address(test_input) @pytest.mark.parametrize( "test_input, expected", [ (mock_socket_ipv4, ("127.0.0.1", 7687)), (mock_socket_ipv6, ("[::1]", 7687, 0, 0)) ] ) def test_address_from_socket(test_input: mock.Mock, expected: tuple) -> None: _ = Address.from_socket(mock_socket_ipv4) address = Address.from_socket(test_input) assert address == expected def test_address_from_socket_with_none() -> None: with pytest.raises(AttributeError): _ = Address.from_socket(None) # type: ignore[arg-type] @pytest.mark.parametrize( "test_input, expected", [ ("127.0.0.1:7687", ("127.0.0.1", 7687)), ("localhost:7687", ("localhost", 7687)), (":7687", ("localhost", 7687)), (":", ("localhost", 0)), ("", ("localhost", 0)), (":abcd", ("localhost", "abcd")), (" ", (" ", 0)), ] ) def test_address_parse_with_ipv4(test_input: str, expected: tuple) -> None: parsed = Address.parse(test_input) assert parsed == expected @pytest.mark.parametrize( "test_input, expected", [ ("[::1]:7687", ("::1", 7687, 0, 0)), ("[::1]:abcd", ("::1", "abcd", 0, 0)), ("[::1]:", ("::1", 0, 0, 0)), ("[::1]", ("::1", 0, 0, 0)), ] ) def test_address_should_parse_ipv6(test_input: str, expected: tuple) -> None: parsed = Address.parse(test_input) assert parsed == expected @pytest.mark.parametrize( "test_input, expected", [ (None, TypeError), (123, TypeError), (("127.0.0.1", 7687), TypeError), (("[::1]", 7687, 1, 2), TypeError), (Address(("127.0.0.1", 7687)), TypeError), ] ) def test_address_parse_with_invalid_input(test_input, expected) -> None: with pytest.raises(expected): _ = Address.parse(test_input) @pytest.mark.parametrize( "test_input, expected", [ (("localhost:7687 [::1]:7687",), 2), (("localhost:7687", "[::1]:7687"), 2), (("localhost:7687 localhost:7688", "[::1]:7687"), 3), (("localhost:7687 localhost:7687", "[::1]:7687"), 3), ] ) def test_address_parse_list(test_input: tuple, expected: int) -> None: addresses = Address.parse_list(*test_input) assert len(addresses) == expected @pytest.mark.parametrize( "test_input, expected", [ (("localhost:7687", None), TypeError), (("localhost:7687", 123), TypeError), (("localhost:7687", ("127.0.0.1", 7687)), TypeError), (("localhost:7687", ("[::1]", 7687, 1, 2)), TypeError), (("localhost:7687", Address(("127.0.0.1", 7687))), TypeError), ] ) def test_address_parse_list_with_invalid_input( test_input: tuple, expected ) -> None: with pytest.raises(TypeError): _ = Address.parse_list(*test_input) neo4j-python-driver-5.2.1/tests/unit/common/test_api.py000066400000000000000000000310401433522662700231510ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations import itertools import typing as t import pytest import neo4j.api from neo4j.exceptions import ConfigurationError standard_ascii = [chr(i) for i in range(128)] not_ascii = "♥O◘♦♥O◘♦" def test_bookmark_is_deprecated() -> None: with pytest.deprecated_call(): neo4j.Bookmark() def test_bookmark_initialization_with_no_values() -> None: with pytest.deprecated_call(): bookmark = neo4j.Bookmark() assert bookmark.values == frozenset() assert bool(bookmark) is False assert repr(bookmark) == "" @pytest.mark.parametrize( "test_input, expected_values, expected_bool, expected_repr", [ ((None,), frozenset(), False, ""), ((None, None), frozenset(), False, ""), (("bookmark1", None), frozenset({"bookmark1"}), True, ""), (("bookmark1", None, "bookmark2", None), frozenset({"bookmark1", "bookmark2"}), True, ""), ((None, "bookmark1", None, "bookmark2", None, None, "bookmark3"), frozenset({"bookmark1", "bookmark2", "bookmark3"}), True, ""), ] ) def test_bookmark_initialization_with_values_none( test_input, expected_values, expected_bool, expected_repr ) -> None: with pytest.deprecated_call(): bookmark = neo4j.Bookmark(*test_input) assert bookmark.values == expected_values assert bool(bookmark) is expected_bool assert repr(bookmark) == expected_repr @pytest.mark.parametrize( "test_input, expected_values, expected_bool, expected_repr", [ (("",), frozenset(), False, ""), (("", ""), frozenset(), False, ""), (("bookmark1", ""), frozenset({"bookmark1"}), True, ""), (("bookmark1", "", "bookmark2", ""), frozenset({"bookmark1", "bookmark2"}), True, ""), (("", "bookmark1", "", "bookmark2", "", "", "bookmark3"), frozenset({"bookmark1", "bookmark2", "bookmark3"}), True, ""), ] ) def test_bookmark_initialization_with_values_empty_string( test_input, expected_values, expected_bool, expected_repr ) -> None: with pytest.deprecated_call(): bookmark = neo4j.Bookmark(*test_input) assert bookmark.values == expected_values assert bool(bookmark) is expected_bool assert repr(bookmark) == expected_repr @pytest.mark.parametrize( "test_input, expected_values, expected_bool, expected_repr", [ (("bookmark1",), frozenset({"bookmark1"}), True, ""), (("bookmark1", "bookmark2", "bookmark3"), frozenset({"bookmark1", "bookmark2", "bookmark3"}), True, ""), (standard_ascii, frozenset(standard_ascii), True, "".format(values="', '".join(standard_ascii))) ] ) def test_bookmark_initialization_with_valid_strings( test_input, expected_values, expected_bool, expected_repr ) -> None: with pytest.deprecated_call(): bookmark = neo4j.Bookmark(*test_input) assert bookmark.values == expected_values assert bool(bookmark) is expected_bool assert repr(bookmark) == expected_repr _bm_input_mark = pytest.mark.parametrize( ("test_input", "expected"), [ ((not_ascii,), ValueError), (("", not_ascii,), ValueError), (("bookmark1", chr(129),), ValueError), ] ) @_bm_input_mark def test_bookmark_initialization_with_invalid_strings( test_input: t.Tuple[str], expected ) -> None: with pytest.raises(expected): with pytest.warns(DeprecationWarning): neo4j.Bookmark(*test_input) @_bm_input_mark def test_bookmarks_initialization_with_invalid_strings( test_input: t.Tuple[str], expected ) -> None: with pytest.raises(expected): neo4j.Bookmarks.from_raw_values(test_input) @pytest.mark.parametrize("test_as_generator", [True, False]) @pytest.mark.parametrize("values", ( ("bookmark1", "bookmark2", "bookmark3"), {"bookmark1", "bookmark2", "bookmark3"}, frozenset(("bookmark1", "bookmark2", "bookmark3")), ["bookmark1", "bookmark2", "bookmark3"], ("bookmark1", "bookmark2", "bookmark1"), ("bookmark1", ""), ("bookmark1",), (), )) def test_bookmarks_raw_values(test_as_generator, values) -> None: expected = frozenset(values) if test_as_generator: values = (v for v in values) received = neo4j.Bookmarks().from_raw_values(values).raw_values assert isinstance(received, frozenset) assert received == expected @pytest.mark.parametrize(("values", "exc_type"), ( (("bookmark1", None), TypeError), ((neo4j.Bookmarks(),), TypeError), (neo4j.Bookmarks(), TypeError), ((None,), TypeError), (None, TypeError), ((False,), TypeError), (((),), TypeError), (([],), TypeError), ((dict(),), TypeError), ((set(),), TypeError), ((frozenset(),), TypeError), ((["bookmark1", "bookmark2"],), TypeError), ((not_ascii,), ValueError), )) def test_bookmarks_invalid_raw_values(values, exc_type) -> None: with pytest.raises(exc_type): neo4j.Bookmarks().from_raw_values(values) @pytest.mark.parametrize(("values", "expected_repr"), ( (("bm1", "bm2"), ""), (("bm2", "bm1"), ""), (("bm42",), ""), ((), ""), )) def test_bookmarks_repr(values, expected_repr) -> None: bookmarks = neo4j.Bookmarks().from_raw_values(values) assert repr(bookmarks) == expected_repr @pytest.mark.parametrize(("values1", "values2"), ( (values for values in itertools.combinations_with_replacement( ( ("bookmark1",), ("bookmark1", "bookmark2"), ("bookmark3",), (), ), 2 )) )) def test_bookmarks_combination(values1, values2) -> None: bookmarks1 = neo4j.Bookmarks().from_raw_values(values1) bookmarks2 = neo4j.Bookmarks().from_raw_values(values2) bookmarks3 = bookmarks1 + bookmarks2 assert bookmarks3.raw_values == (bookmarks2 + bookmarks1).raw_values assert bookmarks3.raw_values == frozenset(values1) | frozenset(values2) @pytest.mark.parametrize( "test_input, expected_str, expected_repr", [ ((), "", "Version()"), ((None,), "None", "Version(None,)"), (("3",), "3", "Version('3',)"), (("3", "0"), "3.0", "Version('3', '0')"), ((3,), "3", "Version(3,)"), ((3, 0), "3.0", "Version(3, 0)"), ((3, 0, 0), "3.0.0", "Version(3, 0, 0)"), ((3, 0, 0, 0), "3.0.0.0", "Version(3, 0, 0, 0)"), ] ) def test_version_initialization( test_input, expected_str, expected_repr ) -> None: version = neo4j.Version(*test_input) assert str(version) == expected_str assert repr(version) == expected_repr @pytest.mark.parametrize( "test_input, expected_str, expected_repr", [ (bytearray([0, 0, 0, 0]), "0.0", "Version(0, 0)"), (bytearray([0, 0, 0, 1]), "1.0", "Version(1, 0)"), (bytearray([0, 0, 1, 0]), "0.1", "Version(0, 1)"), (bytearray([0, 0, 1, 1]), "1.1", "Version(1, 1)"), (bytearray([0, 0, 254, 254]), "254.254", "Version(254, 254)"), ] ) def test_version_from_bytes_with_valid_bolt_version_handshake( test_input, expected_str, expected_repr ) -> None: version = neo4j.Version.from_bytes(test_input) assert str(version) == expected_str assert repr(version) == expected_repr @pytest.mark.parametrize( "test_input, expected", [ (bytearray([0, 0, 0]), ValueError), (bytearray([0, 0, 0, 0, 0]), ValueError), (bytearray([1, 0, 0, 0]), ValueError), (bytearray([0, 1, 0, 0]), ValueError), (bytearray([1, 1, 0, 0]), ValueError), ] ) def test_version_from_bytes_with_not_valid_bolt_version_handshake( test_input, expected ) -> None: with pytest.raises(expected): _ = neo4j.Version.from_bytes(test_input) @pytest.mark.parametrize( "test_input, expected", [ ((), bytearray([0, 0, 0, 0])), ((0,), bytearray([0, 0, 0, 0])), ((1,), bytearray([0, 0, 0, 1])), ((0, 0), bytearray([0, 0, 0, 0])), ((1, 0), bytearray([0, 0, 0, 1])), ((1, 2), bytearray([0, 0, 2, 1])), ((255, 255), bytearray([0, 0, 255, 255])), ] ) def test_version_to_bytes_with_valid_bolt_version( test_input, expected ) -> None: version = neo4j.Version(*test_input) assert version.to_bytes() == expected def test_serverinfo_initialization() -> None: from neo4j.addressing import Address address = Address(("bolt://localhost", 7687)) version = neo4j.Version(3, 0) server_info = neo4j.ServerInfo(address, version) assert server_info.address is address assert server_info.protocol_version is version with pytest.warns(DeprecationWarning): assert server_info.connection_id is None @pytest.mark.parametrize( "test_input, expected_agent", [ ({"server": "Neo4j/3.0.0"}, "Neo4j/3.0.0"), ({"server": "Neo4j/3.X.Y"}, "Neo4j/3.X.Y"), ({"server": "Neo4j/4.3.1"}, "Neo4j/4.3.1"), ] ) @pytest.mark.parametrize("protocol_version", ((3, 0), (4, 3), (42, 1337))) def test_serverinfo_with_metadata( test_input, expected_agent, protocol_version ) -> None: from neo4j.addressing import Address address = Address(("bolt://localhost", 7687)) version = neo4j.Version(*protocol_version) server_info = neo4j.ServerInfo(address, version) server_info.update(test_input) assert server_info.agent == expected_agent assert server_info.protocol_version == version @pytest.mark.parametrize( "test_input, expected_driver_type, expected_security_type, expected_error", [ ("bolt://localhost:7676", neo4j.api.DRIVER_BOLT, neo4j.api.SECURITY_TYPE_NOT_SECURE, None), ("bolt+ssc://localhost:7676", neo4j.api.DRIVER_BOLT, neo4j.api.SECURITY_TYPE_SELF_SIGNED_CERTIFICATE, None), ("bolt+s://localhost:7676", neo4j.api.DRIVER_BOLT, neo4j.api.SECURITY_TYPE_SECURE, None), ("neo4j://localhost:7676", neo4j.api.DRIVER_NEO4J, neo4j.api.SECURITY_TYPE_NOT_SECURE, None), ("neo4j+ssc://localhost:7676", neo4j.api.DRIVER_NEO4J, neo4j.api.SECURITY_TYPE_SELF_SIGNED_CERTIFICATE, None), ("neo4j+s://localhost:7676", neo4j.api.DRIVER_NEO4J, neo4j.api.SECURITY_TYPE_SECURE, None), ("undefined://localhost:7676", None, None, ConfigurationError), ("localhost:7676", None, None, ConfigurationError), ("://localhost:7676", None, None, ConfigurationError), ("bolt+routing://localhost:7676", neo4j.api.DRIVER_NEO4J, neo4j.api.SECURITY_TYPE_NOT_SECURE, ConfigurationError), ("bolt://username@localhost:7676", None, None, ConfigurationError), ("bolt://username:password@localhost:7676", None, None, ConfigurationError), ] ) def test_uri_scheme( test_input, expected_driver_type, expected_security_type, expected_error ) -> None: if expected_error: with pytest.raises(expected_error): neo4j.api.parse_neo4j_uri(test_input) else: driver_type, security_type, parsed = neo4j.api.parse_neo4j_uri(test_input) assert driver_type == expected_driver_type assert security_type == expected_security_type def test_parse_routing_context() -> None: context = neo4j.api.parse_routing_context(query="name=molly&color=white") assert context == {"name": "molly", "color": "white"} def test_parse_routing_context_should_error_when_value_missing() -> None: with pytest.raises(ConfigurationError): neo4j.api.parse_routing_context("name=&color=white") def test_parse_routing_context_should_error_when_key_duplicate() -> None: with pytest.raises(ConfigurationError): neo4j.api.parse_routing_context("name=molly&name=white") neo4j-python-driver-5.2.1/tests/unit/common/test_conf.py000066400000000000000000000336251433522662700233400ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 ssl import pytest from neo4j import ( ExperimentalWarning, TrustAll, TrustCustomCAs, TrustSystemCAs, ) from neo4j._conf import ( Config, PoolConfig, SessionConfig, WorkspaceConfig, ) from neo4j.api import ( READ_ACCESS, TRUST_ALL_CERTIFICATES, TRUST_SYSTEM_CA_SIGNED_CERTIFICATES, WRITE_ACCESS, ) from neo4j.debug import watch from neo4j.exceptions import ConfigurationError # python -m pytest tests/unit/test_conf.py -s -v watch("neo4j") test_pool_config = { "connection_timeout": 30.0, "keep_alive": True, "max_connection_lifetime": 3600, "max_connection_pool_size": 100, "resolver": None, "encrypted": False, "user_agent": "test", "trusted_certificates": TrustSystemCAs(), "ssl_context": None, } test_session_config = { "connection_acquisition_timeout": 60.0, "max_transaction_retry_time": 30.0, "initial_retry_delay": 1.0, "retry_delay_multiplier": 2.0, "retry_delay_jitter_factor": 0.2, "bookmarks": (), "default_access_mode": WRITE_ACCESS, "database": None, "impersonated_user": None, "fetch_size": 100, "bookmark_manager": object(), } def test_pool_config_consume(): test_config = dict(test_pool_config) consumed_pool_config = PoolConfig.consume(test_config) assert isinstance(consumed_pool_config, PoolConfig) assert len(test_config) == 0 for key in test_pool_config.keys(): assert consumed_pool_config[key] == test_pool_config[key] for key in consumed_pool_config.keys(): assert test_pool_config[key] == consumed_pool_config[key] assert len(consumed_pool_config) == len(test_pool_config) def test_pool_config_consume_default_values(): test_config = {} consumed_pool_config = PoolConfig.consume(test_config) assert isinstance(consumed_pool_config, PoolConfig) assert len(test_config) == 0 consumed_pool_config.keep_alive = "changed" assert PoolConfig.keep_alive != consumed_pool_config.keep_alive def test_pool_config_consume_key_not_valid(): test_config = dict(test_pool_config) test_config["not_valid_key"] = "test" with pytest.raises(ConfigurationError) as error: consumed_pool_config = PoolConfig.consume(test_config) error.match("Unexpected config keys: not_valid_key") def test_pool_config_set_value(): test_config = dict(test_pool_config) consumed_pool_config = PoolConfig.consume(test_config) assert consumed_pool_config.get("encrypted") is False assert consumed_pool_config["encrypted"] is False assert consumed_pool_config.encrypted is False consumed_pool_config.encrypted = "test" assert consumed_pool_config.get("encrypted") == "test" assert consumed_pool_config["encrypted"] == "test" assert consumed_pool_config.encrypted == "test" consumed_pool_config.not_valid_key = "test" # Use consume functions def test_pool_config_consume_and_then_consume_again(): test_config = dict(test_pool_config) consumed_pool_config = PoolConfig.consume(test_config) assert consumed_pool_config.encrypted is False consumed_pool_config.encrypted = "test" with pytest.raises(AttributeError): consumed_pool_config = PoolConfig.consume(consumed_pool_config) consumed_pool_config = PoolConfig.consume(dict(consumed_pool_config.items())) consumed_pool_config = PoolConfig.consume(dict(consumed_pool_config.items())) assert consumed_pool_config.encrypted == "test" @pytest.mark.parametrize( ("value_trust", "expected_trusted_certificates_cls"), ( (TRUST_ALL_CERTIFICATES, TrustAll), (TRUST_SYSTEM_CA_SIGNED_CERTIFICATES, TrustSystemCAs), ) ) def test_pool_config_deprecated_trust_config( value_trust, expected_trusted_certificates_cls ): with pytest.warns(DeprecationWarning, match="trust.*trusted_certificates"): consumed_pool_config = PoolConfig.consume({"trust": value_trust}) assert isinstance(consumed_pool_config.trusted_certificates, expected_trusted_certificates_cls) assert not hasattr(consumed_pool_config, "trust") @pytest.mark.parametrize("value_trust", ( TRUST_ALL_CERTIFICATES, TRUST_SYSTEM_CA_SIGNED_CERTIFICATES )) @pytest.mark.parametrize("trusted_certificates", ( TrustSystemCAs(), TrustAll(), TrustCustomCAs("foo"), TrustCustomCAs("foo", "bar") )) def test_pool_config_deprecated_and_new_trust_config(value_trust, trusted_certificates): with pytest.raises(ConfigurationError, match="trusted_certificates.*trust"): PoolConfig.consume({"trust": value_trust, "trusted_certificates": trusted_certificates}) @pytest.mark.parametrize("config_cls", (WorkspaceConfig, SessionConfig)) def test_bookmark_manager_is_experimental(config_cls): bmm = object() with pytest.warns(ExperimentalWarning, match="bookmark_manager"): config = config_cls.consume({"bookmark_manager": bmm}) assert config.bookmark_manager is bmm def test_config_consume_chain(): test_config = {} test_config.update(test_pool_config) test_config.update(test_session_config) with pytest.warns(ExperimentalWarning, match="bookmark_manager"): consumed_pool_config, consumed_session_config = Config.consume_chain( test_config, PoolConfig, SessionConfig ) assert isinstance(consumed_pool_config, PoolConfig) assert isinstance(consumed_session_config, SessionConfig) assert len(test_config) == 0 for key, val in test_pool_config.items(): assert consumed_pool_config[key] == val for key, val in consumed_pool_config.items(): assert test_pool_config[key] == val assert len(consumed_pool_config) == len(test_pool_config) assert len(consumed_session_config) == len(test_session_config) def test_init_session_config_merge(): # python -m pytest tests/unit/test_conf.py -s -v -k test_init_session_config test_config_a = {"connection_acquisition_timeout": 111} test_config_c = {"max_transaction_retry_time": 222} workspace_config = WorkspaceConfig(test_config_a, WorkspaceConfig.consume(test_config_c)) assert len(test_config_a) == 1 assert len(test_config_c) == 0 assert isinstance(workspace_config, WorkspaceConfig) assert workspace_config.connection_acquisition_timeout == WorkspaceConfig.connection_acquisition_timeout assert workspace_config.max_transaction_retry_time == 222 workspace_config = WorkspaceConfig(test_config_c, test_config_a) assert isinstance(workspace_config, WorkspaceConfig) assert workspace_config.connection_acquisition_timeout == 111 assert workspace_config.max_transaction_retry_time == WorkspaceConfig.max_transaction_retry_time test_config_b = {"default_access_mode": READ_ACCESS, "connection_acquisition_timeout": 333} session_config = SessionConfig(workspace_config, test_config_b) assert session_config.connection_acquisition_timeout == 333 assert session_config.default_access_mode == READ_ACCESS session_config = SessionConfig(test_config_b, workspace_config) assert session_config.connection_acquisition_timeout == 111 assert session_config.default_access_mode == READ_ACCESS def test_init_session_config_with_not_valid_key(): # python -m pytest tests/unit/test_conf.py -s -v -k test_init_session_config_with_not_valid_key test_config_a = {"connection_acquisition_timeout": 111} workspace_config = WorkspaceConfig.consume(test_config_a) test_config_b = {"default_access_mode": READ_ACCESS, "connection_acquisition_timeout": 333, "not_valid_key": None} session_config = SessionConfig(workspace_config, test_config_b) with pytest.raises(AttributeError): assert session_config.not_valid_key is None with pytest.raises(ConfigurationError): _ = SessionConfig.consume(test_config_b) assert session_config.connection_acquisition_timeout == 333 @pytest.mark.parametrize("config", ( {}, {"encrypted": False}, {"trusted_certificates": TrustSystemCAs()}, {"trusted_certificates": TrustAll()}, {"trusted_certificates": TrustCustomCAs("foo", "bar")}, )) def test_no_ssl_mock(config, mocker): ssl_context_mock = mocker.patch("ssl.SSLContext", autospec=True) pool_config = PoolConfig.consume(config) assert pool_config.encrypted is False assert pool_config.get_ssl_context() is None ssl_context_mock.assert_not_called() @pytest.mark.parametrize("config", ( {"encrypted": True}, {"encrypted": True, "trusted_certificates": TrustSystemCAs()}, )) def test_trust_system_cas_mock(config, mocker): ssl_context_mock = mocker.patch("ssl.SSLContext", autospec=True) pool_config = PoolConfig.consume(config) assert pool_config.encrypted is True ssl_context = pool_config.get_ssl_context() _assert_mock_tls_1_2(ssl_context_mock) assert ssl_context.minimum_version == ssl.TLSVersion.TLSv1_2 ssl_context_mock.return_value.load_default_certs.assert_called_once_with() ssl_context_mock.return_value.load_verify_locations.assert_not_called() assert ssl_context.check_hostname is True assert ssl_context.verify_mode == ssl.CERT_REQUIRED @pytest.mark.parametrize("config", ( {"encrypted": True, "trusted_certificates": TrustCustomCAs("foo", "bar")}, {"encrypted": True, "trusted_certificates": TrustCustomCAs()}, )) def test_trust_custom_cas_mock(config, mocker): ssl_context_mock = mocker.patch("ssl.SSLContext", autospec=True) certs = config["trusted_certificates"].certs pool_config = PoolConfig.consume(config) assert pool_config.encrypted is True ssl_context = pool_config.get_ssl_context() _assert_mock_tls_1_2(ssl_context_mock) assert ssl_context.minimum_version == ssl.TLSVersion.TLSv1_2 ssl_context_mock.return_value.load_default_certs.assert_not_called() assert ( ssl_context_mock.return_value.load_verify_locations.call_args_list == [((cert,), {}) for cert in certs] ) assert ssl_context.check_hostname is True assert ssl_context.verify_mode == ssl.CERT_REQUIRED @pytest.mark.parametrize("config", ( {"encrypted": True, "trusted_certificates": TrustAll()}, )) def test_trust_all_mock(config, mocker): ssl_context_mock = mocker.patch("ssl.SSLContext", autospec=True) pool_config = PoolConfig.consume(config) assert pool_config.encrypted is True ssl_context = pool_config.get_ssl_context() _assert_mock_tls_1_2(ssl_context_mock) assert ssl_context.minimum_version == ssl.TLSVersion.TLSv1_2 ssl_context_mock.return_value.load_default_certs.assert_not_called() ssl_context_mock.return_value.load_verify_locations.assert_not_called() assert ssl_context.check_hostname is False assert ssl_context.verify_mode is ssl.CERT_NONE def _assert_mock_tls_1_2(mock): mock.assert_called_once_with(ssl.PROTOCOL_TLS_CLIENT) assert mock.return_value.minimum_version == ssl.TLSVersion.TLSv1_2 @pytest.mark.parametrize("config", ( {}, {"encrypted": False}, {"trusted_certificates": TrustSystemCAs()}, {"trusted_certificates": TrustAll()}, {"trusted_certificates": TrustCustomCAs("foo", "bar")}, )) def test_no_ssl(config): pool_config = PoolConfig.consume(config) assert pool_config.encrypted is False assert pool_config.get_ssl_context() is None @pytest.mark.parametrize("config", ( {"encrypted": True}, {"encrypted": True, "trusted_certificates": TrustSystemCAs()}, )) def test_trust_system_cas(config): pool_config = PoolConfig.consume(config) assert pool_config.encrypted is True ssl_context = pool_config.get_ssl_context() assert isinstance(ssl_context, ssl.SSLContext) _assert_context_tls_1_2(ssl_context) assert ssl_context.check_hostname is True assert ssl_context.verify_mode == ssl.CERT_REQUIRED @pytest.mark.parametrize("config", ( {"encrypted": True, "trusted_certificates": TrustCustomCAs()}, )) def test_trust_custom_cas(config): pool_config = PoolConfig.consume(config) assert pool_config.encrypted is True ssl_context = pool_config.get_ssl_context() assert isinstance(ssl_context, ssl.SSLContext) _assert_context_tls_1_2(ssl_context) assert ssl_context.check_hostname is True assert ssl_context.verify_mode == ssl.CERT_REQUIRED @pytest.mark.parametrize("config", ( {"encrypted": True, "trusted_certificates": TrustAll()}, )) def test_trust_all(config): pool_config = PoolConfig.consume(config) assert pool_config.encrypted is True ssl_context = pool_config.get_ssl_context() assert isinstance(ssl_context, ssl.SSLContext) _assert_context_tls_1_2(ssl_context) assert ssl_context.check_hostname is False assert ssl_context.verify_mode is ssl.CERT_NONE def _assert_context_tls_1_2(ctx): assert ctx.protocol == ssl.PROTOCOL_TLS_CLIENT assert ctx.minimum_version == ssl.TLSVersion.TLSv1_2 @pytest.mark.parametrize("encrypted", (True, False)) @pytest.mark.parametrize("trusted_certificates", ( TrustSystemCAs(), TrustAll(), TrustCustomCAs() )) def test_custom_ssl_context(encrypted, trusted_certificates): custom_ssl_context = object() pool_config = PoolConfig.consume({ "encrypted": encrypted, "trusted_certificates": trusted_certificates, "ssl_context": custom_ssl_context, }) assert pool_config.encrypted is encrypted assert pool_config.get_ssl_context() is custom_ssl_context neo4j-python-driver-5.2.1/tests/unit/common/test_debug.py000066400000000000000000000201651433522662700234740ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations import asyncio import io import logging import sys import typing as t import pytest if t.TYPE_CHECKING: import typing_extensions as te from neo4j import debug as neo4j_debug from ..._async_compat import mark_async_test if t.TYPE_CHECKING: class _TSetupMockProtocol(te.Protocol): def __call__(self, *args: str) -> t.Sequence[t.Any]: ... @pytest.fixture def logger_mocker(mocker) -> _TSetupMockProtocol: def setup_mock(*logger_names): loggers = [logging.getLogger(name) for name in logger_names] for logger in loggers: logger.addHandler = mocker.Mock() logger.removeHandler = mocker.Mock() logger.setLevel = mocker.Mock() return loggers return setup_mock def test_watch_returns_watcher(logger_mocker) -> None: logger_name = "neo4j" logger_mocker(logger_name) watcher = neo4j_debug.watch(logger_name) assert isinstance(watcher, neo4j_debug.Watcher) @pytest.mark.parametrize("logger_names", (("neo4j",), ("foobar",), ("neo4j", "foobar"))) def test_watch_enables_logging(logger_names, logger_mocker) -> None: loggers = logger_mocker(*logger_names) neo4j_debug.watch(*logger_names) for logger in loggers: logger.addHandler.assert_called_once() def test_watcher_watch_adds_logger(logger_mocker) -> None: logger_name = "neo4j" logger = logger_mocker(logger_name)[0] watcher = neo4j_debug.Watcher(logger_name) logger.addHandler.assert_not_called() watcher.watch() logger.addHandler.assert_called_once() def test_watcher_stop_removes_logger(logger_mocker) -> None: logger_name = "neo4j" logger = logger_mocker(logger_name)[0] watcher = neo4j_debug.Watcher(logger_name) watcher.watch() (handler,), _ = logger.addHandler.call_args logger.removeHandler.assert_not_called() watcher.stop() logger.removeHandler.assert_called_once_with(handler) def test_watcher_context_manager(mocker) -> None: logger_name = "neo4j" watcher: t.Any = neo4j_debug.Watcher(logger_name) watcher.watch = mocker.Mock() watcher.stop = mocker.Mock() with watcher: watcher.watch.assert_called_once() watcher.stop.assert_not_called() watcher.stop.assert_called_once() @pytest.mark.parametrize( ("default_level", "level", "expected_level"), ( (None, None, logging.DEBUG), (logging.WARNING, None, logging.WARNING), (logging.WARNING, logging.DEBUG, logging.DEBUG), (logging.DEBUG, logging.WARNING, logging.WARNING), (1, None, 1), (None, 1, 1), ) ) def test_watcher_level( logger_mocker, default_level, level, expected_level ) -> None: logger_name = "neo4j" logger = logger_mocker(logger_name)[0] kwargs = {} if default_level is not None: kwargs["default_level"] = default_level watcher = neo4j_debug.Watcher(logger_name, **kwargs) kwargs = {} if level is not None: kwargs["level"] = level watcher.watch(**kwargs) (handler,), _ = logger.addHandler.call_args assert handler.level == logging.NOTSET logger.setLevel.assert_called_once_with(expected_level) custom_log_out = io.StringIO() @pytest.mark.parametrize( ("default_out", "out", "expected_out"), ( (None, None, sys.stderr), (sys.stdout, None, sys.stdout), (sys.stdout, sys.stderr, sys.stderr), (sys.stderr, sys.stdout, sys.stdout), (custom_log_out, None, custom_log_out), (None, custom_log_out, custom_log_out), ) ) def test_watcher_out( logger_mocker, default_out, out, expected_out ) -> None: logger_name = "neo4j" logger = logger_mocker(logger_name)[0] kwargs = {} if default_out is not None: kwargs["default_out"] = default_out watcher = neo4j_debug.Watcher(logger_name, **kwargs) kwargs = {} if out is not None: kwargs["out"] = out watcher.watch(**kwargs) (handler,), _ = logger.addHandler.call_args assert isinstance(handler, logging.StreamHandler) assert handler.stream == expected_out @pytest.mark.parametrize("colour", (True, False)) @pytest.mark.parametrize("thread", (True, False)) @pytest.mark.parametrize("task", (True, False)) def test_watcher_colour(logger_mocker, colour, thread, task) -> None: logger_name = "neo4j" logger = logger_mocker(logger_name)[0] watcher = neo4j_debug.Watcher(logger_name, colour=colour, thread_info=thread, task_info=task) watcher.watch() logger.addHandler.assert_called_once() (handler,), _ = logger.addHandler.call_args assert isinstance(handler, logging.Handler) assert isinstance(handler.formatter, logging.Formatter) if colour: assert isinstance(handler.formatter, neo4j_debug.ColourFormatter) else: assert not isinstance(handler.formatter, neo4j_debug.ColourFormatter) @pytest.mark.parametrize("colour", (True, False)) @pytest.mark.parametrize("thread", (True, False)) @pytest.mark.parametrize("task", (True, False)) def test_watcher_format(logger_mocker, colour, thread, task) -> None: logger_name = "neo4j" logger = logger_mocker(logger_name)[0] watcher = neo4j_debug.Watcher(logger_name, colour=colour, thread_info=thread, task_info=task) watcher.watch() logger.addHandler.assert_called_once() (handler,), _ = logger.addHandler.call_args assert isinstance(handler, logging.Handler) assert isinstance(handler.formatter, logging.Formatter) expected_format = "%(asctime)s %(message)s" if task: expected_format = "[Task %(task)-15s] " + expected_format if thread: expected_format = "[Thread %(thread)d] " + expected_format if not colour: expected_format = "[%(levelname)-8s] " + expected_format # Don't look at me like that. It's just for testing. format_ = handler.formatter._fmt assert format_ == expected_format def _assert_task_injection( async_: bool, mocker, logger_mocker, colour: bool, thread: bool, task: bool ) -> None: handler_cls_mock = mocker.patch("neo4j.debug.StreamHandler", autospec=True) handler_mock = handler_cls_mock.return_value logger_name = "neo4j" watcher = neo4j_debug.Watcher(logger_name, colour=colour, thread_info=thread, task_info=task) record_mock = mocker.Mock(spec=logging.LogRecord) assert not hasattr(record_mock, "task") watcher.watch() if task: handler_mock.addFilter.assert_called_once() (filter_,), _ = handler_mock.addFilter.call_args assert isinstance(filter_, logging.Filter) filter_.filter(record_mock) if async_: assert record_mock.task == id(asyncio.current_task()) else: assert record_mock.task is None else: handler_mock.addFilter.assert_not_called() @pytest.mark.parametrize("colour", (True, False)) @pytest.mark.parametrize("thread", (True, False)) @pytest.mark.parametrize("task", (True, False)) def test_watcher_task_injection( mocker, logger_mocker, colour, thread, task ) -> None: _assert_task_injection(False, mocker, logger_mocker, colour, thread, task) @pytest.mark.parametrize("colour", (True, False)) @pytest.mark.parametrize("thread", (True, False)) @pytest.mark.parametrize("task", (True, False)) @mark_async_test async def test_async_watcher_task_injection( mocker, logger_mocker, colour, thread, task ) -> None: _assert_task_injection(True, mocker, logger_mocker, colour, thread, task) neo4j-python-driver-5.2.1/tests/unit/common/test_exceptions.py000066400000000000000000000253151433522662700245710ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j._exceptions import ( BoltConnectionBroken, BoltConnectionClosed, BoltConnectionError, BoltError, BoltFailure, BoltHandshakeError, BoltProtocolError, BoltSecurityError, ) from neo4j._sync.io import Bolt from neo4j.exceptions import ( AuthConfigurationError, AuthError, CertificateConfigurationError, CLASSIFICATION_CLIENT, CLASSIFICATION_DATABASE, CLASSIFICATION_TRANSIENT, ClientError, ConfigurationError, ConstraintError, CypherSyntaxError, CypherTypeError, DatabaseError, DatabaseUnavailable, DriverError, Forbidden, ForbiddenOnReadOnlyDatabase, IncompleteCommit, Neo4jError, NotALeader, ReadServiceUnavailable, ResultConsumedError, RoutingServiceUnavailable, ServiceUnavailable, SessionExpired, TransactionError, TransactionNestingError, TransientError, WriteServiceUnavailable, ) def test_bolt_error(): with pytest.raises(BoltError) as e: error = BoltError("Error Message", address="localhost") assert repr(error) == "BoltError('Error Message')" assert str(error) == "Error Message" assert error.args == ("Error Message",) assert error.address == "localhost" raise error # The regexp parameter of the match method is matched with the re.search function. with pytest.raises(AssertionError): e.match("FAIL!") assert e.match("Error Message") def test_bolt_protocol_error(): with pytest.raises(BoltProtocolError) as e: error = BoltProtocolError("Driver does not support Bolt protocol version: 0x%06X%02X" % (2, 5), address="localhost") assert error.address == "localhost" raise error # The regexp parameter of the match method is matched with the re.search function. with pytest.raises(AssertionError): e.match("FAIL!") e.match("Driver does not support Bolt protocol version: 0x00000205") def test_bolt_handshake_error(): handshake = b"\x00\x00\x00\x04\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00" response = b"\x00\x00\x00\x00" supported_versions = Bolt.protocol_handlers().keys() with pytest.raises(BoltHandshakeError) as e: error = BoltHandshakeError("The Neo4J server does not support communication with this driver. Supported Bolt Protocols {}".format(supported_versions), address="localhost", request_data=handshake, response_data=response) assert error.address == "localhost" assert error.request_data == handshake assert error.response_data == response raise error e.match("The Neo4J server does not support communication with this driver. Supported Bolt Protocols ") def test_serviceunavailable(): with pytest.raises(ServiceUnavailable) as e: error = ServiceUnavailable("Test error message") raise error assert e.value.__cause__ is None def test_serviceunavailable_raised_from_bolt_protocol_error_with_implicit_style(): error = BoltProtocolError("Driver does not support Bolt protocol version: 0x%06X%02X" % (2, 5), address="localhost") with pytest.raises(ServiceUnavailable) as e: assert error.address == "localhost" try: raise error except BoltProtocolError as error_bolt_protocol: raise ServiceUnavailable(str(error_bolt_protocol)) from error_bolt_protocol # The regexp parameter of the match method is matched with the re.search function. with pytest.raises(AssertionError): e.match("FAIL!") e.match("Driver does not support Bolt protocol version: 0x00000205") assert e.value.__cause__ is error def test_serviceunavailable_raised_from_bolt_protocol_error_with_explicit_style(): error = BoltProtocolError("Driver does not support Bolt protocol version: 0x%06X%02X" % (2, 5), address="localhost") with pytest.raises(ServiceUnavailable) as e: assert error.address == "localhost" try: raise error except BoltProtocolError as error_bolt_protocol: error_nested = ServiceUnavailable(str(error_bolt_protocol)) error_nested.__cause__ = error_bolt_protocol raise error_nested # The regexp parameter of the match method is matched with the re.search function. with pytest.raises(AssertionError): e.match("FAIL!") e.match("Driver does not support Bolt protocol version: 0x00000205") assert e.value.__cause__ is error def test_neo4jerror_hydrate_with_no_args(): error = Neo4jError.hydrate() assert isinstance(error, DatabaseError) assert error.classification == CLASSIFICATION_DATABASE assert error.category == "General" assert error.title == "UnknownError" assert error.metadata == {} assert error.message == "An unknown error occurred" assert error.code == "Neo.DatabaseError.General.UnknownError" def test_neo4jerror_hydrate_with_message_and_code_rubish(): error = Neo4jError.hydrate(message="Test error message", code="ASDF_asdf") assert isinstance(error, DatabaseError) assert error.classification == CLASSIFICATION_DATABASE assert error.category == "General" assert error.title == "UnknownError" assert error.metadata == {} assert error.message == "Test error message" assert error.code == "ASDF_asdf" def test_neo4jerror_hydrate_with_message_and_code_database(): error = Neo4jError.hydrate(message="Test error message", code="Neo.DatabaseError.General.UnknownError") assert isinstance(error, DatabaseError) assert error.classification == CLASSIFICATION_DATABASE assert error.category == "General" assert error.title == "UnknownError" assert error.metadata == {} assert error.message == "Test error message" assert error.code == "Neo.DatabaseError.General.UnknownError" def test_neo4jerror_hydrate_with_message_and_code_transient(): error = Neo4jError.hydrate(message="Test error message", code="Neo.TransientError.General.TestError") # error = Neo4jError.hydrate(message="Test error message", code="Neo.{}.General.TestError".format(CLASSIFICATION_TRANSIENT)) assert isinstance(error, TransientError) assert error.classification == CLASSIFICATION_TRANSIENT assert error.category == "General" assert error.title == "TestError" assert error.metadata == {} assert error.message == "Test error message" assert error.code == "Neo.{}.General.TestError".format(CLASSIFICATION_TRANSIENT) def test_neo4jerror_hydrate_with_message_and_code_client(): error = Neo4jError.hydrate(message="Test error message", code="Neo.{}.General.TestError".format(CLASSIFICATION_CLIENT)) assert isinstance(error, ClientError) assert error.classification == CLASSIFICATION_CLIENT assert error.category == "General" assert error.title == "TestError" assert error.metadata == {} assert error.message == "Test error message" assert error.code == "Neo.{}.General.TestError".format(CLASSIFICATION_CLIENT) @pytest.mark.parametrize( ("code", "expected_cls", "expected_code"), ( ( "Neo.TransientError.Transaction.Terminated", ClientError, "Neo.ClientError.Transaction.Terminated" ), ( "Neo.ClientError.Transaction.Terminated", ClientError, "Neo.ClientError.Transaction.Terminated" ), ( "Neo.TransientError.Transaction.LockClientStopped", ClientError, "Neo.ClientError.Transaction.LockClientStopped" ), ( "Neo.ClientError.Transaction.LockClientStopped", ClientError, "Neo.ClientError.Transaction.LockClientStopped" ), ( "Neo.ClientError.Security.AuthorizationExpired", TransientError, "Neo.ClientError.Security.AuthorizationExpired" ), ( "Neo.TransientError.General.TestError", TransientError, "Neo.TransientError.General.TestError" ) ) ) def test_error_rewrite(code, expected_cls, expected_code): message = "Test error message" error = Neo4jError.hydrate(message=message, code=code) expected_retryable = expected_cls is TransientError assert error.__class__ is expected_cls assert error.code == expected_code assert error.message == message assert error.is_retryable() is expected_retryable with pytest.warns(DeprecationWarning, match=".*is_retryable.*"): assert error.is_retriable() is expected_retryable @pytest.mark.parametrize( ("code", "message", "expected_cls", "expected_str"), ( ( "Neo.ClientError.General.UnknownError", "Test error message", ClientError, "{code: Neo.ClientError.General.UnknownError} " "{message: Test error message}" ), ( None, "Test error message", DatabaseError, "{code: Neo.DatabaseError.General.UnknownError} " "{message: Test error message}" ), ( "", "Test error message", DatabaseError, "{code: Neo.DatabaseError.General.UnknownError} " "{message: Test error message}" ), ( "Neo.ClientError.General.UnknownError", None, ClientError, "{code: Neo.ClientError.General.UnknownError} " "{message: An unknown error occurred}" ), ( "Neo.ClientError.General.UnknownError", "", ClientError, "{code: Neo.ClientError.General.UnknownError} " "{message: An unknown error occurred}" ), ) ) def test_neo4j_error_from_server_as_str(code, message, expected_cls, expected_str): error = Neo4jError.hydrate(code=code, message=message) assert type(error) == expected_cls assert str(error) == expected_str @pytest.mark.parametrize("cls", (Neo4jError, ClientError)) def test_neo4j_error_from_code_as_str(cls): error = cls("Generated somewhere in the driver") assert type(error)== cls assert str(error) == "Generated somewhere in the driver" neo4j-python-driver-5.2.1/tests/unit/common/test_import_neo4j.py000066400000000000000000000062331433522662700250170ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest def test_import_dunder_version(): from neo4j import __version__ def test_import_graphdatabase(): from neo4j import GraphDatabase def test_import_async_graphdatabase(): from neo4j import AsyncGraphDatabase def test_import_driver(): from neo4j import Driver def test_import_async_driver(): from neo4j import AsyncDriver def test_import_boltdriver(): from neo4j import BoltDriver def test_import_async_boltdriver(): from neo4j import AsyncBoltDriver def test_import_neo4jdriver(): from neo4j import Neo4jDriver def test_import_async_neo4jdriver(): from neo4j import AsyncNeo4jDriver def test_import_auth(): from neo4j import Auth def test_import_authtoken(): from neo4j import AuthToken def test_import_basic_auth(): from neo4j import basic_auth def test_import_bearer_auth(): from neo4j import bearer_auth def test_import_kerberos_auth(): from neo4j import kerberos_auth def test_import_custom_auth(): from neo4j import custom_auth def test_import_read_access(): from neo4j import READ_ACCESS def test_import_write_access(): from neo4j import WRITE_ACCESS def test_import_transaction(): from neo4j import Transaction def test_import_async_transaction(): from neo4j import AsyncTransaction def test_import_record(): from neo4j import Record def test_import_session(): from neo4j import Session def test_import_async_session(): from neo4j import AsyncSession def test_import_sessionconfig(): with pytest.warns(DeprecationWarning): from neo4j import SessionConfig def test_import_query(): from neo4j import Query def test_import_result(): from neo4j import Result def test_import_async_result(): from neo4j import AsyncResult def test_import_resultsummary(): from neo4j import ResultSummary def test_import_unit_of_work(): from neo4j import unit_of_work def test_import_config(): with pytest.warns(DeprecationWarning): from neo4j import Config def test_import_poolconfig(): with pytest.warns(DeprecationWarning): from neo4j import PoolConfig def test_import_graph(): from neo4j import graph def test_import_graph_node(): from neo4j.graph import Node def test_import_graph_path(): from neo4j.graph import Path def test_import_graph_graph(): from neo4j.graph import Graph def test_import_spatial(): from neo4j import spatial def test_import_time(): from neo4j import time def test_import_exceptions(): from neo4j import exceptions neo4j-python-driver-5.2.1/tests/unit/common/test_record.py000066400000000000000000000326351433522662700236710ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations import traceback import pytest from neo4j import Record from neo4j._codec.hydration import BrokenHydrationObject from neo4j._codec.hydration.v1 import HydrationHandler from neo4j.exceptions import BrokenRecordError from neo4j.graph import Node # python -m pytest -s -v tests/unit/test_record.py def test_record_equality() -> None: record1 = Record(zip(["name", "empire"], ["Nigel", "The British Empire"])) record2 = Record(zip(["name", "empire"], ["Nigel", "The British Empire"])) record3 = Record(zip(["name", "empire"], ["Stefan", "Das Deutschland"])) assert record1 == record2 assert record1 != record3 assert record2 != record3 def test_record_hashing() -> None: record1 = Record(zip(["name", "empire"], ["Nigel", "The British Empire"])) record2 = Record(zip(["name", "empire"], ["Nigel", "The British Empire"])) record3 = Record(zip(["name", "empire"], ["Stefan", "Das Deutschland"])) assert hash(record1) == hash(record2) assert hash(record1) != hash(record3) assert hash(record2) != hash(record3) def test_record_iter() -> None: a_record = Record(zip(["name", "empire"], ["Nigel", "The British Empire"])) assert list(a_record.__iter__()) == ["Nigel", "The British Empire"] def test_record_as_dict() -> None: a_record = Record(zip(["name", "empire"], ["Nigel", "The British Empire"])) assert dict(a_record) == {"name": "Nigel", "empire": "The British Empire"} def test_record_as_list() -> None: a_record = Record(zip(["name", "empire"], ["Nigel", "The British Empire"])) assert list(a_record) == ["Nigel", "The British Empire"] def test_record_len() -> None: a_record = Record(zip(["name", "empire"], ["Nigel", "The British Empire"])) assert len(a_record) == 2 def test_record_repr() -> None: a_record = Record(zip(["name", "empire"], ["Nigel", "The British Empire"])) assert repr(a_record) == "" def test_record_data() -> None: r = Record(zip(["name", "age", "married"], ["Alice", 33, True])) assert r.data() == {"name": "Alice", "age": 33, "married": True} assert r.data("name") == {"name": "Alice"} assert r.data("age", "name") == {"age": 33, "name": "Alice"} assert r.data("age", "name", "shoe size") == {"age": 33, "name": "Alice", "shoe size": None} assert r.data(0, "name") == {"name": "Alice"} assert r.data(0) == {"name": "Alice"} assert r.data(1, 0) == {"age": 33, "name": "Alice"} with pytest.raises(IndexError): _ = r.data(1, 0, 999) def test_record_keys() -> None: r = Record(zip(["name", "age", "married"], ["Alice", 33, True])) assert r.keys() == ["name", "age", "married"] def test_record_values() -> None: r = Record(zip(["name", "age", "married"], ["Alice", 33, True])) assert r.values() == ["Alice", 33, True] assert r.values("name") == ["Alice"] assert r.values("age", "name") == [33, "Alice"] assert r.values("age", "name", "shoe size") == [33, "Alice", None] assert r.values(0, "name") == ["Alice", "Alice"] assert r.values(0) == ["Alice"] assert r.values(1, 0) == [33, "Alice"] with pytest.raises(IndexError): _ = r.values(1, 0, 999) def test_record_items() -> None: r = Record(zip(["name", "age", "married"], ["Alice", 33, True])) assert r.items() == [("name", "Alice"), ("age", 33), ("married", True)] assert r.items("name") == [("name", "Alice")] assert r.items("age", "name") == [("age", 33), ("name", "Alice")] assert r.items("age", "name", "shoe size") == [("age", 33), ("name", "Alice"), ("shoe size", None)] assert r.items(0, "name") == [("name", "Alice"), ("name", "Alice")] assert r.items(0) == [("name", "Alice")] assert r.items(1, 0) == [("age", 33), ("name", "Alice")] with pytest.raises(IndexError): _ = r.items(1, 0, 999) def test_record_index() -> None: r = Record(zip(["name", "age", "married"], ["Alice", 33, True])) assert r.index("name") == 0 assert r.index("age") == 1 assert r.index("married") == 2 with pytest.raises(KeyError): _ = r.index("shoe size") assert r.index(0) == 0 assert r.index(1) == 1 assert r.index(2) == 2 with pytest.raises(IndexError): _ = r.index(3) with pytest.raises(TypeError): _ = r.index(None) # type: ignore[arg-type] def test_record_value() -> None: r = Record(zip(["name", "age", "married"], ["Alice", 33, True])) assert r.value() == "Alice" assert r.value("name") == "Alice" assert r.value("age") == 33 assert r.value("married") is True assert r.value("shoe size") is None assert r.value("shoe size", 6) == 6 assert r.value(0) == "Alice" assert r.value(1) == 33 assert r.value(2) is True assert r.value(3) is None assert r.value(3, 6) == 6 with pytest.raises(TypeError): _ = r.value(None) # type: ignore[arg-type] def test_record_value_kwargs() -> None: r = Record(zip(["name", "age", "married"], ["Alice", 33, True])) assert r.value() == "Alice" assert r.value(key="name") == "Alice" assert r.value(key="age") == 33 assert r.value(key="married") is True assert r.value(key="shoe size") is None assert r.value(key="shoe size", default=6) == 6 assert r.value(key=0) == "Alice" assert r.value(key=1) == 33 assert r.value(key=2) is True assert r.value(key=3) is None assert r.value(key=3, default=6) == 6 def test_record_contains() -> None: r = Record(zip(["name", "age", "married"], ["Alice", 33, True])) assert "Alice" in r assert 33 in r assert True in r assert 7.5 not in r with pytest.raises(TypeError): _ = r.index(None) # type: ignore[arg-type] def test_record_from_dict() -> None: r = Record({"name": "Alice", "age": 33}) assert r["name"] == "Alice" assert r["age"] == 33 def test_record_get_slice() -> None: r = Record(zip(["name", "age", "married"], ["Alice", 33, True])) assert Record(zip(["name", "age"], ["Alice", 33])) == r[0:2] def test_record_get_by_index() -> None: r = Record(zip(["name", "age", "married"], ["Alice", 33, True])) assert r[0] == "Alice" def test_record_get_by_name() -> None: r = Record(zip(["name", "age", "married"], ["Alice", 33, True])) assert r["name"] == "Alice" def test_record_get_by_out_of_bounds_index() -> None: r = Record(zip(["name", "age", "married"], ["Alice", 33, True])) assert r[9] is None def test_record_get_item() -> None: r = Record(zip(["x", "y"], ["foo", "bar"])) assert r["x"] == "foo" assert r["y"] == "bar" with pytest.raises(KeyError): _ = r["z"] with pytest.raises(TypeError): _ = r[object()] # type: ignore[index] @pytest.mark.parametrize("len_", (0, 1, 2, 42)) def test_record_len_generic(len_) -> None: r = Record(("key_%i" % i, "val_%i" % i) for i in range(len_)) assert len(r) == len_ @pytest.mark.parametrize("len_", range(3)) def test_record_repr_generic(len_) -> None: r = Record(("key_%i" % i, "val_%i" % i) for i in range(len_)) assert repr(r) @pytest.mark.parametrize(("raw", "keys", "serialized"), ( ( zip(["x", "y", "z"], [1, 2, 3]), (), {"x": 1, "y": 2, "z": 3} ), ( zip(["x", "y", "z"], [1, 2, 3]), (1, 2), {"y": 2, "z": 3} ), ( zip(["x", "y", "z"], [1, 2, 3]), ("z", "x"), {"x": 1, "z": 3} ), ( zip(["x"], [None]), (), {"x": None} ), ( zip(["x", "y"], [True, False]), (), {"x": True, "y": False} ), ( zip(["x", "y", "z"], [0.0, 1.0, 3.141592653589]), (), {"x": 0.0, "y": 1.0, "z": 3.141592653589} ), ( zip(["x"], ["hello, world"]), (), {"x": "hello, world"} ), ( zip(["x"], [bytearray([1, 2, 3])]), (), {"x": bytearray([1, 2, 3])} ), ( zip(["x"], [[1, 2, 3]]), (), {"x": [1, 2, 3]} ), ( zip(["x"], [{"one": 1, "two": 2}]), (), {"x": {"one": 1, "two": 2}} ), ( zip( ["a"], [Node( None, # type: ignore[arg-type] "42", 42, "Person", {"name": "Alice"} )]), (), {"a": {"name": "Alice"}} ), )) def test_data(raw, keys, serialized) -> None: assert Record(raw).data(*keys) == serialized def test_data_relationship() -> None: hydration_scope = HydrationHandler().new_hydration_scope() gh = hydration_scope._graph_hydrator alice = gh.hydrate_node(1, {"Person"}, {"name": "Alice", "age": 33}) bob = gh.hydrate_node(2, {"Person"}, {"name": "Bob", "age": 44}) alice_knows_bob = gh.hydrate_relationship(1, 1, 2, "KNOWS", {"since": 1999}) record = Record(zip(["a", "b", "r"], [alice, bob, alice_knows_bob])) assert record.data() == { "a": {"name": "Alice", "age": 33}, "b": {"name": "Bob", "age": 44}, "r": ( {"name": "Alice", "age": 33}, "KNOWS", {"name": "Bob", "age": 44} ), } def test_data_unbound_relationship() -> None: hydration_scope = HydrationHandler().new_hydration_scope() gh = hydration_scope._graph_hydrator some_one_knows_some_one = gh.hydrate_relationship( 1, 42, 43, "KNOWS", {"since": 1999} ) record = Record(zip(["r"], [some_one_knows_some_one])) assert record.data() == {"r": ({}, "KNOWS", {})} @pytest.mark.parametrize("cyclic", (True, False)) def test_data_path(cyclic) -> None: hydration_scope = HydrationHandler().new_hydration_scope() gh = hydration_scope._graph_hydrator alice = gh.hydrate_node(1, {"Person"}, {"name": "Alice", "age": 33}) bob = gh.hydrate_node(2, {"Person"}, {"name": "Bob", "age": 44}) if cyclic: carol = alice else: carol = gh.hydrate_node(3, {"Person"}, {"name": "Carol", "age": 55}) r = [gh.hydrate_unbound_relationship(1, "KNOWS", {"since": 1999}), gh.hydrate_unbound_relationship(2, "DISLIKES", {})] path = gh.hydrate_path([alice, bob, carol], r, [1, 1, -2, 2]) record = Record(zip(["r"], [path])) assert record.data() == { "r": [dict(alice), "KNOWS", dict(bob), "DISLIKES", dict(carol)] } @pytest.mark.parametrize(("accessor", "should_raise"), ( (lambda r: r["a"], False), (lambda r: r["b"], True), (lambda r: r["c"], False), (lambda r: r[0], False), (lambda r: r[1], True), (lambda r: r[2], False), (lambda r: r.value("a"), False), (lambda r: r.value("b"), True), (lambda r: r.value("c"), False), (lambda r: r.value("made-up"), False), (lambda r: r.value(0), False), (lambda r: r.value(1), True), (lambda r: r.value(2), False), (lambda r: r.value(3), False), (lambda r: r.values(0, 2, "made-up"), False), (lambda r: r.values(0, 1), True), (lambda r: r.values(2, 1), True), (lambda r: r.values(1), True), (lambda r: r.values(1, "made-up"), True), (lambda r: r.values(1, 0), True), (lambda r: r.values("a", "c", "made-up"), False), (lambda r: r.values("a", "b"), True), (lambda r: r.values("c", "b"), True), (lambda r: r.values("b"), True), (lambda r: r.values("b", "made-up"), True), (lambda r: r.values("b", "a"), True), (lambda r: r.data(0, 2, "made-up"), False), (lambda r: r.data(0, 1), True), (lambda r: r.data(2, 1), True), (lambda r: r.data(1), True), (lambda r: r.data(1, "made-up"), True), (lambda r: r.data(1, 0), True), (lambda r: r.data("a", "c", "made-up"), False), (lambda r: r.data("a", "b"), True), (lambda r: r.data("c", "b"), True), (lambda r: r.data("b"), True), (lambda r: r.data("b", "made-up"), True), (lambda r: r.data("b", "a"), True), (lambda r: r.get("a"), False), (lambda r: r.get("b"), True), (lambda r: r.get("c"), False), (lambda r: r.get("made-up"), False), (lambda r: list(r), True), (lambda r: list(r.items()), True), (lambda r: r.index("a"), False), (lambda r: r.index("b"), False), (lambda r: r.index("c"), False), (lambda r: r.index(0), False), (lambda r: r.index(1), False), (lambda r: r.index(2), False), )) def test_record_with_error(accessor, should_raise) -> None: class TestException(Exception): pass # raising and catching exceptions to get the stacktrace populated try: raise TestException("test") except TestException as e: exc = e frames = list(traceback.walk_tb(exc.__traceback__)) r = Record((("a", 1), ("b", BrokenHydrationObject(exc, None)), ("c", 3))) if not should_raise: accessor(r) return with pytest.raises(BrokenRecordError) as raised: accessor(r) exc_value = raised.value assert exc_value.__cause__ is exc assert list(traceback.walk_tb(exc_value.__cause__.__traceback__)) == frames neo4j-python-driver-5.2.1/tests/unit/common/test_security.py000066400000000000000000000055001433522662700242510ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations from neo4j.api import ( basic_auth, bearer_auth, custom_auth, kerberos_auth, ) # python -m pytest -s -v tests/unit/test_security.py def test_should_generate_kerberos_auth_token_correctly() -> None: auth = kerberos_auth("I am a base64 service ticket") assert auth.scheme == "kerberos" assert auth.principal == "" assert auth.credentials == "I am a base64 service ticket" assert not hasattr(auth, "ticket") assert not hasattr(auth, "realm") assert not hasattr(auth, "parameters") def test_should_generate_bearer_auth_token_correctly() -> None: auth = bearer_auth("I am a base64 SSO ticket") assert auth.scheme == "bearer" assert auth.credentials == "I am a base64 SSO ticket" assert not hasattr(auth, "principal") assert not hasattr(auth, "ticket") assert not hasattr(auth, "realm") assert not hasattr(auth, "parameters") def test_should_generate_basic_auth_without_realm_correctly() -> None: auth = basic_auth("molly", "meoooow") assert auth.scheme == "basic" assert auth.principal == "molly" assert auth.credentials == "meoooow" assert not hasattr(auth, "realm") assert not hasattr(auth, "parameters") def test_should_generate_base_auth_with_realm_correctly() -> None: auth = basic_auth("molly", "meoooow", "cat_cafe") assert auth.scheme == "basic" assert auth.principal == "molly" assert auth.credentials == "meoooow" assert auth.realm == "cat_cafe" assert not hasattr(auth, "parameters") def test_should_generate_base_auth_with_keyword_realm_correctly() -> None: auth = basic_auth("molly", "meoooow", realm="cat_cafe") assert auth.scheme == "basic" assert auth.principal == "molly" assert auth.credentials == "meoooow" assert auth.realm == "cat_cafe" assert not hasattr(auth, "parameters") def test_should_generate_custom_auth_correctly() -> None: auth = custom_auth("molly", "meoooow", "cat_cafe", "cat", age="1", color="white") assert auth.scheme == "cat" assert auth.principal == "molly" assert auth.credentials == "meoooow" assert auth.realm == "cat_cafe" assert auth.parameters == {"age": "1", "color": "white"} neo4j-python-driver-5.2.1/tests/unit/common/test_types.py000066400000000000000000000520141433522662700235500ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 itertools import product import pytest from neo4j._codec.hydration.v1 import HydrationHandler from neo4j.graph import ( Graph, Node, Path, Relationship, ) # python -m pytest -s -v tests/unit/test_types.py # Node @pytest.mark.parametrize(("id_", "element_id"), ( (123, "123"), (123, None), (None, "foobar"), )) def test_can_create_node(id_, element_id): hydration_scope = HydrationHandler().new_hydration_scope() gh = hydration_scope._graph_hydrator fields = [id_, {"Person"}, {"name": "Alice", "age": 33}] if element_id is not None: fields.append(element_id) alice = gh.hydrate_node(*fields) assert isinstance(alice, Node) with pytest.warns(DeprecationWarning, match="element_id"): assert alice.id == id_ if element_id is not None: assert alice.element_id == element_id else: assert alice.element_id == str(id_) assert alice.labels == {"Person"} assert set(alice.keys()) == {"name", "age"} assert set(alice.values()) == {"Alice", 33} assert set(alice.items()) == {("name", "Alice"), ("age", 33)} assert dict(alice) == {"name": "Alice", "age": 33} assert alice.get("name") == "Alice" assert alice.get("age") == 33 assert alice.get("unknown") is None assert alice.get("unknown", None) is None assert alice.get("unknown", False) is False assert alice.get("unknown", "default") == "default" assert len(alice) == 2 assert alice["name"] == "Alice" assert alice["age"] == 33 assert "name" in alice assert "age" in alice assert set(iter(alice)) == {"name", "age"} def test_node_with_null_properties(): hydration_scope = HydrationHandler().new_hydration_scope() gh = hydration_scope._graph_hydrator stuff = gh.hydrate_node(1, (), {"good": ["puppies", "kittens"], "bad": None}) assert isinstance(stuff, Node) assert set(stuff.keys()) == {"good"} assert stuff.get("good") == ["puppies", "kittens"] assert stuff.get("bad") is None assert len(stuff) == 1 assert stuff["good"] == ["puppies", "kittens"] assert stuff["bad"] is None assert "good" in stuff assert "bad" not in stuff @pytest.mark.parametrize(("g1", "id1", "eid1", "props1", "g2", "id2", "eid2", "props2"), ( (*n1, *n2) for n1, n2 in product( ( # type: ignore (g, id_, element_id, props) # type: ignore for g in (0, 1) for id_, element_id in ( (1, "1"), (1234, "1234"), (None, "1234"), (None, "foobar"), ) for props in (None, {}, {"a": 1}) ), repeat=2 ) )) def test_node_equality(g1, id1, eid1, props1, g2, id2, eid2, props2): graphs = (Graph(), Graph()) node_1 = Node(graphs[g1], eid1, id1, props1) node_2 = Node(graphs[g2], eid2, id2, props2) if g1 == g2 and eid1 == eid2: assert node_1 == node_2 else: assert node_1 != node_2 assert node_1 != "this is not a node" @pytest.mark.parametrize("legacy_id", (True, False)) def test_node_hashing(legacy_id): g = Graph() node_1 = Node(g, "1234" + ("abc" if not legacy_id else ""), 1234) node_2 = Node(g, "1234" + ("abc" if not legacy_id else ""), 1234) node_3 = Node(g, "5678" + ("abc" if not legacy_id else ""), 5678) assert hash(node_1) == hash(node_2) assert hash(node_1) != hash(node_3) def test_node_v1_repr(): hydration_scope = HydrationHandler().new_hydration_scope() gh = hydration_scope._graph_hydrator alice = gh.hydrate_node(1, {"Person"}, {"name": "Alice"}) assert repr(alice) == ( "" ) @pytest.mark.parametrize("legacy_id", (True, False)) def test_node_v2_repr(legacy_id): hydration_scope = HydrationHandler().new_hydration_scope() gh = hydration_scope._graph_hydrator id_ = 1234 element_id = str(id_) if legacy_id else "foobar" alice = gh.hydrate_node(id_, {"Person"}, {"name": "Alice"}, element_id) assert repr(alice) == ( f"" ) # Relationship def test_can_create_relationship_v1(): hydration_scope = HydrationHandler().new_hydration_scope() gh = hydration_scope._graph_hydrator alice = gh.hydrate_node(1, {"Person"}, {"name": "Alice", "age": 33}) bob = gh.hydrate_node(2, {"Person"}, {"name": "Bob", "age": 44}) alice_knows_bob = gh.hydrate_relationship(1, 1, 2, "KNOWS", {"since": 1999}) assert isinstance(alice_knows_bob, Relationship) assert alice_knows_bob.start_node == alice assert alice_knows_bob.type == "KNOWS" assert alice_knows_bob.end_node == bob assert dict(alice_knows_bob) == {"since": 1999} assert set(alice_knows_bob.keys()) == {"since"} assert set(alice_knows_bob.values()) == {1999} assert set(alice_knows_bob.items()) == {("since", 1999)} assert alice_knows_bob.get("since") == 1999 @pytest.mark.parametrize("legacy_id", (True, False)) def test_can_create_relationship_v2(legacy_id): hydration_scope = HydrationHandler().new_hydration_scope() gh = hydration_scope._graph_hydrator alice = gh.hydrate_node( 1, {"Person"}, {"name": "Alice", "age": 33}, "1" if legacy_id else "alice" ) bob = gh.hydrate_node( 2, {"Person"}, {"name": "Bob", "age": 44}, "2" if legacy_id else "bob" ) alice_knows_bob = gh.hydrate_relationship( 1, 1, 2, "KNOWS", {"since": 1999}, "1" if legacy_id else "alice_knows_bob", "1" if legacy_id else "alice", "2" if legacy_id else "bob" ) assert isinstance(alice_knows_bob, Relationship) assert alice_knows_bob.start_node == alice assert alice_knows_bob.type == "KNOWS" assert alice_knows_bob.end_node == bob assert dict(alice_knows_bob) == {"since": 1999} assert set(alice_knows_bob.keys()) == {"since"} assert set(alice_knows_bob.values()) == {1999} assert set(alice_knows_bob.items()) == {("since", 1999)} assert alice_knows_bob.get("since") == 1999 def test_relationship_v1_repr(): hydration_scope = HydrationHandler().new_hydration_scope() gh = hydration_scope._graph_hydrator _alice = gh.hydrate_node(1, {"Person"}, {"name": "Alice"}) _bob = gh.hydrate_node(2, {"Person"}, {"name": "Bob"}) alice_knows_bob = gh.hydrate_relationship(3, 1, 2, "KNOWS", {"since": 1999}) assert repr(alice_knows_bob) == ( ", ) " "type='KNOWS' properties={'since': 1999}>" ) @pytest.mark.parametrize("legacy_id", (True, False)) def test_relationship_v2_repr(legacy_id): hydration_scope = HydrationHandler().new_hydration_scope() gh = hydration_scope._graph_hydrator gh.hydrate_node( 1, {"Person"}, {"name": "Alice"}, "1" if legacy_id else "alice" ) gh.hydrate_node( 2, {"Person"}, {"name": "Bob"}, "2" if legacy_id else "bob" ) alice_knows_bob = gh.hydrate_relationship( 1, 1, 2, "KNOWS", {"since": 1999}, "1" if legacy_id else "alice_knows_bob", "1" if legacy_id else "alice", "2" if legacy_id else "bob" ) expected_eid = "1" if legacy_id else "alice_knows_bob" expected_eid_alice = "1" if legacy_id else "alice" expected_eid_bob = "2" if legacy_id else "bob" assert repr(alice_knows_bob) == ( f", " f") " "type='KNOWS' properties={'since': 1999}>" ) # Path def test_can_create_path_v1(): hydration_scope = HydrationHandler().new_hydration_scope() gh = hydration_scope._graph_hydrator alice = gh.hydrate_node(1, {"Person"}, {"name": "Alice", "age": 33}) bob = gh.hydrate_node(2, {"Person"}, {"name": "Bob", "age": 44}) carol = gh.hydrate_node(3, {"Person"}, {"name": "Carol", "age": 55}) alice_knows_bob = gh.hydrate_relationship(1, 1, 2, "KNOWS", {"since": 1999}) carol_dislikes_bob = gh.hydrate_relationship(2, 3, 2, "DISLIKES", {}) path = Path(alice, alice_knows_bob, carol_dislikes_bob) assert isinstance(path, Path) assert path.start_node is alice assert path.end_node is carol assert path.nodes == (alice, bob, carol) assert path.relationships == (alice_knows_bob, carol_dislikes_bob) assert list(path) == [alice_knows_bob, carol_dislikes_bob] @pytest.mark.parametrize("legacy_id", (True, False)) def test_can_create_path_v2(legacy_id): hydration_scope = HydrationHandler().new_hydration_scope() gh = hydration_scope._graph_hydrator alice = gh.hydrate_node( 1, {"Person"}, {"name": "Alice", "age": 33}, "1" if legacy_id else "alice" ) bob = gh.hydrate_node( 2, {"Person"}, {"name": "Bob", "age": 44}, "2" if legacy_id else "bob" ) carol = gh.hydrate_node( 3, {"Person"}, {"name": "Carol", "age": 55}, "3" if legacy_id else "carol" ) alice_knows_bob = gh.hydrate_relationship( 1, 1, 2, "KNOWS", {"since": 1999}, "1" if legacy_id else "alice_knows_bob", "1" if legacy_id else "alice", "2" if legacy_id else "bob" ) carol_dislikes_bob = gh.hydrate_relationship( 2, 3, 2, "DISLIKES", {}, "2" if legacy_id else "carol_dislikes_bob", "3" if legacy_id else "carol", "2" if legacy_id else "bob" ) path = Path(alice, alice_knows_bob, carol_dislikes_bob) assert isinstance(path, Path) assert path.start_node is alice assert path.end_node is carol assert path.nodes == (alice, bob, carol) assert path.relationships == (alice_knows_bob, carol_dislikes_bob) assert list(path) == [alice_knows_bob, carol_dislikes_bob] @pytest.mark.parametrize("cyclic", (True, False)) def test_can_hydrate_path(cyclic): hydration_scope = HydrationHandler().new_hydration_scope() gh = hydration_scope._graph_hydrator alice = gh.hydrate_node(1, {"Person"}, {"name": "Alice", "age": 33}, "1") bob = gh.hydrate_node(2, {"Person"}, {"name": "Bob", "age": 44}, "2") if cyclic: carol_id = 1 carol_eid = "1" carol = alice else: carol_id = 3 carol_eid = "3" carol = gh.hydrate_node(carol_id, {"Person"}, {"name": "Carol", "age": 55}, carol_eid) r = [gh.hydrate_unbound_relationship(1, "KNOWS", {"since": 1999}, "1"), gh.hydrate_unbound_relationship(2, "DISLIKES", {}), "2"] path = gh.hydrate_path([alice, bob, carol], r, [1, 1, -2, 2]) assert path.start_node is alice assert path.end_node is carol assert path.nodes == (alice, bob, carol) expected_alice_knows_bob = gh.hydrate_relationship( 1, 1, 2, "KNOWS", {"since": 1999}, "1", "1", "2" ) expected_carol_dislikes_bob = gh.hydrate_relationship( 2, carol_id, 2, "DISLIKES", {}, "2", carol_eid, "2" ) assert path.relationships == (expected_alice_knows_bob, expected_carol_dislikes_bob) assert list(path) == [expected_alice_knows_bob, expected_carol_dislikes_bob] def test_path_v1_equality(): hydration_scope = HydrationHandler().new_hydration_scope() gh = hydration_scope._graph_hydrator alice = gh.hydrate_node(1, {"Person"}, {"name": "Alice", "age": 33}) _bob = gh.hydrate_node(2, {"Person"}, {"name": "Bob", "age": 44}) _carol = gh.hydrate_node(3, {"Person"}, {"name": "Carol", "age": 55}) alice_knows_bob = gh.hydrate_relationship(1, 1, 2, "KNOWS", {"since": 1999}) carol_dislikes_bob = gh.hydrate_relationship(2, 3, 2, "DISLIKES", {}) path_1 = Path(alice, alice_knows_bob, carol_dislikes_bob) path_2 = Path(alice, alice_knows_bob, carol_dislikes_bob) assert path_1 == path_2 assert path_1 != "this is not a path" @pytest.mark.parametrize("legacy_id", (True, False)) def test_path_v2_equality(legacy_id): hydration_scope = HydrationHandler().new_hydration_scope() gh = hydration_scope._graph_hydrator alice = gh.hydrate_node( 1, {"Person"}, {"name": "Alice", "age": 33}, "1" if legacy_id else "alice" ) _bob = gh.hydrate_node( 2, {"Person"}, {"name": "Bob", "age": 44}, "2" if legacy_id else "bob" ) _carol = gh.hydrate_node( 3, {"Person"}, {"name": "Carol", "age": 55}, "3" if legacy_id else "carol" ) alice_knows_bob = gh.hydrate_relationship( 1, 1, 2, "KNOWS", {"since": 1999}, "1" if legacy_id else "alice_knows_bob", "1" if legacy_id else "alice", "2" if legacy_id else "bob" ) carol_dislikes_bob = gh.hydrate_relationship( 2, 3, 2, "DISLIKES", {}, "2" if legacy_id else "carol_dislikes_bob", "3" if legacy_id else "carol", "2" if legacy_id else "bob" ) path_1 = Path(alice, alice_knows_bob, carol_dislikes_bob) path_2 = Path(alice, alice_knows_bob, carol_dislikes_bob) assert path_1 == path_2 assert path_1 != "this is not a path" def test_path_v1_hashing(): hydration_scope = HydrationHandler().new_hydration_scope() gh = hydration_scope._graph_hydrator alice = gh.hydrate_node(1, {"Person"}, {"name": "Alice", "age": 33}) _bob = gh.hydrate_node(2, {"Person"}, {"name": "Bob", "age": 44}) _carol = gh.hydrate_node(3, {"Person"}, {"name": "Carol", "age": 55}) alice_knows_bob = gh.hydrate_relationship(1, 1, 2, "KNOWS", {"since": 1999}) carol_dislikes_bob = gh.hydrate_relationship(2, 3, 2, "DISLIKES", {}) path_1 = Path(alice, alice_knows_bob, carol_dislikes_bob) path_2 = Path(alice, alice_knows_bob, carol_dislikes_bob) assert hash(path_1) == hash(path_2) @pytest.mark.parametrize("legacy_id", (True, False)) def test_path_v2_hashing(legacy_id): hydration_scope = HydrationHandler().new_hydration_scope() gh = hydration_scope._graph_hydrator alice = gh.hydrate_node( 1, {"Person"}, {"name": "Alice", "age": 33}, "1" if legacy_id else "alice" ) _bob = gh.hydrate_node( 2, {"Person"}, {"name": "Bob", "age": 44}, "2" if legacy_id else "bob" ) _carol = gh.hydrate_node( 3, {"Person"}, {"name": "Carol", "age": 55}, "3" if legacy_id else "carol" ) alice_knows_bob = gh.hydrate_relationship( 1, 1, 2, "KNOWS", {"since": 1999}, "1" if legacy_id else "alice_knows_bob", "1" if legacy_id else "alice", "2" if legacy_id else "bob" ) carol_dislikes_bob = gh.hydrate_relationship( 2, 3, 2, "DISLIKES", {}, "2" if legacy_id else "carol_dislikes_bob", "3" if legacy_id else "carol", "2" if legacy_id else "bob" ) path_1 = Path(alice, alice_knows_bob, carol_dislikes_bob) path_2 = Path(alice, alice_knows_bob, carol_dislikes_bob) assert hash(path_1) == hash(path_2) def test_path_v1_repr(): hydration_scope = HydrationHandler().new_hydration_scope() gh = hydration_scope._graph_hydrator alice = gh.hydrate_node(1, {"Person"}, {"name": "Alice"}) _bob = gh.hydrate_node(2, {"Person"}, {"name": "Bob"}) _carol = gh.hydrate_node(3, {"Person"}, {"name": "Carol"}) alice_knows_bob = gh.hydrate_relationship(1, 1, 2, "KNOWS", {"since": 1999}) carol_dislikes_bob = gh.hydrate_relationship(2, 3, 2, "DISLIKES", {}) path = Path(alice, alice_knows_bob, carol_dislikes_bob) assert repr(path) == ( " end= size=2>" ) @pytest.mark.parametrize("legacy_id", (True, False)) def test_path_v2_repr(legacy_id): hydration_scope = HydrationHandler().new_hydration_scope() gh = hydration_scope._graph_hydrator alice = gh.hydrate_node( 1, {"Person"}, {"name": "Alice"}, "1" if legacy_id else "alice" ) bob = gh.hydrate_node( 2, {"Person"}, {"name": "Bob"}, "2" if legacy_id else "bob" ) carol = gh.hydrate_node( 3, {"Person"}, {"name": "Carol"}, "3" if legacy_id else "carol" ) alice_knows_bob = gh.hydrate_relationship( 1, 1, 2, "KNOWS", {"since": 1999}, "1" if legacy_id else "alice_knows_bob", alice.element_id, bob.element_id ) carol_dislikes_bob = gh.hydrate_relationship( 2, 3, 2, "DISLIKES", {}, "2" if legacy_id else "carol_dislikes_bob", carol.element_id, bob.element_id ) path = Path(alice, alice_knows_bob, carol_dislikes_bob) assert repr(path) == ( f" " f"end= size=2>" ) def test_graph_views_v1(): hydration_scope = HydrationHandler().new_hydration_scope() gh = hydration_scope._graph_hydrator alice = gh.hydrate_node(1, {"Person"}, {"name": "Alice"}) bob = gh.hydrate_node(2, {"Person"}, {"name": "Bob"}) carol = gh.hydrate_node(3, {"Person"}, {"name": "Carol"}) alice_knows_bob = gh.hydrate_relationship(1, 1, 2, "KNOWS", {"since": 1999}) carol_dislikes_bob = gh.hydrate_relationship(2, 3, 2, "DISLIKES", {}) g = hydration_scope.get_graph() assert len(g.nodes) == 3 for id_, node in ((1, alice), (2, bob), (3, carol)): with pytest.warns(DeprecationWarning, match=r"element_id \(str\)"): assert g.nodes[id_] == node assert g.nodes[str(id_)] == node assert len(g.relationships) == 2 for id_, rel in ((1, alice_knows_bob), (2, carol_dislikes_bob)): with pytest.warns(DeprecationWarning, match=r"element_id \(str\)"): assert g.relationships[id_] == rel assert g.relationships[str(id_)] == rel @pytest.mark.parametrize("legacy_id", (True, False)) def test_graph_views_v2_repr(legacy_id): hydration_scope = HydrationHandler().new_hydration_scope() gh = hydration_scope._graph_hydrator alice_element_id = "1" if legacy_id else "alice" bob_element_id = "2" if legacy_id else "bob" carol_element_id = "3" if legacy_id else "carol" alice = gh.hydrate_node(1, {"Person"}, {"name": "Alice"}, alice_element_id) bob = gh.hydrate_node(2, {"Person"}, {"name": "Bob"}, bob_element_id) carol = gh.hydrate_node(3, {"Person"}, {"name": "Carol"}, carol_element_id) alice_knows_bob_element_id = "1" if legacy_id else "alice_knows_bob" carol_dislikes_bob_element_id = "2" if legacy_id else "carol_dislikes_bob" alice_knows_bob = gh.hydrate_relationship( 1, 1, 2, "KNOWS", {"since": 1999}, alice_knows_bob_element_id, alice_element_id, bob_element_id ) carol_dislikes_bob = gh.hydrate_relationship( 2, 3, 2, "DISLIKES", {}, carol_dislikes_bob_element_id, carol_element_id, bob_element_id ) g = hydration_scope.get_graph() assert len(g.nodes) == 3 for id_, element_id, node in ( (1, alice_element_id, alice), (2, bob_element_id, bob), (3, carol_element_id, carol) ): with pytest.warns(DeprecationWarning, match=r"element_id \(str\)"): assert g.nodes[id_] == node assert g.nodes[element_id] == node if not legacy_id: with pytest.raises(KeyError): g.nodes[str(id_)] assert len(g.relationships) == 2 for id_, element_id, rel in ( (1, alice_knows_bob_element_id, alice_knows_bob), (2, carol_dislikes_bob_element_id, carol_dislikes_bob) ): with pytest.warns(DeprecationWarning, match=r"element_id \(str\)"): assert g.relationships[id_] == rel assert g.relationships[element_id] == rel if not legacy_id: with pytest.raises(KeyError): g.relationships[str(id_)] neo4j-python-driver-5.2.1/tests/unit/common/time/000077500000000000000000000000001433522662700217275ustar00rootroot00000000000000neo4j-python-driver-5.2.1/tests/unit/common/time/__init__.py000066400000000000000000000022421433522662700240400ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 neo4j.time import ( Clock, ClockTime, ) # The existence of this class will make the driver's custom date time # implementation use it instead of a real clock since its precision it higher # than all the other clocks (only up to nanoseconds). class FixedClock(Clock): @classmethod def available(cls): return True @classmethod def precision(cls): return 12 @classmethod def local_offset(cls): return ClockTime() def utc_time(self): return ClockTime(45296, 789000001) neo4j-python-driver-5.2.1/tests/unit/common/time/test_clock.py000066400000000000000000000042051433522662700244340ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j.time._clock_implementations import ( Clock, ClockTime, ) class TestClock: def test_no_clock_implementations(self): try: Clock._Clock__implementations = [] with pytest.raises(RuntimeError): _ = Clock() finally: Clock._Clock__implementations = None def test_base_clock_precision(self): clock = object.__new__(Clock) with pytest.raises(NotImplementedError): _ = clock.precision() def test_base_clock_available(self): clock = object.__new__(Clock) with pytest.raises(NotImplementedError): _ = clock.available() def test_base_clock_utc_time(self): clock = object.__new__(Clock) with pytest.raises(NotImplementedError): _ = clock.utc_time() def test_local_offset(self): clock = object.__new__(Clock) offset = clock.local_offset() assert isinstance(offset, ClockTime) def test_local_time(self): _ = Clock() for impl in Clock._Clock__implementations: assert issubclass(impl, Clock) clock = object.__new__(impl) time = clock.local_time() assert isinstance(time, ClockTime) def test_utc_time(self): _ = Clock() for impl in Clock._Clock__implementations: assert issubclass(impl, Clock) clock = object.__new__(impl) time = clock.utc_time() assert isinstance(time, ClockTime) neo4j-python-driver-5.2.1/tests/unit/common/time/test_clocktime.py000066400000000000000000000056671433522662700253300ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j.time import ( ClockTime, Duration, ) class TestClockTime: def test_zero_(self): ct = ClockTime() assert ct.seconds == 0 assert ct.nanoseconds == 0 def test_only_seconds(self): ct = ClockTime(123456) assert ct.seconds == 123456 assert ct.nanoseconds == 0 def test_float(self): ct = ClockTime(123456.789) assert ct.seconds == 123456 assert ct.nanoseconds == 789000000 def test_only_nanoseconds(self): ct = ClockTime(0, 123456789) assert ct.seconds == 0 assert ct.nanoseconds == 123456789 def test_nanoseconds_overflow(self): ct = ClockTime(0, 2123456789) assert ct.seconds == 2 assert ct.nanoseconds == 123456789 def test_positive_nanoseconds(self): ct = ClockTime(1, 1) assert ct.seconds == 1 assert ct.nanoseconds == 1 def test_negative_nanoseconds(self): ct = ClockTime(1, -1) assert ct.seconds == 0 assert ct.nanoseconds == 999999999 def test_add_float(self): ct = ClockTime(123456.789) + 0.1 assert ct.seconds == 123456 assert ct.nanoseconds == 889000000 def test_add_duration(self): ct = ClockTime(123456.789) + Duration(seconds=1) assert ct.seconds == 123457 assert ct.nanoseconds == 789000000 def test_add_duration_with_months(self): with pytest.raises(ValueError): _ = ClockTime(123456.789) + Duration(months=1) def test_add_object(self): with pytest.raises(TypeError): _ = ClockTime(123456.789) + object() def test_sub_float(self): ct = ClockTime(123456.789) - 0.1 assert ct.seconds == 123456 assert ct.nanoseconds == 689000000 def test_sub_duration(self): ct = ClockTime(123456.789) - Duration(seconds=1) assert ct.seconds == 123455 assert ct.nanoseconds == 789000000 def test_sub_duration_with_months(self): with pytest.raises(ValueError): _ = ClockTime(123456.789) - Duration(months=1) def test_sub_object(self): with pytest.raises(TypeError): _ = ClockTime(123456.789) - object() def test_repr(self): ct = ClockTime(123456.789) assert repr(ct).startswith("ClockTime") neo4j-python-driver-5.2.1/tests/unit/common/time/test_date.py000066400000000000000000000450741433522662700242670ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations import copy import datetime from datetime import date from time import struct_time import pytest import pytz from neo4j.time import ( Date, Duration, UnixEpoch, ZeroDate, ) timezone_eastern = pytz.timezone("US/Eastern") timezone_utc = pytz.utc class TestDate: def test_bad_attribute(self) -> None: d = Date(2000, 1, 1) with pytest.raises(AttributeError): _ = d.x def test_zero_date(self) -> None: d = Date(0, 0, 0) assert d.year_month_day == (0, 0, 0) assert d.year == 0 assert d.month == 0 assert d.day == 0 assert d is ZeroDate def test_zero_ordinal(self) -> None: d = Date.from_ordinal(0) assert d.year_month_day == (0, 0, 0) assert d.year == 0 assert d.month == 0 assert d.day == 0 assert d is ZeroDate def test_ordinal_at_start_of_1970(self) -> None: d = Date.from_ordinal(719163) assert d.year_month_day == (1970, 1, 1) assert d.year == 1970 assert d.month == 1 assert d.day == 1 def test_ordinal_at_end_of_1969(self) -> None: d = Date.from_ordinal(719162) assert d.year_month_day == (1969, 12, 31) assert d.year == 1969 assert d.month == 12 assert d.day == 31 def test_ordinal_at_start_of_2018(self) -> None: d = Date.from_ordinal(736695) assert d.year_month_day == (2018, 1, 1) assert d.year == 2018 assert d.month == 1 assert d.day == 1 def test_ordinal_at_end_of_2017(self) -> None: d = Date.from_ordinal(736694) assert d.year_month_day == (2017, 12, 31) assert d.year == 2017 assert d.month == 12 assert d.day == 31 def test_all_positive_days_of_month_for_31_day_month(self) -> None: for day in range(1, 32): t = Date(1976, 1, day) assert t.year_month_day == (1976, 1, day) assert t.year == 1976 assert t.month == 1 assert t.day == day with pytest.raises(ValueError): _ = Date(1976, 1, 32) def test_all_positive_days_of_month_for_30_day_month(self) -> None: for day in range(1, 31): t = Date(1976, 6, day) assert t.year_month_day == (1976, 6, day) assert t.year == 1976 assert t.month == 6 assert t.day == day with pytest.raises(ValueError): _ = Date(1976, 6, 31) def test_all_positive_days_of_month_for_29_day_month(self) -> None: for day in range(1, 30): t = Date(1976, 2, day) assert t.year_month_day == (1976, 2, day) assert t.year == 1976 assert t.month == 2 assert t.day == day with pytest.raises(ValueError): _ = Date(1976, 2, 30) def test_all_positive_days_of_month_for_28_day_month(self) -> None: for day in range(1, 29): t = Date(1977, 2, day) assert t.year_month_day == (1977, 2, day) assert t.year == 1977 assert t.month == 2 assert t.day == day with pytest.raises(ValueError): _ = Date(1977, 2, 29) def test_last_but_2_day_for_31_day_month(self) -> None: t = Date(1976, 1, -3) assert t.year_month_day == (1976, 1, 29) assert t.year == 1976 assert t.month == 1 assert t.day == 29 def test_last_but_1_day_for_31_day_month(self) -> None: t = Date(1976, 1, -2) assert t.year_month_day == (1976, 1, 30) assert t.year == 1976 assert t.month == 1 assert t.day == 30 def test_last_day_for_31_day_month(self) -> None: t = Date(1976, 1, -1) assert t.year_month_day == (1976, 1, 31) assert t.year == 1976 assert t.month == 1 assert t.day == 31 def test_last_but_1_day_for_30_day_month(self) -> None: t = Date(1976, 6, -2) assert t.year_month_day == (1976, 6, 29) assert t.year == 1976 assert t.month == 6 assert t.day == 29 def test_last_day_for_30_day_month(self) -> None: t = Date(1976, 6, -1) assert t.year_month_day == (1976, 6, 30) assert t.year == 1976 assert t.month == 6 assert t.day == 30 def test_day_28_for_29_day_month(self) -> None: t = Date(1976, 2, 28) assert t.year_month_day == (1976, 2, 28) assert t.year == 1976 assert t.month == 2 assert t.day == 28 def test_last_day_for_29_day_month(self) -> None: t = Date(1976, 2, -1) assert t.year_month_day == (1976, 2, 29) assert t.year == 1976 assert t.month == 2 assert t.day == 29 def test_last_day_for_28_day_month(self) -> None: t = Date(1977, 2, -1) assert t.year_month_day == (1977, 2, 28) assert t.year == 1977 assert t.month == 2 assert t.day == 28 def test_cannot_use_year_lower_than_one(self) -> None: with pytest.raises(ValueError): _ = Date(0, 2, 1) def test_cannot_use_year_higher_than_9999(self) -> None: with pytest.raises(ValueError): _ = Date(10000, 2, 1) def test_from_timestamp_without_tz(self) -> None: d = Date.from_timestamp(0) assert d == Date(1970, 1, 1) def test_from_timestamp_with_tz(self) -> None: d = Date.from_timestamp(0, tz=timezone_eastern) assert d == Date(1969, 12, 31) def test_utc_from_timestamp(self) -> None: d = Date.utc_from_timestamp(0) assert d == Date(1970, 1, 1) def test_from_ordinal(self) -> None: d = Date.from_ordinal(1) assert d == Date(1, 1, 1) def test_parse(self) -> None: d = Date.parse("2018-04-30") assert d == Date(2018, 4, 30) def test_bad_parse_1(self) -> None: with pytest.raises(ValueError): _ = Date.parse("30 April 2018") def test_bad_parse_2(self) -> None: with pytest.raises(ValueError): _ = Date.parse("2018-04") def test_bad_parse_3(self) -> None: with pytest.raises(ValueError): _ = Date.parse(object()) # type: ignore[arg-type] def test_replace(self) -> None: d1 = Date(2018, 4, 30) d2 = d1.replace(year=2017) assert d2 == Date(2017, 4, 30) def test_from_clock_time(self) -> None: d = Date.from_clock_time((0, 0), epoch=UnixEpoch) assert d == Date(1970, 1, 1) def test_bad_from_clock_time(self) -> None: with pytest.raises(ValueError): _ = Date.from_clock_time(object(), None) # type: ignore[arg-type] def test_is_leap_year(self) -> None: assert Date.is_leap_year(2000) assert not Date.is_leap_year(2001) def test_days_in_year(self) -> None: assert Date.days_in_year(2000) == 366 assert Date.days_in_year(2001) == 365 def test_days_in_month(self) -> None: assert Date.days_in_month(2000, 1) == 31 assert Date.days_in_month(2000, 2) == 29 assert Date.days_in_month(2001, 2) == 28 def test_instance_attributes(self) -> None: d = Date(2018, 4, 30) assert d.year == 2018 assert d.month == 4 assert d.day == 30 assert d.year_month_day == (2018, 4, 30) assert d.year_week_day == (2018, 18, 1) assert d.year_day == (2018, 120) def test_can_add_years(self) -> None: d1 = Date(1976, 6, 13) d2 = d1 + Duration(years=2) assert d2 == Date(1978, 6, 13) def test_can_add_negative_years(self) -> None: d1 = Date(1976, 6, 13) d2 = d1 + Duration(years=-2) assert d2 == Date(1974, 6, 13) def test_can_add_years_and_months(self) -> None: d1 = Date(1976, 6, 13) d2 = d1 + Duration(years=2, months=3) assert d2 == Date(1978, 9, 13) def test_can_add_negative_years_and_months(self) -> None: d1 = Date(1976, 6, 13) d2 = d1 + Duration(years=-2, months=-3) assert d2 == Date(1974, 3, 13) def test_can_retain_offset_from_end_of_month(self) -> None: d = Date(1976, 1, -1) assert d == Date(1976, 1, 31) d += Duration(months=1) assert d == Date(1976, 2, 29) d += Duration(months=1) assert d == Date(1976, 3, 31) d += Duration(months=1) assert d == Date(1976, 4, 30) d += Duration(months=1) assert d == Date(1976, 5, 31) d += Duration(months=1) assert d == Date(1976, 6, 30) def test_can_roll_over_end_of_year(self) -> None: d = Date(1976, 12, 1) assert d == Date(1976, 12, 1) d += Duration(months=1) assert d == Date(1977, 1, 1) def test_can_add_months_and_days(self) -> None: d1 = Date(1976, 6, 13) d2 = d1 + Duration(months=1, days=1) assert d2 == Date(1976, 7, 14) def test_can_add_months_then_days(self) -> None: d1 = Date(1976, 6, 13) d2 = d1 + Duration(months=1) + Duration(days=1) assert d2 == Date(1976, 7, 14) def test_cannot_add_seconds(self) -> None: d1 = Date(1976, 6, 13) with pytest.raises(ValueError): _ = d1 + Duration(seconds=1) def test_adding_empty_duration_returns_self(self) -> None: d1 = Date(1976, 6, 13) d2 = d1 + Duration() assert d1 is d2 def test_adding_object(self) -> None: d1 = Date(1976, 6, 13) with pytest.raises(TypeError): _ = d1 + object() # type: ignore[operator] def test_can_add_days_then_months(self) -> None: d1 = Date(1976, 6, 13) d2 = d1 + Duration(days=1) + Duration(months=1) assert d2 == Date(1976, 7, 14) def test_can_add_months_and_days_for_last_day_of_short_month(self) -> None: d1 = Date(1976, 6, 30) d2 = d1 + Duration(months=1, days=1) assert d2 == Date(1976, 8, 1) def test_can_add_months_then_days_for_last_day_of_short_month( self ) -> None: d1 = Date(1976, 6, 30) d2 = d1 + Duration(months=1) + Duration(days=1) assert d2 == Date(1976, 8, 1) def test_can_add_days_then_months_for_last_day_of_short_month( self ) -> None: d1 = Date(1976, 6, 30) d2 = d1 + Duration(days=1) + Duration(months=1) assert d2 == Date(1976, 8, 1) def test_can_add_months_and_days_for_last_day_of_long_month(self) -> None: d1 = Date(1976, 1, 31) d2 = d1 + Duration(months=1, days=1) assert d2 == Date(1976, 3, 1) def test_can_add_months_then_days_for_last_day_of_long_month(self) -> None: d1 = Date(1976, 1, 31) d2 = d1 + Duration(months=1) + Duration(days=1) assert d2 == Date(1976, 3, 1) def test_can_add_days_then_months_for_last_day_of_long_month(self) -> None: d1 = Date(1976, 1, 31) d2 = d1 + Duration(days=1) + Duration(months=1) assert d2 == Date(1976, 3, 1) def test_can_add_negative_months_and_days(self) -> None: d1 = Date(1976, 6, 13) d2 = d1 + Duration(months=-1, days=-1) assert d2 == Date(1976, 5, 12) def test_can_add_negative_months_then_days(self) -> None: d1 = Date(1976, 6, 13) d2 = d1 + Duration(months=-1) + Duration(days=-1) assert d2 == Date(1976, 5, 12) def test_can_add_negative_days_then_months(self) -> None: d1 = Date(1976, 6, 13) d2 = d1 + Duration(days=-1) + Duration(months=-1) assert d2 == Date(1976, 5, 12) def test_can_add_negative_months_and_days_for_first_day_of_month( self ) -> None: d1 = Date(1976, 6, 1) d2 = d1 + Duration(months=-1, days=-1) assert d2 == Date(1976, 4, 30) def test_can_add_negative_months_then_days_for_first_day_of_month( self ) -> None: d1 = Date(1976, 6, 1) d2 = d1 + Duration(months=-1) + Duration(days=-1) assert d2 == Date(1976, 4, 30) def test_can_add_negative_days_then_months_for_last_day_of_month( self ) -> None: d1 = Date(1976, 6, 1) d2 = d1 + Duration(days=-1) + Duration(months=-1) assert d2 == Date(1976, 4, 30) def test_can_add_negative_month_for_last_day_of_long_month(self) -> None: d1 = Date(1976, 5, 31) d2 = d1 + Duration(months=-1) assert d2 == Date(1976, 4, 30) def test_can_add_negative_month_for_january(self) -> None: d1 = Date(1976, 1, 31) d2 = d1 + Duration(months=-1) assert d2 == Date(1975, 12, 31) def test_subtract_date(self) -> None: new_year = Date(2000, 1, 1) christmas = Date(1999, 12, 25) assert new_year - christmas == Duration(days=7) def test_subtract_duration(self) -> None: new_year = Date(2000, 1, 1) christmas = Date(1999, 12, 25) assert new_year - Duration(days=7) == christmas def test_subtract_object(self) -> None: new_year = Date(2000, 1, 1) with pytest.raises(TypeError): _ = new_year - object() # type: ignore[operator] def test_date_less_than(self) -> None: new_year = Date(2000, 1, 1) christmas = Date(1999, 12, 25) assert christmas < new_year def test_date_less_than_object(self) -> None: d = Date(2000, 1, 1) with pytest.raises(TypeError): _ = d < object() # type: ignore[operator] def test_date_less_than_or_equal_to(self) -> None: new_year = Date(2000, 1, 1) christmas = Date(1999, 12, 25) assert christmas <= new_year def test_date_less_than_or_equal_to_object(self) -> None: d = Date(2000, 1, 1) with pytest.raises(TypeError): _ = d <= object() # type: ignore[operator] def test_date_greater_than_or_equal_to(self) -> None: new_year = Date(2000, 1, 1) christmas = Date(1999, 12, 25) assert new_year >= christmas def test_date_greater_than_or_equal_to_object(self) -> None: d = Date(2000, 1, 1) with pytest.raises(TypeError): _ = d >= object() # type: ignore[operator] def test_date_greater_than(self) -> None: new_year = Date(2000, 1, 1) christmas = Date(1999, 12, 25) assert new_year > christmas def test_date_greater_than_object(self) -> None: d = Date(2000, 1, 1) with pytest.raises(TypeError): _ = d > object() # type: ignore[operator] def test_date_equal(self) -> None: d1 = Date(2000, 1, 1) d2 = Date(2000, 1, 1) assert d1 == d2 def test_date_not_equal(self) -> None: d1 = Date(2000, 1, 1) d2 = Date(2000, 1, 2) assert d1 != d2 def test_date_not_equal_to_object(self) -> None: d1 = Date(2000, 1, 1) assert d1 != object() @pytest.mark.parametrize("ordinal", ( Date(2001, 1, 1).to_ordinal(), Date(2008, 1, 1).to_ordinal(), )) def test_year_week_day(self, ordinal) -> None: assert Date.from_ordinal(ordinal).iso_calendar() \ == date.fromordinal(ordinal).isocalendar() def test_time_tuple(self) -> None: d = Date(2018, 4, 30) expected = struct_time((2018, 4, 30, 0, 0, 0, 0, 120, -1)) assert d.time_tuple() == expected def test_to_clock_time(self) -> None: d = Date(2018, 4, 30) assert d.to_clock_time(UnixEpoch) == (1525046400, 0) assert d.to_clock_time(d) == (0, 0) with pytest.raises(TypeError): _ = d.to_clock_time(object()) # type: ignore[arg-type] def test_weekday(self) -> None: d = Date(2018, 4, 30) assert d.weekday() == 0 def test_iso_weekday(self) -> None: d = Date(2018, 4, 30) assert d.iso_weekday() == 1 def test_str(self) -> None: assert str(Date(2018, 4, 30)) == "2018-04-30" assert str(Date(0, 0, 0)) == "0000-00-00" def test_repr(self) -> None: assert repr(Date(2018, 4, 30)) == "neo4j.time.Date(2018, 4, 30)" assert repr(Date(0, 0, 0)) == "neo4j.time.ZeroDate" def test_from_native(self) -> None: native = date(2018, 10, 1) d = Date.from_native(native) assert d.year == native.year assert d.month == native.month assert d.day == native.day def test_to_native(self) -> None: d = Date(2018, 10, 1) native = d.to_native() assert d.year == native.year assert d.month == native.month assert d.day == native.day def test_iso_format(self) -> None: d = Date(2018, 10, 1) assert "2018-10-01" == d.iso_format() def test_from_iso_format(self) -> None: expected = Date(2018, 10, 1) actual = Date.from_iso_format("2018-10-01") assert expected == actual def test_date_copy(self) -> None: d = Date(2010, 10, 1) d2 = copy.copy(d) assert d is not d2 assert d == d2 def test_date_deep_copy(self) -> None: d = Date(2010, 10, 1) d2 = copy.deepcopy(d) assert d is not d2 assert d == d2 @pytest.mark.parametrize(("tz", "expected"), ( (None, (1970, 1, 1)), (timezone_eastern, (1970, 1, 1)), (timezone_utc, (1970, 1, 1)), (pytz.FixedOffset(-12 * 60), (1970, 1, 1)), (datetime.timezone(datetime.timedelta(hours=-12)), (1970, 1, 1)), (pytz.FixedOffset(-13 * 60), (1969, 12, 31)), (datetime.timezone(datetime.timedelta(hours=-13)), (1969, 12, 31)), (pytz.FixedOffset(11 * 60), (1970, 1, 1)), (datetime.timezone(datetime.timedelta(hours=11)), (1970, 1, 1)), (pytz.FixedOffset(12 * 60), (1970, 1, 2)), (datetime.timezone(datetime.timedelta(hours=12)), (1970, 1, 2)), )) def test_today(tz, expected) -> None: d = Date.today(tz=tz) assert isinstance(d, Date) assert d.year_month_day == expected def test_str() -> None: d = Date(2018, 4, 26) assert str(d) == "2018-04-26" def test_format() -> None: d = Date(2018, 4, 26) assert f"{d}" == "2018-04-26" assert f"{d:%Y-%m-%d}" == "2018-04-26" assert f"{d:%H:%M:%S}" == f"{date(2018, 4, 26):%H:%M:%S}" assert f"{d:%Y-%m-%d %H:%M:%S.%f}" == "2018-04-26 00:00:00.000000000" neo4j-python-driver-5.2.1/tests/unit/common/time/test_datetime.py000066400000000000000000000740401433522662700251410ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations import copy import itertools import operator from datetime import ( datetime, timedelta, timezone as datetime_timezone, ) import pytest from pytz import ( FixedOffset, timezone, utc, ) from neo4j.time import ( DateTime, Duration, MAX_YEAR, MIN_YEAR, ) from neo4j.time._arithmetic import ( nano_add, nano_div, ) from neo4j.time._clock_implementations import ClockTime timezone_us_eastern = timezone("US/Eastern") timezone_london = timezone("Europe/London") timezone_berlin = timezone("Europe/Berlin") timezone_utc = timezone("UTC") def seconds_options(seconds, nanoseconds): yield seconds, nanoseconds yield seconds + nanoseconds / 1000000000, class TestDateTime: @pytest.mark.parametrize("args", ( (0, 0, 0), (0, 0, 0, 0, 0, 0, 0) )) def test_zero(self, args) -> None: t = DateTime(*args) assert t.year == 0 assert t.month == 0 assert t.day == 0 assert t.hour == 0 assert t.minute == 0 assert t.second == 0 assert t.nanosecond == 0 def test_non_zero_naive(self) -> None: t = DateTime(2018, 4, 26, 23, 0, 17, 914390409) assert t.year == 2018 assert t.month == 4 assert t.day == 26 assert t.hour == 23 assert t.minute == 0 assert t.second == 17 assert t.nanosecond == 914390409 def test_year_lower_bound(self) -> None: with pytest.raises(ValueError): _ = DateTime(MIN_YEAR - 1, 1, 1, 0, 0, 0) def test_year_upper_bound(self) -> None: with pytest.raises(ValueError): _ = DateTime(MAX_YEAR + 1, 1, 1, 0, 0, 0) def test_month_lower_bound(self) -> None: with pytest.raises(ValueError): _ = DateTime(2000, 0, 1, 0, 0, 0) def test_month_upper_bound(self) -> None: with pytest.raises(ValueError): _ = DateTime(2000, 13, 1, 0, 0, 0) def test_day_zero(self) -> None: with pytest.raises(ValueError): _ = DateTime(2000, 1, 0, 0, 0, 0) def test_day_30_of_29_day_month(self) -> None: with pytest.raises(ValueError): _ = DateTime(2000, 2, 30, 0, 0, 0) def test_day_32_of_31_day_month(self) -> None: with pytest.raises(ValueError): _ = DateTime(2000, 3, 32, 0, 0, 0) def test_day_31_of_30_day_month(self) -> None: with pytest.raises(ValueError): _ = DateTime(2000, 4, 31, 0, 0, 0) def test_day_29_of_28_day_month(self) -> None: with pytest.raises(ValueError): _ = DateTime(1999, 2, 29, 0, 0, 0) def test_last_day_of_month(self) -> None: t = DateTime(2000, 1, -1, 0, 0, 0) assert t.year == 2000 assert t.month == 1 assert t.day == 31 def test_today(self) -> None: t = DateTime.today() assert t.year == 1970 assert t.month == 1 assert t.day == 1 assert t.hour == 12 assert t.minute == 34 assert t.second == 56 assert t.nanosecond == 789000001 def test_now_without_tz(self) -> None: t = DateTime.now() assert t.year == 1970 assert t.month == 1 assert t.day == 1 assert t.hour == 12 assert t.minute == 34 assert t.second == 56 assert t.nanosecond == 789000001 assert t.tzinfo is None def test_now_with_tz(self) -> None: t = DateTime.now(timezone_us_eastern) assert t.year == 1970 assert t.month == 1 assert t.day == 1 assert t.hour == 7 assert t.minute == 34 assert t.second == 56 assert t.nanosecond == 789000001 assert t.utcoffset() == timedelta(seconds=-18000) assert t.dst() == timedelta() assert t.tzname() == "EST" def test_now_with_utc_tz(self) -> None: t = DateTime.now(timezone_utc) assert t.year == 1970 assert t.month == 1 assert t.day == 1 assert t.hour == 12 assert t.minute == 34 assert t.second == 56 assert t.nanosecond == 789000001 assert t.utcoffset() == timedelta(seconds=0) assert t.dst() == timedelta() assert t.tzname() == "UTC" def test_utc_now(self) -> None: t = DateTime.utc_now() assert t.year == 1970 assert t.month == 1 assert t.day == 1 assert t.hour == 12 assert t.minute == 34 assert t.second == 56 assert t.nanosecond == 789000001 assert t.tzinfo is None @pytest.mark.parametrize(("tz", "expected"), ( (None, (1970, 1, 1, 0, 0, 0, 0)), (timezone_utc, (1970, 1, 1, 0, 0, 0, 0)), (datetime_timezone.utc, (1970, 1, 1, 0, 0, 0, 0)), (FixedOffset(60), (1970, 1, 1, 1, 0, 0, 0)), (datetime_timezone(timedelta(hours=1)), (1970, 1, 1, 1, 0, 0, 0)), (timezone_us_eastern, (1969, 12, 31, 19, 0, 0, 0)), )) def test_from_timestamp(self, tz, expected) -> None: t = DateTime.from_timestamp(0, tz=tz) assert t.year_month_day == expected[:3] assert t.hour_minute_second_nanosecond == expected[3:] assert str(t.tzinfo) == str(tz) def test_from_overflowing_timestamp(self) -> None: with pytest.raises(ValueError): _ = DateTime.from_timestamp(999999999999999999) def test_from_timestamp_with_tz(self) -> None: t = DateTime.from_timestamp(0, timezone_us_eastern) assert t.year == 1969 assert t.month == 12 assert t.day == 31 assert t.hour == 19 assert t.minute == 0 assert t.second == 0 assert t.nanosecond == 0 assert t.utc_offset() == timedelta(seconds=-18000) assert t.dst() == timedelta() assert t.tzname() == "EST" @pytest.mark.parametrize("seconds_args", seconds_options(17, 914390409)) def test_conversion_to_t(self, seconds_args) -> None: dt = DateTime(2018, 4, 26, 23, 0, *seconds_args) t = dt.to_clock_time() assert t, ClockTime(63660380417 == 914390409) @pytest.mark.parametrize("seconds_args1", seconds_options(17, 914390409)) @pytest.mark.parametrize("seconds_args2", seconds_options(17, 914390409)) def test_add_timedelta(self, seconds_args1, seconds_args2) -> None: dt1 = DateTime(2018, 4, 26, 23, 0, *seconds_args1) delta = timedelta(days=1) dt2 = dt1 + delta assert dt2, DateTime(2018, 4, 27, 23, 0 == seconds_args2) def test_subtract_datetime_1(self) -> None: dt1 = DateTime(2018, 4, 26, 23, 0, 17, 914390409) dt2 = DateTime(2018, 1, 1, 0, 0, 0) t = dt1 - dt2 assert t == Duration(months=3, days=25, hours=23, seconds=17.914390409) assert t == Duration(months=3, days=25, hours=23, seconds=17, nanoseconds=914390409) def test_subtract_datetime_2(self) -> None: dt1 = DateTime(2018, 4, 1, 23, 0, 17, 914390409) dt2 = DateTime(2018, 1, 26, 0, 0, 0) t = dt1 - dt2 assert t == Duration(months=3, days=-25, hours=23, seconds=17.914390409) assert t == Duration(months=3, days=-25, hours=23, seconds=17, nanoseconds=914390409) def test_subtract_native_datetime_1(self) -> None: dt1 = DateTime(2018, 4, 26, 23, 0, 17, 914390409) dt2 = datetime(2018, 1, 1, 0, 0, 0) t = dt1 - dt2 assert t == timedelta(days=115, hours=23, seconds=17.914390409) def test_subtract_native_datetime_2(self) -> None: dt1 = DateTime(2018, 4, 1, 23, 0, 17, 914390409) dt2 = datetime(2018, 1, 26, 0, 0, 0) t = dt1 - dt2 assert t == timedelta(days=65, hours=23, seconds=17.914390409) def test_normalization(self) -> None: ndt1 = timezone_us_eastern.normalize( DateTime(2018, 4, 27, 23, 0, 17, tzinfo=timezone_us_eastern) ) ndt2 = timezone_us_eastern.normalize( datetime(2018, 4, 27, 23, 0, 17, tzinfo=timezone_us_eastern) ) assert ndt1 == ndt2 def test_localization(self) -> None: ldt1 = timezone_us_eastern.localize(datetime(2018, 4, 27, 23, 0, 17)) ldt2 = timezone_us_eastern.localize(DateTime(2018, 4, 27, 23, 0, 17)) assert ldt1 == ldt2 def test_from_native(self) -> None: native = datetime(2018, 10, 1, 12, 34, 56, 789123) dt = DateTime.from_native(native) assert dt.year == native.year assert dt.month == native.month assert dt.day == native.day assert dt.hour == native.hour assert dt.minute == native.minute assert dt.second == native.second assert dt.nanosecond == native.microsecond * 1000 def test_to_native(self) -> None: dt = DateTime(2018, 10, 1, 12, 34, 56, 789123456) native = dt.to_native() assert dt.year == native.year assert dt.month == native.month assert dt.day == native.day assert dt.hour == native.hour assert dt.minute == native.minute assert dt.second == native.second assert dt.nanosecond // 1000 == native.microsecond @pytest.mark.parametrize(("dt", "expected"), ( ( DateTime(2018, 10, 1, 12, 34, 56, 789123456), "2018-10-01T12:34:56.789123456" ), ( datetime(2018, 10, 1, 12, 34, 56, 789123), "2018-10-01T12:34:56.789123" ), ( DateTime(2018, 10, 1, 12, 34, 56, 789000000), "2018-10-01T12:34:56.789000000" ), ( datetime(2018, 10, 1, 12, 34, 56, 789000), "2018-10-01T12:34:56.789000" ), ( timezone_us_eastern.localize( DateTime(2018, 10, 1, 12, 34, 56, 789123456) ), "2018-10-01T12:34:56.789123456-04:00" ), ( timezone_us_eastern.localize( datetime(2018, 10, 1, 12, 34, 56, 789123) ), "2018-10-01T12:34:56.789123-04:00" ), ( timezone_us_eastern.localize( DateTime(2018, 10, 1, 12, 34, 56, 789000000) ), "2018-10-01T12:34:56.789000000-04:00" ), ( timezone_us_eastern.localize( datetime(2018, 10, 1, 12, 34, 56, 789000) ), "2018-10-01T12:34:56.789000-04:00" ), ( utc.localize(DateTime(2018, 10, 1, 12, 34, 56, 789123456)), "2018-10-01T12:34:56.789123456+00:00" ), ( utc.localize(datetime(2018, 10, 1, 12, 34, 56, 789123)), "2018-10-01T12:34:56.789123+00:00" ), )) def test_iso_format(self, dt, expected) -> None: assert dt.isoformat() == expected def test_from_iso_format_hour_only(self) -> None: expected = DateTime(2018, 10, 1, 12, 0, 0) actual = DateTime.from_iso_format("2018-10-01T12") assert expected == actual def test_from_iso_format_hour_and_minute(self) -> None: expected = DateTime(2018, 10, 1, 12, 34, 0) actual = DateTime.from_iso_format("2018-10-01T12:34") assert expected == actual def test_from_iso_format_hour_minute_second(self) -> None: expected = DateTime(2018, 10, 1, 12, 34, 56) actual = DateTime.from_iso_format("2018-10-01T12:34:56") assert expected == actual def test_from_iso_format_hour_minute_second_milliseconds(self) -> None: expected = DateTime(2018, 10, 1, 12, 34, 56, 123000000) actual = DateTime.from_iso_format("2018-10-01T12:34:56.123") assert expected == actual def test_from_iso_format_hour_minute_second_microseconds(self) -> None: expected = DateTime(2018, 10, 1, 12, 34, 56, 123456000) actual = DateTime.from_iso_format("2018-10-01T12:34:56.123456") assert expected == actual def test_from_iso_format_hour_minute_second_nanosecond(self) -> None: expected = DateTime(2018, 10, 1, 12, 34, 56, 123456789) actual = DateTime.from_iso_format("2018-10-01T12:34:56.123456789") assert expected == actual def test_from_iso_format_with_positive_tz(self) -> None: expected = DateTime(2018, 10, 1, 12, 34, 56, 123456789, tzinfo=FixedOffset(754)) actual = DateTime.from_iso_format("2018-10-01T12:34:56.123456789+12:34") assert expected == actual def test_from_iso_format_with_negative_tz(self) -> None: expected = DateTime(2018, 10, 1, 12, 34, 56, 123456789, tzinfo=FixedOffset(-754)) actual = DateTime.from_iso_format("2018-10-01T12:34:56.123456789-12:34") assert expected == actual def test_from_iso_format_with_positive_long_tz(self) -> None: expected = DateTime(2018, 10, 1, 12, 34, 56, 123456789, tzinfo=FixedOffset(754)) actual = DateTime.from_iso_format("2018-10-01T12:34:56.123456789+12:34:56.123456") assert expected == actual def test_from_iso_format_with_negative_long_tz(self) -> None: expected = DateTime(2018, 10, 1, 12, 34, 56, 123456789, tzinfo=FixedOffset(-754)) actual = DateTime.from_iso_format("2018-10-01T12:34:56.123456789-12:34:56.123456") assert expected == actual def test_datetime_copy(self) -> None: d = DateTime(2010, 10, 1, 10, 0, 10) d2 = copy.copy(d) assert d is not d2 assert d == d2 def test_datetime_deep_copy(self) -> None: d = DateTime(2010, 10, 1, 10, 0, 12) d2 = copy.deepcopy(d) assert d is not d2 assert d == d2 def test_iso_format_with_time_zone_case_1() -> None: # python -m pytest tests/unit/time/test_datetime.py -s -v -k test_iso_format_with_time_zone_case_1 expected = DateTime(2019, 10, 30, 7, 54, 2, 129790999, tzinfo=timezone_utc) assert expected.iso_format() == "2019-10-30T07:54:02.129790999+00:00" assert expected.tzinfo == FixedOffset(0) actual = DateTime.from_iso_format("2019-10-30T07:54:02.129790999+00:00") assert expected == actual def test_iso_format_with_time_zone_case_2() -> None: # python -m pytest tests/unit/time/test_datetime.py -s -v -k test_iso_format_with_time_zone_case_2 expected = DateTime.from_iso_format("2019-10-30T07:54:02.129790999+01:00") assert expected.tzinfo == FixedOffset(60) assert expected.iso_format() == "2019-10-30T07:54:02.129790999+01:00" def test_to_native_case_1() -> None: # python -m pytest tests/unit/time/test_datetime.py -s -v -k test_to_native_case_1 dt = DateTime.from_iso_format("2019-10-30T12:34:56.789123456") native = dt.to_native() assert native.hour == dt.hour assert native.minute == dt.minute assert nano_add(native.second, nano_div(native.microsecond, 1000000)) == 56.789123 assert native.tzinfo is None assert native.isoformat() == "2019-10-30T12:34:56.789123" def test_to_native_case_2() -> None: # python -m pytest tests/unit/time/test_datetime.py -s -v -k test_to_native_case_2 dt = DateTime.from_iso_format("2019-10-30T12:34:56.789123456+00:00") native = dt.to_native() assert native.hour == dt.hour assert native.minute == dt.minute assert nano_add(native.second, nano_div(native.microsecond, 1000000)) == 56.789123 assert native.tzinfo == FixedOffset(0) assert native.isoformat() == "2019-10-30T12:34:56.789123+00:00" def test_to_native_case_3() -> None: # python -m pytest tests/unit/time/test_datetime.py -s -v -k test_to_native_case_3 timestamp = "2021-04-06T00:00:00.500006+00:00" neo4j_datetime = DateTime.from_iso_format(timestamp) native_from_neo4j = neo4j_datetime.to_native() native_from_datetime = datetime(2021, 4, 6, 0, 0, 0, 500006, tzinfo=timezone_utc) assert neo4j_datetime == native_from_datetime assert native_from_neo4j == native_from_datetime def test_from_native_case_1() -> None: # python -m pytest tests/unit/time/test_datetime.py -s -v -k test_from_native_case_1 native = datetime(2018, 10, 1, 12, 34, 56, 789123) dt = DateTime.from_native(native) assert dt.year == native.year assert dt.month == native.month assert dt.day == native.day assert dt.hour == native.hour assert dt.minute == native.minute assert dt.second == native.second assert dt.nanosecond == native.microsecond * 1000 assert dt.tzinfo is None def test_from_native_case_2() -> None: # python -m pytest tests/unit/time/test_datetime.py -s -v -k test_from_native_case_2 native = datetime(2018, 10, 1, 12, 34, 56, 789123, FixedOffset(0)) dt = DateTime.from_native(native) assert dt.year == native.year assert dt.month == native.month assert dt.day == native.day assert dt.hour == native.hour assert dt.minute == native.minute assert dt.second == native.second assert dt.nanosecond == native.microsecond * 1000 assert dt.tzinfo == FixedOffset(0) @pytest.mark.parametrize("datetime_cls", (DateTime, datetime)) def test_transition_to_summertime(datetime_cls) -> None: dt = datetime_cls(2022, 3, 27, 1, 30) dt = timezone_berlin.localize(dt) assert dt.utcoffset() == timedelta(hours=1) assert isinstance(dt, datetime_cls) time = dt.time() assert (time.hour, time.minute) == (1, 30) dt += timedelta(hours=1) # The native datetime object just bluntly carries over the timezone. You'd # have to manually convert to UTC, do the calculation, and then convert # back. Not pretty, but we should make sure our implementation does assert dt.utcoffset() == timedelta(hours=1) assert isinstance(dt, datetime_cls) time = dt.time() assert (time.hour, time.minute) == (2, 30) @pytest.mark.parametrize("datetime_cls", (DateTime, datetime)) @pytest.mark.parametrize("utc_impl", ( utc, datetime_timezone(timedelta(0)), )) @pytest.mark.parametrize("tz", ( timezone_berlin, datetime_timezone(timedelta(hours=-1)) )) def test_transition_to_summertime_in_utc_space(datetime_cls, utc_impl, tz) -> None: if datetime_cls == DateTime: dt = datetime_cls(2022, 3, 27, 1, 30, 1, 123456789) else: dt = datetime_cls(2022, 3, 27, 1, 30, 1, 123456) dt = timezone_berlin.localize(dt) assert isinstance(dt, datetime_cls) assert dt.utcoffset() == timedelta(hours=1) time = dt.time() assert (time.hour, time.minute, time.second) == (1, 30, 1) if datetime_cls == DateTime: assert time.nanosecond == 123456789 else: assert time.microsecond == 123456 dt = dt.astimezone(utc_impl) assert isinstance(dt, datetime_cls) assert dt.utcoffset() == timedelta(0) time = dt.time() assert (time.hour, time.minute) == (0, 30) dt += timedelta(hours=1) assert isinstance(dt, datetime_cls) assert dt.utcoffset() == timedelta(0) time = dt.time() assert (time.hour, time.minute) == (1, 30) dt = dt.astimezone(timezone_berlin) assert isinstance(dt, datetime_cls) assert dt.utcoffset() == timedelta(hours=2) time = dt.time() assert (time.hour, time.minute) == (3, 30) if datetime_cls == DateTime: assert time.nanosecond == 123456789 else: assert time.microsecond == 123456 @pytest.mark.parametrize(("dt1", "dt2"), ( ( datetime(2022, 11, 25, 12, 34, 56, 789123), DateTime(2022, 11, 25, 12, 34, 56, 789123000) ), ( DateTime(2022, 11, 25, 12, 34, 56, 789123456), DateTime(2022, 11, 25, 12, 34, 56, 789123456) ), ( datetime(2022, 11, 25, 12, 34, 56, 789123, FixedOffset(1)), DateTime(2022, 11, 25, 12, 34, 56, 789123000, FixedOffset(1)) ), ( datetime(2022, 11, 25, 12, 34, 56, 789123, FixedOffset(-1)), DateTime(2022, 11, 25, 12, 34, 56, 789123000, FixedOffset(-1)) ), ( DateTime(2022, 11, 25, 12, 34, 56, 789123456, FixedOffset(1)), DateTime(2022, 11, 25, 12, 34, 56, 789123456, FixedOffset(1)) ), ( DateTime(2022, 11, 25, 12, 34, 56, 789123456, FixedOffset(-1)), DateTime(2022, 11, 25, 12, 34, 56, 789123456, FixedOffset(-1)) ), ( DateTime(2022, 11, 25, 12, 35, 56, 789123456, FixedOffset(1)), DateTime(2022, 11, 25, 12, 34, 56, 789123456, FixedOffset(0)) ), ( # Not testing our library directly, but asserting that Python's # datetime implementation is aligned with ours. datetime(2022, 11, 25, 12, 35, 56, 789123, FixedOffset(1)), datetime(2022, 11, 25, 12, 34, 56, 789123, FixedOffset(0)) ), ( datetime(2022, 11, 25, 12, 35, 56, 789123, FixedOffset(1)), DateTime(2022, 11, 25, 12, 34, 56, 789123000, FixedOffset(0)) ), ( DateTime(2022, 11, 25, 12, 35, 56, 789123123, FixedOffset(1)), DateTime(2022, 11, 25, 12, 34, 56, 789123123, FixedOffset(0)) ), ( timezone_london.localize(datetime(2022, 11, 25, 12, 34, 56, 789123)), timezone_berlin.localize(datetime(2022, 11, 25, 13, 34, 56, 789123)) ), ( timezone_london.localize(datetime(2022, 11, 25, 12, 34, 56, 789123)), timezone_berlin.localize(DateTime(2022, 11, 25, 13, 34, 56, 789123000)) ), ( timezone_london.localize(DateTime(2022, 1, 25, 12, 34, 56, 789123123)), timezone_berlin.localize(DateTime(2022, 1, 25, 13, 34, 56, 789123123)) ), )) def test_equality(dt1, dt2) -> None: assert dt1 == dt2 assert dt2 == dt1 assert dt1 <= dt2 assert dt2 <= dt1 assert dt1 >= dt2 assert dt2 >= dt1 @pytest.mark.parametrize(("dt1", "dt2"), ( ( datetime(2022, 11, 25, 12, 34, 56, 789123), DateTime(2022, 11, 25, 12, 34, 56, 789123001) ), ( datetime(2022, 11, 25, 12, 34, 56, 789123), DateTime(2022, 11, 25, 12, 34, 56, 789124000) ), ( datetime(2022, 11, 25, 12, 34, 56, 789123), DateTime(2022, 11, 25, 12, 34, 57, 789123000) ), ( datetime(2022, 11, 25, 12, 34, 56, 789123), DateTime(2022, 11, 25, 12, 35, 56, 789123000) ), ( datetime(2022, 11, 25, 12, 34, 56, 789123), DateTime(2022, 11, 25, 13, 34, 56, 789123000) ), ( DateTime(2022, 11, 25, 12, 34, 56, 789123456), DateTime(2022, 11, 25, 12, 34, 56, 789123450) ), ( DateTime(2022, 11, 25, 12, 34, 56, 789123456), DateTime(2022, 11, 25, 12, 34, 57, 789123456) ), ( DateTime(2022, 11, 25, 12, 34, 56, 789123456), DateTime(2022, 11, 25, 12, 35, 56, 789123456) ), ( DateTime(2022, 11, 25, 12, 34, 56, 789123456), DateTime(2022, 11, 25, 13, 34, 56, 789123456) ), ( datetime(2022, 11, 25, 12, 34, 56, 789123, FixedOffset(2)), DateTime(2022, 11, 25, 12, 34, 56, 789123000, FixedOffset(1)) ), ( datetime(2022, 11, 25, 12, 34, 56, 789123, FixedOffset(-2)), DateTime(2022, 11, 25, 12, 34, 56, 789123000, FixedOffset(-1)) ), ( datetime(2022, 11, 25, 12, 34, 56, 789123), DateTime(2022, 11, 25, 12, 34, 56, 789123000, FixedOffset(0)) ), ( DateTime(2022, 11, 25, 12, 34, 56, 789123456, FixedOffset(2)), DateTime(2022, 11, 25, 12, 34, 56, 789123456, FixedOffset(1)) ), ( DateTime(2022, 11, 25, 12, 34, 56, 789123456, FixedOffset(-2)), DateTime(2022, 11, 25, 12, 34, 56, 789123456, FixedOffset(-1)) ), ( DateTime(2022, 11, 25, 12, 34, 56, 789123456), DateTime(2022, 11, 25, 12, 34, 56, 789123456, FixedOffset(0)) ), ( DateTime(2022, 11, 25, 13, 34, 56, 789123456, FixedOffset(1)), DateTime(2022, 11, 25, 12, 34, 56, 789123456, FixedOffset(0)) ), ( DateTime(2022, 11, 25, 11, 34, 56, 789123456, FixedOffset(1)), DateTime(2022, 11, 25, 12, 34, 56, 789123456, FixedOffset(0)) ), )) def test_inequality(dt1, dt2) -> None: assert dt1 != dt2 assert dt2 != dt1 @pytest.mark.parametrize( ("dt1", "dt2"), itertools.product( ( datetime(2022, 11, 25, 12, 34, 56, 789123), DateTime(2022, 11, 25, 12, 34, 56, 789123000), datetime(2022, 11, 25, 12, 34, 56, 789123, FixedOffset(0)), DateTime(2022, 11, 25, 12, 34, 56, 789123456, FixedOffset(0)), datetime(2022, 11, 25, 12, 35, 56, 789123, FixedOffset(1)), DateTime(2022, 11, 25, 12, 35, 56, 789123456, FixedOffset(1)), datetime(2022, 11, 25, 12, 34, 56, 789123, FixedOffset(-1)), DateTime(2022, 11, 25, 12, 34, 56, 789123456, FixedOffset(-1)), datetime(2022, 11, 25, 12, 34, 56, 789123, FixedOffset(60 * -16)), DateTime(2022, 11, 25, 12, 34, 56, 789123000, FixedOffset(60 * -16)), datetime(2022, 11, 25, 11, 34, 56, 789123, FixedOffset(60 * -17)), DateTime(2022, 11, 25, 11, 34, 56, 789123000, FixedOffset(60 * -17)), DateTime(2022, 11, 25, 12, 34, 56, 789123456, FixedOffset(60 * -16)), DateTime(2022, 11, 25, 11, 34, 56, 789123456, FixedOffset(60 * -17)), ), repeat=2 ) ) def test_hashed_equality(dt1, dt2) -> None: if dt1 == dt2: s = {dt1} assert dt1 in s assert dt2 in s s = {dt2} assert dt1 in s assert dt2 in s else: s = {dt1} assert dt1 in s assert dt2 not in s s = {dt2} assert dt1 not in s assert dt2 in s @pytest.mark.parametrize(("dt1", "dt2"), ( itertools.product( ( datetime(2022, 11, 25, 12, 34, 56, 789123), DateTime(2022, 11, 25, 12, 34, 56, 789123000), DateTime(2022, 11, 25, 12, 34, 56, 789123001), ), repeat=2 ) )) @pytest.mark.parametrize("tz", ( FixedOffset(0), FixedOffset(1), FixedOffset(-1), utc, )) @pytest.mark.parametrize("op", ( operator.lt, operator.le, operator.gt, operator.ge, )) def test_comparison_with_only_one_naive_fails(dt1, dt2, tz, op) -> None: dt1 = dt1.replace(tzinfo=tz) with pytest.raises(TypeError, match="naive"): op(dt1, dt2) @pytest.mark.parametrize( ("dt1", "dt2"), itertools.product( ( datetime(2022, 11, 25, 12, 34, 56, 789123), DateTime(2022, 11, 25, 12, 34, 56, 789123000), DateTime(2022, 11, 25, 12, 34, 56, 789123001), ), repeat=2 ) ) @pytest.mark.parametrize("tz", ( timezone("Europe/Paris"), timezone("Europe/Berlin"), )) @pytest.mark.parametrize("op", ( operator.lt, operator.le, operator.gt, operator.ge, )) def test_comparison_with_one_naive_and_not_fixed_tz(dt1, dt2, tz, op) -> None: dt1tz = tz.localize(dt1) with pytest.raises(TypeError, match="naive"): op(dt1tz, dt2) @pytest.mark.parametrize(("dt1", "dt2"), ( ( datetime(2022, 11, 25, 12, 34, 56, 789123), datetime(2022, 11, 25, 12, 34, 56, 789124) ), ( DateTime(2022, 11, 25, 12, 34, 56, 789123000), datetime(2022, 11, 25, 12, 34, 56, 789124) ), ( datetime(2022, 11, 25, 12, 34, 56, 789123), DateTime(2022, 11, 25, 12, 34, 56, 789124000) ), ( DateTime(2022, 11, 25, 12, 34, 56, 789123000), DateTime(2022, 11, 25, 12, 34, 56, 789124000) ), ( datetime(2022, 11, 24, 12, 34, 56, 789123), datetime(2022, 11, 25, 12, 34, 56, 789123) ), ( datetime(2022, 11, 24, 12, 34, 56, 789123), DateTime(2022, 11, 25, 12, 34, 56, 789123000) ), ( DateTime(2022, 11, 24, 12, 34, 56, 789123123), DateTime(2022, 11, 25, 12, 34, 56, 789123123) ), ( datetime(2022, 11, 24, 12, 34, 57, 789123), datetime(2022, 11, 25, 12, 34, 56, 789123) ), ( datetime(2022, 11, 24, 12, 34, 57, 789123), DateTime(2022, 11, 25, 12, 34, 56, 789123000) ), ( DateTime(2022, 11, 24, 12, 34, 57, 789123123), DateTime(2022, 11, 25, 12, 34, 56, 789123123) ), ( datetime(2022, 11, 25, 12, 34, 56, 789123, FixedOffset(1)), datetime(2022, 11, 25, 12, 34, 56, 789124, FixedOffset(1)), ), ( DateTime(2022, 11, 25, 12, 34, 56, 789123000, FixedOffset(1)), datetime(2022, 11, 25, 12, 34, 56, 789124, FixedOffset(1)), ), ( DateTime(2022, 11, 25, 12, 34, 56, 789123000, FixedOffset(1)), DateTime(2022, 11, 25, 12, 34, 56, 789124000, FixedOffset(1)), ), ( DateTime(2022, 11, 25, 12, 34, 56, 789123000, FixedOffset(1)), DateTime(2022, 11, 25, 12, 34, 56, 789123001, FixedOffset(1)), ), ( datetime(2022, 11, 25, 12, 36, 56, 789123, FixedOffset(1)), datetime(2022, 11, 25, 12, 34, 56, 789124, FixedOffset(-1)), ), ( DateTime(2022, 11, 25, 12, 36, 56, 789123000, FixedOffset(1)), datetime(2022, 11, 25, 12, 34, 56, 789124, FixedOffset(-1)), ), ( DateTime(2022, 11, 25, 12, 36, 56, 789123000, FixedOffset(1)), DateTime(2022, 11, 25, 12, 34, 56, 789124000, FixedOffset(-1)), ), ( DateTime(2022, 11, 25, 12, 36, 56, 789123000, FixedOffset(1)), DateTime(2022, 11, 25, 12, 34, 56, 789123001, FixedOffset(-1)), ), )) def test_comparison(dt1, dt2) -> None: assert dt1 < dt2 assert not dt2 < dt1 assert dt1 <= dt2 assert not dt2 <= dt1 assert dt2 > dt1 assert not dt1 > dt2 assert dt2 >= dt1 assert not dt1 >= dt2 def test_str() -> None: dt = DateTime(2018, 4, 26, 23, 0, 17, 914390409) assert str(dt) == "2018-04-26T23:00:17.914390409" def test_format() -> None: dt = DateTime(2018, 4, 26, 23, 0, 17, 914390409) assert f"{dt}" == "2018-04-26T23:00:17.914390409" assert f"{dt:%Y-%m-%d %H:%M:%S.%f}" == "2018-04-26 23:00:17.914390409" neo4j-python-driver-5.2.1/tests/unit/common/time/test_duration.py000066400000000000000000000514701433522662700251740ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations import copy from datetime import timedelta import pytest from neo4j import time from neo4j.time import Duration class TestDuration: def test_zero(self) -> None: d = Duration() assert d.months == 0 assert d.days == 0 assert d.seconds == 0 assert d.nanoseconds == 0 assert d.years_months_days == (0, 0, 0) assert d.hours_minutes_seconds_nanoseconds == (0, 0, 0, 0) assert not bool(d) def test_years_only(self) -> None: d = Duration(years=2) assert d.months == 24 assert d.days == 0 assert d.seconds == 0 assert d.nanoseconds == 0 assert d.years_months_days == (2, 0, 0) assert d.hours_minutes_seconds_nanoseconds == (0, 0, 0, 0) assert bool(d) def test_months_only(self) -> None: d = Duration(months=20) assert d.months == 20 assert d.days == 0 assert d.seconds == 0 assert d.nanoseconds == 0 assert d.years_months_days == (1, 8, 0) assert d.hours_minutes_seconds_nanoseconds == (0, 0, 0, 0) assert bool(d) def test_months_out_of_range(self) -> None: with pytest.raises(ValueError): _ = Duration(months=(2**64)) def test_weeks_only(self) -> None: d = Duration(weeks=4) assert d.months == 0 assert d.days == 28 assert d.seconds == 0 assert d.nanoseconds == 0 assert d.years_months_days == (0, 0, 28) assert d.hours_minutes_seconds_nanoseconds == (0, 0, 0, 0) assert bool(d) def test_days_only(self) -> None: d = Duration(days=40) assert d.months == 0 assert d.days == 40 assert d.seconds == 0 assert d.nanoseconds == 0 assert d.years_months_days == (0, 0, 40) assert d.hours_minutes_seconds_nanoseconds == (0, 0, 0, 0) assert bool(d) def test_days_out_of_range(self) -> None: with pytest.raises(ValueError): _ = Duration(days=(2**64)) def test_hours_only(self) -> None: d = Duration(hours=10) assert d.months == 0 assert d.days == 0 assert d.seconds == 36000 assert d.nanoseconds == 0 assert d.years_months_days == (0, 0, 0) assert d.hours_minutes_seconds_nanoseconds == (10, 0, 0, 0) assert bool(d) def test_minutes_only(self) -> None: d = Duration(minutes=90.5) assert d.months == 0 assert d.days == 0 assert d.seconds == 5430 assert d.nanoseconds == 0 assert d.years_months_days == (0, 0, 0) assert d.hours_minutes_seconds_nanoseconds == (1, 30, 30, 0) assert bool(d) def test_seconds_only(self) -> None: d = Duration(seconds=123, nanoseconds=456000000) assert d.months == 0 assert d.days == 0 assert d.seconds == 123 assert d.nanoseconds == 456000000 assert d.years_months_days == (0, 0, 0) assert d.hours_minutes_seconds_nanoseconds == (0, 2, 3, 456000000) assert bool(d) def test_seconds_out_of_range(self) -> None: with pytest.raises(ValueError): _ = Duration(seconds=(2**64)) def test_milliseconds_only(self) -> None: d = Duration(milliseconds=1234.567) assert d.months == 0 assert d.days == 0 assert d.seconds == 1 assert d.nanoseconds == 234567000 assert d.years_months_days == (0, 0, 0) assert d.hours_minutes_seconds_nanoseconds == (0, 0, 1, 234567000) assert bool(d) def test_microseconds_only(self) -> None: d = Duration(microseconds=1234.567) assert d.months == 0 assert d.days == 0 assert d.seconds == 0 assert d.nanoseconds == 1234567 assert d.years_months_days == (0, 0, 0) assert d.hours_minutes_seconds_nanoseconds == (0, 0, 0, 1234567) assert bool(d) def test_nanoseconds_only(self) -> None: d = Duration(nanoseconds=1234.567) assert d.months == 0 assert d.days == 0 assert d.seconds == 0 assert d.nanoseconds == 1234 assert d.years_months_days == (0, 0, 0) assert d.hours_minutes_seconds_nanoseconds == (0, 0, 0, 1234) assert bool(d) def test_can_combine_years_months(self) -> None: t = Duration(years=5, months=3) assert t.months == 63 def test_can_combine_weeks_and_days(self) -> None: t = Duration(weeks=5, days=3) assert t.days == 38 def test_can_combine_hours_minutes_seconds(self) -> None: t = Duration(hours=5, minutes=4, seconds=3) assert t.seconds == 18243 def test_can_combine_seconds_and_nanoseconds(self) -> None: t = Duration(seconds=123.456, nanoseconds=321000000) assert t.seconds == 123 assert t.nanoseconds == 777000000 assert t == Duration(seconds=123, nanoseconds=777000000) assert t == Duration(seconds=123.777) def test_full_positive(self) -> None: d = Duration(years=1, months=2, days=3, hours=4, minutes=5, seconds=6.789) assert d.months == 14 assert d.days == 3 assert d.seconds == 14706 assert d.nanoseconds == 789000000 assert d.years_months_days == (1, 2, 3) assert d.hours_minutes_seconds_nanoseconds == (4, 5, 6, 789000000) assert bool(d) def test_full_negative(self) -> None: d = Duration(years=-1, months=-2, days=-3, hours=-4, minutes=-5, seconds=-6.789) assert d.months == -14 assert d.days == -3 assert d.seconds == -14706 assert d.nanoseconds == -789000000 assert d.years_months_days == (-1, -2, -3) assert d.hours_minutes_seconds_nanoseconds == (-4, -5, -6, -789000000) assert bool(d) def test_negative_positive(self) -> None: d = Duration(years=-1, months=-2, days=3, hours=-4, minutes=-5, seconds=-6.789) assert d.months == -14 assert d.days == 3 assert d.seconds == -14706 assert d.nanoseconds == -789000000 assert d.years_months_days == (-1, -2, 3) assert d.hours_minutes_seconds_nanoseconds == (-4, -5, -6, -789000000) def test_positive_negative(self) -> None: d = Duration(years=1, months=2, days=-3, hours=4, minutes=5, seconds=6.789) assert d.months == 14 assert d.days == -3 assert d.seconds == 14706 assert d.nanoseconds == 789000000 assert d.years_months_days == (1, 2, -3) assert d.hours_minutes_seconds_nanoseconds == (4, 5, 6, 789000000) def test_add_duration(self) -> None: d1 = Duration(months=2, days=3, seconds=5, nanoseconds=700000000) d2 = Duration(months=7, days=5, seconds=3, nanoseconds=200000000) d3 = Duration(months=9, days=8, seconds=8, nanoseconds=900000000) assert d1 + d2 == d3 def test_add_timedelta(self) -> None: d1 = Duration(months=2, days=3, seconds=5, nanoseconds=700000000) td = timedelta(days=5, seconds=3.2) d3 = Duration(months=2, days=8, seconds=8, nanoseconds=900000000) assert d1 + td == d3 def test_add_object(self) -> None: with pytest.raises(TypeError): _ = (Duration(months=2, days=3, seconds=5.7) + object()) # type: ignore[operator] def test_subtract_duration(self) -> None: d1 = Duration(months=2, days=3, seconds=5, nanoseconds=700000000) d2 = Duration(months=7, days=5, seconds=3, nanoseconds=200000000) d3 = Duration(months=-5, days=-2, seconds=2, nanoseconds=500000000) assert d1 - d2 == d3 def test_subtract_timedelta(self) -> None: d1 = Duration(months=2, days=3, seconds=5, nanoseconds=700000000) td = timedelta(days=5, seconds=3.2) d3 = Duration(months=2, days=-2, seconds=2, nanoseconds=500000000) assert d1 - td == d3 def test_subtract_object(self) -> None: with pytest.raises(TypeError): _ = (Duration(months=2, days=3, seconds=5.7) - object()) # type: ignore[operator] def test_multiplication_by_int(self) -> None: d1 = Duration(months=2, days=3, seconds=5.7) i = 11 assert d1 * i == Duration(months=22, days=33, seconds=62.7) def test_multiplication_by_float(self) -> None: d1 = Duration(months=2, days=3, seconds=5.7) f = 5.5 assert d1 * f == Duration(months=11, days=16, seconds=31.35) def test_multiplication_by_object(self) -> None: with pytest.raises(TypeError): _ = (Duration(months=2, days=3, seconds=5.7) * object()) # type: ignore[operator] @pytest.mark.parametrize("ns", (0, 1)) def test_floor_division_by_int(self, ns) -> None: d1 = Duration(months=11, days=33, seconds=55.77, nanoseconds=ns) i = 2 assert d1 // i == Duration(months=5, days=16, seconds=27, nanoseconds=885000000) def test_floor_division_by_object(self) -> None: with pytest.raises(TypeError): _ = (Duration(months=2, days=3, seconds=5.7) // object()) # type: ignore[operator] @pytest.mark.parametrize("ns", (0, 1)) def test_modulus_by_int(self, ns) -> None: d1 = Duration(months=11, days=33, seconds=55.77, nanoseconds=ns) i = 2 assert d1 % i == Duration(months=1, days=1, nanoseconds=ns) def test_modulus_by_object(self) -> None: with pytest.raises(TypeError): _ = (Duration(months=2, days=3, seconds=5.7) % object()) # type: ignore[operator] @pytest.mark.parametrize("ns", (0, 1)) def test_floor_division_and_modulus_by_int(self, ns) -> None: d1 = Duration(months=11, days=33, seconds=55.77, nanoseconds=ns) i = 2 assert divmod(d1, i) == (Duration(months=5, days=16, seconds=27, nanoseconds=885000000), Duration(months=1, days=1, nanoseconds=ns)) def test_floor_division_and_modulus_by_object(self) -> None: with pytest.raises(TypeError): _ = divmod(Duration(months=2, days=3, seconds=5.7), object()) # type: ignore[operator] @pytest.mark.parametrize( ("year", "month", "day"), ( *((i, 0, 0) for i in range(4)), *((0, i, 0) for i in range(4)), *((0, 0, i) for i in range(4)), ) ) @pytest.mark.parametrize("second", range(4)) @pytest.mark.parametrize("ns", range(4)) @pytest.mark.parametrize("divisor", (*range(1, 3), 1_000_000_000)) def test_div_mod_is_well_defined(self, year, month, day, second, ns, divisor) -> None: d1 = Duration(years=year, months=month, days=day, seconds=second, nanoseconds=ns) fraction, rest = divmod(d1, divisor) assert d1 == fraction * divisor + rest def test_true_division_by_int(self) -> None: d1 = Duration(months=11, days=33, seconds=55.77) i = 2 assert d1 / i == Duration(months=6, days=16, seconds=27.885) def test_true_division_by_float(self) -> None: d1 = Duration(months=11, days=33, seconds=55.77) f = 2.5 assert d1 / f == Duration(months=4, days=13, seconds=22.308) def test_true_division_by_object(self) -> None: with pytest.raises(TypeError): _ = (Duration(months=2, days=3, seconds=5.7) / object()) # type: ignore[operator] def test_unary_plus(self) -> None: d = Duration(months=11, days=33, seconds=55.77) assert +d == Duration(months=11, days=33, seconds=55.77) def test_unary_minus(self) -> None: d = Duration(months=11, days=33, seconds=55.77) assert -d == Duration(months=-11, days=-33, seconds=-55.77) def test_absolute(self) -> None: d = Duration(months=-11, days=-33, seconds=-55.77) assert abs(d) == Duration(months=11, days=33, seconds=55.77) def test_str(self) -> None: assert str(Duration()) == "PT0S" assert str(Duration(years=1, months=2)) == "P1Y2M" assert str(Duration(years=-1, months=2)) == "P-10M" assert str(Duration(months=-13)) == "P-1Y-1M" assert str(Duration(months=2, days=3, seconds=5.7)) == "P2M3DT5.7S" assert str(Duration(hours=12, minutes=34)) == "PT12H34M" assert str(Duration(seconds=59)) == "PT59S" assert str(Duration(seconds=0.123456789)) == "PT0.123456789S" assert str(Duration(seconds=-0.123456789)) == "PT-0.123456789S" assert str(Duration(seconds=-2, nanoseconds=1)) == "PT-1.999999999S" def test_repr(self) -> None: d = Duration(months=2, days=3, seconds=5.7) assert repr(d) == ( "Duration(months=2, days=3, seconds=5, nanoseconds=700000000)" ) def test_iso_format(self) -> None: assert Duration().iso_format() == "PT0S" assert Duration(years=1, months=2).iso_format() == "P1Y2M" assert Duration(years=-1, months=2).iso_format() == "P-10M" assert Duration(months=-13).iso_format() == "P-1Y-1M" assert (Duration(months=2, days=3, seconds=5.7).iso_format() == "P2M3DT5.7S") assert Duration(hours=12, minutes=34).iso_format() == "PT12H34M" assert Duration(seconds=59).iso_format() == "PT59S" assert Duration(seconds=0.123456789).iso_format() == "PT0.123456789S" assert Duration(seconds=-0.123456789).iso_format() == "PT-0.123456789S" def test_copy(self) -> None: d = Duration(years=1, months=2, days=3, hours=4, minutes=5, seconds=6, milliseconds=7, microseconds=8, nanoseconds=9) d2 = copy.copy(d) assert d is not d2 assert d == d2 def test_deep_copy(self) -> None: d = Duration(years=1, months=2, days=3, hours=4, minutes=5, seconds=6, milliseconds=7, microseconds=8, nanoseconds=9) d2 = copy.deepcopy(d) assert d is not d2 assert d == d2 def test_from_iso_format(self) -> None: assert Duration() == Duration.from_iso_format("PT0S") assert Duration( hours=12, minutes=34, seconds=56.789 ) == Duration.from_iso_format("PT12H34M56.789S") assert Duration( years=1, months=2, days=3 ) == Duration.from_iso_format("P1Y2M3D") assert Duration( years=1, months=2, days=3, hours=12, minutes=34, seconds=56.789 ) == Duration.from_iso_format("P1Y2M3DT12H34M56.789S") # test for float precision issues for i in range(500006000, 500010000, 1000): assert Duration( years=1, months=2, days=3, hours=12, minutes=34, nanoseconds=i ) == Duration.from_iso_format("P1Y2M3DT12H34M00.%sS" % str(i)) assert Duration( years=1, months=2, days=3, hours=12, minutes=34, nanoseconds=i ) == Duration.from_iso_format("P1Y2M3DT12H34M00.%sS" % str(i)[:-3]) @pytest.mark.parametrize("with_day", (True, False)) @pytest.mark.parametrize("with_month", (True, False)) @pytest.mark.parametrize("only_ns", (True, False)) def test_minimal_value(self, with_day, with_month, only_ns) -> None: seconds = (time.MIN_INT64 + with_month * time.AVERAGE_SECONDS_IN_MONTH + with_day * time.AVERAGE_SECONDS_IN_DAY) Duration( months=-with_month, days=-with_day, seconds=0 if only_ns else seconds, nanoseconds=(seconds * time.NANO_SECONDS) if only_ns else 0 ) @pytest.mark.parametrize("with_day", (True, False)) @pytest.mark.parametrize("with_month", (True, False)) @pytest.mark.parametrize("only_ns", (True, False)) @pytest.mark.parametrize("overflow", ( (0, 0, 0, -1), (0, 0, -1, 0), (0, -1, 0, 0), (-1, 0, 0, 0), )) def test_negative_overflow_value(self, with_day, with_month, only_ns, overflow) -> None: seconds = (time.MIN_INT64 + with_month * time.AVERAGE_SECONDS_IN_MONTH + with_day * time.AVERAGE_SECONDS_IN_DAY) kwargs = { "months": overflow[0], "days": overflow[1], "seconds": overflow[2], "nanoseconds": overflow[3] } kwargs["months"] -= with_month kwargs["days"] -= with_day if only_ns: kwargs["nanoseconds"] += seconds * time.NANO_SECONDS else: kwargs["seconds"] += seconds with pytest.raises(ValueError): Duration(**kwargs) @pytest.mark.parametrize(("field", "module"), ( ("days", time.AVERAGE_SECONDS_IN_DAY), ("months", time.AVERAGE_SECONDS_IN_MONTH), )) def test_minimal_value_only_secondary_field(self, field, module) -> None: kwargs = { field: (time.MIN_INT64 // module - (time.MIN_INT64 % module == 0) + 1) } Duration(**kwargs) @pytest.mark.parametrize(("field", "module"), ( ("days", time.AVERAGE_SECONDS_IN_DAY), ("months", time.AVERAGE_SECONDS_IN_MONTH), )) def test_negative_overflow_value_only_secondary_field( self, field, module ) -> None: kwargs = { field: (time.MIN_INT64 // module - (time.MIN_INT64 % module == 0)) } with pytest.raises(ValueError): Duration(**kwargs) def test_negative_overflow_duration_addition(self) -> None: min_ = Duration.min ns = Duration(nanoseconds=1) with pytest.raises(ValueError): min_ - ns min_ + ns @pytest.mark.parametrize("with_day", (True, False)) @pytest.mark.parametrize("with_month", (True, False)) @pytest.mark.parametrize("only_ns", (True, False)) def test_maximal_value(self, with_day, with_month, only_ns) -> None: seconds = (time.MAX_INT64 - with_month * time.AVERAGE_SECONDS_IN_MONTH - with_day * time.AVERAGE_SECONDS_IN_DAY) Duration( months=with_month, days=with_day, seconds=0 if only_ns else seconds, nanoseconds=(seconds * time.NANO_SECONDS) if only_ns else 0 ) @pytest.mark.parametrize("with_day", (True, False)) @pytest.mark.parametrize("with_month", (True, False)) @pytest.mark.parametrize("only_ns", (True, False)) @pytest.mark.parametrize("overflow", ( (0, 0, 0, 1), (0, 0, 1, 0), (0, 1, 0, 0), (1, 0, 0, 0), )) def test_positive_overflow_value(self, with_day, with_month, only_ns, overflow) -> None: seconds = (time.MAX_INT64 - with_month * time.AVERAGE_SECONDS_IN_MONTH - with_day * time.AVERAGE_SECONDS_IN_DAY) kwargs = { "months": overflow[0], "days": overflow[1], "seconds": overflow[2], "nanoseconds": time.NANO_SECONDS - 1 + overflow[3] } kwargs["months"] += with_month kwargs["days"] += with_day if only_ns: kwargs["nanoseconds"] += seconds * time.NANO_SECONDS else: kwargs["seconds"] += seconds with pytest.raises(ValueError): Duration(**kwargs) @pytest.mark.parametrize(("field", "module"), ( ("days", time.AVERAGE_SECONDS_IN_DAY), ("months", time.AVERAGE_SECONDS_IN_MONTH), )) def test_maximal_value_only_secondary_field(self, field, module) -> None: kwargs = { field: time.MAX_INT64 // module } Duration(**kwargs) @pytest.mark.parametrize(("field", "module"), ( ("days", time.AVERAGE_SECONDS_IN_DAY), ("months", time.AVERAGE_SECONDS_IN_MONTH), )) def test_positive_overflow_value_only_secondary_field( self, field, module ) -> None: kwargs = { field: time.MAX_INT64 // module + 1 } with pytest.raises(ValueError): Duration(**kwargs) def test_positive_overflow_duration_addition(self) -> None: max_ = Duration.max ns = Duration(nanoseconds=1) with pytest.raises(ValueError): max_ + ns max_ - ns neo4j-python-driver-5.2.1/tests/unit/common/time/test_time.py000066400000000000000000000441411433522662700243020ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations import itertools import operator from datetime import ( time, timedelta, timezone as datetime_timezone, ) import pytest from pytz import ( FixedOffset, timezone, utc, ) from neo4j.time import Time from neo4j.time._arithmetic import ( nano_add, nano_div, round_half_to_even, ) timezone_us_eastern = timezone("US/Eastern") timezone_utc = timezone("UTC") class TestTime: def test_bad_attribute(self) -> None: t = Time(12, 34, 56, 789000000) with pytest.raises(AttributeError): _ = t.x def test_simple_time(self) -> None: t = Time(12, 34, 56, 789000000) assert t.hour_minute_second_nanosecond == (12, 34, 56, 789000000) assert t.ticks == 45296789000000 assert t.hour == 12 assert t.minute == 34 assert t.second == 56 assert t.nanosecond == 789000000 def test_midnight(self) -> None: t = Time(0, 0, 0) assert t.hour_minute_second_nanosecond == (0, 0, 0, 0) assert t.ticks == 0 assert t.hour == 0 assert t.minute == 0 assert t.second == 0 assert t.nanosecond == 0 def test_nanosecond_precision(self) -> None: t = Time(12, 34, 56, 789123456) assert t.hour_minute_second_nanosecond == (12, 34, 56, 789123456) assert t.ticks == 45296789123456 assert t.hour == 12 assert t.minute == 34 assert t.second == 56 assert t.nanosecond == 789123456 def test_str(self) -> None: t = Time(12, 34, 56, 789123456) assert str(t) == "12:34:56.789123456" @pytest.mark.parametrize(("tz", "expected"), ( (None, (12, 34, 56, 789000001)), (timezone_utc, (12, 34, 56, 789000001)), (datetime_timezone.utc, (12, 34, 56, 789000001)), (FixedOffset(60), (13, 34, 56, 789000001)), (datetime_timezone(timedelta(hours=1)), (13, 34, 56, 789000001)), (timezone_us_eastern, (7, 34, 56, 789000001)), )) def test_now(self, tz, expected) -> None: t = Time.now(tz=tz) assert isinstance(t, Time) assert t.hour_minute_second_nanosecond == expected assert str(t.tzinfo) == str(tz) def test_utc_now(self) -> None: t = Time.utc_now() assert isinstance(t, Time) assert t.hour_minute_second_nanosecond == (12, 34, 56, 789000001) assert t.tzinfo is None def test_from_native(self) -> None: native = time(12, 34, 56, 789123) t = Time.from_native(native) assert t.hour == native.hour assert t.minute == native.minute assert t.second == native.second assert t.nanosecond == native.microsecond * 1000 def test_to_native(self) -> None: t = Time(12, 34, 56, 789123456) native = t.to_native() assert t.hour == native.hour assert t.minute == native.minute assert t.second == native.second assert round_half_to_even(t.nanosecond / 1000) == native.microsecond @pytest.mark.parametrize(("t", "expected"), ( ( Time(12, 34, 56, 789123456), "12:34:56.789123456" ), ( time(12, 34, 56, 789123), "12:34:56.789123" ), ( Time(12, 34, 56, 789000000), "12:34:56.789000000" ), ( time(12, 34, 56, 789000), "12:34:56.789000" ), ( Time(12, 34, 56, 789), "12:34:56.000000789" ), ( time(12, 34, 56, 789), "12:34:56.000789" ), ( Time(12, 34, 56, 789, tzinfo=timezone_utc), "12:34:56.000000789+00:00" ), ( time(12, 34, 56, 789, tzinfo=timezone_utc), "12:34:56.000789+00:00" ), ( Time(12, 34, 56, 789, tzinfo=timezone_us_eastern), "12:34:56.000000789" ), ( time(12, 34, 56, 789, tzinfo=timezone_us_eastern), "12:34:56.000789" ), ( Time(12, 34, 56, 123456789, tzinfo=FixedOffset(83)), "12:34:56.123456789+01:23" ), ( time(12, 34, 56, 123456, tzinfo=FixedOffset(83)), "12:34:56.123456+01:23" ), )) def test_iso_format(self, t, expected) -> None: assert t.isoformat() == expected def test_from_iso_format_hour_only(self) -> None: expected = Time(12, 0, 0) actual = Time.from_iso_format("12") assert expected == actual def test_from_iso_format_hour_and_minute(self) -> None: expected = Time(12, 34, 0) actual = Time.from_iso_format("12:34") assert expected == actual def test_from_iso_format_hour_minute_second(self) -> None: expected = Time(12, 34, 56) actual = Time.from_iso_format("12:34:56") assert expected == actual def test_from_iso_format_hour_minute_second_milliseconds(self) -> None: expected = Time(12, 34, 56, 123000000) actual = Time.from_iso_format("12:34:56.123") assert expected == actual def test_from_iso_format_hour_minute_second_microseconds(self) -> None: expected = Time(12, 34, 56, 123456000) actual = Time.from_iso_format("12:34:56.123456") assert expected == actual def test_from_iso_format_hour_minute_second_nanosecond(self) -> None: expected = Time(12, 34, 56, 123456789) actual = Time.from_iso_format("12:34:56.123456789") assert expected == actual def test_from_iso_format_with_positive_tz(self) -> None: expected = Time(12, 34, 56, 123456789, tzinfo=FixedOffset(754)) actual = Time.from_iso_format("12:34:56.123456789+12:34") assert expected == actual def test_from_iso_format_with_negative_tz(self) -> None: expected = Time(12, 34, 56, 123456789, tzinfo=FixedOffset(-754)) actual = Time.from_iso_format("12:34:56.123456789-12:34") assert expected == actual def test_from_iso_format_with_positive_long_tz(self) -> None: expected = Time(12, 34, 56, 123456789, tzinfo=FixedOffset(754)) actual = Time.from_iso_format("12:34:56.123456789+12:34:56.123456") assert expected == actual def test_from_iso_format_with_negative_long_tz(self) -> None: expected = Time(12, 34, 56, 123456789, tzinfo=FixedOffset(-754)) actual = Time.from_iso_format("12:34:56.123456789-12:34:56.123456") assert expected == actual def test_from_iso_format_with_hour_only_tz(self) -> None: expected = Time(12, 34, 56, 123456789, tzinfo=FixedOffset(120)) actual = Time.from_iso_format("12:34:56.123456789+02:00") assert expected == actual def test_utc_offset_fixed(self) -> None: expected = Time(12, 34, 56, 123456789, tzinfo=FixedOffset(-754)) actual = -754 * 60 offset = expected.utc_offset() assert offset is not None assert offset.total_seconds() == actual def test_iso_format_with_time_zone_case_1(self) -> None: # python -m pytest tests/unit/time/test_time.py -s -v -k test_iso_format_with_time_zone_case_1 expected = Time(7, 54, 2, 129790999, tzinfo=timezone_utc) assert expected.iso_format() == "07:54:02.129790999+00:00" assert expected.tzinfo == FixedOffset(0) actual = Time.from_iso_format("07:54:02.129790999+00:00") assert expected == actual def test_iso_format_with_time_zone_case_2(self) -> None: # python -m pytest tests/unit/time/test_time.py -s -v -k test_iso_format_with_time_zone_case_2 expected = Time.from_iso_format("07:54:02.129790999+01:00") assert expected.tzinfo == FixedOffset(60) assert expected.iso_format() == "07:54:02.129790999+01:00" def test_to_native_case_1(self) -> None: # python -m pytest tests/unit/time/test_time.py -s -v -k test_to_native_case_1 t = Time(12, 34, 56, 789123456) native = t.to_native() assert native.hour == t.hour assert native.minute == t.minute assert nano_add(native.second, nano_div(native.microsecond, 1000000)) \ == 56.789123 assert native.tzinfo is None assert native.isoformat() == "12:34:56.789123" def test_to_native_case_2(self) -> None: # python -m pytest tests/unit/time/test_time.py -s -v -k test_to_native_case_2 t = Time(12, 34, 56, 789123456, tzinfo=timezone_utc) native = t.to_native() assert native.hour == t.hour assert native.minute == t.minute assert nano_add(native.second, nano_div(native.microsecond, 1000000)) \ == 56.789123 assert native.tzinfo == FixedOffset(0) assert native.isoformat() == "12:34:56.789123+00:00" def test_from_native_case_1(self) -> None: # python -m pytest tests/unit/time/test_time.py -s -v -k test_from_native_case_1 native = time(12, 34, 56, 789123) t = Time.from_native(native) assert t.hour == native.hour assert t.minute == native.minute assert t.second == native.second assert t.nanosecond == native.microsecond * 1000 assert t.tzinfo is None def test_from_native_case_2(self) -> None: # python -m pytest tests/unit/time/test_time.py -s -v -k test_from_native_case_2 native = time(12, 34, 56, 789123, FixedOffset(0)) t = Time.from_native(native) assert t.hour == native.hour assert t.minute == native.minute assert t.second == native.second assert t.nanosecond == native.microsecond * 1000 assert t.tzinfo == FixedOffset(0) @pytest.mark.parametrize(("t1", "t2"), ( (time(12, 34, 56, 789123), Time(12, 34, 56, 789123000)), (Time(12, 34, 56, 789123456), Time(12, 34, 56, 789123456)), ( time(12, 34, 56, 789123, FixedOffset(1)), Time(12, 34, 56, 789123000, FixedOffset(1)) ), ( time(12, 34, 56, 789123, FixedOffset(-1)), Time(12, 34, 56, 789123000, FixedOffset(-1)) ), ( Time(12, 34, 56, 789123456, FixedOffset(1)), Time(12, 34, 56, 789123456, FixedOffset(1)) ), ( Time(12, 34, 56, 789123456, FixedOffset(-1)), Time(12, 34, 56, 789123456, FixedOffset(-1)) ), ( Time(12, 35, 56, 789123456, FixedOffset(1)), Time(12, 34, 56, 789123456, FixedOffset(0)) ), ( # Not testing our library directly, but asserting that Python's # time implementation is aligned with ours. time(12, 35, 56, 789123, FixedOffset(1)), time(12, 34, 56, 789123, FixedOffset(0)) ), ( time(12, 35, 56, 789123, FixedOffset(1)), Time(12, 34, 56, 789123000, FixedOffset(0)) ), ( Time(12, 35, 56, 789123123, FixedOffset(1)), Time(12, 34, 56, 789123123, FixedOffset(0)) ), )) def test_equality(self, t1, t2) -> None: assert t1 == t2 assert t2 == t1 assert t1 <= t2 assert t2 <= t1 assert t1 >= t2 assert t2 >= t1 @pytest.mark.parametrize(("t1", "t2"), ( (time(12, 34, 56, 789123), Time(12, 34, 56, 789123001)), (time(12, 34, 56, 789123), Time(12, 34, 56, 789124000)), (time(12, 34, 56, 789123), Time(12, 34, 57, 789123000)), (time(12, 34, 56, 789123), Time(12, 35, 56, 789123000)), (time(12, 34, 56, 789123), Time(13, 34, 56, 789123000)), (Time(12, 34, 56, 789123456), Time(12, 34, 56, 789123450)), (Time(12, 34, 56, 789123456), Time(12, 34, 57, 789123456)), (Time(12, 34, 56, 789123456), Time(12, 35, 56, 789123456)), (Time(12, 34, 56, 789123456), Time(13, 34, 56, 789123456)), ( time(12, 34, 56, 789123, FixedOffset(2)), Time(12, 34, 56, 789123000, FixedOffset(1)) ), ( time(12, 34, 56, 789123, FixedOffset(-2)), Time(12, 34, 56, 789123000, FixedOffset(-1)) ), ( time(12, 34, 56, 789123), Time(12, 34, 56, 789123000, FixedOffset(0)) ), ( Time(12, 34, 56, 789123456, FixedOffset(2)), Time(12, 34, 56, 789123456, FixedOffset(1)) ), ( Time(12, 34, 56, 789123456, FixedOffset(-2)), Time(12, 34, 56, 789123456, FixedOffset(-1)) ), ( Time(12, 34, 56, 789123456), Time(12, 34, 56, 789123456, FixedOffset(0)) ), ( Time(13, 34, 56, 789123456, FixedOffset(1)), Time(12, 34, 56, 789123456, FixedOffset(0)) ), ( Time(11, 34, 56, 789123456, FixedOffset(1)), Time(12, 34, 56, 789123456, FixedOffset(0)) ), )) def test_inequality(self, t1, t2) -> None: assert t1 != t2 assert t2 != t1 @pytest.mark.parametrize( ("t1", "t2"), itertools.product( ( time(12, 34, 56, 789123), Time(12, 34, 56, 789123000), time(12, 34, 56, 789123, FixedOffset(0)), Time(12, 34, 56, 789123456, FixedOffset(0)), time(12, 35, 56, 789123, FixedOffset(1)), Time(12, 35, 56, 789123456, FixedOffset(1)), time(12, 34, 56, 789123, FixedOffset(-1)), Time(12, 34, 56, 789123456, FixedOffset(-1)), time(12, 34, 56, 789123, FixedOffset(60 * -16)), Time(12, 34, 56, 789123000, FixedOffset(60 * -16)), time(11, 34, 56, 789123, FixedOffset(60 * -17)), Time(11, 34, 56, 789123000, FixedOffset(60 * -17)), Time(12, 34, 56, 789123456, FixedOffset(60 * -16)), Time(11, 34, 56, 789123456, FixedOffset(60 * -17)), ), repeat=2 ) ) def test_hashed_equality(self, t1, t2) -> None: if t1 == t2: s = {t1} assert t1 in s assert t2 in s s = {t2} assert t1 in s assert t2 in s else: s = {t1} assert t1 in s assert t2 not in s s = {t2} assert t1 not in s assert t2 in s @pytest.mark.parametrize(("t1", "t2"), ( itertools.product( ( time(12, 34, 56, 789123), Time(12, 34, 56, 789123000), Time(12, 34, 56, 789123001), ), repeat=2 ) )) @pytest.mark.parametrize("tz", ( FixedOffset(0), FixedOffset(1), FixedOffset(-1), utc, )) @pytest.mark.parametrize("op", ( operator.lt, operator.le, operator.gt, operator.ge, )) def test_comparison_with_only_one_naive_fails( self, t1, t2, tz, op ) -> None: t1 = t1.replace(tzinfo=tz) with pytest.raises(TypeError, match="naive"): op(t1, t2) @pytest.mark.parametrize( ("t1", "t2"), itertools.product( ( time(12, 34, 56, 789123), Time(12, 34, 56, 789123000), Time(12, 34, 56, 789123001), ), repeat=2 ) ) @pytest.mark.parametrize("tz", ( timezone("Europe/Paris"), timezone("Europe/Berlin"), )) @pytest.mark.parametrize("op", ( operator.lt, operator.le, operator.gt, operator.ge, )) def test_comparison_with_one_naive_and_not_fixed_tz( self, t1, t2, tz, op ) -> None: t1tz = t1.replace(tzinfo=tz) res = op(t1tz, t2) expected = op(t1, t2) assert res is expected @pytest.mark.parametrize(("t1", "t2"), ( (time(12, 34, 56, 789123), time(12, 34, 56, 789124)), (Time(12, 34, 56, 789123000), time(12, 34, 56, 789124)), (time(12, 34, 56, 789123), Time(12, 34, 56, 789124000)), (Time(12, 34, 56, 789123000), Time(12, 34, 56, 789124000)), ( time(12, 34, 56, 789123, FixedOffset(1)), time(12, 34, 56, 789124, FixedOffset(1)), ), ( Time(12, 34, 56, 789123000, FixedOffset(1)), time(12, 34, 56, 789124, FixedOffset(1)), ), ( Time(12, 34, 56, 789123000, FixedOffset(1)), Time(12, 34, 56, 789124000, FixedOffset(1)), ), ( Time(12, 34, 56, 789123000, FixedOffset(1)), Time(12, 34, 56, 789123001, FixedOffset(1)), ), ( time(12, 36, 56, 789123, FixedOffset(1)), time(12, 34, 56, 789124, FixedOffset(-1)), ), ( Time(12, 36, 56, 789123000, FixedOffset(1)), time(12, 34, 56, 789124, FixedOffset(-1)), ), ( Time(12, 36, 56, 789123000, FixedOffset(1)), Time(12, 34, 56, 789124000, FixedOffset(-1)), ), ( Time(12, 36, 56, 789123000, FixedOffset(1)), Time(12, 34, 56, 789123001, FixedOffset(-1)), ), )) def test_comparison(self, t1, t2) -> None: assert t1 < t2 assert not t2 < t1 assert t1 <= t2 assert not t2 <= t1 assert t2 > t1 assert not t1 > t2 assert t2 >= t1 assert not t1 >= t2 def test_str() -> None: t = Time(12, 34, 56, 789123001) assert str(t) == "12:34:56.789123001" def test_format() -> None: t = Time(12, 34, 56, 789123001) assert f"{t}" == "12:34:56.789123001" assert f"{t:%Y-%m-%d}" == f"{time():%Y-%m-%d}" assert (f"{t:%Y-%m-%d %H:%M:%S.%f}" == f"{time():%Y-%m-%d} 12:34:56.789123001") neo4j-python-driver-5.2.1/tests/unit/mixed/000077500000000000000000000000001433522662700206075ustar00rootroot00000000000000neo4j-python-driver-5.2.1/tests/unit/mixed/__init__.py000066400000000000000000000012011433522662700227120ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. neo4j-python-driver-5.2.1/tests/unit/mixed/async_compat/000077500000000000000000000000001433522662700232675ustar00rootroot00000000000000neo4j-python-driver-5.2.1/tests/unit/mixed/async_compat/__init__.py000066400000000000000000000012011433522662700253720ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. neo4j-python-driver-5.2.1/tests/unit/mixed/async_compat/test_concurrency.py000066400000000000000000000123751433522662700272420ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 asyncio import pytest from neo4j._async_compat.concurrency import AsyncRLock @pytest.mark.asyncio async def test_async_r_lock(): counter = 1 lock = AsyncRLock() async def worker(): nonlocal counter async with lock: counter_ = counter counter += 1 await asyncio.sleep(0) # assert no one else touched the counter assert counter == counter_ + 1 assert not lock.locked() await asyncio.gather(worker(), worker(), worker()) assert not lock.locked() @pytest.mark.asyncio async def test_async_r_lock_is_reentrant(): lock = AsyncRLock() async def worker(): async with lock: assert lock._count == 1 async with lock: assert lock._count == 2 assert lock.locked() assert not lock.locked() await asyncio.gather(worker(), worker(), worker()) assert not lock.locked() @pytest.mark.asyncio async def test_async_r_lock_acquire_timeout_blocked(): lock = AsyncRLock() async def blocker(): assert await lock.acquire() async def waiter(): # make sure blocker has a chance to acquire the lock await asyncio.sleep(0) assert not await lock.acquire(timeout=0.1) assert not lock.locked() await asyncio.gather(blocker(), waiter()) assert lock.locked() # blocker still owns it! @pytest.mark.asyncio async def test_async_r_lock_acquire_timeout_released(): lock = AsyncRLock() async def blocker(): assert await lock.acquire() await asyncio.sleep(0) # waiter: lock.acquire(timeout=0.1) lock.release() async def waiter(): await asyncio.sleep(0) # blocker: lock.acquire() assert await lock.acquire(timeout=0.1) # blocker: lock.release() assert not lock.locked() await asyncio.gather(blocker(), waiter()) assert lock.locked() # waiter still owns it! @pytest.mark.asyncio async def test_async_r_lock_acquire_timeout_reentrant(): lock = AsyncRLock() assert not lock.locked() await lock.acquire() assert lock._count == 1 await lock.acquire() assert lock._count == 2 await lock.acquire(timeout=0.1) assert lock._count == 3 await lock.acquire(timeout=0.1) assert lock._count == 4 for _ in range(4): lock.release() assert not lock.locked() @pytest.mark.asyncio async def test_async_r_lock_acquire_non_blocking(): lock = AsyncRLock() assert not lock.locked() awaits = 0 async def blocker(): nonlocal awaits assert awaits == 0 awaits += 1 assert await lock.acquire() assert awaits == 1 awaits += 1 await asyncio.sleep(0) assert awaits == 4 awaits += 1 # not really, but ok... lock.release() async def waiter_non_blocking(): nonlocal awaits assert awaits == 2 awaits += 1 await asyncio.sleep(0) assert awaits == 5 awaits += 1 assert not await lock.acquire(blocking=False) assert awaits == 7 awaits += 1 assert not await lock.acquire(blocking=False) assert awaits == 9 awaits += 1 assert await lock.acquire(blocking=False) async def waiter(): nonlocal awaits assert awaits == 3 awaits += 1 assert await lock.acquire() assert awaits == 6 awaits += 1 await asyncio.sleep(0) assert awaits == 8 awaits += 1 await asyncio.sleep(0) assert awaits == 10 awaits += 1 lock.release() assert not lock.locked() await asyncio.gather(blocker(), waiter_non_blocking(), waiter()) assert lock.locked() # waiter_non_blocking still owns it! @pytest.mark.parametrize("waits", range(1, 10)) @pytest.mark.asyncio async def test_async_r_lock_acquire_cancellation(waits): lock = AsyncRLock() async def acquire_task(): while True: count = lock._count try: await lock.acquire(timeout=0.1) assert lock._count == count + 1 except asyncio.CancelledError: assert lock._count == count raise try: # we're also ok with a deferred cancellation await asyncio.sleep(0) except asyncio.CancelledError: raise assert count < 50 # safety guard, we shouldn't ever get there! fut = asyncio.ensure_future(acquire_task()) for _ in range(waits): await asyncio.sleep(0) fut.cancel() with pytest.raises(asyncio.CancelledError): await fut neo4j-python-driver-5.2.1/tests/unit/mixed/async_compat/test_shims.py000066400000000000000000000042341433522662700260260ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 asyncio import sys import pytest from neo4j._async_compat import shims from ...._async_compat import mark_async_test async def _check_wait_for(wait_for_, should_propagate_cancellation): inner = asyncio.get_event_loop().create_future() outer = wait_for_(inner, 0.1) outer_future = asyncio.ensure_future(outer) await asyncio.sleep(0) inner.set_result(None) # inner is done outer_future.cancel() # AND outer got cancelled if should_propagate_cancellation: with pytest.raises(asyncio.CancelledError): await outer_future else: await outer_future @pytest.mark.skipif( sys.version_info < (3, 8), reason="wait_for is only broken in Python 3.8+" ) @mark_async_test async def test_wait_for_shim_is_necessary_starting_from_3x8(): # when this tests fails, the shim became superfluous await _check_wait_for( asyncio.wait_for, # this should propagate the cancellation, but it's broken :/ should_propagate_cancellation=False ) @pytest.mark.skipif( sys.version_info >= (3, 8), reason="wait_for is only broken in Python 3.8+" ) @mark_async_test async def test_wait_for_shim_is_not_necessary_prior_to_3x8(): await _check_wait_for( asyncio.wait_for, should_propagate_cancellation=True ) @mark_async_test async def test_wait_for_shim_propagates_cancellation(): # shim should always work regardless of the Python version await _check_wait_for( shims.wait_for, should_propagate_cancellation=True ) neo4j-python-driver-5.2.1/tests/unit/mixed/io/000077500000000000000000000000001433522662700212165ustar00rootroot00000000000000neo4j-python-driver-5.2.1/tests/unit/mixed/io/__init__.py000066400000000000000000000012011433522662700233210ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. neo4j-python-driver-5.2.1/tests/unit/mixed/io/test_direct.py000066400000000000000000000224211433522662700241020ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 asyncio import time from asyncio import ( Condition as AsyncCondition, Event as AsyncEvent, Lock as AsyncLock, ) from threading import ( Condition, Event, Lock, Thread, ) import pytest from neo4j._async_compat.shims import wait_for from neo4j._deadline import Deadline from ...async_.io.test_direct import AsyncFakeBoltPool from ...sync.io.test_direct import FakeBoltPool class MultiEvent: # Adopted from threading.Event def __init__(self): super().__init__() self._cond = Condition(Lock()) self._counter = 0 def _reset_internal_locks(self): # private! called by Thread._reset_internal_locks by _after_fork() self._cond.__init__(Lock()) def counter(self): return self._counter def increment(self): with self._cond: self._counter += 1 self._cond.notify_all() def decrement(self): with self._cond: self._counter -= 1 self._cond.notify_all() def clear(self): with self._cond: self._counter = 0 self._cond.notify_all() def wait(self, value=0, timeout=None): with self._cond: t_start = time.time() while True: if value == self._counter: return True if timeout is None: time_left = None else: time_left = timeout - (time.time() - t_start) if time_left <= 0: return False if not self._cond.wait(time_left): return False class AsyncMultiEvent: # Adopted from threading.Event def __init__(self): super().__init__() self._cond = AsyncCondition() self._counter = 0 def _reset_internal_locks(self): # private! called by Thread._reset_internal_locks by _after_fork() self._cond.__init__(AsyncLock()) def counter(self): return self._counter async def increment(self): async with self._cond: self._counter += 1 self._cond.notify_all() async def decrement(self): async with self._cond: self._counter -= 1 self._cond.notify_all() async def clear(self): async with self._cond: self._counter = 0 self._cond.notify_all() async def wait(self, value=0, timeout=None): async with self._cond: t_start = time.time() while True: if value == self._counter: return True if timeout is None: time_left = None else: time_left = timeout - (time.time() - t_start) if time_left <= 0: return False try: await wait_for(self._cond.wait(), time_left) except asyncio.TimeoutError: return False class TestMixedConnectionPoolTestCase: def assert_pool_size(self, address, expected_active, expected_inactive, pool): try: connections = pool.connections[address] except KeyError: assert 0 == expected_active assert 0 == expected_inactive else: assert (expected_active == len([cx for cx in connections if cx.in_use])) assert (expected_inactive == len([cx for cx in connections if not cx.in_use])) @pytest.mark.parametrize("pre_populated", (0, 3, 5)) def test_multithread(self, pre_populated): connections_lock = Lock() connections = [] pre_populated_connections = [] def acquire_release_conn(pool_, address_, acquired_counter_, release_event_): nonlocal connections, connections_lock conn_ = pool_._acquire(address_, Deadline(3), None) with connections_lock: if connections is not None: connections.append(conn_) acquired_counter_.increment() release_event_.wait() pool_.release(conn_) with FakeBoltPool((), max_connection_pool_size=5) as pool: address = ("127.0.0.1", 7687) acquired_counter = MultiEvent() release_event = Event() # pre-populate the pool with connections for _ in range(pre_populated): conn = pool._acquire(address, Deadline(3), None) pre_populated_connections.append(conn) for conn in pre_populated_connections: pool.release(conn) assert len(set(pre_populated_connections)) == pre_populated self.assert_pool_size(address, 0, pre_populated, pool) # start 10 threads competing for connections from a pool of size 5 threads = [] for i in range(10): t = Thread( target=acquire_release_conn, args=(pool, address, acquired_counter, release_event), daemon=True ) t.start() threads.append(t) if not acquired_counter.wait(5, timeout=1): raise RuntimeError("Acquire threads not fast enough") # The pool size should be 5, all are in-use self.assert_pool_size(address, 5, 0, pool) with connections_lock: assert set(pre_populated_connections).issubset( set(connections) ) connections = pre_populated_connections = None # Now we allow the threads to release connections they obtained # from the pool release_event.set() # wait for all threads to release connections back to pool for t in threads: t.join(timeout=1) # The pool size is still 5, but all are free self.assert_pool_size(address, 0, 5, pool) @pytest.mark.parametrize("pre_populated", (0, 3, 5)) @pytest.mark.asyncio async def test_multi_coroutine(self, pre_populated): connections = [] pre_populated_connections = [] async def acquire_release_conn(pool_, address_, acquired_counter_, release_event_): nonlocal connections conn_ = await pool_._acquire(address_, Deadline(3), None) if connections is not None: connections.append(conn_) await acquired_counter_.increment() await release_event_.wait() await pool_.release(conn_) async def waiter(pool_, acquired_counter_, release_event_): nonlocal pre_populated_connections, connections if not await acquired_counter_.wait(5, timeout=1): raise RuntimeError("Acquire coroutines not fast enough") # The pool size should be 5, all are in-use self.assert_pool_size(address, 5, 0, pool_) assert set(pre_populated_connections).issubset(set(connections)) connections = pre_populated_connections = None # Now we allow the coroutines to release connections they obtained # from the pool release_event_.set() # wait for all coroutines to release connections back to pool if not await acquired_counter_.wait(10, timeout=5): raise RuntimeError("Acquire coroutines not fast enough") # The pool size is still 5, but all are free self.assert_pool_size(address, 0, 5, pool_) async with AsyncFakeBoltPool((), max_connection_pool_size=5) as pool: address = ("127.0.0.1", 7687) acquired_counter = AsyncMultiEvent() release_event = AsyncEvent() # pre-populate the pool with connections for _ in range(pre_populated): conn = await pool._acquire(address, Deadline(3), None) pre_populated_connections.append(conn) for conn in pre_populated_connections: await pool.release(conn) assert len(set(pre_populated_connections)) == pre_populated self.assert_pool_size(address, 0, pre_populated, pool) # start 10 coroutines competing for connections from a pool of size # 5 coroutines = [ acquire_release_conn( pool, address, acquired_counter, release_event ) for _ in range(10) ] await asyncio.gather( waiter(pool, acquired_counter, release_event), *coroutines ) neo4j-python-driver-5.2.1/tests/unit/sync/000077500000000000000000000000001433522662700204555ustar00rootroot00000000000000neo4j-python-driver-5.2.1/tests/unit/sync/__init__.py000066400000000000000000000012011433522662700225600ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. neo4j-python-driver-5.2.1/tests/unit/sync/conftest.py000066400000000000000000000013141433522662700226530ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 .fixtures import * # necessary for pytest to discover the fixtures neo4j-python-driver-5.2.1/tests/unit/sync/fixtures/000077500000000000000000000000001433522662700223265ustar00rootroot00000000000000neo4j-python-driver-5.2.1/tests/unit/sync/fixtures/__init__.py000066400000000000000000000012731433522662700244420ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 .fake_connection import * from .fake_pool import * neo4j-python-driver-5.2.1/tests/unit/sync/fixtures/fake_connection.py000066400000000000000000000171641433522662700260360ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 inspect import pytest from neo4j import ServerInfo from neo4j._deadline import Deadline from neo4j._sync.io import Bolt __all__ = [ "fake_connection_generator", "fake_connection", "scripted_connection_generator", "scripted_connection", ] @pytest.fixture def fake_connection_generator(session_mocker): mock = session_mocker.mock_module class FakeConnection(mock.NonCallableMagicMock): callbacks = [] server_info = ServerInfo("127.0.0.1", (4, 3)) local_port = 1234 def __init__(self, *args, **kwargs): kwargs["spec"] = Bolt super().__init__(*args, **kwargs) self.attach_mock(mock.Mock(return_value=True), "is_reset_mock") self.attach_mock(mock.Mock(return_value=False), "defunct") self.attach_mock(mock.Mock(return_value=False), "stale") self.attach_mock(mock.Mock(return_value=False), "closed") self.attach_mock(mock.Mock(return_value=False), "socket") self.attach_mock(mock.Mock(), "unresolved_address") def close_side_effect(): self.closed.return_value = True self.attach_mock(mock.Mock(side_effect=close_side_effect), "close") self.socket.attach_mock( mock.Mock(return_value=None), "get_deadline" ) def set_deadline_side_effect(deadline): deadline = Deadline.from_timeout_or_deadline(deadline) self.socket.get_deadline.return_value = deadline self.socket.attach_mock( mock.Mock(side_effect=set_deadline_side_effect), "set_deadline" ) @property def is_reset(self): if self.closed.return_value or self.defunct.return_value: raise AssertionError( "is_reset should not be called on a closed or defunct " "connection." ) return self.is_reset_mock() def fetch_message(self, *args, **kwargs): if self.callbacks: cb = self.callbacks.pop(0) cb() return super().__getattr__("fetch_message")(*args, **kwargs) def fetch_all(self, *args, **kwargs): while self.callbacks: cb = self.callbacks.pop(0) cb() return super().__getattr__("fetch_all")(*args, **kwargs) def __getattr__(self, name): parent = super() def build_message_handler(name): def func(*args, **kwargs): def callback(): for cb_name, param_count in ( ("on_success", 1), ("on_summary", 0) ): cb = kwargs.get(cb_name, None) if callable(cb): try: param_count = \ len(inspect.signature(cb).parameters) except ValueError: # e.g. built-in method as cb pass if param_count == 1: res = cb({}) else: res = cb() try: res # maybe the callback is async except TypeError: pass # or maybe it wasn't ;) self.callbacks.append(callback) return func method_mock = parent.__getattr__(name) if name in ("run", "commit", "pull", "rollback", "discard"): method_mock.side_effect = build_message_handler(name) return method_mock return FakeConnection @pytest.fixture def fake_connection(fake_connection_generator): return fake_connection_generator() @pytest.fixture def scripted_connection_generator(fake_connection_generator): class ScriptedConnection(fake_connection_generator): _script = [] _script_pos = 0 def set_script(self, callbacks): """Set a scripted sequence of callbacks. :param callbacks: The callbacks. They should be a list of 2-tuples. `("name_of_message", {"callback_name": arguments})`. E.g., ``` [ ("run", {"on_success": ({},), "on_summary": None}), ("pull", { "on_success": None, "on_summary": None, "on_records": }) ] ``` Note that arguments can be `None`. In this case, ScriptedConnection will make a guess on best-suited default arguments. """ self._script = callbacks self._script_pos = 0 def __getattr__(self, name): parent = super() def build_message_handler(name): def func(*args, **kwargs): try: expected_message, scripted_callbacks = \ self._script[self._script_pos] except IndexError: pytest.fail("End of scripted connection reached.") assert name == expected_message self._script_pos += 1 def callback(): for cb_name, default_cb_args in ( ("on_ignored", ({},)), ("on_failure", ({},)), ("on_records", ([],)), ("on_success", ({},)), ("on_summary", ()), ): cb = kwargs.get(cb_name, None) if ( not callable(cb) or cb_name not in scripted_callbacks ): continue cb_args = scripted_callbacks[cb_name] if cb_args is None: cb_args = default_cb_args res = cb(*cb_args) try: res # maybe the callback is async except TypeError: pass # or maybe it wasn't ;) self.callbacks.append(callback) return func method_mock = parent.__getattr__(name) if name in ("run", "commit", "pull", "rollback", "discard"): method_mock.side_effect = build_message_handler(name) return method_mock return ScriptedConnection @pytest.fixture def scripted_connection(scripted_connection_generator): return scripted_connection_generator() neo4j-python-driver-5.2.1/tests/unit/sync/fixtures/fake_pool.py000066400000000000000000000024711433522662700246430ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j._sync.io._pool import IOPool __all__ = [ "fake_pool", ] @pytest.fixture def fake_pool(fake_connection_generator, mocker): pool = mocker.Mock(spec=IOPool) assert not hasattr(pool, "acquired_connection_mocks") pool.buffered_connection_mocks = [] pool.acquired_connection_mocks = [] def acquire_side_effect(*_, **__): if pool.buffered_connection_mocks: connection = pool.buffered_connection_mocks.pop() else: connection = fake_connection_generator() pool.acquired_connection_mocks.append(connection) return connection pool.acquire.side_effect = acquire_side_effect return pool neo4j-python-driver-5.2.1/tests/unit/sync/io/000077500000000000000000000000001433522662700210645ustar00rootroot00000000000000neo4j-python-driver-5.2.1/tests/unit/sync/io/__init__.py000066400000000000000000000012011433522662700231670ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. neo4j-python-driver-5.2.1/tests/unit/sync/io/conftest.py000066400000000000000000000070761433522662700232750ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 io import BytesIO from struct import ( pack as struct_pack, unpack as struct_unpack, ) import pytest from neo4j._sync.io._common import ( Inbox, Outbox, ) class FakeSocket: def __init__(self, address, unpacker_cls=None): self.address = address self.captured = b"" self.messages = None if unpacker_cls is not None: self.messages = Inbox( self, on_error=print, unpacker_cls=unpacker_cls ) def getsockname(self): return "127.0.0.1", 0xFFFF def getpeername(self): return self.address def recv_into(self, buffer, nbytes): data = self.captured[:nbytes] actual = len(data) buffer[:actual] = data self.captured = self.captured[actual:] return actual def sendall(self, data): self.captured += data def close(self): return def pop_message(self): assert self.messages return self.messages.pop(None) class FakeSocket2: def __init__(self, address=None, on_send=None, packer_cls=None, unpacker_cls=None): self.address = address self.recv_buffer = bytearray() # self.messages = AsyncMessageInbox(self, on_error=print) self.on_send = on_send self._outbox = self._messages = None if packer_cls: self._outbox = Outbox( self, on_error=print, packer_cls=packer_cls ) if unpacker_cls: self._messages = Inbox( self, on_error=print, unpacker_cls=unpacker_cls ) def getsockname(self): return "127.0.0.1", 0xFFFF def getpeername(self): return self.address def recv_into(self, buffer, nbytes): data = self.recv_buffer[:nbytes] actual = len(data) buffer[:actual] = data self.recv_buffer = self.recv_buffer[actual:] return actual def sendall(self, data): if callable(self.on_send): self.on_send(data) def close(self): return def inject(self, data): self.recv_buffer += data def pop_message(self): assert self._messages return self._messages.pop(None) def send_message(self, tag, *fields): assert self._outbox self._outbox.append_message(tag, fields, None) self._outbox.flush() class FakeSocketPair: def __init__(self, address, packer_cls=None, unpacker_cls=None): self.client = FakeSocket2( address, packer_cls=packer_cls, unpacker_cls=unpacker_cls ) self.server = FakeSocket2( packer_cls=packer_cls, unpacker_cls=unpacker_cls ) self.client.on_send = self.server.inject self.server.on_send = self.client.inject @pytest.fixture def fake_socket(): return FakeSocket @pytest.fixture def fake_socket_2(): return FakeSocket2 @pytest.fixture def fake_socket_pair(): return FakeSocketPair neo4j-python-driver-5.2.1/tests/unit/sync/io/test__common.py000066400000000000000000000034651433522662700241340ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j._codec.packstream.v1 import PackableBuffer from neo4j._sync.io._common import Outbox from ...._async_compat import mark_sync_test @pytest.mark.parametrize(("chunk_size", "data", "result"), ( ( 2, bytes(range(10, 15)), bytes((0, 2, 10, 11, 0, 2, 12, 13, 0, 1, 14)) ), ( 2, bytes(range(10, 14)), bytes((0, 2, 10, 11, 0, 2, 12, 13)) ), ( 2, bytes((5,)), bytes((0, 1, 5)) ), )) @mark_sync_test def test_async_outbox_chunking(chunk_size, data, result, mocker): buffer = PackableBuffer() socket_mock = mocker.Mock() packer_mock = mocker.Mock() packer_mock.return_value = packer_mock packer_mock.new_packable_buffer.return_value = buffer packer_mock.pack_struct.side_effect = \ lambda *args, **kwargs: buffer.write(data) outbox = Outbox(socket_mock, pytest.fail, packer_mock, chunk_size) outbox.append_message(None, None, None) socket_mock.sendall.assert_not_called() assert outbox.flush() socket_mock.sendall.assert_called_once_with(result + b"\x00\x00") assert not outbox.flush() socket_mock.sendall.assert_called_once() neo4j-python-driver-5.2.1/tests/unit/sync/io/test_class_bolt.py000066400000000000000000000057571433522662700246400ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 asyncio import pytest from neo4j._async_compat.network import BoltSocket from neo4j._sync.io import Bolt from ...._async_compat import TestDecorators # python -m pytest tests/unit/io/test_class_bolt.py -s -v def test_class_method_protocol_handlers(): protocol_handlers = Bolt.protocol_handlers() assert len(protocol_handlers) == 6 assert protocol_handlers.keys() == { (3, 0), (4, 1), (4, 2), (4, 3), (4, 4), (5, 0), } @pytest.mark.parametrize( "test_input, expected", [ ((0, 0), 0), ((1, 0), 0), ((2, 0), 0), ((3, 0), 1), ((4, 0), 0), ((4, 1), 1), ((4, 2), 1), ((4, 3), 1), ((4, 4), 1), ((5, 0), 1), ((5, 1), 0), ((6, 0), 0), ] ) def test_class_method_protocol_handlers_with_protocol_version(test_input, expected): protocol_handlers = Bolt.protocol_handlers( protocol_version=test_input ) assert len(protocol_handlers) == expected def test_class_method_protocol_handlers_with_invalid_protocol_version(): with pytest.raises(TypeError): Bolt.protocol_handlers(protocol_version=2) def test_class_method_get_handshake(): handshake = Bolt.get_handshake() assert (b"\x00\x00\x00\x05\x00\x02\x04\x04\x00\x00\x01\x04\x00\x00\x00\x03" == handshake) def test_magic_preamble(): preamble = 0x6060B017 preamble_bytes = preamble.to_bytes(4, byteorder="big") assert Bolt.MAGIC_PREAMBLE == preamble_bytes @TestDecorators.mark_async_only_test def test_cancel_hello_in_open(mocker): address = ("localhost", 7687) socket_mock = mocker.Mock(spec=BoltSocket) socket_cls_mock = mocker.patch("neo4j._sync.io._bolt.BoltSocket", autospec=True) socket_cls_mock.connect.return_value = ( socket_mock, (5, 0), None, None ) socket_mock.getpeername.return_value = address bolt_cls_mock = mocker.patch("neo4j._sync.io._bolt5.Bolt5x0", autospec=True) bolt_mock = bolt_cls_mock.return_value bolt_mock.socket = socket_mock bolt_mock.hello.side_effect = asyncio.CancelledError() bolt_mock.local_port = 1234 with pytest.raises(asyncio.CancelledError): Bolt.open(address) bolt_mock.kill.assert_called_once_with() neo4j-python-driver-5.2.1/tests/unit/sync/io/test_class_bolt3.py000066400000000000000000000073111433522662700247070ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j._conf import PoolConfig from neo4j._sync.io._bolt3 import Bolt3 from neo4j.exceptions import ConfigurationError from ...._async_compat import mark_sync_test @pytest.mark.parametrize("set_stale", (True, False)) def test_conn_is_stale(fake_socket, set_stale): address = ("127.0.0.1", 7687) max_connection_lifetime = 0 connection = Bolt3(address, fake_socket(address), max_connection_lifetime) if set_stale: connection.set_stale() assert connection.stale() is True @pytest.mark.parametrize("set_stale", (True, False)) def test_conn_is_not_stale_if_not_enabled(fake_socket, set_stale): address = ("127.0.0.1", 7687) max_connection_lifetime = -1 connection = Bolt3(address, fake_socket(address), max_connection_lifetime) if set_stale: connection.set_stale() assert connection.stale() is set_stale @pytest.mark.parametrize("set_stale", (True, False)) def test_conn_is_not_stale(fake_socket, set_stale): address = ("127.0.0.1", 7687) max_connection_lifetime = 999999999 connection = Bolt3(address, fake_socket(address), max_connection_lifetime) if set_stale: connection.set_stale() assert connection.stale() is set_stale def test_db_extra_not_supported_in_begin(fake_socket): address = ("127.0.0.1", 7687) connection = Bolt3(address, fake_socket(address), PoolConfig.max_connection_lifetime) with pytest.raises(ConfigurationError): connection.begin(db="something") def test_db_extra_not_supported_in_run(fake_socket): address = ("127.0.0.1", 7687) connection = Bolt3(address, fake_socket(address), PoolConfig.max_connection_lifetime) with pytest.raises(ConfigurationError): connection.run("", db="something") @mark_sync_test def test_simple_discard(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt3.UNPACKER_CLS) connection = Bolt3(address, socket, PoolConfig.max_connection_lifetime) connection.discard() connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x2F" assert len(fields) == 0 @mark_sync_test def test_simple_pull(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt3.UNPACKER_CLS) connection = Bolt3(address, socket, PoolConfig.max_connection_lifetime) connection.pull() connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x3F" assert len(fields) == 0 @pytest.mark.parametrize("recv_timeout", (1, -1)) @mark_sync_test def test_hint_recv_timeout_seconds_gets_ignored( fake_socket_pair, recv_timeout, mocker ): address = ("127.0.0.1", 7687) sockets = fake_socket_pair( address, Bolt3.PACKER_CLS, Bolt3.UNPACKER_CLS ) sockets.client.settimeout = mocker.Mock() sockets.server.send_message(b"\x70", { "server": "Neo4j/3.5.0", "hints": {"connection.recv_timeout_seconds": recv_timeout}, }) connection = Bolt3( address, sockets.client, PoolConfig.max_connection_lifetime ) connection.hello() sockets.client.settimeout.assert_not_called() neo4j-python-driver-5.2.1/tests/unit/sync/io/test_class_bolt4x0.py000066400000000000000000000147331433522662700251660ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j._conf import PoolConfig from neo4j._sync.io._bolt4 import Bolt4x0 from ...._async_compat import mark_sync_test @pytest.mark.parametrize("set_stale", (True, False)) def test_conn_is_stale(fake_socket, set_stale): address = ("127.0.0.1", 7687) max_connection_lifetime = 0 connection = Bolt4x0(address, fake_socket(address), max_connection_lifetime) if set_stale: connection.set_stale() assert connection.stale() is True @pytest.mark.parametrize("set_stale", (True, False)) def test_conn_is_not_stale_if_not_enabled(fake_socket, set_stale): address = ("127.0.0.1", 7687) max_connection_lifetime = -1 connection = Bolt4x0(address, fake_socket(address), max_connection_lifetime) if set_stale: connection.set_stale() assert connection.stale() is set_stale @pytest.mark.parametrize("set_stale", (True, False)) def test_conn_is_not_stale(fake_socket, set_stale): address = ("127.0.0.1", 7687) max_connection_lifetime = 999999999 connection = Bolt4x0(address, fake_socket(address), max_connection_lifetime) if set_stale: connection.set_stale() assert connection.stale() is set_stale @mark_sync_test def test_db_extra_in_begin(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x0.UNPACKER_CLS) connection = Bolt4x0(address, socket, PoolConfig.max_connection_lifetime) connection.begin(db="something") connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x11" assert len(fields) == 1 assert fields[0] == {"db": "something"} @mark_sync_test def test_db_extra_in_run(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x0.UNPACKER_CLS) connection = Bolt4x0(address, socket, PoolConfig.max_connection_lifetime) connection.run("", {}, db="something") connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x10" assert len(fields) == 3 assert fields[0] == "" assert fields[1] == {} assert fields[2] == {"db": "something"} @mark_sync_test def test_n_extra_in_discard(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x0.UNPACKER_CLS) connection = Bolt4x0(address, socket, PoolConfig.max_connection_lifetime) connection.discard(n=666) connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x2F" assert len(fields) == 1 assert fields[0] == {"n": 666} @pytest.mark.parametrize( "test_input, expected", [ (666, {"n": -1, "qid": 666}), (-1, {"n": -1}), ] ) @mark_sync_test def test_qid_extra_in_discard(fake_socket, test_input, expected): address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x0.UNPACKER_CLS) connection = Bolt4x0(address, socket, PoolConfig.max_connection_lifetime) connection.discard(qid=test_input) connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x2F" assert len(fields) == 1 assert fields[0] == expected @pytest.mark.parametrize( "test_input, expected", [ (777, {"n": 666, "qid": 777}), (-1, {"n": 666}), ] ) @mark_sync_test def test_n_and_qid_extras_in_discard(fake_socket, test_input, expected): address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x0.UNPACKER_CLS) connection = Bolt4x0(address, socket, PoolConfig.max_connection_lifetime) connection.discard(n=666, qid=test_input) connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x2F" assert len(fields) == 1 assert fields[0] == expected @pytest.mark.parametrize( "test_input, expected", [ (666, {"n": 666}), (-1, {"n": -1}), ] ) @mark_sync_test def test_n_extra_in_pull(fake_socket, test_input, expected): address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x0.UNPACKER_CLS) connection = Bolt4x0(address, socket, PoolConfig.max_connection_lifetime) connection.pull(n=test_input) connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x3F" assert len(fields) == 1 assert fields[0] == expected @pytest.mark.parametrize( "test_input, expected", [ (777, {"n": -1, "qid": 777}), (-1, {"n": -1}), ] ) @mark_sync_test def test_qid_extra_in_pull(fake_socket, test_input, expected): address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x0.UNPACKER_CLS) connection = Bolt4x0(address, socket, PoolConfig.max_connection_lifetime) connection.pull(qid=test_input) connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x3F" assert len(fields) == 1 assert fields[0] == expected @mark_sync_test def test_n_and_qid_extras_in_pull(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x0.UNPACKER_CLS) connection = Bolt4x0(address, socket, PoolConfig.max_connection_lifetime) connection.pull(n=666, qid=777) connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x3F" assert len(fields) == 1 assert fields[0] == {"n": 666, "qid": 777} @pytest.mark.parametrize("recv_timeout", (1, -1)) @mark_sync_test def test_hint_recv_timeout_seconds_gets_ignored( fake_socket_pair, recv_timeout, mocker ): address = ("127.0.0.1", 7687) sockets = fake_socket_pair(address, packer_cls=Bolt4x0.PACKER_CLS, unpacker_cls=Bolt4x0.UNPACKER_CLS) sockets.client.settimeout = mocker.MagicMock() sockets.server.send_message(b"\x70", { "server": "Neo4j/4.0.0", "hints": {"connection.recv_timeout_seconds": recv_timeout}, }) connection = Bolt4x0( address, sockets.client, PoolConfig.max_connection_lifetime ) connection.hello() sockets.client.settimeout.assert_not_called() neo4j-python-driver-5.2.1/tests/unit/sync/io/test_class_bolt4x1.py000066400000000000000000000164571433522662700251740ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j._conf import PoolConfig from neo4j._sync.io._bolt4 import Bolt4x1 from ...._async_compat import mark_sync_test @pytest.mark.parametrize("set_stale", (True, False)) def test_conn_is_stale(fake_socket, set_stale): address = ("127.0.0.1", 7687) max_connection_lifetime = 0 connection = Bolt4x1(address, fake_socket(address), max_connection_lifetime) if set_stale: connection.set_stale() assert connection.stale() is True @pytest.mark.parametrize("set_stale", (True, False)) def test_conn_is_not_stale_if_not_enabled(fake_socket, set_stale): address = ("127.0.0.1", 7687) max_connection_lifetime = -1 connection = Bolt4x1(address, fake_socket(address), max_connection_lifetime) if set_stale: connection.set_stale() assert connection.stale() is set_stale @pytest.mark.parametrize("set_stale", (True, False)) def test_conn_is_not_stale(fake_socket, set_stale): address = ("127.0.0.1", 7687) max_connection_lifetime = 999999999 connection = Bolt4x1(address, fake_socket(address), max_connection_lifetime) if set_stale: connection.set_stale() assert connection.stale() is set_stale @mark_sync_test def test_db_extra_in_begin(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x1.UNPACKER_CLS) connection = Bolt4x1(address, socket, PoolConfig.max_connection_lifetime) connection.begin(db="something") connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x11" assert len(fields) == 1 assert fields[0] == {"db": "something"} @mark_sync_test def test_db_extra_in_run(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x1.UNPACKER_CLS) connection = Bolt4x1(address, socket, PoolConfig.max_connection_lifetime) connection.run("", {}, db="something") connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x10" assert len(fields) == 3 assert fields[0] == "" assert fields[1] == {} assert fields[2] == {"db": "something"} @mark_sync_test def test_n_extra_in_discard(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x1.UNPACKER_CLS) connection = Bolt4x1(address, socket, PoolConfig.max_connection_lifetime) connection.discard(n=666) connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x2F" assert len(fields) == 1 assert fields[0] == {"n": 666} @pytest.mark.parametrize( "test_input, expected", [ (666, {"n": -1, "qid": 666}), (-1, {"n": -1}), ] ) @mark_sync_test def test_qid_extra_in_discard(fake_socket, test_input, expected): address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x1.UNPACKER_CLS) connection = Bolt4x1(address, socket, PoolConfig.max_connection_lifetime) connection.discard(qid=test_input) connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x2F" assert len(fields) == 1 assert fields[0] == expected @pytest.mark.parametrize( "test_input, expected", [ (777, {"n": 666, "qid": 777}), (-1, {"n": 666}), ] ) @mark_sync_test def test_n_and_qid_extras_in_discard(fake_socket, test_input, expected): # python -m pytest tests/unit/io/test_class_bolt4x0.py -s -k test_n_and_qid_extras_in_discard address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x1.UNPACKER_CLS) connection = Bolt4x1(address, socket, PoolConfig.max_connection_lifetime) connection.discard(n=666, qid=test_input) connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x2F" assert len(fields) == 1 assert fields[0] == expected @pytest.mark.parametrize( "test_input, expected", [ (666, {"n": 666}), (-1, {"n": -1}), ] ) @mark_sync_test def test_n_extra_in_pull(fake_socket, test_input, expected): address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x1.UNPACKER_CLS) connection = Bolt4x1(address, socket, PoolConfig.max_connection_lifetime) connection.pull(n=test_input) connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x3F" assert len(fields) == 1 assert fields[0] == expected @pytest.mark.parametrize( "test_input, expected", [ (777, {"n": -1, "qid": 777}), (-1, {"n": -1}), ] ) @mark_sync_test def test_qid_extra_in_pull(fake_socket, test_input, expected): # python -m pytest tests/unit/io/test_class_bolt4x0.py -s -k test_qid_extra_in_pull address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x1.UNPACKER_CLS) connection = Bolt4x1(address, socket, PoolConfig.max_connection_lifetime) connection.pull(qid=test_input) connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x3F" assert len(fields) == 1 assert fields[0] == expected @mark_sync_test def test_n_and_qid_extras_in_pull(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x1.UNPACKER_CLS) connection = Bolt4x1(address, socket, PoolConfig.max_connection_lifetime) connection.pull(n=666, qid=777) connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x3F" assert len(fields) == 1 assert fields[0] == {"n": 666, "qid": 777} @mark_sync_test def test_hello_passes_routing_metadata(fake_socket_pair): address = ("127.0.0.1", 7687) sockets = fake_socket_pair(address, packer_cls=Bolt4x1.PACKER_CLS, unpacker_cls=Bolt4x1.UNPACKER_CLS) sockets.server.send_message(b"\x70", {"server": "Neo4j/4.1.0"}) connection = Bolt4x1( address, sockets.client, PoolConfig.max_connection_lifetime, routing_context={"foo": "bar"} ) connection.hello() tag, fields = sockets.server.pop_message() assert tag == b"\x01" assert len(fields) == 1 assert fields[0]["routing"] == {"foo": "bar"} @pytest.mark.parametrize("recv_timeout", (1, -1)) @mark_sync_test def test_hint_recv_timeout_seconds_gets_ignored( fake_socket_pair, recv_timeout, mocker ): address = ("127.0.0.1", 7687) sockets = fake_socket_pair(address, packer_cls=Bolt4x1.PACKER_CLS, unpacker_cls=Bolt4x1.UNPACKER_CLS) sockets.client.settimeout = mocker.Mock() sockets.server.send_message(b"\x70", { "server": "Neo4j/4.1.0", "hints": {"connection.recv_timeout_seconds": recv_timeout}, }) connection = Bolt4x1(address, sockets.client, PoolConfig.max_connection_lifetime) connection.hello() sockets.client.settimeout.assert_not_called() neo4j-python-driver-5.2.1/tests/unit/sync/io/test_class_bolt4x2.py000066400000000000000000000164441433522662700251710ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j._conf import PoolConfig from neo4j._sync.io._bolt4 import Bolt4x2 from ...._async_compat import mark_sync_test @pytest.mark.parametrize("set_stale", (True, False)) def test_conn_is_stale(fake_socket, set_stale): address = ("127.0.0.1", 7687) max_connection_lifetime = 0 connection = Bolt4x2(address, fake_socket(address), max_connection_lifetime) if set_stale: connection.set_stale() assert connection.stale() is True @pytest.mark.parametrize("set_stale", (True, False)) def test_conn_is_not_stale_if_not_enabled(fake_socket, set_stale): address = ("127.0.0.1", 7687) max_connection_lifetime = -1 connection = Bolt4x2(address, fake_socket(address), max_connection_lifetime) if set_stale: connection.set_stale() assert connection.stale() is set_stale @pytest.mark.parametrize("set_stale", (True, False)) def test_conn_is_not_stale(fake_socket, set_stale): address = ("127.0.0.1", 7687) max_connection_lifetime = 999999999 connection = Bolt4x2(address, fake_socket(address), max_connection_lifetime) if set_stale: connection.set_stale() assert connection.stale() is set_stale @mark_sync_test def test_db_extra_in_begin(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x2.UNPACKER_CLS) connection = Bolt4x2(address, socket, PoolConfig.max_connection_lifetime) connection.begin(db="something") connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x11" assert len(fields) == 1 assert fields[0] == {"db": "something"} @mark_sync_test def test_db_extra_in_run(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x2.UNPACKER_CLS) connection = Bolt4x2(address, socket, PoolConfig.max_connection_lifetime) connection.run("", {}, db="something") connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x10" assert len(fields) == 3 assert fields[0] == "" assert fields[1] == {} assert fields[2] == {"db": "something"} @mark_sync_test def test_n_extra_in_discard(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x2.UNPACKER_CLS) connection = Bolt4x2(address, socket, PoolConfig.max_connection_lifetime) connection.discard(n=666) connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x2F" assert len(fields) == 1 assert fields[0] == {"n": 666} @pytest.mark.parametrize( "test_input, expected", [ (666, {"n": -1, "qid": 666}), (-1, {"n": -1}), ] ) @mark_sync_test def test_qid_extra_in_discard(fake_socket, test_input, expected): address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x2.UNPACKER_CLS) connection = Bolt4x2(address, socket, PoolConfig.max_connection_lifetime) connection.discard(qid=test_input) connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x2F" assert len(fields) == 1 assert fields[0] == expected @pytest.mark.parametrize( "test_input, expected", [ (777, {"n": 666, "qid": 777}), (-1, {"n": 666}), ] ) @mark_sync_test def test_n_and_qid_extras_in_discard(fake_socket, test_input, expected): # python -m pytest tests/unit/io/test_class_bolt4x0.py -s -k test_n_and_qid_extras_in_discard address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x2.UNPACKER_CLS) connection = Bolt4x2(address, socket, PoolConfig.max_connection_lifetime) connection.discard(n=666, qid=test_input) connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x2F" assert len(fields) == 1 assert fields[0] == expected @pytest.mark.parametrize( "test_input, expected", [ (666, {"n": 666}), (-1, {"n": -1}), ] ) @mark_sync_test def test_n_extra_in_pull(fake_socket, test_input, expected): address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x2.UNPACKER_CLS) connection = Bolt4x2(address, socket, PoolConfig.max_connection_lifetime) connection.pull(n=test_input) connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x3F" assert len(fields) == 1 assert fields[0] == expected @pytest.mark.parametrize( "test_input, expected", [ (777, {"n": -1, "qid": 777}), (-1, {"n": -1}), ] ) @mark_sync_test def test_qid_extra_in_pull(fake_socket, test_input, expected): # python -m pytest tests/unit/io/test_class_bolt4x0.py -s -k test_qid_extra_in_pull address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x2.UNPACKER_CLS) connection = Bolt4x2(address, socket, PoolConfig.max_connection_lifetime) connection.pull(qid=test_input) connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x3F" assert len(fields) == 1 assert fields[0] == expected @mark_sync_test def test_n_and_qid_extras_in_pull(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x2.UNPACKER_CLS) connection = Bolt4x2(address, socket, PoolConfig.max_connection_lifetime) connection.pull(n=666, qid=777) connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x3F" assert len(fields) == 1 assert fields[0] == {"n": 666, "qid": 777} @mark_sync_test def test_hello_passes_routing_metadata(fake_socket_pair): address = ("127.0.0.1", 7687) sockets = fake_socket_pair(address, packer_cls=Bolt4x2.PACKER_CLS, unpacker_cls=Bolt4x2.UNPACKER_CLS) sockets.server.send_message(b"\x70", {"server": "Neo4j/4.2.0"}) connection = Bolt4x2( address, sockets.client, PoolConfig.max_connection_lifetime, routing_context={"foo": "bar"} ) connection.hello() tag, fields = sockets.server.pop_message() assert tag == b"\x01" assert len(fields) == 1 assert fields[0]["routing"] == {"foo": "bar"} @pytest.mark.parametrize("recv_timeout", (1, -1)) @mark_sync_test def test_hint_recv_timeout_seconds_gets_ignored( fake_socket_pair, recv_timeout, mocker ): address = ("127.0.0.1", 7687) sockets = fake_socket_pair(address, packer_cls=Bolt4x2.PACKER_CLS, unpacker_cls=Bolt4x2.UNPACKER_CLS) sockets.client.settimeout = mocker.Mock() sockets.server.send_message(b"\x70", { "server": "Neo4j/4.2.0", "hints": {"connection.recv_timeout_seconds": recv_timeout}, }) connection = Bolt4x2( address, sockets.client, PoolConfig.max_connection_lifetime ) connection.hello() sockets.client.settimeout.assert_not_called() neo4j-python-driver-5.2.1/tests/unit/sync/io/test_class_bolt4x3.py000066400000000000000000000206431433522662700251660ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 logging import pytest from neo4j._conf import PoolConfig from neo4j._sync.io._bolt4 import Bolt4x3 from ...._async_compat import mark_sync_test @pytest.mark.parametrize("set_stale", (True, False)) def test_conn_is_stale(fake_socket, set_stale): address = ("127.0.0.1", 7687) max_connection_lifetime = 0 connection = Bolt4x3(address, fake_socket(address), max_connection_lifetime) if set_stale: connection.set_stale() assert connection.stale() is True @pytest.mark.parametrize("set_stale", (True, False)) def test_conn_is_not_stale_if_not_enabled(fake_socket, set_stale): address = ("127.0.0.1", 7687) max_connection_lifetime = -1 connection = Bolt4x3(address, fake_socket(address), max_connection_lifetime) if set_stale: connection.set_stale() assert connection.stale() is set_stale @pytest.mark.parametrize("set_stale", (True, False)) def test_conn_is_not_stale(fake_socket, set_stale): address = ("127.0.0.1", 7687) max_connection_lifetime = 999999999 connection = Bolt4x3(address, fake_socket(address), max_connection_lifetime) if set_stale: connection.set_stale() assert connection.stale() is set_stale @mark_sync_test def test_db_extra_in_begin(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x3.UNPACKER_CLS) connection = Bolt4x3(address, socket, PoolConfig.max_connection_lifetime) connection.begin(db="something") connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x11" assert len(fields) == 1 assert fields[0] == {"db": "something"} @mark_sync_test def test_db_extra_in_run(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x3.UNPACKER_CLS) connection = Bolt4x3(address, socket, PoolConfig.max_connection_lifetime) connection.run("", {}, db="something") connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x10" assert len(fields) == 3 assert fields[0] == "" assert fields[1] == {} assert fields[2] == {"db": "something"} @mark_sync_test def test_n_extra_in_discard(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x3.UNPACKER_CLS) connection = Bolt4x3(address, socket, PoolConfig.max_connection_lifetime) connection.discard(n=666) connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x2F" assert len(fields) == 1 assert fields[0] == {"n": 666} @pytest.mark.parametrize( "test_input, expected", [ (666, {"n": -1, "qid": 666}), (-1, {"n": -1}), ] ) @mark_sync_test def test_qid_extra_in_discard(fake_socket, test_input, expected): address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x3.UNPACKER_CLS) connection = Bolt4x3(address, socket, PoolConfig.max_connection_lifetime) connection.discard(qid=test_input) connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x2F" assert len(fields) == 1 assert fields[0] == expected @pytest.mark.parametrize( "test_input, expected", [ (777, {"n": 666, "qid": 777}), (-1, {"n": 666}), ] ) @mark_sync_test def test_n_and_qid_extras_in_discard(fake_socket, test_input, expected): # python -m pytest tests/unit/io/test_class_bolt4x0.py -s -k test_n_and_qid_extras_in_discard address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x3.UNPACKER_CLS) connection = Bolt4x3(address, socket, PoolConfig.max_connection_lifetime) connection.discard(n=666, qid=test_input) connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x2F" assert len(fields) == 1 assert fields[0] == expected @pytest.mark.parametrize( "test_input, expected", [ (666, {"n": 666}), (-1, {"n": -1}), ] ) @mark_sync_test def test_n_extra_in_pull(fake_socket, test_input, expected): address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x3.UNPACKER_CLS) connection = Bolt4x3(address, socket, PoolConfig.max_connection_lifetime) connection.pull(n=test_input) connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x3F" assert len(fields) == 1 assert fields[0] == expected @pytest.mark.parametrize( "test_input, expected", [ (777, {"n": -1, "qid": 777}), (-1, {"n": -1}), ] ) @mark_sync_test def test_qid_extra_in_pull(fake_socket, test_input, expected): # python -m pytest tests/unit/io/test_class_bolt4x0.py -s -k test_qid_extra_in_pull address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x3.UNPACKER_CLS) connection = Bolt4x3(address, socket, PoolConfig.max_connection_lifetime) connection.pull(qid=test_input) connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x3F" assert len(fields) == 1 assert fields[0] == expected @mark_sync_test def test_n_and_qid_extras_in_pull(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x3.UNPACKER_CLS) connection = Bolt4x3(address, socket, PoolConfig.max_connection_lifetime) connection.pull(n=666, qid=777) connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x3F" assert len(fields) == 1 assert fields[0] == {"n": 666, "qid": 777} @mark_sync_test def test_hello_passes_routing_metadata(fake_socket_pair): address = ("127.0.0.1", 7687) sockets = fake_socket_pair(address, packer_cls=Bolt4x3.PACKER_CLS, unpacker_cls=Bolt4x3.UNPACKER_CLS) sockets.server.send_message(b"\x70", {"server": "Neo4j/4.3.0"}) connection = Bolt4x3( address, sockets.client, PoolConfig.max_connection_lifetime, routing_context={"foo": "bar"} ) connection.hello() tag, fields = sockets.server.pop_message() assert tag == b"\x01" assert len(fields) == 1 assert fields[0]["routing"] == {"foo": "bar"} @pytest.mark.parametrize(("hints", "valid"), ( ({"connection.recv_timeout_seconds": 1}, True), ({"connection.recv_timeout_seconds": 42}, True), ({}, True), ({"whatever_this_is": "ignore me!"}, True), ({"connection.recv_timeout_seconds": -1}, False), ({"connection.recv_timeout_seconds": 0}, False), ({"connection.recv_timeout_seconds": 2.5}, False), ({"connection.recv_timeout_seconds": None}, False), ({"connection.recv_timeout_seconds": False}, False), ({"connection.recv_timeout_seconds": "1"}, False), )) @mark_sync_test def test_hint_recv_timeout_seconds( fake_socket_pair, hints, valid, caplog, mocker ): address = ("127.0.0.1", 7687) sockets = fake_socket_pair(address, packer_cls=Bolt4x3.PACKER_CLS, unpacker_cls=Bolt4x3.UNPACKER_CLS) sockets.client.settimeout = mocker.Mock() sockets.server.send_message( b"\x70", {"server": "Neo4j/4.3.0", "hints": hints} ) connection = Bolt4x3( address, sockets.client, PoolConfig.max_connection_lifetime ) with caplog.at_level(logging.INFO): connection.hello() if valid: if "connection.recv_timeout_seconds" in hints: sockets.client.settimeout.assert_called_once_with( hints["connection.recv_timeout_seconds"] ) else: sockets.client.settimeout.assert_not_called() assert not any("recv_timeout_seconds" in msg and "invalid" in msg for msg in caplog.messages) else: sockets.client.settimeout.assert_not_called() assert any(repr(hints["connection.recv_timeout_seconds"]) in msg and "recv_timeout_seconds" in msg and "invalid" in msg for msg in caplog.messages) neo4j-python-driver-5.2.1/tests/unit/sync/io/test_class_bolt4x4.py000066400000000000000000000220601433522662700251620ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 logging import pytest from neo4j._conf import PoolConfig from neo4j._sync.io._bolt4 import Bolt4x4 from ...._async_compat import mark_sync_test @pytest.mark.parametrize("set_stale", (True, False)) def test_conn_is_stale(fake_socket, set_stale): address = ("127.0.0.1", 7687) max_connection_lifetime = 0 connection = Bolt4x4(address, fake_socket(address), max_connection_lifetime) if set_stale: connection.set_stale() assert connection.stale() is True @pytest.mark.parametrize("set_stale", (True, False)) def test_conn_is_not_stale_if_not_enabled(fake_socket, set_stale): address = ("127.0.0.1", 7687) max_connection_lifetime = -1 connection = Bolt4x4(address, fake_socket(address), max_connection_lifetime) if set_stale: connection.set_stale() assert connection.stale() is set_stale @pytest.mark.parametrize("set_stale", (True, False)) def test_conn_is_not_stale(fake_socket, set_stale): address = ("127.0.0.1", 7687) max_connection_lifetime = 999999999 connection = Bolt4x4(address, fake_socket(address), max_connection_lifetime) if set_stale: connection.set_stale() assert connection.stale() is set_stale @pytest.mark.parametrize(("args", "kwargs", "expected_fields"), ( (("", {}), {"db": "something"}, ({"db": "something"},)), (("", {}), {"imp_user": "imposter"}, ({"imp_user": "imposter"},)), ( ("", {}), {"db": "something", "imp_user": "imposter"}, ({"db": "something", "imp_user": "imposter"},) ), )) @mark_sync_test def test_extra_in_begin(fake_socket, args, kwargs, expected_fields): address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x4.UNPACKER_CLS) connection = Bolt4x4(address, socket, PoolConfig.max_connection_lifetime) connection.begin(*args, **kwargs) connection.send_all() tag, is_fields = socket.pop_message() assert tag == b"\x11" assert tuple(is_fields) == expected_fields @pytest.mark.parametrize(("args", "kwargs", "expected_fields"), ( (("", {}), {"db": "something"}, ("", {}, {"db": "something"})), (("", {}), {"imp_user": "imposter"}, ("", {}, {"imp_user": "imposter"})), ( ("", {}), {"db": "something", "imp_user": "imposter"}, ("", {}, {"db": "something", "imp_user": "imposter"}) ), )) @mark_sync_test def test_extra_in_run(fake_socket, args, kwargs, expected_fields): address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x4.UNPACKER_CLS) connection = Bolt4x4(address, socket, PoolConfig.max_connection_lifetime) connection.run(*args, **kwargs) connection.send_all() tag, is_fields = socket.pop_message() assert tag == b"\x10" assert tuple(is_fields) == expected_fields @mark_sync_test def test_n_extra_in_discard(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x4.UNPACKER_CLS) connection = Bolt4x4(address, socket, PoolConfig.max_connection_lifetime) connection.discard(n=666) connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x2F" assert len(fields) == 1 assert fields[0] == {"n": 666} @pytest.mark.parametrize( "test_input, expected", [ (666, {"n": -1, "qid": 666}), (-1, {"n": -1}), ] ) @mark_sync_test def test_qid_extra_in_discard(fake_socket, test_input, expected): address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x4.UNPACKER_CLS) connection = Bolt4x4(address, socket, PoolConfig.max_connection_lifetime) connection.discard(qid=test_input) connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x2F" assert len(fields) == 1 assert fields[0] == expected @pytest.mark.parametrize( "test_input, expected", [ (777, {"n": 666, "qid": 777}), (-1, {"n": 666}), ] ) @mark_sync_test def test_n_and_qid_extras_in_discard(fake_socket, test_input, expected): # python -m pytest tests/unit/io/test_class_bolt4x0.py -s -k test_n_and_qid_extras_in_discard address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x4.UNPACKER_CLS) connection = Bolt4x4(address, socket, PoolConfig.max_connection_lifetime) connection.discard(n=666, qid=test_input) connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x2F" assert len(fields) == 1 assert fields[0] == expected @pytest.mark.parametrize( "test_input, expected", [ (666, {"n": 666}), (-1, {"n": -1}), ] ) @mark_sync_test def test_n_extra_in_pull(fake_socket, test_input, expected): address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x4.UNPACKER_CLS) connection = Bolt4x4(address, socket, PoolConfig.max_connection_lifetime) connection.pull(n=test_input) connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x3F" assert len(fields) == 1 assert fields[0] == expected @pytest.mark.parametrize( "test_input, expected", [ (777, {"n": -1, "qid": 777}), (-1, {"n": -1}), ] ) @mark_sync_test def test_qid_extra_in_pull(fake_socket, test_input, expected): # python -m pytest tests/unit/io/test_class_bolt4x0.py -s -k test_qid_extra_in_pull address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x4.UNPACKER_CLS) connection = Bolt4x4(address, socket, PoolConfig.max_connection_lifetime) connection.pull(qid=test_input) connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x3F" assert len(fields) == 1 assert fields[0] == expected @mark_sync_test def test_n_and_qid_extras_in_pull(fake_socket): address = ("127.0.0.1", 7687) socket = fake_socket(address, Bolt4x4.UNPACKER_CLS) connection = Bolt4x4(address, socket, PoolConfig.max_connection_lifetime) connection.pull(n=666, qid=777) connection.send_all() tag, fields = socket.pop_message() assert tag == b"\x3F" assert len(fields) == 1 assert fields[0] == {"n": 666, "qid": 777} @mark_sync_test def test_hello_passes_routing_metadata(fake_socket_pair): address = ("127.0.0.1", 7687) sockets = fake_socket_pair(address, packer_cls=Bolt4x4.PACKER_CLS, unpacker_cls=Bolt4x4.UNPACKER_CLS) sockets.server.send_message(b"\x70", {"server": "Neo4j/4.4.0"}) connection = Bolt4x4( address, sockets.client, PoolConfig.max_connection_lifetime, routing_context={"foo": "bar"} ) connection.hello() tag, fields = sockets.server.pop_message() assert tag == b"\x01" assert len(fields) == 1 assert fields[0]["routing"] == {"foo": "bar"} @pytest.mark.parametrize(("hints", "valid"), ( ({"connection.recv_timeout_seconds": 1}, True), ({"connection.recv_timeout_seconds": 42}, True), ({}, True), ({"whatever_this_is": "ignore me!"}, True), ({"connection.recv_timeout_seconds": -1}, False), ({"connection.recv_timeout_seconds": 0}, False), ({"connection.recv_timeout_seconds": 2.5}, False), ({"connection.recv_timeout_seconds": None}, False), ({"connection.recv_timeout_seconds": False}, False), ({"connection.recv_timeout_seconds": "1"}, False), )) @mark_sync_test def test_hint_recv_timeout_seconds( fake_socket_pair, hints, valid, caplog, mocker ): address = ("127.0.0.1", 7687) sockets = fake_socket_pair(address, packer_cls=Bolt4x4.PACKER_CLS, unpacker_cls=Bolt4x4.UNPACKER_CLS) sockets.client.settimeout = mocker.Mock() sockets.server.send_message( b"\x70", {"server": "Neo4j/4.3.4", "hints": hints} ) connection = Bolt4x4( address, sockets.client, PoolConfig.max_connection_lifetime ) with caplog.at_level(logging.INFO): connection.hello() if valid: if "connection.recv_timeout_seconds" in hints: sockets.client.settimeout.assert_called_once_with( hints["connection.recv_timeout_seconds"] ) else: sockets.client.settimeout.assert_not_called() assert not any("recv_timeout_seconds" in msg and "invalid" in msg for msg in caplog.messages) else: sockets.client.settimeout.assert_not_called() assert any(repr(hints["connection.recv_timeout_seconds"]) in msg and "recv_timeout_seconds" in msg and "invalid" in msg for msg in caplog.messages) neo4j-python-driver-5.2.1/tests/unit/sync/io/test_direct.py000066400000000000000000000152231433522662700237520ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 pytest from neo4j._conf import ( Config, PoolConfig, WorkspaceConfig, ) from neo4j._deadline import Deadline from neo4j._sync.io import Bolt from neo4j._sync.io._pool import IOPool from neo4j.exceptions import ( ClientError, ServiceUnavailable, ) from ...._async_compat import mark_sync_test class FakeSocket: def __init__(self, address): self.address = address def getpeername(self): return self.address def sendall(self, data): return def close(self): return class QuickConnection: def __init__(self, socket): self.socket = socket self.address = socket.getpeername() self.local_port = self.address[1] self.connection_id = "bolt-1234" @property def is_reset(self): return True def stale(self): return False def reset(self): pass def close(self): self.socket.close() def closed(self): return False def defunct(self): return False def timedout(self): return False class FakeBoltPool(IOPool): def __init__(self, address, *, auth=None, **config): self.pool_config, self.workspace_config = Config.consume_chain(config, PoolConfig, WorkspaceConfig) if config: raise ValueError("Unexpected config keys: %s" % ", ".join(config.keys())) def opener(addr, timeout): return QuickConnection(FakeSocket(addr)) super().__init__(opener, self.pool_config, self.workspace_config) self.address = address def acquire( self, access_mode, timeout, database, bookmarks, liveness_check_timeout ): return self._acquire( self.address, timeout, liveness_check_timeout ) @mark_sync_test def test_bolt_connection_open(): with pytest.raises(ServiceUnavailable): Bolt.open(("localhost", 9999), auth=("test", "test")) @mark_sync_test def test_bolt_connection_open_timeout(): with pytest.raises(ServiceUnavailable): Bolt.open(("localhost", 9999), auth=("test", "test"), timeout=1) @mark_sync_test def test_bolt_connection_ping(): protocol_version = Bolt.ping(("localhost", 9999)) assert protocol_version is None @mark_sync_test def test_bolt_connection_ping_timeout(): protocol_version = Bolt.ping(("localhost", 9999), timeout=1) assert protocol_version is None @pytest.fixture def pool(): with FakeBoltPool(("127.0.0.1", 7687)) as pool: yield pool def assert_pool_size( address, expected_active, expected_inactive, pool): try: connections = pool.connections[address] except KeyError: assert 0 == expected_active assert 0 == expected_inactive else: assert expected_active == len([cx for cx in connections if cx.in_use]) assert (expected_inactive == len([cx for cx in connections if not cx.in_use])) @mark_sync_test def test_pool_can_acquire(pool): address = ("127.0.0.1", 7687) connection = pool._acquire(address, Deadline(3), None) assert connection.address == address assert_pool_size(address, 1, 0, pool) @mark_sync_test def test_pool_can_acquire_twice(pool): address = ("127.0.0.1", 7687) connection_1 = pool._acquire(address, Deadline(3), None) connection_2 = pool._acquire(address, Deadline(3), None) assert connection_1.address == address assert connection_2.address == address assert connection_1 is not connection_2 assert_pool_size(address, 2, 0, pool) @mark_sync_test def test_pool_can_acquire_two_addresses(pool): address_1 = ("127.0.0.1", 7687) address_2 = ("127.0.0.1", 7474) connection_1 = pool._acquire(address_1, Deadline(3), None) connection_2 = pool._acquire(address_2, Deadline(3), None) assert connection_1.address == address_1 assert connection_2.address == address_2 assert_pool_size(address_1, 1, 0, pool) assert_pool_size(address_2, 1, 0, pool) @mark_sync_test def test_pool_can_acquire_and_release(pool): address = ("127.0.0.1", 7687) connection = pool._acquire(address, Deadline(3), None) assert_pool_size(address, 1, 0, pool) pool.release(connection) assert_pool_size(address, 0, 1, pool) @mark_sync_test def test_pool_releasing_twice(pool): address = ("127.0.0.1", 7687) connection = pool._acquire(address, Deadline(3), None) pool.release(connection) assert_pool_size(address, 0, 1, pool) pool.release(connection) assert_pool_size(address, 0, 1, pool) @mark_sync_test def test_pool_in_use_count(pool): address = ("127.0.0.1", 7687) assert pool.in_use_connection_count(address) == 0 connection = pool._acquire(address, Deadline(3), None) assert pool.in_use_connection_count(address) == 1 pool.release(connection) assert pool.in_use_connection_count(address) == 0 @mark_sync_test def test_pool_max_conn_pool_size(pool): with FakeBoltPool((), max_connection_pool_size=1) as pool: address = ("127.0.0.1", 7687) pool._acquire(address, Deadline(0), None) assert pool.in_use_connection_count(address) == 1 with pytest.raises(ClientError): pool._acquire(address, Deadline(0), None) assert pool.in_use_connection_count(address) == 1 @pytest.mark.parametrize("is_reset", (True, False)) @mark_sync_test def test_pool_reset_when_released(is_reset, pool, mocker): address = ("127.0.0.1", 7687) quick_connection_name = QuickConnection.__name__ is_reset_mock = mocker.patch( f"{__name__}.{quick_connection_name}.is_reset", new_callable=mocker.PropertyMock ) reset_mock = mocker.patch( f"{__name__}.{quick_connection_name}.reset", new_callable=mocker.Mock ) is_reset_mock.return_value = is_reset connection = pool._acquire(address, Deadline(3), None) assert isinstance(connection, QuickConnection) assert is_reset_mock.call_count == 0 assert reset_mock.call_count == 0 pool.release(connection) assert is_reset_mock.call_count == 1 assert reset_mock.call_count == int(not is_reset) neo4j-python-driver-5.2.1/tests/unit/sync/io/test_neo4j_pool.py000066400000000000000000000356741433522662700245640ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 inspect import pytest from neo4j import ( READ_ACCESS, WRITE_ACCESS, ) from neo4j._async_compat.util import Util from neo4j._conf import ( PoolConfig, RoutingConfig, WorkspaceConfig, ) from neo4j._deadline import Deadline from neo4j._sync.io import Neo4jPool from neo4j.addressing import ResolvedAddress from neo4j.exceptions import ( ServiceUnavailable, SessionExpired, ) from ...._async_compat import mark_sync_test ROUTER_ADDRESS = ResolvedAddress(("1.2.3.1", 9001), host_name="host") READER_ADDRESS = ResolvedAddress(("1.2.3.1", 9002), host_name="host") WRITER_ADDRESS = ResolvedAddress(("1.2.3.1", 9003), host_name="host") @pytest.fixture def opener(fake_connection_generator, mocker): def open_(addr, timeout): connection = fake_connection_generator() connection.addr = addr connection.timeout = timeout route_mock = mocker.Mock() route_mock.return_value = [{ "ttl": 1000, "servers": [ {"addresses": [str(ROUTER_ADDRESS)], "role": "ROUTE"}, {"addresses": [str(READER_ADDRESS)], "role": "READ"}, {"addresses": [str(WRITER_ADDRESS)], "role": "WRITE"}, ], }] connection.attach_mock(route_mock, "route") opener_.connections.append(connection) return connection opener_ = mocker.Mock() opener_.connections = [] opener_.side_effect = open_ return opener_ @mark_sync_test def test_acquires_new_routing_table_if_deleted(opener): pool = Neo4jPool( opener, PoolConfig(), WorkspaceConfig(), ROUTER_ADDRESS ) cx = pool.acquire(READ_ACCESS, 30, "test_db", None, None) pool.release(cx) assert pool.routing_tables.get("test_db") del pool.routing_tables["test_db"] cx = pool.acquire(READ_ACCESS, 30, "test_db", None, None) pool.release(cx) assert pool.routing_tables.get("test_db") @mark_sync_test def test_acquires_new_routing_table_if_stale(opener): pool = Neo4jPool( opener, PoolConfig(), WorkspaceConfig(), ROUTER_ADDRESS ) cx = pool.acquire(READ_ACCESS, 30, "test_db", None, None) pool.release(cx) assert pool.routing_tables.get("test_db") old_value = pool.routing_tables["test_db"].last_updated_time pool.routing_tables["test_db"].ttl = 0 cx = pool.acquire(READ_ACCESS, 30, "test_db", None, None) pool.release(cx) assert pool.routing_tables["test_db"].last_updated_time > old_value @mark_sync_test def test_removes_old_routing_table(opener): pool = Neo4jPool( opener, PoolConfig(), WorkspaceConfig(), ROUTER_ADDRESS ) cx = pool.acquire(READ_ACCESS, 30, "test_db1", None, None) pool.release(cx) assert pool.routing_tables.get("test_db1") cx = pool.acquire(READ_ACCESS, 30, "test_db2", None, None) pool.release(cx) assert pool.routing_tables.get("test_db2") old_value = pool.routing_tables["test_db1"].last_updated_time pool.routing_tables["test_db1"].ttl = 0 pool.routing_tables["test_db2"].ttl = \ -RoutingConfig.routing_table_purge_delay cx = pool.acquire(READ_ACCESS, 30, "test_db1", None, None) pool.release(cx) assert pool.routing_tables["test_db1"].last_updated_time > old_value assert "test_db2" not in pool.routing_tables @pytest.mark.parametrize("type_", ("r", "w")) @mark_sync_test def test_chooses_right_connection_type(opener, type_): pool = Neo4jPool( opener, PoolConfig(), WorkspaceConfig(), ROUTER_ADDRESS ) cx1 = pool.acquire( READ_ACCESS if type_ == "r" else WRITE_ACCESS, 30, "test_db", None, None ) pool.release(cx1) if type_ == "r": assert cx1.addr == READER_ADDRESS else: assert cx1.addr == WRITER_ADDRESS @mark_sync_test def test_reuses_connection(opener): pool = Neo4jPool( opener, PoolConfig(), WorkspaceConfig(), ROUTER_ADDRESS ) cx1 = pool.acquire(READ_ACCESS, 30, "test_db", None, None) pool.release(cx1) cx2 = pool.acquire(READ_ACCESS, 30, "test_db", None, None) assert cx1 is cx2 @pytest.mark.parametrize("break_on_close", (True, False)) @mark_sync_test def test_closes_stale_connections(opener, break_on_close): def break_connection(): pool.deactivate(cx1.addr) if cx_close_mock_side_effect: res = cx_close_mock_side_effect() if inspect.isawaitable(res): return res pool = Neo4jPool( opener, PoolConfig(), WorkspaceConfig(), ROUTER_ADDRESS ) cx1 = pool.acquire(READ_ACCESS, 30, "test_db", None, None) pool.release(cx1) assert cx1 in pool.connections[cx1.addr] # simulate connection going stale (e.g. exceeding) and then breaking when # the pool tries to close the connection cx1.stale.return_value = True cx_close_mock = cx1.close if break_on_close: cx_close_mock_side_effect = cx_close_mock.side_effect cx_close_mock.side_effect = break_connection cx2 = pool.acquire(READ_ACCESS, 30, "test_db", None, None) pool.release(cx2) if break_on_close: cx1.close.assert_called() else: cx1.close.assert_called_once() assert cx2 is not cx1 assert cx2.addr == cx1.addr assert cx1 not in pool.connections[cx1.addr] assert cx2 in pool.connections[cx2.addr] @mark_sync_test def test_does_not_close_stale_connections_in_use(opener): pool = Neo4jPool( opener, PoolConfig(), WorkspaceConfig(), ROUTER_ADDRESS ) cx1 = pool.acquire(READ_ACCESS, 30, "test_db", None, None) assert cx1 in pool.connections[cx1.addr] # simulate connection going stale (e.g. exceeding) while being in use cx1.stale.return_value = True cx2 = pool.acquire(READ_ACCESS, 30, "test_db", None, None) pool.release(cx2) cx1.close.assert_not_called() assert cx2 is not cx1 assert cx2.addr == cx1.addr assert cx1 in pool.connections[cx1.addr] assert cx2 in pool.connections[cx2.addr] pool.release(cx1) # now that cx1 is back in the pool and still stale, # it should be closed when trying to acquire the next connection cx1.close.assert_not_called() cx3 = pool.acquire(READ_ACCESS, 30, "test_db", None, None) pool.release(cx3) cx1.close.assert_called_once() assert cx2 is cx3 assert cx3.addr == cx1.addr assert cx1 not in pool.connections[cx1.addr] assert cx3 in pool.connections[cx2.addr] @mark_sync_test def test_release_resets_connections(opener): pool = Neo4jPool( opener, PoolConfig(), WorkspaceConfig(), ROUTER_ADDRESS ) cx1 = pool.acquire(READ_ACCESS, 30, "test_db", None, None) cx1.is_reset_mock.return_value = False cx1.is_reset_mock.reset_mock() pool.release(cx1) cx1.is_reset_mock.assert_called_once() cx1.reset.assert_called_once() @mark_sync_test def test_release_does_not_resets_closed_connections(opener): pool = Neo4jPool( opener, PoolConfig(), WorkspaceConfig(), ROUTER_ADDRESS ) cx1 = pool.acquire(READ_ACCESS, 30, "test_db", None, None) cx1.closed.return_value = True cx1.closed.reset_mock() cx1.is_reset_mock.reset_mock() pool.release(cx1) cx1.closed.assert_called_once() cx1.is_reset_mock.assert_not_called() cx1.reset.assert_not_called() @mark_sync_test def test_release_does_not_resets_defunct_connections(opener): pool = Neo4jPool( opener, PoolConfig(), WorkspaceConfig(), ROUTER_ADDRESS ) cx1 = pool.acquire(READ_ACCESS, 30, "test_db", None, None) cx1.defunct.return_value = True cx1.defunct.reset_mock() cx1.is_reset_mock.reset_mock() pool.release(cx1) cx1.defunct.assert_called_once() cx1.is_reset_mock.assert_not_called() cx1.reset.assert_not_called() @pytest.mark.parametrize("liveness_timeout", (0, 1, 2)) @mark_sync_test def test_acquire_performs_no_liveness_check_on_fresh_connection( opener, liveness_timeout ): pool = Neo4jPool( opener, PoolConfig(), WorkspaceConfig(), ROUTER_ADDRESS ) cx1 = pool._acquire(READER_ADDRESS, Deadline(30), liveness_timeout) assert cx1.addr == READER_ADDRESS cx1.reset.assert_not_called() @pytest.mark.parametrize("liveness_timeout", (0, 1, 2)) @mark_sync_test def test_acquire_performs_liveness_check_on_existing_connection( opener, liveness_timeout ): pool = Neo4jPool( opener, PoolConfig(), WorkspaceConfig(), ROUTER_ADDRESS ) # populate the pool with a connection cx1 = pool._acquire(READER_ADDRESS, Deadline(30), liveness_timeout) # make sure we assume the right state assert cx1.addr == READER_ADDRESS cx1.is_idle_for.assert_not_called() cx1.reset.assert_not_called() cx1.is_idle_for.return_value = True # release the connection pool.release(cx1) cx1.reset.assert_not_called() # then acquire it again and assert the liveness check was performed cx2 = pool._acquire(READER_ADDRESS, Deadline(30), liveness_timeout) assert cx1 is cx2 cx1.is_idle_for.assert_called_once_with(liveness_timeout) cx2.reset.assert_called_once() @pytest.mark.parametrize("liveness_error", (OSError, ServiceUnavailable, SessionExpired)) @mark_sync_test def test_acquire_creates_connection_on_failed_liveness_check( opener, liveness_error ): def liveness_side_effect(*args, **kwargs): raise liveness_error("liveness check failed") liveness_timeout = 1 pool = Neo4jPool( opener, PoolConfig(), WorkspaceConfig(), ROUTER_ADDRESS ) # populate the pool with a connection cx1 = pool._acquire(READER_ADDRESS, Deadline(30), liveness_timeout) # make sure we assume the right state assert cx1.addr == READER_ADDRESS cx1.is_idle_for.assert_not_called() cx1.reset.assert_not_called() cx1.is_idle_for.return_value = True # simulate cx1 failing liveness check cx1.reset.side_effect = liveness_side_effect # release the connection pool.release(cx1) cx1.reset.assert_not_called() # then acquire it again and assert the liveness check was performed cx2 = pool._acquire(READER_ADDRESS, Deadline(30), liveness_timeout) assert cx1 is not cx2 assert cx1.addr == cx2.addr cx1.is_idle_for.assert_called_once_with(liveness_timeout) cx2.reset.assert_not_called() assert cx1 not in pool.connections[cx1.addr] assert cx2 in pool.connections[cx1.addr] @pytest.mark.parametrize("liveness_error", (OSError, ServiceUnavailable, SessionExpired)) @mark_sync_test def test_acquire_returns_other_connection_on_failed_liveness_check( opener, liveness_error ): def liveness_side_effect(*args, **kwargs): raise liveness_error("liveness check failed") liveness_timeout = 1 pool = Neo4jPool( opener, PoolConfig(), WorkspaceConfig(), ROUTER_ADDRESS ) # populate the pool with a connection cx1 = pool._acquire(READER_ADDRESS, Deadline(30), liveness_timeout) cx2 = pool._acquire(READER_ADDRESS, Deadline(30), liveness_timeout) # make sure we assume the right state assert cx1.addr == READER_ADDRESS assert cx2.addr == READER_ADDRESS assert cx1 is not cx2 cx1.is_idle_for.assert_not_called() cx2.is_idle_for.assert_not_called() cx1.reset.assert_not_called() cx1.is_idle_for.return_value = True cx2.is_idle_for.return_value = True # simulate cx1 failing liveness check cx1.reset.side_effect = liveness_side_effect # release the connection pool.release(cx1) pool.release(cx2) cx1.reset.assert_not_called() cx2.reset.assert_not_called() # then acquire it again and assert the liveness check was performed cx3 = pool._acquire(READER_ADDRESS, Deadline(30), liveness_timeout) assert cx3 is cx2 cx1.is_idle_for.assert_called_once_with(liveness_timeout) cx1.reset.assert_called_once() cx3.is_idle_for.assert_called_once_with(liveness_timeout) cx3.reset.assert_called_once() assert cx1 not in pool.connections[cx1.addr] assert cx3 in pool.connections[cx1.addr] @mark_sync_test def test_multiple_broken_connections_on_close(opener, mocker): def mock_connection_breaks_on_close(cx): def close_side_effect(): cx.closed.return_value = True cx.defunct.return_value = True pool.deactivate(READER_ADDRESS) cx.attach_mock(mocker.Mock(side_effect=close_side_effect), "close") # create pool with 2 idle connections pool = Neo4jPool( opener, PoolConfig(), WorkspaceConfig(), ROUTER_ADDRESS ) cx1 = pool.acquire(READ_ACCESS, 30, "test_db", None, None) cx2 = pool.acquire(READ_ACCESS, 30, "test_db", None, None) pool.release(cx1) pool.release(cx2) # both will loose connection mock_connection_breaks_on_close(cx1) mock_connection_breaks_on_close(cx2) # force pool to close cx1, which will make it realize that the server is # unreachable cx1.stale.return_value = True cx3 = pool.acquire(READ_ACCESS, 30, "test_db", None, None) assert cx3 is not cx1 assert cx3 is not cx2 @mark_sync_test def test_failing_opener_leaves_connections_in_use_alone(opener): pool = Neo4jPool( opener, PoolConfig(), WorkspaceConfig(), ROUTER_ADDRESS ) cx1 = pool.acquire(READ_ACCESS, 30, "test_db", None, None) opener.side_effect = ServiceUnavailable("Server overloaded") with pytest.raises((ServiceUnavailable, SessionExpired)): pool.acquire(READ_ACCESS, 30, "test_db", None, None) assert not cx1.closed() @mark_sync_test def test__acquire_new_later_with_room(opener): config = PoolConfig() config.max_connection_pool_size = 1 pool = Neo4jPool( opener, config, WorkspaceConfig(), ROUTER_ADDRESS ) assert pool.connections_reservations[READER_ADDRESS] == 0 creator = pool._acquire_new_later(READER_ADDRESS, Deadline(1)) assert pool.connections_reservations[READER_ADDRESS] == 1 assert callable(creator) if Util.is_async_code: assert inspect.iscoroutinefunction(creator) @mark_sync_test def test__acquire_new_later_without_room(opener): config = PoolConfig() config.max_connection_pool_size = 1 pool = Neo4jPool( opener, config, WorkspaceConfig(), ROUTER_ADDRESS ) _ = pool.acquire(READ_ACCESS, 30, "test_db", None, None) # pool is full now assert pool.connections_reservations[READER_ADDRESS] == 0 creator = pool._acquire_new_later(READER_ADDRESS, Deadline(1)) assert pool.connections_reservations[READER_ADDRESS] == 0 assert creator is None neo4j-python-driver-5.2.1/tests/unit/sync/test_addressing.py000066400000000000000000000073621433522662700242210ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 socket import ( AF_INET, AF_INET6, ) import pytest from neo4j import ( Address, IPv4Address, ) from neo4j._async_compat.network import NetworkUtil from neo4j._async_compat.util import Util from ..._async_compat import mark_sync_test @mark_sync_test def test_address_resolve() -> None: address = Address(("127.0.0.1", 7687)) resolved = NetworkUtil.resolve_address(address) resolved = Util.list(resolved) assert isinstance(resolved, Address) is False assert isinstance(resolved, list) is True assert len(resolved) == 1 assert resolved[0] == IPv4Address(('127.0.0.1', 7687)) @mark_sync_test def test_address_resolve_with_custom_resolver_none() -> None: address = Address(("127.0.0.1", 7687)) resolved = NetworkUtil.resolve_address(address, resolver=None) resolved = Util.list(resolved) assert isinstance(resolved, Address) is False assert isinstance(resolved, list) is True assert len(resolved) == 1 assert resolved[0] == IPv4Address(('127.0.0.1', 7687)) @pytest.mark.parametrize( "test_input, expected", [ (Address(("127.0.0.1", "abcd")), ValueError), (Address((None, None)), ValueError), ] ) @mark_sync_test def test_address_resolve_with_unresolvable_address( test_input, expected ) -> None: with pytest.raises(expected): Util.list( NetworkUtil.resolve_address(test_input, resolver=None) ) @mark_sync_test @pytest.mark.parametrize("resolver_type", ("sync", "async")) def test_address_resolve_with_custom_resolver(resolver_type) -> None: def custom_resolver_sync(_): return [("127.0.0.1", 7687), ("localhost", 1234)] def custom_resolver_async(_): return [("127.0.0.1", 7687), ("localhost", 1234)] if resolver_type == "sync": custom_resolver = custom_resolver_sync else: custom_resolver = custom_resolver_async address = Address(("127.0.0.1", 7687)) resolved = NetworkUtil.resolve_address( address, family=AF_INET, resolver=custom_resolver ) resolved = Util.list(resolved) assert isinstance(resolved, Address) is False assert isinstance(resolved, list) is True assert len(resolved) == 2 # IPv4 only assert resolved[0] == IPv4Address(('127.0.0.1', 7687)) assert resolved[1] == IPv4Address(('127.0.0.1', 1234)) @mark_sync_test def test_address_unresolve() -> None: def custom_resolver(_): return custom_resolved custom_resolved = [("127.0.0.1", 7687), ("localhost", 4321)] address = Address(("foobar", 1234)) unresolved = address.unresolved assert address.__class__ == unresolved.__class__ assert address == unresolved resolved = NetworkUtil.resolve_address( address, family=AF_INET, resolver=custom_resolver ) resolved_list = Util.list(resolved) custom_resolved_addresses = sorted(Address(a) for a in custom_resolved) unresolved_list = sorted(a.unresolved for a in resolved_list) assert custom_resolved_addresses == unresolved_list assert (list(map(lambda a: a.__class__, custom_resolved_addresses)) == list(map(lambda a: a.__class__, unresolved_list))) neo4j-python-driver-5.2.1/tests/unit/sync/test_bookmark_manager.py000066400000000000000000000221021433522662700253620ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations import itertools import typing as t import pytest import neo4j from neo4j._async_compat.util import Util from neo4j._meta import copy_signature from neo4j._sync.bookmark_manager import Neo4jBookmarkManager from neo4j.api import Bookmarks from ..._async_compat import mark_sync_test supplier_async_options = (True, False) if Util.is_async_code else (False,) consumer_async_options = supplier_async_options @copy_signature(neo4j.GraphDatabase.bookmark_manager) def bookmark_manager(*args, **kwargs): with pytest.warns(neo4j.ExperimentalWarning, match="bookmark manager"): return neo4j.GraphDatabase.bookmark_manager(*args, **kwargs) @pytest.mark.parametrize("db", ("foobar", "system")) @mark_sync_test def test_return_empty_if_db_doesnt_exists(db) -> None: bmm = bookmark_manager() assert set(bmm.get_bookmarks(db)) == set() @pytest.mark.parametrize("db", ("db1", "db2", "db3")) @mark_sync_test def test_return_initial_bookmarks_for_the_given_db(db) -> None: initial_bookmarks: t.Dict[str, t.List[str]] = { "db1": ["db1:bm1", "db1:bm1"], "db2": [], "db3": ["db3:bm1", "db3:bm2"], "db4": ["db4:bm4"] } bmm = bookmark_manager(initial_bookmarks=initial_bookmarks) assert set(bmm.get_bookmarks(db)) == set(initial_bookmarks[db]) @pytest.mark.parametrize("db", ("db1", "db2", "db3")) @pytest.mark.parametrize("supplier_async", supplier_async_options) @mark_sync_test def test_return_get_bookmarks_from_bookmarks_supplier( db, mocker, supplier_async ) -> None: extra_bookmarks = ["foo:bm1", "bar:bm2", "foo:bm1"] initial_bookmarks: t.Dict[str, t.List[str]] = { "db1": ["db1:bm1", "db1:bm1"], "db2": [], "db3": ["db3:bm1", "db3:bm2"], "db4": ["db4:bm4"] } mock_cls = mocker.Mock if supplier_async else mocker.Mock supplier = mock_cls( return_value=Bookmarks.from_raw_values(extra_bookmarks) ) bmm = bookmark_manager(initial_bookmarks=initial_bookmarks, bookmarks_supplier=supplier) assert set(bmm.get_bookmarks(db)) == { *extra_bookmarks, *initial_bookmarks.get(db, []) } if supplier_async: supplier.assert_called_once_with(db) else: supplier.assert_called_once_with(db) @pytest.mark.parametrize("with_initial_bookmarks", (True, False)) @mark_sync_test def test_return_all_bookmarks(with_initial_bookmarks) -> None: initial_bookmarks: t.Dict[str, t.List[str]] = { "db1": ["db1:bm1", "db1:bm1"], "db2": [], "db3": ["db3:bm1", "db3:bm2"], "db4": ["db4:bm4"], "db5": ["db3:bm1"] } bmm = bookmark_manager( initial_bookmarks=initial_bookmarks if with_initial_bookmarks else None ) all_bookmarks = bmm.get_all_bookmarks() if with_initial_bookmarks: assert all_bookmarks == set( itertools.chain.from_iterable(initial_bookmarks.values()) ) else: assert all_bookmarks == set() @pytest.mark.parametrize("with_initial_bookmarks", (True, False)) @pytest.mark.parametrize("supplier_async", supplier_async_options) @mark_sync_test def test_return_enriched_bookmarks_list_with_supplied_bookmarks( with_initial_bookmarks, supplier_async, mocker ) -> None: initial_bookmarks: t.Dict[str, t.List[str]] = { "db1": ["db1:bm1", "db1:bm1"], "db2": [], "db3": ["db3:bm1", "db3:bm2"], "db4": ["db4:bm4"], } extra_bookmarks = ["foo:bm1", "bar:bm2", "db3:bm1", "foo:bm1"] mock_cls = mocker.Mock if supplier_async else mocker.Mock supplier = mock_cls( return_value=Bookmarks.from_raw_values(extra_bookmarks) ) bmm = bookmark_manager( initial_bookmarks=(initial_bookmarks if with_initial_bookmarks else None), bookmarks_supplier=supplier ) all_bookmarks = bmm.get_all_bookmarks() if with_initial_bookmarks: assert all_bookmarks == set( itertools.chain(*initial_bookmarks.values(), extra_bookmarks) ) else: assert all_bookmarks == set(extra_bookmarks) if supplier_async: supplier.assert_called_once_with(None) else: supplier.assert_called_once_with(None) @mark_sync_test def test_chains_bookmarks_for_existing_db() -> None: initial_bookmarks: t.Dict[str, t.List[str]] = { "db1": ["db1:bm1", "db1:bm1"], "db2": [], "db3": ["db3:bm1", "db3:bm2"], "db4": ["db4:bm4"], } bmm = bookmark_manager(initial_bookmarks=initial_bookmarks) bmm.update_bookmarks("db3", ["db3:bm1"], ["db3:bm3"]) new_bookmarks = bmm.get_bookmarks("db3") all_bookmarks = bmm.get_all_bookmarks() assert new_bookmarks == {"db3:bm2", "db3:bm3"} assert all_bookmarks == set( itertools.chain.from_iterable(initial_bookmarks.values()) ) - {"db3:bm1"} | {"db3:bm2", "db3:bm3"} @mark_sync_test def test_add_bookmarks_for_a_non_existing_database() -> None: initial_bookmarks: t.Dict[str, t.List[str]] = { "db1": ["db1:bm1", "db1:bm1"], "db2": [], "db3": ["db3:bm1", "db3:bm2"], "db4": ["db4:bm4"], } bmm = bookmark_manager(initial_bookmarks=initial_bookmarks) bmm.update_bookmarks( "db5", ["db3:bm1", "db5:bm1"], ["db3:bm3", "db3:bm5"] ) new_bookmarks = bmm.get_bookmarks("db5") all_bookmarks = bmm.get_all_bookmarks() assert new_bookmarks == {"db3:bm3", "db3:bm5"} assert all_bookmarks == set( itertools.chain.from_iterable(initial_bookmarks.values()) ) | {"db3:bm3", "db3:bm5"} @pytest.mark.parametrize("with_initial_bookmarks", (True, False)) @pytest.mark.parametrize("consumer_async", consumer_async_options) @pytest.mark.parametrize("db", ("db1", "db2", "db3")) @mark_sync_test def test_notify_on_new_bookmarks( with_initial_bookmarks, consumer_async, db, mocker ) -> None: initial_bookmarks: t.Dict[str, t.List[str]] = { "db1": ["db1:bm1", "db1:bm1", "db1:bm2"], "db2": ["db2:bm1"], } mock_cls = mocker.Mock if consumer_async else mocker.Mock consumer = mock_cls() bmm = bookmark_manager( initial_bookmarks=(initial_bookmarks if with_initial_bookmarks else None), bookmarks_consumer=consumer ) bookmarks_old = {"db1:bm1", "db3:bm1"} bookmarks_new = {"db1:bm4"} bmm.update_bookmarks(db, bookmarks_old, bookmarks_new) if consumer_async: consumer.assert_called_once() args = consumer.await_args.args else: consumer.assert_called_once() args = consumer.call_args.args assert args[0] == db assert isinstance(args[1], Bookmarks) if with_initial_bookmarks: expected_bms = ( set(initial_bookmarks.get(db, [])) - bookmarks_old | bookmarks_new ) else: expected_bms = bookmarks_new assert args[1].raw_values == expected_bms @pytest.mark.parametrize("consumer_async", consumer_async_options) @pytest.mark.parametrize("with_initial_bookmarks", (True, False)) @pytest.mark.parametrize("db", ("db1", "db2")) @mark_sync_test def test_does_not_notify_on_empty_new_bookmark_set( with_initial_bookmarks, consumer_async, db, mocker ) -> None: initial_bookmarks: t.Dict[str, t.List[str]] = { "db1": ["db1:bm1", "db1:bm2"] } mock_cls = mocker.Mock if consumer_async else mocker.Mock consumer = mock_cls() bmm = bookmark_manager( initial_bookmarks=(initial_bookmarks if with_initial_bookmarks else None), bookmarks_consumer=consumer ) bmm.update_bookmarks(db, ["db1:bm1"], []) consumer.assert_not_called() @pytest.mark.parametrize("dbs", ( ["db1"], ["db2"], ["db1", "db2"], ["db1", "db3"], ["db1", "db2", "db3"] )) @mark_sync_test def test_forget_database(dbs) -> None: initial_bookmarks: t.Dict[str, t.List[str]] = { "db1": ["db1:bm1", "db1:bm1", "db1:bm2"], "db2": ["db2:bm1"], } bmm = bookmark_manager(initial_bookmarks=initial_bookmarks) for db in dbs: assert (bmm.get_bookmarks(db) == set(initial_bookmarks.get(db, []))) bmm.forget(dbs) # assert the key has been removed (memory optimization) assert isinstance(bmm, Neo4jBookmarkManager) assert (set(bmm._bookmarks.keys()) == set(initial_bookmarks.keys()) - set(dbs)) for db in dbs: assert bmm.get_bookmarks(db) == set() assert bmm.get_all_bookmarks() == set( bm for k, v in initial_bookmarks.items() if k not in dbs for bm in v ) neo4j-python-driver-5.2.1/tests/unit/sync/test_driver.py000066400000000000000000000333641433522662700233720ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 __future__ import annotations import ssl import typing as t import pytest from neo4j import ( BoltDriver, ExperimentalWarning, GraphDatabase, Neo4jDriver, TRUST_ALL_CERTIFICATES, TRUST_SYSTEM_CA_SIGNED_CERTIFICATES, TrustAll, TrustCustomCAs, TrustSystemCAs, ) from neo4j.api import ( BookmarkManager, READ_ACCESS, WRITE_ACCESS, ) from neo4j.exceptions import ConfigurationError from ..._async_compat import ( mark_sync_test, TestDecorators, ) @pytest.mark.parametrize("protocol", ("bolt://", "bolt+s://", "bolt+ssc://")) @pytest.mark.parametrize("host", ("localhost", "127.0.0.1", "[::1]", "[0:0:0:0:0:0:0:1]")) @pytest.mark.parametrize("port", (":1234", "", ":7687")) @pytest.mark.parametrize("params", ("", "?routing_context=test")) @pytest.mark.parametrize("auth_token", (("test", "test"), None)) @mark_sync_test def test_direct_driver_constructor(protocol, host, port, params, auth_token): uri = protocol + host + port + params if params: with pytest.warns(DeprecationWarning, match="routing context"): driver = GraphDatabase.driver(uri, auth=auth_token) else: driver = GraphDatabase.driver(uri, auth=auth_token) assert isinstance(driver, BoltDriver) driver.close() @pytest.mark.parametrize("protocol", ("neo4j://", "neo4j+s://", "neo4j+ssc://")) @pytest.mark.parametrize("host", ("localhost", "127.0.0.1", "[::1]", "[0:0:0:0:0:0:0:1]")) @pytest.mark.parametrize("port", (":1234", "", ":7687")) @pytest.mark.parametrize("params", ("", "?routing_context=test")) @pytest.mark.parametrize("auth_token", (("test", "test"), None)) @mark_sync_test def test_routing_driver_constructor(protocol, host, port, params, auth_token): uri = protocol + host + port + params driver = GraphDatabase.driver(uri, auth=auth_token) assert isinstance(driver, Neo4jDriver) driver.close() @pytest.mark.parametrize("test_uri", ( "bolt+ssc://127.0.0.1:9001", "bolt+s://127.0.0.1:9001", "bolt://127.0.0.1:9001", "neo4j+ssc://127.0.0.1:9001", "neo4j+s://127.0.0.1:9001", "neo4j://127.0.0.1:9001", )) @pytest.mark.parametrize( ("test_config", "expected_failure", "expected_failure_message"), ( ({"encrypted": False}, ConfigurationError, "The config settings"), ({"encrypted": True}, ConfigurationError, "The config settings"), ( {"encrypted": True, "trust": TRUST_ALL_CERTIFICATES}, ConfigurationError, "The config settings" ), ( {"trust": TRUST_ALL_CERTIFICATES}, ConfigurationError, "The config settings" ), ( {"trust": TRUST_SYSTEM_CA_SIGNED_CERTIFICATES}, ConfigurationError, "The config settings" ), ( {"encrypted": True, "trusted_certificates": TrustAll()}, ConfigurationError, "The config settings" ), ( {"trusted_certificates": TrustAll()}, ConfigurationError, "The config settings" ), ( {"trusted_certificates": TrustSystemCAs()}, ConfigurationError, "The config settings" ), ( {"trusted_certificates": TrustCustomCAs("foo", "bar")}, ConfigurationError, "The config settings" ), ( {"ssl_context": None}, ConfigurationError, "The config settings" ), ( {"ssl_context": ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)}, ConfigurationError, "The config settings" ), ) ) @mark_sync_test def test_driver_config_error( test_uri, test_config, expected_failure, expected_failure_message ): def driver_builder(): if "trust" in test_config: with pytest.warns(DeprecationWarning, match="trust"): return GraphDatabase.driver(test_uri, **test_config) else: return GraphDatabase.driver(test_uri, **test_config) if "+" in test_uri: # `+s` and `+ssc` are short hand syntax for not having to configure the # encryption behavior of the driver. Specifying both is invalid. with pytest.raises(expected_failure, match=expected_failure_message): driver_builder() else: driver = driver_builder() driver.close() @pytest.mark.parametrize("test_uri", ( "http://localhost:9001", "ftp://localhost:9001", "x://localhost:9001", )) def test_invalid_protocol(test_uri): with pytest.raises(ConfigurationError, match="scheme"): GraphDatabase.driver(test_uri) @pytest.mark.parametrize( ("test_config", "expected_failure", "expected_failure_message"), ( ({"trust": 1}, ConfigurationError, "The config setting `trust`"), ({"trust": True}, ConfigurationError, "The config setting `trust`"), ({"trust": None}, ConfigurationError, "The config setting `trust`"), ) ) def test_driver_trust_config_error( test_config, expected_failure, expected_failure_message ): with pytest.raises(expected_failure, match=expected_failure_message): GraphDatabase.driver("bolt://127.0.0.1:9001", **test_config) @pytest.mark.parametrize("uri", ( "bolt://127.0.0.1:9000", "neo4j://127.0.0.1:9000", )) @mark_sync_test def test_driver_opens_write_session_by_default(uri, fake_pool, mocker): driver = GraphDatabase.driver(uri) # we set a specific db, because else the driver would try to fetch a RT # to get hold of the actual home database (which won't work in this # unittest) driver._pool = fake_pool with driver.session(database="foobar") as session: mocker.patch("neo4j._sync.work.session.Transaction", autospec=True) tx = session.begin_transaction() fake_pool.acquire.assert_called_once_with( access_mode=WRITE_ACCESS, timeout=mocker.ANY, database=mocker.ANY, bookmarks=mocker.ANY, liveness_check_timeout=mocker.ANY ) tx._begin.assert_called_once_with( mocker.ANY, mocker.ANY, mocker.ANY, WRITE_ACCESS, mocker.ANY, mocker.ANY ) driver.close() @pytest.mark.parametrize("uri", ( "bolt://127.0.0.1:9000", "neo4j://127.0.0.1:9000", )) @mark_sync_test def test_verify_connectivity(uri, mocker): driver = GraphDatabase.driver(uri) pool_mock = mocker.patch.object(driver, "_pool", autospec=True) try: ret = driver.verify_connectivity() finally: driver.close() assert ret is None pool_mock.acquire.assert_called_once() assert pool_mock.acquire.call_args.kwargs["liveness_check_timeout"] == 0 pool_mock.release.assert_called_once() @pytest.mark.parametrize("uri", ( "bolt://127.0.0.1:9000", "neo4j://127.0.0.1:9000", )) @pytest.mark.parametrize("kwargs", ( {"default_access_mode": WRITE_ACCESS}, {"default_access_mode": READ_ACCESS}, {"fetch_size": 69}, )) @mark_sync_test def test_verify_connectivity_parameters_are_deprecated( uri, kwargs, mocker ): driver = GraphDatabase.driver(uri) mocker.patch.object(driver, "_pool", autospec=True) try: with pytest.warns(ExperimentalWarning, match="configuration"): driver.verify_connectivity(**kwargs) finally: driver.close() @pytest.mark.parametrize("uri", ( "bolt://127.0.0.1:9000", "neo4j://127.0.0.1:9000", )) @pytest.mark.parametrize("kwargs", ( {"default_access_mode": WRITE_ACCESS}, {"default_access_mode": READ_ACCESS}, {"fetch_size": 69}, )) @mark_sync_test def test_get_server_info_parameters_are_experimental( uri, kwargs, mocker ): driver = GraphDatabase.driver(uri) mocker.patch.object(driver, "_pool", autospec=True) try: with pytest.warns(ExperimentalWarning, match="configuration"): driver.get_server_info(**kwargs) finally: driver.close() @mark_sync_test def test_with_builtin_bookmark_manager(mocker) -> None: with pytest.warns(ExperimentalWarning, match="bookmark manager"): bmm = GraphDatabase.bookmark_manager() # could be one line, but want to make sure the type checker assigns # bmm whatever type AsyncGraphDatabase.bookmark_manager() returns session_cls_mock = mocker.patch("neo4j._sync.driver.Session", autospec=True) driver = GraphDatabase.driver("bolt://localhost") with driver as driver: with pytest.warns(ExperimentalWarning, match="bookmark_manager"): _ = driver.session(bookmark_manager=bmm) session_cls_mock.assert_called_once() assert session_cls_mock.call_args[0][1].bookmark_manager is bmm @TestDecorators.mark_async_only_test def test_with_custom_inherited_async_bookmark_manager(mocker) -> None: class BMM(BookmarkManager): def update_bookmarks( self, database: str, previous_bookmarks: t.Iterable[str], new_bookmarks: t.Iterable[str] ) -> None: ... def get_bookmarks(self, database: str) -> t.Collection[str]: return [] def get_all_bookmarks(self) -> t.Collection[str]: return [] def forget(self, databases: t.Iterable[str]) -> None: ... bmm = BMM() # could be one line, but want to make sure the type checker assigns # bmm whatever type AsyncGraphDatabase.bookmark_manager() returns session_cls_mock = mocker.patch("neo4j._sync.driver.Session", autospec=True) driver = GraphDatabase.driver("bolt://localhost") with driver as driver: with pytest.warns(ExperimentalWarning, match="bookmark_manager"): _ = driver.session(bookmark_manager=bmm) session_cls_mock.assert_called_once() assert session_cls_mock.call_args[0][1].bookmark_manager is bmm @mark_sync_test def test_with_custom_inherited_sync_bookmark_manager(mocker) -> None: class BMM(BookmarkManager): def update_bookmarks( self, database: str, previous_bookmarks: t.Iterable[str], new_bookmarks: t.Iterable[str] ) -> None: ... def get_bookmarks(self, database: str) -> t.Collection[str]: return [] def get_all_bookmarks(self) -> t.Collection[str]: return [] def forget(self, databases: t.Iterable[str]) -> None: ... bmm = BMM() # could be one line, but want to make sure the type checker assigns # bmm whatever type AsyncGraphDatabase.bookmark_manager() returns session_cls_mock = mocker.patch("neo4j._sync.driver.Session", autospec=True) driver = GraphDatabase.driver("bolt://localhost") with driver as driver: with pytest.warns(ExperimentalWarning, match="bookmark_manager"): _ = driver.session(bookmark_manager=bmm) session_cls_mock.assert_called_once() assert session_cls_mock.call_args[0][1].bookmark_manager is bmm @TestDecorators.mark_async_only_test def test_with_custom_ducktype_async_bookmark_manager(mocker) -> None: class BMM: def update_bookmarks( self, database: str, previous_bookmarks: t.Iterable[str], new_bookmarks: t.Iterable[str] ) -> None: ... def get_bookmarks(self, database: str) -> t.Collection[str]: return [] def get_all_bookmarks(self) -> t.Collection[str]: return [] def forget(self, databases: t.Iterable[str]) -> None: ... bmm = BMM() # could be one line, but want to make sure the type checker assigns # bmm whatever type AsyncGraphDatabase.bookmark_manager() returns session_cls_mock = mocker.patch("neo4j._sync.driver.Session", autospec=True) driver = GraphDatabase.driver("bolt://localhost") with driver as driver: with pytest.warns(ExperimentalWarning, match="bookmark_manager"): _ = driver.session(bookmark_manager=bmm) session_cls_mock.assert_called_once() assert session_cls_mock.call_args[0][1].bookmark_manager is bmm @mark_sync_test def test_with_custom_ducktype_sync_bookmark_manager(mocker) -> None: class BMM: def update_bookmarks( self, database: str, previous_bookmarks: t.Iterable[str], new_bookmarks: t.Iterable[str] ) -> None: ... def get_bookmarks(self, database: str) -> t.Collection[str]: return [] def get_all_bookmarks(self) -> t.Collection[str]: return [] def forget(self, databases: t.Iterable[str]) -> None: ... bmm = BMM() # could be one line, but want to make sure the type checker assigns # bmm whatever type AsyncGraphDatabase.bookmark_manager() returns session_cls_mock = mocker.patch("neo4j._sync.driver.Session", autospec=True) driver = GraphDatabase.driver("bolt://localhost") with driver as driver: with pytest.warns(ExperimentalWarning, match="bookmark_manager"): _ = driver.session(bookmark_manager=bmm) session_cls_mock.assert_called_once() assert session_cls_mock.call_args[0][1].bookmark_manager is bmm neo4j-python-driver-5.2.1/tests/unit/sync/work/000077500000000000000000000000001433522662700214375ustar00rootroot00000000000000neo4j-python-driver-5.2.1/tests/unit/sync/work/__init__.py000066400000000000000000000012011433522662700235420ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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. neo4j-python-driver-5.2.1/tests/unit/sync/work/_fake_connection.py000066400000000000000000000167541433522662700253120ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 inspect import pytest from neo4j import ServerInfo from neo4j._deadline import Deadline from neo4j._sync.io import Bolt @pytest.fixture def fake_connection_generator(session_mocker): mock = session_mocker.mock_module class FakeConnection(mock.NonCallableMagicMock): callbacks = [] server_info = ServerInfo("127.0.0.1", (4, 3)) local_port = 1234 def __init__(self, *args, **kwargs): kwargs["spec"] = Bolt super().__init__(*args, **kwargs) self.attach_mock(mock.Mock(return_value=True), "is_reset_mock") self.attach_mock(mock.Mock(return_value=False), "defunct") self.attach_mock(mock.Mock(return_value=False), "stale") self.attach_mock(mock.Mock(return_value=False), "closed") self.attach_mock(mock.Mock(return_value=False), "socket") self.attach_mock(mock.Mock(), "unresolved_address") def close_side_effect(): self.closed.return_value = True self.attach_mock(mock.Mock(side_effect=close_side_effect), "close") self.socket.attach_mock( mock.Mock(return_value=None), "get_deadline" ) def set_deadline_side_effect(deadline): deadline = Deadline.from_timeout_or_deadline(deadline) self.socket.get_deadline.return_value = deadline self.socket.attach_mock( mock.Mock(side_effect=set_deadline_side_effect), "set_deadline" ) @property def is_reset(self): if self.closed.return_value or self.defunct.return_value: raise AssertionError( "is_reset should not be called on a closed or defunct " "connection." ) return self.is_reset_mock() def fetch_message(self, *args, **kwargs): if self.callbacks: cb = self.callbacks.pop(0) cb() return super().__getattr__("fetch_message")(*args, **kwargs) def fetch_all(self, *args, **kwargs): while self.callbacks: cb = self.callbacks.pop(0) cb() return super().__getattr__("fetch_all")(*args, **kwargs) def __getattr__(self, name): parent = super() def build_message_handler(name): def func(*args, **kwargs): def callback(): for cb_name, param_count in ( ("on_success", 1), ("on_summary", 0) ): cb = kwargs.get(cb_name, None) if callable(cb): try: param_count = \ len(inspect.signature(cb).parameters) except ValueError: # e.g. built-in method as cb pass if param_count == 1: res = cb({}) else: res = cb() try: res # maybe the callback is async except TypeError: pass # or maybe it wasn't ;) self.callbacks.append(callback) return func method_mock = parent.__getattr__(name) if name in ("run", "commit", "pull", "rollback", "discard"): method_mock.side_effect = build_message_handler(name) return method_mock return FakeConnection @pytest.fixture def fake_connection(fake_connection_generator): return fake_connection_generator() @pytest.fixture def scripted_connection_generator(fake_connection_generator): class ScriptedConnection(fake_connection_generator): _script = [] _script_pos = 0 def set_script(self, callbacks): """Set a scripted sequence of callbacks. :param callbacks: The callbacks. They should be a list of 2-tuples. `("name_of_message", {"callback_name": arguments})`. E.g., ``` [ ("run", {"on_success": ({},), "on_summary": None}), ("pull", { "on_success": None, "on_summary": None, "on_records": }) ] ``` Note that arguments can be `None`. In this case, ScriptedConnection will make a guess on best-suited default arguments. """ self._script = callbacks self._script_pos = 0 def __getattr__(self, name): parent = super() def build_message_handler(name): def func(*args, **kwargs): try: expected_message, scripted_callbacks = \ self._script[self._script_pos] except IndexError: pytest.fail("End of scripted connection reached.") assert name == expected_message self._script_pos += 1 def callback(): for cb_name, default_cb_args in ( ("on_ignored", ({},)), ("on_failure", ({},)), ("on_records", ([],)), ("on_success", ({},)), ("on_summary", ()), ): cb = kwargs.get(cb_name, None) if ( not callable(cb) or cb_name not in scripted_callbacks ): continue cb_args = scripted_callbacks[cb_name] if cb_args is None: cb_args = default_cb_args res = cb(*cb_args) try: res # maybe the callback is async except TypeError: pass # or maybe it wasn't ;) self.callbacks.append(callback) return func method_mock = parent.__getattr__(name) if name in ("run", "commit", "pull", "rollback", "discard"): method_mock.side_effect = build_message_handler(name) return method_mock return ScriptedConnection @pytest.fixture def scripted_connection(scripted_connection_generator): return scripted_connection_generator() neo4j-python-driver-5.2.1/tests/unit/sync/work/conftest.py000066400000000000000000000002221433522662700236320ustar00rootroot00000000000000from ._fake_connection import ( fake_connection, fake_connection_generator, scripted_connection, scripted_connection_generator, ) neo4j-python-driver-5.2.1/tests/unit/sync/work/test_result.py000066400000000000000000001115731433522662700243760ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 warnings from unittest import mock import pandas as pd import pytest import pytz from neo4j import ( Address, ExperimentalWarning, Record, Result, ResultSummary, ServerInfo, SummaryCounters, time as neo4j_time, Version, ) from neo4j._async_compat.util import Util from neo4j._codec.hydration.v1 import HydrationHandler from neo4j._codec.packstream import Structure from neo4j._data import ( Node, Relationship, ) from neo4j.exceptions import ( BrokenRecordError, ResultNotSingleError, ) from neo4j.graph import ( EntitySetView, Graph, ) from ...._async_compat import mark_sync_test class Records: def __init__(self, fields, records): self.fields = tuple(fields) self.hydration_scope = HydrationHandler().new_hydration_scope() self.records = tuple(records) assert all(len(self.fields) == len(r) for r in self.records) self._hydrate_records() def _hydrate_records(self): def _hydrate(value): if isinstance(value, (list, tuple)): value = type(value)(_hydrate(v) for v in value) elif isinstance(value, dict): value = {k: _hydrate(v) for k, v in value.items()} if type(value) in self.hydration_scope.hydration_hooks: return self.hydration_scope.hydration_hooks[type(value)](value) return value self.records = tuple(_hydrate(r) for r in self.records) def __len__(self): return self.records.__len__() def __iter__(self): return self.records.__iter__() def __getitem__(self, item): return self.records.__getitem__(item) class ConnectionStub: class Message: def __init__(self, message, *args, **kwargs): self.message = message self.args = args self.kwargs = kwargs def _cb(self, cb_name, *args, **kwargs): # print(self.message, cb_name.upper(), args, kwargs) cb = self.kwargs.get(cb_name) Util.callback(cb, *args, **kwargs) def on_success(self, metadata): self._cb("on_success", metadata) def on_summary(self): self._cb("on_summary") def on_records(self, records): self._cb("on_records", records) def __eq__(self, other): return self.message == other def __repr__(self): return "Message(%s)" % self.message def __init__(self, records=None, run_meta=None, summary_meta=None, force_qid=False): self._multi_result = isinstance(records, (list, tuple)) if self._multi_result: self._records = records self._use_qid = True else: self._records = records, self._use_qid = force_qid self.fetch_idx = 0 self._qid = -1 self.most_recent_qid = None self.record_idxs = [0] * len(self._records) self.to_pull = [None] * len(self._records) self._exhausted = [False] * len(self._records) self.queued = [] self.sent = [] self.run_meta = run_meta self.summary_meta = summary_meta ConnectionStub.server_info.update({"server": "Neo4j/4.3.0"}) self.unresolved_address = None self._new_hydration_scope_called = False def send_all(self): self.sent += self.queued self.queued = [] def fetch_message(self): if self.fetch_idx >= len(self.sent): pytest.fail("Waits for reply to never sent message") msg = self.sent[self.fetch_idx] if msg == "RUN": self.fetch_idx += 1 self._qid += 1 meta = {"fields": self._records[self._qid].fields, **(self.run_meta or {})} if self._use_qid: meta.update(qid=self._qid) msg.on_success(meta) elif msg == "DISCARD": self.fetch_idx += 1 qid = msg.kwargs.get("qid", -1) if qid < 0: qid = self._qid self.record_idxs[qid] = len(self._records[qid]) msg.on_success(self.summary_meta or {}) msg.on_summary() elif msg == "PULL": qid = msg.kwargs.get("qid", -1) if qid < 0: qid = self._qid if self._exhausted[qid]: pytest.fail("PULLing exhausted result") if self.to_pull[qid] is None: n = msg.kwargs.get("n", -1) if n < 0: n = len(self._records[qid]) self.to_pull[qid] = \ min(n, len(self._records[qid]) - self.record_idxs[qid]) # if to == len(self._records): # self.fetch_idx += 1 if self.to_pull[qid] > 0: record = self._records[qid][self.record_idxs[qid]] self.record_idxs[qid] += 1 self.to_pull[qid] -= 1 msg.on_records([record]) elif self.to_pull[qid] == 0: self.to_pull[qid] = None self.fetch_idx += 1 if self.record_idxs[qid] < len(self._records[qid]): msg.on_success({"has_more": True}) else: msg.on_success( {"bookmark": "foo", **(self.summary_meta or {})} ) self._exhausted[qid] = True msg.on_summary() def fetch_all(self): while self.fetch_idx < len(self.sent): self.fetch_message() def run(self, *args, **kwargs): self.queued.append(ConnectionStub.Message("RUN", *args, **kwargs)) def discard(self, *args, **kwargs): self.queued.append(ConnectionStub.Message("DISCARD", *args, **kwargs)) def pull(self, *args, **kwargs): self.queued.append(ConnectionStub.Message("PULL", *args, **kwargs)) server_info = ServerInfo(Address(("bolt://localhost", 7687)), Version(4, 3)) def defunct(self): return False def new_hydration_scope(self): class FakeHydrationScope: hydration_hooks = None dehydration_hooks = None def get_graph(self): return Graph() if len(self._records) > 1: return FakeHydrationScope() assert not self._new_hydration_scope_called assert self._records self._new_hydration_scope_called = True return self._records[0].hydration_scope def noop(*_, **__): pass def fetch_and_compare_all_records( result, key, expected_records, method, limit=None ): received_records = [] if method == "for loop": for record in result: assert isinstance(record, Record) received_records.append([record.data().get(key, None)]) if limit is not None and len(received_records) == limit: break if limit is None: assert result._exhausted elif method == "next": n = len(expected_records) if limit is None else limit for _ in range(n): record = Util.next(result) received_records.append([record.get(key, None)]) if limit is None: with pytest.raises(StopIteration): Util.next(result) assert result._exhausted elif method == "one iter": iter_ = Util.iter(result) n = len(expected_records) if limit is None else limit for _ in range(n): record = Util.next(iter_) received_records.append([record.get(key, None)]) if limit is None: with pytest.raises(StopIteration): Util.next(iter_) assert result._exhausted elif method == "new iter": n = len(expected_records) if limit is None else limit for _ in range(n): iter_ = Util.iter(result) record = Util.next(iter_) received_records.append([record.get(key, None)]) if limit is None: iter_ = Util.iter(result) with pytest.raises(StopIteration): Util.next(iter_) assert result._exhausted else: raise ValueError() assert received_records == expected_records @pytest.mark.parametrize("method", ("for loop", "next", "one iter", "new iter")) @pytest.mark.parametrize("records", ( [], [[42]], [[1], [2], [3], [4], [5]], )) @mark_sync_test def test_result_iteration(method, records): connection = ConnectionStub(records=Records(["x"], records)) result = Result(connection, 2, noop, noop) result._run("CYPHER", {}, None, None, "r", None) fetch_and_compare_all_records(result, "x", records, method) @mark_sync_test def test_result_iteration_mixed_methods(): records = [[i] for i in range(10)] connection = ConnectionStub(records=Records(["x"], records)) result = Result(connection, 4, noop, noop) result._run("CYPHER", {}, None, None, "r", None) iter1 = Util.iter(result) iter2 = Util.iter(result) assert (Util.next(iter1)).get("x") == records[0][0] assert (Util.next(iter2)).get("x") == records[1][0] assert (Util.next(iter2)).get("x") == records[2][0] assert (Util.next(iter1)).get("x") == records[3][0] assert (Util.next(iter1)).get("x") == records[4][0] assert (Util.next(result)).get("x") == records[5][0] assert (Util.next(iter2)).get("x") == records[6][0] assert (Util.next(iter1)).get("x") == records[7][0] assert ((Util.next(Util.iter(result))).get("x") == records[8][0]) assert [r.get("x") for r in result] == [records[9][0]] with pytest.raises(StopIteration): Util.next(iter1) with pytest.raises(StopIteration): Util.next(iter2) with pytest.raises(StopIteration): Util.next(result) with pytest.raises(StopIteration): Util.next(Util.iter(result)) assert [r.get("x") for r in result] == [] @pytest.mark.parametrize("method", ("for loop", "next", "one iter", "new iter")) @pytest.mark.parametrize("invert_fetch", (True, False)) @mark_sync_test def test_parallel_result_iteration(method, invert_fetch): records1 = [[i] for i in range(1, 6)] records2 = [[i] for i in range(6, 11)] connection = ConnectionStub( records=(Records(["x"], records1), Records(["x"], records2)) ) result1 = Result(connection, 2, noop, noop) result1._run("CYPHER1", {}, None, None, "r", None) result2 = Result(connection, 2, noop, noop) result2._run("CYPHER2", {}, None, None, "r", None) if invert_fetch: fetch_and_compare_all_records( result2, "x", records2, method ) fetch_and_compare_all_records( result1, "x", records1, method ) else: fetch_and_compare_all_records( result1, "x", records1, method ) fetch_and_compare_all_records( result2, "x", records2, method ) @pytest.mark.parametrize("method", ("for loop", "next", "one iter", "new iter")) @pytest.mark.parametrize("invert_fetch", (True, False)) @mark_sync_test def test_interwoven_result_iteration(method, invert_fetch): records1 = [[i] for i in range(1, 10)] records2 = [[i] for i in range(11, 20)] connection = ConnectionStub( records=(Records(["x"], records1), Records(["y"], records2)) ) result1 = Result(connection, 2, noop, noop) result1._run("CYPHER1", {}, None, None, "r", None) result2 = Result(connection, 2, noop, noop) result2._run("CYPHER2", {}, None, None, "r", None) start = 0 for n in (1, 2, 3, 1, None): end = n if n is None else start + n if invert_fetch: fetch_and_compare_all_records( result2, "y", records2[start:end], method, n ) fetch_and_compare_all_records( result1, "x", records1[start:end], method, n ) else: fetch_and_compare_all_records( result1, "x", records1[start:end], method, n ) fetch_and_compare_all_records( result2, "y", records2[start:end], method, n ) start = end @pytest.mark.parametrize("records", ([[1], [2]], [[1]], [])) @pytest.mark.parametrize("fetch_size", (1, 2)) @mark_sync_test def test_result_peek(records, fetch_size): connection = ConnectionStub(records=Records(["x"], records)) result = Result(connection, fetch_size, noop, noop) result._run("CYPHER", {}, None, None, "r", None) for i in range(len(records) + 1): record = result.peek() if i == len(records): assert record is None else: assert isinstance(record, Record) assert record.get("x") == records[i][0] iter_ = Util.iter(result) Util.next(iter_) # consume the record @pytest.mark.parametrize("records", ([[1], [2]], [[1]], [])) @pytest.mark.parametrize("fetch_size", (1, 2)) @pytest.mark.parametrize("default", (True, False)) @mark_sync_test def test_result_single_non_strict(records, fetch_size, default): kwargs = {} if not default: kwargs["strict"] = False connection = ConnectionStub(records=Records(["x"], records)) result = Result(connection, fetch_size, noop, noop) result._run("CYPHER", {}, None, None, "r", None) if len(records) == 0: assert result.single(**kwargs) is None else: if len(records) == 1: record = result.single(**kwargs) else: with pytest.warns(Warning, match="multiple"): record = result.single(**kwargs) assert isinstance(record, Record) assert record.get("x") == records[0][0] @pytest.mark.parametrize("records", ([[1], [2]], [[1]], [])) @pytest.mark.parametrize("fetch_size", (1, 2)) @mark_sync_test def test_result_single_strict(records, fetch_size): connection = ConnectionStub(records=Records(["x"], records)) result = Result(connection, fetch_size, noop, noop) result._run("CYPHER", {}, None, None, "r", None) try: record = result.single(strict=True) except ResultNotSingleError as exc: assert len(records) != 1 if len(records) == 0: assert exc is not None assert "no records" in str(exc).lower() elif len(records) > 1: assert exc is not None assert "more than one record" in str(exc).lower() else: assert len(records) == 1 assert isinstance(record, Record) assert record.get("x") == records[0][0] @pytest.mark.parametrize("records", ( [[1], [2], [3]], [[1]], [], [[i] for i in range(100)] )) @pytest.mark.parametrize("fetch_size", (1, 2)) @pytest.mark.parametrize("strict", (True, False)) @mark_sync_test def test_result_single_exhausts_records(records, fetch_size, strict): connection = ConnectionStub(records=Records(["x"], records)) result = Result(connection, fetch_size, noop, noop) result._run("CYPHER", {}, None, None, "r", None) try: with warnings.catch_warnings(): warnings.simplefilter("ignore") result.single(strict=strict) except ResultNotSingleError: pass assert not result.closed() # close has nothing to do with being exhausted assert [r for r in result] == [] assert not result.closed() @pytest.mark.parametrize("records", ( [[1], [2], [3]], [[1]], [], [[i] for i in range(100)] )) @pytest.mark.parametrize("fetch_size", (1, 2)) @pytest.mark.parametrize("strict", (True, False)) @mark_sync_test def test_result_fetch(records, fetch_size, strict): connection = ConnectionStub(records=Records(["x"], records)) result = Result(connection, fetch_size, noop, noop) result._run("CYPHER", {}, None, None, "r", None) assert result.fetch(0) == [] assert result.fetch(-1) == [] assert [[r.get("x")] for r in result.fetch(2)] == records[:2] assert [[r.get("x")] for r in result.fetch(1)] == records[2:3] assert [[r.get("x")] for r in result] == records[3:] @mark_sync_test def test_keys_are_available_before_and_after_stream(): connection = ConnectionStub(records=Records(["x"], [[1], [2]])) result = Result(connection, 1, noop, noop) result._run("CYPHER", {}, None, None, "r", None) assert list(result.keys()) == ["x"] Util.list(result) assert list(result.keys()) == ["x"] @pytest.mark.parametrize("records", ([[1], [2]], [[1]], [])) @pytest.mark.parametrize("consume_one", (True, False)) @pytest.mark.parametrize("summary_meta", (None, {"database": "foobar"})) @pytest.mark.parametrize("consume_times", (1, 2)) @mark_sync_test def test_consume(records, consume_one, summary_meta, consume_times): connection = ConnectionStub( records=Records(["x"], records), summary_meta=summary_meta ) result = Result(connection, 1, noop, noop) result._run("CYPHER", {}, None, None, "r", None) if consume_one: try: Util.next(Util.iter(result)) except StopIteration: pass for _ in range(consume_times): summary = result.consume() assert isinstance(summary, ResultSummary) if summary_meta and "db" in summary_meta: assert summary.database == summary_meta["db"] else: assert summary.database is None server_info = summary.server assert isinstance(server_info, ServerInfo) assert server_info.protocol_version == Version(4, 3) assert isinstance(summary.counters, SummaryCounters) @pytest.mark.parametrize("t_first", (None, 0, 1, 123456789)) @pytest.mark.parametrize("t_last", (None, 0, 1, 123456789)) @mark_sync_test def test_time_in_summary(t_first, t_last): run_meta = None if t_first is not None: run_meta = {"t_first": t_first} summary_meta = None if t_last is not None: summary_meta = {"t_last": t_last} connection = ConnectionStub( records=Records(["n"], [[i] for i in range(100)]), run_meta=run_meta, summary_meta=summary_meta ) result = Result(connection, 1, noop, noop) result._run("CYPHER", {}, None, None, "r", None) summary = result.consume() if t_first is not None: assert isinstance(summary.result_available_after, int) assert summary.result_available_after == t_first else: assert summary.result_available_after is None if t_last is not None: assert isinstance(summary.result_consumed_after, int) assert summary.result_consumed_after == t_last else: assert summary.result_consumed_after is None assert not hasattr(summary, "t_first") assert not hasattr(summary, "t_last") @mark_sync_test def test_counts_in_summary(): connection = ConnectionStub(records=Records(["n"], [[1], [2]])) result = Result(connection, 1, noop, noop) result._run("CYPHER", {}, None, None, "r", None) summary = result.consume() assert isinstance(summary.counters, SummaryCounters) @pytest.mark.parametrize("query_type", ("r", "w", "rw", "s")) @mark_sync_test def test_query_type(query_type): connection = ConnectionStub( records=Records(["n"], [[1], [2]]), summary_meta={"type": query_type} ) result = Result(connection, 1, noop, noop) result._run("CYPHER", {}, None, None, "r", None) summary = result.consume() assert isinstance(summary.query_type, str) assert summary.query_type == query_type @pytest.mark.parametrize("num_records", range(0, 5)) @mark_sync_test def test_data(num_records): connection = ConnectionStub( records=Records(["n"], [[i + 1] for i in range(num_records)]) ) result = Result(connection, 1, noop, noop) result._run("CYPHER", {}, None, None, "r", None) result._buffer_all() records = result._record_buffer.copy() assert len(records) == num_records expected_data = [] for i, record in enumerate(records): record.data = mock.Mock() expected_data.append("magic_return_%s" % i) record.data.return_value = expected_data[-1] assert result.data("hello", "world") == expected_data for record in records: assert record.data.called_once_with("hello", "world") @pytest.mark.parametrize("records", ( Records(["n"], []), Records(["n"], [[42], [69], [420], [1337]]), Records(["n1", "r", "n2"], [ [ # Node Structure(b"N", 0, ["Person", "LabelTest1"], {"name": "Alice"}), # Relationship Structure(b"R", 0, 0, 1, "KNOWS", {"since": 1999}), # Node Structure(b"N", 1, ["Person", "LabelTest2"], {"name": "Bob"}), ] ]), )) @mark_sync_test def test_result_graph(records): connection = ConnectionStub(records=records) result = Result(connection, 1, noop, noop) result._run("CYPHER", {}, None, None, "r", None) graph = result.graph() assert isinstance(graph, Graph) if records.fields == ("n",): assert len(graph.relationships) == 0 assert len(graph.nodes) == 0 else: # EntitySetView is a little broken. It's a weird mixture of set, dict, # and iterable. Let's just test the underlying raw dict assert isinstance(graph.nodes, EntitySetView) nodes = graph.nodes assert set(nodes._entity_dict) == {"0", "1"} for key in ( "0", 0, 0.0, # I pray to god that no-one actually accessed nodes with complex # numbers, but theoretically it would have worked with the legacy # number IDs 0+0j, ): if not isinstance(key, str): with pytest.warns(DeprecationWarning, match="element_id"): alice = nodes[key] else: alice = nodes[key] assert isinstance(alice, Node) isinstance(alice.labels, frozenset) assert alice.labels == {"Person", "LabelTest1"} assert set(alice.keys()) == {"name"} assert alice["name"] == "Alice" for key in ("1", 1, 1.0, 1+0j): if not isinstance(key, str): with pytest.warns(DeprecationWarning, match="element_id"): bob = nodes[key] else: bob = nodes[key] assert isinstance(bob, Node) isinstance(bob.labels, frozenset) assert bob.labels == {"Person", "LabelTest2"} assert set(bob.keys()) == {"name"} assert bob["name"] == "Bob" assert isinstance(graph.relationships, EntitySetView) rels = graph.relationships assert set(rels._entity_dict) == {"0"} for key in ("0", 0, 0.0, 0+0j): if not isinstance(key, str): with pytest.warns(DeprecationWarning, match="element_id"): rel = rels[key] else: rel = rels[key] assert isinstance(rel, Relationship) assert rel.nodes == (alice, bob) assert rel.type == "KNOWS" assert set(rel.keys()) == {"since"} assert rel["since"] == 1999 @pytest.mark.parametrize( ("keys", "values", "types", "instances"), ( (["i"], list(zip(range(5))), ["int64"], None), (["x"], list(zip((n - .5) / 5 for n in range(5))), ["float64"], None), (["s"], list(zip(("foo", "bar", "baz", "foobar"))), ["object"], None), (["l"], list(zip(([1, 2], [3, 4]))), ["object"], None), ( ["n"], list(zip(( Structure(b"N", 0, ["LABEL_A"], {"a": 1, "b": 2}), Structure(b"N", 2, ["LABEL_B"], {"a": 1, "c": 1.2}), Structure(b"N", 1, ["LABEL_A", "LABEL_B"], {"a": [1, "a"]}), Structure(b"N", None, ["LABEL_A", "LABEL_B"], {"a": [1, "a"]}, "cool_id"), ))), ["object"], [Node] ), ( ["r"], list(zip(( Structure(b"R", 0, 1, 2, "TYPE", {"a": 1, "b": 2}), Structure(b"R", 420, 1337, 69, "HYPE", {"all memes": True}), Structure(b"R", None, None, None, "HYPE", {"all memes": True}, "420", "1337", "69"), ))), ["object"], [Relationship] ), ) ) @pytest.mark.parametrize("test_default_expand", (True, False)) @mark_sync_test def test_to_df(keys, values, types, instances, test_default_expand): connection = ConnectionStub(records=Records(keys, values)) result = Result(connection, 1, noop, noop) result._run("CYPHER", {}, None, None, "r", None) if test_default_expand: df = result.to_df() else: df = result.to_df(expand=False) assert isinstance(df, pd.DataFrame) assert df.keys().to_list() == keys assert len(df) == len(values) assert df.dtypes.to_list() == types expected_df = pd.DataFrame( {k: [v[i] for v in values] for i, k in enumerate(keys)} ) if instances: for i, k in enumerate(keys): assert all(isinstance(v, instances[i]) for v in df[k]) else: assert df.equals(expected_df) @pytest.mark.parametrize( ("keys", "values", "expected_columns", "expected_rows", "expected_types"), ( ( ["i"], list(zip(range(5))), ["i"], [[0], [1], [2], [3], [4]], ["int64"], ), # test variable name escaping ( ["i.[]->.().{}.\\"], list(zip(range(5))), ["i\\.[]->\\.()\\.{}\\.\\\\"], [[0], [1], [2], [3], [4]], ["int64"], ), ( ["x"], list(zip((n - .5) / 5 for n in range(5))), ["x"], [[-0.1], [0.1], [0.3], [0.5], [0.7]], ["float64"], ), ( ["s"], list(zip(("foo", "bar", "baz", "foobar"))), ["s"], [["foo"], ["bar"], ["baz"], ["foobar"]], ["object"], ), ( ["l"], list(zip(([1, 2], [3, 4]))), ["l[].0", "l[].1"], [[1, 2], [3, 4]], ["int64", "int64"], ), ( ["l"], list(zip(([1, 2], [3, 4, 5], [6]))), ["l[].0", "l[].1", "l[].2"], [[1, 2, None], [3, 4, 5], [6, None, None]], # pandas turns None in int columns into NaN # which requires the column to become a float column ["int64", "float64", "float64"], ), ( ["d"], list(zip(({"a": 1, "b": 2}, {"a": 3, "b": 4, "": 0}))), ["d{}.a", "d{}.b", "d{}."], [[1, 2, None], [3, 4, 0]], ["int64", "int64", "float64"], ), # test key escaping ( ["d"], list(zip(({"a.[]\\{}->.().{}.": 1, "b": 2},))), ["d{}.a\\.[]\\\\{}->\\.()\\.{}\\.", "d{}.b"], [[1, 2]], ["int64", "int64"], ), ( ["d"], list(zip(({"a": 1, "b": 2}, {"a": 3, "c": 4}))), ["d{}.a", "d{}.b", "d{}.c"], [[1, 2, None], [3, None, 4]], # pandas turns None in int columns into NaN # which requires the column to become a float column ["int64", "float64", "float64"], ), ( ["x"], list(zip(([{"foo": "bar", "baz": [42, 0.1]}, "foobar"],))), ["x[].0{}.foo", "x[].0{}.baz[].0", "x[].0{}.baz[].1", "x[].1"], [["bar", 42, 0.1, "foobar"]], ["object", "int64", "float64", "object"], ), ( ["n"], list(zip(( Node(None, # type: ignore[arg-type] "00", 0, ["LABEL_A"], {"a": 1, "b": 2, "d": 1}), Node(None, # type: ignore[arg-type] "02", 2, ["LABEL_B"], {"a": 1, "c": 1.2, "d": 2}), Node(None, # type: ignore[arg-type] "01", 1, ["LABEL_A", "LABEL_B"], {"a": [1, "a"], "d": 3}), ))), [ "n().element_id", "n().labels", "n().prop.a", "n().prop.b", "n().prop.c", "n().prop.d" ], [ ["00", frozenset(("LABEL_A",)), 1, 2, None, 1], ["02", frozenset(("LABEL_B",)), 1, None, 1.2, 2], [ "01", frozenset(("LABEL_A", "LABEL_B")), [1, "a"], None, None, 3 ], ], ["object", "object", "object", "float64", "float64", "int64"], ), ( ["r"], list(zip(( Structure(b"R", 0, 1, 2, "TYPE", {"a": 1, "all memes": False}, "r-0", "r-1", "r-2"), Structure(b"R", 420, 1337, 69, "HYPE", {"all memes": True}, "r-420", "r-1337", "r-69"), ))), [ "r->.element_id", "r->.start.element_id", "r->.end.element_id", "r->.type", "r->.prop.a", "r->.prop.all memes" ], [ ["r-0", "r-1", "r-2", "TYPE", 1, False], ["r-420", "r-1337", "r-69", "HYPE", None, True], ], ["object", "object", "object", "object", "float64", "bool"], ), ( ["dt"], [[neo4j_time.DateTime(2022, 1, 2, 3, 4, 5, 6)]], ["dt"], [[neo4j_time.DateTime(2022, 1, 2, 3, 4, 5, 6)]], ["object"], ), ) ) @mark_sync_test def test_to_df_expand(keys, values, expected_columns, expected_rows, expected_types): connection = ConnectionStub(records=Records(keys, values)) result = Result(connection, 1, noop, noop) result._run("CYPHER", {}, None, None, "r", None) df = result.to_df(expand=True) assert isinstance(df, pd.DataFrame) assert len(set(expected_columns)) == len(expected_columns) assert set(df.keys().to_list()) == set(expected_columns) # We don't expect the columns to be in a specific order. # Hence, we need to sort them before comparing. new_order = [df.keys().get_loc(ex_c) for ex_c in expected_columns] expected_rows = [ [row[i] for i in new_order] for row in expected_rows ] expected_types = [expected_types[i] for i in new_order] expected_columns = [expected_columns[i] for i in new_order] assert len(df) == len(values) assert df.dtypes.to_list() == expected_types expected_df = pd.DataFrame(expected_rows, columns=expected_columns) assert df.equals(expected_df) @pytest.mark.parametrize( ("keys", "values", "expected_df"), ( # DateTime ( ["dt"], [ [neo4j_time.DateTime(2022, 1, 2, 3, 4, 5, 6)], ], pd.DataFrame( [[pd.Timestamp("2022-01-02 03:04:05.000000006")]], columns=["dt"], ) ), # Date ( ["d"], [ [neo4j_time.Date(2222, 2, 22)], ], pd.DataFrame( [[pd.Timestamp("2222-02-22")]], columns=["d"], ) ), # DateTime with timezone ( ["dt_tz"], [ [ pytz.timezone("Europe/Stockholm").localize( neo4j_time.DateTime(1970, 1, 1, 0, 0, 0, 0) ), ], ], pd.DataFrame( [[ pytz.timezone("Europe/Stockholm").localize( pd.Timestamp("1970-01-01") ) ]], columns=["dt_tz"], ) ), # DateTime, Date, DateTime with timezone, and None ( ["mixed"], [ [None], [neo4j_time.DateTime(2022, 1, 2, 3, 4, 5, 6)], [neo4j_time.Date(2222, 2, 22)], [ pytz.timezone("Europe/Stockholm").localize( neo4j_time.DateTime(1970, 1, 1, 0, 0, 0, 0) ), ], ], pd.DataFrame( [ [pd.NaT], [pd.Timestamp("2022-01-02 03:04:05.000000006")], [pd.Timestamp("2222-02-22")], [ pytz.timezone("Europe/Stockholm").localize( pd.Timestamp("1970-01-01") ) ], ], columns=["mixed"], ) ), # DateTime, Date, DateTime with timezone, and None in the middle ( ["mixed"], [ [neo4j_time.DateTime(2022, 1, 2, 3, 4, 5, 6)], [neo4j_time.Date(2222, 2, 22)], [None], [ pytz.timezone("Europe/Stockholm").localize( neo4j_time.DateTime(1970, 1, 1, 0, 0, 0, 0) ), ], ], pd.DataFrame( [ [pd.Timestamp("2022-01-02 03:04:05.000000006")], [pd.Timestamp("2222-02-22")], [pd.NaT], [ pytz.timezone("Europe/Stockholm").localize( pd.Timestamp("1970-01-01") ) ], ], columns=["mixed"], ) ), # DateTime, Date, DateTime with timezone, and None at the end ( ["mixed"], [ [neo4j_time.DateTime(2022, 1, 2, 3, 4, 5, 6)], [neo4j_time.Date(2222, 2, 22)], [ pytz.timezone("Europe/Stockholm").localize( neo4j_time.DateTime(1970, 1, 1, 0, 0, 0, 0) ), ], [None], ], pd.DataFrame( [ [pd.Timestamp("2022-01-02 03:04:05.000000006")], [pd.Timestamp("2222-02-22")], [ pytz.timezone("Europe/Stockholm").localize( pd.Timestamp("1970-01-01") ) ], [pd.NaT], ], columns=["mixed"], ) ), # Column with only None (should not be transfomred to NaT) ( ["all_none"], [ [None], [None], ], pd.DataFrame( [[None], [None]], columns=["all_none"], ) ), # Multiple columns ( ["all_none", "mixed", "n"], [ [ None, None, 1, ], [ None, neo4j_time.DateTime(2022, 1, 2, 3, 4, 5, 6), 1.234, ], ], pd.DataFrame( [ [ None, pd.NaT, 1.0, ], [ None, pd.Timestamp("2022-01-02 03:04:05.000000006"), 1.234 ], ], columns=["all_none", "mixed", "n"], ) ), ), ) @pytest.mark.parametrize("expand", [True, False]) @mark_sync_test def test_to_df_parse_dates(keys, values, expected_df, expand): connection = ConnectionStub(records=Records(keys, values)) result = Result(connection, 1, noop, noop) result._run("CYPHER", {}, None, None, "r", None) df = result.to_df(expand=expand, parse_dates=True) pd.testing.assert_frame_equal(df, expected_df) @pytest.mark.parametrize("nested", [True, False]) @mark_sync_test def test_broken_hydration(nested): value_in = Structure(b"a", "broken") if nested: value_in = [value_in] records_in = Records(["foo", "bar"], [["foobar", value_in]]) connection = ConnectionStub(records=records_in) result = Result(connection, 1, noop, noop) result._run("CYPHER", {}, None, None, "r", None) records_out = Util.list(result) assert len(records_out) == 1 record_out = records_out[0] assert len(record_out) == 2 assert record_out[0] == "foobar" with pytest.raises(BrokenRecordError) as exc: _ = record_out[1] cause = exc.value.__cause__ assert isinstance(cause, ValueError) assert repr(b"a") in str(cause) neo4j-python-driver-5.2.1/tests/unit/sync/work/test_session.py000066400000000000000000000431271433522662700245420ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 contextlib import contextmanager import pytest from neo4j import ( Bookmarks, ManagedTransaction, Session, Transaction, unit_of_work, ) from neo4j._conf import SessionConfig from neo4j._sync.io import ( BoltPool, Neo4jPool, ) from neo4j.api import BookmarkManager from ...._async_compat import mark_sync_test @contextmanager def assert_warns_tx_func_deprecation(tx_func_name): if tx_func_name.endswith("_transaction"): with pytest.warns(DeprecationWarning, match=f"{tx_func_name}.*execute_"): yield else: yield @mark_sync_test def test_session_context_calls_close(mocker): s = Session(None, SessionConfig()) mock_close = mocker.patch.object(s, 'close', autospec=True, side_effect=s.close) with s: pass mock_close.assert_called_once_with() @pytest.mark.parametrize("test_run_args", ( ("RETURN $x", {"x": 1}), ("RETURN 1",) )) @pytest.mark.parametrize(("repetitions", "consume"), ( (1, False), (2, False), (2, True) )) @mark_sync_test def test_opens_connection_on_run( fake_pool, test_run_args, repetitions, consume ): with Session(fake_pool, SessionConfig()) as session: assert session._connection is None result = session.run(*test_run_args) assert session._connection is not None if consume: result.consume() @pytest.mark.parametrize("test_run_args", ( ("RETURN $x", {"x": 1}), ("RETURN 1",) )) @pytest.mark.parametrize("repetitions", range(1, 3)) @mark_sync_test def test_closes_connection_after_consume( fake_pool, test_run_args, repetitions ): with Session(fake_pool, SessionConfig()) as session: result = session.run(*test_run_args) result.consume() assert session._connection is None assert session._connection is None @pytest.mark.parametrize("test_run_args", ( ("RETURN $x", {"x": 1}), ("RETURN 1",) )) @mark_sync_test def test_keeps_connection_until_last_result_consumed( fake_pool, test_run_args ): with Session(fake_pool, SessionConfig()) as session: result1 = session.run(*test_run_args) result2 = session.run(*test_run_args) assert session._connection is not None result1.consume() assert session._connection is not None result2.consume() assert session._connection is None @mark_sync_test def test_opens_connection_on_tx_begin(fake_pool): with Session(fake_pool, SessionConfig()) as session: assert session._connection is None with session.begin_transaction() as _: assert session._connection is not None @pytest.mark.parametrize("test_run_args", ( ("RETURN $x", {"x": 1}), ("RETURN 1",) )) @pytest.mark.parametrize("repetitions", range(1, 3)) @mark_sync_test def test_keeps_connection_on_tx_run( fake_pool, test_run_args, repetitions ): with Session(fake_pool, SessionConfig()) as session: with session.begin_transaction() as tx: for _ in range(repetitions): tx.run(*test_run_args) assert session._connection is not None @pytest.mark.parametrize("test_run_args", ( ("RETURN $x", {"x": 1}), ("RETURN 1",) )) @pytest.mark.parametrize("repetitions", range(1, 3)) @mark_sync_test def test_keeps_connection_on_tx_consume( fake_pool, test_run_args, repetitions ): with Session(fake_pool, SessionConfig()) as session: with session.begin_transaction() as tx: for _ in range(repetitions): result = tx.run(*test_run_args) result.consume() assert session._connection is not None @pytest.mark.parametrize("test_run_args", ( ("RETURN $x", {"x": 1}), ("RETURN 1",) )) @mark_sync_test def test_closes_connection_after_tx_close(fake_pool, test_run_args): with Session(fake_pool, SessionConfig()) as session: with session.begin_transaction() as tx: for _ in range(2): result = tx.run(*test_run_args) result.consume() tx.close() assert session._connection is None assert session._connection is None @pytest.mark.parametrize("test_run_args", ( ("RETURN $x", {"x": 1}), ("RETURN 1",) )) @mark_sync_test def test_closes_connection_after_tx_commit(fake_pool, test_run_args): with Session(fake_pool, SessionConfig()) as session: with session.begin_transaction() as tx: for _ in range(2): result = tx.run(*test_run_args) result.consume() tx.commit() assert session._connection is None assert session._connection is None @pytest.mark.parametrize( "bookmark_values", (None, [], ["abc"], ["foo", "bar"], {"a", "b"}, ("1", "two")) ) @mark_sync_test def test_session_returns_bookmarks_directly(fake_pool, bookmark_values): if bookmark_values is not None: bookmarks = Bookmarks.from_raw_values(bookmark_values) else: bookmarks = Bookmarks() with Session( fake_pool, SessionConfig(bookmarks=bookmarks) ) as session: ret_bookmarks = (session.last_bookmarks()) assert isinstance(ret_bookmarks, Bookmarks) ret_bookmarks = ret_bookmarks.raw_values if bookmark_values is None: assert ret_bookmarks == frozenset() else: assert ret_bookmarks == frozenset(bookmark_values) @pytest.mark.parametrize( "bookmarks", (None, [], ["abc"], ["foo", "bar"], ("1", "two")) ) @mark_sync_test def test_session_last_bookmark_is_deprecated(fake_pool, bookmarks): if bookmarks is not None: with pytest.warns(DeprecationWarning): session = Session(fake_pool, SessionConfig(bookmarks=bookmarks)) else: session = Session(fake_pool, SessionConfig(bookmarks=bookmarks)) with session: with pytest.warns(DeprecationWarning): if bookmarks: assert (session.last_bookmark()) == bookmarks[-1] else: assert (session.last_bookmark()) is None @pytest.mark.parametrize( "bookmarks", (("foo",), ("foo", "bar"), (), ["foo", "bar"], {"a", "b"}) ) @mark_sync_test def test_session_bookmarks_as_iterable_is_deprecated( fake_pool, bookmarks ): with pytest.warns(DeprecationWarning): with Session(fake_pool, SessionConfig( bookmarks=bookmarks )) as session: ret_bookmarks = (session.last_bookmarks()).raw_values assert ret_bookmarks == frozenset(bookmarks) @pytest.mark.parametrize(("query", "error_type"), ( (None, ValueError), (1234, TypeError), ({"how about": "no?"}, TypeError), (["I don't", "think so"], TypeError), )) @mark_sync_test def test_session_run_wrong_types(fake_pool, query, error_type): with Session(fake_pool, SessionConfig()) as session: with pytest.raises(error_type): session.run(query) @pytest.mark.parametrize("tx_type", ("write_transaction", "read_transaction", "execute_write", "execute_read",)) @mark_sync_test def test_tx_function_argument_type(fake_pool, tx_type): called = False def work(tx): nonlocal called called = True assert isinstance(tx, ManagedTransaction) with Session(fake_pool, SessionConfig()) as session: with assert_warns_tx_func_deprecation(tx_type): getattr(session, tx_type)(work) assert called @pytest.mark.parametrize("tx_type", ("write_transaction", "read_transaction", "execute_write", "execute_read")) @pytest.mark.parametrize("decorator_kwargs", ( {}, {"timeout": 5}, {"metadata": {"foo": "bar"}}, {"timeout": 5, "metadata": {"foo": "bar"}}, )) @mark_sync_test def test_decorated_tx_function_argument_type( fake_pool, tx_type, decorator_kwargs ): called = False @unit_of_work(**decorator_kwargs) def work(tx): nonlocal called called = True assert isinstance(tx, ManagedTransaction) with Session(fake_pool, SessionConfig()) as session: with assert_warns_tx_func_deprecation(tx_type): getattr(session, tx_type)(work) assert called @mark_sync_test def test_session_tx_type(fake_pool): with Session(fake_pool, SessionConfig()) as session: tx = session.begin_transaction() assert isinstance(tx, Transaction) @pytest.mark.parametrize("parameters", ( {"x": None}, {"x": True}, {"x": False}, {"x": 123456789}, {"x": 3.1415926}, {"x": float("nan")}, {"x": float("inf")}, {"x": float("-inf")}, {"x": "foo"}, {"x": bytearray([0x00, 0x33, 0x66, 0x99, 0xCC, 0xFF])}, {"x": b"\x00\x33\x66\x99\xcc\xff"}, {"x": [1, 2, 3]}, {"x": ["a", "b", "c"]}, {"x": ["a", 2, 1.234]}, {"x": ["a", 2, ["c"]]}, {"x": {"one": "eins", "two": "zwei", "three": "drei"}}, {"x": {"one": ["eins", "uno", 1], "two": ["zwei", "dos", 2]}}, )) @pytest.mark.parametrize("run_type", ("auto", "unmanaged", "managed")) @mark_sync_test def test_session_run_with_parameters(fake_pool, parameters, run_type): with Session(fake_pool, SessionConfig()) as session: if run_type == "auto": session.run("RETURN $x", **parameters) elif run_type == "unmanaged": tx = session.begin_transaction() tx.run("RETURN $x", **parameters) elif run_type == "managed": def work(tx): tx.run("RETURN $x", **parameters) session.execute_write(work) else: raise ValueError(run_type) assert len(fake_pool.acquired_connection_mocks) == 1 connection_mock = fake_pool.acquired_connection_mocks[0] connection_mock.run.assert_called_once() call = connection_mock.run.call_args assert call.args[0] == "RETURN $x" assert call.kwargs["parameters"] == parameters @pytest.mark.parametrize( ("params", "kw_params", "expected_params"), ( ({"x": 1}, {}, {"x": 1}), ({}, {"x": 1}, {"x": 1}), ({"x": 1}, {"y": 2}, {"x": 1, "y": 2}), ({"x": 1}, {"x": 2}, {"x": 2}), ({"x": 1}, {"x": 2}, {"x": 2}), ({"x": 1, "y": 3}, {"x": 2}, {"x": 2, "y": 3}), ({"x": 1}, {"x": 2, "y": 3}, {"x": 2, "y": 3}), # potentially internally used keyword arguments ({}, {"timeout": 2}, {"timeout": 2}), ({"timeout": 2}, {}, {"timeout": 2}), ({}, {"imp_user": "hans"}, {"imp_user": "hans"}), ({"imp_user": "hans"}, {}, {"imp_user": "hans"}), ({}, {"db": "neo4j"}, {"db": "neo4j"}), ({"db": "neo4j"}, {}, {"db": "neo4j"}), ({}, {"database": "neo4j"}, {"database": "neo4j"}), ({"database": "neo4j"}, {}, {"database": "neo4j"}), ) ) @pytest.mark.parametrize("run_type", ("auto", "unmanaged", "managed")) @mark_sync_test def test_session_run_parameter_precedence( fake_pool, params, kw_params, expected_params, run_type ): with Session(fake_pool, SessionConfig()) as session: if run_type == "auto": session.run("RETURN $x", params, **kw_params) elif run_type == "unmanaged": tx = session.begin_transaction() tx.run("RETURN $x", params, **kw_params) elif run_type == "managed": def work(tx): tx.run("RETURN $x", params, **kw_params) session.execute_write(work) else: raise ValueError(run_type) assert len(fake_pool.acquired_connection_mocks) == 1 connection_mock = fake_pool.acquired_connection_mocks[0] connection_mock.run.assert_called_once() call = connection_mock.run.call_args assert call.args[0] == "RETURN $x" assert call.kwargs["parameters"] == expected_params @pytest.mark.parametrize("db", (None, "adb")) @pytest.mark.parametrize("routing", (True, False)) # no home db resolution when connected to Neo4j 4.3 or earlier @pytest.mark.parametrize("home_db_gets_resolved", (True, False)) @pytest.mark.parametrize("additional_session_bookmarks", (None, ["session", "bookmarks"])) @mark_sync_test def test_with_bookmark_manager( fake_pool, db, routing, scripted_connection, home_db_gets_resolved, additional_session_bookmarks, mocker ): def update_routing_table_side_effect( database, imp_user, bookmarks, acquisition_timeout=None, database_callback=None ): if home_db_gets_resolved: database_callback("homedb") def bmm_get_bookmarks(database): return [f"{database}:bm1"] def bmm_gat_all_bookmarks(): return ["all", "bookmarks"] scripted_connection.set_script([ ("run", {"on_success": None, "on_summary": None}), ("pull", { "on_success": ({"bookmark": "res:bm1", "has_more": False},), "on_summary": None, "on_records": None, }) ]) fake_pool.buffered_connection_mocks.append(scripted_connection) bmm = mocker.Mock(spec=BookmarkManager) bmm.get_bookmarks.side_effect = bmm_get_bookmarks bmm.get_all_bookmarks.side_effect = bmm_gat_all_bookmarks if routing: fake_pool.mock_add_spec(Neo4jPool) fake_pool.update_routing_table.side_effect = \ update_routing_table_side_effect else: fake_pool.mock_add_spec(BoltPool) config = SessionConfig() config.bookmark_manager = bmm if db is not None: config.database = db if additional_session_bookmarks: config.bookmarks = Bookmarks.from_raw_values( additional_session_bookmarks ) with Session(fake_pool, config) as session: assert not bmm.method_calls session.run("RETURN 1") # assert called bmm accordingly expected_bmm_method_calls = [mocker.call.get_bookmarks("system"), mocker.call.get_all_bookmarks()] if routing and db is None: expected_bmm_method_calls = [ # extra call for resolving the home database mocker.call.get_bookmarks("system"), *expected_bmm_method_calls ] assert bmm.method_calls == expected_bmm_method_calls assert (bmm.get_bookmarks.call_count == len(expected_bmm_method_calls) - 1) bmm.get_all_bookmarks.assert_called_once() bmm.method_calls.clear() expected_update_for_db = db if not db: if home_db_gets_resolved and routing: expected_update_for_db = "homedb" else: expected_update_for_db = "" assert [call[0] for call in bmm.method_calls] == ["update_bookmarks"] assert bmm.method_calls[0].kwargs == {} assert len(bmm.method_calls[0].args) == 3 assert bmm.method_calls[0].args[0] == expected_update_for_db assert (set(bmm.method_calls[0].args[1]) == {"all", "bookmarks", *(additional_session_bookmarks or [])}) assert set(bmm.method_calls[0].args[2]) == {"res:bm1"} expected_pool_method_calls = ["acquire", "release"] if routing and db is None: expected_pool_method_calls = ["update_routing_table", *expected_pool_method_calls] assert ([call[0] for call in fake_pool.method_calls] == expected_pool_method_calls) assert (set(fake_pool.acquire.call_args.kwargs["bookmarks"]) == {"system:bm1", *(additional_session_bookmarks or [])}) if routing and db is None: assert ( set(fake_pool.update_routing_table.call_args.kwargs["bookmarks"]) == {"system:bm1", *(additional_session_bookmarks or [])} ) assert len(fake_pool.acquired_connection_mocks) == 1 connection_mock = fake_pool.acquired_connection_mocks[0] connection_mock.run.assert_called_once() connection_run_call_kwargs = connection_mock.run.call_args.kwargs assert (set(connection_run_call_kwargs["bookmarks"]) == {"all", "bookmarks", *(additional_session_bookmarks or [])}) @pytest.mark.parametrize("routing", (True, False)) @pytest.mark.parametrize("session_method", ("run", "get_server_info")) @mark_sync_test def test_last_bookmarks_do_not_leak_bookmark_managers_bookmarks( fake_pool, routing, session_method, mocker ): def bmm_get_bookmarks(database): return [f"bmm:{database}"] def bmm_gat_all_bookmarks(): return ["bmm:all", "bookmarks"] fake_pool.mock_add_spec(Neo4jPool if routing else BoltPool) bmm = mocker.Mock(spec=BookmarkManager) bmm.get_bookmarks.side_effect = bmm_get_bookmarks bmm.get_all_bookmarks.side_effect = bmm_gat_all_bookmarks config = SessionConfig() config.bookmark_manager = bmm config.bookmarks = Bookmarks.from_raw_values(["session", "bookmarks"]) with Session(fake_pool, config) as session: if session_method == "run": session.run("RETURN 1") elif session_method == "get_server_info": session._get_server_info() else: assert False last_bookmarks = session.last_bookmarks() assert last_bookmarks.raw_values == {"session", "bookmarks"} assert last_bookmarks.raw_values == {"session", "bookmarks"} neo4j-python-driver-5.2.1/tests/unit/sync/work/test_transaction.py000066400000000000000000000145021433522662700253770ustar00rootroot00000000000000# Copyright (c) "Neo4j" # Neo4j Sweden AB [https://neo4j.com] # # This file is part of Neo4j. # # 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 # # https://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 unittest.mock import MagicMock from uuid import uuid4 import pytest from neo4j import ( Query, Transaction, ) from ...._async_compat import mark_sync_test @pytest.mark.parametrize(("explicit_commit", "close"), ( (False, False), (True, False), (True, True), )) @mark_sync_test def test_transaction_context_when_committing( mocker, fake_connection, explicit_commit, close ): on_closed = mocker.Mock() on_error = mocker.Mock() on_cancel = mocker.Mock() tx = Transaction(fake_connection, 2, on_closed, on_error, on_cancel) mock_commit = mocker.patch.object(tx, "_commit", wraps=tx._commit) mock_rollback = mocker.patch.object(tx, "_rollback", wraps=tx._rollback) with tx as tx_: assert mock_commit.call_count == 0 assert mock_rollback.call_count == 0 assert tx is tx_ if explicit_commit: tx_.commit() mock_commit.assert_called_once_with() assert tx_.closed() if close: tx_.close() assert tx_.closed() mock_commit.assert_called_once_with() assert mock_rollback.call_count == 0 assert tx_.closed() @pytest.mark.parametrize(("rollback", "close"), ( (True, False), (False, True), (True, True), )) @mark_sync_test def test_transaction_context_with_explicit_rollback( mocker, fake_connection, rollback, close ): on_closed = mocker.Mock() on_error = mocker.Mock() on_cancel = mocker.Mock() tx = Transaction(fake_connection, 2, on_closed, on_error, on_cancel) mock_commit = mocker.patch.object(tx, "_commit", wraps=tx._commit) mock_rollback = mocker.patch.object(tx, "_rollback", wraps=tx._rollback) with tx as tx_: assert mock_commit.call_count == 0 assert mock_rollback.call_count == 0 assert tx is tx_ if rollback: tx_.rollback() mock_rollback.assert_called_once_with() assert tx_.closed() if close: tx_.close() mock_rollback.assert_called_once_with() assert tx_.closed() assert mock_commit.call_count == 0 mock_rollback.assert_called_once_with() assert tx_.closed() @mark_sync_test def test_transaction_context_calls_rollback_on_error( mocker, fake_connection ): class OopsError(RuntimeError): pass on_closed = MagicMock() on_error = MagicMock() on_cancel = MagicMock() tx = Transaction(fake_connection, 2, on_closed, on_error, on_cancel) mock_commit = mocker.patch.object(tx, "_commit", wraps=tx._commit) mock_rollback = mocker.patch.object(tx, "_rollback", wraps=tx._rollback) with pytest.raises(OopsError): with tx as tx_: assert mock_commit.call_count == 0 assert mock_rollback.call_count == 0 assert tx is tx_ raise OopsError assert mock_commit.call_count == 0 mock_rollback.assert_called_once_with() assert tx_.closed() @mark_sync_test def test_transaction_run_takes_no_query_object(fake_connection): on_closed = MagicMock() on_error = MagicMock() on_cancel = MagicMock() tx = Transaction(fake_connection, 2, on_closed, on_error, on_cancel) with pytest.raises(ValueError): tx.run(Query("RETURN 1")) @mark_sync_test def test_transaction_rollbacks_on_open_connections( fake_connection ): tx = Transaction( fake_connection, 2, lambda *args, **kwargs: None, lambda *args, **kwargs: None, lambda *args, **kwargs: None ) with tx as tx_: fake_connection.is_reset_mock.return_value = False fake_connection.is_reset_mock.reset_mock() tx_.rollback() fake_connection.is_reset_mock.assert_called_once() fake_connection.reset.assert_not_called() fake_connection.rollback.assert_called_once() @mark_sync_test def test_transaction_no_rollback_on_reset_connections( fake_connection ): tx = Transaction( fake_connection, 2, lambda *args, **kwargs: None, lambda *args, **kwargs: None, lambda *args, **kwargs: None ) with tx as tx_: fake_connection.is_reset_mock.return_value = True fake_connection.is_reset_mock.reset_mock() tx_.rollback() fake_connection.is_reset_mock.assert_called_once() fake_connection.reset.assert_not_called() fake_connection.rollback.assert_not_called() @mark_sync_test def test_transaction_no_rollback_on_closed_connections( fake_connection ): tx = Transaction( fake_connection, 2, lambda *args, **kwargs: None, lambda *args, **kwargs: None, lambda *args, **kwargs: None ) with tx as tx_: fake_connection.closed.return_value = True fake_connection.closed.reset_mock() fake_connection.is_reset_mock.reset_mock() tx_.rollback() fake_connection.closed.assert_called_once() fake_connection.is_reset_mock.assert_not_called() fake_connection.reset.assert_not_called() fake_connection.rollback.assert_not_called() @mark_sync_test def test_transaction_no_rollback_on_defunct_connections( fake_connection ): tx = Transaction( fake_connection, 2, lambda *args, **kwargs: None, lambda *args, **kwargs: None, lambda *args, **kwargs: None ) with tx as tx_: fake_connection.defunct.return_value = True fake_connection.defunct.reset_mock() fake_connection.is_reset_mock.reset_mock() tx_.rollback() fake_connection.defunct.assert_called_once() fake_connection.is_reset_mock.assert_not_called() fake_connection.reset.assert_not_called() fake_connection.rollback.assert_not_called() neo4j-python-driver-5.2.1/tox.ini000066400000000000000000000006711433522662700166770ustar00rootroot00000000000000[tox] envlist = py{37,38,39,310}-{unit,integration,performance} [testenv] passenv = TEST_NEO4J_* deps = -r tests/requirements.txt commands = coverage erase unit: coverage run -m pytest -W error -v {posargs} tests/unit integration: coverage run -m pytest -W error -v {posargs} tests/integration performance: python -m pytest --benchmark-autosave -v {posargs} tests/performance unit,integration: coverage report