# 📚 PyQt5 Tutorial - Part 3/6: Dialogs, Files & Threading
#PyQt5 #Python #Threading #FileDialogs #DragAndDrop

Welcome to Part 3 of our PyQt5 series! This comprehensive lesson dives into professional dialog handling, file operations, drag-and-drop functionality, and threading - essential for building production-grade applications.

---

## 🔹 Professional Dialog Handling
### 1. Standard Dialogs
PyQt5 provides built-in dialogs for common tasks:

from PyQt5.QtWidgets import (QFileDialog, QColorDialog, 
                            QFontDialog, QInputDialog, QMessageBox)

# File Dialog
file_path, _ = QFileDialog.getOpenFileName(
    self, "Open File", "", "Text Files (*.txt);;All Files (*)")

# Color Dialog
color = QColorDialog.getColor()

# Font Dialog
font, ok = QFontDialog.getFont()

# Input Dialog
text, ok = QInputDialog.getText(self, "Input", "Enter your name:")

# Message Box
reply = QMessageBox.question(
    self, "Message", "Are you sure?",
    QMessageBox.Yes | QMessageBox.No, QMessageBox.No)

### 2. Custom Dialog Classes
Create reusable dialog windows:

class LoginDialog(QDialog):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setWindowTitle("Login")
        
        self.username = QLineEdit()
        self.password = QLineEdit()
        self.password.setEchoMode(QLineEdit.Password)
        
        buttons = QDialogButtonBox(
            QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
        buttons.accepted.connect(self.accept)
        buttons.rejected.connect(self.reject)
        
        layout = QFormLayout()
        layout.addRow("Username:", self.username)
        layout.addRow("Password:", self.password)
        layout.addRow(buttons)
        
        self.setLayout(layout)
    
    def get_credentials(self):
        return (self.username.text(), self.password.text())

# Usage
dialog = LoginDialog()
if dialog.exec_():
    username, password = dialog.get_credentials()

---

## 🔹 File System Operations
### 1. File and Directory Handling

from PyQt5.QtCore import QDir, QFile, QFileInfo

# Check file existence
file_info = QFileInfo("path/to/file")
if file_info.exists():
    print("File size:", file_info.size())

# Directory operations
directory = QDir()
directory.mkdir("new_folder")
print("Current path:", directory.currentPath())

# File reading/writing
file = QFile("data.txt")
if file.open(QIODevice.ReadOnly | QIODevice.Text):
    stream = QTextStream(file)
    content = stream.readAll()
    file.close()

### 2. Monitoring File Changes

from PyQt5.QtCore import QFileSystemWatcher

class FileMonitor(QObject):
    def __init__(self):
        super().__init__()
        self.watcher = QFileSystemWatcher()
        self.watcher.fileChanged.connect(self.on_file_changed)
    
    def add_file(self, path):
        self.watcher.addPath(path)
    
    def on_file_changed(self, path):
        print(f"File changed: {path}")

monitor = FileMonitor()
monitor.add_file("important_file.txt")

---

## 🔹 Drag and Drop
### 1. Enabling Drag-and-Drop

class DropArea(QLabel):
    def __init__(self):
        super().__init__("Drop files here")
        self.setAcceptDrops(True)
        self.setAlignment(Qt.AlignCenter)
        self.setStyleSheet("border: 2px dashed #aaa;")
    
    def dragEnterEvent(self, event):
        if event.mimeData().hasUrls():
            event.acceptProposedAction()
    
    def dropEvent(self, event):
        for url in event.mimeData().urls():
            file_path = url.toLocalFile()
            print("Dropped file:", file_path)

### 2. Custom Drag Sources

class DraggableList(QListWidget):
    def __init__(self):
        super().__init__()
        self.setDragEnabled(True)
        self.setAcceptDrops(True)
        self.setDragDropMode(QAbstractItemView.InternalMove)
        
        for i in range(5):
            self.addItem(f"Item {i+1}")
    
    def startDrag(self, supportedActions):
        item = self.currentItem()
        mime_data = QMimeData()
        mime_data.setText(item.text())
        
        drag = QDrag(self)
        drag.setMimeData(mime_data)
        drag.exec_(Qt.MoveAction)

---

## 🔹 Threading with QThread
### 1. Worker Thread Pattern

class Worker(QObject):
    finished = pyqtSignal()
    progress = pyqtSignal(int)
    
    def run(self):
        for i in range(1, 101):
            time.sleep(0.1)
            self.progress.emit(i)
        self.finished.emit()

class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        
        self.thread = QThread()
        self.worker = Worker()
        self.worker.moveToThread(self.thread)
        
        self.thread.started.connect(self.worker.run)
        self.worker.finished.connect(self.thread.quit)
        self.worker.finished.connect(self.worker.deleteLater)
        self.thread.finished.connect(self.thread.deleteLater)
        self.worker.progress.connect(self.update_progress)
        
        self.thread.start()
    
    def update_progress(self, value):
        print("Progress:", value)

### 2. Thread Pool for Concurrent Tasks

from PyQt5.QtCore import QRunnable, QThreadPool

class Task(QRunnable):
    def __init__(self, task_id):
        super().__init__()
        self.task_id = task_id
    
    def run(self):
        print(f"Starting task {self.task_id}")
        time.sleep(2)
        print(f"Finished task {self.task_id}")

pool = QThreadPool.globalInstance()
for i in range(5):
    pool.start(Task(i))
print("Max threads:", pool.maxThreadCount())

---

## 🔹 Practical Example: File Processor

class FileProcessor(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setup_ui()
        self.setup_thread()
    
    def setup_ui(self):
        self.setWindowTitle("File Processor")
        
        # Central Widget
        widget = QWidget()
        layout = QVBoxLayout()
        
        # File Selection
        self.file_list = QListWidget()
        self.file_list.setSelectionMode(QAbstractItemView.MultiSelection)
        
        add_btn = QPushButton("Add Files")
        add_btn.clicked.connect(self.add_files)
        
        # Processing Controls
        self.progress = QProgressBar()
        process_btn = QPushButton("Process Files")
        process_btn.clicked.connect(self.process_files)
        
        # Layout
        layout.addWidget(QLabel("Files to Process:"))
        layout.addWidget(self.file_list)
        layout.addWidget(add_btn)
        layout.addWidget(self.progress)
        layout.addWidget(process_btn)
        
        widget.setLayout(layout)
        self.setCentralWidget(widget)
    
    def setup_thread(self):
        self.thread = QThread()
        self.worker = FileWorker()
        self.worker.moveToThread(self.thread)
        
        self.thread.started.connect(self.worker.process)
        self.worker.progress.connect(self.progress.setValue)
        self.worker.finished.connect(self.on_processing_finished)
        self.worker.error.connect(self.show_error)
    
    def add_files(self):
        files, _ = QFileDialog.getOpenFileNames(
            self, "Select Files", "", "All Files (*)")
        self.file_list.addItems(files)
    
    def process_files(self):
        if self.file_list.count() == 0:
            QMessageBox.warning(self, "Warning", "No files selected!")
            return
        
        files = [self.file_list.item(i).text() 
                for i in range(self.file_list.count())]
        self.worker.set_files(files)
        self.thread.start()
    
    def on_processing_finished(self):
        self.thread.quit()
        QMessageBox.information(self, "Done", "Processing completed!")

    def show_error(self, message):
        self.thread.quit()
        QMessageBox.critical(self, "Error", message)

class FileWorker(QObject):
    progress = pyqtSignal(int)
    finished = pyqtSignal()
    error = pyqtSignal(str)
    
    def __init__(self):
        super().__init__()
        self.files = []
    
    def set_files(self, files):
        self.files = files
    
    def process(self):
        try:
            total = len(self.files)
            for i, file in enumerate(self.files):
                # Simulate processing
                time.sleep(0.5)
                
                # Check for cancellation
                if QThread.currentThread().isInterruptionRequested():
                    break
                
                # Update progress
                self.progress.emit(int((i + 1) / total * 100))
            
            self.finished.emit()
        except Exception as e:
            self.error.emit(str(e))

---

## 🔹 Best Practices
1. Always clean up threads - Use finished signals
2. Never update UI from worker threads - Use signals
3. Validate file operations - Check permissions/existence
4. Handle drag-and-drop properly - Check MIME types
5. Make dialogs modal/non-modal appropriately - exec_() vs show()

---

### 📌 What's Next?
In Part 4, we'll cover:
➡️ Database Integration (SQLite, PostgreSQL)
➡️ Data Visualization (Charts, Graphs)
➡️ Model-View-Controller Pattern
➡️ Advanced Widget Customization

#PyQt5 #ProfessionalDevelopment #PythonGUI 🚀

Practice Exercise:
1. Build a thumbnail generator with progress reporting
2. Create a JSON config editor with file monitoring
3. Implement a thread-safe logging system for background tasks

# 📚 PyQt5 Tutorial - Part 4/6: Database Integration & Data Visualization
#PyQt5 #SQL #DataViz #MVC #ProfessionalDevelopment

Welcome to Part 4 of our PyQt5 series! This comprehensive lesson covers professional database integration, data visualization, and architectural patterns for building robust desktop applications.

---

## 🔹 Database Integration with PyQt5
### 1. SQLite Connection & Setup

from PyQt5.QtSql import QSqlDatabase, QSqlQuery

def setup_database():
    db = QSqlDatabase.addDatabase("QSQLITE")
    db.setDatabaseName("app_data.db")
    
    if not db.open():
        QMessageBox.critical(None, "Database Error", db.lastError().text())
        return False
    
    # Create tables if they don't exist
    query = QSqlQuery()
    query.exec_("""
        CREATE TABLE IF NOT EXISTS contacts (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            name TEXT NOT NULL,
            email TEXT UNIQUE,
            phone TEXT,
            created_at DATETIME DEFAULT CURRENT_TIMESTAMP
        )
    """)
    return True

### 2. SQL Model-View Integration

from PyQt5.QtSql import QSqlTableModel

class ContactManager(QWidget):
    def __init__(self):
        super().__init__()
        self.model = QSqlTableModel()
        self.model.setTable("contacts")
        self.model.select()
        
        self.setup_ui()
    
    def setup_ui(self):
        layout = QVBoxLayout()
        
        # Table View
        self.table = QTableView()
        self.table.setModel(self.model)
        self.table.setSelectionBehavior(QTableView.SelectRows)
        self.table.setEditTriggers(QTableView.DoubleClicked)
        
        # Buttons
        add_btn = QPushButton("Add Contact")
        add_btn.clicked.connect(self.add_contact)
        
        del_btn = QPushButton("Delete Selected")
        del_btn.clicked.connect(self.delete_contact)
        
        # Layout
        btn_layout = QHBoxLayout()
        btn_layout.addWidget(add_btn)
        btn_layout.addWidget(del_btn)
        
        layout.addWidget(self.table)
        layout.addLayout(btn_layout)
        self.setLayout(layout)
    
    def add_contact(self):
        name, ok = QInputDialog.getText(self, "Add Contact", "Name:")
        if ok and name:
            record = self.model.record()
            record.setValue("name", name)
            self.model.insertRecord(-1, record)
            self.model.submitAll()
    
    def delete_contact(self):
        selected = self.table.selectionModel().selectedRows()
        for index in sorted(selected, reverse=True):
            self.model.removeRow(index.row())
        self.model.submitAll()

### 3. PostgreSQL Connection

def connect_postgresql():
    db = QSqlDatabase.addDatabase("QPSQL")
    db.setHostName("localhost")
    db.setDatabaseName("myapp")
    db.setUserName("postgres")
    db.setPassword("password")
    db.setPort(5432)
    
    if not db.open():
        error = db.lastError()
        QMessageBox.critical(None, "Database Error", 
                           f"Code: {error.number()}\n{error.text()}")
        return False
    return True

---

## 🔹 Data Visualization
### 1. QtCharts Basic Setup

from PyQt5.QtChart import QChart, QChartView, QBarSet, QBarSeries, QBarCategoryAxis

class SalesChart(QWidget):
    def __init__(self, data):
        super().__init__()
        self.chart = QChart()
        self.chart.setTitle("Quarterly Sales")
        self.chart.setAnimationOptions(QChart.SeriesAnimations)
        
        self.setup_series(data)
        self.setup_axes()
        
        chart_view = QChartView(self.chart)
        chart_view.setRenderHint(QPainter.Antialiasing)
        
        layout = QVBoxLayout()
        layout.addWidget(chart_view)
        self.setLayout(layout)
    
    def setup_series(self, data):
        series = QBarSeries()
        
        for product, values in data.items():
            bar_set = QBarSet(product)
            bar_set.append(values)
            series.append(bar_set)
        
        self.chart.addSeries(series)
    
    def setup_axes(self):
        categories = ["Q1", "Q2", "Q3", "Q4"]
        
        axis_x = QBarCategoryAxis()
        axis_x.append(categories)
        self.chart.addAxis(axis_x, Qt.AlignBottom)
        
        axis_y = QValueAxis()
        axis_y.setRange(0, 1000)
        self.chart.addAxis(axis_y, Qt.AlignLeft)
        
        for series in self.chart.series():
            series.attachAxis(axis_x)
            series.attachAxis(axis_y)

### 2. Interactive Line Chart

from PyQt5.QtChart import QLineSeries, QValueAxis

class InteractiveChart(QChartView):
    def __init__(self, data):
        super().__init__()
        self.series = QLineSeries()
        self.series.setName("Data Series")
        
        for point in data:
            self.series.append(*point)
        
        self.chart = QChart()
        self.chart.addSeries(self.series)
        self.chart.createDefaultAxes()
        self.chart.setTitle("Interactive Chart")
        
        self.setChart(self.chart)
        self.setRubberBand(QChartView.RectangleRubberBand)
        self.setRenderHint(QPainter.Antialiasing)
    
    def mousePressEvent(self, event):
        if event.button() == Qt.LeftButton:
            point = self.chart.mapToValue(event.pos())
            self.series.append(point.x(), point.y())
        super().mousePressEvent(event)

### 3. Real-Time Data Visualization

class RealTimeChart(QThread):
    data_updated = pyqtSignal(list)
    
    def __init__(self):
        super().__init__()
        self.running = True
    
    def run(self):
        x = 0
        while self.running:
            time.sleep(0.1)
            y = random.randint(0, 100)
            self.data_updated.emit([(x, y)])
            x += 1
    
    def stop(self):
        self.running = False
        self.wait()

class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.series = QLineSeries()
        
        self.chart = QChart()
        self.chart.addSeries(self.series)
        self.chart.createDefaultAxes()
        
        self.chart_view = QChartView(self.chart)
        self.setCentralWidget(self.chart_view)
        
        self.thread = RealTimeChart()
        self.thread.data_updated.connect(self.update_chart)
        self.thread.start()
    
    def update_chart(self, points):
        for x, y in points:
            self.series.append(x, y)
            if self.series.count() > 100:
                self.series.remove(0)
            self.chart.axisX().setRange(x-100, x)
    
    def closeEvent(self, event):
        self.thread.stop()
        super().closeEvent(event)

---

## 🔹 Model-View-Controller (MVC) Pattern
### 1. MVC Implementation

# Model
class DataModel(QObject):
    data_changed = pyqtSignal(list)
    
    def __init__(self):
        super().__init__()
        self._data = []
    
    def load_data(self, source):
        # Simulate data loading
        self._data = [(i, random.randint(0, 100)) for i in range(10)]
        self.data_changed.emit(self._data)
    
    def get_data(self):
        return self._data

# View
class DataView(QWidget):
    def __init__(self, controller):
        super().__init__()
        self.controller = controller
        self.table = QTableWidget()
        
        layout = QVBoxLayout()
        layout.addWidget(self.table)
        self.setLayout(layout)
    
    def update_view(self, data):
        self.table.setRowCount(len(data))
        self.table.setColumnCount(2)
        
        for row, (x, y) in enumerate(data):
            self.table.setItem(row, 0, QTableWidgetItem(str(x)))
            self.table.setItem(row, 1, QTableWidgetItem(str(y)))

# Controller
class DataController:
    def __init__(self):
        self.model = DataModel()
        self.view = DataView(self)
        
        self.model.data_changed.connect(self.handle_data_change)
        self.model.load_data("dummy_source")
    
    def handle_data_change(self, data):
        self.view.update_view(data)
    
    def show_view(self):
        self.view.show()

### 2. Advanced MVC with SQL

class SqlController:
    def __init__(self):
        self.db = setup_database()  # From earlier example
        self.model = QSqlTableModel()
        self.model.setTable("contacts")
        self.model.select()
        
        self.view = ContactView(self)
    
    def add_contact(self, name, email, phone):
        record = self.model.record()
        record.setValue("name", name)
        record.setValue("email", email)
        record.setValue("phone", phone)
        return self.model.insertRecord(-1, record)
    
    def delete_contact(self, row):
        return self.model.removeRow(row)

class ContactView(QWidget):
    def __init__(self, controller):
        super().__init__()
        self.controller = controller
        self.setup_ui()
    
    def setup_ui(self):
        # Form setup
        self.name_input = QLineEdit()
        self.email_input = QLineEdit()
        self.phone_input = QLineEdit()
        
        add_btn = QPushButton("Add Contact")
        add_btn.clicked.connect(self.on_add)
        
        # Table setup
        self.table = QTableView()
        self.table.setModel(self.controller.model)
        
        # Layout
        form_layout = QFormLayout()
        form_layout.addRow("Name:", self.name_input)
        form_layout.addRow("Email:", self.email_input)
        form_layout.addRow("Phone:", self.phone_input)
        form_layout.addRow(add_btn)
        
        main_layout = QVBoxLayout()
        main_layout.addLayout(form_layout)
        main_layout.addWidget(self.table)
        
        self.setLayout(main_layout)
    
    def on_add(self):
        name = self.name_input.text()
        email = self.email_input.text()
        phone = self.phone_input.text()
        
        if name:
            if self.controller.add_contact(name, email, phone):
                self.controller.model.submitAll()
                self.clear_form()
    
    def clear_form(self):
        self.name_input.clear()
        self.email_input.clear()
        self.phone_input.clear()

---

## 🔹 Advanced Widget Customization
### 1. Custom Delegate for Table Views

class ProgressBarDelegate(QStyledItemDelegate):
    def paint(self, painter, option, index):
        progress = index.data(Qt.DisplayRole)
        
        # Draw background
        painter.save()
        painter.setPen(Qt.NoPen)
        painter.setBrush(QColor("#e0e0e0"))
        painter.drawRect(option.rect)
        
        # Draw progress
        if progress > 0:
            width = option.rect.width() * progress / 100
            progress_rect = QRectF(option.rect)
            progress_rect.setWidth(width)
            
            gradient = QLinearGradient(progress_rect.topLeft(), progress_rect.topRight())
            gradient.setColorAt(0, QColor("#4CAF50"))
            gradient.setColorAt(1, QColor("#2E7D32"))
            
            painter.setBrush(QBrush(gradient))
            painter.drawRect(progress_rect)
        
        # Draw text
        painter.setPen(QColor("#333"))
        painter.drawText(option.rect, Qt.AlignCenter, f"{progress}%")
        painter.restore()

# Usage
table = QTableView()
table.setItemDelegateForColumn(2, ProgressBarDelegate())

### 2. Custom Widget with QPainter

class GaugeWidget(QWidget):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.value = 0
        self.min_value = 0
        self.max_value = 100
    
    def set_value(self, value):
        self.value = max(self.min_value, min(value, self.max_value))
        self.update()
    
    def paintEvent(self, event):
        painter = QPainter(self)
        painter.setRenderHint(QPainter.Antialiasing)
        
        # Draw background
        rect = self.rect().adjusted(5, 5, -5, -5)
        painter.setPen(QPen(QColor("#333"), 2)
        painter.setBrush(QColor("#f5f5f5"))
        painter.drawEllipse(rect)
        
        # Draw gauge
        angle = 180 * (self.value - self.min_value) / (self.max_value - self.min_value)
        span_angle = -angle * 16  # 1/16th of a degree
        
        pen = QPen(QColor("#FF5722"), 10)
        pen.setCapStyle(Qt.RoundCap)
        painter.setPen(pen)
        
        painter.drawArc(rect, 180 * 16, span_angle)
        
        # Draw text
        font = painter.font()
        font.setPointSize(20)
        painter.setFont(font)
        painter.drawText(rect, Qt.AlignCenter, f"{self.value}%")

---

## 🔹 Best Practices
1. Separate database logic from UI code
2. Use transactions for batch database operations
3. Optimize chart performance with limited data points
4. Follow MVC pattern for complex applications
5. Document custom widgets thoroughly

---

### 📌 What's Next?
In Part 5, we'll cover:
➡️ Networking & Web APIs
➡️ Multimedia Applications
➡️ Internationalization
➡️ Deployment & Packaging

#PyQt5 #Database #DataVisualization 🚀

Practice Exercise:
1. Build a sales dashboard with database-backed charts
2. Create a custom weather widget with API data
3. Implement an MVC-based inventory management system

# 📚 PyQt5 Tutorial - Part 5/6: Networking, Multimedia & Internationalization
#PyQt5 #Networking #Multimedia #i18n #Deployment

Welcome to Part 5 of our PyQt5 series! This comprehensive lesson covers professional networking, multimedia handling, internationalization, and deployment strategies for production applications.

---

## 🔹 Networking with PyQt5
### 1. HTTP Requests with QNetworkAccessManager

from PyQt5.QtNetwork import QNetworkRequest, QNetworkAccessManager
from PyQt5.QtCore import QUrl

class ApiClient(QObject):
    response_received = pyqtSignal(str)
    error_occurred = pyqtSignal(str)

    def __init__(self):
        super().__init__()
        self.manager = QNetworkAccessManager()
        self.manager.finished.connect(self.handle_response)

    def fetch_data(self, url):
        request = QNetworkRequest(QUrl(url))
        self.manager.get(request)

    def handle_response(self, reply):
        if reply.error():
            self.error_occurred.emit(reply.errorString())
        else:
            data = reply.readAll().data().decode('utf-8')
            self.response_received.emit(data)
        reply.deleteLater()

# Usage
client = ApiClient()
client.response_received.connect(lambda data: print("Received:", data))
client.error_occurred.connect(lambda err: print("Error:", err))
client.fetch_data("https://api.example.com/data")

### 2. WebSocket Communication

from PyQt5.QtWebSockets import QWebSocket

class WebSocketClient(QObject):
    message_received = pyqtSignal(str)
    connected = pyqtSignal()
    disconnected = pyqtSignal()

    def __init__(self):
        super().__init__()
        self.socket = QWebSocket()
        self.socket.textMessageReceived.connect(self.message_received)
        self.socket.connected.connect(self.connected)
        self.socket.disconnected.connect(self.disconnected)

    def connect_to_server(self, url):
        self.socket.open(QUrl(url))

    def send_message(self, message):
        self.socket.sendTextMessage(message)

# Usage
ws_client = WebSocketClient()
ws_client.connect_to_server("ws://echo.websocket.org")
ws_client.iss.onessage_received.connect(print)

### 3. TCP Socket Server

from PyQt5.QtNetwork import QTcpServer, QTcpSocket

class TcpServer(QObject):
    new_connection = pyqtSignal(QTcpSocket)

    def __init__(self):
        super().__init__()
        self.server = QTcpServer()
        self.server.newConnection.connect(self.handle_new_connection)

    def start(self, port=12345):
        if not self.server.listen(QHostAddress.Any, port):
            print("Server error:", self.server.errorString())
            return False
        print(f"Server started on port {port}")
        return True

    def handle_new_connection(self):
        client = self.server.nextPendingConnection()
        client.readyRead.connect(lambda: self.read_data(client))
        client.disconnected.connect(client.deleteLater)
        self.new_connection.emit(client)

    def read_data(self, client):
        data = client.readAll().data().decode('utf-8')
        print("Received:", data)
        client.write(f"Echo: {data}".encode())

---

## 🔹 Multimedia Applications
### 1. Audio Player

from PyQt5.QtMultimedia import QMediaPlayer, QMediaContent
from PyQt5.QtMultimediaWidgets import QVideoWidget

class MediaPlayer(QWidget):
    def __init__(self):
        super().__init__()
        self.player = QMediaPlayer()
        self.setup_ui()

    def setup_ui(self):
        # Video display
        video_widget = QVideoWidget()
        
        # Controls
        play_btn = QPushButton("Play")
        pause_btn = QPushButton("Pause")
        stop_btn = QPushButton("Stop")
        volume_slider = QSlider(Qt.Horizontal)
        volume_slider.setRange(0, 100)
        volume_slider.setValue(50)
        
        # Layout
        control_layout = QHBoxLayout()
        control_layout.addWidget(play_btn)
        control_layout.addWidget(pause_btn)
        control_layout.addWidget(stop_btn)
        control_layout.addWidget(volume_slider)
        
        main_layout = QVBoxLayout()
        main_layout.addWidget(video_widget)
        main_layout.addLayout(control_layout)
        self.setLayout(main_layout)
        
        # Connections
        self.player.setVideoOutput(video_widget)
        play_btn.clicked.connect(self.player.play)
        pause_btn.clicked.connect(self.player.pause)
        stop_btn.clicked.connect(self.player.stop)
        volume_slider.valueChanged.connect(self.player.setVolume)
    
    def load_file(self, path):
        self.player.setMedia(QMediaContent(QUrl.fromLocalFile(path)))

### 2. Camera Capture

from PyQt5.QtMultimedia import QCamera, QCameraImageCapture
from PyQt5.QtMultimediaWidgets import QCameraViewfinder

class CameraApp(QWidget):
    def __init__(self):
        super().__init__()
        self.camera = QCamera()
        self.image_capture = QCameraImageCapture(self.camera)
        self.setup_ui()
    
    def setup_ui(self):
        # Camera viewfinder
        viewfinder = QCameraViewfinder()
        self.camera.setViewfinder(viewfinder)
        
        # Controls
        capture_btn = QPushButton("Capture")
        capture_btn.clicked.connect(self.capture_image)
        
        # Layout
        layout = QVBoxLayout()
        layout.addWidget(viewfinder)
        layout.addWidget(capture_btn)
        self.setLayout(layout)
        
        # Start camera
        self.camera.start()
    
    def capture_image(self):
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        path = f"capture_{timestamp}.jpg"
        self.image_capture.capture(path)
        print(f"Image saved to {path}")

---

## 🔹 Internationalization (i18n)
### 1. Translation Setup

from PyQt5.QtCore import QTranslator, QLocale

class TranslatableApp(QApplication):
    def __init__(self, argv):
        super().__init__(argv)
        self.translator = QTranslator()
        
        # Load system language
        locale = QLocale.system().name()
        self.load_translation(locale)
    
    def load_translation(self, lang):
        # Remove old translator
        self.removeTranslator(self.translator)
        
        # Create new translator
        self.translator = QTranslator()
        if self.translator.load(f":/translations/app_{lang}.qm"):
            self.installTranslator(self.translator)
            return True
        return False

# Mark strings for translation
self.label.setText(self.tr("Welcome to the application"))

### 2. Creating Translation Files
1. Mark strings with self.tr() or QObject.tr()
2. Extract strings:

   pylupdate5 -verbose myapp.pro
   

3. Translate using Qt Linguist
4. Compile translations:

   lrelease myapp.pro

### 3. Dynamic Language Switching

class LanguageMenu(QMenu):
    language_changed = pyqtSignal(str)
    
    def __init__(self):
        super().__init__("Language")
        self.language_map = {
            "English": "en",
            "Français": "fr",
            "Español": "es",
            "中文": "zh"
        }
        
        for lang_name, lang_code in self.language_map.items():
            action = self.addAction(lang_name)
            action.triggered.connect(
                lambda _, code=lang_code: self.language_changed.emit(code))

---

## 🔹 Deployment & Packaging
### 1. PyInstaller Configuration

# Create spec file
pyi-makespec --windowed --icon=app.ico --name MyApp main.py

# Add these to the spec file:
a = Analysis(
    ['main.py'],
    datas=[
        ('translations/*.qm', 'translations'),
        ('images/*.png', 'images')
    ],
    hiddenimports=['PyQt5.QtNetwork', 'PyQt5.QtMultimedia'],
    hookspath=[],
    runtime_hooks=[],
    excludes=[],
    win_no_prefer_redirects=False,
    win_private_assemblies=False,
    cipher=block_cipher
)

### 2. Creating Installers
Windows (NSIS):

pyinstaller --onefile --windowed --icon=app.ico main.py
makensis installer.nsi

MacOS (DMG):

pyinstaller --windowed --osx-bundle-identifier com.yourcompany.yourapp main.py
hdiutil create -volname "MyApp" -srcfolder dist/MyApp.app -ov MyApp.dmg

Linux (AppImage):

pyinstaller --onefile --windowed main.py
./appimagetool-x86_64.AppImage dist/MyApp.AppDir

### 3. Updating Mechanism

class Updater(QObject):
    update_available = pyqtSignal(str)
    update_downloaded = pyqtSignal(str)
    
    def __init__(self):
        super().__init__()
        self.manager = QNetworkAccessManager()
        self.manager.finished.connect(self.handle_response)
        
    def check_for_updates(self):
        request = QNetworkRequest(QUrl("https://api.example.com/version"))
        self.manager.get(request)
    
    def handle_response(self, reply):
        if reply.error():
            print("Update check failed:", reply.errorString())
            return
            
        latest_version = reply.readAll().data().decode('utf-8')
        current_version = self.get_current_version()
        
        if latest_version > current_version:
            self.update_available.emit(latest_version)
    
    def download_update(self):
        # Implementation for downloading update package
        pass

---

## 🔹 Practical Example: Weather App

class WeatherApp(QMainWindow):
    def __init__(self):
        super().__init__()
        self.api_key = "YOUR_API_KEY"
        self.setup_ui()
        self.setup_network()
    
    def setup_ui(self):
        self.setWindowTitle(self.tr("Weather App"))
        
        # Location Input
        self.location_input = QLineEdit()
        search_btn = QPushButton(self.tr("Search"))
        search_btn.clicked.connect(self.fetch_weather)
        
        # Weather Display
        self.weather_icon = QLabel()
        self.weather_icon.setAlignment(Qt.AlignCenter)
        
        self.temp_label = QLabel()
        self.temp_label.setAlignment(Qt.AlignCenter)
        font = self.temp_label.font()
        font.setPointSize(48)
        self.temp_label.setFont(font)
        
        self.details_label = QLabel()
        self.details_label.setAlignment(Qt.AlignCenter)
        
        # Layout
        input_layout = QHBoxLayout()
        input_layout.addWidget(self.location_input)
        input_layout.addWidget(search_btn)
        
        main_layout = QVBoxLayout()
        main_layout.addLayout(input_layout)
        main_layout.addWidget(self.weather_icon)
        main_layout.addWidget(self.temp_label)
        main_layout.addWidget(self.details_label)
        
        container = QWidget()
        container.setLayout(main_layout)
        self.setCentralWidget(container)
    
    def setup_network(self):
        self.manager = QNetworkAccessManager()
        self.manager.finished.connect(self.handle_weather_response)
        
        self.icon_manager = QNetworkAccessManager()
        self.icon_manager.finished.connect(self.handle_icon_response)
    
    def fetch_weather(self):
        location = self.location_input.text()
        if not location:
            return
            
        url = f"https://api.openweathermap.org/data/2.5/weather?q={location}&appid={self.api_key}&units=metric"
        self.manager.get(QNetworkRequest(QUrl(url)))
    
    def handle_weather_response(self, reply):
        if reply.error():
            QMessageBox.warning(self, self.tr("Error"), 
                              self.tr("Failed to fetch weather data"))
            return
            
        data = json.loads(reply.readAll().data().decode('utf-8'))
        
        # Update UI
        temp = data['main']['temp']
        self.temp_label.setText(f"{temp}°C")
        
        description = data['weather'][0]['description'].capitalize()
        humidity = data['main']['humidity']
        wind = data['wind']['speed']
        self.details_label.setText(
            self.tr(f"{description}\nHumidity: {humidity}%\nWind: {wind} m/s"))
        
        # Fetch weather icon
        icon_code = data['weather'][0]['icon']
        icon_url = f"https://openweathermap.org/img/wn/{icon_code}@2x.png"
        self.icon_manager.get(QNetworkRequest(QUrl(icon_url)))
    
    def handle_icon_response(self, reply):
        if not reply.error():
            pixmap = QPixmap()
            pixmap.loadFromData(reply.readAll())
            self.weather_icon.setPixmap(pixmap.scaledToWidth(100))

---

## 🔹 Best Practices
1. Handle network errors gracefully - Always check reply.error()
2. Clean up resources - Call deleteLater() on network objects
3. Cache API responses - Reduce unnecessary network calls
4. Use QThread for intensive operations - Keep UI responsive
5. Test translations thoroughly - Verify all UI elements adapt

---

### 📌 What's Next?
In Final Part 6, we'll cover:
➡️ Advanced Architecture Patterns
➡️ Plugin Systems
➡️ Performance Optimization
➡️ Cross-Platform Considerations

#PyQt5 #Networking #Multimedia #Deployment 🚀

Practice Exercise:
1. Build a podcast player with download capability
2. Create a multilingual chat application
3. Implement an auto-updating stock ticker

# 📚 PyQt5 Tutorial - Part 6/6: Advanced Architecture & Optimization
#PyQt5 #AdvancedPatterns #PluginSystem #Performance #CrossPlatform

Welcome to the final installment of our PyQt5 series! This comprehensive lesson explores professional architectural patterns, plugin systems, performance optimization, and cross-platform development strategies.

---

## 🔹 Advanced Architectural Patterns
### 1. Model-View-ViewModel (MVVM)

from PyQt5.QtCore import QObject, pyqtProperty, pyqtSignal

class ViewModel(QObject):
    data_changed = pyqtSignal()
    
    def __init__(self):
        super().__init__()
        self._username = ""
        self._password = ""
    
    @pyqtProperty(str, notify=data_changed)
    def username(self):
        return self._username
        
    @username.setter
    def username(self, value):
        if self._username != value:
            self._username = value
            self.data_changed.emit()
    
    @pyqtProperty(str, notify=data_changed)
    def password(self):
        return self._password
        
    @password.setter
    def password(self, value):
        if self._password != value:
            self._password = value
            self.data_changed.emit()

# View binds to ViewModel properties
view_model = ViewModel()
username_edit = QLineEdit()
username_edit.textChanged.connect(view_model.setUsername)
view_model.data_changed.connect(
    lambda: username_edit.setText(view_model.username))

### 2. Dependency Injection Container

class Container:
    _instance = None
    
    def __init__(self):
        self._services = {}
        
    def register(self, name, service):
        self._services[name] = service
        
    def resolve(self, name):
        return self._services.get(name)
        
    @classmethod
    def instance(cls):
        if cls._instance is None:
            cls._instance = Container()
        return cls._instance

# Usage
container = Container.instance()
container.register('database', DatabaseService())
container.register('api', ApiClient())

# In other classes
db_service = container.resolve('database')

### 3. Event Bus Pattern

from PyQt5.QtCore import QObject, pyqtSignal

class EventBus(QObject):
    app_started = pyqtSignal()
    user_logged_in = pyqtSignal(str)  # username
    data_loaded = pyqtSignal(dict)
    
    _instance = None
    
    @classmethod
    def instance(cls):
        if cls._instance is None:
            cls._instance = EventBus()
        return cls._instance

# Publisher
EventBus.instance().user_logged_in.emit("john_doe")

# Subscriber
EventBus.instance().user_logged_in.connect(
    lambda username: print(f"User {username} logged in"))

---

## 🔹 Plugin System Implementation
### 1. Plugin Architecture

# Plugin Interface
class IPlugin:
    def initialize(self, app):
        raise NotImplementedError
        
    def name(self):
        raise NotImplementedError

# Main Application
class Application:
    def __init__(self):
        self.plugins = []
        
    def load_plugins(self, plugin_dir):
        for filename in os.listdir(plugin_dir):
            if filename.endswith('.py'):
                module_name = filename[:-3]
                spec = importlib.util.spec_from_file_location(
                    module_name, os.path.join(plugin_dir, filename))
                module = importlib.util.module_from_spec(spec)
                spec.loader.exec_module(module)
                
                for item in dir(module):
                    obj = getattr(module, item)
                    if (isinstance(obj, type) and 
                        issubclass(obj, IPlugin) and 
                        obj != IPlugin):
                        plugin = obj()
                        plugin.initialize(self)
                        self.plugins.append(plugin)

# Example Plugin
class WeatherPlugin(IPlugin):
    def initialize(self, app):
        self.app = app
        print(f"WeatherPlugin initialized for {app}")
        
    def name(self):
        return "Weather Plugin"

### 2. Dynamic UI Integration

class PluginWidget(QWidget):
    def __init__(self, plugin, parent=None):
        super().__init__(parent)
        self.plugin = plugin
        self.setup_ui()
        
    def setup_ui(self):
        layout = QVBoxLayout()
        title = QLabel(f"Plugin: {self.plugin.name()}")
        title.setStyleSheet("font-weight: bold; font-size: 16px;")
        
        # Let plugin provide its UI
        plugin_ui = self.plugin.get_ui()
        
        layout.addWidget(title)
        layout.addWidget(plugin_ui)
        self.setLayout(layout)

# In main window
def load_plugin_uis(self):
    for plugin in self.app.plugins:
        tab = self.plugin_tabs.addTab(
            PluginWidget(plugin), plugin.name())

---

## 🔹 Performance Optimization
### 1. Lazy Loading

class LazyTabWidget(QTabWidget):
    def __init__(self):
        super().__init__()
        self._loaded_tabs = set()
        self.currentChanged.connect(self._load_current_tab)
    
    def addTab(self, widget, label):
        super().addTab(QLabel("Loading..."), label)
        self.setTabData(self.count()-1, widget)
    
    def _load_current_tab(self, index):
        if index not in self._loaded_tabs:
            widget = self.tabData(index)
            self._loaded_tabs.add(index)
            self.removeTab(index)
            self.insertTab(index, widget, widget.windowTitle())
            self.setCurrentIndex(index)

### 2. Efficient Data Handling

class LargeDataModel(QAbstractTableModel):
    def __init__(self, data_source):
        super().__init__()
        self._data_source = data_source  # Should implement chunked loading
        
    def rowCount(self, parent=None):
        return self._data_source.total_rows()
        
    def columnCount(self, parent=None):
        return self._data_source.total_columns()
        
    def data(self, index, role=Qt.DisplayRole):
        if not index.isValid() or role != Qt.DisplayRole:
            return None
            
        # Load only visible data
        if self._data_source.is_loaded(index.row(), index.column()):
            return self._data_source.get_data(index.row(), index.column())
        else:
            # Trigger background loading
            self._data_source.request_data(index.row(), index.column())
            return "Loading..."

### 3. Memory Management

class ResourceManager:
    _instance = None
    
    def __init__(self):
        self._resources = {}
        self._cache = LRUCache(maxsize=100)  # Custom LRU cache
        
    def get_image(self, path):
        if path in self._cache:
            return self._cache[path]
            
        pixmap = QPixmap(path)
        if not pixmap.isNull():
            self._cache[path] = pixmap
            return pixmap
        return None
        
    def cleanup(self):
        self._cache.clear()

# Usage
image = ResourceManager.instance().get_image("large_image.png")

---

## 🔹 Cross-Platform Considerations
### 1. Platform-Specific Code

class PlatformUtils:
    @staticmethod
    def get_config_path():
        if sys.platform == "win32":
            return os.path.join(os.environ["APPDATA"], "MyApp")
        elif sys.platform == "darwin":
            return os.path.expanduser("~/Library/Application Support/MyApp")
        else:  # Linux/Unix
            return os.path.expanduser("~/.config/MyApp")

    @staticmethod
    def open_file_browser(path):
        if sys.platform == "win32":
            os.startfile(path)
        elif sys.platform == "darwin":
            subprocess.run(["open", path])
        else:
            subprocess.run(["xdg-open", path])

### 2. High DPI Support

if hasattr(Qt, 'AA_EnableHighDpiScaling'):
    QApplication.setAttribute(Qt.AA_EnableHighDpiScaling, True)
if hasattr(Qt, 'AA_UseHighDpiPixmaps'):
    QApplication.setAttribute(Qt.AA_UseHighDpiPixmaps, True)

# In main QApplication
app = QApplication([])
app.setAttribute(Qt.AA_UseStyleSheetPropagationInWidgetStyles, True)

### 3. Dark Mode Detection

def is_dark_mode():
    if sys.platform == "darwin":
        # MacOS dark mode detection
        process = subprocess.Popen(
            ["defaults", "read", "-g", "AppleInterfaceStyle"],
            stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        out, _ = process.communicate()
        return out.strip() == b"Dark"
    elif sys.platform == "win32":
        # Windows 10+ dark mode detection
        try:
            import winreg
            key = winreg.OpenKey(
                winreg.HKEY_CURRENT_USER,
                r"Software\Microsoft\Windows\CurrentVersion\Themes\Personalize")
            value, _ = winreg.QueryValueEx(key, "AppsUseLightTheme")
            return value == 0
        except:
            return False
    else:
        return False  # Default to light mode on other platforms

---

## 🔹 Practical Example: Plugin-Based Text Editor

class TextEditor(QMainWindow):
    def __init__(self):
        super().__init__()
        self.plugins = []
        self.setup_ui()
        self.load_plugins()
    
    def setup_ui(self):
        # Core editor
        self.editor = QPlainTextEdit()
        self.setCentralWidget(self.editor)
        
        # Plugin toolbar
        self.plugin_toolbar = QToolBar("Plugins")
        self.addToolBar(Qt.LeftToolBarArea, self.plugin_toolbar)
        
        # Plugin menu
        self.plugin_menu = self.menuBar().addMenu("Plugins")
    
    def load_plugins(self):
        plugin_dir = os.path.join(os.path.dirname(__file__), "plugins")
        if not os.path.exists(plugin_dir):
            return
            
        for filename in os.listdir(plugin_dir):
            if filename.endswith('.py'):
                try:
                    spec = importlib.util.spec_from_file_location(
                        f"plugins.{filename[:-3]}", 
                        os.path.join(plugin_dir, filename))
                    module = importlib.util.module_from_spec(spec)
                    spec.loader.exec_module(module)
                    
                    for name, obj in inspect.getmembers(module):
                        if (inspect.isclass(obj) and 
                            issubclass(obj, BasePlugin) and 
                            obj != BasePlugin):
                            plugin = obj(self)
                            plugin.initialize()
                            self.plugins.append(plugin)
                            
                            # Add to UI
                            if hasattr(plugin, 'get_toolbar_widget'):
                                self.plugin_toolbar.addWidget(
                                    plugin.get_toolbar_widget())
                            if hasattr(plugin, 'get_menu_action'):
                                self.plugin_menu.addAction(
                                    plugin.get_menu_action())
                except Exception as e:
                    print(f"Failed to load plugin {filename}: {e}")

class BasePlugin:
    def __init__(self, editor):
        self.editor = editor
        
    def initialize(self):
        raise NotImplementedError

---

## 🔹 Best Practices for Production Apps
1. Error Handling
- Implement comprehensive logging
- Use sentry.io for crash reporting
- Create recovery mechanisms

2. Update Strategy
- Implement delta updates
- Support rollback capability
- Verify digital signatures

3. Accessibility
- Set proper widget roles
- Support screen readers
- Ensure keyboard navigation

4. Security
- Sanitize all inputs
- Use HTTPS for network requests
- Secure sensitive data storage

5. Testing
- Unit tests for core logic
- UI tests with QTest
- Cross-platform testing matrix

---

### 🎉 Congratulations on Completing the Series!
You've now mastered:
1. PyQt5 Fundamentals
2. Advanced Widgets & Customization
3. Database Integration & MVC
4. Networking & Multimedia
5. Internationalization & Deployment
6. Advanced Architecture & Optimization

#PyQt5Mastery #ProfessionalGUI #PythonDevelopment 🚀

Here are the top resources to master PyQt5, categorized for different learning styles and skill levels:

---

### 📚 Official Documentation & Core Resources
1. Qt Official Documentation
- The definitive reference for all Qt classes (PyQt5 closely follows Qt's C++ docs)
- *Best for:* Understanding class hierarchies and method signatures

2. Riverbank Computing PyQt5 Official
- Python-specific documentation and licensing details
- *Best for:* Python-specific implementation details

---

### 🎓 Structured Courses
3. Udemy: PyQt5 Masterclass
- Hands-on projects (calculator, database apps, web browsers)
- *Best for:* Visual learners who prefer project-based learning

4. Real Python: PyQt5 Tutorials
- Free high-quality tutorials with practical examples
- *Best for:* Beginners wanting concise, practical introductions

5. ZetCode PyQt5 Tutorial
- Comprehensive free tutorial covering widgets to advanced topics
- *Best for:* Methodical learners who prefer text-based learning

---

### 📖 Books
6. "PyQt5 GUI Application Development" (2023 Edition)
- Covers modern PyQt5 practices including QML integration
- *Best for:* Developers wanting up-to-date best practices

7. "Create GUI Applications with Python & Qt" (Martin Fitzpatrick)
- Available as ebook with free sample chapters
- *Best for:* Practical application development

8. "Rapid GUI Programming with Python and Qt" (Mark Summerfield)
- Classic book covering PyQt fundamentals
- *Best for:* Understanding Qt's design philosophy

---

### 🛠 Tools & Utilities
9. Qt Designer
- Bundled with PyQt5 (pyqt5-tools package)
- Drag-and-drop UI builder (generates .ui files)
- *Tip:* Convert .ui to Python with:

     pyuic5 input.ui -o output.py
     

10. Eric IDE
- Full-featured Python IDE built with PyQt5
- Includes Qt Designer integration and debugger
- Download here

---

### 💡 Advanced Learning
11. PyQtGraph
- High-performance data visualization library built on PyQt5
- *Best for:* Scientific applications and real-time plotting

12. PyQt6 Migration Guide
- Essential if planning to upgrade to PyQt6
- *Key changes:* Enums, QAction initialization

13. Qt Examples Repository
- Clone the official Qt examples and port them to PyQt5:

      git clone https://code.qt.io/cgit/qt/qtbase.git --branch=5.15
      

---

### 🎥 Video Resources
14. Python GUIs YouTube Channel
- Free tutorials on PyQt5/PySide2
- *Highlights:* Custom widget tutorials and modern UI techniques

15. FreeCodeCamp PyQt5 Course
- 5-hour comprehensive free course
- *Best for:* Learners who prefer long-form video content

---

### 🌐 Communities
16. Stack Overflow [pyqt] Tag
- Over 30k answered questions
- *Pro tip:* Search with [pyqt] is:answered

17. /r/pyqt on Reddit
- Active community for troubleshooting and sharing projects

18. PyQt Discord Server
- Real-time help from experienced developers
- Invite link: Python GUIs Discord

---

### 🔧 Project Templates
19. PyQt5 Boilerplate
- Pre-configured project with:
- MVC structure
- QSS styling
- Resource management

20. PyQt5-Starter-Template
- Includes:
- Dark/light theme toggle
- High DPI support
- Logging setup

---

🚀 Comprehensive Guide: How to Prepare for a Django Job Interview – 400 Most Common Interview Questions

Are you ready to get a job: https://hackmd.io/@husseinsheikho/django-mcq

#DjangoInterview #Python #WebDevelopment #Django #BackendDevelopment #RESTAPI #Database #Security #Scalability #DevOps #InterviewPrep