Programming code

import tkinter as tk

from tkinter import ttk

from ttkthemes import ThemedStyle

import platform, psutil, os, glob, subprocess, hashlib, sys, time, requests, socket

import mysql.connector as mysql

from tkinter import messagebox

# Definir la versión de la aplicación

version = “0.5”

# Obtener datos de usuario.

user_ip = socket.gethostbyname(socket.gethostname())

user_ip_str = ‘,’.join(user_ip)

# Detectando componentes del OS

system_info = platform.uname()

disk_info = psutil.disk_partitions()

# Cambiar frame de registor por frame de login

def change_screens(value):

if value==1:

login_frame.forget()

register_frame.pack()

elif value==2:

register_frame.forget()

login_frame.pack()

elif value==3:

login_frame.forget()

init_frame.pack()

else:

pass

# Verificar licencia (registro)

def check_license():

url_servidor_licencias = “http://localhost:8080/verificar” # Cambia la URL según tu configuración

global clave_licencia

clave_licencia = valid_license.get()

headers = {“Clave-Licencia”: clave_licencia}

response = requests.get(url_servidor_licencias, headers=headers)

global license_status

license_status = False

if response.status_code == 200:

estado_licencia = response.text

if estado_licencia == “valida”:

license_status = True

else:

messagebox.showerror(“Error”, “La licencia es invalida, verifica la autenticidad/escritura de la misma.”)

else:

print(“Error al verificar la licencia. Código de estado:”, response.status_code)

# Funcion inicio de sesion software.

def login():

# DB-LOGIN

db = mysql.connect(

host=”localhost”,

user=”root”,

password=”root”,

database=”test”

)

cursor = db.cursor()

ft_user = user_entry.get()

ft_pass = pass_entry.get()

consulta = “SELECT * FROM logins WHERE principal = %s AND pass = %s”

parametros = (ft_user, ft_pass)

cursor.execute(consulta, parametros)

result = cursor.fetchone()

if result is not None:

cursor.close()

db.close()

change_screens(3)

else:

messagebox.showerror(“Inicio de sesion invalido.”, “El usuario o la contraseña colocada no son correctos, intentelo nuevamente.”)

def register():

# DB-LOGIN

db = mysql.connect(

host=”localhost”,

user=”root”,

password=”root”,

database=”test”

)

cursor = db.cursor()

ft_user = new_user_entry.get()

ft_pass = new_pass_entry.get()

check_license()

if license_status == True:

consulta = “SELECT * FROM logins WHERE principal = %s”

parametros = (ft_user,)

cursor.execute(consulta, parametros)

result = cursor.fetchone()

if result is not None:

messagebox.showerror(“Error de registro.”, “El usuario ya existe. Pruebe con uno distinto.”)

else:

consulta_license = “SELECT * FROM logins WHERE license = %s”

parametros_license = (clave_licencia,)

cursor.execute(consulta_license, parametros_license)

result_license = cursor.fetchone()

if result_license is not None:

messagebox.showerror(“Licencia invalida”, “Esta licencia ya ha sido reclamada. Intenta con otra o contactate con soporte tenico.”)

else:

consulta_ip = “SELECT COUNT(*) FROM logins WHERE IP = %s”

parametro_ip = (f’192.168.0.36′,)

user_ip_final=user_ip_str.replace(“,”,””)

cursor.execute(consulta_ip, parametro_ip)

resultado_ip = cursor.fetchone()

user_ip_final=str(resultado_ip[0])

print(user_ip_final)

if int(user_ip_final) >= 3:

messagebox.showerror(“Max IP registered.”, “Has registrado la mayor cantidad de cuentas por computadora posible.”)

else:

consulta2 = “INSERT INTO logins (principal, pass, license, IP) VALUES (%s, %s, %s, %s)”

parametros2 = (ft_user, ft_pass, clave_licencia, user_ip)

cursor.execute(consulta2, parametros2,)

db.commit()

messagebox.showinfo(“Registro exitoso.”, “Usuario registrado exitosamente!”)

cursor.close()

db.close()

else:

pass

# Eliminar archivos duplicados

def encontrar_archivos_duplicados(directorio):

hashes = {}

archivos_duplicados = []

for root, _, files in os.walk(directorio):

# Excluir directorios importantes en Windows

if platform.system() == “Windows” and (

root.lower().startswith(“c:\\windows”) or

root.lower().startswith(“c:\\program files”)

continue

for archivo in files:

ruta_completa = os.path.join(root, archivo)

# Calcular el hash MD5 del archivo

with open(ruta_completa, “rb”) as f:

contenido = f.read()

hash_md5 = hashlib.md5(contenido).hexdigest()

# Verificar si el hash ya existe en el diccionario

if hash_md5 in hashes:

archivos_duplicados.append((ruta_completa, hashes[hash_md5]))

else:

hashes[hash_md5] = ruta_completa

return archivos_duplicados

def eliminar_archivos_duplicados(archivos_duplicados):

for duplicado in archivos_duplicados:

print(f”Eliminando duplicado: {duplicado[0]}”)

os.remove(duplicado[0])

def delete_dupl():

directorio = ‘C:’

if os.path.exists(directorio):

archivos_duplicados = encontrar_archivos_duplicados(directorio)

if archivos_duplicados:

print(“Archivos duplicados encontrados:”)

for duplicado in archivos_duplicados:

print(f”Duplicado 1: {duplicado[0]}\nDuplicado 2: {duplicado[1]}\n”)

eliminar_archivos_duplicados(archivos_duplicados)

print(“Archivos duplicados eliminados.”)

else:

print(“No se encontraron archivos duplicados en el directorio.”)

else:

print(“La ruta del directorio ingresada no es válida.”)

# Desfragmentar discos

def listar_unidades_disponibles():

try:

# Ejecutar el comando para listar unidades disponibles

result = subprocess.run([“fsutil”, “fsinfo”, “drives”], capture_output=True, text=True)

drives = result.stdout.strip().split()[1:]

return drives

except Exception as e:

print(f”Error al listar unidades disponibles: {str(e)}”)

return []

def desfragmentar_disco(unidad):

try:

# Ejecutar el comando de desfragmentación del disco con optimización

subprocess.run([“defrag”, unidad, “/O”])

print(f”Desfragmentación y optimización del disco {unidad} completada con éxito.”)

except Exception as e:

print(f”Error al desfragmentar el disco {unidad}: {str(e)}”)

# Listar unidades disponibles

def defrag_disk():

unidades = listar_unidades_disponibles()

if unidades:

# Enumerar unidades disponibles

print(“Unidades disponibles:”)

for i, unidad in enumerate(unidades, start=1):

print(f”{i}. {unidad}”)

try:

# Solicitar al usuario que elija una unidad

seleccion = int(input(“¿Qué disco deseas desfragmentar?: “))

if 1 <= seleccion <= len(unidades):

unidad_seleccionada = unidades[seleccion – 1]

desfragmentar_disco(unidad_seleccionada)

else:

print(“Selección no válida.”)

except ValueError:

print(“Entrada no válida. Ingresa el número correspondiente a la unidad que deseas desfragmentar.”)

else:

print(“No se encontraron unidades disponibles.”)

# Limpiar memoria RAM

def ram_cleaner():

try:

# Obtener la lista de todos los procesos en ejecución

for process in psutil.process_iter():

try:

# Obtener información sobre el proceso

process_info = process.as_dict(attrs=[‘pid’, ‘name’, ‘memory_info’])

# Obtener el PID y el nombre del proceso

pid = process_info[‘pid’]

process_name = process_info[‘name’]

# Liberar la memoria RAM del proceso

psutil.Process(pid).terminate()

print(f”Memoria RAM liberada para el proceso: {process_name} (PID: {pid})”)

except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):

pass

print(“Toda la memoria RAM liberada con éxito.”)

except Exception as e:

print(f”Error al liberar la memoria RAM: {str(e)}”)

# Finalizar procesos innecesarios

def stop_process():

procesos_a_detener = [

“SysMain”, “Superfetch”, “seclogon”, “WSearch”, “BITS”, “wermgr”, “wuauserv”, “spoolsv”, “Themes”,

“WerFault.exe”, “TiWorker.exe”, “CompatTelRunner.exe”, “CompatTelRunner.exe”, “CEIP”, “WbioSrvc”,

“wmpnetwk.exe”, “spoolsv.exe”, “termsrv.exe”, “w32time”, “WinRM”, “XblAuthManager.exe”, “XblGameSave.exe”,

“XboxNetApiSvc”, “WpnUserService”, “OneDrive.exe”, “OfficeClickToRun.exe”, “SearchUI.exe”, “CDPSvc”,

“MSOSYNC.EXE”, “wmplayer.exe”, “msstore.exe”, “wisvc”, “UsoSvc”, “PeopleApp.exe”, “WerSvc”, “VaultSvc”,

“WerSvc”, “bthserv”, “HomeGroupListener”, “HomeGroupProvider”, “TabletInputService”, “wercplsupport”,

“hidserv”, “SensrSvc”, “WerSvc”, “stisvc”, “RemoteRegistry”, “TrkWks”, “WMPNetworkSvc”, “FontCache”,

“MpsSvc”, “WinDefend”, “MpsSvc”, “DPS”, “icssvc”, “WerSvc”

]

for proceso in procesos_a_detener:

try:

for p in psutil.process_iter(attrs=[‘pid’, ‘name’]):

if p.info[‘name’] == proceso:

pid = p.info[‘pid’]

psutil.Process(pid).terminate()

print(f”Proceso {proceso} (PID: {pid}) detenido con éxito.”)

break

else:

print(f”Proceso {proceso} no encontrado. Ignorando…”)

except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):

print(f”No se pudo detener el proceso {proceso}. Ignorando…”)

except Exception as e:

print(f”Error al detener el proceso {proceso}: {str(e)}”)

# Limpiar archivos temporales y servicios

def temporal_cleaner():

temp_paths = [

os.path.join(os.environ.get(‘TEMP’), ‘*’),

os.path.join(os.environ.get(‘TMP’), ‘*’),

‘C:\\Windows\\Temp\\*’,

]

try:

for path in temp_paths:

# Eliminar archivos en la ruta especificada

for filename in glob.glob(path):

if os.path.isfile(filename):

os.remove(filename)

print(“Archivos temporales limpiados con éxito.”)

except Exception as e:

print(f”Error al limpiar archivos temporales: {str(e)}”)

# Función que se ejecuta cuando se hace clic en el botón

def detect_disk():

for disk in disk_info:

print(f”\nDisco: {disk.device}”)

print(f”Sistema de Archivos: {disk.fstype}”)

try:

disk_usage = psutil.disk_usage(disk.device)

print(f”Espacio Total: {disk_usage.total / (1024**3):.2f} GB”)

print(f”Espacio Usado: {disk_usage.used / (1024**3):.2f} GB”)

print(f”Espacio Libre: {disk_usage.free / (1024**3):.2f} GB”)

print(f”Porcentaje Usado: {disk_usage.percent}%”)

except Exception as e:

print(f”Error al obtener información del disco: {str(e)}”)

# Verificar si el disco está particionado

if disk.device == disk.mountpoint:

partition_state=True

else:

partition_state=False

print(“Disco particionado: “+str(partition_state)+”\n”)

# Advertir al usuario sobre la defragmentacion de discos

def windows_warning(opt):

if opt == True:

global casilla_marcada

if not casilla_marcada:

messagebox.showwarning(“Advertencia”, “Esta opcion esta en modo experimental, no apague el dispositivo en ningun momento. Proceda bajo precaucion.”)

casilla_marcada = True

elif opt == False:

global casilla_marcada2

if not casilla_marcada2:

messagebox.showwarning(“Advertencia”, “Esta opcion esta en modo experimental, no apague el dispositivo en ningun momento. Proceda bajo precaucion.”)

casilla_marcada2 = True

# Función que se ejecuta cuando se hace clic en el botón

def start_cleaning():

print(“Iniciando limpieza del sistema operativo…” + “\n”)

print(“– OS INFO –“)

print(“Sistema operativo: ” + system_info.system)

print(“Version: ” + system_info.version)

print(“– DISK INFO –“)

detect_disk()

# Verificar el estado de los casilleros y ejecutar la limpieza correspondiente

print(“Las acciones que se realizaran a continuacion son las siguientes:”+”\n”)

if check_temp.get():

print(“Limpiar archivos temporales.”)

if check_kill.get():

print(“Finalizar servicios innecesarios.”)

if check_ram.get():

print(“Limpiar memoria RAM.”)

if check_win.get():

print(“Desfragmentar disco.”)

if check_dupli.get():

print(“Eliminar archivos duplicados.”)

while True:

ans=input(“\n”+”Estas seguro de continuar? Estos cambios son irreversibles: (y/n): “)

if ans==”y”:

print(“Limpiando archivos temporales…”+”\n”)

temporal_cleaner()

print(“ARCHIVOS TEMPORALES ELIMINADOS EXITOSAMENTE.”+”\n”)

print(“Finalizando procesos innecesarios…”+”\n”)

stop_process()

print(“PROCESOS INNECESARIOS FINALIZADOS EXITOSAMENTE.”+”\n”)

print(“Limpiando memoria RAM…”+”\n”)

ram_cleaner()

print(“RAM LIMPIADA EXITOSAMENTE.”+”\n”)

print(“Desfragmentando disco…”+”\n”)

defrag_disk()

print(“DISCO DESFRAGMENTADO EXITOSAMENTE.”+”\n”)

print(“Eliminando archivos duplicados…”+”\n”)

delete_dupl()

print(“ARCHIVOS DUPLICADOS ELIMINADOS EXITOSAMENTE.”+”\n”)

elif ans==”n”:

sys.exit()

else:

print(“No se ha introducido una respuesta correcta. Las opciones disponibles son y (yes), n (no)”)

time.sleep(2)

print(“”)

# Crear la ventana principal

root = tk.Tk()

os.system(“cls”)

# Crear frame principal

init_frame = tk.Frame(root)

# Valor para funcion de casillas.

casilla_marcada = False

casilla_marcada2 = False

# Bloquear la geometría de la ventana y establecer el tamaño para mostrar el título completo

root.geometry(“400×250”) # Ajusta las dimensiones según tus necesidades

root.title(“Master Cleaner v” + version) # Título con la versión

# Aplicar un tema personalizado

style = ThemedStyle(root)

style.set_theme(“plastik”) # Puedes cambiar “plastik” a otro tema de tu elección

# Crear un título encima del botón

title_label = ttk.Label(init_frame, text=”Haz click abajo para limpiar el sistema”, font=(“Arial”, 16))

title_label.pack(pady=5)

# Personalizar el estilo del botón

style.configure(“TButton”, padding=(20, 10), font=(“Arial”, 14))

# Crear casilleros

check_temp = tk.BooleanVar()

check_kill = tk.BooleanVar()

check_ram = tk.BooleanVar()

check_win = tk.BooleanVar()

check_dupli = tk.BooleanVar()

check_temporal = ttk.Checkbutton(init_frame, text=”Limpieza de archivos temporales”, variable=check_temp).pack(pady=1)

check_killer = ttk.Checkbutton(init_frame, text=”Finalizar procesos innecesarios”, variable=check_kill).pack(pady=1)

check_rammer = ttk.Checkbutton(init_frame, text=”Limpieza de memoria RAM”, variable=check_ram).pack(pady=1)

check_windows = ttk.Checkbutton(init_frame, text=”Desfragmentar discos”, variable=check_win, command=lambda:windows_warning(True)).pack(pady=1)

check_duplicated = ttk.Checkbutton(init_frame, text=”Eliminar archivos duplicados”, variable=check_dupli, command=lambda:windows_warning(False)).pack(pady=1)

# Crear un botón con estilo

start_button = ttk.Button(init_frame, text=”START CLEANING”, command=start_cleaning)

start_button.pack(pady=20) # Agregar un espacio en blanco alrededor del botón

# Crear frame de inicio de sesion

login_frame = tk.Frame(root)

tk.Label(login_frame, text=”Inicie sesión con su cuenta”).pack(pady=5)

tk.Label(login_frame, text=”Usuario:”).pack(pady=2)

user_entry = tk.Entry(login_frame)

user_entry.pack(pady=2)

tk.Label(login_frame, text=”Contraseña:”).pack(pady=2)

pass_entry = tk.Entry(login_frame)

pass_entry.pack(pady=2)

tk.Button(login_frame, text=”Iniciar sesión”, command=login).pack(pady=4)

tk.Button(login_frame, text=”Crear cuenta”, command=lambda:change_screens(1), font=”Calibri, 8″).pack(pady=8)

# Crear frame registro

register_frame = tk.Frame(root)

tk.Label(register_frame, text=”Registre una nueva cuenta”).pack(pady=5)

tk.Label(register_frame, text=”Usuario:”).pack(pady=2)

new_user_entry = tk.Entry(register_frame)

new_user_entry.pack(pady=2)

tk.Label(register_frame, text=”Contraseña:”).pack(pady=2)

new_pass_entry = tk.Entry(register_frame)

new_pass_entry.pack(pady=2)

tk.Label(register_frame, text=”Licencia:”).pack(pady=2)

valid_license = tk.Entry(register_frame)

valid_license.pack(pady=2)

tk.Button(register_frame, text=”Registrarse”, command=register).pack(pady=4)

tk.Button(register_frame, text=”Iniciar sesion”, command=lambda:change_screens(2), font=”Calibri, 8″).pack(pady=8)

# Asegúrate de agregar login_frame a tu ventana principal

login_frame.pack()

# Iniciar el bucle principal de la aplicación

login_frame.pack()

root.mainloop()

Download as PDF

Please follow and like us: