motulco 0.2.0__py3-none-any.whl

motulco/__init__.py

@@ -0,0 +1,8 @@
+from .colors_utils import *
+from .df_utils import *
+from .doc_utils import *
+from .excel_utils import *
+from .pdf_utils import *
+from .ppt_utils import *
+from .py_utils import *
+from .shapes_utils import *

motulco/colors_utils.py

@@ -0,0 +1,12 @@
+
+
+
+################################################################################################################################
+################################################################################################################################
+####################################################### Convierte de HEX a RGB #################################################
+################################################################################################################################
+################################################################################################################################
+def hex_to_rgb(hex_color):
+    """Convierte color hex (#RRGGBB) a tupla RGB (R,G,B)"""
+    hex_color = hex_color.lstrip("#")
+    return tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))

motulco/df_utils.py

@@ -0,0 +1,185 @@
+import pandas as pd
+import os
+from unidecode import unidecode
+from openpyxl import load_workbook
+
+################################################################################################################################
+################################################################################################################################
+################################# Quita los .0 en los textos de un df en las columnas dadas ####################################
+################################################################################################################################
+################################################################################################################################
+def QuitarPuntosDecimalesTextos(df, columnas):
+    """Convierte las columnas especificadas a string y elimina el sufijo '.0' de los valores numéricos.
+    Returns:
+        pd.DataFrame: El DataFrame con las columnas modificadas.
+    """
+    df[columnas] = df[columnas].astype(str).replace(r'^(\d+)\.0$', r'\1', regex=True)
+    return df
+
+################################################################################################################################
+################################################################################################################################
+################################## Hace la union (merge/join) de df1 y df2 y valida cruces  ####################################
+################################################################################################################################
+################################################################################################################################
+def mergeBases(dataframe1, dataframe2, lefton, righton):
+    """Une dos DataFrames de Pandas asegurando que no haya duplicados en el cruce y detectando registros sin coincidencias en cada DataFrame.
+
+    Parámetros:
+    - dataframe1: Primer DataFrame de Pandas.
+    - dataframe2: Segundo DataFrame de Pandas.
+    - lefton: Lista de columnas clave en dataframe1.
+    - righton: Lista de columnas clave en dataframe2.
+
+    Retorna:
+    - dfmerge: DataFrame con la unión.
+    - df_no_match_left: Registros en dataframe1 que no encontraron match en dataframe2.
+    - df_no_match_right: Registros en dataframe2 que no encontraron match en dataframe1.
+    - alerta_duplicados: Mensaje de alerta si hay duplicados en la clave.
+    """
+
+    # Realizar el merge con how='left'
+    if lefton == righton:
+        dfmerge = pd.merge(dataframe1, dataframe2, on=lefton, how='left',suffixes=('','_right'))
+    else:
+        dfmerge = pd.merge(dataframe1, dataframe2, left_on=lefton, right_on=righton, how='left', suffixes=('','_right'))
+
+    # Eliminar columnas duplicadas generadas por el merge
+    if isinstance(righton, list):  # Si righton es una lista de columnas
+        for col in righton:
+            columna_duplicada = f"{col}_right"
+            if columna_duplicada in dfmerge.columns:
+                dfmerge = dfmerge.drop(columns=[columna_duplicada])
+    else:  # Si righton es una sola columna
+        columna_duplicada = f"{righton}_right"
+        if columna_duplicada in dfmerge.columns:
+            dfmerge = dfmerge.drop(columns=[columna_duplicada])
+
+    # Detectar registros de df1 que no tienen coincidencias en df2 (valores NaN en columnas de df2)
+    columnas_df2 = [col for col in dataframe2.columns if col not in righton]
+    df_no_match_left = dfmerge[dfmerge[columnas_df2].isna().all(axis=1)]
+
+    # Detectar registros de df2 que no tienen coincidencias en df1
+    claves_merge = set(dfmerge[lefton].drop_duplicates().itertuples(index=False, name=None))
+    df_no_match_right = dataframe2[~dataframe2[righton].apply(lambda x: tuple(x) in claves_merge, axis=1)]
+
+    # Detectar duplicados en las claves del merge
+    duplicados = dfmerge.groupby(lefton).size()
+    duplicados = duplicados[duplicados > 1]  # Filtrar claves duplicadas
+
+    alerta_duplicados = "⚠️ Hay duplicados en la clave del cruce" if len(duplicados) > 0 else "✅ No hay duplicados en la clave"
+
+    return dfmerge, df_no_match_left, df_no_match_right, alerta_duplicados
+
+################################################################################################################################
+################################################################################################################################
+################################### Quita las tildes del contenido de un DataFrame  ############################################
+################################################################################################################################
+################################################################################################################################
+def dfSinTildes(dataframe):
+    for columna in dataframe.columns:
+        if dataframe[columna].dtype == 'object':
+            dataframe[columna] = dataframe[columna].apply(unidecode)
+    return  dataframe
+
+################################################################################################################################
+################################################################################################################################
+################################### Quita las tildes de los encabezados de un DataFrame   ######################################
+################################################################################################################################
+################################################################################################################################
+def dfEncabezadosSinTildes(dataframe):
+    nuevos_nombres_columnas = [unidecode(columna) 
+        if dataframe[columna].dtype == 'object' else columna for columna in dataframe.columns]
+    dataframe.columns = nuevos_nombres_columnas
+    return  dataframe
+
+
+################################################################################################################################
+################################################################################################################################
+############################### Guarda un df como un excel en caso de existir reemplaza   ######################################
+################################################################################################################################
+################################################################################################################################
+def GuardarRemplazarExcel(dataframe,rutaParaGuardado,nombreHoja, ejecutar=True):  
+    if ejecutar:
+        if os.path.exists(rutaParaGuardado):
+            os.remove(rutaParaGuardado)
+        dataframe.to_excel(rutaParaGuardado,sheet_name=nombreHoja, index=False)
+
+################################################################################################################################
+################################################################################################################################
+############################### Guarda un df como un CSV en caso de existir reemplaza   ########################################
+################################################################################################################################
+################################################################################################################################
+def GuardarRemplazarCsv(dataframe,rutaParaGuardado, ejecutar=True):  
+    if ejecutar:
+        if os.path.exists(rutaParaGuardado):
+            os.remove(rutaParaGuardado)
+        dataframe.to_csv(rutaParaGuardado, index=False)
+
+################################################################################################################################
+################################################################################################################################
+############################### Guarda un df como un parquet en caso de existir reemplaza   ####################################
+################################################################################################################################
+################################################################################################################################
+def GuardarRemplazarParquet(dataframe,rutaParaGuardado, ejecutar=True, engine="fastparquet"):  
+    if ejecutar:
+        if os.path.exists(rutaParaGuardado):
+            os.remove(rutaParaGuardado)
+        if engine=="":    
+            dataframe.to_parquet(rutaParaGuardado, index=False)
+        else:
+            dataframe.to_parquet(rutaParaGuardado, index=False, engine=engine)
+
+################################################################################################################################
+################################################################################################################################
+######################################################### Convierte columnas en tipo bool   ####################################
+################################################################################################################################
+################################################################################################################################
+def EstandarizarColumnasConDatosBool(dataframe):
+    for col in dataframe.columns:
+        # Si en la columna hay al menos un valor booleano
+        if dataframe[col].apply(lambda x: isinstance(x, bool)).any():
+            # Reemplazar NaN con False y convertir todo a tipo bool
+            dataframe[col] = dataframe[col].astype(object).fillna(False).astype(bool)
+    return dataframe
+
+################################################################################################################################
+################################################################################################################################
+######################################################### Convierte columnas en tipo bool   ####################################
+################################################################################################################################
+################################################################################################################################
+def extraerMesInicioDelNombre(nombreArchivo,Separador):
+    """ Extrae el número y nombre del mes desde el nombre del archivo. """
+    nombreArchivo = nombreArchivo.replace(" ", "")  # Elimina espacios extra
+    partes = nombreArchivo.split(Separador)
+    if len(partes) >= 1:
+        numero_mes = partes[0].strip()  # "01"
+        return numero_mes
+
+    return None, None  # Retornar valores nulos si el formato no es el esperado
+
+################################################################################################################################
+################################################################################################################################
+################ Funcion que convierte una cadena a (UpperCamelCase), eliminando espacios y guiones bajos.   ###################
+################################################################################################################################
+################################################################################################################################
+def pasarACamelCase(texto,Separador):
+    # Reemplaza guiones bajos por espacios, divide en palabras, y las capitaliza
+    partes = texto.replace(Separador, " ").split()
+    return ''.join(p.capitalize() for p in partes)
+
+
+################################################################################################################################
+################################################################################################################################
+################ Renombrar columnas de un df con poniendo en CamelCase lo que esta a la izquierda del separador  ###############
+################################################################################################################################
+################################################################################################################################
+def renombraColumnasTablas(dataframe,Separador):
+    nuevas_columnas = {}
+    for col in dataframe.columns:
+        if "_" in col:
+            izquierda, derecha = col.split("_", 1)  # Solo divide en el primer guion bajo
+            nuevo_nombre = f"{pasarACamelCase(izquierda,Separador)}_{derecha}"
+        else:
+            nuevo_nombre = pasarACamelCase(col,Separador)
+        nuevas_columnas[col] = nuevo_nombre
+    return dataframe.rename(columns=nuevas_columnas)

motulco/doc_utils.py

@@ -0,0 +1,84 @@
+import numpy as np
+import pandas as pd
+import os 
+import shutil
+from unidecode import unidecode
+
+
+################################################################################################################################
+################################################################################################################################
+####################################### Borrar los archivos si existen en la carpeta ###########################################
+################################################################################################################################
+################################################################################################################################
+def BorrrarArchivo(rutaArchivo):  
+    if os.path.exists(rutaArchivo):# Verificar si el archivo ya existe
+        os.remove(rutaArchivo)
+
+################################################################################################################################
+################################################################################################################################
+################################# Mueve los archivos descargados a la carpeta que se requiere ##################################
+################################################################################################################################
+################################################################################################################################
+def moverArchivo(RutaOrigen, RutaDestino):
+    try:
+        shutil.move(RutaOrigen, RutaDestino)
+        print(f"El archivo '{RutaOrigen}' se ha movido correctamente a '{RutaDestino}'.")
+    except Exception as e:
+        print(f"No se pudo mover el archivo '{RutaOrigen}' a '{RutaDestino}': {e}")
+
+################################################################################################################################
+################################################################################################################################
+############################################### Copia un archivo de un destino a otro ##########################################
+################################################################################################################################
+################################################################################################################################
+def copiarArchivo(RutaOrigen, RutaDestino):
+    try:
+        shutil.copy2(RutaOrigen, RutaDestino)  # `copy2` copia metadatos (marca de tiempo) además del archivo
+        print(f"El archivo '{RutaOrigen}' se ha copiado correctamente a '{RutaDestino}'.")
+    except Exception as e:
+        print(f"No se pudo copiar el archivo '{RutaOrigen}' a '{RutaDestino}': {e}")
+
+################################################################################################################################
+################################################################################################################################
+###################################### Obtiene el archivo más reciente de una carpeta ##########################################
+################################################################################################################################
+################################################################################################################################
+def obtenerArchivoMasReciente(rutaCarpeta, formato=".txt"):
+    # Obtener la lista de archivos en la carpeta
+    archivos_en_carpeta = [archivo for archivo in os.listdir(rutaCarpeta) if archivo.endswith(formato)]
+    # Verificar si hay archivos en la carpeta
+    if archivos_en_carpeta:
+        # Obtener el archivo más reciente basado en la última modificación
+        archivo_mas_reciente = max(archivos_en_carpeta,key=lambda x: os.path.getmtime(os.path.join(rutaCarpeta, x)))
+        # Obtener la fecha de modificación del archivo más reciente
+        fecha_modificacion = os.path.getmtime(os.path.join(rutaCarpeta, archivo_mas_reciente))
+        # Retornar nombre y fecha
+        return archivo_mas_reciente, fecha_modificacion
+    else:
+        return None, None
+
+################################################################################################################################
+################################################################################################################################
+###################################### Retorna la ruta que exista del arreglo de rutas #########################################
+################################################################################################################################
+################################################################################################################################
+def ExisteRuta(arregloDeRutas):
+    carpeta_correcta = None
+    for carpeta in arregloDeRutas:
+        try:
+            # Verifica si la ruta existe y es una carpeta
+            if os.path.isdir(carpeta):
+                print(f"La carpeta existe en: {carpeta}")
+                carpeta_correcta = carpeta
+                break  # Sale del ciclo si la carpeta existe
+        except Exception as e:
+            # Maneja otras posibles excepciones (e.g., problemas de permisos)
+            print(f"Error al verificar la carpeta {carpeta}: {e}")
+            continue
+    if carpeta_correcta is None:
+        print("La carpeta no se encontró en ninguna de las rutas proporcionadas.")
+    else:
+        # Aquí puedes continuar con el procesamiento usando la carpeta_correcta
+        pass
+    return carpeta_correcta
+

motulco/excel_utils.py

@@ -0,0 +1,126 @@
+import os 
+import pandas as pd
+import openpyxl
+import time
+import pythoncom
+import win32com.client
+from openpyxl import load_workbook
+
+
+################################################################################################################################
+################################################################################################################################
+############################################### Carga un archivo de excel como un df ###########################################
+################################################################################################################################
+################################################################################################################################
+def cargaExcel(rutaArchivo,sheetName, AsString=False,engine='openpyxl'):
+    df = pd.read_excel(rutaArchivo, sheet_name=sheetName, engine=engine)
+    if AsString:
+        df=df.astype(str)
+    return df
+
+################################################################################################################################
+################################################################################################################################
+############################################# Ejecuta la funcion Actualizar todo de excel ######################################
+################################################################################################################################
+################################################################################################################################
+
+def ActualizarTodoExcel(rutaArchivo):
+    pythoncom.CoInitialize()  # Inicializa COM correctamente
+
+    try:
+        rutaArchivoAbsoluta = os.path.abspath(rutaArchivo)
+        print(f"Intentando abrir el archivo: {rutaArchivoAbsoluta}")
+
+        if not os.path.exists(rutaArchivoAbsoluta):
+            print(f"⚠️ El archivo no existe en la ruta: {rutaArchivoAbsoluta}")
+            return
+        # Iniciar Excel y hacerlo visible
+        excel_app = win32com.client.DispatchEx("Excel.Application")
+        excel_app.Visible = True  
+        excel_app.DisplayAlerts = False
+        # Abrir el archivo de Excel
+        workbook = excel_app.Workbooks.Open(rutaArchivoAbsoluta)
+        print("📂 Archivo abierto correctamente, iniciando actualización...")
+
+        # Activar la primera hoja (por si acaso)
+        workbook.Sheets(1).Activate()
+        # Iniciar actualización
+        workbook.RefreshAll()
+        print("🔄 Actualizando conexiones y tablas de Power Query...")
+        # Esperar que Excel termine la actualización y cálculos
+        while excel_app.CalculationState != 0:  # 0 significa "listo"
+            print("⌛ Esperando que Excel termine los cálculos...")
+            time.sleep(2)
+        print("✅ Actualización completada.")
+        # Guardar y cerrar Excel
+        print(f'📁 Archivo actualizado y cerrado: {rutaArchivoAbsoluta}')
+    except Exception as e:
+        print(f"❌ Error al actualizar el archivo {rutaArchivoAbsoluta}: {e}")
+    finally:
+        # Asegurar que Excel se cierra correctamente
+        if 'excel_app' in locals():
+            a=10
+        pythoncom.CoUninitialize()
+
+################################################################################################################################
+################################################################################################################################
+#################################### Consolida Archivos de excel cuyo nombre es semejante ######################################
+################################################################################################################################
+################################################################################################################################
+def consolidarArchivosExcelPrefijo(NombreConElQueIniciaLosArchivos,RutaALaCarpeta,TipoArchivos='.xlsx'):
+    dataframes = []
+    for archivo in os.listdir(RutaALaCarpeta):
+        if archivo.endswith(TipoArchivos) and archivo.startswith(NombreConElQueIniciaLosArchivos):
+            ruta_archivo = os.path.join(RutaALaCarpeta, archivo)
+            df = pd.read_excel(ruta_archivo)
+            dataframes.append(df)    
+    df_consolidado = pd.concat(dataframes, ignore_index=True)
+    return df_consolidado
+
+################################################################################################################################
+################################################################################################################################
+############################################## Consolida Archivos de excel en una carpeta ######################################
+################################################################################################################################
+################################################################################################################################
+def consolidarArchivosExcelGlobal(NombreConElQueIniciaLosArchivos,RutaALaCarpeta,TipoArchivos='.xlsx'):
+    dataframes = []
+    for archivo in os.listdir(RutaALaCarpeta):
+        if archivo.endswith(TipoArchivos):
+            ruta_archivo = os.path.join(RutaALaCarpeta, archivo)
+            df = pd.read_excel(ruta_archivo)
+            dataframes.append(df)    
+    df_consolidado = pd.concat(dataframes, ignore_index=True)
+    return df_consolidado
+
+
+################################################################################################################################
+################################################################################################################################
+################################## Funcion que retornas el arreglo de hojas visibles (no oculta) en excel    ###################
+################################################################################################################################
+################################################################################################################################
+def obtenerHojasVisiblesExcel(RutaArchivo):
+    """Obtiene solo las hojas visibles de un archivo Excel (.xlsx)."""
+    try:
+        wb = load_workbook(RutaArchivo, read_only=True)
+        hojas_visibles = [sheet.title for sheet in wb.worksheets if sheet.sheet_state == "visible"]
+        wb.close()
+        return hojas_visibles
+    except Exception as e:
+        print(f"Error al leer hojas de {RutaArchivo}: {e}")
+        return []
+
+################################################################################################################################
+################################################################################################################################
+################################## Funcion que retornas el arreglo de todas las hojas en excel    ##############################
+################################################################################################################################
+################################################################################################################################
+def obtenerTodasLasHojasExcel(RutaArchivo):
+    """Obtiene todas las hojas de un archivo Excel (.xlsx), sin importar si están visibles u ocultas."""
+    try:
+        wb = load_workbook(RutaArchivo, read_only=True)
+        hojas = [sheet.title for sheet in wb.worksheets]  # Todas las hojas
+        wb.close()
+        return hojas
+    except Exception as e:
+        print(f"Error al leer hojas de {RutaArchivo}: {e}")
+        return []

motulco/pdf_utils.py

@@ -0,0 +1,29 @@
+from pypdf import PdfReader, PdfWriter
+
+
+
+################################################################################################################################
+################################################################################################################################
+####################################### Rota los grados y paginas deseadas de un pdf ###########################################
+################################################################################################################################
+################################################################################################################################
+def rotarPaginasPdf(pdf_entrada, pdf_salida, paginas_a_rotar, grados):
+    """
+    Rota páginas específicas de un PDF.
+
+    pdf_entrada: str -> ruta del PDF original
+    pdf_salida: str -> ruta del PDF modificado
+    paginas_a_rotar: list[int] -> índices de páginas a rotar (0 = primera)
+    grados: int -> grados de rotación (90, 180, 270)
+    """
+
+    reader = PdfReader(pdf_entrada)
+    writer = PdfWriter()
+
+    for i, page in enumerate(reader.pages):
+        if i in paginas_a_rotar:
+            page.rotate(grados)
+        writer.add_page(page)
+
+    with open(pdf_salida, "wb") as f:
+        writer.write(f)

motulco/ppt_utils.py

@@ -0,0 +1,309 @@
+
+import os
+import shutil
+from PIL import Image
+import pandas as pd
+
+
+################################################################################################################################
+################################################################################################################################
+################################################# Abre una diapositiva existente ###############################################
+################################################################################################################################
+################################################################################################################################
+def abrirPresentacion(RutaPpt):
+    # --- 1️⃣ Limpiar la caché COM dañada ---
+    gen_py_path = os.path.join(os.environ["LOCALAPPDATA"], "Temp", "gen_py")
+    if os.path.exists(gen_py_path):
+        try:
+            shutil.rmtree(gen_py_path, ignore_errors=True)
+        except Exception as e:
+            print(f"No se pudo eliminar la caché gen_py: {e}")
+
+    # --- 2️⃣ Regenerar caché de COM ---
+    import win32com.client.gencache
+    win32com.client.gencache.is_readonly = False
+    try:
+        win32com.client.gencache.Rebuild()
+    except Exception:
+        pass  # A veces da advertencias inofensivas
+
+    # --- 3️⃣ Crear o usar instancia de PowerPoint ---
+    try:
+        ppt_app = win32com.client.GetActiveObject("PowerPoint.Application")
+    except Exception:
+        ppt_app = win32com.client.Dispatch("PowerPoint.Application")
+
+    ppt_app.Visible = True
+
+    # --- 4️⃣ Abrir la presentación plantilla ---
+    pres_src = ppt_app.Presentations.Open(RutaPpt)
+
+    return ppt_app, pres_src
+
+################################################################################################################################
+################################################################################################################################
+################################################# Crea un libro de ppt en blanco ###############################################
+################################################################################################################################
+################################################################################################################################
+def CrearPresentacion(pptDestino):
+    import time
+    import win32com.client as win32
+
+    try:
+        ppt_app = win32.gencache.EnsureDispatch("PowerPoint.Application")
+    except Exception:
+        # Si falla, limpia la caché y usa Dispatch
+        import os, shutil
+        gen_py_path = os.path.join(os.environ["LOCALAPPDATA"], "Temp", "gen_py")
+        shutil.rmtree(gen_py_path, ignore_errors=True)
+        ppt_app = win32.Dispatch("PowerPoint.Application")
+
+    ppt_app.Visible = True
+    pres_dst = ppt_app.Presentations.Add()
+    pres_dst.SaveAs(pptDestino)
+    time.sleep(1)
+    return ppt_app, pres_dst
+
+################################################################################################################################
+################################################################################################################################
+################################################# Copia diapositivas entre ppt's ###############################################
+################################################################################################################################
+################################################################################################################################
+def copiarDiaposPosicion(pres_src, pres_dst, posicionesCopiar):
+    # ✅ Ajustar tamaño de página igual al origen
+    pres_dst.PageSetup.SlideWidth = pres_src.PageSetup.SlideWidth
+    pres_dst.PageSetup.SlideHeight = pres_src.PageSetup.SlideHeight
+
+    for pos in posicionesCopiar:
+        pres_src.Slides(pos + 1).Copy()  # Copiar (recordar que es base 1)
+        pres_dst.Slides.Paste()  # Pegar manteniendo formato
+
+    #pres_dst.Save()  # ✅ Guardar cambios
+
+################################################################################################################################
+################################################################################################################################
+######################################################## Guarda una presentacion ###############################################
+################################################################################################################################
+################################################################################################################################
+def guardarPpt(pres_dst):
+    pres_dst.Save()
+
+
+################################################################################################################################
+################################################################################################################################
+#################################### Obtienene la ultima posicion Vertical de la ppt ###########################################
+################################################################################################################################
+################################################################################################################################
+def getNextY(slide, padding=5):
+    """ Calcula la siguiente posición disponible en Y dentro de una diapositiva """
+    max_y = 0
+    for shape in slide.Shapes:
+        bottom = shape.Top + shape.Height
+        if bottom > max_y:
+            max_y = bottom
+    return max_y + padding
+
+################################################################################################################################
+################################################################################################################################
+########################################## Obtienene la cantidad de slides en la ppt ###########################################
+################################################################################################################################
+################################################################################################################################
+def obtenerDiapositivaMaxima(presentacion):
+    try:
+        return presentacion.Slides.Count
+    except:
+        return None
+
+
+
+################################################################################################################################
+################################################################################################################################
+################################################# Agregar Elemento (shape) a una ppt ###########################################
+################################################################################################################################
+################################################################################################################################
+def agregarElemento(pres_dst, pres_src, num_slide, tipo, contenido, x=50, y="auto",
+                     ancho=300, alto=100, font_size=20,
+                     font_name="Arial", bold=False, italic=False,
+                     color=(0, 0, 0), align="left",
+                     crop_top=0, crop_bottom=0, crop_left=0, crop_right=0,
+                     auto_crop=False, mantener_relacion=True, mantener_relacion_base="ancho",
+                     paddingSet=5, rotacion=0):
+    """
+    Inserta texto o imagen en una diapositiva de PowerPoint.
+    Ahora incluye rotación para imágenes vía rotacion=grados.
+    """
+    puntosACentimetros=28.3465
+    slide = pres_dst.Slides(num_slide)
+    slide_width = pres_dst.PageSetup.SlideWidth
+    slide_height = pres_dst.PageSetup.SlideHeight
+
+    # ======== Calcular Y inicial ========
+    if y == "auto":
+        y = getNextY(slide, paddingSet) - crop_top * puntosACentimetros * 6
+
+    # ======== Auto crop ========
+    if auto_crop:
+        crop_top = 0.05
+        crop_bottom = 0.05
+        crop_left = 0.03
+        crop_right = 0.03
+
+    # ======== Mantener relación si es imagen ========
+    if tipo == "imagen" and mantener_relacion:
+        try:
+            with Image.open(contenido) as img:
+                width_orig, height_orig = img.size
+                aspect_ratio = width_orig / height_orig
+
+            if mantener_relacion_base == "ancho":
+                # Ajustar alto usando el ancho como referencia
+                alto = ancho / aspect_ratio
+
+            elif mantener_relacion_base == "alto":
+                # Ajustar ancho usando el alto como referencia
+                ancho = alto * aspect_ratio
+
+            else:
+                print(f"⚠️ Opción inválida en mantener_relacion_base: {mantener_relacion_base}")
+
+        except Exception as e:
+            print(f"⚠️ No se pudo calcular proporción de imagen: {e}")
+
+
+    # ======== Calcular alto visible ========
+    alto_visible = alto * (1 - crop_top - crop_bottom)
+
+    # ======== Verificar si cabe ========
+    if y + alto_visible > slide_height:
+        copiarDiaposPosicion(pres_src, pres_dst, [0])
+        num_slide += 1
+        slide = pres_dst.Slides(num_slide)
+        y = getNextY(slide, paddingSet) - crop_top * puntosACentimetros * 6
+
+    # ======== Convertir color HEX a RGB ========
+    if isinstance(color, str):
+        color = hex_to_rgb(color)
+
+    # ======== TEXTO / TÍTULO ========
+    if tipo in ["texto", "titulo"]:
+        textbox = slide.Shapes.AddTextbox(1, x if x != "center" else 50, y, ancho, alto)
+        text_range = textbox.TextFrame.TextRange
+        text_range.Text = contenido
+        text_range.Font.Name = font_name
+        text_range.Font.Size = font_size
+        text_range.Font.Bold = -1 if bold else 0
+        text_range.Font.Italic = -1 if italic else 0
+        text_range.Font.Color.RGB = color[0] + (color[1] << 8) + (color[2] << 16)
+
+        if align == "center":
+            textbox.TextFrame.TextRange.ParagraphFormat.Alignment = 2
+        elif align == "right":
+            textbox.TextFrame.TextRange.ParagraphFormat.Alignment = 3
+        elif align == "justify":
+            textbox.TextFrame.TextRange.ParagraphFormat.Alignment = 4
+        else:
+            textbox.TextFrame.TextRange.ParagraphFormat.Alignment = 1
+
+        if tipo == "titulo":
+            text_range.Font.Bold = -1
+
+            # ⭐ Aplicar rotación a texto
+        try:
+            textbox.Rotation = float(rotacion)
+        except:
+            print(f"⚠️ No se pudo aplicar rotación a texto: {rotacion}")
+
+        return textbox
+
+    # ======== IMAGEN ========
+    elif tipo == "imagen":
+        shape = slide.Shapes.AddPicture(
+            contenido, LinkToFile=False, SaveWithDocument=True,
+            Left=0, Top=y, Width=ancho, Height=alto
+        )
+
+        shape.LockAspectRatio = mantener_relacion
+
+        # --- Aplicar recortes ---
+        shape.PictureFormat.CropTop = crop_top * shape.Height
+        shape.PictureFormat.CropBottom = crop_bottom * shape.Height
+        shape.PictureFormat.CropLeft = crop_left * shape.Width
+        shape.PictureFormat.CropRight = crop_right * shape.Width
+
+        # --- Centrar horizontalmente ---
+        if isinstance(x, str) and x.lower() in ["center", "x_center"]:
+            ancho_real = shape.Width
+            shape.Left = (slide_width - ancho_real) / 2
+        else:
+            shape.Left = x
+
+        # --- ⭐ APLICAR ROTACIÓN ⭐ ---
+        try:
+            shape.Rotation = float(rotacion)
+        except:
+            print(f"⚠️ No se pudo aplicar rotación: {rotacion}")
+
+        return shape
+
+
+################################################################################################################################
+################################################################################################################################
+################################################# Agregar Elemento (shape) a una ppt ###########################################
+################################################################################################################################
+################################################################################################################################
+def AgregarElementoConindicador(Indicador, tipo,df_Control,PresDest,PresSrc,contenidoAdicional):
+    puntosACentimetros=28.3465
+    if df_Control.at[Indicador, 'INSERTAR SLIDE']:
+        copiarDiaposPosicion(PresSrc, PresDest, [0])
+    
+    if contenidoAdicional =="" and tipo != "imagen": 
+        contenidoFinal=df_Control.at[Indicador, 'CONTENIDO'] 
+    elif contenidoAdicional !="" and tipo != "imagen":
+        if pd.isna(df_Control.at[Indicador, 'CONTENIDO']) or str(df_Control.at[Indicador, 'CONTENIDO']).strip().lower() in ["nan", "none", ""]:
+            contenidoFinal=f"{contenidoAdicional}"
+        else:
+            contenidoFinal=df_Control.at[Indicador, 'CONTENIDO'] + f" {contenidoAdicional}" 
+            
+    if tipo == "imagen":
+        agregarElemento(pres_dst=PresDest,pres_src=PresSrc,num_slide = PresDest.Slides.Count ,tipo= df_Control.at[Indicador, 'TIPO'],
+                          contenido=os.path.abspath(df_Control.at[Indicador, 'CONTENIDO']) ,x=convertirPuntosACentimetros(df_Control.at[Indicador, 'POSICION X']),
+                            y=convertirPuntosACentimetros(df_Control.at[Indicador, 'POSICION Y']) ,ancho=df_Control.at[Indicador, 'ANCHO'] * puntosACentimetros,
+                            alto=df_Control.at[Indicador, 'ALTO'] * puntosACentimetros ,font_size=df_Control.at[Indicador, 'TAMANIO FUENTE'],
+                            font_name=df_Control.at[Indicador, 'TIPO FUENTE'] ,bold=df_Control.at[Indicador, 'NEGRITA'], italic=df_Control.at[Indicador, 'CURSIVA']
+                            ,color=df_Control.at[Indicador, 'COLOR'], align=df_Control.at[Indicador, 'ALINEACION'] ,crop_top=df_Control.at[Indicador, 'CORTE SUPERIOR']
+                            ,crop_bottom=df_Control.at[Indicador, 'CORTE INFERIOR'] ,crop_left=df_Control.at[Indicador, 'CORTE IZQUIERDA'],
+                            crop_right=df_Control.at[Indicador, 'CORTE DERECHA'] ,auto_crop=df_Control.at[Indicador, 'AUTO CORTE']
+                            ,mantener_relacion=df_Control.at[Indicador, 'RELACION ASPECTO'],paddingSet=df_Control.at[Indicador, 'PADDING'],
+                            rotacion=df_Control.at[Indicador, 'ROTACION'],mantener_relacion_base=df_Control.at[Indicador, 'BASE RELACION ASPECTO'])
+    else:
+        agregarElemento(pres_dst=PresDest,pres_src=PresSrc,num_slide = PresDest.Slides.Count ,tipo= df_Control.at[Indicador, 'TIPO'],
+                         contenido=contenidoFinal ,x=convertirPuntosACentimetros(df_Control.at[Indicador, 'POSICION X']), y=convertirPuntosACentimetros(df_Control.at[Indicador, 'POSICION Y']),
+                         ancho=df_Control.at[Indicador, 'ANCHO'] * puntosACentimetros, alto=df_Control.at[Indicador, 'ALTO'] * puntosACentimetros,
+                         font_size=df_Control.at[Indicador, 'TAMANIO FUENTE'], font_name=df_Control.at[Indicador, 'TIPO FUENTE'] ,bold=df_Control.at[Indicador, 'NEGRITA'],
+                         italic=df_Control.at[Indicador, 'CURSIVA'] ,color=df_Control.at[Indicador, 'COLOR'], align=df_Control.at[Indicador, 'ALINEACION'],
+                         crop_top=df_Control.at[Indicador, 'CORTE SUPERIOR'], crop_bottom=df_Control.at[Indicador, 'CORTE INFERIOR'],
+                         crop_left=df_Control.at[Indicador, 'CORTE IZQUIERDA'], crop_right=df_Control.at[Indicador, 'CORTE DERECHA'],
+                         auto_crop=df_Control.at[Indicador, 'AUTO CORTE'], mantener_relacion=df_Control.at[Indicador, 'RELACION ASPECTO'],
+                         paddingSet=df_Control.at[Indicador, 'PADDING'],rotacion=df_Control.at[Indicador, 'ROTACION'])
+
+################################################################################################################################
+################################################################################################################################
+################################################# Convierte de puntos a centimetros ############################################
+################################################################################################################################
+################################################################################################################################
+def convertirPuntosACentimetros(value):
+    puntosACentimetros=28.3465
+    try:
+        return (float(value) * puntosACentimetros)
+    except (ValueError, TypeError):
+        return str(value)
+    
+################################################################################################################################
+################################################################################################################################
+####################################################### Convierte de HEX a RGB #################################################
+################################################################################################################################
+################################################################################################################################
+def hex_to_rgb(hex_color):
+    """Convierte color hex (#RRGGBB) a tupla RGB (R,G,B)"""
+    hex_color = hex_color.lstrip("#")
+    return tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))

motulco/py_utils.py

@@ -0,0 +1,54 @@
+import os, shutil, win32com.client, importlib
+import nbformat
+from nbconvert.preprocessors import ExecutePreprocessor
+from pathlib import Path
+
+################################################################################################################################
+################################################################################################################################
+################################################# Limpia el Caché ##############################################################
+################################################################################################################################
+################################################################################################################################
+def limpiarCache():
+    # Rutas posibles de caché
+    paths = [
+        os.path.join(os.environ["LOCALAPPDATA"], "Temp", "gen_py"),
+        os.path.join(os.path.dirname(win32com.__file__), "gen_py"),
+    ]
+
+    for path in paths:
+        if os.path.exists(path):
+            print(f"Eliminando caché: {path}")
+            shutil.rmtree(path, ignore_errors=True)
+        else:
+            print(f"No existe: {path}")
+
+    # Forzar limpieza interna del gencache
+    try:
+        win32com.client.gencache.is_readonly = False
+        win32com.client.gencache.Rebuild()
+        print("🔄 Caché reconstruida.")
+    except Exception as e:
+        print("⚠️ No se pudo reconstruir automáticamente:", e)
+
+################################################################################################################################
+################################################################################################################################
+################################################# Ejecuta un ipynb desde otro codigo ###########################################
+################################################################################################################################
+################################################################################################################################
+def ejecutar_notebook(ruta_notebook):
+    """
+    Ejecuta un notebook Jupyter (.ipynb) en la ruta proporcionada.
+    """
+    try:
+        # Cargar el notebook
+        with open(ruta_notebook, 'r', encoding='utf-8') as f:
+            notebook = nbformat.read(f, as_version=4)
+        
+        # Preprocesador para ejecutar el notebook
+        ep = ExecutePreprocessor(timeout=600, kernel_name='python3')
+        
+        # Ejecutar el notebook
+        ep.preprocess(notebook, {'metadata': {'path': Path(ruta_notebook).parent}})
+        print(f"Notebook ejecutado correctamente: {ruta_notebook}")
+    except Exception as e:
+        print(f"Error al ejecutar {ruta_notebook}: {e}")

motulco/shapes_utils.py

@@ -0,0 +1,409 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import pandas as pd
+import os
+from html2image import Html2Image
+from PIL import Image
+from PIL import ImageChops
+
+
+################################################################################################################################
+################################################################################################################################
+########################################## Generacion de graficos de Barras y Lineas ###########################################
+################################################################################################################################
+################################################################################################################################
+
+def graficoBarrasYLineas(meses, InfoBarras=None, InfoLineas=None,
+                                 coloresBarras=["#19BDE6", "#152C47", "#BACF00"],
+                                 titulo="", ruta_salida="grafico.png", mostrar_tabla=True,
+                                 ancho_figura=14, alto_figura=6, labelLineas="Resultado Real",
+                                 colorLinea="#A461AB", AnchoGrafica=0.8, desplazamientoLeyenda=-0.25,
+                                 BarrasPorcentaje=False, LineasPorcentaje=False,
+                                 cantidadDecimBarras="0", cantidadDecimLineas="0"):
+
+    x = np.arange(len(meses))
+    fig, ax1 = plt.subplots(figsize=(ancho_figura, alto_figura))
+
+    # Decidir si deben compartir eje (cuando ambos tienen mismo tipo: ambos % o ambos absolutos)
+    share_axis = (BarrasPorcentaje == LineasPorcentaje)
+
+    # --- METAS (barras) ---
+    handles1, labels1 = [], []
+    if InfoBarras is not None and len(InfoBarras) > 0:
+        width = AnchoGrafica / len(InfoBarras) if len(InfoBarras) > 0 else AnchoGrafica
+        for i, (meta_name, valores_raw) in enumerate(InfoBarras.items()):
+            # Asegurarse que sean floats
+            valores = [float(v) for v in valores_raw]
+
+            # Multiplicar por 100 para graficar si es porcentaje
+            plot_vals = [v * 100 for v in valores] if BarrasPorcentaje else valores
+
+            ax1.bar(
+                x + (i - len(InfoBarras) / 2) * width + width / 2,
+                plot_vals,
+                width,
+                label=meta_name,
+                color=coloresBarras[i % len(coloresBarras)]
+            )
+        handles1, labels1 = ax1.get_legend_handles_labels()
+
+    # --- RESULTADOS REALES (líneas) ---
+    handles2, labels2 = [], []
+    eje_leyenda = ax1  # por defecto
+
+    if InfoLineas is not None and len(InfoLineas) > 0:
+        # decidir ax2: si comparten eje -> ax2 = ax1; si no -> crear twin sólo si hace falta
+        if share_axis:
+            ax2 = ax1
+        else:
+            # si las lineas están en porcentaje pero las barras no, o viceversa, usar twin
+            ax2 = ax1.twinx() if LineasPorcentaje else ax1
+
+        if isinstance(InfoLineas, pd.DataFrame):
+            num_lineas = InfoLineas.shape[1]
+            labels = labelLineas if isinstance(labelLineas, list) else InfoLineas.columns.tolist()
+            colores = colorLinea if isinstance(colorLinea, list) else [colorLinea] * num_lineas
+
+            for i, col in enumerate(InfoLineas.columns):
+                vals_raw = InfoLineas[col].astype(float).values
+                vals = [float(v) for v in vals_raw]
+
+                # Multiplicar por 100 si es porcentaje
+                if LineasPorcentaje:
+                    vals = [v * 100 for v in vals]
+
+                ax2.plot(x, vals, marker="o", linewidth=2, color=colores[i % len(colores)], label=labels[i])
+
+                # Etiquetas de los puntos
+                max_val = max(vals) if len(vals) > 0 else 0.0
+                for j, val in enumerate(vals):
+                    ax2.text(
+                        x[j], val + max_val * 0.03,
+                        f"{val:.{cantidadDecimLineas}f}%" if LineasPorcentaje else f"{val:.{cantidadDecimLineas}f}",
+                        ha="center", fontsize=10, color="white",
+                        bbox=dict(facecolor=colores[i % len(colores)], edgecolor="none", boxstyle="round,pad=0.25")
+                    )
+            eje_leyenda = ax2
+
+        else:
+            # Caso 1 sola lista
+            vals = [float(v) for v in InfoLineas]
+
+            if LineasPorcentaje:
+                vals = [v * 100 for v in vals]
+            ax2.plot(x, vals, marker="o", linewidth=2, color=colorLinea,
+                     label=labelLineas if isinstance(labelLineas, str) else labelLineas[0])
+
+            max_val = max(vals) if len(vals) > 0 else 0.0
+            for i, val in enumerate(vals):
+                ax2.text(
+                    x[i], val + max_val * 0.03,
+                    f"{val:.{cantidadDecimLineas}f}%" if LineasPorcentaje else f"{val:.{cantidadDecimLineas}f}",
+                    ha="center", fontsize=8, color="white",
+                    bbox=dict(facecolor=colorLinea if isinstance(colorLinea, str) else colorLinea[0],
+                              edgecolor="none", boxstyle="round,pad=0.25")
+                )
+            eje_leyenda = ax2
+
+        # Combinar leyendas
+        handles2, labels2 = eje_leyenda.get_legend_handles_labels()
+        labels_final, handles_final = [], []
+        for h, l in zip(handles1 + handles2, labels1 + labels2):
+            if l not in labels_final:
+                labels_final.append(l)
+                handles_final.append(h)
+
+        # --- TÍTULO ---
+        plt.title(titulo, fontsize=13, pad=25)
+
+    # --- LEYENDA ---
+    handles_final, labels_final = [], []
+
+    if 'handles1' in locals():
+        handles_final += handles1
+        labels_final += labels1
+    if 'handles2' in locals():
+        handles_final += handles2
+        labels_final += labels2
+
+    if handles_final:
+        plt.legend(handles_final, labels_final,
+                loc="upper center", bbox_to_anchor=(0.5, desplazamientoLeyenda),
+                ncol=4, fontsize=8, frameon=False)
+
+
+    # --- AJUSTAR ESCALAS ---
+    # Si comparten eje (ambos % o ambos absolutos) forzar mismos límites
+    if InfoLineas is not None:
+        if share_axis:
+            # obtener límites actuales (si ax2 es el mismo que ax1 esto es redundante pero seguro)
+            try:
+                # si existe ax2 y es distinto a ax1 (por seguridad), considerar ambos
+                if 'ax2' in locals() and ax2 is not ax1:
+                    min_y = min(ax1.get_ylim()[0], ax2.get_ylim()[0])
+                    max_y = max(ax1.get_ylim()[1], ax2.get_ylim()[1])
+                else:
+                    min_y, max_y = ax1.get_ylim()
+                ax1.set_ylim(min_y, max_y)
+                if 'ax2' in locals() and ax2 is not ax1:
+                    ax2.set_ylim(min_y, max_y)
+            except Exception:
+                pass  # si falla por algún motivo, no detener el plotting
+
+    # --- QUITAR EJES ---
+    ax1.axis("off")
+    if 'ax2' in locals() and (ax2 is not ax1) and InfoLineas is not None and LineasPorcentaje:
+        ax2.axis("off")
+
+    # --- TABLA ---
+    if mostrar_tabla and (InfoBarras is not None or InfoLineas is not None):
+        tabla_data = []
+        row_labels = []
+
+        # Barras
+        if InfoBarras is not None:
+            for fila_raw in InfoBarras.values():
+                fila = [float(v) for v in fila_raw]
+                fila_formateada = [
+                    f"{val * 100:,.{cantidadDecimBarras}f}%" if BarrasPorcentaje else f"{val:,.{cantidadDecimBarras}f}"
+                    for val in fila
+                ]
+                tabla_data.append(fila_formateada)
+            row_labels += list(InfoBarras.keys())
+
+        # Líneas
+        if InfoLineas is not None:
+            if isinstance(InfoLineas, pd.DataFrame):
+                for i, col in enumerate(InfoLineas.columns):
+                    vals = InfoLineas[col].astype(float).values
+                    if LineasPorcentaje:
+                        vals = [v * 100 for v in vals]
+                        fila_resultado = [f"{v:,.{cantidadDecimLineas}f}%" for v in vals]
+                    else:
+                        fila_resultado = [f"{v:,.{cantidadDecimLineas}f}" for v in vals]
+                    tabla_data.append(fila_resultado)
+                row_labels += (labelLineas if isinstance(labelLineas, list) else InfoLineas.columns.tolist())
+            else:
+                vals = [float(v) for v in InfoLineas]
+                if LineasPorcentaje:
+                    vals = [v * 100 for v in vals]
+                    fila_resultado = [f"{v:,.{cantidadDecimLineas}f}%" for v in vals]
+                else:
+                    fila_resultado = [f"{v:,.{cantidadDecimLineas}f}" for v in vals]
+                tabla_data.append(fila_resultado)
+                row_labels.append(labelLineas if isinstance(labelLineas, str) else labelLineas[0])
+
+        # Crear tabla
+        tabla = plt.table(cellText=tabla_data, rowLabels=row_labels, colLabels=meses,
+                          cellLoc="center", loc="bottom")
+        tabla.auto_set_font_size(False)
+        tabla.set_fontsize(10) # Mas tamaño
+        tabla.scale(1, 1.5) #Ancho y alto 
+        plt.subplots_adjust(left=0.05, bottom=0.30, top=0.80)
+
+    # --- GUARDAR ---
+    plt.tight_layout()
+    plt.savefig(ruta_salida.replace(".png", ".svg"), format="svg", bbox_inches="tight")
+    plt.close()
+
+
+
+################################################################################################################################
+################################################################################################################################
+######################################################## Generacion de tablas  #################################################
+################################################################################################################################
+################################################################################################################################
+
+def generar_tabla(
+df,tendenciasPorColumna=None,mostrarFlechas=True,separador_miles=False,color_encabezado="#0a4d8c",color_texto_encabezado="#ffffff",
+color_fondo="#ffffff",color_borde="#cccccc",ruta_imagen=None,ajusteColumnas=0,ajusteTexto=0,anchoPrimeraColumna=160,
+anchoOtrasColumnas=90,resaltarUltimaFila=True,negritaUltimaFila=True,colores_celdas=None  # 🆕 NUEVO
+):
+    df = df.copy()
+
+    # 1) Tendencias
+    tendencias_calculadas = {}
+    if tendenciasPorColumna is not None:
+        for col, modo in tendenciasPorColumna.items():
+            if modo == "auto":
+                tendencias_calculadas[col] = df[col].apply(
+                    lambda x: "subió" if x > 0 else ("bajó" if x < 0 else "mantuvo")
+                )
+            elif isinstance(modo, list):
+                tendencias_calculadas[col] = modo
+
+    # 2) Formato de valores
+    def aplicar_formato(valor, col):
+        if pd.isna(valor):
+            return ""
+        if isinstance(valor, bool):
+            return "<span style='color:green; font-weight:bold; font-size:18px;'>✅</span>" if valor else "<span style='color:red; font-weight:bold; font-size:18px;'>❌</span>"
+        elif mostrarFlechas and col in tendencias_calculadas:
+            idx = df.index[df[col] == valor][0]
+            tendencia = tendencias_calculadas[col][idx]
+            if tendencia == "subió":
+                return f"<span style='color:green;'>▲ {valor:.1f}%</span>"
+            elif tendencia == "bajó":
+                return f"<span style='color:red;'>▼ {valor:.1f}%</span>"
+            else:
+                return f"<span style='color:gray;'>• {valor:.1f}%</span>"
+        elif isinstance(valor, (int, float)) and "%" in col:
+            return f"{valor:.1f}%"
+        elif separador_miles and isinstance(valor, (int, float)):
+            return (
+                f"{valor:,.0f}".replace(",", ".")
+                if abs(valor) >= 1000
+                else (f"{valor:.1f}" if valor != int(valor) else f"{int(valor)}")
+            )
+        elif isinstance(valor, (int, float)):
+            return f"{valor:.1f}"
+        else:
+            return valor
+
+    for col in df.columns:
+        df[col] = df[col].apply(lambda x: aplicar_formato(x, col))
+
+    # 3) Estilos base
+    font_size_base = 14 + ajusteTexto
+    ultima_fila_bg = "#f2f2f2" if resaltarUltimaFila else color_fondo
+    ultima_fila_fw = "bold" if negritaUltimaFila else "normal"
+
+    estilos = f"""
+    <style>
+        html, body {{
+            margin: 0;
+            padding: 0;
+            background: transparent;
+        }}
+        .tabla-tiv {{
+            border-collapse: collapse;
+            font-family: Arial, sans-serif;
+            font-size: {font_size_base}px;
+            color: #000000;
+            background-color: {color_fondo};
+            table-layout: fixed;
+            margin: 0;
+        }}
+        .tabla-tiv th, .tabla-tiv td {{
+            border: 1px solid {color_borde};
+            padding: 6px;
+            text-align: center;
+            vertical-align: middle;
+            word-wrap: break-word;
+            box-sizing: border-box;
+        }}
+        .tabla-tiv th {{
+            background-color: {color_encabezado};
+            color: {color_texto_encabezado};
+            font-weight: bold;
+        }}
+        .tabla-tiv tr:last-child td {{
+            background-color: {ultima_fila_bg};
+            font-weight: {ultima_fila_fw};
+        }}
+        .tabla-tiv th:first-child, .tabla-tiv td:first-child {{
+            width: {anchoPrimeraColumna + ajusteColumnas}px;
+            text-align: left;
+            padding-left: 10px;
+        }}
+        .tabla-tiv th:not(:first-child), .tabla-tiv td:not(:first-child) {{
+            width: {anchoOtrasColumnas + ajusteColumnas}px;
+        }}
+    </style>
+    """
+
+    html_tabla = estilos + df.to_html(index=False, escape=False, classes="tabla-tiv")
+
+    # 🎨 NUEVO: Colores por celda (acepta lista o DataFrame)
+    if colores_celdas is not None:
+
+        if isinstance(colores_celdas, pd.DataFrame):
+            matriz = colores_celdas.values.tolist()
+        else:
+            matriz = colores_celdas
+
+        filas, columnas = df.shape
+
+        if len(matriz) != filas or any(len(fila) != columnas for fila in matriz):
+            raise ValueError("colores_celdas debe tener exactamente las mismas dimensiones que df")
+
+        estilos_celdas = "<style>\n"
+        for i in range(filas):
+            for j in range(columnas):
+                color = matriz[i][j]
+                if color:
+                    estilos_celdas += f"""
+                    .tabla-tiv tbody tr:nth-child({i+1}) td:nth-child({j+1}) {{
+                        background-color: {color} !important;
+                    }}
+                    """
+        estilos_celdas += "</style>\n"
+
+        html_tabla = estilos_celdas + html_tabla
+
+    # 4) Captura imagen
+    if ruta_imagen:
+        os.makedirs(os.path.dirname(ruta_imagen), exist_ok=True)
+        hti = Html2Image(output_path=os.path.dirname(ruta_imagen))
+        hti.browser.flags = [
+            "--hide-scrollbars",
+            "--no-sandbox",
+            "--disable-gpu",
+            "--force-device-scale-factor=1"
+        ]
+        hti.screenshot(
+            html_str=html_tabla,
+            save_as=os.path.basename(ruta_imagen)
+        )
+
+    return html_tabla
+
+
+################################################################################################################################
+################################################################################################################################
+################################################# Recortar los bordes blancos  #################################################
+################################################################################################################################
+################################################################################################################################
+
+def recortar_espacios_blancos(ruta_entrada, ruta_salida=None):
+    img = Image.open(ruta_entrada)
+    # Convertir la imagen a modo que permita detectar el fondo
+    img_sin_alpha = img.convert("RGB")
+    # Crear una imagen en blanco del mismo tamaño
+    fondo = Image.new("RGB", img_sin_alpha.size, (255, 255, 255))
+    # Calcular diferencia
+    diff = Image.eval(ImageChops.difference(img_sin_alpha, fondo), lambda x: 255 if x else 0)
+    bbox = diff.getbbox()  # Encuentra el área sin blanco
+    if bbox:
+        img_recortada = img.crop(bbox)
+        if ruta_salida:
+            img_recortada.save(ruta_salida)
+        return img_recortada
+    return img
+
+
+################################################################################################################################
+################################################################################################################################
+######################################################### Girar una imagen  ####################################################
+################################################################################################################################
+################################################################################################################################
+
+def rotar_imagen_python(ruta_imagen, grados, ruta_salida=None):
+    """
+    Rota una imagen directamente en Python usando PIL.
+    Retorna la ruta de la imagen rotada.
+    """
+    try:
+        img = Image.open(ruta_imagen)
+        img_rotada = img.rotate(grados, expand=True)  # expand evita recortes
+
+        if ruta_salida is None:
+            # genera nombre temporal
+            ruta_salida = ruta_imagen.replace(".", f"_rotada_{grados}.")
+
+        img_rotada.save(ruta_salida)
+        return ruta_salida
+
+    except Exception as e:
+        print(f"Error rotando la imagen: {e}")
+        return ruta_imagen

motulco-0.2.0.dist-info/METADATA

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: motulco
+Version: 0.2.0
+Summary: Librería de Python para manejo de archivos y DataFrames de Daniel Ochoa
+Author-email: DanielOchoa <df.ochoa202@gmail.com>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: numpy>=1.26.0
+Requires-Dist: openpyxl>=3.1.0
+Requires-Dist: unidecode>=1.3.6
+Requires-Dist: pywin32>=306
+Requires-Dist: pypdf>=4.0.0
+Requires-Dist: Pillow>=10.0.0
+Requires-Dist: nbformat>=5.9.0
+Requires-Dist: nbconvert>=7.9.0
+Requires-Dist: matplotlib>=3.8.0
+Requires-Dist: html2image>=2.0.4
+Dynamic: license-file
+
+# motulco
+Librería de Python para manejo de archivos y procesamiento de DataFrames.

motulco-0.2.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+motulco/__init__.py,sha256=zRd3Kfp3CIJxaGOA9RKaiLbbWCS5OyK8QkUip-AZMZM,205
+motulco/colors_utils.py,sha256=jqGLyzBD2rDfSadbqiHxr0Q-fkjiqckmoBRJuvf0gu4,846
+motulco/df_utils.py,sha256=5WE0y3h-6GmQZi4W1DaZkYzD0xySFqVSVA9S-OKG_bY,12844
+motulco/doc_utils.py,sha256=ieT0tnhO1U6bY9ZjIeQBwf09iMRZWerbZ6nKLaqcx9Q,5717
+motulco/excel_utils.py,sha256=7yzohXl1debV-uxKRc0HTSU33wNYL3f0yIrhMmOBmUg,7801
+motulco/pdf_utils.py,sha256=21BUKGZfg23Upb94Hsn1FDehuMpX_xZ2m9060iHxxWQ,1335
+motulco/ppt_utils.py,sha256=U-alkXanoxm-0sKggKhxDUv4--HbQ6SsTNyGbpL-AuQ,17986
+motulco/py_utils.py,sha256=5LidHC8A0o95HSziVLqDSPme5UO3TuoiPQhy_KLEXpA,2874
+motulco/shapes_utils.py,sha256=GIRUXaw6emSGD8kcmRICUBN7ZqMbiV6rQp3-cnPLzdE,18366
+motulco-0.2.0.dist-info/licenses/LICENSE,sha256=Jn96Lhnfqd-Zr3dFIJhaDlIZJSk-pbfnZ6sGlp0Gv5E,12
+motulco-0.2.0.dist-info/METADATA,sha256=I7CE_v-OPojUrG8vZGHKmppRezIFmNERLKjDLFEE7l8,735
+motulco-0.2.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+motulco-0.2.0.dist-info/top_level.txt,sha256=vmdmHWbWDEBabUTgsBx7i5muUhJECnn7y8JfCMki6Gg,8
+motulco-0.2.0.dist-info/RECORD,,

motulco-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

motulco-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1 @@
+MIT License

motulco-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+motulco