Lecture csv de fichier - Transformation Solution SQLMANY

Version imprimable

Bonjour

Voici le code de Base

il charge la base sqllight depuis un fichier csv

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
 
 
# coding: utf-8  
'''
Created on 23 mars 2018
 
@author: 
'''
import csv
import sqlite3
import sys
import datetime
import csv
import os
import encodings
 
from codecs import open
 
def convertie_date(src):
    if src =='NULL':
        valid_date = None
    else:
        alpha_aaaa = int(src[0:4]) 
        alpha_mm =   int(src[4:6]) 
        alpha_jj =  int(src[6:8]) 
        try :
            valid_date = datetime.date(alpha_aaaa,alpha_mm,alpha_jj) 
            return valid_date
        except ValueError:
            print('%s Date invalide !' % src)
            return None
pass  
 
def EstceNull(src):
    if src =='NULL':
        return  None
    else:
        return src
 
def Estce_nombreNull(src):
    if src =='NULL':
        return  None
    else:
        return int(src)    
 
class ExcelFr(csv.excel):
    # Séparateur de champ
    delimiter = ";"
    # Séparateur de ''chaîne''
    quotechar = None
    # Gestion du séparateur dans les ''chaînes''
    escapechar = None
    doublequote = True
    # Fin de ligne
    lineterminator = "\r\n"
    # Ajout automatique du séparateur de chaîne (pour ''writer'')
    quoting = csv.QUOTE_NONE
    # Ne pas ignorer les espaces entre le délimiteur de chaîne
    # et le texte
    skipinitialspace = False 
    encodage ='utf8'
 
class vls_actes(object):
 
    def __init__(self,liste):
 
        self.ACT_CODE = EstceNull(liste[0]);
        self.ACT_LIBELLE = EstceNull(liste[1]);
 
    def __str__(self):
        resultat = "Act_Code : " +  str(self.ACT_CODE) + "\n"
        resultat += "ACT_LIBELLE: " + str(self.ACT_LIBELLE )  
        return  resultat
 
    def table_sqllite(self,Base):
        creer_table  = """CREATE TABLE vsl_actes(
            ACT_CODE TEXT(255) NOT NULL,
            ACT_LIBELLE TEXT(255),
            CONSTRAINT actes_pk PRIMARY KEY(ACT_CODE)
        );
        """ 
 
        detruire_table  = """DROP TABLE IF EXISTS vsl_actes;"""
 
        curseur =  Base.cursor() # appel au curseur
 
        # supprimer table existante
        if(detruire_table !=""):
            try:
                curseur.execute(detruire_table)  
            except sqlite3.Error as e:
                print("Problème"+ " :" +   e.args[0]  + " sur commande /n"+ detruire_table )
                Base.rollback()
            else:
                Base.commit()    
 
 
        if(creer_table !=""):
            print("creer base")
            try:
                curseur.execute(creer_table)
            except sqlite3.Error as e:
                print("Problème"+ " :" +   e.args[0]  + " sur commande /n"+ creer_table )  
                Base.rollback()
            else:
                Base.commit()    
 
        index_table =""" CREATE INDEX vsl_actes_IDX ON vsl_actes(ACT_LIBELLE);"""       
        if(index_table !=""):
            try:
                curseur.execute(index_table)
 
            except sqlite3.Error as e:
                print("Problème de creation d'index : "  +   e.args[0]  + "/n" )  
                print(index_table)
                Base.rollback()
            else: 
                Base.commit()      
 
 # self.GEL_CODE = self.GEL_CODE[7:12]
        pass
 
    def insertion_sqllite(self,Base):
 
        curseur = Base.cursor() # appel au curseur
        data=[self.ACT_CODE,self.ACT_LIBELLE]
 
        rq = """INSERT OR IGNORE INTO vsl_actes
                    (ACT_CODE, ACT_LIBELLE)
                       VALUES(?, ?);"""
 
        try:
            curseur.execute(rq,data)
 
        except sqlite3.Error as e:
            print("Problème"+ " :" +   e.args[0]  + " sur commande d'insertion /n" )  
            print(rq)
            Base.rollback()
        else: 
            Base.commit()  
 
 
 
 
def actes(nomfichier,Base):
 
    file =open(nomfichier ) 
    i=0 # indeteur de ligne du fichier pour ne pas traiter l'entete 
    #
    # Ouverture du fichier source.
    #
    try:
        #
        # Cr�ation du ''lecteur'' CSV.
        #
        fichier_lu = csv.reader(file, 'excel-fr')
 
        max_long_ACT_CODE = 0
        max_long_ACT_LIBELLE = 0
        for row in fichier_lu:
            i+=1
 
            if(i>1):
                nouvel_acte = vls_actes(row)  
 
                if(i==2): # Suppprsseion de la table pr�c�dente  si besion 
                    # cr�ation de la nouvelle table 
                    nouvel_acte.table_sqllite(Base)
                # insertion de donn�es
                nouvel_acte.insertion_sqllite(Base)
 
                if(max_long_ACT_CODE < len(nouvel_acte.ACT_CODE)):
                     max_long_ACT_CODE = len(nouvel_acte.ACT_CODE)
 
                if(max_long_ACT_LIBELLE < len(nouvel_acte.ACT_LIBELLE)):
                     max_long_ACT_LIBELLE = len(nouvel_acte.ACT_LIBELLE)
 
        #print(max_long_ACT_CODE, end='\n' )
        #print(max_long_ACT_LIBELLE , end='\n')
    except OSError:
            print("Problème d'access au fichier :" + nomfichier)
    finally:
        #
        # Fermeture du fichier source
        #
        file.close()     
 
 
 
if __name__ == '__main__':
    # Enregistre ce dialecte aupr�s du module csv
    encodage ="utf-8"
    LaBase ="acte.db" 
    Base = sqlite3.connect(LaBase)
    csv.register_dialect('excel-fr', ExcelFr())
 
    actes("actes2.csv" , Base)
 
    Base.close()

Voici la solution base sur un concept de reader utilsant la collections /namedtuple sur la base d'une solution proposé par wiztricks

https://www.developpez.net/forums/d1836440/autres-langages/python-zope/general-python/convertion-csv-vers-python/

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
# coding: utf-8  
'''
Created on 23 mars 2018
 
@author: 
'''
import csv
import sqlite3
import sys
import csv
import os
import encodings
from collections import namedtuple
from src.convertie import *
 
 
 
 
class record(namedtuple('record', 'ACT_CODE, ACT_LIBELLE')):
    def __new__(cls, ACT_CODE, ACT_LIBELLE):
        if ACT_CODE == 'NULL':
            ACT_CODE = None
 
        if   ACT_LIBELLE == 'NULL': 
             ACT_LIBELLE = None
 
        return super().__new__(cls, ACT_CODE, ACT_LIBELLE)
    def __str__(self):
        resultat = str(self.ACT_CODE)
        resultat += str(self.ACT_LIBELLE)  
        return  resultat   
 
 
 
 
class Reader:
    def __init__(self, file):
        self._reader = csv.reader(file)  
 
    def get_records(self, count=10):
        records = []
        try:
            for _ in range(count): #injection par groupe de 3 lignes et vérifier les doublons
                row = next(self._reader)
                # on construit les tuples 
                enregistrement = record (row[0] , row[1])
                print(enregistrement)
                # on vérifie les doubles  
                if(enregistrement  not in records):
                    records.append(enregistrement)
        except StopIteration:
            pass
        except:
            raise
        return records
 
 
class Writer:
    def __init__(self, path=':memory:'):
    #def __init__(self, path='mem.db'):    
        cnx = self._cnx = sqlite3.connect(path)
        commandesql = '''drop table if  exists actes;  ''' 
 
        try:
            cnx.execute(commandesql)   
        except sqlite3.Error as e: 
            print("Problème"+ " :" +   e.args[0]  + " sur commande /n"+ commandesql )
            self._cnx.rollback()
        else:
            self._cnx.commit()      
 
 
        commandesql = """CREATE TABLE vsl_actes(
            ACT_CODE TEXT(255),
            ACT_LIBELLE TEXT(255),
            CONSTRAINT actes_pk PRIMARY KEY(ACT_CODE));"""
 
        try:
            cnx.execute(commandesql)   
        except sqlite3.Error as e: 
            print("Problème"+ " :" +   e.args[0]  + " sur commande /n"+ commandesql )
            self._cnx.rollback()
        else:
            self._cnx.commit()            
 
        commandesql = """CREATE INDEX vsl_actes_IDX ON vsl_actes(ACT_LIBELLE);"""      
 
        try:
            cnx.execute(commandesql)  
        except sqlite3.Error as e: 
            print("Problème"+ " :" +   e.args[0]  + " sur commande /n"+ commandesql )
            self._cnx.rollback()
        else:
            self._cnx.commit()        
 
    def writesmany(self, records):
        rq = """INSERT OR IGNORE INTO vsl_actes
        (ACT_CODE, ACT_LIBELLE)
        VALUES(?, ?);"""
        with self._cnx:
            try:
                self._cnx.executemany(rq, records)
            except sqlite3.Error as e:
                print("Problème"+ " :" +   e.args[0]  + " sur commande d'insertion /n" )  
 
                print("\t"  +str(records))
                self._cnx.rollback()
                # dans le cas d'un problème d'injection multipls on repasse à la mono injection au cas par cas
                # et on laisse les mécasnisme de sécurite de la base agir
                self.writemono( records)
            else: 
                self._cnx.commit()
 
    def writemono(self, records):
        rq = """INSERT OR IGNORE INTO vsl_actes
        (ACT_CODE, ACT_LIBELLE)
        VALUES(?, ?);"""
 
        with self._cnx:
            for enregistrement in records:
                try:
                    self._cnx.execute(rq, enregistrement)
                except sqlite3.Error as e:
                    print("Problème"+ " :" +   e.args[0]  + " sur commande d'insertion /n" )  
 
                    print("\t"  +str(enregistrement))
                    self._cnx.rollback()
                else: 
                    self._cnx.commit()
 
    def dump(self):
        with self._cnx:
            for row in self._cnx.execute('select * from vsl_actes'):
                print (row)
 
 
def load(reader, writer):
    while 1:
        records = reader.get_records()
        print(records)
        if not records:
            break
        writer.writesmany(records)
 
 
if __name__ == '__main__':
 
    csv.register_dialect('excel-fr', ExcelFr())
    writer = Writer()
    with open('actes.csv' ,'r') as file:
        load(Reader(file), writer)
    writer.dump()

Mon problème est le chargement du fichier

enregistrement = record (row[0] , row[1])
IndexError: list index out of range

12/04/2018, 08h29
wiztricks
Citation:

Envoyé par dedalios

Mon problème est le chargement du fichier
enregistrement = record (row[0] , row[1])
IndexError: list index out of range

Le CSV reader découpe la ligne suivant le délimiteur sans garantir le nombre de colonne: çà ce retourne ce qu'il trouve. Donc si le fichier CSV n'est pas "bien formé", çà pourra retourner une liste vide ou une liste avec n-éléments.
Ce qui est facile à voir en quelques lignes:
Code:

1 2 3 4 5 6 7 8 9 10 >>> from io import StringIO >>> import csv >>> reader = csv.reader(StringIO(lines), delimiter=' ') >>> next(reader) ['1', '2', '3'] >>> next(reader) [] >>> next(reader) ['a', 'b'] >>>
Et si le fichier est "bon", c'est que vous n'avez pas passé le bon "delimiter" au Reader pour qu'il puisse le découper correctement (ce qui devrait se "voir" avec un "print" des enregistrements récupérés).

- W

Il manque dans les codes précédemment déposé ce modules

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
# coding: utf-8  
'''
Created on 23 mars 2018
 
 
'''
import csv
from datetime import datetime
from datetime import date
 
def convertie_date(src):
    if src =='NULL':
        valid_date = None
    else:
        alpha_aaaa = int(src[0:4]) 
        alpha_mm =   int(src[4:6]) 
        alpha_jj =  int(src[6:8]) 
        try :
            valid_date = date(alpha_aaaa,alpha_mm,alpha_jj) 
            return valid_date
        except ValueError:
            print('%s Date invalide !' % src)
            return None
pass  
 
def EstceNull(src):
    if src =='NULL':
        return  None
    else:
        return src
 
 
def Estce_nombreNull(src):
    if src =='NULL':
        return  None
    else:
        return int(src)    
 
 
class ExcelFr(csv.excel):
    # Séparateur de champ
    delimiter = ";"
    # Séparateur de ''chaîne''
    quotechar = None
    # Gestion du séparateur dans les ''chaînes''
    escapechar = None
    doublequote = True
    # Fin de ligne
    lineterminator = "\r\n"
    # Ajout automatique du séparateur de chaîne (pour ''writer'')
    quoting = csv.QUOTE_NONE
    # Ne pas ignorer les espaces entre le délimiteur de chaîne
    # et le texte
    skipinitialspace = False 
    encodage ='utf8'

la définition de la structure de fichier csv est donnée par cette ligne de commande

Code:

csv.register_dialect('excel-fr', ExcelFr())

La structure du fichier csv est identique dans les 2 programmes.
et conforme à la description.

La classe Reader ne contient une erreur il manque l'utilisation de l'appel à la classs ExcelFr(csv.excel)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Reader:
    def __init__(self, file):
  #Code en erreur      self._reader = csv.reader(file )  
        self._reader = csv.reader(file, 'excel-fr')  

    def get_records(self, count=10):
        records = []
        try:
            for _ in range(count): #injection par groupe de 3 lignes et vérifier les doublons
                row = next(self._reader)
                # on construit les tuples 
                enregistrement = record (row[0] , row[1])
                print(enregistrement)
                # on vérifie les doubles  
                if(enregistrement  not in records):
                    records.append(enregistrement)
        except StopIteration:
            pass
        except:
            raise
        return records

Par contre il me faut trouver la solution de l'encodage UTF8
voici le code corrigé

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
# coding: utf-8  
'''
Created on 23 mars 2018
 
@author: 
'''
import csv
import sqlite3
import sys
import csv
import os
import encodings
from collections import namedtuple
from src.convertie import *
 
 
class record(namedtuple('record', 'ACT_CODE, ACT_LIBELLE')):
    def __new__(cls, ACT_CODE, ACT_LIBELLE):
        if ACT_CODE == 'NULL':
            ACT_CODE = None
 
        if   ACT_LIBELLE == 'NULL': 
             ACT_LIBELLE = None
 
        return super().__new__(cls, ACT_CODE, ACT_LIBELLE)
    def __str__(self):
        resultat = str(self.ACT_CODE)
        resultat += str(self.ACT_LIBELLE)  
        return  resultat   
 
 
 
class Reader:
    def __init__(self, file):
        self._reader = csv.reader(file, 'excel-fr')  
 
    def get_records(self, count=10):
        records = []
        try:
            for _ in range(count): #injection par groupe de 3 lignes et vérifier les doublons
                row = next(self._reader)
                # on construit les tuples 
                enregistrement = record (row[0] , row[1])
                print(enregistrement)
                # on vérifie les doubles  
                if(enregistrement  not in records):
                    records.append(enregistrement)
        except StopIteration:
            pass
        except:
            raise
        return records
 
 
class Writer:
    def __init__(self, path):
    #def __init__(self, path='mem.db'):    
        cnx = self._cnx = sqlite3.connect(path)
        commandesql = '''drop table if  exists vsl_actes;  ''' 
 
        try:
            cnx.execute(commandesql)   
        except sqlite3.Error as e: 
            print("Problème"+ " :" +   e.args[0]  + " sur commande /n"+ commandesql )
            self._cnx.rollback()
        else:
            self._cnx.commit()      
 
        commandesql = """CREATE TABLE vsl_actes(
            ACT_CODE TEXT(255),
            ACT_LIBELLE TEXT(255),
            CONSTRAINT actes_pk PRIMARY KEY(ACT_CODE));"""
 
        try:
            cnx.execute(commandesql)   
        except sqlite3.Error as e: 
            print("Problème"+ " :" +   e.args[0]  + " sur commande /n"+ commandesql )
            self._cnx.rollback()
        else:
            self._cnx.commit()            
 
        commandesql = """CREATE INDEX vsl_actes_IDX ON vsl_actes(ACT_LIBELLE);"""      
 
        try:
            cnx.execute(commandesql)  
        except sqlite3.Error as e: 
            print("Problème"+ " :" +   e.args[0]  + " sur commande /n"+ commandesql )
            self._cnx.rollback()
        else:
            self._cnx.commit()        
 
    def writesmany(self, records):
        rq = """INSERT OR IGNORE INTO vsl_actes
        (ACT_CODE, ACT_LIBELLE)
        VALUES(?, ?);"""
        with self._cnx:
            try:
                self._cnx.executemany(rq, records)
            except sqlite3.Error as e:
                print("Problème"+ " :" +   e.args[0]  + " sur commande d'insertion /n" )  
 
                print("\t"  +str(records))
                self._cnx.rollback()
                # dans le cas d'un problème d'injection multipls on repasse à la mono injection au cas par cas
                # et on laisse les mécasnisme de sécurite de la base agir
                self.writemono( records)
            else: 
                self._cnx.commit()
 
    def writemono(self, records):
        rq = """INSERT OR IGNORE INTO vsl_actes
        (ACT_CODE, ACT_LIBELLE)
        VALUES(?, ?);"""
 
        with self._cnx:
            for enregistrement in records:
                try:
                    self._cnx.execute(rq, enregistrement)
                except sqlite3.Error as e:
                    print("Problème"+ " :" +   e.args[0]  + " sur commande d'insertion /n" )  
 
                    print("\t"  +str(enregistrement))
                    self._cnx.rollback()
                else: 
                    self._cnx.commit()
 
    def dump(self):
        with self._cnx:
            for row in self._cnx.execute('select * from vsl_actes'):
                print (row)
 
 
def load(reader, writer):
    while 1:
        records = reader.get_records()
        #print(records)
        if not records:
            break
        writer.writesmany(records)
 
 
if __name__ == '__main__':
    encodage ="utf-8"
    csv.register_dialect('excel-fr', ExcelFr())
    writer = Writer("Actes2.db")
    with open('actes2.csv' ,'r') as file:
        load(Reader(file), writer)
    writer.dump()

la classe de définition pour csv

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
class ExcelFr(csv.excel):
    # Séparateur de champ
    delimiter = ";"
    # Séparateur de ''chaîne''
    quotechar = None
    # Gestion du séparateur dans les ''chaînes''
    escapechar = None
    doublequote = True
    # Fin de ligne
    lineterminator = "\r\n"
    # Ajout automatique du séparateur de chaîne (pour ''writer'')
    quoting = csv.QUOTE_NONE
    # Ne pas ignorer les espaces entre le délimiteur de chaîne
    # et le texte
    skipinitialspace = False 
    encodage ='utf8'

le fichier csv est bien définie comme encodé en UTF8 mais étrangement les données générer lors du traitement ne le sont pas.
on retrouve ceci "rÃ©els" que j'ai pu corrigé dans la version N°1 avec l'ajoute de encodage ='utf8' dans csv

Citation:

Envoyé par dedalios

le fichier csv est bien définie comme encodé en UTF8 mais étrangement les données générer lors du traitement ne le sont pas.
on retrouve ceci "rÃ©els" que j'ai pu corrigé dans la version N°1 avec l'ajoute de encodage ='utf8' dans csv

Outre qu'"encodage" ne sonne pas très anglais, si c'était comme çà qu'il fallait s'y prendre, la documentation sur les Dialect en parlerait.
De plus en récupérant "rÃ©els", l'expérience dit que Ã© est une séquence UTF-8 (un caractères) lue avec un décodage latin-1 (ou n'importe quel encodage qui considère que un byte = un caractère).

Ceci dit, vous voyez que c'est un peu le bazard côté Reader. Donc il en fait trop ou pas assez mais assez mal pour que vous y perdiez votre latin. Dans ce cas là, ce que je fais souvent c'est redécouper rôles et responsabilités. A la base, ce Reader ne fait que mettre en liste des tuples qu'il tire d'un iterable pour fabriquer des "records".
Si on le réduit à çà, çà donnerait:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 class Packer: def __init__(self, iterable, factory): self._iterable = iterable self._factory = factory def get_records(self, count=2): done = False while not done: records = [] for _ in range(count): try: row = next(self._iterable) except StopIteration: done = True break except: raise records.append(self._factory(row)) yield records raise StopIteration
nota: Packer çà lui va mieux comme nom, non?

Après c'est le problème de l'appelant d'ouvrir le fichier avec le bon encoding, de le passer à un csv.reader ou à autre chose (l'iterable) et de lui passer la bonne machine pour fabriquer des tuple à partir de ce que remonte l'itérable... i.e.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 if __name__ == '__main__': from collections import namedtuple from io import StringIO import csv class record(namedtuple('record', 'a b')): def __new__(cls, row): return super().__new__(cls, *row) data = ('1 aaa\n' '2 bbb\n' '3 ccc\n' '4 ddd\n' '5 ddd\n') reader = csv.reader(StringIO(data), delimiter=' ') packer = Packer(reader, record) i = 1 for records in packer.get_records(): print(i, records) i += 1
Et pour l'occasion, j'ai modifié le traitement de la fin.
nota, et çà permet de lui donner à manger des fichiers plats sans le changer (le boulot se fera ailleurs).

- W

Citation:
Envoyé par wiztricks
Outre qu'"encodage" ne sonne pas très anglais, si c'était comme çà qu'il fallait s'y prendre, la documentation sur les Dialect en parlerait.
De plus en récupérant "rÃ©els", l'expérience dit que Ã© est une séquence UTF-8 (un caractères) lue avec un décodage latin-1 (ou n'importe quel encodage qui considère que un byte = un caractère).

Ceci dit, vous voyez que c'est un peu le bazard côté Reader. Donc il en fait trop ou pas assez mais assez mal pour que vous y perdiez votre latin. Dans ce cas là, ce que je fais souvent c'est redécouper rôles et responsabilités. A la base, ce Reader ne fait que mettre en liste des tuples qu'il tire d'un iterable pour fabriquer des "records".
Si on le réduit à çà, çà donnerait:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 class Packer: def __init__(self, iterable, factory): self._iterable = iterable self._factory = factory def get_records(self, count=2): done = False while not done: records = [] for _ in range(count): try: row = next(self._iterable) except StopIteration: done = True break except: raise records.append(self._factory(row)) yield records raise StopIteration
nota: Packer çà lui va mieux comme nom, non?

Après c'est le problème de l'appelant d'ouvrir le fichier avec le bon encoding, de le passer à un csv.reader ou à autre chose (l'iterable) et de lui passer la bonne machine pour fabriquer des tuple à partir de ce que remonte l'itérable... i.e.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 if __name__ == '__main__': from collections import namedtuple from io import StringIO import csv class record(namedtuple('record', 'a b')): def __new__(cls, row): return super().__new__(cls, *row) data = ('1 aaa\n' '2 bbb\n' '3 ccc\n' '4 ddd\n' '5 ddd\n') reader = csv.reader(StringIO(data), delimiter=' ') packer = Packer(reader, record) i = 1 for records in packer.get_records(): print(i, records) i += 1
Et pour l'occasion, j'ai modifié le traitement de la fin.
nota, et çà permet de lui donner à manger des fichiers plats sans le changer (le boulot se fera ailleurs).

- W
Pour ce qui concerne le problème UTF-8
effectivement le paramètre "encoding" n'est pas porter par la définition du "Dialect" définissant le fichier csv mais plutôt un paramètre a ajouter sur l'ouverture du fichier

Code:

with open('actes2.csv' ,'r' ) as file:

doit être remplacer par ceci

Code:

with open('actes2.csv' ,'r' , encoding='utf-8') as file:

Je me suis laisse abusé par les exemples présent sur une documentation a savoir
documentation

ou 2 exemples qui se suive, lu trop rapidement peuvent être trompeur
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 # coding: utf-8 import csv with open('actes2.csv', encoding='utf-8') as f: reader = csv.reader(f) for row in reader: print(row) with open('actes2.csv', newline='') as f: reader = csv.reader(f, delimiter=';', quoting=csv.QUOTE_NONE) for row in reader: print(row)

12/04/2018, 13h52
wiztricks

Citation:

Envoyé par dedalios

Je me suis laisse abusé par les exemples présent sur une documentation a savoir documentation

Certes mais lorsqu'une fonctionnalité ne fonctionne pas comme on l'a compris, il faut essayer de relire la documentation histoire de voir si on utilise la chose correctement: c'est, hélas, les déconvenues de tout programmeur que de réaliser qu'il a lu trop vite ou de travers.

Citation:

Envoyé par dedalios

Pour ce qui concerne le problème UTF-8
effectivement le paramètre "encoding" n'est pas porter par la définition du "Dialect" définissant le fichier csv mais plutôt un paramètre a ajouter sur l'ouverture du fichier

Code:

with open('actes2.csv' ,'r' ) as file:

doit être remplacer par ceci

Code:

with open('actes2.csv' ,'r' , encoding='utf-8') as file:

Un fichier est ouvert "r" par défaut. Donc, on peut s'en passer.
Pour newline='', la documentation dit:

Citation:

csv.reader(csvfile, dialect='excel', **fmtparams)

Return a reader object which will iterate over lines in the given csvfile. csvfile can be any object which supports the iterator protocol and returns a string each time its __next__() method is called — file objects and list objects are both suitable. If csvfile is a file object, it should be opened with newline=''

.
Et plus loin:

Citation:

Note

The reader is hard-coded to recognise either '\r' or '\n' as end-of-line, and ignores lineterminator. This behavior may change in the future.

Dans une version future, l'oubli pourrait causer problème même si aujourd'hui çà ne sert que côté Writer ou le Dialect précise à quoi ressemble la fin de ligne et si c'est lui qui s'en charge, il faut bien inhiber sa gestion côté file object.

- W

Ma solution

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
# coding: utf-8  
'''
Created on 23 mars 2018
 
@author: 
'''
import csv
import sqlite3
import sys
import csv
import os
import encodings
from collections import namedtuple
from src.convertie import *
 
 
class record(namedtuple('record', 'ACT_CODE, ACT_LIBELLE')):
    def __new__(cls, row):
        if row[0] == 'NULL':
            row[0] = None
        if   row[1] == 'NULL': 
             row[1] = None
        return super().__new__(cls, *row)
 
class Writer:
    def __init__(self, path):
    #def __init__(self, path='mem.db'):    
        cnx = self._cnx = sqlite3.connect(path)
        commandesql = '''drop table if  exists vsl_actes;  ''' 
 
        try:
            cnx.execute(commandesql)   
        except sqlite3.Error as e: 
            print("Problème"+ " :" +   e.args[0]  + " sur commande /n"+ commandesql )
            self._cnx.rollback()
        else:
            self._cnx.commit()      
 
        commandesql = """CREATE TABLE vsl_actes(
            ACT_CODE TEXT(255),
            ACT_LIBELLE TEXT(255),
            CONSTRAINT actes_pk PRIMARY KEY(ACT_CODE));"""
 
        try:
            cnx.execute(commandesql)   
        except sqlite3.Error as e: 
            print("Problème"+ " :" +   e.args[0]  + " sur commande /n"+ commandesql )
            self._cnx.rollback()
        else:
            self._cnx.commit()            
 
        commandesql = """CREATE INDEX vsl_actes_IDX ON vsl_actes(ACT_LIBELLE);"""      
 
        try:
            cnx.execute(commandesql)  
        except sqlite3.Error as e: 
            print("Problème"+ " :" +   e.args[0]  + " sur commande /n"+ commandesql )
            self._cnx.rollback()
        else:
            self._cnx.commit()        
 
    def writesmany(self, records):
        rq = """INSERT OR IGNORE INTO vsl_actes
        (ACT_CODE, ACT_LIBELLE)
        VALUES(?, ?);"""
        with self._cnx:
            try:
                self._cnx.executemany(rq, records)
            except sqlite3.Error as e:
                print("Problème"+ " :" +   e.args[0]  + " sur commande d'insertion /n" )  
 
                print("\t"  +str(records))
                self._cnx.rollback()
                # dans le cas d'un problème d'injection multipls on repasse à la mono injection au cas par cas
                # et on laisse les mécasnisme de sécurite de la base agir
                self.writemono( records)
            else: 
                self._cnx.commit()
 
    def writemono(self, records):
        rq = """INSERT OR IGNORE INTO vsl_actes
        (ACT_CODE, ACT_LIBELLE)
        VALUES(?, ?);"""
 
        with self._cnx:
            for enregistrement in records:
                try:
                    self._cnx.execute(rq, enregistrement)
                except sqlite3.Error as e:
                    print("Problème"+ " :" +   e.args[0]  + " sur commande d'insertion /n" )  
 
                    print("\t"  +str(enregistrement))
                    self._cnx.rollback()
                else: 
                    self._cnx.commit()
 
    def dump(self):
        with self._cnx:
            for row in self._cnx.execute('select * from vsl_actes'):
                print (row)
 
 
if __name__ == '__main__':
    encodage ="utf-8"
    csv.register_dialect('excel-fr', ExcelFr())
    writer = Writer("Actes3.db")
    with open('actes2.csv'   , encoding='utf-8') as file:
        reader = csv.reader(file,'excel-fr')
        reader.__next__() # bypass l'entete du fichier
        packer = Packer(reader, record)
        i = 1
 
        for records in packer.get_records():
            writer.writesmany(records)
            #print(i, records)
            i += 1  
 
    #writer.dump()

Le module convertie

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
# coding: utf-8  
'''
Created on 23 mars 2018
 
@author: 
'''
import csv
from datetime import datetime
from datetime import date
 
def convertie_date(src):
    if src =='NULL':
        valid_date = None
    else:
        alpha_aaaa = int(src[0:4]) 
        alpha_mm =   int(src[4:6]) 
        alpha_jj =  int(src[6:8]) 
        try :
            valid_date = date(alpha_aaaa,alpha_mm,alpha_jj) 
            return valid_date
        except ValueError:
            print('%s Date invalide !' % src)
            return None
pass  
 
def EstceNull(src):
    if src =='NULL':
        return  None
    else:
        return src
 
 
def Estce_nombreNull(src):
    if src =='NULL':
        return  None
    else:
        return int(src)    
 
 
class ExcelFr(csv.excel):
    # Séparateur de champ
    delimiter = ";"
    # Séparateur de ''chaîne''
    quotechar = None
    # Gestion du séparateur dans les ''chaînes''
    escapechar = None
    doublequote = True
    # Fin de ligne
    lineterminator = "\r\n"
    # Ajout automatique du séparateur de chaîne (pour ''writer'') 
    # Note La classe reader est codée en dur pour reconnaître '\r' et '\n' comme marqueurs de fin de ligne, et ignorer lineterminator. 
    # Ce comportement pourrait changer dans le futur  donc par defaut je garde cette info
    quoting = csv.QUOTE_NONE
    # Ne pas ignorer les espaces entre le délimiteur de chaîne
    # et le texte
    skipinitialspace = False 
 
 
 
 
class Packer:
    def __init__(self, iterable, factory):
        self._iterable = iterable
        self._factory = factory
 
    def get_records(self, count=5):
        done = False
        while not done:
            records = []
            for _ in range(count):
                try:
                    row = next(self._iterable)
                except StopIteration:
                    done = True
                    break
                except:
                    raise
                enregistrement = self._factory(row)
                if enregistrement not in records:
                    records.append(self._factory(row))
            yield records
        raise StopIteration

Salut,

Expliquez moi à quoi bien peut servir cette verrue, ligne 78:

Code:

1
2
3
                enregistrement = self._factory(row)
                if enregistrement not in records:
                    records.append(self._factory(row))

- W

12/04/2018, 17h49
dedalios
Citation:
Envoyé par wiztricks

Salut,

Expliquez moi à quoi bien peut servir cette verrue, ligne 78:

Code:

1 2 3 enregistrement = self._factory(row) if enregistrement not in records: records.append(self._factory(row))

- W
A réduire le chargement des tuples en supprimant les enregistrements potentiellement en doubles dans le fichier
Ceci permettant de réduire le nombre de tuple en mémoire réinjecté en plus des mécanisme de sécurité d'insertion sur la base de donnée

Citation:

Envoyé par dedalios

A réduire le chargement des tuples en supprimant les enregistrements potentiellement en doubles dans le fichier

Oui mais çà ne le fait pas: records ne contient jamais tous les enregistrements du fichier (et encore moins ceux qui sont déjà dans la table).

Même remarque concernant:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 def writesmany(self, records): rq = """INSERT OR IGNORE INTO vsl_actes (ACT_CODE, ACT_LIBELLE) VALUES(?, ?);""" with self._cnx: try: self._cnx.executemany(rq, records) except sqlite3.Error as e: print("Problème"+ " :" + e.args[0] + " sur commande d'insertion /n" ) print("\t" +str(records)) self._cnx.rollback() # dans le cas d'un problème d'injection multipls on repasse à la mono injection au cas par cas # et on laisse les mécasnisme de sécurite de la base agir self.writemono( records) else: self._cnx.commit()
"INSERT OR IGNORE" gère déjà les doublons, si çà remonte une erreur ce n'est pas à cause de cà mais pour des erreurs qui n'ont pas été prévues. Et si vous n'avez pas prévu, c'est que vous ignorez, à fortiori, la reprise d'erreur à appliquer.

- W

extrait de code base sur les versions de code note précédement

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
class record(namedtuple('record', 'PDT_CODE,BON_CODE ,PBO_DATE_DEBUT ,PBO_DATE_FIN ')):
    def __new__(cls, row):
        if row[0] == 'NULL':
            row[0] = None
        #else:
            #row[0] =  valeur[7:]   
        if row[1] == 'NULL':
            row[1] = convertie_date(row[1])
 
        if( row[2] == 'NULL'):
            row[2] = None
        else:
            row[2] = convertie_date(row[2])
 
        if( row[3] == 'NULL'):
            row[3] = None
        else:
            row[3] = convertie_date(row[3])
 
        return super().__new__(cls, *row)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
rq     """INSERT OR IGNORE INTO vsl_p
        (PDT_CODE, BON_CODE, PBO_DATE_DEBUT, PBO_DATE_FIN)
        VALUES('', '', '', '');"""
 
             with self._cnx:
            for enregistrement in records:
                try:
                    self._cnx.execute(rq, enregistrement)
                except sqlite3.Error as e:
                    print('----')
                    print(enregistrement)
                    print("Problème"+ " :" +   e.args[0]  + " sur commande d'insertion /n" )  
 
                    print("\t"  +str(enregistrement))
                    self._cnx.rollback()
                else: 
                    self._cnx.commit()

message d'erreur de l'insertion

----
record(PDT_CODE='aa', BON_CODE='bb', PBO_DATE_DEBUT=datetime.date(2016, 1, 1), PBO_DATE_FIN=None)
Problème :Incorrect number of bindings supplied. The current statement uses 0, and there are 4 supplied. sur commande d'insertion /n
record(PDT_CODE='aa', BON_CODE='bb', PBO_DATE_DEBUT=datetime.date(2016, 1, 1), PBO_DATE_FIN=None)

Pourquoi cette erreur pourrais elle ce produire.

Particularité de la table

Code:

1
2
3
4
5
6
7
8
9
 
            CREATE TABLE vsl_p(
            PDT_CODE TEXT(255),
            BON_CODE TEXT(255),
            PBO_DATE_DEBUT TEXT(10),
            PBO_DATE_FIN TEXT(10) ,
            CONSTRAINT vsl_produits_vs_bonifications_pk PRIMARY KEY(PDT_CODE,BON_CODE,PBO_DATE_DEBUT),
            FOREIGN KEY(PDT_CODE) REFERENCES vsl_PDT_CODE (PDT_CODE),
            FOREIGN KEY(BON_CODE) REFERENCES vsl_BON_CODE (BON_CODE)

les 2 tables vsl_PDT_CODE et vsl_BON_CODE existent et sont chargées

13/04/2018, 19h42
wiztricks

Citation:

Envoyé par dedalios

Problème :Incorrect number of bindings supplied. The current statement uses 0, and there are 4 supplied. sur commande d'insertion /n
record(PDT_CODE='aa', BON_CODE='bb', PBO_DATE_DEBUT=datetime.date(2016, 1, 1), PBO_DATE_FIN=None)

Le message d'erreur est pourtant clair... :ptdr: et le problème n'a rien à voir avec le sujet de cette discussion.

- W
14/04/2018, 11h44
dedalios
Citation:

Envoyé par wiztricks

Le message d'erreur est pourtant clair... :ptdr: et le problème n'a rien à voir avec le sujet de cette discussion.

- W

c'est un point de vue

Comment le problème est en relation avec le même code que ceux présente dans cette note avec un simple datation du nombre de champ du tuple, il me semble logique de le poste ici.

Pour en revenir au message ?

J'ai un tupe (ou une liste tuple) contenant 4 informations

record(PDT_CODE='aa', BON_CODE='bb', PBO_DATE_DEBUT=datetime.date(2016, 1, 1), PBO_DATE_FIN=None)

une commande d'insertion
Code:

1 2 3 rq """INSERT OR IGNORE INTO vsl_p (PDT_CODE, BON_CODE, PBO_DATE_DEBUT, PBO_DATE_FIN) VALUES('', '', '', '');"""
et effectivement
Code:

1 2 3 rq """INSERT OR IGNORE INTO vsl_p (PDT_CODE, BON_CODE, PBO_DATE_DEBUT, PBO_DATE_FIN) VALUES(?, ?, ?, ?);"""
le value que j'ai du recuperé dans la base ne contient pas les elements d'injection des tuples

Pas avoir construit 10 tables codes sur les bases de cette échanges avec toutes leurs subtilités propres ... la fatigue ce fait sentir et les évidences disparaissent