[Enhacement] Generalizing, Other Use Cases and further developments

[jlugao]

This project started to solve a very specific pain of mine, however many use cases are interesting and could be explored. Basically what was going on in my mind was: I want this lib (that is not maintained since 2016) with FastApi-like interface. A couple of options for rule engine were available and didn't match my criteria, such as:

• No obscure DSL (perhaps I am being ignorant here, but I don want to have a fully functional language to create conditions) - https://github.com/buguroo/pyknow
• Being able to easily implement new conditions easily without operator juggling - http://jsonlogic.com/ (this could be implemented as a condition if someone wants a condition which takes an operator to apply on other parameters)
• No complex lingo and higher level abstractions that I should learn in order to use (ok, this was something I considered a lot, but I really don't want to know stuff that can't be easily explained to have a simple rule engine running) - https://github.com/jruizgit/rules and https://github.com/nemonik/Intellect (it took me a while to strip this down to basic functionality and this was way too generic. Ok, we are walking in to the generic problem solving path, but we should keep in mind to have simple api to solve simple problems and more general api or more specific api to solve broader and more complex cases)

Some of the other use cases I could come up with:

• ETL
• programmatic workflow automation (would requires some libs for common tasks in common apps such as google docs, trello, etc) - and here we can have many applications such as bots and integrations

[jlugao]

After a meeting, this is the proposed api:

class Engine():
    def __init__():
        self.conditions = []
        self.actions = []

    def export_engine_metadata():
        return {
            "conditions": [condition.export_condition() for condition in conditions],
            "actions": [condition.export_action() for action in actions],
        }

    def run(rule, session):
        parsed_rules = parse_rules(rule)
        for idx, item in enumerate(parsed_rules):
            item.run(session)
            session["runtime"] = {
                "call_stack" : session.get("runtime", []).append({
                    "index": idx,
                    "item": item
                }),
            }
        ...

class Item(ABC):
    def get_item_metadata():
        ...
    def export_item():
        ...

class Condition(Item):
    ...

class Action(Item):
    ...

class Operator(Item):
    ...

Payload:

        {
            "name": "first_condition",
            "args": {"lower_number": 3, "greater_number": 10},
            "type": "condition"
        },
        {
            "name": "print_the_equation",
            "args": {"lower_number": 3, "greater_number": 10},
            "type": "action"
        }

[jlugao]

Well, this was part of the first major refactoring. So far so good