PyDecisionGraph 0.3.2.post1__cp315-cp315-win_amd64.whl

decision_graph/decision_tree/bake/c_expr.pxd

@@ -0,0 +1,129 @@
+from cpython.object cimport PyObject
+
+from cbase.allocator_protocol cimport allocator_protocol
+
+from .c_node cimport LogicNode, dcg_node, dcg_node_type
+from .c_var cimport dcg_var_t
+
+
+cdef extern from "decision_graph/decision_tree/bake/c_expr.h":
+    const size_t DCG_EXPR_DEFAULT_ARGS
+
+    ctypedef enum dcg_op_code:
+        DCG_OP_NONE
+        DCG_OP_ARITH
+        DCG_OP_ADD
+        DCG_OP_SUB
+        DCG_OP_MUL
+        DCG_OP_DIV
+        DCG_OP_FLOORDIV
+        DCG_OP_POW
+        DCG_OP_NEG
+        DCG_OP_COMPARE
+        DCG_OP_EQ
+        DCG_OP_NE
+        DCG_OP_GT
+        DCG_OP_GE
+        DCG_OP_LT
+        DCG_OP_LE
+        DCG_OP_LOGIC
+        DCG_OP_AND
+        DCG_OP_OR
+        DCG_OP_NOT
+        DCG_OP_ACCESS
+        DCG_OP_ATTR
+        DCG_OP_GETITEM
+
+    ctypedef enum dcg_op_mask:
+        DCG_OP_FAMILY_MASK
+        DCG_OP_VARIANT_MASK
+
+    ctypedef int (*dcg_expr_apply_fn)(dcg_var_t* out, const dcg_var_t* a, const dcg_var_t* b) noexcept nogil
+
+    ctypedef struct dcg_expression_node:
+        dcg_node base
+        dcg_op_code op
+        size_t n_args
+        dcg_node** components
+        dcg_var_t args[]
+
+    dcg_expression_node* c_dcg_node_new_expr(size_t n_args, dcg_node_type ntype, allocator_protocol* allocator) noexcept nogil
+    void c_dcg_node_free_expr(dcg_expression_node* node) noexcept nogil
+    dcg_expression_node* c_dcg_node_new_expr_unary(dcg_op_code op, dcg_node* src, allocator_protocol* allocator) noexcept nogil
+    dcg_expression_node* c_dcg_node_new_expr_binary(dcg_op_code op, dcg_node* var_0, dcg_node* var_1, allocator_protocol* allocator) noexcept nogil
+    dcg_expression_node* c_dcg_node_new_expr_ternary(dcg_op_code op, dcg_node* var_0, dcg_node* var_1, dcg_node* var_2, allocator_protocol* allocator) noexcept nogil
+    dcg_expression_node* c_dcg_node_new_expr_call(dcg_op_code op, dcg_node** vars, size_t n_vars, const char* repr, allocator_protocol* allocator) noexcept nogil
+    int c_dcg_node_expr_bind(dcg_expression_node* node, size_t index, dcg_node* input) noexcept nogil
+
+    int c_dcg_node_expr_set_op(dcg_expression_node* node, dcg_op_code op) noexcept nogil
+    dcg_expr_apply_fn c_dcg_node_expr_apply_fn_of(dcg_node_type ntype, dcg_op_code op) noexcept nogil
+    int c_dcg_node_expr_apply_unary(dcg_var_t* out, dcg_op_code op, const dcg_var_t* a) noexcept nogil
+    int c_dcg_node_expr_apply_binary(dcg_var_t* out, dcg_op_code op, const dcg_var_t* a, const dcg_var_t* b) noexcept nogil
+
+    int c_dcg_node_expr_apply_refuse(dcg_var_t* out, const dcg_var_t* a, const dcg_var_t* b) noexcept nogil
+    int c_dcg_node_expr_apply_neg(dcg_var_t* out, const dcg_var_t* a, const dcg_var_t* b) noexcept nogil
+    int c_dcg_node_expr_apply_not(dcg_var_t* out, const dcg_var_t* a, const dcg_var_t* b) noexcept nogil
+    int c_dcg_node_expr_apply_add(dcg_var_t* out, const dcg_var_t* a, const dcg_var_t* b) noexcept nogil
+    int c_dcg_node_expr_apply_sub(dcg_var_t* out, const dcg_var_t* a, const dcg_var_t* b) noexcept nogil
+    int c_dcg_node_expr_apply_mul(dcg_var_t* out, const dcg_var_t* a, const dcg_var_t* b) noexcept nogil
+    int c_dcg_node_expr_apply_div(dcg_var_t* out, const dcg_var_t* a, const dcg_var_t* b) noexcept nogil
+    int c_dcg_node_expr_apply_floordiv(dcg_var_t* out, const dcg_var_t* a, const dcg_var_t* b) noexcept nogil
+    int c_dcg_node_expr_apply_pow(dcg_var_t* out, const dcg_var_t* a, const dcg_var_t* b) noexcept nogil
+    int c_dcg_node_expr_apply_eq(dcg_var_t* out, const dcg_var_t* a, const dcg_var_t* b) noexcept nogil
+    int c_dcg_node_expr_apply_ne(dcg_var_t* out, const dcg_var_t* a, const dcg_var_t* b) noexcept nogil
+    int c_dcg_node_expr_apply_gt(dcg_var_t* out, const dcg_var_t* a, const dcg_var_t* b) noexcept nogil
+    int c_dcg_node_expr_apply_ge(dcg_var_t* out, const dcg_var_t* a, const dcg_var_t* b) noexcept nogil
+    int c_dcg_node_expr_apply_lt(dcg_var_t* out, const dcg_var_t* a, const dcg_var_t* b) noexcept nogil
+    int c_dcg_node_expr_apply_le(dcg_var_t* out, const dcg_var_t* a, const dcg_var_t* b) noexcept nogil
+    int c_dcg_node_expr_apply_and(dcg_var_t* out, const dcg_var_t* a, const dcg_var_t* b) noexcept nogil
+    int c_dcg_node_expr_apply_or(dcg_var_t* out, const dcg_var_t* a, const dcg_var_t* b) noexcept nogil
+    int c_dcg_node_expr_eval_operand(dcg_expression_node* node, size_t index) noexcept nogil
+
+    int c_dcg_node_expr_eval(dcg_node* node, void* user_data) noexcept nogil
+    int c_dcg_node_expr_eval_refuse(dcg_node* node, void* user_data) noexcept nogil
+    int c_dcg_node_expr_eval_unknown(dcg_node* node, void* user_data) noexcept nogil
+    int c_dcg_node_expr_eval_ternary(dcg_node* node, void* user_data) noexcept nogil
+    int c_dcg_node_expr_eval_call(dcg_node* node, void* user_data) noexcept nogil
+    int c_dcg_node_expr_eval_neg(dcg_node* node, void* user_data) noexcept nogil
+    int c_dcg_node_expr_eval_not(dcg_node* node, void* user_data) noexcept nogil
+    int c_dcg_node_expr_eval_add(dcg_node* node, void* user_data) noexcept nogil
+    int c_dcg_node_expr_eval_sub(dcg_node* node, void* user_data) noexcept nogil
+    int c_dcg_node_expr_eval_mul(dcg_node* node, void* user_data) noexcept nogil
+    int c_dcg_node_expr_eval_div(dcg_node* node, void* user_data) noexcept nogil
+    int c_dcg_node_expr_eval_floordiv(dcg_node* node, void* user_data) noexcept nogil
+    int c_dcg_node_expr_eval_pow(dcg_node* node, void* user_data) noexcept nogil
+    int c_dcg_node_expr_eval_eq(dcg_node* node, void* user_data) noexcept nogil
+    int c_dcg_node_expr_eval_ne(dcg_node* node, void* user_data) noexcept nogil
+    int c_dcg_node_expr_eval_gt(dcg_node* node, void* user_data) noexcept nogil
+    int c_dcg_node_expr_eval_ge(dcg_node* node, void* user_data) noexcept nogil
+    int c_dcg_node_expr_eval_lt(dcg_node* node, void* user_data) noexcept nogil
+    int c_dcg_node_expr_eval_le(dcg_node* node, void* user_data) noexcept nogil
+    int c_dcg_node_expr_eval_and(dcg_node* node, void* user_data) noexcept nogil
+    int c_dcg_node_expr_eval_or(dcg_node* node, void* user_data) noexcept nogil
+    int c_dcg_node_expr_alias(const dcg_node* input, char* out, size_t cap) noexcept nogil
+    int c_dcg_node_expr_op_style(dcg_node* const* inputs, size_t n_inputs, dcg_op_code op, char* out, size_t cap) noexcept nogil
+    int c_dcg_node_expr_func_style(dcg_node* const* inputs, size_t n_inputs, dcg_op_code op, const char* name, char* out, size_t cap) noexcept nogil
+
+
+cdef class ExpressionNode(LogicNode):
+    cdef PyObject** components
+
+    cdef void c_components_alloc(self, size_t n_args)
+
+    cdef void c_components_assign(self, size_t index, LogicNode node)
+
+
+cdef class UnaryExpression(ExpressionNode):
+    pass
+
+
+cdef class BinaryExpression(ExpressionNode):
+    pass
+
+
+cdef class TernaryExpression(ExpressionNode):
+    pass
+
+
+cdef class CallExpression(ExpressionNode):
+    pass

decision_graph/decision_tree/bake/c_expr.pyi

@@ -0,0 +1,280 @@
+"""The operator layer: the expressions a graph computes with.
+
+An expression is an operator over operands, and its operands are nodes: a
+literal, a read, another expression. The node its operands are bound to holds
+them - a slot that refers to an operand reads that operand's storage, so the
+expression keeps the node alive for as long as it reads through it.
+
+The arity is the class: a unary node takes one operand, a binary two, a ternary
+three, and a call as many as it is given.
+
+A composition written with a Python value puts a literal in that operand's place:
+``5 + read`` builds the same node as ``ConstantNode(5) + read``, and ``read - 5``
+the same as ``read - ConstantNode(5)``.
+"""
+
+import enum
+from typing import Any
+
+from .c_node import LogicNode
+
+
+class ExpressionOperator(enum.IntEnum):
+    """The op codes an expression node can carry.
+
+    One member per code the C layer knows, family by family, with the arithmetic
+    and comparison symbols spelled as the operators they are. The enum is the
+    Python face of the C op codes: a cimported C constant is not a module
+    attribute, so without it a caller would pass bare numbers.
+    """
+
+    none: int
+    arith: int
+    add: int
+    sub: int
+    mul: int
+    div: int
+    floordiv: int
+    pow: int
+    neg: int
+    compare: int
+    eq: int
+    ne: int
+    gt: int
+    ge: int
+    lt: int
+    le: int
+    logic: int
+    and_: int
+    or_: int
+    not_: int
+    access: int
+    attr: int
+    getitem: int
+
+
+class ExpressionNode(LogicNode):
+    """An operator over operands, of an arity the type does not fix.
+
+    The operands are the nodes its arguments read from, and this wrapper HOLDS
+    them: an argument that refers to a node reads that node's storage, so a
+    released operand would leave the expression reading a block that is gone.
+    """
+
+    def __init__(self, n_args: int = ..., node_type: int = ...) -> None:
+        """Build an expression of an explicit arity and node type.
+
+        Args:
+            n_args: How many operands it takes.
+            node_type: The C node type this expression is.
+
+        Raises:
+            MemoryError: When the block cannot be allocated.
+        """
+        ...
+
+    def bind(self, index: int, node: LogicNode) -> None:
+        """Bind an operand to one of this expression's argument slots.
+
+        Args:
+            index: Argument position to bind.
+            node: Node whose value the argument takes.
+
+        Raises:
+            RuntimeError: When the C layer refuses the binding.
+        """
+        ...
+
+    def __add__(self, other: LogicNode | bool | int | float | str) -> BinaryExpression:
+        """Compose a sum expression with another node."""
+        ...
+
+    def __radd__(self, other: LogicNode | bool | int | float | str) -> BinaryExpression:
+        """Compose a sum expression with a Python value on the left."""
+        ...
+
+    def __sub__(self, other: LogicNode | bool | int | float | str) -> BinaryExpression:
+        """Compose a difference expression with another node."""
+        ...
+
+    def __rsub__(self, other: LogicNode | bool | int | float | str) -> BinaryExpression:
+        """Compose a difference expression with a Python value on the left."""
+        ...
+
+    def __mul__(self, other: LogicNode | bool | int | float | str) -> BinaryExpression:
+        """Compose a product expression with another node."""
+        ...
+
+    def __rmul__(self, other: LogicNode | bool | int | float | str) -> BinaryExpression:
+        """Compose a product expression with a Python value on the left."""
+        ...
+
+    def __truediv__(self, other: LogicNode | bool | int | float | str) -> BinaryExpression:
+        """Compose a division expression with another node."""
+        ...
+
+    def __rtruediv__(self, other: LogicNode | bool | int | float | str) -> BinaryExpression:
+        """Compose a division expression with a Python value on the left."""
+        ...
+
+    def __floordiv__(self, other: LogicNode | bool | int | float | str) -> BinaryExpression:
+        """Compose a floor-division expression with another node."""
+        ...
+
+    def __rfloordiv__(self, other: LogicNode | bool | int | float | str) -> BinaryExpression:
+        """Compose a floor-division expression with a Python value on the left."""
+        ...
+
+    def __pow__(self, other: LogicNode | bool | int | float | str) -> BinaryExpression:
+        """Compose a power expression with another node."""
+        ...
+
+    def __rpow__(self, other: LogicNode | bool | int | float | str) -> BinaryExpression:
+        """Compose a power expression with a Python value on the left."""
+        ...
+
+    def __neg__(self) -> UnaryExpression:
+        """Compose a negation of this expression."""
+        ...
+
+    def __eq__(self, other: LogicNode | bool | int | float | str) -> BinaryExpression:
+        """Compose an equality CONDITION with another node."""
+        ...
+
+    def __ne__(self, other: LogicNode | bool | int | float | str) -> BinaryExpression:
+        """Compose an inequality condition with another node."""
+        ...
+
+    def __hash__(self) -> int:
+        """Hash by the C block's address, so a node can key a dict."""
+        ...
+
+    def __lt__(self, other: LogicNode | bool | int | float | str) -> BinaryExpression:
+        """Compose a less-than condition with another node."""
+        ...
+
+    def __le__(self, other: LogicNode | bool | int | float | str) -> BinaryExpression:
+        """Compose a less-or-equal condition with another node."""
+        ...
+
+    def __gt__(self, other: LogicNode | bool | int | float | str) -> BinaryExpression:
+        """Compose a greater-than condition with another node."""
+        ...
+
+    def __ge__(self, other: LogicNode | bool | int | float | str) -> BinaryExpression:
+        """Compose a greater-or-equal condition with another node."""
+        ...
+
+    def __and__(self, other: LogicNode | bool | int | float | str) -> BinaryExpression:
+        """Compose a conjunction with another node."""
+        ...
+
+    def __rand__(self, other: LogicNode | bool | int | float | str) -> BinaryExpression:
+        """Compose a conjunction with a Python value on the left."""
+        ...
+
+    def __or__(self, other: LogicNode | bool | int | float | str) -> BinaryExpression:
+        """Compose a disjunction with another node."""
+        ...
+
+    def __ror__(self, other: LogicNode | bool | int | float | str) -> BinaryExpression:
+        """Compose a disjunction with a Python value on the left."""
+        ...
+
+    def __invert__(self) -> UnaryExpression:
+        """Compose the negation of this expression as a condition."""
+        ...
+
+    @property
+    def op(self) -> ExpressionOperator:
+        """The operator this expression applies."""
+        ...
+
+    @property
+    def n_args(self) -> int:
+        """How many operands the expression takes."""
+        ...
+
+    @property
+    def operands(self) -> list[LogicNode | None]:
+        """The nodes the arguments read from, in argument order.
+
+        An entry is None where the argument reads from nothing this wrapper
+        holds - an argument a value was folded into, whose operand node is gone
+        by design.
+        """
+        ...
+
+
+class UnaryExpression(ExpressionNode):
+    """An expression over one operand."""
+
+    def __init__(self, op: ExpressionOperator, src: LogicNode) -> None:
+        """Build a one-operand expression.
+
+        Args:
+            op: The operator to apply.
+            src: The operand it applies to.
+
+        Raises:
+            MemoryError: When the block cannot be allocated.
+        """
+        ...
+
+
+class BinaryExpression(ExpressionNode):
+    """An expression over two operands: the arithmetic and comparison shape."""
+
+    def __init__(self, op: ExpressionOperator, var_0: LogicNode, var_1: LogicNode) -> None:
+        """Build a two-operand expression.
+
+        Args:
+            op: The operator to apply.
+            var_0: The left operand.
+            var_1: The right operand.
+
+        Raises:
+            MemoryError: When the block cannot be allocated.
+        """
+        ...
+
+
+class TernaryExpression(ExpressionNode):
+    """An expression over three operands: the conditional shape."""
+
+    def __init__(self, op: ExpressionOperator, var_0: LogicNode, var_1: LogicNode, var_2: LogicNode) -> None:
+        """Build a three-operand expression.
+
+        Args:
+            op: The operator to apply.
+            var_0: The first operand.
+            var_1: The second operand.
+            var_2: The third operand.
+
+        Raises:
+            MemoryError: When the block cannot be allocated.
+        """
+        ...
+
+
+class CallExpression(ExpressionNode):
+    """An expression over any number of operands, written as a call.
+
+    The callee's name is display text, composed into the node's ``repr``: it is
+    not a field of the block, which is why a reconstruction brings a call back as
+    the generic node view rather than as this class.
+    """
+
+    def __init__(self, op: ExpressionOperator, inputs: Any, name: str | None = None) -> None:
+        """Build a call-shaped expression.
+
+        Args:
+            op: The operator to apply.
+            inputs: The arguments, in order.
+            name: The callee's name, for the node's display text.
+
+        Raises:
+            TypeError: When an argument is not a node.
+            MemoryError: When the block cannot be allocated.
+        """
+        ...

decision_graph/decision_tree/bake/c_expr.pyx

@@ -0,0 +1,272 @@
+import enum
+
+from cpython.mem cimport PyMem_Calloc, PyMem_Free, PyMem_Malloc
+from cpython.ref cimport Py_XDECREF, Py_XINCREF
+from cpython.unicode cimport PyUnicode_AsUTF8
+
+from .c_allocator_protocol cimport DCG_DEFAULT_ALLOCATOR
+from .c_const cimport c_dcg_node_pypack
+from .c_var cimport dcg_ret_code
+
+
+class ExpressionOperator(enum.IntEnum):
+    none = DCG_OP_NONE
+
+    arith = DCG_OP_ARITH
+    add = DCG_OP_ADD
+    sub = DCG_OP_SUB
+    mul = DCG_OP_MUL
+    div = DCG_OP_DIV
+    floordiv = DCG_OP_FLOORDIV
+    pow = DCG_OP_POW
+    neg = DCG_OP_NEG
+
+    compare = DCG_OP_COMPARE
+    eq = DCG_OP_EQ
+    ne = DCG_OP_NE
+    gt = DCG_OP_GT
+    ge = DCG_OP_GE
+    lt = DCG_OP_LT
+    le = DCG_OP_LE
+
+    logic = DCG_OP_LOGIC
+    and_ = DCG_OP_AND
+    or_ = DCG_OP_OR
+    not_ = DCG_OP_NOT
+
+    access = DCG_OP_ACCESS
+    attr = DCG_OP_ATTR
+    getitem = DCG_OP_GETITEM
+
+
+cdef class ExpressionNode(LogicNode):
+    def __init__(self, size_t n_args=DCG_EXPR_DEFAULT_ARGS, dcg_node_type node_type=dcg_node_type.DCG_NODE_OP):
+        cdef dcg_expression_node* node = c_dcg_node_new_expr(n_args, node_type, DCG_DEFAULT_ALLOCATOR)
+        if not node:
+            raise MemoryError(f'Failed to allocate the {self.__class__.__name__}.')
+
+        self.header = &node.base
+        self.owner = True
+        self.c_components_alloc(node.n_args)
+        self.c_register_node()
+
+    def __dealloc__(self):
+        cdef size_t i
+        cdef size_t n_args = DCG_EXPR_DEFAULT_ARGS
+
+        if self.header:
+            n_args = (<dcg_expression_node*> self.header).n_args
+
+        if self.components:
+            for i in range(n_args):
+                Py_XDECREF(self.components[i])
+
+        PyMem_Free(self.components)
+
+    # === Cython Internal Binding ===
+
+    cdef void c_components_alloc(self, size_t n_args):
+        self.components = <PyObject**> PyMem_Calloc(n_args, sizeof(PyObject*))
+        if not self.components:
+            raise MemoryError(f'Failed to allocate the operand array of the {self.__class__.__name__}.')
+
+    cdef void c_components_assign(self, size_t index, LogicNode node):
+        if self.components[index] == <PyObject*> node:
+            return
+        Py_XINCREF(<PyObject*> node)
+        Py_XDECREF(self.components[index])
+        self.components[index] = <PyObject*> node
+
+    # === Python Interfaces ===
+
+    def bind(self, size_t index, LogicNode node):
+        cdef int ret_code = c_dcg_node_expr_bind(<dcg_expression_node*> self.header, index, node.header)
+        if ret_code != dcg_ret_code.DCG_OK:
+            raise RuntimeError(f'c_dcg_node_expr_bind failed with err code: {ret_code}')
+        self.c_components_assign(index, node)
+
+    # === Python Operators ===
+
+    def __add__(self, object other):
+        return BinaryExpression(DCG_OP_ADD, self, c_dcg_node_pypack(other))
+
+    def __radd__(self, object other):
+        return BinaryExpression(DCG_OP_ADD, c_dcg_node_pypack(other), self)
+
+    def __sub__(self, object other):
+        return BinaryExpression(DCG_OP_SUB, self, c_dcg_node_pypack(other))
+
+    def __rsub__(self, object other):
+        return BinaryExpression(DCG_OP_SUB, c_dcg_node_pypack(other), self)
+
+    def __mul__(self, object other):
+        return BinaryExpression(DCG_OP_MUL, self, c_dcg_node_pypack(other))
+
+    def __rmul__(self, object other):
+        return BinaryExpression(DCG_OP_MUL, c_dcg_node_pypack(other), self)
+
+    def __truediv__(self, object other):
+        return BinaryExpression(DCG_OP_DIV, self, c_dcg_node_pypack(other))
+
+    def __rtruediv__(self, object other):
+        return BinaryExpression(DCG_OP_DIV, c_dcg_node_pypack(other), self)
+
+    def __floordiv__(self, object other):
+        return BinaryExpression(DCG_OP_FLOORDIV, self, c_dcg_node_pypack(other))
+
+    def __rfloordiv__(self, object other):
+        return BinaryExpression(DCG_OP_FLOORDIV, c_dcg_node_pypack(other), self)
+
+    def __pow__(self, object other):
+        return BinaryExpression(DCG_OP_POW, self, c_dcg_node_pypack(other))
+
+    def __rpow__(self, object other):
+        return BinaryExpression(DCG_OP_POW, c_dcg_node_pypack(other), self)
+
+    def __neg__(self):
+        return UnaryExpression(DCG_OP_NEG, self)
+
+    def __eq__(self, object other):
+        return BinaryExpression(DCG_OP_EQ, self, c_dcg_node_pypack(other))
+
+    def __ne__(self, object other):
+        return BinaryExpression(DCG_OP_NE, self, c_dcg_node_pypack(other))
+
+    def __hash__(self):
+        return hash(self.address)
+
+    # Ordered comparisons build comparison nodes.
+    def __lt__(self, object other):
+        return BinaryExpression(DCG_OP_LT, self, c_dcg_node_pypack(other))
+
+    def __le__(self, object other):
+        return BinaryExpression(DCG_OP_LE, self, c_dcg_node_pypack(other))
+
+    def __gt__(self, object other):
+        return BinaryExpression(DCG_OP_GT, self, c_dcg_node_pypack(other))
+
+    def __ge__(self, object other):
+        return BinaryExpression(DCG_OP_GE, self, c_dcg_node_pypack(other))
+
+    def __and__(self, object other):
+        return BinaryExpression(DCG_OP_AND, self, c_dcg_node_pypack(other))
+
+    def __rand__(self, object other):
+        return BinaryExpression(DCG_OP_AND, c_dcg_node_pypack(other), self)
+
+    def __or__(self, object other):
+        return BinaryExpression(DCG_OP_OR, self, c_dcg_node_pypack(other))
+
+    def __ror__(self, object other):
+        return BinaryExpression(DCG_OP_OR, c_dcg_node_pypack(other), self)
+
+    def __invert__(self):
+        return UnaryExpression(DCG_OP_NOT, self)
+
+    property op:
+        def __get__(self):
+            if not self.header:
+                raise RuntimeError(f'<{self.__class__.__name__}> not initialized!')
+            cdef dcg_expression_node* node = <dcg_expression_node*> self.header
+            return ExpressionOperator(node.op)
+
+    property n_args:
+        def __get__(self):
+            if not self.header:
+                raise RuntimeError(f'<{self.__class__.__name__}> not initialized!')
+            cdef dcg_expression_node* node = <dcg_expression_node*> self.header
+            return node.n_args
+
+    property operands:
+        def __get__(self):
+            if not self.header:
+                raise RuntimeError(f'<{self.__class__.__name__}> not initialized!')
+
+            cdef dcg_expression_node* node = <dcg_expression_node*> self.header
+            cdef size_t i
+            cdef list held = []
+
+            for i in range(node.n_args):
+                held.append(None if not self.components[i] else <object> self.components[i])
+            return held
+
+
+cdef class UnaryExpression(ExpressionNode):
+    def __init__(self, dcg_op_code op, LogicNode src):
+        cdef dcg_expression_node* node = c_dcg_node_new_expr_unary(op, src.header, DCG_DEFAULT_ALLOCATOR)
+        if not node:
+            raise MemoryError('Failed to allocate the UnaryExpression.')
+
+        self.header = &node.base
+        self.owner = True
+        self.c_components_alloc(1)
+        self.c_components_assign(0, src)
+        self.c_register_node()
+
+
+cdef class BinaryExpression(ExpressionNode):
+    def __init__(self, dcg_op_code op, LogicNode var_0, LogicNode var_1):
+        cdef dcg_expression_node* node = c_dcg_node_new_expr_binary(op, var_0.header, var_1.header, DCG_DEFAULT_ALLOCATOR)
+        if not node:
+            raise MemoryError('Failed to allocate the BinaryExpression.')
+
+        self.header = &node.base
+        self.owner = True
+        self.c_components_alloc(2)
+        self.c_components_assign(0, var_0)
+        self.c_components_assign(1, var_1)
+        self.c_register_node()
+
+
+cdef class TernaryExpression(ExpressionNode):
+    def __init__(self, dcg_op_code op, LogicNode var_0, LogicNode var_1, LogicNode var_2):
+        cdef dcg_expression_node* node = c_dcg_node_new_expr_ternary(op, var_0.header, var_1.header, var_2.header, DCG_DEFAULT_ALLOCATOR)
+        if not node:
+            raise MemoryError('Failed to allocate the TernaryExpression.')
+
+        self.header = &node.base
+        self.owner = True
+        self.c_components_alloc(3)
+        self.c_components_assign(0, var_0)
+        self.c_components_assign(1, var_1)
+        self.c_components_assign(2, var_2)
+        self.c_register_node()
+
+
+cdef class CallExpression(ExpressionNode):
+    def __init__(self, dcg_op_code op, object inputs, str name=None):
+        cdef size_t n_vars = len(inputs)
+        cdef dcg_node** vars
+        cdef dcg_expression_node* node = NULL
+        cdef size_t i
+        cdef object argument
+
+        if n_vars == 0:
+            raise ValueError('A CallExpression needs at least one input.')
+
+        vars = <dcg_node**> PyMem_Malloc(n_vars * sizeof(dcg_node*))
+        if not vars:
+            raise MemoryError('Failed to allocate the argument array.')
+        try:
+            for i in range(n_vars):
+                argument = inputs[i]
+                if not isinstance(argument, LogicNode):
+                    raise TypeError(f'CallExpression argument {i} is not a LogicNode, but {type(argument).__name__}.')
+                vars[i] = (<LogicNode> argument).header
+            node = c_dcg_node_new_expr_call(
+                op, vars, n_vars,
+                PyUnicode_AsUTF8(name) if name is not None else NULL,
+                DCG_DEFAULT_ALLOCATOR,
+            )
+        finally:
+            PyMem_Free(vars)
+
+        if not node:
+            raise MemoryError('Failed to allocate the CallExpression.')
+
+        self.header = &node.base
+        self.owner = True
+        self.c_components_alloc(n_vars)
+        for i in range(n_vars):
+            self.c_components_assign(i, <LogicNode> inputs[i])
+        self.c_register_node()