SHARE
TWEET

Code projet BDD

Raiseit May 31st, 2020 (edited) 910 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. # -*- coding: utf-8 -*-
  2.  
  3. ######################## Importation des bibliothèques ########################
  4.  
  5. import sqlite3 as sq    # Bibliothèque qui permet de faire des requètes en SQL
  6. import math             # Pour avoir pi
  7. from sys import exit    # On importe la fonction qui va nous permettre de quitter le programme
  8. from json import dumps  # Pour convertir un dictionnaire en chaine de caractères
  9. from datetime import datetime as dt
  10.  
  11.  
  12. ########################## Définition des fonctions ###########################
  13.  
  14. # Si on a trouvé aucun materiaux, on ne peut rien traiter. On sort donc du programme
  15. def testQuantite(nbMateriauxTrouve):
  16.   if nbMateriauxTrouve == 0:
  17.     print("\nAucune matière ne correspond à votre recherche")
  18.     toLog("Aucune matière/coussinet ne correspond à la recherche")
  19.     quitter()
  20.  
  21. # Fonction qui sert principalement au deboggage. Felt it was cute, might delete later.
  22. def affMatierePossible(nb, critere):
  23.   log.write("[" + str(dt.now()) +  "] " + str(nb) + " matériaux correspondent au critère de " + str(critere) + " (")
  24.   for i in range(0, nb):
  25.     log.write(str(Nom[i]) + ", ")
  26.   log.write(")\n")
  27.  
  28. # Permet de supprimer une matière qui ne convient pas
  29. def delMatiere(position):
  30.   toLog("Aucun coussinet en " + str(Nom[position]) + " ne convient")
  31.   del l[position]
  32.   del Id_Mat[position]
  33.   del Nom[position]
  34.   del P_Adm[position]
  35.   del PV_Adm[position]
  36.   toLog("Matière supprimée")
  37.  
  38. # Fonction qui gère le choix du coussinet si l'utilisateur décide de ne pas ajouter de critères
  39. def recherche(longMinCouss):
  40.  
  41.   # Ok ok, alors....
  42.   # On définie d'abords les variables qui vont nous permettre de stocker ce
  43.   # qu'on extrait de la BDD, c'est à dire les dimension du coussinet, son ID,
  44.   # et sa matière. On extrait aussi le coefficient de prix de la matière pour
  45.   # pouvoir calculer le prix ensuite
  46.  
  47.   Id_couss = []
  48.   Diam_Int = []
  49.   Diam_Ext = []
  50.   Diam_Col = []
  51.   Epais_Col = []
  52.   Longueur = []
  53.   Mat = []
  54.   Coeff_Prix = []
  55.  
  56.   # Dans le for en dessous, on va traiter les coussinets matière par matière
  57.   for i in Id_Mat:
  58.  
  59.     # On fait une requête SQL pr extraire la plus petite valeur de l tel que
  60.     # l > lmin pr les coussinets dans la matière concerné.
  61.     if longMinCouss == 0:
  62.       toLog("Récupération de lmin réel pour " + str(Nom[Id_Mat.index(i)]))
  63.       cursor.execute("SELECT MIN(Longueur) FROM Coussinets WHERE Mat = " + str(i) + " AND Diam_Int = " + str(diametre) + " AND Longueur >= " + str(l[Id_Mat.index(i)]))
  64.  
  65.       # On sort la valeur minimale et on la met dans une variable
  66.       for j in cursor:
  67.         if not None in j:
  68.           longMinCouss = j["MIN(Longueur)"]
  69.  
  70.     toLog("Lmin réel récupéré : " + str(longMinCouss))
  71.  
  72.     # Du coup ici on extrait les coussinets qui correspondent à tous les
  73.     # critères déterminés plus tot, tjrs dans la matières concernées
  74.     toLog("Récupération des coussinets compatibles")
  75.     cursor.execute("SELECT Coussinets.*, Matériaux.Coeff_Prix FROM Coussinets INNER JOIN Matériaux ON Coussinets.Mat = Matériaux.Id_Mat WHERE Longueur = " + str(longMinCouss) + " AND Mat = " + str(i) + " AND Diam_Int = " + str(diametre))
  76.  
  77.     # On stocke les info dans des listes
  78.     for j in cursor:
  79.       if not None in j:
  80.         Id_couss.append(j["Id_couss"])
  81.         Diam_Int.append(j["Diam_Int"])
  82.         Diam_Ext.append(j["Diam_Ext"])
  83.         Diam_Col.append(j["Diam_Col"])
  84.         Epais_Col.append(j["Epais_Col"])
  85.         Longueur.append(j["Longueur"])
  86.         Mat.append(j["Mat"])
  87.         Coeff_Prix.append(j["Coeff_Prix"])
  88.  
  89.     toLog("Coussinets compatibles en " + str(Nom[Id_Mat.index(i)]) + " récupérés")
  90.  
  91.  
  92.  
  93.   # Et hop, là on est sortis de la boucle. Ca veut dire qu'on a extrait les
  94.   # informations de tout les coussinets qui conviennent, dans tt les matières
  95.   # adaptés. Maintenant on va calculer leur prix et prendre le moins chère.
  96.   # Le calcul est celui donné dans les document. J'ai séparé le calcul du
  97.   # volume pr plus de clartée.
  98.  
  99.   toLog("Calcul des prix des coussinets")
  100.   prix = []
  101.   volume = []
  102.   for i in range(0, len(Id_couss)):
  103.     volume.append((math.pi/2)*((Longueur[i]-Epais_Col[i])*(Diam_Ext[i]-Diam_Int[i])+Epais_Col[i]*(Diam_Col[i]-Diam_Int[i])))
  104.     prix.append(volume[i]*Coeff_Prix[i]*10**-3)
  105.  
  106.   toLog("Prix récupérés")
  107.  
  108.   # Ici on détermine la position du coussinet le moins chère. Si il y en a
  109.   # plusieurs, python prends le premier qu'il trouve. J'aurais pu faire
  110.   # un générateurde nombre aléatoire, mais non. Et je demande pas à
  111.   # l'utilisateur parce qu'il veut laisser faire l'ordinateur
  112.   pos = prix.index(min(prix))
  113.  
  114.   # Du coup on stocke les info demandé dans un dictionnaire, parce que
  115.   # pourquoi pas (et ça peut faire des points en plus aussi)
  116.   resultat = {"Diametre interieur":Diam_Int[pos], "Diametre exterieur":Diam_Ext[pos], "Diametre du col":Diam_Col[pos], "Epaisseur du col":Epais_Col[pos], "Longueur":Longueur[pos], "Materiau":Nom[Id_Mat.index(Mat[pos])], "Prix":round(prix[pos], 2)}
  117.  
  118.   # On affiche les résultats de la recherche à l'utilisateur
  119.   print("\n", resultat)
  120.  
  121.   # On stocke aussi les résultats dans un fichier, parce que j'ai pas de
  122.   # mémoire
  123.   fichier = open('resultat.txt', 'w')
  124.   string = dumps(resultat)                                                     # Celle là elle permet de convertir le contenu du dictionnaire en chaine de caractère (parce qu'on peut pas mettre un dictionnaire dans un fichier txt comme ça)
  125.   fichier.write(string)
  126.   fichier.close()
  127.  
  128.   quitter()
  129.  
  130. #fonction qui permet de filtrer les coussinets sur plus de critères
  131. def filtrageManuel():
  132.  
  133.   filtre = 0
  134.   choix = ""
  135.   val = 0
  136.  
  137.   while True:
  138.  
  139.     if filtre != 0 and filtre != 3:
  140.       while choix != "oui" and choix != "non" and choix !="exit":
  141.         print("\nVoulez-vous affiner d'avantage la recherche ?")
  142.         choix = str(input("(oui/non) : "))
  143.         choix = choix.casefold()
  144.  
  145.     if choix == "oui" or filtre == 0:
  146.  
  147.       print("\nCritères disponibles pour filtration supplémentaire :")
  148.       if filtre == 0:
  149.         print("\n 1) Matière\n 2) Longueur")
  150.         choix = input("1,2 : ")
  151.       elif filtre == 1:
  152.         print("\n 2) Longueur")
  153.         choix = str(input("Appuyez sur entrer pour continuer, entrez exit pour quitter : "))
  154.       elif filtre == 2:
  155.         print("\n 1) Matière")
  156.         choix = str(input("Appuyez sur entrer pour continuer, entrez exit pour quitter : "))
  157.  
  158.       if choix == "1" or (choix == "" and filtre == 2):
  159.         print("\nMatières disponible pour filtration :")
  160.         for i in Id_Mat:
  161.           print(" " + str(i) + ") " + str(Nom[Id_Mat.index(i)]))
  162.  
  163.         while True:
  164.           try:
  165.             matiere = int(input("Entrez le numéro de la matière que vous voulez garder : "))
  166.           except ValueError:
  167.             print("Veuillez entrer un nombre")
  168.           else:
  169.             if matiere in Id_Mat:
  170.               break
  171.             print("Entrez un chiffre de la liste")
  172.  
  173.         matiere = Id_Mat.index(matiere)
  174.  
  175.         for i in range(0, len(Id_Mat)):
  176.           if i < matiere:
  177.             delMatiere(0)
  178.           elif i > matiere:
  179.             delMatiere(1)
  180.  
  181.         filtre += 1
  182.  
  183.       elif choix == "1" and (filtre == 1 or filtre == 3):
  184.         print("Vous avez déja défini la matière")
  185.  
  186.       elif choix == "2" or (choix == "" and filtre == 1):
  187.  
  188.         filtreLongueur = []
  189.         for i in Id_Mat:
  190.           cursor.execute("SELECT Longueur FROM Coussinets WHERE Mat = " + str(i) + " AND Diam_Int = " + str(diametre) + " AND Longueur >= " + str(l[Id_Mat.index(i)]))
  191.           for j in cursor:
  192.             if not None in j:
  193.               if not j["longueur"] in filtreLongueur:
  194.                   filtreLongueur.append(j["Longueur"])
  195.  
  196.         print("\nVoici les longueurs disponibles à la filtration :")
  197.         for i in range(0, len(filtreLongueur)):
  198.           print(filtreLongueur[i], "\bmm")
  199.  
  200.         valType = False
  201.         while not valType:
  202.           try:
  203.             val = int(input("Laquelle voulez-vous choisir ? (entrez la valeur) : "))
  204.           except ValueError:
  205.             print("Veuillez entrer une valeur numérique")
  206.           else:
  207.             valType = True
  208.             if not val in filtreLongueur:
  209.               print("Choisisser une valeur dans la liste de celles données")
  210.               valType = False
  211.  
  212.         filtre =+2
  213.  
  214.       elif choix == "1 ou 2":
  215.         print("Bruh")
  216.       elif choix=="exit":
  217.         quitter()
  218.       else:
  219.         print("Veuillez entrer 1 ou 2")
  220.  
  221.     elif choix == "non":
  222.       toLog("Début récupération coussinet suite à filtration supplémentaire")
  223.       break
  224.  
  225.     else:
  226.       quitter()
  227.  
  228.   recherche(val)
  229.  
  230.   quitter()
  231.  
  232.  
  233. def toLog(msg):
  234.   log.write("[" + str(dt.now()) + "] " + str(msg) + "\n")
  235.  
  236. def quitter():
  237.   input("Appuyer sur entrer pour quitter")
  238.   toLog("Fermeture des fichiers et extinction du programme")
  239.   log.close()
  240.   base.close()
  241.   exit(0)
  242.  
  243.  
  244.  
  245. ###############################################################################
  246.  
  247.  
  248.  
  249.  
  250. ###############################################################################
  251. ################################## Début ######################################
  252. ###############################################################################
  253.  
  254. # On crée un fichier qui permettra de stocker les logs du programme
  255. log = open('fichiersProjet\log.txt', 'w', encoding = "UTF-8")
  256. toLog("Début du programme")
  257.  
  258. base = sq.connect("fichiersProjet\Coussinets.db")                              # On se connecte à la base de donnée que l'on va utiliser
  259. base.row_factory = sq.Row                                                      # On met le row factory en sq.row, ce qui nous permet de parcourir les valeurs avec le nom des colonnes (dans le code python)
  260.  
  261. # On crée un curseur pour parcourir les bases de données
  262. cursor = base.cursor()
  263.  
  264. # On demande les différentes caractéristiques nécessaire au choix du coussinet.
  265. # Le try, except permet de gérer l'entrée d'un nombre (En vrai on aurait pu faire ça autrement, mais comme je connais pas les standards j'ai fait comme ça, c'est plus cool :D )
  266. toLog("Requête critères")
  267. varType = False                                                                # Le variable qui nous permettra de déterminer si le type est bojn ou pas
  268. while not varType:
  269.   try:
  270.     diametre = float(input("Diamètre de l'arbre (mm) : "))                     # On demande le diamètre de l'arbre à l'utilisateur
  271.   except ValueError:
  272.     print("Veuillez entrer un nombre.")                                        # On affiche ce message si l'entrée reçu ne peut pas être convertie en flottant
  273.     toLog("Tentative de passage de valeur non numérique pour diametre")
  274.   else:
  275.     if diametre > 100:                                                         # On check si la valeur du diamètre
  276.       print("Le diamètre entré est trop grand")
  277.       toLog("Diamètre entré > valeur max")
  278.       varType = False
  279.     elif diametre < 0:
  280.       print("Diamètre retenu :", diametre, "\bmm")
  281.       varType = True
  282.       toLog("diametre récupéré")
  283.     else:
  284.       varType = True
  285.       toLog("diametre récupéré")
  286.  
  287. while varType:
  288.   try:
  289.     frequence = float(input("Fréquence de rotation (tr/min) : "))              # Même chose qu'au dessus
  290.   except ValueError:
  291.     print("Entrez un nombre")
  292.     toLog("Tentative de passage de valeur non numérique pour frequence")
  293.   else:
  294.     varType = False
  295.     toLog("frequence récupéré")
  296.  
  297. while not varType:
  298.   try:
  299.     charge = float(input("Charge radiale (N) : "))                             # Same
  300.   except ValueError:
  301.     print("Entrez un nombre")
  302.     toLog("Tentative de passage de valeur non numérique pour charge")
  303.   else:
  304.     varType = True
  305.     toLog("charge récupéré")
  306.  
  307. toLog("Critères récupérés : diamètre = " + str(diametre) + ", vitesse = " + str(frequence) + ", charge = " + str(charge))
  308.  
  309.  
  310. ##################### Vitesse circonférentielle ###############################
  311.  
  312. # On calcule la vitesse radiale / circonférentielle
  313. toLog("Calcul vitesse radiale")
  314. vitRad = (math.pi*diametre*frequence)/(60*pow(10,3))
  315. toLog("Vitesse radiale : " + str(vitRad) + " m/s")
  316.  
  317. # On récupère les info des matériaux qui correspondent au critère de vitesse
  318. toLog("Recherche de materiaux correspondant au critère de vitesse")
  319. cursor.execute("SELECT Id_Mat, Nom, P_Adm, PV_Adm FROM Matériaux WHERE V_Adm > " + str(vitRad))
  320.  
  321. # Définition des listes qui permettront de stocker le contenu extrait de la base de donnée
  322. Id_Mat = []
  323. Nom = []
  324. P_Adm = []
  325. PV_Adm = []
  326.  
  327. # Stockage des données récupérées dans les listes
  328. for i in cursor:
  329.   if not None in i:
  330.     Id_Mat.append(i["Id_Mat"])
  331.     Nom.append(i["Nom"])
  332.     P_Adm.append(i["P_Adm"])
  333.     PV_Adm.append(i["PV_Adm"])
  334.  
  335. # On regarde cb de matière on a trouvé. Si c'est 0, on arrête le programme.
  336. testQuantite(len(Id_Mat))
  337.  
  338. toLog("Matériaux récupérés")
  339.  
  340. # Si on peut executer ce qui suit, on a trouve au moins une matière compatible. On les affiche
  341. affMatierePossible(len(Id_Mat), "vitesse circonférencielle")
  342.  
  343.  
  344. ################## Calcul et comparaison longueur minimale ####################
  345. l = []                                                                         # Liste qui servira a stocker ttes les longueur minimale pr chaque matière
  346. l1 = []                                                                        # Liste qui stockeront les différents résultats des calcul de lmin
  347. l2 = []
  348. rejet = 0                                                                      # Variable qui servira à compter le nombre de matières rejetés
  349.  
  350. toLog("Calcul lmin")
  351.  
  352. for i in range(0, len(Id_Mat)):
  353.  
  354.   l1.append(charge/(P_Adm[i-rejet]*diametre))                                  # Calcul longueur minimale via pression max admissible
  355.   l2.append((math.pi*charge*frequence)/(60*PV_Adm[i-rejet]*pow(10,3)))         # Calcul lmin via produit PV adm
  356.  
  357.   l.append(max(l1[i-rejet], l2[i-rejet]))                                      #On prend la plus grande valeur des deux qu'on vient de trouver
  358.  
  359.   toLog("lmin récupéré pour " + str(Nom[i-rejet]) + " : " +  str(l[i-rejet]))
  360.  
  361.   # On rejete tous les materiaux où l min est superieur à la longueur maximale
  362.   # possible d'un coussinet
  363.   if (l[i-rejet] > 100):                                                       # 100 = longueur maximale d'un coussinet
  364.     delMatiere(i-rejet)
  365.     rejet += 1
  366.     testQuantite(len(Id_Mat)-rejet)
  367.  
  368. testQuantite(len(Id_Mat))
  369. affMatierePossible(len(Id_Mat), "longueur")
  370.  
  371.  
  372. #### Recherche de coussinet en matière compatible avec diamètre compatible ####
  373.  
  374. Mat = []        #Liste qui nous permettra de stocker les matières des coussinets
  375. matDiff = 0     # Variable qui nous permettra de compter le nombre de matières différentes
  376.  
  377. # Ttes les petites commande habituelles pr extraire les différentes matières
  378. # avec le diamètre et la longueur qui correspondent aux critères
  379. for i in Id_Mat:
  380.   cursor.execute("SELECT Mat FROM Coussinets WHERE Diam_Int = " + str(diametre) + " AND Longueur >= " + str(l[Id_Mat.index(i)]) + " AND Mat = " + str(i))
  381.   for j in cursor :
  382.     if not None in j :
  383.       Mat.append(j["Mat"])
  384.       matDiff += 1
  385.  
  386.       # Si on trouve plus de deux coussinets assez long, dans les bonnes
  387.       # matières (très probable), on compare les matières entre elles pr
  388.       # savoir si elles sont différentes
  389.       if len(Mat) > 1:
  390.         if Mat[len(Mat)-1] == Mat[len(Mat)-2]:
  391.           matDiff -=1
  392.  
  393. # Si y'a aucune matière qui convient, c'est con
  394. testQuantite(matDiff)
  395. toLog(str(matDiff) + " matériaux compatibles avec le critères de diamètre. Comparaison avec les précédents critères")
  396.  
  397. # Si les matières des filtres précédants sont pas dans celle qui satisfont le
  398. # critère de diamètre, on l'enlève.
  399. for i in Id_Mat:
  400.   if not i in Mat:
  401.     delMatiere(Id_Mat.index(i))
  402.  
  403. # On regarde si il nous reste des matières compatibles
  404. testQuantite(len(Id_Mat))
  405.  
  406. affMatierePossible(len(Id_Mat), "diamètre")
  407.  
  408.  
  409. ## Finalement, on affiche toutes les matières qui correspondent aux critères ##
  410. # C'est pas bien compliqué, normalement y'a pas besoin d'explications. Si y'en
  411. # a besoin, envoyez-moi un fax (je répondrais par fax aussi)
  412.  
  413. print("\nVoici les matériaux qui correspondent aux critères donnés :")
  414. for i in range(0, len(Id_Mat)):
  415.   print(i, "\b)", Nom[i], "\b, longueur minimale :", l[i], "\bmm")
  416. print("")
  417.  
  418.  
  419. # On demande à l'utilisateur s'il veut affiner sa recheche, ou laisser
  420. # l'ordinateur choisir pour lui
  421. # Simple input dans un while qui tourne tant qu'on a pas une des réponses que
  422. # l'on veut. Le casefold sert à tt passer en minuscule. (Je sais pas si
  423. # Exemple == exemple, donc j'ai fait ça). Le exit est uniquement pr moi, ça
  424. # m'évite de faire tourner tt le programme juste pr vérifier un truc au début
  425.  
  426. choix = ""
  427. while choix != "oui" and choix != "non" and choix !="exit":
  428.   print("Voulez-vous affiner la recherche (Si non, le choix se fera sur le coussinet le moins chère) ?")
  429.   choix = str(input("(oui/non) : "))
  430.   choix = choix.casefold()
  431.  
  432. toLog("Choix récupéré : " + str(choix))
  433.  
  434. # On fait ce qu'on doit faire en fonction de la décision de l'utilisateur
  435. if choix == "non":
  436.   toLog("Lancement sélection automatique")
  437.   recherche(0)
  438. elif choix == "oui":
  439.   toLog("Lancement sélection manuelle")
  440.   filtrageManuel()
  441. else:
  442.   quitter()
  443.  
  444.  
  445. quitter()
  446.  
  447.  
  448. # Todo :
  449. # Faire un plus jolie truc pr la recherche parce que c'est nul (mais au moins ça fonctionne)
  450. # Acquisition critères dans une fonction
  451. # Passer sur une interface graphique
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Top