PyDecisionGraph 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

decision_graph/__init__.py

@@ -0,0 +1,16 @@
+__version__ = "0.1.2"
+
+import logging
+import sys
+
+LOGGER = logging.getLogger("DecisionGraph")
+LOGGER.setLevel(logging.INFO)
+
+if not LOGGER.hasHandlers():
+    ch = logging.StreamHandler(sys.stdout)
+    ch.setLevel(logging.INFO)  # Set handler level
+    formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
+    ch.setFormatter(formatter)
+    LOGGER.addHandler(ch)
+
+

decision_graph/decision_tree/__init__.py

@@ -0,0 +1,44 @@
+import logging
+
+from .. import LOGGER
+
+LOGGER = LOGGER.getChild("DecisionTree")
+
+__all__ = [
+    'LOGGER', 'set_logger', 'activate_expression_model', 'activate_node_model',
+    'NodeError', 'TooManyChildren', 'TooFewChildren', 'NodeNotFountError', 'NodeValueError', 'EdgeValueError', 'ResolutionError', 'ExpressFalse', 'ContextsNotFound',
+    'LGM', 'LogicGroup', 'SkipContextsBlock', 'LogicExpression', 'ExpressionCollection', 'LogicNode', 'ActionNode', 'ELSE_CONDITION',
+    'NoAction', 'LongAction', 'ShortAction', 'RootLogicNode', 'ContextLogicExpression', 'AttrExpression', 'MathExpression', 'ComparisonExpression', 'LogicalExpression',
+    'LogicMapping', 'LogicGenerator'
+]
+
+from .exc import *
+from .abc import *
+from .node import *
+from .collection import *
+
+
+def set_logger(logger: logging.Logger):
+    global LOGGER
+    LOGGER = logger
+
+    abc.LOGGER = logger.getChild('abc')
+
+
+def activate_expression_model():
+    import importlib
+    importlib.import_module('decision_graph.decision_tree.expression')
+    importlib.reload(collection)
+    collection.LogicMapping.AttrExpression = AttrExpression
+    collection.LogicGenerator.AttrExpression = AttrExpression
+    # importlib.reload(logic_group)
+
+
+def activate_node_model():
+    import importlib
+
+    importlib.import_module('decision_graph.decision_tree.node')
+    importlib.reload(collection)
+    collection.LogicMapping.AttrExpression = AttrExpression
+    collection.LogicGenerator.AttrExpression = AttrExpression
+    # importlib.reload(logic_group)

{decision_tree → decision_graph/decision_tree}/abc.py

@@ -11,6 +11,8 @@ from typing import Any, Self, final
 from . import LOGGER
 from .exc import TooFewChildren, TooManyChildren, EdgeValueError, NodeValueError, NodeNotFountError
 
+LOGGER = LOGGER.getChild('abc')
+
 __all__ = ['LGM', 'LogicGroup', 'SkipContextsBlock', 'LogicExpression', 'ExpressionCollection', 'LogicNode', 'ActionNode', 'ELSE_CONDITION']
 
 
@@ -46,9 +48,11 @@ class LogicGroupManager(metaclass=Singleton):
         # Cursor to track the currently active LogicGroups
         self._active_groups: list[LogicGroup] = []
         self._active_nodes: list[LogicNode] = []
-        self._exit_nodes: list[ActionNode] = []  # action nodes, usually NoAction() nodes, marked as an early-exit of a logic group
-        self._pending_connection_nodes: list[ActionNode] = []  # for those exit-nodes, they will be activated when the corresponding logic group is finalized.
+        self._breakpoint_nodes: list[ActionNode] = []  # action nodes, usually NoAction() nodes, marked as an early-exit (breakpoint) of a logic group
+        self._pending_connection_nodes: list[ActionNode] = []  # for those breakpoint-nodes, they will be activated when the corresponding logic group is finalized.
+        self._shelved_state = []  # shelve state to support temporally initialize a separate node-graph
         self.inspection_mode = False
+        self.vigilant_mode = False
 
     def __call__(self, name: str, cls: type[LogicGroup], **kwargs) -> LogicGroup:
         """
@@ -95,7 +99,7 @@ class LogicGroupManager(metaclass=Singleton):
 
         self._active_groups.pop(-1)
 
-        for node in self._exit_nodes:
+        for node in self._breakpoint_nodes:
             if getattr(node, 'break_from') is logic_group:
                 self._pending_connection_nodes.append(node)
 
@@ -129,6 +133,38 @@ class LogicGroupManager(metaclass=Singleton):
 
         self._active_nodes.pop(-1)
 
+    def shelve(self):
+        shelved_state = dict(
+            active_nodes=self._active_nodes.copy(),
+            breakpoint_nodes=self._breakpoint_nodes.copy(),
+            pending_connection_nodes=self._pending_connection_nodes.copy()
+        )
+
+        self._active_nodes.clear()
+        self._breakpoint_nodes.clear()
+        self._pending_connection_nodes.clear()
+
+        self._shelved_state.append(shelved_state)
+        return shelved_state
+
+    def unshelve(self, reset_active: bool = True, reset_breakpoints: bool = True, reset_pending: bool = True):
+        shelved_state = self._shelved_state.pop(-1)
+
+        if reset_active:
+            self._active_nodes.clear()
+
+        if reset_breakpoints:
+            self._breakpoint_nodes.clear()
+
+        if reset_pending:
+            self._pending_connection_nodes.clear()
+
+        self._active_nodes[:0] = shelved_state['active_nodes']
+        self._breakpoint_nodes[:0] = shelved_state['breakpoint_nodes']
+        self._pending_connection_nodes[:0] = shelved_state['pending_connection_nodes']
+
+        return shelved_state
+
     def clear(self):
         """
         Clear the cache of LogicGroup instances and reset active groups.
@@ -242,12 +278,17 @@ class LogicGroup(object, metaclass=LogicGroupMeta):
             if active_node is not None:
                 active_node: LogicNode
                 if not active_node.nodes:
-                    raise TooFewChildren()
-                else:
-                    last_node = active_node.last_leaf
-                    assert isinstance(last_node, ActionNode), NodeValueError('An ActionNode is required before breaking a LogicGroup.')
-                    last_node.break_from = scope
-                    LGM._exit_nodes.append(last_node)
+                    if LGM.vigilant_mode:
+                        raise TooFewChildren()
+                    else:
+                        LOGGER.warning('Must have at least one action node before breaking from logic group. A NoAction node will be automatically assigned.')
+                        from .node import NoAction
+                        NoAction()
+
+                last_node = active_node.last_leaf
+                assert isinstance(last_node, ActionNode), NodeValueError('An ActionNode is required before breaking a LogicGroup.')
+                last_node.break_from = scope
+                LGM._breakpoint_nodes.append(last_node)
             return
 
         raise scope.Break()
@@ -542,14 +583,14 @@ class LogicExpression(SkipContextsBlock):
 
 
 class ExpressionCollection(LogicGroup):
-    def __init__(self, data: Any, name: str, repr: str = None, **kwargs):
+    def __init__(self, data: Any, name: str, **kwargs):
         if 'logic_group' not in kwargs:
             logic_group = kwargs.get("logic_group")
         else:
             logic_group = LGM.active_logic_group
 
         super().__init__(
-            name=repr if repr is not None else name if logic_group is None else f'{logic_group.name}.{name}',
+            name=name if name is not None else f'{logic_group.name}.{self.__class__.__name__}',
             parent=logic_group
         )
 
@@ -842,7 +883,7 @@ class LogicNode(LogicExpression):
 
         return root
 
-    def to_html(self, with_group=True, dry_run=True, filename="decision_tree.html", **kwargs):
+    def to_html(self, with_group=True, dry_run=True, filename="decision_graph.html", **kwargs):
         """
         Visualizes the decision tree using PyVis.
         If dry_run=True, shows structure without highlighting active path.
@@ -1098,8 +1139,7 @@ class LogicNode(LogicExpression):
 class ActionNode(LogicNode):
     def __init__(
             self,
-            action: float | int | bool | None | Exception | Callable[[], Any],
-            dtype: type = None,
+            action: Callable[[], Any] | None = None,
             repr: str = None,
             auto_connect: bool = True
     ):
@@ -1108,10 +1148,10 @@ class ActionNode(LogicNode):
 
         Args:
             action (Union[Any, Callable[[], Any]]): The action to execute.
-            dtype (type, optional): The expected type of the evaluated value (float, int, or bool).
             repr (str, optional): A string representation of the expression.
+            auto_connect: auto-connect to the current active decision graph.
         """
-        super().__init__(expression=True, dtype=dtype, repr=repr)
+        super().__init__(expression=True, repr=repr)
         self.action = action
 
         if auto_connect:
@@ -1123,6 +1163,14 @@ class ActionNode(LogicNode):
     def _on_exit(self):
         pass
 
+    def _post_eval(self):
+        """
+        override this method to perform clean up functions.
+        """
+
+        if self.action is not None:
+            self.action()
+
     def eval_recursively(self, path=None):
         """
         Evaluates the decision tree from this node based on the given state.
@@ -1134,10 +1182,10 @@ class ActionNode(LogicNode):
 
         value = self.eval()
 
-        if self.action is not None:
-            self.action()
+        self._post_eval()
 
         for condition, child in self.nodes.items():
+            LOGGER.warning(f'{self.__class__.__name__} should not have any sub-nodes.')
             if condition == value or condition is NO_CONDITION:
                 return child.eval_recursively(path=path)
 

{decision_tree → decision_graph/decision_tree}/collection.py

@@ -3,16 +3,14 @@ from __future__ import annotations
 from collections.abc import Mapping, Sequence
 from typing import Any
 
-from . import AttrExpression as _AE
+from . import AttrExpression
 from .abc import LogicGroup, ExpressionCollection
 
 __all__ = ['LogicMapping', 'LogicGenerator']
 
 
 class LogicMapping(ExpressionCollection):
-    AttrExpression = _AE
-
-    def __init__(self, data: dict, name: str, repr: str = None, logic_group: LogicGroup = None):
+    def __init__(self, data: dict, name: str, logic_group: LogicGroup = None):
         if data is None:
             data = {}
 
@@ -22,7 +20,6 @@ class LogicMapping(ExpressionCollection):
         super().__init__(
             data=data,
             name=name,
-            repr=repr,
             logic_group=logic_group
         )
 
@@ -33,10 +30,10 @@ class LogicMapping(ExpressionCollection):
         return self.data.__len__()
 
     def __getitem__(self, key: str):
-        return self.AttrExpression(attr=key, logic_group=self)
+        return AttrExpression(attr=key, logic_group=self)
 
     def __getattr__(self, key: str):
-        return self.AttrExpression(attr=key, logic_group=self)
+        return AttrExpression(attr=key, logic_group=self)
 
     def reset(self):
         pass
@@ -52,9 +49,7 @@ class LogicMapping(ExpressionCollection):
 
 
 class LogicGenerator(ExpressionCollection):
-    AttrExpression = _AE
-
-    def __init__(self, data: list[Any], name: str, repr: str = None, logic_group: LogicGroup = None):
+    def __init__(self, data: list[Any], name: str, logic_group: LogicGroup = None):
         if data is None:
             data = []
 
@@ -64,7 +59,6 @@ class LogicGenerator(ExpressionCollection):
         super().__init__(
             data=data,
             name=name,
-            repr=repr,
             logic_group=logic_group
         )
 
@@ -75,13 +69,13 @@ class LogicGenerator(ExpressionCollection):
             # if isinstance(value, ContextLogicExpression):
             #     yield value
 
-            yield self.AttrExpression(attr=index, logic_group=self)
+            yield AttrExpression(attr=index, logic_group=self)
 
     def __len__(self) -> int:
         return len(self.data)
 
     def __getitem__(self, index: int):
-        return self.AttrExpression(attr=index, logic_group=self)
+        return AttrExpression(attr=index, logic_group=self)
 
     def append(self, value):
         self.data.append(value)

{decision_tree → decision_graph/decision_tree}/node.py

@@ -14,11 +14,12 @@ __all__ = ['NoAction', 'LongAction', 'ShortAction', 'RootLogicNode', 'ContextLog
 class NoAction(ActionNode):
     def __init__(self, auto_connect: bool = True):
         super().__init__(
-            action=None,
             repr='<NoAction>',
             auto_connect=auto_connect
         )
 
+        self.sig = 0
+
     def eval(self, enforce_dtype: bool = False) -> ActionNode:
         return self
 
@@ -26,11 +27,12 @@ class NoAction(ActionNode):
 class LongAction(ActionNode):
     def __init__(self, sig: int = 1, auto_connect: bool = True):
         super().__init__(
-            action=sig,
             repr=f'<LongAction>(sig = {sig})',
             auto_connect=auto_connect
         )
 
+        self.sig = sig
+
     def eval(self, enforce_dtype: bool = False) -> ActionNode:
         return self
 
@@ -38,11 +40,12 @@ class LongAction(ActionNode):
 class ShortAction(ActionNode):
     def __init__(self, sig: int = -1, auto_connect: bool = True):
         super().__init__(
-            action=sig,
             repr=f'<ShortAction>(sig = {sig})',
             auto_connect=auto_connect
         )
 
+        self.sig = sig
+
     def eval(self, enforce_dtype: bool = False) -> ActionNode:
         return self
 
@@ -58,17 +61,28 @@ class RootLogicNode(LogicNode):
         return True
 
     def _on_enter(self):
-        self._inspection_mode = LGM.inspection_mode
-        LGM.inspection_mode = True
-        LGM._active_nodes.clear()
+        # pre-shelve call
         LGM.enter_expression(node=self)
 
+        state = LGM.shelve()
+
+        state['inspection_mode'] = LGM.inspection_mode
+
+        LGM.inspection_mode = True
+
+        # post-shelve call
+        LGM._active_nodes.append(self)
+
     def _on_exit(self):
+        # pre-unshelve call
+        # LGM.exit_expression(node=self)
+
+        state = LGM.unshelve()
+
+        # post-unshelve call
         LGM.exit_expression(node=self)
-        if hasattr(self, '_inspection_mode'):
-            LGM.inspection_mode = self._inspection_mode
-        else:
-            LGM.inspection_mode = False
+
+        LGM.inspection_mode = state['inspection_mode']
 
     def append(self, expression: Self, edge_condition: Any = None):
         if self.nodes:
@@ -78,7 +92,7 @@ class RootLogicNode(LogicNode):
     def eval_recursively(self, **kwargs):
         return self.child.eval_recursively(**kwargs)
 
-    def to_html(self, with_group=True, dry_run=True, filename="decision_tree.html", **kwargs):
+    def to_html(self, with_group=True, dry_run=True, filename="decision_graph.html", **kwargs):
         return self.child.to_html(with_group=with_group, dry_run=dry_run, filename=filename, **kwargs)
 
     @property

decision_graph/logic_group/__init__.py

@@ -0,0 +1,22 @@
+import logging
+
+from .. import LOGGER
+
+LOGGER = LOGGER.getChild("LogicGroup")
+
+__all__ = [
+    'SignalLogicGroup', 'InstantConfirmationLogicGroup',
+    'StateMapping', 'RequestAction', 'PendingRequest', 'RequestConfirmed', 'RequestDenied', 'RequestRegistered', 'DelayedConfirmationLogicGroup',
+]
+
+
+def set_logger(logger: logging.Logger):
+    global LOGGER
+    LOGGER = logger
+
+    base.LOGGER = logger.getChild('base')
+    pending_request.LOGGER = logger.getChild('delayed')
+
+
+from .base import *
+from .pending_request import *

decision_graph/logic_group/base.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from typing import Literal, Any, Self, overload
+
+from . import LOGGER
+from ..decision_tree import AttrExpression, LogicGroup, ActionNode, LGM, LongAction, ShortAction, NoAction
+
+LOGGER = LOGGER.getChild('base')
+
+__all__ = ['SignalLogicGroup', 'InstantConfirmationLogicGroup']
+
+
+class SignalLogicGroup(LogicGroup):
+    def __init__(self, name: str, parent: Self = None, contexts: dict[str, Any] = None):
+        super().__init__(name=name, parent=parent, contexts=contexts)
+
+    def get(self, attr: str, dtype: type = None, repr: str = None):
+        """
+        Retrieve an attribute as a LogicExpression.
+        """
+        return AttrExpression(attr=attr, logic_group=self, dtype=dtype, repr=repr)
+
+    def reset(self):
+        self.signal = 0
+
+    @property
+    def signal(self):
+        return self.contexts.get('signal', 0)
+
+    @signal.setter
+    def signal(self, value: int):
+        self.contexts['signal'] = value
+
+
+class InstantConfirmationLogicGroup(SignalLogicGroup):
+    def __init__(self, parent: SignalLogicGroup, name: str = None):
+        super().__init__(
+            name=f'{parent.name}.Instant' if name is None else name,
+            parent=parent
+        )
+
+    def reset(self):
+        pass
+
+    @overload
+    def confirm(self, sig: Literal[1]) -> LongAction:
+        ...
+
+    @overload
+    def confirm(self, sig: Literal[-1]) -> ShortAction:
+        ...
+
+    def confirm(self, sig: Literal[-1, 1]) -> ActionNode:
+        self.signal = sig
+
+        if sig > 0:
+            return LongAction(sig=sig)
+        elif sig < 0:
+            return ShortAction(sig=sig)
+
+        if not LGM.inspection_mode:
+            LOGGER.warning(f'{self} received a confirmation of {sig=}! Which is not expected.')
+
+        return NoAction()
+
+    @property
+    def signal(self):
+        return self.parent.signal
+
+    @signal.setter
+    def signal(self, value: int):
+        self.parent.signal = value

decision_graph/logic_group/pending_request.py

@@ -0,0 +1,253 @@
+from __future__ import annotations
+
+import enum
+import time
+import uuid
+from collections.abc import Mapping
+from typing import Literal, Self, TypedDict
+
+from . import LOGGER
+from .base import SignalLogicGroup
+from ..decision_tree import ActionNode, LogicMapping, LogicGroup, NodeValueError, LongAction, ShortAction, LGM, NoAction
+
+LOGGER = LOGGER.getChild('request')
+
+__all__ = ['RequestAction', 'PendingRequest', 'RequestConfirmed', 'RequestDenied', 'RequestRegistered', 'DelayedConfirmationLogicGroup']
+
+
+class StateMapping(TypedDict):
+    timestamp: float
+
+
+class RequestAction(enum.StrEnum):
+    open = enum.auto()
+    unwind = enum.auto()
+    idle = enum.auto()
+
+
+class PendingRequest(dict):
+
+    def __init__(
+            self,
+            name: str,
+            timestamp: float,
+            sig: Literal[-1, 1] | int,
+            action: str,
+            timeout: float,
+            logic_group: LogicGroup = None,
+            uid: uuid.UUID = None,
+            **kwargs
+    ):
+        super().__init__(
+            name=name,
+            timestamp=timestamp,
+            sig=sig,
+            timeout=timeout,
+            action=RequestAction(action),
+            uid=uuid.uuid4() if uid is None else uid,
+            **kwargs
+        )
+
+        self.logic_group = logic_group
+
+    def reset(self) -> PendingRequest:
+        self.update(
+            name='DummyRequest',
+            timestamp=0,
+            sig=0,
+            action=RequestAction.idle,
+            timeout=0,
+            uid=uuid.UUID(int=0)
+        )
+        return self
+
+    @classmethod
+    def empty(cls) -> PendingRequest:
+        return PendingRequest(
+            name='DummyRequest',
+            timestamp=0,
+            sig=0,
+            action=RequestAction.idle,
+            timeout=0,
+            uid=uuid.UUID(int=0)
+        )
+
+    def __bool__(self):
+        if not self.sig:
+            return False
+        return True
+
+    @property
+    def name(self) -> str:
+        return self['name']
+
+    @property
+    def timestamp(self) -> float:
+        return self['timestamp']
+
+    @property
+    def sig(self) -> int:
+        return self['sig']
+
+    @property
+    def timeout(self) -> float:
+        return self['timeout']
+
+    @property
+    def action(self) -> RequestAction:
+        return self['action']
+
+    @property
+    def uid(self) -> uuid.UUID:
+        return self['uid']
+
+
+class RequestConfirmed(ActionNode):
+    def __init__(self, sig: Literal[-1, 1], req: PendingRequest, auto_connect: bool = True):
+        super().__init__(
+            repr=f'<Pending Request Confirmed {sig=}>',
+            auto_connect=auto_connect
+        )
+
+        self.sig = sig
+        self.req = req
+
+    def eval(self, enforce_dtype: bool = False) -> ActionNode:
+        sig = self.sig
+
+        if sig > 0:
+            return LongAction(sig=sig, auto_connect=False)
+        elif sig < 0:
+            return ShortAction(sig=sig, auto_connect=False)
+
+        if not LGM.inspection_mode:
+            LOGGER.warning(f'{self} received a confirmation of {sig=}! Which is not expected.')
+
+        return NoAction(auto_connect=False)
+
+    def _post_eval(self) -> Self:
+        self.req.reset()
+
+
+class RequestDenied(ActionNode):
+    def __init__(self, req: PendingRequest, auto_connect: bool = True):
+        super().__init__(
+            repr='<Pending Request Denied>',
+            auto_connect=auto_connect
+        )
+
+        self.req = req
+
+    def eval(self, enforce_dtype: bool = False) -> ActionNode:
+        return NoAction(auto_connect=False)
+
+    def _post_eval(self) -> Self:
+        self.req.reset()
+
+
+class RequestRegistered(ActionNode):
+    def __init__(self, sig: Literal[-1, 1], req: PendingRequest, state: StateMapping | Mapping | LogicMapping = None, action: RequestAction = RequestAction.open, timeout: float = float('inf'), auto_connect: bool = True):
+        super().__init__(
+            action=self._registered,
+            repr=f'<Pending Request Registered {sig=}>',
+            auto_connect=auto_connect
+        )
+
+        self.state = state
+        self.req = req
+
+        self.sig = sig
+        self.action = action
+        self.timeout = timeout
+
+    def eval(self, enforce_dtype: bool = False) -> ActionNode:
+        return NoAction(auto_connect=False)
+
+    def _registered(self) -> Self:
+        sig = self.sig
+        timestamp = time.time() if self.state is None else self.state['timestamp']
+        action = self.action
+        timeout = self.timeout
+        uid = uuid.uuid4()
+
+        if self.sig > 0:
+            name = 'state.long'
+        elif self.sig < 0:
+            name = 'state.short'
+        else:
+            raise NodeValueError('Signal Must not be zero.')
+
+        self.req.update(
+            name=name,
+            timestamp=timestamp,
+            sig=sig,
+            timeout=timeout,
+            action=action,
+            uid=uid
+        )
+
+        return self
+
+
+class DelayedConfirmationLogicGroup(SignalLogicGroup):
+    def __init__(self, parent: SignalLogicGroup, name: str = None):
+        super().__init__(
+            name=f'{parent.name}.Delayed' if name is None else name,
+            parent=parent
+        )
+
+        self.req = self.contexts['pending_request'] = PendingRequest.empty()
+
+    def register(self, sig: Literal[1, -1], state: StateMapping | Mapping | LogicMapping = None, timeout: float = float('inf'), action: RequestAction | str = RequestAction.open) -> RequestRegistered:
+        action_register = RequestRegistered(
+            sig=sig,
+            req=self.req,
+            state=state,
+            action=RequestAction(action),
+            timeout=timeout
+        )
+
+        return action_register
+
+    def confirm(self, sig: Literal[1, -1]) -> RequestConfirmed:
+        action_confirm = RequestConfirmed(req=self.req, sig=sig)
+        return action_confirm
+
+    def deny(self) -> RequestDenied:
+        action_deny = RequestDenied(req=self.req)
+        return action_deny
+
+    def reset(self):
+        self.pending_request.reset()
+        super().reset()
+
+    @property
+    def action(self) -> RequestAction:
+        return self.pending_request.action
+
+    @property
+    def pending_request(self) -> LogicMapping:
+        req = self.req
+
+        m = LogicMapping(
+            data=req,
+            name=f'{self.name}.PendingRequest',
+            logic_group=self
+        )
+
+        return m
+
+    @pending_request.setter
+    def pending_request(self, value: PendingRequest):
+        LOGGER.warning('Assigning pending request will break the reference of previous generated decision graph. Use with caution.')
+        assert isinstance(value, PendingRequest)
+        self.req = self.contexts['pending_request'] = value
+
+    @property
+    def signal(self):
+        return self.parent.signal
+
+    @signal.setter
+    def signal(self, value: Literal[-1, 0, 1]):
+        assert isinstance(value, (int, float))
+        self.parent.signal = value

pydecisiongraph-0.1.2.dist-info/METADATA

@@ -0,0 +1,149 @@
+Metadata-Version: 2.2
+Name: PyDecisionGraph
+Version: 0.1.2
+Summary: A rule-based decision tree implementation for Python
+Home-page: https://github.com/BolunHan/PyDecisionGraph
+Author: Han Bolun
+Author-email: Han Bolun <Bolun.Han@outlook.com>
+License: MIT
+Project-URL: Homepage, https://github.com/BolunHan/PyDecisionGraph
+Project-URL: Repository, https://github.com/BolunHan/PyDecisionGraph
+Project-URL: Issues, https://github.com/BolunHan/PyDecisionGraph/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: sphinx-rtd-theme; extra == "docs"
+Requires-Dist: sphinx-autodoc-typehints; extra == "docs"
+Provides-Extra: visualization
+Requires-Dist: pyvis; extra == "visualization"
+Requires-Dist: networkx; extra == "visualization"
+
+# PyDecisionGraph
+
+`PyDecisionGraph` is an easy-to-use library to create custom decision trees, primarily designed for trading and financial decision-making. This package helps you build rule-based decision processes and visualize them effectively.
+
+## Installation
+
+To install the package, run:
+
+```bash
+pip install PyDecisionGraph
+```
+
+# Requirements
+
+- Python 3.12 or higher
+
+# Documentation
+
+For detailed documentation, visit https://pydecisiongraph.readthedocs.io/.
+
+# Quick Start
+
+Here is a quick demo on how to use `PyDecisionGraph` for building a decision tree based on various conditions:
+
+```python
+from decision_graph.decision_tree import LogicNode, LOGGER, AttrExpression, LongAction, ShortAction, NoAction, RootLogicNode, LogicMapping
+
+# Mapping of attribute names to their values
+LogicMapping.AttrExpression = AttrExpression
+
+state = {
+    "exposure": 0,  # Current exposure
+    "working_order": 0,  # Current working order
+    "up_prob": 0.8,  # Probability of price going up
+    "down_prob": 0.2,  # Probability of price going down
+    "volatility": 0.24,  # Current market volatility
+    "ttl": 15.3  # Time to live (TTL) of the decision tree
+}
+
+# Root of the logic tree
+with RootLogicNode() as root:
+    # Define root logic mapping with state data
+    with LogicMapping(name='Root', data=state) as lg_root:
+        lg_root: LogicMapping
+
+        # Condition for zero exposure
+        with lg_root.exposure == 0:
+            root: LogicNode
+            with LogicMapping(name='check_open', data=state) as lg:
+                with lg.working_order != 0:
+                    break_point = NoAction()  # No action if there's a working order
+                    lg.break_(scope=lg)  # Exit the current scope
+
+                with lg.volatility > 0.25:  # Check if volatility is high
+                    with lg.down_prob > 0.1:  # Action for down probability
+                        LongAction()
+
+                    with lg.up_prob < -0.1:  # Action for up probability
+                        ShortAction()
+
+        # Condition when TTL is greater than 30
+        with lg_root.ttl > 30:
+            with lg_root.working_order > 0:
+                ShortAction()  # Action to short if working order exists
+            LongAction()  # Always take long action
+            lg_root.break_(scope=lg_root)  # Exit scope
+
+        # Closing logic based on exposure and probabilities
+        with LogicMapping(name='check_close', data=state) as lg:
+            with (lg.exposure > 0) & (lg.down_prob > 0.):
+                ShortAction()  # Short action for positive exposure and down probability
+
+            with (lg.exposure < 0) & (lg.up_prob > 0.):
+                LongAction()  # Long action for negative exposure and up probability
+
+# Visualize the decision tree
+root.to_html()
+
+# Log the evaluation result
+LOGGER.info(root())
+```
+
+## Explanation of the Script:
+
+- LogicNode & LogicMapping:
+    - LogicNode: Represents a node in the decision tree where conditions are evaluated.
+    - LogicMapping: Associates logical conditions with the state (data) used in decision-making.
+
+- State:
+    - A dictionary containing the variables used for decision-making, such as exposure, working_order, up_prob, etc.
+
+- RootLogicNode:
+    - The entry point for the decision tree where all logical decisions are linked.
+
+- Decision Conditions:
+    - Inside each with block, logical conditions are evaluated (e.g., lg.volatility > 0.25, lg.up_prob < -0.1) to determine which action to take.
+    - Actions like LongAction() or ShortAction() are taken based on the conditions.
+
+- Action Handling:
+    - LongAction(), ShortAction(), and NoAction() represent different actions you can trigger in the decision tree based on the conditions.
+
+- Logging:
+    - The result of the tree evaluation is logged using the LOGGER object, which outputs to the console.
+
+- Visualization:
+    - root.to_html() generates an HTML representation of the decision tree for visualization.
+
+# Features
+
+- Easily define custom decision rules.
+- Actionable outcomes like LongAction, ShortAction, and NoAction.
+- Log outputs for debugging and tracking.
+- Visualize decision paths through HTML export.
+
+---
+
+# Contributing
+
+Feel free to fork, submit issues, and create pull requests. Contributions are always welcome!
+
+# License
+
+This project is licensed under the Mozilla Public License 2.0 - see the LICENSE file for details.

pydecisiongraph-0.1.2.dist-info/RECORD

@@ -0,0 +1,15 @@
+decision_graph/__init__.py,sha256=4QpoJ4PAJKXqLFITUOq55uOILaN60NWWz6q-FIBhYH4,386
+decision_graph/decision_tree/__init__.py,sha256=S1UVgQ_wj1QQ9SkVkVvVOLKA_kjulvuo56EcBIt6spM,1512
+decision_graph/decision_tree/abc.py,sha256=28tGBgXicJ802oLCPQm0Gvcm54mB1pMpbHimnt2L1MU,42114
+decision_graph/decision_tree/collection.py,sha256=PLb58A_SS7vLRJ0l-T1OaZFHYhAHjdwij68uP_HpL70,2242
+decision_graph/decision_tree/exc.py,sha256=THgIIP8S2PyJ9HIyUbNRhKT1umHfmf3Nh4rYrV8ywXU,646
+decision_graph/decision_tree/expression.py,sha256=_bd1U2tjHnCydoC1Ya6RwTasRbKweMzUsghXsDe4ZpA,16777
+decision_graph/decision_tree/node.py,sha256=x69Fa3izFQZRU_4urwYGorTR_eNAOr2IbKU7P5eeCnI,8721
+decision_graph/logic_group/__init__.py,sha256=7lnQfCbVdgP3DtsCwFJ3Ht1Ig9LKONgdX2zvHT3gT1M,528
+decision_graph/logic_group/base.py,sha256=F3eUO5nE4mB11f_KiSMpiYGFUAf947-2ESxbzskHT2U,1942
+decision_graph/logic_group/pending_request.py,sha256=0Caip4FGFqdqiw1VaRlASDJv57ExQnAvlq3PQB1NCr8,6888
+pydecisiongraph-0.1.2.dist-info/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
+pydecisiongraph-0.1.2.dist-info/METADATA,sha256=pjalVP0bT4Z1Rkx9Qki7f-SED8NxedVl27Qfhz1hWNU,5456
+pydecisiongraph-0.1.2.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+pydecisiongraph-0.1.2.dist-info/top_level.txt,sha256=3_p81U9qj9sTh1K6a1ZE-JNv7LKHaCeavuzci28VjFk,15
+pydecisiongraph-0.1.2.dist-info/RECORD,,

pydecisiongraph-0.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+decision_graph

decision_tree/__init__.py

@@ -1,36 +0,0 @@
-__version__ = "0.1.0"
-
-import logging
-import sys
-
-LOGGER = logging.getLogger("DecisionTree")
-LOGGER.setLevel(logging.INFO)
-
-if not LOGGER.hasHandlers():
-    ch = logging.StreamHandler(sys.stdout)
-    ch.setLevel(logging.INFO)  # Set handler level
-    formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
-    ch.setFormatter(formatter)
-    LOGGER.addHandler(ch)
-
-
-def set_logger(logger: logging.Logger):
-    global LOGGER
-    LOGGER = logger
-
-    exc.LOGGER = logger.getChild('TradeUtils')
-    abc.LOGGER = logger.getChild('TA')
-
-
-NODE_MODEL = True
-
-from .exc import *
-from .abc import *
-
-if NODE_MODEL:
-    from .node import *
-else:
-    from .expression import *
-
-from .collection import *
-from .logic_group import *

decision_tree/logic_group.py

@@ -1,307 +0,0 @@
-from __future__ import annotations
-
-import enum
-import uuid
-from typing import Literal, Any, Self
-
-from . import AttrExpression, LogicMapping
-from .abc import LogicGroup, SkipContextsBlock
-
-__all__ = ['SignalLogicGroup', 'InstantConfirmationLogicGroup', 'RequestAction', 'PendingRequest', 'DelayedConfirmationLogicGroup', 'RacingConfirmationLogicGroup', 'BarrierConfirmationLogicGroup']
-
-
-class SignalLogicGroup(LogicGroup):
-    def __init__(self, name: str, parent: Self = None, contexts: dict[str, Any] = None):
-        super().__init__(name=name, parent=parent, contexts=contexts)
-
-    def get(self, attr: str, dtype: type = None, repr: str = None):
-        """
-        Retrieve an attribute as a LogicExpression.
-        """
-        return AttrExpression(attr=attr, logic_group=self, dtype=dtype, repr=repr)
-
-    def reset(self):
-        self.signal = 0
-
-    @property
-    def signal(self):
-        return self.contexts.get('signal', 0)
-
-    @signal.setter
-    def signal(self, value: int):
-        self.contexts['signal'] = value
-
-
-class InstantConfirmationLogicGroup(SignalLogicGroup):
-    def __init__(self, parent: SignalLogicGroup, name: str = None):
-        super().__init__(
-            name=f'{parent.name}.Instant' if name is None else name,
-            parent=parent
-        )
-
-    def reset(self):
-        pass
-
-    def confirm(self, sig: Literal[-1, 1]):
-        self.signal = sig
-        return
-
-    @property
-    def signal(self):
-        return self.parent.signal
-
-    @signal.setter
-    def signal(self, value: int):
-        self.parent.signal = value
-
-
-class RequestAction(enum.StrEnum):
-    open = enum.auto()
-    unwind = enum.auto()
-    idle = enum.auto()
-
-
-class PendingRequest(dict):
-    class Skip(Exception):
-        pass
-
-    def __init__(
-            self,
-            name: str | RequestAction,
-            timestamp: float,
-            sig: Literal[-1, 1] | int,
-            action: str,
-            timeout: float,
-            logic_group: LogicGroup = None,
-            uid: uuid.UUID = None,
-            **kwargs
-    ):
-        super().__init__(
-            name=name,
-            timestamp=timestamp,
-            sig=sig,
-            timeout=timeout,
-            action=RequestAction(action),
-            uid=uuid.uuid4() if uid is None else uid,
-            **kwargs
-        )
-
-        self.logic_group = logic_group
-
-    @classmethod
-    def empty(cls) -> PendingRequest:
-        return PendingRequest(
-            name='DummyRequest',
-            timestamp=0,
-            sig=0,
-            action=RequestAction.idle,
-            timeout=0,
-            uid=uuid.UUID(int=0)
-        )
-
-    def __bool__(self):
-        if not self.sig:
-            return False
-        return True
-
-    @property
-    def name(self) -> str:
-        return self['name']
-
-    @property
-    def timestamp(self) -> float:
-        return self['timestamp']
-
-    @property
-    def sig(self) -> int:
-        return self['sig']
-
-    @property
-    def timeout(self) -> float:
-        return self['timeout']
-
-    @property
-    def action(self) -> RequestAction:
-        return self['action']
-
-    @property
-    def uid(self) -> uuid.UUID:
-        return self['uid']
-
-
-class DelayedConfirmationLogicGroup(SignalLogicGroup):
-    def __init__(self, parent: SignalLogicGroup, name: str = None):
-        super().__init__(
-            name=f'{parent.name}.Delayed' if name is None else name,
-            parent=parent
-        )
-
-    def register(self, name: str, timestamp: float, sig: Literal[1, -1], timeout: float | None, action: Literal['open', 'unwind'] = 'open', uid: uuid.UUID = None, **kwargs):
-        req = self.pending_request = PendingRequest(
-            name=name,
-            logic_group=self,
-            timestamp=timestamp,
-            sig=sig,
-            timeout=timeout,
-            action=action,
-            uid=uid,
-            **kwargs
-        )
-
-        return req
-
-    def confirm(self):
-        req = self.contexts.get('pending_request')
-        sig = 0 if req is None else req.sig
-        self.reset()
-        self.signal = sig
-        return sig
-
-    def deny(self):
-        # denying all the pending request
-        self.reset()
-        return 0
-
-    def reset(self):
-        # self.pending_request = PendingRequest.empty()
-        self.contexts.pop('pending_request', None)
-        super().reset()
-
-    @property
-    def action(self) -> RequestAction:
-        if 'pending_request' in self.contexts:
-            return self.pending_request.action
-
-        return RequestAction.idle
-
-    @property
-    def pending_request(self) -> LogicMapping | SkipContextsBlock:
-
-        if (req := self.contexts.get('pending_request')) is None:
-            return SkipContextsBlock(True)
-
-        m = LogicMapping(
-            data=req,
-            name=f'{self.name}.PendingRequest.{req.uid.hex}',
-            logic_group=self
-        )
-
-        return m
-
-    @pending_request.setter
-    def pending_request(self, value: PendingRequest):
-        assert isinstance(value, PendingRequest)
-        self.contexts['pending_request'] = value
-
-    @property
-    def signal(self):
-        return self.parent.signal
-
-    @signal.setter
-    def signal(self, value: Literal[-1, 0, 1]):
-        assert isinstance(value, (int, float))
-        self.parent.signal = value
-
-
-class RacingConfirmationLogicGroup(DelayedConfirmationLogicGroup):
-
-    def __init__(self, parent: SignalLogicGroup, name: str = None):
-        super().__init__(
-            name=f'{parent.name}.Racing' if name is None else name,
-            parent=parent
-        )
-
-    def __getitem__(self, uid: uuid.UUID | str | bytes | int) -> PendingRequest:
-        if not (request_pool := self.pending_request):
-            raise KeyError(f'uid {uid} not found!')
-
-        match uid:
-            case uuid.UUID():
-                for _pending_request in request_pool:
-                    if _pending_request.uid == uid:
-                        return _pending_request
-                raise KeyError(f'uid {uid} not found!')
-            case str():
-                for _pending_request in request_pool:
-                    if _pending_request.uid.hex == uid:
-                        return _pending_request
-                raise KeyError(f'uid {uid} not found!')
-            case bytes():
-                for _pending_request in request_pool:
-                    if _pending_request.uid.bytes == uid:
-                        return _pending_request
-                raise KeyError(f'uid {uid} not found!')
-            case int():
-                return request_pool[uid]
-            case _:
-                raise TypeError(f'Invalid uid {uid}! Expected UUID or bytes or str!')
-
-    def register(self, name: str, timestamp: float, sig: Literal[1, -1], timeout: float, action: Literal['open', 'unwind'] = 'open', uid: uuid.UUID = None, **kwargs):
-        self.pending_request.append(
-            PendingRequest(
-                name=name,
-                timestamp=timestamp,
-                sig=sig,
-                timeout=timeout,
-                action=action,
-                uid=uid,
-                **kwargs
-            )
-        )
-
-    def confirm(self, pending_request: PendingRequest = None, uid: uuid.UUID = None):
-        if pending_request is None and uid is None:
-            assert len(self.pending_request) == 1, ValueError('Multiple pending requests found! Must assign uid or pending_request instance!')
-            pending_request = self.pending_request[0]
-        elif pending_request is None:
-            pending_request = self.__getitem__(uid=uid)
-
-        sig = pending_request.sig
-        self.reset()
-        self.signal = sig
-        return sig
-
-    def deny(self, pending_request: PendingRequest = None, uid: uuid.UUID = None):
-        # denying all the pending request
-        if pending_request is None and uid is None:
-            self.pending_request.clear()
-            self.signal = 0
-            return
-
-        if pending_request is not None:
-            self.pending_request.remove(pending_request)
-            self.signal = 0
-
-        if uid is not None:
-            pending_request = self.__getitem__(uid=uid)
-            self.pending_request.remove(pending_request)
-            self.signal = 0
-
-    @property
-    def pending_request(self) -> list[PendingRequest]:
-        return self.contexts.setdefault('pending_request', [])
-
-
-class BarrierConfirmationLogicGroup(RacingConfirmationLogicGroup):
-
-    def __init__(self, parent: SignalLogicGroup, name: str = None):
-        super().__init__(
-            name=f'{parent.name}.Barrier' if name is None else name,
-            parent=parent
-        )
-
-    def confirm(self, pending_request: PendingRequest = None, uid: uuid.UUID = None):
-        if pending_request is None and uid is None:
-            assert len(self.pending_request) == 1, ValueError('Multiple pending requests found! Must assign uid or pending_request instance!')
-            pending_request = self.pending_request[0]
-        elif pending_request is None:
-            pending_request = self.__getitem__(uid=uid)
-
-        self.pending_request.remove(pending_request)
-
-        if self.pending_request:
-            return 0
-
-        sig = pending_request.sig
-        self.signal = sig
-        return sig

pydecisiongraph-0.1.0.dist-info/METADATA

@@ -1,21 +0,0 @@
-Metadata-Version: 2.2
-Name: PyDecisionGraph
-Version: 0.1.0
-Summary: A rule-based decision tree implementation for Python
-Home-page: https://github.com/BolunHan/PyDecisionTree
-Author: Han Bolun
-Author-email: Han Bolun <Bolun.Han@outlook.com>
-License: MIT
-Project-URL: Homepage, https://github.com/BolunHan/PyDecisionTree
-Project-URL: Repository, https://github.com/BolunHan/PyDecisionTree
-Project-URL: Issues, https://github.com/BolunHan/PyDecisionTree/issues
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.12
-Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.12
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
-# PyDecisionTree
-A easy way to create custom decision tree

pydecisiongraph-0.1.0.dist-info/RECORD

@@ -1,12 +0,0 @@
-decision_tree/__init__.py,sha256=AFHLZX4P9b6woOM78Uw5HIo83iqk9IP87quzxgsCVUM,739
-decision_tree/abc.py,sha256=yV9EraSbsDAAT01_TQVf0iuCbcE9hFCQKvQzui5CuKs,40439
-decision_tree/collection.py,sha256=K9fob0e7493BSXik0zfPzVSFupQezz1zvABYvMAo27k,2403
-decision_tree/exc.py,sha256=THgIIP8S2PyJ9HIyUbNRhKT1umHfmf3Nh4rYrV8ywXU,646
-decision_tree/expression.py,sha256=_bd1U2tjHnCydoC1Ya6RwTasRbKweMzUsghXsDe4ZpA,16777
-decision_tree/logic_group.py,sha256=-PkZJ9VzJf3WXRNmlepGeSRXBdf0K0o9yBr6xxeqvzI,9219
-decision_tree/node.py,sha256=eGxI3l7_zQMhbTtXgNnrFhKMDVvkKtJOR0_d9vfzyyY,8598
-pydecisiongraph-0.1.0.dist-info/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
-pydecisiongraph-0.1.0.dist-info/METADATA,sha256=LDfkD50rVrkYoSbnxwVuaiLbFjY3G2hOkhiMfp7VQQE,827
-pydecisiongraph-0.1.0.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-pydecisiongraph-0.1.0.dist-info/top_level.txt,sha256=bpPqmvSipqlIOvoSo-_Vc2muvqyhrfKbE6Zp-Km0J7o,14
-pydecisiongraph-0.1.0.dist-info/RECORD,,

pydecisiongraph-0.1.0.dist-info/top_level.txt

@@ -1 +0,0 @@
-decision_tree