from pathlib import Path
import time

from watchdog.events import FileSystemEventHandler
from watchdog.observers import Observer


class MyHandler(FileSystemEventHandler):
    def on_created(self, event):
        print(f"생성됨: {event.src_path}")

    def on_modified(self, event):
        print(f"수정됨: {event.src_path}")

    def on_deleted(self, event):
        print(f"삭제됨: {event.src_path}")

    def on_moved(self, event):
        print(f"이동됨: {event.src_path} -> {event.dest_path}")


def main():
    watch_path = Path("./watch_folder")
    watch_path.mkdir(exist_ok=True)

    event_handler = MyHandler()
    observer = Observer()
    observer.schedule(event_handler, str(watch_path), recursive=True)

    observer.start()
    print(f"감시 시작: {watch_path}")

    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        observer.stop()

    observer.join()


if __name__ == "__main__":
    main()

from pathlib import Path
import csv
import logging
import shutil
import time

from watchdog.events import FileSystemEventHandler
from watchdog.observers import Observer


INPUT_DIR = Path("./input")
PROCESSED_DIR = Path("./processed")
FAILED_DIR = Path("./failed")

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s %(levelname)s %(message)s",
)


def wait_until_file_ready(file_path: Path, timeout: float = 10.0) -> bool:
    last_size = -1
    start_time = time.time()

    while time.time() - start_time < timeout:
        if not file_path.exists():
            return False

        current_size = file_path.stat().st_size

        if current_size == last_size:
            return True

        last_size = current_size
        time.sleep(0.5)

    return False


class CsvHandler(FileSystemEventHandler):
    def on_created(self, event):
        if event.is_directory:
            return

        file_path = Path(event.src_path)

        if file_path.suffix.lower() != ".csv":
            return

        logging.info("CSV 감지: %s", file_path)

        if not wait_until_file_ready(file_path):
            logging.warning("파일 준비 시간 초과: %s", file_path)
            self.move_to_failed(file_path)
            return

        try:
            self.process_csv(file_path)

            target_path = PROCESSED_DIR / file_path.name
            shutil.move(str(file_path), str(target_path))
            logging.info("처리 완료: %s", target_path)

        except Exception:
            logging.exception("처리 실패: %s", file_path)
            self.move_to_failed(file_path)

    def process_csv(self, file_path: Path) -> None:
        with file_path.open("r", encoding="utf-8-sig", newline="") as f:
            reader = csv.DictReader(f)

            for row in reader:
                logging.info("처리 데이터: %s", row)

    def move_to_failed(self, file_path: Path) -> None:
        if not file_path.exists():
            return

        target_path = FAILED_DIR / file_path.name
        shutil.move(str(file_path), str(target_path))
        logging.info("실패 폴더 이동: %s", target_path)


def main():
    INPUT_DIR.mkdir(exist_ok=True)
    PROCESSED_DIR.mkdir(exist_ok=True)
    FAILED_DIR.mkdir(exist_ok=True)

    observer = Observer()
    observer.schedule(CsvHandler(), str(INPUT_DIR), recursive=False)
    observer.start()

    logging.info("CSV 감시 시작: %s", INPUT_DIR)

    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        logging.info("감시 종료")
        observer.stop()

    observer.join()


if __name__ == "__main__":
    main()

import time
from pathlib import Path


class Debouncer:
    def __init__(self, interval: float = 1.0):
        self.interval = interval
        self.last_seen: dict[Path, float] = {}

    def should_process(self, file_path: Path) -> bool:
        now = time.time()
        last = self.last_seen.get(file_path, 0)

        if now - last < self.interval:
            return False

        self.last_seen[file_path] = now
        return True

from watchdog.observers.polling import PollingObserver as Observer