# 📚 PyQt5 Tutorial - Part 1/6: Introduction to GUI Programming
#PyQt5 #Python #GUI #BeginnerFriendly #Qt

Welcome to Part 1 of our comprehensive PyQt5 series! This lesson will introduce you to GUI development with Python and PyQt5, perfect for beginners.

---

## 🔹 What is PyQt5?
PyQt5 is a set of Python bindings for Qt (a powerful C++ GUI framework). It lets you create:
- Desktop applications
- Cross-platform GUIs
- Professional-looking interfaces
- Apps with databases, networking, and multimedia

Key Features:
✔️ 620+ classes
✔️ 6,000+ functions
✔️ Windows, Mac, Linux support
✔️ Open-source (GPL/commercial licenses)

---

## 🔹 Installation
Install PyQt5 and tools:

pip install PyQt5 PyQt5-tools

Verify Installation:

import PyQt5
print(PyQt5.__version__)  # Should show version like 5.15.4

---

## 🔹 Your First PyQt5 App
Let's create a simple window:

import sys
from PyQt5.QtWidgets import QApplication, QLabel, QWidget

# 1. Create the application object
app = QApplication(sys.argv)

# 2. Create main window
window = QWidget()
window.setWindowTitle("My First App")
window.setGeometry(100, 100, 400, 200)  # x, y, width, height

# 3. Add a label
label = QLabel("Hello PyQt5!", parent=window)
label.move(150, 80)  # x, y position

# 4. Show the window
window.show()

# 5. Run the application
sys.exit(app.exec_())

Code Breakdown:
1. QApplication: Manages app control flow
2. QWidget: Base class for all UI objects
3. QLabel: Displays text/images
4. exec_(): Starts the event loop

---

## 🔹 Core PyQt5 Components
### 1. Main Window Types
| Class | Purpose |
|-------|---------|
| QWidget | Basic empty window |
| QMainWindow | With menu bar, status bar, toolbars |
| QDialog | Popup dialog windows |

### 2. Common Widgets

from PyQt5.QtWidgets import (
    QPushButton,  # Clickable button
    QLineEdit,    # Single-line text input
    QTextEdit,    # Multi-line text area
    QCheckBox,    # Toggle option
    QRadioButton, # Exclusive choice
    QComboBox,    # Dropdown menu
    QSlider       # Value selector
)

### 3. Layout Managers

from PyQt5.QtWidgets import (
    QVBoxLayout,  # Vertical arrangement
    QHBoxLayout,  # Horizontal arrangement
    QGridLayout   # Grid arrangement
)

---

## 🔹 Creating a Functional App
Let's build a temperature converter:

from PyQt5.QtWidgets import (QApplication, QWidget, QVBoxLayout, 
                            QLabel, QLineEdit, QPushButton)

class ConverterApp(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Temperature Converter")
        self.setup_ui()
    
    def setup_ui(self):
        # Create widgets
        self.celsius_input = QLineEdit()
        self.fahrenheit_input = QLineEdit()
        self.convert_btn = QPushButton("Convert")
        self.result_label = QLabel("Enter temperature to convert")
        
        # Set up layout
        layout = QVBoxLayout()
        layout.addWidget(QLabel("Celsius:"))
        layout.addWidget(self.celsius_input)
        layout.addWidget(QLabel("Fahrenheit:"))
        layout.addWidget(self.fahrenheit_input)
        layout.addWidget(self.convert_btn)
        layout.addWidget(self.result_label)
        
        # Connect button click
        self.convert_btn.clicked.connect(self.convert)
        
        self.setLayout(layout)
    
    def convert(self):
        try:
            if self.celsius_input.text():
                # Celsius to Fahrenheit
                celsius = float(self.celsius_input.text())
                fahrenheit = (celsius * 9/5) + 32
                self.fahrenheit_input.setText(f"{fahrenheit:.2f}")
                self.result_label.setText("Conversion complete!")
            elif self.fahrenheit_input.text():
                # Fahrenheit to Celsius
                fahrenheit = float(self.fahrenheit_input.text())
                celsius = (fahrenheit - 32) * 5/9
                self.celsius_input.setText(f"{celsius:.2f}")
                self.result_label.setText("Conversion complete!")
        except ValueError:
            self.result_label.setText("Please enter a valid number!")

if __name__ == "__main__":
    app = QApplication([])
    window = ConverterApp()
    window.show()
    app.exec_()

---

## 🔹 PyQt5 Designer Tool
Qt Designer lets you create UIs visually:

1. Launch Designer:

   pyqt5-tools designer
   

2. Design your interface (saves as .ui file)
3. Convert to Python code:

   pyuic5 input.ui -o output.py
   

Example Usage:

from PyQt5 import uic
class MyApp(QMainWindow):
    def __init__(self):
        super().__init__()
        uic.loadUi('design.ui', self)  # Load UI file

---

## 🔹 Event Handling Basics
PyQt5 uses signals and slots for interactivity:

# Connecting signals to slots
button.clicked.connect(self.on_button_click)
checkbox.stateChanged.connect(self.on_checkbox_change)
line_edit.textChanged.connect(self.on_text_change)

# Example slot methods
def on_button_click(self):
    print("Button clicked!")

def on_checkbox_change(self, state):
    print("Checkbox state:", state)

def on_text_change(self, text):
    print("Text changed to:", text)

---

## 🔹 Best Practices for Beginners
1. Organize code in classes/methods
2. Use layouts instead of absolute positioning
3. Name widgets clearly (e.g., self.login_btn)
4. Separate UI code from business logic
5. Handle errors gracefully in event handlers

---

### 📌 What's Next?
In Part 2, we'll cover:
➡️ Advanced Widgets (Tables, Trees, Tabs)
➡️ Custom Signals
➡️ Styling with QSS
➡️ Multiple Windows

#PyQt5Tutorial #GUIPython #LearnToCode 🚀

Practice Exercise:
1. Create a simple calculator app
2. Build a text editor with save/load buttons
3. Make a color picker that changes window background

# 📚 PyQt5 Tutorial - Part 2/6: Advanced Widgets & Customization
#PyQt5 #PythonGUI #AdvancedWidgets #QSS #SignalsSlots

Welcome to Part 2 of our PyQt5 series! This in-depth lesson covers advanced widgets, custom styling, multi-window applications, and professional patterns.

---

## 🔹 Advanced Widgets Overview
### 1. Tabbed Interfaces (QTabWidget)

from PyQt5.QtWidgets import QTabWidget, QTextEdit, QWidget

class TabDemo(QWidget):
    def __init__(self):
        super().__init__()
        
        tabs = QTabWidget()
        
        # Tab 1: Text Editor
        tab1 = QWidget()
        text_edit = QTextEdit()
        tab1_layout = QVBoxLayout()
        tab1_layout.addWidget(text_edit)
        tab1.setLayout(tab1_layout)
        
        # Tab 2: Settings
        tab2 = QWidget()
        tab2_layout = QVBoxLayout()
        tab2_layout.addWidget(QLabel("Settings Panel"))
        tab2.setLayout(tab2_layout)
        
        tabs.addTab(tab1, "Editor")
        tabs.addTab(tab2, "Settings")
        
        main_layout = QVBoxLayout()
        main_layout.addWidget(tabs)
        self.setLayout(main_layout)

### 2. Tree Widget (QTreeWidget)

def setup_file_tree(self):
    tree = QTreeWidget()
    tree.setHeaderLabels(["Name", "Size", "Type"])
    
    # Add parent items
    root = QTreeWidgetItem(tree)
    root.setText(0, "Project Root")
    
    # Add children
    for file in ["main.py", "config.ini", "README.md"]:
        child = QTreeWidgetItem(root)
        child.setText(0, file)
        child.setText(1, "10 KB")
        child.setText(2, "Python" if file.endswith(".py") else "Text")
    
    tree.expandAll()
    return tree

### 3. Table Widget (QTableWidget)

def setup_data_table(self):
    table = QTableWidget(5, 3)  # Rows, columns
    table.setHorizontalHeaderLabels(["ID", "Name", "Status"])
    
    sample_data = [
        [101, "Product A", "Active"],
        [102, "Product B", "Inactive"],
        [103, "Product C", "Pending"]
    ]
    
    for row, data in enumerate(sample_data):
        for col, text in enumerate(data):
            item = QTableWidgetItem(str(text))
            table.setItem(row, col, item)
    
    table.resizeColumnsToContents()
    return table

---

## 🔹 Custom Signals & Slots
### 1. Creating Custom Signals

from PyQt5.QtCore import pyqtSignal, QObject

class Worker(QObject):
    progress_changed = pyqtSignal(int)
    task_completed = pyqtSignal(str)
    
    def run_task(self):
        for i in range(1, 101):
            time.sleep(0.05)
            self.progress_changed.emit(i)
        self.task_completed.emit("Task finished!")

### 2. Advanced Signal-Slot Connections

# Multiple signals to single slot
button1.clicked.connect(self.handle_click)
button2.clicked.connect(self.handle_click)

# Signal with arguments
self.worker.progress_changed.connect(self.update_progress_bar)

# Lambda slots
button.clicked.connect(lambda: self.process_data(param1, param2))

# Slot decorator
@pyqtSlot()
def on_button_click(self):
    print("Button clicked!")

---

## 🔹 Styling with Qt Style Sheets (QSS)
### 1. Basic Styling

app.setStyleSheet("""
    QPushButton {
        background-color: #4CAF50;
        border: none;
        color: white;
        padding: 8px 16px;
        font-size: 14px;
    }
    QPushButton:hover {
        background-color: #45a049;
    }
    QLineEdit {
        padding: 5px;
        border: 1px solid #ccc;
        border-radius: 3px;
    }
""")

### 2. Advanced Selectors

/* Style only buttons in the toolbar */
QToolBar QPushButton {
    min-width: 80px;
}

/* Style checked checkboxes differently */
QCheckBox:checked {
    color: #0085FF;
}

/* Style odd/even table rows */
QTableView::item:alternate {
    background: #f0f0f0;
}

### 3. Dynamic Style Changes

# Change style programmatically
button.setStyleSheet("""
    QPushButton {
        background-color: red;
        font-weight: bold;
    }
""")

# Reset to default
button.setStyleSheet("")

---

## 🔹 Multi-Window Applications
### 1. Creating Secondary Windows

class SettingsWindow(QDialog):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Settings")
        layout = QVBoxLayout()
        layout.addWidget(QLabel("Application Settings"))
        self.setLayout(layout)

# In main window:
def show_settings(self):
    settings = SettingsWindow()
    settings.exec_()  # Modal dialog
    # OR settings.show() for non-modal

### 2. Window Communication

# Main window with signal
class MainWindow(QMainWindow):
    settings_changed = pyqtSignal(dict)
    
    def open_settings(self):
        dialog = SettingsDialog(self)  # Pass parent
        if dialog.exec_():
            self.settings_changed.emit(dialog.get_settings())

# Settings dialog
class SettingsDialog(QDialog):
    def __init__(self, parent=None):
        super().__init__(parent)
        # ... setup UI ...
    
    def get_settings(self):
        return {"theme": self.theme_combo.currentText()}

---

## 🔹 Model-View Architecture
### 1. QListView with StringListModel

model = QStringListModel()
model.setStringList(["Item 1", "Item 2", "Item 3"])

list_view = QListView()
list_view.setModel(model)

# Add items
model.insertRow(model.rowCount())
model.setData(model.index(model.rowCount()-1), "New Item")

### 2. Custom Table Model

class CustomTableModel(QAbstractTableModel):
    def __init__(self, data):
        super().__init__()
        self._data = data
    
    def rowCount(self, parent=None):
        return len(self._data)
    
    def columnCount(self, parent=None):
        return len(self._data[0]) if self._data else 0
    
    def data(self, index, role=Qt.DisplayRole):
        if role == Qt.DisplayRole:
            return str(self._data[index.row()][index.column()])
        return None

# Usage
data = [[1, "Alice"], [2, "Bob"], [3, "Charlie"]]
model = CustomTableModel(data)
table = QTableView()
table.setModel(model)

---

## 🔹 Practical Example: Text Editor

class TextEditor(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setup_ui()
        self.setup_menu()
    
    def setup_ui(self):
        self.text_edit = QTextEdit()
        self.setCentralWidget(self.text_edit)
        
        # Status bar
        self.statusBar().showMessage("Ready")
        
        # Toolbar
        toolbar = self.addToolBar("Tools")
        save_act = QAction(QIcon("save.png"), "Save", self)
        save_act.triggered.connect(self.save_file)
        toolbar.addAction(save_act)
    
    def setup_menu(self):
        menubar = self.menuBar()
        
        # File menu
        file_menu = menubar.addMenu("File")
        
        open_act = QAction("Open", self)
        open_act.triggered.connect(self.open_file)
        file_menu.addAction(open_act)
        
        # Edit menu
        edit_menu = menubar.addMenu("Edit")
        edit_menu.addAction("Copy", self.text_edit.copy)
        edit_menu.addAction("Paste", self.text_edit.paste)
    
    def open_file(self):
        path, _ = QFileDialog.getOpenFileName()
        if path:
            with open(path, 'r') as f:
                self.text_edit.setText(f.read())
    
    def save_file(self):
        path, _ = QFileDialog.getSaveFileName()
        if path:
            with open(path, 'w') as f:
                f.write(self.text_edit.toPlainText())

---

## 🔹 Best Practices
1. Separate UI code from business logic
2. Use models for complex data views
3. Optimize performance for large datasets
4. Localize strings for internationalization
5. Document signals and public methods

---

### 📌 What's Next?
In Part 3, we'll cover:
➡️ Dialogs & Message Boxes
➡️ File System Operations
➡️ Drag & Drop
➡️ Threading with QThread

#PyQt5 #GUIPython #ProfessionalDevelopment 🚀

Practice Exercise:
1. Create a contacts app with tree view and detail form
2. Build a styled calculator with custom buttons
3. Implement a multi-window image viewer with thumbnails

# 📚 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.message_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")
        
        denoscription = data['weather'][0]['denoscription'].capitalize()
        humidity = data['main']['humidity']
        wind = data['wind']['speed']
        self.details_label.setText(
            self.tr(f"{denoscription}\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()
        noscript = QLabel(f"Plugin: {self.plugin.name()}")
        noscript.setStyleSheet("font-weight: bold; font-size: 16px;")
        
        # Let plugin provide its UI
        plugin_ui = self.plugin.get_ui()
        
        layout.addWidget(noscript)
        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 🚀