[Python Serial Timeout Example
Facunda Ganesh
It is recommended that coroutines use try/finally blocks to robustlyperform clean-up logic. In case asyncio.CancelledErroris explicitly caught, it should generally be propagated whenclean-up is complete. asyncio.CancelledError directly subclassesBaseException so most code will not need to be aware of it.
The asyncio components that enable structured concurrency, likeasyncio.TaskGroup and asyncio.timeout(),are implemented using cancellation internally and might misbehave ifa coroutine swallows asyncio.CancelledError. Similarly, user codeshould not generally call uncancel.However, in cases when suppressing asyncio.CancelledError istruly desired, it is necessary to also call uncancel() to completelyremove the cancellation state.
The async with statement will wait for all tasks in the group to finish.While waiting, new tasks may still be added to the group(for example, by passing tg into one of the coroutinesand calling tg.create_task() in that coroutine).Once the last task has finished and the async with block is exited,no new tasks may be added to the group.
Once all tasks have finished, if any tasks have failedwith an exception other than asyncio.CancelledError,those exceptions are combined in anExceptionGroup or BaseExceptionGroup(as appropriate; see their documentation)which is then raised.
Two base exceptions are treated specially:If any task fails with KeyboardInterrupt or SystemExit,the task group still cancels the remaining tasks and waits for them,but then the initial KeyboardInterrupt or SystemExitis re-raised instead of ExceptionGroup or BaseExceptionGroup.
If the body of the async with statement exits with an exception(so __aexit__() is called with an exception set),this is treated the same as if one of the tasks failed:the remaining tasks are cancelled and then waited for,and non-cancellation exceptions are grouped into anexception group and raised.The exception passed into __aexit__(),unless it is asyncio.CancelledError,is also included in the exception group.The same special case is made forKeyboardInterrupt and SystemExit as in the previous paragraph.
A new alternative to create and run tasks concurrently andwait for their completion is asyncio.TaskGroup. TaskGroupprovides stronger safety guarantees than gather for scheduling a nesting of subtasks:if a task (or a subtask, a task scheduled by a task)raises an exception, TaskGroup will, while gather will not,cancel the remaining scheduled tasks).
When using this factory (via loop.set_task_factory(asyncio.eager_task_factory)),coroutines begin execution synchronously during Task construction.Tasks are only scheduled on the event loop if they block.This can be a performance improvement as the overhead of loop schedulingis avoided for coroutines that complete synchronously.
If long_running_task takes more than 10 seconds to complete,the context manager will cancel the current task and handlethe resulting asyncio.CancelledError internally, transforming itinto a TimeoutError which can be caught and handled.
Run awaitable objects in the awsiterable concurrently. Return an iterator of coroutines.Each coroutine returned can be awaited to get the earliest nextresult from the iterable of the remaining awaitables.
Any *args and **kwargs supplied for this function are directly passedto func. Also, the current contextvars.Context is propagated,allowing context variables from the event loop thread to be accessed in theseparate thread.
Directly calling blocking_io() in any coroutine would block the event loopfor its duration, resulting in an additional 1 second of run time. Instead,by using asyncio.to_thread(), we can run it in a separate thread withoutblocking the event loop.
Tasks are used to run coroutines in event loops.If a coroutine awaits on a Future, the Task suspendsthe execution of the coroutine and waits for the completionof the Future. When the Future is done, the execution ofthe wrapped coroutine resumes.
To cancel a running Task use the cancel() method. Calling itwill cause the Task to throw a CancelledError exception intothe wrapped coroutine. If a coroutine is awaiting on a Futureobject during cancellation, the Future object will be cancelled.
An optional keyword-only context argument allows specifying acustom contextvars.Context for the coro to run in.If no context is provided, the Task copies the current contextand later runs its coroutine in the copied context.
An optional keyword-only eager_start argument allows eagerly startingthe execution of the asyncio.Task at task creation time.If set to True and the event loop is running, the task will startexecuting the coroutine immediately, until the first time the coroutineblocks. If the coroutine returns or raises without blocking, the taskwill be finished eagerly and will skip scheduling to the event loop.
If the wrapped coroutine is not done, this returns the stackwhere it is suspended. If the coroutine has completedsuccessfully or was cancelled, this returns an empty list.If the coroutine was terminated by an exception, this returnsthe list of traceback frames.
The optional limit argument sets the maximum number of framesto return; by default all available frames are returned.The ordering of the returned list differs depending on whethera stack or a traceback is returned: the newest frames of astack are returned, but the oldest frames of a traceback arereturned. (This matches the behavior of the traceback module.)
While the block with make_request() and make_another_request()might get cancelled due to the timeout, unrelated_code() shouldcontinue running even in case of the timeout. This is implementedwith uncancel(). TaskGroup context managers useuncancel() in a similar fashion.
Note that if this number is greater than zero but the Task isstill executing, cancelled() will still return False.This is because this number can be lowered by calling uncancel(),which can lead to the task not being cancelled after all if thecancellation requests go down to zero.
The address format required by a particular socket object is automaticallyselected based on the address family specified when the socket object wascreated. Socket addresses are represented as follows:
A pair (host, port) is used for the AF_INET address family,where host is a string representing either a hostname in internet domainnotation like 'daring.cwi.nl' or an IPv4 address like '100.50.200.5',and port is an integer.
For IPv4 addresses, two special forms are accepted instead of a hostaddress: '' represents INADDR_ANY, which is used to bind to allinterfaces, and the string '' representsINADDR_BROADCAST. This behavior is not compatible with IPv6,therefore, you may want to avoid these if you intend to support IPv6 with yourPython programs.
For AF_INET6 address family, a four-tuple (host, port, flowinfo,scope_id) is used, where flowinfo and scope_id represent the sin6_flowinfoand sin6_scope_id members in struct sockaddr_in6 in C. Forsocket module methods, flowinfo and scope_id can be omitted just forbackward compatibility. Note, however, omission of scope_id can cause problemsin manipulating scoped IPv6 addresses.
Linux-only support for TIPC is available using the AF_TIPCaddress family. TIPC is an open, non-IP based networked protocol designedfor use in clustered computer environments. Addresses are represented by atuple, and the fields depend on the address type. The general tuple form is(addr_type, v1, v2, v3 [, scope]), where:
A tuple (interface, ) is used for the AF_CAN address family,where interface is a string representing a network interface name like'can0'. The network interface name '' can be used to receive packetsfrom all network interfaces of this family.
CAN_J1939 protocol require a tuple (interface, name, pgn, addr)where additional parameters are 64-bit unsigned integer representing theECU name, a 32-bit unsigned integer representing the Parameter Group Number(PGN), and an 8-bit integer representing the address.
A string or a tuple (id, unit) is used for the SYSPROTO_CONTROLprotocol of the PF_SYSTEM family. The string is the name of akernel control using a dynamically assigned ID. The tuple can be used if IDand unit number of the kernel control are known or if a registered ID isused.
BTPROTO_HCI accepts (device_id,) where device_id iseither an integer or a string with the Bluetooth address of theinterface. (This depends on your OS; NetBSD and DragonFlyBSD expecta Bluetooth address while everything else expects an integer.)
AF_QIPCRTR is a Linux-only socket based interface for communicatingwith services running on co-processors in Qualcomm platforms. The addressfamily is represented as a (node, port) tuple where the node and portare non-negative integers.
IPPROTO_UDPLITE is a variant of UDP which allows you to specifywhat portion of a packet is covered with the checksum. It adds two socketoptions that you can change.self.setsockopt(IPPROTO_UDPLITE, UDPLITE_SEND_CSCOV, length) willchange what portion of outgoing packets are covered by the checksum andself.setsockopt(IPPROTO_UDPLITE, UDPLITE_RECV_CSCOV, length) willfilter out packets which cover too little of their data. In both caseslength should be in range(8, 2**16, 8).
AF_HYPERV is a Windows-only socket based interface for communicatingwith Hyper-V hosts and guests. The address family is represented as a(vm_id, service_id) tuple where the vm_id and service_id areUUID strings.
If you use a hostname in the host portion of IPv4/v6 socket address, theprogram may show a nondeterministic behavior, as Python uses the first addressreturned from the DNS resolution. The socket address will be resolveddifferently into an actual IPv4/v6 address, depending on the results from DNSresolution and/or the host configuration. For deterministic behavior use anumeric address in host portion.
All errors raise exceptions. The normal exceptions for invalid argument typesand out-of-memory conditions can be raised. Errorsrelated to socket or address semantics raise OSError or one of itssubclasses.
A subclass of OSError, this exception is raised foraddress-related errors, i.e. for functions that use h_errno in the POSIXC API, including gethostbyname_ex() and gethostbyaddr().The accompanying value is a pair (h_errno, string) representing anerror returned by a library call. h_errno is a numeric value, whilestring represents the description of h_errno, as returned by thehstrerror() C function.
795a8134c1