code: def _rpc_methods(
      self,
  ) -> dict[str, t.Callable[..., t.Awaitable["Response"]]]:
      def make_async_fn(
          method_name: str,
          input_type: t.Any,
          output_type: t.Any,
      ) -> t.Callable[..., t.Awaitable["Response"]]:
          rpc = self.channel.unary_unary(
              method_name,
              request_serializer=input_type.SerializeToString,
              response_deserializer=output_type.FromString,
          )
  
          def fn(
              channel_kwargs: t.Dict[str, t.Any],
              method_kwargs: t.Dict[str, t.Any],
          ) -> t.Awaitable["Response"]:
              return t.cast(
                  t.Awaitable["Response"],
                  rpc(input_type(**method_kwargs), **channel_kwargs),
              )
  
          return fn
  
      return {
          method_name: make_async_fn(
              method_name,
              input_type=metadata["input_type"],
              output_type=metadata["output_type"],
          )
          for method_name, metadata in self._rpc_metadata.items()
      }
  
imports: from __future__ import annotations
  import asyncio
  import logging
  import time
  import typing
  from functools import cached_property
  from typing import TYPE_CHECKING
  from packaging.version import parse
  from ...exceptions import BentoMLException
  from ...grpc.utils import LATEST_PROTOCOL_VERSION
  from ...grpc.utils import import_generated_stubs
  from ...grpc.utils import import_grpc
  from ...grpc.utils import load_from_file
  from ..None import io_descriptors
  from ..service import Service
  from ..service.inference_api import InferenceAPI
  from ..utils import LazyLoader
  from .None import AsyncClient
  from .None import Client
  from .None import SyncClient
label_desc: Use image node_id 5 for calling the AsyncGrpcClient obj's underlying member method code with example usage: obj._rpc_methods() and returns: unknown, fn, t