Comment je peux faire une interface graphique pour ce code sur python

import numpy as np
import networkx as nx
import matplotlib.pyplot as plt

class PL:

def __init__(self, A = np.empty([0,0]), b = np.empty([0,0]), c = np.empty([0,0]), minmax = "MAX"):
self.A = A
self.b = b
self.c = c
self.x = [float(0)] * len(c)
self.minmax = minmax
self.printIter = False
self.optimalValue = None
self.transform = False

def addA(self, A):
self.A = A

def addB(self, b):
self.b = b

def addC(self, c):
self.c = c
self.transform = False

def setObj(self, minmax):
if(minmax == "MIN" or minmax == "MAX"):
self.minmax = minmax
else:
print("Objectif invalide.")
self.transform = False

def setPrintIter(self, printIter):
self.printIter = printIter

def printSoln(self):
print("La solution optimal du PL:\n\n X* =", end=" ",sep="")
print(self.x)
print("\n")
print("La cardinalité du transversal minimum :\n\n Z* = ", end=" ",sep="")
print(int(self.optimalValue))
print("\n")
def printTableau(self, tableau):

print("ind \t\t", end = "")
for j in range(0, len(c)):
print("x_" + str(j), end = "\t")
for j in range(0, (len(tableau[0]) - len(c) - 2)):
print("s_" + str(j), end = "\t")

print()
for j in range(0, len(tableau)):
for i in range(0, len(tableau[0])):
if(not np.isnan(tableau[j, i])):
if(i == 0):
print(int(tableau[j, i]), end = "\t")
else:
print(round(tableau[j, i], 2), end = "\t")
else:
print(end = "\t")
print()

def getTableau(self):
# construct starting tableau

if(self.minmax == "MIN" and self.transform == False):
self.c[0:len(c)] = 1 * self.c[0:len(c)]
self.transform = False

t1 = np.array([None, 0])
numVar = len(self.c)
numSlack = len(self.A)

t1 = np.hstack(([None], [0], self.c, [0] * numSlack))

basis = np.array([0] * numSlack)

for i in range(0, len(basis)):
basis[i] = numVar + i

A = self.A

if(not ((numSlack + numVar) == len(self.A[0]))):
B = np.identity(numSlack)
A = np.hstack((self.A, B))

t2 = np.hstack((np.transpose([basis]), np.transpose([self.b]), A))

tableau = np.vstack((t1, t2))

tableau = np.array(tableau, dtype ='float')

return tableau

def optimize(self):

if(self.minmax == "MIN" and self.transform == False):
for i in range(len(self.c)):
self.c[i] = -1 * self.c[i]
transform = False

tableau = self.getTableau()

if(self.printIter == True):
print("Tableau de départ:")
self.printTableau(tableau)

# assume initial basis is not optimal
optimal = False

# keep track of iterations for display
iter = 1

while(True):

if(self.printIter == True):
print("----------------------------------")
print("Itération :", iter)
self.printTableau(tableau)

if(self.minmax == "MAX"):
for profit in tableau[0, 2:]:
if profit > 0:
optimal = False
break
optimal = True
else:
for cost in tableau[0, 2:]:
if cost < 0:
optimal = False
break
optimal = True

# if all directions result in decreased profit or increased cost
if optimal == True:
break

# nth variable enters basis, account for tableau indexing
if (self.minmax == "MAX"):
n = tableau[0, 2:].tolist().index(np.amax(tableau[0, 2:])) + 2
else:
n = tableau[0, 2:].tolist().index(np.amin(tableau[0, 2:])) + 2

# minimum ratio test, rth variable leaves basis
minimum = 99999
r = -1

for i in range(1, len(tableau)):
if(tableau[i, n] > 0):
val = tableau[i, 1]/tableau[i, n]
if val<minimum:
minimum = val
r = i

pivot = tableau[r, n]



# perform row operations
# divide the pivot row with the pivot element
tableau[r, 1:] = tableau[r, 1:] / pivot



# pivot other rows
for i in range(0, len(tableau)):
if i != r:
mult = tableau[i, n] / tableau[r, n]
tableau[i, 1:] = tableau[i, 1:] - mult * tableau[r, 1:]


# new basic variable
tableau[r, 0] = n - 2

iter += 1


if(self.printIter == True):
print("----------------------------------")
print("Le tableau final parvenu en", iter, "itérations")
self.printTableau(tableau)
else:
print('\n\n' + '\033[32m' + ' >>> Résolu! <<<' + '\x1b[0m')

self.x = np.array([0] * len(c), dtype = int)
# save coefficients
for key in range(1, (len(tableau))):
if(tableau[key, 0] < len(c)):

self.x[int(tableau[key, 0])] = tableau[key, 1]

for i in range(0,len(self.x)):
if(self.x[i]==0):
self.x[i]=1
else:
self.x[i]=0



self.optimalValue = len(c) - 1 * tableau[0,1]

a = 0

class b():
global a
a = self.x


model = PL()
A = np.array([ [1,0,1,0],[1,1,0,0],[0,1,0,1],[0,0,1,1] ])
B = A.transpose()
n = len(B)
m = len(B[1])

b=np.ones(n,dtype=int)
c=np.ones(m,dtype=int)
model.addA(B)
model.addB(b)
model.addC(c)
model.setObj("MIN")

C = np.zeros([m,m], dtype = int)

for i in range(0,n):
h =-1
k =-1
for j in range(0,m):
if(B[i][j]==1):
if(h==-1):
h=j
else:
k=j
C[h][k]=1
C[k][h]=1


print("La matrice d'incidence :\n\nM1 =\n", A, "\n")
print("La matrice d'adjacence :\n\nM2 =\n", C, "\n")
print("Le graphe correspondant :\n\nG >>\n")

G=nx.from_numpy_matrix(C)

nx.draw(G,with_labels=1,node_color='c',font_size=12)
plt.show()

print("Le PL correspondant:\n\n(P) >>\n")
objf = "( Min(Z) = "
for i in range(0,m):
objf += "X" + str(i) + " + "
d = len(objf)
y = slice(d-2)
objf = objf[y]
print(objf)
print("|")
for i in range(0,n):
st = "| "
for j in range(0,m):
if(B[i][j]==1):
st += "X" + str(j) + " + "


x = slice(10)
st = st[x]
st += " >= 1"
print(st)
print("|")
print("( xᵢ >= 0, ∀ i ∈ {0,...," + str(m-1) + "}")
model.optimize()
print("\n")

model.printSoln()
print("Le transversal minimum est:\n\n T* = ", end=" ",sep="")
v = len(a)

Tm = "{"
for i in range(0,v):
if(a[i]==1):
Tm += "X" + str(i) + ", "
p = len(Tm)
z = slice(p-2)
Tm = Tm[z]
Tm += "}"
print(Tm)