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`

__init__(package: 'str', path: 'str', name: 'str') → None

`classe` `WeaveKwargs`

`fonction` `as_op`

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`

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 :

@weave.op
def add(a: int, b: int) -> int:
     return a + b

result, call = add.call(1, 2)

`fonction` `calls`

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 :

@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`

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`

is_op(obj: 'Any') → TypeIs[Op]

Vérifie si un objet est une op.

`fonction` `is_placeholder_call`

is_placeholder_call(call: 'Call') → TypeIs[NoOpCall]

`fonction` `is_tracing_setting_disabled`

is_tracing_setting_disabled() → bool

`fonction` `maybe_bind_method`

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`

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`

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`

placeholder_call() → Call

`fonction` `setup_dunder_weave_dict`

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`

should_skip_tracing_for_op(op: 'Op') → bool

​Aperçu de l’API

​classe DisplayNameFuncError

​classe OpCallError

​classe OpKwargs

​classe Sentinel

​méthode __init__

​classe WeaveKwargs

​fonction as_op

​fonction call

​fonction calls

​fonction get_captured_code

​fonction is_op

​fonction is_placeholder_call

​fonction is_tracing_setting_disabled

​fonction maybe_bind_method

​fonction maybe_unbind_method

​fonction op

​fonction placeholder_call

​fonction setup_dunder_weave_dict

​fonction should_skip_tracing_for_op