text: import json
  import logging
  import asyncio
  from .utils import is_invalid_params
  from .exceptions import (
      JSONRPCInvalidParams,
      JSONRPCInvalidRequest,
      JSONRPCInvalidRequestException,
      JSONRPCMethodNotFound,
      JSONRPCParseError,
      JSONRPCServerError,
      JSONRPCDispatchException,
  )
  from .jsonrpc1 import JSONRPC10Response
  from .jsonrpc2 import (
      JSONRPC20BatchRequest,
      JSONRPC20BatchResponse,
      JSONRPC20Response,
  )
  from .jsonrpc import JSONRPCRequest
  
  logger = logging.getLogger(__name__)
  
  
  class AsyncJSONRPCResponseManager(object):
  
      """ JSON-RPC response manager.
  
      Method brings syntactic sugar into library. Given dispatcher it handles
      request (both single and batch) and handles errors.
      Request could be handled in parallel, it is server responsibility.
  
      :param str request_str: json string. Will be converted into
          JSONRPC20Request, JSONRPC20BatchRequest or JSONRPC10Request
  
      :param dict dispather: dict<function_name:function>.
  
      """
  
      RESPONSE_CLASS_MAP = {
          "1.0": JSONRPC10Response,
          "2.0": JSONRPC20Response,
      }
  
      @classmethod
      async def handle(cls, request_str, dispatcher):
          if isinstance(request_str, bytes):
              request_str = request_str.decode("utf-8")
  
          try:
              data = json.loads(request_str)
          except (TypeError, ValueError):
              return JSONRPC20Response(error=JSONRPCParseError()._data)
  
          try:
              request = JSONRPCRequest.from_data(data)
          except JSONRPCInvalidRequestException:
              return JSONRPC20Response(error=JSONRPCInvalidRequest()._data)
  
          return await cls.handle_request(request, dispatcher)
  
      @classmethod
      async def handle_request(cls, request, dispatcher):
          """ Handle request data.
  
          At this moment request has correct jsonrpc format.
  
          :param dict request: data parsed from request_str.
          :param jsonrpc.dispatcher.Dispatcher dispatcher:
  
          .. versionadded: 1.8.0
  
          """
          rs = request if isinstance(request, JSONRPC20BatchRequest) \
              else [request]
          responses = [r for r in (await cls._get_responses(rs, dispatcher))
                       if r is not None]
  
          # notifications
          if not responses:
              return
  
          if isinstance(request, JSONRPC20BatchRequest):
              response = JSONRPC20BatchResponse(*responses)
              response.request = request
              return response
          else:
              return responses[0]
  
      @classmethod
      async def _get_responses(cls, requests, dispatcher):
          """ Response to each single JSON-RPC Request.
  
          :return iterator(JSONRPC20Response):
  
          .. versionadded: 1.9.0
            TypeError inside the function is distinguished from Invalid Params.
  
          """
          results = []
          for request in requests:
              def make_response(**kwargs):
                  response = cls.RESPONSE_CLASS_MAP[request.JSONRPC_VERSION](
                      _id=request._id, **kwargs)
                  response.request = request
                  return response
  
              try:
                  method = dispatcher[request.method]
              except KeyError:
                  output = make_response(error=JSONRPCMethodNotFound()._data)
              else:
                  try:
                      if asyncio.iscoroutinefunction(method):
                          result = await method(*request.args, **request.kwargs)
                      else:
                          result = method(*request.args, **request.kwargs)
                  except JSONRPCDispatchException as e:
                      output = make_response(error=e.error._data)
                  except Exception as e:
                      data = {
                          "type": e.__class__.__name__,
                          "args": e.args,
                          "message": str(e),
                      }
  
                      logger.exception("API Exception: {0}".format(data))
  
                      if isinstance(e, TypeError) and is_invalid_params(
                              method, *request.args, **request.kwargs):
                          output = make_response(
                              error=JSONRPCInvalidParams(data=data)._data)
                      else:
                          output = make_response(
                              error=JSONRPCServerError(data=data)._data)
                  else:
                      output = make_response(result=result)
              finally:
                  if not request.is_notification:
                      results.append(output)
  
          return results
  