import os
import datetime

def automatic_backup():
    # MySQL backup
    backup_mysql_db('localhost', 'root', 'password', 'my_database', backup_path)

    # File system backup
    backup_files(source_dir, dest_dir)

# Example usage
source_dir = '/path/to/source'
dest_dir = '/path/to/backup'
backup_path = '/path/to/backup'

automatic_backup()

import logging

def backup_mysql_db(host, user, password, db_name, backup_path):
    # Connect to MySQL database
    try:
        conn = pymysql.connect(host=host, user=user, password=password, database=db_name)
        cursor = conn.cursor()
    except Exception as e:
        logging.error(f"Failed to connect to MySQL database: {e}")
        return

    # Backup database
    try:
        current_time = datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S')
        backup_file = f"{backup_path}/{db_name}_backup_{current_time}.sql"
        with open(backup_file, 'w') as f:
            for line in conn.iterdump():
                f.write('%s\n' % line)
        logging.info(f"Backup of database {db_name} completed successfully: {backup_file}")
    except Exception as e:
        logging.error(f"Failed to backup database {db_name}: {e}")
    finally:
        cursor.close()
        conn.close()

# Set up logging
logging.basicConfig(filename='/path/to/backup.log', level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

# Example usage
backup_mysql_db('localhost', 'root', 'password', 'my_database', '/path/to/backup')

import os
import shutil
import datetime

def incremental_backup(source_dir, dest_dir, last_backup_dir):
    current_time = datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S')
    backup_dir = f"{dest_dir}/backup_{current_time}"
    
    # Copy new or modified files since last backup
    for root, dirs, files in os.walk(source_dir):
        relative_path = os.path.relpath(root, source_dir)
        backup_root = os.path.join(backup_dir, relative_path)
        os.makedirs(backup_root, exist_ok=True)
        for file in files:
            source_file = os.path.join(root, file)
            backup_file = os.path.join(backup_root, file)
            last_backup_file = os.path.join(last_backup_dir, relative_path, file)
            if not os.path.exists(last_backup_file) or os.path.getmtime(source_file) > os.path.getmtime(last_backup_file):
                shutil.copy2(source_file, backup_file)
    
    return backup_dir

# Example usage
source_dir = '/path/to/source'
dest_dir = '/path/to/backup'
last_backup_dir = '/path/to/last_backup'

backup_dir = incremental_backup(source_dir, dest_dir, last_backup_dir)

def update_last_backup_dir(last_backup_dir, backup_dir):
    if os.path.exists(last_backup_dir):
        shutil.rmtree(last_backup_dir)
    shutil.copytree(backup_dir, last_backup_dir)

# Example usage
update_last_backup_dir(last_backup_dir, backup_dir)

import os
import shutil
import datetime
import logging

def setup_logger(log_file):
    logger = logging.getLogger('backup_logger')
    logger.setLevel(logging.INFO)
    formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
    file_handler = logging.FileHandler(log_file)
    file_handler.setFormatter(formatter)
    logger.addHandler(file_handler)
    return logger

def incremental_backup(source_dir, dest_dir, last_backup_dir, log_file):
    logger = setup_logger(log_file)
    current_time = datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S')
    backup_dir = f"{dest_dir}/backup_{current_time}"
    
    try:
        if not os.path.exists(last_backup_dir):
            logger.error(f"Last backup directory '{last_backup_dir}' does not exist.")
            return None
        
        # Copy new or modified files since last backup
        for root, dirs, files in os.walk(source_dir):
            relative_path = os.path.relpath(root, source_dir)
            backup_root = os.path.join(backup_dir, relative_path)
            os.makedirs(backup_root, exist_ok=True)
            for file in files:
                source_file = os.path.join(root, file)
                backup_file = os.path.join(backup_root, file)
                last_backup_file = os.path.join(last_backup_dir, relative_path, file)
                if not os.path.exists(last_backup_file) or os.path.getmtime(source_file) > os.path.getmtime(last_backup_file):
                    shutil.copy2(source_file, backup_file)
        
        logger.info(f"Incremental backup completed successfully. Backup directory: {backup_dir}")
        return backup_dir
    except Exception as e:
        logger.error(f"Incremental backup failed: {e}")
        return None

# Example usage
source_dir = '/path/to/source'
dest_dir = '/path/to/backup'
last_backup_dir = '/path/to/last_backup'
log_file = '/path/to/backup.log'

backup_dir = incremental_backup(source_dir, dest_dir, last_backup_dir, log_file)
if backup_dir:
    update_last_backup_dir(last_backup_dir, backup_dir)