add robust logging and localization

Author: leafspark

AutoGGUF.py

@@ -0,0 +1,54 @@
+from PyQt6.QtWidgets import *
+from PyQt6.QtCore import *
+from PyQt6.QtGui import *
+import os
+import sys
+import psutil
+import subprocess
+import time
+import signal
+import json
+import platform
+import requests
+import zipfile
+from datetime import datetime
+
+class DownloadThread(QThread):
+    progress_signal = pyqtSignal(int)
+    finished_signal = pyqtSignal(str)
+    error_signal = pyqtSignal(str)
+
+    def __init__(self, url, save_path):
+        super().__init__()
+        self.url = url
+        self.save_path = save_path
+
+    def run(self):
+        try:
+            response = requests.get(self.url, stream=True)
+            response.raise_for_status()
+            total_size = int(response.headers.get('content-length', 0))
+            block_size = 8192
+            downloaded = 0
+
+            with open(self.save_path, 'wb') as file:
+                for data in response.iter_content(block_size):
+                    size = file.write(data)
+                    downloaded += size
+                    if total_size:
+                        progress = int((downloaded / total_size) * 100)
+                        self.progress_signal.emit(progress)
+
+            # Extract the downloaded zip file
+            extract_dir = os.path.splitext(self.save_path)[0]
+            with zipfile.ZipFile(self.save_path, 'r') as zip_ref:
+                zip_ref.extractall(extract_dir)
+
+            # Remove the zip file after extraction
+            os.remove(self.save_path)
+
+            self.finished_signal.emit(extract_dir)
+        except Exception as e:
+            self.error_signal.emit(str(e))
+            if os.path.exists(self.save_path):
+                os.remove(self.save_path)

DownloadThread.py

@@ -0,0 +1,33 @@
+from PyQt6.QtWidgets import QWidget, QHBoxLayout, QLineEdit, QComboBox, QPushButton
+from PyQt6.QtCore import pyqtSignal
+
+class KVOverrideEntry(QWidget):
+    deleted = pyqtSignal(QWidget)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        layout = QHBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+
+        self.key_input = QLineEdit()
+        self.key_input.setPlaceholderText("Key")
+        layout.addWidget(self.key_input)
+
+        self.type_combo = QComboBox()
+        self.type_combo.addItems(["int", "str", "float"])
+        layout.addWidget(self.type_combo)
+
+        self.value_input = QLineEdit()
+        self.value_input.setPlaceholderText("Value")
+        layout.addWidget(self.value_input)
+
+        delete_button = QPushButton("X")
+        delete_button.setFixedSize(30, 30)
+        delete_button.clicked.connect(self.delete_clicked)
+        layout.addWidget(delete_button)
+
+    def delete_clicked(self):
+        self.deleted.emit(self)
+
+    def get_override_string(self):
+        return f"{self.key_input.text()}={self.type_combo.currentText()}:{self.value_input.text()}"

KVOverrideEntry.py

@@ -0,0 +1,46 @@
+import logging
+from logging.handlers import RotatingFileHandler
+import os
+import sys
+from datetime import datetime
+
+class Logger:
+    def __init__(self, name, log_dir):
+        self.logger = logging.getLogger(name)
+        self.logger.setLevel(logging.DEBUG)
+
+        # Create logs directory if it doesn't exist
+        os.makedirs(log_dir, exist_ok=True)
+
+        # Console handler
+        console_handler = logging.StreamHandler()
+        console_handler.setLevel(logging.INFO)
+        console_format = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
+        console_handler.setFormatter(console_format)
+
+        # File handler
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        log_file = os.path.join(log_dir, f"latest_{timestamp}.log")
+        file_handler = RotatingFileHandler(log_file, maxBytes=10*1024*1024, backupCount=5, encoding='utf-8')
+        file_handler.setLevel(logging.DEBUG)
+        file_format = logging.Formatter('%(asctime)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s')
+        file_handler.setFormatter(file_format)
+
+        # Add handlers to logger
+        self.logger.addHandler(console_handler)
+        self.logger.addHandler(file_handler)
+
+    def debug(self, message):
+        self.logger.debug(message)
+
+    def info(self, message):
+        self.logger.info(message)
+
+    def warning(self, message):
+        self.logger.warning(message)
+
+    def error(self, message):
+        self.logger.error(message)
+
+    def critical(self, message):
+        self.logger.critical(message)

Logger.py

@@ -0,0 +1,48 @@
+from PyQt6.QtWidgets import *
+from PyQt6.QtCore import *
+from PyQt6.QtGui import *
+import os
+import sys
+import psutil
+import subprocess
+import time
+import signal
+import json
+import platform
+import requests
+import zipfile
+from datetime import datetime
+
+class ModelInfoDialog(QDialog):
+    def __init__(self, model_info, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Model Information")
+        self.setGeometry(200, 200, 600, 400)
+
+        layout = QVBoxLayout()
+
+        info_text = QTextEdit()
+        info_text.setReadOnly(True)
+        info_text.setHtml(self.format_model_info(model_info))
+
+        layout.addWidget(info_text)
+
+        close_button = QPushButton("Close")
+        close_button.clicked.connect(self.accept)
+        layout.addWidget(close_button)
+
+        self.setLayout(layout)
+
+    def format_model_info(self, model_info):
+        html = "<h2>Model Information</h2>"
+        html += f"<p><b>Architecture:</b> {model_info.get('architecture', 'N/A')}</p>"
+        html += f"<p><b>Quantization Type:</b> {model_info.get('quantization_type', 'N/A')}</p>"
+        html += f"<p><b>KV Pairs:</b> {model_info.get('kv_pairs', 'N/A')}</p>"
+        html += f"<p><b>Tensors:</b> {model_info.get('tensors', 'N/A')}</p>"
+        
+        html += "<h3>Key-Value Pairs:</h3>"
+        for key, value in model_info.get('kv_data', {}).items():
+            html += f"<p><b>{key}:</b> {value}</p>"
+
+        return html        
+        

ModelInfoDialog.py

@@ -0,0 +1,79 @@
+from PyQt6.QtWidgets import *
+from PyQt6.QtCore import *
+from PyQt6.QtGui import *
+import os
+import sys
+import psutil
+import subprocess
+import time
+import signal
+import json
+import platform
+import requests
+import zipfile
+import traceback
+from datetime import datetime
+from imports_and_globals import open_file_safe
+
+class QuantizationThread(QThread):
+    output_signal = pyqtSignal(str)
+    status_signal = pyqtSignal(str)
+    finished_signal = pyqtSignal()
+    error_signal = pyqtSignal(str)
+    model_info_signal = pyqtSignal(dict)
+
+    def __init__(self, command, cwd, log_file):
+        super().__init__()
+        self.command = command
+        self.cwd = cwd
+        self.log_file = log_file
+        self.process = None
+        self.model_info = {}
+
+    def run(self):
+        try:
+            self.process = subprocess.Popen(self.command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, 
+                                       text=True, cwd=self.cwd)
+            with open_file_safe(self.log_file, 'w') as log:
+                for line in self.process.stdout:
+                    line = line.strip()
+                    self.output_signal.emit(line)
+                    log.write(line + '\n')
+                    log.flush()
+                    self.status_signal.emit("In Progress")
+                    self.parse_model_info(line)
+            self.process.wait()
+            if self.process.returncode == 0:
+                self.status_signal.emit("Completed")
+                self.model_info_signal.emit(self.model_info)
+            else:
+                self.error_signal.emit(f"Process exited with code {self.process.returncode}")
+            self.finished_signal.emit()
+        except Exception as e:
+            self.error_signal.emit(str(e))
+
+    def parse_model_info(self, line):
+        if "llama_model_loader: loaded meta data with" in line:
+            parts = line.split()
+            self.model_info['kv_pairs'] = parts[6]
+            self.model_info['tensors'] = parts[9]
+        elif "general.architecture" in line:
+            self.model_info['architecture'] = line.split('=')[-1].strip()
+        elif line.startswith("llama_model_loader: - kv"):
+            key = line.split(':')[2].strip()
+            value = line.split('=')[-1].strip()
+            self.model_info.setdefault('kv_data', {})[key] = value
+        elif line.startswith("llama_model_loader: - type"):
+            parts = line.split(':')
+            if len(parts) > 1:
+                quant_type = parts[1].strip()
+                tensors = parts[2].strip().split()[0]
+                self.model_info.setdefault('quantization_type', []).append(f"{quant_type}: {tensors} tensors")
+
+    def terminate(self):
+        if self.process:
+            os.kill(self.process.pid, signal.SIGTERM)
+            self.process.wait(timeout=5)
+            if self.process.poll() is None:
+                os.kill(self.process.pid, signal.SIGKILL)
+

QuantizationThread.py

@@ -0,0 +1,57 @@
+from PyQt6.QtWidgets import *
+from PyQt6.QtCore import *
+from PyQt6.QtGui import *
+import os
+import sys
+import psutil
+import subprocess
+import time
+import signal
+import json
+import platform
+import requests
+import zipfile
+from datetime import datetime
+
+class TaskListItem(QWidget):
+    def __init__(self, task_name, log_file, parent=None):
+        super().__init__(parent)
+        self.task_name = task_name
+        self.log_file = log_file
+        self.status = "Pending"
+        layout = QHBoxLayout(self)
+        self.task_label = QLabel(task_name)
+        self.progress_bar = QProgressBar()
+        self.progress_bar.setRange(0, 100)
+        self.status_label = QLabel(self.status)
+        layout.addWidget(self.task_label)
+        layout.addWidget(self.progress_bar)
+        layout.addWidget(self.status_label)
+        self.progress_timer = QTimer(self)
+        self.progress_timer.timeout.connect(self.update_progress)
+        self.progress_value = 0
+
+    def update_status(self, status):
+        self.status = status
+        self.status_label.setText(status)
+        if status == "In Progress":
+            self.progress_bar.setRange(0, 100)
+            self.progress_timer.start(100)
+        elif status == "Completed":
+            self.progress_timer.stop()
+            self.progress_bar.setValue(100)
+        elif status == "Canceled":
+            self.progress_timer.stop()
+            self.progress_bar.setValue(0)
+        
+    def set_error(self):
+        self.status = "Error"
+        self.status_label.setText("Error")
+        self.status_label.setStyleSheet("color: red;")
+        self.progress_bar.setRange(0, 100)
+        self.progress_timer.stop()
+
+    def update_progress(self):
+        self.progress_value = (self.progress_value + 1) % 101
+        self.progress_bar.setValue(self.progress_value)
+

TaskListItem.py

@@ -0,0 +1,30 @@
+import os
+import sys
+import psutil
+import subprocess
+import time
+import signal
+import json
+import platform
+import requests
+import zipfile
+from datetime import datetime
+from PyQt6.QtWidgets import (QApplication, QMainWindow, QVBoxLayout, QHBoxLayout, QWidget, QPushButton, 
+                             QListWidget, QLineEdit, QLabel, QFileDialog, QProgressBar, QComboBox, QTextEdit,
+                             QCheckBox, QGroupBox, QFormLayout, QScrollArea, QSlider, QSpinBox, QListWidgetItem,
+                             QMessageBox, QDialog, QPlainTextEdit, QMenu)
+from PyQt6.QtCore import QTimer, QThread, pyqtSignal, Qt, QSize
+from PyQt6.QtGui import QCloseEvent, QAction
+
+def ensure_directory(path):
+    if not os.path.exists(path):
+        os.makedirs(path)
+        
+def open_file_safe(file_path, mode='r'):
+    encodings = ['utf-8', 'latin-1', 'ascii', 'utf-16']
+    for encoding in encodings:
+        try:
+            return open(file_path, mode, encoding=encoding)
+        except UnicodeDecodeError:
+            continue
+    raise ValueError(f"Unable to open file {file_path} with any of the encodings: {encodings}")