| Message:
<pre>
De la meta programmation en noeud/reseau/graphe
le noeud 1 contient un programme que tu definit
le noeud 2 contient un programme que tu definit aussi
le noeud 3 contient aussi un programme que tu definit aussi
chaque noeud peut etre relié a un autre et modifié les variables/programmes des autres
Chaque noeud est un meta noeud, chaque donnée du meta noeud est un noeud
si par exemple tu as deux noeud qui ont une donnée qui est egale a 5
ce 5 va etre un noeud avec un lien vers ces deux metas noeuds.
En gros je bosse sur un bout d ia ou le but est de tester plein de choses avec des arbres decisionnels.
Par exemple ce type de programme sert a lister des possibilités
chaque noeud peut avoir un poids :
le noeud 1 a un poids de 1 il a une relation avec le noeud 2 et 3
il va vers le noeud 3 qui un poids de 5 contre 4 pour le noeud 2.
Ensuite le noeud trois execute un programme qui prends les parametre du noeud 1,
ce programme modifie les poids des noeud 5 et 6 qui ont un lien avec trois.
En gros a chaque etape du graphe tu modifies le poids des noeuds en amont ou en aval pour determiner le meilleur parcour du graphe a chaque etapes
(pour les echecs le poker le go le deplacement d une unité).
bref je me suis bien amusé
[code]
import threading
class Graph:
def __init__(self,name):
self.name = name
self.list_neighbor = {}
self.list_node = {}
def add_node(self,node):
self.list_node[node] = True
def add_edge(self,node,nodebis):
try :
self.list_neighbor[node].append(nodebis)
except :
self.list_neighbor[node] = []
self.list_neighbor[node].append(nodebis)
try :
self.list_neighbor[nodebis].append(node)
except :
self.list_neighbor[nodebis] = []
self.list_neighbor[nodebis].append(node)
def neighbors(self,node):
try :
return self.list_neighbor[node]
except :
return []
def nodes(self):
return self.list_node.keys()
def delete_edge(self,node,nodebis):
self.list_neighbor[node].remove(nodebis)
self.list_neighbor[nodebis].remove(node)
def delete_node(self,node):
del self.list_node[node]
try :
for nodebis in self.list_neighbor[node] :
self.list_neighbor[nodebis].remove(node)
del self.list_neighbor[node]
except :
return "error"
class Graphe(Graph):
count = 0
liste_node_main = {}
liste_node_type = {}
liste_name = {}
liste_type = {}
liste_weight = {}
liste_key = {}
liste_value = {}
liste_link = {}
liste_func = {}
liste_result = {}
liste_free = {}
def add_node(self,node,name='',type='',weight='',func='',data = ''):
self.count += 1
node_coun = self.count
Graph.add_node(self,node_coun)
self.liste_node_main[node] = node_coun
self.liste_node_type[node_coun] = 'main'
if name != '' :
self.add_node_name(node,name)
if type != '':
self.add_node_type(node,type)
if func != '':
self.add_node_func(node,func)
if data != '':
self.add_node_data(node,data)
if weight != '':
self.add_node_weight(node,weight)
def add_node_weight(self,node,weight):
node = self.get_real_node(node)
node_coun = node
if weight not in self.liste_weight.values():
self.count += 1
node_coun = self.count
print node_coun
Graph.add_node(self,self.count)
self.liste_node_type[self.count] = 'weight'
self.liste_weight[self.count] = weight
else :
for key in self.liste_weight :
if self.liste_weight[key] == weight :
node_coun = key
Graph.add_edge(self,node,node_coun)
def add_node_result(self,node,result):
node = self.get_real_node(node)
node_coun = node
if result not in self.liste_result.values():
self.count += 1
node_coun = self.count
Graph.add_node(self,self.count)
self.liste_node_type[self.count] = 'result'
self.liste_result[self.count] = result
else :
for key in self.liste_result :
if self.liste_result[key] == result :
node_coun = key
Graph.add_edge(self,node,node_coun)
def add_node_data(self,node,data):
nodes = node
node = self.get_real_node(node)
for key in data.keys() :
if key not in self.liste_key.values() :
self.count += 1
node_coun = self.count
Graph.add_node(self,self.count)
self.liste_node_type[self.count] = 'key'
self.liste_key[self.count] = key
else :
for keys in self.liste_key :
if self.liste_key[keys] == key :
node_coun = keys
Graph.add_edge(self,node,node_coun)
if data[key] not in self.liste_value.values() :
self.count += 1
node_counv = self.count
Graph.add_node(self,self.count)
self.liste_node_type[self.count] = 'value'
self.liste_value[self.count] = data[key]
else :
for keys in self.liste_value :
if self.liste_value[keys] == data[key] :
node_counv = keys
Graph.add_edge(self,node,node_counv)
Graph.add_edge(self,node_coun,node_counv)
if [node,node_coun,node_counv] not in self.liste_link.values() :
self.count += 1
node_counl = self.count
Graph.add_node(self,self.count)
self.liste_node_type[self.count] = 'link'
self.liste_link[self.count] = [node,node_coun,node_counv]
else :
for key in self.liste_link :
if self.liste_link[key] == [node,node_coun,node_counv] :
node_counl = key
Graph.add_edge(self,node,node_counl)
Graph.add_edge(self,node_coun,node_counl)
Graph.add_edge(self,node_counv,node_counl)
def get_node_weight(self,node):
node = self.get_real_node(node)
liste = Graph.neighbors(self,node)
for n in liste :
if self.liste_node_type[n] == 'weight' :
return self.liste_weight[n]
def get_node_data(self,node):
node = self.get_real_node(node)
liste = Graph.neighbors(self,node)
lister = {}
for n in liste :
if self.liste_node_type[n] == 'link' :
lister[self.liste_key[self.liste_link[n][1]]] = self.liste_value[self.liste_link[n][2]]
return lister
def get_real_node(self,node):
return self.liste_node_main[node]
def get_node_surname(self,node):
k = self.liste_node_main.keys()
for n in k :
if self.liste_node_main[n] == node :
return n
def add_node_name(self,node,name):
node = self.get_real_node(node)
node_coun = node
if (name not in self.liste_name.values()):
self.count += 1
node_coun = self.count
Graph.add_node(self,self.count)
self.liste_node_type[self.count] = 'name'
self.liste_name[self.count] = name
else :
for key in self.liste_name :
if self.liste_name[key] == name :
node_coun = key
Graph.add_edge(self,node,node_coun)
def get_node_name(self,node):
node = self.get_real_node(node)
liste = Graph.neighbors(self,node)
for n in liste :
if self.liste_node_type[n] == 'name' :
return self.liste_name[n]
def get_key_node (self,key):
for k in self.liste_key.keys() :
if self.liste_key[k] == key :
return k
def get_value_node (self,value):
for k in self.liste_value.keys() :
if self.liste_value[k] == value :
return k
def add_node_type(self,node,type):
node = self.get_real_node(node)
node_coun = node
if type not in self.liste_type.values():
self.count += 1
node_coun = self.count
Graph.add_node(self,self.count)
self.liste_node_type[self.count] = 'type'
self.liste_type[self.count] = type
else :
for key in self.liste_type :
if self.liste_type[key] == type :
node_coun = key
Graph.add_edge(self,node,node_coun)
def get_node_type(self,node):
node = self.get_real_node(node)
liste = Graph.neighbors(self,node)
for n in liste :
if self.liste_node_type[n] == 'type' :
return self.liste_type[n]
def add_node_func(self,node,func):
node = self.get_real_node(node)
node_coun = node
if func not in self.liste_func.values():
self.count += 1
node_coun = self.count
Graph.add_node(self,self.count)
self.liste_node_type[self.count] = 'func'
self.liste_func[self.count] = func
else :
for key in self.liste_type :
if self.liste_func[key] == func :
node_coun = key
Graph.add_edge(self,node,node_coun)
def get_node_func(self,node):
node = self.get_real_node(node)
liste = Graph.neighbors(self,node)
for n in liste :
if self.liste_node_type[n] == 'func' :
return self.liste_func[n]
def __exec_func(self,func,node):
dataold = self.get_node_data(node)
data = self.get_node_data(node)
exec(func)
var = None
for key in data.keys():
if data[key] != dataold[key] :
self.change_node_data(node, data)
self.add_node_result(node, var)
self.liste_free[node] = 1
def get_node_result(self,node):
while self.liste_free[node] != 1 :
pass
node = self.get_real_node(node)
liste = Graph.neighbors(self,node)
lister = []
for n in liste :
if self.liste_node_type[n] == 'result' :
lister.append(self.liste_result[n])
return lister
def exec_node_func(self,node):
self.liste_free[node] = 0
nodec = self.get_real_node(node)
liste = Graph.neighbors(self,nodec)
for n in liste :
if self.liste_node_type[n] == 'func' :
t = threading.Thread(target=self.__exec_func, args=(self.liste_func[n],node))
t.start()
def get_neighbors(self,node):
node = self.get_real_node(node)
liste = Graph.neighbors(self,node)
lister = []
for n in liste :
if self.liste_node_type[n] == 'main' :
lister.append(self.get_node_surname(n))
return lister
def add_edge(self,node,nodebis):
Graph.add_edge(self,self.get_real_node(node),self.get_real_node(nodebis))
def change_node_name(self,node,name):
nameold = self.get_node_name(node)
nodes = node
node = self.get_real_node(node)
for key in self.liste_name :
if self.liste_name[key] == nameold :
node_coun = key
Graph.delete_edge(self,node,node_coun)
if Graph.neighbors(self,node_coun) == []:
del self.liste_node_type[node_coun]
del self.liste_name[node_coun]
Graph.delete_node(self,node_coun)
self.add_node_name(nodes,name)
def change_node_type(self,node,type):
typeold = self.get_node_type(node)
nodes = node
node = self.get_real_node(node)
for key in self.liste_type :
if self.liste_type[key] == typeold :
node_coun = key
Graph.delete_edge(self,node,node_coun)
if Graph.neighbors(self,node_coun) == []:
del self.liste_node_type[node_coun]
del self.liste_type[node_coun]
Graph.delete_node(self,node_coun)
self.add_node_type(nodes,type)
def change_node_weight(self,node,weight):
weightold = self.get_node_weight(node)
nodes = node
node = self.get_real_node(node)
for key in self.liste_weight :
if self.liste_weight[key] == weightold :
node_coun = key
Graph.delete_edge(self,node,node_coun)
if Graph.neighbors(self,node_coun) == []:
del self.liste_node_type[node_coun]
del self.liste_weight[node_coun]
Graph.delete_node(self,node_coun)
self.add_node_weight(nodes,weight)
def change_node_func(self,node,func):
funcold = self.get_node_func(node)
nodes = node
node = self.get_real_node(node)
for key in self.liste_func :
if self.liste_func[key] == funcold :
node_coun = key
Graph.delete_edge(self,node,node_coun)
if Graph.neighbors(self,node_coun) == []:
del self.liste_node_type[node_coun]
del self.liste_func[node_coun]
Graph.delete_node(self,node_coun)
self.add_node_func(nodes,func)
def get_liste_node(self):
return self.liste_node_main
def get_nodes(self):
listeretour = []
for node in self.liste_node_main :
liste = {}
liste['number'] = node
liste['type'] = self.get_node_type(node)
liste['name'] = self.get_node_name(node)
liste['weight'] = self.get_node_weight(node)
liste['func'] = self.get_node_func(node)
liste['data'] = self.get_node_data(node)
listeretour.append(liste)
return listeretour
def change_node_data(self,node,data):
dataold = self.get_node_data(node)
for keys in data.keys() :
key = keys
value = dataold[keys]
nodev = self.get_value_node(value)
nodek = self.get_key_node(key)
listen = Graph.neighbors(self, nodev)
for noden in listen :
if self.liste_node_type[noden] == 'link' and self.liste_link[noden] == [node,nodek,nodev] :
Graph.delete_edge(self, nodev, node)
Graph.delete_edge(self, nodev, nodek)
Graph.delete_edge(self, nodev, noden)
Graph.delete_edge(self, nodek, noden)
Graph.delete_node(self, noden)
print "n %s"%Graph.neighbors(self, nodev)
if Graph.neighbors(self, nodev) == [] :
Graph.delete_node(self, nodev)
node = self.get_real_node(node)
self.add_node_data(node,data)
def debug(self):
j = 0
for node in Graph.nodes(self):
j +=1
if self.liste_node_type[node] == 'link' :
print "node : %s type : %s value : %s neighbors : %s"%(node,self.liste_node_type[node],self.liste_link[node],Graph.neighbors(self,node))
else :
if self.liste_node_type[node] == 'value' :
print "node : %s type : %s value : %s neighbors : %s"%(node,self.liste_node_type[node],self.liste_value[node],Graph.neighbors(self,node))
else :
if self.liste_node_type[node] == 'key' :
print "node : %s type : %s value : %s neighbors : %s"%(node,self.liste_node_type[node],self.liste_key[node],Graph.neighbors(self,node))
else :
if self.liste_node_type[node] == 'main' :
print "node : %s type : %s neighbors : %s"%(node,self.liste_node_type[node],Graph.neighbors(self,node))
else:
if self.liste_node_type[node] == 'weight' :
print "node : %s type : %s value : %s neighbors : %s"%(node,self.liste_node_type[node],self.liste_weight[node],Graph.neighbors(self,node))
else :
if self.liste_node_type[node] == 'type' :
print "node : %s type : %s value : %s neighbors : %s"%(node,self.liste_node_type[node],self.liste_type[node],Graph.neighbors(self,node))
else :
if self.liste_node_type[node] == 'name' :
print "node : %s type : %s value : %s neighbors : %s"%(node,self.liste_node_type[node],self.liste_name[node],Graph.neighbors(self,node))
else :
if self.liste_node_type[node] == 'func' :
print "node : %s type : %s value : %s neighbors : %s"%(node,self.liste_node_type[node],self.liste_func[node],Graph.neighbors(self,node))
return j
def get_meta_graphe(self):
liste = {}
for node in Graph.nodes(self):
if self.liste_node_type[node] == 'link' :
liste[node] = {'type' : self.liste_node_type[node],'value' :self.liste_link[node],'neighbors':Graph.neighbors(self,node)}
else :
if self.liste_node_type[node] == 'value' :
liste[node] = {'type' : self.liste_node_type[node],'value' :self.liste_value[node],'neighbors':Graph.neighbors(self,node)}
else :
if self.liste_node_type[node] == 'key' :
liste[node] = {'type' : self.liste_node_type[node],'value' :self.liste_key[node],'neighbors':Graph.neighbors(self,node)}
else :
if self.liste_node_type[node] == 'main' :
liste[node] = {'type' : self.liste_node_type[node],'value' : '','neighbors':Graph.neighbors(self,node)}
else:
if self.liste_node_type[node] == 'weight' :
liste[node] = {'type' : self.liste_node_type[node],'value' :self.liste_weight[node],'neighbors':Graph.neighbors(self,node)}
else :
if self.liste_node_type[node] == 'type' :
liste[node] = {'type' : self.liste_node_type[node],'value' : self.liste_type[node],'neighbors':Graph.neighbors(self,node)}
else :
if self.liste_node_type[node] == 'name' :
liste[node] = {'type' : self.liste_node_type[node],'value' : self.liste_name[node],'neighbors':Graph.neighbors(self,node)}
else :
if self.liste_node_type[node] == 'func' :
liste[node] = {'type' : self.liste_node_type[node],'value' :self.liste_func[node],'neighbors':Graph.neighbors(self,node)}
return liste
if __name__ == "__main__":
G=Graphe(name="I have a name!")
G.add_node(1,"node1",'node',3,"data['data1'] = 2*data['data3']",{'data1':1,'data2':'toto','data3':4})
G.add_node(2,"node2",'nod',4,'self.add_node_data(node,self.get_node_data(node-1))',{'data':0,'data2':'toto','data3':3})
print G.get_node_data(1)
print G.get_node_data(2)
print G.get_nodes()
G.change_node_weight(2, 6)
print G.debug()
print G.get_node_weight(2)
G.exec_node_func(1)
print "result : %s"%G.get_node_result(1)
print G.get_node_data(1)
G.exec_node_func(2)
G.get_node_result(2)
print G.get_node_data(2)
print G.get_meta_graphe()
[/code]
</pre> |
Forum 
