paramsx 1.0.0__py3-none-any.whl

paramsx/funcions.py

@@ -0,0 +1,254 @@
+import time
+import os
+from .text import HEADER_ASCII, FOOTER_TEXT
+import curses
+
+# Función para obtener parámetros con un entorno específico
+def get_parameters_by_prefix(ssm, prefix):
+    parameters = []
+    next_token = None
+
+    while True:
+        request_args = {
+            "Path": prefix,
+            "WithDecryption": True,
+            "Recursive": True,
+        }
+
+        if next_token:
+            request_args["NextToken"] = next_token
+
+        try:
+            response = ssm.get_parameters_by_path(**request_args)
+        except Exception as e:
+            raise RuntimeError(f"Error al obtener parámetros: {e}")
+
+        for param in response.get('Parameters', []):
+            parameters.append({
+                "parameter_name": param['Name'],
+                "parameter_value": param['Value']
+            })
+
+        next_token = response.get('NextToken')
+        if not next_token:
+            break
+
+    if not parameters:
+        raise ValueError(f"No se encontraron parámetros con el prefijo: {prefix}")
+
+    return parameters
+
+# Función para borrar los parámetros
+def delete_parameter(ssm_client, parameter_name):
+    try:
+        ssm_client.delete_parameter(Name=parameter_name)
+        print(f"Parámetro eliminado: {parameter_name}")
+    except Exception as e:
+        print(f"Error al eliminar el parámetro {parameter_name}: {e}")
+
+# Función para exportar parámetros a un archivo
+def export_parameters_to_file(parameters, file_path):
+    with open(file_path, 'w') as f:
+        f.write("# PARAMS exportados\n")
+        f.write("parametros = [\n")
+        for param in parameters:
+            parameter_name = param['parameter_name']
+            parameter_value = param['parameter_value']
+            # Usar triple comillas para valores largos
+            f.write(f"    {{'parameter_name': '{parameter_name}',\n")
+            f.write(f"     'parameter_value': \"\"\"{parameter_value}\"\"\"}},\n\n")
+        f.write("]\n")
+
+# Función para comparar parámetros y mostrar las diferencias
+def compare_parameters(file_path, backup_file_path, stdscr):
+    if not os.path.exists(file_path) or not os.path.exists(backup_file_path):
+        return None
+
+    # Usar diccionarios específicos para cargar los archivos
+    current_scope = {}
+    backup_scope = {}
+
+    with open(file_path, 'r') as f:
+        exec(f.read(), current_scope)
+
+    with open(backup_file_path, 'r') as f:
+        exec(f.read(), backup_scope)
+
+    # Extraer los parámetros de cada archivo
+    current_params = current_scope.get('parametros', [])
+    backup_params = backup_scope.get('parametros', [])
+
+    # Comparar parámetros
+    changes = []
+    current_dict = {p['parameter_name']: p['parameter_value'] for p in current_params}
+    backup_dict = {p['parameter_name']: p['parameter_value'] for p in backup_params}
+
+    for key in current_dict:
+        if key not in backup_dict:
+            changes.append((key, "Nuevo", f"{key} - Nuevo"))
+        elif current_dict[key] != backup_dict[key]:
+            changes.append((key, "Modificado", f"{key} - Modificado"))
+
+    for key in backup_dict:
+        if key not in current_dict:
+            changes.append((key, "Eliminado", f"{key} - Eliminado"))
+
+    return changes
+
+# Mostrar contenido comparado
+def show_comparison_results(stdscr, changes):
+    stdscr.clear()
+    draw_header(stdscr)
+
+    max_y, max_x = stdscr.getmaxyx()  # Tamaño del terminal
+    start_line = HEADER_ASCII.count("\n") + 1  # Reservar espacio para el header
+    visible_height = max_y - start_line - 3  # Espacio visible en el terminal (sin header/footer)
+    scroll_offset = 0  # Controlar desde qué línea se empieza a mostrar
+    buffer_lines = 2  # Número de líneas adicionales para mostrar al final
+
+    while True:
+        stdscr.clear()
+        draw_header(stdscr)
+
+        # Mostrar encabezado de la lista con cantidad y guía de navegación
+        title = f"Cambios detectados ({len(changes)}) - Usa ↑ y ↓ para navegar - Intro confirmar y Esc para salir"
+        stdscr.addstr(start_line, 0, title.center(max_x, "-"))
+
+        # Calcular el rango visible incluyendo el buffer
+        visible_changes = changes[scroll_offset:scroll_offset + visible_height]
+
+        for i, change in enumerate(visible_changes, start=1 + scroll_offset):
+            comment = f"{i}. {change[0]} - {change[1]}"
+            truncated_comment = comment[:max_x - 1]  # Truncar si excede el ancho
+            stdscr.addstr(start_line + i - scroll_offset, 0, truncated_comment)
+
+        # Mostrar footer vacío o decorativo
+        draw_footer(stdscr)
+
+        # Actualizar pantalla
+        stdscr.refresh()
+
+        # Capturar entrada del usuario
+        key = stdscr.getkey()
+
+        # Manejar teclas de desplazamiento
+        if key == "KEY_UP" and scroll_offset > 0:
+            scroll_offset -= 1
+        elif key == "KEY_DOWN" and scroll_offset + visible_height < len(changes) + buffer_lines:
+            scroll_offset += 1
+        elif key == '\x1b':  # Presionar Esc para salir
+            return False
+        elif key == '\n':  # Presionar Enter para confirmar
+            return True
+
+
+# Función para mostrar el header personalizado
+def draw_header(stdscr):
+    max_y, max_x = stdscr.getmaxyx()
+    separator = "=" * max_x
+    stdscr.addstr(0, 0, separator)  # Línea superior del header
+
+    # Mostrar HEADER_ASCII línea por línea sin strip
+    header_lines = HEADER_ASCII.split("\n")  # No eliminar espacios ni líneas vacías
+    last_line_index = 0  # Guardar el índice de la última línea válida
+
+    for i, line in enumerate(header_lines, start=1):
+        if line.strip():  # Solo imprimir líneas no vacías
+            stdscr.addstr(i, 0, line)
+            last_line_index = i  # Actualizar la posición de la última línea visible
+
+    stdscr.addstr(last_line_index + 1, 0, separator)  # Línea inferior después de la última línea del header
+
+# Función para mostrar el footer personalizado
+def draw_footer(stdscr):
+    rows, cols = stdscr.getmaxyx()  # Tamaño del terminal
+    exit_text = "Pulsa 'Esc' para volver o salir"  # Mensaje adicional
+    footer_text = FOOTER_TEXT[:cols - 1]  # Recortar el texto si es más ancho que el terminal
+    separator = "-" * cols  # Separador completo ajustado al ancho
+
+    # Asegurarse de que hay espacio suficiente para el footer
+    if rows > 2:  # Verifica que haya espacio mínimo para el footer
+        try:
+            stdscr.addstr(rows - 3, 0, exit_text.center(cols, " "))  # Centrar el texto de salida
+            stdscr.addstr(rows - 2, 0, separator)  # Línea separadora
+            stdscr.addstr(rows - 1, 0, footer_text.center(cols - 1, " "))  # Centrar el texto
+        except curses.error:
+            pass  # Ignorar errores si no hay espacio suficiente
+
+# Mostrar contenido principal del menú
+def show_main_menu(stdscr):
+    start_line = HEADER_ASCII.count("\n") + 1  # Calcula dónde termina el header
+    stdscr.addstr(start_line, 0, "1. Leer parámetros".ljust(60))
+    stdscr.addstr(start_line + 1, 0, "2. Cargar parámetros desde archivo".ljust(60))
+    stdscr.addstr(start_line + 2, 0, "3. Crear Backup de parámetros".ljust(60))
+    stdscr.addstr(start_line + 3, 0, "Elija una opción (1/2): ")
+
+# Mostrar selección de parámetros
+def show_parameter_selection(stdscr, options):
+    stdscr.clear()
+    draw_header(stdscr)
+    start_line = HEADER_ASCII.count("\n") + 1  # Calcula el inicio después del header
+    stdscr.addstr(start_line, 0, "Seleccione un parámetro para leer:".center(60, "-"))
+    for idx, option in enumerate(options, start=1):
+        stdscr.addstr(start_line + idx, 0, f"{idx}. {option}")
+    draw_footer(stdscr)
+    stdscr.refresh()
+
+    while True:
+        key = stdscr.getkey()
+        if key == '\x1b':  # Si se presiona Esc
+            return None  # Cancelar selección
+        try:
+            choice = int(key) - 1
+            if 0 <= choice < len(options):
+                return choice
+        except ValueError:
+            pass  # Ignorar entradas inválidas
+
+# Mostrar selección de entorno
+def show_environment_selection(stdscr, environments):
+    stdscr.clear()
+    draw_header(stdscr)
+    start_line = HEADER_ASCII.count("\n") + 1
+    stdscr.addstr(start_line, 0, "Seleccione el entorno:".center(60, "-"))
+    for idx, env in enumerate(environments, start=1):
+        stdscr.addstr(start_line + idx, 0, f"{idx}. {env}")
+    draw_footer(stdscr)
+    stdscr.refresh()
+
+    while True:
+        key = stdscr.getkey()
+        if key == '\x1b':  # Si se presiona Esc
+            return None  # Cancelar selección
+        try:
+            choice = int(key) - 1
+            if 0 <= choice < len(environments):
+                return choice
+        except ValueError:
+            pass  # Ignorar entradas inválidas
+
+# Pantalla de confirmación o resultados
+def show_message(stdscr, message, color_pair=1):
+    stdscr.clear()
+    draw_header(stdscr)
+    start_line = HEADER_ASCII.count("\n") + 1
+    stdscr.addstr(start_line, 0, message.center(60, " "), curses.color_pair(color_pair))
+    draw_footer(stdscr)
+    stdscr.refresh()
+    time.sleep(3)
+
+# Errores varios
+def load_parameters(file_path):
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"El archivo {file_path} no existe.")
+
+    param_scope = {}
+    try:
+        with open(file_path, 'r') as f:
+            exec(f.read(), param_scope)  # Ejecuta el archivo en el contexto de param_scope
+    except SyntaxError as e:
+        raise SyntaxError(
+            f"Error de sintaxis en {file_path}.\nRevisa las comillas o el formato del archivo."
+        )
+    
+    return param_scope.get('parametros', [])

paramsx/main.py

@@ -0,0 +1,206 @@
+import os
+import boto3
+import curses
+import importlib.util
+from .funcions import (
+    draw_header, draw_footer, show_main_menu, show_comparison_results,
+    show_environment_selection, show_message, show_parameter_selection,
+    get_parameters_by_prefix, delete_parameter, export_parameters_to_file, 
+    compare_parameters, load_parameters
+)
+
+
+# Ruta de la configuración personalizada
+CONFIG_PATH = os.path.expanduser("~/.xsoft/paramsx_config.py")
+
+# Cargar configuraciones desde el archivo de usuario
+def load_config():
+    if not os.path.exists(CONFIG_PATH):
+        raise FileNotFoundError(f"No se encontró el archivo de configuración en {CONFIG_PATH}")
+    spec = importlib.util.spec_from_file_location("config", CONFIG_PATH)
+    config = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(config)
+    return config.configuraciones
+
+# Función principal
+def main(stdscr):
+
+    ## Cargando configuración
+    config = load_config()
+    # Configurar boto3 con el perfil y región del usuario
+    boto3.setup_default_session(profile_name=config["profile_name"])
+    ssm = boto3.client("ssm", region_name=config["region_name"])
+
+    curses.start_color()
+    curses.init_pair(1, curses.COLOR_WHITE, curses.COLOR_BLUE)
+    curses.init_pair(2, curses.COLOR_RED, curses.COLOR_BLACK)
+    curses.init_pair(3, curses.COLOR_GREEN, curses.COLOR_BLACK)
+    
+    environments = config['entornos']
+    PARAMETER_LIST = config['parameter_list']
+
+    while True:
+        stdscr.clear()
+        draw_header(stdscr)
+        show_main_menu(stdscr)
+        draw_footer(stdscr)
+        stdscr.refresh()
+
+        choice = stdscr.getkey()
+        
+        if choice == '\x1b':  # Código ASCII para 'Esc'
+                break  # Salir del programa
+        
+        elif choice == '1':
+            # Leer parámetros
+            param_choice = show_parameter_selection(stdscr, PARAMETER_LIST)
+            if param_choice is None:  # Si se presionó Esc
+                continue  # Regresar al menú principal
+
+            selected_param = PARAMETER_LIST[param_choice]
+
+            env_choice = show_environment_selection(stdscr, environments)
+            if env_choice is None:  # Si se presionó Esc
+                continue  # Regresar al menú principal
+
+            selected_env = environments[env_choice]
+
+            # Crear el prefijo completo
+            full_path = f"{selected_param}/{selected_env}"
+            show_message(stdscr, f"Buscando parámetros en: {full_path}...", 3)  # Mensaje inicial
+
+            try:
+                # Obtener parámetros desde AWS SSM
+                parameters = get_parameters_by_prefix(ssm, full_path)
+            except ValueError as e:
+                show_message(stdscr, f"ERROR: {e}", 2)  # Error por prefijo vacío
+                continue  # Regresar al menú principal
+            except Exception as e:
+                show_message(stdscr, f"Error inesperado: {e}", 2)  # Error genérico
+                continue  # Regresar al menú principal
+
+            # Validar si se encontraron parámetros antes de continuar
+            if not parameters:
+                show_message(stdscr, f"No se encontraron parámetros en: {full_path}.", 2)
+                continue  # Regresar al menú principal
+
+            # Crear archivos si se encontraron parámetros
+            file_name = f"parameters_{selected_env}.py"
+            backup_file_name = f"parameters_{selected_env}_backup.py"
+
+            # Exportar parámetros al archivo principal
+            export_parameters_to_file(parameters, file_name)
+
+            # Crear un respaldo exacto del archivo principal
+            export_parameters_to_file(parameters, backup_file_name)
+
+            # Confirmación de archivos creados
+            show_message(stdscr, f"Archivos creados:\n- {file_name}\n- {backup_file_name}", 3)
+
+        elif choice == '2':
+            # Cargar parámetros desde archivo
+            env_choice = show_environment_selection(stdscr, environments)
+            if env_choice is None:  # Si se presionó Esc
+                continue  # Regresar al menú principal
+
+            selected_env = environments[env_choice]
+            file_name = f"parameters_{selected_env}.py"
+            backup_file_name = f"parameters_{selected_env}_backup.py"
+
+            if not os.path.exists(file_name) or not os.path.exists(backup_file_name):
+                show_message(stdscr, f"Archivos {file_name} o {backup_file_name} no encontrados.", 2)
+                continue
+
+
+            try:
+                # Cargar parámetros del archivo principal
+                parametros = load_parameters(file_name)
+            except SyntaxError as e:
+                show_message(stdscr, f"ERROR: {e}", 2)
+                continue  # Regresar al menú principal
+            except Exception as e:
+                show_message(stdscr, f"Error inesperado: {e}", 2)
+                continue  # Regresar al menú principal
+
+            # Comparar los parámetros
+            changes = compare_parameters(file_name, backup_file_name, stdscr)
+
+            if changes:
+                # Mostrar resultados de la comparación
+                confirmed = show_comparison_results(stdscr, changes)
+
+                if not confirmed:  # Si el usuario cancela
+                    show_message(stdscr, "Operación cancelada volvemos a menú principal.", 2)
+                    continue
+
+                # Subir parámetros si se confirman los cambios
+                with open(file_name, 'r') as f:
+                    param_scope = {}
+                    exec(f.read(), param_scope)
+
+                parametros = param_scope.get('parametros', [])
+                current_dict = {p['parameter_name']: p['parameter_value'] for p in parametros}
+
+                for change in changes:
+                    param_name, change_type, _ = change
+                    if change_type == "Nuevo" or change_type == "Modificado":
+                        # Subir o actualizar parámetros
+                        ssm.put_parameter(
+                            Name=param_name,
+                            Value=current_dict[param_name],
+                            Type='SecureString',
+                            Overwrite=True
+                        )
+                    elif change_type == "Eliminado":
+                        # Borrar parámetros eliminados
+                        delete_parameter(ssm, param_name)
+
+                # Eliminar los archivos una vez procesados
+                os.remove(file_name)
+                os.remove(backup_file_name)
+                show_message(stdscr, "¡Cambios aplicados y archivos eliminados!", 3)
+            else:
+                show_message(stdscr, "No se encontraron cambios entre los archivos.", 3)
+
+        elif choice == '3':
+            # Crear backup
+            param_choice = show_parameter_selection(stdscr, PARAMETER_LIST)
+            if param_choice is None:  # Si se presionó Esc
+                continue  # Regresar al menú principal
+
+            selected_param = PARAMETER_LIST[param_choice]
+
+            env_choice = show_environment_selection(stdscr, environments)
+            if env_choice is None:  # Si se presionó Esc
+                continue  # Regresar al menú principal
+
+            selected_env = environments[env_choice]
+
+            # Crear el prefijo completo
+            full_path = f"{selected_param}/{selected_env}"
+            try:
+                # Obtener parámetros desde AWS SSM
+                parameters = get_parameters_by_prefix(ssm, full_path)
+            except ValueError as e:
+                show_message(stdscr, f"ERROR: {e}", 2)
+                continue  # Regresar al menú principal
+            except Exception as e:
+                show_message(stdscr, f"Error inesperado: {e}", 2)
+                continue  # Regresar al menú principal
+
+            # Crear archivo de backup con nombre claro
+            backup_file_name = f"{selected_param.replace('/', '_')}_{selected_env}_backup.py"
+            export_parameters_to_file(parameters, backup_file_name)
+
+            # Confirmación de backup creado
+            show_message(stdscr, f"Backup creado:\n- {backup_file_name}", 3)
+
+
+        else:
+            show_message(stdscr, "Opción inválida. Inténtalo de nuevo.", 2)
+
+def entry_point():
+    curses.wrapper(main)
+
+if __name__ == "__main__":
+    curses.wrapper(main)

paramsx/paramsx_config.py

@@ -0,0 +1,12 @@
+## Configuraciones ParamsX
+
+configuraciones = {
+    "profile_name": "default",
+    "region_name": "eu-south-2",
+    "entornos": ['DEV','PROD'],
+    "parameter_list":[
+        "params1",
+        "params2"
+    ]
+}
+

paramsx/text.py

@@ -0,0 +1,12 @@
+HEADER_ASCII = """
+  _____                             __   __
+ |  __ \                            \ \ / /
+ | |__) |_ _ _ __ __ _ _ __ ___  ___ \ V / 
+ |  ___/ _` | '__/ _` | '_ ` _ \/ __| > <  
+ | |  | (_| | | | (_| | | | | | \__ \/ . \ 
+ |_|   \__,_|_|  \__,_|_| |_| |_|___/_/ \_\
+
+
+"""
+
+FOOTER_TEXT = "By Mariox"

paramsx-1.0.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Mario x
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

paramsx-1.0.0.dist-info/METADATA

@@ -0,0 +1,9 @@
+Metadata-Version: 2.1
+Name: paramsx
+Version: 1.0.0
+Summary: Librería para gestionar y respaldar parámetros de AWS SSM de manera sencilla y eficiente.
+Home-page: https://github.com/pistatxos/paramsx
+Author: Mariox
+Author-email: info@tomonota.net
+License-File: LICENSE
+Requires-Dist: boto3

paramsx-1.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+paramsx/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+paramsx/funcions.py,sha256=1053brCERgadfA1lB31U8VbnYksCbfttQ5HnxhDlZ2Q,9629
+paramsx/main.py,sha256=Wgh-8bibDIGhdeoTcRCZr39ph_D0AYnQeODCjmScAjQ,8356
+paramsx/paramsx_config.py,sha256=uBKYtCLiPfuCw58nzMCc-kKx2yXJLXA4ytaXHOneP74,213
+paramsx/text.py,sha256=nJf5wJ0dZNiuBrp8zFacu-mWe1FbIEcslWRokR9SPS4,315
+paramsx-1.0.0.dist-info/LICENSE,sha256=GrUwVxQBOoDjqiy-ts0ms4stmdZjDEZZlkjUgCaGcCQ,1064
+paramsx-1.0.0.dist-info/METADATA,sha256=rYC2-6_DBNiyupV-D8vl8ZYF5vxYqkhusUeSEVanH0s,290
+paramsx-1.0.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+paramsx-1.0.0.dist-info/entry_points.txt,sha256=DaoL0NejfYIz3DaYsnAZzB3pWhtqydt-T5K2rE4iQ1k,53
+paramsx-1.0.0.dist-info/top_level.txt,sha256=LiSJIPKNZVfaJcRHqKr0YoBl7cHS_IolBI6cYB-aBbE,8
+paramsx-1.0.0.dist-info/RECORD,,

paramsx-1.0.0.dist-info/WHEEL

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

paramsx-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+paramsx = paramsx.main:entry_point

paramsx-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+paramsx