(phAt SrSSKrSSKrSSKrSSKrSSKrSSKJr SSKJ r SSK J r SSK J r SSK Jr \R"\5R#\R$"55 SSKJr "S S \5r"S S \5r"SS\R25r\R6"SS\R855r\R6"SS\R855r"SS\R25r"SS\5r "SS\R25r!"SS\!\RDS9r#"SS\R25r$"SS \R25r%"S!S"\R25r&"S#S$\R25r'"S%S&\R25r("S'S(\)5r*"S)S*\)5r+"S+S,\R25r,"S-S.\R25r-"S/S0\R25r."S1S2\)5r/"S3S4\)5r0"S5S6\R25r1"S7S8\R25r2"S9S:\R25r3"S;S<\R25r4"S=S>\R25r5"S?S@\!\RDS9r6"SASB\R25r7"SCSD\R25r8"SESF\R25r9"SGSH\9\RDS9r:"SISJ\R25r;"SKSL\R25r<StSMjr=StSNjr>StSOjr?StSPjr@SQrASuSRjrBSvSSjrCSvSTjrDSUrESVrFSWrGSwSXjrHSYrISZrJSvS[jrKSxS\jrL\R6"S]S^\R855rM\MR4S_jrO\MR4S`jrPSvSajrQSbrRScrSSdrTStSejrUStSfjrVSgrWSyShjrX\RSi5rZ\R6"SjSk\R55r\Slr]SSK^r^\RRSm\^05 SSKara\RRSn\a05 SSKbrb\RRSo\b05 \RSp:a+\Sq:Xa$SSrKJdrd \RRSs\d05 ggg!\a S rGN&f=f!\a Nf=f!\a Nf=f!\a Nkf=f)zzgRPC's Python API.N) _compression)cygrpc)protos)protos_and_services)services) __version__dev0c\rSrSrSrSrg)FutureTimeoutError'z3Indicates that a method call on a Future timed out.N__name__ __module__ __qualname____firstlineno____doc____static_attributes__r @/var/www/html/venv/lib/python3.13/site-packages/grpc/__init__.pyr r 's=rr c\rSrSrSrSrg)FutureCancelledError+zAIndicates that the computation underlying a Future was cancelled.r Nrr rrrr+sKrrcD\rSrSrSr\R S5r\R S5r\R S5r \R S5r \R S Sj5r \R S S j5r \R S S j5r \R S 5rS rg)Future/zA representation of a computation in another control flow. Computations represented by a Future may be yet to be begun, may be ongoing, or may have already completed. c[5e)aAttempts to cancel the computation. This method does not block. Returns: bool: Returns True if the computation was canceled. Returns False under all other circumstances, for example: 1. computation has begun and could not be canceled. 2. computation has finished 3. computation is scheduled for execution and it is impossible to determine its state without blocking. NotImplementedErrorselfs rcancel Future.cancel6 ""##rc[5e)aLDescribes whether the computation was cancelled. This method does not block. Returns: bool: Returns True if the computation was cancelled before its result became available. Returns False under all other circumstances, for example: 1. computation was not cancelled. 2. computation's result is available. rr s r cancelledFuture.cancelledI "##rc[5e)zDescribes whether the computation is taking place. This method does not block. Returns: Returns True if the computation is scheduled for execution or currently executing. Returns False if the computation already executed or was cancelled. rr s rrunningFuture.running[ "##rc[5e)aFDescribes whether the computation has taken place. This method does not block. Returns: bool: Returns True if the computation already executed or was cancelled. Returns False if the computation is scheduled for execution or currently executing. This is exactly opposite of the running() method's result. rr s rdone Future.donei "##rNc[5e)aqReturns the result of the computation or raises its exception. This method may return immediately or may block. Args: timeout: The length of time in seconds to wait for the computation to finish or be cancelled. If None, the call will block until the computations's termination. Returns: The return value of the computation. Raises: FutureTimeoutError: If a timeout value is passed and the computation does not terminate within the allotted time. FutureCancelledError: If the computation was cancelled. Exception: If the computation raised an exception, this call will raise the same exception. rr!timeouts rresult Future.resultx *"##rc[5e)aDReturn the exception raised by the computation. This method may return immediately or may block. Args: timeout: The length of time in seconds to wait for the computation to terminate or be cancelled. If None, the call will block until the computations's termination. Returns: The exception raised by the computation, or None if the computation did not raise an exception. Raises: FutureTimeoutError: If a timeout value is passed and the computation does not terminate within the allotted time. FutureCancelledError: If the computation was cancelled. rr2s r exceptionFuture.exception ("##rc[5e)aeAccess the traceback of the exception raised by the computation. This method may return immediately or may block. Args: timeout: The length of time in seconds to wait for the computation to terminate or be cancelled. If None, the call will block until the computation's termination. Returns: The traceback of the exception raised by the computation, or None if the computation did not raise an exception. Raises: FutureTimeoutError: If a timeout value is passed and the computation does not terminate within the allotted time. FutureCancelledError: If the computation was cancelled. rr2s r tracebackFuture.tracebackr:rc[5e)aAdds a function to be called at completion of the computation. The callback will be passed this Future object describing the outcome of the computation. Callbacks will be invoked after the future is terminated, whether successfully or not. If the computation has already completed, the callback will be called immediately. Exceptions raised in the callback will be logged at ERROR level, but will not terminate any threads of execution. Args: fn: A callable taking this Future object as its single parameter. r)r!fns radd_done_callbackFuture.add_done_callbackr$rr N)rrrrrabcabstractmethodr"r&r*r.r4r8r<r@rr rrrr/s  $$$ $$"  $ $  $ $ $$, $$* $$* $$rrc\rSrSrSr\R RS4r\R RS4r \R RS4r \R RS4r\R RS4rSrg ) ChannelConnectivityaWMirrors grpc_connectivity_state in the gRPC Core. Attributes: IDLE: The channel is idle. CONNECTING: The channel is connecting. READY: The channel is ready to conduct RPCs. TRANSIENT_FAILURE: The channel has seen a failure from which it expects to recover. SHUTDOWN: The channel has seen a failure from which it cannot recover. idle connectingreadyztransient failureshutdownr N)rrrrr_cygrpcConnectivityStaterHIDLErI CONNECTINGrJREADYtransient_failureTRANSIENT_FAILURErKSHUTDOWNrr rrrFrFs}   % % * *F 3D++66 EJ  & & , ,g 6E!!33))22J?HrrFcH\rSrSrSr\R RS4r\R RS4r \R RS4r \R RS4r\R RS4r\R R"S4r\R R&S 4r\R R*S 4r\R R.S 4r\R R2S 4r\R R6S 4r\R R:S4r\R R>S4r \R RBS4r"\R RFS4r$\R RJS4r&\R RNS4r(Sr)g) StatusCodeapMirrors grpc_status_code in the gRPC Core. Attributes: OK: Not an error; returned on success CANCELLED: The operation was cancelled (typically by the caller). UNKNOWN: Unknown error. INVALID_ARGUMENT: Client specified an invalid argument. DEADLINE_EXCEEDED: Deadline expired before operation could complete. NOT_FOUND: Some requested entity (e.g., file or directory) was not found. ALREADY_EXISTS: Some entity that we attempted to create (e.g., file or directory) already exists. PERMISSION_DENIED: The caller does not have permission to execute the specified operation. UNAUTHENTICATED: The request does not have valid authentication credentials for the operation. RESOURCE_EXHAUSTED: Some resource has been exhausted, perhaps a per-user quota, or perhaps the entire file system is out of space. FAILED_PRECONDITION: Operation was rejected because the system is not in a state required for the operation's execution. ABORTED: The operation was aborted, typically due to a concurrency issue like sequencer check failures, transaction aborts, etc. UNIMPLEMENTED: Operation is not implemented or not supported/enabled in this service. INTERNAL: Internal errors. Means some invariants expected by underlying system has been broken. UNAVAILABLE: The service is currently unavailable. DATA_LOSS: Unrecoverable data loss or corruption. okr&unknownzinvalid argumentzdeadline exceededz not foundzalready existszpermission deniedzresource exhaustedzfailed preconditionabortedz out of range unimplementedinternal unavailablez data lossunauthenticatedr N)*rrrrrrLrUrWOKr& CANCELLEDrXUNKNOWNinvalid_argumentINVALID_ARGUMENTdeadline_exceededDEADLINE_EXCEEDED not_found NOT_FOUNDalready_existsALREADY_EXISTSpermission_deniedPERMISSION_DENIEDresource_exhaustedRESOURCE_EXHAUSTEDfailed_preconditionFAILED_PRECONDITIONrYABORTED out_of_range OUT_OF_RANGErZ UNIMPLEMENTEDr[INTERNALr\ UNAVAILABLE data_loss DATA_LOSSr]UNAUTHENTICATEDrr rrrUrUs8      &B##--{;I!!))95G**;;=OP,,##--{;I((779IJN,, -- ..!!))95G&&33^DL''55GM""++Z8H%%11=AK##--{;I))99;LMOrrUc\rSrSrSrSrg)Statusi)aDescribes the status of an RPC. This is an EXPERIMENTAL API. Attributes: code: A StatusCode object to be sent to the client. details: A UTF-8-encodable string to be sent to the client upon termination of the RPC. trailing_metadata: The trailing :term:`metadata` in the RPC. r Nrr rrryry)s rryc\rSrSrSrSrg)RpcErrori9zERaised by the gRPC library to indicate non-OK-status RPC termination.r Nrr rrr{r{9sOrr{c\rSrSrSr\R S5r\R S5r\R S5r \R S5r Sr g) RpcContexti@z,Provides RPC-related information and action.c[5e)zsDescribes whether the RPC is active or has terminated. Returns: bool: True if RPC is active, False otherwise. rr s r is_activeRpcContext.is_activeC "##rc[5e)aDescribes the length of allowed time remaining for the RPC. Returns: A nonnegative float indicating the length of allowed time in seconds remaining for the RPC to complete before it is considered to have timed out, or None if no deadline was specified for the RPC. rr s rtime_remainingRpcContext.time_remainingM "##rc[5e)zRCancels the RPC. Idempotent and has no effect if the RPC has already terminated. rr s rr"RpcContext.cancelX "##rc[5e)aERegisters a callback to be called on RPC termination. Args: callback: A no-parameter callable to be called on RPC termination. Returns: True if the callback was added and will be called later; False if the callback was not added and will not be called (because the RPC already terminated or some other reason). rr!callbacks r add_callbackRpcContext.add_callback`r,rr N) rrrrrrCrDrrr"rrr rrr}r}@sk6$$ $$ $$  $ $rr}c\rSrSrSr\R S5r\R S5r\R S5r \R S5r Sr g) Callirz*Invocation-side utility object for an RPC.c[5e)zAccesses the initial metadata sent by the server. This method blocks until the value is available. Returns: The initial :term:`metadata`. rr s rinitial_metadataCall.initial_metadataurrc[5e)zAccesses the trailing metadata sent by the server. This method blocks until the value is available. Returns: The trailing :term:`metadata`. rr s rtrailing_metadataCall.trailing_metadatarrc[5e)zAccesses the status code sent by the server. This method blocks until the value is available. Returns: The StatusCode value for the RPC. rr s rcode Call.coderrc[5e)zAccesses the details sent by the server. This method blocks until the value is available. Returns: The details string of the RPC. rr s rdetails Call.detailsrrr N) rrrrrrCrDrrrrrr rrrrrsk4$$ $$ $$ $$rr) metaclassc\rSrSrSrSrg)ClientCallDetailsiaDescribes an RPC to be invoked. Attributes: method: The method name of the RPC. timeout: An optional duration of time in seconds to allow for the RPC. metadata: Optional :term:`metadata` to be transmitted to the service-side of the RPC. credentials: An optional CallCredentials for the RPC. wait_for_ready: An optional flag to enable :term:`wait_for_ready` mechanism. compression: An element of grpc.compression, e.g. grpc.compression.Gzip. r Nrr rrrrs rrc<\rSrSrSr\R S5rSrg)UnaryUnaryClientInterceptoriz-Affords intercepting unary-unary invocations.c[5e)aIntercepts a unary-unary invocation asynchronously. Args: continuation: A function that proceeds with the invocation by executing the next interceptor in chain or invoking the actual RPC on the underlying Channel. It is the interceptor's responsibility to call it if it decides to move the RPC forward. The interceptor can use `response_future = continuation(client_call_details, request)` to continue with the RPC. `continuation` returns an object that is both a Call for the RPC and a Future. In the event of RPC completion, the return Call-Future's result value will be the response message of the RPC. Should the event terminate with non-OK status, the returned Call-Future's exception value will be an RpcError. client_call_details: A ClientCallDetails object describing the outgoing RPC. request: The request value for the RPC. Returns: An object that is both a Call for the RPC and a Future. In the event of RPC completion, the return Call-Future's result value will be the response message of the RPC. Should the event terminate with non-OK status, the returned Call-Future's exception value will be an RpcError. rr! continuationclient_call_detailsrequests rintercept_unary_unary1UnaryUnaryClientInterceptor.intercept_unary_unarys 8"##rr N) rrrrrrCrDrrr rrrrs7$$rrc<\rSrSrSr\R S5rSrg)UnaryStreamClientInterceptoriz.Affords intercepting unary-stream invocations.c[5e)a[Intercepts a unary-stream invocation. Args: continuation: A function that proceeds with the invocation by executing the next interceptor in chain or invoking the actual RPC on the underlying Channel. It is the interceptor's responsibility to call it if it decides to move the RPC forward. The interceptor can use `response_iterator = continuation(client_call_details, request)` to continue with the RPC. `continuation` returns an object that is both a Call for the RPC and an iterator for response values. Drawing response values from the returned Call-iterator may raise RpcError indicating termination of the RPC with non-OK status. client_call_details: A ClientCallDetails object describing the outgoing RPC. request: The request value for the RPC. Returns: An object that is both a Call for the RPC and an iterator of response values. Drawing response values from the returned Call-iterator may raise RpcError indicating termination of the RPC with non-OK status. This object *should* also fulfill the Future interface, though it may not. rrs rintercept_unary_stream3UnaryStreamClientInterceptor.intercept_unary_stream :"##rr N) rrrrrrCrDrrr rrrr8$$rrc<\rSrSrSr\R S5rSrg)StreamUnaryClientInterceptoriz.Affords intercepting stream-unary invocations.c[5e)aIntercepts a stream-unary invocation asynchronously. Args: continuation: A function that proceeds with the invocation by executing the next interceptor in chain or invoking the actual RPC on the underlying Channel. It is the interceptor's responsibility to call it if it decides to move the RPC forward. The interceptor can use `response_future = continuation(client_call_details, request_iterator)` to continue with the RPC. `continuation` returns an object that is both a Call for the RPC and a Future. In the event of RPC completion, the return Call-Future's result value will be the response message of the RPC. Should the event terminate with non-OK status, the returned Call-Future's exception value will be an RpcError. client_call_details: A ClientCallDetails object describing the outgoing RPC. request_iterator: An iterator that yields request values for the RPC. Returns: An object that is both a Call for the RPC and a Future. In the event of RPC completion, the return Call-Future's result value will be the response message of the RPC. Should the event terminate with non-OK status, the returned Call-Future's exception value will be an RpcError. rr!rrrequest_iterators rintercept_stream_unary3StreamUnaryClientInterceptor.intercept_stream_unaryrrr N) rrrrrrCrDrrr rrrrrrrc<\rSrSrSr\R S5rSrg)StreamStreamClientInterceptoriz/Affords intercepting stream-stream invocations.c[5e)ayIntercepts a stream-stream invocation. Args: continuation: A function that proceeds with the invocation by executing the next interceptor in chain or invoking the actual RPC on the underlying Channel. It is the interceptor's responsibility to call it if it decides to move the RPC forward. The interceptor can use `response_iterator = continuation(client_call_details, request_iterator)` to continue with the RPC. `continuation` returns an object that is both a Call for the RPC and an iterator for response values. Drawing response values from the returned Call-iterator may raise RpcError indicating termination of the RPC with non-OK status. client_call_details: A ClientCallDetails object describing the outgoing RPC. request_iterator: An iterator that yields request values for the RPC. Returns: An object that is both a Call for the RPC and an iterator of response values. Drawing response values from the returned Call-iterator may raise RpcError indicating termination of the RPC with non-OK status. This object *should* also fulfill the Future interface, though it may not. rrs rintercept_stream_stream5StreamStreamClientInterceptor.intercept_stream_streamrrr N) rrrrrrCrDrrr rrrrs9$$rrc\rSrSrSrSrSrg)ChannelCredentialsiBaPAn encapsulation of the data required to create a secure Channel. This class has no supported interface - it exists to define the type of its instances and its instances exist to be passed to other functions. For example, ssl_channel_credentials returns an instance of this class and secure_channel requires an instance of this class. cXlgrB _credentialsr! credentialss r__init__ChannelCredentials.__init__K'rrNrrrrrrrr rrrrBs (rrc\rSrSrSrSrSrg)CallCredentialsiOaAn encapsulation of the data required to assert an identity over a call. A CallCredentials has to be used with secure Channel, otherwise the metadata will not be transmitted to the server. A CallCredentials may be composed with ChannelCredentials to always assert identity for every call over that Channel. This class has no supported interface - it exists to define the type of its instances and its instances exist to be passed to other functions. cXlgrBrrs rrCallCredentials.__init__\rrrNrr rrrrOs  (rrc\rSrSrSrSrg)AuthMetadataContexti`zProvides information to call credentials metadata plugins. Attributes: service_url: A string URL of the service being called into. method_name: A string of the fully qualified method name being called. r Nrr rrrr`rrc\rSrSrSrSrSrg)AuthMetadataPluginCallbackiiz.Callback object received by a metadata plugin.c[5e)zPasses to the gRPC runtime authentication metadata for an RPC. Args: metadata: The :term:`metadata` used to construct the CallCredentials. error: An Exception to indicate error or None to indicate success. r)r!metadataerrors r__call__#AuthMetadataPluginCallback.__call__l "##rr Nrrrrrrrr rrrris 8$rrc\rSrSrSrSrSrg)AuthMetadataPluginivz*A specification for custom authentication.c[5e)abImplements authentication by passing metadata to a callback. This method will be invoked asynchronously in a separate thread. Args: context: An AuthMetadataContext providing information on the RPC that the plugin is being called to authenticate. callback: An AuthMetadataPluginCallback to be invoked either synchronously or asynchronously. r)r!contextrs rrAuthMetadataPlugin.__call__y "##rr Nrr rrrrvs 4 $rrc\rSrSrSrSrSrg)ServerCredentialsizAn encapsulation of the data required to open a secure port on a Server. This class has no supported interface - it exists to define the type of its instances and its instances exist to be passed to other functions. cXlgrBrrs rrServerCredentials.__init__rrrNrr rrrrs  (rrc\rSrSrSrSrSrg)ServerCertificateConfigurationia.A certificate configuration for use with an SSL-enabled Server. Instances of this class can be returned in the certificate configuration fetching callback. This class has no supported interface -- it exists to define the type of its instances and its instances exist to be passed to other functions. cXlgrB_certificate_configuration)r!certificate_configurations rr'ServerCertificateConfiguration.__init__s*C'rrNrr rrrrs Drrc\rSrSrSr\R SSj5r\R SSj5r\R SSj5r Sr g) UnaryUnaryMultiCallableiz4Affords invoking a unary-unary RPC from client-side.Nc[5e)aSynchronously invokes the underlying RPC. Args: request: The request value for the RPC. timeout: An optional duration of time in seconds to allow for the RPC. metadata: Optional :term:`metadata` to be transmitted to the service-side of the RPC. credentials: An optional CallCredentials for the RPC. Only valid for secure Channel. wait_for_ready: An optional flag to enable :term:`wait_for_ready` mechanism. compression: An element of grpc.compression, e.g. grpc.compression.Gzip. Returns: The response value for the RPC. Raises: RpcError: Indicating that the RPC terminated with non-OK status. The raised RpcError will also be a Call for the RPC affording the RPC's metadata, status code, and details. rr!rr3rrwait_for_ready compressions rr UnaryUnaryMultiCallable.__call__@"##rc[5e)aSynchronously invokes the underlying RPC. Args: request: The request value for the RPC. timeout: An optional durating of time in seconds to allow for the RPC. metadata: Optional :term:`metadata` to be transmitted to the service-side of the RPC. credentials: An optional CallCredentials for the RPC. Only valid for secure Channel. wait_for_ready: An optional flag to enable :term:`wait_for_ready` mechanism. compression: An element of grpc.compression, e.g. grpc.compression.Gzip. Returns: The response value for the RPC and a Call value for the RPC. Raises: RpcError: Indicating that the RPC terminated with non-OK status. The raised RpcError will also be a Call for the RPC affording the RPC's metadata, status code, and details. rrs r with_call!UnaryUnaryMultiCallable.with_callrrc[5e)a2Asynchronously invokes the underlying RPC. Args: request: The request value for the RPC. timeout: An optional duration of time in seconds to allow for the RPC. metadata: Optional :term:`metadata` to be transmitted to the service-side of the RPC. credentials: An optional CallCredentials for the RPC. Only valid for secure Channel. wait_for_ready: An optional flag to enable :term:`wait_for_ready` mechanism. compression: An element of grpc.compression, e.g. grpc.compression.Gzip. Returns: An object that is both a Call for the RPC and a Future. In the event of RPC completion, the return Call-Future's result value will be the response message of the RPC. Should the event terminate with non-OK status, the returned Call-Future's exception value will be an RpcError. rrs rfutureUnaryUnaryMultiCallable.future >"##rr NNNNN rrrrrrCrDrrrrr rrrrs>$$B $$B $$rrcJ\rSrSrSr\R SSj5rSrg)UnaryStreamMultiCallablei z5Affords invoking a unary-stream RPC from client-side.Nc[5e)aInvokes the underlying RPC. Args: request: The request value for the RPC. timeout: An optional duration of time in seconds to allow for the RPC. If None, the timeout is considered infinite. metadata: An optional :term:`metadata` to be transmitted to the service-side of the RPC. credentials: An optional CallCredentials for the RPC. Only valid for secure Channel. wait_for_ready: An optional flag to enable :term:`wait_for_ready` mechanism. compression: An element of grpc.compression, e.g. grpc.compression.Gzip. Returns: An object that is a Call for the RPC, an iterator of response values, and a Future for the RPC. Drawing response values from the returned Call-iterator may raise RpcError indicating termination of the RPC with non-OK status. rrs rr!UnaryStreamMultiCallable.__call__ <"##rr r rrrrrrCrDrrr rrrr s.?$$rrc\rSrSrSr\R SSj5r\R SSj5r\R SSj5r Sr g) StreamUnaryMultiCallablei1z5Affords invoking a stream-unary RPC from client-side.Nc[5e)a6Synchronously invokes the underlying RPC. Args: request_iterator: An iterator that yields request values for the RPC. timeout: An optional duration of time in seconds to allow for the RPC. If None, the timeout is considered infinite. metadata: Optional :term:`metadata` to be transmitted to the service-side of the RPC. credentials: An optional CallCredentials for the RPC. Only valid for secure Channel. wait_for_ready: An optional flag to enable :term:`wait_for_ready` mechanism. compression: An element of grpc.compression, e.g. grpc.compression.Gzip. Returns: The response value for the RPC. Raises: RpcError: Indicating that the RPC terminated with non-OK status. The raised RpcError will also implement grpc.Call, affording methods such as metadata, code, and details. rr!rr3rrrrs rr!StreamUnaryMultiCallable.__call__4B"##rc[5e)adSynchronously invokes the underlying RPC on the client. Args: request_iterator: An iterator that yields request values for the RPC. timeout: An optional duration of time in seconds to allow for the RPC. If None, the timeout is considered infinite. metadata: Optional :term:`metadata` to be transmitted to the service-side of the RPC. credentials: An optional CallCredentials for the RPC. Only valid for secure Channel. wait_for_ready: An optional flag to enable :term:`wait_for_ready` mechanism. compression: An element of grpc.compression, e.g. grpc.compression.Gzip. Returns: The response value for the RPC and a Call object for the RPC. Raises: RpcError: Indicating that the RPC terminated with non-OK status. The raised RpcError will also be a Call for the RPC affording the RPC's metadata, status code, and details. rrs rr"StreamUnaryMultiCallable.with_callWrrc[5e)aAsynchronously invokes the underlying RPC on the client. Args: request_iterator: An iterator that yields request values for the RPC. timeout: An optional duration of time in seconds to allow for the RPC. If None, the timeout is considered infinite. metadata: Optional :term:`metadata` to be transmitted to the service-side of the RPC. credentials: An optional CallCredentials for the RPC. Only valid for secure Channel. wait_for_ready: An optional flag to enable :term:`wait_for_ready` mechanism. compression: An element of grpc.compression, e.g. grpc.compression.Gzip. Returns: An object that is both a Call for the RPC and a Future. In the event of RPC completion, the return Call-Future's result value will be the response message of the RPC. Should the event terminate with non-OK status, the returned Call-Future's exception value will be an RpcError. rrs rrStreamUnaryMultiCallable.futurezrrr rrr rrrr1s? $ $D  $ $D $$rrcJ\rSrSrSr\R SSj5rSrg)StreamStreamMultiCallableiz4Affords invoking a stream-stream RPC on client-side.Nc[5e)aLInvokes the underlying RPC on the client. Args: request_iterator: An iterator that yields request values for the RPC. timeout: An optional duration of time in seconds to allow for the RPC. If not specified, the timeout is considered infinite. metadata: Optional :term:`metadata` to be transmitted to the service-side of the RPC. credentials: An optional CallCredentials for the RPC. Only valid for secure Channel. wait_for_ready: An optional flag to enable :term:`wait_for_ready` mechanism. compression: An element of grpc.compression, e.g. grpc.compression.Gzip. Returns: An object that is a Call for the RPC, an iterator of response values, and a Future for the RPC. Drawing response values from the returned Call-iterator may raise RpcError indicating termination of the RPC with non-OK status. rrs rr"StreamStreamMultiCallable.__call__rrr rrr rrr r s.>$$rr cL\rSrSrSr\R SSj5r\R S5r\R SSj5r \R SSj5r \R SSj5r \R SS j5r \R S 5r S rS rS rg)ChannelizAffords RPC invocation via generic methods on client-side. Channel objects implement the Context Manager type, although they need not support being entered and exited multiple times. c[5e)a Subscribe to this Channel's connectivity state machine. A Channel may be in any of the states described by ChannelConnectivity. This method allows application to monitor the state transitions. The typical use case is to debug or gain better visibility into gRPC runtime's state. Args: callback: A callable to be invoked with ChannelConnectivity argument. ChannelConnectivity describes current state of the channel. The callable will be invoked immediately upon subscription and again for every change to ChannelConnectivity until it is unsubscribed or this Channel object goes out of scope. try_to_connect: A boolean indicating whether or not this Channel should attempt to connect immediately. If set to False, gRPC runtime decides when to connect. r)r!rtry_to_connects r subscribeChannel.subscribes &"##rc[5e)zUnsubscribes a subscribed callback from this Channel's connectivity. Args: callback: A callable previously registered with this Channel from having been passed to its "subscribe" method. rrs r unsubscribeChannel.unsubscriberrNc[5e)aHCreates a UnaryUnaryMultiCallable for a unary-unary method. Args: method: The name of the RPC method. request_serializer: Optional :term:`serializer` for serializing the request message. Request goes unserialized in case None is passed. response_deserializer: Optional :term:`deserializer` for deserializing the response message. Response goes undeserialized in case None is passed. _registered_method: Implementation Private. A bool representing whether the method is registered. Returns: A UnaryUnaryMultiCallable value for the named unary-unary method. rr!methodrequest_serializerresponse_deserializer_registered_methods r unary_unaryChannel.unary_unary ."##rc[5e)aKCreates a UnaryStreamMultiCallable for a unary-stream method. Args: method: The name of the RPC method. request_serializer: Optional :term:`serializer` for serializing the request message. Request goes unserialized in case None is passed. response_deserializer: Optional :term:`deserializer` for deserializing the response message. Response goes undeserialized in case None is passed. _registered_method: Implementation Private. A bool representing whether the method is registered. Returns: A UnaryStreamMultiCallable value for the name unary-stream method. rrs r unary_streamChannel.unary_streamrrc[5e)aLCreates a StreamUnaryMultiCallable for a stream-unary method. Args: method: The name of the RPC method. request_serializer: Optional :term:`serializer` for serializing the request message. Request goes unserialized in case None is passed. response_deserializer: Optional :term:`deserializer` for deserializing the response message. Response goes undeserialized in case None is passed. _registered_method: Implementation Private. A bool representing whether the method is registered. Returns: A StreamUnaryMultiCallable value for the named stream-unary method. rrs r stream_unaryChannel.stream_unaryrrc[5e)aPCreates a StreamStreamMultiCallable for a stream-stream method. Args: method: The name of the RPC method. request_serializer: Optional :term:`serializer` for serializing the request message. Request goes unserialized in case None is passed. response_deserializer: Optional :term:`deserializer` for deserializing the response message. Response goes undeserialized in case None is passed. _registered_method: Implementation Private. A bool representing whether the method is registered. Returns: A StreamStreamMultiCallable value for the named stream-stream method. rrs r stream_streamChannel.stream_stream4rrc[5e)zCloses this Channel and releases all resources held by it. Closing the Channel will immediately terminate all RPCs active with the Channel and it is not valid to invoke new RPCs with the Channel. This method is idempotent. rr s rclose Channel.closeMrrc[5e)z9Enters the runtime context related to the channel object.rr s r __enter__Channel.__enter__X !##rc[5e)z8Exits the runtime context related to the channel object.r)r!exc_typeexc_valexc_tbs r__exit__Channel.__exit__\r-rr F)NNF)rrrrrrCrDrrrrr"r%r(r+r2rr rrr r s  $$( $$  " $$0  " $$0  " $$0  " $$0 $$$$rr c\rSrSrSr\R S5r\R S5r\R S5r \R S5r \R S5r Sr \R S 5r \R S 5rS r\R S 5r\R S 5r\R S5r\R S5rSrSrSrSrg)ServicerContextidz2A context object passed to method implementations.c[5e)zWAccesses the metadata sent by the client. Returns: The invocation :term:`metadata`. rr s rinvocation_metadata#ServicerContext.invocation_metadatagrrc[5e)zIdentifies the peer that invoked the RPC being serviced. Returns: A string identifying the peer that invoked the RPC being serviced. The string format is determined by gRPC runtime. rr s rpeerServicerContext.peerprrc[5e)aGets one or more peer identity(s). Equivalent to servicer_context.auth_context().get(servicer_context.peer_identity_key()) Returns: An iterable of the identities, or None if the call is not authenticated. Each identity is returned as a raw bytes type. rr s rpeer_identitiesServicerContext.peer_identitieszrrc[5e)aThe auth property used to identify the peer. For example, "x509_common_name" or "x509_subject_alternative_name" are used to identify an SSL peer. Returns: The auth property (string) that indicates the peer identity, or None if the call is not authenticated. rr s rpeer_identity_key!ServicerContext.peer_identity_keyrrc[5e)zqGets the auth context for the call. Returns: A map of strings to an iterable of bytes for each auth property. rr s r auth_contextServicerContext.auth_contextrrc[5e)zSet the compression algorithm to be used for the entire call. Args: compression: An element of grpc.compression, e.g. grpc.compression.Gzip. r)r!rs rset_compressionServicerContext.set_compressionrrc[5e)zSends the initial metadata value to the client. This method need not be called by implementations if they have no metadata to add to what the gRPC runtime will transmit. Args: initial_metadata: The initial :term:`metadata`. r)r!rs rsend_initial_metadata%ServicerContext.send_initial_metadata "##rc[5e)aSets the trailing metadata for the RPC. Sets the trailing metadata to be sent upon completion of the RPC. If this method is invoked multiple times throughout the lifetime of an RPC, the value supplied in the final invocation will be the value sent over the wire. This method need not be called by implementations if they have no metadata to add to what the gRPC runtime will transmit. Args: trailing_metadata: The trailing :term:`metadata`. r)r!rs rset_trailing_metadata%ServicerContext.set_trailing_metadatar(rc[5e)zAccess value to be used as trailing metadata upon RPC completion. This is an EXPERIMENTAL API. Returns: The trailing :term:`metadata` for the RPC. rr s rr!ServicerContext.trailing_metadatarrc[5e)aRaises an exception to terminate the RPC with a non-OK status. The code and details passed as arguments will supersede any existing ones. Args: code: A StatusCode object to be sent to the client. It must not be StatusCode.OK. details: A UTF-8-encodable string to be sent to the client upon termination of the RPC. Raises: Exception: An exception is always raised to signal the abortion the RPC to the gRPC runtime. r)r!rrs rabortServicerContext.abortr$rc[5e)aRaises an exception to terminate the RPC with a non-OK status. The status passed as argument will supersede any existing status code, status message and trailing metadata. This is an EXPERIMENTAL API. Args: status: A grpc.Status object. The status code in it must not be StatusCode.OK. Raises: Exception: An exception is always raised to signal the abortion the RPC to the gRPC runtime. r)r!statuss rabort_with_status!ServicerContext.abort_with_statusr$rc[5e)zSets the value to be used as status code upon RPC completion. This method need not be called by method implementations if they wish the gRPC runtime to determine the status code of the RPC. Args: code: A StatusCode object to be sent to the client. r)r!rs rset_codeServicerContext.set_coderLrc[5e)aSets the value to be used as detail string upon RPC completion. This method need not be called by method implementations if they have no details to transmit. Args: details: A UTF-8-encodable string to be sent to the client upon termination of the RPC. r)r!rs r set_detailsServicerContext.set_detailsrrc[5e)zAccesses the value to be used as status code upon RPC completion. This is an EXPERIMENTAL API. Returns: The StatusCode value for the RPC. rr s rrServicerContext.code rrc[5e)zAccesses the value to be used as detail string upon RPC completion. This is an EXPERIMENTAL API. Returns: The details string of the RPC. rr s rrServicerContext.detailsrrc[5e)zDisables compression for the next response message. This method will override any compression configuration set during server creation or set on the call. rr s r disable_next_message_compression0ServicerContext.disable_next_message_compression!rrr N)rrrrrrCrDr8r;r>rArDrGrJrNrrSrWrZr]rrrdrr rrr6r6ds:<$$ $$  $ $  $ $ $$$  $ $ $$"$ $$$ $$$  $ $  $ $$$$rr6c\rSrSrSrSrg)RpcMethodHandleri-aAn implementation of a single RPC method. Attributes: request_streaming: Whether the RPC supports exactly one request message or any arbitrary number of request messages. response_streaming: Whether the RPC supports exactly one response message or any arbitrary number of response messages. request_deserializer: A callable :term:`deserializer` that accepts a byte string and returns an object suitable to be passed to this object's business logic, or None to indicate that this object's business logic should be passed the raw request bytes. response_serializer: A callable :term:`serializer` that accepts an object produced by this object's business logic and returns a byte string, or None to indicate that the byte strings produced by this object's business logic should be transmitted on the wire as they are. unary_unary: This object's application-specific business logic as a callable value that takes a request value and a ServicerContext object and returns a response value. Only non-None if both request_streaming and response_streaming are False. unary_stream: This object's application-specific business logic as a callable value that takes a request value and a ServicerContext object and returns an iterator of response values. Only non-None if request_streaming is False and response_streaming is True. stream_unary: This object's application-specific business logic as a callable value that takes an iterator of request values and a ServicerContext object and returns a response value. Only non-None if request_streaming is True and response_streaming is False. stream_stream: This object's application-specific business logic as a callable value that takes an iterator of request values and a ServicerContext object and returns an iterator of response values. Only non-None if request_streaming and response_streaming are both True. r Nrr rrrgrg-s rrgc\rSrSrSrSrg)HandlerCallDetailsiQzDescribes an RPC that has just arrived for service. Attributes: method: The method name of the RPC. invocation_metadata: The :term:`metadata` sent by the client. r Nrr rrririQrrric<\rSrSrSr\R S5rSrg)GenericRpcHandleriZz2An implementation of arbitrarily many RPC methods.c[5e)zReturns the handler for servicing the RPC. Args: handler_call_details: A HandlerCallDetails describing the RPC. Returns: An RpcMethodHandler with which the RPC may be serviced if the implementation chooses to service this RPC, or None otherwise. r)r!handler_call_detailss rserviceGenericRpcHandler.service]rrr N) rrrrrrCrDrnrr rrrkrkZs< $ $rrkc<\rSrSrSr\R S5rSrg)ServiceRpcHandlerikaLAn implementation of RPC methods belonging to a service. A service handles RPC methods with structured names of the form '/Service.Name/Service.Method', where 'Service.Name' is the value returned by service_name(), and 'Service.Method' is the method name. A service can have multiple method names, but only a single service name. c[5e)z;Returns this service's name. Returns: The service name. rr s r service_nameServiceRpcHandler.service_nameurrr N) rrrrrrCrDrsrr rrrqrqks! $$rrqc<\rSrSrSr\R S5rSrg)ServerInterceptoriz7Affords intercepting incoming RPCs on the service-side.c[5e)aIntercepts incoming RPCs before handing them over to a handler. State can be passed from an interceptor to downstream interceptors via contextvars. The first interceptor is called from an empty contextvars.Context, and the same Context is used for downstream interceptors and for the final handler call. Note that there are no guarantees that interceptors and handlers will be called from the same thread. Args: continuation: A function that takes a HandlerCallDetails and proceeds to invoke the next interceptor in the chain, if any, or the RPC handler lookup logic, with the call details passed as an argument, and returns an RpcMethodHandler instance if the RPC is considered serviced, or None otherwise. handler_call_details: A HandlerCallDetails describing the RPC. Returns: An RpcMethodHandler with which the RPC may be serviced if the interceptor chooses to service this RPC, or None otherwise. r)r!rrms rintercept_service#ServerInterceptor.intercept_servicerrr N) rrrrrrCrDrxrr rrrvrvsA$$rrvc\rSrSrSr\R S5rSr\R S5r \R S5r \R S5r \R S5r S S jr S rg ) ServerizServices RPCs.c[5e)zRegisters GenericRpcHandlers with this Server. This method is only safe to call before the server is started. Args: generic_rpc_handlers: An iterable of GenericRpcHandlers that will be used to service RPCs. r)r!generic_rpc_handlerss radd_generic_rpc_handlersServer.add_generic_rpc_handlersrLrcg)a]Registers GenericRpcHandlers with this Server. This method is only safe to call before the server is started. If the same method have both generic and registered handler, registered handler will take precedence. Args: service_name: The service name. method_handlers: A dictionary that maps method names to corresponding RpcMethodHandler. Nr )r!rsmethod_handlerss radd_registered_method_handlers%Server.add_registered_method_handlerssrc[5e)aBOpens an insecure port for accepting RPCs. This method may only be called before starting the server. Args: address: The address for which to open a port. If the port is 0, or not specified in the address, then gRPC runtime will choose a port. Returns: An integer port on which server will accept RPC requests. r)r!addresss radd_insecure_portServer.add_insecure_portr0rc[5e)auOpens a secure port for accepting RPCs. This method may only be called before starting the server. Args: address: The address for which to open a port. if the port is 0, or not specified in the address, then gRPC runtime will choose a port. server_credentials: A ServerCredentials object. Returns: An integer port on which server will accept RPC requests. r)r!rserver_credentialss radd_secure_portServer.add_secure_ports "##rc[5e)zWStarts this Server. This method may only be called once. (i.e. it is not idempotent). rr s rstart Server.startrrc[5e)a.Stops this Server. This method immediately stop service of new RPCs in all cases. If a grace period is specified, this method waits until all active RPCs are finished or until the grace period is reached. RPCs that haven't been terminated within the grace period are aborted. If a grace period is not specified (by passing None for `grace`), all existing RPCs are aborted immediately and this method blocks until the last RPC handler terminates. This method is idempotent and may be called at any time. Passing a smaller grace value in a subsequent call will have the effect of stopping the Server sooner (passing None will have the effect of stopping the server immediately). Passing a larger grace value in a subsequent call *will not* have the effect of stopping the server later (i.e. the most restrictive grace value is used). Args: grace: A duration of time in seconds or None. Returns: A threading.Event that will be set when this Server has completely stopped, i.e. when running RPCs either complete or are aborted and all handlers have terminated. r)r!graces rstop Server.stoprrNc[5e)aTBlock current thread until the server stops. This is an EXPERIMENTAL API. The wait will not consume computational resources during blocking, and it will block until one of the two following conditions are met: 1) The server is stopped or terminated; 2) A timeout occurs if timeout is not `None`. The timeout argument works in the same way as `threading.Event.wait()`. https://docs.python.org/3/library/threading.html#threading.Event.wait Args: timeout: A floating point number specifying a timeout for the operation in seconds. Returns: A bool indicates if the operation times out. rr2s rwait_for_terminationServer.wait_for_terminationr6rr rB)rrrrrrCrDr~rrrrrrrr rrr{r{s $ $    $ $ $$  $$ $$<$rr{c >SSKJn URSSUUUSSS5$)aCreates an RpcMethodHandler for a unary-unary RPC method. Args: behavior: The implementation of an RPC that accepts one request and returns one response. request_deserializer: An optional :term:`deserializer` for request deserialization. response_serializer: An optional :term:`serializer` for response serialization. Returns: An RpcMethodHandler object that is typically used by grpc.Server. r _utilitiesFNgrpcrrgbehaviorrequest_deserializerresponse_serializerrs runary_unary_rpc_method_handlerr!s2  & &       rc >SSKJn URSSUUSUSS5$)aCreates an RpcMethodHandler for a unary-stream RPC method. Args: behavior: The implementation of an RPC that accepts one request and returns an iterator of response values. request_deserializer: An optional :term:`deserializer` for request deserialization. response_serializer: An optional :term:`serializer` for response serialization. Returns: An RpcMethodHandler object that is typically used by grpc.Server. rrFTNrrs runary_stream_rpc_method_handlerr=s2  & &       rc >SSKJn URSSUUSSUS5$)aCreates an RpcMethodHandler for a stream-unary RPC method. Args: behavior: The implementation of an RPC that accepts an iterator of request values and returns a single response value. request_deserializer: An optional :term:`deserializer` for request deserialization. response_serializer: An optional :term:`serializer` for response serialization. Returns: An RpcMethodHandler object that is typically used by grpc.Server. rrTFNrrs rstream_unary_rpc_method_handlerrYs2  & &       rc >SSKJn URSSUUSSSU5$)aCreates an RpcMethodHandler for a stream-stream RPC method. Args: behavior: The implementation of an RPC that accepts an iterator of request values and returns an iterator of response values. request_deserializer: An optional :term:`deserializer` for request deserialization. response_serializer: An optional :term:`serializer` for response serialization. Returns: An RpcMethodHandler object that is typically used by grpc.Server. rrTNrrs r stream_stream_rpc_method_handlerrus2  & &       rc0SSKJn URX5$)a}Creates a GenericRpcHandler from RpcMethodHandlers. Args: service: The name of the service that is implemented by the method_handlers. method_handlers: A dictionary that maps method names to corresponding RpcMethodHandler. Returns: A GenericRpcHandler. This is typically added to the grpc.Server object with add_generic_rpc_handlers() before starting the server. rr)rrDictionaryGenericHandler)rnrrs rmethod_handlers_generic_handlerrs  . .w HHrcB[[R"XU55$)aCreates a ChannelCredentials for use with an SSL-enabled Channel. Args: root_certificates: The PEM-encoded root certificates as a byte string, or None to retrieve them from a default location chosen by gRPC runtime. private_key: The PEM-encoded private key as a byte string, or None if no private key should be used. certificate_chain: The PEM-encoded certificate chain as a byte string to use or None if no certificate chain should be used. Returns: A ChannelCredentials for use with an SSL-enabled Channel. )rrLSSLChannelCredentials)root_certificates private_keycertificate_chains rssl_channel_credentialsrs%" %% ,=  rcrUc [5OUn[[R"UR55$)a'Creates a ChannelCredentials for use with xDS. This is an EXPERIMENTAL API. Args: fallback_credentials: Credentials to use in case it is not possible to establish a secure connection via xDS. If no fallback_credentials argument is supplied, a default SSLChannelCredentials is used. )rrrLXDSChannelCredentialsrfallback_credentialss rxds_channel_credentialsrs> ' ! ! %%&:&G&GH rc0SSKJn URX5$)zConstruct CallCredentials from an AuthMetadataPlugin. Args: metadata_plugin: An AuthMetadataPlugin to use for authentication. name: An optional name for the plugin. Returns: A CallCredentials. r_plugin_wrapping)rr metadata_plugin_call_credentials)metadata_pluginnamers rmetadata_call_credentialsrs&  < < rc\SSKJn SSKJn URUR U5S5$)zConstruct CallCredentials from an access token. Args: access_token: A string to place directly in the http request authorization header, for example "authorization: Bearer ". Returns: A CallCredentials. r)_authrN)rrrrAccessTokenAuthMetadataPlugin) access_tokenrrs raccess_token_call_credentialsrs-%  < < ++L94 rc`[[R"[SU5555$)zCompose multiple CallCredentials to make a new CallCredentials. Args: *call_credentials: At least two CallCredentials objects. Returns: A CallCredentials object composed of the given CallCredentials objects. c3:# UHnURv M g7frBr.0single_call_credentialss r -composite_call_credentials../?+(44/?)rrLCompositeCallCredentialstuplecall_credentialss rcomposite_call_credentialsrs4 (( /?   rcv[[R"[SU55UR55$)a&Compose a ChannelCredentials and one or more CallCredentials objects. Args: channel_credentials: A ChannelCredentials object. *call_credentials: One or more CallCredentials objects. Returns: A ChannelCredentials composed of the given ChannelCredentials and CallCredentials objects. c3:# UHnURv M g7frBrrs rr0composite_channel_credentials..rr)rrLCompositeChannelCredentialsrr)channel_credentialsrs rcomposite_channel_credentialsrs? ++ /?  , ,   rc U(d [S5eU(aUc [S5e[[R"UUVVs/sHup4[R"X45PM snnU55$s snnf)aCreates a ServerCredentials for use with an SSL-enabled Server. Args: private_key_certificate_chain_pairs: A list of pairs of the form [PEM-encoded private key, PEM-encoded certificate chain]. root_certificates: An optional byte string of PEM-encoded client root certificates that the server will use to verify client authentication. If omitted, require_client_auth must also be False. require_client_auth: A boolean indicating whether or not to require clients to be authenticated. May only be True if root_certificates is not None. Returns: A ServerCredentials for use with an SSL-enabled Server. Typically, this object is an argument to add_secure_port() method during server setup. [[R"55$)aCreates a credentials object directing the server to use no credentials. This is an EXPERIMENTAL API. This object cannot be used directly in a call to `add_secure_port`. Instead, it should be used to construct other credentials objects, e.g. with xds_server_credentials. )rrLinsecure_server_credentialsr rrrrSs W@@B CCrc U(aI[[R"UUVVs/sHup#[R"X#5PM snn55$[ S5es snnf)aCreates a ServerCertificateConfiguration for use with a Server. Args: private_key_certificate_chain_pairs: A collection of pairs of the form [PEM-encoded private key, PEM-encoded certificate chain]. root_certificates: An optional byte string of PEM-encoded client root certificates that the server will use to verify client authentication. Returns: A ServerCertificateConfiguration that can be returned in the certificate configuration fetching callback. r)rrLserver_certificate_config_sslrr)rrrrs r$ssl_server_certificate_configurationr^sg +-  1 1!%H$G--c7$G    J  s"AcD[[R"UUU55$)aCreates a ServerCredentials for use with an SSL-enabled Server. Args: initial_certificate_configuration (ServerCertificateConfiguration): The certificate configuration with which the server will be initialized. certificate_configuration_fetcher (callable): A callable that takes no arguments and should return a ServerCertificateConfiguration to replace the server's current certificate, or None for no change (i.e., the server will continue its current certificate config). The library will call this callback on *every* new client connection before starting the TLS handshake with the client, thus allowing the user application to optionally return a new ServerCertificateConfiguration that the server will then use for the handshake. require_client_authentication: A boolean indicating whether or not to require clients to be authenticated. Returns: A ServerCredentials. )rrL*server_credentials_ssl_dynamic_cert_config)!initial_certificate_configuration!certificate_configuration_fetcherrequire_client_authentications rdynamic_ssl_server_credentialsr~s(2 :: - - )  rcp\rSrSrSr\R Rr\R Rr Sr g)LocalConnectionTypeizTypes of local connection for local credential creation. Attributes: UDS: Unix domain socket connections LOCAL_TCP: Local TCP connections. r N) rrrrrrLrudsUDS local_tcp LOCAL_TCPrr rrrrs+  % % ) )C++55IrrcT[[R"UR55$)aCreates a local ChannelCredentials used for local connections. This is an EXPERIMENTAL API. Local credentials are used by local TCP endpoints (e.g. localhost:10000) also UDS connections. The connections created by local channel credentials are not encrypted, but will be checked if they are local or not. The UDS connections are considered secure by providing peer authentication and data confidentiality while TCP connections are considered insecure. It is allowed to transmit call credentials over connections created by local channel credentials. Local channel credentials are useful for 1) eliminating insecure_channel usage; 2) enable unit testing for call credentials without setting up secrets. Args: local_connect_type: Local connection type (either grpc.LocalConnectionType.UDS or grpc.LocalConnectionType.LOCAL_TCP) Returns: A ChannelCredentials for use with a local Channel )rrLchannel_credentials_localvaluelocal_connect_types rlocal_channel_credentialsrs&4 ))*<*B*BC rcT[[R"UR55$)a~Creates a local ServerCredentials used for local connections. This is an EXPERIMENTAL API. Local credentials are used by local TCP endpoints (e.g. localhost:10000) also UDS connections. The connections created by local server credentials are not encrypted, but will be checked if they are local or not. The UDS connections are considered secure by providing peer authentication and data confidentiality while TCP connections are considered insecure. It is allowed to transmit call credentials over connections created by local server credentials. Local server credentials are useful for 1) eliminating insecure_channel usage; 2) enable unit testing for call credentials without setting up secrets. Args: local_connect_type: Local connection type (either grpc.LocalConnectionType.UDS or grpc.LocalConnectionType.LOCAL_TCP) Returns: A ServerCredentials for use with a local Server )rrLserver_credentials_localrrs rlocal_server_credentialsrs&4 (();)A)AB rcR[[R"U=(d /55$)aCreates a ChannelCredentials for use with an ALTS-enabled Channel. This is an EXPERIMENTAL API. ALTS credentials API can only be used in GCP environment as it relies on handshaker service being available. For more info about ALTS see https://cloud.google.com/security/encryption-in-transit/application-layer-transport-security Args: service_accounts: A list of server identities accepted by the client. If target service accounts are provided and none of them matches the peer identity of the server, handshake will fail. The arg can be empty if the client does not have any information about trusted server identity. Returns: A ChannelCredentials for use with an ALTS-enabled Channel )rrLchannel_credentials_alts)service_accountss ralts_channel_credentialsrs%" (()9)?R@ rc>[[R"55$)aCreates a ServerCredentials for use with an ALTS-enabled connection. This is an EXPERIMENTAL API. ALTS credentials API can only be used in GCP environment as it relies on handshaker service being available. For more info about ALTS see https://cloud.google.com/security/encryption-in-transit/application-layer-transport-security Returns: A ServerCredentials for use with an ALTS-enabled Server )rrLserver_credentials_altsr rralts_server_credentialsrs W<<> ??rcT[[R"UR55$)a$Creates a compute engine channel credential. This credential can only be used in a GCP environment as it relies on a handshaker service. For more info about ALTS, see https://cloud.google.com/security/encryption-in-transit/application-layer-transport-security This channel credential is expected to be used as part of a composite credential in conjunction with a call credentials that authenticates the VM's default service account. If used with any other sort of call credential, the connection may suddenly and unexpectedly begin failing RPCs. )rrL"channel_credentials_compute_enginerrs r"compute_engine_channel_credentialsrs( 22  ) )  rc0SSKJn URU5$)a@Creates a Future that tracks when a Channel is ready. Cancelling the Future does not affect the channel's state machine. It merely decouples the Future from channel state machine. Args: channel: A Channel object. Returns: A Future object that matures when the channel connectivity is ChannelConnectivity.READY. rr)rrchannel_ready_future)channelrs rrr"s  * *7 33rcJSSKJn URXcSSU5$USU5$)a|Creates an insecure Channel to a server. The returned Channel is thread-safe. Args: target: The server address options: An optional list of key-value pairs (:term:`channel_arguments` in gRPC Core runtime) to configure the channel. compression: An optional value indicating the compression method to be used over the lifetime of the channel. Returns: A Channel. r_channelNr )rr r )targetoptionsrr s rinsecure_channelr 4s6   oD+ +2D+ rcSSKJn SSKJn URULa [ S5eUR UUcSOUURU5$)aCreates a secure Channel to a server. The returned Channel is thread-safe. Args: target: The server address. credentials: A ChannelCredentials instance. options: An optional list of key-value pairs (:term:`channel_arguments` in gRPC Core runtime) to configure the channel. compression: An optional value indicating the compression method to be used over the lifetime of the channel. Returns: A Channel. rr)_insecure_channel_credentialszYsecure_channel cannot be called with insecure credentials. Call insecure_channel instead.r )rr grpc.experimentalrrrr )r rr rr rs rsecure_channelrJsX ?#@@ 0     o7    rc4SSKJn UR"U/UQ76$)akIntercepts a channel through a set of interceptors. Args: channel: A Channel. interceptors: Zero or more objects of type UnaryUnaryClientInterceptor, UnaryStreamClientInterceptor, StreamUnaryClientInterceptor, or StreamStreamClientInterceptor. Interceptors are given control in the order they are listed. Returns: A Channel that intercepts each invocation via the provided interceptors. Raises: TypeError: If interceptor does not derive from any of UnaryUnaryClientInterceptor, UnaryStreamClientInterceptor, StreamUnaryClientInterceptor, or StreamStreamClientInterceptor. r) _interceptor)rrintercept_channel)r interceptorsrs rrrjs,"  ) )' AL AArc ZSSKJn URUUcSOUUcSOUUcSOUUUU5$)aCreates a Server with which RPCs can be serviced. Args: thread_pool: A futures.ThreadPoolExecutor to be used by the Server to execute RPC handlers. handlers: An optional list of GenericRpcHandlers used for executing RPCs. More handlers may be added by calling add_generic_rpc_handlers any time before the server is started. interceptors: An optional list of ServerInterceptor objects that observe and optionally manipulate the incoming RPCs before handing them over to handlers. The interceptors are given control in the order they are specified. This is an EXPERIMENTAL API. options: An optional list of key-value pairs (:term:`channel_arguments` in gRPC runtime) to configure the channel. maximum_concurrent_rpcs: The maximum number of concurrent RPCs this server will service before returning RESOURCE_EXHAUSTED status, or None to indicate no limit. compression: An element of grpc.compression, e.g. grpc.compression.Gzip. This compression algorithm will be used for the lifetime of the server unless overridden. xds: If set to true, retrieves server configuration via xDS. This is an EXPERIMENTAL option. Returns: A Server object. r_serverr )rr create_server) thread_poolhandlersrr maximum_concurrent_rpcsrxdsrs rserverrsDF  H" o7  rc#d# SSKJn URXU5nUv UR5 g7f)Nrr)rr_Context_finalize_state) rpc_eventstaterrrs r_create_servicer_contextr#s,y1EFG M s.0c`\rSrSrSr\R r\Rr\RrSr g) CompressionizIndicates the compression method to be used for an RPC. Attributes: NoCompression: Do not use compression algorithm. Deflate: Use "Deflate" compression algorithm. Gzip: Use "Gzip" compression algorithm. r N) rrrrrr NoCompressionDeflateGziprr rrr%r%s*!..M""G   Drr%)@r rrrFrUryr{r}rrrrrrr%rrrrrrrr rrrrr r6rgrirkrqr{rvrrrrrrrrrrrrrrrrrrrr rrrrrrrrrz grpc.toolsz grpc.healthzgrpc.reflection)r)aiozgrpc.aio)NN)NNNrB)NFr4)NNNNNF)errC contextlibenumloggingsysrr grpc._cythonrrLgrpc._runtime_protosrrr getLoggerr addHandler NullHandlergrpc._grpcio_metadatar ImportError Exceptionr rABCruniqueEnumrFrUryr{r}ABCMetarrrrrrobjectrrrrrrrrrrr r r6rgrirkrqrvr{rrrrrrrrrrrrrrrrrrrrrrrrr rrrcontextmanagerr#IntEnumr%__all__ grpc_toolsmodulesupdate grpc_healthgrpc_reflection version_infor+r rrrFs   *'4)(&&w':':'<=1>>L9L]$SWW]$F@$))@ @,9N9N 9N~ SWW  PyP,$,$d-$:-$f  $#''$D $377 $F $377 $F $CGG $L ( ((f("#'' $ $$$"(( DV D$f$cggf$R!$sww!$Hh$swwh$V!$!$N[$cgg[$BC$jCKKC$R!sww!H$$"$)S[[$.$$@y$SWWy$@>B:>B:>B:>B8I&AE0&"&&0( V D<@ F#(D 6$)) 6  62E1N1N>1D0M0M>, @&4$,@B:   -`  $,,    A L KK j12 KK {34 KK)?;< v(f"4KK C()#5QHKpG      sH&R&!R!R"*!R.RRRR"R+*R+.R76R7