"contextvars" --- Variables de Contexto
***************************************

======================================================================

Este módulo proporciona APIs para gestionar, almacenar y acceder a
estados en el contexto local. La clase "ContextVar" se utiliza para
declarar y trabajar con Variables de Contexto (*Context Variables*).
La función "copy_context()" y la clase "Context" deberían ser
utilizadas para gestionar el contexto actual en frameworks asíncronos.

Los gestores de contexto que tienen un estado establecido deberían
utilizar Variables de Contexto en lugar de "threading.local()", para
así evitar que este estado se inyecte inesperadamente a otro código,
cuando se utilice en código concurrente.

Ver **PEP 567** para más detalles.

Nuevo en la versión 3.7.


Variables de Contexto
=====================

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

   Esta clase se utiliza para declarar una nueva Variable de Contexto,
   por ejemplo:

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

   El parámetro obligatorio *name* se utiliza para introspección y
   depuración.

   El parámetro opcional de sólo palabra clave *default* es utilizado
   por "ContextVar.get()", cuando en el contexto actual no se
   encuentra ningún valor para la variable.

   **Importante:** las Variables de Contexto deberían ser creadas en
   lo más alto a nivel de módulo y nunca en clausura. Los objetos
   "Context" mantienen referencias a variables de contexto, lo cual no
   permitiría que estas variables de contexto sean limpiadas por el
   recolector de basura.

   name

      El nombre de la variable. Propiedad de sólo lectura.

      Nuevo en la versión 3.7.1.

   get([default])

      Retorna un valor para la variable de contexto en el contexto
      actual.

      Si la variable no tiene ningún valor en el contexto actual, el
      método:

      * retornará el valor del argumento *default* del método, si
        alguno fue dado; o

      * retornará el valor por defecto de la variable de contexto, si
        ésta fue creada con alguno; o

      * lanzará "LookupError".

   set(value)

      Establece un nuevo valor para la variable de contexto en el
      contexto actual.

      El argumento obligatorio *value* es el nuevo valor de la
      variable de contexto.

      Retorna un objeto "Token" que puede utilizarse para restaurar la
      variable a su valor anterior, utilizando el método
      "ContextVar.reset()".

   reset(token)

      Restablece la variable de contexto al valor que tenía antes de
      llamar al método "ContextVar.set()", que creó el *token*
      utilizado.

      Por ejemplo:

         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

   Los objetos *token* son retornados por el método
   "ContextVar.set()". Se le pueden dar al método "ContextVar.reset()"
   para restablecer el valor de la variable al que estuviese dado
   antes del *set* correspondiente.

   var

      Propiedad de sólo lectura. Apunta al objeto "ContextVar" que
      creó el *token*.

   old_value

      Propiedad de sólo lectura. Es el valor que la variable tenía
      antes de llamar al método "ContextVar.set()" que creó el
      *token*. Apunta a "Token.MISSING" si la variable no estaba
      establecida antes de la llamada.

   MISSING

      Marcador utilizado por "Token.old_value".


Gestión de Contexto Manual
==========================

contextvars.copy_context()

   Retorna una copia del objeto "Context" actual.

   El siguiente código obtiene una copia del contexto actual e imprime
   todas las variables y sus valores establecidos en el contexto:

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

   La función tiene una complejidad de O(1); es decir, trabaja a la
   misma velocidad en contextos con pocas o con muchas variables de
   contexto.

class contextvars.Context

   Mapeo de "ContextVars" con sus valores.

   "Context()" crea un contexto vacío sin valores. Para obtener una
   copia del contexto actual, se puede utilizar la función
   "copy_context()".

   Every thread will have a different top-level "Context" object. This
   means that a "ContextVar" object behaves in a similar fashion to
   "threading.local()" when values are assigned in different threads.

   *Context* implementa la interfaz "collections.abc.Mapping".

   run(callable, *args, **kwargs)

      Ejecuta el código de "callable(*args, **kwargs)" en el objeto de
      contexto del cual se llama al método *run*. Retorna el resultado
      de la ejecución, o propaga una excepción si alguna ocurre.

      Cualquier cambio realizado por *callable* sobre cualquier
      variable de contexto será contenido en el objeto de contexto:

         var = ContextVar('var')
         var.set('spam')

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

             var.set('ham')

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

         ctx = copy_context()

         # 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:
         # ctx[var] == 'ham'

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

      El método lanzará "RuntimeError" cuando es llamado desde el
      mismo objeto de contexto desde más de un hilo del sistema
      operativo, o si se llama recursivamente.

   copy()

      Retorna una copia superficial (*shallow copy*) del objeto de
      contexto.

   var in context

      Retorna "True" si *context* tiene un valor establecido para
      *var*; de lo contrario, retorna "False".

   context[var]

      Retorna el valor de la variable "ContextVar" *var*. Si la
      variable no está establecida en el contexto actual, se lanzará
      "KeyError".

   get(var[, default])

      Retorna el valor de *var*, si *var* tiene el valor en el objeto
      de contexto; de lo contrario, retorna *default*. Si *default* no
      es dado, retorna "None".

   iter(context)

      Retorna un iterador de las variables almacenadas en el objeto de
      contexto.

   len(proxy)

      Retorna el número de variables establecidas en el objeto de
      contexto.

   keys()

      Retorna un listado de todas las variables en el objeto de
      contexto.

   values()

      Retorna un listado de los valores de todas las variables en el
      objeto de contexto.

   items()

      Retorna un listado de dos tuplas que contienen todas las
      variables y sus variables en el contexto actual.


Soporte asyncio
===============

Las variables de contexto están soportadas de forma nativa en
"asyncio" y se pueden utilizar sin ninguna configuración adicional.
Por ejemplo, el siguiente código crea un servidor simple de respuesta,
que utiliza una variable de contexto que hace que la dirección del
cliente remoto esté disponible en la *Task* que gestiona al cliente:

   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}\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(line)

       writer.write(render_goodbye())
       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:
   #     telnet 127.0.0.1 8081
