PyDecisionGraph 0.3.2.post1__cp315-cp315-win_amd64.whl

decision_graph/logic_group/__init__.py

@@ -0,0 +1,25 @@
+import logging
+
+from .. import LOGGER
+
+LOGGER = LOGGER.getChild("LogicGroup")
+
+
+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 *
+
+__all__ = [
+    'SignalLogicGroup', 'InstantConfirmationLogicGroup',
+
+    'RequestType', 'RequestStatus', 'PendingRequest',
+    'RequestRegistered', 'RequestDenied', 'RequestConfirmed',
+    'DelayedConfirmationLogicGroup'
+]

decision_graph/logic_group/base.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+from typing import Literal, Any, overload, final
+
+from . import LOGGER
+from ..decision_tree import USING_CAPI, AttrExpression, LogicGroup, ActionNode, LGM, LongAction, ShortAction, NoAction
+
+LOGGER = LOGGER.getChild('base')
+
+__all__ = ['SignalLogicGroup', 'InstantConfirmationLogicGroup']
+
+
+class SignalLogicGroup(LogicGroup):
+    def __new__(
+            cls,
+            *,
+            name: str = None,
+            parent: LogicGroup = None,
+            contexts: dict[str, Any] = None,
+            **kwargs
+    ):
+        instance = super().__new__(
+            cls,
+            name=name,
+            parent=parent,
+            contexts=contexts
+        )
+        instance.signal = 0
+        return instance
+
+    def get(self, attr: str, dtype: type = None, repr: str = None):
+        return AttrExpression(attr=attr, logic_group=self, dtype=dtype, repr=repr)
+
+    def reset(self):
+        self.signal = 0
+
+    @property
+    def signal(self):
+        return self.contexts.setdefault('signal', 0)
+
+    @signal.setter
+    def signal(self, value: int):
+        self.contexts['signal'] = value
+
+
+@final
+class InstantConfirmationLogicGroup(SignalLogicGroup):
+    def __new__(
+            cls,
+            *,
+            name: str = None,
+            parent: LogicGroup = None,
+            contexts: dict[str, Any] = None,
+            **kwargs
+    ):
+        if not parent:
+            parent = LGM.active_group
+
+        if not isinstance(parent, SignalLogicGroup):
+            raise TypeError('InstantConfirmationLogicGroup requires a SignalLogicGroup as parent!')
+
+        instance = super().__new__(
+            cls,
+            name=f'{parent.name}.Instant' if not name else name,
+            parent=parent,
+            contexts=contexts
+        )
+        return instance
+
+    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,384 @@
+from __future__ import annotations
+
+import enum
+import threading
+import time
+import uuid
+from math import inf
+from typing import Literal, Any
+
+from algo_engine.exchange_profile import PROFILE
+
+from . import LOGGER
+from .base import SignalLogicGroup
+from ..decision_tree import ActionNode, LogicGroup, NodeValueError, LongAction, ShortAction, LGM, NoAction
+
+LOGGER = LOGGER.getChild('Request')
+
+__all__ = [
+    'RequestType', 'RequestStatus', 'PendingRequest',
+    'RequestRegistered', 'RequestDenied', 'RequestConfirmed',
+    'DelayedConfirmationLogicGroup'
+]
+
+
+class RequestType(enum.StrEnum):
+    generic = enum.auto()
+    open = enum.auto()
+    unwind = enum.auto()
+
+
+class RequestStatus(enum.StrEnum):
+    active = enum.auto()
+    idle = enum.auto()
+    locked = enum.auto()
+
+
+class PendingRequest(object):
+    def __init__(
+            self,
+            name: str = None,
+            uid: uuid.UUID = None,
+            **kwargs
+    ):
+        self.uid = uid or uuid.uuid4()
+        self.name = name or f'PendingRequest.{self.uid}'
+        self.logic_group = kwargs.get('logic_group', LGM.active_group)
+
+        self.state = {
+            'sig': kwargs.get('sig', 0),
+            'rtype': kwargs.get('rtype', RequestType.generic),
+            'rstatus': kwargs.get('rstatus', RequestStatus.idle),
+            'activated_ts': kwargs.get('activated_ts', 0),
+            'activated_by': kwargs.get('activated_by'),
+            'deactivated_by': kwargs.get('deactivated_by'),
+            'confirmed_by': kwargs.get('confirmed_by'),
+            'timeout': kwargs.get('timeout', inf),
+        }
+
+        self.register_node = {}
+        self.confirmation_node = {}
+        self.denial_node = {}
+        self.lock = threading.Lock()
+
+    def bind(self, node_id: uuid.UUID, logic_node: RequestRegistered | RequestDenied | RequestConfirmed):
+        if isinstance(logic_node, RequestRegistered):
+            self.register_node[node_id] = logic_node
+        elif isinstance(logic_node, RequestDenied):
+            self.denial_node[node_id] = logic_node
+        elif isinstance(logic_node, RequestConfirmed):
+            self.confirmation_node[node_id] = logic_node
+        else:
+            raise TypeError('PendingRequest can only be bound to RequestRegistered, RequestConfirmed, or RequestDenied nodes!')
+        return logic_node
+
+    def activate(self, node_id: uuid.UUID):
+        if self.rstatus == RequestStatus.active:
+            return
+
+        if node_id not in self.register_node:
+            raise NodeValueError('The provided node_id is not bound with this PendingRequest!')
+
+        reg_node = self.register_node[node_id]
+
+        if not reg_node.sig:
+            raise NodeValueError('Signal Must not be zero.')
+
+        if not self.lock.acquire(blocking=False):
+            raise NodeValueError('Cannot activate a locked PendingRequest!')
+
+        self.state['sig'] = reg_node.sig
+        self.state['rtype'] = reg_node.rtype
+        self.state['rstatus'] = RequestStatus.active
+        self.state['activated_ts'] = self.logic_group.contexts.get('timestamp', time.time())
+        self.state['activated_by'] = reg_node
+        self.state['deactivated_by'] = None
+        self.state['confirmed_by'] = None
+        self.state['timeout'] = reg_node.timeout
+
+        self.lock.release()
+
+    def deactivate(self, node_id: uuid.UUID):
+        if self.rstatus == RequestStatus.idle:
+            return
+
+        if node_id not in self.denial_node:
+            raise NodeValueError('The provided node_id is not bound with this PendingRequest!')
+
+        node = self.denial_node[node_id]
+
+        if not self.lock.acquire(blocking=False):
+            raise NodeValueError('Cannot deactivate a locked PendingRequest!')
+
+        self.state['sig'] = 0
+        self.state['rtype'] = RequestType.generic
+        self.state['rstatus'] = RequestStatus.idle
+        self.state['activated_ts'] = 0
+        self.state['activated_by'] = None
+        self.state['deactivated_by'] = node
+        self.state['confirmed_by'] = None
+        self.state['timeout'] = 0
+
+        self.lock.release()
+
+    def confirm(self, node_id: uuid.UUID) -> ShortAction | NoAction | LongAction:
+        if self.rstatus != RequestStatus.active:
+            raise NodeValueError('Cannot confirm a inactive PendingRequest!')
+
+        if node_id not in self.confirmation_node:
+            raise NodeValueError('The provided node_id is not bound with this PendingRequest!')
+
+        node = self.confirmation_node[node_id]
+
+        if not self.lock.acquire(blocking=False):
+            raise NodeValueError('Cannot confirm a locked PendingRequest!')
+
+        # Step 1: Lock the request
+        self.state['rstatus'] = RequestStatus.locked
+        prelaunch_check = True
+
+        # Step 2: Check timeout
+        current_ts = self.logic_group.contexts.get('timestamp', time.time())
+        activated_ts = self.state['activated_ts']
+        timeout = self.state['timeout']
+        elapsed_time = PROFILE.trading_time_between(activated_ts, current_ts)
+        if elapsed_time >= timeout:
+            prelaunch_check = False
+
+        # Step 3: Check signal match
+        if prelaunch_check and node.sig != self.sig:
+            prelaunch_check = False
+
+        # Step 4: Finalize confirmation or denial
+        if prelaunch_check:
+            if node.sig > 0:
+                action = LongAction(sig=node.sig, auto_connect=False)
+            elif node.sig < 0:
+                action = ShortAction(sig=node.sig, auto_connect=False)
+            else:
+                action = NoAction(auto_connect=False)
+        else:
+            action = NoAction(auto_connect=False)
+
+        # Step 5: Reset the request state
+        self.state['sig'] = 0
+        self.state['rtype'] = RequestType.generic
+        self.state['rstatus'] = RequestStatus.idle
+        self.state['activated_ts'] = 0
+        self.state['activated_by'] = None
+        self.state['deactivated_by'] = None
+        self.state['confirmed_by'] = node
+        self.state['timeout'] = 0
+
+        # Step 6: Release the lock and return the action
+        self.lock.release()
+        return action
+
+    def __bool__(self):
+        if not self.sig:
+            return False
+        return True
+
+    @property
+    def sig(self) -> int:
+        return self.state['sig']
+
+    @property
+    def rtype(self) -> RequestType:
+        return self.state['rtype']
+
+    @property
+    def rstatus(self) -> RequestStatus:
+        return self.state['rstatus']
+
+    @property
+    def activated_ts(self) -> float:
+        return self.state['activated_ts']
+
+    @property
+    def activated_by(self) -> RequestRegistered:
+        return self.state['activated_by']
+
+    @property
+    def deactivated_by(self) -> RequestDenied:
+        return self.state['deactivated_by']
+
+    @property
+    def confirmed_by(self) -> RequestConfirmed:
+        return self.state['confirmed_by']
+
+    @property
+    def timeout(self) -> float:
+        return self.state['timeout']
+
+
+class RequestRegistered(ActionNode):
+    def __new__(
+            cls,
+            *,
+            sig: Literal[-1, 1],
+            req: PendingRequest,
+            rtype: RequestType = RequestType.generic,
+            timeout: float = float('inf'),
+            action=None,
+            expression=None,
+            dtype=None,
+            repr=None,
+            auto_connect: bool = True,
+            **kwargs
+    ):
+        uid = uuid.uuid4()
+
+        if action is None:
+            action = lambda: req.activate(uid)
+
+        if expression is None:
+            expression = NoAction(auto_connect=False)
+
+        instance = super().__new__(
+            cls,
+            action=action,
+            expression=expression,
+            dtype=dtype,
+            repr=repr or f'<Pending Request Registered {sig=}>',
+            auto_connect=auto_connect
+        )
+
+        instance.uid = uid
+        instance.sig = sig
+        instance.req = req
+        instance.rtype = rtype
+        instance.timeout = timeout
+
+        return req.bind(uid, instance)
+
+
+class RequestDenied(ActionNode):
+    def __new__(
+            cls,
+            *,
+            req: PendingRequest,
+            action=None,
+            expression=None,
+            dtype=None,
+            repr=None,
+            auto_connect: bool = True,
+            **kwargs
+    ):
+        uid = uuid.uuid4()
+
+        if action is None:
+            action = lambda: req.deactivate(uid)
+
+        if expression is None:
+            expression = NoAction(auto_connect=False)
+
+        instance = super().__new__(
+            cls,
+            action=action,
+            expression=expression,
+            dtype=dtype,
+            repr=repr or '<Pending Request Denied>',
+            auto_connect=auto_connect
+        )
+
+        instance.uid = uid
+        instance.req = req
+        return req.bind(uid, instance)
+
+
+class RequestConfirmed(ActionNode):
+    def __new__(
+            cls,
+            *,
+            sig: Literal[-1, 1],
+            req: PendingRequest,
+            action=None,
+            expression=None,
+            dtype=None,
+            repr=None,
+            auto_connect: bool = True,
+            **kwargs
+    ):
+        uid = uuid.uuid4()
+
+        if action is None:
+            action = lambda: req.confirm(uid)
+
+        if expression is None:
+            expression = lambda: req.confirm(uid)
+
+        instance = super().__new__(
+            cls,
+            action=action,
+            expression=expression,
+            dtype=dtype,
+            repr=repr or f'<Pending Request Confirmed {sig=}>',
+            auto_connect=auto_connect
+        )
+
+        instance.uid = uid
+        instance.sig = sig
+        instance.req = req
+        return req.bind(uid, instance)
+
+
+class DelayedConfirmationLogicGroup(SignalLogicGroup):
+    def __new__(
+            cls,
+            *,
+            name: str = None,
+            parent: LogicGroup = None,
+            contexts: dict[str, Any] = None,
+            **kwargs
+    ):
+        if not parent:
+            parent = LGM.active_group
+
+        if not isinstance(parent, SignalLogicGroup):
+            raise TypeError('InstantConfirmationLogicGroup requires a SignalLogicGroup as parent!')
+
+        instance = super().__new__(
+            cls,
+            name=f'{parent.name}.Instant' if not name else name,
+            parent=parent,
+            contexts=contexts
+        )
+
+        instance.req = instance.contexts['pending_request'] = PendingRequest()
+        return instance
+
+    def register(self, sig: Literal[1, -1], timeout: float = float('inf'), rtype: RequestType = RequestType.generic) -> RequestRegistered:
+        action_register = RequestRegistered(
+            sig=sig,
+            req=self.req,
+            rtype=rtype,
+            timeout=timeout
+        )
+        return action_register
+
+    def deny(self) -> RequestDenied:
+        action_deny = RequestDenied(
+            req=self.req
+        )
+        return action_deny
+
+    def confirm(self, sig: Literal[1, -1]) -> RequestConfirmed:
+        action_confirm = RequestConfirmed(
+            sig=sig,
+            req=self.req
+        )
+        return action_confirm
+
+    def reset(self):
+        self.req.reset()
+        super().reset()
+
+    @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

decision_graph/webui/__init__.py

@@ -0,0 +1,24 @@
+"""The web UIs — one per API surface.
+
+Each layer gets its own sub-package and reads that layer directly:
+
+- ``.capi``    ``decision_graph.decision_tree.capi``   — the Cython C API
+- ``.native``  ``decision_graph.decision_tree.native`` — the pure-Python model
+- ``.bake``    ``decision_graph.decision_tree.bake``   — the bake layer
+
+Nothing is imported here on purpose: a UI drags in Flask and a directory of
+browser assets, and importing this package is not asking for either. Reach for
+the layer you want, by name::
+
+    from decision_graph.webui.bake import to_html
+
+The three share no code, also on purpose. A visualiser is worth reading only if
+it shows what ITS layer actually built, and a helper shared between two layers
+is the first place a real difference between them gets papered over.
+"""
+
+import logging
+
+# The layer's logger hangs off the root one, so a consumer that re-points
+# `decision_graph.LOGGER` re-points every UI with it.
+LOGGER = logging.getLogger("DecisionGraph").getChild("WebUI")

decision_graph/webui/bake/__init__.py

@@ -0,0 +1,65 @@
+"""The web UI of the bake layer (``decision_graph.decision_tree.bake``).
+
+The graph it draws is a bake graph — the same node set the bake protocol
+prepares for a hot walk — read through the bake surface alone; see ``.app`` for
+the one place that surface is named.
+
+A bake graph comes in two states and the page draws both:
+
+- UNBAKED, the way a build leaves it: the breakpoints a split build stopped at
+  are still in the graph, and a branch that was reserved and never filled is
+  still a placeholder;
+- BAKED, the way a walk sees it: the breakpoints are gone (what they carried
+  took their place and their arm), the stand-ins are consolidated, and the
+  graph is sealed and locked.
+"""
+
+import logging
+
+from .. import LOGGER
+from decision_graph.decision_tree.bake.c_hierarchy import RootLogicNode
+from decision_graph.decision_tree.bake.c_node import LogicNode
+
+LOGGER = LOGGER.getChild('WebUI.Bake')
+
+from . import app
+from .app import BakeWebUi
+
+
+def show(root: LogicNode, with_eval: bool = True, **kwargs):
+    _app = BakeWebUi(
+        host=kwargs.get('host', "127.0.0.1"),
+        port=kwargs.get('port', 5000),
+        debug=kwargs.get('debug', False)
+    )
+    _app.show(
+        node=root,
+        with_eval=with_eval
+    )
+
+
+def watch(root: RootLogicNode, interval: float = .5, block: bool = False, **kwargs):
+    _app = BakeWebUi(
+        host=kwargs.get('host', "127.0.0.1"),
+        port=kwargs.get('port', 5000),
+        debug=kwargs.get('debug', False)
+    )
+    _app.watch(
+        node=root,
+        interval=interval,
+        block=block
+    )
+
+
+def to_html(root: LogicNode, file_name: str, with_eval: bool = True):
+    BakeWebUi.to_html(
+        node=root,
+        file_name=file_name,
+        with_eval=with_eval
+    )
+
+
+def set_logger(logger: logging.Logger):
+    global LOGGER
+    LOGGER = logger.getChild('WebUI.Bake')
+    app.LOGGER = LOGGER