RǻiddlmZddlZddlmZddlmZddlm Z ddl m Z m Z m Z mZmZmZmZmZmZddlmZmZmZmZmZmZdd lmZdd lmZm Z m!Z!dd l"m#Z#m$Z$m%Z%dd l&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3dd l4m5Z5m6Z6m7Z7m8Z8ddl9m:Z:m;Z;ddl4mZ>m?Z@mAZBddlCmDZDddlEmFZFmGZGmHZHejr,ddlJZJddlKmLZLddl mMZMmNZNmOZOGddeLZPePjZRneSZRejdZUGddZVGddZWGddZXGdd ZY d)d!Z"Gd"d#eWeYZZGd$d%eXeYZ[d&d'd(Z\y)*) annotationsN)NoneType)_typing)Address) DRIVER_BOLT DRIVER_NEO4JNotificationMinimumSeverityparse_neo4j_uriparse_routing_contextRoutingControlSECURITY_TYPE_SECURE%SECURITY_TYPE_SELF_SIGNED_CERTIFICATE TelemetryAPI)ConfigConfigurationError SessionConfigTrustAll TrustStoreWorkspaceConfig)ENABLED)deprecation_warn preview_warnunclosed_resource_warn) EagerResultQuery unit_of_work) _TAuthAuthBookmarkManager Bookmarks READ_ACCESS ServerInfoURI_SCHEME_BOLTURI_SCHEME_BOLT_SECURE'URI_SCHEME_BOLT_SELF_SIGNED_CERTIFICATEURI_SCHEME_NEO4JURI_SCHEME_NEO4J_SECURE(URI_SCHEME_NEO4J_SELF_SIGNED_CERTIFICATE WRITE_ACCESS) AuthManager AuthManagersClientCertificateClientCertificateProvider) DriverError Neo4jError) _StaticClientCertificateProvider)Neo4jBookmarkManager TBmConsumer TBmSupplier) PoolConfig)ManagedTransactionResultSession)Enum)$T_NotificationDisabledClassificationT_NotificationMinimumSeverityT_RoutingControlceZdZdZy) _DefaultEnumdefaultN)__name__ __module__ __qualname__r@P/opt/lhia/marcimex/agent/venv/lib/python3.12/site-packages/neo4j/_sync/driver.pyr?r?gsrEr?_TcTeZdZdZej r`edddddddddddddddddddddddddddd d dZnedd d dZe d ddZed Z edd Z y) GraphDatabasez0Accessor for :class:`neo4j.Driver` construction..)authmax_connection_lifetimeliveness_check_timeoutmax_connection_pool_sizeconnection_timeoutconnection_write_timeoutresolver encryptedtrusted_certificatesclient_certificate ssl_context user_agent keep_alivenotifications_min_severity!notifications_disabled_categories¬ifications_disabled_classificationswarn_notification_severitytelemetry_disabledmax_transaction_retry_timeconnection_acquisition_timeoutinitial_retry_delayretry_delay_multiplierretry_delay_jitter_factordatabase fetch_sizeimpersonated_userbookmark_managercyNrD)clsurirJrKrLrMrNrOrPrQrRrSrTrUrVrWrXrYrZr[r\r]r^r_r`rarbrcrds rFdriverzGraphDatabase.driverwsdrEN)rJc t|\}}}t|tstj|}||d<|j d}t|t rt||d<d|vr9t|dts&tdjt|d|tthvrEd|vsd|vsd|vr9tdjttgt t"t$t&g|tk(rd|d<n|tk(rd|d<t)|d<d |vr t+d d t-|d |j d}||dkrtd|d|t.t0hvsJ|t.k(rAt3|j4rtd|d|j6|j8fi|St3|j4} |j:|j8fd| i|S)a 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. rJrSrRzThe config setting "trusted_certificates" must be of type neo4j.TrustAll, neo4j.TrustCustomCAs, orneo4j.TrustSystemCAs but was {}rQrTzThe config settings "encrypted", "trusted_certificates", and "ssl_context" can only be used with the URI schemes {!r}. Use the other URI schemes {!r} for setting encryption settings.TrXdnotifications_disabled_categories is deprecated, use notifications_disabled_classifications instead.r stack_level driver_levelrLrzWThe config setting "liveness_check_timeout" must be greater than or equal to 0 but was .zrRouting context (URI query parameters) are not supported by direct drivers ("bolt[+s[sc]]://" scheme). Given URI: routing_context)r isinstancer+r,staticgetr-r2rrformattyperrr$r'r&r%r)r(rr_normalize_notifications_configrr r query _bolt_drivernetloc _neo4j_driver) rgrhrJconfig driver_type security_typeparsedrSrLrqs rFrizGraphDatabase.driversW&2A1E .KdK0#**40!F6N!',@!A ,.?@55GH+,&/ -. 9)66BH rEct|ttfsLtddtjt j t jt|}n|}t|||S)a 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 # omitting closing the driver for brevity driver = neo4j.GraphDatabase.driver(...) bookmark_manager = neo4j.GraphDatabase.bookmark_manager(...) with ( driver.session(bookmark_manager=bookmark_manager) as session1, driver.session( bookmark_manager=bookmark_manager, default_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. .. deprecated:: 6.0 Passing raw string bookmarks is deprecated. Use a :class:`.Bookmarks` object instead. :param bookmarks_supplier: Function which will be called every time the default bookmark manager's method :meth:`.BookmarkManager.get_bookmarks` gets called. The function takes no arguments and 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. It will, however, not update the internal set of bookmarks. :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 new set of bookmarks as a :class:`.Bookmarks` object and return :data:`None`. :returns: A default implementation of :class:`.BookmarkManager`. .. versionadded:: 5.0 .. versionchanged:: 5.3 The bookmark manager no longer tracks bookmarks per database. This effectively changes the signature of almost all bookmark manager related methods: * ``initial_bookmarks`` is no longer a mapping from database name to bookmarks but plain bookmarks. * ``bookmarks_supplier`` no longer receives the database name as an argument. * ``bookmarks_consumer`` no longer receives the database name as an argument. .. versionchanged:: 5.8 Stabilized from experimental. .. versionchanged:: 6.0 Deprecated passing raw string bookmarks as initial_bookmarks. zWPassing raw strings as initial_bookmarks is deprecated. Use a Bookmarks object instead.rrl)initial_bookmarksbookmarks_supplierbookmarks_consumer) rrr!rrfrom_raw_valuestcastIterablestrr3)rgrrrcast_initial_bookmarkss rFrdzGraphDatabase.bookmark_managersop+i-BC 6  &/%>%>qzz#(9:& "&7 "#411  rEc ddlm}m} tj|fi|S#||f$r}ddlm}|t||d}~wwxYw)z Create a direct driver. Create a driver for direct Bolt server access that uses socket I/O and thread-based concurrency. rBoltHandshakeErrorBoltSecurityErrorServiceUnavailableN) _exceptionsrr BoltDriver_open exceptionsrr)rgtargetr|rrerrorrs rFryzGraphDatabase._bolt_driversL  <##F5f5 5"$56 < 7$SZ0e ; eZdZdZdZdZdZedZe dZ y)_Direct localhost:c||_yrf_address)selfaddresss rF__init__z_Direct.__init__s  rEc|jSrfrrs rFrz_Direct.addresss }}rEcv|s |j}tj||j|jS)z,Parse a target string to produce an address. default_host default_port)_default_targetrparse _default_host _default_port)rgrs rF _parse_targetz_Direct._parse_targets8((F}} ****  rEN) rArBrCrrrrpropertyrrrrDrErFrrs>MMO   rErc>eZdZdZdZdZdZedZe dZ y)_Routingrrz: :17601 :17687c||_yrf_initial_addresses)rinitial_addressess rFrz_Routing.__init__s "3rEc|jSrfrrs rFrz_Routing.initial_addressess&&&rEcdj|}|s |j}tj||j|j S)z>Parse a sequence of target strings to produce an address list. r)join_default_targetsr parse_listrr)rgtargetss rF_parse_targetsz_Routing._parse_targetssH((7#**G!! ****  rEN) rArBrCrrrrrrrrrDrErFrrs?MM(4''    rErc eZdZUdZdZded<dZdZd"dZdZ e fd Z d Z e d#d Zej r5d d d d d d d d d d d d d d d d  d$dZnd%dZd%dZdZedZd&dZej.dej2ddd dd f d'dZej.dej2ddd dd f d(dZdej2ddedej:f d)dZe d*dZej r8d d d d d d d d d d d d d d d d d d+dZnd&dZej r8d d d d d d d d d d d d d d d d d d,dZ nd-dZ d#dZ!ej r. d. d/dZ"n d0 d1dZ"d#d Z#d-d!Z$y)2rzf Base class for all driver types. Drivers are used as the primary access point to Neo4j. Nt.Any_poolFcb|J|J||_||_tj|_yrf)r_default_workspace_configrIrd_query_bookmark_managerrpooldefault_workspace_configs rFrzDriver.__init__s:'333 )A&'4'E'E'G$rEc|SrfrDrs rF __enter__zDriver.__enter__s rEc$|jyrf)close)rexc_type exc_value tracebacks rF__exit__zDriver.__exit__s  rEc.|js ||yyrf)_closed)r_unclosed_resource_warns rF__del__zDriver.__del__s|| #D )rEc2|jr tdy)Nz Driver closed)rr/rs rF _check_statezDriver._check_states <<o. . rEcTt|jjjS)z=Indicate whether the driver was configured to use encryption.)rr pool_configrQrs rFrQzDriver.encrypted sDJJ**4455rE.)r]r\rarbrc bookmarksdefault_access_moderdrJrWrXrYr^r_r`cyrfrD)rr]r\rarbrcrrrdrJrWrXrYr^r_r`s rFsessionzDriver.sessions:rEc |jdd|jd|vr tdd|j|}|j |S)a Create a session. See :ref:`session-construction-ref` for details. :param config: session configuration key-word arguments, see :ref:`session-configuration-ref` for available key-word arguments. :returns: new :class:`neo4j.Session` object :raises DriverError: if the driver has been closed. .. versionchanged:: 6.0 * Raise :exc:`DriverError` if the driver has been closed. * Deprecated ``notifications_disabled_categories`` in favor of ``notifications_disabled_classifications``. rZNrXrkrrl)poprr_read_session_config_sessionrr|session_configs rFrzDriver.session1sY, JJ3T :    2f< J ! "66v>N==0 0rEc.t|j|Srf)r9r)rrs rFrzDriver._sessionSstzz>22rEcP|j|}t|j|Srf)_prepare_session_configrr)r config_kwargsr|s rFrzDriver._read_session_configVs%--m<T;;VDDrEct||Srf)rw)rgrs rFrzDriver._prepare_session_configZs' 6rEc|jry |jjd|_y#tj$r d|_wxYw)aShut down, closing any open connections in the pool. .. warning:: While the driver object is concurrency-safe, ``close`` is *not*. Make sure you are not using the driver object or any resources spawned from it (such as sessions or transactions) while calling this method. Failing to do so results in unspecified behavior. NT)rrrasyncioCancelledErrorrs rFrz Driver.close_sM <<   JJ    %% DL  s 1A c yrfrD rquery_ parameters_routing_ database_impersonated_user_bookmark_manager_auth_result_transformer_kwargss rF execute_queryzDriver.execute_queryss rEc yrfrDrs rFrzDriver.execute_querysrEc 8|j| D cgc]} | dddk7s | dddk(s| } } | rtd| dt|tr;|j} |j } |j }t| | t}n|}t}t|xsifi| }|tur |j}|tusJ|j||||d}|j|}|5|tjk(rt }n(|tj"k(rt$}ntd||j&5|j)|t*j,||||ficdddcdddScc} w#1swYnxYw dddy#1swYyxYw) a" Execute a query in a transaction function and return all results. This method is a handy wrapper for lower-level driver APIs like sessions, transactions, and transaction functions. It is intended for simple use cases where there is no need for managing all possible options. The internal usage of transaction functions provides a retry-mechanism for appropriate errors. Furthermore, this means that queries using ``CALL {} IN TRANSACTIONS`` or the older ``USING PERIODIC COMMIT`` will not work (use :meth:`Session.run` for these). The method is roughly equivalent to:: def execute_query( query_, parameters_, routing_, database_, impersonated_user_, bookmark_manager_, auth_, result_transformer_, **kwargs ): @unit_of_work(query_.metadata, query_.timeout) def work(tx): result = tx.run(query_.text, parameters_, **kwargs) return result_transformer_(result) with driver.session( database=database_, impersonated_user=impersonated_user_, bookmark_manager=bookmark_manager_, auth=auth_, ) as session: if routing_ == RoutingControl.WRITE: return session.execute_write(work) elif routing_ == RoutingControl.READ: return session.execute_read(work) Usage example:: from typing import List import neo4j def example(driver: neo4j.Driver) -> List[str]: """Get the name of all 42 year-olds.""" records, summary, keys = driver.execute_query( "MATCH (p:Person {age: $age}) RETURN p.name", {"age": 42}, routing_=neo4j.RoutingControl.READ, # or just "r" database_="neo4j", ) assert keys == ["p.name"] # not needed, just for illustration # log_summary(summary) # log some metadata return [str(record["p.name"]) for record in records] # or: return [str(record[0]) for record in records] # or even: return list(map(lambda r: str(r[0]), records)) Another example:: import neo4j def example(driver: neo4j.Driver) -> int: """Call all young people "My dear" and get their count.""" record = driver.execute_query( "MATCH (p:Person) WHERE p.age <= $age " "SET p.nickname = 'My dear' " "RETURN count(*)", # optional routing parameter, as write is default # routing_=neo4j.RoutingControl.WRITE, # or just "w", database_="neo4j", result_transformer_=neo4j.Result.single, age=15, ) assert record is not None # for typechecking and illustration count = record[0] assert isinstance(count, int) return count :param query_: Cypher query to execute. Use a :class:`.Query` object to pass a query with additional transaction configuration. :type query_: typing.LiteralString | Query :param parameters_: parameters to use in the query :type parameters_: typing.Optional[typing.Dict[str, typing.Any]] :param routing_: Whether to route the query to a reader (follower/read replica) or a writer (leader) in the cluster. Default is to route to a writer. :type routing_: RoutingControl :param database_: Database to execute the query against. :data:`None` (default) uses the database configured on the server side. .. 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 default database first. See also the Session config :ref:`database-ref`. :type database_: typing.Optional[str] :param impersonated_user_: Name of the user to impersonate. This means that all query 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. See also the Session config :ref:`impersonated-user-ref`. :type impersonated_user_: typing.Optional[str] :param auth_: Authentication information to use for this query. By default, the driver configuration is used. See also the Session config :ref:`session-auth-ref`. :type auth_: typing.Tuple[typing.Any, typing.Any] | Auth | None :param result_transformer_: A function that gets passed the :class:`neo4j.Result` object resulting from the query and converts it to a different type. The result of the transformer function is returned by this method. .. warning:: The transformer function must **not** return the :class:`neo4j.Result` itself. .. warning:: N.B. the driver might retry the underlying transaction so the transformer might get invoked more than once (with different :class:`neo4j.Result` objects). Therefore, it needs to be idempotent (i.e., have the same effect, regardless if called once or many times). Example transformer that checks that exactly one record is in the result stream, then returns the record and the result summary:: from typing import Tuple import neo4j def transformer( result: neo4j.Result ) -> Tuple[neo4j.Record, neo4j.ResultSummary]: record = result.single(strict=True) summary = result.consume() return record, summary Note that methods of :class:`neo4j.Result` that don't take mandatory arguments can be used directly as transformer functions. For example:: import neo4j def example(driver: neo4j.Driver) -> neo4j.Record:: record = driver.execute_query( "SOME QUERY", result_transformer_=neo4j.Result.single ) # is equivalent to: def transformer(result: neo4j.Result) -> neo4j.Record: return result.single() def example(driver: neo4j.Driver) -> neo4j.Record:: record = driver.execute_query( "SOME QUERY", result_transformer_=transformer ) :type result_transformer_: typing.Callable[[Result], typing.Union[T]] :param bookmark_manager_: Specify a bookmark manager to use. If present, the bookmark manager is used to keep the query causally consistent with all work executed using the same bookmark manager. Defaults to the driver's :attr:`.execute_query_bookmark_manager`. Pass :data:`None` to disable causal consistency. :type bookmark_manager_: BookmarkManager | BookmarkManager | None :param kwargs: additional keyword parameters. None of these can end with a single underscore. This is to avoid collisions with the keyword configuration parameters of this method. If you need to pass such a parameter, use the ``parameters_`` parameter instead. Parameters passed as kwargs take precedence over those passed in ``parameters_``. :type kwargs: typing.Any :returns: the result of the ``result_transformer_`` :rtype: T :raises DriverError: if the driver has been closed. .. versionadded:: 5.5 .. versionchanged:: 5.8 * Added ``auth_`` parameter in preview. * Stabilized from experimental. .. versionchanged:: 5.14 Stabilized ``auth_`` parameter from preview. .. versionchanged:: 5.15 The ``query_`` parameter now also accepts a :class:`.Query` object instead of only :class:`str`. .. versionchanged:: 6.0 Raise :exc:`DriverError` if the driver has been closed. _Nz:keyword parameters must not end with a single '_'. Found: z You either misspelled an existing configuration parameter or tried to send a query parameter that is reserved. In the latter case, use the `parameters_` dictionary instead.)rarcrdrJzInvalid routing control value: )r ValueErrorrrrtimeoutmetadatatextr_workdict_defaultrrrr WRITEr*READr"_pipelined_begin_run_transactionrDRIVER)rrrrrrrrrrkinvalid_kwargsrr query_strwork parametersrr access_modes rFrzDriver.execute_querys`  2bSQrsVs]A   (+,II  fe $nnGH I2<'259DID++6v6  ( $ < <  00022%%7$5   --/  >///* ^000)  5h\B)) // '' ,?@     E V      s4 E5E5E5-AF<&E:" F:F ?FFc|jS)aK The driver's default query bookmark manager. This is the default :class:`.BookmarkManager` used by :meth:`.execute_query`. This can be used to causally chain :meth:`.execute_query` calls and sessions. Example:: def example(driver: neo4j.Driver) -> None: driver.execute_query("") with driver.session( bookmark_manager=driver.execute_query_bookmark_manager ) as session: # every query inside this session will be causally chained # (i.e., can read what was written by ) session.run("") # subsequent execute_query calls will be causally chained # (i.e., can read what was written by ) driver.execute_query("") .. versionadded:: 5.5 .. versionchanged:: 5.8 * Renamed from ``query_bookmark_manager`` to ``execute_query_bookmark_manager``. * Stabilized from experimental. )rrs rFexecute_query_bookmark_managerz%Driver.execute_query_bookmark_managers:+++rE)session_connection_timeoutr]r\rarbrcrrrdrJrWrXrYr^r_r`cyrfrDrrr]r\rarbrcrrrdrJrWrXrYr^r_r`s rFverify_connectivityzDriver.verify_connectivitys<rEc |j|r td|j|}|j|y)a+ 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:: Passing key-word arguments is a preview feature. It might be changed or removed in any future version without prior notice. :raises Exception: if the driver cannot connect to the remote. Use the exception to further understand the cause of the connectivity problem. :raises DriverError: if the driver has been closed. .. versionchanged:: 5.0 The undocumented return value has been removed. If you need information about the remote server, use :meth:`get_server_info` instead. .. versionchanged:: 6.0 Raise :exc:`DriverError` if the driver has been closed. zIPassing key-word arguments to verify_connectivity() is a preview feature.Nrrr_get_server_infors rFrzDriver.verify_connectivitysA@    '"66v>N  ! !. 1rEcyrfrDrs rFget_server_infozDriver.get_server_info(s<rEc |j|r td|j|}|j|S)a 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:: Passing key-word arguments is a preview feature. It might be changed or removed in any future version without prior notice. :raises Exception: if the driver cannot connect to the remote. Use the exception to further understand the cause of the connectivity problem. :raises DriverError: if the driver has been closed. .. versionadded:: 5.0 .. versionchanged:: 6.0 Raise :exc:`DriverError` if the driver has been closed. zEPassing key-word arguments to get_server_info() is a preview feature.rrs rFr"zDriver.get_server_infoJsDB    '"66v>N((8 8rEc|j|ji}|j|5}|jt|j sJ|j j cdddS#1swYyxYw)a Check if the server or cluster supports multi-databases. .. note:: Feature support query based solely on the Bolt protocol version. The feature might still be disabled on the server side even if this function return :data:`True`. It just guarantees that the driver won't throw a :exc:`.ConfigurationError` when trying to use this driver feature. :returns: Returns true if the server or cluster the driver connects to supports multi-databases, otherwise false. :raises DriverError: if the driver has been closed. .. versionchanged:: 6.0 Raise :exc:`DriverError` if the driver has been closed. N)rrr_connectr" _connectionsupports_multiple_databasesrrrs rFsupports_multi_dbzDriver.supports_multi_dbtss& 2226 ]]> * Cg   [ )&& &&&&BB C C C 9A66A?cyrfrD)rrJrr]r\rarbrcrrrdr^r_r`s rFverify_authenticationzDriver.verify_authentications(rEc X|j|r tdd|vrd|d<|j|}t|d|i}|j |5} |j  dddy#t $r!}|jdvr Yd}~dddyd}~wwxYw#1swYyxYw) a Verify that the authentication information is valid. Like :meth:`.verify_connectivity`, but for checking authentication. Try to establish a working read connection to the remote server or a member of a cluster and exchange some data. In a cluster, there is no guarantee about which server will be contacted. If the data exchange is successful and the authentication information is valid, :data:`True` is returned. Otherwise, the error will be matched against a list of known authentication errors. If the error is on that list, :data:`False` is returned indicating that the authentication information is invalid. Otherwise, the error is re-raised. :param auth: authentication information to verify. Same as the session config :ref:`auth-ref`. :param config: accepts the same configuration key-word arguments as :meth:`session`. .. warning:: Passing key-word arguments (except ``auth``) is a preview feature. It might be changed or removed in any future version without prior notice. :raises Exception: if the driver cannot connect to the remote. Use the exception to further understand the cause of the connectivity problem. :raises DriverError: if the driver has been closed. .. versionadded:: 5.8 .. versionchanged:: 5.14 Stabilized from experimental. .. versionchanged:: 6.0 Raise :exc:`DriverError` if the driver has been closed. zYPassing key-word arguments except 'auth' to verify_authentication() is a preview feature.rasystemrJ>"Neo.ClientError.Security.Forbidden%Neo.ClientError.Security.TokenExpired%Neo.ClientError.Security.Unauthorized+Neo.ClientError.Security.CredentialsExpiredNFT)rrrrr_verify_authenticationr0code)rrJr|rrexcs rFr,zDriver.verify_authenticationsT    D'%-z"!66v>N*>FD>JN~. ' 224 "xx$ %   s6B A33 B<B B BBB  B)c|j|ji}|j|5}|jt|j sJ|j j cdddS#1swYyxYw)a  Check if the remote supports connection re-authentication. .. note:: Feature support query based solely on the Bolt protocol version. The feature might still be disabled on the server side even if this function return :data:`True`. It just guarantees that the driver won't throw a :exc:`.ConfigurationError` when trying to use this driver feature. :returns: Returns true if the server or cluster the driver connects to supports re-authentication of existing connections, otherwise false. :raises DriverError: if the driver has been closed. .. versionadded:: 5.8 .. versionchanged:: 6.0 Raise :exc:`DriverError` if the driver has been closed. N)rrrr%r"r&supports_re_authr(s rFsupports_session_authzDriver.supports_session_authso, 2226 ]]> * 8g   [ )&& &&&&77 8 8 8r*cp|j|5}|jcdddS#1swYyxYwrf)rr r(s rFr zDriver._get_server_infos1 ]]> * .g++- . . .s,5)rr)rr) r]rr\rrarrbrrcrrzBookmarks | NonerrrdrrJrrWrrXrrYrr^rr_rr`rrr9)rr9)rNone)rt.LiteralString | Queryrdict[str, t.Any] | Nonerr=rrrrrrrrrz*t.Callable[[Result], t.Union[EagerResult]]rrrr)rr;rr<rr=rrrrrrrrr!t.Callable[[Result], t.Union[_T]]rrrrG)rr;rr<rr=rrrrrzJBookmarkManager | BookmarkManager | t.Literal[_DefaultEnum.default] | Nonerrrz$t.Callable[[Result], t.Union[t.Any]]rrrr)rr )"rrr]rr\rrarrbrrcrr"t.Iterable[str] | Bookmarks | NonerrrdrrJAuth | tuple[str, str]rWrrXrrYrr^rr_rr`rrr:)"rrr]rr\rrarrbrrcrrr>rrrdrrJr?rWrrXrrYrr^rr_rr`rrr#)rr#) N............)rJAuth | tuple[str, str] | Nonerrr]rr\rrarrbrrcrrr>rrrdrr^rr_rr`rrrrf)rJr@rr)%rArBrCrr__annotations__rrrrrrrrrQrrrrrrrroverloadr r rr r8to_eager_resultrrr"r)r,r8r rDrErFrrs.E5GH!7*/66  5803#&!,/*-'**-,//29 -2 ).   !      * ( "% 9  5 &H' ,H- 4"'5 6%*7 8(-9 :; B 1D3E(ZZ04%3%9%9 $)-  '-#    '  5  "ZZ04%3%9%9 $)- AD ' - #    '  5  ?     $04%3%9%9 $)-   " "!c'c-c# c  c ' c cc c"#c$ %cJ ,,< 144703#&!,/`_ 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. N)rqcddlm}|j|}tj|t t \}}|j||||d}|||S)Nr1) Neo4jPool)rqrrL)rMrTrrrNr6rrO) rgrqrr|rT addressesrrrs rFrzNeo4jDriver._openFsb!&C&&0 060D0D J1 - -y~~ +#5   4122rEcttj||jgtj|||yrf)rrrrrs rFrzNeo4jDriver.__init__Vs)$/d$<=rErQrDrErFrr9s# -1 3 3>rErFrnc $d}|D]4}|j|}||Dcgc]}t|d|c}||<6|jdd}|*|jd}||}nth||}||d<d}|D]&}|j|}|t|d|||<(|jd}|htdvrt d|d|r7|t rtj|d<yy|tjk(rd|d<yyycc}w) N)rXrYvaluerXrY)rWrZrZz?"@!!#&  !(!?M# @   : ;E 818488++0'2+ ,   =/;;:;155 5:>M6 76 I"IsD ) rFr7rxzt.LiteralStringrzdict[str, t.Any]rGr=rrG)] __future__rrtypesrrr _addressingr_apirr r r r r rrr_confrrrrrr_debugrr[ _warningsrrrr rrrapirrr r!r"r#r$r%r&r'r(r)r*auth_managementr+r,r-r.rr/r0r2rdr3r4 _TBmConsumerr5 _TBmSupplierr|r6rr7r8r9rsslenumr:r;r<r=r?r@r objectTypeVarrGrIrrrrrrwrDrErFrts`"#!   .   > ?? t##HxHQYYt_|<|<~   0  2g .g .T !3    B& BF>(F>DDI3?rE