code: def make_buffered_asgi_receive(serialized_body: bytes) -> Receive:
      """Returns an ASGI receiver that returns the provided buffered body."""
  
      # Simulates receiving HTTP body from TCP socket.  In reality, the body has
      # already been streamed in chunks and stored in serialized_body.
      received = False
  
      async def mock_receive():
          nonlocal received
  
          # If the request has already been received, starlette will keep polling
          # for HTTP disconnect. We will pause forever. The coroutine should be
          # cancelled by starlette after the response has been sent.
          if received:
              block_forever = asyncio.Event()
              await block_forever.wait()
  
          received = True
          return {
              "body": serialized_body,
              "type": "http.request",
              "more_body": False,
          }
  
      return mock_receive
  
imports: import asyncio
  import inspect
  import json
  import logging
  import pickle
  import socket
  from dataclasses import dataclass
  from typing import Any, List, Optional, Tuple, Type
  import starlette
  from fastapi.encoders import jsonable_encoder
  from starlette.types import ASGIApp, Message, Receive, Scope, Send
  from uvicorn.config import Config
  from uvicorn.lifespan.on import LifespanOn
  from ray._private.pydantic_compat import IS_PYDANTIC_2
  from ray.actor import ActorHandle
  from ray.serve._private.constants import SERVE_LOGGER_NAME
  from ray.serve._private.utils import serve_encoders
  from ray.serve.exceptions import RayServeException
label_desc: Use image node_id 1 for calling a global function with example usage: make_buffered_asgi_receive(serialized_body) and returns: mock_receive, dict