📘 Programación Orientada a Objetos

# ═══════════════════════════════════════════════════════
# SISTEMA DE HOTEL — Unidad 1, ejemplo de negocio
# Aprende a leer: cada línea tiene su explicación ↓
# ═══════════════════════════════════════════════════════

class Habitacion:  # Define la clase Habitacion
    """
    Esta es la CLASE Habitacion.
    Una clase es como un MOLDE para crear objetos.
    Imagina que el molde define cómo es cada habitación.
    """

    def __init__(self, numero, tipo, precio_noche):  # Constructor: inicializa el objeto con los datos recibidos
        # __init__ es el CONSTRUCTOR: se ejecuta al crear cada habitación.
        # 'self' representa a ESTA habitación específica (el objeto).
        # Los parámetros son datos que recibimos al crear la habitación.
        self.numero = numero              # Guardamos el número (ej: 101)
        self.tipo = tipo                  # Guardamos el tipo (ej: "suite")
        self.precio_noche = precio_noche  # Precio por noche (ej: 850.0)
        self.disponible = True           # Al inicio, siempre disponible

    def reservar(self):  # Método que reservar
        # Este es un MÉTODO: una acción que puede hacer la habitación.
        if self.disponible:  # Verifica self.disponible antes de continuar
            self.disponible = False      # Marcamos como NO disponible
            return f"✅ Habitación {self.numero} reservada con éxito."  # Retorna el valor calculado al que llamó este método
        else:  # Si la condición anterior no se cumplió
            return f"❌ Habitación {self.numero} ya está ocupada."  # Retorna el valor calculado al que llamó este método

    def liberar(self):  # Método que liberar
        self.disponible = True  # Guarda disponible como atributo de instancia
        return f"🔓 Habitación {self.numero} disponible nuevamente."  # Retorna el valor calculado al que llamó este método

    def __str__(self):  # Define cómo se muestra el objeto al usar print()
        # __str__ define cómo se muestra el objeto cuando usamos print()
        estado = "Disponible" if self.disponible else "Ocupada"  # Asigna un valor inicial o calculado a estado
        return f"Hab. {self.numero} | {self.tipo} | ${self.precio_noche}/noche | {estado}"  # Retorna el valor calculado al que llamó este método


class Persona:  # Define la clase Persona
    # CLASE BASE (padre). Contiene lo que tienen en común clientes y empleados.
    def __init__(self, nombre, email):  # Constructor: inicializa el objeto con los datos recibidos
        self.nombre = nombre  # Guarda nombre como atributo de instancia
        self.email = email  # Guarda email como atributo de instancia


class Cliente(Persona):  # Cliente hereda de Persona — recibe todos sus atributos y métodos
    """
    HERENCIA: Cliente HEREDA de Persona.
    Escrito como: class Cliente(Persona)
    Esto significa que Cliente tiene TODO lo de Persona
    (nombre y email), MÁS sus propias cosas.
    """
    def __init__(self, nombre, email, telefono):  # Constructor: inicializa el objeto con los datos recibidos
        super().__init__(nombre, email)  # Llama al constructor de Persona
        self.telefono = telefono           # Agrega atributo propio
        self.reservaciones = []            # Lista vacía de reservaciones

    def agregar_reservacion(self, reservacion):  # Método que agregar reservacion
        self.reservaciones.append(reservacion)  # Agrega un elemento al final de self.reservaciones


class Reservacion:  # Define la clase Reservacion
    def __init__(self, cliente, habitacion, fecha_entrada, fecha_salida):  # Constructor: inicializa el objeto con los datos recibidos
        self.cliente = cliente  # Guarda cliente como atributo de instancia
        self.habitacion = habitacion  # Guarda habitacion como atributo de instancia
        self.fecha_entrada = fecha_entrada  # Guarda fecha_entrada como atributo de instancia
        self.fecha_salida = fecha_salida  # Guarda fecha_salida como atributo de instancia

    def calcular_costo(self, noches):  # Método que calcular costo
        return self.habitacion.precio_noche * noches  # Retorna el valor calculado al que llamó este método

    def confirmar(self):  # Método que confirmar
        resultado = self.habitacion.reservar()   # Llama al método de Habitacion
        self.cliente.agregar_reservacion(self)   # Agrega a la lista del cliente
        return resultado  # Retorna el valor calculado al que llamó este método


# ══════════════════ PROGRAMA PRINCIPAL ══════════════════
# Aquí creamos objetos (instancias) de nuestras clases

hab101 = Habitacion(101, "Suite Ejecutiva", 1200.0)  # Asigna un valor inicial o calculado a hab101
hab102 = Habitacion(102, "Doble Estándar", 650.0)  # Asigna un valor inicial o calculado a hab102

cliente1 = Cliente("Ana García", "ana@mail.com", "662-100-2000")  # Asigna un valor inicial o calculado a cliente1

reserva = Reservacion(cliente1, hab101, "2026-06-01", "2026-06-04")  # Asigna un valor inicial o calculado a reserva
print(reserva.confirmar())                 # ✅ Habitación 101 reservada
print(hab101)                              # Muestra estado de la habitación
print(f"Costo: ${reserva.calcular_costo(3)}")  # Costo por 3 noches

class ConfiguracionHotel:  # Define la clase ConfiguracionHotel
    """
    PATRÓN SINGLETON: garantiza que solo exista
    UNA instancia de esta clase en todo el programa.
    Útil para configuraciones, conexiones a BD, etc.
    """
    _instancia = None   # Almacena la única instancia (empieza vacía)

    def __new__(cls):  # Método que new
        # __new__ se llama ANTES de __init__, al crear el objeto.
        # Si no existe instancia, la creamos; si ya existe, devolvemos la misma.
        if cls._instancia is None:  # Verifica cls._instancia is None antes de continuar
            cls._instancia = super().__new__(cls)  # Asigna un valor inicial o calculado a cls._instancia
        return cls._instancia  # Retorna el valor calculado al que llamó este método

    def __init__(self):  # Constructor: inicializa el objeto con los datos recibidos
        self.nombre_hotel = "Hotel UTH Grand"  # Guarda nombre_hotel como atributo de instancia
        self.ciudad = "Hermosillo, Sonora"  # Guarda ciudad como atributo de instancia
        self.max_habitaciones = 50  # Guarda max_habitaciones como atributo de instancia

# Probamos que solo hay UNA instancia:
cfg1 = ConfiguracionHotel()  # Asigna un valor inicial o calculado a cfg1
cfg2 = ConfiguracionHotel()  # Asigna un valor inicial o calculado a cfg2
print(cfg1 is cfg2)   # True — ¡son el mismo objeto!
print(cfg1.nombre_hotel)  # Muestra en consola el resultado

class HabitacionFactory:  # Define la clase HabitacionFactory
    """
    PATRÓN FACTORY: una clase que se encarga de CREAR otros objetos.
    En lugar de crear objetos directamente con Habitacion(...),
    le pedimos a la fábrica que lo haga según el tipo.
    """
    @staticmethod  # Decorador: este método no necesita self (no depende del objeto)
    def crear(tipo):  # Método que crear
        # Según el tipo, creamos y configuramos la habitación
        if tipo == "suite":  # Verifica tipo == "suite" antes de continuar
            return Habitacion(0, "Suite Ejecutiva", 1500.0)  # Retorna el valor calculado al que llamó este método
        elif tipo == "doble":  # Evalúa otra condición: tipo == "doble"
            return Habitacion(0, "Doble Estándar", 700.0)  # Retorna el valor calculado al que llamó este método
        elif tipo == "sencilla":  # Evalúa otra condición: tipo == "sencilla"
            return Habitacion(0, "Sencilla", 450.0)  # Retorna el valor calculado al que llamó este método
        else:  # Si la condición anterior no se cumplió
            raise ValueError(f"Tipo desconocido: {tipo}")  # Lanza una excepción si hay un error; detiene el flujo normal

# Uso: le pedimos a la fábrica
suite = HabitacionFactory.crear("suite")  # Asigna un valor inicial o calculado a suite
doble = HabitacionFactory.crear("doble")  # Asigna un valor inicial o calculado a doble
print(suite)  # Muestra en consola el resultado
print(doble)  # Muestra en consola el resultado

# ═════════════════════════════════════════════════════════════════
# SISTEMA DE INVENTARIO — Tienda de Ropa "Moda Hermosillo"
# Unidad 2: Herencia, Encapsulamiento, Polimorfismo
# ═════════════════════════════════════════════════════════════════

class Producto:  # Define la clase Producto
    """
    CLASE BASE para todos los productos de la tienda.
    Define lo que tienen en común: nombre, precio, stock.
    """
    iva = 0.16   # Atributo de CLASE: compartido por todos los productos

    def __init__(self, nombre, precio_base, stock):  # Constructor: inicializa el objeto con los datos recibidos
        self.nombre = nombre  # Guarda nombre como atributo de instancia
        self.__precio_base = precio_base   # __ = privado (encapsulado)
        self.__stock = stock               # __ = privado

    # ── PROPIEDADES (acceso controlado a atributos privados) ──

    @property  # Decorador: permite acceder a este método como si fuera un atributo
    def precio_base(self):  # Método que precio base
        # @property permite acceder como atributo: producto.precio_base
        return self.__precio_base  # Retorna el valor calculado al que llamó este método

    @precio_base.setter  # Decorador: define el setter de una propiedad para validar o actualizar datos
    def precio_base(self, valor):  # Método que precio base
        # El setter VALIDA el dato antes de guardarlo
        if valor < 0:  # Verifica valor < 0 antes de continuar
            raise ValueError("El precio no puede ser negativo.")  # Lanza una excepción si hay un error; detiene el flujo normal
        self.__precio_base = valor  # Guarda __precio_base como atributo de instancia

    @property  # Decorador: permite acceder a este método como si fuera un atributo
    def stock(self):  # Método que stock
        return self.__stock  # Retorna el valor calculado al que llamó este método

    def precio_con_iva(self):  # Método que precio con iva
        # Calcula el precio final sumando el IVA
        return self.__precio_base * (1 + self.iva)  # Retorna el valor calculado al que llamó este método

    def vender(self, cantidad):  # Método que vender
        # Verifica stock antes de vender
        if cantidad > self.__stock:  # Verifica cantidad > self.__stock antes de continuar
            return f"❌ Stock insuficiente. Solo hay {self.__stock} unidades."  # Retorna el valor calculado al que llamó este método
        self.__stock -= cantidad  # Continúa la lógica del ejemplo paso a paso
        return f"✅ Venta de {cantidad} '{self.nombre}' registrada. Stock: {self.__stock}"  # Retorna el valor calculado al que llamó este método

    def descripcion(self):  # Método que descripcion
        # Método que CADA subclase puede reemplazar (polimorfismo)
        return f"Producto genérico: {self.nombre}"  # Retorna el valor calculado al que llamó este método

    def __str__(self):  # Define cómo se muestra el objeto al usar print()
        return (  # Retorna el valor calculado al que llamó este método
            f"📦 {self.nombre}\n"  # Continúa la lógica del ejemplo paso a paso
            f"   Precio base: ${self.__precio_base:.2f}\n"  # Continúa la lógica del ejemplo paso a paso
            f"   Precio con IVA: ${self.precio_con_iva():.2f}\n"  # Continúa la lógica del ejemplo paso a paso
            f"   Stock: {self.__stock} unidades"  # Continúa la lógica del ejemplo paso a paso
        )  # Cierra la estructura abierta en las líneas anteriores


class Ropa(Producto):  # Ropa hereda de Producto — recibe todos sus atributos y métodos
    """
    SUBCLASE de Producto. Agrega talla y color.
    Hereda TODO de Producto y le añade sus propias cosas.
    """
    def __init__(self, nombre, precio_base, stock, talla, color):  # Constructor: inicializa el objeto con los datos recibidos
        super().__init__(nombre, precio_base, stock)  # Inicializa la parte de Producto
        self.talla = talla  # Guarda talla como atributo de instancia
        self.color = color  # Guarda color como atributo de instancia

    def descripcion(self):  # Método que descripcion
        # SOBREESCRITURA del método (polimorfismo): Ropa tiene su propia descripción
        return f"👔 Ropa: {self.nombre} | Talla: {self.talla} | Color: {self.color}"  # Retorna el valor calculado al que llamó este método


class Calzado(Producto):  # Calzado hereda de Producto — recibe todos sus atributos y métodos
    def __init__(self, nombre, precio_base, stock, numero, material):  # Constructor: inicializa el objeto con los datos recibidos
        super().__init__(nombre, precio_base, stock)  # Llama al constructor de la clase padre para inicializar los atributos heredados
        self.numero = numero  # Guarda numero como atributo de instancia
        self.material = material  # Guarda material como atributo de instancia

    def descripcion(self):  # Método que descripcion
        return f"👟 Calzado: {self.nombre} | No.{self.numero} | {self.material}"  # Retorna el valor calculado al que llamó este método


class Inventario:  # Define la clase Inventario
    """
    Clase que CONTIENE una lista de productos (Composición).
    El inventario tiene productos, no hereda de ellos.
    """
    def __init__(self, nombre_tienda):  # Constructor: inicializa el objeto con los datos recibidos
        self.nombre_tienda = nombre_tienda  # Guarda nombre_tienda como atributo de instancia
        self.productos = []  # Guarda productos como atributo de instancia

    def agregar(self, producto):  # Método que agregar
        self.productos.append(producto)  # Agrega un elemento al final de self.productos
        print(f"➕ '{producto.nombre}' añadido al inventario.")  # Muestra en consola el resultado

    def mostrar_catalogo(self):  # Método que mostrar catalogo
        print(f"\n{'='*50}")  # Muestra en consola el resultado
        print(f"🏪 {self.nombre_tienda} — Catálogo")  # Muestra en consola el resultado
        print(f"{'='*50}")  # Muestra en consola el resultado
        for p in self.productos:  # Itera sobre cada p en self.productos
            print(p.descripcion())  # POLIMORFISMO: cada p llama su propia descripcion()
            print(f"   Precio con IVA: ${p.precio_con_iva():.2f}")  # Muestra en consola el resultado


# ══════════════════ PROGRAMA PRINCIPAL ══════════════════
inv = Inventario("Moda Hermosillo")  # Asigna un valor inicial o calculado a inv

inv.agregar(Ropa("Playera Polo", 250.0, 30, "M", "Azul marino"))  # Completa la llamada o expresión iniciada anteriormente
inv.agregar(Ropa("Jeans Skinny", 480.0, 15, "28", "Negro"))  # Completa la llamada o expresión iniciada anteriormente
inv.agregar(Calzado("Tenis Running", 890.0, 10, 27, "Sintético"))  # Completa la llamada o expresión iniciada anteriormente

inv.mostrar_catalogo()  # Completa la llamada o expresión iniciada anteriormente

# Probamos venta:
print("\n🛒 Realizando venta...")  # Muestra en consola el resultado
print(inv.productos[0].vender(3))   # Vende 3 playeras
print(inv.productos[0].vender(50))  # Intenta vender 50 (stock insuficiente)

class CuentaBancaria:  # Define la clase CuentaBancaria
    def __init__(self, titular, saldo_inicial):  # Constructor: inicializa el objeto con los datos recibidos
        self.titular = titular            # Público
        self.__saldo = saldo_inicial      # Privado — nadie lo toca directamente
        self.__historial = []             # Privado — registro de movimientos

    @property  # Decorador: permite acceder a este método como si fuera un atributo
    def saldo(self):  # Método que saldo
        # Getter: permite LEER el saldo de forma controlada
        return self.__saldo  # Retorna el valor calculado al que llamó este método

    def depositar(self, monto):  # Método que depositar
        if monto <= 0:  # Verifica monto <= 0 antes de continuar
            return "❌ Monto debe ser mayor a 0."  # Retorna el valor calculado al que llamó este método
        self.__saldo += monto  # Continúa la lógica del ejemplo paso a paso
        self.__historial.append(f"+${monto}")  # Agrega un elemento al final de self.__historial
        return f"✅ Depósito de ${monto}. Saldo: ${self.__saldo}"  # Retorna el valor calculado al que llamó este método

    def retirar(self, monto):  # Método que retirar
        if monto > self.__saldo:  # Verifica monto > self.__saldo antes de continuar
            return "❌ Fondos insuficientes."  # Retorna el valor calculado al que llamó este método
        self.__saldo -= monto  # Continúa la lógica del ejemplo paso a paso
        self.__historial.append(f"-${monto}")  # Agrega un elemento al final de self.__historial
        return f"✅ Retiro de ${monto}. Saldo: ${self.__saldo}"  # Retorna el valor calculado al que llamó este método

    def ver_historial(self):  # Método que ver historial
        return self.__historial  # Retorna el valor calculado al que llamó este método

# Prueba:
cuenta = CuentaBancaria("Juan López", 5000)  # Asigna un valor inicial o calculado a cuenta
print(cuenta.depositar(2000))  # Muestra en consola el resultado
print(cuenta.retirar(800))  # Muestra en consola el resultado
print(f"Saldo actual: ${cuenta.saldo}")  # Usamos la property
# cuenta.__saldo = 999999  ← ERROR: no se puede acceder directamente

class MetodoPago:  # Define la clase MetodoPago
    # Clase abstracta base para métodos de pago
    def procesar(self, monto):  # Método que procesar
        raise NotImplementedError("Cada pago debe implementar procesar()")  # Lanza una excepción si hay un error; detiene el flujo normal

class PagoEfectivo(MetodoPago):  # PagoEfectivo hereda de MetodoPago — recibe todos sus atributos y métodos
    def procesar(self, monto):  # Método que procesar
        return f"💵 Pago en efectivo de ${monto:.2f} recibido."  # Retorna el valor calculado al que llamó este método

class PagoTarjeta(MetodoPago):  # PagoTarjeta hereda de MetodoPago — recibe todos sus atributos y métodos
    def __init__(self, ultimos4):  # Constructor: inicializa el objeto con los datos recibidos
        self.ultimos4 = ultimos4  # Guarda ultimos4 como atributo de instancia
    def procesar(self, monto):  # Método que procesar
        return f"💳 Cargo de ${monto:.2f} a tarjeta ****{self.ultimos4}."  # Retorna el valor calculado al que llamó este método

class PagoTransferencia(MetodoPago):  # PagoTransferencia hereda de MetodoPago — recibe todos sus atributos y métodos
    def __init__(self, banco):  # Constructor: inicializa el objeto con los datos recibidos
        self.banco = banco  # Guarda banco como atributo de instancia
    def procesar(self, monto):  # Método que procesar
        return f"🏦 Transferencia de ${monto:.2f} vía {self.banco}."  # Retorna el valor calculado al que llamó este método

# POLIMORFISMO en acción:
# La función no necesita saber QUÉ tipo de pago es, solo llama procesar()
def cobrar(pago: MetodoPago, total: float):  # Método que cobrar
    resultado = pago.procesar(total)   # Cada objeto responde diferente
    print(resultado)  # Muestra en consola el resultado

cobrar(PagoEfectivo(), 350.00)  # Completa la llamada o expresión iniciada anteriormente
cobrar(PagoTarjeta("4521"), 1280.50)  # Completa la llamada o expresión iniciada anteriormente
cobrar(PagoTransferencia("BBVA"), 9500.00)  # Completa la llamada o expresión iniciada anteriormente

# ═══════════════════════════════════════════════════════════════
# ABSTRACCIÓN — Sistema de Reportes
# Empresa de Logística "Envíos Sonora"
# Unidad 2 · Programación Orientada a Objetos
# ═══════════════════════════════════════════════════════════════

from abc import ABC, abstractmethod   # Paso 1: importar el módulo abc


# ── CLASE ABSTRACTA BASE ────────────────────────────────────────
# No se puede instanciar: ReporteBase() lanzaría TypeError
# Solo define el CONTRATO que deben cumplir las subclases
class ReporteBase(ABC):  # ReporteBase hereda de ABC — recibe todos sus atributos y métodos
    """
    Contrato base para todos los tipos de reporte.
    Cualquier clase que herede de ReporteBase DEBE implementar:
        - generar()
        - enviar()
        - nombre_formato (propiedad)
    """

    def __init__(self, titulo, datos):  # Constructor: inicializa el objeto con los datos recibidos
        self.titulo = titulo          # Común a todos los reportes
        self.datos  = datos           # Lista de registros a reportar

    # ── Métodos ABSTRACTOS: cada subclase los implementa a su manera ──

    @abstractmethod  # Decorador: obliga a las subclases a implementar este método
    def generar(self):  # Método que generar
        """Genera el contenido del reporte en el formato específico."""
        ...   # Los '...' indican que el cuerpo lo define la subclase

    @abstractmethod  # Decorador: obliga a las subclases a implementar este método
    def enviar(self, destino):  # Método que enviar
        """Envía el reporte generado al destino indicado."""
        ...  # Continúa la lógica del ejemplo paso a paso

    @property  # Decorador: permite acceder a este método como si fuera un atributo
    @abstractmethod  # Decorador: obliga a las subclases a implementar este método
    def nombre_formato(self):  # Método que nombre formato
        """Devuelve el nombre del formato (PDF, Excel, Email...)."""
        ...  # Continúa la lógica del ejemplo paso a paso

    # ── Método CONCRETO: ya tiene implementación, se hereda tal cual ──
    def encabezado(self):  # Método que encabezado
        # Este método funciona igual para TODOS los formatos
        sep = "═" * 48  # Asigna un valor inicial o calculado a sep
        return (  # Retorna el valor calculado al que llamó este método
            f"\n{sep}\n"  # Continúa la lógica del ejemplo paso a paso
            f"  📊 {self.titulo}\n"  # Continúa la lógica del ejemplo paso a paso
            f"  Formato : {self.nombre_formato}\n"  # Continúa la lógica del ejemplo paso a paso
            f"  Registros: {len(self.datos)}\n"  # Continúa la lógica del ejemplo paso a paso
            f"{sep}"  # Continúa la lógica del ejemplo paso a paso
        )  # Cierra la estructura abierta en las líneas anteriores


# ── SUBCLASE CONCRETA 1: Reporte en PDF ─────────────────────────
class ReportePDF(ReporteBase):  # ReportePDF hereda de ReporteBase — recibe todos sus atributos y métodos
    """Implementación concreta para reportes en formato PDF."""

    @property  # Decorador: permite acceder a este método como si fuera un atributo
    def nombre_formato(self):  # Método que nombre formato
        return "PDF"  # Retorna el valor calculado al que llamó este método

    def generar(self):  # Método que generar
        # Aquí iría la librería reportlab/fpdf en un proyecto real
        lineas = [f"  • {r['paquete']} → {r['destino']} [{r['estado']}]"  # Asigna un valor inicial o calculado a lineas
                  for r in self.datos]  # Itera sobre cada elemento de la colección indicada
        return self.encabezado() + "\n" + "\n".join(lineas)  # Retorna el valor calculado al que llamó este método

    def enviar(self, destino):  # Método que enviar
        return f"📤 PDF enviado a la ruta: {destino}/reporte.pdf"  # Retorna el valor calculado al que llamó este método


# ── SUBCLASE CONCRETA 2: Reporte en Excel ───────────────────────
class ReporteExcel(ReporteBase):  # ReporteExcel hereda de ReporteBase — recibe todos sus atributos y métodos
    """Implementación concreta para reportes en formato Excel."""

    @property  # Decorador: permite acceder a este método como si fuera un atributo
    def nombre_formato(self):  # Método que nombre formato
        return "Excel (.xlsx)"  # Retorna el valor calculado al que llamó este método

    def generar(self):  # Método que generar
        # En proyecto real usaría openpyxl o pandas
        encabezado_cols = "  PAQUETE          | DESTINO       | ESTADO"  # Asigna un valor inicial o calculado a encabezado_cols
        filas = [f"  {r['paquete']:<18}| {r['destino']:<14}| {r['estado']}"  # Asigna un valor inicial o calculado a filas
                 for r in self.datos]  # Itera sobre cada elemento de la colección indicada
        return self.encabezado() + f"\n{encabezado_cols}\n" + "\n".join(filas)  # Retorna el valor calculado al que llamó este método

    def enviar(self, destino):  # Método que enviar
        return f"📊 Excel guardado en: {destino}/reporte.xlsx"  # Retorna el valor calculado al que llamó este método


# ── SUBCLASE CONCRETA 3: Reporte por Correo ─────────────────────
class ReporteEmail(ReporteBase):  # ReporteEmail hereda de ReporteBase — recibe todos sus atributos y métodos
    """Implementación concreta para envío por correo electrónico."""

    @property  # Decorador: permite acceder a este método como si fuera un atributo
    def nombre_formato(self):  # Método que nombre formato
        return "Correo Electrónico"  # Retorna el valor calculado al que llamó este método

    def generar(self):  # Método que generar
        resumen = f"Total de envíos: {len(self.datos)}\n"  # Asigna un valor inicial o calculado a resumen
        pendientes = sum(1 for r in self.datos if r['estado'] == "Pendiente")  # Asigna un valor inicial o calculado a pendientes
        return self.encabezado() + f"\n  {resumen}  Pendientes: {pendientes}"  # Retorna el valor calculado al que llamó este método

    def enviar(self, destino):  # Método que enviar
        return f"✉️  Correo enviado a: {destino}"  # Retorna el valor calculado al que llamó este método


# ══════════════════ PROGRAMA PRINCIPAL ══════════════════
paquetes = [  # Asigna un valor inicial o calculado a paquetes
    {"paquete": "PKT-001", "destino": "Hermosillo", "estado": "Entregado"},  # Continúa la lógica del ejemplo paso a paso
    {"paquete": "PKT-002", "destino": "Nogales",    "estado": "En tránsito"},  # Continúa la lógica del ejemplo paso a paso
    {"paquete": "PKT-003", "destino": "Guaymas",    "estado": "Pendiente"},  # Continúa la lógica del ejemplo paso a paso
]  # Cierra la estructura abierta en las líneas anteriores

# Creamos los tres tipos de reporte
reportes = [  # Asigna un valor inicial o calculado a reportes
    ReportePDF  ("Envíos Sonora — Semana 18", paquetes),  # Continúa la lógica del ejemplo paso a paso
    ReporteExcel("Envíos Sonora — Semana 18", paquetes),  # Continúa la lógica del ejemplo paso a paso
    ReporteEmail("Envíos Sonora — Semana 18", paquetes),  # Continúa la lógica del ejemplo paso a paso
]  # Cierra la estructura abierta en las líneas anteriores

# ABSTRACCIÓN + POLIMORFISMO: el mismo código funciona con cualquier tipo
for rep in reportes:  # Itera sobre cada rep en reportes
    print(rep.generar())  # Muestra en consola el resultado
    print(rep.enviar("C:/reportes"))  # Muestra en consola el resultado
    print()  # Muestra en consola el resultado

# ── ¿Qué pasa si intentamos instanciar la clase abstracta? ──
# reporte = ReporteBase("X", [])   ← TypeError: Can't instantiate abstract class
# Python NO lo permite. ¡Eso es justamente la abstracción!

"""
inventario_tienda.py
====================
Sistema de Inventario para Tienda de Ropa.
Módulo principal — Versión 1.0

Autor: Nombre del Alumno
Materia: Programación Orientada a Objetos
Docente: Bernardo Prado Díaz
Fecha: Mayo 2026
"""

class Producto:  # Define la clase Producto
    """
    Representa un producto en el inventario de la tienda.

    Atributos:
        nombre (str): Nombre descriptivo del producto.
        precio_base (float): Precio antes de impuestos.
        stock (int): Unidades disponibles.

    Ejemplo:
        >>> p = Producto("Playera", 200.0, 10)
        >>> p.precio_con_iva()
        232.0
    """

    def precio_con_iva(self) -> float:  # Método que precio con iva
        """
        Calcula el precio total incluyendo IVA del 16%.

        Returns:
            float: Precio base más 16% de IVA.
        """
        return self.precio_base * 1.16  # Retorna el valor calculado al que llamó este método

import flet as ft   # Importamos FLET con el alias "ft"

def main(page: ft.Page):  # Método que main
    """
    'page' es la VENTANA de la aplicación.
    Todo lo que pongas aquí aparecerá en pantalla.
    """
    page.title = "Mi Primera App FLET"    # Título de la ventana
    page.bgcolor = ft.colors.BLUE_GREY_50  # Color de fondo
    page.window_width = 500              # Ancho de la ventana en pixeles
    page.window_height = 400             # Alto de la ventana en pixeles

    # ft.Text crea un texto visible
    titulo = ft.Text(  # Asigna un valor inicial o calculado a titulo
        value="¡Hola, UTH! 🎓",           # El texto a mostrar
        size=32,                          # Tamaño de fuente
        color=ft.colors.BLUE_900,         # Color del texto
        weight=ft.FontWeight.BOLD         # Negrita
    )  # Cierra la estructura abierta en las líneas anteriores

    # ft.ElevatedButton crea un botón
    boton = ft.ElevatedButton(  # Asigna un valor inicial o calculado a boton
        text="Presióname 👋",  # Asigna un valor inicial o calculado a text
        on_click=lambda e: page.add(   # on_click = qué hacer al presionar
            ft.Text("¡Botón presionado! 🎉", color=ft.colors.GREEN_700)  # Completa la llamada o expresión iniciada anteriormente
        )  # Cierra la estructura abierta en las líneas anteriores
    )  # Cierra la estructura abierta en las líneas anteriores

    # page.add() agrega componentes a la ventana
    page.add(  # Inicia una llamada o estructura en varias líneas para mejorar la lectura
        ft.Column(                        # Column organiza elementos verticalmente
            controls=[titulo, boton],     # Lista de componentes
            horizontal_alignment=ft.CrossAxisAlignment.CENTER,  # Asigna un valor inicial o calculado a horizontal_alignment
            spacing=20                   # Espacio entre elementos
        )  # Cierra la estructura abierta en las líneas anteriores
    )  # Cierra la estructura abierta en las líneas anteriores

# ft.app() inicia la aplicación y llama a la función main
ft.app(target=main)  # Completa la llamada o expresión iniciada anteriormente

-- Ejecuta este script en DBeaver o phpMyAdmin
-- Selecciona la BD 'pos_tienda' antes de ejecutar

USE pos_tienda;

-- Tabla de Categorías
CREATE TABLE categorias (
    id         INT AUTO_INCREMENT PRIMARY KEY,
    nombre     VARCHAR(100) NOT NULL,
    descripcion TEXT
);

-- Tabla de Productos
CREATE TABLE productos (
    id           INT AUTO_INCREMENT PRIMARY KEY,
    nombre       VARCHAR(150) NOT NULL,
    precio       DECIMAL(10,2) NOT NULL,
    stock        INT DEFAULT 0,
    id_categoria INT,
    codigo_barra VARCHAR(50),
    FOREIGN KEY (id_categoria) REFERENCES categorias(id)
);

-- Tabla de Clientes
CREATE TABLE clientes (
    id       INT AUTO_INCREMENT PRIMARY KEY,
    nombre   VARCHAR(150) NOT NULL,
    telefono VARCHAR(20),
    email    VARCHAR(100)
);

-- Tabla de Ventas (encabezado)
CREATE TABLE ventas (
    id         INT AUTO_INCREMENT PRIMARY KEY,
    id_cliente INT,
    fecha      DATETIME DEFAULT NOW(),
    total      DECIMAL(10,2),
    FOREIGN KEY (id_cliente) REFERENCES clientes(id)
);

-- Tabla de Detalle de Venta
CREATE TABLE detalle_venta (
    id          INT AUTO_INCREMENT PRIMARY KEY,
    id_venta    INT,
    id_producto INT,
    cantidad    INT,
    precio_unit DECIMAL(10,2),
    FOREIGN KEY (id_venta) REFERENCES ventas(id),
    FOREIGN KEY (id_producto) REFERENCES productos(id)
);

-- Datos de prueba
INSERT INTO categorias (nombre) VALUES
    ('Abarrotes'), ('Bebidas'), ('Lácteos');

INSERT INTO productos (nombre, precio, stock, id_categoria) VALUES
    ('Arroz 1kg', 22.50, 100, 1),
    ('Refresco 600ml', 18.00, 60, 2),
    ('Leche 1L', 28.00, 40, 3);

import mysql.connector   # Importamos el conector de MySQL

class Conexion:  # Define la clase Conexion
    """
    Clase que maneja la conexión a MySQL.
    Usamos el patrón Singleton para que solo haya UNA conexión.
    """
    _instancia = None  # Asigna un valor inicial o calculado a _instancia

    def __new__(cls):  # Método que new
        if cls._instancia is None:  # Verifica cls._instancia is None antes de continuar
            cls._instancia = super().__new__(cls)  # Asigna un valor inicial o calculado a cls._instancia
            cls._instancia._conectar()  # Completa la llamada o expresión iniciada anteriormente
        return cls._instancia  # Retorna el valor calculado al que llamó este método

    def _conectar(self):  # Método que conectar
        # Establece la conexión con MySQL
        self.conn = mysql.connector.connect(  # Guarda conn como atributo de instancia
            host="localhost",      # El servidor (WampServer)
            user="root",           # Usuario MySQL
            password="tu_password",# Tu contraseña configurada
            database="pos_tienda"  # Nombre de la BD
        )  # Cierra la estructura abierta en las líneas anteriores
        self.cursor = self.conn.cursor(dictionary=True)  # Guarda cursor como atributo de instancia
        # dictionary=True → los resultados vienen como dicts {col: valor}

    def ejecutar(self, sql, params=None):  # Método que ejecutar
        # Ejecuta una instrucción SQL (INSERT, UPDATE, DELETE)
        self.cursor.execute(sql, params)  # Completa la llamada o expresión iniciada anteriormente
        self.conn.commit()         # Guarda los cambios en la BD

    def consultar(self, sql, params=None):  # Método que consultar
        # Ejecuta un SELECT y retorna los resultados
        self.cursor.execute(sql, params)  # Completa la llamada o expresión iniciada anteriormente
        return self.cursor.fetchall()  # Lista de diccionarios

    def cerrar(self):  # Método que cerrar
        self.cursor.close()  # Completa la llamada o expresión iniciada anteriormente
        self.conn.close()  # Completa la llamada o expresión iniciada anteriormente
        Conexion._instancia = None   # Limpia el singleton

from database import Conexion  # Importa Conexion del módulo database

class ProductoDAO:  # Define la clase ProductoDAO
    """
    DAO (Data Access Object) para la tabla 'productos'.
    TODA la lógica de base de datos de productos va aquí.
    Principio de Responsabilidad Única (SOLID-S):
    esta clase solo se encarga de acceso a datos.
    """

    def __init__(self):  # Constructor: inicializa el objeto con los datos recibidos
        self.db = Conexion()   # Obtenemos la conexión (singleton)

    def obtener_todos(self):  # Método que obtener todos
        # SELECT: obtiene todos los productos
        sql = "SELECT p.id, p.nombre, p.precio, p.stock, c.nombre AS categoria FROM productos p LEFT JOIN categorias c ON p.id_categoria = c.id"  # Asigna un valor inicial o calculado a sql
        return self.db.consultar(sql)  # Retorna el valor calculado al que llamó este método

    def insertar(self, nombre, precio, stock, id_categoria):  # Método que insertar
        # INSERT: agrega un nuevo producto
        # Usamos %s como marcadores de posición (evita SQL Injection)
        sql = "INSERT INTO productos (nombre, precio, stock, id_categoria) VALUES (%s, %s, %s, %s)"  # Asigna un valor inicial o calculado a sql
        self.db.ejecutar(sql, (nombre, precio, stock, id_categoria))  # Completa la llamada o expresión iniciada anteriormente

    def actualizar(self, id_prod, nombre, precio, stock):  # Método que actualizar
        # UPDATE: modifica un producto existente
        sql = "UPDATE productos SET nombre=%s, precio=%s, stock=%s WHERE id=%s"  # Asigna un valor inicial o calculado a sql
        self.db.ejecutar(sql, (nombre, precio, stock, id_prod))  # Completa la llamada o expresión iniciada anteriormente

    def eliminar(self, id_prod):  # Método que eliminar
        # DELETE: elimina un producto por ID
        sql = "DELETE FROM productos WHERE id = %s"  # Asigna un valor inicial o calculado a sql
        self.db.ejecutar(sql, (id_prod,))   # Nota la coma: es una tupla

    def buscar_por_nombre(self, texto):  # Método que buscar por nombre
        sql = "SELECT * FROM productos WHERE nombre LIKE %s"  # Asigna un valor inicial o calculado a sql
        return self.db.consultar(sql, (f"%{texto}%",))  # Retorna el valor calculado al que llamó este método

import flet as ft  # Importa el módulo flet para usar sus funciones y clases
from producto_dao import ProductoDAO  # Importa ProductoDAO del módulo producto_dao

def main(page: ft.Page):  # Método que main
    page.title = "🏪 POS Tienda Hermosillo"  # Asigna un valor inicial o calculado a page.title
    page.bgcolor = ft.colors.GREY_50  # Asigna un valor inicial o calculado a page.bgcolor
    page.window_width = 900  # Asigna un valor inicial o calculado a page.window_width
    page.window_height = 650  # Asigna un valor inicial o calculado a page.window_height
    page.window_center()  # Completa la llamada o expresión iniciada anteriormente

    dao = ProductoDAO()   # Creamos el DAO para acceder a la BD

    # ── Campos del formulario ──
    txt_nombre  = ft.TextField(label="Nombre del producto", expand=True)  # Asigna un valor inicial o calculado a txt_nombre
    txt_precio  = ft.TextField(label="Precio ($)", width=150)  # Asigna un valor inicial o calculado a txt_precio
    txt_stock   = ft.TextField(label="Stock", width=100)  # Asigna un valor inicial o calculado a txt_stock
    id_seleccionado = [None]   # Lista para guardar el ID seleccionado

    # ── Tabla de datos ──
    tabla = ft.DataTable(  # Asigna un valor inicial o calculado a tabla
        columns=[  # Asigna un valor inicial o calculado a columns
            ft.DataColumn(ft.Text("ID")),  # Continúa la lógica del ejemplo paso a paso
            ft.DataColumn(ft.Text("Nombre")),  # Continúa la lógica del ejemplo paso a paso
            ft.DataColumn(ft.Text("Precio")),  # Continúa la lógica del ejemplo paso a paso
            ft.DataColumn(ft.Text("Stock")),  # Continúa la lógica del ejemplo paso a paso
            ft.DataColumn(ft.Text("Categoría")),  # Continúa la lógica del ejemplo paso a paso
        ],  # Continúa la lógica del ejemplo paso a paso
        rows=[],   # Se llenará con datos de BD
        border=ft.border.all(1, ft.colors.GREY_300),  # Asigna un valor inicial o calculado a border
    )  # Cierra la estructura abierta en las líneas anteriores

    def cargar_productos(e=None):  # Método que cargar productos
        # Lee productos de MySQL y llena la tabla
        tabla.rows.clear()  # Completa la llamada o expresión iniciada anteriormente
        productos = dao.obtener_todos()  # Asigna un valor inicial o calculado a productos
        for p in productos:  # Itera sobre cada p en productos
            tabla.rows.append(ft.DataRow(  # Agrega un elemento al final de tabla.rows
                cells=[  # Asigna un valor inicial o calculado a cells
                    ft.DataCell(ft.Text(str(p["id"]))),  # Continúa la lógica del ejemplo paso a paso
                    ft.DataCell(ft.Text(p["nombre"])),  # Continúa la lógica del ejemplo paso a paso
                    ft.DataCell(ft.Text(f"${p['precio']:.2f}")),  # Continúa la lógica del ejemplo paso a paso
                    ft.DataCell(ft.Text(str(p["stock"]))),  # Continúa la lógica del ejemplo paso a paso
                    ft.DataCell(ft.Text(p["categoria"] or "—")),  # Continúa la lógica del ejemplo paso a paso
                ],  # Continúa la lógica del ejemplo paso a paso
                on_select_changed=lambda e, prod=p: seleccionar(prod)  # Asigna un valor inicial o calculado a on_select_changed
            ))  # Completa la llamada o expresión iniciada anteriormente
        page.update()   # Refresca la interfaz

    def seleccionar(prod):  # Método que seleccionar
        # Rellena el formulario con los datos del producto seleccionado
        txt_nombre.value  = prod["nombre"]  # Asigna un valor inicial o calculado a txt_nombre.value
        txt_precio.value  = str(prod["precio"])  # Asigna un valor inicial o calculado a txt_precio.value
        txt_stock.value   = str(prod["stock"])  # Asigna un valor inicial o calculado a txt_stock.value
        id_seleccionado[0] = prod["id"]  # Asigna un valor inicial o calculado a id_seleccionado[0]
        page.update()  # Completa la llamada o expresión iniciada anteriormente

    def guardar(e):  # Método que guardar
        if id_seleccionado[0]:  # Verifica id_seleccionado[0] antes de continuar
            # Si hay ID seleccionado → UPDATE
            dao.actualizar(id_seleccionado[0], txt_nombre.value,  # Continúa la lógica del ejemplo paso a paso
                           float(txt_precio.value), int(txt_stock.value))  # Completa la llamada o expresión iniciada anteriormente
        else:  # Si la condición anterior no se cumplió
            # Si no → INSERT
            dao.insertar(txt_nombre.value, float(txt_precio.value),  # Continúa la lógica del ejemplo paso a paso
                         int(txt_stock.value), 1)  # Completa la llamada o expresión iniciada anteriormente
        limpiar(None)  # Completa la llamada o expresión iniciada anteriormente
        cargar_productos()  # Completa la llamada o expresión iniciada anteriormente

    def eliminar(e):  # Método que eliminar
        if id_seleccionado[0]:  # Verifica id_seleccionado[0] antes de continuar
            dao.eliminar(id_seleccionado[0])  # Completa la llamada o expresión iniciada anteriormente
            limpiar(None)  # Completa la llamada o expresión iniciada anteriormente
            cargar_productos()  # Completa la llamada o expresión iniciada anteriormente

    def limpiar(e):  # Método que limpiar
        txt_nombre.value = txt_precio.value = txt_stock.value = ""  # Asigna un valor inicial o calculado a txt_nombre.value
        id_seleccionado[0] = None  # Asigna un valor inicial o calculado a id_seleccionado[0]
        page.update()  # Completa la llamada o expresión iniciada anteriormente

    # ── Botones ──
    btns = ft.Row([  # Asigna un valor inicial o calculado a btns
        ft.ElevatedButton("💾 Guardar",  on_click=guardar,  # Continúa la lógica del ejemplo paso a paso
                          bgcolor=ft.colors.BLUE_700, color=ft.colors.WHITE),  # Asigna un valor inicial o calculado a bgcolor
        ft.ElevatedButton("🗑 Eliminar", on_click=eliminar,  # Continúa la lógica del ejemplo paso a paso
                          bgcolor=ft.colors.RED_700,  color=ft.colors.WHITE),  # Asigna un valor inicial o calculado a bgcolor
        ft.ElevatedButton("🔄 Refrescar",on_click=cargar_productos),  # Continúa la lógica del ejemplo paso a paso
        ft.TextButton("✖ Limpiar", on_click=limpiar),  # Continúa la lógica del ejemplo paso a paso
    ])  # Completa la llamada o expresión iniciada anteriormente

    # ── AppBar (barra superior) ──
    page.appbar = ft.AppBar(  # Asigna un valor inicial o calculado a page.appbar
        title=ft.Text("Sistema POS — Tienda Hermosillo", color=ft.colors.WHITE),  # Asigna un valor inicial o calculado a title
        bgcolor=ft.colors.BLUE_900  # Asigna un valor inicial o calculado a bgcolor
    )  # Cierra la estructura abierta en las líneas anteriores

    # ── Layout principal ──
    page.add(  # Inicia una llamada o estructura en varias líneas para mejorar la lectura
        ft.Column([  # Continúa la lógica del ejemplo paso a paso
            ft.Text("📦 Gestión de Productos", size=18, weight=ft.FontWeight.BOLD),  # Continúa la lógica del ejemplo paso a paso
            ft.Row([txt_nombre, txt_precio, txt_stock]),  # Continúa la lógica del ejemplo paso a paso
            btns,  # Continúa la lógica del ejemplo paso a paso
            ft.Divider(),  # Continúa la lógica del ejemplo paso a paso
            ft.Text("Haz clic en una fila para seleccionar", size=12, color=ft.colors.GREY_600),  # Continúa la lógica del ejemplo paso a paso
            tabla,  # Continúa la lógica del ejemplo paso a paso
        ], scroll=ft.ScrollMode.AUTO)  # Completa la llamada o expresión iniciada anteriormente
    )  # Cierra la estructura abierta en las líneas anteriores

    cargar_productos()   # Carga datos al iniciar la app

ft.app(target=main)  # Completa la llamada o expresión iniciada anteriormente

# 1. Crear el entorno virtual (ejecuta una sola vez)
python -m venv venv

# 2. Activarlo (cada vez que abras el proyecto)
venv\Scripts\activate          # Windows

# Verás el prefijo (venv) en el terminal, significa que está activo

# 3. Instalar librerías dentro del venv
pip install flet mysql-connector-python

# 4. Guardar lista de dependencias
pip freeze > requirements.txt

# 5. Para instalar en otro equipo:
pip install -r requirements.txt

# ── Estructura básica de try/except ──
try:  # Intenta ejecutar el bloque; si hay error, lo captura el except
    # Código que PUEDE fallar va aquí
    numero = int(input("Ingresa un número: "))  # Asigna un valor inicial o calculado a numero
    resultado = 100 / numero  # Asigna un valor inicial o calculado a resultado
    print(f"Resultado: {resultado}")  # Muestra en consola el resultado

except ValueError:  # Captura el error ValueError si ocurre en el try
    # Se ejecuta si el usuario escribe texto en lugar de número
    print("❌ Error: debes ingresar un número entero.")  # Muestra en consola el resultado

except ZeroDivisionError:  # Captura el error ZeroDivisionError si ocurre en el try
    # Se ejecuta si el usuario escribe 0
    print("❌ Error: no se puede dividir entre cero.")  # Muestra en consola el resultado

except Exception as e:  # Captura el error Exception as e si ocurre en el try
    # Captura CUALQUIER otro error inesperado
    print(f"❌ Error inesperado: {e}")  # Muestra en consola el resultado

else:  # Si la condición anterior no se cumplió
    # Se ejecuta SOLO si NO hubo error
    print("✅ Operación exitosa.")  # Muestra en consola el resultado

finally:  # Se ejecuta SIEMPRE, haya o no error (para limpieza de recursos)
    # Se ejecuta SIEMPRE, haya o no error (útil para cerrar BD, archivos)
    print("ℹ️ Fin de la operación.")  # Muestra en consola el resultado


# ── Excepciones personalizadas ──
class StockInsuficienteError(Exception):  # StockInsuficienteError hereda de Exception — recibe todos sus atributos y métodos
    """Error propio de nuestra aplicación."""
    def __init__(self, producto, cantidad_pedida, stock_actual):  # Constructor: inicializa el objeto con los datos recibidos
        self.producto = producto  # Guarda producto como atributo de instancia
        mensaje = (  # Asigna un valor inicial o calculado a mensaje
            f"Stock insuficiente para '{producto}'. "  # Continúa la lógica del ejemplo paso a paso
            f"Pedido: {cantidad_pedida}, Disponible: {stock_actual}"  # Continúa la lógica del ejemplo paso a paso
        )  # Cierra la estructura abierta en las líneas anteriores
        super().__init__(mensaje)  # Llama al constructor de la clase padre para inicializar los atributos heredados


class ProductoService:  # Define la clase ProductoService
    def vender(self, producto, cantidad, stock):  # Método que vender
        if cantidad > stock:  # Verifica cantidad > stock antes de continuar
            raise StockInsuficienteError(producto, cantidad, stock)  # Lanza una excepción si hay un error; detiene el flujo normal
        return stock - cantidad  # Retorna el valor calculado al que llamó este método


# Uso con manejo de la excepción propia:
svc = ProductoService()  # Asigna un valor inicial o calculado a svc
try:  # Intenta ejecutar el bloque; si hay error, lo captura el except
    nuevo_stock = svc.vender("Arroz 1kg", 50, 10)  # Asigna un valor inicial o calculado a nuevo_stock
except StockInsuficienteError as e:  # Captura el error StockInsuficienteError as e si ocurre en el try
    print(f"❌ {e}")   # Muestra el mensaje personalizado


# ── Excepciones en conexión MySQL ──
import mysql.connector  # Importa el módulo mysql.connector para usar sus funciones y clases

def conectar_bd():  # Método que conectar bd
    try:  # Intenta ejecutar el bloque; si hay error, lo captura el except
        conn = mysql.connector.connect(  # Asigna un valor inicial o calculado a conn
            host="localhost", user="root",  # Asigna un valor inicial o calculado a host
            password="pass", database="pos_tienda"  # Asigna un valor inicial o calculado a password
        )  # Cierra la estructura abierta en las líneas anteriores
        return conn  # Retorna el valor calculado al que llamó este método
    except mysql.connector.Error as e:  # Captura el error mysql.connector.Error as e si ocurre en el try
        print(f"❌ No se pudo conectar a MySQL: {e}")  # Muestra en consola el resultado
        return None  # Retorna el valor calculado al que llamó este método

import unittest  # Importa el módulo unittest para usar sus funciones y clases
from inventario_tienda import Producto, Ropa   # Importamos las clases a probar

class TestProducto(unittest.TestCase):  # TestProducto hereda de unittest.TestCase — recibe todos sus atributos y métodos
    """
    Clase de pruebas. Hereda de unittest.TestCase.
    Cada método que empiece con 'test_' es una prueba.
    """

    def setUp(self):  # Se ejecuta automáticamente antes de cada prueba para preparar el entorno
        # setUp() se ejecuta ANTES de cada prueba
        # Aquí creamos objetos que necesitaremos en las pruebas
        self.prod = Producto("Arroz", 20.0, 10)  # Guarda prod como atributo de instancia

    def test_precio_con_iva(self):  # Prueba unitaria: verifica que precio con iva funcione correctamente
        # Verifica que el cálculo de IVA sea correcto
        resultado = self.prod.precio_con_iva()  # Asigna un valor inicial o calculado a resultado
        self.assertAlmostEqual(resultado, 23.2, places=2)  # Verifica que ambos valores sean casi iguales (útil con decimales)

    def test_vender_exitoso(self):  # Prueba unitaria: verifica que vender exitoso funcione correctamente
        # Verifica que vender 3 unidades funcione
        resultado = self.prod.vender(3)  # Asigna un valor inicial o calculado a resultado
        self.assertIn("✅", resultado)         # Debe contener ✅
        self.assertEqual(self.prod.stock, 7)  # Stock debe quedar en 7

    def test_vender_stock_insuficiente(self):  # Prueba unitaria: verifica que vender stock insuficiente funcione correctamente
        # Verifica que vender más del stock muestre error
        resultado = self.prod.vender(100)  # Asigna un valor inicial o calculado a resultado
        self.assertIn("❌", resultado)  # Verifica que el elemento esperado esté dentro de la colección

    def test_precio_negativo_lanza_error(self):  # Prueba unitaria: verifica que precio negativo lanza error funcione correctamente
        # Verifica que precio negativo lance ValueError
        with self.assertRaises(ValueError):  # Abre un contexto controlado para usar y cerrar recursos automáticamente
            self.prod.precio_base = -100   # Debe lanzar excepción

    def test_herencia_ropa(self):  # Prueba unitaria: verifica que herencia ropa funcione correctamente
        # Verifica que Ropa herede correctamente
        ropa = Ropa("Playera", 250.0, 5, "M", "Blanco")  # Asigna un valor inicial o calculado a ropa
        self.assertIsInstance(ropa, Producto)  # Ropa ES un Producto
        self.assertEqual(ropa.talla, "M")  # Verifica que ambos valores sean iguales; falla el test si son diferentes

    def tearDown(self):  # Se ejecuta automáticamente después de cada prueba para limpiar
        # tearDown() se ejecuta DESPUÉS de cada prueba (limpieza)
        pass  # Cuerpo vacío por ahora; aquí irá la lógica en las subclases


# Ejecutar pruebas:
if __name__ == "__main__":  # Se ejecuta solo cuando este archivo se corre directamente (no cuando se importa)
    unittest.main(verbosity=2)   # verbosity=2 muestra detalle de cada prueba

mi_sistema_poo/
│
├── main.py              ← Punto de entrada de la aplicación
│
├── database/
│   ├── __init__.py
│   ├── conexion.py      ← Clase Singleton de conexión MySQL
│   └── script.sql       ← Script para crear la BD
│
├── models/              ← Clases del negocio (POO)
│   ├── __init__.py
│   ├── producto.py
│   ├── cliente.py
│   └── venta.py
│
├── dao/                 ← Clases DAO (acceso a BD)
│   ├── __init__.py
│   ├── producto_dao.py
│   ├── cliente_dao.py
│   └── venta_dao.py
│
├── ui/                  ← Vistas FLET
│   ├── __init__.py
│   ├── login_view.py
│   ├── menu_view.py
│   ├── productos_view.py
│   └── ventas_view.py
│
├── services/            ← Lógica del negocio (SOLID-S)
│   ├── __init__.py
│   └── venta_service.py
│
├── tests/               ← Pruebas unitarias
│   ├── __init__.py
│   ├── test_producto.py
│   └── test_venta.py
│
├── docs/                ← Documentación
│   ├── manual_usuario.pdf
│   ├── guia_instalacion.pdf
│   └── diagrama_clases.drawio
│
├── requirements.txt     ← pip freeze > requirements.txt
└── README.md            ← Descripción del proyecto

"""
Sistema de Administración — Proyecto Final POO
Universidad Tecnológica de Hermosillo
Materia: Programación Orientada a Objetos
Docente: Bernardo Prado Díaz
Alumno: [Tu Nombre]
Fecha: Mayo–Agosto 2026
"""

import flet as ft  # Importa el módulo flet para usar sus funciones y clases
from ui.login_view import LoginView  # Importa LoginView del módulo ui.login_view
from ui.menu_view import MenuView  # Importa MenuView del módulo ui.menu_view
from database.conexion import Conexion  # Importa Conexion del módulo database.conexion

def main(page: ft.Page):  # Método que main
    page.title = "Sistema de Administración UTH"  # Asigna un valor inicial o calculado a page.title
    page.bgcolor = ft.colors.BLUE_GREY_50  # Asigna un valor inicial o calculado a page.bgcolor
    page.window_width = 1200  # Asigna un valor inicial o calculado a page.window_width
    page.window_height = 750  # Asigna un valor inicial o calculado a page.window_height
    page.window_center()  # Completa la llamada o expresión iniciada anteriormente

    def ir_a_menu(usuario):  # Método que ir a menu
        # Función para navegar del login al menú principal
        page.clean()  # Completa la llamada o expresión iniciada anteriormente
        page.add(MenuView(page, usuario))  # Completa la llamada o expresión iniciada anteriormente
        page.update()  # Completa la llamada o expresión iniciada anteriormente

    try:  # Intenta ejecutar el bloque; si hay error, lo captura el except
        db = Conexion()    # Verificamos la conexión a BD al iniciar
        page.add(LoginView(page, ir_a_menu))  # Completa la llamada o expresión iniciada anteriormente
    except Exception as e:  # Captura el error Exception as e si ocurre en el try
        # Si no hay conexión, mostramos error en vez de colapsar
        page.add(ft.Column([  # Continúa la lógica del ejemplo paso a paso
            ft.Icon(ft.icons.ERROR_OUTLINE, size=60, color=ft.colors.RED),  # Continúa la lógica del ejemplo paso a paso
            ft.Text("No se pudo conectar a la base de datos", size=20),  # Continúa la lógica del ejemplo paso a paso
            ft.Text(str(e), size=13, color=ft.colors.GREY_600),  # Continúa la lógica del ejemplo paso a paso
            ft.ElevatedButton("Reintentar", on_click=lambda _: page.clean()),  # Continúa la lógica del ejemplo paso a paso
        ], horizontal_alignment=ft.CrossAxisAlignment.CENTER))  # Completa la llamada o expresión iniciada anteriormente

    page.update()  # Completa la llamada o expresión iniciada anteriormente

ft.app(target=main)  # Completa la llamada o expresión iniciada anteriormente

# 🏢 Sistema de Administración [Nombre del Negocio]

## Descripción
Sistema de gestión desarrollado como proyecto final de la asignatura
**Programación Orientada a Objetos** en la Universidad Tecnológica de Hermosillo.

**Alumno:** [Tu Nombre]
**Docente:** Bernardo Prado Díaz
**Periodo:** Mayo–Agosto 2026
**Carrera:** TIID

## Tecnologías
- Python 3.12+
- FLET (GUI)
- MySQL / WampServer 3.3.7
- DBeaver 25.1.0
- Git

## Características
- ✅ CRUD completo de productos y clientes
- ✅ Módulo de ventas con reportes
- ✅ Autenticación de usuarios
- ✅ Manejo de excepciones personalizado
- ✅ Pruebas unitarias

## Instalación
1. Clonar: `git clone [URL]`
2. Activar venv: `venv\Scripts\activate`
3. Instalar: `pip install -r requirements.txt`
4. Ejecutar SQL: abrir `database/script.sql` en DBeaver
5. Configurar contraseña en `database/conexion.py`
6. Ejecutar: `python main.py`

## Estructura del Proyecto
[ver documentación técnica en /docs]