node.py

from state import State


def zero_heuristic(state: State) -> int:
    return 0


class Node:
    children: list["Node"]
    action: tuple
    depth: int
    parent: "Node"
    path_cost: int

    heuristic = zero_heuristic

    def __init__(
        self, state: State, action=None, depth=0, parent=None, path_cost=0, children=[]
    ):
        self.state = state
        self.parent = parent
        self.children = children
        self.action = action  # Action performed on parent
        self.depth = depth  # Depth of this node
        self.path_cost = path_cost  # Cost from root to here
        self.is_expanded = False  # Expanded?

    def expand(self, actions: list[tuple[State, tuple, int]]) -> list["Node"]:
        children = []
        for action in actions:
            cost = self.path_cost + action[2]
            depth = self.depth + 1
            parent = self
            new_node = Node(action[0], action[1], depth, parent, cost)
            children.append(new_node)

        self.is_expanded = True
        self.children.extend(children)
        return children

    def equals_int_state(self, other: "Node") -> bool:
        return other.state == self.state

    def get_identity(self):
        return self.state

    def get_cost(self):
        return self.path_cost + Node.heuristic(self.state)

    def __gt__(self, other: "Node") -> bool:
        if not isinstance(other, Node):
            raise TypeError(
                "Error while comparing object with type",
                type(other),
                "and a Node object",
            )
        return self.get_cost() > other.get_cost()

    def __ge__(self, other: "Node") -> bool:
        if not isinstance(other, Node):
            raise TypeError(
                "Error while comparing object with type",
                type(other),
                "and a Node object",
            )
        return self.get_cost() >= other.get_cost()

    def __lt__(self, other: "Node") -> bool:
        if not isinstance(other, Node):
            raise TypeError(
                "Error while comparing object with type",
                type(other),
                "and a Node object",
            )
        return self.get_cost() < other.get_cost()

    def __le__(self, other: "Node") -> bool:
        if not isinstance(other, Node):
            raise TypeError(
                "Error while comparing object with type",
                type(other),
                "and a Node object",
            )
        return self.get_cost() <= other.get_cost()

    def __repr__(self):
        return self.__str__()

    def __str__(self):
        return "State: " + str(self.state) + " | Cost: " + str(self.get_cost())