Can you help me turn this python app into a windows application that is standalone and is JIT complied ? code: import sys
import os
import pickle
import threading
from PyQt6.QtWidgets import (
    QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout,
    QLabel, QLineEdit, QPushButton, QFileDialog, QGridLayout, QScrollArea
)
from PyQt6.QtGui import QPixmap, QIcon
from PyQt6.QtCore import Qt, QSize
from transformers import CLIPModel, CLIPProcessor
import torch
from PIL import Image

class ImageSearchApp(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("AI Image Search")
        self.setWindowIcon(QIcon('icon.png'))  # Optional: Set your app icon
        self.setMinimumSize(800, 600)
        self.model, self.processor = self.load_model()
        self.image_embeddings = None
        self.image_paths = []
        self.embeddings_cache = {}
        self.cache_file = ''
        self.image_dir = ''
        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        self.model.to(self.device)
        self.init_ui()

    def init_ui(self):
        # Central widget
        central_widget = QWidget()
        self.setCentralWidget(central_widget)

        # Main layout
        main_layout = QVBoxLayout()
        central_widget.setLayout(main_layout)

        # Scroll area for images
        scroll_area = QScrollArea()
        scroll_widget = QWidget()
        self.grid_layout = QGridLayout()
        scroll_widget.setLayout(self.grid_layout)
        scroll_area.setWidgetResizable(True)
        scroll_area.setWidget(scroll_widget)
        main_layout.addWidget(scroll_area)

        # Search bar layout
        search_layout = QHBoxLayout()
        self.search_bar = QLineEdit()
        self.search_bar.setPlaceholderText("Type your prompt here...")
        self.search_bar.textChanged.connect(self.update_search_results)
        search_layout.addWidget(self.search_bar)

        # Settings button
        settings_button = QPushButton("Settings")
        settings_button.clicked.connect(self.open_settings)
        search_layout.addWidget(settings_button)
        main_layout.addLayout(search_layout)

        # Apply dark theme
        self.apply_dark_theme()

    def load_model(self):
        # Load CLIP model and processor
        model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
        processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")
        return model, processor

    def open_settings(self):
        # Open directory selection dialog
        dir_path = QFileDialog.getExistingDirectory(self, "Select Image Directory")
        if dir_path:
            self.image_dir = dir_path
            self.cache_file = os.path.join(self.image_dir, "embeddings_cache.pkl")
            self.load_images()
            self.index_images()

    def load_images(self):
        # Load image paths
        supported_formats = ('.png', '.jpg', '.jpeg', '.bmp', '.gif')
        self.image_paths = [
            os.path.join(self.image_dir, f)
            for f in os.listdir(self.image_dir)
            if f.lower().endswith(supported_formats)
        ]

    def index_images(self):
        # Load or compute image embeddings
        if os.path.exists(self.cache_file):
            with open(self.cache_file, 'rb') as f:
                self.image_embeddings = pickle.load(f)
        else:
            embeddings = []
            for img_path in self.image_paths:
                image = Image.open(img_path).convert("RGB")
                inputs = self.processor(images=image, return_tensors="pt").to(self.device)
                with torch.no_grad():
                    embedding = self.model.get_image_features(**inputs)
                    embedding = embedding / embedding.norm(p=2, dim=-1, keepdim=True)
                embeddings.append(embedding.cpu())
            self.image_embeddings = torch.vstack(embeddings)
            # Save embeddings to cache
            with open(self.cache_file, 'wb') as f:
                pickle.dump(self.image_embeddings, f)

        # Initial display of images
        self.display_images(self.image_paths)

    def update_search_results(self, text):
        if not text or not self.image_embeddings is not None:
            self.display_images(self.image_paths)
            return

        # Compute text embedding
        inputs = self.processor(text=[text], return_tensors="pt").to(self.device)
        with torch.no_grad():
            text_embedding = self.model.get_text_features(**inputs)
            text_embedding = text_embedding / text_embedding.norm(p=2, dim=-1, keepdim=True)

        # Compute similarities
        similarities = (self.image_embeddings @ text_embedding.T).squeeze(1)
        sorted_indices = similarities.argsort(descending=True)
        sorted_paths = [self.image_paths[i] for i in sorted_indices]

        # Update displayed images
        self.display_images(sorted_paths)

    def display_images(self, image_paths):
        # Clear grid layout
        for i in reversed(range(self.grid_layout.count())):
            widget = self.grid_layout.itemAt(i).widget()
            if widget:
                widget.setParent(None)

        # Display images in grid
        cols = 4  # Number of columns in the grid
        for index, img_path in enumerate(image_paths):
            row = index // cols
            col = index % cols
            pixmap = QPixmap(img_path).scaled(200, 200, Qt.AspectRatioMode.KeepAspectRatio, Qt.TransformationMode.SmoothTransformation)
            label = QLabel()
            label.setPixmap(pixmap)
            label.mousePressEvent = lambda event, p=img_path: self.show_full_image(p)
            self.grid_layout.addWidget(label, row, col)

    def show_full_image(self, img_path):
        # Display full-resolution image
        self.full_image_window = QWidget()
        self.full_image_window.setWindowTitle("Image Preview")
        vbox = QVBoxLayout()
        self.full_image_window.setLayout(vbox)
        pixmap = QPixmap(img_path)
        screen_rect = QApplication.primaryScreen().availableGeometry()
        screen_size = screen_rect.size()
        pixmap = pixmap.scaled(screen_size, Qt.AspectRatioMode.KeepAspectRatio, Qt.TransformationMode.SmoothTransformation)
        label = QLabel()
        label.setPixmap(pixmap)
        vbox.addWidget(label)
        self.full_image_window.showFullScreen()
        self.full_image_window.mousePressEvent = self.close_full_image

    def close_full_image(self, event):
        self.full_image_window.close()

    def apply_dark_theme(self):
        # Apply a dark theme stylesheet
        dark_stylesheet = """
            QWidget {
                background-color: #2b2b2b;
                color: #d3d3d3;
            }
            QLineEdit, QPushButton {
                background-color: #3c3c3c;
                border: 1px solid #555;
                padding: 5px;
                color: #d3d3d3;
            }
            QLabel {
                color: #d3d3d3;
            }
        """
        self.setStyleSheet(dark_stylesheet)

def main():
    app = QApplication(sys.argv)
    window = ImageSearchApp()
    window.show()
    sys.exit(app.exec())

if __name__ == "__main__":
    main()