Strategy Pattern para pagos en Python

Curso de Patrones de Diseño y SOLID en Python

Contenido del curso

Patrones de Diseño y Principios SOLID

1
Patrones de diseño y SOLID en Python
02:07 min

Principios SOLID

Reestructuración del proyecto

13
Reestructuración con módulos de Python y SOLID
13:32 min

Patrones de Diseño

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0010:58

Strategy Pattern para pagos en Python

Curso de Patrones de Diseño y SOLID en Python

Clase 16 de 27

Clase 16 / 27

Comentarios (12)12 comentarios

Mario Alexander Vargas Celis

Hace 2 años

El **Patrón Strategy** es ideal para escenarios donde necesitas implementar varias variantes de un algoritmo o comportamiento y quieres que sean intercambiables de manera dinámica sin alterar el código del cliente. Este patrón encapsula cada algoritmo dentro de su propia clase y permite al cliente seleccionar la estrategia que desea usar en tiempo de ejecución.

### Implementación del Patrón Strategy en Python

A continuación, implementaremos un ejemplo práctico: un sistema para calcular descuentos en una tienda. Según el tipo de cliente, aplicaremos diferentes estrategias de descuento.

#### Paso 1: Crear una Interfaz para las Estrategias

Definimos una clase base que todas las estrategias implementarán.


from abc import ABC, abstractmethod



class DiscountStrategy(ABC):

&#x20;   @abstractmethod

&#x20;   def calculate(self, amount: float) -> float:

&#x20;       """Calcula el descuento aplicado a la cantidad dada."""

&#x20;       pass

#### Paso 2: Implementar Estrategias Concretas

Creamos varias clases que representan diferentes estrategias de descuento.


class NoDiscount(DiscountStrategy):

&#x20;   def calculate(self, amount: float) -> float:

&#x20;       return amount  # Sin descuento



class SeasonalDiscount(DiscountStrategy):

&#x20;   def calculate(self, amount: float) -> float:

&#x20;       return amount \* 0.9  # 10% de descuento



class LoyaltyDiscount(DiscountStrategy):

&#x20;   def calculate(self, amount: float) -> float:

&#x20;       return amount \* 0.85  # 15% de descuento

#### Paso 3: Crear la Clase Contexto

El contexto es la clase que utiliza las estrategias de descuento. Permite establecer y cambiar dinámicamente la estrategia de descuento.


class ShoppingCart:

&#x20;   def \_\_init\_\_(self):

&#x20;       self.total\_amount = 0

&#x20;       self.discount\_strategy: DiscountStrategy = NoDiscount()



&#x20;   def add\_item(self, price: float):

&#x20;       self.total\_amount += price



&#x20;   def set\_discount\_strategy(self, strategy: DiscountStrategy):

&#x20;       self.discount\_strategy = strategy



&#x20;   def checkout(self) -> float:

&#x20;       return self.discount\_strategy.calculate(self.total\_amount)

- **add\_item**: Añade el precio de un artículo al carrito.

- **set\_discount\_strategy**: Permite configurar la estrategia de descuento deseada.

- **checkout**: Calcula el total con el descuento aplicado.

#### Paso 4: Usar el Patrón Strategy

Ahora, podemos usar el sistema con diferentes estrategias de descuento.


\# Crear un carrito de compras

cart = ShoppingCart()



\# Agregar artículos al carrito

cart.add\_item(100)

cart.add\_item(200)



\# Sin descuento

print(f"Total sin descuento: {cart.checkout()}")  # Output: 300.0



\# Aplicar un descuento de temporada

cart.set\_discount\_strategy(SeasonalDiscount())

print(f"Total con descuento de temporada: {cart.checkout()}")  # Output: 270.0



\# Cambiar a descuento por fidelidad

cart.set\_discount\_strategy(LoyaltyDiscount())

print(f"Total con descuento por fidelidad: {cart.checkout()}")  # Output: 255.0

### Ventajas del Patrón Strategy

1. **Cambio Dinámico de Comportamiento**: Es fácil cambiar el algoritmo utilizado en tiempo de ejecución.

2. **Separación de Responsabilidades**: Cada estrategia está encapsulada en su propia clase, lo que hace el código más modular y fácil de mantener.

3. **Cumplimiento del Principio Abierto/Cerrado (OCP)**: Podemos añadir nuevas estrategias sin modificar el código existente.

### Desventajas del Patrón Strategy

1. **Aumento del Número de Clases**: Cada nueva estrategia requiere una clase concreta, lo que puede aumentar la complejidad en proyectos grandes.

2. **Complejidad Inicial**: Puede ser excesivo para problemas simples donde no se necesitan múltiples estrategias.

### Conclusión

El **Patrón Strategy** es una solución elegante para problemas donde necesitas encapsular algoritmos intercambiables. Esta implementación en Python demuestra cómo el patrón puede mejorar la flexibilidad y extensibilidad del sistema al permitir cambiar dinámicamente los comportamientos sin alterar la lógica central.

Bryann Andrei Valderrama Avila

Hace 2 años

No se agregaron los recursos en esta clase que es de implementación, pero si en la de explicación. Sería genial que lo corrigieran, así poder ir avanzando de una mejor manera.

Jonnathan Mackey Martínez Robledo

Hace 2 años

Búscalos en la clase 2

Juan Cruz Romero

Hace 2 años

Buenas! Alguien me explica porqué en la función "get_notifier_implementation()" directamente no retorno la instancia y debo crear una función a parte como "get_email_notifier()" o "get_sms_notifier()"

Gracias!

Angel Romero

Hace 2 años

Una pregunta, el uso de este patrón no es con el fin de no usar el tema de las condicionales if?, ósea lo digo porque en la parte de la funcion get_notifier_implementation no se usan los if? ¿o solo es con el fin de simplificar el uso de estos mismos?

Sebastian Alejandro Gómez Ardila

Hace 2 años

¿Dónde puedo acceder a los recursos de esta clase y las posteriores?

Jonnathan Mackey Martínez Robledo

Hace 2 años

Están en la clase 2

Juan Camilo Suarez

Hace 2 años

Tuve muchos problemas con este código ;-;

Sin exagerar, pasé un día solo haciendo que corra, sin resolver los ejercicios.

Y quise dejar algunos problemas con el código actual:

1- ve a la carpeta src/payment_service/listeners, dirígete al archivo __init__.py y agrega la linea from listener import Listener , también agrega a la lista "listener"

2- Cuando se instancia el service (al final del archivo main.py), en las validaciones también me salía un error, y por ello adjunto esto:


if __name__ == "__main__":
    stripe_pay_processor = StripePaymentProcessor()
    # 🆗 principio S
    customer_data =get_customer_info()
    notifier= get_notifier_implementation(customer_data = customer_data)
    # Para cambiar de estrategia según el contexto parte 1:
    email_notifier = get_mail
    sms_notifier = get_sms()
    
    # Se crea el manejador de dict y configura la cadena de validación
    handler_map = CustomerHandler()
    payment_data_validator = PaymentDataValidator()
    handler_map.set_next(payment_data_validator)
    # Asigna la cadena de validadores a dictionaries_map
    dictionaries_map = handler_map
    
    logger = TransactionLogger()
    
    service = PaymentService( 
        payment_processor=stripe_pay_processor, 
        notifier=notifier, #🆗
        validators= dictionaries_map, 
        logger=logger
    )
    # parte 2: Cambia la estrategia a email: 🆗
    service.set_notifier(EmailNotifier)
    #si falla: escoge la otra estrategia:
    service. set_notifier()
```Ojalá les sea de ayuda. &#x20;

búscame como @camilocsoto🐈‍⬛

Rodrigo Martinez

Hace 10 meses

La implementacion del tipo de procesador de pago dependiendo del tipo de pago es calcada a la implmentacion del tipo de notifier. Es decir, if TIPO_DE_PAGO: select paymentProcessor(tipo de pago)

juan esteban colcombet

Hace 2 años

es posible que "get_notifier_implementation" sea una especie del patron factory?

Joel Gabriel Germán Valdez

Hace un año

Hola esta fue mi solucion al reto que el profesor puso de notificar cuando no se encuentra la info de contacto y aplicar el strategy pattern para los procesadores de pago, que porcierto me apoye conceptualmente para esta implementacion de la solucion de otro compañero del curso. import enumfrom .logs import TransactionLoggerfrom .commons import CustomerData, ContactInfofrom .notifiers import EmailNotifier,NotifierProtocol,SMSNotifierfrom .processors import ( PaymentProcessorProtocol, RecurringPaymentProtocol, RefundPaymentProtocol, OfflinePaymentProcessor, LocalPaymentProcessor, StripePaymentProcessor)from .services import PaymentService from .validators.custom import CustomerValidatorfrom .validators.payment import PaymentDataValidator

def get_email_notifier() -> EmailNotifier: return EmailNotifier()def get_sms_notifier() -> SMSNotifier: return SMSNotifier(gateway="Altice") def get_non_contact_notifier(): return Exception('No contact info found, but transaction successful')

def get_stripe_processor() -> StripePaymentProcessor: return StripePaymentProcessor()def get_offline_processor() -> OfflinePaymentProcessor: return OfflinePaymentProcessor() def get_local_processor() -> LocalPaymentProcessor: return LocalPaymentProcessor()

class ProcessorPaymentType(enum.Enum): STRIPE = "stripe" OFFLINE = "offline" LOCAL = "local" def get_payment_processor(proccesor_type: ProcessorPaymentType) -> PaymentProcessorProtocol: if proccesor_type == ProcessorPaymentType.STRIPE: return get_stripe_processor() elif proccesor_type == ProcessorPaymentType.OFFLINE: return get_offline_processor() elif proccesor_type == ProcessorPaymentType.LOCAL: return get_local_processor() else: raise Exception(f"Unsupported processor type: {proccesor_type}")

def get_notifier_implemetation(customer_data: CustomerData) -> NotifierProtocol: if customer_data.contact_info.email: return get_email_notifier() if customer_data.contact_info.phone: return get_sms_notifier() raise get_non_contact_notifier()

def get_customer_data() -> CustomerData: customer_data = CustomerData( name="John Doe", contact_info=ContactInfo(email="x@x.com"), ) return customer_data if __name__ == "__main__": proccessor = get_payment_processor(ProcessorPaymentType.STRIPE) customer_data = get_customer_data() notifier = get_notifier_implemetation(customer_data) email_notifier = get_email_notifier() sms_notifier = get_sms_notifier() customer_validator = CustomerValidator() payment_validator = PaymentDataValidator() logger = TransactionLogger()

recurring_capable = isinstance(proccessor, RecurringPaymentProtocol) refund_capable = isinstance(proccessor, RefundPaymentProtocol) service = PaymentService( payment_processor=proccessor, notifier=email_notifier, customer_validator=customer_validator, payment_validator=payment_validator, logger=logger, recurring_processor=proccessor if recurring_capable else None, refund_processor=proccessor if refund_capable else None )

# Cambio de estrategia de notificación a Email service.set_notifier(email_notifier) # Cambio de estrategia de notificacion a SMS service.set_notifier(sms_notifier) # Cambio de estrategia de procesamiento a offline service.set_payment_processor(get_offline_processor()) # Cambio de estrategia de procesamiento a local service.set_payment_processor(get_local_processor())

import enum
from .logs import TransactionLogger
from .commons import CustomerData, ContactInfo
from .notifiers import EmailNotifier,NotifierProtocol,SMSNotifier
from .processors import (
    PaymentProcessorProtocol,
    RecurringPaymentProtocol,
    RefundPaymentProtocol,
    OfflinePaymentProcessor,
    LocalPaymentProcessor,
    StripePaymentProcessor
)
from .services import PaymentService 
from .validators.custom import CustomerValidator
from .validators.payment import PaymentDataValidator


def get_email_notifier() -> EmailNotifier:
    return EmailNotifier()
def get_sms_notifier() -> SMSNotifier:
    return SMSNotifier(gateway="Altice")

def get_non_contact_notifier():
    return Exception('No contact info found, but transaction successful')


def get_stripe_processor() -> StripePaymentProcessor:
    return StripePaymentProcessor()
def get_offline_processor() -> OfflinePaymentProcessor:
    return OfflinePaymentProcessor()

def get_local_processor() -> LocalPaymentProcessor:
    return LocalPaymentProcessor()


class ProcessorPaymentType(enum.Enum):
    STRIPE = "stripe"
    OFFLINE = "offline"
    LOCAL = "local"

def get_payment_processor(proccesor_type: ProcessorPaymentType) -> PaymentProcessorProtocol:
    if proccesor_type == ProcessorPaymentType.STRIPE:
        return get_stripe_processor()
    elif proccesor_type == ProcessorPaymentType.OFFLINE:
        return get_offline_processor()
    elif proccesor_type == ProcessorPaymentType.LOCAL:
        return get_local_processor()
    else:
        raise Exception(f"Unsupported processor type: {proccesor_type}")


def get_notifier_implemetation(customer_data: CustomerData) -> NotifierProtocol: 
    if customer_data.contact_info.email:
        return get_email_notifier()
    if customer_data.contact_info.phone:
        return get_sms_notifier()
    raise get_non_contact_notifier()


def get_customer_data() -> CustomerData:
    customer_data = CustomerData(
        name="John Doe",
        contact_info=ContactInfo(email="x@x.com"),
    )
    return customer_data

if __name__ == "__main__":

    proccessor = get_payment_processor(ProcessorPaymentType.STRIPE)

    customer_data = get_customer_data()
    
    notifier = get_notifier_implemetation(customer_data)

    email_notifier = get_email_notifier()
    sms_notifier = get_sms_notifier()

    customer_validator = CustomerValidator()
    payment_validator = PaymentDataValidator()
    logger = TransactionLogger()


    recurring_capable = isinstance(proccessor, RecurringPaymentProtocol)
    refund_capable = isinstance(proccessor, RefundPaymentProtocol)
    
    service = PaymentService(
        payment_processor=proccessor,
        notifier=email_notifier,
        customer_validator=customer_validator,
        payment_validator=payment_validator,
        logger=logger,
        recurring_processor=proccessor if recurring_capable else None,
        refund_processor=proccessor if refund_capable else None
    )


    # Cambio de estrategia de notificación a Email
    service.set_notifier(email_notifier)
    # Cambio de estrategia de notificacion a SMS
    service.set_notifier(sms_notifier)

    # Cambio de estrategia de procesamiento a offline
    service.set_payment_processor(get_offline_processor())

    # Cambio de estrategia de procesamiento a local
    service.set_payment_processor(get_local_processor())

Luis Russian

Hace un año

Emilio Nicolás Mendoza Patti

Hace 2 años

Este es mi solucion al desafio del profesor para implementar el patron strategy en el payment_procesor. Si alguien nota algo mal o a mejorar me avisa. from enum import Enum

from enum import Enum
from notifiers import EmailNotifier, NotifierProtocol, SMSNotifier

from .commons import CustomerData, ContactInfo
from .processors import StripePaymentProcessor, PaymentProcessorProtocol, LocalPaymentProcessor, OfflinePaymentProcessor
from .service import PaymentService
from .validators import CustomerValidator, PaymentDataValidator
from .loggers import TransactionLogger

def get_email_notifier() -> EmailNotifier:
    return EmailNotifier()

def get_sms_notifier() -> SMSNotifier:
    return SMSNotifier(gateway="SMSGateway")

def get_stripe_processor() -> StripePaymentProcessor:
    return StripePaymentProcessor()

def get_local_processor() -> LocalPaymentProcessor:
    return LocalPaymentProcessor()

def get_offline_processor() -> OfflinePaymentProcessor:
    return OfflinePaymentProcessor()


def get_notifier_implementation(
    customer_data: CustomerData,
) -> NotifierProtocol:
    if customer_data.contact_info.phone:
        return get_sms_notifier()

    if customer_data.contact_info.email:
        return get_email_notifier()

    raise ValueError("No se puede elegir la estrategia correcta")


def get_customer_data() -> CustomerData:
    contact_info = ContactInfo(email="jon.doe@mail.com", phone="+1234567890")
    customer_data = CustomerData(
        name="John Doe",
        contact_info=contact_info,
    )
    return customer_data


class PaymentProcessorType(Enum):
    STRIPE ="Stripe"
    LOCAL = "Local"
    OFFLINE = "Offline"


def get_payment_processor_implementation(
    payment_processor_type: PaymentProcessorType,
) -> PaymentProcessorProtocol:
    if PaymentProcessorType.STRIPE == payment_processor_type:
        return get_stripe_processor()
    if PaymentProcessorType.LOCAL == payment_processor_type:
        return get_local_processor()
    if PaymentProcessorType.OFFLINE == payment_processor_type:
        return get_offline_processor()
    raise ValueError("No se puede elegir la estrategia correcta")


def get_payment_processor_type() -> PaymentProcessorType:
    payment_processor_type = PaymentProcessorType.STRIPE
    return payment_processor_type


if __name__ == "__main__":
    payment_processor = get_payment_processor_implementation(get_payment_processor_type())

    strip_processor = get_stripe_processor()
    local_processor = get_local_processor()
    offline_processor = get_offline_processor()

    notifier = get_notifier_implementation(get_customer_data())

    email_notifier = get_email_notifier()
    sms_notifier = get_sms_notifier()

    costumer_validator = CustomerValidator()
    payment_data_validator = PaymentDataValidator()
    logger = TransactionLogger()
    service = PaymentService(
        payment_processor=payment_processor,
        notifier=notifier,
        customer_validator=costumer_validator,
        payment_validator=payment_data_validator,
        logger=logger,
    )

    # Cambio de estrategia de notificación a estrategia de email
    service.set_notifier(email_notifier)

    # Cambio de estrategia de notificación a estrategia de SMS
    service.set_notifier(sms_notifier)

    # Cambio de estrategia de procesamiento de pago a estrategia de Stripe
    service.set_payment_processor(strip_processor)

    # Cambio de estrategia de procesamiento de pago a estrategia de Local
    service.set_payment_processor(local_processor)

    # Cambio de estrategia de procesamiento de pago a estrategia de Offline
    service.set_payment_processor(offline_processor)

daniela.arenas7396

Hace 2 años

Alguien sabe si el código de este curso se puede encontrar en Github?

Hector Emanuel Barboza

Hace un año

Esta en la primera clase

Recursos

Seleccionar la estrategia correcta en tiempo de ejecución es una de las ventajas más potentes del Strategy Pattern. En un procesador de pagos construido en Python, esta capacidad permite intercambiar notificadores —correo electrónico o mensaje de texto— sin modificar la clase principal del servicio, manteniendo un diseño flexible y extensible.

¿Cómo se detecta cuándo aplicar el Strategy Pattern?

Una señal clara para aplicar este patrón es cuando un atributo de la clase de alto nivel tiene como tipo de dato una interfaz (o en Python, un protocol) [01:08]. Esto indica que múltiples clases implementan esa interfaz y cada una resuelve un caso puntual con una estrategia diferente.

En el servicio de pagos, la clase PaymentService define su atributo notifier con el tipo NotifierProtocol. Esto significa que cualquier clase que cumpla con ese protocolo puede ocupar ese lugar: un EmailNotifier, un SMSNotifier o cualquier implementación futura.

¿Cuál es el primer paso para implementar la estrategia?

El primer paso es crear un método que permita modificar la implementación de la estrategia en tiempo de ejecución [02:00]. Dentro de PaymentService se define el método set_notifier:

python def set_notifier(self, notifier: NotifierProtocol): self.notifier = notifier print("Cambiando la implementación del notificador")

Este método recibe una instancia que cumpla con NotifierProtocol y reemplaza el notificador actual. Es simple, pero es la pieza que habilita el intercambio dinámico.

¿Cómo se elige la estrategia correcta según el contexto?

El segundo paso consiste en crear una función que seleccione la estrategia adecuada para cada caso de uso [02:38]. En el archivo principal se define get_notifier_implementation, que recibe los datos del cliente y evalúa qué canal de notificación usar:

python def get_notifier_implementation(customer_data: CustomerData) -> NotifierProtocol: if customer_data.contact_info.phone: return get_sms_notifier() elif customer_data.contact_info.email: return get_email_notifier() raise Exception("No se puede elegir la estrategia correcta")

Si el contact_info contiene teléfono, se retorna un SMSNotifier [03:16].
Si contiene email, se retorna un EmailNotifier [03:50].
Si no hay ninguno de los dos, se levanta una excepción porque no existe una estrategia válida [04:12].

¿Cómo se encapsulan las estrategias disponibles?

Cada estrategia se encapsula en su propia función factoría para mantener el código limpio:

python def get_email_notifier() -> EmailNotifier: return EmailNotifier()

def get_sms_notifier() -> SMSNotifier: return SMSNotifier(gateway="sms_gateway_example")

Estas funciones se pueden invocar de forma independiente cuando se necesite cambiar la estrategia manualmente [06:30].

¿Cómo se intercambian estrategias en tiempo de ejecución?

Una vez seleccionada la estrategia inicial, el patrón permite reaccionar ante fallos y cambiar de notificador sin reiniciar el proceso [07:00]. Por ejemplo, si el envío por email falla, se captura la excepción y se cambia a SMS:

python email_notifier = get_email_notifier() sms_notifier = get_sms_notifier()

Estrategia inicial

service.set_notifier(email_notifier)

Si falla el email, cambiar a SMS

try: service.process_payment() except Exception: print("Cambio de estrategia de notificación a SMS") service.set_notifier(sms_notifier)

Este mecanismo ofrece dos beneficios principales:

Selección contextual: la estrategia se elige automáticamente según los datos del cliente.
Intercambio dinámico: ante un fallo, se sustituye la estrategia sin alterar la lógica del servicio.

Un detalle interesante es que la excepción lanzada cuando no hay teléfono ni email revela la oportunidad de crear una tercera estrategia [08:08]. Podría ser una notificación push o un registro en base de datos que garantice que el usuario reciba confirmación de su pago.

El mismo principio aplica al procesador de pagos: su atributo también es un protocolo, lo que abre la puerta a seleccionar dinámicamente entre diferentes métodos de pago [08:50]. ¿Cómo implementarías tú el Strategy Pattern para elegir el procesador de pagos correcto según el tipo de transacción? Comparte tu propuesta en los comentarios.

from abc import ABC, abstractmethod

class DiscountStrategy(ABC):

&#x20;   @abstractmethod

&#x20;   def calculate(self, amount: float) -> float:

&#x20;       """Calcula el descuento aplicado a la cantidad dada."""

&#x20;       pass

class NoDiscount(DiscountStrategy):

&#x20;   def calculate(self, amount: float) -> float:

&#x20;       return amount  # Sin descuento

class SeasonalDiscount(DiscountStrategy):

&#x20;   def calculate(self, amount: float) -> float:

&#x20;       return amount \* 0.9  # 10% de descuento

class LoyaltyDiscount(DiscountStrategy):

&#x20;   def calculate(self, amount: float) -> float:

&#x20;       return amount \* 0.85  # 15% de descuento

class ShoppingCart:

&#x20;   def \_\_init\_\_(self):

&#x20;       self.total\_amount = 0

&#x20;       self.discount\_strategy: DiscountStrategy = NoDiscount()

&#x20;   def add\_item(self, price: float):

&#x20;       self.total\_amount += price

&#x20;   def set\_discount\_strategy(self, strategy: DiscountStrategy):

&#x20;       self.discount\_strategy = strategy

&#x20;   def checkout(self) -> float:

&#x20;       return self.discount\_strategy.calculate(self.total\_amount)

\# Crear un carrito de compras

cart = ShoppingCart()

\# Agregar artículos al carrito

cart.add\_item(100)

cart.add\_item(200)

\# Sin descuento

print(f"Total sin descuento: {cart.checkout()}")  # Output: 300.0

\# Aplicar un descuento de temporada

cart.set\_discount\_strategy(SeasonalDiscount())

print(f"Total con descuento de temporada: {cart.checkout()}")  # Output: 270.0

\# Cambiar a descuento por fidelidad

cart.set\_discount\_strategy(LoyaltyDiscount())

print(f"Total con descuento por fidelidad: {cart.checkout()}")  # Output: 255.0

if __name__ == "__main__":
    stripe_pay_processor = StripePaymentProcessor()
    # 🆗 principio S
    customer_data =get_customer_info()
    notifier= get_notifier_implementation(customer_data = customer_data)
    # Para cambiar de estrategia según el contexto parte 1:
    email_notifier = get_mail
    sms_notifier = get_sms()
    
    # Se crea el manejador de dict y configura la cadena de validación
    handler_map = CustomerHandler()
    payment_data_validator = PaymentDataValidator()
    handler_map.set_next(payment_data_validator)
    # Asigna la cadena de validadores a dictionaries_map
    dictionaries_map = handler_map
    
    logger = TransactionLogger()
    
    service = PaymentService( 
        payment_processor=stripe_pay_processor, 
        notifier=notifier, #🆗
        validators= dictionaries_map, 
        logger=logger
    )
    # parte 2: Cambia la estrategia a email: 🆗
    service.set_notifier(EmailNotifier)
    #si falla: escoge la otra estrategia:
    service. set_notifier()
```Ojalá les sea de ayuda. &#x20;

búscame como @camilocsoto🐈‍⬛

import enum
from .logs import TransactionLogger
from .commons import CustomerData, ContactInfo
from .notifiers import EmailNotifier,NotifierProtocol,SMSNotifier
from .processors import (
    PaymentProcessorProtocol,
    RecurringPaymentProtocol,
    RefundPaymentProtocol,
    OfflinePaymentProcessor,
    LocalPaymentProcessor,
    StripePaymentProcessor
)
from .services import PaymentService 
from .validators.custom import CustomerValidator
from .validators.payment import PaymentDataValidator


def get_email_notifier() -> EmailNotifier:
    return EmailNotifier()
def get_sms_notifier() -> SMSNotifier:
    return SMSNotifier(gateway="Altice")

def get_non_contact_notifier():
    return Exception('No contact info found, but transaction successful')


def get_stripe_processor() -> StripePaymentProcessor:
    return StripePaymentProcessor()
def get_offline_processor() -> OfflinePaymentProcessor:
    return OfflinePaymentProcessor()

def get_local_processor() -> LocalPaymentProcessor:
    return LocalPaymentProcessor()


class ProcessorPaymentType(enum.Enum):
    STRIPE = "stripe"
    OFFLINE = "offline"
    LOCAL = "local"

def get_payment_processor(proccesor_type: ProcessorPaymentType) -> PaymentProcessorProtocol:
    if proccesor_type == ProcessorPaymentType.STRIPE:
        return get_stripe_processor()
    elif proccesor_type == ProcessorPaymentType.OFFLINE:
        return get_offline_processor()
    elif proccesor_type == ProcessorPaymentType.LOCAL:
        return get_local_processor()
    else:
        raise Exception(f"Unsupported processor type: {proccesor_type}")


def get_notifier_implemetation(customer_data: CustomerData) -> NotifierProtocol: 
    if customer_data.contact_info.email:
        return get_email_notifier()
    if customer_data.contact_info.phone:
        return get_sms_notifier()
    raise get_non_contact_notifier()


def get_customer_data() -> CustomerData:
    customer_data = CustomerData(
        name="John Doe",
        contact_info=ContactInfo(email="x@x.com"),
    )
    return customer_data

if __name__ == "__main__":

    proccessor = get_payment_processor(ProcessorPaymentType.STRIPE)

    customer_data = get_customer_data()
    
    notifier = get_notifier_implemetation(customer_data)

    email_notifier = get_email_notifier()
    sms_notifier = get_sms_notifier()

    customer_validator = CustomerValidator()
    payment_validator = PaymentDataValidator()
    logger = TransactionLogger()


    recurring_capable = isinstance(proccessor, RecurringPaymentProtocol)
    refund_capable = isinstance(proccessor, RefundPaymentProtocol)
    
    service = PaymentService(
        payment_processor=proccessor,
        notifier=email_notifier,
        customer_validator=customer_validator,
        payment_validator=payment_validator,
        logger=logger,
        recurring_processor=proccessor if recurring_capable else None,
        refund_processor=proccessor if refund_capable else None
    )


    # Cambio de estrategia de notificación a Email
    service.set_notifier(email_notifier)
    # Cambio de estrategia de notificacion a SMS
    service.set_notifier(sms_notifier)

    # Cambio de estrategia de procesamiento a offline
    service.set_payment_processor(get_offline_processor())

    # Cambio de estrategia de procesamiento a local
    service.set_payment_processor(get_local_processor())

   

from enum import Enum
from notifiers import EmailNotifier, NotifierProtocol, SMSNotifier

from .commons import CustomerData, ContactInfo
from .processors import StripePaymentProcessor, PaymentProcessorProtocol, LocalPaymentProcessor, OfflinePaymentProcessor
from .service import PaymentService
from .validators import CustomerValidator, PaymentDataValidator
from .loggers import TransactionLogger

def get_email_notifier() -> EmailNotifier:
    return EmailNotifier()

def get_sms_notifier() -> SMSNotifier:
    return SMSNotifier(gateway="SMSGateway")

def get_stripe_processor() -> StripePaymentProcessor:
    return StripePaymentProcessor()

def get_local_processor() -> LocalPaymentProcessor:
    return LocalPaymentProcessor()

def get_offline_processor() -> OfflinePaymentProcessor:
    return OfflinePaymentProcessor()


def get_notifier_implementation(
    customer_data: CustomerData,
) -> NotifierProtocol:
    if customer_data.contact_info.phone:
        return get_sms_notifier()

    if customer_data.contact_info.email:
        return get_email_notifier()

    raise ValueError("No se puede elegir la estrategia correcta")


def get_customer_data() -> CustomerData:
    contact_info = ContactInfo(email="jon.doe@mail.com", phone="+1234567890")
    customer_data = CustomerData(
        name="John Doe",
        contact_info=contact_info,
    )
    return customer_data


class PaymentProcessorType(Enum):
    STRIPE ="Stripe"
    LOCAL = "Local"
    OFFLINE = "Offline"


def get_payment_processor_implementation(
    payment_processor_type: PaymentProcessorType,
) -> PaymentProcessorProtocol:
    if PaymentProcessorType.STRIPE == payment_processor_type:
        return get_stripe_processor()
    if PaymentProcessorType.LOCAL == payment_processor_type:
        return get_local_processor()
    if PaymentProcessorType.OFFLINE == payment_processor_type:
        return get_offline_processor()
    raise ValueError("No se puede elegir la estrategia correcta")


def get_payment_processor_type() -> PaymentProcessorType:
    payment_processor_type = PaymentProcessorType.STRIPE
    return payment_processor_type


if __name__ == "__main__":
    payment_processor = get_payment_processor_implementation(get_payment_processor_type())

    strip_processor = get_stripe_processor()
    local_processor = get_local_processor()
    offline_processor = get_offline_processor()

    notifier = get_notifier_implementation(get_customer_data())

    email_notifier = get_email_notifier()
    sms_notifier = get_sms_notifier()

    costumer_validator = CustomerValidator()
    payment_data_validator = PaymentDataValidator()
    logger = TransactionLogger()
    service = PaymentService(
        payment_processor=payment_processor,
        notifier=notifier,
        customer_validator=costumer_validator,
        payment_validator=payment_data_validator,
        logger=logger,
    )

    # Cambio de estrategia de notificación a estrategia de email
    service.set_notifier(email_notifier)

    # Cambio de estrategia de notificación a estrategia de SMS
    service.set_notifier(sms_notifier)

    # Cambio de estrategia de procesamiento de pago a estrategia de Stripe
    service.set_payment_processor(strip_processor)

    # Cambio de estrategia de procesamiento de pago a estrategia de Local
    service.set_payment_processor(local_processor)

    # Cambio de estrategia de procesamiento de pago a estrategia de Offline
    service.set_payment_processor(offline_processor)

Resumen

¿Cómo se detecta cuándo aplicar el Strategy Pattern?

¿Cuál es el primer paso para implementar la estrategia?

El primer paso es crear un método que permita modificar la implementación de la estrategia en tiempo de ejecución [02:00]. Dentro de PaymentService se define el método set_notifier:

python def set_notifier(self, notifier: NotifierProtocol): self.notifier = notifier print("Cambiando la implementación del notificador")

Este método recibe una instancia que cumpla con NotifierProtocol y reemplaza el notificador actual. Es simple, pero es la pieza que habilita el intercambio dinámico.

¿Cómo se elige la estrategia correcta según el contexto?

Si el contact_info contiene teléfono, se retorna un SMSNotifier [03:16].
Si contiene email, se retorna un EmailNotifier [03:50].
Si no hay ninguno de los dos, se levanta una excepción porque no existe una estrategia válida [04:12].

¿Cómo se encapsulan las estrategias disponibles?

Cada estrategia se encapsula en su propia función factoría para mantener el código limpio:

python def get_email_notifier() -> EmailNotifier: return EmailNotifier()

def get_sms_notifier() -> SMSNotifier: return SMSNotifier(gateway="sms_gateway_example")

Estas funciones se pueden invocar de forma independiente cuando se necesite cambiar la estrategia manualmente [06:30].

¿Cómo se intercambian estrategias en tiempo de ejecución?

python email_notifier = get_email_notifier() sms_notifier = get_sms_notifier()

Estrategia inicial

service.set_notifier(email_notifier)

Si falla el email, cambiar a SMS

try: service.process_payment() except Exception: print("Cambio de estrategia de notificación a SMS") service.set_notifier(sms_notifier)

Este mecanismo ofrece dos beneficios principales:

Selección contextual: la estrategia se elige automáticamente según los datos del cliente.
Intercambio dinámico: ante un fallo, se sustituye la estrategia sin alterar la lógica del servicio.

Patrones de Diseño y Principios SOLID

Patrones de diseño y SOLID en Python

Principios SOLID

Qué es el principio de responsabilidad única

Procesador de pagos en Python con Stripe

Cómo aplicar SRP en un procesador de pagos con Stripe

Principio open-closed en Python

Clases abstractas y principio abierto-cerrado

Principio de Liskov en S.O.L.I.D.

Principio de sustitución de Liskov en Python

Principio de segregación de interfaces en SOLID

Segregación de interfaces en procesadores de pagos

Principio de inversión de dependencias en SOLID

Principio de inversión de dependencias: servicio de pagos flexible

Reestructuración del proyecto

Reestructuración con módulos de Python y SOLID

Patrones de Diseño

Qué son los patrones de diseño: definición y categorías

Strategy Pattern con Python y setprocessor

Strategy Pattern para pagos en Python

Factory Pattern: centralizar creación de objetos

Patrón Factory para procesar pagos con match

Qué es el patrón Decorator

Patrón decorador en servicios de pagos

Builder Pattern: construcción paso a paso

Builder Pattern aplicado a un servicio de pagos

Observer Pattern en sistemas de eventos

Observer en sistemas de pagos con Python

Chain of Responsibility para validar pagos

Chain of Responsibility en servicios de pagos

Código funcional vs código mantenible en Python

Strategy Pattern para pagos en Python

Progreso del curso

Patrones de Diseño y Principios SOLID

Principios SOLID

Reestructuración del proyecto

Patrones de Diseño

Recursos

Recursos