rule-engine-core 0.0.1__tar.gz → 0.0.3__tar.gz

{rule_engine_core-0.0.1 → rule_engine_core-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rule-engine-core
-Version: 0.0.1
+Version: 0.0.3
 Summary: A rule engine core library for Python.
 Home-page: https://github.com/temp-noob/rule-engine
 Author: Mohit Tripathi
@@ -24,7 +24,7 @@ Dynamic: summary
 ## Build
 -> create venv and activate
 (install meta)
--> pip install steuptools wheel twine
+-> pip install setuptools wheel twine
 (build package)
 -> python setup.py sdist bdist_wheel
 -> pip install dist/rule-engine-core-0.1.0-py3-none-any.whl

{rule_engine_core-0.0.1 → rule_engine_core-0.0.3}/README.md

@@ -1,7 +1,7 @@
 ## Build
 -> create venv and activate
 (install meta)
--> pip install steuptools wheel twine
+-> pip install setuptools wheel twine
 (build package)
 -> python setup.py sdist bdist_wheel
 -> pip install dist/rule-engine-core-0.1.0-py3-none-any.whl

{rule_engine_core-0.0.1 → rule_engine_core-0.0.3}/rule_engine_core/entity_base.py

@@ -18,7 +18,7 @@ class EntityBase(ABC):
         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.expression_tree: Node = self._parse_expression(expression)
         self.node_type = node_type
         self.name = name
 
@@ -27,7 +27,7 @@ class EntityBase(ABC):
         Validates whether the operands of the entity are valid.
         _validate_node must be implemented by subclasses
         """
-        return self._validate_node(self._expression_tree)
+        return self._validate_node(self.expression_tree)
 
     @abstractmethod
     def _validate_node(self, node: Node) -> bool:
@@ -57,7 +57,7 @@ class EntityBase(ABC):
             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)
+        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:
         """
@@ -87,7 +87,7 @@ class EntityBase(ABC):
             'expression': self.expression,
             'node_type': self.node_type,
             'name': self.name,
-            'expression_tree': self._expression_tree,
+            'expression_tree': self.expression_tree,
         }
         
         

rule_engine_core-0.0.3/rule_engine_core/metadata_dao.py

@@ -0,0 +1,89 @@
+"""
+DAO and sync helpers for metadata persisted in PostgreSQL.
+"""
+
+import json
+import os
+import logging
+import psycopg2
+from typing import Optional
+from psycopg2.extensions import connection as PgConnection
+from psycopg2.extras import Json
+from rule_engine_core.entity_dao import create_connection
+
+_logger = logging.getLogger(__name__)
+
+
+class MetadataDao:
+    def __init__(self, config: Optional[dict] = None):
+        self._connection: Optional[PgConnection] = create_connection(config)
+        if self._connection is None:
+            raise RuntimeError("Failed to create a connection to the database")
+
+    def get_all_metadata(self) -> dict[str, dict]:
+        with self._connection.cursor() as cursor:
+            cursor.execute("SELECT column_name, metadata_json FROM metadata")
+            rows = cursor.fetchall()
+            return {row[0]: row[1] for row in rows}
+
+    def get_metadata(self, column_name: str) -> Optional[dict]:
+        with self._connection.cursor() as cursor:
+            cursor.execute(
+                "SELECT metadata_json FROM metadata WHERE column_name = %s",
+                (column_name,),
+            )
+            row = cursor.fetchone()
+            return row[0] if row is not None else None
+
+    def upsert_metadata(self, column_name: str, metadata_json: dict) -> bool:
+        with self._connection.cursor() as cursor:
+            try:
+                cursor.execute(
+                    """
+                    INSERT INTO metadata (column_name, metadata_json)
+                    VALUES (%s, %s)
+                    ON CONFLICT (column_name)
+                    DO UPDATE SET metadata_json = EXCLUDED.metadata_json
+                    """,
+                    (column_name, Json(metadata_json)),
+                )
+                self._connection.commit()
+                return True
+            except psycopg2.Error:
+                _logger.exception("Failed to upsert metadata for column: %s", column_name)
+                self._connection.rollback()
+                return False
+
+    def delete_metadata(self, column_name: str) -> bool:
+        with self._connection.cursor() as cursor:
+            try:
+                cursor.execute("DELETE FROM metadata WHERE column_name = %s", (column_name,))
+                self._connection.commit()
+                return True
+            except psycopg2.Error:
+                _logger.exception("Failed to delete metadata for column: %s", column_name)
+                self._connection.rollback()
+                return False
+
+    def dump_metadata_to_file(self, metadata_store_file_path: str) -> dict[str, dict]:
+        metadata = self.get_all_metadata()
+        parent_dir = os.path.dirname(metadata_store_file_path)
+        if parent_dir:
+            os.makedirs(parent_dir, exist_ok=True)
+        with open(metadata_store_file_path, "w", encoding="utf-8") as metadata_file:
+            json.dump(metadata, metadata_file, indent=4)
+        return metadata
+
+    def __del__(self):
+        self.close()
+
+    def close(self):
+        if self._connection is not None:
+            self._connection.close()
+            self._connection = None
+
+
+def sync_metadata_store_file(config: Optional[dict] = None, metadata_store_file_path: Optional[str] = None) -> dict[str, dict]:
+    resolved_metadata_store_file_path = metadata_store_file_path or os.getenv("METADATA_STORE_FILE_PATH", "metadata.json")
+    metadata_dao = MetadataDao(config)
+    return metadata_dao.dump_metadata_to_file(resolved_metadata_store_file_path)

{rule_engine_core-0.0.1 → rule_engine_core-0.0.3}/rule_engine_core/parser.py

@@ -66,7 +66,7 @@ class Parser:
     def tokenize(self, text: str):
         # Define token specifications.
         token_spec = [
-            ('NUMBER',   r'\d+(\.\d+)?'),         # Integer or decimal number
+            ('NUMBER',   r'-?\d+(\.\d+)?'),         # Integer or decimal number
             ('RELOP',    r'(<=|>=|<|>)'),          # Relational operators
             ('IDENT',    r'[A-Za-z_]\w*'),         # Identifiers (operands)
             ('OP',       r'[+\-*/&|!]'),           # Other operators
@@ -219,4 +219,4 @@ class Parser:
             _logger.error(errMsg)
             raise RuntimeError(errMsg)
         return node
-        
+        

{rule_engine_core-0.0.1 → rule_engine_core-0.0.3}/rule_engine_core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rule-engine-core
-Version: 0.0.1
+Version: 0.0.3
 Summary: A rule engine core library for Python.
 Home-page: https://github.com/temp-noob/rule-engine
 Author: Mohit Tripathi
@@ -24,7 +24,7 @@ Dynamic: summary
 ## Build
 -> create venv and activate
 (install meta)
--> pip install steuptools wheel twine
+-> pip install setuptools wheel twine
 (build package)
 -> python setup.py sdist bdist_wheel
 -> pip install dist/rule-engine-core-0.1.0-py3-none-any.whl

{rule_engine_core-0.0.1 → rule_engine_core-0.0.3}/rule_engine_core.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ 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_dao.py
 rule_engine_core/metadata_store.py
 rule_engine_core/parser.py
 rule_engine_core/rule.py
@@ -14,5 +15,6 @@ 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_metadata_dao.py
 tests/test_rule_creation_storage.py
 tests/test_rule_evaluation.py

{rule_engine_core-0.0.1 → rule_engine_core-0.0.3}/setup.py

@@ -14,7 +14,7 @@ def parse_requirements(filename):
 path = os.path.join(os.getenv('BUILD_PATH'), "requirements.txt")
 setup(
     name="rule-engine-core",  
-    version="0.0.1",          
+    version="0.0.3",          
     author="Mohit Tripathi",     
     author_email="tripathimohit051@gmail.com",
     description="A rule engine core library for Python.",

rule_engine_core-0.0.3/tests/test_metadata_dao.py

@@ -0,0 +1,82 @@
+from rule_engine_core.metadata_dao import MetadataDao, sync_metadata_store_file
+
+
+class StubCursor:
+    def __init__(self, connection):
+        self._connection = connection
+        self._rows = []
+        self._single_row = None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc, tb):
+        return False
+
+    def execute(self, query, params=None):
+        if "SELECT column_name, metadata_json FROM metadata" in query:
+            self._rows = [(k, v) for k, v in self._connection.store.items()]
+        elif "SELECT metadata_json FROM metadata WHERE column_name = %s" in query:
+            value = self._connection.store.get(params[0])
+            self._single_row = (value,) if value is not None else None
+        elif "INSERT INTO metadata" in query:
+            self._connection.store[params[0]] = getattr(params[1], "adapted", params[1])
+        elif "DELETE FROM metadata WHERE column_name = %s" in query:
+            self._connection.store.pop(params[0], None)
+
+    def fetchall(self):
+        return self._rows
+
+    def fetchone(self):
+        return self._single_row
+
+
+class StubConnection:
+    def __init__(self):
+        self.store = {"price": {"type": "float"}}
+        self.closed = 0
+
+    def cursor(self):
+        return StubCursor(self)
+
+    def commit(self):
+        return None
+
+    def rollback(self):
+        return None
+
+    def close(self):
+        self.closed = 1
+
+
+def test_metadata_dao_crud_and_dump(monkeypatch, tmp_path):
+    stub_connection = StubConnection()
+    monkeypatch.setattr("rule_engine_core.metadata_dao.create_connection", lambda _: stub_connection)
+    metadata_dao = MetadataDao()
+
+    assert metadata_dao.get_all_metadata() == {"price": {"type": "float"}}
+    assert metadata_dao.get_metadata("price") == {"type": "float"}
+    assert metadata_dao.get_metadata("missing") is None
+
+    assert metadata_dao.upsert_metadata("country", {"type": "string"})
+    assert metadata_dao.get_metadata("country") == {"type": "string"}
+
+    assert metadata_dao.delete_metadata("country")
+    assert metadata_dao.get_metadata("country") is None
+
+    metadata_file_path = tmp_path / "metadata.json"
+    metadata = metadata_dao.dump_metadata_to_file(str(metadata_file_path))
+    assert metadata == {"price": {"type": "float"}}
+    assert metadata_file_path.exists()
+
+
+def test_sync_metadata_store_file_uses_env_path(monkeypatch, tmp_path):
+    stub_connection = StubConnection()
+    monkeypatch.setattr("rule_engine_core.metadata_dao.create_connection", lambda _: stub_connection)
+    metadata_file_path = tmp_path / "metadata-from-env.json"
+    monkeypatch.setenv("METADATA_STORE_FILE_PATH", str(metadata_file_path))
+
+    metadata = sync_metadata_store_file()
+
+    assert metadata == {"price": {"type": "float"}}
+    assert metadata_file_path.exists()