PyDecisionGraph 0.3.2.post1__cp315-cp315-win_amd64.whl

decision_graph/decision_tree/bake/c_var.pyx

@@ -0,0 +1,228 @@
+import enum
+
+from cpython.object cimport PyObject
+from cpython.unicode cimport PyUnicode_AsUTF8, PyUnicode_FromString
+from libc.stdint cimport uintptr_t
+
+
+class VarType(enum.IntEnum):
+    raw_ptr = VAR_TYPE_RAW_PTR
+    string = VAR_TYPE_STRING
+    bool = VAR_TYPE_BOOL
+    double = VAR_TYPE_DOUBLE
+    int = VAR_TYPE_INT
+    offset = VAR_TYPE_OFFSET
+    time = VAR_TYPE_TIME
+    date = VAR_TYPE_DATE
+    datetime = VAR_TYPE_DATETIME
+    d_vector = VAR_TYPE_D_VECTOR
+    d_matrix = VAR_TYPE_D_MATRIX
+    node = VAR_TYPE_NODE
+    reserved = VAR_TYPE_RESERVED
+
+    raw_ptr_ref = VAR_TYPE_RAW_PTR_REF
+    string_ref = VAR_TYPE_STRING_REF
+    bool_ref = VAR_TYPE_BOOL_REF
+    double_ref = VAR_TYPE_DOUBLE_REF
+    int_ref = VAR_TYPE_INT_REF
+    offset_ref = VAR_TYPE_OFFSET_REF
+    time_ref = VAR_TYPE_TIME_REF
+    date_ref = VAR_TYPE_DATE_REF
+    datetime_ref = VAR_TYPE_DATETIME_REF
+    d_vector_ref = VAR_TYPE_D_VECTOR_REF
+    d_matrix_ref = VAR_TYPE_D_MATRIX_REF
+    node_ref = VAR_TYPE_NODE_REF
+    inferred = VAR_TYPE_INFERRED
+
+    raw_ptr_ref_ref = VAR_TYPE_RAW_PTR_REF_REF
+    string_ref_ref = VAR_TYPE_STRING_REF_REF
+    bool_ref_ref = VAR_TYPE_BOOL_REF_REF
+    double_ref_ref = VAR_TYPE_DOUBLE_REF_REF
+    int_ref_ref = VAR_TYPE_INT_REF_REF
+    offset_ref_ref = VAR_TYPE_OFFSET_REF_REF
+    time_ref_ref = VAR_TYPE_TIME_REF_REF
+    date_ref_ref = VAR_TYPE_DATE_REF_REF
+    datetime_ref_ref = VAR_TYPE_DATETIME_REF_REF
+    d_vector_ref_ref = VAR_TYPE_D_VECTOR_REF_REF
+    d_matrix_ref_ref = VAR_TYPE_D_MATRIX_REF_REF
+    node_ref_ref = VAR_TYPE_NODE_REF_REF
+
+
+class VarNumeric(enum.IntEnum):
+    none = VAR_NUMERIC_NONE
+    int = VAR_NUMERIC_INT
+    double = VAR_NUMERIC_DOUBLE
+
+
+cdef void c_dcg_var_pypack(dcg_var_t* out, object value) except *:
+    cdef int ret_code
+
+    if value is None:
+        ret_code = c_dcg_var_init(out)
+    elif isinstance(value, bytes):
+        ret_code = c_dcg_var_init_string(out, <const char*> value)
+    elif isinstance(value, str):
+        ret_code = c_dcg_var_init_string(out, PyUnicode_AsUTF8(value))
+    elif isinstance(value, bool):
+        ret_code = c_dcg_var_init_bool(out, value)
+    elif isinstance(value, int):
+        ret_code = c_dcg_var_init_int(out, <ssize_t> value)
+    elif isinstance(value, float):
+        ret_code = c_dcg_var_init_double(out, value)
+    else:
+        # A NODE packs as a node - the same pointer, tagged so that unpacking it
+        # hands the wrapper back (see c_dcg_var_pyunpack). The class is the node
+        # layer's, one above this one, so it arrives by lazy import (DEPENDENCY.md
+        # 3.3); anything else packs as the opaque Python pointer it is.
+        from .c_node import LogicNode  # up, by lazy import
+
+        if isinstance(value, LogicNode):
+            ret_code = c_dcg_var_init_node(out, <const dcg_node*> <uintptr_t> value.address)
+        else:
+            ret_code = c_dcg_var_init_ptr(out, <void*> <PyObject*> value)
+
+    if ret_code != DCG_OK:
+        raise ValueError(f'Cannot pack {value!r} into a dcg_var_t.')
+
+
+cdef object c_dcg_var_pyunpack(const dcg_var_t* var):
+    if not var:
+        return None
+    if c_dcg_var_is_null(var):
+        return None
+
+    cdef dcg_var_type base = c_dcg_var_ref_base(var.dtype)
+
+    if base == VAR_TYPE_NODE:
+        # A node-shaped value is the node itself, so what it unpacks to is the
+        # wrapper the layer holds for it. The registry is the node layer's, one
+        # above this one, so it arrives by lazy import - the reach DEPENDENCY.md
+        # 3.3 records, and the same one the node layer takes for its own class.
+        from .c_node import NODE_REGISTRY
+        return NODE_REGISTRY[<uintptr_t> c_dcg_var_as_node(var)]
+
+    if base == VAR_TYPE_BOOL:
+        return c_dcg_var_as_bool(var)
+    if base == VAR_TYPE_INT or base == VAR_TYPE_OFFSET:
+        return c_dcg_var_as_int(var)
+    if base == VAR_TYPE_DOUBLE:
+        return c_dcg_var_as_double(var)
+    if base == VAR_TYPE_STRING:
+        return PyUnicode_FromString(c_dcg_var_as_string(var))
+    return None
+
+
+cdef class VarView:
+    def __init__(self, uintptr_t address):
+        self.header = <const dcg_var_t*> address
+
+    @staticmethod
+    cdef inline VarView c_from_header(const dcg_var_t* var):
+        cdef VarView view = VarView.__new__(VarView)
+        view.header = var
+        return view
+
+    def __repr__(self):
+        if not self.header:
+            return f'<{self.__class__.__name__} (Uninitialized)>'
+        return f'<{self.__class__.__name__}({self.format()})>'
+
+    def format(self):
+        if not self.header:
+            raise RuntimeError(f'<{self.__class__.__name__}> not initialized!')
+        cdef char buf[DCG_VAR_STRING_MAXLEN]
+        cdef int written = c_dcg_var_format(self.header, buf, sizeof(buf))
+        if written < 0:
+            raise RuntimeError(f'c_dcg_var_format failed with err code: {written}')
+        return PyUnicode_FromString(buf)
+
+    property address:
+        def __get__(self):
+            if not self.header:
+                raise RuntimeError(f'<{self.__class__.__name__}> not initialized!')
+            return <uintptr_t> self.header
+
+    property dtype:
+        def __get__(self):
+            if not self.header:
+                raise RuntimeError(f'<{self.__class__.__name__}> not initialized!')
+            return VarType(self.header.dtype)
+
+    property type_name:
+        def __get__(self):
+            if not self.header:
+                raise RuntimeError(f'<{self.__class__.__name__}> not initialized!')
+            return PyUnicode_FromString(c_dcg_var_type_name(self.header.dtype))
+
+    property is_null:
+        def __get__(self):
+            if not self.header:
+                raise RuntimeError(f'<{self.__class__.__name__}> not initialized!')
+            return c_dcg_var_is_null(self.header)
+
+    property is_ref:
+        def __get__(self):
+            if not self.header:
+                raise RuntimeError(f'<{self.__class__.__name__}> not initialized!')
+            return c_dcg_var_is_ref(self.header.dtype)
+
+    property ref_level:
+        def __get__(self):
+            if not self.header:
+                raise RuntimeError(f'<{self.__class__.__name__}> not initialized!')
+            return c_dcg_var_ref_level(self.header.dtype)
+
+    property ref_base:
+        def __get__(self):
+            if not self.header:
+                raise RuntimeError(f'<{self.__class__.__name__}> not initialized!')
+            return VarType(c_dcg_var_ref_base(self.header.dtype))
+
+    property numeric:
+        def __get__(self):
+            if not self.header:
+                raise RuntimeError(f'<{self.__class__.__name__}> not initialized!')
+            return VarNumeric(c_dcg_var_numeric_of(self.header))
+
+    property value:
+        def __get__(self):
+            if not self.header:
+                raise RuntimeError(f'<{self.__class__.__name__}> not initialized!')
+            return c_dcg_var_pyunpack(self.header)
+
+    property as_bool:
+        def __get__(self):
+            if not self.header:
+                raise RuntimeError(f'<{self.__class__.__name__}> not initialized!')
+            return c_dcg_var_as_bool(self.header)
+
+    property as_int:
+        def __get__(self):
+            if not self.header:
+                raise RuntimeError(f'<{self.__class__.__name__}> not initialized!')
+            return c_dcg_var_as_int(self.header)
+
+    property as_double:
+        def __get__(self):
+            if not self.header:
+                raise RuntimeError(f'<{self.__class__.__name__}> not initialized!')
+            return c_dcg_var_as_double(self.header)
+
+    property as_string:
+        def __get__(self):
+            if not self.header:
+                raise RuntimeError(f'<{self.__class__.__name__}> not initialized!')
+            cdef const char* text = c_dcg_var_as_string(self.header)
+            return None if not text else PyUnicode_FromString(text)
+
+    property as_ptr:
+        def __get__(self):
+            if not self.header:
+                raise RuntimeError(f'<{self.__class__.__name__}> not initialized!')
+            return <uintptr_t> <void*> c_dcg_var_as_ptr(self.header)
+
+    property as_ref:
+        def __get__(self):
+            if not self.header:
+                raise RuntimeError(f'<{self.__class__.__name__}> not initialized!')
+            return <uintptr_t> c_dcg_var_as_ref(self.header)

decision_graph/decision_tree/capi/__infra__.pxd

@@ -0,0 +1,33 @@
+__all__ = [
+    'GLOBAL_SINGLETON', 'Singleton',
+    'NodeEdgeCondition', 'ConditionElse', 'ConditionAny', 'ConditionAuto', 'BinaryCondition', 'ConditionTrue', 'ConditionFalse',
+    'NO_CONDITION', 'ELSE_CONDITION', 'AUTO_CONDITION', 'TRUE_CONDITION', 'FALSE_CONDITION',
+    'SkipContextsBlock', 'LogicExpression', 'LogicGroupManager', 'LGM',
+    'LogicGroupFrame', 'LogicGroupStack', 'ShelvedStateFrame', 'ShelvedStateStack', 'LogicGroup',
+    'LogicNodeFrame', 'LogicNodeStack', 'LogicNode', 'BreakpointNode',
+    'ActionNode', 'PlaceholderNode', 'NoAction', 'LongAction', 'ShortAction',
+    'RootLogicNode', 'ContextLogicExpression', 'AttrExpression', 'AttrNestedExpression', 'GetterExpression', 'GetterNestedExpression',
+    'MathExpressionOperator', 'MathExpression', 'ComparisonExpressionOperator', 'ComparisonExpression',
+    'LogicalExpressionOperator', 'LogicalExpression',
+    'LogicMapping', 'LogicSequence', 'LogicGenerator',
+]
+
+from .c_abc cimport (
+    GLOBAL_SINGLETON, Singleton,
+    NodeEdgeCondition, ConditionElse, ConditionAny, ConditionAuto, BinaryCondition, ConditionTrue, ConditionFalse,
+    NO_CONDITION, ELSE_CONDITION, AUTO_CONDITION, TRUE_CONDITION, FALSE_CONDITION,
+    SkipContextsBlock, LogicExpression, LogicGroupManager, LGM,
+    LogicGroupFrame, LogicGroupStack, ShelvedStateFrame, ShelvedStateStack, LogicGroup,
+    LogicNodeFrame, LogicNodeStack, LogicNode, BreakpointNode,
+    ActionNode, PlaceholderNode, NoAction, LongAction, ShortAction,
+)
+
+from .c_node cimport (
+    RootLogicNode, ContextLogicExpression, AttrExpression, AttrNestedExpression,  GetterExpression, GetterNestedExpression,
+    MathExpressionOperator, MathExpression, ComparisonExpressionOperator, ComparisonExpression,
+    LogicalExpressionOperator, LogicalExpression,
+)
+
+from .c_collection cimport (
+    LogicMapping, LogicSequence, LogicGenerator,
+)

decision_graph/decision_tree/capi/__init__.pxd

@@ -0,0 +1,33 @@
+__all__ = [
+    'GLOBAL_SINGLETON', 'Singleton',
+    'NodeEdgeCondition', 'ConditionElse', 'ConditionAny', 'ConditionAuto', 'BinaryCondition', 'ConditionTrue', 'ConditionFalse',
+    'NO_CONDITION', 'ELSE_CONDITION', 'AUTO_CONDITION', 'TRUE_CONDITION', 'FALSE_CONDITION',
+    'SkipContextsBlock', 'LogicExpression', 'LogicGroupManager', 'LGM',
+    'LogicGroupFrame', 'LogicGroupStack', 'ShelvedStateFrame', 'ShelvedStateStack', 'LogicGroup',
+    'LogicNodeFrame', 'LogicNodeStack', 'LogicNode', 'BreakpointNode',
+    'ActionNode', 'PlaceholderNode', 'NoAction', 'LongAction', 'ShortAction',
+    'RootLogicNode', 'ContextLogicExpression', 'AttrExpression', 'AttrNestedExpression', 'GetterExpression', 'GetterNestedExpression',
+    'MathExpressionOperator', 'MathExpression', 'ComparisonExpressionOperator', 'ComparisonExpression',
+    'LogicalExpressionOperator', 'LogicalExpression',
+    'LogicMapping', 'LogicSequence', 'LogicGenerator',
+]
+
+from .c_abc cimport (
+    GLOBAL_SINGLETON, Singleton,
+    NodeEdgeCondition, ConditionElse, ConditionAny, ConditionAuto, BinaryCondition, ConditionTrue, ConditionFalse,
+    NO_CONDITION, ELSE_CONDITION, AUTO_CONDITION, TRUE_CONDITION, FALSE_CONDITION,
+    SkipContextsBlock, LogicExpression, LogicGroupManager, LGM,
+    LogicGroupFrame, LogicGroupStack, ShelvedStateFrame, ShelvedStateStack, LogicGroup,
+    LogicNodeFrame, LogicNodeStack, LogicNode, BreakpointNode,
+    ActionNode, PlaceholderNode, NoAction, LongAction, ShortAction,
+)
+
+from .c_node cimport (
+    RootLogicNode, ContextLogicExpression, AttrExpression, AttrNestedExpression,  GetterExpression, GetterNestedExpression,
+    MathExpressionOperator, MathExpression, ComparisonExpressionOperator, ComparisonExpression,
+    LogicalExpressionOperator, LogicalExpression,
+)
+
+from .c_collection cimport (
+    LogicMapping, LogicSequence, LogicGenerator,
+)

decision_graph/decision_tree/capi/__init__.py

@@ -0,0 +1,57 @@
+import logging
+
+from .. import LOGGER
+
+LOGGER = LOGGER.getChild('CAPI')
+
+from .c_abc import (
+    Singleton,
+    NodeEdgeCondition, ConditionElse, ConditionAny, ConditionAuto, BinaryCondition, ConditionTrue, ConditionFalse,
+    NO_CONDITION, ELSE_CONDITION, AUTO_CONDITION, TRUE_CONDITION, FALSE_CONDITION,
+    SkipContextsBlock, LogicExpression, LogicNode,
+    LogicGroupManager, LGM, LogicGroup,
+    ActionNode, BreakpointNode, PlaceholderNode,
+    NoAction, LongAction, ShortAction, CancelAction
+)
+
+from .c_node import (
+    RootLogicNode, ContextLogicExpression,
+    AttrExpression, AttrNestedExpression,
+    GetterExpression, GetterNestedExpression,
+    MathExpressionOperator, MathExpression,
+    ComparisonExpressionOperator, ComparisonExpression,
+    LogicalExpressionOperator, LogicalExpression,
+)
+
+from .c_collection import (
+    LogicMapping,
+    LogicSequence,
+    LogicGenerator,
+)
+
+
+def set_logger(logger: logging.Logger):
+    global LOGGER
+    LOGGER = logger
+    c_abc.LOGGER = logger.getChild('abc')
+
+
+__all__ = [
+    'LOGGER', 'set_logger',
+    'Singleton',
+    'NodeEdgeCondition', 'ConditionElse', 'ConditionAny', 'ConditionAuto', 'BinaryCondition', 'ConditionTrue', 'ConditionFalse',
+    'NO_CONDITION', 'ELSE_CONDITION', 'AUTO_CONDITION', 'TRUE_CONDITION', 'FALSE_CONDITION',
+    'SkipContextsBlock', 'LogicExpression', 'LogicNode',
+    'LogicGroupManager', 'LGM', 'LogicGroup',
+    'ActionNode', 'BreakpointNode', 'PlaceholderNode',
+    'NoAction', 'LongAction', 'ShortAction', 'CancelAction',
+
+    'RootLogicNode', 'ContextLogicExpression',
+    'AttrExpression', 'AttrNestedExpression',
+    'GetterExpression', 'GetterNestedExpression',
+    'MathExpressionOperator', 'MathExpression',
+    'ComparisonExpressionOperator', 'ComparisonExpression',
+    'LogicalExpressionOperator', 'LogicalExpression',
+
+    'LogicMapping', 'LogicSequence', 'LogicGenerator'
+]

decision_graph/decision_tree/capi/c_abc.pxd

@@ -0,0 +1,246 @@
+from cpython.object cimport PyObject
+from cpython.pystate cimport PyThreadState
+
+cdef extern from "Python.h":
+    void PyThreadState_EnterTracing(PyThreadState* tstate)
+    void PyThreadState_LeaveTracing(PyThreadState* tstate)
+
+
+cdef dict GLOBAL_SINGLETON
+
+
+cdef class Singleton:
+    pass
+
+
+cdef class NodeEdgeCondition(Singleton):
+    cdef PyObject* value_addr
+
+
+cdef class ConditionElse(NodeEdgeCondition):
+    pass
+
+
+cdef class ConditionAny(NodeEdgeCondition):
+    pass
+
+
+cdef class ConditionAuto(NodeEdgeCondition):
+    pass
+
+
+cdef class BinaryCondition(NodeEdgeCondition):
+    pass
+
+
+cdef class ConditionTrue(BinaryCondition):
+    pass
+
+
+cdef class ConditionFalse(BinaryCondition):
+    pass
+
+
+cdef ConditionAny NO_CONDITION
+cdef ConditionElse ELSE_CONDITION
+cdef ConditionAuto AUTO_CONDITION
+cdef ConditionTrue TRUE_CONDITION
+cdef ConditionFalse FALSE_CONDITION
+
+
+cdef class SkipContextsBlock:
+    cdef public bint default_entry_check
+
+    cdef type skip_exception
+    cdef bint tracer_override
+    cdef object cframe
+    cdef tuple enter_line
+
+    cdef size_t cframe_tracer_sig_count
+    cdef object cframe_tracer
+
+    cdef size_t global_tracer_sig_count
+    cdef object global_tracer
+
+    cdef size_t global_profiler_sig_count
+    cdef object global_profiler
+
+    cdef bint c_entry_check(self)
+
+    cdef void c_on_enter(self)
+
+    cdef void c_on_exit(self)
+
+
+cdef class LogicExpression(SkipContextsBlock):
+    cdef readonly object expression
+    cdef readonly type dtype
+    cdef readonly str repr
+    cdef readonly object uid
+
+    cdef object c_eval(self, bint enforce_dtype)
+
+    @staticmethod
+    cdef LogicExpression c_cast(object value, type dtype)
+
+    @staticmethod
+    cdef LogicExpression c_math_op(LogicExpression self, object other, object op, str operator_str, type dtype)
+
+
+cdef struct LogicGroupFrame:
+    PyObject* logic_group
+    LogicGroupFrame* prev
+
+
+cdef struct LogicGroupStack:
+    LogicGroupFrame* top
+    size_t size
+
+
+cdef struct LogicNodeFrame:
+    PyObject* logic_node
+    LogicNodeFrame* prev
+
+
+cdef struct LogicNodeStack:
+    LogicNodeFrame* top
+    size_t size
+
+
+cdef struct ShelvedStateFrame:
+    LogicGroupStack* active_groups
+    LogicNodeStack* active_nodes
+    LogicNodeStack* breakpoint_nodes
+    LogicNodeStack* active_breakpoints
+    bint inspection_mode
+    bint vigilant_mode
+    ShelvedStateFrame* prev
+
+
+cdef struct ShelvedStateStack:
+    ShelvedStateFrame* top
+    size_t size
+
+
+cdef class LogicGroupManager(Singleton):
+    cdef LogicGroupStack* _active_groups
+    cdef LogicNodeStack* _active_nodes
+    cdef LogicNodeStack* _breakpoint_nodes
+    cdef ShelvedStateStack* _shelved_state
+
+    cdef readonly dict _cache
+    cdef public bint inspection_mode
+    cdef public bint vigilant_mode
+
+    @staticmethod
+    cdef inline void c_ln_stack_push(LogicNodeStack* stack, LogicNode logic_node)
+
+    @staticmethod
+    cdef inline void c_ln_stack_pop(LogicNodeStack* stack, LogicNode logic_node=*)
+
+    @staticmethod
+    cdef inline void c_ln_stack_remove(LogicNodeStack* stack, LogicNode logic_node)
+
+    @staticmethod
+    cdef inline LogicNodeFrame* c_ln_stack_locate(LogicNodeStack* stack, LogicNode logic_node)
+
+    @staticmethod
+    cdef inline void c_ln_stack_relocate(LogicNodeStack* original_stack, LogicNodeStack* new_stack, LogicNode logic_node)
+
+    cdef inline LogicGroup c_cached_init(self, str name, type cls, dict kwargs)
+
+    cdef inline void c_lg_enter(self, LogicGroup logic_group)
+
+    cdef inline void c_lg_exit(self, LogicGroup logic_group=*)
+
+    cdef inline void c_ln_enter(self, LogicNode logic_node)
+
+    cdef inline void c_ln_exit(self, LogicNode logic_node)
+
+    cdef inline void c_shelve(self)
+
+    cdef inline void c_unshelve(self)
+
+    cdef inline void c_clear(self)
+
+
+cdef LogicGroupManager LGM
+
+
+cdef class LogicGroup:
+    cdef readonly str name
+    cdef readonly LogicGroup parent
+    cdef readonly type Break
+    cdef readonly dict contexts
+
+    cdef void c_break_inspection(self)
+
+    cdef void c_break_active(self)
+
+    cdef void c_break_runtime(self)
+
+
+cdef class LogicNode(LogicExpression):
+    cdef LogicNodeStack* subordinates
+    cdef readonly NodeEdgeCondition condition_to_parent
+    cdef readonly LogicNode parent
+    cdef readonly dict children
+    cdef readonly list labels
+    cdef readonly bint autogen
+
+    cdef NodeEdgeCondition c_infer_condition(self, LogicNode child)
+
+    cdef PlaceholderNode c_get_placeholder(self)
+
+    cdef void c_append(self, LogicNode child, NodeEdgeCondition condition)
+
+    cdef void c_overwrite(self, LogicNode new_node, NodeEdgeCondition condition)
+
+    cdef void c_replace(self, LogicNode original_node, LogicNode new_node)
+
+    cdef void c_validate(self)
+
+    cdef tuple c_eval_recursively(self, list path=*, object default=*)
+
+    cdef void c_auto_fill(self)
+
+    cdef size_t c_consolidate_placeholder(self)
+
+
+cdef class BreakpointNode(LogicNode):
+    cdef readonly LogicGroup break_from
+    cdef readonly bint await_connection
+
+    cdef void c_connect(self, LogicNode child)
+
+
+cdef class ActionNode(LogicNode):
+    cdef readonly object action
+
+    cdef void c_auto_connect(self)
+
+    cdef void c_post_eval(self)
+
+
+cdef class PlaceholderNode(ActionNode):
+    pass
+
+
+cdef class NoAction(ActionNode):
+    cdef readonly ssize_t sig
+
+
+cdef class LongAction(ActionNode):
+    cdef readonly ssize_t sig
+
+
+cdef class ShortAction(ActionNode):
+    cdef readonly ssize_t sig
+
+
+cdef class CancelAction(ActionNode):
+    cdef readonly ssize_t sig
+
+
+cdef class ClearAction(ActionNode):
+    cdef readonly ssize_t sig