"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()".

      For convenience, the token object can be used as a context
      manager to avoid calling "ContextVar.reset()" manually:

         var = ContextVar('var', default='default value')

         with var.set('new value'):
             assert var.get() == 'new value'

         assert var.get() == 'default value'

      It is a shorthand for:

         var = ContextVar('var', default='default value')

         token = var.set('new value')
         try:
             assert var.get() == 'new value'
         finally:
             var.reset(token)

         assert var.get() == 'default value'

      Ajouté dans la version 3.14: Added support for using tokens as
      context managers.

   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.

      The same *token* cannot be used twice.

class contextvars.Token

   *Token* objects are returned by the "ContextVar.set()" method. They
   can be passed to the "ContextVar.reset()" method to revert the
   value of the variable to what it was before the corresponding
   *set*. A single token cannot reset a context variable more than
   once.

   Tokens support the context manager protocol to automatically reset
   context variables. See "ContextVar.set()".

   Ajouté dans la version 3.14: Added support for usage as a context
   manager.

   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, it is now possible to get the
       # 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
