def launch(self):
if os.name == 'nt':
# Windows needs a custom event loop to use subprocess transport
loop = asyncio.ProactorEventLoop()
else:
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
returncode = loop.run_until_complete(self._run())
loop.close()
if os.name != 'nt':
# the watcher must be reset otherwise a repeated invocation fails inside asyncio
asyncio.get_event_loop_policy().set_child_watcher(None)
return returncode
def __init__(self, max_workers: int = 1, loop: asyncio.AbstractEventLoop = None, debug=False):
if not max_workers or not isinstance(max_workers, int) or max_workers < 1:
raise TypeError("Expect integer greater than 0")
if loop is None:
loop = asyncio.get_event_loop_policy().get_event_loop()
if not isinstance(loop, asyncio.AbstractEventLoop):
raise TypeError("Must provide an EventLoop")
self._loop = loop
self._current_workers = 0
self._max_workers = max_workers
self._futures_to_wait = dict()
self._debug = debug
self._pending_queue = collections.deque()
self._shutdowned = False
self._waiter = asyncio.Condition(loop=self._loop)
if self._debug:
async def _thread_monitor():
try:
while True:
if self._current_workers > 0:
print("Current tasks: %d" % self._current_workers)
await asyncio.sleep(1, loop=self._loop)
except asyncio.CancelledError:
print("All tasks are done! [%d]" % self._current_workers)
self._futures_to_wait["thread_monitor"] = asyncio.ensure_future(_thread_monitor(), loop=self._loop)
def __init__(self, work_queue, result_queue):
self.WORK_QUEUE = work_queue
self.RESULT_QUEUE = result_queue
policy = asyncio.get_event_loop_policy()
policy.set_event_loop(policy.new_event_loop())
self.LOOP = asyncio.get_event_loop()
super().__init__()
def setUp(self):
# Trigger a cleanup of the mapping so we start with a clean slate.
AsyncIOLoop().close()
# If we don't clean up after ourselves other tests may fail on
# py34.
self.orig_policy = asyncio.get_event_loop_policy()
asyncio.set_event_loop_policy(asyncio.DefaultEventLoopPolicy())
def setUp(self):
policy = asyncio.get_event_loop_policy()
policy.get_event_loop().close()
self.event_loop = policy.new_event_loop()
policy.set_event_loop(self.event_loop)
super().setUp()
def get_identity(*args, **kwargs):
return copy.deepcopy({
'auth': {},
'credentials': {},
'settings': {},
'callback_url': 'example.com'
})
self.mock_identity = MockCoroutine(side_effect=get_identity)
# self.mock_identity.return_value = identity_future
self.identity_patcher = mock.patch('waterbutler.server.api.v0.core.auth_handler.fetch', self.mock_identity)
self.mock_provider = MockProvider1({}, {}, {})
self.mock_make_provider = mock.Mock(return_value=self.mock_provider)
self.make_provider_patcher = mock.patch('waterbutler.core.utils.make_provider', self.mock_make_provider)
if hasattr(self, 'HOOK_PATH'):
self.mock_send_hook = mock.Mock()
self.send_hook_patcher = mock.patch(self.HOOK_PATH, self.mock_send_hook)
self.send_hook_patcher.start()
self.identity_patcher.start()
self.make_provider_patcher.start()
def pytest_pyfunc_call(pyfuncitem):
"""
Run asyncio marked test functions in an event loop instead of a normal
function call.
"""
for marker_name, fixture_name in _markers_2_fixtures.items():
if marker_name in pyfuncitem.keywords:
event_loop = pyfuncitem.funcargs[fixture_name]
forbid_global_loop = pyfuncitem.keywords[marker_name].kwargs.get('forbid_global_loop')
policy = asyncio.get_event_loop_policy()
if forbid_global_loop:
asyncio.set_event_loop_policy(ForbiddenEventLoopPolicy())
else:
policy.set_event_loop(event_loop)
funcargs = pyfuncitem.funcargs
testargs = {arg: funcargs[arg]
for arg in pyfuncitem._fixtureinfo.argnames}
try:
event_loop.run_until_complete(
asyncio.async(pyfuncitem.obj(**testargs), loop=event_loop))
finally:
if forbid_global_loop:
asyncio.set_event_loop_policy(policy)
event_loop.close()
return True
def run(args):
"""Handle ensure configuration commandline script."""
# Disable logging
logging.getLogger('homeassistant.core').setLevel(logging.CRITICAL)
parser = argparse.ArgumentParser(
description=("Run a Home Assistant benchmark."))
parser.add_argument('name', choices=BENCHMARKS)
parser.add_argument('--script', choices=['benchmark'])
args = parser.parse_args()
bench = BENCHMARKS[args.name]
print('Using event loop:', asyncio.get_event_loop_policy().__module__)
with suppress(KeyboardInterrupt):
while True:
loop = asyncio.new_event_loop()
hass = core.HomeAssistant(loop)
hass.async_stop_track_tasks()
runtime = loop.run_until_complete(bench(hass))
print('Benchmark {} done in {}s'.format(bench.__name__, runtime))
loop.run_until_complete(hass.async_stop())
loop.close()
return 0
def event_loop():
policy = asyncio.get_event_loop_policy()
res = policy.new_event_loop()
_close = res.close
res.close = lambda: None
yield res
_close()
def tearDown(self):
policy = asyncio.get_event_loop_policy()
if policy.loop is not None:
self.assertTrue(policy.loop.is_closed())
self.assertTrue(policy.loop.shutdown_ag_run)
asyncio.set_event_loop_policy(None)
super().tearDown()
def _io_event_loop_thread(self):
"""Worker thread for running the I/O event loop"""
io_event_loop = asyncio.get_event_loop_policy().new_event_loop()
asyncio.set_event_loop(io_event_loop)
assert isinstance(io_event_loop, AbstractEventLoop)
self._io_event_loop = io_event_loop
self._event_loop_started.release()
self._io_event_loop.run_forever()
def _unset_loop(self):
policy = asyncio.get_event_loop_policy()
if not self.use_default_loop:
self.loop.close()
policy.reset_watcher()
asyncio.set_event_loop_policy(policy.original_policy)
self.loop = None
def setUp(self):
policy = asyncio.get_event_loop_policy()
self.loop = policy.new_event_loop()
self.set_event_loop(self.loop)
watcher = self.Watcher()
watcher.attach_loop(self.loop)
policy.set_child_watcher(watcher)
self.addCleanup(policy.set_child_watcher, None)
def conn(request, event_loop):
def callback(*args):
pass
loop = asyncio.get_event_loop_policy().new_event_loop()
manager = testing.Manager(loop=loop)
manager.register_event('Peer*', callback)
return manager.protocol
def inner(**kwargs):
loop = asyncio.get_event_loop_policy().new_event_loop()
try:
coro = func(**kwargs)
if coro is not None:
future = asyncio.ensure_future(coro, loop=loop)
loop.run_until_complete(future)
finally:
loop.close()
def event_loop(request, setup_dsn):
"""
To avoid the error that a pending task is attached to a different loop,
create an instance of the default event loop for each test case.
"""
import asyncio
loop = asyncio.get_event_loop_policy().new_event_loop()
yield loop
loop.close()
def check(self, src, value):
policy = asyncio.get_event_loop_policy()
loop = policy.new_event_loop()
asyncio.set_event_loop_policy(ForbiddenEventLoopPolicy())
try:
loop.run_until_complete(self._check(src, value, loop))
finally:
loop.close()
asyncio.set_event_loop_policy(policy)
def installEventLoopExceptionHandler():
policy = asyncio.get_event_loop_policy()
factory = policy._loop_factory
class PatchedEventLoop(factory):
def __init__(self, selector= None):
super().__init__(selector)
self.set_exception_handler(_eventLoopHandler)
policy._loop_factory = PatchedEventLoop
def __init__(self, flags=None, default=None):
with MonkeyJail():
import asyncio
self.policy = asyncio.get_event_loop_policy()
self.aio = self.policy.get_event_loop()
self.error_handler = None
self.fork_watchers = set()
self._ref_count = 0
self._stop_handle = None
self.aio.set_exception_handler(self._handle_aio_error)
def setUp(self):
policy = asyncio.get_event_loop_policy()
self.loop = policy.new_event_loop()
# ensure that the event loop is passed explicitly in asyncio
policy.set_event_loop(None)
watcher = self.Watcher()
watcher.attach_loop(self.loop)
policy.set_child_watcher(watcher)
def event_loop(request):
"""
Create an instance of the default event loop.
"""
policy = asyncio.get_event_loop_policy()
policy.get_event_loop().close()
_event_loop = policy.new_event_loop()
policy.set_event_loop(_event_loop)
request.addfinalizer(_event_loop.close)
return _event_loop
def _unset_loop(self):
policy = asyncio.get_event_loop_policy()
if not self.use_default_loop:
if sys.version_info >= (3, 6):
self.loop.run_until_complete(self.loop.shutdown_asyncgens())
self.loop.close()
policy.reset_watcher()
asyncio.set_event_loop_policy(policy.original_policy)
self.loop = None
def event_loop():
"""Create an instance of the default event loop for each test case."""
policy = asyncio.get_event_loop_policy()
res = policy.new_event_loop()
asyncio.set_event_loop(res)
res._close = res.close
res.close = lambda: None
yield res
res._close()
def run(self):
policy = asyncio.get_event_loop_policy()
policy.set_event_loop(policy.new_event_loop())
loop = asyncio.get_event_loop()
asyncio.ensure_future(self._reconcile())
asyncio.ensure_future(self._start_clearing_brokerage_queue())
try:
loop.run_forever()
finally:
loop.close()
def event_loop(close: bool) -> Iterator[None]:
policy = asyncio.get_event_loop_policy()
old_loop = policy.get_event_loop()
loop = policy.new_event_loop()
asyncio.set_event_loop(loop)
try:
yield
finally:
policy.set_event_loop(old_loop)
if close:
loop.close()
def test_new_event_loop(monkeypatch, request):
"""Test that _new_event_loop returns the default event loop."""
policy = asyncio.get_event_loop_policy()
def restore_event_loop_policy():
asyncio.set_event_loop_policy(policy)
request.addfinalizer(restore_event_loop_policy)
asyncio.set_event_loop_policy(None)
event_loop = _new_event_loop()
assert isinstance(event_loop, asyncio.base_events.BaseEventLoop)
def run(self):
policy = asyncio.get_event_loop_policy()
policy.set_event_loop(policy.new_event_loop())
loop = asyncio.get_event_loop()
self._inventory_event.set()
asyncio.ensure_future(self._take_inventory())
asyncio.ensure_future(self._get_dispatch_instructions())
try:
loop.run_forever()
finally:
loop.close()
def _init_loop(self):
if self.use_default_loop:
self.loop = asyncio.get_event_loop()
loop = None
else:
loop = self.loop = asyncio.new_event_loop()
policy = _Policy(asyncio.get_event_loop_policy(),
loop, self.forbid_get_event_loop)
asyncio.set_event_loop_policy(policy)
self.loop = self._patch_loop(self.loop)
def test_proactor_win_policy(self):
async def main():
self.assertIsInstance(
asyncio.get_running_loop(),
asyncio.ProactorEventLoop)
old_policy = asyncio.get_event_loop_policy()
try:
asyncio.set_event_loop_policy(
asyncio.WindowsProactorEventLoopPolicy())
asyncio.run(main())
finally:
asyncio.set_event_loop_policy(old_policy)
def event_loop(request):
"""Create an instance of the default event loop for each test case."""
policy = asyncio.get_event_loop_policy()
policy.get_event_loop().close()
event_loop = policy.new_event_loop()
policy.set_event_loop(event_loop)
def _close():
event_loop.close()
request.addfinalizer(_close)
return event_loop
def run(self):
"""Start the main loop."""
policy = asyncio.get_event_loop_policy()
self.loop = policy.new_event_loop()
policy.set_event_loop(self.loop)
self.client = hangups.Client(self.cookies)
self.client.on_connect.add_observer(self.on_connect)
self.client.on_disconnect.add_observer(self.on_disconnect)
self.client.on_reconnect.add_observer(self.on_reconnect)
self.loop.run_until_complete(self.client.connect())
self.send_message_to_xmpp({"what": "disconnected"})
logger.info("Hangouts thread stopped.")
}],
"counties": [{
"regions": ["HH1", "HH2"]
}],
},
"singleTicketTariffLevelId":
14,
"extraFareType":
"NO",
},
})
print(sto)
print()
print("Example 17: ticketList()")
tl = await gti.ticketList({"stationKey": "Master:92903"})
print(tl)
# To avoid 'Event loop is closed' RuntimeError due to compatibility issue with aiohttp
if sys.platform.startswith("win") and sys.version_info >= (3, 8):
try:
from asyncio import WindowsSelectorEventLoopPolicy
except ImportError:
pass
else:
if not isinstance(asyncio.get_event_loop_policy(),
WindowsSelectorEventLoopPolicy):
asyncio.set_event_loop_policy(WindowsSelectorEventLoopPolicy())
asyncio.run(main())
HeaderExpectationFailed,
InvalidUsage,
PayloadTooLarge,
RequestTimeout,
ServerError,
ServiceUnavailable,
)
from sanic.log import access_logger, logger
from sanic.request import EXPECT_HEADER, Request, StreamBuffer
from sanic.response import HTTPResponse
try:
import uvloop # type: ignore
if not isinstance(asyncio.get_event_loop_policy(), uvloop.EventLoopPolicy):
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
except ImportError:
pass
OS_IS_WINDOWS = os.name == "nt"
class Signal:
stopped = False
class HttpProtocol(asyncio.Protocol):
"""
This class provides a basic HTTP implementation of the sanic framework.
"""
def setUp(self):
self.loop = asyncio.get_event_loop_policy().get_event_loop()
def create_task(awaitable: Awaitable[T]) -> asyncio.Task[T]:
loop = asyncio.get_event_loop_policy().get_event_loop()
return asyncio.ensure_future(awaitable, loop=loop)
def _check_recursion(self):
if _real_asyncio.get_event_loop_policy() is self:
raise NotImplementedError("this class is only a wrapper")
import asyncio
import sys
# this is necessary seems...
# see: https://bugs.python.org/issue34679
policy = asyncio.get_event_loop_policy()
policy._loop_factory = asyncio.SelectorEventLoop
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
def run_once():
print("run_once")
sys.stdout.flush()
loop.call_soon(loop.stop)
loop.run_forever()
async def test():
# our async task
print("Pre-Await")
sys.stdout.flush()
await asyncio.sleep(1)
print("Post-Await")
sys.stdout.flush()
task = loop.create_task(test())
def inputTypes():
LynchUserHandler, PubBrawlHandler)
from loult_serv.state import LoultServerState
if __name__ == "__main__":
argparser = argparse.ArgumentParser()
argparser.add_argument("-d", "--debug", action="store_true")
args = argparser.parse_args()
if args.debug:
logging.basicConfig(level=logging.DEBUG)
else:
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger('server')
try:
asyncio_policy = get_event_loop_policy()
import uvloop
# Make sure to set uvloop as the default before importing anything
# from autobahn else it won't use uvloop
set_event_loop_policy(uvloop.EventLoopPolicy())
logger.info("uvloop's event loop succesfully activated.")
except:
set_event_loop_policy(asyncio_policy)
logger.info(
"Failed to use uvloop, falling back to asyncio's event loop.")
finally:
from autobahn.asyncio.websocket import WebSocketServerProtocol, \
WebSocketServerFactory
loop = get_event_loop()
def loop(self) -> Optional[asyncio.AbstractEventLoop]:
if self._loop is None:
self._loop = asyncio.get_event_loop_policy().new_event_loop()
return self._loop
def setUp(self):
self.orig_policy = asyncio.get_event_loop_policy()
self.executor = ThreadPoolExecutor(1)
def event_loop() -> Iterator[asyncio.AbstractEventLoop]:
loop = asyncio.get_event_loop_policy().new_event_loop()
yield loop
loop.close()
def __call__(self, *args, **kwargs):
# You can't call AsyncToSync from a thread with a running event loop
try:
event_loop = get_running_loop()
except RuntimeError:
pass
else:
if event_loop.is_running():
raise RuntimeError(
"You cannot use AsyncToSync in the same thread as "
"an async event loop - "
"just await the async function directly.")
if contextvars is not None:
# Wrapping context in list so it can be reassigned from within
# `main_wrap`.
context = [contextvars.copy_context()]
else:
context = None
# Make a future for the return information
call_result = Future()
# Get the source thread
source_thread = threading.current_thread()
# Make a CurrentThreadExecutor we'll use to idle in this thread - we
# need one for every sync frame, even if there's one above us in the
# same thread.
if hasattr(self.executors, "current"):
old_current_executor = self.executors.current
else:
old_current_executor = None
current_executor = CurrentThreadExecutor()
self.executors.current = current_executor
# Use call_soon_threadsafe to schedule a synchronous callback on the
# main event loop's thread if it's there, otherwise make a new loop
# in this thread.
try:
awaitable = self.main_wrap(args, kwargs, call_result,
source_thread, sys.exc_info(), context)
if not (self.main_event_loop
and self.main_event_loop.is_running()):
# Make our own event loop - in a new thread - and run inside that.
# Note(cosven): There must be only one QEventLoop instance,
# so we should use asyncio.DefaultEventLoopPolicy to create new
# event loops.
policy = asyncio.get_event_loop_policy()
try:
asyncio.set_event_loop_policy(
asyncio.DefaultEventLoopPolicy())
loop = asyncio.new_event_loop()
finally:
asyncio.set_event_loop_policy(policy)
loop_executor = ThreadPoolExecutor(max_workers=1)
loop_future = loop_executor.submit(self._run_event_loop, loop,
awaitable)
if current_executor:
# Run the CurrentThreadExecutor until the future is done
current_executor.run_until_future(loop_future)
# Wait for future and/or allow for exception propagation
loop_future.result()
else:
# Call it inside the existing loop
self.main_event_loop.call_soon_threadsafe(
self.main_event_loop.create_task, awaitable)
if current_executor:
# Run the CurrentThreadExecutor until the future is done
current_executor.run_until_future(call_result)
finally:
# Clean up any executor we were running
if hasattr(self.executors, "current"):
del self.executors.current
if old_current_executor:
self.executors.current = old_current_executor
if contextvars is not None:
_restore_context(context[0])
# Wait for results from the future.
return call_result.result()
def test_default_loop(self) -> None:
self.assertIs(self.loop,
asyncio.get_event_loop_policy().get_event_loop())
def event_loop(request: Any) -> Generator[asyncio.AbstractEventLoop, Any, Any]:
loop = asyncio.get_event_loop_policy().get_event_loop()
yield loop
def __enter__(self):
self.elp_save = asyncio.get_event_loop_policy()
asyncio.set_event_loop_policy(self)
def get_event_loop():
return asyncio.get_event_loop_policy().get_event_loop()
def fetch_analysis_and_save(self, reviews):
async def process_reviews():
with concurrent.futures.ThreadPoolExecutor(
max_workers=24) as executor:
def sync_get_sentiment_analysis(review):
return requests.post(
'https://language.googleapis.com/v1/documents:analyzeSentiment?key={}'
.format(google_api_key),
json={
"encodingType": "UTF8",
"document": {
"type": "PLAIN_TEXT",
"content": review['review_text']
}
})
def sync_get_entity_analysis(review):
return requests.post(
'https://language.googleapis.com/v1/documents:analyzeEntities?key={}'
.format(google_api_key),
json={
"encodingType": "UTF8",
"document": {
"type": "PLAIN_TEXT",
"content": review['review_text']
}
})
sentiment_futures = [
loop.run_in_executor(executor, sync_get_sentiment_analysis,
r) for r in reviews
]
entity_futures = [
loop.run_in_executor(executor, sync_get_entity_analysis, r)
for r in reviews
]
sentiment_responses = [
response
for response in await asyncio.gather(*sentiment_futures)
]
entity_responses = [
response
for response in await asyncio.gather(*entity_futures)
]
analysed_reviews = [
dict(
r, **{
'analysis':
json.dumps({
'sentiment':
sentiment_responses[i].json(),
'entity':
entity_responses[i].json()
})
}) for i, r in enumerate(reviews)
]
self.bulk_insert(analysed_reviews)
loop = asyncio.get_event_loop_policy().new_event_loop()
loop.run_until_complete(process_reviews())
remove and bump tornado requirement for py38
borrowed from ipykernel: https://github.com/ipython/ipykernel/pull/456
"""
if sys.platform.startswith("win") and sys.version_info >= (3, 8):
import asyncio
try:
from asyncio import (
WindowsProactorEventLoopPolicy,
WindowsSelectorEventLoopPolicy,
)
except ImportError:
pass
# not affected
else:
if (type(asyncio.get_event_loop_policy()) is
WindowsProactorEventLoopPolicy):
# WindowsProactorEventLoopPolicy is not compatible with tornado 6
# fallback to the pre-3.8 default of Selector
asyncio.set_event_loop_policy(WindowsSelectorEventLoopPolicy())
class QtConsole(RichJupyterWidget):
"""Qt view for the console, an integrated iPython terminal in napari.
Parameters
----------
user_variables : dict
Dictionary of user variables to declare in console name space.
Attributes
params, _in_query_parameters)
async def entry_point(module, session):
url = build_url(module.params)
async with session.get(url, **session_timeout(module.params)) as resp:
_json = await resp.json()
if "value" not in _json: # 7.0.2+
_json = {"value": _json}
if module.params.get("service"):
_json["id"] = module.params.get("service")
elif module.params.get("label"): # TODO extend the list of filter
_json = await exists(module.params, session, url)
elif (isinstance(_json["value"], list) and len(_json["value"]) > 0
and isinstance(_json["value"][0], str)):
# this is a list of id, we fetch the details
full_device_list = await build_full_device_list(
session, url, _json)
_json = {"value": [i["value"] for i in full_device_list]}
return await update_changed_flag(_json, resp.status, "get")
if __name__ == "__main__":
import asyncio
current_loop = asyncio.get_event_loop_policy().get_event_loop()
current_loop.run_until_complete(main())
def __init__(
self,
tokens: Token = None,
*,
group_id: int = None,
debug: typing.Union[str, bool] = True,
loop: asyncio.AbstractEventLoop = None,
throw_errors: bool = True,
log_to_path: typing.Union[str, bool] = None,
patcher: Patcher = None,
mobile: bool = False,
secret: str = None,
extension: AbstractExtension = None,
logs_folder: typing.Optional[str] = None,
only_asyncio_loop: bool = False,
**context,
):
"""
Init bot
:param tokens: bot tokens
:param group_id:
:param debug: should bot debug messages for emulating
:param log_to_path: make logs
:param secret: secret vk code for callback
:param extension:
"""
# Base bot classifiers
self.__tokens: typing.List[str] = [tokens] if isinstance(
tokens, str) else tokens
self.__debug: bool = debug
self.__wait = None
self.__secret = secret
self._status: BotStatus = BotStatus()
self.context: dict = context
if uvloop is not None:
if not only_asyncio_loop:
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
if isinstance(debug, bool):
debug = "INFO" if debug else "ERROR"
self.logger = LoggerLevel(debug)
if not Patcher.get_current():
Patcher.set_current(patcher if patcher is not None else Patcher(
pattern="^{}$", validators=DefaultValidators))
logger.remove()
logger.add(
sys.stderr,
colorize=True,
format=
"<level>[<blue>VKBottle</blue>] {message}</level> <white>[TIME {time:HH:MM:ss}]</white>",
filter=self.logger,
level=0,
enqueue=mobile is False,
)
logger.level("INFO", color="<white>")
logger.level("ERROR", color="<red>")
if log_to_path:
logger.add(
(logs_folder or "") +
"log_{time}.log" if log_to_path is True else log_to_path,
rotation="20 MB",
)
self.group_id = group_id or self.get_id_by_token(self.__tokens[0])
self.loop = loop or asyncio.get_event_loop()
# Sign assets
self._api: Api = Api(self.__tokens, throw_errors=throw_errors)
self.error_handler: VKErrorHandler = DefaultErrorHandler()
self.extension: AbstractExtension = (extension if extension is not None
else StandardExtension())
self._throw_errors: bool = throw_errors
Api.set_current(self._api)
VKErrorHandler.set_current(self.error_handler)
AbstractExtension.set_current(self.extension)
# Main workers
self.branch: typing.Union[ABCBranchGenerator,
DictBranch] = DictBranch()
self.middleware: MiddlewareExecutor = MiddlewareExecutor()
self.on: BotHandler = BotHandler(self.group_id)
self._stop: bool = False
self.deconstructed_handle: BotProcessor = BotProcessor(self.group_id)
logger.info("Using JSON_MODULE - {}".format(USAGE))
logger.info("Using asyncio loop - {}".format(
asyncio.get_event_loop_policy().__class__.__module__))
def pytest_fixture_setup(fixturedef, request):
"""Adjust the event loop policy when an event loop is produced."""
if isasyncgenfunction(fixturedef.func):
# This is an async generator function. Wrap it accordingly.
f = fixturedef.func
strip_event_loop = False
if 'event_loop' not in fixturedef.argnames:
fixturedef.argnames += ('event_loop', )
strip_event_loop = True
strip_request = False
if 'request' not in fixturedef.argnames:
fixturedef.argnames += ('request', )
strip_request = True
def wrapper(*args, **kwargs):
loop = kwargs['event_loop']
request = kwargs['request']
if strip_event_loop:
del kwargs['event_loop']
if strip_request:
del kwargs['request']
gen_obj = f(*args, **kwargs)
async def setup():
res = await gen_obj.__anext__()
return res
def finalizer():
"""Yield again, to finalize."""
async def async_finalizer():
try:
await gen_obj.__anext__()
except StopAsyncIteration:
pass
else:
msg = "Async generator fixture didn't stop."
msg += "Yield only once."
raise ValueError(msg)
loop.run_until_complete(async_finalizer())
request.addfinalizer(finalizer)
return loop.run_until_complete(setup())
fixturedef.func = wrapper
elif inspect.iscoroutinefunction(fixturedef.func):
# Just a coroutine, not an async generator.
f = fixturedef.func
strip_event_loop = False
if 'event_loop' not in fixturedef.argnames:
fixturedef.argnames += ('event_loop', )
strip_event_loop = True
def wrapper(*args, **kwargs):
loop = kwargs['event_loop']
if strip_event_loop:
del kwargs['event_loop']
async def setup():
res = await f(*args, **kwargs)
return res
return loop.run_until_complete(setup())
fixturedef.func = wrapper
outcome = yield
if fixturedef.argname == "event_loop" and 'asyncio' in request.keywords:
loop = outcome.get_result()
for kw in _markers_2_fixtures.keys():
if kw not in request.keywords:
continue
policy = asyncio.get_event_loop_policy()
old_loop = policy.get_event_loop()
policy.set_event_loop(loop)
fixturedef.addfinalizer(lambda: policy.set_event_loop(old_loop))
def request_init_slide(self, session, html):
""" 处理滑块，拿到 session_id, sig """
OrderLog.add_quick_log('正在识别滑动验证码...').flush()
return asyncio.get_event_loop_policy().new_event_loop().run_until_complete(
self.__request_init_slide(session, html))
def event_loop(request):
"""Create an instance of the default event loop for each test case."""
loop = asyncio.get_event_loop_policy().new_event_loop()
yield loop
loop.close()
def event_loop(request: SubRequest) -> asyncio.AbstractEventLoop:
loop = asyncio.get_event_loop_policy().new_event_loop()
yield loop
loop.close()
def pytest_fixture_setup(fixturedef, request):
"""Adjust the event loop policy when an event loop is produced."""
if fixturedef.argname == "event_loop" and 'asyncio' in request.keywords:
outcome = yield
loop = outcome.get_result()
policy = asyncio.get_event_loop_policy()
try:
old_loop = policy.get_event_loop()
except RuntimeError as exc:
if 'no current event loop' not in str(exc):
raise
old_loop = None
policy.set_event_loop(loop)
fixturedef.addfinalizer(lambda: policy.set_event_loop(old_loop))
return
if isasyncgenfunction(fixturedef.func):
# This is an async generator function. Wrap it accordingly.
generator = fixturedef.func
strip_request = False
if 'request' not in fixturedef.argnames:
fixturedef.argnames += ('request', )
strip_request = True
def wrapper(*args, **kwargs):
request = kwargs['request']
if strip_request:
del kwargs['request']
gen_obj = generator(*args, **kwargs)
async def setup():
res = await gen_obj.__anext__()
return res
def finalizer():
"""Yield again, to finalize."""
async def async_finalizer():
try:
await gen_obj.__anext__()
except StopAsyncIteration:
pass
else:
msg = "Async generator fixture didn't stop."
msg += "Yield only once."
raise ValueError(msg)
asyncio.get_event_loop().run_until_complete(async_finalizer())
request.addfinalizer(finalizer)
return asyncio.get_event_loop().run_until_complete(setup())
fixturedef.func = wrapper
elif inspect.iscoroutinefunction(fixturedef.func):
coro = fixturedef.func
def wrapper(*args, **kwargs):
async def setup():
res = await coro(*args, **kwargs)
return res
return asyncio.get_event_loop().run_until_complete(setup())
fixturedef.func = wrapper
yield
def test_default_loop(loop: Any) -> None:
assert asyncio.get_event_loop_policy().get_event_loop() is loop
from rest_framework import viewsets
from rest_framework.response import Response
from rest_framework.decorators import list_route
from django.http import HttpResponse, HttpResponseBadRequest
from rest_framework import status
from django.conf import settings
import hashlib
from django.db.models import Count
from .factories.facebook_factories import MessageFactory
from .services.message_handlers import MessageHandlerManager
import json
import requests
import hmac
import asyncio
loop = asyncio.get_event_loop_policy().new_event_loop()
class MessageViewSet(viewsets.ModelViewSet):
queryset = Message.objects.all()
serializer_class = MessageSerializer
@list_route(methods=['post', 'get'])
def webhook(self, request):
if request.method == 'POST':
sha_key, signature = request.META.get(
'HTTP_X_HUB_SIGNATURE').split('=')
digester = hmac.new(settings.BOT_SECRET.encode(), request.body,
hashlib.sha1)
calculated_signature = digester.hexdigest()
if signature == calculated_signature:
def event_loop(
request: Request) -> Generator[asyncio.AbstractEventLoop, None, None]:
loop = asyncio.get_event_loop_policy().new_event_loop()
yield loop
loop.close()
def tearDown(self):
asyncio.get_event_loop_policy().get_event_loop().close()
asyncio.set_event_loop_policy(self.orig_policy)
def event_loop(request):
loop = asyncio.get_event_loop_policy().new_event_loop()
yield loop
loop.close()
import asyncio
import time
now = lambda: time.time()
async def do_some_work(x):
print('Waiting: ', x)
return x
def callback(future):
print('Callback: ', future.result())
start = now()
coroutine = do_some_work(2)
loop = asyncio.get_event_loop()
print(asyncio.get_event_loop_policy())
# task = asyncio.ensure_future(coroutine)
task = loop.create_task(coroutine)
print(task)
#可以通过增加 完成之后的callback，对返回的数据进行处理
task.add_done_callback(callback)
loop.run_until_complete(task)
print(task)
#也可以直接处理
print(task.result())
print('TIME: ', now() - start)
