Skip to content
TheChatArchiveThe Chat Archive
gpt-3.5-turbo-0301· OpenAIAi2 WildChat-4.8M (AI2)

voici mon code : class node: def init(self, identity, label, parents, children): '''…

  1. User

    voici mon code : class node:

    def __init__(self, identity, label, parents, children):
        '''
        identity: int; its unique id in the graph
        label: string;
        parents: int->int dict; maps a parent node's id to its multiplicity
        children: int->int dict; maps a child node's id to its multiplicity
        '''
        self.id = identity
        self.label = label
        self.parents = parents
        self.children = children
        
    def __repr__ (self):
        return "id: "+ str(self.id) + ", " + "label: " + str(self.label) + ", " + "parents: " + str(self.parents) + ", " + "children: " + str(self.children)
    #ok  
    
    def get_id (self):
        return self.id
    
    def get_label (self):
        return self.label
    #ok
        
    def get_parents_ids (self):
        return [i for i in self.parents.keys()]
    #ok
        
    def get_children_ids (self):
        return [i for i in self.children.keys()]
    #ok
    
    def get_children(self):
        return self.children.values()
    
    def get_parents(self):
        return self.parents.values()
    
    def set_id(self, i):
        self.id = i
    #ok
    
    def set_label(self, i):
        self.label = i
    #ok
    
    def set_parents_ids(self, i):
        self.parents = i
    #ok
    
    def set_children_ids(self, i):
        self.children = i
    #ok
    
    def add_child_id(self, i):
        if i in self.get_children_ids():
            self.children[i] +=1
        else:
            self.children[i] = 1
    #ok
    
    def add_parent_id(self, i):
        if i in self.get_parents_ids():
            self.parents[i] +=1
        else:
            self.parents[i] = 1
    #ok
    
    def remove_parent_once(self, id):
        try:
            if self.parents[id] <= 1:
                self.remove_parent_id(id)
                return
            self.parents[id] = self.parents[id] - 1
        except KeyError:
            raise "Invalid parent id"
    #ok
    
    def remove_child_once(self, id):
        try:
            if self.children[id] <= 1:
                self.remove_child_id(id)
                return
            self.children[id] = self.children[id] - 1
        except KeyError:
            raise "Invalid child id"
    #ok
    
    def remove_parent_id(self, id):
        try:
            self.parents.pop(id)
        except KeyError:
            raise "Invalid parent id"
    #ok
    
    def remove_child_id(self, id):
        try:
            self.children.pop(id)
        except KeyError:
            raise "Invalid child id"
    #ok
    
    def indegree(self):
        res = 0
        for p in self.parents.values():
            res += p
        return res
    
    def outdegree(self):
        res = 0
        for c in self.children.values():
            res +=c
        return res
    
    def degree(self):
        return self.indegree()+self.outdegree()
         
    

    n = node(2, 0, {1: 2}, {3: 2}) #print(n.indegree()) #print(n.outdegree()) #print(n.degree())

    class open_digraph(open_digraph_display_mx, open_digraph_connectivite_mx, open_digraph_tritopo_mx, node): # for open directed graph

    def __init__(self, inputs, outputs, nodes):
        '''
        inputs: int list; the ids of the input nodes
        outputs: int list; the ids of the output nodes
        nodes: node list;
        '''
        self.inputs = inputs
        self.outputs = outputs
        self.nodes = {node.id:node for node in nodes} # self.nodes: <int,node> dict
    
    def __str__ (self):
        return "inputs: " + str(self.inputs) + "\n" + "outputs: "+ str(self.outputs) + "\n" + "nodes: " + str(self.nodes)
    
    @classmethod
    def empty(cls):
        return cls([],[],[])
    
    def copy(self):
        newNodes = {}
        d = open_digraph.empty()
        d.inputs = self.inputs.copy()
        d.outputs = self.outputs.copy()
        for key in self.nodes.keys():
            n0 = node(-1, '', {}, {})
            n0.id = self.nodes[key].id
            n0.label = self.nodes[key].label
            n0.parents = self.nodes[key].parents.copy()
            n0.children = self.nodes[key].children.copy()
            newNodes[key]=n0
        d.nodes = newNodes
        return d
    #ok
    
    def get_input_ids(self):
        return self.inputs
        #return [i.get_id() for i in self.inputs] 
    #ok
    
    def get_output_ids(self):
        return self.outputs
        #return [i.get_id() for i in self.outputs]
    #ok
    
    def get_id_node_map(self):
        return self.nodes
    #ok
    
    def get_nodes(self):
        return [i for i in self.nodes.values()]
    #ok
    
    def get_node_ids(self):
        return [i for i in self.nodes.keys()]
    #ok
    
    def get_node_by_id(self, i):
        '''
        i : int (id of the node)
        '''
        return self.nodes[i]
    #ok
    
    def get_nodes_by_ids(self, t):
        '''
        t : int iter
        '''
        return [self.nodes[i] for i in t]
    #ok
    
    def get_input_nodes(self):
        return [self.nodes[node_id] for node_id in self.inputs]
    
    def get_output_nodes(self):
        return [node for node in self.nodes.values() if node.outdegree() == 0 and node in self.outputs]
    
    def set_input_ids(self, t):
        '''
        t : int list
        '''
        self.inputs = t
    #ok
    
    def set_output_ids(self, t):
        '''
        t : int list
        '''
        self.outputs = t
    #ok
    
    def add_node(self, label='', parents=None, children=None): #parents et children sont des dictionnaires
        '''
        adds a NEW (it creates it !) a node
        label : string
        parents : int:int dict
        children : int:int dict
        '''
        if parents is None:
            parents = {}
        if children is None:
            children = {}
        new_id = self.new_id()
        new_node = node(new_id, label, parents, children)
        self.nodes[new_id] = new_node
        for parent_id in parents:
            self.nodes[parent_id].children[new_id] = parents[parent_id]
        for child_id in children:
            self.nodes[child_id].parents[new_id] = children[child_id]
        return new_id
    #ok
    
    def add_input_node (self, id):
        nid = self.new_id()
        if (id in self.get_input_ids()) or (id in self.get_output_ids()):
            raise  "invalid connection"
        else:
            self.nodes[nid] = node(nid, "input", dict(), {id:1})
            self.nodes[id].parents[nid] = 1
            self.add_input_id(nid)
    #ok
    
    def add_output_node (self, id):
        nid = self.new_id()
        if (id in self.get_input_ids()) or (id in self.get_output_ids()):
            raise  "invalid connection"
        else:
            self.nodes[nid] = node(nid,"output",{id:1},dict())
            self.nodes[id].children[nid] = 1
            self.add_output_id(nid)
    #ok
    
    def add_input_id(self, t):
        '''
        makes an existing node an input
        t : int (id of the node)
        '''
        if t in self.inputs:
            raise "Already an input"
        else:
            self.inputs += [t]
    #ok
    
    def add_output_id(self, t):
        '''
        makes an existing node an output
        t : int (id of the node)
        '''
        if t in self.outputs:
            raise 'Already an output'
        else:
            self.outputs += [t]
    #ok
    
    def add_edge(self, src, tgt):
        if src not in self.nodes:
            raise ValueError(f"node id source invalide :{src}")  #vérifie si le noeud source (src) existe dans la liste des noeuds (nodes) de ce graph
        if tgt not in self.nodes:
            raise ValueError(f"node id cible invalide :{tgt}") #vérifie si le noeud cible (tgt) existe dans la liste des noeuds (nodes)
    
        src_node = self.get_node_by_id(src) # récupere le noeud source a partir de la liste de neouds en utilisant l'identifiant src du noeud source
        tgt_node = self.get_node_by_id(tgt) # recupere le noeud cible a partir de la liste des noeuds en utilisant l'id tgt du noeud cible
        src_node.add_child_id(tgt)
        tgt_node.add_parent_id(src)
    #ok
    
    def add_edges(self, edges):
        '''
        edges : (int, int) iter
        '''
        for src, tgt in edges:
         self.add_edge(src, tgt)
    #ok
    
  2. Assistant

    def remove_node(self, id): ''' removes the node with the given id ''' if id in self.inputs: self.inputs.remove(id) if id in self.outputs: self.outputs.remove(id) if id not in self.nodes: raise ValueError(f"node id invalide :{id}") node = self.nodes[id] for parent_id in node.get_parents_ids(): p = self.nodes[parent_id] p.remove_child_id(id) for child_id in node.get_children_ids(): c = self.nodes[child_id] c.remove_parent_id(id) del self.nodes[id] #ok

    def remove_edge(self, src, tgt):
        '''
        removes the edge (src,tgt)
        '''
        src_node = self.get_node_by_id(src)
        tgt_node = self.get_node_by_id(tgt)
        src_node.remove_child_id(tgt)
        tgt_node.remove_parent_id(src)
    #ok
    
    def turn(self):
        '''
        reverse the direction of ALL the edges
        '''
        new_dag = self.copy()
        for n1 in self.nodes.values():
            for c_id in n1.get_children_ids():
                new_dag.remove_edge(n1.get_id(), c_id)
                new_dag.add_edge(c_id, n1.get_id())
        return new_dag
    #ok
    
    def reverse(self):
        '''
        creates a REVERSED copy of the graph
        '''
        new_dag = self.copy()
        for node in new_dag.nodes.values():
            node.parents, node.children = node.children, node.parents
        new_dag.inputs, new_dag.outputs = new_dag.outputs, new_dag.inputs
        return new_dag
     
    def new_id(self):
        '''
        returns a new, unused id in the graph
        '''
        ids = set(self.get_node_ids()) | set(self.get_input_ids()) | set(self.get_output_ids())
        for i in range(1, len(ids)+1):
            if i not in ids:
                return i
        return len(ids)+1
    
    def make_dot(self):
        '''
        creates a pydot.Digraph object representing the directed graph
        '''
        dot = pydot.Dot(graph_type='digraph')
        nodes = {}
        for n in self.nodes.values():
            label = n.get_label()
            if label == '':
                label = str(n.get_id())
            nodes[n.get_id()] = pydot.Node(str(n.get_id()), label=label)
            for c_id, c_mult in n.children.items():
                if c_id in nodes:
                    tgt_node = nodes[c_id]
                else:
                    label = self.nodes[c_id].get_label()
                    if label == '':
                        label = str(c_id)
                    tgt_node = pydot.Node(str(c_id), label=label)
                    nodes[c_id] = tgt_node
                src_node = nodes[n.get_id()]
                for _ in range(c_mult):
                    dot.add_edge(pydot.Edge(src_node, tgt_node))
        for i_id in self.get_input_ids():
            if i_id not in nodes:
                nodes[i_id] = pydot.Node(str(i_id), label='input', shape='box')
            dot.add_edge(pydot.Edge(nodes[i_id], nodes[self.get_node_by_id(i_id).get_children_ids()[0]]))
        for o_id in self.get_output_ids():
            if o_id not in nodes:
                nodes[o_id] = pydot.Node(str(o_id), label='output', shape='box')
            dot.add_edge(pydot.Edge(nodes[self.get_node_by_id(o_id).get_parents_ids()[0]], nodes[o_id]))
        return dot
    
    def draw(self):
        '''
        draws the directed graph in jupyter
        '''
        return self.make_dot().create_jupyter_notebook_svg()