Python相当于TaskCompletionSource的情况 <T> （。净）？

Question

I am trying to implement the following pseudo-code (partly inspired from what would be possible with the TaskCompletionSource<T> in .NET), where the objective is to wait for a particular event to be received to continue execution (or throw a TimeoutError ):

from axel import Event

def _wait_for_provider_up(self, data_provider: Provider, ms_timeout: int) -> bool:
    if provider.State == ProviderState.Connected: return True
    if provider.State == ProviderState.Faulted: return False
    taskCompletion = TaskCompletionSource<bool>()

    def onStateChanged(sender, e: ProviderStateChangedEventArgs):
        if e.State == ProviderState.Connected:
            taskCompletion.TrySetResult(True)
        elif e.State == ProviderState.Faulted:
            taskCompletion.TrySetResult(False)

    provider.StateChanged += onStateChanged
    try:
        if provider.State == ProviderState.Connected: return True
        elif provider.State == ProviderState.Faulted: return False
        if not taskCompletion.Task.Wait(ms_timeout) or not taskCompletion.Task.Result or provider.State != ProviderState.Connected:
            return False
    finally:
        provider.StateChanged -= onStateChanged
    return True

What would be a recommended pythonic (or .NET-ish but python-compatible) way to achieve that?

Answer 1

I've tried to rewrite your code in asyncio way but please pay attention: function _wait_for_provider_up has been changed to coroutine :

from axel import Event

async def _wait_for_provider_up(self, data_provider: Provider, ms_timeout: int) -> bool:
    if provider.State == ProviderState.Connected: 
        return True
    if provider.State == ProviderState.Faulted: 
        return False
    taskCompletion = asyncio.Future()

    def onStateChanged(sender, e: ProviderStateChangedEventArgs):
        if e.State == ProviderState.Connected:
            taskCompletion.set_result(True)
        elif e.State == ProviderState.Faulted:
            taskCompletion.set_result(False)

    provider.StateChanged += onStateChanged
    try:
        if provider.State == ProviderState.Connected: 
            return True
        elif provider.State == ProviderState.Faulted: 
            return False
        try:
            result = await asyncio.wait_for(taskCompletion, timeout=ms_timeout/1000)
            if not result or provider.State != ProviderState.Connected:
                return False
        except asyncio.TimeoutError:
            return False  
    finally:
        provider.StateChanged -= onStateChanged
    return True

The code is still not very pythonic but I hope you'll get my point.

Answer 2

The python equivalent is asyncio.Future .

import asyncio
source = asyncio.Future()

async def await_concat(x):
    return x + await source


async def set_after_two_seconds():
    print("READY")
    await asyncio.sleep(2)
    print("SET")
    source.set_result("GO")

print(asyncio.get_event_loop().run_until_complete(asyncio.gather(
    await_concat("PASS "),
    set_after_two_seconds(),
)))

## prints
# READY
## (note: two second pause here)
# SET
# ['PASS GO', None]

Answer 3

Assuming the provider is a python thread. You can use the join(timeout) method which waits for the thread to compete or the timeout. join() always returns None so to check if the thread is still alive you need to use isAlive(). Here is one option in implementing the taskCompletion

def taskCompletion(thread,timeout): 
   thread.join(timeout) 
   return isAlive()