paramsx 1.0.0__tar.gz

paramsx-1.0.0/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,89 @@
+# ParamsX
+
+ParamsX es una librería diseñada para gestionar parámetros de AWS SSM de manera sencilla y eficiente. Con ella podrás:
+- Leer parámetros almacenados en AWS SSM.
+- Comparar y actualizar parámetros existentes.
+- Eliminar parámetros que ya no estén presentes en los archivos de configuración.
+- Crear respaldos para evitar pérdida de datos.
+
+
+#### Consejos varios para tener un orden en los parámetros
+Para un uso óptimo, se recomienda organizar los parámetros de AWS SSM utilizando prefijos que sigan una estructura lógica. Por ejemplo:
+- /APP/nombreApp/tipoEntorno/más datos...
+
+Esta estructura permite identificar y gestionar los parámetros por su aplicación y entorno. En ParamsX, puedes configurar listas específicas para modificar y gestionar estos parámetros de manera eficiente.
+
+## Instalación
+
+pip install paramx
+
+### Configuración inicial
+Al instalar el paquete, se crea automáticamente una carpeta de configuración en tu directorio de usuario:
+
+Windows: C:\Users\<tu_usuario>\.xsoft
+Linux/MacOS: /home/<tu_usuario>/.xsoft
+
+Dentro de esta carpeta encontrarás un archivo llamado paramsx_config.py. 
+Este archivo contiene la configuración inicial de la librería. Antes de usarla, debes asegurarte de editar este archivo para incluir el perfil de AWS y la región que utilizarás.
+
+Contenido de paramsx_config.py:
+
+```
+configuraciones = {
+    "profile_name": "default",  # Cambiar por el nombre de tu perfil en ~/.aws/credentials
+    "region_name": "us-east-1",  # Cambiar por tu región de AWS
+    "entornos": ["DEV", "PROD"],  # Los entornos que manejarás
+    "parameter_list": [
+        "/params1/xx",
+        "/params2/xx",
+    ]
+}
+```
+Nota: Si el archivo paramsx_config.py ya existe, no será sobrescrito durante la instalación para proteger las configuraciones personalizadas.
+
+
+## Modo de Uso
+Ejecuta el comando principal desde la terminal:
+
+```paramsx```
+
+Navega por el menú interactivo:
+
+El programa mostrará un menú donde Podrás:
+- Leer parámetros desde AWS SSM.
+- Cargar y actualizar parámetros.
+- Backup de parámetros.
+
+
+### Leer Parámetros:
+1. Selecciona la opción "Leer parámetros" en el menú.
+2. Elige el prefijo y el entorno que deseas consultar.
+3. Los parámetros serán descargados y guardados en archivos como:
+    - parameters_DEV.py
+    - parameters_DEV_backup.py
+    ```Importante: Los archivos se generarán en la misma ruta desde donde ejecutes el comando paramsx```
+
+
+### Cargar Parámetros:
+1. Modifica los archivos generados (parameters_DEV.py).
+2. Usa la opción "Cargar parámetros desde archivo" para comparar los cambios.
+3. El programa mostrará una lista con los siguientes estados:
+    - Nuevos: Parámetros que se agregarán.
+    - Modificados: Parámetros existentes que se actualizarán.
+    - Eliminados: Parámetros que se eliminarán automáticamente de AWS SSM.
+    * Revisa los cambios antes de confirmar.
+    ```Importante: Una vez confirmados los cambios, los archivos parameters_DEV.py y parameters_DEV_backup.py se eliminarán automáticamente```
+
+### Notas Adicionales
+- Credenciales de AWS:
+    Asegúrate de que el perfil especificado en paramsx_config.py exista en tus archivos de configuración de AWS (~/.aws/credentials y ~/.aws/config).
+
+- Seguridad:
+    Los parámetros se manejan como SecureString para garantizar que la información sensible esté cifrada
+
+- Backup:
+    Antes de realizar cualquier cambio, ParamsX crea automáticamente un respaldo (parameters_DEV_backup.py). Este archivo se eliminará después de cargar los nuevos parámetro
+
+## Licencia
+ParamsX se distribuye bajo la licencia MIT. Puedes usarlo libremente, modificarlo y adaptarlo a tus necesidades. Recuerda siempre hacer un respaldo de tus configuraciones antes de realizar cambios.
+```Nota: El creador de ParamsX no se hace responsable de posibles pérdidas de datos o configuraciones incorrectas.```

paramsx-1.0.0/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-1.0.0/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-1.0.0/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-1.0.0/paramsx/text.py

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

paramsx-1.0.0/paramsx.egg-info/PKG-INFO

@@ -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/paramsx.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+setup.py
+paramsx/__init__.py
+paramsx/funcions.py
+paramsx/main.py
+paramsx/paramsx_config.py
+paramsx/text.py
+paramsx.egg-info/PKG-INFO
+paramsx.egg-info/SOURCES.txt
+paramsx.egg-info/dependency_links.txt
+paramsx.egg-info/entry_points.txt
+paramsx.egg-info/requires.txt
+paramsx.egg-info/top_level.txt

paramsx-1.0.0/paramsx.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

paramsx-1.0.0/paramsx.egg-info/entry_points.txt

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

paramsx-1.0.0/paramsx.egg-info/requires.txt

@@ -0,0 +1 @@
+boto3

paramsx-1.0.0/paramsx.egg-info/top_level.txt

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

paramsx-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

paramsx-1.0.0/setup.py

@@ -0,0 +1,98 @@
+from setuptools import setup, find_packages
+from setuptools.command.install import install
+import os
+import sys
+import shutil
+import platform
+
+class CustomInstallCommand(install):
+    def run(self):
+        # Ejecutar instalación predeterminada
+        install.run(self)
+
+        # Detectar el sistema operativo
+        system = platform.system()
+        scripts_dir = None
+
+        if system == "Windows":
+            # Ruta del directorio de scripts para Windows
+            scripts_dir = os.path.join(
+                os.path.expanduser("~"),
+                "AppData",
+                "Roaming",
+                "Python",
+                f"Python{sys.version_info.major}{sys.version_info.minor}",
+                "Scripts",
+            )
+        elif system in ["Linux", "Darwin"]:  # Linux o macOS
+            # Ruta del directorio de scripts para Linux/macOS
+            scripts_dir = os.path.join(os.path.dirname(sys.executable), "bin")
+
+        if scripts_dir:
+            # Verificar si el directorio ya está en el PATH
+            path_env = os.environ.get("PATH", "")
+            if scripts_dir not in path_env:
+                if system == "Windows":
+                    # Agregar al PATH en Windows
+                    os.system(f'setx PATH "{path_env};{scripts_dir}"')
+                    print(f"Se agregó {scripts_dir} al PATH. Reinicia tu terminal para que los cambios surtan efecto.")
+                elif system == "Darwin":
+                    # Usar .zshrc en macOS
+                    zshrc_path = os.path.expanduser("~/.zshrc")
+                    self._add_to_shell_config(zshrc_path, scripts_dir)
+                elif system == "Linux":
+                    # Usar .bashrc en Linux
+                    bashrc_path = os.path.expanduser("~/.bashrc")
+                    self._add_to_shell_config(bashrc_path, scripts_dir)
+
+        # Crear el directorio de configuración de paramsx
+        config_dir = os.path.expanduser("~/.xsoft")
+        os.makedirs(config_dir, exist_ok=True)
+
+        # Archivo de configuración
+        config_file = "paramsx/paramsx_config.py"
+        target_file = os.path.join(config_dir, "paramsx_config.py")
+
+        if os.path.exists(target_file):
+            print(f"El archivo de configuración ya existe en {target_file}. No se sobrescribirá.")
+        else:
+            if os.path.exists(config_file):
+                shutil.copy(config_file, target_file)
+                print(f"Archivo de configuración copiado a {target_file}")
+            else:
+                print(f"Advertencia: No se encontró {config_file}. No se creó la configuración inicial.")
+
+
+    def _add_to_shell_config(self, config_file, scripts_dir):
+        """Añadir el directorio de scripts al archivo de configuración de shell."""
+        export_line = f'export PATH="{scripts_dir}:$PATH"'
+        if os.path.exists(config_file):
+            with open(config_file, "a") as f:
+                f.write(f"\n{export_line}\n")
+            print(f"Se agregó {scripts_dir} a {config_file}.")
+        else:
+            with open(config_file, "w") as f:
+                f.write(f"{export_line}\n")
+            print(f"Se creó {config_file} y se agregó {scripts_dir}.")
+
+setup(
+    name="paramsx",
+    version="1.0.0",
+    packages=find_packages(),
+    include_package_data=True,
+    install_requires=[
+        "boto3",
+    ],
+    entry_points={
+        "console_scripts": [
+            "paramsx=paramsx.main:entry_point",
+        ],
+    },
+    cmdclass={
+        "install": CustomInstallCommand,
+    },
+    description="Librería para gestionar y respaldar parámetros de AWS SSM de manera sencilla y eficiente.",
+    author="Mariox",
+    author_email="info@tomonota.net",
+    url="https://github.com/pistatxos/paramsx",
+)