Padrões em Movimento

class UserManager:
    # auth
    def validate_email(self, e): ...
    def hash_password(self, p): ...

    # email
    def send_welcome_email(self, u): ...

    # pdf
    def generate_pdf_report(self, u): ...

    # banco
    def save_to_db(self, u): ...
    def find_by_id(self, i): ...

    # util
    def format_date(self, d): ...
# Cinco domínios sob o mesmo nome.

Auth, email, PDF, banco e utilitários moram juntos. Cada PR mexe em assuntos sem ligação entre si.

class OrderService:
    def __init__(self):
        # Cada vendor pelo nome
        self.db = MySQLConnection("prod")
        self.mail = SendGridClient(API_KEY)
        self.log = FileLogger("/var/log/orders")
        self.pay = StripeGateway(SECRET)

    def place(self, order):
        self.db.save(order)
        self.pay.charge(order.total)
        self.mail.send(order.email)
        self.log.write("ok")
# Trocar o banco? Mexer no construtor.
# Testar sem internet? Impossível.

Quatro fornecedores fincados dentro do construtor. Cada troca pede edição, cada teste pede o mundo real.

class UserService:
    def __init__(self):
        self.db = Database("prod")

class OrderService:
    def __init__(self):
        self.db = Database("prod")

# Cada serviço abre uma conexão nova.

Cinco serviços. Cinco conexões diferentes para o mesmo banco. Nenhuma compartilha estado.

def peso_total(carro):
    return (
        carro.motor.pistao_1.kg +
        carro.motor.pistao_2.kg +
        carro.motor.bloco.kg +
        carro.roda_FE.pneu.kg +
        carro.roda_FE.aro.kg +
        carro.roda_FD.pneu.kg +
        carro.roda_FD.aro.kg +
        carro.banco_M.kg +
        carro.banco_C.kg
    )
# Cliente enumera cada peça pelo nome.
# Peça nova? Linha nova na soma.

Os objetos estão espalhados. O cliente é quem amarra tudo, peça por peça. Bateria nova? Edita a função em todos os lugares que somam o carro.

class CheckoutService:
    def notify(self, kind, msg):
        if kind == "email":
            n = EmailNotification()
        elif kind == "sms":
            n = SmsNotification()
        elif kind == "push":
            n = PushNotification()
        n.send(msg)
# O mesmo if/elif aparece em vários serviços.

Cada serviço carrega o mesmo bloco de decisão. Adicionar WhatsApp obriga editar todos.

class ShoppingCart:
    def calculate(self, kind, price):
        if kind == "regular":
            return price
        elif kind == "vip":
            return price * 0.90
        elif kind == "blackFriday":
            return price * 0.75
        elif kind == "employee":
            return price * 0.65
# O método cresce a cada promo.

Toda regra mora dentro do mesmo método. Adicionar Aniversariante obriga editar a classe.

class Order:
    def confirm(self):
        # ... lógica de negócio
        EmailService.send(self)
        InvoiceGenerator.create(self)
        StockManager.reserve(self)
        Analytics.track(self)
        AuditLog.write(self)
# Reação nova? Edita Order de novo.

Order conhece todo mundo pelo nome. Cada feature nova obriga a abrir essa classe e mexer.

class UserService:
    def __init__(self, conn):
        self.conn = conn

    def activate(self, user_id):
        cur = self.conn.cursor()
        cur.execute(
            "SELECT * FROM users WHERE id = %s",
            (user_id,)
        )
        row = cur.fetchone()
        # ... regra de negócio
        cur.execute(
            "UPDATE users SET active=1 WHERE id=%s",
            (user_id,)
        )
# SQL e dialeto do banco dentro do domínio.

A regra de negócio convive com cursor, tabela e sintaxe SQL. Trocar o banco quebra a classe inteira.

class ModernCheckout:
    def pay(self, amount):
        # Tem que falar a língua do legado
        xml = LegacyGateway.executeTransaction({
            "type": "PAY",
            "amt": amount,
            "fmt": "XML"
        })
        # E parsear XML cru na volta
        result = XMLParser.parse(xml)
        return result.find("status").text
# Negócio misturado com tradução.

A regra de pagamento convive com formato XML, dialeto legado e parsing. Cada novo cliente repete tudo.