# 📚 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"

Why identical arguments can create different entries in `lru_cache`? 🤔

The lru_cache creates a key not only from the values of the arguments, but also from the way they are passed.

load(True)
load(debug=True)

Although both calls pass the same value, for the cache, these are different keys, so the function will be executed twice.

print(load.cache_info())
# CacheInfo(hits=0, misses=2, ...)

The order of named arguments can also affect how an entry is created in the cache.

func(a=1, b=2)
func(b=2, a=1)

Therefore, it is best to call cached functions in a consistent style: either by position or by name, in the same order.

load(debug=True)
load(debug=True)

🔥 A consistent call format prevents unnecessary cache misses and redundant execution of expensive operations.

#Python #lru_cache #Caching #Performance #ProgrammingTips #CodeBestPractices

✨ Join Best TG Channels https://t.iss.one/addlist/0f6vfFbEMdAwODBk

⭐️ Join Our WhatsApp Channel https://whatsapp.com/channel/0029VaC7Weq29753hpcggW2A