decision_engine.rules

Complexity

Total Complexity

12

Size/Duplication

Total Lines	62
Duplicated Lines	0 %

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	BooleanAndRule.__repr__()	0	2	1
A	SimpleComparisonRule.check()	0	4	1
A	SimpleComparisonRule.__repr__()	0	2	1
A	BooleanAndRule.check()	0	2	1
A	BooleanAndRule.__init__()	0	3	1
A	SimpleComparisonRule.__init__()	0	6	1
A	BooleanOrRule.check()	0	2	1
A	BooleanOrRule.__init__()	0	3	1
A	BooleanOrRule.__repr__()	0	2	1
A	Rule.check()	0	3	1
A	Rule.__init__()	0	2	1
A	Rule.__repr__()	0	3	1

from abc import ABC, abstractmethod
from typing import List

from decision_engine.comparisons import Comparison
from decision_engine.sources import Source


class Rule(ABC):
    def __init__(self, name: str = None):
        self.name = name

    @abstractmethod
    def __repr__(self):
        raise NotImplementedError  # pragma: no cover

    @abstractmethod
    def check(self, data: dict) -> bool:
        raise NotImplementedError  # pragma: no cover


class SimpleComparisonRule(Rule):
    def __init__(self, source1: Source, source2: Source,
                 comparison: Comparison, name: str = None) -> None:
        self.source1 = source1
        self.source2 = source2
        self.comparison = comparison
        super().__init__(name)

    def __repr__(self):
        return f"Name: '{self.name}' | source1: '{self.source1.name}' | " \
               f"source2: '{self.source2.name}' | " \
               f"comparison: '{self.comparison.__class__.__name__}'"

    def check(self, data: dict) -> bool:
        val1 = self.source1.get_value(data)
        val2 = self.source2.get_value(data)
        return self.comparison.check(val1, val2)


class BooleanOrRule(Rule):
    def __init__(self, rules: List[Rule], name: str = None) -> None:
        self.rules = rules
        super().__init__(name)

    def __repr__(self):
        return f"Name: '{self.name}' | rules: {self.rules}"

    def check(self, data: dict) -> bool:
        return any([rule.check(data) for rule in self.rules])


class BooleanAndRule(Rule):
    def __init__(self, rules: List[Rule], name: str = None) -> None:
        self.rules = rules
        super().__init__(name)

    def __repr__(self):
        return f"Name: '{self.name}' | rules: {self.rules}"

    def check(self, data: dict) -> bool:
        return all([rule.check(data) for rule in self.rules])