code: def execute_fields(
          self,
          parent_type: GraphQLObjectType,
          source_value: Any,
          path: Optional[ResponsePath],
          fields: Dict[str, List[FieldNode]],
      ) -> AwaitableOrValue[Dict[str, Any]]:
          
          results = {}
          awaitable_fields: List[str] = []
          append_awaitable = awaitable_fields.append
          for response_name, field_nodes in fields.items():
              field_path = add_path(path, response_name)
              result = self.resolve_field(
                  parent_type, source_value, field_nodes, field_path
              )
              if result is not INVALID:
                  results[response_name] = result
                  if isawaitable(result):
                      append_awaitable(response_name)
  
          #  If there are no coroutines, we can just return the object
          if not awaitable_fields:
              return results
  
          # Otherwise, results is a map from field name to the result of resolving that
          # field, which is possibly a coroutine object. Return a coroutine object that
          # will yield this same map, but with any coroutines awaited in parallel and
          # replaced with the values they yielded.
          async def get_results():
              results.update(
                  zip(
                      awaitable_fields,
                      await gather(*(results[field] for field in awaitable_fields)),
                  )
              )
              return results
  
          return get_results()
docs: Execute the given fields concurrently.
  
          Implements the "Evaluating selection sets" section of the spec for "read" mode.