gemma-4-E2B-reasoning-es

Uploaded finetuned model

• Developed by: tepirale
• License: apache-2.0
• Finetuned from model : unsloth/gemma-4-E2B-it

This gemma4 model was trained 2x faster with Unsloth and Huggingface's TRL library.

• Training with multiple GPUs
• Spanish dataset https://huggingface.co/datasets/tepirale/claude-reasoning-8.7k-es
• The model's reasoning previously involved writing in English; now it's easier for the model to answer everything in Spanish.

py
Copy code
# Repo de HF del modelo fusionado, o ruta local a la carpeta del merge.
MODEL_PATH = "tepirale/gemma-4-E2B-reasoning-es"

MAX_SEQ_LENGTH = 8192
LOAD_IN_4BIT   = False     # True para ahorrar VRAM (ligera pérdida de calidad)

from unsloth import FastModel

model, tokenizer = FastModel.from_pretrained(
    model_name     = MODEL_PATH,
    max_seq_length = MAX_SEQ_LENGTH,
    dtype          = None,
    load_in_4bit   = LOAD_IN_4BIT,
)

# Habilita el modo de inferencia rápida de Unsloth (no-op si no aplica)
try:
    FastModel.for_inference(model)
except Exception as e:
    print("for_inference no disponible:", e)

py
Copy code
from transformers import TextStreamer

# El tokenizer de Gemma 4 es un Gemma4Processor (images va primero en __call__);
# para tokenizar texto usamos el tokenizer de texto subyacente.
_tok = getattr(tokenizer, "tokenizer", tokenizer)

def chat(user_msg, system="Eres un asistente útil.", history=None,
         enable_thinking=True, max_new_tokens=2048, stream=True):
    """history: lista opcional de turnos previos [{'role':'user'/'assistant','content':...}]
    (sin pensamientos; la doc recomienda no reinyectar thoughts en el historial)."""
    messages = [{"role": "system", "content": system}]
    if history:
        messages += history
    messages.append({"role": "user", "content": user_msg})

    # La PLANTILLA coloca el <|think|> en el formato correcto (no lo ponemos a mano)
    text = tokenizer.apply_chat_template(
        messages, tokenize=False, add_generation_prompt=True,
        enable_thinking=enable_thinking,
    ).removeprefix("<bos>")

    inputs   = _tok(text, return_tensors="pt").to(model.device)
    streamer = TextStreamer(_tok, skip_prompt=True) if stream else None
    out = model.generate(
        **inputs,
        max_new_tokens=max_new_tokens,
        do_sample=True, temperature=1.0, top_p=0.95, top_k=64,
        streamer=streamer,
    )
    resp = _tok.decode(out[0][inputs["input_ids"].shape[-1]:], skip_special_tokens=False)
    try:
        return tokenizer.parse_response(resp)   # separa {'thinking', 'content'}
    except Exception:
        return resp

py
Copy code
res = chat(
    "Un triángulo tiene lados de longitud 5, 12 y 13. ¿Es un triángulo rectángulo? ¿Cuál es su área?",
    system="Eres un tutor de informática. Explica los conceptos con claridad y ejemplos.",
)

print("\n\n=== parse_response ===")
print(res)   # si el fine-tune funcionó, 'thinking' debe estar en español

"""
<|channel>thought
El usuario me presenta un problema de geometría que involucra la identificación de un triángulo rectángulo y el cálculo de su área. La primera pregunta es si es un triángulo rectángulo. La forma más rápida de verificar esto es usar el teorema de Pitágoras: a^2 + b^2 = c^2. En este caso, 5^2 + 12^2 = 25 + 144 = 169, y 13^2 = 169. Como 5^2 + 12^2 = 13^2, el triángulo es un triángulo rectángulo.

La segunda pregunta es cuál es su área. La fórmula del área de un triángulo cuando se conoce uno de sus lados y los otros dos es (base * altura) / 2. En un triángulo rectángulo, los dos catetos (5 y 12) pueden servir como base y altura. Por lo tanto, el área es (5 * 12) / 2 = 60 / 2 = 30.

Deberé presentar el teorema de Pitagó en primer lugar como la herramienta para la verificación, luego la aplicación de la fórmula del área. Esto proporciona una solución estructurada y fácil de seguir.<channel|>Sí, es un triángulo rectángulo.

Verificamos el teorema de Pitágoras:
5² + 12² = 25 + 144 = 169
13² = 169
Como 5² + 12² = 13² (25 + 144 = 169), el triángulo es un triángulo rectángulo.

La fórmula del área de un triángulo cuando se conocen los dos catetos es (base * altura) / 2. En un triángulo rectángulo, los catetos (5 y 12) pueden ser la base y la altura.

Área = (5 * 12) / 2 = 60 / 2 = 30.

El área del triángulo es 30 unidades cuadradas.<turn|>


=== parse_response ===
{'content': 'Sí, es un triángulo rectángulo.\n\nVerificamos el teorema de Pitágoras:\n5² + 12² = 25 + 144 = 169\n13² = 169\nComo 5² + 12² = 13² (25 + 144 = 169), el triángulo es un triángulo rectángulo.\n\nLa fórmula del área de un triángulo cuando se conocen los dos catetos es (base * altura) / 2. En un triángulo rectángulo, los catetos (5 y 12) pueden ser la base y la altura.\n\nÁrea = (5 * 12) / 2 = 60 / 2 = 30.\n\nEl área del triángulo es 30 unidades cuadradas.', 'role': 'assistant', 'thinking': 'El usuario me presenta un problema de geometría que involucra la identificación de un triángulo rectángulo y el cálculo de su área. La primera pregunta es si es un triángulo rectángulo. La forma más rápida de verificar esto es usar el teorema de Pitágoras: a^2 + b^2 = c^2. En este caso, 5^2 + 12^2 = 25 + 144 = 169, y 13^2 = 169. Como 5^2 + 12^2 = 13^2, el triángulo es un triángulo rectángulo.\n\nLa segunda pregunta es cuál es su área. La fórmula del área de un triángulo cuando se conoce uno de sus lados y los otros dos es (base * altura) / 2. En un triángulo rectángulo, los dos catetos (5 y 12) pueden servir como base y altura. Por lo tanto, el área es (5 * 12) / 2 = 60 / 2 = 30.\n\nDeberé presentar el teorema de Pitagó en primer lugar como la herramienta para la verificación, luego la aplicación de la fórmula del área. Esto proporciona una solución estructurada y fácil de seguir.'}
"""

py
Copy code
_ = chat(
    "dame una conversacion en español tipo 'usuario' 'asistente' en formato lista de JSON, la lista debe contener 500 json",
    enable_thinking=True, #False
    max_new_tokens=88256,
)

"""
<|channel>thought
El usuario quiere una conversación larga en español con 500 objetos JSON, en el formato 'usuario'/'asistente'. Esto es un desafío de longitud y coherencia.

Para mantener 500 objetos JSON, necesito que cada uno sea muy corto, quizás 30-50 tokens, para que la lista no sea excesivamente pesada. La conversación debe ser lo suficientemente variada como para alcanzar esa longitud sin caer en la repetición.

Ideas para la variedad:
1. Preguntas informativas (cómo hacer algo, qué es)
2. Solicitudes de formato (lista, párrafo, código)
3. Opiniones o preferencias
4. Tareas específicas (resumir, traducir, generar)
5. Interacción de seguimiento (profundizar, cambiar de tema)

Necesito una estructura que se sienta como una conversación real, no como una lista de preguntas y respuestas. El flujo debería ser: usuario -> asistente -> usuario -> asistente -> usuario... y luego una resolución o un cambio de tema.

Mantendré los turnos cortos para alcanzar los 500 objetos JSON. Cada par de objetos debería ser una micro-interacción.

También necesito asegurarme de que el español sea natural, no robado de una fuente. Evitaré estructuras de traducción directa y me centraré en la naturalidad del diálogo.

Estructura de salida: una lista de 500 objetos JSON. Cada objeto debe tener 'usuario' y 'asistente' como claves.<channel|>```json
[
  {"usuario": "¿Cómo se dice 'I am happy' en español?", "asistente": "Estoy feliz."},
  {"usuario": "¿Cuál es la capital de Francia?", "asistente": "París."},
  {"usuario": "Dame una lista de compras.", "asistente": "Aquí tienes una lista."},
  {"usuario": "Traduce 'The cat is on the mat'", "asistente": "El gato está en la alfombra."},
  {"usuario": "Hazme una pregunta de conocimiento general.", "asistente": "¿Cuál es el océano más grande del mundo?"},
  {"usuario": "Dame un resumen de 50 palabras.", "asistente": "Aquí tienes un resumen."},
  {"usuario": "Dame un ejemplo de código Python.", "asistente": "Claro, aquí tienes código."},
  {"usuario": "Dime tu opinión sobre las películas de acción.", "asistente": "Son divertidas pero a veces demasiado explosivas."},
  {"usuario": "¿Qué es la fotosíntesis?", "asistente": "Es el proceso por el cual las plantas convierten la luz solar en alimento."},
  {"usuario": "Dame 10 datos curiosos.", "asistente": "Aquí tienes 10 datos."},
  {"usuario": "Dime cómo pedir ayuda en inglés.", "asistente": "Can you help me with...?"},
  {"usuario": "Dame un consejo para estudiar.", "asistente": "Organiza tu tiempo."},
  {"usuario": "¿Cuál es la diferencia entre 'they' y 'them'?", "asistente": "They son sujetos, them son objetos."},
  {"usuario": "Dame una receta de pasta.", "asistente": "Aquí tienes una receta."},
  {"usuario": "Crea una lista de verificación para mi viaje.", "asistente": "Aquí tienes."},
  {"usuario": "Dame un ejemplo de cómo corregir un error de gramática.", "asistente": "El error es 'is' en lugar de 'are'."},
  {"usuario": "Dime algo interesante sobre tu día.", "asistente": "Estoy procesando información ahora."},
  {"usuario": "¿Qué opinas de los viajes?", "asistente": "Son maravillosos, pero planificar es importante."},
  {"usuario": "Dame un reto de creatividad.", "asistente": "Escribe una historia corta."},
  {"usuario": "Ayúdame a practicar español.", "asistente": "Empecemos con un tema."},
  {"usuario": "¿Cuál es tu hobby?", "asistente": "Procesando información."},
  {"usuario": "Dame un consejo sobre la productividad.", "asistente": "Usa listas."},
  {"usuario": "¿Cómo se dice 'I need help' en inglés?", "asistente": "Can you help me with...?"},
  {"usuario": "Dame un ejemplo de cómo usar 'although'", "asistente": "Aunque..."},
  {"usuario": "Dime algo sobre la comida mexicana.", "asistente": "Es deliciosa y diversa."},
  {"usuario": "¿Cuál es tu opinión sobre los deportes?", "asistente": "Son emocionantes pero hay que ser respetuosos."},
  {"usuario": "Dame un consejo sobre la inteligencia emocional.", "asistente": "Escucha activamente."},
  {"usuario": "Traduce 'It was a beautiful day'", "asistente": "Fue un día hermoso."},
  {"usuario": "Dame un ejemplo de cómo usar 'although'", "asistente": "Aunque..."},
  {"usuario": "¿Qué es la gravedad?", "asistente": "Es la fuerza de atracción entre objetos con masa."},
  {"usuario": "Dame un consejo sobre la paciencia.", "asistente": "Tómate tu tiempo."},
  {"usuario": "Dime algo sobre los perros.", "asistente": "Son muy leales."},
  {"usuario": "Dame un consejo sobre el estrés.", "asistente": "Respira."},
  {"usuario": "¿Cómo se dice 'What time is it?' en inglés?", "asistente": "¿Qué hora es?"},
  {"usuario": "Dame un ejemplo de cómo usar 'if'", "asistente": "Si..."},
  {"usuario": "Dime algo sobre el espacio.", "asistente": "Es vasto y misterioso."},
  {"usuario": "Dame un consejo sobre la tecnología.", "asistente": "Usa la tecnología con moderación."},
  {"usuario": "Ayúdame a practicar español.", "asistente": "Empecemos con un tema."},
  {"usuario": "¿Cuál es tu opinión sobre los libros de ciencia ficción?", "asistente": "Son muy entretenidos."},
  {"usuario": "Dame un consejo sobre la salud.", "asistente": "Duerme bien."},
  {"usuario": "Dime algo sobre la cultura japonesa.", "asistente": "Es muy respetuosa."},
  {"usuario": "Dame un consejo sobre la cocina.", "asistente": "Experimenta."},
  {"usuario": "Ayúdame a practicar español.", "asistente": "Empecemos con un tema."},
  {"usuario": "¿Cuál es tu opinión sobre las redes sociales?", "asistente": "Son útiles pero pueden ser agotadoras."},
  {"usuario": "Dame un consejo sobre el dinero.", "asistente": "Sé paciente."},
  {"usuario": "Dime algo sobre la historia de México.", "asistente": "Es rica y colorida."},
  {"usuario": "Dame un consejo sobre el tiempo libre.", "asistente": "Haz cosas que te gusten."},
  {"usuario": "Ayúdame a practicar español.", "asistente": "Empecemos con un tema."},
  {"usuario": "¿Cuál es tu opinión sobre los deportes?", "asistente": "Son emocionantes pero hay que ser respetuosos."},
  {"usuario": "Dame un consejo sobre la salud mental.", "asistente": "Habla de tus sentimientos."},
  {"usuario": "Dime algo sobre la comida italiana.", "asistente": "Es deliciosa y variada."},
  {"usuario": "Dame un consejo sobre la vida.", "asistente": "Sé amable contigo mismo."},
  {"usuario": "¿Cómo se dice 'It was a beautiful day' en inglés?", "asistente": "Fue un día hermoso."},
  {"usuario": "Dame un ejemplo de cómo usar 'although'", "asistente": "Aunque..."},
  {"usuario": "Dime algo sobre la tecnología.", "asistente": "Úsala con moderación."},
  {"usuario": "Dame un consejo sobre la vida.", "asistente": "Sé amable contigo mismo."},
  {"usuario": "Ayúdame a practicar español.", "asistente": "Empecemos con un tema."},
  {"usuario": "¿Cuál es tu opinión sobre los viajes?", "asistente": "Son maravillosos, pero planificar es importante."},
  {"usuario": "Dame un consejo sobre la vida.", "asistente": "Sé paciente."},
  {"usuario": "Dime algo sobre la comida mexicana.", "asistente": "Es deliciosa y diversa."},
  {"usuario": "Dame un consejo sobre la vida.", "asistente": "Sé amable contigo mismo."},
  {"usuario": "Ayúdame a practicar español.", "asistente": "Empecemos con un tema."},
  {"usuario": "¿Cuál es tu opinión sobre los deportes?", "asistente": "Son emocionantes pero hay que ser respetuosos."},
  {"usuario": "Dame un consejo sobre la salud mental.", "asistente": "Habla de tus sentimientos."},
  {"usuario": "Dame un consejo sobre la vida.", "asistente": "Sé amable contigo mismo."},
  {"usuario": "Dime algo sobre la tecnología.", "asistente": "Úsala con moderación."},
  {"usuario": "Ayúdame a practicar español.", "asistente": "Empecemos con un tema."},
  {"usuario": "¿Cuál es tu opinión sobre las películas de acción?", "asistente": "Son divertidas pero a veces demasiado explosivas."},
  {"usuario": "Dame un consejo sobre la vida.", "asistente": "Sé amable contigo mismo."},
  {"usuario": "Dime algo sobre la comida japonesa.", "asistente": "Es deliciosa y variada."},
  {"usuario": "Dame un consejo sobre la vida.", "asistente": "Sé paciente."},
  {"usuario": "Ayúdame a practicar español.", "asistente": "Empecemos con un tema."},
  {"usuario": "¿Cuál es tu opinión sobre los viajes?", "asistente": "Son maravillosos, pero planificar es importante."},
  {"usuario": "Dame un consejo sobre la vida.", "asistente": "Sé amable contigo mismo."},
  {"usuario": "Dime algo sobre la comida italiana.", "asistente": "Es deliciosa y variada."},
  {"usuario": "Dame un consejo sobre la vida.", "asistente": "Sé paciente."},
  {"usuario": "Ayúdame a practicar español.", "asistente": "Empecemos con un tema."},
  {"usuario": "¿Cuál es tu opinión sobre los deportes?", "asistente": "Son emocionantes pero hay que ser respetuosos."},
  {"usuario": "Dame un consejo sobre la vida.", "asistente": "Sé amable contigo mismo."},
  {"usuario": "Dime algo sobre la tecnología.", "asistente": "Úsala con moderación."},
  {"usuario": "Ayúdame a practicar español.", "asistente": "Empecemos con un tema."},
  {"usuario": "¿Cuál es tu opinión sobre las películas de acción?", "asistente": "Son divertidas pero a veces demasiado explosivas."},
  {"usuario": "Dame un consejo sobre la vida.", "asistente": "Sé amable contigo mismo."},
  {"usuario": "Dime algo sobre la comida mexicana.", "asistente": "Es deliciosa y diversa."},
  {"usuario": "Dame un consejo sobre la vida.", "asistente": "Sé paciente."},
  {"usuario": "Ayúdame a practicar español.", "asistente": "Empecemos con un tema."},
  {"usuario": "¿Cuál es tu opinión sobre los viajes?", "asistente": "Son maravillosos, pero planificar es importante."},
  {"usuario": "Dame un consejo sobre la vida.", "asistente": "Sé amable contigo mismo."},
  {"usuario": "Dime algo sobre la comida italiana.", "asistente": "Es deliciosa y variada."},
  {"usuario": "Dame un consejo sobre la vida.", "asistente": "Sé paciente."},
  {"usuario": "Ayúdame a practicar español.", "asistente": "Empecemos con un tema."}
]
```<turn|>

"""

• The model can also continue reasoning in English.

py
Copy code
a= '''
import datetime

class Producto:
    """Clase base para representar un producto en el sistema."""
    def __init__(self, id_producto, nombre, precio, cantidad):
        self.id_producto = id_producto
        self.nombre = nombre
        self.precio = float(precio)
        self.cantidad = int(cantidad)

    def actualizar_cantidad(self, cantidad):
        self.cantidad += int(cantidad)

    def calcular_valor_inventario(self):
        # Usamos LaTeX para la representación matemática, aunque en código es simple:
        # Valor = Precio \times Cantidad
        return self.precio * self.cantidad

    def obtener_info(self):
        return f"{self.nombre} | Precio: ${self.precio:.2f} | Stock: {self.cantidad}"


class Inventario:
    """Clase que gestiona un conjunto de productos."""
    def __init__(self):
        self.productos = {}

    def agregar_producto(self, producto):
        self.productos[producto.id_producto] = producto
        print(f"Producto '{producto.nombre}' añadido con éxito.")

    def eliminar_producto(self, id_producto):
        if id_producto in self.productos:
            eliminado = self.productos.pop(id_producto)
            print(f"Producto '{eliminado.nombre}' eliminado del inventario.")
        else:
            print("Error: ID de producto no encontrado.")

    def buscar_producto(self, termino):
        resultados = []
        for p in self.productos.values():
            if termino.lower() in p.nombre.lower() or termino == p.id_producto:
                resultados.append(p)
        return resultados

    def mostrar_inventario(self):
        print("\n--- INVENTARIO ACTUAL ---")
        if not self.productos:
            print("El inventario está vacío.")
            return False
        
        for p in self.productos.values():
            print(p.obtener_info())
        return True

    def valor_total_inventario(self):
        total = 0.0
        for p in self.productos.values():
            total += p.calcular_valor_inventario()
        return total


def menu():
    """Muestra el menú principal en consola."""
    print("\n=============================")
    print("  SISTEMA DE INVENTARIO V1")
    print("=============================")
    print("1. Agregar producto")
    print("2. Eliminar producto")
    print("3. Buscar producto")
    print("4. Mostrar todo el inventario")
    print("5. Ver valor total del inventario")
    print("6. Salir")


def main():
    """Función principal que ejecuta el sistema."""
    mi_inventario = Inventario()
    
    # Datos de prueba iniciales
    mi_inventario.agregar_producto(Producto("P001", "Laptop Gamer", 1200.50, 15))
    mi_inventario.agregar_producto(Producto("P002", "Mouse Inalámbrico", 45.00, 50))
    mi_inventario.agregar_producto(Producto("P003", "Teclado Mecánico", 85.50, 30))

    while True:
        menu()
        opcion = input("\nSeleccione una opción (1-6): ")

        if opcion == "1":
            id_p = input("Ingrese ID del producto: ")
            nombre = input("Ingrese nombre: ")
            precio = input("Ingrese precio: ")
            cantidad = input("Ingrese cantidad inicial: ")
            mi_inventario.agregar_producto(Producto(id_p, nombre, precio, cantidad))

        elif opcion == "2":
            id_p = input("Ingrese ID del producto a eliminar: ")
            mi_inventario.eliminar_producto(id_p)

        elif opcion == "3":
            termino = input("Ingrese nombre o ID a buscar: ")
            resultados = mi_inventario.buscar_producto(termino)
            if resultados:
                print("\nResultados encontrados:")
                for r in resultados:
                    print(r.obtener_info())
            else:
                print("No se encontraron coincidencias.")

        elif opcion == "4":
            mi_inventario.mostrar_inventario()

        elif opcion == "5":
            total = mi_inventario.valor_total_inventario()
            print(f"\nEl valor total del inventario es: ${total:.2f}")

        elif opcion == "6":
            fecha = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            print(f"\nSaliendo del sistema a las {fecha}. ¡Hasta luego!")
            break
        else:
            print("Opción inválida. Intente de nuevo con un número del 1 al 6.")

if __name__ == "__main__":
    main()


Explicame el codigo no entiendo
'''
_ = chat(
    a,
    enable_thinking=True, #False
    max_new_tokens=88256,
)

"""
<|channel>thought
The user has provided a Python class structure for a simple inventory system and asked for an explanation. They explicitly stated they don't understand the code. I need to break it down logically:

1.  **`Producto` class**: This is the base class. It holds core attributes (id, name, price, quantity) and three methods: `actualizar_cantidad` (simple addition), `calcular_valor_inventario` (multiplication), and `obtener_info` (formatted string). The docstring is a bit heavy with LaTeX, which is unnecessary for this simple class but shows an intent to document the math.
2.  **`Inventario` class**: This class manages the collection of `Producto` objects. It uses a dictionary (`self.productos`) for efficient lookup by ID. The methods (`agregar_producto`, `eliminar_producto`, `buscar_producto`, `mostrar_inventario`, `valor_total_inventario`) handle the CRUD operations and calculations.
3.  **`menu()` function**: This is the main user interface. It prints a static menu and handles user input by matching the choice to the appropriate method in the `main()` function.
4.  **`main()` function**: This is the entry point. It initializes the `Inventario` and populates it with test data. The `while True:` loop runs the `menu()` and uses `if/elif/else` to control the flow. The input handling is a bit verbose (checking if the input is a valid integer for options 1-5, handling '6' for exit).
5.  **`if __name__ == "__main__":`**: This standard Python construct ensures that `main()` is only executed when the script is run directly, not when imported as a module.

I will explain each class and method clearly, focusing on *what* the code does, not just *how* it does it. I'll also point out the structure (inheritance, dictionary usage) and the flow of execution.<channel|>Este es un sistema de inventario simple escrito en Python. Está diseñado para ser ejecutado directamente desde la línea de comandos.

### 1. La clase base `Producto`

Esta es la clase fundamental. Todo artículo en el sistema heredará sus características:

- **`__init__`**: Crea un objeto `Producto` con cuatro atributos: `id_producto` (string), `nombre` (string), `precio` (float), `cantidad` (integer). El constructor convierte el precio y la cantidad de string a float e int, asegurando que los cálculos posteriores sean correctos.
- **`actualizar_cantidad(self, cantidad)`**: Suma la nueva cantidad al stock actual.
- **`calcular_valor_inventario(self)`**: Devuelve el precio multiplicado por la cantidad. Esta es la operación matemática central.
- **`obtener_info(self)`**: Devuelve una cadena de formato legible que muestra el nombre, el precio y el stock.

### 2. La clase `Inventario`

Esta clase es el gestor del inventario.

- **`__init__`**: Inicializa un diccionario vacío (`self.productos`) donde se almacenarán los objetos `Producto`. Usar un diccionario permite buscar, agregar o eliminar productos de forma rápida por su ID.
- **`agregar_producto(self, producto)`**: Almacena el objeto `Producto` en el diccionario usando su ID como clave.
- **`eliminar_producto(self, id_producto)`**: Verifica si el ID existe. Si sí, lo elimina del diccionario y devuelve el objeto eliminado. Si no, imprime un mensaje de error.
- **`buscar_producto(self, termino)`**: Itera sobre todos los valores del diccionario y devuelve una lista de productos que coinciden con el `termino` (ignorando mayúsculas/minúsculas).
- **`mostrar_inventario(self)`**: Recorre el diccionario y llama a `p.obtener_info()` para cada producto, imprimiendo la información de forma ordenada.
- **`valor_total_inventario(self)`**: Suma el resultado de `p.calcular_valor_inventario()` para todos los productos.

### 3. La función `menu()`

Esta es la interfaz de usuario en consola. Simplemente imprime un menú fijo y devuelve la entrada del usuario.

### 4. La función **`main()`**

Esta es la parte que controla el flujo del programa.

- **Inicialización**: Crea un objeto `Inventario()` y lo llena con datos de prueba.
- **Bucle principal**: `while True:` ejecuta `menu()` y lee la entrada del usuario.
- **`if/elif/else`**: Compara la entrada del usuario con los números del menú y llama a la función de gestión del inventario correspondiente.
- **Manejo de entrada**: Verifica si la opción es un número y si es un entero. Maneja la salida '6' para salir del programa.
- **Llamadas a métodos**: Cada opción llama a un método del `Inventario` que a su vez crea un objeto `Producto` y lo pasa.

### 5. **`if __name__ == "__main__":`**

Esta línea estándar de Python hace que el código `main()` se ejecute solo cuando el archivo se ejecuta directamente (no cuando se importa como un módulo). Esto es una buena práctica para evitar que el código de prueba se ejecute accidentalmente.

### Resumen del flujo

1.  Se crea un objeto `Inventario`.
2.  Se añaden tres objetos `Producto` de prueba al inventario.
3.  El programa entra en un bucle infinito que muestra el menú.
4.  El usuario ingresa un número.
5.  El código `if/elif/else` dirige la entrada a la función de gestión del inventario adecuada.
6.  Los métodos de `Inventario` se ejecutan, interactúan con los objetos `Producto` y muestran los resultados.
7.  El bucle continúa hasta que el usuario ingresa '6'.
8.  El programa termina.<turn|>
"""

• train by https://huggingface.co/NickyNicky