When the debug mode is enabled:

* asyncio checks for:ref:`coroutines that were not awaited

<asyncio-coroutine-not-scheduled>` and logs them; this mitigates

the "forgotten await" pitfall.

* Many non-threadsafe asyncio APIs (such as:meth:`loop.call_soon` and

:meth:`loop.call_at` methods) raise an exception if they are called

from a wrong thread.

..versionadded::3.5.2

..method::loop.create_task(coro, *, name=None, context=None)

..method::loop.create_task(coro, *, name=None, context=None, **kwargs)

Schedule the execution of:ref:`coroutine<coroutine>` *coro*.

Return a:class:`Task` object.

for interoperability. In this case, the result type is a subclass

of:class:`Task`.

The full function signature is largely the same as that of the

:class:`Task` constructor (or factory) - all of the keyword arguments to

this function are passed through to that interface, except *name*,

or *context* if it is ``None``.

If the *name* argument is provided and not ``None``, it is set as

the name of the task using:meth:`Task.set_name`.

..versionchanged::3.11

Added the *context* parameter.

..versionchanged::3.13.3

Added ``kwargs`` which passes on arbitrary extra parameters, including ``name`` and ``context``.

..versionchanged::3.13.4

Rolled back the change that passes on *name* and *context* (if it is None),

while still passing on other arbitrary keyword arguments (to avoid breaking backwards compatibility with 3.13.3).

..method::loop.set_task_factory(factory)

Set a task factory that will be used by

event loop, and *coro* is a coroutine object. The callable

must pass on all *kwargs*, and return a:class:`asyncio.Task`-compatible object.

..versionchanged::3.13.3

Required that all *kwargs* are passed on to:class:`asyncio.Task`.

..versionchanged::3.13.4

*name* is no longer passed to task factories. *context* is no longer passed

to task factories if it is ``None``.

..method::loop.get_task_factory()

Return a task factory or ``None`` if the default one is in use.

This module provides functions for encoding binary data to printable

ASCII characters and decoding such encodings back to binary data.

It provides encoding and decoding functions for the encodings specified in

:rfc:`4648`, which defines the Base16, Base32, and Base64 algorithms,

and for the de-facto standard Ascii85 and Base85 encodings.

The:rfc:`4648` encodings are suitable for encoding binary data so that it can be

safely sent by email, used as parts of URLs, or included as part of an HTTP

POST request. The encoding algorithm is not the same as the

:program:`uuencode` program.

This includes the:ref:`encodings specified in<base64-rfc-4648>`

:rfc:`4648` (Base64, Base32 and Base16)

and the non-standard:ref:`Base85 encodings<base64-base-85>`.

There are two interfaces provided by this module. The modern interface

supports encoding:term:`bytes-like objects <bytes-like object>` to ASCII

:class:`bytes`, and decoding:term:`bytes-like objects <bytes-like object>` or

strings containing ASCII to:class:`bytes`. Both base-64 alphabets

defined in:rfc:`4648` (normal, and URL- and filesystem-safe) are supported.

The legacy interface does not support decoding from strings, but it does

The:ref:`legacy interface<base64-legacy>` does not support decoding from strings, but it does

provide functions for encoding and decoding to and from:term:`file objects

<file object>`. It only supports the Base64 standard alphabet, and it adds

newlines every 76 characters as per:rfc:`2045`. Note that if you are looking

Any:term:`bytes-like objects <bytes-like object>` are now accepted by all

encoding and decoding functions in this module. Ascii85/Base85 support added.

The modern interface provides:

.. _base64-rfc-4648:

RFC 4648 Encodings

The:rfc:`4648` encodings are suitable for encoding binary data so that it can be

safely sent by email, used as parts of URLs, or included as part of an HTTP

POST request.

..function::b64encode(s, altchars=None)

incorrectly padded or if there are non-alphabet characters present in the

input.

.. _base64-base-85:

Base85 Encodings

Base85 encoding is not formally specified but rather a de facto standard,

thus different systems perform the encoding differently.

The:func:`a85encode` and:func:`b85encode` functions in this module are two implementations of

the de facto standard. You should call the function with the Base85

implementation used by the software you intend to work with.

The two functions present in this module differ in how they handle the following:

* Whether to include enclosing ``<~`` and ``~>`` markers

* Whether to include newline characters

* The set of ASCII characters used for encoding

* Handling of null bytes

Refer to the documentation of the individual functions for more information.

..function::a85encode(b, *, foldspaces=False, wrapcol=0, pad=False, adobe=False)

..versionadded::3.13

The legacy interface:

.. _base64-legacy:

Legacy Interface

..function::decode(input, output)

``'Last-Modified:'`` header with the file's modification time.

Then follows a blank line signifying the end of the headers, and then the

contents of the file are output. If the file's MIME type starts with

``text/`` the file is opened in text mode; otherwise binary mode is used.

contents of the file are output.

For example usage, see the implementation of the ``test`` function

in:source:`Lib/http/server.py`.

`JavaScript<https://en.wikipedia.org/wiki/JavaScript>`_ object literal syntax

(although it is not a strict subset of JavaScript [#rfc-errata]_ ).

..note::

The term "object" in the context of JSON processing in Python can be

ambiguous. All values in Python are objects. In JSON, an object refers to

any data wrapped in curly braces, similar to a Python dictionary.

..warning::

Be cautious when parsing JSON data from untrusted sources. A malicious

JSON string may cause the decoder to consume considerable CPU and memory

resources. Limiting the size of data to be parsed is recommended.

:mod:`json` exposes an API familiar to users of the standard library

This module exposes an API familiar to users of the standard library

:mod:`marshal` and:mod:`pickle` modules.

Encoding basic Python object hierarchies::

Specializing JSON object encoding::

Customizing JSON object encoding::

Specializing JSON object decoding::

Customizing JSON object decoding::

If set, a function that is called with the result of

any object literal decoded (a:class:`dict`).

anyJSONobject literal decoded (a:class:`dict`).

The return value of this function will be used

instead of the:class:`dict`.

This feature can be used to implement custom decoders,

If set, a function that is called with the result of

any object literal decoded with an ordered list of pairs.

anyJSONobject literal decoded with an ordered list of pairs.

The return value of this function will be used

instead of the:class:`dict`.

This feature can be used to implement custom decoders.

``?``

Matches one non-separator character.

``[seq]``

Matches one character in *seq*.

Matches one character in *seq*, where *seq* is a sequence of characters.

Range expressions are supported; for example, ``[a-z]`` matches any lowercase ASCII letter.

Multiple ranges can be combined: ``[a-zA-Z0-9_]`` matches any ASCII letter, digit, or underscore.

``[!seq]``

Matches one character not in *seq*.

Matches one character not in *seq*, where *seq* follows the same rules as above.

For a literal match, wrap the meta-characters in brackets.

For example, ``"[?]"`` matches the character ``"?"``.

That way, separator components are always found at the same relative

indices within the result list.

Emptymatchesfor the pattern split the string only when not adjacent

to a previousempty match.

Adjacent emptymatchesare not possible, but an empty match can occur

immediately after a non-empty match.

..code::pycon

The optional argument *count* is the maximum number of pattern occurrences to be

replaced; *count* must be a non-negative integer. If omitted or zero, all

occurrences will be replaced. Empty matches for the pattern are replaced only

when not adjacent to a previous empty match, so ``sub('x*', '-', 'abxd')`` returns

``'-a-b--d-'``.

occurrences will be replaced.

Adjacent empty matches are not possible, but an empty match can occur

immediately after a non-empty match.

As a result, ``sub('x*', '-', 'abxd')`` returns ``'-a-b--d-'``

instead of ``'-a-b-d-'``.

..index::single: \g; in regular expressions

..versionchanged::3.7

Unknown escapes in *repl* consisting of ``'\'`` and an ASCII letter

now are errors.

Empty matches for the pattern are replaced when adjacent to a previous

non-empty match.

An empty match can occur immediately after a non-empty match.

..versionchanged::3.12

Group *id* can only contain ASCII digits.

If *sep* is not specified or is ``None`` and *maxsplit* is ``0``, only