Aperçu de l’API

`classe` `CrossProjectRefError`

Levée lorsque le calcul de digest côté client rencontre une référence à un autre projet qui ne peut pas être résolue en ID interne.

`classe` `FlushStatus`

Informations sur le statut de l’opération de vidage en cours.

`classe` `NoInternalProjectIDError`

Levée lorsque le calcul du digest côté client ne peut pas se poursuivre, car aucun ID de projet interne n’a encore été résolu.

`classe` `PendingJobCounts`

Nombre de jobs en attente par type.

`classe` `WeaveClient`

`méthode` `init`

__init__(
    entity: 'str',
    project: 'str',
    server: 'TraceServerClientInterface',
    ensure_project_exists: 'bool' = True
)

`propriété` num_outstanding_jobs

Renvoie le nombre total de jobs en attente sur l’ensemble des exécuteurs et le serveur. Cette propriété permet de suivre l’avancement des tâches en arrière-plan sans bloquer le thread principal. Retourne :

int: Le nombre total de jobs en attente

`méthode` `add_cost`

add_cost(
    llm_id: 'str',
    prompt_token_cost: 'float',
    completion_token_cost: 'float',
    effective_date: 'datetime | None' = None,
    prompt_token_cost_unit: 'str | None' = 'USD',
    completion_token_cost_unit: 'str | None' = 'USD',
    provider_id: 'str | None' = 'default'
) → CostCreateRes

Ajoutez un coût au projet en cours. Exemples :

client.add_cost(llm_id="my_expensive_custom_model", prompt_token_cost=1, completion_token_cost=2)
client.add_cost(llm_id="my_expensive_custom_model", prompt_token_cost=500, completion_token_cost=1000, effective_date=datetime(1998, 10, 3))

Arguments :

llm_id : L’ID du LLM. p. ex. “gpt-4o-mini-2024-07-18”
prompt_token_cost : Le coût par token du prompt. p. ex. .0005
completion_token_cost : Le coût par token de complétion. p. ex. .0015
effective_date : Valeur par défaut : la date du jour. Objet datetime.datetime.
provider_id : Le fournisseur du LLM. Valeur par défaut : “default”. p. ex. “openai”
prompt_token_cost_unit : L’unité du coût des tokens du prompt. Valeur par défaut : “USD”. (Actuellement inutilisé, sera utilisé à l’avenir pour spécifier le type d’unité du coût, p. ex. “tokens” ou “time”)
completion_token_cost_unit : L’unité du coût des tokens de complétion. Valeur par défaut : “USD”. (Actuellement inutilisé, sera utilisé à l’avenir pour spécifier le type d’unité du coût, p. ex. “tokens” ou “time”) Retourne : Un objet CostCreateRes. Il comporte un champ nommé ids, qui est une liste de tuples. Chaque tuple contient le llm_id et l’ID de l’objet de coût créé.

`méthode` `add_tags`

add_tags(obj_ref: 'ObjectRef | str', tags: 'list[str]') → None

Ajoutez des tags à une version d’objet. Arguments :

`méthode` `clear_wandb_run_context`

clear_wandb_run_context() → None

Efface la surcharge du contexte de run de wandb. Après cet appel, les appels reviendront à utiliser le wandb.run global (s’il est disponible) pour les informations de run_id et d’étape.

obj_ref: Référence à la version de l’objet, soit un ObjectRef, soit une chaîne d’URI Weave.
tags: Liste des chaînes de tag à ajouter. Exemples :

client = weave.init("my-project")
client.set_wandb_run_context(run_id="my-run-id", step=5)
# ... effectuer quelques appels ...
client.clear_wandb_run_context()
# Les appels utiliseront à nouveau le wandb.run global

`méthode` `create_call`

create_call(
    op: 'str | Op',
    inputs: 'dict[str, Any]',
    parent: 'Call | None' = None,
    attributes: 'dict[str, Any] | None' = None,
    display_name: 'str | Callable[[Call], str] | None' = None,
    use_stack: 'bool' = True,
    _call_id_override: 'str | None' = None,
    started_at: 'datetime | None' = None
) → Call

Créer, journaliser et empiler un appel sur la pile d’exécution. Arguments :

op : L’opération qui produit l’appel, ou le nom d’une opération anonyme.
inputs : Les entrées de l’opération.
parent : L’appel parent. Si parent n’est pas fourni, le run actuel est utilisé comme parent.
display_name : Le nom d’affichage de l’appel. La valeur par défaut est None.
attributes : Les attributs de l’appel. La valeur par défaut est None.
use_stack : Indique s’il faut empiler l’appel sur la pile d’exécution. La valeur par défaut est True.
started_at : Redéfinit l’heure de début de l’appel. Si None, utilise l’heure actuelle. Retourne : L’objet Appel créé.

`méthode` `delete_all_object_versions`

delete_all_object_versions(object_name: 'str') → int

Supprime toutes les versions d’un objet. Arguments :

object_name : Le nom de l’objet dont toutes les versions doivent être supprimées. Retourne : Le nombre de versions supprimées.

`méthode` `delete_all_op_versions`

delete_all_op_versions(op_name: 'str') → int

Supprime toutes les versions d’une op. Arguments :

op_name : Le nom de l’op dont les versions doivent être supprimées. Retourne : Le nombre de versions supprimées.

`méthode` `delete_call`

delete_call(call: 'Call') → None

`méthode` `delete_calls`

delete_calls(call_ids: 'list[str]') → None

Supprimez les appels à l’aide de leurs IDs. La suppression d’un appel supprime également tous ses appels enfants. Arguments :

`méthode` `delete_object_version`

delete_object_version(object: 'ObjectRef') → None

`méthode` `delete_object_versions`

delete_object_versions(object_name: 'str', digests: 'list[str]') → int

Supprime des versions spécifiques d’un objet.

call_ids : Une liste d’ID d’appel à supprimer. Ex. : [“2F0193e107-8fcf-7630-b576-977cc3062e2e”] Arguments :
object_name : Le nom de l’objet dont les versions doivent être supprimées.
digests : Liste des digests à supprimer. Peut inclure des alias comme “latest” ou “v0”. Retourne : Le nombre de versions supprimées.

`méthode` `delete_op_version`

delete_op_version(op: 'OpRef') → None

`méthode` `fail_call`

fail_call(call: 'Call', exception: 'BaseException') → None

Signale l’échec d’un appel avec une exception. Il s’agit d’une méthode utilitaire pour finish_call.

`méthode` `finish`

finish(
    use_progress_bar: 'bool' = True,
    callback: 'Callable[[FlushStatus], None] | None' = None
) → None

Vide toutes les tâches en arrière-plan afin de s’assurer qu’elles sont traitées. Cette méthode bloque jusqu’à ce que tous les jobs actuellement en file d’attente soient traités, en affichant une barre de progression pour indiquer le statut des tâches en attente. Elle permet le traitement en parallèle pendant l’exécution du thread principal et peut améliorer les performances lorsque le code utilisateur se termine avant que les données n’aient été envoyées au serveur. Arguments :

`méthode` `finish_call`

finish_call(
    call: 'Call',
    output: 'Any' = None,
    exception: 'BaseException | None' = None,
    op: 'Op | None' = None,
    ended_at: 'datetime | None' = None
) → None

Finaliser un appel et enregistrer ses résultats. Toutes les valeurs présentes dans call.summary sont fusionnées de manière récursive avec les statistiques récapitulatives calculées (par ex. les nombres d’utilisations et de statuts) avant d’être écrites dans la base de données.

`méthode` `flush`

flush() → None

Vide les tâches asynchrones en arrière-plan ; peut être appelée sans risque plusieurs fois.

`méthode` `get`

get(ref: 'ObjectRef', objectify: 'bool' = True) → Any

`méthode` `get_aliases`

get_aliases(obj_ref: 'ObjectRef | str') → list[str]

Obtenir les alias d’une version d’objet.

use_progress_bar : Indique s’il faut afficher une barre de progression pendant le vidage. Définissez-la sur False dans les environnements où une barre de progression ne s’afficherait pas correctement (par ex., les environnements CI).
callback : Fonction de rappel facultative qui reçoit des mises à jour de statut. Remplace use_progress_bar. Arguments :
obj_ref : Référence à la version de l’objet, soit un ObjectRef, soit une chaîne d’URI Weave. Retourne : Liste de chaînes d’alias. Inclut l’alias virtuel “latest” si la version de l’objet est la plus récente.

`méthode` `get_call`

get_call(
    call_id: 'str',
    include_costs: 'bool' = False,
    include_feedback: 'bool' = False,
    columns: 'list[str] | None' = None
) → WeaveObject

Obtenir un appel unique par son ID. Arguments :

call_id : L’ID de l’appel à récupérer.
include_costs : Si true, les informations de coût sont incluses dans summary.weave
include_feedback : Si true, les informations de feedback sont incluses dans summary.weave.feedback
columns : Liste des colonnes à inclure dans la réponse. Si None, toutes les colonnes sont incluses. Spécifier moins de colonnes peut améliorer les performances. Certaines colonnes sont toujours incluses id, project_id, trace_id, op_name, started_at Retourne : Un objet appel.

`méthode` `get_calls`

get_calls(
    filter: 'CallsFilterLike | None' = None,
    limit: 'int | None' = None,
    offset: 'int | None' = None,
    sort_by: 'list[SortByLike] | None' = None,
    query: 'QueryLike | None' = None,
    include_costs: 'bool' = False,
    include_feedback: 'bool' = False,
    include_storage_size: 'bool' = False,
    include_total_storage_size: 'bool' = False,
    columns: 'list[str] | None' = None,
    expand_columns: 'list[str] | None' = None,
    return_expanded_column_values: 'bool' = True,
    scored_by: 'str | list[str] | None' = None,
    page_size: 'int' = 1000
) → CallsIter

Récupère une liste d’appels tracés (opérations) pour ce projet. Cette méthode fournit une interface puissante et flexible pour interroger les données de trace. Elle prend en charge la pagination, le filtrage, le tri, la projection de champs et les métadonnées de scoring, et peut servir à créer des interfaces utilisateur de trace personnalisées ou des outils d’analyse. Conseil de performance : spécifiez columns et utilisez filter ou query pour réduire la taille des résultats. Arguments :

filter: Filtre de haut niveau permettant d’affiner les résultats à partir de champs comme op_name, parent_ids, etc.
limit: Nombre maximal d’appels à renvoyer.
offset: Nombre d’appels à ignorer avant de renvoyer les résultats (utilisé pour la pagination).
sort_by: Liste des champs selon lesquels trier les résultats (par exemple, started_at desc).
query: Expression de type Mongo pour un filtrage avancé. Tous les opérateurs Mongo ne sont pas pris en charge.
include_costs: Si True, inclut les informations de token/coût dans summary.weave.
include_feedback: Si True, inclut les retours dans summary.weave.feedback.
include_storage_size: Si True, inclut la taille de stockage d’un appel.
include_total_storage_size: Si True, inclut la taille de stockage totale d’une trace.
columns: Liste des champs à renvoyer pour chaque appel. Réduire cette liste peut considérablement améliorer les performances. (Certains champs comme id, trace_id, op_name et started_at sont toujours inclus.)
scored_by: Filtre sur un ou plusieurs évaluateurs (nom ou URI de référence). Plusieurs évaluateurs sont combinés avec un ET.
page_size: Nombre d’appels récupérés par page. Ajustez cette valeur pour optimiser les performances dans les requêtes volumineuses.

Retourne :

CallsIter: Un itérateur sur des objets Call. Prend en charge le découpage, l’itération et .to_pandas().

Exemple :

calls = client.get_calls(
     filter=CallsFilter(op_names=["my_op"]),
     columns=["inputs", "output", "summary"],
     limit=100,
)
for call in calls:
     print(call.inputs, call.output)

`méthode` `get_evaluation`

get_evaluation(uri: 'str') → Evaluation

Récupérer un objet Evaluation spécifique à partir de son URI. Les URI d’évaluation suivent généralement le format : weave:///entity/project/object/Evaluation:version Vous pouvez également obtenir l’évaluation par son nom « convivial » : get_evaluation(“Evaluation:v1”) Arguments :

uri (str) : L’identifiant de ressource unique de l’évaluation à récupérer.

Retourne :

Evaluation : L’objet Evaluation correspondant à l’URI fourni.

Exceptions levées :

TypeError : Si l’objet situé à l’URI n’est pas une instance de Evaluation.
ValueError : Si l’URI n’est pas valide ou si l’objet est introuvable.

Exemples :

client = weave.init("my-project")
evaluation = client.get_evaluation("weave:///entity/project/object/my-eval:v1")
print(evaluation.name)

`méthode` `get_evaluations`

get_evaluations() → list[Evaluation]

Récupère tous les objets Évaluation du projet actuel. Retourne :

list[Evaluation]: Une liste de tous les objets Évaluation du projet actuel. Une liste vide si aucune évaluation n’est trouvée ou si toutes les conversions échouent.

Exemples :

client = weave.init("my-project")
evaluations = client.get_evaluations()
print(f"Found {len(evaluations)} evaluations")
for eval in evaluations:
     print(f"Evaluation: {eval.name}")

`méthode` `get_feedback`

get_feedback(
    query: 'Query | str | None' = None,
    reaction: 'str | None' = None,
    offset: 'int' = 0,
    limit: 'int' = 100
) → FeedbackQuery

Interroger le projet pour obtenir des retours. Exemples :

# Récupère un objet de feedback spécifique.
# Notez que cela renvoie toujours une collection, qui est censée
# contenir zéro ou un élément(s).
client.get_feedback("1B4082A3-4EDA-4BEB-BFEB-2D16ED59AA07")

# Trouve tous les objets de feedback ayant une réaction spécifique.
client.get_feedback(reaction="👍", limit=10)

# Trouve tous les objets de feedback d'un type spécifique
# via une requête de style mongo.
from weave.trace_server.interface.query import Query

query = Query(
    **{
        "$expr": {
            "$eq": [
                {"$getField": "feedback_type"},
                {"$literal": "wandb.reaction.1"},
            ],
        }
    }
)
client.get_feedback(query=query)

Arguments :

query: Une expression de requête au format Mongo. Pour plus de simplicité, accepte également une chaîne UUID de feedback.
reaction: Pour plus de simplicité, permet de filtrer par un emoji de réaction spécifique.
offset: Le décalage à partir duquel commencer à récupérer les objets de feedback.
limit: Le nombre maximal d’objets de feedback à récupérer. Retourne : Un objet FeedbackQuery.

`méthode` `get_tags`

get_tags(obj_ref: 'ObjectRef | str') → list[str]

Obtenir les tags d’une version d’objet. Arguments :

obj_ref : Référence à la version d’objet, soit un ObjectRef, soit une chaîne d’URI weave ///. Retourne : Liste de chaînes de caractères de tag. Renvoie une liste vide si la version d’objet n’a aucun tag.

`méthode` `get_tags_and_aliases`

get_tags_and_aliases(obj_ref: 'ObjectRef | str') → tuple[list[str], list[str]]

Obtenir les tags et les alias d’une version d’objet en un appel unique. Arguments :

obj_ref : Référence à la version de l’objet, soit un ObjectRef, soit une chaîne d’URI weave:///. Retourne : Un tuple (tags, alias). Chacun correspond à une liste de chaînes. Renvoie des listes vides si la version de l’objet n’a ni tags ni alias.

`méthode` `list_aliases`

list_aliases() → list[str]

Listez tous les alias distincts du projet. Retourne : Liste de tous les alias du projet sous forme de chaînes.

list_tags() → list[str]

Listez tous les tags distincts du projet. Retourne : Liste de toutes les chaînes de caractères des tags du projet.

`méthode` `purge_costs`

purge_costs(ids: 'list[str] | str') → None

Supprime les coûts du projet actuel. Exemples :

client.purge_costs([ids])
client.purge_costs(ids)

Arguments :

`méthode` `query_costs`

query_costs(
    query: 'Query | str | None' = None,
    llm_ids: 'list[str] | None' = None,
    offset: 'int' = 0,
    limit: 'int' = 100
) → list[CostQueryOutput]

Interroge le projet pour récupérer les coûts.

ids : les ID de coûts à purger. Peut s’agir d’un seul ID ou d’une liste d’ID. Exemples :

# Récupère un objet de coût spécifique.
# Notez que cela renvoie toujours une collection, qui est censée
# contenir zéro ou un élément.
client.query_costs("1B4082A3-4EDA-4BEB-BFEB-2D16ED59AA07")

# Trouve tous les objets de coût avec une réaction spécifique.
client.query_costs(llm_ids=["gpt-4o-mini-2024-07-18"], limit=10)

Arguments :

query : Une expression de requête de type Mongo. Pour plus de commodité, accepte également un UUID de coût sous forme de chaîne.
llm_ids : Pour plus de commodité, permet de filtrer sur un ensemble de llm_ids.
offset : Le décalage à partir duquel commencer à récupérer les objets de coût.
limit : Le nombre maximal d’objets de coût à récupérer. Retourne : Un objet CostQuery.

`méthode` `remove_aliases`

remove_aliases(obj_ref: 'ObjectRef | str', alias: 'str | list[str]') → None

Supprimez un ou plusieurs alias d’un objet. Arguments :

`méthode` `remove_tags`

remove_tags(obj_ref: 'ObjectRef | str', tags: 'list[str]') → None

Supprimez les tags d’une version d’objet.

obj_ref : Référence à l’objet, soit un ObjectRef, soit une chaîne d’URI Weave (le digest n’est pas utilisé, car les alias ont une portée limitée à l’objet).
alias : Nom d’alias ou liste de noms d’alias à supprimer. Arguments :

`méthode` `save`

save(val: 'Any', name: 'str', branch: 'str' = 'latest') → Any

N’appelez pas directement cette méthode ; utilisez plutôt weave.publish().

obj_ref : Référence vers la version de l’objet, soit un ObjectRef, soit une chaîne d’URI weave ///.
tags : Liste des chaînes de caractères des tags à supprimer. Arguments :
val : L’objet à enregistrer.
name : Le nom sous lequel enregistrer l’objet.
branch : La branche sous laquelle enregistrer l’objet. La valeur par défaut est “latest”. Retourne : Une version désérialisée de l’objet enregistré.

`méthode` `set_aliases`

set_aliases(obj_ref: 'ObjectRef | str', alias: 'str | list[str]') → None

Définissez un ou plusieurs alias pour une version d’objet. Arguments :

`méthode` `set_wandb_run_context`

set_wandb_run_context(run_id: 'str', step: 'int | None' = None) → None

Surcharge le run_id wandb et l’étape pour les appels créés par ce client. Cela vous permet d’associer des appels Weave à un run wandb spécifique qui n’est pas rattaché au symbole global wandb.run.

obj_ref: Référence vers la version de l’objet, soit un ObjectRef, soit une chaîne d’URI weave ///.
alias: Un nom d’alias ou une liste de noms d’alias à définir (par exemple, “production”). Arguments :
run_id: L’ID du run (sans le préfixe entité/projet). Le client ajoutera automatiquement le préfixe entité/projet.
step: Le numéro d’étape à utiliser pour les appels. Si None, l’étape ne sera pas définie. Exemples :

client = weave.init("my-project")
client.set_wandb_run_context(run_id="my-run-id", step=5)
# Tous les appels seront désormais associés à entity/project/my-run-id à l'étape 5

# Ou sans étape
client.set_wandb_run_context(run_id="my-run-id")
# Les appels seront associés à entity/project/my-run-id sans étape

`fonction` `get_obj_name`

get_obj_name(val: 'Any') → str

`fonction` `get_parallelism_settings`

get_parallelism_settings() → tuple[int | None, int | None]

`fonction` `map_to_refs`

map_to_refs(obj: 'Any') → Any

`fonction` `print_call_link`

print_call_link(call: 'Call') → None

`fonction` `redact_sensitive_keys`

redact_sensitive_keys(obj: 'Any') → Any

`fonction` `sanitize_object_name`

sanitize_object_name(name: 'str') → str

​Aperçu de l’API

​classe CrossProjectRefError

​classe FlushStatus

​classe NoInternalProjectIDError

​classe PendingJobCounts

​classe WeaveClient

​méthode __init__

​propriété num_outstanding_jobs

​méthode add_cost

​méthode add_tags

​méthode clear_wandb_run_context

​méthode create_call

​méthode delete_all_object_versions

​méthode delete_all_op_versions

​méthode delete_call

​méthode delete_calls

​méthode delete_object_version

​méthode delete_object_versions

​méthode delete_op_version

​méthode fail_call

​méthode finish

​méthode finish_call

​méthode flush

​méthode get

​méthode get_aliases

​méthode get_call

​méthode get_calls

​méthode get_evaluation

​méthode get_evaluations

​méthode get_feedback

​méthode get_tags

​méthode get_tags_and_aliases

​méthode list_aliases

​méthode list_tags

​méthode purge_costs

​méthode query_costs

​méthode remove_aliases

​méthode remove_tags

​méthode save

​méthode set_aliases

​méthode set_wandb_run_context

​fonction get_obj_name

​fonction get_parallelism_settings

​fonction map_to_refs

​fonction print_call_link

​fonction redact_sensitive_keys

​fonction sanitize_object_name

Aperçu de l’API

`classe` `CrossProjectRefError`

`classe` `FlushStatus`

`classe` `NoInternalProjectIDError`

`classe` `PendingJobCounts`

`classe` `WeaveClient`

`méthode` `init`

`propriété` num_outstanding_jobs

`méthode` `add_cost`

`méthode` `add_tags`

`méthode` `clear_wandb_run_context`

`méthode` `create_call`

`méthode` `delete_all_object_versions`

`méthode` `delete_all_op_versions`

`méthode` `delete_call`

`méthode` `delete_calls`

`méthode` `delete_object_version`

`méthode` `delete_object_versions`

`méthode` `delete_op_version`

`méthode` `fail_call`

`méthode` `finish`

`méthode` `finish_call`

`méthode` `flush`

`méthode` `get`

`méthode` `get_aliases`

`méthode` `get_call`

`méthode` `get_calls`

`méthode` `get_evaluation`

`méthode` `get_evaluations`

`méthode` `get_feedback`

`méthode` `get_tags`

`méthode` `get_tags_and_aliases`

`méthode` `list_aliases`

`méthode` `list_tags`

`méthode` `purge_costs`

`méthode` `query_costs`

`méthode` `remove_aliases`

`méthode` `remove_tags`

`méthode` `save`

`méthode` `set_aliases`

`méthode` `set_wandb_run_context`

`fonction` `get_obj_name`

`fonction` `get_parallelism_settings`

`fonction` `map_to_refs`

`fonction` `print_call_link`

`fonction` `redact_sensitive_keys`

`fonction` `sanitize_object_name`