def emit_after(
self,
delay: float,
name: str,
args: tuple = (),
kwargs: dict = None,
loop: asyncio.AbstractEventLoop = None,
retries: int = None,
):
"""
Emit an event after a given period of time.
:param delay: a float of the time (in seconds) you want to delay the call
:param name: event name
:param args: additional event arguments
:param kwargs: addition event keyword arguments
:param loop: asyncio event loop from which you want the event to be emitted
"""
# event = self._events.get(name)
loop = loop or self.loop
assert loop.is_running()
loop.call_later(delay,
self.emit,
name,
args=args,
kwargs=kwargs,
retries=retries,
loop=loop)
async def start_server(loop: asyncio.AbstractEventLoop):
server = Server()
await server.init()
server.set_endpoint("opc.tcp://0.0.0.0:4840/freeopcua/server/")
# setup our own namespace, not really necessary but should as spec
uri = "http://examples.freeopcua.github.io"
idx = await server.register_namespace(uri)
# get Objects node, this is where we should put our custom stuff
objects = server.get_objects_node()
# populating our address space
myobj = await objects.add_object(idx, "MyObject")
# Creating a custom event: Approach 1
# The custom event object automatically will have members from its parent (BaseEventType)
etype = await server.create_custom_event_type(
idx, 'MyFirstEvent', ua.ObjectIds.BaseEventType,
[('MyNumericProperty', ua.VariantType.Float),
('MyStringProperty', ua.VariantType.String)])
myevgen = await server.get_event_generator(etype, myobj)
# Creating a custom event: Approach 2
custom_etype = await server.nodes.base_event_type.add_object_type(
2, 'MySecondEvent')
await custom_etype.add_property(2, 'MyIntProperty',
ua.Variant(0, ua.VariantType.Int32))
await custom_etype.add_property(2, 'MyBoolProperty',
ua.Variant(True, ua.VariantType.Boolean))
mysecondevgen = await server.get_event_generator(custom_etype, myobj)
await server.start()
loop.call_later(2, emmit_event, loop, myevgen, mysecondevgen, 1)
def emmit_event(loop: asyncio.AbstractEventLoop, myevgen: EventGenerator, mysecondevgen: EventGenerator, count: int):
myevgen.event.Message = ua.LocalizedText("MyFirstEvent %d" % count)
myevgen.event.Severity = count
myevgen.event.MyNumericProperty = count
myevgen.event.MyStringProperty = "Property %d" % count
myevgen.trigger()
mysecondevgen.trigger(message="MySecondEvent %d" % count)
count += 1
loop.call_later(2, emmit_event, loop, myevgen, mysecondevgen, count)
async def main(loop: asyncio.AbstractEventLoop):
# 공유 이벤트 생성
event = asyncio.Event()
print(f"event start state: {event.is_set()}")
loop.call_later(0.1, functools.partial(set_event, event))
await asyncio.wait([coro1(event), coro2(event)])
print(f"event end state: {event.is_set()}")
def autostop_loop(
temp_event_loop: asyncio.AbstractEventLoop, ) -> asyncio.AbstractEventLoop:
# Create a new event loop, and arrange for that loop to end almost
# immediately. This will allow the calls to main() in these tests to
# also exit almost immediately. Otherwise, the foreground test
# process will hang.
temp_event_loop.call_later(AUTOSTOP_DELAY, temp_event_loop.stop)
#
return temp_event_loop
def update_current_time(loop: asyncio.AbstractEventLoop) -> None:
"""缓存当前时间,用于管理timeout,缓存于全局变量CURRENT_TIME.
Parameters:
loop (asyncio.AbstractEventLoop) : - 服务使用的事件循环
"""
global CURRENT_TIME
CURRENT_TIME = time()
loop.call_later(1, partial(update_current_time, loop))
def test_asyncio_run_sync_multiple(
asyncio_event_loop: asyncio.AbstractEventLoop,
) -> None:
"""Regression test for #304."""
asyncio_event_loop.call_later(0.5, asyncio_event_loop.stop)
for _ in range(3):
asyncio_event_loop.run_until_complete(to_thread.run_sync(time.sleep, 0))
for t in threading.enumerate():
if t.name == "AnyIO worker thread":
t.join(2)
assert not t.is_alive()
async def main(loop: asyncio.AbstractEventLoop):
# 공유 락의 생성과 획득
lock = asyncio.Lock()
print("acquiring the lock before starting coroutines")
await lock.acquire()
print(f"lock acquired: {lock.locked()}")
# 락을 해제하기 위한 콜백 예약
loop.call_later(0.1, functools.partial(unlock, lock))
# 락을 사용하려는 코루틴을 실행
print("waiting for coroutines")
await asyncio.wait([coro1(lock), coro2(lock)])
async def test_select(loop: asyncio.AbstractEventLoop):
f_one = asyncio.Event()
f_two = asyncio.Event()
loop.call_soon(f_one.set)
loop.call_later(1, f_two.set)
one, two = await aiomisc.select(f_one.wait(), f_two.wait())
assert one
assert two is None
one, two = await aiomisc.select(f_one.wait(), f_two.wait())
assert one
def run_forever(self, loop: asyncio.AbstractEventLoop = None):
"""
Creates an event loop and runs the server forever.
:param asyncio.AbstractEventLoop loop: the event loop to use
"""
loop = loop or asyncio.get_event_loop()
self.start_listening(loop)
def wakeup():
"""Needed for Windows to notice Ctrl-C and other signals"""
loop.call_later(0.1, wakeup)
loop.call_later(0.1, wakeup)
loop.run_forever()
def __init__(self, loop: asyncio.AbstractEventLoop,
controller: IController, market_events: MarketEvents,
frequency_limiter: FrequencyLimiter, speed: float):
"""Initialise a new instance of the ExecutionChannel class."""
self.competitor: Optional[Competitor] = None
self.controller: IController = controller
self.closing: bool = False
self.data: bytes = b""
self.event_loop: asyncio.AbstractEventLoop = loop
self.file_number: int = -1
self.frequency_limiter: FrequencyLimiter = frequency_limiter
self.logger: logging.Logger = logging.getLogger("EXECUTION")
self.login_timeout: asyncio.Handle = loop.call_later(1.0, self.close)
self.market_events: MarketEvents = market_events
self.name: Optional[str] = None
self.transport: Optional[asyncio.Transport] = None
self.speed: float = speed
self.start_time: float = 0.0
self.account_message: bytearray = bytearray(
POSITION_CHANGE_MESSAGE_SIZE)
self.error_message: bytearray = bytearray(ERROR_MESSAGE_SIZE)
self.order_message: bytearray = bytearray(ORDER_STATUS_MESSAGE_SIZE)
HEADER.pack_into(self.error_message, 0, ERROR_MESSAGE_SIZE,
MessageType.ERROR)
HEADER.pack_into(self.account_message, 0, POSITION_CHANGE_MESSAGE_SIZE,
MessageType.POSITION_CHANGE)
HEADER.pack_into(self.order_message, 0, ORDER_STATUS_MESSAGE_SIZE,
MessageType.ORDER_STATUS)
def __init__(self, dt: datetime.datetime, *,
loop: asyncio.AbstractEventLoop) -> None:
self.loop: asyncio.AbstractEventLoop = loop
self.future: asyncio.Future[None] = loop.create_future()
relative_delta = discord.utils.compute_timedelta(dt)
self.handle = loop.call_later(relative_delta, self.future.set_result,
True)
def _handle(self, loop: asyncio.AbstractEventLoop, delay: float,
event: Event, event_simulator: EventSimulator):
delayed_handler = DelayedHandler()
self.handlers.add(delayed_handler)
loop = loop or asyncio.get_event_loop()
timer_handler = loop.call_later(delay, delayed_handler)
delayed_handler.event = event
delayed_handler.event_simulator = event_simulator
delayed_handler.timer_handler = timer_handler
delayed_handler.handlers = self.handlers
async def _wait(self, fs, return_when=FIRST_COMPLETED, *, add:bool=False, loop:AbstractEventLoop=None,
timeout:int=None):
"""A modified version of _wait in asyncio.
The fs argument must be a collection of Futures.
"""
if(not len(fs)): return [], self.pending
timeout_handle = None
if(loop is None):
loop = self.loop
if timeout is not None:
timeout_handle = loop.call_later(timeout, _release_waiter, self.waiter)
if(add):
self.counter += len(fs)
else:
self.counter = len(fs)
def __on_completion(f):
self.counter -= 1
if (self.counter <= 0 or
return_when == FIRST_COMPLETED or
return_when == FIRST_EXCEPTION and (not f.cancelled() and
f.exception() is not None)):
if timeout_handle is not None:
timeout_handle.cancel()
if not self.waiter.done():
self.waiter.set_result(None)
for f in fs:
f.add_done_callback(__on_completion)
try:
await self.waiter
finally:
if timeout_handle is not None:
timeout_handle.cancel()
for f in fs:
f.remove_done_callback(__on_completion)
if(not add):
done, pending = set(), set()
for f in fs:
if f.done():
done.add(f)
else:
pending.add(f)
return done, pending
def future_with_timeout(loop: asyncio.AbstractEventLoop,
timeout: Union[int, float],
future: asyncio.Future=None) -> asyncio.Future:
loop = loop or asyncio.get_event_loop()
f = future or create_future(loop=loop)
def on_timeout():
if f.done():
return
f.set_exception(asyncio.TimeoutError)
if timeout:
handler = loop.call_later(timeout, on_timeout)
def on_result(*_):
with suppress(Exception):
handler.cancel()
f.add_done_callback(on_result)
return f
def run_reboot_loop(loop: asyncio.AbstractEventLoop):
"""
Run the bot, and re-run it if it fails or disconnects. The bot will still stop if an error
bubbles outside the event loop, in the case that KeyboardInterrupt is raised (Ctrl+C/SIGINT),
or that sys.exit() is called.
"""
def reset_backoff(backoff: Backoff, sequence):
if sequence == backoff.n: # don't do it if we had a retry in the meantime
backoff.reset()
logger.info("Welcome to KazTron v{}, booting up...".format(kaztron.__version__))
# noinspection PyBroadException
try:
bo_timer = Backoff(initial_time=3.0, base=1.58, max_attempts=12)
wait_time = 0
while True:
reset_task = loop.call_later(wait_time, reset_backoff, bo_timer, bo_timer.n)
run(loop)
logger.error("Bot halted unexpectedly.")
reset_task.cancel()
wait_time = bo_timer.next()
logger.info("Restarting bot in {:.1f} seconds...".format(wait_time))
time.sleep(wait_time)
logger.info("Restarting bot...")
except StopIteration:
logger.error("Too many failed attempts. Exiting.")
sys.exit(ErrorCodes.RETRY_MAX_ATTEMPTS)
except KeyboardInterrupt: # outside of runner.run
logger.info("Interrupted by user. Exiting.")
except Exception:
logger.exception("Exception in reboot loop.")
raise
finally:
logger.info("Exiting.")
loop.close()
def __init__(self, loop: asyncio.AbstractEventLoop,
competitor_manager: CompetitorManager,
frequency_limiter: FrequencyLimiter, timer: Timer):
"""Initialise a new instance of the ExecutionChannel class."""
Connection.__init__(self)
self.competitor: Optional[Competitor] = None
self.competitor_manager: CompetitorManager = competitor_manager
self.closing: bool = False
self.frequency_limiter: FrequencyLimiter = frequency_limiter
self.logger: logging.Logger = logging.getLogger("EXECUTION")
self.login_timeout: asyncio.Handle = loop.call_later(1.0, self.close)
self.timer: Timer = timer
self.__error_message = bytearray(ERROR_MESSAGE_SIZE)
self.__order_status_message = bytearray(ORDER_STATUS_MESSAGE_SIZE)
self.__order_filled_message = bytearray(ORDER_FILLED_MESSAGE_SIZE)
HEADER.pack_into(self.__error_message, 0, ERROR_MESSAGE_SIZE,
MessageType.ERROR)
HEADER.pack_into(self.__order_status_message, 0,
ORDER_STATUS_MESSAGE_SIZE, MessageType.ORDER_STATUS)
HEADER.pack_into(self.__order_filled_message, 0,
ORDER_FILLED_MESSAGE_SIZE, MessageType.ORDER_FILLED)
def trampoline(loop: AbstractEventLoop, name: str = "") -> None:
print(name, end=" ")
print_now()
loop.call_later(random.random(), trampoline, loop, name)
loop.call_later(random.random(), trampoline, loop, name)
def update_screen(self, end_time, loop: asyncio.AbstractEventLoop, screen: Screen):
screen.draw_next_frame()
if loop.time() < end_time:
loop.call_later(0.05, self.update_screen, end_time, loop, screen)
else:
loop.stop()
def _wakeup(loop: asyncio.AbstractEventLoop,
delay: float = 1.0) -> None:
loop.call_later(delay, _wakeup, loop, delay)