rule-engine-core 0.0.1__py3-none-any.whl

rule_engine_core/entity_base.py

@@ -0,0 +1,94 @@
+"""
+This is the base class for filter and rule entities.
+"""
+
+from abc import ABC, abstractmethod
+from rule_engine_core.parser import Node, Parser
+
+from rule_engine_core.entity_types import EntityEnum, EntityNode
+
+class EntityBase(ABC):
+    """
+    Base class for entities like Filter and Rule.
+    Provides a common implementation for evaluate and enforces validate implementation.
+    """
+
+    def __init__(self, expression: str, node_type: EntityEnum, name: str):
+        """
+        Initializes the entity with an expression string and parses it into an expression tree.
+        """
+        self.expression = expression
+        self._expression_tree: Node = self._parse_expression(expression)
+        self.node_type = node_type
+        self.name = name
+
+    def validate(self) -> bool:
+        """
+        Validates whether the operands of the entity are valid.
+        _validate_node must be implemented by subclasses
+        """
+        return self._validate_node(self._expression_tree)
+
+    @abstractmethod
+    def _validate_node(self, node: Node) -> bool:
+        """
+        Validates the operands of the entity.
+        Must be implemented by subclasses.
+        """
+        pass
+
+    @abstractmethod
+    def _evaluate_node(self, node: Node, data: dict, entity_cache: dict, entity_eval_cache) -> float|int|bool:
+        """
+        Evaluates a single node of the expression tree.
+        Must be implemented by subclasses.
+        """
+        pass
+    """
+    During eval, entity_cache should not be modified, if any lock is to be acquired, it should be acquired
+    before evaluation. Similarly, entity_eval_cache should not be modified during eval.
+    """
+    def evaluate(self, pos_data: dict, entity_eval_cache: dict, entity_cache: dict[EntityEnum, dict[str, Node]]) -> float|int|bool:
+        """
+        Evaluates the entity against the given data.
+        The evaluation is done by traversing the expression tree and evaluating each node.
+        Arguments:
+            pos_data: Dictionary of data where keys are position id and the value is a dictionary of fields and their resepective values for the position.
+            entity_eval_cache: Dictionary of cached evaluation results for entities. We do a dfs sort of thing and keep on populating the cache with the results.
+            entity_cache: Dictionary of cached entities. This is used to get entity object by entity id.
+        """
+        return self._evaluate_node(EntityNode(self._expression_tree, self.node_type), pos_data, entity_eval_cache, entity_cache)
+
+    def _parse_expression(self, expression: str) -> Node:
+        """
+        Parses the expression string into an expression tree.
+        """
+        return Parser.parse(expression)
+    
+    def _check_if_node_is_number(self, node_ident: str) -> bool:
+        """
+        Check if the node is a number (int/float)
+        """
+        try:
+            int(node_ident)
+            return True
+        except ValueError:
+            try:
+                float(node_ident)
+                return True
+            except ValueError:
+                return False
+
+    def __getstate__(self):
+        """Control what gets pickled, excluding connection objects and other unpicklable items"""
+        # only copy expression tree, expression, name and node_type
+        # rest everything is not needed
+        state = {
+            'expression': self.expression,
+            'node_type': self.node_type,
+            'name': self.name,
+            'expression_tree': self._expression_tree,
+        }
+        
+        
+        return state

rule_engine_core/entity_dao.py

@@ -0,0 +1,179 @@
+"""
+This module defines the EntityDao class.
+This is responsible for storing and managing filter and rule entities.
+We will store these in a postgres database.
+"""
+import json
+from psycopg2.extensions import connection as PgConnection
+import psycopg2
+from rule_engine_core.parser import Node
+import os, logging
+from typing import Optional
+import pickle
+import sys
+from rule_engine_core.entity_types import EntityEnum, EntityNode
+
+# Add an alias for backwards compatibility with pickled data
+# This allows pickle to find the module at the old path
+sys.modules['entity_types'] = sys.modules['rule_engine_core.entity_types']
+sys.modules['parser'] = sys.modules['rule_engine_core.parser']
+
+from rule_engine_core.entity_base import EntityBase
+
+_logger = logging.getLogger(__name__)
+
+def create_connection(config: Optional[dict] = None) -> PgConnection:
+    if config is None:
+        # Load the config from the environment variables
+        # and assume db is on the same host as the application
+        # using the default port: 5432
+        config = {
+            "database": os.getenv("POSTGRES_DB"),
+            "user": os.getenv("POSTGRES_USER"),
+            "password": os.getenv("POSTGRES_PASSWORD"),
+            "host": os.getenv("POSTGRES_HOST", "localhost"),
+            # "port": os.getenv("POSTGRES_PORT", 5432),
+        }
+    connection = psycopg2.connect(
+        dbname=config["database"],
+        user=config["user"],
+        password=config["password"],
+        host=config["host"],
+    )
+    # check and log if the connection is successful
+    if connection.closed == 0:
+        _logger.info("Connection to the database was successful")
+        return connection
+    else:
+        _logger.error("Connection to the database failed")
+        return None
+
+class EntityDao:
+    """
+    This class is a dao for the postgres database which stores the filters and rules.
+    """    
+    def __init__(self, config_file_path: Optional[str] = None):
+        """
+        Initializes the MetadataStore object with an empty dictionary to store metadata.
+        """
+        if config_file_path is not None:
+            with open(config_file_path, 'r') as f:
+                config = json.load(f)
+        self._connection = create_connection(config if config_file_path is not None else None)
+        if self._connection is None:
+            raise RuntimeError("Failed to create a connection to the database")
+    
+    def get_all_entities(self, entity_type: EntityEnum) -> dict[str, EntityBase]:
+        """
+        Retrieves all entities of the specified type from the store.
+        """
+        # if entity_type is filter, read from the filter table
+        # if entity_type is rule, read from the rule table
+        # and then return the result as a dictionary. Where the key maps to rule_name/filter_name and the value maps to rule_data/filter_data
+        if entity_type == EntityEnum.FILTER:
+            query = "SELECT * FROM filters"
+        elif entity_type == EntityEnum.RULE:
+            query = "SELECT * FROM rules"
+        else:
+            raise ValueError(f"Invalid entity type: {entity_type}")
+        with self._connection.cursor() as cursor:
+            cursor.execute(query)
+            rows = cursor.fetchall()
+            entities = {}
+            for row in rows:
+                entity_id = row[0]
+                entity_data = row[1]
+                try:
+                    # convert the entity data to a Node object
+                    node = pickle.loads(entity_data)
+                    entities[entity_id] = node
+                except Exception as e:
+                    _logger.error(f"Failed to unpickle entity {entity_id}: {e}")
+                    # Skip this entity and continue
+                    continue
+            return entities
+        
+
+    def store_entity(self, entity_enum: EntityEnum, entity: EntityBase) -> bool:
+        """
+        Stores the entity and the expression in the store.
+        """
+        print(f"Storing entity: {entity.name} of type: {entity_enum}")
+        # if entity_enum is filter, store in the filter table
+        # if entity_enum is rule, store in the rule table
+        # and then return True if the operation was successful, False otherwise
+        
+        # Compare by value instead of direct equality
+        if entity_enum.value == EntityEnum.FILTER.value:
+            query = "INSERT INTO filters (filter_name, filter_data) VALUES (%s, %s)"
+        elif entity_enum.value == EntityEnum.RULE.value:
+            query = "INSERT INTO rules (rule_name, rule_data) VALUES (%s, %s)"
+        else:
+            raise ValueError(f"Invalid entity type: {entity_enum}")
+        
+        with self._connection.cursor() as cursor:
+            try:
+                # there shouldnt be a need to store the expression tree in the database
+                # todo: change it later
+                cursor.execute(query, (entity.name, pickle.dumps(entity)))
+                self._connection.commit()
+                return True
+            except Exception as e:
+                _logger.error(f"Failed to store entity: {e}")
+                self._connection.rollback()
+                return False
+        
+    
+    def entity_exists(self, entity_enum: EntityEnum, entity_id: str) -> bool:
+        """
+        Checks if the entity exists in the store.
+        """
+        # if entity_enum is filter, check in the filter table
+        # if entity_enum is rule, check in the rule table
+        # and then return True if the entity exists, False otherwise
+        if entity_enum.value == EntityEnum.FILTER.value:
+            query = "SELECT * FROM filters WHERE filter_name = %s"
+        elif entity_enum.value == EntityEnum.RULE.value:
+            query = "SELECT * FROM rules WHERE rule_name = %s"
+        else:
+            raise ValueError(f"Invalid entity type: {entity_enum}")
+        with self._connection.cursor() as cursor:
+            cursor.execute(query, (entity_id,))
+            rows = cursor.fetchall()
+            if len(rows) > 0:
+                return True
+            else:
+                return False
+        # close the connection
+    
+    def delete_entity(self, entity_enum: EntityEnum, entity_id: str) -> bool:
+        """
+        Deletes the entity from the store.
+        """
+        # if entity_enum is filter, delete from the filter table
+        # if entity_enum is rule, delete from the rule table
+        # and then return True if the operation was successful, False otherwise
+        if entity_enum == EntityEnum.FILTER:
+            query = "DELETE FROM filters WHERE filter_name = %s"
+        elif entity_enum == EntityEnum.RULE:
+            query = "DELETE FROM rules WHERE rule_name = %s"
+        else:
+            raise ValueError(f"Invalid entity type: {entity_enum}")
+        
+        with self._connection.cursor() as cursor:
+            try:
+                cursor.execute(query, (entity_id,))
+                self._connection.commit()
+                return True
+            except Exception as e:
+                _logger.error(f"Failed to delete entity: {e}")
+                self._connection.rollback()
+                return False
+
+    # create destructor for EntityDao class to close the connection
+    def __del__(self):
+        if self._connection is not None:
+            self._connection.close()
+            _logger.info("Connection to the database closed")
+        else:  
+            _logger.error("Connection to the database was not established")

rule_engine_core/entity_types.py

@@ -0,0 +1,10 @@
+from enum import Enum
+from rule_engine_core.parser import Node
+class EntityEnum(Enum):
+    RULE = "rule"
+    FILTER = "filter"
+
+class EntityNode:
+    def __init__(self, node: Node, entity_type: EntityEnum):
+        self.entity_type = entity_type
+        self.node = node

rule_engine_core/filter.py

@@ -0,0 +1,145 @@
+"""
+This module defines the Filter class, which represents a filter in the rule engine.
+Each filter is a single condition that can be evaluated against a given data.
+Filters can be combined with binary operators to create complex rules.
+Example of unary filter: !x: which means !(bool(x))
+Example of binary filter: x > 5 and y < 10: which means (x > 5) and (y < 10)
+The filter operands are a set of variables from financial metadata, which are used to evaluate the filter. The various operands from the metadata are used to define various aspects of a financial transaction.
+The Filter class has following methods:
+    -> validate: validates whether the operands of the filter are valid. The operands of filter should be either present in our finance metadata or filters database if the filer is composed of more leaf level filters . It queries the underlying store to check if filter operands exist either in the financial metadata or the filters database.
+    -> evaluate: evaluates the filter against the given data. The evaluation is done by evaluating each operand and combining the results using the operator.
+    -> __init__: initializes the Filter object with a string representing the expression string of the filter. The expression string is parsed to create a expression tree. The nodes of the tree are created using the Filter class. The tree is then used to evaluate the filter.
+"""
+
+from rule_engine_core.parser import Node, OPERATOR_SET
+from rule_engine_core.metadata_store import MetadataStore
+from rule_engine_core.entity_dao import EntityDao
+from rule_engine_core.entity_types import EntityEnum, EntityNode
+from rule_engine_core.entity_base import EntityBase
+import logging
+
+_logger = logging.getLogger(__name__)
+
+class Filter(EntityBase):
+    """
+    This class represents a filter in the rule engine.
+    Each filter is a single condition that can be evaluated against a given data.
+    Filters can be combined with binary operators to create complex rules.
+    """
+
+    def __init__(self, filter_name: str, expression: str, metadata_store: MetadataStore, entity_dao: EntityDao):
+        """
+        Initializes the Filter object with a string representing the expression string of the filter.
+        The expression string is parsed to create a expression tree. The nodes of the tree are created using the Filter class. The tree is then used to evaluate the filter.
+        """
+        super().__init__(expression, EntityEnum.FILTER, filter_name)
+        self.filter_name = filter_name
+        self._metadata_store = metadata_store
+        self._entity_dao = entity_dao
+
+        
+    def _validate_node(self, node: Node) -> bool:
+        """
+        Recursively validates the operands of the filter.
+        """
+        if node is None:
+            return True
+
+        if node.value in OPERATOR_SET:
+            return self._validate_node(node.left) and self._validate_node(node.right)
+
+        # make a debug log to check if the node is a number or a field in the metadata store or an existing filter in the database
+        _logger.debug(f"Node: {node.value} is node a number {self._check_if_node_is_number(node.value)} or a field in the metadata store {self._metadata_store.does_field_exist(node.value)} or an existing filter in the database {self._entity_dao.entity_exists(EntityEnum.FILTER, node.value)}")
+        # check if node value is a number or a field in the metadata store or an existing filter in the database
+        return self._check_if_node_is_number(node.value) or \
+            self._metadata_store.does_field_exist(node.value) or \
+            self._entity_dao.entity_exists(EntityEnum.FILTER, node.value)
+    
+    def _evaluate_node(self, node: EntityNode, pos_data: dict[str, str|int|float], entity_eval_cache: dict[EntityEnum, dict[str, int|float|bool]], entity_cache: dict[EntityEnum, dict[str, EntityBase]]) -> float|int|bool:
+        """
+        Evaluates the node against the given data. And updates the cache with the result. 
+        """
+        _logger.info(f"Evaluating filter {self.filter_name} with value {node.node.value} and node type {node.entity_type}")
+        # check is filter_name is cached in entity_eval_cache
+        if self.filter_name in entity_eval_cache[EntityEnum.FILTER]:
+            return entity_eval_cache[EntityEnum.FILTER][self.filter_name]
+        if node.entity_type != EntityEnum.FILTER or node.node is None:
+            raise ValueError(f"Invalid node type: {node.entity_type} or invalide node: {node.node}")
+        
+        if node.node.value not in OPERATOR_SET:
+            raise ValueError(f"Invalid operator: {node.node.value}")
+        
+        def evaluate_node_or_leaf(node_ident: str) -> float|int|bool:
+            # First check if the node_ident is a number (int/float)
+            # then check is it is a metadata field and evaluate the value
+            # from pos_data
+            # then finally check if it is a filter in the database
+            try:
+                return int(node_ident)
+            except ValueError:
+                try:
+                    return float(node_ident)
+                except ValueError:
+                    if self._metadata_store.does_field_exist(node_ident):
+                        return pos_data[node_ident]
+                    else:
+                        # if not found in metadata store, evaluate the filter from struct
+                        # since the filter has not been evaluated yet
+                        if entity_cache[EntityEnum.FILTER].get(node_ident) is None:
+                            err_msg = f"Filter {node_ident} is not a valid entity for this rule evaluation cycle"
+                            _logger.error(err_msg)
+                            # propagata the error to the rule evaluation 
+                            raise ValueError(err_msg)
+                        if entity_cache[EntityEnum.FILTER].get(node_ident).node_type is not EntityEnum.FILTER:
+                            err_msg = f"Filter {node_ident}: has bad expression tree"
+                            _logger.error(err_msg)
+                            # propagata the error to the rule evaluation 
+                            raise ValueError(err_msg)
+                        return entity_cache[EntityEnum.FILTER][node_ident].evaluate(pos_data, entity_eval_cache, entity_cache)
+        
+        match node.node.value:
+            case "!":
+                # Unary not operator
+                result = not evaluate_node_or_leaf(node.node.left.value)
+            case "&":
+                # Binary and operator
+                result = evaluate_node_or_leaf(node.node.left.value) and \
+                    evaluate_node_or_leaf(node.node.right.value)
+            case "|":
+                # Binary or operator
+                result = evaluate_node_or_leaf(node.node.left.value) or \
+                    evaluate_node_or_leaf(node.node.right.value)
+            case ">":
+                # bonary greater than operator
+                result = evaluate_node_or_leaf(node.node.left.value) > \
+                    evaluate_node_or_leaf(node.node.right.value)
+            case "<":
+                # Binary less than operator
+                result = evaluate_node_or_leaf(node.node.left.value) < \
+                    evaluate_node_or_leaf(node.node.right.value)
+            case ">=":
+                # Binary greater than or equal to operator
+                result = evaluate_node_or_leaf(node.node.left.value) >= \
+                    evaluate_node_or_leaf(node.node.right.value)
+            case "<=":
+                # Binary less than or equal to operator
+                result = evaluate_node_or_leaf(node.node.left.value) <= \
+                    evaluate_node_or_leaf(node.node.right.value)
+            case "+":
+                # Binary addition operator
+                result = evaluate_node_or_leaf(node.node.left.value) + \
+                    evaluate_node_or_leaf(node.node.right.value)
+            case "-":
+                # Binary subtraction operator
+                result = evaluate_node_or_leaf(node.node.left.value) - \
+                    evaluate_node_or_leaf(node.node.right.value)
+            case "*":
+                # Binary multiplication operator
+                result = evaluate_node_or_leaf(node.node.left.value) * \
+                    evaluate_node_or_leaf(node.node.right.value)
+            case "/":
+                # Binary division operator
+                result = evaluate_node_or_leaf(node.node.left.value) / \
+                    evaluate_node_or_leaf(node.node.right.value)
+        entity_eval_cache[EntityEnum.FILTER][self.filter_name] = result
+        return result

rule_engine_core/metadata_store.py

@@ -0,0 +1,49 @@
+"""
+This module defines the MetadataStore class, which is responsible for retrieval of financial metadata.
+The MetadataStore class provides methods for retrieval of metadata.
+There should be no writes to this and this is expected to be a read-only store.
+The MetadataStore class has the following methods:
+    -> get_attributes: Get the list of attributes available for the metadata.
+    -> get_all_metadata: retrieves all metadata from the store. The metadata is a list of dictionaries each defining a key value pair.
+    -> attribute_exist_for_field: checks if field exists in the store and if the attribute exists for the field.
+"""
+
+import json
+
+class MetadataStore:
+    def __init__(self, metadata_file_path: str):
+        """
+        Initializes the MetadataStore object with an empty dictionary to store metadata.
+        """
+        with open(metadata_file_path, 'r') as f:
+            self._metadata_store: dict[str, dict[str, str|int|float]] = json.load(f)
+        self._attributes = self._populate_attributes()
+
+    def _populate_attributes(self):
+        """
+        Populates the attributes from the metadata store.
+        """
+        attributes_set = set()
+        for _, entity_data in self._metadata_store.items():
+            for field in entity_data:
+                if field not in attributes_set:
+                    attributes_set.add(field)
+        return attributes_set
+    
+    def get_all_metadata(self) -> dict[str, dict[str, str|int|float]]:
+        """
+        Retrieves all metadata from the store. The metadata is a list of dictionaries each defining a key value pair.
+        """
+        return self._metadata_store
+
+    def does_field_exist(self, field: str) -> bool:
+        """
+        Checks if field exists in the store.
+        """
+        return field in self._metadata_store
+
+    def attribute_exist_for_field(self, field: str, attribute: str) -> bool:
+        """
+        Checks if field exists in the store and if the attribute exists for the field.
+        """
+        return field in self._metadata_store and attribute in self._metadata_store[field] and self._metadata_store[field][attribute] is not None

rule_engine_core/parser.py

@@ -0,0 +1,222 @@
+"""
+This module defines the Parser class, which is responsible for parsing the expression string of a rule or filter.
+The expression string is a string of operands and operators.
+The Parser class has the staticmethod:
+    -> parse: parses the expression string and creates a prefix expression tree. It returns the root of the tree and raises RuntimeError if the expression is invalid.
+"""
+import logging
+_logger = logging.getLogger(__name__)
+
+def _replace_words_with_symbols(expression_str):
+    """
+    Replaces NOT by ! and AND by & and OR by | in the expression string.
+    """
+    expression_str = expression_str.replace("NOT", "!")
+    expression_str = expression_str.replace("AND", "&")
+    expression_str = expression_str.replace("OR", "|")
+    return expression_str
+
+import re
+
+class Node:
+    def __init__(self, value, left=None, right=None):
+        """
+        Represents a node in the expression tree.
+        - value: a string representing an operator or operand.
+        - left: the left child (None if not applicable).
+        - right: the right child (None for leaves or unary operators).
+        """
+        self.value: str = value
+        self.left: Node = left
+        self.right: Node = right
+
+    def __repr__(self):
+        if self.left is None and self.right is None:
+            return f"Node({self.value})"
+        if self.right is None:
+            return f"Node({self.value}, {self.left})"
+        return f"Node({self.value}, {self.left}, {self.right})"
+
+OPERATOR_SET = {'+', '-', '*', '/', '&', '|', '!', '<', '<=', '>', '>='}
+
+class Parser:
+    """
+    A recursive descent parser for infix expressions that supports:
+    - Parentheses: ( and )
+    - Operands as numbers or identifiers (like abc)
+    - Operators:
+      * Unary: ! (logical not)
+      * Binary arithmetic: +, -, *, /
+      * Relational: <, <=, >, >=
+      * Bitwise: & (and), | (or)
+      
+    Operator precedence (from highest to lowest):
+      1. Unary: !
+      2. Multiplicative: *, /
+      3. Additive: +, -
+      4. Comparison: <, <=, >, >=
+      5. Bitwise AND: &
+      6. Bitwise OR: |
+    """
+    def __init__(self, text: str):
+        self.text = text
+        self.tokens = self.tokenize(text)
+        self.pos = 0
+
+    def tokenize(self, text: str):
+        # Define token specifications.
+        token_spec = [
+            ('NUMBER',   r'\d+(\.\d+)?'),         # Integer or decimal number
+            ('RELOP',    r'(<=|>=|<|>)'),          # Relational operators
+            ('IDENT',    r'[A-Za-z_]\w*'),         # Identifiers (operands)
+            ('OP',       r'[+\-*/&|!]'),           # Other operators
+            ('LPAREN',   r'\('),                  # Left Parenthesis
+            ('RPAREN',   r'\)'),                  # Right Parenthesis
+            ('SKIP',     r'\s+'),                 # Skip whitespace
+            ('MISMATCH', r'.'),                   # Any other character
+        ]
+        token_regex = '|'.join(f'(?P<{name}>{pattern})' for name, pattern in token_spec)
+        tokens = []
+        for mo in re.finditer(token_regex, text):
+            kind = mo.lastgroup
+            value = mo.group()
+            if kind == 'NUMBER':
+                tokens.append(('NUMBER', value))
+            elif kind == 'RELOP':
+                tokens.append(('RELOP', value))
+            elif kind == 'IDENT':
+                tokens.append(('IDENT', value))
+            elif kind == 'OP':
+                tokens.append(('OP', value))
+            elif kind == 'LPAREN':
+                tokens.append(('LPAREN', value))
+            elif kind == 'RPAREN':
+                tokens.append(('RPAREN', value))
+            elif kind == 'SKIP':
+                continue
+            else:
+                raise RuntimeError(f"Unexpected token: {value}")
+        return tokens
+
+    def peek(self):
+        if self.pos < len(self.tokens):
+            return self.tokens[self.pos]
+        return None
+
+    def consume(self, expected_type=None, expected_value=None):
+        token = self.peek()
+        if token is None:
+            return None
+        if expected_type and token[0] != expected_type:
+            raise RuntimeError(f"Expected token type '{expected_type}', got '{token[0]}' with value '{token[1]}'")
+        if expected_value and token[1] != expected_value:
+            raise RuntimeError(f"Expected token value '{expected_value}', got '{token[1]}'")
+        self.pos += 1
+        return token
+
+    def parse_expression(self):
+        # Top-level rule: start with the lowest precedence, bitwise OR.
+        return self.parse_bitwise_or()
+
+    def parse_bitwise_or(self):
+        node = self.parse_bitwise_and()
+        while True:
+            token = self.peek()
+            if token and token[0] == 'OP' and token[1] == '|':
+                self.consume('OP', '|')
+                right = self.parse_bitwise_and()
+                node = Node('|', node, right)
+            else:
+                break
+        return node
+
+    def parse_bitwise_and(self):
+        node = self.parse_comparison()
+        while True:
+            token = self.peek()
+            if token and token[0] == 'OP' and token[1] == '&':
+                self.consume('OP', '&')
+                right = self.parse_comparison()
+                node = Node('&', node, right)
+            else:
+                break
+        return node
+
+    def parse_comparison(self):
+        node = self.parse_additive()
+        token = self.peek()
+        # Allow at most one comparison operator (non-associative)
+        if token and token[0] == 'RELOP':
+            op = token[1]
+            self.consume('RELOP', op)
+            right = self.parse_additive()
+            node = Node(op, node, right)
+        return node
+
+    def parse_additive(self):
+        node = self.parse_multiplicative()
+        while True:
+            token = self.peek()
+            if token and token[0] == 'OP' and token[1] in ('+', '-'):
+                op = token[1]
+                self.consume('OP', op)
+                right = self.parse_multiplicative()
+                node = Node(op, node, right)
+            else:
+                break
+        return node
+
+    def parse_multiplicative(self):
+        node = self.parse_unary()
+        while True:
+            token = self.peek()
+            if token and token[0] == 'OP' and token[1] in ('*', '/'):
+                op = token[1]
+                self.consume('OP', op)
+                right = self.parse_unary()
+                node = Node(op, node, right)
+            else:
+                break
+        return node
+
+    def parse_unary(self):
+        token = self.peek()
+        if token and token[0] == 'OP' and token[1] == '!':
+            self.consume('OP', '!')
+            operand = self.parse_unary()
+            return Node('!', operand)
+        return self.parse_primary()
+
+    def parse_primary(self):
+        token = self.peek()
+        if token is None:
+            raise RuntimeError("Unexpected end of expression")
+        if token[0] == 'NUMBER' or token[0] == 'IDENT':
+            self.consume(token[0])
+            return Node(token[1])
+        elif token[0] == 'LPAREN':
+            self.consume('LPAREN')
+            node = self.parse_expression()
+            if self.peek() is None or self.peek()[0] != 'RPAREN':
+                raise RuntimeError("Missing closing parenthesis")
+            self.consume('RPAREN')
+            return node
+        else:
+            raise RuntimeError(f"Unexpected token: {token}")
+
+    @staticmethod
+    def parse(expr: str) -> Node:
+        """
+        Parses the given infix expression string and returns the root 
+        of the generated expression tree.
+        Raises RuntimeError if the expression is invalid.
+        """
+        expr = _replace_words_with_symbols(expr)
+        parser = Parser(expr)
+        node = parser.parse_expression()
+        if parser.pos != len(parser.tokens):
+            errMsg = f"Invalid expression: Extra tokens present. Parser pos{parser.pos} and tokens  {parser.tokens}"
+            _logger.error(errMsg)
+            raise RuntimeError(errMsg)
+        return node
+        

rule_engine_core/rule.py

@@ -0,0 +1,137 @@
+"""
+This module defines the Rule class, which represents a rule in the rule engine.
+Each rule contains a combination of filters or existing rule.
+Rules can be made in the following ways:
+    -> Rule with filters: A rule can be created with a combination of filters. Filters can be either combined with binary operators or can be used as a single filter optionally with a unary operators.
+    -> Rule with filters and existing rules: A rule can be created with a combination of filters and existing rules using binary operators.
+    -> Rule with existing rules: A rule can be created with a combination of existing rules using binary operators.
+The Rule class has following methods:
+    -> validate: validates whether the operands of the rule are valid. The operands of rule being rules and filters. It queries the underlying store to check if filter and rule exist.
+    -> evaluate: evaluates the rule against the given data. The evaluation is done by evaluating each operand and combining the results using the operator.
+    -> __init__: initializes the Rule object with a string representing the expression string of the rule. The expression string is parsed to create a expression tree. The nodes of the tree are created using the Filter and Rule classes. The tree is then used to evaluate the rule.
+"""
+
+from rule_engine_core.metadata_store import MetadataStore
+from rule_engine_core.entity_dao import EntityDao
+from rule_engine_core.entity_types import EntityEnum, EntityNode
+from rule_engine_core.entity_base import EntityBase
+from rule_engine_core.parser import Node, OPERATOR_SET
+import logging
+from rule_engine_core.filter import Filter
+
+_logger = logging.getLogger(__name__)
+
+class Rule(EntityBase):
+    def __init__(self, rule_name: str, expression: str, metadata_store: MetadataStore, entity_dao: EntityDao):
+        """
+        Initializes the Rule object with a string representing the expression string of the rule.
+        The expression string is parsed to create a expression tree. The nodes of the tree are created using the Filter and Rule classes. The tree is then used to evaluate the rule.
+        """
+        super().__init__(expression, EntityEnum.RULE, rule_name)
+        self.rule_name = rule_name
+        self._metadata_store = metadata_store
+        self._entity_dao = entity_dao
+    
+    def _validate_node(self, node: Node) -> bool:
+        # Recursively validates the operands of the rule.
+        if node is None:
+            return True
+        if node.value in OPERATOR_SET:
+            return self._validate_node(node.left) and self._validate_node(node.right)
+
+        # debug log if rule is a number or a field in the metadata store or an existing rule/filter in the database
+        _logger.debug(f"Node: {node.value} is node a number {self._check_if_node_is_number(node.value)} or a field in the metadata store {self._metadata_store.does_field_exist(node.value)} or an existing filter in the database {self._entity_dao.entity_exists(EntityEnum.FILTER, node.value)} or existing rule in the database {self._entity_dao.entity_exists(EntityEnum.RULE, node.value)}")
+        # todo: do we want the rules to have primary operands or just composed of rules and filters ?
+        # check if node value is a number or a field in the metadata store or an existing filter in the database
+        return self._check_if_node_is_number(node.value) or \
+            self._metadata_store.does_field_exist(node.value) or \
+            self._entity_dao.entity_exists(EntityEnum.FILTER, node.value) or \
+            self._entity_dao.entity_exists(EntityEnum.RULE, node.value)
+
+    def _evaluate_node(self, node: EntityNode, pos_data: dict[str, str|int|float], entity_eval_cache: dict[EntityEnum, dict[str, int|float|bool]], entity_cache: dict[EntityEnum, dict[str, EntityBase]]) -> float|int|bool:
+        _logger.info(f"Evaluating rule {self.rule_name} with value {node.node.value} and node type {node.entity_type}")
+        # Evaluates the node against the given data. And updates the cache with the result. 
+        # check is rule_name is cached in entity_eval_cache
+        if self.rule_name in entity_eval_cache[EntityEnum.RULE]:
+            return entity_eval_cache[EntityEnum.RULE][self.rule_name]
+        if node.entity_type != EntityEnum.RULE or node.node is None:
+            raise ValueError(f"Invalid node type: {node.entity_type} or invalide node: {node.node}")
+        
+        if node.node.value not in OPERATOR_SET:
+            raise ValueError(f"Invalid operator: {node.node.value}")
+        
+        def evaluate_node_or_leaf(node_ident: str) -> float|int|bool:
+            try:
+                return int(node_ident)
+            except ValueError:
+                try:
+                    return float(node_ident)
+                except ValueError:
+                    if self._metadata_store.does_field_exist(node_ident):
+                        return pos_data[node_ident]
+                    else:
+                        # if not found in metadata store, evaluate the filter from struct
+                        # since the filter has not been evaluated yet
+                        if entity_cache[EntityEnum.FILTER].get(node_ident, None) is None and \
+                            entity_cache[EntityEnum.RULE].get(node_ident, None) is None:
+                            err_msg = f"Filter {node_ident} is not a valid entity for this rule evaluation cycle. FIlter keys {entity_cache[EntityEnum.FILTER].keys()} Rule keys {entity_cache[EntityEnum.RULE].keys()}"
+                            _logger.error(err_msg)
+                            # propagata the error to the rule evaluation 
+                            raise ValueError(err_msg)
+                        if (node_ident in entity_cache[EntityEnum.FILTER] and entity_cache[EntityEnum.FILTER].get(node_ident).node_type is not EntityEnum.FILTER) or (node_ident in entity_cache[EntityEnum.RULE] and entity_cache[EntityEnum.RULE].get(node_ident).node_type is not EntityEnum.RULE):
+                            err_msg = f"Filter {node_ident}: has bad expression tree"
+                            _logger.error(err_msg)
+                            # propagata the error to the rule evaluation 
+                            raise ValueError(err_msg)
+                        _logger.debug(f"Evaluating child node {node_ident} of type {EntityEnum.FILTER.value if node_ident in entity_cache[EntityEnum.FILTER] else EntityEnum.RULE.value}")
+                        # import pdb; pdb.set_trace()
+                        return entity_cache[EntityEnum.FILTER][node_ident].evaluate(pos_data, entity_eval_cache, entity_cache) if entity_cache[EntityEnum.FILTER][node_ident].node_type == EntityEnum.FILTER else \
+                            entity_cache[EntityEnum.RULE][node_ident].evaluate(pos_data, entity_eval_cache, entity_cache)
+                    
+        match node.node.value:
+            case "!":
+                # Unary not operator
+                result = not evaluate_node_or_leaf(node.node.left.value)
+            case "&":
+                # Binary and operator
+                result = evaluate_node_or_leaf(node.node.left.value) and \
+                    evaluate_node_or_leaf(node.node.right.value)
+            case "|":
+                # Binary or operator
+                result = evaluate_node_or_leaf(node.node.left.value) or \
+                    evaluate_node_or_leaf(node.node.right.value)
+            case ">":
+                # bonary greater than operator
+                result = evaluate_node_or_leaf(node.node.left.value) > \
+                    evaluate_node_or_leaf(node.node.right.value)
+            case "<":
+                # Binary less than operator
+                result = evaluate_node_or_leaf(node.node.left.value) < \
+                    evaluate_node_or_leaf(node.node.right.value)
+            case ">=":
+                # Binary greater than or equal to operator
+                result = evaluate_node_or_leaf(node.node.left.value) >= \
+                    evaluate_node_or_leaf(node.node.right.value)
+            case "<=":
+                # Binary less than or equal to operator
+                result = evaluate_node_or_leaf(node.node.left.value) <= \
+                    evaluate_node_or_leaf(node.node.right.value)
+            case "+":
+                # Binary addition operator
+                result = evaluate_node_or_leaf(node.node.left.value) + \
+                    evaluate_node_or_leaf(node.node.right.value)
+            case "-":
+                # Binary subtraction operator
+                result = evaluate_node_or_leaf(node.node.left.value) - \
+                    evaluate_node_or_leaf(node.node.right.value)
+            case "*":
+                # Binary multiplication operator
+                result = evaluate_node_or_leaf(node.node.left.value) * \
+                    evaluate_node_or_leaf(node.node.right.value)
+            case "/":
+                # Binary division operator
+                result = evaluate_node_or_leaf(node.node.left.value) / \
+                    evaluate_node_or_leaf(node.node.right.value)
+        entity_eval_cache[EntityEnum.RULE][self.rule_name] = result
+        return result
+

rule_engine_core-0.0.1.dist-info/METADATA

@@ -0,0 +1,36 @@
+Metadata-Version: 2.4
+Name: rule-engine-core
+Version: 0.0.1
+Summary: A rule engine core library for Python.
+Home-page: https://github.com/temp-noob/rule-engine
+Author: Mohit Tripathi
+Author-email: tripathimohit051@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: psycopg2-binary
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+## Build
+-> create venv and activate
+(install meta)
+-> pip install steuptools wheel twine
+(build package)
+-> python setup.py sdist bdist_wheel
+-> pip install dist/rule-engine-core-0.1.0-py3-none-any.whl
+(Publish to pypi)
+-> pip install twine
+-> twine upload dist/*
+
+### Docker
+-> `psql --username=$POSTGRES_USER -d $POSTGRES_DB`

rule_engine_core-0.0.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+rule_engine_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rule_engine_core/entity_base.py,sha256=fBxO3o5I6lVfAmhABEUtrnNw4OQyMK0r3lLDFLP-qY4,3569
+rule_engine_core/entity_dao.py,sha256=luDAqOUfk_A9tt5M9vRxAgNX78tqO8YYsiLWAcopGk4,7457
+rule_engine_core/entity_types.py,sha256=KQ5x3NsVy1HYukWJvPiSsMe-BgDgAUwz76U3IqEAXPs,271
+rule_engine_core/filter.py,sha256=4bcL2W2UWby_L_5zN-jcsYD3g590mL74ksfFR1O9MfI,8647
+rule_engine_core/metadata_store.py,sha256=d-i-7RAN-DOCSpwkARDWoM4OPgJDNDCqH1TXz8bSWj8,2148
+rule_engine_core/parser.py,sha256=FLBXlE_72bmMCrjlrQnOgqDxI5HO4E0aeIP8p-rpQS8,8069
+rule_engine_core/rule.py,sha256=pnKRm3GxLrumm0byKCQcXH3YwT6OAGtbSDBjm6uCbjQ,9160
+rule_engine_core-0.0.1.dist-info/METADATA,sha256=HttQ90_OcKDZ60QRfaN96sgLWxz4Ilg16_56D3M3YTA,992
+rule_engine_core-0.0.1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+rule_engine_core-0.0.1.dist-info/top_level.txt,sha256=cAKgKEaQs3beemyeE5dLxLJ37qvZTVXc5gz0yuP2KrA,17
+rule_engine_core-0.0.1.dist-info/RECORD,,

rule_engine_core-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (78.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

rule_engine_core-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+rule_engine_core