> ## Documentation Index
> Fetch the complete documentation index at: https://docs.coreweave.com/llms.txt
> Use this file to discover all available pages before exploring further.
# util
> Référence du SDK Python pour weave.trace.util
export const SourceLink = ({url}) =>
Source
;
Aperçu de l’API
***
class `ContextAwareThread`
Un Thread qui exécute des fonctions avec le contexte de l’appelant.
Cette classe remplace directement threading.Thread et 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 copient pas automatiquement le contexte du parent, ce qui peut entraîner la perte du contexte d’appel -- à éviter ! Cette classe automatise la copie des contextvars afin que ce thread « fonctionne tout simplement », comme l’utilisateur s’y attend probablement.
Vous pouvez obtenir le même résultat sans cette classe en écrivant plutôt :
```python theme={"system"}
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__`
```python theme={"system"}
__init__(*args: 'Any', **kwargs: 'Any') → None
```
***
property daemon
Valeur booléenne indiquant si ce thread est un thread démon.
Elle doit être définie avant l’appel de start(), sinon une RuntimeError est levée. Sa valeur initiale est héritée du thread qui l’a créé ; le thread principal n’étant pas un thread démon, tous les threads créés dans le thread principal ont par défaut daemon = False.
Le programme Python tout entier se termine lorsqu’il ne reste plus que des threads démons.
***
property ident
Identifiant de ce thread, ou None s’il n’a pas encore é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.
***
property name
Chaîne de caractères servant uniquement à l’identification.
Elle n’a aucune valeur sémantique. Plusieurs threads peuvent porter le même nom. Le nom initial est défini par le constructeur.
***
property native\_id
ID de thread natif (entier) de ce thread, ou None s’il n’a pas été démarré.
Il s’agit d’un entier positif ou nul. Voir la fonction get\_native\_id(). Il correspond à l’ID du thread tel que renvoyé par le noyau.
***
méthode `run`
```python theme={"system"}
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 dans l’exécuteur. Weave exige que certaines contextvars soient définies (voir call\_context.py), mais les nouveaux threads ne copient pas automatiquement le contexte du thread parent, ce qui peut entraîner la perte du contexte d’appel -- pas idéal ! Cette classe automatise la copie des contextvars pour que cet exécuteur « fonctionne tout simplement », comme l’utilisateur s’y attend sans doute.
Vous pouvez obtenir le même résultat sans cette classe en écrivant :
```python theme={"system"}
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__`
```python theme={"system"}
__init__(*args: 'Any', **kwargs: 'Any') → None
```
***
méthode `map`
```python theme={"system"}
map(
fn: 'Callable',
*iterables: 'Iterable[Any]',
timeout: 'float | None' = None,
chunksize: 'int' = 1
) → Iterator
```
***
méthode `submit`
```python theme={"system"}
submit(fn: 'Callable', *args: 'Any', **kwargs: 'Any') → Any
```
***
fonction `deprecated`
```python theme={"system"}
deprecated(new_name: 'str') → Callable[[Callable[P, R]], Callable[P, R]]
```
Décorateur permettant de marquer une fonction comme obsolète et de rediriger les utilisateurs vers `new_name`.
***
fonction `is_colab`
```python theme={"system"}
is_colab()
```
***
fonction `is_notebook`
```python theme={"system"}
is_notebook() → bool
```
***
fonction `log_once`
```python theme={"system"}
log_once(log_method: 'Callable[[str], None]', message: 'str') → None
```
Journalise un message une seule fois et supprime les messages suivants du même type. Cette fonction permet de notifier l’utilisateur d’erreurs sans saturer les journaux.
Elle est surtout utile lorsque le même message d’erreur risque d’apparaître de nombreuses fois. Par exemple, si l’enregistrement d’un op échoue, l’échec se reproduira probablement à chaque appel de cet op. De même, si une erreur survient dans notre itérateur patché, elle se produira probablement à chaque itération sur le résultat. Cette fonction permet d’informer l’utilisateur de l’erreur sans encombrer ses journaux.
**Arguments :**
* `log_method` : la méthode à utiliser pour journaliser le message. Elle doit accepter un argument de type string.
* `message` : le message à journaliser.
**Exemple :**
```python theme={"system"}
log_once(logger.error, "Failed to save op")
```