# requirements.txt
# 自動化腳本常用庫
requests>=2.28.0          # 網(wǎng)絡(luò)請求
pandas>=1.5.0             # 數(shù)據(jù)處理
openpyxl>=3.0.0           # Excel操作
selenium>=4.0.0           # 網(wǎng)頁自動化
beautifulsoup4>=4.11.0    # HTML解析
python-docx>=0.8.0        # Word文檔操作
pyautogui>=0.9.0          # 圖形界面自動化
schedule>=1.1.0           # 任務(wù)調(diào)度
pillow>=9.0.0             # 圖像處理
pywin32>=300.0.0          # Windows系統(tǒng)操作

pip install -r requirements.txt

import os
import shutil
import logging
from pathlib import Path
from datetime import datetime

class FileOrganizer:
    """
    智能文件整理器
    自動根據(jù)文件類型分類并整理文件
    """
    
    # 文件類型與文件夾的映射
    FILE_CATEGORIES = {
        'Images': ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.svg', '.webp'],
        'Documents': ['.pdf', '.doc', '.docx', '.txt', '.rtf', '.xlsx', '.pptx'],
        'Audio': ['.mp3', '.wav', '.flac', '.aac', '.ogg'],
        'Video': ['.mp4', '.avi', '.mov', '.wmv', '.flv', '.mkv'],
        'Archives': ['.zip', '.rar', '.7z', '.tar', '.gz'],
        'Code': ['.py', '.js', '.html', '.css', '.java', '.cpp', '.c'],
        'Executables': ['.exe', '.msi', '.dmg', '.pkg']
    }
    
    def __init__(self, target_directory):
        """
        初始化文件整理器
        
        Args:
            target_directory (str): 要整理的目錄路徑
        """
        self.target_dir = Path(target_directory)
        self.setup_logging()
        
    def setup_logging(self):
        """設(shè)置日志記錄"""
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s',
            handlers=[
                logging.FileHandler('file_organizer.log'),
                logging.StreamHandler()
            ]
        )
        self.logger = logging.getLogger(__name__)
    
    def get_file_category(self, file_extension):
        """
        根據(jù)文件擴(kuò)展名獲取文件類別
        
        Args:
            file_extension (str): 文件擴(kuò)展名
            
        Returns:
            str: 文件類別名稱
        """
        for category, extensions in self.FILE_CATEGORIES.items():
            if file_extension.lower() in extensions:
                return category
        return 'Others'
    
    def create_category_folders(self):
        """創(chuàng)建分類文件夾"""
        for category in list(self.FILE_CATEGORIES.keys()) + ['Others']:
            category_path = self.target_dir / category
            category_path.mkdir(exist_ok=True)
    
    def organize_files(self, dry_run=False):
        """
        整理文件
        
        Args:
            dry_run (bool): 是否為試運行模式（不實際移動文件）
            
        Returns:
            dict: 整理統(tǒng)計信息
        """
        self.logger.info(f"開始整理目錄: {self.target_dir}")
        
        if not self.target_dir.exists():
            self.logger.error(f"目錄不存在: {self.target_dir}")
            return {}
        
        # 創(chuàng)建分類文件夾
        self.create_category_folders()
        
        # 統(tǒng)計信息
        stats = {
            'total_files': 0,
            'moved_files': 0,
            'skipped_files': 0,
            'errors': 0,
            'file_categories': {}
        }
        
        try:
            for file_path in self.target_dir.iterdir():
                # 跳過目錄和隱藏文件
                if file_path.is_dir() or file_path.name.startswith('.'):
                    continue
                    
                stats['total_files'] += 1
                file_extension = file_path.suffix
                category = self.get_file_category(file_extension)
                
                # 更新類別統(tǒng)計
                if category not in stats['file_categories']:
                    stats['file_categories'][category] = 0
                stats['file_categories'][category] += 1
                
                # 目標(biāo)路徑
                target_path = self.target_dir / category / file_path.name
                
                # 處理文件名沖突
                counter = 1
                while target_path.exists():
                    stem = file_path.stem
                    new_name = f"{stem}_{counter}{file_extension}"
                    target_path = self.target_dir / category / new_name
                    counter += 1
                
                if dry_run:
                    self.logger.info(f"[試運行] 將移動: {file_path.name} -> {category}/")
                    stats['moved_files'] += 1
                else:
                    try:
                        shutil.move(str(file_path), str(target_path))
                        self.logger.info(f"已移動: {file_path.name} -> {category}/")
                        stats['moved_files'] += 1
                    except Exception as e:
                        self.logger.error(f"移動文件失敗 {file_path.name}: {str(e)}")
                        stats['errors'] += 1
                        
        except Exception as e:
            self.logger.error(f"整理過程發(fā)生錯誤: {str(e)}")
            stats['errors'] += 1
        
        # 記錄統(tǒng)計信息
        self.logger.info(f"整理完成: 總共{stats['total_files']}個文件, "
                        f"移動{stats['moved_files']}個, "
                        f"錯誤{stats['errors']}個")
        
        return stats
    
    def find_duplicate_files(self):
        """
        查找重復(fù)文件
        
        Returns:
            list: 重復(fù)文件組列表
        """
        self.logger.info("開始查找重復(fù)文件...")
        
        file_hashes = {}
        duplicates = []
        
        for file_path in self.target_dir.rglob('*'):
            if file_path.is_file():
                try:
                    # 使用文件大小和修改時間作為初步判斷
                    file_stat = file_path.stat()
                    file_key = (file_stat.st_size, file_stat.st_mtime)
                    
                    if file_key in file_hashes:
                        # 計算MD5進(jìn)行精確比較
                        import hashlib
                        with open(file_path, 'rb') as f:
                            file_hash = hashlib.md5(f.read()).hexdigest()
                        
                        if file_hash in [h for _, h in file_hashes[file_key]]:
                            duplicates.append(str(file_path))
                    else:
                        file_hashes[file_key] = [(str(file_path), file_hash)]
                        
                except Exception as e:
                    self.logger.warning(f"處理文件失敗 {file_path}: {str(e)}")
        
        self.logger.info(f"找到 {len(duplicates)} 個重復(fù)文件")
        return duplicates

# 使用示例
def demo_file_organizer():
    """演示文件整理器的使用"""
    # 初始化整理器（假設(shè)整理下載文件夾）
    organizer = FileOrganizer(r"C:\Users\YourName\Downloads")
    
    # 先進(jìn)行試運行
    print("=== 試運行模式 ===")
    stats = organizer.organize_files(dry_run=True)
    
    # 確認(rèn)后實際執(zhí)行
    user_input = input("\n確認(rèn)執(zhí)行整理？(y/n): ")
    if user_input.lower() == 'y':
        print("=== 實際執(zhí)行 ===")
        stats = organizer.organize_files(dry_run=False)
        
        # 顯示統(tǒng)計信息
        print(f"\n=== 整理統(tǒng)計 ===")
        print(f"總文件數(shù): {stats['total_files']}")
        print(f"移動文件: {stats['moved_files']}")
        print(f"錯誤數(shù)量: {stats['errors']}")
        print("文件分類統(tǒng)計:")
        for category, count in stats['file_categories'].items():
            print(f"  {category}: {count}個文件")
    
    # 查找重復(fù)文件
    print("\n=== 查找重復(fù)文件 ===")
    duplicates = organizer.find_duplicate_files()
    if duplicates:
        print("發(fā)現(xiàn)重復(fù)文件:")
        for dup in duplicates[:5]:  # 只顯示前5個
            print(f"  {dup}")
    else:
        print("未發(fā)現(xiàn)重復(fù)文件")

if __name__ == "__main__":
    demo_file_organizer()

import pandas as pd
import numpy as np
from datetime import datetime, timedelta
import os
import logging
from openpyxl import Workbook
from openpyxl.styles import Font, PatternFill, Alignment
from openpyxl.chart import BarChart, Reference
import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.base import MIMEBase
from email.mime.text import MIMEText
from email import encoders

class ExcelReportGenerator:
    """
    Excel報表自動生成器
    自動從數(shù)據(jù)源生成格式化的Excel報表
    """
    
    def __init__(self, output_path="reports"):
        """
        初始化報表生成器
        
        Args:
            output_path (str): 報表輸出目錄
        """
        self.output_path = Path(output_path)
        self.output_path.mkdir(exist_ok=True)
        self.setup_logging()
    
    def setup_logging(self):
        """設(shè)置日志記錄"""
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s'
        )
        self.logger = logging.getLogger(__name__)
    
    def generate_sample_data(self):
        """
        生成示例銷售數(shù)據(jù)
        
        Returns:
            pd.DataFrame: 銷售數(shù)據(jù)
        """
        np.random.seed(42)
        dates = pd.date_range(start='2024-01-01', end='2024-01-31', freq='D')
        
        data = {
            'date': dates,
            'product': np.random.choice(['Product A', 'Product B', 'Product C'], len(dates)),
            'category': np.random.choice(['Electronics', 'Clothing', 'Books'], len(dates)),
            'sales': np.random.randint(100, 5000, len(dates)),
            'quantity': np.random.randint(1, 100, len(dates)),
            'region': np.random.choice(['North', 'South', 'East', 'West'], len(dates))
        }
        
        df = pd.DataFrame(data)
        df['revenue'] = df['sales'] * df['quantity']
        return df
    
    def create_formatted_excel(self, df, filename):
        """
        創(chuàng)建格式化的Excel報表
        
        Args:
            df (pd.DataFrame): 數(shù)據(jù)框
            filename (str): 輸出文件名
            
        Returns:
            str: 生成的文件路徑
        """
        try:
            # 創(chuàng)建Excel工作簿
            wb = Workbook()
            ws = wb.active
            ws.title = "銷售報表"
            
            # 設(shè)置標(biāo)題
            title = "月度銷售報告 - {}".format(datetime.now().strftime("%Y年%m月"))
            ws['A1'] = title
            ws.merge_cells('A1:F1')
            title_cell = ws['A1']
            title_cell.font = Font(size=16, bold=True)
            title_cell.alignment = Alignment(horizontal='center')
            
            # 添加數(shù)據(jù)
            headers = list(df.columns)
            for col, header in enumerate(headers, 1):
                cell = ws.cell(row=3, column=col, value=header)
                cell.font = Font(bold=True)
                cell.fill = PatternFill(start_color="DDDDDD", end_color="DDDDDD", fill_type="solid")
            
            for row, (_, data_row) in enumerate(df.iterrows(), 4):
                for col, value in enumerate(data_row, 1):
                    ws.cell(row=row, column=col, value=value)
            
            # 添加匯總行
            summary_row = len(df) + 5
            ws.cell(row=summary_row, column=4, value="總計:").font = Font(bold=True)
            ws.cell(row=summary_row, column=5, value=f"=SUM(E4:E{len(df)+3})")
            ws.cell(row=summary_row, column=6, value=f"=SUM(F4:F{len(df)+3})")
            
            # 創(chuàng)建圖表
            self.add_charts(ws, df, len(df) + 8)
            
            # 自動調(diào)整列寬
            for column in ws.columns:
                max_length = 0
                column_letter = column[0].column_letter
                for cell in column:
                    try:
                        if len(str(cell.value)) > max_length:
                            max_length = len(str(cell.value))
                    except:
                        pass
                adjusted_width = (max_length + 2)
                ws.column_dimensions[column_letter].width = adjusted_width
            
            # 保存文件
            filepath = self.output_path / filename
            wb.save(filepath)
            self.logger.info(f"Excel報表已生成: {filepath}")
            
            return str(filepath)
            
        except Exception as e:
            self.logger.error(f"生成Excel報表失敗: {str(e)}")
            return None
    
    def add_charts(self, worksheet, df, start_row):
        """
        添加圖表到工作表
        
        Args:
            worksheet: Excel工作表
            df (pd.DataFrame): 數(shù)據(jù)
            start_row (int): 圖表起始行
        """
        try:
            # 按產(chǎn)品匯總銷售數(shù)據(jù)
            product_sales = df.groupby('product')['sales'].sum().reset_index()
            
            # 創(chuàng)建柱狀圖
            chart = BarChart()
            chart.title = "產(chǎn)品銷售對比"
            chart.x_axis.title = "產(chǎn)品"
            chart.y_axis.title = "銷售額"
            
            # 準(zhǔn)備圖表數(shù)據(jù)
            data = Reference(worksheet, 
                           min_col=5, min_row=3, 
                           max_col=5, max_row=3 + len(product_sales))
            categories = Reference(worksheet,
                                 min_col=2, min_row=4,
                                 max_row=3 + len(product_sales))
            
            chart.add_data(data, titles_from_data=True)
            chart.set_categories(categories)
            
            # 將圖表添加到工作表
            worksheet.add_chart(chart, f"A{start_row}")
            
        except Exception as e:
            self.logger.warning(f"添加圖表失敗: {str(e)}")
    
    def send_report_email(self, filepath, recipient_email):
        """
        發(fā)送報表郵件（需要配置SMTP）
        
        Args:
            filepath (str): 報表文件路徑
            recipient_email (str): 收件人郵箱
        """
        try:
            # 郵件配置（需要根據(jù)實際情況修改）
            smtp_server = "smtp.example.com"
            smtp_port = 587
            sender_email = "reports@company.com"
            sender_password = "password"
            
            # 創(chuàng)建郵件
            msg = MIMEMultipart()
            msg['From'] = sender_email
            msg['To'] = recipient_email
            msg['Subject'] = "月度銷售報告"
            
            # 郵件正文
            body = f"您好，\n\n附件是{datetime.now().strftime('%Y年%m月')}的銷售報告。\n\n此郵件為自動發(fā)送，請勿回復(fù)。"
            msg.attach(MIMEText(body, 'plain'))
            
            # 添加附件
            with open(filepath, "rb") as attachment:
                part = MIMEBase('application', 'octet-stream')
                part.set_payload(attachment.read())
            
            encoders.encode_base64(part)
            part.add_header(
                'Content-Disposition',
                f'attachment; filename= {os.path.basename(filepath)}'
            )
            msg.attach(part)
            
            # 發(fā)送郵件
            server = smtplib.SMTP(smtp_server, smtp_port)
            server.starttls()
            server.login(sender_email, sender_password)
            server.send_message(msg)
            server.quit()
            
            self.logger.info(f"報表郵件已發(fā)送至: {recipient_email}")
            
        except Exception as e:
            self.logger.error(f"發(fā)送郵件失敗: {str(e)}")

# 使用示例
def demo_excel_reporter():
    """演示Excel報表生成器的使用"""
    generator = ExcelReportGenerator()
    
    # 生成示例數(shù)據(jù)
    df = generator.generate_sample_data()
    
    # 生成Excel報表
    filename = f"sales_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
    filepath = generator.create_formatted_excel(df, filename)
    
    if filepath:
        print(f"報表已生成: {filepath}")
        
        # 顯示數(shù)據(jù)統(tǒng)計
        print("\n=== 數(shù)據(jù)統(tǒng)計 ===")
        print(f"總記錄數(shù): {len(df)}")
        print(f"總銷售額: {df['sales'].sum():,}")
        print(f"總收入: {df['revenue'].sum():,}")
        print("\n按產(chǎn)品統(tǒng)計:")
        product_stats = df.groupby('product').agg({
            'sales': ['sum', 'mean', 'count'],
            'revenue': 'sum'
        }).round(2)
        print(product_stats)
    
    return filepath

if __name__ == "__main__":
    demo_excel_reporter()

import requests
from bs4 import BeautifulSoup
import hashlib
import time
import json
import logging
from datetime import datetime
from pathlib import Path
import smtplib
from email.mime.text import MIMEText
import schedule

class WebContentMonitor:
    """
    網(wǎng)頁內(nèi)容監(jiān)控器
    監(jiān)控網(wǎng)頁內(nèi)容變化并發(fā)送通知
    """
    
    def __init__(self, config_file="monitor_config.json"):
        """
        初始化監(jiān)控器
        
        Args:
            config_file (str): 配置文件路徑
        """
        self.config_file = Path(config_file)
        self.monitor_data = self.load_monitor_data()
        self.setup_logging()
    
    def setup_logging(self):
        """設(shè)置日志記錄"""
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s',
            handlers=[
                logging.FileHandler('web_monitor.log'),
                logging.StreamHandler()
            ]
        )
        self.logger = logging.getLogger(__name__)
    
    def load_monitor_data(self):
        """
        加載監(jiān)控數(shù)據(jù)
        
        Returns:
            dict: 監(jiān)控數(shù)據(jù)
        """
        if self.config_file.exists():
            with open(self.config_file, 'r', encoding='utf-8') as f:
                return json.load(f)
        else:
            # 默認(rèn)配置
            default_config = {
                "websites": {},
                "check_interval": 300,  # 5分鐘
                "email_config": {
                    "smtp_server": "smtp.example.com",
                    "smtp_port": 587,
                    "sender_email": "monitor@example.com",
                    "sender_password": "password",
                    "recipient_email": "user@example.com"
                }
            }
            self.save_monitor_data(default_config)
            return default_config
    
    def save_monitor_data(self, data=None):
        """
        保存監(jiān)控數(shù)據(jù)
        
        Args:
            data (dict): 要保存的數(shù)據(jù)
        """
        if data is None:
            data = self.monitor_data
        
        with open(self.config_file, 'w', encoding='utf-8') as f:
            json.dump(data, f, indent=2, ensure_ascii=False)
    
    def add_website(self, name, url, css_selector=None):
        """
        添加要監(jiān)控的網(wǎng)站
        
        Args:
            name (str): 網(wǎng)站名稱
            url (str): 網(wǎng)站URL
            css_selector (str): 要監(jiān)控的CSS選擇器（可選）
        """
        if name not in self.monitor_data["websites"]:
            self.monitor_data["websites"][name] = {
                "url": url,
                "css_selector": css_selector,
                "last_content_hash": "",
                "last_check": None,
                "change_count": 0
            }
            self.save_monitor_data()
            self.logger.info(f"已添加監(jiān)控網(wǎng)站: {name} - {url}")
        else:
            self.logger.warning(f"網(wǎng)站已存在: {name}")
    
    def remove_website(self, name):
        """
        移除監(jiān)控網(wǎng)站
        
        Args:
            name (str): 網(wǎng)站名稱
        """
        if name in self.monitor_data["websites"]:
            del self.monitor_data["websites"][name]
            self.save_monitor_data()
            self.logger.info(f"已移除監(jiān)控網(wǎng)站: {name}")
        else:
            self.logger.warning(f"網(wǎng)站不存在: {name}")
    
    def fetch_web_content(self, url, css_selector=None):
        """
        獲取網(wǎng)頁內(nèi)容
        
        Args:
            url (str): 網(wǎng)頁URL
            css_selector (str): CSS選擇器
            
        Returns:
            str: 網(wǎng)頁內(nèi)容
        """
        try:
            headers = {
                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
            }
            response = requests.get(url, headers=headers, timeout=10)
            response.raise_for_status()
            
            if css_selector:
                soup = BeautifulSoup(response.content, 'html.parser')
                elements = soup.select(css_selector)
                content = "\n".join([elem.get_text(strip=True) for elem in elements])
            else:
                content = response.text
            
            return content
            
        except requests.RequestException as e:
            self.logger.error(f"獲取網(wǎng)頁內(nèi)容失敗 {url}: {str(e)}")
            return None
    
    def calculate_content_hash(self, content):
        """
        計算內(nèi)容哈希值
        
        Args:
            content (str): 內(nèi)容
            
        Returns:
            str: 哈希值
        """
        return hashlib.md5(content.encode('utf-8')).hexdigest()
    
    def check_website_changes(self):
        """
        檢查所有網(wǎng)站的內(nèi)容變化
        """
        self.logger.info("開始檢查網(wǎng)站內(nèi)容變化...")
        changes_detected = []
        
        for name, site_info in self.monitor_data["websites"].items():
            self.logger.info(f"檢查網(wǎng)站: {name}")
            
            content = self.fetch_web_content(site_info["url"], site_info["css_selector"])
            if content is None:
                continue
            
            current_hash = self.calculate_content_hash(content)
            last_hash = site_info["last_content_hash"]
            
            # 更新最后檢查時間
            site_info["last_check"] = datetime.now().isoformat()
            
            if last_hash and current_hash != last_hash:
                # 檢測到變化
                site_info["change_count"] += 1
                site_info["last_content_hash"] = current_hash
                
                change_info = {
                    "name": name,
                    "url": site_info["url"],
                    "timestamp": datetime.now().isoformat(),
                    "change_count": site_info["change_count"]
                }
                changes_detected.append(change_info)
                
                self.logger.info(f"檢測到變化: {name}")
                
                # 發(fā)送通知
                self.send_change_notification(change_info, content)
            
            elif not last_hash:
                # 第一次檢查，保存初始哈希
                site_info["last_content_hash"] = current_hash
                self.logger.info(f"初始監(jiān)控設(shè)置完成: {name}")
        
        # 保存更新后的數(shù)據(jù)
        self.save_monitor_data()
        
        if changes_detected:
            self.logger.info(f"檢測到 {len(changes_detected)} 個網(wǎng)站有變化")
        else:
            self.logger.info("未檢測到變化")
        
        return changes_detected
    
    def send_change_notification(self, change_info, new_content):
        """
        發(fā)送變化通知
        
        Args:
            change_info (dict): 變化信息
            new_content (str): 新內(nèi)容
        """
        try:
            email_config = self.monitor_data["email_config"]
            
            # 創(chuàng)建郵件內(nèi)容
            subject = f"網(wǎng)頁內(nèi)容變化通知 - {change_info['name']}"
            body = f"""
            檢測到網(wǎng)頁內(nèi)容發(fā)生變化：
            
            網(wǎng)站名稱: {change_info['name']}
            網(wǎng)址: {change_info['url']}
            變化時間: {change_info['timestamp']}
            變化次數(shù): {change_info['change_count']}
            
            新內(nèi)容預(yù)覽:
            {new_content[:500]}...
            
            ---
            此郵件由網(wǎng)頁內(nèi)容監(jiān)控器自動發(fā)送
            """
            
            msg = MIMEText(body, 'plain', 'utf-8')
            msg['Subject'] = subject
            msg['From'] = email_config["sender_email"]
            msg['To'] = email_config["recipient_email"]
            
            # 發(fā)送郵件
            server = smtplib.SMTP(email_config["smtp_server"], email_config["smtp_port"])
            server.starttls()
            server.login(email_config["sender_email"], email_config["sender_password"])
            server.send_message(msg)
            server.quit()
            
            self.logger.info(f"變化通知已發(fā)送: {change_info['name']}")
            
        except Exception as e:
            self.logger.error(f"發(fā)送通知失敗: {str(e)}")
    
    def start_monitoring(self):
        """開始定時監(jiān)控"""
        interval = self.monitor_data["check_interval"]
        
        self.logger.info(f"開始定時監(jiān)控，檢查間隔: {interval}秒")
        
        # 安排定時任務(wù)
        schedule.every(interval).seconds.do(self.check_website_changes)
        
        # 立即執(zhí)行一次檢查
        self.check_website_changes()
        
        # 保持程序運行
        try:
            while True:
                schedule.run_pending()
                time.sleep(1)
        except KeyboardInterrupt:
            self.logger.info("監(jiān)控已停止")

# 使用示例
def demo_web_monitor():
    """演示網(wǎng)頁監(jiān)控器的使用"""
    monitor = WebContentMonitor()
    
    # 添加要監(jiān)控的網(wǎng)站
    monitor.add_website(
        "Python官網(wǎng)",
        "https://www.python.org",
        ".introduction"  # 只監(jiān)控介紹部分
    )
    
    monitor.add_website(
        "GitHub動態(tài)",
        "https://github.com/trending",
        ".Box-row"  # 監(jiān)控趨勢項目
    )
    
    # 執(zhí)行一次檢查
    print("=== 執(zhí)行首次檢查 ===")
    changes = monitor.check_website_changes()
    
    if changes:
        print(f"檢測到 {len(changes)} 個變化:")
        for change in changes:
            print(f"  - {change['name']}: 第{change['change_count']}次變化")
    else:
        print("未檢測到變化")
    
    # 顯示監(jiān)控狀態(tài)
    print("\n=== 監(jiān)控狀態(tài) ===")
    for name, info in monitor.monitor_data["websites"].items():
        status = "已初始化" if info["last_content_hash"] else "待初始化"
        print(f"  {name}: {status}")

if __name__ == "__main__":
    demo_web_monitor()

import imaplib
import email
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
import time
import re
import logging
from datetime import datetime
import json
from pathlib import Path

class AutoEmailResponder:
    """
    郵件自動回復(fù)器
    自動處理常見咨詢郵件并發(fā)送預(yù)設(shè)回復(fù)
    """
    
    def __init__(self, config_file="email_config.json"):
        """
        初始化自動回復(fù)器
        
        Args:
            config_file (str): 配置文件路徑
        """
        self.config_file = Path(config_file)
        self.config = self.load_config()
        self.setup_logging()
        self.processed_emails = set()
    
    def setup_logging(self):
        """設(shè)置日志記錄"""
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s',
            handlers=[
                logging.FileHandler('auto_responder.log'),
                logging.StreamHandler()
            ]
        )
        self.logger = logging.getLogger(__name__)
    
    def load_config(self):
        """
        加載配置
        
        Returns:
            dict: 配置信息
        """
        if self.config_file.exists():
            with open(self.config_file, 'r', encoding='utf-8') as f:
                return json.load(f)
        else:
            # 默認(rèn)配置
            default_config = {
                "imap_server": "imap.example.com",
                "imap_port": 993,
                "smtp_server": "smtp.example.com",
                "smtp_port": 587,
                "email": "your_email@example.com",
                "password": "your_password",
                "check_interval": 300,
                "auto_replies": {
                    "price_inquiry": {
                        "keywords": ["價格", "多少錢", "報價", "cost", "price"],
                        "subject": "關(guān)于產(chǎn)品價格的回復(fù)",
                        "template": """尊敬的客戶，

感謝您對我們產(chǎn)品的關(guān)注。

我們的產(chǎn)品價格根據(jù)配置不同有所差異，具體如下：
- 基礎(chǔ)版: ￥999
- 專業(yè)版: ￥1999
- 企業(yè)版: ￥3999

如需詳細(xì)報價單，請告知您的具體需求。

祝好！
{company_name}團(tuán)隊"""
                    },
                    "technical_support": {
                        "keywords": ["問題", "錯誤", "幫助", "怎么用", "problem", "error", "help"],
                        "subject": "技術(shù)支持回復(fù)",
                        "template": """尊敬的客戶，

感謝您聯(lián)系我們。

我們已經(jīng)收到您的技術(shù)咨詢，我們的技術(shù)支持團(tuán)隊將在24小時內(nèi)為您提供詳細(xì)解答。

常見問題解決方案可以參考我們的幫助文檔：
{help_url}

祝您使用愉快！
{company_name}技術(shù)支持團(tuán)隊"""
                    },
                    "general_inquiry": {
                        "keywords": ["咨詢", "了解", "信息", "inquiry", "information"],
                        "subject": "感謝您的咨詢",
                        "template": """尊敬的客戶，

感謝您對我們的關(guān)注和咨詢。

我們已經(jīng)收到您的消息，相關(guān)業(yè)務(wù)人員會盡快與您聯(lián)系，為您提供詳細(xì)的信息。

您也可以通過以下方式聯(lián)系我們：
- 電話：{phone}
- 官網(wǎng)：{website}

期待與您的合作！
{company_name}團(tuán)隊"""
                    }
                },
                "company_info": {
                    "company_name": "您的公司",
                    "phone": "400-123-4567",
                    "website": "https://www.example.com",
                    "help_url": "https://help.example.com"
                }
            }
            self.save_config(default_config)
            return default_config
    
    def save_config(self, config=None):
        """
        保存配置
        
        Args:
            config (dict): 配置信息
        """
        if config is None:
            config = self.config
        
        with open(self.config_file, 'w', encoding='utf-8') as f:
            json.dump(config, f, indent=2, ensure_ascii=False)
    
    def connect_to_email(self):
        """
        連接到郵箱服務(wù)器
        
        Returns:
            tuple: (imap_connection, smtp_connection) 或 (None, None) 如果失敗
        """
        try:
            # 連接到IMAP服務(wù)器
            imap = imaplib.IMAP4_SSL(self.config["imap_server"], self.config["imap_port"])
            imap.login(self.config["email"], self.config["password"])
            
            # 連接到SMTP服務(wù)器
            smtp = smtplib.SMTP(self.config["smtp_server"], self.config["smtp_port"])
            smtp.starttls()
            smtp.login(self.config["email"], self.config["password"])
            
            self.logger.info("成功連接到郵箱服務(wù)器")
            return imap, smtp
            
        except Exception as e:
            self.logger.error(f"連接郵箱服務(wù)器失敗: {str(e)}")
            return None, None
    
    def classify_email(self, subject, body):
        """
        分類郵件內(nèi)容
        
        Args:
            subject (str): 郵件主題
            body (str): 郵件正文
            
        Returns:
            str: 郵件類型
        """
        content = (subject + " " + body).lower()
        
        for reply_type, reply_config in self.config["auto_replies"].items():
            for keyword in reply_config["keywords"]:
                if keyword.lower() in content:
                    return reply_type
        
        return "general_inquiry"  # 默認(rèn)回復(fù)類型
    
    def generate_reply(self, original_subject, reply_type, sender_name=""):
        """
        生成回復(fù)內(nèi)容
        
        Args:
            original_subject (str): 原始郵件主題
            reply_type (str): 回復(fù)類型
            sender_name (str): 發(fā)件人姓名
            
        Returns:
            tuple: (回復(fù)主題, 回復(fù)內(nèi)容)
        """
        if reply_type not in self.config["auto_replies"]:
            reply_type = "general_inquiry"
        
        reply_config = self.config["auto_replies"][reply_type]
        company_info = self.config["company_info"]
        
        # 個性化問候
        greeting = "尊敬的客戶"
        if sender_name:
            greeting = f"尊敬的{sender_name}"
        
        # 生成回復(fù)內(nèi)容
        template = reply_config["template"]
        reply_content = template.format(
            greeting=greeting,
            company_name=company_info["company_name"],
            phone=company_info["phone"],
            website=company_info["website"],
            help_url=company_info["help_url"]
        )
        
        # 生成回復(fù)主題
        reply_subject = f"Re: {original_subject}"
        if reply_config["subject"]:
            reply_subject = reply_config["subject"]
        
        return reply_subject, reply_content
    
    def extract_sender_name(self, from_header):
        """
        從發(fā)件人信息中提取姓名
        
        Args:
            from_header (str): 發(fā)件人頭信息
            
        Returns:
            str: 發(fā)件人姓名
        """
        # 簡單的姓名提取邏輯
        match = re.search(r'([^<]+)<', from_header)
        if match:
            name = match.group(1).strip().strip('"\'')
            if name:
                return name
        
        # 如果無法提取姓名，返回空字符串
        return ""
    
    def process_new_emails(self, imap, smtp):
        """
        處理新郵件
        
        Args:
            imap: IMAP連接
            smtp: SMTP連接
            
        Returns:
            int: 處理的郵件數(shù)量
        """
        try:
            # 選擇收件箱
            imap.select("INBOX")
            
            # 搜索未讀郵件
            status, messages = imap.search(None, 'UNSEEN')
            if status != 'OK':
                self.logger.warning("搜索郵件失敗")
                return 0
            
            email_ids = messages[0].split()
            processed_count = 0
            
            for email_id in email_ids:
                try:
                    # 獲取郵件內(nèi)容
                    status, msg_data = imap.fetch(email_id, '(RFC822)')
                    if status != 'OK':
                        continue
                    
                    raw_email = msg_data[0][1]
                    msg = email.message_from_bytes(raw_email)
                    
                    # 獲取郵件信息
                    subject = msg.get('Subject', '')
                    from_header = msg.get('From', '')
                    message_id = msg.get('Message-ID', '')
                    
                    # 跳過已處理的郵件
                    if message_id in self.processed_emails:
                        continue
                    
                    # 提取發(fā)件人姓名
                    sender_name = self.extract_sender_name(from_header)
                    
                    # 提取郵件正文
                    body = ""
                    if msg.is_multipart():
                        for part in msg.walk():
                            content_type = part.get_content_type()
                            content_disposition = str(part.get("Content-Disposition"))
                            
                            if content_type == "text/plain" and "attachment" not in content_disposition:
                                body = part.get_payload(decode=True).decode('utf-8', errors='ignore')
                                break
                    else:
                        body = msg.get_payload(decode=True).decode('utf-8', errors='ignore')
                    
                    # 分類郵件并生成回復(fù)
                    email_type = self.classify_email(subject, body)
                    reply_subject, reply_content = self.generate_reply(subject, email_type, sender_name)
                    
                    # 發(fā)送回復(fù)
                    self.send_reply(smtp, from_header, reply_subject, reply_content)
                    
                    # 標(biāo)記為已處理
                    self.processed_emails.add(message_id)
                    processed_count += 1
                    
                    self.logger.info(f"已處理郵件: {subject[:50]}...")
                    
                except Exception as e:
                    self.logger.error(f"處理郵件失敗 {email_id}: {str(e)}")
            
            return processed_count
            
        except Exception as e:
            self.logger.error(f"處理新郵件過程失敗: {str(e)}")
            return 0
    
    def send_reply(self, smtp, to_address, subject, content):
        """
        發(fā)送回復(fù)郵件
        
        Args:
            smtp: SMTP連接
            to_address (str): 收件人地址
            subject (str): 郵件主題
            content (str): 郵件內(nèi)容
        """
        try:
            msg = MIMEMultipart()
            msg['From'] = self.config["email"]
            msg['To'] = to_address
            msg['Subject'] = subject
            
            # 添加郵件正文
            msg.attach(MIMEText(content, 'plain', 'utf-8'))
            
            # 發(fā)送郵件
            smtp.send_message(msg)
            self.logger.info(f"已發(fā)送回復(fù)至: {to_address}")
            
        except Exception as e:
            self.logger.error(f"發(fā)送回復(fù)失敗: {str(e)}")
    
    def start_auto_responder(self):
        """啟動自動回復(fù)器"""
        self.logger.info("啟動郵件自動回復(fù)器")
        
        check_interval = self.config["check_interval"]
        
        while True:
            try:
                self.logger.info("檢查新郵件...")
                
                imap, smtp = self.connect_to_email()
                if imap and smtp:
                    processed = self.process_new_emails(imap, smtp)
                    self.logger.info(f"處理了 {processed} 封新郵件")
                    
                    # 關(guān)閉連接
                    imap.close()
                    imap.logout()
                    smtp.quit()
                
                # 等待下次檢查
                time.sleep(check_interval)
                
            except KeyboardInterrupt:
                self.logger.info("自動回復(fù)器已停止")
                break
            except Exception as e:
                self.logger.error(f"自動回復(fù)器運行錯誤: {str(e)}")
                time.sleep(check_interval)

# 使用示例
def demo_auto_responder():
    """演示自動回復(fù)器的使用"""
    responder = AutoEmailResponder()
    
    print("=== 郵件自動回復(fù)器配置 ===")
    print("當(dāng)前配置的自動回復(fù)類型:")
    for reply_type, config in responder.config["auto_replies"].items():
        print(f"  {reply_type}: {len(config['keywords'])}個關(guān)鍵詞")
    
    print("\n公司信息:")
    for key, value in responder.config["company_info"].items():
        print(f"  {key}: {value}")
    
    print(f"\n檢查間隔: {responder.config['check_interval']}秒")
    
    # 注意：實際使用時需要先配置正確的郵箱信息
    print("\n注意：請先編輯 email_config.json 文件配置正確的郵箱信息")

if __name__ == "__main__":
    demo_auto_responder()

import psutil
import logging
import json
from datetime import datetime, timedelta
from pathlib import Path
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
import schedule
import time

class SystemHealthMonitor:
    """
    系統(tǒng)健康監(jiān)控器
    監(jiān)控系統(tǒng)資源使用情況并生成健康報告
    """
    
    def __init__(self, config_file="system_monitor_config.json"):
        """
        初始化系統(tǒng)監(jiān)控器
        
        Args:
            config_file (str): 配置文件路徑
        """
        self.config_file = Path(config_file)
        self.config = self.load_config()
        self.health_data = []
        self.setup_logging()
    
    def setup_logging(self):
        """設(shè)置日志記錄"""
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s',
            handlers=[
                logging.FileHandler('system_monitor.log'),
                logging.StreamHandler()
            ]
        )
        self.logger = logging.getLogger(__name__)
    
    def load_config(self):
        """
        加載配置
        
        Returns:
            dict: 配置信息
        """
        if self.config_file.exists():
            with open(self.config_file, 'r', encoding='utf-8') as f:
                return json.load(f)
        else:
            # 默認(rèn)配置
            default_config = {
                "monitor_interval": 60,  # 監(jiān)控間隔（秒）
                "alert_thresholds": {
                    "cpu_percent": 80,
                    "memory_percent": 85,
                    "disk_percent": 90,
                    "temperature": 80
                },
                "report_interval": 3600,  # 報告間隔（秒）
                "email_alerts": {
                    "enabled": False,
                    "smtp_server": "smtp.example.com",
                    "smtp_port": 587,
                    "sender_email": "monitor@example.com",
                    "sender_password": "password",
                    "recipient_email": "admin@example.com"
                },
                "log_retention_days": 7
            }
            self.save_config(default_config)
            return default_config
    
    def save_config(self, config=None):
        """
        保存配置
        
        Args:
            config (dict): 配置信息
        """
        if config is None:
            config = self.config
        
        with open(self.config_file, 'w', encoding='utf-8') as f:
            json.dump(config, f, indent=2, ensure_ascii=False)
    
    def collect_system_metrics(self):
        """
        收集系統(tǒng)指標(biāo)
        
        Returns:
            dict: 系統(tǒng)指標(biāo)數(shù)據(jù)
        """
        try:
            # CPU使用率
            cpu_percent = psutil.cpu_percent(interval=1)
            
            # 內(nèi)存使用情況
            memory = psutil.virtual_memory()
            
            # 磁盤使用情況
            disk = psutil.disk_usage('/')
            
            # 網(wǎng)絡(luò)IO
            net_io = psutil.net_io_counters()
            
            # 系統(tǒng)啟動時間
            boot_time = datetime.fromtimestamp(psutil.boot_time())
            
            # 溫度信息（如果可用）
            try:
                temperatures = psutil.sensors_temperatures()
                if temperatures:
                    cpu_temp = temperatures.get('coretemp', [{}])[0].current if 'coretemp' in temperatures else None
                else:
                    cpu_temp = None
            except:
                cpu_temp = None
            
            metrics = {
                'timestamp': datetime.now().isoformat(),
                'cpu': {
                    'percent': cpu_percent,
                    'cores': psutil.cpu_count(),
                    'frequency': psutil.cpu_freq().current if psutil.cpu_freq() else None
                },
                'memory': {
                    'total': memory.total,
                    'available': memory.available,
                    'used': memory.used,
                    'percent': memory.percent
                },
                'disk': {
                    'total': disk.total,
                    'used': disk.used,
                    'free': disk.free,
                    'percent': disk.percent
                },
                'network': {
                    'bytes_sent': net_io.bytes_sent,
                    'bytes_recv': net_io.bytes_recv
                },
                'system': {
                    'boot_time': boot_time.isoformat(),
                    'temperature': cpu_temp
                }
            }
            
            return metrics
            
        except Exception as e:
            self.logger.error(f"收集系統(tǒng)指標(biāo)失敗: {str(e)}")
            return None
    
    def check_health_status(self, metrics):
        """
        檢查系統(tǒng)健康狀態(tài)
        
        Args:
            metrics (dict): 系統(tǒng)指標(biāo)
            
        Returns:
            dict: 健康狀態(tài)信息
        """
        alerts = []
        status = "healthy"
        
        thresholds = self.config["alert_thresholds"]
        
        # 檢查CPU使用率
        if metrics['cpu']['percent'] > thresholds['cpu_percent']:
            alerts.append(f"CPU使用率過高: {metrics['cpu']['percent']}%")
            status = "warning"
        
        # 檢查內(nèi)存使用率
        if metrics['memory']['percent'] > thresholds['memory_percent']:
            alerts.append(f"內(nèi)存使用率過高: {metrics['memory']['percent']}%")
            status = "warning"
        
        # 檢查磁盤使用率
        if metrics['disk']['percent'] > thresholds['disk_percent']:
            alerts.append(f"磁盤使用率過高: {metrics['disk']['percent']}%")
            status = "warning"
        
        # 檢查溫度
        if (metrics['system']['temperature'] and 
            metrics['system']['temperature'] > thresholds['temperature']):
            alerts.append(f"溫度過高: {metrics['system']['temperature']}°C")
            status = "critical"
        
        health_status = {
            'status': status,
            'alerts': alerts,
            'timestamp': metrics['timestamp']
        }
        
        return health_status
    
    def send_alert_email(self, health_status, metrics):
        """
        發(fā)送警報郵件
        
        Args:
            health_status (dict): 健康狀態(tài)
            metrics (dict): 系統(tǒng)指標(biāo)
        """
        if not self.config["email_alerts"]["enabled"]:
            return
        
        try:
            email_config = self.config["email_alerts"]
            
            # 創(chuàng)建郵件
            msg = MIMEMultipart()
            msg['From'] = email_config["sender_email"]
            msg['To'] = email_config["recipient_email"]
            msg['Subject'] = f"系統(tǒng)健康警報 - {health_status['status'].upper()}"
            
            # 郵件正文
            body = f"""
系統(tǒng)健康監(jiān)控警報

狀態(tài): {health_status['status'].upper()}
時間: {health_status['timestamp']}

警報信息:
{chr(10).join(health_status['alerts'])}

系統(tǒng)指標(biāo)概覽:
- CPU使用率: {metrics['cpu']['percent']}%
- 內(nèi)存使用率: {metrics['memory']['percent']}%
- 磁盤使用率: {metrics['disk']['percent']}%
- 系統(tǒng)溫度: {metrics['system']['temperature'] or 'N/A'}°C

請及時檢查系統(tǒng)狀態(tài)。

---
此郵件由系統(tǒng)健康監(jiān)控器自動發(fā)送
"""
            
            msg.attach(MIMEText(body, 'plain', 'utf-8'))
            
            # 發(fā)送郵件
            server = smtplib.SMTP(email_config["smtp_server"], email_config["smtp_port"])
            server.starttls()
            server.login(email_config["sender_email"], email_config["sender_password"])
            server.send_message(msg)
            server.quit()
            
            self.logger.info("警報郵件已發(fā)送")
            
        except Exception as e:
            self.logger.error(f"發(fā)送警報郵件失敗: {str(e)}")
    
    def generate_health_report(self, hours=24):
        """
        生成健康報告
        
        Args:
            hours (int): 報告覆蓋的小時數(shù)
            
        Returns:
            dict: 健康報告
        """
        # 過濾指定時間范圍內(nèi)的數(shù)據(jù)
        cutoff_time = datetime.now() - timedelta(hours=hours)
        recent_data = [
            data for data in self.health_data 
            if datetime.fromisoformat(data['timestamp']) > cutoff_time
        ]
        
        if not recent_data:
            return {"error": "沒有足夠的數(shù)據(jù)生成報告"}
        
        # 計算統(tǒng)計信息
        cpu_values = [data['metrics']['cpu']['percent'] for data in recent_data]
        memory_values = [data['metrics']['memory']['percent'] for data in recent_data]
        disk_values = [data['metrics']['disk']['percent'] for data in recent_data]
        
        report = {
            'report_time': datetime.now().isoformat(),
            'period_hours': hours,
            'data_points': len(recent_data),
            'summary': {
                'cpu': {
                    'average': sum(cpu_values) / len(cpu_values),
                    'max': max(cpu_values),
                    'min': min(cpu_values)
                },
                'memory': {
                    'average': sum(memory_values) / len(memory_values),
                    'max': max(memory_values),
                    'min': min(memory_values)
                },
                'disk': {
                    'average': sum(disk_values) / len(disk_values),
                    'max': max(disk_values),
                    'min': min(disk_values)
                }
            },
            'alerts_count': len([data for data in recent_data if data['health']['status'] != 'healthy']),
            'status_distribution': {
                'healthy': len([data for data in recent_data if data['health']['status'] == 'healthy']),
                'warning': len([data for data in recent_data if data['health']['status'] == 'warning']),
                'critical': len([data for data in recent_data if data['health']['status'] == 'critical'])
            }
        }
        
        return report
    
    def monitor_cycle(self):
        """執(zhí)行一次監(jiān)控循環(huán)"""
        self.logger.info("執(zhí)行系統(tǒng)健康檢查...")
        
        # 收集指標(biāo)
        metrics = self.collect_system_metrics()
        if not metrics:
            return
        
        # 檢查健康狀態(tài)
        health_status = self.check_health_status(metrics)
        
        # 存儲數(shù)據(jù)
        monitor_data = {
            'timestamp': datetime.now().isoformat(),
            'metrics': metrics,
            'health': health_status
        }
        self.health_data.append(monitor_data)
        
        # 清理舊數(shù)據(jù)
        retention_days = self.config.get("log_retention_days", 7)
        cutoff_time = datetime.now() - timedelta(days=retention_days)
        self.health_data = [
            data for data in self.health_data 
            if datetime.fromisoformat(data['timestamp']) > cutoff_time
        ]
        
        # 記錄狀態(tài)
        if health_status['status'] != 'healthy':
            self.logger.warning(f"系統(tǒng)狀態(tài): {health_status['status']} - {', '.join(health_status['alerts'])}")
            
            # 發(fā)送警報
            if health_status['status'] in ['warning', 'critical']:
                self.send_alert_email(health_status, metrics)
        else:
            self.logger.info("系統(tǒng)狀態(tài): 健康")
    
    def start_monitoring(self):
        """開始監(jiān)控"""
        self.logger.info("啟動系統(tǒng)健康監(jiān)控器")
        
        interval = self.config["monitor_interval"]
        report_interval = self.config["report_interval"]
        
        # 安排監(jiān)控任務(wù)
        schedule.every(interval).seconds.do(self.monitor_cycle)
        
        # 安排報告任務(wù)
        schedule.every(report_interval).seconds.do(self.generate_daily_report)
        
        # 立即執(zhí)行一次監(jiān)控
        self.monitor_cycle()
        
        # 保持程序運行
        try:
            while True:
                schedule.run_pending()
                time.sleep(1)
        except KeyboardInterrupt:
            self.logger.info("系統(tǒng)監(jiān)控已停止")
    
    def generate_daily_report(self):
        """生成每日報告"""
        report = self.generate_health_report(24)
        
        # 保存報告到文件
        report_file = Path(f"system_health_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json")
        with open(report_file, 'w', encoding='utf-8') as f:
            json.dump(report, f, indent=2, ensure_ascii=False)
        
        self.logger.info(f"健康報告已生成: {report_file}")

# 使用示例
def demo_system_monitor():
    """演示系統(tǒng)監(jiān)控器的使用"""
    monitor = SystemHealthMonitor()
    
    print("=== 系統(tǒng)健康監(jiān)控器 ===")
    
    # 收集一次系統(tǒng)指標(biāo)
    metrics = monitor.collect_system_metrics()
    if metrics:
        print("\n當(dāng)前系統(tǒng)狀態(tài):")
        print(f"CPU使用率: {metrics['cpu']['percent']}%")
        print(f"內(nèi)存使用率: {metrics['memory']['percent']}%")
        print(f"磁盤使用率: {metrics['disk']['percent']}%")
        if metrics['system']['temperature']:
            print(f"CPU溫度: {metrics['system']['temperature']}°C")
        
        # 檢查健康狀態(tài)
        health_status = monitor.check_health_status(metrics)
        print(f"\n健康狀態(tài): {health_status['status']}")
        if health_status['alerts']:
            print("警報:")
            for alert in health_status['alerts']:
                print(f"  - {alert}")
    
    print(f"\n監(jiān)控配置:")
    print(f"檢查間隔: {monitor.config['monitor_interval']}秒")
    print(f"報告間隔: {monitor.config['report_interval']}秒")
    print("警報閾值:")
    for metric, threshold in monitor.config['alert_thresholds'].items():
        print(f"  {metric}: {threshold}")

if __name__ == "__main__":
    demo_system_monitor()

"""
10個效率翻倍的Python自動化腳本 - 完整代碼集合
作者: AI助手
日期: 2024年
"""

import os
import shutil
import logging
import pandas as pd
import numpy as np
import requests
from bs4 import BeautifulSoup
import hashlib
import time
import json
import smtplib
import imaplib
import email
import psutil
import schedule
from datetime import datetime, timedelta
from pathlib import Path
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from email import encoders
import re

# 所有腳本的導(dǎo)入和類定義都在上面各節(jié)中提供
# 這里省略重復(fù)的代碼以節(jié)省空間

def main():
    """主函數(shù) - 演示所有腳本的使用"""
    print("=== Python自動化腳本集合 ===")
    print("請選擇要演示的腳本:")
    print("1. 智能文件整理腳本")
    print("2. Excel報表自動生成器")
    print("3. 網(wǎng)頁內(nèi)容監(jiān)控器")
    print("4. 郵件自動回復(fù)器")
    print("5. 系統(tǒng)健康監(jiān)控器")
    print("6. 退出")
    
    while True:
        choice = input("\n請輸入選擇 (1-6): ").strip()
        
        if choice == '1':
            print("\n--- 智能文件整理腳本演示 ---")
            # 這里調(diào)用文件整理腳本的演示函數(shù)
            demo_file_organizer()
            
        elif choice == '2':
            print("\n--- Excel報表自動生成器演示 ---")
            # 這里調(diào)用Excel報表生成器的演示函數(shù)
            demo_excel_reporter()
            
        elif choice == '3':
            print("\n--- 網(wǎng)頁內(nèi)容監(jiān)控器演示 ---")
            # 這里調(diào)用網(wǎng)頁監(jiān)控器的演示函數(shù)
            demo_web_monitor()
            
        elif choice == '4':
            print("\n--- 郵件自動回復(fù)器演示 ---")
            # 這里調(diào)用郵件回復(fù)器的演示函數(shù)
            demo_auto_responder()
            
        elif choice == '5':
            print("\n--- 系統(tǒng)健康監(jiān)控器演示 ---")
            # 這里調(diào)用系統(tǒng)監(jiān)控器的演示函數(shù)
            demo_system_monitor()
            
        elif choice == '6':
            print("謝謝使用！")
            break
            
        else:
            print("無效選擇，請重新輸入。")

if __name__ == "__main__":
    main()