📊 DEVASC Topics 1.4-1.6

# config.py
DATABASE_URL = "postgresql://localhost/mydb"
API_KEY = "your-api-key"

# database.py
import psycopg2
from config import DATABASE_URL

class Database:
    def __init__(self):
        self.conn = None
    
    def connect(self):
        self.conn = psycopg2.connect(DATABASE_URL)
    
    def query(self, sql):
        cursor = self.conn.cursor()
        cursor.execute(sql)
        return cursor.fetchall()

# api_client.py
import requests
from config import API_KEY

class APIClient:
    def __init__(self, base_url):
        self.base_url = base_url
        self.headers = {"Authorization": f"Bearer {API_KEY}"}
    
    def get(self, endpoint):
        url = f"{self.base_url}/{endpoint}"
        return requests.get(url, headers=self.headers)

# main.py
from database import Database
from api_client import APIClient

# Clean, organized, and maintainable!
db = Database()
db.connect()
results = db.query("SELECT * FROM devices")

api = APIClient("https://api.example.com")
response = api.get("devices/status")

# Model - Data and business logic
class DeviceModel:
    def __init__(self):
        self.devices = []
    
    def add_device(self, hostname, ip):
        device = {"hostname": hostname, "ip": ip, "status": "active"}
        self.devices.append(device)
        return device
    
    def get_all_devices(self):
        return self.devices
    
    def get_device(self, hostname):
        return next((d for d in self.devices if d["hostname"] == hostname), None)

# View - Presentation
class DeviceView:
    def display_devices(self, devices):
        print("\\n=== Network Devices ===")
        for device in devices:
            print(f"{device['hostname']}: {device['ip']} - {device['status']}")
    
    def display_device(self, device):
        if device:
            print(f"Device: {device['hostname']}")
            print(f"IP: {device['ip']}")
            print(f"Status: {device['status']}")
        else:
            print("Device not found")

# Controller - Application logic
class DeviceController:
    def __init__(self):
        self.model = DeviceModel()
        self.view = DeviceView()
    
    def add_device(self, hostname, ip):
        device = self.model.add_device(hostname, ip)
        print(f"Added device: {hostname}")
    
    def show_all_devices(self):
        devices = self.model.get_all_devices()
        self.view.display_devices(devices)
    
    def show_device(self, hostname):
        device = self.model.get_device(hostname)
        self.view.display_device(device)

# Usage
controller = DeviceController()
controller.add_device("Router1", "192.168.1.1")
controller.add_device("Switch1", "192.168.1.2")
controller.show_all_devices()
controller.show_device("Router1")

# Observer Pattern Implementation

class NetworkMonitor:
    """Subject/Observable"""
    def __init__(self):
        self._observers = []
        self._device_status = {}
    
    def attach(self, observer):
        self._observers.append(observer)
    
    def detach(self, observer):
        self._observers.remove(observer)
    
    def notify(self, device, status):
        for observer in self._observers:
            observer.update(device, status)
    
    def set_device_status(self, device, status):
        self._device_status[device] = status
        print(f"[Monitor] {device} status changed to {status}")
        self.notify(device, status)

class EmailAlert:
    """Observer 1"""
    def update(self, device, status):
        if status == "down":
            print(f"[Email] Alert! {device} is DOWN - sending email...")

class SMSAlert:
    """Observer 2"""
    def update(self, device, status):
        if status == "down":
            print(f"[SMS] Alert! {device} is DOWN - sending SMS...")

class Logger:
    """Observer 3"""
    def update(self, device, status):
        print(f"[Logger] Logging: {device} - {status}")

# Usage
monitor = NetworkMonitor()

# Attach observers
email_alert = EmailAlert()
sms_alert = SMSAlert()
logger = Logger()

monitor.attach(email_alert)
monitor.attach(sms_alert)
monitor.attach(logger)

# State changes trigger notifications
monitor.set_device_status("Router1", "up")
print()
monitor.set_device_status("Switch1", "down")