> ## Documentation Index
> Fetch the complete documentation index at: https://docs.wandb.ai/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.
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 :
```python theme={null}
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={null}
__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`
```python theme={null}
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 :
```python theme={null}
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={null}
__init__(*args: 'Any', **kwargs: 'Any') → None
```
***
### méthode `map`
```python theme={null}
map(
fn: 'Callable',
*iterables: 'Iterable[Any]',
timeout: 'float | None' = None,
chunksize: 'int' = 1
) → Iterator
```
***
### méthode `submit`
```python theme={null}
submit(fn: 'Callable', *args: 'Any', **kwargs: 'Any') → Any
```
***
### fonction `obsolète`
```python theme={null}
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`
```python theme={null}
is_colab()
```
***
### fonction `is_notebook`
```python theme={null}
is_notebook() → bool
```
***
### fonction `log_once`
```python theme={null}
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 :**
```python theme={null}
log_once(logger.error, "Failed to save op")
```