motulco 0.2.2__tar.gz

motulco-0.2.2/LICENSE

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

motulco-0.2.2/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: motulco
+Version: 0.2.2
+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.2/README.md

@@ -0,0 +1,2 @@
+# motulco
+Librería de Python para manejo de archivos y procesamiento de DataFrames.

motulco-0.2.2/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-0.2.2/motulco/colors_utils.py

@@ -0,0 +1,12 @@
+
+
+
+################################################################################################################################
+################################################################################################################################
+####################################################### Convierte de HEX a RGB #################################################
+################################################################################################################################
+################################################################################################################################
+def hexToRgb(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-0.2.2/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-0.2.2/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-0.2.2/motulco/excel_utils.py

@@ -0,0 +1,155 @@
+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 []
+    
+################################################################################################################################
+################################################################################################################################
+################################## Retorna el color de las celdas de una hoja de un excel    ###################################
+################################################################################################################################
+################################################################################################################################
+def RetornarColoresCeldas(workbook, sheet, solo_coloreadas=True):
+    ws = workbook[sheet]
+    data = []
+    for fila in ws.iter_rows():
+        for celda in fila:
+
+            # Opcional: ignorar celdas totalmente vacías
+            if solo_coloreadas and celda.value is None:
+                continue
+
+            fill = celda.fill
+            color = "FFFFFF"  # blanco por defecto
+
+            if fill and fill.patternType and fill.start_color.type == "rgb":
+                color = fill.start_color.rgb[-6:]  # quitar alpha
+
+            data.append({
+                "fila": celda.row,
+                "columna": celda.column_letter,
+                "valor": celda.value,
+                "color_hex": color
+            })
+
+    return pd.DataFrame(data)

motulco-0.2.2/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)