import sys
import threading
import asyncio
import concurrent.futures
import warnings


async def acreate_process_then_sleep(started_event, stop_event):
    event = asyncio.Event()

    async def create_process():
        loop = asyncio.get_running_loop()
        loop.call_soon(event.set)
        proc = await asyncio.create_subprocess_exec(
            sys.executable,
            "-c",
            "print('hello')",
            stdin=None,
            stdout=asyncio.subprocess.PIPE,
            stderr=asyncio.subprocess.STDOUT,
        )
        await proc.communicate()

    async def sleep():
        await event.wait()
        started_event.set()
        stop_event.wait()

    await asyncio.gather(create_process(), sleep())


def create_process_then_sleep(*args, **kwargs):
    asyncio.run(acreate_process_then_sleep(*args, **kwargs))


def main():
    with concurrent.futures.ThreadPoolExecutor() as tpe:
        stop_event = threading.Event()
        started_event = threading.Event()
        warnings.warn("demo warning", DeprecationWarning)
        fut = tpe.submit(
            create_process_then_sleep,
            started_event=started_event,
            stop_event=stop_event,
        )
        try:
            started_event.wait()
            warnings.warn("demo warning2", DeprecationWarning)
        finally:
            stop_event.set()
            fut.result()


if __name__ == "__main__":
    sys.exit(main())