Code projet BDD

# -*- coding: utf-8 -*-

######################## Importation des bibliothèques ########################

import sqlite3 as sq    # Bibliothèque qui permet de faire des requètes en SQL
import math             # Pour avoir pi
from sys import exit    # On importe la fonction qui va nous permettre de quitter le programme
from json import dumps  # Pour convertir un dictionnaire en chaine de caractères
from datetime import datetime as dt


########################## Définition des fonctions ###########################

# Si on a trouvé aucun materiaux, on ne peut rien traiter. On sort donc du programme
def testQuantite(nbMateriauxTrouve):
  if nbMateriauxTrouve == 0:
    print("\nAucune matière ne correspond à votre recherche")
    toLog("Aucune matière/coussinet ne correspond à la recherche")
    quitter()

# Fonction qui sert principalement au deboggage. Felt it was cute, might delete later.
def affMatierePossible(nb, critere):
  log.write("[" + str(dt.now()) +  "] " + str(nb) + " matériaux correspondent au critère de " + str(critere) + " (")
  for i in range(0, nb):
    log.write(str(Nom[i]) + ", ")
  log.write(")\n")

# Permet de supprimer une matière qui ne convient pas
def delMatiere(position):
  toLog("Aucun coussinet en " + str(Nom[position]) + " ne convient")
  del l[position]
  del Id_Mat[position]
  del Nom[position]
  del P_Adm[position]
  del PV_Adm[position]
  toLog("Matière supprimée")

# Fonction qui gère le choix du coussinet si l'utilisateur décide de ne pas ajouter de critères
def recherche(longMinCouss):

  # Ok ok, alors....
  # On définie d'abords les variables qui vont nous permettre de stocker ce
  # qu'on extrait de la BDD, c'est à dire les dimension du coussinet, son ID,
  # et sa matière. On extrait aussi le coefficient de prix de la matière pour
  # pouvoir calculer le prix ensuite

  Id_couss = []
  Diam_Int = []
  Diam_Ext = []
  Diam_Col = []
  Epais_Col = []
  Longueur = []
  Mat = []
  Coeff_Prix = []

  # Dans le for en dessous, on va traiter les coussinets matière par matière
  for i in Id_Mat:

    # On fait une requête SQL pr extraire la plus petite valeur de l tel que
    # l > lmin pr les coussinets dans la matière concerné.
    if longMinCouss == 0:
      toLog("Récupération de lmin réel pour " + str(Nom[Id_Mat.index(i)]))
      cursor.execute("SELECT MIN(Longueur) FROM Coussinets WHERE Mat = " + str(i) + " AND Diam_Int = " + str(diametre) + " AND Longueur >= " + str(l[Id_Mat.index(i)]))

      # On sort la valeur minimale et on la met dans une variable
      for j in cursor:
        if not None in j:
          longMinCouss = j["MIN(Longueur)"]

    toLog("Lmin réel récupéré : " + str(longMinCouss))

    # Du coup ici on extrait les coussinets qui correspondent à tous les
    # critères déterminés plus tot, tjrs dans la matières concernées
    toLog("Récupération des coussinets compatibles")
    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))

    # On stocke les info dans des listes
    for j in cursor:
      if not None in j:
        Id_couss.append(j["Id_couss"])
        Diam_Int.append(j["Diam_Int"])
        Diam_Ext.append(j["Diam_Ext"])
        Diam_Col.append(j["Diam_Col"])
        Epais_Col.append(j["Epais_Col"])
        Longueur.append(j["Longueur"])
        Mat.append(j["Mat"])
        Coeff_Prix.append(j["Coeff_Prix"])

    toLog("Coussinets compatibles en " + str(Nom[Id_Mat.index(i)]) + " récupérés")



  # Et hop, là on est sortis de la boucle. Ca veut dire qu'on a extrait les
  # informations de tout les coussinets qui conviennent, dans tt les matières
  # adaptés. Maintenant on va calculer leur prix et prendre le moins chère.
  # Le calcul est celui donné dans les document. J'ai séparé le calcul du
  # volume pr plus de clartée.

  toLog("Calcul des prix des coussinets")
  prix = []
  volume = []
  for i in range(0, len(Id_couss)):
    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])))
    prix.append(volume[i]*Coeff_Prix[i]*10**-3)

  toLog("Prix récupérés")

  # Ici on détermine la position du coussinet le moins chère. Si il y en a
  # plusieurs, python prends le premier qu'il trouve. J'aurais pu faire
  # un générateurde nombre aléatoire, mais non. Et je demande pas à
  # l'utilisateur parce qu'il veut laisser faire l'ordinateur
  pos = prix.index(min(prix))

  # Du coup on stocke les info demandé dans un dictionnaire, parce que
  # pourquoi pas (et ça peut faire des points en plus aussi)
  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)}

  # On affiche les résultats de la recherche à l'utilisateur
  print("\n", resultat)

  # On stocke aussi les résultats dans un fichier, parce que j'ai pas de
  # mémoire
  fichier = open('resultat.txt', 'w')
  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)
  fichier.write(string)
  fichier.close()

  quitter()

#fonction qui permet de filtrer les coussinets sur plus de critères
def filtrageManuel():

  filtre = 0
  choix = ""
  val = 0

  while True:

    if filtre != 0 and filtre != 3:
      while choix != "oui" and choix != "non" and choix !="exit":
        print("\nVoulez-vous affiner d'avantage la recherche ?")
        choix = str(input("(oui/non) : "))
        choix = choix.casefold()

    if choix == "oui" or filtre == 0:

      print("\nCritères disponibles pour filtration supplémentaire :")
      if filtre == 0:
        print("\n 1) Matière\n 2) Longueur")
        choix = input("1,2 : ")
      elif filtre == 1:
        print("\n 2) Longueur")
        choix = str(input("Appuyez sur entrer pour continuer, entrez exit pour quitter : "))
      elif filtre == 2:
        print("\n 1) Matière")
        choix = str(input("Appuyez sur entrer pour continuer, entrez exit pour quitter : "))

      if choix == "1" or (choix == "" and filtre == 2):
        print("\nMatières disponible pour filtration :")
        for i in Id_Mat:
          print(" " + str(i) + ") " + str(Nom[Id_Mat.index(i)]))

        while True:
          try:
            matiere = int(input("Entrez le numéro de la matière que vous voulez garder : "))
          except ValueError:
            print("Veuillez entrer un nombre")
          else:
            if matiere in Id_Mat:
              break
            print("Entrez un chiffre de la liste")

        matiere = Id_Mat.index(matiere)

        for i in range(0, len(Id_Mat)):
          if i < matiere:
            delMatiere(0)
          elif i > matiere:
            delMatiere(1)

        filtre += 1

      elif choix == "1" and (filtre == 1 or filtre == 3):
        print("Vous avez déja défini la matière")

      elif choix == "2" or (choix == "" and filtre == 1):

        filtreLongueur = []
        for i in Id_Mat:
          cursor.execute("SELECT Longueur FROM Coussinets WHERE Mat = " + str(i) + " AND Diam_Int = " + str(diametre) + " AND Longueur >= " + str(l[Id_Mat.index(i)]))
          for j in cursor:
            if not None in j:
              if not j["longueur"] in filtreLongueur:
                  filtreLongueur.append(j["Longueur"])

        print("\nVoici les longueurs disponibles à la filtration :")
        for i in range(0, len(filtreLongueur)):
          print(filtreLongueur[i], "\bmm")

        valType = False
        while not valType:
          try:
            val = int(input("Laquelle voulez-vous choisir ? (entrez la valeur) : "))
          except ValueError:
            print("Veuillez entrer une valeur numérique")
          else:
            valType = True
            if not val in filtreLongueur:
              print("Choisisser une valeur dans la liste de celles données")
              valType = False

        filtre =+2

      elif choix == "1 ou 2":
        print("Bruh")
      elif choix=="exit":
        quitter()
      else:
        print("Veuillez entrer 1 ou 2")

    elif choix == "non":
      toLog("Début récupération coussinet suite à filtration supplémentaire")
      break

    else:
      quitter()

  recherche(val)

  quitter()


def toLog(msg):
  log.write("[" + str(dt.now()) + "] " + str(msg) + "\n")

def quitter():
  input("Appuyer sur entrer pour quitter")
  toLog("Fermeture des fichiers et extinction du programme")
  log.close()
  base.close()
  exit(0)



###############################################################################




###############################################################################
################################## Début ######################################
###############################################################################

# On crée un fichier qui permettra de stocker les logs du programme
log = open('fichiersProjet\log.txt', 'w', encoding = "UTF-8")
toLog("Début du programme")

base = sq.connect("fichiersProjet\Coussinets.db")                              # On se connecte à la base de donnée que l'on va utiliser
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)

# On crée un curseur pour parcourir les bases de données
cursor = base.cursor()

# On demande les différentes caractéristiques nécessaire au choix du coussinet.
# 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 )
toLog("Requête critères")
varType = False                                                                # Le variable qui nous permettra de déterminer si le type est bojn ou pas
while not varType:
  try:
    diametre = float(input("Diamètre de l'arbre (mm) : "))                     # On demande le diamètre de l'arbre à l'utilisateur
  except ValueError:
    print("Veuillez entrer un nombre.")                                        # On affiche ce message si l'entrée reçu ne peut pas être convertie en flottant
    toLog("Tentative de passage de valeur non numérique pour diametre")
  else:
    if diametre > 100:                                                         # On check si la valeur du diamètre
      print("Le diamètre entré est trop grand")
      toLog("Diamètre entré > valeur max")
      varType = False
    elif diametre < 0:
      print("Diamètre retenu :", diametre, "\bmm")
      varType = True
      toLog("diametre récupéré")
    else:
      varType = True
      toLog("diametre récupéré")

while varType:
  try:
    frequence = float(input("Fréquence de rotation (tr/min) : "))              # Même chose qu'au dessus
  except ValueError:
    print("Entrez un nombre")
    toLog("Tentative de passage de valeur non numérique pour frequence")
  else:
    varType = False
    toLog("frequence récupéré")

while not varType:
  try:
    charge = float(input("Charge radiale (N) : "))                             # Same
  except ValueError:
    print("Entrez un nombre")
    toLog("Tentative de passage de valeur non numérique pour charge")
  else:
    varType = True
    toLog("charge récupéré")

toLog("Critères récupérés : diamètre = " + str(diametre) + ", vitesse = " + str(frequence) + ", charge = " + str(charge))


##################### Vitesse circonférentielle ###############################

# On calcule la vitesse radiale / circonférentielle
toLog("Calcul vitesse radiale")
vitRad = (math.pi*diametre*frequence)/(60*pow(10,3))
toLog("Vitesse radiale : " + str(vitRad) + " m/s")

# On récupère les info des matériaux qui correspondent au critère de vitesse
toLog("Recherche de materiaux correspondant au critère de vitesse")
cursor.execute("SELECT Id_Mat, Nom, P_Adm, PV_Adm FROM Matériaux WHERE V_Adm > " + str(vitRad))

# Définition des listes qui permettront de stocker le contenu extrait de la base de donnée
Id_Mat = []
Nom = []
P_Adm = []
PV_Adm = []

# Stockage des données récupérées dans les listes
for i in cursor:
  if not None in i:
    Id_Mat.append(i["Id_Mat"])
    Nom.append(i["Nom"])
    P_Adm.append(i["P_Adm"])
    PV_Adm.append(i["PV_Adm"])

# On regarde cb de matière on a trouvé. Si c'est 0, on arrête le programme.
testQuantite(len(Id_Mat))

toLog("Matériaux récupérés")

# Si on peut executer ce qui suit, on a trouve au moins une matière compatible. On les affiche
affMatierePossible(len(Id_Mat), "vitesse circonférencielle")


################## Calcul et comparaison longueur minimale ####################
l = []                                                                         # Liste qui servira a stocker ttes les longueur minimale pr chaque matière
l1 = []                                                                        # Liste qui stockeront les différents résultats des calcul de lmin
l2 = []
rejet = 0                                                                      # Variable qui servira à compter le nombre de matières rejetés

toLog("Calcul lmin")

for i in range(0, len(Id_Mat)):

  l1.append(charge/(P_Adm[i-rejet]*diametre))                                  # Calcul longueur minimale via pression max admissible
  l2.append((math.pi*charge*frequence)/(60*PV_Adm[i-rejet]*pow(10,3)))         # Calcul lmin via produit PV adm

  l.append(max(l1[i-rejet], l2[i-rejet]))                                      #On prend la plus grande valeur des deux qu'on vient de trouver

  toLog("lmin récupéré pour " + str(Nom[i-rejet]) + " : " +  str(l[i-rejet]))

  # On rejete tous les materiaux où l min est superieur à la longueur maximale
  # possible d'un coussinet
  if (l[i-rejet] > 100):                                                       # 100 = longueur maximale d'un coussinet
    delMatiere(i-rejet)
    rejet += 1
    testQuantite(len(Id_Mat)-rejet)

testQuantite(len(Id_Mat))
affMatierePossible(len(Id_Mat), "longueur")


#### Recherche de coussinet en matière compatible avec diamètre compatible ####

Mat = []        #Liste qui nous permettra de stocker les matières des coussinets
matDiff = 0     # Variable qui nous permettra de compter le nombre de matières différentes

# Ttes les petites commande habituelles pr extraire les différentes matières
# avec le diamètre et la longueur qui correspondent aux critères
for i in Id_Mat:
  cursor.execute("SELECT Mat FROM Coussinets WHERE Diam_Int = " + str(diametre) + " AND Longueur >= " + str(l[Id_Mat.index(i)]) + " AND Mat = " + str(i))
  for j in cursor :
    if not None in j :
      Mat.append(j["Mat"])
      matDiff += 1

      # Si on trouve plus de deux coussinets assez long, dans les bonnes
      # matières (très probable), on compare les matières entre elles pr
      # savoir si elles sont différentes
      if len(Mat) > 1:
        if Mat[len(Mat)-1] == Mat[len(Mat)-2]:
          matDiff -=1

# Si y'a aucune matière qui convient, c'est con
testQuantite(matDiff)
toLog(str(matDiff) + " matériaux compatibles avec le critères de diamètre. Comparaison avec les précédents critères")

# Si les matières des filtres précédants sont pas dans celle qui satisfont le
# critère de diamètre, on l'enlève.
for i in Id_Mat:
  if not i in Mat:
    delMatiere(Id_Mat.index(i))

# On regarde si il nous reste des matières compatibles
testQuantite(len(Id_Mat))

affMatierePossible(len(Id_Mat), "diamètre")


## Finalement, on affiche toutes les matières qui correspondent aux critères ##
# C'est pas bien compliqué, normalement y'a pas besoin d'explications. Si y'en
# a besoin, envoyez-moi un fax (je répondrais par fax aussi)

print("\nVoici les matériaux qui correspondent aux critères donnés :")
for i in range(0, len(Id_Mat)):
  print(i, "\b)", Nom[i], "\b, longueur minimale :", l[i], "\bmm")
print("")


# On demande à l'utilisateur s'il veut affiner sa recheche, ou laisser
# l'ordinateur choisir pour lui
# Simple input dans un while qui tourne tant qu'on a pas une des réponses que
# l'on veut. Le casefold sert à tt passer en minuscule. (Je sais pas si
# Exemple == exemple, donc j'ai fait ça). Le exit est uniquement pr moi, ça
# m'évite de faire tourner tt le programme juste pr vérifier un truc au début

choix = ""
while choix != "oui" and choix != "non" and choix !="exit":
  print("Voulez-vous affiner la recherche (Si non, le choix se fera sur le coussinet le moins chère) ?")
  choix = str(input("(oui/non) : "))
  choix = choix.casefold()

toLog("Choix récupéré : " + str(choix))

# On fait ce qu'on doit faire en fonction de la décision de l'utilisateur
if choix == "non":
  toLog("Lancement sélection automatique")
  recherche(0)
elif choix == "oui":
  toLog("Lancement sélection manuelle")
  filtrageManuel()
else:
  quitter()


quitter()


# Todo :
# Faire un plus jolie truc pr la recherche parce que c'est nul (mais au moins ça fonctionne)
# Acquisition critères dans une fonction
# Passer sur une interface graphique