Passer au contenu principal

​
Aperçu de l’API

​
class ContextAwareThread

Un thread qui exécute des fonctions avec le contexte de l’appelant. Il s’agit d’un remplacement direct de threading.Thread qui garantit que les appels se comportent comme prévu à l’intérieur du thread. Weave exige que certaines contextvars soient définies (voir call_context.py), mais les nouveaux threads ne recopient pas automatiquement le contexte du parent, ce qui peut entraîner la perte du contexte d’appel — ce qui n’est pas idéal. Cette classe automatise la copie des contextvars afin que l’utilisation de ce thread “fonctionne tout simplement”, comme l’utilisateur s’y attend probablement. Vous pouvez obtenir le même effet sans cette classe en écrivant plutôt : 
def run_with_context(func, *args, **kwargs):
     context = copy_context()
     def wrapper():
         context.run(func, *args, **kwargs)
     return wrapper

thread = threading.Thread(target=run_with_context(your_func, *args, **kwargs))
thread.start()

​
méthode __init__

__init__(*args: 'Any', **kwargs: 'Any') → None

​
propriété daemon

Valeur booléenne indiquant si ce thread est un thread daemon. Cette propriété doit être définie avant l’appel à start(), sinon une exception RuntimeError est levée. Sa valeur initiale est héritée du thread qui l’a créé ; le thread principal n’est pas un thread daemon et, par conséquent, tous les threads créés dans le thread principal ont par défaut daemon = False. L’ensemble du programme Python se termine lorsqu’il ne reste plus que des threads daemon.

​
propriété ident

Identifiant de ce thread, ou None s’il n’a pas été démarré. Il s’agit d’un entier non nul. Voir la fonction get_ident(). Les identifiants de thread peuvent être réutilisés lorsqu’un thread se termine et qu’un autre thread est créé. L’identifiant reste disponible même après la fin du thread.

​
propriété nom

Chaîne utilisée uniquement à des fins d’identification. Elle n’a pas de signification particulière. Plusieurs threads peuvent avoir le même nom. Le nom initial est défini par le constructeur.

​
propriété native_id

Identifiant natif entier de ce thread, ou None s’il n’a pas encore été démarré. Il s’agit d’un entier non négatif. Voir la fonction get_native_id(). Il correspond à l’ID du thread tel que renvoyé par le noyau.

​
méthode run

run() → None

​
class ContextAwareThreadPoolExecutor

Un ThreadPoolExecutor qui exécute des fonctions avec le contexte de l’appelant. Il s’agit d’un remplacement direct de concurrent.futures.ThreadPoolExecutor qui garantit que les appels Weave se comportent comme prévu au sein de l’exécuteur. Weave nécessite que certaines contextvars soient définies (voir call_context.py), mais les nouveaux threads ne copient pas automatiquement le contexte du parent, ce qui peut entraîner la perte du contexte d’appel — ce n’est pas idéal ! Cette classe automatise la copie des contextvars, de sorte que l’utilisation de cet exécuteur « fonctionne tout simplement », comme l’utilisateur s’y attend probablement. Vous pouvez obtenir le même effet sans cette classe en écrivant plutôt : 
with concurrent.futures.ThreadPoolExecutor() as executor:
     contexts = [copy_context() for _ in range(len(vals))]

     def _wrapped_fn(*args):
         return contexts.pop().run(fn, *args)

     executor.map(_wrapped_fn, vals)

​
méthode __init__

__init__(*args: 'Any', **kwargs: 'Any') → None

​
méthode map

map(
    fn: 'Callable',
    *iterables: 'Iterable[Any]',
    timeout: 'float | None' = None,
    chunksize: 'int' = 1
) → Iterator

​
méthode submit

submit(fn: 'Callable', *args: 'Any', **kwargs: 'Any') → Any

​
fonction obsolète

deprecated(new_name: 'str') → Callable[[Callable[P, R]], Callable[P, R]]
Décorateur permettant de signaler qu’une fonction est obsolète et de rediriger les utilisateurs vers new_name.

​
fonction is_colab

is_colab()

​
fonction is_notebook

is_notebook() → bool

​
fonction log_once

log_once(log_method: 'Callable[[str], None]', message: 'str') → None
Consigne un message une seule fois, en supprimant les messages suivants du même type. Cela permet de notifier l’utilisateur des erreurs sans saturer les logs. C’est surtout utile lorsque le même message d’erreur risque de se produire de nombreuses fois. Par exemple, si une op ne parvient pas à être enregistrée, cela se produira probablement chaque fois que cette op sera appelée. Ou, si une erreur se produit dans notre itérateur patché, elle se produira probablement chaque fois que nous itérerons sur le résultat. Cela nous permet d’informer l’utilisateur de l’erreur sans encombrer ses logs. Arguments :
  • log_method: La méthode à utiliser pour consigner le message. Elle doit accepter un argument de type chaîne de caractères.
  • message: Le message à consigner. Exemple :
log_once(logger.error, "Failed to save op")