def test_context_new_1(self): with self.assertRaisesRegex(TypeError, 'any arguments'): contextvars.Context(1) with self.assertRaisesRegex(TypeError, 'any arguments'): contextvars.Context(1, a=1) with self.assertRaisesRegex(TypeError, 'any arguments'): contextvars.Context(a=1) contextvars.Context(**{})
def test_context_new_1(self): with self.assertRaises(TypeError): contextvars.Context(1) with self.assertRaises(TypeError): contextvars.Context(1, a=1) with self.assertRaises(TypeError): contextvars.Context(a=1) contextvars.Context(**{})
def _ensure_updating(self) -> None: """Ensure that we are updating the job list from the remote resource. This will automatically stop if there are no outstanding requests. """ async def updating(): """Do the actual update, stop if not requests left.""" await self._update_job_info() # Any outstanding requests? if self._update_requests_outstanding(): self._update_handle = self._loop.call_later( self._get_next_update_delay(), asyncio.ensure_future, updating(), context=contextvars.Context(), # type: ignore[call-arg] ) else: self._update_handle = None # Check if we're already updating if self._update_handle is None: self._update_handle = self._loop.call_later( self._get_next_update_delay(), asyncio.ensure_future, updating(), context=contextvars.Context(), # type: ignore[call-arg] )
def identify_indexes(self, di): di = list(self.expand_ellipsis(di)) a2s = [] contexts = [] ta = self.transformation_axes if ta == None: ta = set(range(len(self.wrapped.axes))) for i in range(len(self.wrapped.axes)): if isinstance(di[i], Number): #wrap the scalar indexes, this is needed to make sure samplers work on the right axis di[i] = np.array([di[i]]) a2s.append(i) for i in ta: if i < 0: i = len(self.wrapped.axes) - i ctx = contextvars.Context() contexts.append((i, ctx)) di[i] = ctx.run(self.axis_identify_indexes, di[i], i) axes_to_squeeze.set(tuple(a2s)) axis_contexts.set(contexts) return tuple(di)
def _get_context(): state = _get_state() ctx = getattr(state, "context", None) if ctx is None: ctx = contextvars.Context() state.context = ctx return ctx
def test_context_run_2(self): ctx = contextvars.Context() def func(*args, **kwargs): kwargs['spam'] = 'foo' args += ('bar', ) return args, kwargs for f in (func, functools.partial(func)): # partial doesn't support FASTCALL self.assertEqual(ctx.run(f), (('bar', ), {'spam': 'foo'})) self.assertEqual(ctx.run(f, 1), ((1, 'bar'), {'spam': 'foo'})) self.assertEqual(ctx.run(f, a=2), (('bar', ), { 'a': 2, 'spam': 'foo' })) self.assertEqual(ctx.run(f, 11, a=2), ((11, 'bar'), { 'a': 2, 'spam': 'foo' })) a = {} self.assertEqual(ctx.run(f, 11, **a), ((11, 'bar'), { 'spam': 'foo' })) self.assertEqual(a, {})
def ydumps(obj, sink=None, trait_help=None, classes=()) -> Optional[str]: """ Dump any false objects as empty string, None as nothing, or as YAML. :param classes: The list of other classes to be YAMLed, to consider for redundancy. Will return `cls` even if it is not defined on `cls` if the defining class is not in `classes`. See also: :meth:`~Configurable._defining_class()` """ if not obj: if sink: sink.write('') return # type: ignore return '' def dump_with_contextvars(): if trait_help is not None: _dump_trait_help.set(trait_help) _classes_yamling.set(classes) get_yamel().dump(obj, sink) dump_to_str = not bool(sink) if dump_to_str: sink = io.StringIO() cv.Context().run(dump_with_contextvars) if dump_to_str: return sink.getvalue().strip()
def render_form(giveaway_view, prize_view, field_state): def build_state(): fields.set(field_state) giveaway_id.set(f"{UUID(bytes=giveaway_view[0])}") title.set("\u00A0".join(giveaway_view[1].split())) prizes.set([ prize_toggle( id="giveaway-prize:id", value=f"{UUID(bytes=id)}", title=title, theme=theme, image_src=image_src, featured="featured" if int(featured) == 1 else "", ) for title, image_src, theme, id, _giveaway_id, _quantity, featured in prize_view ]) ctx = contextvars.Context() ctx.run(build_state) return ctx.run(lambda: html.tostring(document("Giveaway Registration: ", *giveaway_form()), pretty_print=True, doctype="<!doctype html>"))
def test_context_run_7(self): ctx = contextvars.Context() def fun(): with self.assertRaisesRegex(RuntimeError, 'is already entered'): ctx.run(fun) ctx.run(fun)
def test_context_getset_4(self): c = contextvars.ContextVar('c', default=42) ctx = contextvars.Context() tok = ctx.run(c.set, 1) with self.assertRaisesRegex(ValueError, 'different Context'): c.reset(tok)
def test_context_typerrors_1(self): ctx = contextvars.Context() with self.assertRaisesRegex(TypeError, 'ContextVar key was expected'): ctx[1] with self.assertRaisesRegex(TypeError, 'ContextVar key was expected'): 1 in ctx with self.assertRaisesRegex(TypeError, 'ContextVar key was expected'): ctx.get(1)
def test_context_run_3(self): ctx = contextvars.Context() def func(*args, **kwargs): 1 / 0 with self.assertRaises(ZeroDivisionError): ctx.run(func) with self.assertRaises(ZeroDivisionError): ctx.run(func, 1, 2) with self.assertRaises(ZeroDivisionError): ctx.run(func, 1, 2, a=123)
def __start_span(self, span): if span.id in self.__span_by_id: LOGGER.debug( "Duplicate span with lifetime 'Start' " "with id '%s'", span.id) return kwargs = { "operation_name": span.symbolic_name, "start_time": span.timestamp.timestamp(), "ignore_active_span": (self.__ignore_active_span and self.__is_top(span)), } if not span.is_top: try: parent_span, parent_ot_span, is_stripped = self.__span_by_id[ span.parent_id] except KeyError: LOGGER.warning("Parent span with id '%s' is not found.", span.parent_id) return kwargs["child_of"] = parent_ot_span LOGGER.debug( "%s is child of %s", span.symbolic_name, parent_span.symbolic_name, ) else: LOGGER.debug("Top span: %s", span.symbolic_name) kwargs["tags"] = { "hostname": span.hostname, "process_id": span.process_id, "thread_id": span.thread_id, "file_name": span.file_name, "line_number": span.line_number, "is_coroutine": span.is_coroutine, "is_generator": span.is_generator, } context = self.__context_by_pid_tid.setdefault( (span.process_id, span.thread_id), contextvars.Context()) should_strip = self.__should_strip(span) ot_span = None if not should_strip: ot_span = context.run(self.__tracer.start_span, **kwargs) self.__span_by_id[span.id] = (span, ot_span, should_strip) LOGGER.debug( "Started span with id '%s' and name '%s'%s.", span.id, span.symbolic_name, " as stripped" if should_strip else "", )
async def updating(): """Do the actual update, stop if not requests left.""" await self._update_job_info() # Any outstanding requests? if self._update_requests_outstanding(): self._update_handle = self._loop.call_later( self._get_next_update_delay(), asyncio.ensure_future, updating(), context=contextvars.Context(), # type: ignore[call-arg] ) else: self._update_handle = None
def test_context_run_6(self): ctx = contextvars.Context() c = contextvars.ContextVar('a', default=0) def fun(): self.assertEqual(c.get(), 0) self.assertIsNone(ctx.get(c)) c.set(42) self.assertEqual(c.get(), 42) self.assertEqual(ctx.get(c), 42) ctx.run(fun)
def test_context_run_5(self): ctx = contextvars.Context() var = contextvars.ContextVar('var') def func(): self.assertIsNone(var.get(None)) var.set('spam') 1 / 0 with self.assertRaises(ZeroDivisionError): ctx.run(func) self.assertIsNone(var.get(None))
def test_context_run_4(self): ctx1 = contextvars.Context() ctx2 = contextvars.Context() var = contextvars.ContextVar('var') def func2(): self.assertIsNone(var.get(None)) def func1(): self.assertIsNone(var.get(None)) var.set('spam') ctx2.run(func2) self.assertEqual(var.get(None), 'spam') cur = contextvars.copy_context() self.assertEqual(len(cur), 1) self.assertEqual(cur[var], 'spam') return cur returned_ctx = ctx1.run(func1) self.assertEqual(ctx1, returned_ctx) self.assertEqual(returned_ctx[var], 'spam') self.assertIn(var, returned_ctx)
def render_status(status, message, giveaway_title, registration_id=None, **kwargs): def build_state(): title.set("\u00A0".join(giveaway_title.split())) ctx = contextvars.Context() ctx.run(build_state) return ctx.run(lambda: html.tostring(document( "Registration Status: ", *status_section(status, message, registration_id)), pretty_print=True, doctype="<!doctype html>"))
def test_context_getset_3(self): c = contextvars.ContextVar('c', default=42) ctx = contextvars.Context() def fun(): self.assertEqual(c.get(), 42) with self.assertRaises(KeyError): ctx[c] self.assertIsNone(ctx.get(c)) self.assertEqual(ctx.get(c, 'spam'), 'spam') self.assertNotIn(c, ctx) self.assertEqual(list(ctx.keys()), []) t = c.set(1) self.assertEqual(list(ctx.keys()), [c]) self.assertEqual(ctx[c], 1) c.reset(t) self.assertEqual(list(ctx.keys()), []) with self.assertRaises(KeyError): ctx[c] ctx.run(fun)
def test_context_copy_1(self): ctx1 = contextvars.Context() c = contextvars.ContextVar('c', default=42) def ctx1_fun(): c.set(10) ctx2 = ctx1.copy() self.assertEqual(ctx2[c], 10) c.set(20) self.assertEqual(ctx1[c], 20) self.assertEqual(ctx2[c], 10) ctx2.run(ctx2_fun) self.assertEqual(ctx1[c], 20) self.assertEqual(ctx2[c], 30) def ctx2_fun(): self.assertEqual(c.get(), 10) c.set(30) self.assertEqual(c.get(), 30) ctx1.run(ctx1_fun)
def test_context_run(self): contextvars.Context().run(self.assertLevel)
def wrapper(*args, **kwargs): ctx = contextvars.Context() return ctx.run(func, *args, **kwargs)
def run_in_clean_context(*args, **kwargs): contextvars.Context().run(func, *args, **kwargs)
try: os.chdir(original_cwd) except os.error: pass saved.starting_locals["help"] = arepl_overloads.help_overload saved.starting_locals["input"] = arepl_overloads.input_overload saved.starting_locals["howdoi"] = arepl_overloads.howdoi_wrapper eval_locals = deepcopy(saved.starting_locals) noGlobalVarsMsg = {"zz status": "AREPL is configured to not show global vars"} try: run_context = contextvars.Context() except NameError: run_context = None def exec_input(exec_args: ExecArgs): """ returns info about the executed code (local vars, errors, and timing) :rtype: returnInfo """ global eval_locals global run_context argv[0] = exec_args.filePath # see https://docs.python.org/3/library/sys.html#sys.argv saved.starting_locals["__file__"] = exec_args.filePath
def exec_input(exec_args: ExecArgs): """ returns info about the executed code (local vars, errors, and timing) :rtype: returnInfo """ global eval_locals global run_context argv[0] = exec_args.filePath # see https://docs.python.org/3/library/sys.html#sys.argv saved.starting_locals["__file__"] = exec_args.filePath if exec_args.filePath: saved.starting_locals["__loader__"].path = os.path.basename( exec_args.filePath) if not exec_args.usePreviousVariables: eval_locals = saved.get_eval_locals(exec_args.savedCode) # re-import imports. (pickling imports from saved code was unfortunately not possible) exec_args.evalCode = saved.copy_saved_imports_to_exec( exec_args.evalCode, exec_args.savedCode) # clear new modules from last run each run has same fresh start current_module_names = set([module_name for module_name in modules]) new_modules = current_module_names - modules_to_keep for module_name in new_modules: del modules[module_name] # not sure why i need to do this when module was deleted # but if I don't next run will say event loop closed asyncio.set_event_loop(asyncio.new_event_loop()) with script_path(os.path.dirname(exec_args.filePath)): if not exec_args.usePreviousVariables and run_context is not None: run_context = contextvars.Context() try: start = time() if run_context is not None: run_context.run(exec, exec_args.evalCode, eval_locals) else: # python 3.6 fallback exec(exec_args.evalCode, eval_locals) execTime = time() - start except BaseException: execTime = time() - start _, exc_obj, exc_tb = exc_info() if not get_settings().show_global_vars: raise UserError(exc_obj, exc_tb, noGlobalVarsMsg, execTime) else: raise UserError(exc_obj, exc_tb, eval_locals, execTime) finally: if sys.stdout.flush and callable(sys.stdout.flush): # a normal program will flush at the end of the run # arepl never stops so we have to do it manually sys.stdout.flush() saved.arepl_store = eval_locals.get("arepl_store") # clear mock stdin for next run arepl_overloads.arepl_input_iterator = None if get_settings().show_global_vars: userVariables = pickle_user_vars( eval_locals, get_settings().default_filter_vars, get_settings().default_filter_types, ) else: userVariables = pickle_user_vars( noGlobalVarsMsg, get_settings().default_filter_vars, get_settings().default_filter_types, ) return ReturnInfo("", userVariables, execTime, None)
def request_transport( self, authinfo: AuthInfo) -> Iterator[Awaitable[Transport]]: """ Request a transport from an authinfo. Because the client is not allowed to request a transport immediately they will instead be given back a future that can be awaited to get the transport:: async def transport_task(transport_queue, authinfo): with transport_queue.request_transport(authinfo) as request: transport = await request # Do some work with the transport :param authinfo: The authinfo to be used to get transport :return: A future that can be yielded to give the transport """ open_callback_handle = None transport_request = self._transport_requests.get(authinfo.id, None) if transport_request is None: # There is no existing request for this transport (i.e. on this authinfo) transport_request = TransportRequest() self._transport_requests[authinfo.id] = transport_request transport = authinfo.get_transport() safe_open_interval = transport.get_safe_open_interval() def do_open(): """ Actually open the transport """ if transport_request and transport_request.count > 0: # The user still wants the transport so open it _LOGGER.debug('Transport request opening transport for %s', authinfo) try: transport.open() except Exception as exception: # pylint: disable=broad-except _LOGGER.error( 'exception occurred while trying to open transport:\n %s', exception) transport_request.future.set_exception(exception) # Cleanup of the stale TransportRequest with the excepted transport future self._transport_requests.pop(authinfo.id, None) else: transport_request.future.set_result(transport) # Save the handle so that we can cancel the callback if the user no longer wants it # Note: Don't pass the Process context, since (a) it is not needed by `do_open` and (b) the transport is # passed around to many places, including outside aiida-core (e.g. paramiko). Anyone keeping a reference # to this handle would otherwise keep the Process context (and thus the process itself) in memory. # See https://github.com/aiidateam/aiida-core/issues/4698 open_callback_handle = self._loop.call_later( safe_open_interval, do_open, context=contextvars.Context()) # type: ignore[call-arg] try: transport_request.count += 1 yield transport_request.future except asyncio.CancelledError: # pylint: disable=try-except-raise # note this is only required in python<=3.7, # where asyncio.CancelledError inherits from Exception _LOGGER.debug('Transport task cancelled') raise except Exception: _LOGGER.error('Exception whilst using transport:\n%s', traceback.format_exc()) raise finally: transport_request.count -= 1 assert transport_request.count >= 0, 'Transport request count dropped below 0!' # Check if there are no longer any users that want the transport if transport_request.count == 0: if transport_request.future.done(): _LOGGER.debug('Transport request closing transport for %s', authinfo) transport_request.future.result().close() elif open_callback_handle is not None: open_callback_handle.cancel() self._transport_requests.pop(authinfo.id, None)
def test_context_run_1(self): ctx = contextvars.Context() with self.assertRaisesRegex(TypeError, 'missing 1 required'): ctx.run()
def __getitem__(self, indexes): ctx = contextvars.Context() indexes = ctx.run(self.identify_indexes, indexes) values = self.wrapped[indexes] values = ctx.run(self.calculate_values, values) return values