nebius.aio.request.Request

Await the active native call without losing a completed result.

SDK shutdown cancels runtime tasks directly. When the native done callback has already published completion, recover that authoritative result or error instead of allowing wrapper cancellation to replace it.

Await the request's shared submission and return its result.

Reject a request inherited by a child process before locking.

Claim the request's documented one-shot await operation.

Copy terminal state without allowing SDK close to erase success.

The native response is already authoritative when this method starts. Runtime shutdown can cancel the parent submission. A shielded child task processes final metadata, converts errors, wraps the result, and releases the transport. The parent waits for this task before it returns.

Attempt to raise and swallow a RequestError from an AioRpcError.

This helper is used to set status and other metadata that came with the AioRpcError without actually raising the RequestError.

Schedule the request once and return its shared awaitable.

Built-in channels return a reusable cross-loop handle, allowing synchronous wait to avoid an unnecessary second runtime task. Legacy channels retain their loop-local scheduled-awaitable behavior.

Ensure metadata is received and return the request and trace ids.

Returns a tuple (request_id, trace_id) extracted from the initial metadata. This coroutine awaits the request if the metadata is not available.

Publish native attempt completion before its awaiter resumes.

The SDK loop still has to classify a terminal attempt as success, final error, or retriable error. Cancellation during that interval is recorded but does not cancel the wrapper task and erase a native success.

Extract request and trace ids from cached initial metadata.

Raises RequestError when initial metadata is not present.

Pause the request-only clock while authorization runs.

SDK-loop queueing is charged before the first pause. Native RPC work, retry classification, and backoff consume the retained budget; time spent authenticating does not. The authorization deadline separately caps authentication plus all request attempts.

Convert a gRPC AioRpcError into the SDK's RequestError and status.

This extracts initial/trailing metadata, parses request identifiers and attempts to convert the gRPC status into the SDK's structured RequestStatus. The resulting status is stored on self._status and a nebius.aio.service_error.RequestError is raised.

Release and forget the request's current transport lease.

Clearing the reference before invoking channel code prevents an outer authorization retry from reusing a wrapper that has already returned to the shared pool. It also ensures a custom release failure cannot leave this request claiming a lease whose pool state is unknown.

Wrap request retry loop with an authorization loop.

This outer ownership guard releases a caller-supplied transport when provider construction, authentication, or cancellation fails before the native retry loop assumes responsibility for the lease. Cleanup failures are logged without replacing the original request error.

Authenticate and run the native request/retry state machine.

The authorization loop will attempt to authenticate and then execute the request retry loop. If the result is UNAUTHENTICATED and the authenticator allows retry, it will re-authenticate and try again while respecting the overall auth timeout.

Publish an authorization retry decision atomically.

An UNAUTHENTICATED native error remains terminal while the authenticator decides whether the logical request may retry. A cancellation accepted during that interval wins only when a retry would otherwise occur; a final native error remains authoritative.

Resume the request-only clock for native RPC and retry work.

Core retry loop for the RPC invocation.

This coroutine executes the RPC, applies per-attempt and overall timeouts, and implements retry/backoff rules for retriable errors. It returns the RPC result or raises the error that terminated the operation.

Prepare and start the underlying gRPC unary-unary call.

Responsibilities:

• Validate/serialize the request payload.
• Populate parent identifiers into the request when absent and the channel exposes a parent id.
• Resolve an AddressChannel via Channel.get_channel_by_method when no override was provided.
• Create the gRPC call object and store it on self._call.

Classify rich service retry hints before publishing finality.

Native gRPC status codes alone are insufficient: a rich status can carry a service error whose retry policy is CALL. Decode that status before cancel decides whether the logical request is final. Conversion is repeated by _raise_request_error only on the exceptional path so that the public status retains request IDs.

Return the bounded wait used by synchronous request adapters.

Applicable authorization deadlines start when built-in runtime work is submitted and bound the full authentication-plus-request process. Request timeout excludes authentication, so it is the outer wait only when authorization does not apply. Before submission this method makes the same choice when the channel exposes the caller-safe provider probe. Legacy channels enforce both independent clocks inside their request state machine. A small grace period lets the internal timeout path publish its structured error and finish cancellation before the outer blocking wait expires.