> ## 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.

# Définir le nom d'affichage d'un Appel

> Définir ou remplacer le nom d'affichage d'un Appel dans le Tracing W&B Weave

Les Ops produisent des Appels. Un Op est une fonction ou une méthode que vous décorez avec `@weave.op`. Par défaut, le nom de l'Op correspond au nom de la fonction, et les Appels associés ont le même nom d'affichage.

Un nom d'affichage personnalisé permet d'identifier plus facilement les Appels dans l'interface Weave. Utilisez-en un pour distinguer les Appels d'un même Op, faire ressortir un contexte dynamique comme des valeurs d'entrée ou des horodatages, ou aligner les noms des Appels sur les conventions de votre équipe.

Vous pouvez remplacer le nom d'affichage de tous les Appels d'un Op donné de plusieurs façons. Choisissez l'approche qui correspond à la portée dont vous avez besoin : un Appel unique, tous les Appels d'un Op, ou l'Op lui-même.

<Tabs>
  <Tab title="Python">
    1. Modifiez le nom d'affichage au moment d'appeler l'Op. L'exemple suivant utilise le dictionnaire `__weave` pour définir le nom d'affichage de l'Appel, qui prévaut sur le nom d'affichage de l'Op :

    ```python lines theme={null}
    result = my_function("World", __weave={"display_name": "My Custom Display Name"})
    ```

    2. Modifiez le nom d'affichage Appel par Appel. L'exemple suivant utilise la méthode [`Op.call`](/fr/weave/reference/python-sdk/trace/op#function-call) pour renvoyer un objet `call`. Vous pouvez ensuite utiliser cet objet pour définir le nom d'affichage avec [`call.set_display_name`](/fr/weave/reference/python-sdk/trace/weave_client#method-set_display_name) :

    ```python lines theme={null}
    result, call = my_function.call("World")
    call.set_display_name("My Custom Display Name")
    ```

    3. Modifiez le nom d'affichage de tous les Appels d'un Op donné. L'exemple suivant définit le nouveau nom d'affichage directement dans le décorateur de fonction `@weave.op` afin qu'il s'applique à tous les Appels de l'Op :

    ```python lines theme={null}
    @weave.op(call_display_name="My Custom Display Name")
    def my_function(name: str):
        return f"Hello, {name}!"
    ```

    `call_display_name` peut aussi être une fonction qui prend un objet `call` et renvoie une chaîne. Weave transmet automatiquement l'objet `call` lorsque la fonction s'exécute. Vous pouvez l'utiliser pour générer dynamiquement des noms à partir du nom de la fonction, des entrées de l'Appel, des champs, etc. Cela est utile lorsque vous voulez que le nom de chaque Appel reflète le contexte d'exécution.

    Un cas d'usage courant consiste à ajouter un horodatage au nom de la fonction.

    ```python lines theme={null}
    from datetime import datetime

    @weave.op(call_display_name=lambda call: f"{call.func_name}__{datetime.now()}")
    def func():
        return ...
    ```

    Vous pouvez également journaliser des métadonnées personnalisées avec `.attributes`.

    ```python lines theme={null}
    def custom_attribute_name(call):
        model = call.attributes["model"]
        revision = call.attributes["revision"]
        now = call.attributes["date"]

        return f"{model}__{revision}__{now}"

    @weave.op(call_display_name=custom_attribute_name)
    def func():
        return ...

    with weave.attributes(
        {
            "model": "finetuned-llama-3.1-8b",
            "revision": "v0.1.2",
            "date": "2024-08-01",
        }
    ):
        func()  # le nom d'affichage sera "finetuned-llama-3.1-8b__v0.1.2__2024-08-01"

        with weave.attributes(
            {
                "model": "finetuned-gpt-4o",
                "revision": "v0.1.3",
                "date": "2024-08-02",
            }
        ):
            func()  # le nom d'affichage sera "finetuned-gpt-4o__v0.1.3__2024-08-02"
    ```

    4. Modifiez le nom d'affichage de l'Op lui-même. Les Appels associés à un Op ont le même nom d'affichage, donc renommer l'Op est le moyen le plus direct de renommer chaque Appel qu'il produit. Si vous remplacez le nom de l'Op lui-même, le nom d'affichage de l'Appel change également. Vous pouvez le faire de deux façons :

       * Définissez la propriété `name` de l'Op avant d'enregistrer des Appels :
         ```python lines theme={null}
         my_function.name = "My Custom Op Name"
         ```

       * Définissez l'option `name` sur le décorateur de l'Op :
         ```python lines theme={null}
         @weave.op(name="My Custom Op Name")
         ```
  </Tab>

  <Tab title="TypeScript">
    Pour remplacer le nom par défaut d'un Appel, utilisez l'option `callDisplayName` lors de l'appel à `weave.op()`.

    ```typescript twoslash lines {2} theme={null}
    // @noErrors
    const extractDinosOp = weave.op(extractDinos, {
    callDisplayName: (input: string) => `Your New Display Name`
    });
    ```
  </Tab>
</Tabs>

Si vous devez renommer un Appel après l'avoir déjà enregistré, vous pouvez aussi [mettre à jour le nom d'affichage d'un Appel](/fr/weave/guides/tracking/update-call) après l'exécution.