async def run_cell_async(self, raw_cell: str, store_history=False, silent=False, shell_futures=True, *, transformed_cell: Optional[str]=None, preprocessing_exc_tuple: Optional[Any]=None) -> ExecutionResult:
    "Run a complete IPython cell asynchronously.\n\n        Parameters\n        ----------\n        raw_cell : str\n          The code (including IPython code such as %magic functions) to run.\n        store_history : bool\n          If True, the raw and translated cell will be stored in IPython's\n          history. For user code calling back into IPython's machinery, this\n          should be set to False.\n        silent : bool\n          If True, avoid side-effects, such as implicit displayhooks and\n          and logging.  silent=True forces store_history=False.\n        shell_futures : bool\n          If True, the code will share future statements with the interactive\n          shell. It will both be affected by previous __future__ imports, and\n          any __future__ imports in the code will affect the shell. If False,\n          __future__ imports are not shared in either direction.\n        transformed_cell: str\n          cell that was passed through transformers\n        preprocessing_exc_tuple:\n          trace if the transformation failed.\n\n        Returns\n        -------\n        result : :class:`ExecutionResult`\n\n        .. versionadded:: 7.0\n        "
    info = ExecutionInfo(raw_cell, store_history, silent, shell_futures)
    result = ExecutionResult(info)
    if ((not raw_cell) or raw_cell.isspace()):
        self.last_execution_succeeded = True
        self.last_execution_result = result
        return result
    if silent:
        store_history = False
    if store_history:
        result.execution_count = self.execution_count

    def error_before_exec(value):
        if store_history:
            self.execution_count += 1
        result.error_before_exec = value
        self.last_execution_succeeded = False
        self.last_execution_result = result
        return result
    self.events.trigger('pre_execute')
    if (not silent):
        self.events.trigger('pre_run_cell', info)
    if (transformed_cell is None):
        warnings.warn('`run_cell_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.', DeprecationWarning, stacklevel=2)
        try:
            cell = self.transform_cell(raw_cell)
        except Exception:
            preprocessing_exc_tuple = sys.exc_info()
            cell = raw_cell
        else:
            preprocessing_exc_tuple = None
    elif (preprocessing_exc_tuple is None):
        cell = transformed_cell
    else:
        cell = raw_cell
    if (store_history and (raw_cell.strip(' %') != 'paste')):
        self.history_manager.store_inputs(self.execution_count, cell, raw_cell)
    if (not silent):
        self.logger.log(cell, raw_cell)
    if (preprocessing_exc_tuple is not None):
        self.showtraceback(preprocessing_exc_tuple)
        if store_history:
            self.execution_count += 1
        return error_before_exec(preprocessing_exc_tuple[1])
    compiler = (self.compile if shell_futures else self.compiler_class())
    _run_async = False
    with self.builtin_trap:
        cell_name = compiler.cache(cell, self.execution_count, raw_code=raw_cell)
        with self.display_trap:
            try:
                code_ast = compiler.ast_parse(cell, filename=cell_name)
            except self.custom_exceptions as e:
                (etype, value, tb) = sys.exc_info()
                self.CustomTB(etype, value, tb)
                return error_before_exec(e)
            except IndentationError as e:
                self.showindentationerror()
                return error_before_exec(e)
            except (OverflowError, SyntaxError, ValueError, TypeError, MemoryError) as e:
                self.showsyntaxerror()
                return error_before_exec(e)
            try:
                code_ast = self.transform_ast(code_ast)
            except InputRejected as e:
                self.showtraceback()
                return error_before_exec(e)
            self.displayhook.exec_result = result
            interactivity = ('none' if silent else self.ast_node_interactivity)
            has_raised = (await self.run_ast_nodes(code_ast.body, cell_name, interactivity=interactivity, compiler=compiler, result=result))
            self.last_execution_succeeded = (not has_raised)
            self.last_execution_result = result
            self.displayhook.exec_result = None
    if store_history:
        self.history_manager.store_output(self.execution_count)
        self.execution_count += 1
    return result
Run a complete IPython cell asynchronously.

Parameters
----------
raw_cell : str
  The code (including IPython code such as %magic functions) to run.
store_history : bool
  If True, the raw and translated cell will be stored in IPython's
  history. For user code calling back into IPython's machinery, this
  should be set to False.
silent : bool
  If True, avoid side-effects, such as implicit displayhooks and
  and logging.  silent=True forces store_history=False.
shell_futures : bool
  If True, the code will share future statements with the interactive
  shell. It will both be affected by previous __future__ imports, and
  any __future__ imports in the code will affect the shell. If False,
  __future__ imports are not shared in either direction.
transformed_cell: str
  cell that was passed through transformers
preprocessing_exc_tuple:
  trace if the transformation failed.

Returns
-------
result : :class:`ExecutionResult`

.. versionadded:: 7.0
async def run_cell_async(self, raw_cell: str, store_history=False, silent=False, shell_futures=True, *, transformed_cell: Optional[str]=None, preprocessing_exc_tuple: Optional[Any]=None) -> ExecutionResult:
    "Run a complete IPython cell asynchronously.\n\n        Parameters\n        ----------\n        raw_cell : str\n          The code (including IPython code such as %magic functions) to run.\n        store_history : bool\n          If True, the raw and translated cell will be stored in IPython's\n          history. For user code calling back into IPython's machinery, this\n          should be set to False.\n        silent : bool\n          If True, avoid side-effects, such as implicit displayhooks and\n          and logging.  silent=True forces store_history=False.\n        shell_futures : bool\n          If True, the code will share future statements with the interactive\n          shell. It will both be affected by previous __future__ imports, and\n          any __future__ imports in the code will affect the shell. If False,\n          __future__ imports are not shared in either direction.\n        transformed_cell: str\n          cell that was passed through transformers\n        preprocessing_exc_tuple:\n          trace if the transformation failed.\n\n        Returns\n        -------\n        result : :class:`ExecutionResult`\n\n        .. versionadded:: 7.0\n        "
    info = ExecutionInfo(raw_cell, store_history, silent, shell_futures)
    result = ExecutionResult(info)
    if ((not raw_cell) or raw_cell.isspace()):
        self.last_execution_succeeded = True
        self.last_execution_result = result
        return result
    if silent:
        store_history = False
    if store_history:
        result.execution_count = self.execution_count

    def error_before_exec(value):
        if store_history:
            self.execution_count += 1
        result.error_before_exec = value
        self.last_execution_succeeded = False
        self.last_execution_result = result
        return result
    self.events.trigger('pre_execute')
    if (not silent):
        self.events.trigger('pre_run_cell', info)
    if (transformed_cell is None):
        warnings.warn('`run_cell_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.', DeprecationWarning, stacklevel=2)
        try:
            cell = self.transform_cell(raw_cell)
        except Exception:
            preprocessing_exc_tuple = sys.exc_info()
            cell = raw_cell
        else:
            preprocessing_exc_tuple = None
    elif (preprocessing_exc_tuple is None):
        cell = transformed_cell
    else:
        cell = raw_cell
    if (store_history and (raw_cell.strip(' %') != 'paste')):
        self.history_manager.store_inputs(self.execution_count, cell, raw_cell)
    if (not silent):
        self.logger.log(cell, raw_cell)
    if (preprocessing_exc_tuple is not None):
        self.showtraceback(preprocessing_exc_tuple)
        if store_history:
            self.execution_count += 1
        return error_before_exec(preprocessing_exc_tuple[1])
    compiler = (self.compile if shell_futures else self.compiler_class())
    _run_async = False
    with self.builtin_trap:
        cell_name = compiler.cache(cell, self.execution_count, raw_code=raw_cell)
        with self.display_trap:
            try:
                code_ast = compiler.ast_parse(cell, filename=cell_name)
            except self.custom_exceptions as e:
                (etype, value, tb) = sys.exc_info()
                self.CustomTB(etype, value, tb)
                return error_before_exec(e)
            except IndentationError as e:
                self.showindentationerror()
                return error_before_exec(e)
            except (OverflowError, SyntaxError, ValueError, TypeError, MemoryError) as e:
                self.showsyntaxerror()
                return error_before_exec(e)
            try:
                code_ast = self.transform_ast(code_ast)
            except InputRejected as e:
                self.showtraceback()
                return error_before_exec(e)
            self.displayhook.exec_result = result
            interactivity = ('none' if silent else self.ast_node_interactivity)
            has_raised = (await self.run_ast_nodes(code_ast.body, cell_name, interactivity=interactivity, compiler=compiler, result=result))
            self.last_execution_succeeded = (not has_raised)
            self.last_execution_result = result
            self.displayhook.exec_result = None
    if store_history:
        self.history_manager.store_output(self.execution_count)
        self.execution_count += 1
    return result