def run_project(
        project_directory: str,
        output_directory: str = None,
        log_path: str = None,
        shared_data: dict = None,
        reader_path: str = None,
        reload_project_libraries: bool = False
) -> ExecutionResult:
    """
    Opens, executes and closes a Cauldron project in a single command in
    production mode (non-interactive).

    :param project_directory:
        Directory where the project to run is located
    :param output_directory:
        Directory where the project display data will be saved
    :param log_path:
        Path to a file or directory where logging information will be
        written
    :param shared_data:
        Data to load into the cauldron.shared object prior to executing the
        project
    :param reader_path:
        Specifies a path where a reader file will be saved after the project
        has finished running. If no path is specified, no reader file will be
        saved. If the path is a directory, a reader file will be saved in that
        directory with the project name as the file name.
    :param reload_project_libraries:
        Whether or not to reload all project libraries prior to execution of
        the project. By default this is False, but can be enabled in cases
        where refreshing the project libraries before execution is needed.
    :return:
        The response result from the project execution
    """
    log_path = initialize_logging_path(log_path)
    logger.add_output_path(log_path)

    def on_complete(
            command_response: environ.Response,
            project_data: SharedCache = None,
            message: str = None
    ) -> ExecutionResult:
        environ.modes.remove(environ.modes.SINGLE_RUN)
        if message:
            logger.log(message)
        logger.remove_output_path(log_path)
        return ExecutionResult(
            command_response=command_response,
            project_data=project_data or SharedCache()
        )

    environ.modes.add(environ.modes.SINGLE_RUN)

    open_response = open_command.execute(
        context=cli.make_command_context(open_command.NAME),
        path=project_directory,
        results_path=output_directory
    )
    if open_response.failed:
        return on_complete(
            command_response=open_response,
            message='[ERROR]: Aborted trying to open project'
        )

    project = cauldron.project.get_internal_project()
    project.shared.put(**(shared_data if shared_data is not None else dict()))

    commander.preload()
    run_response = run_command.execute(
        context=cli.make_command_context(run_command.NAME),
        skip_library_reload=not reload_project_libraries
    )

    project_cache = SharedCache().put(
        **project.shared._shared_cache_data
    )

    if run_response.failed:
        return on_complete(
            command_response=run_response,
            project_data=project_cache,
            message='[ERROR]: Aborted trying to run project steps'
        )

    if reader_path:
        save_command.execute(
            context=cli.make_command_context(save_command.NAME),
            path=reader_path
        )

    close_response = close_command.execute(
        context=cli.make_command_context(close_command.NAME)
    )
    if close_response.failed:
        return on_complete(
            command_response=close_response,
            project_data=project_cache,
            message='[ERROR]: Failed to close project cleanly after run'
        )

    return on_complete(
        command_response=run_response,
        project_data=project_cache,
        message='Project execution complete'
    )
Opens, executes and closes a Cauldron project in a single command in
    production mode (non-interactive).

    :param project_directory:
        Directory where the project to run is located
    :param output_directory:
        Directory where the project display data will be saved
    :param log_path:
        Path to a file or directory where logging information will be
        written
    :param shared_data:
        Data to load into the cauldron.shared object prior to executing the
        project
    :param reader_path:
        Specifies a path where a reader file will be saved after the project
        has finished running. If no path is specified, no reader file will be
        saved. If the path is a directory, a reader file will be saved in that
        directory with the project name as the file name.
    :param reload_project_libraries:
        Whether or not to reload all project libraries prior to execution of
        the project. By default this is False, but can be enabled in cases
        where refreshing the project libraries before execution is needed.
    :return:
        The response result from the project execution