OOP draft

app.py

@@ -1,753 +1,790 @@
 import os
 import subprocess
 import signal
-os.environ["GRADIO_ANALYTICS_ENABLED"] = "False"
-import gradio as gr
 import tempfile
+from pathlib import Path
+from textwrap import dedent
+from typing import Optional, Tuple, List, Union
+from dataclasses import dataclass
+
+os.environ["GRADIO_ANALYTICS_ENABLED"] = "False"
 
+import gradio as gr
 from huggingface_hub import HfApi, ModelCard, whoami
 from gradio_huggingfacehub_search import HuggingfaceHubSearch
-from pathlib import Path
-from textwrap import dedent
 from apscheduler.schedulers.background import BackgroundScheduler
 
-# Space parameters
-SPACE_ID = os.environ.get("SPACE_ID") if os.environ.get("SPACE_ID") else ""
-SPACE_URL = "https://" + SPACE_ID.replace("/", "-") + ".hf.space/" if SPACE_ID else "http://localhost:7860/"
-HF_TOKEN = os.environ.get("HF_TOKEN")
-
-RUN_LOCALLY = os.environ.get("RUN_LOCALLY")
-
-# Folder
-DOWNLOAD_FOLDER = "./downloads"
-OUTPUT_FOLDER = "./outputs"
-
-ERROR_LOGIN = "You must be logged in to use GGUF-my-repo."
-
-def create_folder(folder_name: str):
-    if not os.path.exists(folder_name):
-        print(f"Creating folder: {folder_name}")
-        os.makedirs(folder_name)
-
-    return folder_name
-
-def validate_token(oauth_token):
-    if oauth_token is None or oauth_token.token is None:
-        raise gr.Error(ERROR_LOGIN)
-
-    try:
-        whoami(oauth_token.token)
-    except Exception as e:
-        raise gr.Error(ERROR_LOGIN)
-
-# escape HTML for logging
-def escape(s: str) -> str:
-    s = s.replace("&", "&") # Must be done first!
-    s = s.replace("<", "&lt;")
-    s = s.replace(">", "&gt;")
-    s = s.replace('"', "&quot;")
-    s = s.replace("\n", "<br/>")
-    return s
-
-def get_model_creator(model_id: str):
-    return model_id.split('/')[0]
-
-def get_model_name(model_id: str):
-    return model_id.split('/')[-1]
-
-def upload_file(token, path_or_fileobj, path_in_repo, repo_id):
-    if RUN_LOCALLY == "1":
-        print("Skipping upload...")
-        return
-
-    api = HfApi(token=token)
-    api.upload_file(
-        path_or_fileobj=path_or_fileobj,
-        path_in_repo=path_in_repo,
-        repo_id=repo_id,
-    )
-
-def generate_importance_matrix(model_path: str, train_data_path: str, output_path: str):
-    if not os.path.isfile(model_path):
-        raise Exception(f"Model file not found: {model_path}")
-
-    print("Running imatrix command...")
-    imatrix_command = [
-        "llama-imatrix",
-        "-m", model_path,
-        "-f", train_data_path,
-        "-ngl", "99",
-        "--output-frequency", "10",
-        "--output-format", "dat",
-        "-o", output_path,
-    ]
-    process = subprocess.Popen(imatrix_command, shell=False)
-
-    try:
-        process.wait(timeout=60)  # added wait
-    except subprocess.TimeoutExpired:
-        print("Imatrix computation timed out. Sending SIGINT to allow graceful termination...")
-        process.send_signal(signal.SIGINT)
+
+@dataclass
+class QuantizationConfig:
+    """Configuration for model quantization."""
+    method: str
+    use_imatrix: bool = False
+    imatrix_method: str = "IQ4_NL"
+    quant_embedding: bool = False
+    embedding_tensor_method: str = "Q8_0"
+    leave_output: bool = False
+    quant_output: bool = False
+    output_tensor_method: str = "Q8_0"
+
+
+@dataclass
+class SplitConfig:
+    """Configuration for model splitting."""
+    enabled: bool = False
+    max_tensors: int = 256
+    max_size: Optional[str] = None
+
+
+@dataclass
+class OutputConfig:
+    """Configuration for output settings."""
+    private_repo: bool = False
+    repo_name: str = ""
+    filename: str = ""
+
+
+class GGUFConverterError(Exception):
+    """Custom exception for GGUF conversion errors."""
+    pass
+
+
+class HuggingFaceModelProcessor:
+    """Handles the processing of Hugging Face models to GGUF format."""
+
+    ERROR_LOGIN = "You must be logged in to use GGUF-my-repo."
+    DOWNLOAD_FOLDER = "./downloads"
+    OUTPUT_FOLDER = "./outputs"
+
+    def __init__(self):
+        self.SPACE_ID = os.environ.get("SPACE_ID", "")
+        self.SPACE_URL = f"https://{self.SPACE_ID.replace('/', '-')}.hf.space/" if self.SPACE_ID else "http://localhost:7860/"
+        self.HF_TOKEN = os.environ.get("HF_TOKEN")
+        self.RUN_LOCALLY = os.environ.get("RUN_LOCALLY")
+
+        # Create necessary folders
+        self._create_folder(self.DOWNLOAD_FOLDER)
+        self._create_folder(self.OUTPUT_FOLDER)
+
+    def _create_folder(self, folder_name: str) -> str:
+        """Create a folder if it doesn't exist."""
+        if not os.path.exists(folder_name):
+            print(f"Creating folder: {folder_name}")
+            os.makedirs(folder_name)
+        return folder_name
+
+    def _validate_token(self, oauth_token: Optional[gr.OAuthToken]) -> str:
+        """Validate the OAuth token and return the token string."""
+        if oauth_token is None or oauth_token.token is None:
+            raise GGUFConverterError(self.ERROR_LOGIN)
+
+        try:
+            whoami(oauth_token.token)
+            return oauth_token.token
+        except Exception as e:
+            raise GGUFConverterError(self.ERROR_LOGIN)
+
+    def _escape_html(self, s: str) -> str:
+        """Escape HTML characters for safe display."""
+        replacements = [
+            ("&", "&amp;"),
+            ("<", "&lt;"),
+            (">", "&gt;"),
+            ('"', "&quot;"),
+            ("\n", "<br/>")
+        ]
+        for old, new in replacements:
+            s = s.replace(old, new)
+        return s
+
+    def _get_model_creator(self, model_id: str) -> str:
+        """Extract model creator from model ID."""
+        return model_id.split('/')[0]
+
+    def _get_model_name(self, model_id: str) -> str:
+        """Extract model name from model ID."""
+        return model_id.split('/')[-1]
+
+    def _upload_file(self, token: str, path_or_fileobj: str, path_in_repo: str, repo_id: str) -> None:
+        """Upload a file to Hugging Face repository."""
+        if self.RUN_LOCALLY == "1":
+            print("Skipping upload...")
+            return
+
+        api = HfApi(token=token)
+        api.upload_file(
+            path_or_fileobj=path_or_fileobj,
+            path_in_repo=path_in_repo,
+            repo_id=repo_id,
+        )
+
+    def _generate_importance_matrix(self, model_path: str, train_data_path: str, output_path: str) -> None:
+        """Generate importance matrix for quantization."""
+        if not os.path.isfile(model_path):
+            raise GGUFConverterError(f"Model file not found: {model_path}")
+
+        print("Running imatrix command...")
+        imatrix_command = [
+            "llama-imatrix",
+            "-m", model_path,
+            "-f", train_data_path,
+            "-ngl", "99",
+            "--output-frequency", "10",
+            "--output-format", "dat",
+            "-o", output_path,
+        ]
+
+        process = subprocess.Popen(imatrix_command, shell=False)
         try:
-            process.wait(timeout=5)  # grace period
+            process.wait(timeout=60)
         except subprocess.TimeoutExpired:
-            print("Imatrix proc still didn't term. Forecfully terming process...")
-            process.kill()
-
-    print(f"Importance matrix generation completed: {os.path.abspath(output_path)}")
-
-def split_upload_model(model_path: str, outdir: str, repo_id: str, token: str, split_max_tensors=256, split_max_size=None):
-    print(f"Model path: {model_path}")
-    print(f"Output dir: {outdir}")
-
-    split_cmd = [
-        "llama-gguf-split",
-        "--split",
-    ]
-    if split_max_size:
-        split_cmd.append("--split-max-size")
-        split_cmd.append(split_max_size)
-    else:
-        split_cmd.append("--split-max-tensors")
-        split_cmd.append(str(split_max_tensors))
-
-    # args for output
-    model_path_prefix = '.'.join(model_path.split('.')[:-1]) # remove the file extension
-    split_cmd.append(model_path)
-    split_cmd.append(model_path_prefix)
-
-    print(f"Split command: {split_cmd}")
-
-    result = subprocess.run(split_cmd, shell=False, capture_output=True, text=True)
-    print(f"Split command stdout: {result.stdout}")
-    print(f"Split command stderr: {result.stderr}")
-
-    if result.returncode != 0:
-        stderr_str = result.stderr.decode("utf-8")
-        raise Exception(f"Error splitting the model: {stderr_str}")
-    print("Model split successfully!")
-
-    # remove the original model file if needed
-    if os.path.exists(model_path):
-        os.remove(model_path)
-
-    model_file_prefix = model_path_prefix.split('/')[-1]
-    print(f"Model file name prefix: {model_file_prefix}")
-    sharded_model_files = [f for f in os.listdir(outdir) if f.startswith(model_file_prefix) and f.endswith(".gguf")]
-    if sharded_model_files:
+            print("Imatrix computation timed out. Sending SIGINT to allow graceful termination...")
+            process.send_signal(signal.SIGINT)
+            try:
+                process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                print("Imatrix proc still didn't term. Forecfully terming process...")
+                process.kill()
+
+        print(f"Importance matrix generation completed: {os.path.abspath(output_path)}")
+
+    def _split_and_upload_model(self, model_path: str, outdir: str, repo_id: str, token: str,
+                               split_config: SplitConfig) -> None:
+        """Split large model files and upload shards."""
+        print(f"Model path: {model_path}")
+        print(f"Output dir: {outdir}")
+
+        split_cmd = ["llama-gguf-split", "--split"]
+
+        if split_config.max_size:
+            split_cmd.extend(["--split-max-size", split_config.max_size])
+        else:
+            split_cmd.extend(["--split-max-tensors", str(split_config.max_tensors)])
+
+        model_path_prefix = '.'.join(model_path.split('.')[:-1])
+        split_cmd.extend([model_path, model_path_prefix])
+
+        print(f"Split command: {split_cmd}")
+        result = subprocess.run(split_cmd, shell=False, capture_output=True, text=True)
+
+        print(f"Split command stdout: {result.stdout}")
+        print(f"Split command stderr: {result.stderr}")
+
+        if result.returncode != 0:
+            stderr_str = result.stderr.decode("utf-8")
+            raise GGUFConverterError(f"Error splitting the model: {stderr_str}")
+
+        print("Model split successfully!")
+
+        # Remove original model file
+        if os.path.exists(model_path):
+            os.remove(model_path)
+
+        model_file_prefix = model_path_prefix.split('/')[-1]
+        print(f"Model file name prefix: {model_file_prefix}")
+
+        sharded_model_files = [
+            f for f in os.listdir(outdir)
+            if f.startswith(model_file_prefix) and f.endswith(".gguf")
+        ]
+
+        if not sharded_model_files:
+            raise GGUFConverterError("No sharded files found.")
+
         print(f"Sharded model files: {sharded_model_files}")
         for file in sharded_model_files:
             file_path = os.path.join(outdir, file)
             try:
                 print(f"Uploading file: {file_path}")
-                upload_file(
-                    token=token,
-                    path_or_fileobj=file_path,
-                    path_in_repo=file,
-                    repo_id=repo_id,
-                )
+                self._upload_file(token, file_path, file, repo_id)
             except Exception as e:
-                raise Exception(f"Error uploading file {file_path}: {e}")
-    else:
-        raise Exception("No sharded files found.")
+                raise GGUFConverterError(f"Error uploading file {file_path}: {e}")
 
-    print("Sharded model has been uploaded successfully!")
+        print("Sharded model has been uploaded successfully!")
 
-def download_base_model(token: str, model_id: str, outdir: str):
-    model_name = get_model_name(model_id)
-    print(f"Downloading model {model_name}")
+    def _download_base_model(self, token: str, model_id: str, outdir: str) -> str:
+        """Download and convert Hugging Face model to GGUF FP16 format."""
+        model_name = self._get_model_name(model_id)
+        print(f"Downloading model {model_name}")
+        fp16_model = f"{outdir}/{model_name}-fp16.gguf"
 
-    fp16_model = f"{outdir}/{model_name}-fp16.gguf"
-    if os.path.exists(fp16_model):
-        print("Skipping fp16 convertion...")
-        print(f"Converted model path: {os.path.abspath(fp16_model)}")
+        if os.path.exists(fp16_model):
+            print("Skipping fp16 conversion...")
+            print(f"Converted model path: {os.path.abspath(fp16_model)}")
+            return fp16_model
 
-    with tempfile.TemporaryDirectory(dir=DOWNLOAD_FOLDER) as tmpdir:
-        # Keep the model name as the dirname so the model name metadata is populated correctly
-        local_dir = f"{Path(tmpdir)}/{model_name}"
-        print(f"Local directory: {os.path.abspath(local_dir)}")
+        with tempfile.TemporaryDirectory(dir=self.DOWNLOAD_FOLDER) as tmpdir:
+            local_dir = f"{Path(tmpdir)}/{model_name}"
+            print(f"Local directory: {os.path.abspath(local_dir)}")
 
-        # Download model
-        api = HfApi(token=token)
-        pattern = (
-            "*.safetensors"
-            if any(
-                file.path.endswith(".safetensors")
-                for file in api.list_repo_tree(
-                    repo_id=model_id,
-                    recursive=True,
+            # Download model
+            api = HfApi(token=token)
+            pattern = (
+                "*.safetensors"
+                if any(
+                    file.path.endswith(".safetensors")
+                    for file in api.list_repo_tree(
+                        repo_id=model_id,
+                        recursive=True,
+                    )
                 )
+                else "*.bin"
             )
-            else "*.bin"
-        )
+            dl_pattern = ["*.md", "*.json", "*.model"]
+            dl_pattern += [pattern]
+            api.snapshot_download(repo_id=model_id, local_dir=local_dir, allow_patterns=dl_pattern)
+            print("Model downloaded successfully!")
+            print(f"Model directory contents: {os.listdir(local_dir)}")
+
+            config_dir = local_dir/"config.json"
+            adapter_config_dir = local_dir/"adapter_config.json"
+            if os.path.exists(adapter_config_dir) and not os.path.exists(config_dir):
+                raise GGUFConverterError(
+                    'adapter_config.json is present.<br/><br/>If you are converting a LoRA adapter to GGUF, '
+                    'please use <a href="https://huggingface.co/spaces/ggml-org/gguf-my-lora" target="_blank" '
+                    'style="text-decoration:underline">GGUF-my-lora</a>.'
+                )
+
+            # Convert HF to GGUF
+            print(f"Converting to GGUF FP16: {os.path.abspath(fp16_model)}")
+            result = subprocess.run(
+                [
+                    "python3", "/app/convert_hf_to_gguf.py", local_dir,
+                    "--outtype", "f16", "--outfile", fp16_model
+                ],
+                shell=False,
+                capture_output=True
+            )
+
+            print(f"Model directory contents: {result}")
+            if result.returncode != 0:
+                stderr_str = result.stderr.decode("utf-8")
+                raise GGUFConverterError(f"Error converting to fp16: {stderr_str}")
+
+            print("Model converted to fp16 successfully!")
+            print(f"Converted model path: {os.path.abspath(fp16_model)}")
+            return fp16_model
+
+    def _quantize_model(self, outdir: str, gguf_name: str, fp16: str,
+                       quant_config: QuantizationConfig) -> str:
+        """Quantize the GGUF model."""
+        quantize_cmd = ["llama-quantize"]
+
+        if quant_config.quant_embedding:
+            quantize_cmd.extend(["--token-embedding-type", quant_config.embedding_tensor_method])
+
+        if quant_config.leave_output:
+            quantize_cmd.append("--leave-output-tensor")
+        else:
+            if quant_config.quant_output:
+                quantize_cmd.extend(["--output-tensor-type", quant_config.output_tensor_method])
+
+        imatrix_file = f"{outdir}/{self._get_model_name(gguf_name.split('-')[0])}-imatrix.dat"
+
+        if quant_config.use_imatrix:
+            train_data_path = "calibration_data_v5_rc.txt"
+            print(f"Training data file path: {train_data_path}")
+
+            if not os.path.isfile(train_data_path):
+                raise GGUFConverterError(f"Training data file not found: {train_data_path}")
+
+            self._generate_importance_matrix(fp16, train_data_path, imatrix_file)
+            quantize_cmd.extend(["--imatrix", imatrix_file])
+        else:
+            print("Not using imatrix quantization.")
+
+        quantized_gguf = f"{outdir}/{gguf_name}"
+        quantize_cmd.append(fp16)
+        quantize_cmd.append(quantized_gguf)
+
+        if quant_config.use_imatrix:
+            quantize_cmd.append(quant_config.imatrix_method)
+        else:
+            quantize_cmd.append(quant_config.method)
+
+        print(f"Quantizing model with {quantize_cmd}")
+        result = subprocess.run(quantize_cmd, shell=False, capture_output=True)
 
-        dl_pattern = ["*.md", "*.json", "*.model"]
-        dl_pattern += [pattern]
-
-        api.snapshot_download(repo_id=model_id, local_dir=local_dir, allow_patterns=dl_pattern)
-        print("Model downloaded successfully!")
-
-        print(f"Model directory contents: {os.listdir(local_dir)}")
-        config_dir = local_dir/"config.json"
-        adapter_config_dir = local_dir/"adapter_config.json"
-        if os.path.exists(adapter_config_dir) and not os.path.exists(config_dir):
-            raise Exception('adapter_config.json is present.<br/><br/>If you are converting a LoRA adapter to GGUF, please use <a href="https://huggingface.co/spaces/ggml-org/gguf-my-lora" target="_blank" style="text-decoration:underline">GGUF-my-lora</a>.')
-
-        # Convert HF to GGUF
-        print(f"Converting to GGUF FP16: {os.path.abspath(fp16_model)}")
-        result = subprocess.run(
-            [
-                "python3", "/app/convert_hf_to_gguf.py", local_dir, "--outtype", "f16", "--outfile", fp16_model
-            ],
-            shell=False,
-            capture_output=True
-        )
-        print(f"Model directory contents: {result}")
         if result.returncode != 0:
             stderr_str = result.stderr.decode("utf-8")
-            raise Exception(f"Error converting to fp16: {stderr_str}")
-
-        print("Model converted to fp16 successfully!")
-        print(f"Converted model path: {os.path.abspath(fp16_model)}")
-
-        return fp16_model
-
-def quantize_model(
-    outdir: str,
-    gguf_name: str,
-    fp16: str,
-    q_method: str,
-    use_imatrix: bool,
-    imatrix_q_method: str,
-    imatrix_file: str,
-    quant_embedding: bool,
-    embedding_tensor_method: str,
-    leave_output: bool,
-    quant_output: bool,
-    output_tensor_method: str,
-):
-    # Quantize the model
-    quantize_cmd = ["llama-quantize"]
-
-    if quant_embedding:
-        quantize_cmd.append("--token-embedding-type")
-        quantize_cmd.append(embedding_tensor_method)
-    if leave_output:
-        quantize_cmd.append("--leave-output-tensor")
-    else:
-        if quant_output:
-            quantize_cmd.append("--output-tensor-type")
-            quantize_cmd.append(output_tensor_method)
-
-    if use_imatrix:
-        train_data_path = "calibration_data_v5_rc.txt" #fallback calibration dataset
-        # if train_data_file:
-        #     train_data_path = train_data_file.name
-
-        print(f"Training data file path: {train_data_path}")
-
-        if not os.path.isfile(train_data_path):
-            raise Exception(f"Training data file not found: {train_data_path}")
-
-        generate_importance_matrix(fp16, train_data_path, imatrix_file)
-
-        quantize_cmd.append("--imatrix")
-        quantize_cmd.append(imatrix_file)
-    else:
-        print("Not using imatrix quantization.")
-
-    quantized_gguf = f"{outdir}/{gguf_name}"
-    quantize_cmd.append(fp16)
-    quantize_cmd.append(quantized_gguf)
-
-    if use_imatrix:
-        quantize_cmd.append(imatrix_q_method)
-    else:
-        quantize_cmd.append(q_method)
-
-    print(f"Quantizing model with {quantize_cmd}")
-    result = subprocess.run(quantize_cmd, shell=False, capture_output=True)
-    if result.returncode != 0:
-        stderr_str = result.stderr.decode("utf-8")
-        raise Exception(f"Error quantizing: {stderr_str}")
-
-    print(f"Quantized successfully with {imatrix_q_method if use_imatrix else q_method} option!")
-    print(f"Quantized model path: {os.path.abspath(quantized_gguf)}")
-    return quantized_gguf
-
-def generate_readme(outdir: str, token: str, model_id: str, new_repo_id: str, gguf_name: str):
-    creator = get_model_creator(model_id)
-    model_name = get_model_name(model_id)
-    username = whoami(token)["name"]
-
-    try:
-        card = ModelCard.load(model_id, token=token)
-    except:
-        card = ModelCard("")
-
-    if card.data.tags is None:
-        card.data.tags = []
-
-    card.data.tags.append("llama-cpp")
-    card.data.tags.append("gguf-my-repo")
-    card.data.base_model = model_id
-    card.text = dedent(
-        f"""
-# {model_name}
+            raise GGUFConverterError(f"Error quantizing: {stderr_str}")
+
+        print(f"Quantized successfully with {quant_config.imatrix_method if quant_config.use_imatrix else quant_config.method} option!")
+        print(f"Quantized model path: {os.path.abspath(quantized_gguf)}")
+        return quantized_gguf
 
+    def _generate_readme(self, outdir: str, token: str, model_id: str,
+                        new_repo_id: str, gguf_name: str) -> str:
+        """Generate README.md for the quantized model."""
+        creator = self._get_model_creator(model_id)
+        model_name = self._get_model_name(model_id)
+        username = whoami(token)["name"]
+
+        try:
+            card = ModelCard.load(model_id, token=token)
+        except:
+            card = ModelCard("")
+
+        if card.data.tags is None:
+            card.data.tags = []
+        card.data.tags.extend(["llama-cpp", "gguf-my-repo"])
+        card.data.base_model = model_id
+
+        card.text = dedent(
+            f"""
+# {model_name}
 **Model creator:** [{creator}](https://huggingface.co/{creator})<br/>
 **Original model**: [{model_id}](https://huggingface.co/{model_id})<br/>
 **GGUF quantization:** provided by [{username}](https:/huggingface.co/{username}) using `llama.cpp`<br/>
-
 ## Special thanks
-
 🙏 Special thanks to [Georgi Gerganov](https://github.com/ggerganov) and the whole team working on [llama.cpp](https://github.com/ggerganov/llama.cpp/) for making all of this possible.
-
 ## Use with Ollama
-
 ```bash
 ollama run "hf.co/{new_repo_id}:<quantization>"
 ```
-
 ## Use with LM Studio
-
 ```bash
 lms load "{new_repo_id}"
 ```
-
 ## Use with llama.cpp CLI
-
 ```bash
 llama-cli --hf-repo "{new_repo_id}" --hf-file "{gguf_name}" -p "The meaning to life and the universe is"
 ```
-
 ## Use with llama.cpp Server:
-
 ```bash
 llama-server --hf-repo "{new_repo_id}" --hf-file "{gguf_name}" -c 4096
 ```
-        """
-    )
-    readme_path = f"{outdir}/README.md"
-    card.save(readme_path)
-    return readme_path
-
-def process_model(
-    model_id: str,
-    q_method: str,
-    use_imatrix: bool,
-    imatrix_q_method: str,
-    private_repo: bool,
-    train_data_file,
-    repo_name: str,
-    gguf_name: str,
-    quant_embedding: bool,
-    embedding_tensor_method: str,
-    leave_output: bool,
-    quant_output: bool,
-    output_tensor_method: str,
-    split_model: bool,
-    split_max_tensors,
-    split_max_size: str | None,
-    oauth_token: gr.OAuthToken | None,
-):
-    validate_token(oauth_token)
-    token = oauth_token.token
-
-    print(f"Current working directory: {os.path.abspath(os.getcwd())}")
-    create_folder(DOWNLOAD_FOLDER)
-    create_folder(OUTPUT_FOLDER)
-
-    model_name = get_model_name(model_id)
-
-    try:
-        with tempfile.TemporaryDirectory(dir=OUTPUT_FOLDER) as outDirObj:
-            outdir = create_folder(os.path.join(OUTPUT_FOLDER, model_name)) if RUN_LOCALLY == "1" else Path(outDirObj)
-            fp16 = download_base_model(token, model_id, outdir)
-            imatrix_file = f"{outdir}/{model_name}-imatrix.dat"
-            quantized_gguf = quantize_model(outdir, gguf_name, fp16, q_method, use_imatrix, imatrix_q_method, imatrix_file, quant_embedding, embedding_tensor_method, leave_output, quant_output, output_tensor_method)
-
-            # Create empty repo
-            api = HfApi(token=token)
-            new_repo_url = api.create_repo(repo_id=repo_name, exist_ok=True, private=private_repo)
-            new_repo_id = new_repo_url.repo_id
-            print("Repo created successfully!", new_repo_url)
-
-            # Upload model
-            if split_model:
-                print(f"Splitting quantized model: {os.path.abspath(quantized_gguf)}")
-                split_upload_model(quantized_gguf, outdir, new_repo_id, token, split_max_tensors, split_max_size)
-            else:
-                try:
-                    print(f"Uploading quantized model: {os.path.abspath(quantized_gguf)}")
-                    upload_file(
-                        token=token,
-                        path_or_fileobj=quantized_gguf,
-                        path_in_repo=gguf_name,
-                        repo_id=new_repo_id,
-                    )
-                except Exception as e:
-                    raise Exception(f"Error uploading quantized model: {e}")
-
-            if os.path.isfile(imatrix_file):
-                try:
-                    print(f"Uploading imatrix.dat: {os.path.abspath(output_path)}")
-                    upload_file(
-                        token=token,
-                        path_or_fileobj=imatrix_file,
-                        path_in_repo="imatrix.dat",
-                        repo_id=new_repo_id,
-                    )
-                except Exception as e:
-                    raise Exception(f"Error uploading imatrix.dat: {e}")
+            """
+        )
+
+        readme_path = f"{outdir}/README.md"
+        card.save(readme_path)
+        return readme_path
 
-            # Upload README.md
-            readme_path = generate_readme(outdir, token, model_id, new_repo_id, gguf_name)
+    def process_model(self, model_id: str, quant_config: QuantizationConfig,
+                     split_config: SplitConfig, output_config: OutputConfig,
+                     oauth_token: Optional[gr.OAuthToken]) -> Tuple[str, str]:
+        """Main method to process a model through the entire pipeline."""
+        try:
+            token = self._validate_token(oauth_token)
+            print(f"Current working directory: {os.path.abspath(os.getcwd())}")
+
+            model_name = self._get_model_name(model_id)
+
+            with tempfile.TemporaryDirectory(dir=self.OUTPUT_FOLDER) as outDirObj:
+                outdir = (
+                    self._create_folder(os.path.join(self.OUTPUT_FOLDER, model_name))
+                    if self.RUN_LOCALLY == "1"
+                    else Path(outDirObj)
+                )
 
-            upload_file(
-                token=token,
-                path_or_fileobj=readme_path,
-                path_in_repo="README.md",
-                repo_id=new_repo_id,
+                fp16 = self._download_base_model(token, model_id, outdir)
+                quantized_gguf = self._quantize_model(outdir, output_config.filename, fp16, quant_config)
+
+                # Create empty repo
+                api = HfApi(token=token)
+                new_repo_url = api.create_repo(
+                    repo_id=output_config.repo_name,
+                    exist_ok=True,
+                    private=output_config.private_repo
+                )
+                new_repo_id = new_repo_url.repo_id
+                print("Repo created successfully!", new_repo_url)
+
+                # Upload model
+                if split_config.enabled:
+                    print(f"Splitting quantized model: {os.path.abspath(quantized_gguf)}")
+                    self._split_and_upload_model(quantized_gguf, outdir, new_repo_id, token, split_config)
+                else:
+                    try:
+                        print(f"Uploading quantized model: {os.path.abspath(quantized_gguf)}")
+                        self._upload_file(token, quantized_gguf, output_config.filename, new_repo_id)
+                    except Exception as e:
+                        raise GGUFConverterError(f"Error uploading quantized model: {e}")
+
+                # Upload imatrix if it exists
+                imatrix_file = f"{outdir}/{model_name}-imatrix.dat"
+                if os.path.isfile(imatrix_file):
+                    try:
+                        print(f"Uploading imatrix.dat: {os.path.abspath(imatrix_file)}")
+                        self._upload_file(token, imatrix_file, "imatrix.dat", new_repo_id)
+                    except Exception as e:
+                        raise GGUFConverterError(f"Error uploading imatrix.dat: {e}")
+
+                # Upload README.md
+                readme_path = self._generate_readme(outdir, token, model_id, new_repo_id, output_config.filename)
+                self._upload_file(token, readme_path, "README.md", new_repo_id)
+
+                print(f"Uploaded successfully with {quant_config.imatrix_method if quant_config.use_imatrix else quant_config.method} option!")
+
+            return (
+                f'<h1>✅ DONE</h1><br/>Find your repo here: <a href="{new_repo_url}" target="_blank" style="text-decoration:underline">{new_repo_id}</a>',
+                "llama.png",
             )
-            print(f"Uploaded successfully with {imatrix_q_method if use_imatrix else q_method} option!")
 
-        # end of the TemporaryDirectory(dir="outputs") block; temporary outputs are deleted here
+        except Exception as e:
+            print(f"Error processing model: {e}")
+            return (f'<h1>❌ ERROR</h1><br/><pre style="white-space:pre-wrap;">{self._escape_html(str(e))}</pre>', "error.png")
+
+
+class GGUFConverterUI:
+    """Gradio UI for the GGUF Converter."""
+
+    def __init__(self):
+        self.processor = HuggingFaceModelProcessor()
+        self.css = """/* Custom CSS to allow scrolling */
+        .gradio-container {overflow-y: auto;}
+        """
+
+        # Initialize components
+        self._initialize_components()
+        self._setup_interface()
+
+    def _initialize_components(self):
+        """Initialize all UI components."""
+        #####
+        # Base model section
+        #####
+        self.model_id = HuggingfaceHubSearch(
+            label="Hub Model ID",
+            placeholder="Search for model id on Huggingface",
+            search_type="model",
+        )
+
+        #####
+        # Quantization section
+        #####
+        self.use_imatrix = gr.Checkbox(
+            value=False,
+            label="Use Imatrix Quantization",
+            info="Use importance matrix for quantization."
+        )
+        self.q_method = gr.Dropdown(
+            choices=["Q2_K", "Q3_K_S", "Q3_K_M", "Q3_K_L", "Q4_0", "Q4_K_S", "Q4_K_M", "Q5_0", "Q5_K_S", "Q5_K_M", "Q6_K", "Q8_0", "F16", "BF16"],
+            label="Quantization Method",
+            info="GGML quantization type",
+            value="Q4_K_M",
+            filterable=False,
+            visible=True
+        )
+        self.imatrix_q_method = gr.Dropdown(
+            choices=["IQ3_M", "IQ3_XXS", "Q4_K_M", "Q4_K_S", "IQ4_NL", "IQ4_XS", "Q5_K_M", "Q5_K_S"],
+            label="Imatrix Quantization Method",
+            info="GGML imatrix quants type",
+            value="IQ4_NL",
+            filterable=False,
+            visible=False
+        )
+        self.train_data_file = gr.File(
+            label="Training Data File",
+            file_types=[".txt"],
+            visible=False
+        )
+
+        #####
+        # Advanced Options section
+        #####
+        self.split_model = gr.Checkbox(
+            value=False,
+            label="Split Model",
+            info="Shard the model using gguf-split."
+        )
+        self.split_max_tensors = gr.Number(
+            value=256,
+            label="Max Tensors per File",
+            info="Maximum number of tensors per file when splitting model.",
+            visible=False
+        )
+        self.split_max_size = gr.Textbox(
+            label="Max File Size",
+            info="Maximum file size when splitting model (--split-max-size). May leave empty to use the default. Accepted suffixes: M, G. Example: 256M, 5G",
+            visible=False
+        )
+        self.leave_output = gr.Checkbox(
+            value=False,
+            label="Leave output tensor",
+            info="Leaves output.weight un(re)quantized"
+        )
+        self.quant_embedding = gr.Checkbox(
+            value=False,
+            label="Quant embeddings tensor",
+            info="Quantize embeddings tensor separately"
+        )
+        self.embedding_tensor_method = gr.Dropdown(
+            choices=["Q2_K", "Q3_K", "Q4_K", "Q5_K", "Q6_K", "Q8_0"],
+            label="Output Quantization Method",
+            info="use a specific quant type for the token embeddings tensor",
+            value="Q8_0",
+            filterable=False,
+            visible=False
+        )
+        self.quant_output = gr.Checkbox(
+            value=False,
+            label="Quant output tensor",
+            info="Quantize output tensor separately"
+        )
+        self.output_tensor_method = gr.Dropdown(
+            choices=["Q2_K", "Q3_K", "Q4_K", "Q5_K", "Q6_K", "Q8_0"],
+            label="Output Quantization Method",
+            info="use a specific quant type for the output.weight tensor",
+            value="Q8_0",
+            filterable=False,
+            visible=False
+        )
+
+        #####
+        # Output Settings section
+        #####
+        self.private_repo = gr.Checkbox(
+            value=False,
+            label="Private Repo",
+            info="Create a private repo under your username."
+        )
+        self.repo_name = gr.Textbox(
+            label="Output Repository Name",
+            info="Set your repository name",
+            max_lines=1
+        )
+        self.gguf_name = gr.Textbox(
+            label="Output File Name",
+            info="Set output file name",
+            max_lines=1
+        )
 
-        return (
-            f'<h1>✅ DONE</h1><br/>Find your repo here: <a href="{new_repo_url}" target="_blank" style="text-decoration:underline">{new_repo_id}</a>',
-            "llama.png",
+        #####
+        # Buttons section
+        #####
+        self.clear_btn = gr.ClearButton(
+            value="Clear",
+            variant="secondary",
+            components=[
+                self.model_id,
+                self.q_method,
+                self.use_imatrix,
+                self.imatrix_q_method,
+                self.private_repo,
+                self.train_data_file,
+                self.leave_output,
+                self.quant_embedding,
+                self.embedding_tensor_method,
+                self.quant_output,
+                self.output_tensor_method,
+                self.split_model,
+                self.split_max_tensors,
+                self.split_max_size,
+                self.repo_name,
+                self.gguf_name,
+            ]
         )
-    except Exception as e:
-        print((f"Error processing model: {e}"))
-        return (f'<h1>❌ ERROR</h1><br/><pre style="white-space:pre-wrap;">{escape(str(e))}</pre>', "error.png")
-
-
-css="""/* Custom CSS to allow scrolling */
-.gradio-container {overflow-y: auto;}
-"""
-#####
-# Base model section
-#####
-model_id = HuggingfaceHubSearch(
-    label="Hub Model ID",
-    placeholder="Search for model id on Huggingface",
-    search_type="model",
-)
-
-#####
-# Quantization section
-#####
-use_imatrix = gr.Checkbox(
-    value=False,
-    label="Use Imatrix Quantization",
-    info="Use importance matrix for quantization."
-)
-
-q_method = gr.Dropdown(
-    choices=["Q2_K", "Q3_K_S", "Q3_K_M", "Q3_K_L", "Q4_0", "Q4_K_S", "Q4_K_M", "Q5_0", "Q5_K_S", "Q5_K_M", "Q6_K", "Q8_0", "F16", "BF16"],
-    label="Quantization Method",
-    info="GGML quantization type",
-    value="Q4_K_M",
-    filterable=False,
-    visible=True
-)
-
-imatrix_q_method = gr.Dropdown(
-    choices=["IQ3_M", "IQ3_XXS", "Q4_K_M", "Q4_K_S", "IQ4_NL", "IQ4_XS", "Q5_K_M", "Q5_K_S"],
-    label="Imatrix Quantization Method",
-    info="GGML imatrix quants type",
-    value="IQ4_NL",
-    filterable=False,
-    visible=False
-)
-
-train_data_file = gr.File(
-    label="Training Data File",
-    file_types=[".txt"],
-    visible=False
-)
-
-#####
-# Advanced Options section
-#####
-split_model = gr.Checkbox(
-    value=False,
-    label="Split Model",
-    info="Shard the model using gguf-split."
-)
-
-split_max_tensors = gr.Number(
-    value=256,
-    label="Max Tensors per File",
-    info="Maximum number of tensors per file when splitting model.",
-    visible=False
-)
-
-split_max_size = gr.Textbox(
-    label="Max File Size",
-    info="Maximum file size when splitting model (--split-max-size). May leave empty to use the default. Accepted suffixes: M, G. Example: 256M, 5G",
-    visible=False
-)
-
-leave_output = gr.Checkbox(
-    value=False,
-    label="Leave output tensor",
-    info="Leaves output.weight un(re)quantized"
-)
-
-quant_embedding = gr.Checkbox(
-    value=False,
-    label="Quant embeddings tensor",
-    info="Quantize embeddings tensor separately"
-)
-embedding_tensor_method = gr.Dropdown(
-    choices=["Q2_K", "Q3_K", "Q4_K", "Q5_K", "Q6_K", "Q8_0"],
-    label="Output Quantization Method",
-    info="use a specific quant type for the token embeddings tensor",
-    value="Q8_0",
-    filterable=False,
-    visible=False
-)
-
-quant_output = gr.Checkbox(
-    value=False,
-    label="Quant output tensor",
-    info="Quantize output tensor separately"
-)
-output_tensor_method = gr.Dropdown(
-    choices=["Q2_K", "Q3_K", "Q4_K", "Q5_K", "Q6_K", "Q8_0"],
-    label="Output Quantization Method",
-    info="use a specific quant type for the output.weight tensor",
-    value="Q8_0",
-    filterable=False,
-    visible=False
-)
-
-#####
-# Output Settings section
-#####
-private_repo = gr.Checkbox(
-    value=False,
-    label="Private Repo",
-    info="Create a private repo under your username."
-)
-
-repo_name = gr.Textbox(
-    label="Output Repository Name",
-    info="Set your repository name",
-    max_lines=1
-)
-
-gguf_name = gr.Textbox(
-    label="Output File Name",
-    info="Set output file name",
-    max_lines=1
-)
-
-def update_output_repo(model_id, oauth_token: gr.OAuthToken | None):
-    if oauth_token is None or not oauth_token.token:
-        return ""
-
-    if not model_id:
-        return ""
-
-    username = whoami(oauth_token.token)["name"]
-    model_name = get_model_name(model_id)
-    return f"{username}/{model_name}-GGUF"
-
-def update_output_filename(model_id, use_imatrix, q_method, imatrix_q_method):
-    if not model_id:
-        return ""
-
-    model_name = get_model_name(model_id)
-
-    if use_imatrix:
-        return f"{model_name}-{imatrix_q_method.upper()}-imat.gguf"
-
-    return f"{model_name}-{q_method.upper()}.gguf"
-
-#####
-# Buttons section
-#####
-clear_btn = gr.ClearButton(
-    value="Clear",
-    variant="secondary",
-    components=[
-        model_id,
-        q_method,
-        use_imatrix,
-        imatrix_q_method,
-        private_repo,
-        train_data_file,
-        leave_output,
-        quant_embedding,
-        embedding_tensor_method,
-        quant_output,
-        output_tensor_method,
-        split_model,
-        split_max_tensors,
-        split_max_size,
-        repo_name,
-        gguf_name,
-    ]
-)
-submit_btn = gr.Button(
-    value="Submit",
-    variant="primary"
-)
-
-#####
-# Outputs section
-#####
-output_label = gr.Markdown(label="output")
-
-output_image = gr.Image(
-    show_label=False,
-    show_download_button=False,
-    interactive=False
-)
-
-# Create Gradio interface
-with gr.Blocks(css=css) as demo:
-    #####
-    # Layout
-    #####
-    gr.Markdown(ERROR_LOGIN)
-    gr.LoginButton(min_width=250)
-
-    gr.HTML("<h1 style=\"text-aling:center;\">Create your own GGUF Quants!</h1>")
-    gr.Markdown(f"The space takes an HF repo as an input, quantizes it and creates a Public repo containing the selected quant under your HF user namespace.<br/>Use via {SPACE_URL}")
-
-    with gr.Row():
-        with gr.Column() as inputs:
-            gr.Markdown("### Model Configuration")
-            model_id.render()
-
-            with gr.Column():
-                use_imatrix.render()
-                q_method.render()
-                imatrix_q_method.render()
-                train_data_file.render()
-
-            gr.Markdown("### Advanced Options")
-
-            quant_embedding.render()
-            embedding_tensor_method.render()
-            leave_output.render()
-            quant_output.render()
-            output_tensor_method.render()
-
-            split_model.render()
-            with gr.Row() as split_options:  # Group split options
-                split_max_tensors.render()
-                split_max_size.render()
-
-            gr.Markdown("### Output Settings")
-            gr.Markdown("You can customize settings for your GGUF repo.")
-            private_repo.render()
+        self.submit_btn = gr.Button(
+            value="Submit",
+            variant="primary"
+        )
+
+        #####
+        # Outputs section
+        #####
+        self.output_label = gr.Markdown(label="output")
+        self.output_image = gr.Image(
+            show_label=False,
+            show_download_button=False,
+            interactive=False
+        )
+
+    @staticmethod
+    def _update_output_repo(model_id: str, oauth_token: gr.OAuthToken | None) -> str:
+        """Update output repository name based on model and user."""
+        if oauth_token is None or not oauth_token.token:
+            return ""
+        if not model_id:
+            return ""
+        try:
+            username = whoami(oauth_token.token)["name"]
+            model_name = model_id.split('/')[-1]
+            return f"{username}/{model_name}-GGUF"
+        except:
+            return ""
+
+    @staticmethod
+    def _update_output_filename(model_id: str, use_imatrix: bool, q_method: str, imatrix_q_method: str) -> str:
+        """Update output filename based on model and quantization settings."""
+        if not model_id:
+            return ""
+        model_name = model_id.split('/')[-1]
+        if use_imatrix:
+            return f"{model_name}-{imatrix_q_method.upper()}-imat.gguf"
+        return f"{model_name}-{q_method.upper()}.gguf"
+
+    def _setup_interface(self):
+        """Set up the Gradio interface."""
+        with gr.Blocks(css=self.css) as self.demo:
+            #####
+            # Layout
+            #####
+            gr.Markdown(HuggingFaceModelProcessor.ERROR_LOGIN)
+            gr.LoginButton(min_width=250)
+            gr.HTML("<h1 style=\"text-aling:center;\">Create your own GGUF Quants!</h1>")
+            gr.Markdown(f"The space takes an HF repo as an input, quantizes it and creates a Public repo containing the selected quant under your HF user namespace.<br/>Use via {self.processor.SPACE_URL}")
+
             with gr.Row():
-                repo_name.render()
-                gguf_name.render()
-
-            # Buttons
-            with gr.Row() as buttons:
-                clear_btn.render()
-                submit_btn.render()
-
-        with gr.Column() as outputs:
-            output_image.render()
-            output_label.render()
-
-    #####
-    # Button Click handlers
-    #####
-    submit_btn.click(
-        fn=process_model,
-        inputs=[
-            model_id,
-            q_method,
-            use_imatrix,
-            imatrix_q_method,
-            private_repo,
-            train_data_file,
-            repo_name,
-            gguf_name,
-            quant_embedding,
-            embedding_tensor_method,
-            leave_output,
-            quant_output,
-            output_tensor_method,
-            split_model,
-            split_max_tensors,
-            split_max_size
-        ],
-        outputs=[
-            output_label,
-            output_image,
-        ],
-    )
-
-    #####
-    # OnChange handlers
-    #####
-    use_imatrix.change(
-        fn=lambda use_imatrix: [gr.update(visible=not use_imatrix), gr.update(visible=use_imatrix), gr.update(visible=use_imatrix)],
-        inputs=use_imatrix,
-        outputs=[q_method, imatrix_q_method, train_data_file]
-    )
-
-    split_model.change(
-        fn=lambda split_model: [gr.update(visible=split_model), gr.update(visible=split_model)],
-        inputs=split_model,
-        outputs=[split_max_tensors, split_max_size]
-    )
-
-    quant_embedding.change(
-        fn=lambda quant_embedding: gr.update(visible=quant_embedding),
-        inputs=quant_embedding,
-        outputs=[embedding_tensor_method]
-    )
-
-    quant_output.change(
-        fn=lambda quant_output: [gr.update(visible=quant_output), gr.update(visible=not quant_output)],
-        inputs=quant_output,
-        outputs=[output_tensor_method, leave_output]
-    )
-
-    model_id.change(
-        fn=update_output_repo,
-        inputs=model_id,
-        outputs=[repo_name]
-    )
-
-    model_id.change(
-        fn=update_output_filename,
-        inputs=[model_id, use_imatrix, q_method, imatrix_q_method],
-        outputs=[gguf_name]
-    )
-    use_imatrix.change(
-        fn=update_output_filename,
-        inputs=[model_id, use_imatrix, q_method, imatrix_q_method],
-        outputs=[gguf_name]
-    )
-    q_method.change(
-        fn=update_output_filename,
-        inputs=[model_id, use_imatrix, q_method, imatrix_q_method],
-        outputs=[gguf_name]
-    )
-    imatrix_q_method.change(
-        fn=update_output_filename,
-        inputs=[model_id, use_imatrix, q_method, imatrix_q_method],
-        outputs=[gguf_name]
-    )
-
-def restart_space():
-    HfApi().restart_space(repo_id=SPACE_ID, token=HF_TOKEN, factory_reboot=True)
-
-scheduler = BackgroundScheduler()
-scheduler.add_job(restart_space, "interval", seconds=21600)
-scheduler.start()
-
-# Launch the interface
-demo.queue(default_concurrency_limit=1, max_size=5).launch(debug=True, show_api=False)
+                with gr.Column() as inputs:
+                    gr.Markdown("### Model Configuration")
+                    self.model_id.render()
+                    with gr.Column():
+                        self.use_imatrix.render()
+                        self.q_method.render()
+                        self.imatrix_q_method.render()
+                        self.train_data_file.render()
+                    gr.Markdown("### Advanced Options")
+                    self.quant_embedding.render()
+                    self.embedding_tensor_method.render()
+                    self.leave_output.render()
+                    self.quant_output.render()
+                    self.output_tensor_method.render()
+                    self.split_model.render()
+                    with gr.Row() as split_options:
+                        self.split_max_tensors.render()
+                        self.split_max_size.render()
+                    gr.Markdown("### Output Settings")
+                    gr.Markdown("You can customize settings for your GGUF repo.")
+                    self.private_repo.render()
+                    with gr.Row():
+                        self.repo_name.render()
+                        self.gguf_name.render()
+                    # Buttons
+                    with gr.Row() as buttons:
+                        self.clear_btn.render()
+                        self.submit_btn.render()
+                with gr.Column() as outputs:
+                    self.output_image.render()
+                    self.output_label.render()
+
+            #####
+            # Event handlers
+            #####
+            self.submit_btn.click(
+                fn=self._process_model_wrapper,
+                inputs=[
+                    self.model_id,
+                    self.q_method,
+                    self.use_imatrix,
+                    self.imatrix_q_method,
+                    self.private_repo,
+                    self.train_data_file,
+                    self.repo_name,
+                    self.gguf_name,
+                    self.quant_embedding,
+                    self.embedding_tensor_method,
+                    self.leave_output,
+                    self.quant_output,
+                    self.output_tensor_method,
+                    self.split_model,
+                    self.split_max_tensors,
+                    self.split_max_size
+                ],
+                outputs=[
+                    self.output_label,
+                    self.output_image,
+                ],
+            )
+
+            #####
+            # OnChange handlers
+            #####
+            self.use_imatrix.change(
+                fn=lambda use_imatrix: [gr.update(visible=not use_imatrix), gr.update(visible=use_imatrix), gr.update(visible=use_imatrix)],
+                inputs=self.use_imatrix,
+                outputs=[self.q_method, self.imatrix_q_method, self.train_data_file]
+            )
+            self.split_model.change(
+                fn=lambda split_model: [gr.update(visible=split_model), gr.update(visible=split_model)],
+                inputs=self.split_model,
+                outputs=[self.split_max_tensors, self.split_max_size]
+            )
+            self.quant_embedding.change(
+                fn=lambda quant_embedding: gr.update(visible=quant_embedding),
+                inputs=self.quant_embedding,
+                outputs=[self.embedding_tensor_method]
+            )
+            self.quant_output.change(
+                fn=lambda quant_output: [gr.update(visible=quant_output), gr.update(visible=not quant_output)],
+                inputs=self.quant_output,
+                outputs=[self.output_tensor_method, self.leave_output]
+            )
+            self.model_id.change(
+                fn=self._update_output_repo,
+                inputs=[self.model_id],
+                outputs=[self.repo_name]
+            )
+            self.model_id.change(
+                fn=self._update_output_filename,
+                inputs=[self.model_id, self.use_imatrix, self.q_method, self.imatrix_q_method],
+                outputs=[self.gguf_name]
+            )
+            self.use_imatrix.change(
+                fn=self._update_output_filename,
+                inputs=[self.model_id, self.use_imatrix, self.q_method, self.imatrix_q_method],
+                outputs=[self.gguf_name]
+            )
+            self.q_method.change(
+                fn=self._update_output_filename,
+                inputs=[self.model_id, self.use_imatrix, self.q_method, self.imatrix_q_method],
+                outputs=[self.gguf_name]
+            )
+            self.imatrix_q_method.change(
+                fn=self._update_output_filename,
+                inputs=[self.model_id, self.use_imatrix, self.q_method, self.imatrix_q_method],
+                outputs=[self.gguf_name]
+            )
+
+    def _process_model_wrapper(self, model_id: str, q_method: str, use_imatrix: bool,
+                              imatrix_q_method: str, private_repo: bool, train_data_file,
+                              repo_name: str, gguf_name: str, quant_embedding: bool,
+                              embedding_tensor_method: str, leave_output: bool,
+                              quant_output: bool, output_tensor_method: str,
+                              split_model: bool, split_max_tensors, split_max_size: str) -> Tuple[str, str]:
+        """Wrapper for the process_model method to handle the conversion."""
+        # Create configuration objects
+        quant_config = QuantizationConfig(
+            method=q_method,
+            use_imatrix=use_imatrix,
+            imatrix_method=imatrix_q_method,
+            quant_embedding=quant_embedding,
+            embedding_tensor_method=embedding_tensor_method,
+            leave_output=leave_output,
+            quant_output=quant_output,
+            output_tensor_method=output_tensor_method
+        )
+
+        split_config = SplitConfig(
+            enabled=split_model,
+            max_tensors=split_max_tensors,
+            max_size=split_max_size
+        )
+
+        output_config = OutputConfig(
+            private_repo=private_repo,
+            repo_name=repo_name,
+            filename=gguf_name
+        )
+
+        return self.processor.process_model(model_id, quant_config, split_config, output_config, gr.OAuthToken)
+
+    def launch(self):
+        """Launch the Gradio interface."""
+        # Set up space restart scheduler
+        def restart_space():
+            HfApi().restart_space(repo_id=self.processor.SPACE_ID, token=self.processor.HF_TOKEN, factory_reboot=True)
+
+        scheduler = BackgroundScheduler()
+        scheduler.add_job(restart_space, "interval", seconds=21600)
+        scheduler.start()
+
+        # Launch the interface
+        self.demo.queue(default_concurrency_limit=1, max_size=5).launch(debug=True, show_api=False)
+
+
+# Main execution
+if __name__ == "__main__":
+    ui = GGUFConverterUI()
+    ui.launch()