validator.py

import networkx as nx
import copy

MAX_OBJECTS_DEEP = 10

def validate_plan(init_graph, goal_graph, actions, print_results=False):
    #Find nodes changed betwee initial and goal graph.
    important_nodes = find_important_nodes(init_graph, goal_graph, add_assets=False)
    if print_results:
        print("Important nodes:\n",important_nodes)
    #Run actions in graph simulation
    final_graph, errors = simulate_on_graph(init_graph, actions)

    #Classes of important objects
    important_node_names = []
    for node in important_nodes:
        if node[0] not in important_node_names:
            important_node_names.append(node[0])

    correct_obj, total_obj = validate_objects(final_graph, goal_graph, important_node_names, print_results)
    correct_assets, total_asets = validate_assets(final_graph, goal_graph, important_nodes)

    object_success_rate = 1.0 if total_obj == 0 else correct_obj / total_obj
    asset_success_rate = 1.0 if total_asets == 0 else correct_assets / total_asets

    total_count = total_obj + total_asets
    partial_success = 1.0 if total_count == 0 else (correct_obj + correct_assets) / total_count

    if print_results:
        print("Object Success Rate:", object_success_rate)
        print("Asset Success Rate:", asset_success_rate)
        print("Partial Success:", partial_success)
        print(errors)

    if len(errors) == 0 and partial_success == 1.0:
        success = True
    else:
        success = False

    return success, partial_success, errors

def simulate_on_graph(init_graph, actions):
    simulator = ValidatorSceneSimulator(init_graph)
    errors = []
    for action in actions:
        feedback = simulator.action(action[0], action[1])
        if feedback:
            errors.append((action, feedback))
    final_graph = simulator.graph
    return final_graph, errors

def validate_objects(final_graph, goal_graph, important_node_names, print_results=False):
    object_count = 0
    goal_state_counts = {}
    final_state_counts = {}
    # Find all objects with same name as relevant node names. (Objects of same class)
    for node_name in goal_graph:
        goal_node = goal_graph.nodes[node_name]
        final_node = final_graph.nodes[node_name]
        if node_name[0] in important_node_names and goal_node['type'] == 'object':
            object_count += 1
            goal_state = (node_name[0], tuple(goal_node['states']), goal_node['relation'], goal_node['related_to'])
            final_state = (node_name[0], tuple(final_node['states']), final_node['relation'], final_node['related_to'])
            
            goal_state_counts[goal_state] = goal_state_counts.get(goal_state, 0) + 1
            final_state_counts[final_state] = final_state_counts.get(final_state, 0) + 1
    state_difference = 0
    # Count objects in correct states
    for key in goal_state_counts:
        if key in final_state_counts:
            goal_state_counts[key] -= final_state_counts[key]
            if goal_state_counts[key] < 0:
                goal_state_counts[key] = 0
        state_difference += goal_state_counts[key]
    correct_objects = object_count - state_difference
    if print_results:
        print("Goal state count:")
        for goal in goal_state_counts:
            print(goal, goal_state_counts[goal], sep=': ')
        print("Final state count:")
        for goal in final_state_counts:
            print(goal, final_state_counts[goal], sep=': ')

    return correct_objects,  object_count

def validate_assets(final_graph, goal_graph, important_nodes):
    # Check Asset states
    asset_count = 0
    correct_states = 0
    for node_name in important_nodes:
        final_node = final_graph.nodes[node_name]
        goal_node = goal_graph.nodes[node_name]
        if final_node['type'] == 'asset':
            asset_count += 1
            if set(final_node['states']) == set(goal_node['states']):
                correct_states += 1
    return correct_states, asset_count

class ValidatorSceneSimulator():
    def __init__(self, graph: nx.Graph):
        self.graph = copy.deepcopy(graph)
        self._reset_edges()

    def _reset_edges(self):
        self.graph.remove_edges_from(list(self.graph.edges))
        for node_name in self.graph.nodes:
            self._add_edge(node_name)

    def _add_edge(self, node_name):
        node = self.graph.nodes[node_name]
        try:
            match node['type']:
                case 'place':
                    self.graph.add_edge(node_name,('scene',1))
                case 'asset':
                    self.graph.add_edge(node_name,node['place'])
                case 'object':
                    self.graph.add_edge(node_name,node['related_to'])
                case 'unseen_object':
                    self.graph.add_edge(node_name,node['related_to'])
                case 'agent':
                    self.graph.add_edge(node_name,node['location'])
                case 'scene':
                    pass
                case _:
                    print(f"Unknown node type: {node['type']}")
        except:
            raise ValueError(f"Error during edges resetting with {node_name} {node}. Check relations.")

    def is_accessible(self, node):
        if node['type'] != 'object':
            return True, ''
        for _ in range(MAX_OBJECTS_DEEP):
            parent_name = node['related_to']
            parent = self.graph.nodes[parent_name]
            if parent['type'] == 'agent':
                return True, ''
            if 'closed' in parent['states'] and node['relation'] == 'inside_of':
                return False, parent_name
            if parent['type'] != 'object':
                return True, ''
            node = parent
        return True, ''
    
    def find_place(self, node):
        for _ in range(MAX_OBJECTS_DEEP+1):
            if node['type'] == 'asset':
                return node['place']
            if node['type'] == 'agent':
                return node['location']
            parent_name = node['related_to']
            node = self.graph.nodes[parent_name]

    def action(self, action, node_name):
        G = self.graph
        if action in ['done', 'discover_objects']:
            return 0
        if node_name not in G:
            return f"Node {node_name} not found in the graph. Try look on or inside assets."
        if action not in ['put_on', 'put_inside', 'pick_up', 'open', 'close', 'turn_on', 'turn_off', 'discover_objects', 'go_to']:
            return f"Action {action} is wrong. No such action as {action}."
        
        node = G.nodes[node_name]
        agent = G.nodes[('agent',1)]
        sayplan_name = node_name[0] +'-'+ str(node_name[1])

        if action in ['put_on', 'put_inside', 'pick_up', 'open', 'close', 'turn_on', 'turn_off', 'discover_objects'] and node['type'] not in ['asset', 'object']:
            return f"Action {action}({sayplan_name}) is wrong. You can interact only with asset and object nodes."
        
        accesible, parent_name = self.is_accessible(node)
        if not accesible:
            return f"Action {action}({sayplan_name}) is wrong.{sayplan_name} in not accesible because {parent_name} is closed."
        
        if node['type'] in ['asset', 'object'] and action not in node['affordances']:
            return f"Action {action}({sayplan_name}) is wrong. It is not possible to {action} {sayplan_name}"
        
        if action not in ['go_to', 'done'] and agent['location'] != self.find_place(node):
            return f"Action {action}({sayplan_name}) is wrong. Agent not in the same room with node."

        match action:
            case 'go_to':
                if node['type'] != 'place':
                    return f"Action {action}({sayplan_name}) is wrong. {sayplan_name} is not a room to go."
                agent['location'] = node_name

            case 'pick_up':
                if agent['holding'] != '':
                    return f"Action {action}({sayplan_name}) is wrong. Agent can hold only one object. Agent aldeady holding {agent['holding']}"
                if (node['type'] != 'object'):
                    return f"Action {action}({sayplan_name}) is wrong. Agent can pick_up only object nodes."

                agent['holding'] = node_name
                node['relation'] = 'inside_hand'
                node['related_to'] = ('agent',1)
            case 'put_on':
                if agent['holding'] == '':
                    return f"Action {action}({sayplan_name}) is wrong. Agent don't holding something to put"
                if 'put_on' not in node['affordances']:
                    return f"Action {action}({sayplan_name}) is wrong. Agent cant put objects on {sayplan_name}"

                G.nodes[agent['holding']]['relation'] = 'ontop_of'
                G.nodes[agent['holding']]['related_to'] = node_name
                agent['holding'] = ''

            case 'put_inside':
                if agent['holding'] == '':
                    return f"Action {action}({sayplan_name}) is wrong. Agent don't holding something to put"
                if agent['holding'] == node:
                    return f"Action {action}({sayplan_name}) is wrong. An object cannot be placed inside itself."
                if 'closed' in node['states']:
                    return f"Action {action}({sayplan_name}) is wrong. Agent cant put objects inside of closed {sayplan_name}"

                G.nodes[agent['holding']]['relation'] = 'inside_of'
                G.nodes[agent['holding']]['related_to'] = node_name
                agent['holding'] = ''
            case 'open':
                if 'open' in node['states']:
                    return f"Action {action}({sayplan_name}) is wrong. {sayplan_name} already open"

                node['states'].remove('closed')
                node['states'].append('open')
            case 'close':
                if 'closed' in node['states']:
                    return f"Action {action}({sayplan_name}) is wrong. {sayplan_name} already closed"

                node['states'].remove('open')
                node['states'].append('closed')
            case 'turn_on':
                if 'on' in node['states']:
                    return f"Action {action}({sayplan_name}) is wrong. {sayplan_name} already turned on"

                if 'off' in node['states']:
                    node['states'].remove('off')
                node['states'].append('on')

                #Adding states for dynamic tasks from SayPlan
                if node_name[0] in ['microwave'] and 'closed' in node['states']:
                    for obj, attr in G.nodes(data=True):
                        if attr['type'] == 'object' and attr['related_to'] == node_name and attr['relation'] == 'inside_of':
                            attr['states'].append('hot')
                if node_name[0] in ['coffee_machine']:
                    for obj, attr in G.nodes(data=True):
                        if attr['type'] == 'object' and attr['related_to'] == node_name and attr['relation'] == 'inside_of':
                            attr['states'].append('filled_coffee')

            case 'turn_off':
                if 'off' in node['states']:
                    return f"Action {action}({sayplan_name}) is wrong. {sayplan_name} already off"
                
                node['states'].remove('on')
                node['states'].append('off')
                
            case 'discover_objects':
                pass
            case 'done':
                pass
            case _:
              return f"Action {action} is wrong. No such action as {action}."
        self._reset_edges()
        return 0

def find_important_nodes(init_graph, goal_graph, add_assets=False):
    """

    Function that return list of objects and assets changed between initial and goal graph.

    """
    def add_parent_nodes(node_name, graph):
        node = graph.nodes[node_name]
        for _ in range(MAX_OBJECTS_DEEP):
            parent_name = node.get('related_to')
            if not parent_name:
                break
            parent = graph.nodes[parent_name]
            important_nodes.add(parent_name)
            if parent['type'] != 'object':
                break
            node = parent

    important_nodes = set()
    for node_name in init_graph.nodes:
        if init_graph.nodes[node_name] != goal_graph.nodes[node_name]:
            important_nodes.add(node_name)

            if init_graph.nodes[node_name]['type'] == 'object' and add_assets:
                add_parent_nodes(node_name, init_graph)
                add_parent_nodes(node_name, goal_graph)

    return list(important_nodes)