126 lines
3.6 KiB
Python
126 lines
3.6 KiB
Python
"""
|
|
aiosched: Yet another Python async scheduler
|
|
|
|
Copyright (C) 2022 nocturn9x
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
https:www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
"""
|
|
|
|
import inspect
|
|
from threading import local
|
|
from timeit import default_timer
|
|
from aiosched.kernel import FIFOKernel
|
|
from aiosched.errors import SchedulerError
|
|
from aiosched.util.debugging import BaseDebugger
|
|
from typing import Coroutine, Callable, Any
|
|
from aiosched.context import TaskPool, TaskScope
|
|
|
|
|
|
local_storage = local()
|
|
|
|
|
|
def get_event_loop():
|
|
"""
|
|
Returns the event loop associated to the current
|
|
thread
|
|
"""
|
|
|
|
try:
|
|
return local_storage.loop
|
|
except AttributeError:
|
|
raise SchedulerError("loop is not running") from None
|
|
|
|
|
|
def new_event_loop(clock_function: Callable, debugger: BaseDebugger | None = None):
|
|
"""
|
|
Associates a new event loop to the current thread
|
|
and deactivates the old one. This should not be
|
|
called explicitly unless you know what you're doing.
|
|
If an event loop is currently set, and it is running,
|
|
a SchedulerError exception is raised
|
|
"""
|
|
|
|
try:
|
|
loop = get_event_loop()
|
|
except SchedulerError:
|
|
local_storage.loop = FIFOKernel(clock_function, debugger)
|
|
else:
|
|
if not loop.done():
|
|
raise SchedulerError("cannot change event loop while running")
|
|
else:
|
|
loop.close()
|
|
local_storage.loop = FIFOKernel(clock_function, debugger)
|
|
|
|
|
|
def run(func: Callable[[Any, Any], Coroutine[Any, Any, Any]], *args, **kwargs):
|
|
"""
|
|
Starts the event loop from a synchronous entry point
|
|
"""
|
|
|
|
if inspect.iscoroutine(func):
|
|
raise SchedulerError(
|
|
"Looks like you tried to call aiosched.run(your_func(arg1, arg2, ...)), that is wrong!"
|
|
"\nWhat you wanna do, instead, is this: aiosched.run(your_func, arg1, arg2, ...)"
|
|
)
|
|
elif not inspect.iscoroutinefunction(func):
|
|
raise SchedulerError("aiosched.run() requires an async function as parameter!")
|
|
clock_function = default_timer
|
|
debugger = None
|
|
if "clock_function" in kwargs:
|
|
clock_function = kwargs.pop("clock_function")
|
|
if "debugger" in kwargs:
|
|
debugger = kwargs.pop("debugger")
|
|
new_event_loop(clock_function, debugger)
|
|
return get_event_loop().start(func, *args, **kwargs)
|
|
|
|
|
|
def create_pool(*args, **kwargs) -> TaskPool:
|
|
"""
|
|
Creates and returns a new TaskPool
|
|
object. All positional and keyword arguments
|
|
are passed to the TaskPool constructor
|
|
"""
|
|
|
|
return TaskPool(*args, **kwargs)
|
|
|
|
|
|
def with_timeout(timeout: int | float) -> TaskScope:
|
|
"""
|
|
Returns a new task scope with the
|
|
specified timeout. A TimeoutError
|
|
exception is raised if the timeout
|
|
expires
|
|
"""
|
|
|
|
return TaskScope(timeout=timeout)
|
|
|
|
|
|
def skip_after(timeout: int | float) -> TaskScope:
|
|
"""
|
|
Returns a new task scope with the specified
|
|
timeout. No exception is raised if the timeout
|
|
expires, but the timed_out attribute of the scope
|
|
is set accordingly
|
|
"""
|
|
|
|
return TaskScope(timeout=timeout, silent=True)
|
|
|
|
|
|
def clock() -> float:
|
|
"""
|
|
Returns the current clock time of the thread-local event
|
|
loop
|
|
"""
|
|
|
|
return get_event_loop().clock()
|