> ## Documentation Index
> Fetch the complete documentation index at: https://wb-21fd5541-docs-sandboxes-integrations-placement.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# op
> Référence du SDK Python pour weave.trace.op
export const SourceLink = ({url}) =>
Source
;
# Aperçu de l’API
***
## classe `DisplayNameFuncError`
***
## classe `OpCallError`
***
## classe `OpKwargs`
TypedDict des arguments nommés de op().
***
## classe `Sentinel`
Sentinel(package: 'str', path: 'str', name: 'str')
### méthode `__init__`
```python theme={null}
__init__(package: 'str', path: 'str', name: 'str') → None
```
***
## classe `WeaveKwargs`
***
### fonction `as_op`
```python theme={null}
as_op(fn: 'Callable[P, R]') → Op[P, R]
```
Étant donné une fonction décorée avec @weave.op, renvoie son Op.
Les fonctions décorées avec @weave.op sont déjà des instances d’Op ; cette fonction ne devrait donc être sans effet à l’exécution. Vous pouvez toutefois l’utiliser pour satisfaire les vérificateurs de types si vous devez accéder aux attributs d’OpDef de manière sûre du point de vue du typage.
**Arguments :**
* `fn`: Une fonction décorée avec @weave.op.
**Retourne :**
L’Op de la fonction.
***
### fonction `call`
```python theme={null}
call(
op: 'Op',
*args: 'Any',
__weave: 'WeaveKwargs | None' = None,
__should_raise: 'bool' = False,
__require_explicit_finish: 'bool' = False,
**kwargs: 'Any'
) → tuple[Any, Call] | Coroutine[Any, Any, tuple[Any, Call]]
```
Exécute l'op et renvoie à la fois le résultat et un Appel représentant l'exécution.
Cette fonction ne lèvera jamais d'exception. Toute erreur est capturée dans l'objet Appel.
Cette méthode est automatiquement associée à toute fonction décorée avec `@weave.op`, ce qui permet une utilisation comme suit :
```python theme={null}
@weave.op
def add(a: int, b: int) -> int:
return a + b
result, call = add.call(1, 2)
```
***
### fonction `calls`
```python theme={null}
calls(op: 'Op') → CallsIter
```
Obtenez un itérateur de tous les appels à cet op.
Cette méthode est automatiquement associée à toute fonction décorée par `@weave.op`, ce qui permet une utilisation comme :
```python theme={null}
@weave.op
def add(a: int, b: int) -> int:
return a + b
calls = add.calls()
for call in calls:
print(call)
```
***
### fonction `get_captured_code`
```python theme={null}
get_captured_code(op: 'Op') → str
```
Obtenir le code capturé de l’op.
Cela fonctionne uniquement lorsque vous obtenez un op depuis une ref. Le schéma est le suivant :
ref = weave.publish(func) op = ref.get() captured\_code = op.get\_captured\_code()
***
### fonction `is_op`
```python theme={null}
is_op(obj: 'Any') → TypeIs[Op]
```
Vérifie si un objet est une op.
***
### fonction `is_placeholder_call`
```python theme={null}
is_placeholder_call(call: 'Call') → TypeIs[NoOpCall]
```
***
### fonction `is_tracing_setting_disabled`
```python theme={null}
is_tracing_setting_disabled() → bool
```
***
### fonction `maybe_bind_method`
```python theme={null}
maybe_bind_method(func: 'Callable', self: 'Any' = None) → Callable | MethodType
```
Associez une fonction à n’importe quel objet (même s’il ne s’agit pas d’une classe).
Si self est None, renvoyez la fonction telle quelle.
***
### fonction `maybe_unbind_method`
```python theme={null}
maybe_unbind_method(oplike: 'Op | MethodType | partial') → Op
```
Délie une méthode de type op ou une fonction partielle pour obtenir une fonction op simple.
Pour :
* les méthodes, supprime le paramètre `self` prédéfini
* les fonctions partielles, supprime tous les paramètres prédéfinis
***
### fonction `op`
```python theme={null}
op(
func: 'Callable[P, R] | None' = None,
name: 'str | None' = None,
call_display_name: 'str | CallDisplayNameFunc | None' = None,
postprocess_inputs: 'PostprocessInputsFunc | None' = None,
postprocess_output: 'PostprocessOutputFunc | None' = None,
tracing_sample_rate: 'float' = 1.0,
enable_code_capture: 'bool' = True,
accumulator: 'Callable[[Any | None, Any], Any] | None' = None,
kind: 'OpKind | None' = None,
color: 'OpColor | None' = None,
eager_call_start: 'bool' = False
) → Callable[[Callable[P, R]], Op[P, R]] | Op[P, R]
```
Un décorateur pour convertir une fonction ou une méthode en op Weave. Fonctionne aussi bien en synchrone qu'en asynchrone. Détecte automatiquement les fonctions itératrices et applique le comportement approprié.
**Arguments :**
***
### fonction `placeholder_call`
```python theme={null}
placeholder_call() → Call
```
***
### fonction `setup_dunder_weave_dict`
```python theme={null}
setup_dunder_weave_dict(op: 'Op', d: 'WeaveKwargs | None' = None) → WeaveKwargs
```
Configure un dict \_\_weave utilisé pour transmettre des WeaveKwargs aux ops.
* `func` : La fonction à décorer.
* `name` : Nom personnalisé pour l’op. Valeur par défaut : le nom de la fonction.
* `call_display_name` : Nom d’affichage des appels, peut être une chaîne ou un callable.
* `postprocess_inputs` : Fonction pour transformer les entrées avant la journalisation.
* `postprocess_output` : Fonction pour transformer la sortie avant la journalisation.
* `tracing_sample_rate` : Fraction des appels à tracer (de 0.0 à 1.0).
* `enable_code_capture` : Indique s’il faut capturer le code source pour cet op.
* `accumulator` : Fonction pour accumuler les résultats pour les ops de flux.
* `eager_call_start` : Si True, les démarrages d’appel sont envoyés immédiatement au lieu d’être regroupés par lots. Utile pour les opérations de longue durée comme les évaluations, qui doivent être visibles immédiatement dans l’interface utilisateur.
**Arguments :**
* `d` : dict WeaveKwargs existant facultatif à mettre à jour.
* `op` : op à partir duquel extraire kind et color.
**Retourne :**
dict WeaveKwargs avec attributes, display\_name et, éventuellement, kind/color définis.
***
### fonction `should_skip_tracing_for_op`
```python theme={null}
should_skip_tracing_for_op(op: 'Op') → bool
```