import sys
# 導(dǎo)入logging模塊，用于記錄程序運行時的日志信息
import logging
# 從watchdog.observers模塊中導(dǎo)入Observer類，用于監(jiān)控文件系統(tǒng)的變化
from watchdog.observers import Observer
# 從watchdog.events模塊中導(dǎo)入LoggingEventHandler類，用于處理文件系統(tǒng)事件并記錄日志
from watchdog.events import LoggingEventHandler

if __name__ == "__main__":
    # 配置日志記錄的基本設(shè)置
    # level=logging.INFO表示只記錄INFO級別及以上的日志信息
    # format='%(asctime)s - %(message)s'指定日志的輸出格式，包含時間戳和日志消息
    # datefmt='%Y-%m-%d %H:%M:%S'指定時間戳的格式
    logging.basicConfig(level=logging.INFO,
                        format='%(asctime)s - %(message)s',
                        datefmt='%Y-%m-%d %H:%M:%S')
    # 指定要監(jiān)控的文件夾路徑，該文件夾必須存在
    path = "demo_folder"
    # 創(chuàng)建一個LoggingEventHandler對象，用于處理文件系統(tǒng)事件并記錄日志
    event_handler = LoggingEventHandler()
    # 創(chuàng)建一個Observer對象，用于監(jiān)控文件系統(tǒng)的變化
    observer = Observer()
    # 安排觀察者監(jiān)控指定路徑下的文件系統(tǒng)事件
    # event_handler是事件處理程序
    # path是要監(jiān)控的路徑
    # recursive=True表示遞歸監(jiān)控該路徑下的所有子文件夾
    observer.schedule(event_handler, path, recursive=True)
    # 啟動觀察者，開始監(jiān)控文件系統(tǒng)的變化
    observer.start()
    try:
        # 當(dāng)觀察者處于活動狀態(tài)時，持續(xù)循環(huán)
        while observer.is_alive():
            # 等待1秒，讓觀察者有時間處理文件系統(tǒng)事件
            observer.join(1)
    finally:
        # 停止觀察者，結(jié)束文件系統(tǒng)的監(jiān)控
        observer.stop()
        # 等待觀察者線程結(jié)束
        observer.join()

# 該類用于處理文件系統(tǒng)事件，如文件的創(chuàng)建、刪除、修改等
from watchdog.events import FileSystemEventHandler
from watchdog.observers import Observer

# 定義一個自定義的文件事件處理類，繼承自FileSystemEventHandler
class FileEventHandler(FileSystemEventHandler):
    def __init__(self):
        FileSystemEventHandler.__init__(self)
        # 初始化一個空列表，用于存儲文件名
        self.file_names = []  

    # 當(dāng)文件或目錄被移動時觸發(fā)此方法
    def on_moved(self, event):
        # 判斷是否是目錄移動
        if event.is_directory:
            # 打印目錄移動的信息
            print(f"目錄從 {event.src_path} 移動到 {event.dest_path}")
        else:
            # 打印文件移動的信息
            print(f"文件從 {event.src_path} 移動到 {event.dest_path}")

    # 當(dāng)文件或目錄被創(chuàng)建時觸發(fā)此方法
    def on_created(self, event):
        # 判斷是否是目錄創(chuàng)建
        if event.is_directory:
            # 打印目錄創(chuàng)建的信息
            print(f"目錄已創(chuàng)建: {event.src_path}")
        else:
            # 打印文件創(chuàng)建的信息
            print(f"文件已創(chuàng)建: {event.src_path}")
            # 從文件的完整路徑中提取文件名
            file_full_name = str(event.src_path.split('/')[-1])
            if file_full_name.endswith('.csv'):
                # 如果是csv文件，將其添加到文件名列表中
                self.file_names.append(file_full_name)
            # 打印文件名列表
            print(self.file_names)

    # 當(dāng)文件或目錄被刪除時觸發(fā)此方法
    def on_deleted(self, event):
        # 判斷是否是目錄刪除
        if event.is_directory:
            # 打印目錄刪除的信息
            print(f"目錄已刪除: {event.src_path}")
        else:
            # 打印文件刪除的信息
            print(f"文件已刪除: {event.src_path}")

    # 當(dāng)文件或目錄被修改時觸發(fā)此方法，注釋代碼表示不觸發(fā)修改事件
    # def on_modified(self, event):
    #     pass

if __name__ == "__main__":
    # 創(chuàng)建一個Observer對象，用于監(jiān)控文件系統(tǒng)的變化
    observer = Observer()
    # 創(chuàng)建一個自定義的文件事件處理對象
    event_handler = FileEventHandler()
    # 定義要監(jiān)控的目錄
    watch_directory = "demo_folder"
    # 將事件處理對象和要監(jiān)控的目錄添加到觀察者中，并設(shè)置為遞歸監(jiān)控
    observer.schedule(event_handler, watch_directory, recursive=True)
    # 啟動觀察者，開始監(jiān)控文件系統(tǒng)的變化
    observer.start()
    try:
        # 當(dāng)觀察者處于活動狀態(tài)時，持續(xù)循環(huán)
        while observer.is_alive():
            # 等待1秒，讓觀察者有時間處理文件系統(tǒng)事件
            observer.join(1)
    finally:
        # 停止觀察者，結(jié)束文件系統(tǒng)的監(jiān)控
        observer.stop()
        # 等待觀察者線程結(jié)束
        observer.join()

import time
import os
import threading
from watchdog.observers import Observer
from watchdog.events import *
from watchdog.utils.dirsnapshot import DirectorySnapshot, DirectorySnapshotDiff


class FileChangeHandler(FileSystemEventHandler):
    def __init__(self, monitored_path, delay=0.5):
        # 調(diào)用父類構(gòu)造函數(shù)
        super().__init__()
        # 被監(jiān)控的目錄路徑
        self.monitored_path = monitored_path
        self.delay = delay
        # 定時器對象，用于延遲檢查
        self.delay_timer = None
        # 快照用于記錄指定目錄在某個時間點的狀態(tài)，包含了目錄下所有文件和子目錄的信息，
        # 記錄目錄的初始快照
        self.initial_snapshot = DirectorySnapshot(self.monitored_path)

    def on_any_event(self, event):
        # 通過定時器減少不必要的檢查
        # 如果定時器已存在，取消它
        if self.delay_timer:
            self.delay_timer.cancel()
        # 創(chuàng)建一個新的定時器，延遲后執(zhí)行檢查快照的操作
        # 通過快照檢測文件系統(tǒng)變化
        self.delay_timer = threading.Timer(self.delay, self._check_directory_changes)
        self.delay_timer.start()

    def _check_directory_changes(self):
        # 獲取當(dāng)前目錄的新快照
        new_snapshot = DirectorySnapshot(self.monitored_path)
        # 計算新舊快照之間的差異
        snapshot_difference = DirectorySnapshotDiff(self.initial_snapshot, new_snapshot)
        # 更新初始快照為新快照
        self.initial_snapshot = new_snapshot
        # 清空定時器
        self.delay_timer = None
        # 打印目錄變化信息
        self._print_changes(snapshot_difference)

    def _print_changes(self, diff):
        # 打印文件和目錄的創(chuàng)建、刪除、修改和移動信息
        print("創(chuàng)建的文件:", diff.files_created)
        print("刪除的文件:", diff.files_deleted)
        print("修改的文件:", diff.files_modified)
        print("移動的文件:", diff.files_moved)
        print("修改的目錄:", diff.dirs_modified)
        print("移動的目錄:", diff.dirs_moved)
        print("刪除的目錄:", diff.dirs_deleted)
        print("創(chuàng)建的目錄:", diff.dirs_created)

class DirectoryMonitor:
    def __init__(self, monitored_path):
        # 被監(jiān)控的目錄路徑
        self.monitored_path = monitored_path
        # 創(chuàng)建一個觀察者對象
        self.directory_observer = Observer()

    def start_monitoring(self):
        # 創(chuàng)建文件變化處理對象
        change_handler = FileChangeHandler(self.monitored_path)
        # 安排觀察者監(jiān)控指定目錄，遞歸地監(jiān)控子目錄
        self.directory_observer.schedule(change_handler, self.monitored_path, recursive=True)
        # 啟動觀察者
        self.directory_observer.start()

    def stop_monitoring(self):
        # 停止觀察者
        self.directory_observer.stop()
        # 等待觀察者線程結(jié)束
        self.directory_observer.join()

if __name__ == "__main__":
    monitor = DirectoryMonitor("demo_folder")
    # 開始監(jiān)控
    monitor.start_monitoring()
    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        monitor.stop_monitoring()

from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler
class CustomFileEventHandler(FileSystemEventHandler):
    def on_created(self, event):
            patterns = [“*.jpg”， “*.png”， “*.gif”]  # 只監(jiān)控圖片文件    def on_modified(self， event)：        print(f“圖片文件有變化：{event.src_path}”)
        entity = "directory" if event.is_directory else "file"
        print(f"{entity} on_created: {event.src_path}")

if __name__ == "__main__":
    file_observer = Observer()
    monitored_directories = ['demo_folder', 'demo_folder2']
    file_event_handler = CustomFileEventHandler()
    for directory in monitored_directories:
        # 為每個目錄注冊事件處理程序
        file_observer.schedule(file_event_handler, directory, recursive=True)
    file_observer.start()
    try:
        # 當(dāng)觀察者處于活動狀態(tài)時，持續(xù)循環(huán)
        while file_observer.is_alive():
            # 等待1秒，讓觀察者有時間處理文件系統(tǒng)事件
            file_observer.join(1)
    finally:
        # 停止觀察者，結(jié)束文件系統(tǒng)的監(jiān)控
        file_observer.stop()
        # 等待觀察者線程結(jié)束
        file_observer.join()