yeboyebo-backup-tools 1.1__tar.gz

yeboyebo_backup_tools-1.1/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: yeboyebo-backup-tools
+Version: 1.1
+Summary: Herramienta de backup PostgreSQL multiplataforma
+Home-page: https://github.com/yeboyebo/utils
+Author: Jose A. Fernandez
+Author-email: aullasistemas@gmail.com
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Archiving :: Backup
+Classifier: Topic :: Database
+Requires-Python: >=3.8
+Description-Content-Type: text/plain
+Requires-Dist: fernet
+Provides-Extra: loki
+Requires-Dist: python-logging-loki-v2; extra == "loki"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+Herramienta de backup PostgreSQL con montaje remoto, replicacion, test de integridad y alertas por email. Compatible Linux y Windows.

yeboyebo_backup_tools-1.1/backup_tools.py

@@ -0,0 +1,1036 @@
+# -*- coding: utf-8 -*-
+""" BackupTools package. """
+
+import os
+import sys
+import shutil
+import smtplib
+import datetime
+import base64
+import hashlib
+import uuid
+import tempfile
+import subprocess
+import tarfile
+import platform
+from pathlib import Path
+
+import fernet
+
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+
+from typing import Optional, List, Tuple
+
+__VERSION__ = "1.1"
+
+import logging
+LOGGER: "logging.Logger" = logging.getLogger("backup_tools")
+LOGGER.addHandler(logging.StreamHandler())
+LOGGER.setLevel(logging.WARNING)
+
+def check_command(name: str) -> None:
+    """Check command."""
+    if not SysUtils.which(name):
+        raise Exception("Comando %s no encontrado" % name)
+
+def run_command(original_command: str, level: int = 19) -> bool:
+    """Run command."""
+    # -20. Prioridad alta.
+    # 0. Prioridad normal.
+    # 19 Prioridad baja.
+    LOGGER.debug("\t* Ejecutando: %s" % original_command)
+    command = SysUtils.nice_command(original_command, level)
+    return subprocess.run(command, shell=True).returncode == 0
+
+def init_logger() -> "logging.Logger":
+    """Configure LOGGER with level from CLI args and optional Loki handler."""
+    global LOGGER
+
+    level = logging.WARNING
+    for argv in sys.argv[:]:
+        if argv.startswith("-vv"):
+            level = logging.DEBUG
+            sys.argv.remove(argv)
+            break
+        elif argv.startswith("-v"):
+            level = logging.INFO
+            sys.argv.remove(argv)
+            break
+
+    LOGGER.handlers.clear()
+    sh = logging.StreamHandler()
+    sh.setFormatter(logging.Formatter(
+        '%(levelname)-6s %(name)-10s %(filename)s:%(lineno)-10s %(message)s'
+    ))
+    LOGGER.addHandler(sh)
+    LOGGER.setLevel(level)
+
+    # Loki handler (opt-in via loki_url)
+    try:
+        _cfg = configTools(create=False)
+        _loki_url = _cfg.getParam("loki_url", default="https://monitor.yeboyebo.es/loki/api/v1/push")
+    except Exception:
+        _loki_url = ""
+
+    if _loki_url:
+        try:
+            from logging_loki import LokiHandler
+            _loki_tags = {
+                "app": _cfg.getParam("loki_app", default="backup_tools"),
+                "env": _cfg.getParam("loki_env", default="produccion"),
+            }
+            _loki_kwargs: dict = {
+                "url": _loki_url,
+                "tags": _loki_tags,
+                "version": "1",
+            }
+            try:
+                _loki_user = _cfg.getParam("loki_user", ofs=True)
+            except Exception:
+                _loki_user = ""
+            try:
+                _loki_pass = _cfg.getParam("loki_pass", ofs=True)
+            except Exception:
+                _loki_pass = ""
+            if _loki_user and _loki_pass:
+                _loki_kwargs["auth"] = (_loki_user, _loki_pass)
+            _loki_handler = LokiHandler(**_loki_kwargs)
+            LOGGER.addHandler(_loki_handler)
+            LOGGER.info("Loki logging enabled: %s", _loki_url)
+        except ImportError:
+            LOGGER.warning("logging-loki not installed. Loki logging disabled.")
+        except Exception as _loki_err:
+            LOGGER.warning("Loki setup failed: %s", _loki_err)
+
+    return LOGGER
+class Cifrado:
+
+    def __init__(self, key: str = None):
+        """Init."""
+
+        self.fernet : "fernet.Fernet" = None
+        self.key: str = key
+
+
+    def ofuscar(self, texto: str) -> bool:
+        """Save password."""
+
+        # save_password("password","CIF_EMPRESA")
+        self.init_fernet()
+        if len(texto) < 64:
+            texto = texto.ljust(64, "\n")
+            
+        encoded_bytes = self.fernet.encrypt(texto.encode())
+        return base64.b64encode(encoded_bytes).decode()
+
+        
+
+    def resolver(self, cipher_text: str) -> str:
+        """Resuelve password."""
+
+        self.init_fernet()
+
+        cipher_bytes = base64.b64decode(cipher_text.encode())
+        text = self.fernet.decrypt(cipher_bytes).decode()
+        text = text.rstrip("\n")
+        return text
+    
+    def init_fernet(self) -> None:
+        """Initialize fernet."""
+
+        if not self.fernet:
+            if not self.key:
+                raise Exception("No se ha especificado key")
+            key = self.key
+            # salt = os.urandom(9)
+            salt = b'\xa1\x8c\x8f\xdb\x8fi?_\xde'
+            key_encoded = key.encode()
+
+            hmac = hashlib.pbkdf2_hmac("sha256", key_encoded , salt, 10000)
+            dict_passwd = {
+                # Algorithm:
+                # .. pbkdf2: short algorithm name
+                # .. sha256: hash function used
+                # .. 4: number of zeroes used on iterations
+                "algorithm": "pbkdf2-sha256-4",
+                "salt": base64.b64encode(salt).decode(),
+                "hash": base64.b64encode(hmac).decode(),
+            }
+            hashed_password = "%(algorithm)s:%(salt)s:%(hash)s" % dict_passwd
+
+            key_salt = hashlib.sha256(hashed_password.encode()).digest()
+            new_key = hashlib.pbkdf2_hmac("sha256", key_encoded, key_salt, 10000)
+            key64 = base64.urlsafe_b64encode(new_key)
+            self.fernet = fernet.Fernet(key64)
+
+
+class configTools:
+
+    config_file: str 
+
+    def __init__(self, create: bool = True):
+        """Init."""
+
+        env_config = os.environ.get("BACKUP_TOOLS_CONFIG", "")
+        if env_config:
+            self.config_file = env_config
+        else:
+            self.config_file = os.path.join(os.path.dirname(__file__), "config.ini")
+
+        if create:
+            self.create_file()
+    
+    def create_file(self):
+        if not os.path.exists(self.config_file):
+            SysUtils.touch(self.config_file)
+    
+    def getParam(self, param: str, ofs: bool = False, default= None) -> str:
+        """Get param."""
+        
+        result : Optional[str] = None
+
+        with open(self.config_file, "r") as f:
+            for line in f:
+                if line.startswith(param):
+                    result = "=".join(line.split("=")[1:])
+                    if not ofs:
+                        result = result.strip("\n")
+                    break
+        if result is not None:
+            token = self.getParam("token") if ofs else  None
+            return result if not ofs else Cifrado(token).resolver(result)
+        elif default is not None:
+            self.setParam(param, str(default), ofs)
+            return default
+
+
+        raise Exception("Parametro no encontrado: %s" % param)
+    
+    def setParam(self, param: str, orig_value: str, ofs: bool = False):
+        """Set param."""
+
+        with open(self.config_file, "r", encoding="UTF-8") as f:
+            lines = f.readlines()
+
+        token = self.getParam("token") if ofs else None
+        value = orig_value if not ofs else Cifrado(token).ofuscar(orig_value)
+        
+        found = False
+        for pos, line in enumerate(lines):
+            if line.startswith(param):
+                lines[pos] = "%s=%s\n" % (param, value)
+                with open(self.config_file, "w", encoding="UTF-8") as f:
+                    for line in lines:
+                        f.write(line)
+                found = True
+                break
+        if not found:
+                with open(self.config_file, "a", encoding="UTF-8") as f:
+                    line = "%s=%s\n" % (param, value)
+                    f.write(line)
+
+        LOGGER.debug("\t(CONFIG) Establecido el valor %s para %s" % (orig_value, param))
+
+        return True
+
+class FilesActions:
+
+    config : 'configTools' = configTools(False)
+    flag_file : str = "no_tocar.txt"
+
+    def __init__(self):
+        """Initialice"""
+        pass
+
+    def move_files(self, local_folder:str, remote_device: str, horas: int = 12) -> bool:
+        """Move files."""
+        local_folder_backups = self.config.getParam("local_folder_backups")
+        LOGGER.info("Moviendo archivos de %s a %s modificados en las últimas %d horas" % (local_folder_backups, local_folder, horas))
+        self.mount_local_folder_backups()
+        self.mount_external(remote_device, local_folder)
+        minutos = horas * 60
+        files = SysUtils.find_recent_files(local_folder_backups, "*", minutos)
+        SysUtils.copy_files(files, local_folder)
+        self.umount_external(local_folder)
+        self.umount_local_folder_backups()
+        return True
+
+    def mount_local_folder_backups(self) -> bool:
+        """Mount local folder backup."""
+        local_folder = self.config.getParam("local_folder_backups")
+        device = self.config.getParam("local_folder_backups_device")
+        if device != "0":
+            return self.mount(device, local_folder)
+        return True
+
+    def umount_local_folder_backups(self) -> bool:
+        """Umount local folder backup."""
+        local_folder = self.config.getParam("local_folder_backups")
+        device = self.config.getParam("local_folder_backups_device")
+        if device != "0":
+            self.umount(local_folder)
+            return True
+        return True
+
+    def mount_external(self, remote_device: str, local_folder: str) -> bool:
+        """Mount external device."""
+        return self.mount(remote_device, local_folder, True)
+
+    def umount_external(self, local_folder: str) -> bool:
+        """Umount external device."""
+        return self.umount(local_folder)
+
+    def mount(self, device: str, local_folder: str, use_cifs: bool = False) -> bool:
+        """Mount."""
+        flag_file_path = os.path.join(local_folder, self.flag_file)
+        result = SysUtils.mount_device(device, local_folder, use_cifs)
+
+        if not os.path.exists(flag_file_path):
+            if result:
+                LOGGER.warning("Creando flag remoto ( %s )" % flag_file_path)
+                SysUtils.touch(flag_file_path)
+            else:
+                raise Exception("No se ha podido montar el dispositivo %s" % device)
+
+        return True
+
+    def umount(self, local_folder: str) -> bool:
+        """Umount"""
+        flag_file_path = os.path.join(local_folder, self.flag_file)
+        SysUtils.umount_device(local_folder)
+        return not os.path.exists(flag_file_path)
+
+
+class SendEmail:
+
+    gmail_user : str
+    gmail_password : str
+
+    def __init__(self, user_, pass_):
+    
+        self.gmail_user = user_
+        self.gmail_password = pass_
+
+    
+
+    def sendEmail(self, email, subject, body_file) -> bool:
+  
+        sent_from = self.gmail_user
+        to = email.split(',')
+        
+        LOGGER.debug("Enviando email a %s" % email)
+        message = MIMEMultipart("alternative")
+        message["Subject"] = subject
+        message["From"] = sent_from
+        message["To"] = email
+
+        file = open(body_file, "r")
+        text = file.read()
+        # Turn these into plain/html MIMEText objects
+        part1 = MIMEText(text, "html")
+        #part2 = MIMEText(html, "html")
+
+        # Add HTML/plain-text parts to MIMEMultipart message
+        # The email client will try to render the last part first
+        message.attach(part1)
+        #message.attach(part2)
+
+        try:
+            server = smtplib.SMTP('smtp.gmail.com')
+            #server.ehlo()
+            server.starttls()
+            server.login(self.gmail_user, self.gmail_password)
+            server.sendmail(sent_from, to, message.as_string())
+            server.quit()
+            LOGGER.debug("Email sent!")
+            return True
+
+        except Exception as inst:
+            LOGGER.error('Something went wrong...')
+            LOGGER.error(type(inst))    # the exception instance
+            LOGGER.error(inst.args)     # arguments stored in .args
+            LOGGER.error(inst)
+            return False
+
+
+class backupTools:
+
+    action_name: Optional[str] = None
+    arguments: List[str] = []
+    config: 'configTools' = configTools(False)
+    file_acts: 'FilesActions' = FilesActions()
+
+    def __init__(self):
+        """Init."""
+
+        
+        self.check_config()
+        self.load_arguments()
+
+    def check_config(self):
+        """Check config."""
+
+        if not os.path.exists(self.config.config_file):
+            LOGGER.debug("\t(CONFIG) Inicializando %s" % self.config.config_file)
+            self.config.create_file()
+
+        params = {
+            'days_alive': '20',
+            'local_folder_backups' : '/backups',
+            'token' : uuid.uuid4().hex,
+            'local_folder_backups_device': '0',
+            'current_copies':'1',
+            'current_folder':'currents',
+            'min_size': '5000', # en bytes 5kb
+            'loki_url': 'https://monitor.yeboyebo.es/loki/api/v1/push',
+            'loki_app': 'backup_tools',
+            'loki_env': 'produccion',
+        }
+
+        for name, value in params.items():
+            self.config.getParam(name, default=value)
+        
+
+
+    def load_arguments(self):
+        """Load arguments."""
+
+        if len(sys.argv) > 1:
+            self.action_name = sys.argv[1]
+            self.arguments = sys.argv[2:] 
+        else:
+            raise Exception("No se ha especificado la acción")
+    
+    def run(self) -> bool:
+        """Run."""
+        result = False
+        SysUtils.clear()
+        LOGGER.warning("Backup tools v%s acción %s" % (__VERSION__, self.action_name))
+
+        if self.action_name == "db":
+            result = self.db_actions()
+        elif self.action_name == "file":
+            result = self.file_actions()
+        elif self.action_name == "config":
+            result = self.config_actions()
+        elif self.action_name == "resume":
+            result = self.resume_actions()
+        elif self.action_name == "alive":
+            result = self.alive_actions()
+        elif self.action_name == "version":
+            print(__VERSION__)
+            result = True
+        else:
+            raise Exception("Acción no reconocida")
+        return result
+
+    def config_actions(self) -> bool:
+        """Config actions."""
+
+        if len(self.arguments) < 2:
+            raise Exception("Se necesitan 2 argumentos aparte de la acción")
+
+        param = self.arguments[0]
+        value = self.arguments[1]
+        obf = len(self.arguments) > 2 and str(self.arguments[2]).lower() == "true"
+        self.config.setParam(param, value, obf)
+
+        return True
+
+    def alive_actions(self) -> bool:
+        """Alive actions."""
+
+        if len(self.arguments) < 1:
+            raise Exception("Se necesita 1 argumento aparte de la acción")
+
+        host_url = self.arguments[0]
+        result = SysUtils.ping_host(host_url)
+        if not result:
+            timestamp = datetime.datetime.now().strftime("%d/%m/%Y %H:%M:%S")
+            server_name = self.config.getParam("server_name", default="unbutu-server")
+            tittle = "Servidor %s no es accesible desde %s" % (host_url, server_name)
+            data = [
+                "<a>El servidor %s no ha respondido a la solicitud (ping)</a>" % host_url,
+                "Esta comprobación fué realizada a las %s desde %s" % (timestamp, server_name),
+                ]
+
+            return self.send_email("<br>\n".join(data), tittle)
+
+        return True
+    
+    def resume_actions(self) -> bool:
+        """Resume actions."""
+
+        # Recolectar info de ficheros creados en las últimas 24 horas en local_folder_backups
+        local_folder_backups = self.config.getParam("local_folder_backups")
+        if not self.file_acts.mount_local_folder_backups():
+            raise Exception("No se ha montado el directorio %s" % local_folder_backups)
+        yesterday = datetime.datetime.now() - datetime.timedelta(days=1) # 24 horas atrás
+
+        # Lista de fichero creados en las últimas 24 horas en la carpeta local_folder_backup
+        files = os.listdir(local_folder_backups)
+        files = [os.path.join(local_folder_backups, f) for f in files]
+        result_files = []
+        for file in files:
+            if file.endswith(".tar.gz"):
+                file_timestamp = os.path.getmtime(file)
+                file_size = os.path.getsize(file)
+                if datetime.datetime.fromtimestamp(file_timestamp) > yesterday:
+                    result_files.append([file, file_size])
+                    
+        # result_files.sort(key=lambda x: os.path.getmtime(x[0])) # ordena por nombre
+        self.file_acts.umount_local_folder_backups()
+        result_files.sort(key=lambda x: x[1]) # Ordena por tamaño
+        result_files.reverse()
+
+        # Enviar email informando ...
+        data = []
+        cnt_result = len(result_files)
+        if cnt_result:
+            data.append("<a>Los siguientes %d ficheros se han generado en la últimas 24 horas en %s:</a>" % (cnt_result, local_folder_backups))
+            data.append("<table><tr><th>Nombre</th><th>Tamaño</tr>")
+            for file_name, file_size in result_files:
+                file_size_txt = ""
+                if file_size > 1024 * 1024:
+                    file_size_txt = "%.2f MB" % (file_size / (1024 * 1024))
+                elif file_size > 1024:
+                    file_size_txt = "%.2f KB" % (file_size / 1024)
+                else:
+                    file_size_txt = "%d Bytes" % file_size
+
+                data.append("<tr><td>%s</td><td>%s</td></tr>" % (os.path.basename(file_name), file_size_txt))
+            data.append("</table>")
+        else:
+            data.append("<a>No se han generado ficheros en la última 24 horas en %s</a>" % local_folder_backups)
+
+
+        tittle = "Backup servidor %s" % self.config.getParam("server_name", default="unbutu-server")
+        return self.send_email("\n".join(data), tittle)
+
+
+    def file_actions(self) -> bool:
+       """File actions."""
+
+       if len(self.arguments) < 3:
+          raise Exception("Se necesitan 3 argumentos aparte de la acción")
+       
+       mode = self.arguments[0] # remote
+       local_folder = self.arguments[1] # /mnt/sinology
+       remote_folder = self.arguments[2] # //smb/loquesea
+       horas = self.arguments[3] if len(self.arguments) > 3 else 12
+
+       if mode == "remote":
+           return self.file_acts.move_files(local_folder, remote_folder, horas)
+
+       raise Exception("No implementado")
+            
+
+    
+    def db_actions(self) -> bool:
+        """DB actions."""
+
+        if len(self.arguments) < 2:
+            raise Exception("Se necesitan 2 argumentos aparte de la acción")
+
+        mode = self.arguments[0]
+        files_list = self.arguments[1].split(",")
+
+        check_command("pg_dump")
+        check_command("psql")
+        check_command("tar")
+
+        
+        dbs_names = []
+        for file_name_list in files_list:
+            file_path = self.resuelve_fichero(file_name_list)
+
+            with open(file_path, "r") as f:
+                lines = f.readlines()
+                for line in lines:
+                    dbs_names.append(line.strip("\n"))
+
+        error = False
+        is_replicate = False
+        check_older_files = True
+        if mode == "replicate":
+            mode = "dump"
+            is_replicate = True
+        if mode in ["dump", "restore"]:
+            ini_time = datetime.datetime.now()
+            print("* Inicio tarea %s a las %s" % (mode, ini_time.strftime("%d/%m/%Y %H:%M:%S")))
+            for db_name in dbs_names:
+                try:
+                    
+                    if not self.backup_db(mode, db_name, is_replicate):
+                        error = True
+                except Exception as inst:
+                    LOGGER.error(inst)
+                    error = True
+
+            fin_time = datetime.datetime.now()
+            print("* Fin tarea %s a las %s" % (mode, fin_time.strftime("%d/%m/%Y %H:%M:%S")))
+            minutos = (fin_time - ini_time).seconds / 60
+            segundos = (fin_time - ini_time).seconds % 60
+            print("* Duración: %d minutos y %d segundos" % (minutos, segundos))
+        elif mode == "test":
+            data = []
+            check_older_files = False
+            mail_tittle = "CHECK BACKUPS %s (%s)" % (self.config.getParam("server_name", default="unbutu-server"), ",".join(files_list))
+            ini_time = datetime.datetime.now()
+            print("* Inicio tarea %s a las %s" % (mode, ini_time.strftime("%d/%m/%Y %H:%M:%S")))
+            try:
+                for db_name in dbs_names:
+                    self.backup_db_test(db_name)
+            except Exception as inst:
+                LOGGER.error(inst)
+                data.append("<a>Se ha producido un error en el test de backups</a>")
+                data.append("<a>ERROR: %s</a>" % inst)
+                error = True
+            else:
+                data.append("<a>Test de backups realizado correctamente</a>")
+
+            fin_time = datetime.datetime.now()
+            print("* Fin tarea %s a las %s" % (mode, fin_time.strftime("%d/%m/%Y %H:%M:%S")))
+            minutos = (fin_time - ini_time).seconds / 60
+            segundos = (fin_time - ini_time).seconds % 60
+            print("* Duración: %d minutos y %d segundos" % (minutos, segundos))
+            self.send_email("\n".join(data), mail_tittle)
+
+
+        else:
+            raise Exception("Modo %s no reconocido" % (mode))
+        
+
+        if not error:
+            if check_older_files:
+                return self.remove_old_backups(dbs_names)
+            return True
+        else:
+            return False
+
+    def resuelve_fichero(self, file_name: str) -> str:
+        """Resuelve fichero."""
+
+
+        result : str = file_name if file_name.startswith("/") else ""
+        if not result:
+            # Busqueda en local
+            result = os.path.join(os.path.dirname(__file__), file_name)
+            if not os.path.exists(result):
+                file_name_home = "~/%s" % file_name
+                result = os.path.expanduser(file_name_home)
+
+        result = os.path.abspath(result)
+
+        if not os.path.exists(result):
+            raise Exception("Fichero %s no encontrado" % file_name)
+
+        return result
+            
+ 
+        
+    def remove_old_backups(self, files_names: List[str] = []) -> bool:
+        """Check backups."""
+        days_alive = int(self.config.getParam("days_alive"))
+        local_folder_backups = self.config.getParam("local_folder_backups")
+        if not self.file_acts.mount_local_folder_backups():
+            raise Exception("No se ha montado el directorio %s" % local_folder_backups)
+        LOGGER.info("\t Comprobando backups viejos... ( más de %d días en carpeta %s)" % (days_alive, local_folder_backups))
+        cutoff = datetime.datetime.now().timestamp() - (days_alive * 86400)
+        for file_name in files_names:
+            LOGGER.info("\t\t* Comprobando %s" % file_name)
+            for p in Path(local_folder_backups).glob("%s_*.tar.gz" % file_name):
+                if p.is_file() and p.stat().st_mtime < cutoff:
+                    LOGGER.info("\t\t\t- Borrando %s" % p)
+                    p.unlink()
+            self.check_current_backups(file_name)
+
+        self.file_acts.umount_local_folder_backups()
+        return True
+    
+    def check_current_backups(self, file_name: str) -> bool:
+        """Check current backups."""
+        cnt_files = int(self.config.getParam("current_copies"))
+        if cnt_files < 1:
+            return False
+
+        local_folder_backups = self.config.getParam("local_folder_backups")
+        current_folder = self.config.getParam("current_folder")
+        current_path = os.path.join(local_folder_backups, current_folder)
+        if not os.path.exists(current_path):
+            LOGGER.info("\t\t* Creando directorio %s" % current_path)
+            os.mkdir(current_path)
+
+        # Mover los cnt_files más recientes desde local_folder_backups a currents
+        recent = SysUtils.newest_files(local_folder_backups, "%s_*.tar.gz" % file_name, cnt_files)
+        selected_files_path: List[str] = []
+        for f in recent:
+            target_file = os.path.join(current_path, f.name)
+            selected_files_path.append(target_file)
+            if not os.path.exists(target_file):
+                LOGGER.info("\t\t* Moviendo %s a %s" % (f, current_path))
+                shutil.copy2(str(f), target_file)
+            else:
+                LOGGER.info("\t\t* %s ya existe en %s" % (f, current_path))
+
+        # Borrar los ficheros que no están en selected_files_path
+        for f in SysUtils.glob_files(current_path, "%s_*.tar.gz" % file_name):
+            if str(f) not in selected_files_path:
+                LOGGER.info("\t\t* Borrando %s" % f)
+                f.unlink()
+
+        return True
+
+    def resolve_newset_file_name(self, db_name: str, newest: bool = False) -> str:
+        """Resolve newset file name."""
+        local_folder_backups = self.config.getParam("local_folder_backups")
+        if newest:
+            return "%s_%s.sql" % (db_name, datetime.datetime.now().strftime("%Y%m%d_%H%M%S"))
+        # Buscar fichero mas reciente con el nombre que comience por db_name
+        newest_file = SysUtils.newest_file(local_folder_backups, "%s*.tar.gz" % db_name)
+        return str(newest_file) if newest_file else ""
+    
+    def backup_db_test(self, orig_db_name: str) -> bool:
+        """Backup DB test."""
+
+        user_db = self.config.getParam("user_db", True)
+        pass_db = self.config.getParam("pass_db", True)
+        port_db = self.config.getParam("port_db", default="5432")
+        local_folder_backups = self.config.getParam("local_folder_backups")
+        if not self.file_acts.mount_local_folder_backups():
+            raise Exception("No se ha montado el directorio %s" % local_folder_backups)
+        time_ini = datetime.datetime.now()
+        print("* %s Realizando TEST de %s" % (time_ini.strftime("%Y/%m/%d %H:%M:%S"), orig_db_name))
+        host_db = self.config.getParam("host_db", default="127.0.0.1" )
+
+        current_dir = os.getcwd()
+
+        dest_file_tar_gz = self.resolve_newset_file_name(orig_db_name)
+        if not dest_file_tar_gz:
+            raise Exception("No se ha encontrado fichero para %s en %s" % (orig_db_name, local_folder_backups))
+        dest_file = dest_file_tar_gz.replace(".tar.gz", "")
+        os.chdir(local_folder_backups)
+        # Comprueba si el fichero existe
+        if not os.path.exists(dest_file_tar_gz):
+            raise Exception("Fichero %s no encontrado" % dest_file_tar_gz)
+
+        LOGGER.info("Descromprimiendo %s ...." % (dest_file_tar_gz))
+        with tarfile.open(dest_file_tar_gz, "r:gz") as tar:
+            tar.extractall(path=local_folder_backups)
+        if not os.path.exists(dest_file):
+            raise Exception("Fichero %s no encontrado" % dest_file)
+
+        if orig_db_name == "roles":
+            print("TEST de roles. El fichero existe. No se va a comprobar si es restaurable")
+            Path(dest_file).unlink()
+            return True
+        
+        db_name = "%s_test" % (orig_db_name)
+
+        psql_cmd = ["psql", "--dbname=postgresql://%s:%s@%s:%s/" % (user_db, pass_db, host_db, port_db)]
+        subprocess.run(psql_cmd + ["-c", "DROP DATABASE IF EXISTS %s" % db_name], check=False)
+        subprocess.run(psql_cmd + ["-c", "CREATE DATABASE %s" % db_name], check=True)
+
+        # Restaurar dump
+        has_error: Optional[str] = None
+        restore_cmd = SysUtils.nice_command(
+            "psql --dbname=postgresql://%s:%s@%s:%s/%s" % (user_db, pass_db, host_db, port_db, db_name), -20
+        ).split()
+        with open(dest_file, "r") as f:
+            if subprocess.run(restore_cmd, stdin=f).returncode != 0:
+                has_error = "No se ha restaurado el dump"
+
+        if not has_error:
+            sql = "SELECT pg_size_pretty(pg_database_size(pg_database.datname)) AS SIZE FROM pg_database where pg_database.datname = '%s'" % db_name
+            cmd = ["psql", "--dbname=postgresql://%s:%s@%s:%s/" % (user_db, pass_db, host_db, port_db), "-c", sql]
+            proc = subprocess.run(cmd, capture_output=True, text=True)
+            result_list = proc.stdout.split("\n")
+            if len(result_list) > 3:
+                size_orig = result_list[2]
+                size_datatable = int(size_orig.strip(" ").split(" ")[0])
+                if size_datatable < 1:
+                    has_error = "Tamaño datatable inválido (%s)" % size_orig
+            else:
+                has_error = "Tamaño datatable inválido. Error de consulta"
+
+    
+        subprocess.run(psql_cmd + ["-c", "DROP DATABASE IF EXISTS %s" % db_name], check=False)
+
+        if has_error:
+            raise Exception("Error al restaurar %s:%s" % (dest_file, has_error))
+
+        Path(dest_file).unlink()
+
+        self.file_acts.umount_local_folder_backups()
+        os.chdir(current_dir)
+        time_fin = datetime.datetime.now()
+        # Convertir la diferencia de time_fin y time_ini a minutos/segundos
+        minutos_total = (time_fin - time_ini).total_seconds() / 60
+        minutos_total = int(minutos_total)
+        segundos_total = (time_fin - time_ini).total_seconds() % 60
+        segundos_total = int(segundos_total)
+        tiempo_total = "%02d:%02d" % (minutos_total, segundos_total)
+        print("* %s Finalizado test de %s. Tiempo backup: %s minutos" % (time_fin.strftime("%Y/%m/%d %H:%M:%S"), db_name, tiempo_total))
+
+        return True
+
+    
+    def backup_db(self, mode: str, db_name: str, replicate: bool = False) -> bool:
+        """Backup DB."""
+        user_db = self.config.getParam("user_db", True)
+        pass_db = self.config.getParam("pass_db", True)
+        port_db = self.config.getParam("port_db", default="5432")
+        local_folder_backups = self.config.getParam("local_folder_backups")
+        if not self.file_acts.mount_local_folder_backups():
+            raise Exception("No se ha montado el directorio %s" % local_folder_backups)
+        time_ini = datetime.datetime.now()
+        print("* %s Realizando %s de %s" % (time_ini.strftime("%Y/%m/%d %H:%M:%S"), mode, db_name))
+        orig_host_db = self.config.getParam("host_db", default="127.0.0.1")
+
+        current_dir = os.getcwd()
+
+        try:
+            if mode == "dump":
+                dest_file = self.resolve_newset_file_name(db_name, True)
+                dest_file_tar_gz = "%s.tar.gz" % (dest_file)
+                os.chdir(local_folder_backups)
+                if os.path.exists(dest_file):
+                    os.remove(dest_file)
+                # Crear dump
+                conn_str = "postgresql://%s:%s@%s:%s" % (user_db, pass_db, orig_host_db, port_db)
+                if db_name == "roles":
+                    cmd = ["pg_dumpall", "--dbname=%s" % conn_str, "--globals-only"]
+                else:
+                    cmd = ["pg_dump", "--dbname=%s/%s" % (conn_str, db_name)]
+                with open(dest_file, "w") as f:
+                    subprocess.run(cmd, stdout=f, check=True)
+                LOGGER.debug("\t* Ejecutando: %s" % " ".join(cmd))
+                if not os.path.exists(dest_file):
+                    raise Exception("Fichero %s no encontrado" % dest_file)
+
+                LOGGER.info("\t* Comprimiendo %s ...." % (dest_file))
+                with tarfile.open(dest_file_tar_gz, "w:gz") as tar:
+                    tar.add(dest_file, arcname=os.path.basename(dest_file))
+                Path(dest_file).unlink()
+
+                self.check_file_size(dest_file_tar_gz)
+
+                result = self.backup_db("restore", db_name, True) if replicate else os.path.exists(dest_file_tar_gz)
+                if not result:
+                    raise Exception("Error al realizar el backup de %s" % db_name)
+                os.chdir(current_dir)
+
+            elif mode == "restore":
+                dest_file_tar_gz = self.resolve_newset_file_name(db_name)
+                dest_file = dest_file_tar_gz.replace(".tar.gz", "")
+                os.chdir(local_folder_backups)
+                if not os.path.exists(dest_file_tar_gz):
+                    raise Exception("Fichero %s no encontrado" % dest_file_tar_gz)
+
+                LOGGER.info("Descromprimiendo %s ...." % (dest_file_tar_gz))
+                with tarfile.open(dest_file_tar_gz, "r:gz") as tar:
+                    tar.extractall(path=local_folder_backups)
+                if not os.path.exists(dest_file):
+                    raise Exception("Fichero %s no encontrado" % dest_file)
+
+                host_db = self.config.getParam("replicate_host_db") if replicate else orig_host_db
+                conn_str = "postgresql://%s:%s@%s:%s" % (user_db, pass_db, host_db, port_db)
+
+                psql_cmd = ["psql", "--dbname=%s/" % conn_str]
+                subprocess.run(psql_cmd + ["-c", "DROP DATABASE %s" % db_name], check=False)
+                subprocess.run(psql_cmd + ["-c", "CREATE DATABASE %s" % db_name], check=True)
+
+                # Restaurar dump
+                restore_cmd = SysUtils.nice_command(
+                    "psql --dbname=%s/%s" % (conn_str, db_name), -20
+                ).split()
+                with open(dest_file, "r") as f:
+                    subprocess.run(restore_cmd, stdin=f, check=True)
+
+                Path(dest_file).unlink()
+
+            self.file_acts.umount_local_folder_backups()
+            os.chdir(current_dir)
+            time_fin = datetime.datetime.now()
+            minutos_total = int((time_fin - time_ini).total_seconds() / 60)
+            segundos_total = int((time_fin - time_ini).total_seconds() % 60)
+            tiempo_total = "%02d:%02d" % (minutos_total, segundos_total)
+            print("* %s Finalizada %s de %s. Tiempo backup: %s minutos" % (time_fin.strftime("%Y/%m/%d %H:%M:%S"), mode, db_name, tiempo_total))
+        except Exception as inst:
+            self.file_acts.umount_local_folder_backups()
+            os.chdir(current_dir)
+            LOGGER.error(type(inst))
+            LOGGER.error(inst.args)
+            LOGGER.error(inst)
+            return False
+
+        return True
+    
+    def check_file_size(self, file_name: str) -> bool:
+        """Check file size."""
+
+        min_size = int(self.config.getParam("min_size"))
+        file_size = os.path.getsize(file_name)
+        # print("Check file size %s %s > %s" % (file_name, file_size, min_size))
+        
+        if file_size < min_size:
+            tittle = "Problema en fichero de backup detectado"
+            data = [
+                "<a>El fichero %s se ha generado con un tamaño inferior a %sBytes (%s)</a>" % (file_name, min_size, file_size),
+                ]
+            return self.send_email("\n".join(data), tittle)
+
+        return True
+
+    def send_email(self, payload: str, tittle: str) -> bool:
+        """Enviar email."""
+
+        user_ = self.config.getParam("user_email")
+        pass_ = self.config.getParam("pass_email", True)
+        payload += "<br><br>Yeboyebo backup tools v%s" % __VERSION__
+
+        timestamp = datetime.datetime.now().strftime("%Y%m%d%H%M%S")
+        file_name = os.path.join(SysUtils.temp_dir(), "%s.txt" % timestamp)
+        with open(file_name, "wb") as f:
+            f.write(payload.encode("utf-8"))
+
+        emails_list = self.config.getParam("list_mails").split(",")
+        result = None
+        s = SendEmail(user_, pass_)
+        for email in emails_list:
+            if s.sendEmail(email,tittle,file_name):
+                result = True
+            else:
+                result = False
+                break
+        
+        if result is None:
+            LOGGER.error("No se han especificado emails en list_mails")
+
+
+        return result
+
+class SysUtils:
+    """Platform abstraction for OS-specific operations."""
+
+    IS_WIN: bool = os.name == "nt"
+
+    @staticmethod
+    def clear() -> None:
+        """Clear terminal screen."""
+        os.system("cls" if SysUtils.IS_WIN else "clear")
+
+    @staticmethod
+    def nice_command(command: str, level: int) -> str:
+        """Wrap command with nice on Linux. No-op on Windows."""
+        if SysUtils.IS_WIN:
+            return command
+        return "nice -n %d %s" % (level, command)
+
+    @staticmethod
+    def ping_host(host: str, count: int = 3) -> bool:
+        """Ping a host. Returns True if reachable."""
+        flag = "-n" if SysUtils.IS_WIN else "-c"
+        cmd = ["ping", flag, str(count), host]
+        return subprocess.run(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL).returncode == 0
+
+    @staticmethod
+    def mount_device(device: str, mount_point: str, use_cifs: bool = False) -> bool:
+        """Mount a device. CIFS on Linux uses mount.cifs; on Windows uses net use."""
+        if SysUtils.IS_WIN:
+            # net use <drive>: \\server\share
+            cmd = ["net", "use", mount_point, device]
+            if use_cifs:
+                cmd.extend(["/user:guest", ""])
+        else:
+            if use_cifs:
+                cmd = ["mount.cifs", device, mount_point, "-o", "rw,guest,vers=2.0"]
+            else:
+                cmd = ["mount", device, mount_point]
+        return subprocess.run(cmd).returncode == 0
+
+    @staticmethod
+    def umount_device(mount_point: str) -> bool:
+        """Unmount a device. Returns True if flag file no longer exists."""
+        if SysUtils.IS_WIN:
+            cmd = ["net", "use", mount_point, "/delete"]
+        else:
+            cmd = ["umount", mount_point]
+        subprocess.run(cmd)
+        return True
+
+    @staticmethod
+    def touch(path: str) -> None:
+        """Create an empty file."""
+        Path(path).touch()
+
+    @staticmethod
+    def which(name: str) -> Optional[str]:
+        """Locate a command. Returns path or None."""
+        return shutil.which(name)
+
+    @staticmethod
+    def find_recent_files(directory: str, pattern: str, minutes: int) -> List[Path]:
+        """Find files matching glob pattern modified in the last N minutes."""
+        cutoff = datetime.datetime.now().timestamp() - (minutes * 60)
+        results = []
+        for p in Path(directory).rglob(pattern):
+            if p.is_file() and p.stat().st_mtime >= cutoff:
+                results.append(p)
+        return results
+
+    @staticmethod
+    def copy_files(files: List[Path], dest_dir: str) -> None:
+        """Copy files preserving metadata."""
+        dest = Path(dest_dir)
+        for f in files:
+            shutil.copy2(str(f), str(dest / f.name))
+
+    @staticmethod
+    def newest_file(directory: str, glob_pattern: str) -> Optional[Path]:
+        """Return the most recently modified file matching glob pattern, or None."""
+        files = sorted(Path(directory).glob(glob_pattern), key=lambda p: p.stat().st_mtime, reverse=True)
+        return files[0] if files else None
+
+    @staticmethod
+    def newest_files(directory: str, glob_pattern: str, count: int) -> List[Path]:
+        """Return the N most recently modified files matching glob pattern."""
+        files = sorted(Path(directory).glob(glob_pattern), key=lambda p: p.stat().st_mtime, reverse=True)
+        return files[:count]
+
+    @staticmethod
+    def glob_files(directory: str, glob_pattern: str) -> List[Path]:
+        """Return all files matching glob pattern."""
+        return [p for p in Path(directory).glob(glob_pattern) if p.is_file()]
+
+    @staticmethod
+    def temp_dir() -> str:
+        """Return OS-appropriate temp directory."""
+        return tempfile.gettempdir()
+
+    @staticmethod
+    def run(cmd: List[str], **kwargs) -> subprocess.CompletedProcess:
+        """Run a command via subprocess. Returns CompletedProcess."""
+        return subprocess.run(cmd, **kwargs)
+
+
+def main() -> None:
+    """Entry point for console_scripts."""
+    global LOGGER
+    LOGGER = init_logger()
+    obj = backupTools()
+    if not obj.run():
+        LOGGER.error("(ERROR) Error al ejecutar la acción %s" % obj.action_name)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
+
+# python3 backup_tools.py db restore lista.txt
+# python3 backup_tools.py db dump lista.txt
+# python3 backup_tools.py file remote local_folder remote_device horas? 12
+# python3 backup_tools.py config current_copies 3
+# python3 backup_tools.py resume
+# python3 backup_tools.py alive 192.168.1.30

yeboyebo_backup_tools-1.1/setup.cfg

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

yeboyebo_backup_tools-1.1/setup.py

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+"""Setup for yeboyebo-backup-tools."""
+
+from setuptools import setup
+
+long_description = "Herramienta de backup PostgreSQL con montaje remoto, replicacion, test de integridad y alertas por email. Compatible Linux y Windows."
+
+setup(
+    name="yeboyebo-backup-tools",
+    version="1.1",
+    description="Herramienta de backup PostgreSQL multiplataforma",
+    long_description=long_description,
+    long_description_content_type="text/plain",
+    author="Jose A. Fernandez",
+    author_email="aullasistemas@gmail.com",
+    url="https://github.com/yeboyebo/utils",
+    py_modules=["backup_tools"],
+    install_requires=[
+        "fernet",
+    ],
+    extras_require={
+        "loki": ["python-logging-loki-v2"],
+    },
+    entry_points={
+        "console_scripts": [
+            "backup-tools=backup_tools:main",
+        ],
+    },
+    classifiers=[
+        "Development Status :: 5 - Production/Stable",
+        "Environment :: Console",
+        "Intended Audience :: System Administrators",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: POSIX :: Linux",
+        "Operating System :: Microsoft :: Windows",
+        "Programming Language :: Python :: 3",
+        "Topic :: System :: Archiving :: Backup",
+        "Topic :: Database",
+    ],
+    python_requires=">=3.8",
+)

yeboyebo_backup_tools-1.1/tests/test_backup_tools.py

@@ -0,0 +1,121 @@
+# -*- coding: utf-8 -*-
+"""Tests for backup_tools."""
+
+import os
+import sys
+import uuid
+import tempfile
+import pytest
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+from backup_tools import Cifrado, configTools, SysUtils
+
+
+class TestCifrado:
+    """Tests for Cifrado (Fernet-based obfuscation)."""
+
+    def test_ofuscar_resolver_roundtrip(self):
+        key = uuid.uuid4().hex
+        c = Cifrado(key)
+        plain = "mi_contraseña_secreta"
+        obf = c.ofuscar(plain)
+        assert obf != plain
+        assert c.resolver(obf) == plain
+
+    def test_ofuscar_short_text_pads_to_64(self):
+        key = uuid.uuid4().hex
+        c = Cifrado(key)
+        obf = c.ofuscar("short")
+        resolved = c.resolver(obf)
+        assert resolved == "short"
+
+    def test_different_keys_produce_different_ciphertext(self):
+        c1 = Cifrado(uuid.uuid4().hex)
+        c2 = Cifrado(uuid.uuid4().hex)
+        obf1 = c1.ofuscar("test")
+        obf2 = c2.ofuscar("test")
+        assert obf1 != obf2
+
+    def test_no_key_raises(self):
+        c = Cifrado()
+        with pytest.raises(Exception):
+            c.ofuscar("test")
+
+
+class TestConfigTools:
+    """Tests for configTools (INI file persistence)."""
+
+    def test_set_and_get_plain_param(self):
+        tmp = os.path.join(tempfile.gettempdir(), "test_config_%s.ini" % uuid.uuid4().hex[:8])
+        os.environ["BACKUP_TOOLS_CONFIG"] = tmp
+        try:
+            cfg = configTools(create=True)
+            cfg.setParam("test_key", "test_value")
+            assert cfg.getParam("test_key") == "test_value"
+        finally:
+            del os.environ["BACKUP_TOOLS_CONFIG"]
+            if os.path.exists(tmp):
+                os.remove(tmp)
+
+    def test_get_with_default_creates_param(self):
+        tmp = os.path.join(tempfile.gettempdir(), "test_config_%s.ini" % uuid.uuid4().hex[:8])
+        os.environ["BACKUP_TOOLS_CONFIG"] = tmp
+        try:
+            cfg = configTools(create=True)
+            val = cfg.getParam("new_param", default="default_val")
+            assert val == "default_val"
+            assert cfg.getParam("new_param") == "default_val"
+        finally:
+            del os.environ["BACKUP_TOOLS_CONFIG"]
+            if os.path.exists(tmp):
+                os.remove(tmp)
+
+    def test_missing_param_raises(self):
+        tmp = os.path.join(tempfile.gettempdir(), "test_config_%s.ini" % uuid.uuid4().hex[:8])
+        os.environ["BACKUP_TOOLS_CONFIG"] = tmp
+        try:
+            cfg = configTools(create=True)
+            with pytest.raises(Exception):
+                cfg.getParam("nonexistent")
+        finally:
+            del os.environ["BACKUP_TOOLS_CONFIG"]
+            if os.path.exists(tmp):
+                os.remove(tmp)
+
+
+class TestSysUtils:
+    """Tests for SysUtils platform abstraction."""
+
+    def test_which_existing_command(self):
+        assert SysUtils.which("python") is not None or SysUtils.which("python3") is not None
+
+    def test_which_nonexistent_command(self):
+        assert SysUtils.which("xyznonexistentcmd123") is None
+
+    def test_touch_creates_file(self):
+        tmp = os.path.join(tempfile.gettempdir(), "test_touch_%s.txt" % uuid.uuid4().hex[:8])
+        try:
+            SysUtils.touch(tmp)
+            assert os.path.exists(tmp)
+        finally:
+            if os.path.exists(tmp):
+                os.remove(tmp)
+
+    def test_temp_dir(self):
+        d = SysUtils.temp_dir()
+        assert os.path.isdir(d)
+
+    def test_find_recent_files(self):
+        tmpdir = tempfile.mkdtemp()
+        try:
+            p = os.path.join(tmpdir, "recent.txt")
+            SysUtils.touch(p)
+            files = SysUtils.find_recent_files(tmpdir, "*.txt", 1)
+            assert len(files) >= 1
+        finally:
+            import shutil
+            shutil.rmtree(tmpdir, ignore_errors=True)
+
+    def test_is_win(self):
+        assert isinstance(SysUtils.IS_WIN, bool)

yeboyebo_backup_tools-1.1/yeboyebo_backup_tools.egg-info/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: yeboyebo-backup-tools
+Version: 1.1
+Summary: Herramienta de backup PostgreSQL multiplataforma
+Home-page: https://github.com/yeboyebo/utils
+Author: Jose A. Fernandez
+Author-email: aullasistemas@gmail.com
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Archiving :: Backup
+Classifier: Topic :: Database
+Requires-Python: >=3.8
+Description-Content-Type: text/plain
+Requires-Dist: fernet
+Provides-Extra: loki
+Requires-Dist: python-logging-loki-v2; extra == "loki"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+Herramienta de backup PostgreSQL con montaje remoto, replicacion, test de integridad y alertas por email. Compatible Linux y Windows.

yeboyebo_backup_tools-1.1/yeboyebo_backup_tools.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+backup_tools.py
+setup.py
+tests/test_backup_tools.py
+yeboyebo_backup_tools.egg-info/PKG-INFO
+yeboyebo_backup_tools.egg-info/SOURCES.txt
+yeboyebo_backup_tools.egg-info/dependency_links.txt
+yeboyebo_backup_tools.egg-info/entry_points.txt
+yeboyebo_backup_tools.egg-info/requires.txt
+yeboyebo_backup_tools.egg-info/top_level.txt

yeboyebo_backup_tools-1.1/yeboyebo_backup_tools.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

yeboyebo_backup_tools-1.1/yeboyebo_backup_tools.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+backup-tools = backup_tools:main

yeboyebo_backup_tools-1.1/yeboyebo_backup_tools.egg-info/requires.txt

@@ -0,0 +1,4 @@
+fernet
+
+[loki]
+python-logging-loki-v2

yeboyebo_backup_tools-1.1/yeboyebo_backup_tools.egg-info/top_level.txt

@@ -0,0 +1 @@
+backup_tools