|
def | __call__ (self, request, timeout=None, metadata=None, credentials=None, wait_for_ready=None, compression=None) |
|
def | __init__ (self, channel, managed_call, method, request_serializer, response_deserializer) |
|
def | future (self, request, timeout=None, metadata=None, credentials=None, wait_for_ready=None, compression=None) |
|
def | with_call (self, request, timeout=None, metadata=None, credentials=None, wait_for_ready=None, compression=None) |
|
|
def | _blocking (self, request, timeout, metadata, credentials, wait_for_ready, compression) |
|
def | _prepare (self, request, timeout, metadata, wait_for_ready, compression) |
|
Definition at line 885 of file grpc/_channel.py.
◆ __init__()
def grpc._channel._UnaryUnaryMultiCallable.__init__ |
( |
|
self, |
|
|
|
channel, |
|
|
|
managed_call, |
|
|
|
method, |
|
|
|
request_serializer, |
|
|
|
response_deserializer |
|
) |
| |
◆ __call__()
def grpc._channel._UnaryUnaryMultiCallable.__call__ |
( |
|
self, |
|
|
|
request, |
|
|
|
timeout = None , |
|
|
|
metadata = None , |
|
|
|
credentials = None , |
|
|
|
wait_for_ready = None , |
|
|
|
compression = None |
|
) |
| |
Synchronously 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: This is an EXPERIMENTAL argument. An optional
flag to enable :term:`wait_for_ready` mechanism.
compression: An element of grpc.compression, e.g.
grpc.compression.Gzip. This is an EXPERIMENTAL option.
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.
Reimplemented from grpc.UnaryUnaryMultiCallable.
Definition at line 937 of file grpc/_channel.py.
◆ _blocking()
def grpc._channel._UnaryUnaryMultiCallable._blocking |
( |
|
self, |
|
|
|
request, |
|
|
|
timeout, |
|
|
|
metadata, |
|
|
|
credentials, |
|
|
|
wait_for_ready, |
|
|
|
compression |
|
) |
| |
|
private |
◆ _prepare()
def grpc._channel._UnaryUnaryMultiCallable._prepare |
( |
|
self, |
|
|
|
request, |
|
|
|
timeout, |
|
|
|
metadata, |
|
|
|
wait_for_ready, |
|
|
|
compression |
|
) |
| |
|
private |
◆ future()
def grpc._channel._UnaryUnaryMultiCallable.future |
( |
|
self, |
|
|
|
request, |
|
|
|
timeout = None , |
|
|
|
metadata = None , |
|
|
|
credentials = None , |
|
|
|
wait_for_ready = None , |
|
|
|
compression = None |
|
) |
| |
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: This is an EXPERIMENTAL argument. An optional
flag to enable :term:`wait_for_ready` mechanism.
compression: An element of grpc.compression, e.g.
grpc.compression.Gzip. This is an EXPERIMENTAL option.
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.
Reimplemented from grpc.UnaryUnaryMultiCallable.
Definition at line 959 of file grpc/_channel.py.
◆ with_call()
def grpc._channel._UnaryUnaryMultiCallable.with_call |
( |
|
self, |
|
|
|
request, |
|
|
|
timeout = None , |
|
|
|
metadata = None , |
|
|
|
credentials = None , |
|
|
|
wait_for_ready = None , |
|
|
|
compression = None |
|
) |
| |
Synchronously 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: This is an EXPERIMENTAL argument. An optional
flag to enable :term:`wait_for_ready` mechanism.
compression: An element of grpc.compression, e.g.
grpc.compression.Gzip. This is an EXPERIMENTAL option.
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.
Reimplemented from grpc.UnaryUnaryMultiCallable.
Definition at line 948 of file grpc/_channel.py.
◆ _channel
grpc._channel._UnaryUnaryMultiCallable._channel |
|
private |
◆ _context
grpc._channel._UnaryUnaryMultiCallable._context |
|
private |
◆ _managed_call
grpc._channel._UnaryUnaryMultiCallable._managed_call |
|
private |
◆ _method
grpc._channel._UnaryUnaryMultiCallable._method |
|
private |
◆ _request_serializer
grpc._channel._UnaryUnaryMultiCallable._request_serializer |
|
private |
◆ _response_deserializer
grpc._channel._UnaryUnaryMultiCallable._response_deserializer |
|
private |
The documentation for this class was generated from the following file: