PyDecisionGraph 0.1.0__py3-none-any.whl

decision_tree/logic_group.py

@@ -0,0 +1,307 @@
+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

decision_tree/node.py

@@ -0,0 +1,180 @@
+from __future__ import annotations
+
+from abc import ABCMeta
+from collections.abc import Callable
+from typing import Any, Self
+
+from .abc import LogicGroup, LogicNode, ActionNode, LGM, NO_CONDITION
+from .exc import TooManyChildren, TooFewChildren
+from .expression import ContextLogicExpression as _CLE, AttrExpression as _AE, MathExpression as _ME, ComparisonExpression as _CE, LogicalExpression as _LE
+
+__all__ = ['NoAction', 'LongAction', 'ShortAction', 'RootLogicNode', 'ContextLogicExpression', 'AttrExpression', 'MathExpression', 'ComparisonExpression', 'LogicalExpression']
+
+
+class NoAction(ActionNode):
+    def __init__(self, auto_connect: bool = True):
+        super().__init__(
+            action=None,
+            repr='<NoAction>',
+            auto_connect=auto_connect
+        )
+
+    def eval(self, enforce_dtype: bool = False) -> ActionNode:
+        return self
+
+
+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
+        )
+
+    def eval(self, enforce_dtype: bool = False) -> ActionNode:
+        return self
+
+
+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
+        )
+
+    def eval(self, enforce_dtype: bool = False) -> ActionNode:
+        return self
+
+
+class RootLogicNode(LogicNode):
+    def __init__(self):
+        super().__init__(
+            expression=True,
+            repr=f'Entry Point'
+        )
+
+    def _entry_check(self):
+        return True
+
+    def _on_enter(self):
+        self._inspection_mode = LGM.inspection_mode
+        LGM.inspection_mode = True
+        LGM._active_nodes.clear()
+        LGM.enter_expression(node=self)
+
+    def _on_exit(self):
+        LGM.exit_expression(node=self)
+        if hasattr(self, '_inspection_mode'):
+            LGM.inspection_mode = self._inspection_mode
+        else:
+            LGM.inspection_mode = False
+
+    def append(self, expression: Self, edge_condition: Any = None):
+        if self.nodes:
+            raise TooManyChildren()
+        super().append(expression=expression, edge_condition=NO_CONDITION)
+
+    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):
+        return self.child.to_html(with_group=with_group, dry_run=dry_run, filename=filename, **kwargs)
+
+    @property
+    def child(self) -> LogicNode:
+        if self.nodes:
+            return self.last_node
+
+        raise TooFewChildren()
+
+
+class ContextLogicExpression(_CLE, LogicNode, metaclass=ABCMeta):
+    def __init__(self, expression: float | int | bool | Exception | Callable[[], Any], dtype: type = None, repr: str = None, logic_group: LogicGroup = None):
+        super().__init__(expression=expression, dtype=dtype, repr=repr, logic_group=logic_group)
+        LogicNode.__init__(self=self, expression=expression, dtype=dtype, repr=repr)
+
+    # magic method to invoke AttrExpression
+    def __getitem__(self, key: str) -> AttrExpression:
+        return AttrExpression(attr=key, logic_group=self.logic_group)
+
+    def __getattr__(self, key: str) -> AttrExpression:
+        return AttrExpression(attr=key, logic_group=self.logic_group)
+
+    # math operation to invoke MathExpression
+
+    def __add__(self, other: int | float | bool | Self) -> Self:
+        return MathExpression(left=self, op=MathExpression.Operator.add, right=other, logic_group=self.logic_group)
+
+    def __sub__(self, other: int | float | bool | Self) -> Self:
+        return MathExpression(left=self, op=MathExpression.Operator.sub, right=other, logic_group=self.logic_group)
+
+    def __mul__(self, other: int | float | bool | Self) -> Self:
+        return MathExpression(left=self, op=MathExpression.Operator.mul, right=other, logic_group=self.logic_group)
+
+    def __truediv__(self, other: int | float | bool | Self) -> Self:
+        return MathExpression(left=self, op=MathExpression.Operator.truediv, right=other, logic_group=self.logic_group)
+
+    def __floordiv__(self, other: int | float | bool | Self) -> Self:
+        return MathExpression(left=self, op=MathExpression.Operator.floordiv, right=other, logic_group=self.logic_group)
+
+    def __pow__(self, other: int | float | bool | Self) -> Self:
+        return MathExpression(left=self, op=MathExpression.Operator.pow, right=other, logic_group=self.logic_group)
+
+    def __neg__(self):
+        return MathExpression(left=self, op=MathExpression.Operator.neg, repr=f'-{self.repr}', logic_group=self.logic_group)
+
+    # Comparison operation to invoke ComparisonExpression
+
+    def __eq__(self, other: int | float | bool | str | Self) -> Self:
+        return ComparisonExpression(left=self, op=ComparisonExpression.Operator.eq, right=other, logic_group=self.logic_group)
+
+    def __ne__(self, other: int | float | bool | str | Self) -> Self:
+        return ComparisonExpression(left=self, op=ComparisonExpression.Operator.ne, right=other, logic_group=self.logic_group)
+
+    def __gt__(self, other: int | float | bool | Self) -> Self:
+        return ComparisonExpression(left=self, op=ComparisonExpression.Operator.gt, right=other, logic_group=self.logic_group)
+
+    def __ge__(self, other: int | float | bool | Self) -> Self:
+        return ComparisonExpression(left=self, op=ComparisonExpression.Operator.ge, right=other, logic_group=self.logic_group)
+
+    def __lt__(self, other: int | float | bool | Self) -> Self:
+        return ComparisonExpression(left=self, op=ComparisonExpression.Operator.lt, right=other, logic_group=self.logic_group)
+
+    def __le__(self, other: int | float | bool | Self) -> Self:
+        return ComparisonExpression(left=self, op=ComparisonExpression.Operator.le, right=other, logic_group=self.logic_group)
+
+    # Logical operation to invoke LogicalExpression
+
+    def __and__(self, other: int | float | bool | Self) -> Self:
+        return LogicalExpression(left=self, op=LogicalExpression.Operator.and_, right=other, logic_group=self.logic_group)
+
+    def __or__(self, other: Self | bool) -> Self:
+        return LogicalExpression(left=self, op=LogicalExpression.Operator.or_, right=other, logic_group=self.logic_group)
+
+    def __invert__(self) -> Self:
+        return LogicalExpression(left=self, op=LogicalExpression.Operator.not_, repr=f'~{self.repr}', logic_group=self.logic_group)
+
+
+class AttrExpression(_AE, ContextLogicExpression):
+    def __init__(self, attr: str | int, dtype: type = None, repr: str = None, logic_group: LogicGroup = None, edge_condition: Any = True):
+        super().__init__(attr=attr, repr=repr, logic_group=logic_group)
+        ContextLogicExpression.__init__(self=self, expression=self._eval, dtype=self.dtype, repr=self.repr, logic_group=self.logic_group)
+
+
+class MathExpression(_ME, ContextLogicExpression):
+    def __init__(self, left: ContextLogicExpression | int | float, op: _ME.Operator, right: ContextLogicExpression | int | float = None, dtype: type = None, repr: str = None, logic_group: LogicGroup = None, edge_condition: Any = True):
+        super().__init__(left=left, op=op, right=right, dtype=dtype, repr=repr, logic_group=logic_group)
+        ContextLogicExpression.__init__(self=self, expression=self._eval, dtype=self.dtype, repr=self.repr, logic_group=self.logic_group)
+
+
+class ComparisonExpression(_CE, ContextLogicExpression):
+    def __init__(self, left: ContextLogicExpression | int | float, op: _CE.Operator, right: ContextLogicExpression | int | float = None, dtype: type = None, repr: str = None, logic_group: LogicGroup = None, edge_condition: Any = True):
+        super().__init__(left=left, op=op, right=right, dtype=dtype, repr=repr, logic_group=logic_group)
+        ContextLogicExpression.__init__(self=self, expression=self._eval, dtype=self.dtype, repr=self.repr, logic_group=self.logic_group)
+
+
+class LogicalExpression(_LE, ContextLogicExpression):
+    def __init__(self, left: ContextLogicExpression | int | float, op: _LE.Operator, right: ContextLogicExpression | int | float = None, dtype: type = None, repr: str = None, logic_group: LogicGroup = None, edge_condition: Any = True):
+        super().__init__(left=left, op=op, right=right, dtype=dtype, repr=repr, logic_group=logic_group)
+        ContextLogicExpression.__init__(self=self, expression=self._eval, dtype=self.dtype, repr=self.repr, logic_group=self.logic_group)