script.py

from core import networkdata as nd
from core.parsing.jsonparser import JSONParser
from core.parsing.jsonencoder import JSONEncoder
from cytoapp.cytoscapeapp import CytoscapeApp
from userapps.rovercase.roverdatahandler import RoverDataHandler
import itertools
import copy
import webbrowser
from core.visualization.tikzstandard import StandardTikzVisualizer as s
from core.visualization.tikzlayer import LayeredTikzVisualizer as l
### HRT Metrics Script

''' The folder containing the JSON data.
'''
directory: str = "data/RevisedWMC/"

''' The JSON files in the given folder
'''
data_sets: list[str] = [
    "initial_model"
]


# Define a dictionary with edges as keys and lists of QOS values as values
# edge_qos_values = {
#     # ("PP", "NWS"): [30, 31, 42, 43],
#     ("PP", "NWS"): [10, 15, 20, 25, 30, 31, 42, 43],
#     # ("PP", "NWS"): [0, 10, 15, 20],
#     ("Confirmation-BLM", "BLM"): [0, 20, 30, 40]
# }
edge_qos_values = {
    # "PP_NWS": [30, 31, 42, 43],
    # ("PP", "NWS"): [10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100, 110, 130, 150, 180, 210, 240, 270],
    ("PP", "NWS"): [10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70],
    # ("PP", "NWS"): [1, 2, 3, 5, 10, 15, 20, 25, 30, 40, 50, 60, 70, 80, 90, 100, 120, 140, 160, 200, 240, 320],
    # ("Confirmation-BLM", "BLM"): [0, 20, 30, 40, 50, 60, 80]
    # ("confirmation", ""): [0]
    ("confirmation", ""): [0,10,20,30,40,50,60,70,80,90,100]
}


# Class for user data
class UserData:
    def __init__(self, QOS=1000000):  # Default value set to 1000000
        self.QOS = QOS

# Custom edge_user_data processor
def custom_user_parse(user_data):
    ''' The default behavior for parsing user data. These types of
        functions recieve the data tied to the "UserData" entries in
        JSON files and return what user_data within the network model
        elements should be set to.
    '''

    QOS = user_data["QOS"]
    # user_data = lambda: None
    if QOS != "":
        user_data = UserData(float(QOS))
    else:
        user_data = UserData(1000000) # Assumption for missing data

    return user_data

''' Store the parsed network models in a dictionary.
'''
data_dict: dict[str, nd.NetworkModel] = {}
for name in data_sets:
    data_dict[name] = JSONParser.parse(directory + name + ".json", e_user_data_func = custom_user_parse)


# Main network
main_net = data_dict["initial_model"]

# Define roles for both human and operator (is there a way to do this through the JSON?)
operator: nd.Agent = nd.Agent("Operator")
rover: nd.Agent = nd.Agent("Robot")

operator.add_action(main_net.get_node("LAA"), operator.allocation_types.Authority)
operator.add_action(main_net.get_node("OLL"), operator.allocation_types.Authority)
operator.add_action(main_net.get_node("CAM"), operator.allocation_types.Authority)
# Obstacle size estimation?

rover.add_action(main_net.get_node("BLM"), rover.allocation_types.Authority)
rover.add_action(main_net.get_node("TMP"), rover.allocation_types.Authority)
rover.add_action(main_net.get_node("RPP"), rover.allocation_types.Authority)
rover.add_action(main_net.get_node("NWS"), rover.allocation_types.Authority)
rover.add_action(main_net.get_node("IC"), rover.allocation_types.Authority)
rover.add_action(main_net.get_node("RM"), rover.allocation_types.Authority) # Remove this function?

# Responsibility
operator.add_action(main_net.get_node("BLM"), operator.allocation_types.Responsibility)
operator.add_action(main_net.get_node("TMP"), operator.allocation_types.Responsibility)
operator.add_action(main_net.get_node("RPP"), operator.allocation_types.Responsibility)
operator.add_action(main_net.get_node("NWS"), operator.allocation_types.Responsibility)
operator.add_action(main_net.get_node("IC"), operator.allocation_types.Responsibility)
operator.add_action(main_net.get_node("RM"), operator.allocation_types.Responsibility) # Remove this function?


# # Identify the shared resources
# shared_resources = []

# # Loop over all nodes in the graph
# for node_id in main_net.get_graph().nodes():
    
#     node = main_net.get_node(node_id)
    
#     # Check if WorkDomainResource
#     if issubclass (node.__class__, nd.WorkDomainResource):

#         # Get all neighboring nodes (actionNodes)
#         functions_that_set = main_net.get_graph().predecessors(node_id)
#         functions_that_get = main_net.get_graph().successors(node_id)

#         # A list of all function pairs that are connected through this resources
#         interdependent_functions = list(itertools.product(functions_that_get,functions_that_set))

#         # For each pair, check whether roles is the same
#         for pair in interdependent_functions:
#             agent_setting = main_net.get_node(pair[0]).get_authorized_agent()
#             agent_getting = main_net.get_node(pair[1]).get_authorized_agent()

#             if agent_setting.id != agent_getting.id:
#                 shared_resources.append((node_id,pair))


# # For each of the shared resources, do something!
# # Current rule: When an information resource is shared between agents at the taskwork level, 
# # then a function must be created at the teamwork level to show the relaying of information, 
# # such that a shared awareness is formed at the social organizational level. 
# for element in shared_resources:

#     # print("There is a shared resource",element[0],"between ", element[1][0], "and", element[1][1])

#     # Create a shared resources node and a teamwork function node
#     soc_org_node = main_net.add_node(nd.Node("shared_"+element[0])) # TODO: Specify the node type/class
#     teamwork_node = main_net.add_node(nd.ActionNode("sharing_"+element[0]))

#     # Add edge going from teamwork node to shared_resource node
#     main_net.add_edge("sharing_"+element[0],"shared_"+element[0])

#     # Add edge going from original resource to the teamwork node
#     main_net.add_edge(element[0],"sharing_"+element[0])

#     # Add QOS to each edge (making an assumption that this needs to updated always but can change!)
#     user_data = lambda: None
#     user_data.QOS = 0
#     # main_net.get_edge("sharing_"+element[0],"shared_"+element[0]).user_data = user_data # No QOS needed--because is set relationship
#     main_net.get_edge(element[0],"sharing_"+element[0]).user_data = user_data


# Identify the shared resources
shared_actions = []

# Loop over all nodes in the graph
for node_id in main_net.get_graph().nodes():
    
    node = main_net.get_node(node_id)
    
    # Check if TaskworkAction
    if issubclass (node.__class__, nd.TaskworkAction):

        # Get all neighboring nodes (actionNodes)
        authorized_agent = node.get_authorized_agent()
        # responsible_agent = node.get_responsible_agent()

        # For each pair, check whether roles is the same
        if authorized_agent != operator:
            shared_actions.append(node_id)

# For each of the shared action, do something!
# Current rule: When authority-responsibility mismatch, create a confirmation resources and an a confirmation
# action that is allocated to the operator
for node_id in shared_actions:

    if node_id == "RM":
        continue

    # Create a coordination resource and a teamwork function node
    soc_org_node = main_net.add_node(nd.CoordinationResource("Confirmation-"+node_id)) # TODO: Specify the node type/class
    main_net.get_node("Confirmation-"+node_id).user_data = "Confirmation-"+node_id # Need to fill these for WMC parsing
    teamwork_node = main_net.add_node(nd.TeamworkAction("Confirming-"+node_id))
    main_net.get_node("Confirming-"+node_id).user_data = "Confirming-"+node_id # Need to fill these for WMC parsing

    # Add edge going from teamwork node to coordination resource
    main_net.add_edge("Confirming-"+node_id,"Confirmation-"+node_id)
    main_net.get_edge("Confirming-"+node_id,"Confirmation-"+node_id).user_data = UserData(100000)

    # Add edges going from coordination resource to original node
    main_net.add_edge("Confirmation-"+node_id,node_id)

    # Add edge going from work domain resources set by shared action to teamwork node
    for wd_resource in main_net.get_graph().successors(node_id):
        main_net.add_edge(wd_resource,"Confirming-"+node_id)
        
        # Add QOS to each edge (making an assumption that this needs to updated always but can change!)
        main_net.get_edge(wd_resource,"Confirming-"+node_id).user_data = UserData(1000000)

    # Allocate authority and responsibility to human
    operator.add_action(main_net.get_node("Confirming-"+node_id), operator.allocation_types.Authority)
    operator.add_action(main_net.get_node("Confirming-"+node_id), operator.allocation_types.Responsibility)

    # Add QOS to each edge (making an assumption that this needs to updated always but can change!)
    main_net.get_edge("Confirmation-"+node_id,node_id).user_data = UserData(0)


# We want to write this new graph to an output JSON file.
# Create a custom encoder for the user data that should fill the QOS
def custom_user_encode(user_data):

    user_data = {
                "QOS": user_data.QOS,
            }
    
    return user_data


# Create all combinations of QOS values for the edges
qos_combinations = list(itertools.product(*edge_qos_values.values()))

# Loop over each combination to create copies of the main_net with these QOS values
for qos_combo in qos_combinations:
    # Create a deep copy of the main_net to modify
    temp_net = copy.deepcopy(main_net)
    
    # Set the QOS values for the edges in the temp_net
    for edge, qos_value in zip(edge_qos_values.keys(), qos_combo):
        if edge[0] == "confirmation":
            confirmation_nodes = [node for node in temp_net.get_node_ids() if node.startswith("Confirmation-")]
            for full_node_id in confirmation_nodes:
                node_id_after_dash = full_node_id.split("-", 1)[1]
                print(full_node_id,node_id_after_dash)
                temp_net.get_edge(full_node_id, node_id_after_dash).user_data = UserData(qos_value)
        else:
            print(edge[0])
            temp_net.get_edge(*edge).user_data = UserData(qos_value)
    
    # Write the data to a JSON file using the JSONEncoder and custom_user_encode
    # The file name includes the QOS values for identification
    file_name = "data/ForWMCreading/PPtoNWS_{}_conf_{}.json".format(*qos_combo)
    JSONEncoder.encode(file_name, temp_net, e_user_data_func=custom_user_encode)



# Manually set the QOS for NWP to RM to 0. This is necessary because WMC schedules NWS but for 
# the network analysis, this edge must be triggered
main_net.get_edge("NWP","RM").user_data = UserData(0)


# Now add attributes that represent when each WorkDomainResource and OrgResource was last updated
for node_id in main_net.get_node_ids():
    
    node = main_net.get_node(node_id)
    
    # Check if WorkDomainResource
    if issubclass (node.__class__, nd.WorkDomainResource) or issubclass (node.__class__, nd.CoordinationResource):
        
        user_data = lambda: None # Lambda function that we can add attributes to, could use to set last_update_time to zero.
        user_data.last_update_time = 0#-1000000 # Something really small so that it updates the first time we run it.
        node.user_data = user_data

# Check that previous is actually working
# for node_id in main_net.get_node_ids():
    
#     node = main_net.get_node(node_id)
    
#     # Check if WorkDomainResource
#     if issubclass (node.__class__, nd.WorkDomainResource) or issubclass (node.__class__, nd.CoordinationResource):
        
#         print(node.user_data.last_update_time)

# Check that QOS is loaded properly
# for edge_id in main_net.get_edge_ids():
    
#     edge = main_net.get_edge(edge_id[0],edge_id[1])
    
#     print(edge.user_data.QOS)

# Now we can do some funky things with the QOS requirements...
# First want to find edges that need updating based on when resources were last updated.
current_time = 32 #Needs something different here

# Manually change when resources were last updated
# Strategy for NWS without updating PP
# main_net.get_node("PP").user_data.last_update_time = current_time

# Strategy without cross-checking
# main_net.get_node("Confirmation-NWS").user_data.last_update_time = current_time
# main_net.get_node("Confirmation-BLM").user_data.last_update_time = current_time
# main_net.get_node("Confirmation-TMP").user_data.last_update_time = current_time
# main_net.get_node("Confirmation-RPP").user_data.last_update_time = current_time

# Strategy without obstacle location
# main_net.get_node("OL").user_data.last_update_time = current_time

# Strategy without battery level and temperature measurement
# main_net.get_node("OST").user_data.last_update_time = current_time
# main_net.get_node("OBL").user_data.last_update_time = current_time


out_of_bound_edges = []

# Identify which edges are out of QOS bound
for edge_id in main_net.get_edge_ids():
    
    edge = main_net.get_edge(edge_id[0],edge_id[1])
    
    # Check if the target is a function node
    target_node = main_net.get_node(edge_id[1])
    if issubclass (target_node.__class__, nd.ActionNode):
        
        # Check when resource was last updated
        source_node = main_net.get_node(edge_id[0])
        last_update_time = source_node.user_data.last_update_time
        QOS = edge.user_data.QOS

        if float(current_time) - float(last_update_time) > float(QOS):
            print("QOS for",source_node.id,"to",target_node.id,"is out of bounds with QOS",float(QOS),"and last update time",last_update_time)

            out_of_bound_edges.append(edge_id)

# This function is used to identify functional nodes are predependencies for a target function
# based on QOS bounds and when resources were last updated.
# This function takes in a node id of a FUNCTION node that is the target
# It returns a list of function and resource nodes that need to be updated/executed to abide by QOS requirements
def add_predecessors_to_strategy(node_id, out_of_bound_edges, strategy_list, main_net):

    # Get the node handle
    node = main_net.get_node(node_id)

    # If this node is not yet in the strategy, add it!
    if node not in strategy_list:
        strategy_list.append(node)

    # Now loop over all incoming edges
    for pred_node_id in main_net.get_graph().predecessors(node_id):

        # And check whether it is within QOS bound
        if (pred_node_id, node_id) in out_of_bound_edges:

            # If out of QOS bound, need to add to our strategy (in need for an update)
            strategy_list.append(main_net.get_node(pred_node_id))

            # We need to add each of the functions that is linked to set this predecessor node
            # and perform the same check to see if we need to add their predecessors
            for pred_pred_node_id in main_net.get_graph().predecessors(pred_node_id):

                if main_net.get_node(pred_pred_node_id) not in strategy_list:
                    add_predecessors_to_strategy(pred_pred_node_id, out_of_bound_edges, strategy_list, main_net)

    return strategy_list

# Identify the strategy
strategy_list = add_predecessors_to_strategy('RM', out_of_bound_edges, [], main_net)

# # Identify edges to highlight (that are connecting the nodes in the strategy)
# connecting_edges = []
# for node in strategy_list:
#     for neighbor in main_net.get_graph().neighbors(node.id):
#         if main_net.get_node(neighbor) in strategy_list:
#             edge = (node.id, neighbor) if (node.id, neighbor) in main_net.get_edge_ids() else (neighbor, node.id)
#             if edge not in connecting_edges:
#                 connecting_edges.append(edge)

# Identify all incoming edges for every node in the strategy_list
connecting_edges = []
for node in strategy_list:
    print(node.id)
    for incoming_edge in main_net.get_graph().in_edges(node.id):
        if incoming_edge not in connecting_edges:
            connecting_edges.append(incoming_edge)

# Let's output as a TikZ graph
l.visualize(main_net, "tikzout3.tex")

''' Alter networks after they have been read 
    from JSON.
'''
# app = CytoscapeApp(data_dict, RoverDataHandler, connecting_edges)
app = CytoscapeApp(data_dict, RoverDataHandler)
webbrowser.open_new("http://127.0.0.1:8050")
app.run()