`contextvars` --- Context Variables¶

Ce module fournit des API pour gérer, stocker et accéder à l'état local de contexte. La classe ContextVar est utilisée pour déclarer et travailler avec les Variables de contexte. La fonction copy_context() et la classe Context doivent être utilisées pour la gestion du contexte actuel dans les cadriciels asynchrones.

Context managers that have state should use Context Variables instead of threading.local() to prevent their state from bleeding to other code unexpectedly, when used in concurrent code.

Voir aussi PEP 567 pour plus de détails.

Ajouté dans la version 3.7.

Variables de contexte¶

class contextvars.ContextVar(name[, *, default])¶

Cette classe est utilisée pour déclarer une nouvelle variable de contexte, p. ex :

var: ContextVar[int] = ContextVar('var', default=42)

Le paramètre requis name est utilisé à des fins d'introspection et de débogage.

Le paramètre nommé default est renvoyé par ContextVar.get() quand aucune valeur n'est trouvée dans le contexte actuel pour la variable.

Important : les variables de contexte doivent être créées au plus haut niveau du module et jamais dans des fermetures (closures). Les objets Context maintiennent des références fortes aux variables de contexte ce qui empêche que les variables de contexte soient correctement nettoyées par le ramasse-miette.

name¶: Nom de la variable. Cette propriété est en lecture seule.

Ajouté dans la version 3.7.1.

get([default])¶

Renvoie la valeur de la variable de contexte pour le contexte actuel.

S'il n'y a pas de valeur pour la variable dans le contexte actuel, la méthode :

renvoie la valeur de l'argument default passé à la méthode, s'il a été fourni ;
ou renvoie la valeur par défaut de la variable de contexte, si elle a été créée avec une valeur par défaut ;
ou lève une erreur LookupError.

set(value)¶

Assigne une nouvelle valeur à la variable de contexte dans le contexte actuel.

L'argument requis value est la nouvelle valeur pour la variable de contexte.

Renvoie un objet Token qui peut être utilisé pour rétablir la variable à sa valeur précédente par la méthode ContextVar.reset().

reset(token)¶

Réinitialise la variable de contexte à la valeur qu'elle avait avant l'appel de ContextVar.set() qui a créé le token.

Par exemple :

var = ContextVar('var')

token = var.set('new value')
# code that uses 'var'; var.get() returns 'new value'.
var.reset(token)

# After the reset call the var has no value again, so
# var.get() would raise a LookupError.

class contextvars.Token¶

Les objets Token sont renvoyés par la méthode ContextVar.set(). Ils peuvent être passés à la méthode ContextVar.reset() pour réaffecter la valeur de la variable à ce qu'elle était avant le set correspondant.

var¶: Propriété en lecture seule. Pointe vers l'objet ContextVar qui a créé le token.

old_value¶: A read-only property. Set to the value the variable had before the ContextVar.set() method call that created the token. It points to Token.MISSING if the variable was not set before the call.

MISSING¶: Objet marqueur utilisé par Token.old_value.

Gestion de contexte manuelle¶

contextvars.copy_context()¶

Renvoie une copie de l'objet Context actuel.

Le fragment de code qui suit obtient une copie du contexte actuel et affiche toutes les variables avec leurs valeurs définies dans ce contexte :

ctx: Context = copy_context()
print(list(ctx.items()))

The function has an O(1) complexity, i.e. works equally fast for contexts with a few context variables and for contexts that have a lot of them.

class contextvars.Context¶

Tableau associatif entre ContextVars et leurs valeurs.

Context() crée un contexte vide ne contenant aucune valeur. Pour obtenir une copie du contexte actuel, utilisez la fonction copy_context().

Each thread has its own effective stack of Context objects. The current context is the Context object at the top of the current thread's stack. All Context objects in the stacks are considered to be entered.

Entering a context, which can be done by calling its run() method, makes the context the current context by pushing it onto the top of the current thread's context stack.

Exiting from the current context, which can be done by returning from the callback passed to the run() method, restores the current context to what it was before the context was entered by popping the context off the top of the context stack.

Since each thread has its own context stack, ContextVar objects behave in a similar fashion to threading.local() when values are assigned in different threads.

Attempting to enter an already entered context, including contexts entered in other threads, raises a RuntimeError.

After exiting a context, it can later be re-entered (from any thread).

Any changes to ContextVar values via the ContextVar.set() method are recorded in the current context. The ContextVar.get() method returns the value associated with the current context. Exiting a context effectively reverts any changes made to context variables while the context was entered (if needed, the values can be restored by re-entering the context).

Context implémente l'interface collections.abc.Mapping.

run(callable, *args, **kwargs)¶

Enters the Context, executes callable(*args, **kwargs), then exits the Context. Returns callable's return value, or propagates an exception if one occurred.

Example:

import contextvars

var = contextvars.ContextVar('var')
var.set('spam')
print(var.get())  # 'spam'

ctx = contextvars.copy_context()

def main():
    # 'var' was set to 'spam' before
    # calling 'copy_context()' and 'ctx.run(main)', so:
    print(var.get())  # 'spam'
    print(ctx[var])  # 'spam'

    var.set('ham')

    # Now, after setting 'var' to 'ham':
    print(var.get())  # 'ham'
    print(ctx[var])  # 'ham'

# Any changes that the 'main' function makes to 'var'
# will be contained in 'ctx'.
ctx.run(main)

# The 'main()' function was run in the 'ctx' context,
# so changes to 'var' are contained in it:
print(ctx[var])  # 'ham'

# However, outside of 'ctx', 'var' is still set to 'spam':
print(var.get())  # 'spam'

copy()¶: Renvoie une copie superficielle de l'objet de contexte.

var in context: Renvoie True si le context a une valeur pour var ; sinon renvoie False.

context[var]: Renvoie la valeur de la variable ContextVar var. Si la variable n'est pas définie dans l'objet de contexte, une KeyError est levée.

get(var[, default])¶: Renvoie la valeur de var si var possède une valeur dans l'objet de contexte. Renvoie default sinon (ou None si default n'est pas donné).

iter(context): Renvoie un itérateur sur les variables stockées dans l'objet de contexte.

len(proxy): Renvoie le nombre de variables définies dans l'objet de contexte.

keys()¶: Renvoie une liste de toutes les variables dans l'objet de contexte.

values()¶: Renvoie une liste de toutes les valeurs des variables dans l'objet de contexte.

items()¶: Renvoie une liste de paires contenant toutes les variables et leurs valeurs dans l'objet de contexte.

Gestion avec asyncio¶

asyncio gère nativement les variables de contexte et elles sont prêtes à être utilisées sans configuration supplémentaire. Par exemple, voici un serveur echo simple qui utilise une variable de contexte pour que l’adresse d'un client distant soit disponible dans le Task qui gère ce client :

import asyncio
import contextvars

client_addr_var = contextvars.ContextVar('client_addr')

def render_goodbye():
    # The address of the currently handled client can be accessed
    # without passing it explicitly to this function.

    client_addr = client_addr_var.get()
    return f'Good bye, client @ {client_addr}\r\n'.encode()

async def handle_request(reader, writer):
    addr = writer.transport.get_extra_info('socket').getpeername()
    client_addr_var.set(addr)

    # In any code that we call is now possible to get
    # client's address by calling 'client_addr_var.get()'.

    while True:
        line = await reader.readline()
        print(line)
        if not line.strip():
            break

    writer.write(b'HTTP/1.1 200 OK\r\n')  # status line
    writer.write(b'\r\n')  # headers
    writer.write(render_goodbye())  # body
    writer.close()

async def main():
    srv = await asyncio.start_server(
        handle_request, '127.0.0.1', 8081)

    async with srv:
        await srv.serve_forever()

asyncio.run(main())

# To test it you can use telnet or curl:
#     telnet 127.0.0.1 8081
#     curl 127.0.0.1:8081

`contextvars` --- Context Variables¶

Variables de contexte¶

Gestion de contexte manuelle¶

Gestion avec asyncio¶

Table des matières

Sujet précédent

Sujet suivant

Cette page

contextvars --- Context Variables¶

Variables de contexte¶

Gestion de contexte manuelle¶

Gestion avec asyncio¶

`contextvars` --- Context Variables¶