a 4j*@sxdZddlmZddlZddlmZzddlZdZWneyJdZYn0d ddZ e Z Gd d d e Z dd d Z dS)a8 This module provides functionality to support "async steps" (coroutines) in a step-module with behave. This functionality simplifies to test frameworks and protocols that make use of `asyncio.coroutines`_ or provide `asyncio.coroutines`_. EXAMPLE: .. code-block:: python # -- FILE: features/steps/my_async_steps.py # EXAMPLE REQUIRES: Python >= 3.5 from behave import step from behave.api.async_step import async_run_until_complete @step('an async coroutine step waits {duration:f} seconds') @async_run_until_complete async def step_async_step_waits_seconds(context, duration): await asyncio.sleep(duration) .. code-block:: python # -- FILE: features/steps/my_async_steps2.py # EXAMPLE REQUIRES: Python >= 3.4 from behave import step from behave.api.async_step import async_run_until_complete import asyncio @step('a tagged-coroutine async step waits {duration:f} seconds') @async_run_until_complete @asyncio.coroutine def step_async_step_waits_seconds2(context, duration): yield from asyncio.sleep(duration) .. requires:: Python 3.5 (or 3.4) or :mod:`asyncio` backport (like :pypi:`trollius`) .. seealso:: https://docs.python.org/3/library/asyncio.html .. _asyncio.coroutines: https://docs.python.org/3/library/asyncio-task.html#coroutines )print_functionN) string_typesTFcs^tdddur2fdd}|Sts>Jtfdd}|SdS)aProvides a function decorator for async-steps (coroutines). Provides an async event loop and runs the async-step until completion (or timeout, if specified). .. code-block:: python from behave import step from behave.api.async_step import async_run_until_complete import asyncio @step("an async step is executed") @async_run_until_complete async def astep_impl(context) await asycio.sleep(0.1) @step("an async step is executed") @async_run_until_complete(timeout=1.2) async def astep_impl2(context) # -- NOTE: Wrapped event loop waits with timeout=1.2 seconds. await asycio.sleep(0.3) Parameters: astep_func: Async step function (coroutine) loop (asyncio.EventLoop): Event loop to use or None. timeout (int, float): Timeout to wait for async-step completion. async_context (name): Async_context name or object to use. should_close (bool): Indicates if event lopp should be closed. .. note:: * If :param:`loop` is None, the default event loop will be used or a new event loop is created. * If :param:`timeout` is provided, the event loop waits only the specified time. * :param:`async_context` is only used, if :param:`loop` is None. * If :param:`async_context` is a name, it will be used to retrieve the real async_context object from the context. c _s:|dd}|dd}|dd}|dd}t|trHt||d}n8|rt|trl|}t||}|j}nt|tszJ|j}|durtpt }z|dur| ||g|Ri|nH| ||g|Ri|} | tj | g|d\} } | rJd|W|r6|r6| n|r4|r4| 0dS)N_loop_timeout_async_context _should_close)timeoutzTIMEOUT-OCCURED: timeout=%s)pop isinstancergetattruse_or_create_async_contextloop AsyncContextasyncioget_event_loopnew_event_looprun_until_completeZ create_taskwaitclose) astep_funccontextargskwargsr r async_context should_closenametaskdonependingr;E:\soccer\ml_env\Lib\site-packages\behave/api/async_step.pystep_decoratores6         z0async_run_until_complete..step_decoratorNcs0tfdd}ts,J|S)Ncs"|g|Rd|S)N)rrrrrrrrrrr rr!rrr wrapped_decorator2szPasync_run_until_complete..wrapped_decorator1..wrapped_decorator2 functoolswrapscallable)rr$)rr rr!r)rr wrapped_decorator1s z4async_run_until_complete..wrapped_decorator1cs|g|Ri|SNrr")rr!rr wrapped_decoratorsz3async_run_until_complete..wrapped_decoratorr%)rr rrrr)r+rr#r async_run_until_complete<s) #  r,c@s.eZdZdZdZd ddZddZd d ZdS) ra/Provides a context object for "async steps" to keep track: * which event loop is used * which (asyncio) tasks are used or of interest .. attribute:: loop Event loop object to use. If none is provided, the current event-loop is used (or a new one is created). .. attribute:: tasks List of started :mod:`asyncio` tasks (of interest). .. attribute:: name Optional name of this object (in the behave context). If none is provided, :attr:`AsyncContext.default_name` is used. .. attribute:: should_close Indicates if the :attr:`loop` (event-loop) should be closed or not. EXAMPLE: .. code-block:: python # -- FILE: features/steps/my_async_steps.py # REQUIRES: Python 3.5 from behave import given, when, then, step from behave.api.async_step import AsyncContext @when('I dispatch an async-call with param "{param}"') def step_impl(context, param): async_context = getattr(context, "async_context", None) if async_context is None: async_context = context.async_context = AsyncContext() task = async_context.loop.create_task(my_async_func(param)) async_context.tasks.append(task) @then('I wait at most {duration:f} seconds until all async-calls are completed') def step_impl(context, duration): async_context = context.async_context assert async_context.tasks done, pending = async_context.loop.run_until_complete(asyncio.wait( async_context.tasks, loop=async_context.loop, timeout=duration)) assert len(pending) == 0 # -- COROUTINE: async def my_async_func(param): await asyncio.sleep(0.5) return param.upper() rNFcCs6|ptpt|_|pg|_|p(|j|_||_dSr*)rrrr tasks default_namerr)selfr rrr-rrr __init__s  zAsyncContext.__init__cCs|jr|jr|dSr*)r rrr/rrr __del__s zAsyncContext.__del__cCs$|jr |js |jd|_dSr*)r Z is_closedrr1rrr rs zAsyncContext.close)NNFN)__name__ __module__ __qualname____doc__r.r0r2rrrrr rs 4 rcKsj|durtj}t||d}|durDtf||d|}t||j|t|tsRJt||j|usfJ|S)aXUtility function to be used in step implementations to ensure that an :class:`AsyncContext` object is stored in the :param:`context` object. If no such attribute exists (under the given name), a new :class:`AsyncContext` object is created with the provided args. Otherwise, the existing context attribute is used. EXAMPLE: .. code-block:: python # -- FILE: features/steps/my_async_steps.py # EXAMPLE REQUIRES: Python 3.5 from behave import when from behave.api.async_step import use_or_create_async_context @when('I dispatch an async-call with param "{param}"') def step_impl(context, param): async_context = use_or_create_async_context(context, "async_context") task = async_context.loop.create_task(my_async_func(param)) async_context.tasks.append(task) # -- COROUTINE: async def my_async_func(param): await asyncio.sleep(0.5) return param.upper() :param context: Behave context object to use. :param name: Optional name of async-context object (as string or None). :param loop: Optional event_loop object to use for create call. :param kwargs: Optional :class:`AsyncContext` params for create call. :return: :class:`AsyncContext` object from the param:`context`. N)r r)rr.r setattrrr )rrr rrrrr r s" r )NNNNF)NN)r6 __future__rr&sixrrZ has_asyncio ImportErrorr,robjectrr rrrr s+     eK