# python: Uso de derive
URL: https://generaltranslation.com/es/docs/python/tutorials/derive.mdx
---
title: Uso de derive
description: Cómo usar derive para la concordancia gramatical, el contenido reutilizable y el análisis estático
---

## ¿Qué es `derive`?

[`derive`](/docs/python/api/derive) es una función de identidad que marca contenido para el análisis estático del CLI de GT. Cuando el CLI analiza tu código, reconoce las llamadas a `derive(...)` y determina todos los posibles valores de retorno, creando una entrada de traducción independiente para cada uno.

Esto es útil para:

* Preservar la **concordancia gramatical** entre idiomas (género, número, caso)
* **Contenido reutilizable** con llamadas a funciones dentro de cadenas traducidas
* **Frases fragmentadas** en las que una parte de la cadena tiene un conjunto conocido de posibles resultados

***

## Mantener la concordancia gramatical

Los idiomas tienen reglas gramaticales (género, número y caso) que afectan a las palabras que las rodean. Sin `derive`, una sola entrada de traducción no puede manejar la concordancia:

```python
# Sin derive — una sola traducción, sin concordancia posible
message = t(f"The {get_subject(gender)} is playing.")
# "The boy is playing." y "The girl is playing." comparten una sola traducción
```

Con `derive`, la CLI crea una entrada independiente para cada resultado:

```python
from gt_flask import derive, t

def get_subject(gender: str) -> str:
    return "boy" if gender == "male" else "girl"

message = t(f"The {derive(get_subject(gender))} is playing.")
```

Esto genera dos entradas de traducción:

* `"The boy is playing."` → `"El niño está jugando."`
* `"The girl is playing."` → `"La niña está jugando."`

Observa cómo en español se usa "El" o "La" según el sujeto: la concordancia se resuelve automáticamente.

***


## Cómo funciona

1. **En tiempo de construcción**, la CLI de GT analiza las expresiones envueltas en `derive`
2. Determina todos los valores de retorno posibles (deben poder analizarse estáticamente)
3. Crea entradas de traducción independientes para cada resultado único
4. **En runtime**, `derive` es simplemente una función identidad: devuelve su argumento sin cambios

***

## Ejemplos

### Expresiones en línea

Puedes incluir lógica directamente en `derive`:

```python
from gt_flask import derive, t

message = t(f"The {derive('boy' if gender == 'male' else 'girl')} is playing.")
```


### Llamadas a funciones

Envuelve las llamadas a funciones con un conjunto conocido de valores de retorno:

```python
from gt_flask import derive, t

def get_status_label(status: str) -> str:
    if status == "complete":
        return "completed"
    elif status == "pending":
        return "pending"
    return "unknown"

message = t(f"Task is {derive(get_status_label(status))}.")
```


### Contenido reutilizable

```python
from gt_flask import derive, t

def get_subject() -> str:
    return "boy"

translation1 = t(f"The {derive(get_subject())} is playing.")
translation2 = t(f"The {derive(get_subject())} is having fun.")
```


### Con `declare_var`

Combina `derive` con [`declare_var`](/docs/python/api/declare-var) cuando necesites contenido dinámico dentro de una expresión estática:

```python
from gt_flask import derive, declare_var, t

def get_greeting(name: str | None) -> str:
    if name:
        return f"Hello, {declare_var(name, name='user')}"
    return "Hello, stranger"

message = t(f"{derive(get_greeting(name))}! How are you?")
```

***


## Consideraciones de rendimiento

`derive` multiplica las entradas de traducción. Cada llamada con N resultados posibles crea N entradas, y varias llamadas a `derive` en la misma cadena hacen que estas se multipliquen exponencialmente. Úsalo con criterio.