def init():
from rodio.internals.parther import getTransformer
from rodio import EventLoop, printfromprocess
tx = getTransformer(__file__)
printfromprocess("__main__.py init")
process = EventLoop("MainEventLoop", self_pause=False, shared_queue=False)
process.load_module(tx('./mainmod.py'), block=True)
process.terminate()
printfromprocess("__main__.py end")
def buildEventLoop(count):
if is_within_loop():
parent = get_running_loop()
printfromprocess(
f"_is_directly_contained: {parent._is_directly_nested}")
if count == 10:
return
process = EventLoop(f'process:{count}')
process.nextTick(buildEventLoop, count + 1)
process.scheduleExit()
import asyncio
from rodio import EventLoop
process = EventLoop(block=False)
async def asyncfun1():
print('asuncfun1 waiting 2 secs')
await asyncio.sleep(2)
print('asuncfun1 done waiting !')
async def asyncfun2():
print('asuncfun2 waiting 2 secs')
await asyncio.sleep(2)
print('asuncfun2 done waiting !')
def queueAsyncFns():
process.nextTick([asyncfun1, asyncfun2])
def actingfunction():
print("helloworld")
process.nextTick([queueAsyncFns, lambda: process.scheduleExit()])
print("before start")
process.nextTick(actingfunction)
print("after start")
from rodio.internals.parther import getTransformer
from rodio import get_running_loop, EventLoop, is_within_loop, printfromprocess
tx = getTransformer(__file__)
printfromprocess("mainmod.py init")
process1 = EventLoop(f"process1", self_pause=False, shared_queue=False)
process2 = EventLoop(f"process2", self_pause=False, shared_queue=False)
module1 = process1.load_module(tx('./module01.py'))
module2 = process2.load_module(tx('./module02.py'))
module1.on('complete', lambda process: (process.kill()
if not process.ended() else None))
module2.on('complete', lambda process: (process.kill()
if not process.ended() else None))
process1.join()
process2.join()
printfromprocess("mainmod.py exit")
import time
from rodio import EventLoop, get_current_loop, printfromprocess
def decoy():
loop = get_current_loop()
printfromprocess("heyyo from decoy")
printfromprocess("sleeping for 2 secs...")
time.sleep(2)
printfromprocess("quiting after 3 secs...")
time.sleep(3)
loop.scheduleExit()
printfromprocess("main init")
with EventLoop(block=True) as loop:
loop.nextTick(lambda: printfromprocess("hello"))
loop.nextTick(lambda: printfromprocess("world"))
loop.nextTick(decoy)
printfromprocess("main exit")
def main():
process = EventLoop(self_pause=False, shared_queue=False)
module = process.load_module(sys.argv[1], block=True)
process.terminate()
import time
from rodio import EventLoop, get_current_loop, printfromprocess
def decoy():
loop = get_current_loop()
printfromprocess("heyyo from decoy")
printfromprocess("sleeping for 2 secs...")
time.sleep(2)
printfromprocess("quiting after 3 secs...")
time.sleep(3)
loop.scheduleExit()
printfromprocess("main init")
with EventLoop(block=False) as loop:
loop.nextTick(lambda: printfromprocess("hello"))
loop.nextTick(lambda: printfromprocess("world"))
loop.nextTick(decoy)
printfromprocess("main exit")
import asyncio
from rodio import EventLoop
process = EventLoop()
def normalfunction():
print("normalfunction from within the eventloop")
async def normalasyncfunction1():
print("normalasyncfunction1 called from within the eventloop")
async def normalasyncfunction2():
print("normalasyncfunction2 called from within the eventloop")
async def awaitingasyncfunction1():
print('awaitingasyncfunction1 will wait for 2 seconds')
await asyncio.sleep(2)
print('awaitingasyncfunction1 done waiting for 2 seconds')
async def awaitingasyncfunction2():
print('awaitingasyncfunction2 will wait for 2 seconds')
await asyncio.sleep(2)
print('awaitingasyncfunction2 done waiting for 2 seconds')
print("=====================================================")
import threading
from rodio import EventLoop, get_current_thread
process = EventLoop()
process.start()
def queuedFn(name):
print(f"hello from queued function by {name}")
def queueDecoy():
thread = get_current_thread()
print(f"queue from {thread.name}")
process.nextTick(queuedFn, thread.name)
threads = []
for i in range(10):
thread = threading.Thread(name=f"thread{i}", target=queueDecoy)
thread.start()
threads.append(thread)
[thread.join() for thread in threads]
process.scheduleExit()