o tBh*@sddlZddlZddlZddlZddlZddlmZddlmZddl m Z m Z ddl m Z mZmZmZmZmZmZmZmZmZmZmZddlZddlmZddlmZmZmZm Z m!Z!m"Z"m#Z#m$Z$dd l%m&Z&dd l'm(Z(dd l)m*Z*m+Z+dd l,m-Z-dd l.m/Z/ddl0m1Z1ddl0m2Z3ddl0m4Z4ddl5m6Z6 ej7dddkrddl m8Z8nddl9m8Z8e:e;ZGdddZ?edede fdZ@ee@ge@fZAGddde?ZBdS) N)Future)Queue)EventThread) AnyAsyncGeneratorCallableDict GeneratorListOptionalTupleTypeVarUnioncastoverload) fail_after) DocumentNodeExecutionResult GraphQLSchemaIntrospectionQuerybuild_ast_schemaget_introspection_queryparsevalidate)GraphQLRequest)AsyncTransport)TransportClosedTransportQueryError)LocalSchemaTransport) Transport)build_client_schema) parse_result)serialize_variable_values)str_first_element))Literalc@s eZdZdZ          dXdeeeefdeedeee e fd e d ee d eee efd e d e dede fddZeddZdefddZdefddZe    dYdddedee eefdeed ee dee dedd e eeffd!d"Ze    dYdedee eefdeed ee dee ded#d efd$d"Ze    dYdedee eefdeed ee dee de d ee eefeffd%d"Z     dZdedee eefdeed ee dee de d ee eefeffd&d"Zeddd'd(eed ee dee dedd ee eeff d)d*Zeddd'd(eed ee dee ded#d eef d+d*Zeddd'd(eed ee dee de d eee eefeeff d,d*Zdddd-d(eed ee dee de d eee eefeeff d.d*Ze    dYdddedee eefdeed ee dee dedd e eeffd/d0Ze    dYdedee eefdeed ee dee ded#d efd1d0Ze    dYdedee eefdeed ee dee de d ee eefeffd2d0Z     dZdedee eefdeed ee dee de d ee eefeffd3d0Ze    dYdddedee eefdeed ee dee dedd e eeffd4d5Ze    dYdedee eefdeed ee dee ded#d efd6d5Ze    dYdedee eefdeed ee dee de d ee eefeffd7d5Z     dZdedee eefdeed ee dee de d ee eefeffd8d5Zeddd'd(eed ee dee dedd ee eeff d9d:Zeddd'd(eed ee dee ded#d eef d;d:Zeddd'd(eed ee dee de d eee eefeeff dd?Z!e    dYdedee eefdeed ee dee ded#d e edffd@d?Z!e    dYdedee eefdeed ee dee de d ee e eefdfe edfffdAd?Z!     dZdedee eefdeed ee dee de d ee e eefdfe edfffdBd?Z!e    dYdddedee eefdeed ee dee dedd e"e eefddffdCdDZ#e    dYdedee eefdeed ee dee ded#d e"eddffdEdDZ#e    dYdedee eefdeed ee dee de d ee"e eefddfe"eddfffdFdDZ#    d[dddedee eefdeed ee dee de d ee"e eefddfe"eddfffdGdDZ#d\dHdIZ$dJdKZ%dLdMZ&dNdOZ'dPdQZ(dRdSZ)dTdUZ*dVdWZ+dS)]ClientaThe Client class is the main entrypoint to execute GraphQL requests on a GQL transport. It can take sync or async transports as argument and can either execute and subscribe to requests itself with the :func:`execute ` and :func:`subscribe ` methods OR can be used to get a sync or async session depending on the transport type. To connect to an :ref:`async transport ` and get an :class:`async session `, use :code:`async with client as session:` To connect to a :ref:`sync transport ` and get a :class:`sync session `, use :code:`with client as session:` NF rschema introspection transportfetch_schema_from_transportintrospection_argsexecute_timeoutserialize_variables parse_resultsbatch_interval batch_maxc Cs|r |rJdt|}t|trt|} t| }|r.|r.|r#Jdt|jdkr.Jd|r6|s6t|}||_||_ ||_ ||_ |durHin||_ ||_ ||_||_| |_| |_dS)a"Initialize the client with the given parameters. :param schema: an optional GraphQL Schema for local validation See :ref:`schema_validation` :param transport: The provided :ref:`transport `. :param fetch_schema_from_transport: Boolean to indicate that if we want to fetch the schema from the transport using an introspection query. :param introspection_args: arguments passed to the get_introspection_query method of graphql-core. :param execute_timeout: The maximum time in seconds for the execution of a request before a TimeoutError is raised. Only used for async transports. Passing None results in waiting forever for a response. :param serialize_variables: whether the variable values should be serialized. Used for custom scalars and/or enums. Default: False. :param parse_results: Whether gql will try to parse the serialized output sent by the backend. Can be used to unserialize custom scalars or enums. :param batch_interval: Time to wait in seconds for batching requests together. Batching is disabled (by default) if 0. :param batch_max: Maximum number of requests in a single batch. z9Cannot provide introspection and schema at the same time.z>Cannot fetch the schema from transport if is already provided.AppSyncWebsocketsTransportzfetch_schema_from_transport=True is not allowed for AppSyncWebsocketsTransport because only subscriptions are allowed on the realtime endpoint.N)r" isinstancestrrrtype__name__r r,r-r.r/r0r1r2r3r4r5) selfr,r-r.r/r0r1r2r3r4r5 type_def_astr=a/var/www/html/riverr-enterprise-integrations-main/venv/lib/python3.10/site-packages/gql/client.py__init__Qs<"  zClient.__init__cCs |jdkS)Nr)r4r;r=r=r>batching_enabled zClient.batching_enableddocumentcCs*|jsJdt|j|}|r|ddS):meta private:z@Cannot validate the document locally, you need to pass a schema.rN)r,r)r;rCvalidation_errorsr=r=r>rs zClient.validateexecution_resultcCsH|jrtdt|jd|j|j|jdtt|j|_t|j|_ dS)NzError while fetching schema: zT If you don't need the schema, you can try with: "fetch_schema_from_transport=False"errorsdata extensions) rHrr%rIrJrrr-r"r,)r;rFr=r=r> _build_schema_from_introspections z'Client._build_schema_from_introspection.get_execution_resultvariable_valuesoperation_namer#rMreturncKdSNr=r;rCrNrOr2r#rMkwargsr=r=r> execute_sync zClient.execute_syncTcKrQrRr=rSr=r=r>rUrVcKrQrRr=rSr=r=r>rUrVc KsF|}|j|f|||||d|WdS1swYdS)rDrNrOr2r#rMNexecute r;rCrNrOr2r#rMrTsessionr=r=r>rUs $r2r#requestscKrQrRr=r;r]r2r#rMrTr=r=r>execute_batch_sync zClient.execute_batch_synccKrQrRr=r^r=r=r>r_r`cKrQrRr=r^r=r=r>r_r`r2r#rMcKsB|}|j|f|||d|WdS1swYdS)rDraN) execute_batch)r;r]r2r#rMrTr[r=r=r>r_&s $cdSrRr=rSr=r=r> execute_async9 zClient.execute_asynccrcrRr=rSr=r=r>rdGrecrcrRr=rSr=r=r>rdUrec sb|4IdH}|j|f|||||d|IdHWdIdHS1IdHs*wYdSrDNrWrXrZr=r=r>rdcs  0cKrQrRr=rSr=r=r>rYyrVzClient.executecKrQrRr=rSr=r=r>rYrVcKrQrRr=rSr=r=r>rYrVc Kst|jtrVz!ttjdddt}Wdn1s!wYWnty9t }t |Ynw| rBJd| |j |f|||||d|} | S|j|f|||||d|S)abExecute the provided document AST against the remote server using the transport provided during init. This function **WILL BLOCK** until the result is received from the server. Either the transport is sync and we execute the query synchronously directly OR the transport is async and we execute the query in the asyncio loop (blocking here until answer). This method will: - connect using the transport to get a session - execute the GraphQL request on the transport session - close the session and close the connection to the server If you have multiple requests to send, it is better to get your own session and execute the requests in your session. The extra arguments passed in the method will be passed to the transport execute method. ignoreThere is no current event loopmessageNzpCannot run client.execute(query) if an asyncio loop is running. Use 'await client.execute_async(query)' instead.rW)r7r.rwarningscatch_warningsfilterwarningsasyncioget_event_loop RuntimeErrornew_event_loopset_event_loop is_runningrun_until_completerdrU) r;rCrNrOr2r#rMrTlooprIr=r=r>rYsR      cKrQrRr=r^r=r=r>rbr`zClient.execute_batchcKrQrRr=r^r=r=r>rbr`cKrQrRr=r^r=r=r>rbr`cKs.t|jtr td|j|f|||d|S)afExecute multiple GraphQL requests in a batch against the remote server using the transport provided during init. This function **WILL BLOCK** until the result is received from the server. Either the transport is sync and we execute the query synchronously directly OR the transport is async and we execute the query in the asyncio loop (blocking here until answer). This method will: - connect using the transport to get a session - execute the GraphQL requests on the transport session - close the session and close the connection to the server If you want to perform multiple executions, it is better to use the context manager to keep a session active. The extra arguments passed in the method will be passed to the transport execute method. z*Batching is not implemented for async yet.ra)r7r.rNotImplementedErrorr_r^r=r=r>rbs cKrQrRr=rSr=r=r>subscribe_async=rVzClient.subscribe_asynccKrQrRr=rSr=r=r>rwKrVcKrQrRr=rSr=r=r>rwYc Ksx|4IdH(}|j|f|||||d|} | 2z 3dHW} | Vq6WdIdHdS1IdHs5wYdSrf) subscribe) r;rCrNrOr2r#rMrTr[ generatorresultr=r=r>rwis"  .cKrQrRr=rSr=r=r>ryrVzClient.subscribecKrQrRr=rSr=r=r>ryrVcKrQrRr=rSr=r=r>ryrxc ksz!ttjdddt}Wdn1swYWnty4t}t|Ynw|j|f|||||d|} | rLJdz tj | |d} | | } | VqNt yiYdStttfytj | |d| | |w) z|Execute a GraphQL subscription with a python generator. We need an async transport for this functionality. rgrhriNrWztCannot run client.subscribe(query) if an asyncio loop is running. Use 'await client.subscribe_async(query)' instead.T)ru)rkrlrmrnrorprqrrrwrs ensure_future __anext__rtStopAsyncIterationKeyboardInterrupt Exception GeneratorExitaclosecancelshutdown_asyncgens) r;rCrNrOr2r#rMrTruasync_generatorgenerator_taskr{r=r=r>rys^     cst|jts Jd|r tdd|i||_|jIdHn|jIdHt|d|_z|jrA|j sE|j IdHW|jSW|jSW|jSt yX|j IdHw)a`Connect asynchronously with the underlying async transport to produce a session. That session will be a permanent auto-reconnecting session if :code:`reconnecting=True`. If you call this method, you should call the :meth:`close_async ` method for cleanup. :param reconnecting: if True, create a permanent reconnecting session :param \**kwargs: additional arguments for the :meth:`ReconnectingAsyncClientSession init method `. zBOnly a transport of type AsyncTransport can be used asynchronouslyclientNrr=) r7r.rReconnectingAsyncClientSessionr[start_connecting_taskconnectAsyncClientSessionr/r, fetch_schemarclose)r; reconnectingrTr=r=r> connect_asyncs.    zClient.connect_asynccs2t|jtr|jIdH|jIdHdS)zBClose the async transport and stop the optional reconnecting task.N)r7r[rstop_connecting_taskr.rr@r=r=r> close_async%s zClient.close_asynccs|IdHSrR)rr@r=r=r> __aenter__-szClient.__aenter__cs|IdHdSrR)r)r;exc_typeexctbr=r=r> __aexit__0szClient.__aexit__cCs~t|jtr Jdt|dst|d|_|jz|jr*|js.|j W|jSW|jSW|jSt y>|j w)zConnect synchronously with the underlying sync transport to produce a session. If you call this method, you should call the :meth:`close_sync ` method for cleanup. zSOnly a sync transport can be used. Use 'async with Client(...) as session:' insteadr[r) r7r.rhasattrSyncClientSessionr[rr/r,rrrr@r=r=r> connect_sync3s$        zClient.connect_synccCs|jdS)zClose the sync session and the sync transport. If batching is enabled, this will block until the remaining queries in the batching queue have been processed. N)r[rr@r=r=r> close_syncSszClient.close_synccCs|SrR)rr@r=r=r> __enter__[szClient.__enter__cGs |dSrR)r)r;argsr=r=r>__exit__^s zClient.__exit__) NNNFNr+FFrr+....NNNNFNNNN)F),r: __module__ __qualname____doc__r rr8rrr!rboolr intfloatr?propertyrArrrrKrrr)rUr rr_rdrYrbrrwr ryrrrrrrrrr=r=r=r>r*=s   R                          K      +             "  " L)  r*c@sbeZdZdZdefddZ    d1dedeee e fdee d ee d ee d e f d d Z e    d2dddedeee e fdee d ee d ee dedd ee e ffddZe    d2dedeee e fdee d ee d ee dedd e fddZe    d2dedeee e fdee d ee d ee de d eee e fe ffddZ     d3dedeee e fdee d ee d ee de d eee e fe ffddZdddddeed ee d ee dee d ee f ddZeddddeed ee d ee dedd eee e ff ddZeddddeed ee d ee dedd ee f d dZeddddeed ee d ee de d eeee e fee ff d!dZdddd"deed ee d ee de d eeee e fee ff d#dZd4d$d%Zd&ed efd'd(Zd)d*Zd+d,Zd4d-d.Zed/d0ZdS)5rzAn instance of this class is created when using :code:`with` on the client. It contains the sync method execute to send queries on a sync transport using the same session. rcC ||_dSz;:param client: the :class:`client ` usedNrr;rr=r=r>r?irBzSyncClientSession.__init__NrCrNrOr2r#rPc Ks|jjr"|j||dur"|s|dur"|jjr"t|jj|||d}|jjr7t|||d}||}|} n |j j |f||d|} |jjr^|sR|dur^|jj r^t |jj|| j |d| _ | S)aExecute the provided document AST synchronously using the sync transport, returning an ExecutionResult object. :param document: GraphQL query as AST Node object. :param variable_values: Dictionary of input parameters. :param operation_name: Name of the operation that shall be executed. :param serialize_variables: whether the variable values should be serialized. Used for custom scalars and/or enums. By default use the serialize_variables argument of the client. :param parse_result: Whether gql will unserialize the result. By default use the parse_results argument of the client. The extra arguments are passed to the transport execute method.NrOrNrO)rr,rr2r$rAr_execute_futurer{r.rYr3parse_result_fnrI) r;rCrNrOr2r#rTrequest future_resultr{r=r=r>_executemsH   zSyncClientSession._execute.rLrMFcKrQrRr=rSr=r=r>rYrVzSyncClientSession.executeTcKrQrRr=rSr=r=r>rYrVcKrQrRr=rSr=r=r>rYrVc Ks^|j|f||||d|}|jrtt|j|j|j|jd|jdus(Jd|r,|S|jS)aExecute the provided document AST synchronously using the sync transport. Raises a TransportQueryError if an error has been returned in the ExecutionResult. :param document: GraphQL query as AST Node object. :param variable_values: Dictionary of input parameters. :param operation_name: Name of the operation that shall be executed. :param serialize_variables: whether the variable values should be serialized. Used for custom scalars and/or enums. By default use the serialize_variables argument of the client. :param parse_result: Whether gql will unserialize the result. By default use the parse_results argument of the client. :param get_execution_result: return the full ExecutionResult instance instead of only the "data" field. Necessary if you want to get the "extensions" field. The extra arguments are passed to the transport execute method.rNrOr2r#rGNrYs.  r2r#validate_documentr]rc  sjjr%|r|D] }j|jq|s|dur%jjr%fdd|D}jj|fi|}jjrP|s=|durPjjrP|D]}tjj|j|j |j d|_ q?|S)aExecute multiple GraphQL requests in a batch, using the sync transport, returning a list of ExecutionResult objects. :param requests: List of requests that will be executed. :param serialize_variables: whether the variable values should be serialized. Used for custom scalars and/or enums. By default use the serialize_variables argument of the client. :param parse_result: Whether gql will unserialize the result. By default use the parse_results argument of the client. :param validate_document: Whether we still need to validate the document. The extra arguments are passed to the transport execute method.Ncs(g|]}|jdur|jjn|qSrR)rNr$rr,).0reqr@r=r> 5s  z4SyncClientSession._execute_batch..r) rr,rrCr2r.rbr3rrIrO) r;r]r2r#rrTrresultsr{r=r@r>_execute_batchs(  z SyncClientSession._execute_batchr\cKrQrRr=r^r=r=r>rbKr`zSyncClientSession.execute_batchcKrQrRr=r^r=r=r>rbWr`cKrQrRr=r^r=r=r>rbcr`racKs~|j|f||d|}|D]}|jr!tt|j|j|j|jd|jdus*Jdq|r/|Stttt t fdd|DS)aExecute multiple GraphQL requests in a batch, using the sync transport. This method sends the requests to the server all at once. Raises a TransportQueryError if an error has been returned in any ExecutionResult. :param requests: List of requests that will be executed. :param serialize_variables: whether the variable values should be serialized. Used for custom scalars and/or enums. By default use the serialize_variables argument of the client. :param parse_result: Whether gql will unserialize the result. By default use the parse_results argument of the client. :param get_execution_result: return the full ExecutionResult instance instead of only the "data" field. Necessary if you want to get the "extensions" field. The extra arguments are passed to the transport execute method.r\rGNrcSsg|]}|jqSr=)rI)rr{r=r=r>rsz3SyncClientSession.execute_batch..) rrHrr%rIrJrr r r8r)r;r]r2r#rMrTrr{r=r=r>rbos,  c Cs2d}|sg}|j}|durn|||j|jjdkr't|jjt |jjdD]}|j r8n|j}|durEd}n||q/dd|D}dd|D}z |j |dddd}Wnt y}z|D]} | |qnWYd}~qd}~wwt||D] \} } | | q|r|jdS) zTmain loop of the thread used to wait for requests to execute them in a batchFNrTcSsg|]\}}|qSr=r=)rr_r=r=r>rz1SyncClientSession._batch_loop..cSsg|]\}}|qSr=r=)rrfuturer=r=r>rrr) batch_queuegetappendqsizerr5timesleepr4rangeemptyrr set_exceptionzip set_result_batch_thread_stopped_eventset) r; stop_looprequests_and_futuresrequest_and_futurerr]futuresrrrr{r=r=r> _batch_loopsH         -zSyncClientSession._batch_looprcCs:t|ds Jd|jrJdt}|j||f|S)zIf batching is enabled, this method will put a request in the batching queue instead of executing it directly so that the requests could be put in a batch. rzBatching is not enabledz Batching thread has been stopped)r_batch_thread_stop_requestedrrput)r;rrr=r=r>rs z!SyncClientSession._execute_futurecCsF|jjrt|_d|_t|_t|jdd|_ |j |j dS)z]Connect the transport and initialize the batch threading loop if batching is enabled.FT)targetdaemonN) rrArrrrrrr _batch_threadstartr.rr@r=r=r>rs zSyncClientSession.connectcCs4t|drd|_|jd|j|jdS)zClose the transport and cleanup the batching thread if batching is enabled. Will wait until all the remaining requests in the batch processing queue have been executed. rTN)rrrrrwaitr.rr@r=r=r>rs   zSyncClientSession.closecCs2tdi|jj}|jt|}|j|dSzFetch the GraphQL schema explicitly using introspection. Don't use this function and instead set the fetch_schema_from_transport attribute to TrueNr=rrr0r.rYrrKr;introspection_queryrFr=r=r>rszSyncClientSession.fetch_schemacC|jjSrRrr.r@r=r=r>r.zSyncClientSession.transportrrrrPN)r:rrrr*r?rr r r8rrrrrr)rYrr rrrbrrrrrrrr.r=r=r=r>rbsn D      = 7      55   rc@seZdZdZdefddZ    d#dedeee e fdee d ee d ee d e e dff d d Ze    d$dddedeee e fdee d ee d ee dedd e ee e fdffddZe    d$dedeee e fdee d ee d ee dedd e e dffddZe    d$dedeee e fdee d ee d ee de d ee ee e fdfe e dfffddZ     d%dedeee e fdee d ee d ee de d ee ee e fdfe e dfffddZ    d#dedeee e fdee d ee d ee d e f ddZe    d$dddedeee e fdee d ee d ee dedd ee e ffddZe    d$dedeee e fdee d ee d ee dedd e fddZe    d$dedeee e fdee d ee d ee de d eee e fe ffddZ     d%dedeee e fdee d ee d ee de d eee e fe ffddZd&dd Zed!d"ZdS)'rzAn instance of this class is created when using :code:`async with` on a :class:`client `. It contains the async methods (execute, subscribe) to send queries on an async transport using the same session. rcCrrrrr=r=r>r?rBzAsyncClientSession.__init__NrCrNrOr2r#rPc Ks|jjr#|j||dur#|s|dur#|jjr#t|jj|||d}|jj|f||d|}||_z1|2z#3dHW}|jjrV|sJ|durV|jjrVt |jj||j |d|_ |Vq66W| IdHdS| IdHw)aCoroutine to subscribe asynchronously to the provided document AST asynchronously using the async transport, returning an async generator producing ExecutionResult objects. * Validate the query with the schema if provided. * Serialize the variable_values if requested. :param document: GraphQL query as AST Node object. :param variable_values: Dictionary of input parameters. :param operation_name: Name of the operation that shall be executed. :param serialize_variables: whether the variable values should be serialized. Used for custom scalars and/or enums. By default use the serialize_variables argument of the client. :param parse_result: Whether gql will unserialize the result. By default use the parse_results argument of the client. The extra arguments are passed to the transport subscribe method.Nrr) rr,rr2r$r.ry _generatorr3rrIr r;rCrNrOr2r#rTinner_generatorr{r=r=r> _subscribe"sH   "zAsyncClientSession._subscribe.rLrMFcKrQrRr=rSr=r=r>rymrVzAsyncClientSession.subscribeTcKrQrRr=rSr=r=r>ry{rVcKrQrRr=rSr=r=r>ryrxc Ks|j|f||||d|}z4|2z&3dHW} | jr)tt| j| j| j| jd| jdur8|r4| Vq| jVq6W|IdHdS|IdHw)aCoroutine to subscribe asynchronously to the provided document AST asynchronously using the async transport. Raises a TransportQueryError if an error has been returned in the ExecutionResult. :param document: GraphQL query as AST Node object. :param variable_values: Dictionary of input parameters. :param operation_name: Name of the operation that shall be executed. :param serialize_variables: whether the variable values should be serialized. Used for custom scalars and/or enums. By default use the serialize_variables argument of the client. :param parse_result: Whether gql will unserialize the result. By default use the parse_results argument of the client. :param get_execution_result: yield the full ExecutionResult instance instead of only the "data" field. Necessary if you want to get the "extensions" field. The extra arguments are passed to the transport subscribe method.rNrG)rrHrr%rIrJr) r;rCrNrOr2r#rMrTrr{r=r=r>rys6  "cs|jjr#|j||dur#|s|dur#|jjr#t|jj|||d}t|jj|jj|f||d|IdH}Wdn1sDwY|jjrc|sW|durc|jj rct |jj||j |d|_ |S)afCoroutine to execute the provided document AST asynchronously using the async transport, returning an ExecutionResult object. * Validate the query with the schema if provided. * Serialize the variable_values if requested. :param document: GraphQL query as AST Node object. :param variable_values: Dictionary of input parameters. :param operation_name: Name of the operation that shall be executed. :param serialize_variables: whether the variable values should be serialized. Used for custom scalars and/or enums. By default use the serialize_variables argument of the client. :param parse_result: Whether gql will unserialize the result. By default use the parse_results argument of the client. The extra arguments are passed to the transport execute method.Nrr) rr,rr2r$rr1r.rYr3rrI)r;rCrNrOr2r#rTr{r=r=r>rs>  zAsyncClientSession._executecrcrRr=rSr=r=r>rYrezAsyncClientSession.executecrcrRr=rSr=r=r>rY"recrcrRr=rSr=r=r>rY0rec sf|j|f||||d|IdH}|jr#tt|j|j|j|jd|jdus,Jd|r0|S|jS)aCoroutine to execute the provided document AST asynchronously using the async transport. Raises a TransportQueryError if an error has been returned in the ExecutionResult. :param document: GraphQL query as AST Node object. :param variable_values: Dictionary of input parameters. :param operation_name: Name of the operation that shall be executed. :param serialize_variables: whether the variable values should be serialized. Used for custom scalars and/or enums. By default use the serialize_variables argument of the client. :param parse_result: Whether gql will unserialize the result. By default use the parse_results argument of the client. :param get_execution_result: return the full ExecutionResult instance instead of only the "data" field. Necessary if you want to get the "extensions" field. The extra arguments are passed to the transport execute method.rNrGrrrr=r=r>rY>s0   cs:tdi|jj}|jt|IdH}|j|dSrrrr=r=r>rwszAsyncClientSession.fetch_schemacCrrRrr@r=r=r>r.rzAsyncClientSession.transportrrrr)r:rrrr*r?rr r r8rrrrrrr)ryrrrYrrr.r=r=r=r>rs  K        ? ?      9 r _CallableT.)boundcs4eZdZdZ  ddedeeefdeeeffddZdd Z d d Z d d Z    dde de eeefde ede ede edef fdd Z    dde de eeefde ede ede edef ddZ    dde de eeefde ede ede edeedff fdd ZZS)ra<An instance of this class is created when using the :meth:`connect_async ` method of the :class:`Client ` class with :code:`reconnecting=True`. It is used to provide a single session which will reconnect automatically if the connection fails. Tr retry_connect retry_executecCs||_d|_t|_t|_|durtjtjt dd|_ n|dur)dd|_ n t |s/J||_ |durDtjtjt dd dd |_ n|durNd d|_ n t |sTJ||_ | |j |_| |jj|_dS) a :param client: the :class:`client ` used. :param retry_connect: Either a Boolean to activate/deactivate the retries for the connection to the transport OR a backoff decorator to provide specific retries parameters for the connections. :param retry_execute: Either a Boolean to activate/deactivate the retries for the execute method OR a backoff decorator to provide specific retries parameters for this method. NT<) max_valueFcS|SrRr=er=r=r>z9ReconnectingAsyncClientSession.__init__..cSs t|tSrR)r7rrr=r=r>rs ) max_triesgiveupcSrrRr=rr=r=r>rr)r _connect_taskrnr_reconnect_request_event_connected_eventbackoff on_exceptionexporrcallabler _execute_once_execute_with_retriesr.r_connect_with_retries)r;rrrr=r=r>r?s6        z'ReconnectingAsyncClientSession.__init__csB |IdH|j|j|j|jIdHq)zCoroutine used for the connection task. - try to connect to the transport with retries - send a connected event when the connection has been made - then wait for a reconnect request to try to connect again TN)rrrclearrrr@r=r=r>_connection_loops   z/ReconnectingAsyncClientSession._connection_loopcs:|jr tddSt||_|jIdHdS)zrStart the task responsible to restart the connection of the transport when requested by an event. zconnect task already started!N)rlogwarningrnr|rrrr@r=r=r>rs z4ReconnectingAsyncClientSession.start_connecting_taskcs$|jdur|jd|_dSdS)zStop the connecting task.N)rrr@r=r=r>rs    z3ReconnectingAsyncClientSession.stop_connecting_taskNrCrNrOr2r#rPcsHztj|f||||d|IdH}W|Sty#|jw)zSame Coroutine as parent method _execute but requesting a reconnection if we receive a TransportClosed exception. rN)superrrrr)r;rCrNrOr2r#rTanswer __class__r=r>rs"  z,ReconnectingAsyncClientSession._execute_oncecs$|j|f||||d|IdHS)zSame Coroutine as parent, but with optional retries and requesting a reconnection if we receive a TransportClosed exception. rN)r)r;rCrNrOr2r#rTr=r=r>r s  z'ReconnectingAsyncClientSession._executec  stj|f||||d|}z'z|2z 3dHW}|Vq6Wn ty-|jwW|IdHdS|IdHw)zSame Async generator as parent method _subscribe but requesting a reconnection if we receive a TransportClosed exception. rN)rrrrrrrrr=r>r!s*    "z)ReconnectingAsyncClientSession._subscribe)TTr)r:rrrr*rr _Decoratorr?rrrrr r r8rrrrrr __classcell__r=r=rr>rs    6    r)Crnloggingsysrrkconcurrent.futuresrqueuer threadingrrtypingrrrr r r r r rrrrranyiorgraphqlrrrrrrrrgraphql_requestrtransport.async_transportrtransport.exceptionsrrtransport.local_schemar transport.transportr! utilitiesr"r#rr$utilsr% version_infor)typing_extensions getLoggerr:rr*rrrrrr=r=r=r>sV  8 (         +7r