Passer au contenu principal

​
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