| import os
|
| import csv
|
| import json
|
| import logging
|
| from datetime import datetime
|
| import time
|
| import psutil
|
| import GPUtil
|
| import traceback
|
|
|
|
|
| class LoggingManager:
|
| def __init__(self, settings):
|
| self.settings = settings
|
| self.log_dir = "logs"
|
| self.feedback_dir = "feedback"
|
| self.ensure_directories()
|
| self.setup_logging()
|
| self.benchmark_file = None
|
| self.feedback_file = None
|
| self.error_file = None
|
| self.last_api_params = None
|
| self.last_status_message = ""
|
| self.loading_symbols = ["|", "/", "-", "\\"]
|
| self.loading_index = 0
|
|
|
| def log_npc_manager(self, message):
|
| """บันทึกข้อความสำหรับ NPC Manager แบบกรองแล้ว"""
|
|
|
| important_messages = [
|
| "NPC Manager started",
|
| "Data loaded successfully",
|
| "Font system ready",
|
| "Error:",
|
| "Warning:",
|
| ]
|
|
|
|
|
| if any(msg in message for msg in important_messages):
|
| print(message)
|
|
|
| def log_startup_info(self):
|
| """บันทึกข้อมูลสำคัญตอนเริ่มต้นระบบ"""
|
| current_model = self.settings.get_displayed_model()
|
| screen_size = self.settings.get("screen_size", "2560x1440")
|
| use_gpu = self.settings.get("use_gpu_for_ocr", False)
|
|
|
| startup_info = [
|
| "=== MagicBabel System Started ===",
|
| f"Model: {current_model}",
|
| f"Screen Size: {screen_size}",
|
| f"OCR Processing: {'GPU' if use_gpu else 'CPU'}",
|
| "===============================",
|
| ]
|
|
|
| for line in startup_info:
|
| logging.info(line)
|
| print(line)
|
|
|
| def log_model_change(self, old_model, new_model, parameters):
|
| """บันทึกการเปลี่ยนแปลง model"""
|
| log_lines = [
|
| "=== Model Change ===",
|
| f"From: {old_model}",
|
| f"To: {new_model}",
|
| "Parameters:",
|
| f"- Max Tokens: {parameters.get('max_tokens', 'N/A')}",
|
| f"- Temperature: {parameters.get('temperature', 'N/A')}",
|
| "===================",
|
| ]
|
|
|
| for line in log_lines:
|
| logging.info(line)
|
| print(line)
|
|
|
| def log_system_status(self):
|
| """บันทึกสถานะระบบ"""
|
| memory_usage = psutil.Process().memory_info().rss / 1024 / 1024
|
| gpu_usage = (
|
| self.get_gpu_usage() if self.settings.get("use_gpu_for_ocr") else "N/A"
|
| )
|
|
|
| status_lines = [
|
| "=== System Status ===",
|
| f"Memory Usage: {memory_usage:.2f} MB",
|
| f"GPU Usage: {gpu_usage}",
|
| "====================",
|
| ]
|
|
|
| for line in status_lines:
|
| logging.info(line)
|
| print(line)
|
|
|
| def ensure_directories(self):
|
| for directory in [self.log_dir, self.feedback_dir]:
|
| if not os.path.exists(directory):
|
| os.makedirs(directory)
|
|
|
| def setup_logging(self):
|
| logging.basicConfig(
|
| filename=os.path.join(self.log_dir, "app.log"),
|
| level=logging.INFO,
|
| format="%(asctime)s - %(levelname)s - %(message)s",
|
| )
|
| logging.info("Logging initialized")
|
|
|
| def init_benchmark_logging(self):
|
| self.benchmark_file = os.path.join(
|
| self.log_dir, f"benchmark_{datetime.now().strftime('%Y%m%d')}.csv"
|
| )
|
| file_exists = os.path.isfile(self.benchmark_file)
|
|
|
| with open(self.benchmark_file, "a", newline="") as file:
|
| writer = csv.writer(file)
|
| if not file_exists:
|
| writer.writerow(
|
| ["Timestamp", "Action", "Duration", "Memory Usage", "GPU Usage"]
|
| )
|
| logging.info(f"Benchmark logging initialized: {self.benchmark_file}")
|
|
|
| def log_benchmark(self, action, duration):
|
| if not self.benchmark_file or not os.path.isfile(self.benchmark_file):
|
| self.init_benchmark_logging()
|
|
|
| memory_usage = psutil.Process().memory_info().rss / 1024 / 1024
|
| gpu_usage = (
|
| self.get_gpu_usage() if self.settings.get("use_gpu_for_ocr") else "N/A"
|
| )
|
|
|
| with open(self.benchmark_file, "a", newline="") as file:
|
| writer = csv.writer(file)
|
| writer.writerow([datetime.now(), action, duration, memory_usage, gpu_usage])
|
|
|
|
|
| self.update_status(f"Benchmark: {action}, Duration: {duration:.4f}s")
|
|
|
| def get_gpu_usage(self):
|
| try:
|
| gpus = GPUtil.getGPUs()
|
| if gpus:
|
| return f"{gpus[0].load * 100:.2f}%"
|
| except Exception as e:
|
| logging.error(f"Error getting GPU usage: {e}")
|
| return "N/A"
|
|
|
| def log_api_params_change(self):
|
| current_api_params = self.settings.get_api_parameters()
|
| if current_api_params != self.last_api_params:
|
| today = datetime.now().strftime("%Y%m%d")
|
| self.feedback_file = os.path.join(
|
| self.feedback_dir, f"feedback_{today}.json"
|
| )
|
|
|
| api_change_data = {
|
| "timestamp": datetime.now().isoformat(),
|
| "new_params": current_api_params,
|
| }
|
|
|
| if os.path.isfile(self.feedback_file):
|
| with open(self.feedback_file, "r+", encoding="utf-8") as file:
|
| data = json.load(file)
|
| if "api_params_changes" not in data:
|
| data["api_params_changes"] = []
|
| data["api_params_changes"].append(api_change_data)
|
| data["api_parameters"] = current_api_params
|
| file.seek(0)
|
| file.truncate()
|
| json.dump(data, file, indent=2, ensure_ascii=False)
|
| else:
|
| with open(self.feedback_file, "w", encoding="utf-8") as file:
|
| initial_data = {
|
| "api_parameters": current_api_params,
|
| "api_params_changes": [api_change_data],
|
| "feedbacks": [],
|
| }
|
| json.dump(initial_data, file, indent=2, ensure_ascii=False)
|
|
|
| self.last_api_params = current_api_params
|
| logging.info("API parameters updated and logged")
|
|
|
| def log_error(self, error_message):
|
| logging.error(error_message)
|
| self.write_error_to_file(error_message)
|
|
|
| def write_error_to_file(self, error_message):
|
| today = datetime.now().strftime("%Y%m%d")
|
| self.error_file = os.path.join(self.log_dir, f"error_{today}.log")
|
|
|
| timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
|
| formatted_error = f"[{timestamp}] {error_message}\n"
|
| formatted_error += f"Traceback:\n{traceback.format_exc()}\n\n"
|
|
|
| with open(self.error_file, "a", encoding="utf-8") as file:
|
| file.write(formatted_error)
|
|
|
| def log_info(self, info_message):
|
| """
|
| บันทึก log ข้อมูลโดยไม่แสดงซ้ำ
|
| """
|
|
|
| skip_logging_messages = {
|
| "OCR scanning...",
|
| "OCR completed",
|
| "Waiting for text...",
|
| "Translating...",
|
| }
|
|
|
| if info_message not in skip_logging_messages:
|
| logging.info(info_message)
|
|
|
| def log_warning(self, warning_message):
|
| logging.warning(warning_message)
|
| self.write_error_to_file(f"WARNING: {warning_message}")
|
|
|
| def log_critical(self, critical_message):
|
| logging.critical(critical_message)
|
| self.write_error_to_file(f"CRITICAL: {critical_message}")
|
|
|
| def update_status(self, message):
|
| """
|
| อัพเดทและแสดงสถานะแบบต่อเนื่องในบรรทัดเดียว
|
| Args:
|
| message: ข้อความที่ต้องการแสดง
|
| """
|
| current_time = time.time()
|
|
|
|
|
| continuous_states = {
|
| "OCR scanning": {
|
| "icon": "🔍",
|
| "variants": ["scanning.", "scanning..", "scanning..."],
|
| },
|
| "Waiting for text": {
|
| "icon": "⌛",
|
| "variants": ["waiting.", "waiting..", "waiting..."],
|
| },
|
| }
|
|
|
|
|
| for state, config in continuous_states.items():
|
| if state in message:
|
| if not hasattr(self, "_animation_state"):
|
| self._animation_state = 0
|
| self._last_animation_time = 0
|
|
|
|
|
| if current_time - self._last_animation_time > 0.3:
|
| self._animation_state = (self._animation_state + 1) % len(
|
| config["variants"]
|
| )
|
| self._last_animation_time = current_time
|
|
|
| display_message = f"{config['icon']} {state}{config['variants'][self._animation_state]}"
|
| print(f"\r{display_message:<60}", end="", flush=True)
|
| return
|
|
|
|
|
| skip_messages = {"OCR completed", "Processing image"}
|
|
|
| if message in skip_messages:
|
| if hasattr(self, "_last_message") and self._last_message == message:
|
| return
|
|
|
|
|
| self._last_message = message
|
|
|
|
|
| important_messages = {
|
| "Translation updated": "✅ Translation updated",
|
| "Error": "❌ Error detected",
|
| }
|
|
|
| if message in important_messages:
|
| display_message = important_messages[message]
|
| print(f"\r{display_message:<60}", end="", flush=True)
|
| logging.info(message)
|
|
|
