Est-ce la bonne solution

Version imprimable

Bonjour
Voici une programmequi fonctionne parfaitement.Il lit un fichier plat et extrait de cilui-ci les donnée et les affiche. Rien de complexeen soit.
Ce que je cherche a savoir c'est est-ce la bonne méthode ?Est-ce la meilleur solution ?

le code dit lanceur. __init__.py

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
# coding: utf-8  
 
import string
import sys
import datetime
import os
 
from  Explorateur import * 
from  Les_Dates import * 
from  class_all import entete 
 
l_entete = entete()
# Base Application
if __name__ == '__main__':
 
    open_ok =False    
    nom_fichier_path_in = explorateur_window(".//") # Recherche via explorateur
    if os.path.isfile(nom_fichier_path_in):
 
# Ouverture du fichier destination
        nom_fichier_in = os.path.basename(nom_fichier_path_in) # Retourne le nom du fichier
        nom_fichier_path = os.path.dirname(nom_fichier_path_in) # Retourne le répertoire comple
        list_nf = os.path.split(nom_fichier_path_in) # Fractionne le chemin d'acc�s. Retourne un tuple
 
        print(nom_fichier_path_in)
 
        with open(nom_fichier_path_in, 'r') as fichier:
                        # traitement du fichier
                for ligne in fichier:
                    if(ligne[0:3] == "000"):
                        l_entete.ext_entete(ligne)
                        l_entete.__str__()

Explorateur

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
# coding: utf-8  
 
import tkinter 
from tkinter.filedialog import askopenfilename
 
'''Created on 21 aout 2017 
@author: jiji
'''
def explorateur_window(repertoireinit):
    """ Explorateur Windows    """
    #root = tkinter.Tk()
 
    filename = tkinter.filedialog.askopenfilename(
        initialdir=repertoireinit,
        title="Choisir votre fichier",
        filetypes=(
            ("Fichier .txt", "*.txt"),
            ("Tous type de fichier","*.*")
        )
    )
    return filename
pass

Les_Dates

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
# coding: utf-8 
import time
import datetime
 
def cvt_date_aaaammjj(src):
    if(src=="00000000"):
        return None
    elif(src=="000000"):
        return None
    elif(src=="        "):
        return None
    else:
        alpha_aaaa = src[0:4] 
        alpha_mm = src[4:6] 
        alpha_jj = src[6:8] 
        date_format = '%Y/%m/%d'
        my_date=alpha_aaaa+"/"+ alpha_mm + "/"+alpha_jj
        try :
            valid_date = datetime.datetime.strptime(my_date, date_format)
            valid_date_ = datetime.date(valid_date.year, valid_date.month,valid_date.day)
            return valid_date_
        except ValueError:
            print('%s Date invalide !' % my_date)
        return None
pass

class_all

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
# coding: utf-8  
 
 
#lecture du nom des feuilles
 
 
from Les_Dates import  *
 
 
class entete(object): 
    def __init__(self):
        self.Nom_element=None
        self.Type_enregistrement=None
        self.Emetteur_fichier=None
        self.Destinataire_fichier=None
        self.Date_exploitation=None
        self.Code_Norme=None
        self.Version_Norme=None
        self.Filler=None
 
    def ext_entete(self,datalu):
        print(datalu)
        self.Type_enregistrement =  datalu[0:3]         # Alimenté avec 000                                    
        self.Emetteur_fichier =     datalu[3:17]        # N°»                           
        self.Destinataire_fichier = datalu[17:31]       # Fixe »                              
        self.Date_exploitation = str( cvt_date_aammjj ( datalu[31:39]  ) )    # Format AAAAMMDD                                      
        self.Code_Norme =           datalu[39:49]       # (blancs après)               
        self.Version_Norme =        datalu[49:59]       # Exemple : 1.00                                       
        self.Filler =               datalu[59:999]      # Zone libre
    def __str__(self):
        print("Type_enregistrement :" + self.Type_enregistrement + '\n')
        print("Emetteur_fichier :" + self.Emetteur_fichier + '\n')
        print("Destinataire_fichier :" + self.Destinataire_fichier + '\n')
        print("Date_exploitation :" + self.Date_exploitation + '\n')
        print("Code_Norme :" + self.Code_Norme + '\n')
        print("Version_Norme :" + self.Version_Norme + '\n')       
        print("Filler :" + self.Filler + '\n')

des generateurs de code vont crer ceci pour la classe entete , des outils tel que BOUML

Code:

1
2
3
4
5
6
7
8
9
10
class entete_1(object): 
    def __init__(self,Nom_element,Type_enregistrement,Emetteur_fichier,Destinataire_fichier,Date_exploitation,Code_Norme,Version_Norme,Filler):
        self.Nom_element=Nom_element
        self.Type_enregistrement=Type_enregistrement
        self.Emetteur_fichier=Emetteur_fichier
        self.Destinataire_fichier=Destinataire_fichier
        self.Date_exploitation=Date_exploitation
        self.Code_Norme=Code_Norme
        self.Version_Norme=Version_Norme
        self.Filler=Filler

mais pour autant cela ne me semble pas pertinant car il faut ajouter toutes les les informations dans la creation de l'objet .

il faudrait modifier l'appel à la classe

Code:

l_entete = entete_1(None, .... None)

avec autant de zone que de variable
ou mettre

Code:

l_entete = entete_1(ligne[0:3], .... )

avec laconvertion de données et j trouve que cette solution n'est pas top ?

Solution N2 pour la classe entete

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class entete(object): 
    def __init__(self,Nom_element,Type_enregistrement,Emetteur_fichier,Destinataire_fichier,Date_exploitation,Code_Norme,Version_Norme,Filler):
        self.Nom_element=Nom_element
        self.Type_enregistrement=Type_enregistrement
        self.Emetteur_fichier=Emetteur_fichier
        self.Destinataire_fichier=Destinataire_fichier
        self.Date_exploitation=Date_exploitation
        self.Code_Norme=Code_Norme
        self.Version_Norme=Version_Norme
        self.Filler=Filler
 
 
    def ext_entete(self,datalu):
        print(datalu)
        self.Type_enregistrement =  datalu[0:3]         # Alimenté avec 000                                    
        self.Emetteur_fichier =     datalu[3:17]        #                           
        self.Destinataire_fichier = datalu[17:31]       #         »                              
        self.Date_exploitation = str( cvt_date_aammjj ( datalu[31:39]  ) )    # Format AAAAMMDD                                      
        self.Code_Norme =           datalu[39:49]       # T(blancs après)               
        self.Version_Norme =        datalu[49:59]       # Exemple : 1.00                                       
        self.Filler =               datalu[59:999]      # Zone libre
    def __str__(self):
        print("Type_enregistrement :" + self.Type_enregistrement + '\n')
        print("Emetteur_fichier :" + self.Emetteur_fichier + '\n')
        print("Destinataire_fichier :" + self.Destinataire_fichier + '\n')
        print("Date_exploitation :" + self.Date_exploitation + '\n')
        print("Code_Norme :" + self.Code_Norme + '\n')
        print("Version_Norme :" + self.Version_Norme + '\n')       
        print("Filler :" + self.Filler + '\n')

dans __init__2.py

la creation de l'objet entete

Code:

1
2
 
l_entete = entete(None,None,None,None,None,None,None,None)

Mais est-ce plus pertinant?

06/01/2019, 17h17
wiztricks

Salut,

Citation:

Envoyé par dedalios

cela ne me semble pas pertinant car il faut ajouter toutes les les informations dans la creation de l'objet.

__init__ va/doit initialiser les différents attributs de l'objet... histoire d'avoir un objet "fonctionnel" dès sa création. Sinon vous allez devoir noter quelque part que l'objet a bien été initialisé et le tester avant de récupérer les valeurs de ses attributs.

Citation:

Envoyé par dedalios

il faudrait modifier l'appel à la classe

Code:

l_entete = entete_1(None, .... None)

avec autant de zone que de variable
ou mettre

Code:

l_entete = entete_1(ligne[0:3], .... )

avec la convertion de données et j trouve que cette solution n'est pas top ?

Vous pouvez écrire:

Code:

l_entete = entete_1(*convertion(ligne))

où convertion retourne un tuple en cachant les détails de la fabrication des arguments...

- W
07/01/2019, 08h40
dedalios

Citation:

Envoyé par wiztricks

Salut,

__init__ va/doit initialiser les différents attributs de l'objet... histoire d'avoir un objet "fonctionnel" dès sa création. Sinon vous allez devoir noter quelque part que l'objet a bien été initialisé et le tester avant de récupérer les valeurs de ses attributs.

Vous pouvez écrire:

Code:

l_entete = entete_1(*convertion(ligne))

où convertion retourne un tuple en cachant les détails de la fabrication des arguments...

- W

convertion retourne un tuple en cachant les détails de la fabrication des arguments...
donc convertion ce tuple est adapter a toutes type de modalite de convertion j'avous avoir quelqu problème à voir cela.

exemple la zone '0:3' est un char

la zone '10:18' doit etre convertie en type date
la zone '25:26' doit etre entier
la zone '33:40' doit etre flottant exemple 01502 ==>15,02
la zone '40:49' doit etre entier qui doit etre vérifier une clé de cryptage
la zone '55:56' est un char qui support 2 valeur (O/N) si tel n'est pas le cas il doit y avoir un processus d'erreur.

dans ce cas comment pourrait on ecrire ce tuple.

si l'on démiultiple cela par le fait que par defaut un fichier plat de ce type supporte possiblement un nobre conséquent de structure qui sont construit sont la meme forme que la class entete.
j'ai bien du mal a voir comment construire le tuple.

Citation:

Noter quelque part que l'objet a bien été initialisé et le tester avant de récupérer les valeurs de ses attributs. ?
07/01/2019, 09h10
wiztricks
Citation:

Envoyé par dedalios

dans ce cas comment pourrait on ecrire ce tuple.
Code:

1 2 3 4 5 def convertion(ligne): z1 = ... z2 = ... ... return z1, z2, ...
où z1, z2, .... sont le découpage en "zones" de votre ligne.

- W

Donc pour chaque format structurant le fichier plat il faudra avoir une fonction de convertion.

Code:

1
2
3
4
5
6
7
8
9
10
def extraire(datalu):
    print(datalu)
    Type_enregistrement =  datalu[0:3]         # Alimenté avec 000   
    Emetteur_fichier =     datalu[3:17]        #    
    Destinataire_fichier = datalu[17:31]       #      
    Date_exploitation = str( cvt_date_aammjj ( datalu[31:39]  ) )    # Format AAAAMMDD     
    Code_Norme =datalu[39:49]       #    (blancs après)    
    Version_Norme =        datalu[49:59]       # Exemple : 1.00      
    Filler =    datalu[59:999]      # Zone libre      
    return Type_enregistrement ,Emetteur_fichier , Destinataire_fichier, Date_exploitation ,Code_Norme ,Version_Norme ,Filler

Code:

1
2
3
4
5
6
7
def extraire_v2(datalu):
    print(datalu)
    Type_enregistrement =  datalu[0:3]         # Alimenté avec 777
     N_de_Dossier=  =  datalu[3:30]  
     Date_Creation= convertiondate (datalu[30:38])         #AAAMMJJ  ---> il faut creer une fonction de convertion de la zone alpha en date
     Heure_Creation=datalu[38:46]       # hh:mn:ss
    return Type_enregistrement ,N_de_Dossier, Date_Creation, Heure_Creation

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
# coding: utf-8  
 
import string
import sys
import datetime
import os
 
from  Explorateur import * 
from  Les_Dates import * 
from  class_all import *
 
# Base Application
if __name__ == '__main__':
 
    open_ok =False    
    nom_fichier_path_in = explorateur_window(".//") # Recherche via explorateur
    if os.path.isfile(nom_fichier_path_in):
 
# Ouverture du fichier destination
        nom_fichier_in = os.path.basename(nom_fichier_path_in) # Retourne le nom du fichier
        nom_fichier_path = os.path.dirname(nom_fichier_path_in) # Retourne le répertoire comple
        list_nf = os.path.split(nom_fichier_path_in) # Fractionne le chemin d'acc�s. Retourne un tuple
 
        print(nom_fichier_path_in)
 
        with open(nom_fichier_path_in, 'r') as fichier:
                        # traitement du fichier
                for ligne in fichier:
                    if(ligne[0:3] == "000"):
                        l_entete  =   entete(extraire(datalu))
                        l_entete.__str__()
 
                    elif(ligne[0:3] == "777"):
      ...

.... et donc il faut pour chaque format avoir un extracteur .

par contre le trouve plus pertinant la solution ou je creer une classe pour chaque format de fichier que cette solution

je trouve plus interessant d' avoir un objet qui correspond a chque format définie dans le fichier plat.
Avec

une fonction d'affichage.
une fonction qui convertie l'enregistrement lu et renseigne l'objet
et bien d'autre fonction pour le chargement de la base de donné qui peut être utliser... etc.

Salut,

Citation:

Envoyé par dedalios

par contre le trouve plus pertinant la solution ou je creer une classe pour chaque format de fichier que cette solution

De toutes façons, pour découper une ligne en champs pour en faire un tuple vous avez besoin de réaliser 2 opérations.
Après comment les regrouper?
Il y a des tas de solutions et choisir la plus adaptée ne se fera pas selon des critères techniques.

Vous voyez bien que vous avez autant de fonctions à fabriquer que de format de fichiers.
C'est répétitif et source d'erreurs.
Peut être que vous pourriez partir de métadonnées comme:
Code:

1 2 3 4 5 6 7 Type_enregistrement, 0:3, str, 000 Emetteur_fichier, 3:17, str # Destinataire_fichier, 17:31, str # Date_exploitation, 31:39, date (AAAAMMDD) Code_Norme, 39:49,... Version_Norme, 49:59,... Filler, 59:999
Autrement dit un Label à extraire de n:m dans la ligne pour fabriquer un certain type de données avec éventuellement des valeurs par défaut.
note: ce ne serait pas forcément un fichier "texte", un script Python mettant ces données en forme pourrait être plus simple.

Dans ce cas, une seule "classe Extracteur" instanciée avec ses métadonnées ferait le boulot pour un fichier de format donné.

Un machin comme çà s'appelle un ETL pour extract/transform/load.
Vous en avez des commerciaux et vous avez certainement des solutions OpenSource (éventuellement écrites avec Python).
S'informer sur l'état de l'art (ce qui a déjà été fait) pour voir si çà le fait ou s'en inspirer avant de se lancer tête baissée à coder...

- W

08/01/2019, 21h17
dedalios

ETL

J'utilise dejà un ETL de ce cote la pas de problème , je cherche simplement a faire de même avec python pour mon plaisir.