Card processors

processors.py

from __future__ import annotations
from abc import ABC, abstractmethod
from typing import Any, Optional


class CardSettings(object):
    def load_credentials():
        pass


class AmuCardSettings(CardSettings):
    # TODO completar
    pass


class TruuCardSettings(CardSettings):
    # TODO Completar
    pass


class Handler(ABC):
    @abstractmethod
    def set_next(self, handler: Handler) -> Handler:
        pass

    @abstractmethod
    def handle(self, request) -> Optional[CardProcessor]:
        pass


class AbstractHandler(Handler):
    """
    The default chaining behavior can be implemented inside a base handler
    class.
    """

    _next_handler: Handler = None

    def set_next(self, handler: Handler) -> Handler:
        self._next_handler = handler
        return handler

    @abstractmethod
    def handle(self, card: Card) -> Optional[CardSettings]:
        if self._next_handler:
            return self._next_handler.handle(card)
        raise NotImplementedError


class AmuHandler(AbstractHandler):
    def handle(self, card: Card) -> CardSettings:
        if card.is_tutuka():
            return AmuCardSettings()
        else:
            return super().handle(card)


class TruuHandler(AbstractHandler):
    def handle(self, card: Card) -> CardSettings:
        if card.is_parabilia():
            return TruuCardSettings()
        else:
            return super().handle(card)



class CardSettingsBuilder(object):
    @classmethod
    def build(card: Card) -> CardProcessor:
        amu = AmuHandler()
        truu = TruuHandler()

        processor = (
            monkey.
            set_next(amu).
            set_next(truu)
        )

        return processor