rule-engine-core 0.0.1__tar.gz

rule_engine_core-0.0.1/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,13 @@
+## 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/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"

rule_engine_core-0.0.1/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-0.0.1/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-0.0.1/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-0.0.1/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-0.0.1/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-0.0.1/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-0.0.1/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/rule_engine_core.egg-info/PKG-INFO

@@ -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/rule_engine_core.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+README.md
+pyproject.toml
+setup.py
+rule_engine_core/__init__.py
+rule_engine_core/entity_base.py
+rule_engine_core/entity_dao.py
+rule_engine_core/entity_types.py
+rule_engine_core/filter.py
+rule_engine_core/metadata_store.py
+rule_engine_core/parser.py
+rule_engine_core/rule.py
+rule_engine_core.egg-info/PKG-INFO
+rule_engine_core.egg-info/SOURCES.txt
+rule_engine_core.egg-info/dependency_links.txt
+rule_engine_core.egg-info/requires.txt
+rule_engine_core.egg-info/top_level.txt
+tests/test_rule_creation_storage.py
+tests/test_rule_evaluation.py

rule_engine_core-0.0.1/rule_engine_core.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

rule_engine_core-0.0.1/rule_engine_core.egg-info/requires.txt

@@ -0,0 +1 @@
+psycopg2-binary

rule_engine_core-0.0.1/rule_engine_core.egg-info/top_level.txt

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

rule_engine_core-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

rule_engine_core-0.0.1/setup.py

@@ -0,0 +1,33 @@
+from setuptools import setup, find_packages
+import os
+
+def parse_requirements(filename):
+    """Read requirements from file, removing comments and empty lines"""
+    requirements = []
+    with open(filename, "r") as file:
+        for line in file:
+            line = line.strip()
+            # Skip comments and empty lines
+            if line and not line.startswith('#'):
+                requirements.append(line)
+    return requirements
+path = os.path.join(os.getenv('BUILD_PATH'), "requirements.txt")
+setup(
+    name="rule-engine-core",  
+    version="0.0.1",          
+    author="Mohit Tripathi",     
+    author_email="tripathimohit051@gmail.com",
+    description="A rule engine core library for Python.",
+    long_description=open("README.md").read(),
+    long_description_content_type="text/markdown",
+    url="https://github.com/temp-noob/rule-engine", 
+    packages=find_packages(),  
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.10",  
+    # install_requires=parse_requirements("/home/tripathimohit051/rule-engine/rule-engine-core/requirements.txt")
+    install_requires=parse_requirements(path),  # Use the function to parse requirements
+)

rule_engine_core-0.0.1/tests/test_rule_creation_storage.py

@@ -0,0 +1,34 @@
+# Tests the rule creation and storage functionality
+# These are integration tests that check if the rule engine can create and store rules correctly.
+from rule_engine_core.rule import Rule
+from rule_engine_core.entity_dao import EntityDao
+from rule_engine_core.entity_types import EntityEnum, EntityNode
+from rule_engine_core.filter import Filter
+from rule_engine_core.parser import Node
+from rule_engine_core.metadata_store import MetadataStore
+import uuid
+
+def test_filter_creation_validation_storage_retrieval():
+    metadata_store = MetadataStore("tests/test_metadatastore.json")
+    entity_dao = EntityDao()
+    # Create a filter
+    filter_name = str(uuid.uuid4())
+    expression = "col2 > 10"
+    filter_obj = Filter(filter_name, expression, metadata_store, entity_dao)
+    # Validate the filter
+    assert filter_obj.validate() == True
+    # Store the filter
+    entity_dao.store_entity(EntityEnum.FILTER, filter_obj)
+    # Retrieve the filter
+    does_filter_exist = entity_dao.entity_exists(EntityEnum.FILTER, filter_name)
+    assert does_filter_exist is True
+    # Validate the retrieved filter
+    all_filters = entity_dao.get_all_entities(EntityEnum.FILTER)
+    is_filter_present = any(
+        filter_obj.name == filter_name and filter_obj.expression == expression
+        for filter_obj in all_filters.values()
+    )
+    assert is_filter_present is True
+    # Clean up
+    assert entity_dao.delete_entity(EntityEnum.FILTER, filter_name)
+

rule_engine_core-0.0.1/tests/test_rule_evaluation.py

@@ -0,0 +1,115 @@
+# Tests the rule evaluation
+# These are integration tests which first create the rule and then evaluate it.
+from rule_engine_core.rule import Rule
+from rule_engine_core.entity_dao import EntityDao
+from rule_engine_core.entity_types import EntityEnum, EntityNode
+from rule_engine_core.filter import Filter
+from rule_engine_core.parser import Node
+from rule_engine_core.metadata_store import MetadataStore
+import uuid
+import logging
+import random, string
+
+_logger = logging.getLogger(__name__)
+
+def generate_random_alphanumeric(length=8):
+    """
+    Generate a random alphanumeric string of specified length
+    where the first character is always a letter.
+    
+    Args:
+        length (int): The length of the string to generate (default: 8)
+        
+    Returns:
+        str: A random alphanumeric string starting with a letter
+    """
+    if length < 1:
+        raise ValueError("Length must be at least 1")
+    
+    # Generate a random letter for the first character
+    first_char = random.choice(string.ascii_letters)
+    
+    # Generate random alphanumeric characters for the rest of the string
+    if length > 1:
+        rest_chars = ''.join(random.choices(
+            string.ascii_letters + string.digits, 
+            k=length-1
+        ))
+        return first_char + rest_chars
+    else:
+        return first_char
+
+def test_rule_evaluation(entity_dao: EntityDao):
+    metadata_store = MetadataStore("tests/test_metadatastore.json")
+    # Create a filter with a filter name which is just alpha numeric and no dash
+    
+    filter_name = generate_random_alphanumeric()
+    _logger.debug('filter1_name: %s', filter_name)
+    expression = "col2 > 10"
+    filter_obj = Filter(filter_name, expression, metadata_store, entity_dao)
+    # Validate the filter
+    assert filter_obj.validate() == True
+    # Store the filter
+    entity_dao.store_entity(EntityEnum.FILTER, filter_obj)
+    # create another filter
+    filter_name2 = generate_random_alphanumeric()
+    _logger.debug('filter2_name: %s', filter_name2)
+    expression2 = "col3 < 20"
+    filter_obj2 = Filter(filter_name2, expression2, metadata_store, entity_dao)
+    # Validate the filter
+    assert filter_obj2.validate() == True
+    # Store the filter
+    entity_dao.store_entity(EntityEnum.FILTER, filter_obj2)
+    # Create a rule
+    rule_name = generate_random_alphanumeric()
+    expression = f"{filter_name} AND {filter_name2}"
+    rule_obj = Rule(rule_name, expression, metadata_store, entity_dao)
+    # Validate the rule
+    assert rule_obj.validate() == True
+    # Store the rule
+    entity_dao.store_entity(EntityEnum.RULE, rule_obj)
+    # import pdb; pdb.set_trace()
+    # populate the entity_cache for evaluation
+    entity_cache = {}
+    rule_entities = entity_dao.get_all_entities(EntityEnum.RULE)
+    entity_cache[EntityEnum.RULE] = {}
+    for rule_name, rule_obj in rule_entities.items():
+        entity_cache[EntityEnum.RULE][rule_name] = Rule(rule_name, rule_obj.expression, metadata_store, entity_dao)
+    filter_entities = entity_dao.get_all_entities(EntityEnum.FILTER)
+    entity_cache[EntityEnum.FILTER] = {}
+    for filter_name, filter_obj in filter_entities.items():
+        entity_cache[EntityEnum.FILTER][filter_name] = Filter(filter_name, filter_obj.expression, metadata_store, entity_dao)
+    for key in entity_cache.keys():
+        _logger.info(f"entity_cache: {key.value}: {entity_cache[key].keys()}")
+    # initialise the entity_eval_cache for evaluation
+    # populate the pos_data for evaluation. pos_data is a list of all positions, each position
+    # containing the data for the columns. where columns are the fields in the metadata store
+    pos_data = [
+        {
+            "col1": "abc",
+            "col2": 15,
+            "col3": 25
+        },
+        {
+            "col1": "def",
+            "col2": 5,
+            "col3": 10
+        },
+        {
+            "col1": "ghi",
+            "col2": 12,
+            "col3": 19
+        }
+    ]
+    expectations = [False, False, True]
+    for rule_name, rule_obj in entity_cache[EntityEnum.RULE].items():
+        for pos, exp in zip(pos_data, expectations):
+            entity_eval_cache = {EntityEnum.RULE: {}, EntityEnum.FILTER: {}}
+            _logger.info(f"evaluating rule {rule_name} for pos {pos}")
+            # evaluate the rule
+            result = rule_obj.evaluate(pos, entity_eval_cache, entity_cache)
+            _logger.debug(f"state of entity_eval_cache: {entity_eval_cache}")
+            _logger.debug(f"expectation: {exp}")
+            _logger.info(f"result: {result}")
+            assert result == exp
+