Discussion :

[dedalios]

Bonjour

Dans ce code la lecture du fichier csv charge a chaque enregistrement la Base Python

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 # coding: utf-8  
'''
Created on 23 mars 2018
 
@author: 
'''
import csv
import sqlite3
import sys
import datetime
import csv
import os
import encodings
from unidecode import unidecode
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 
 
 
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()    
 
        pass       
        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()    
        pass
 
    def insertion_sqllite(self,Base):
 
        curseur = Base.cursor() # appel au curseur
        data=[self.ACT_CODE,self.ACT_LIBELLE]
 
        if(self.ACT_CODE == '9BFC1'):
            print(data)     
        rq = """       INSERT 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,  encoding='utf8')
    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 precedente  si besion 
                    # creation de la nouvelle table 
                    nouvel_acte.table_sqllite(Base)
                # insertion de donnees
                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 aupres du module csv
    encodage ="utf-8"
    LaBase ="nombase2.sq3" 
    Base = sqlite3.connect(LaBase)
    csv.register_dialect('excel-fr', ExcelFr())
 
    actes("actes.csv" , Base)
 
    Base.close()

Problème j'ai 15 fichiers de ce type a convertir dans une seule base de données .
Les structures de base sont pour chaque cas specifique.
mais sur ce moèle j'ai creer 5 tables ( et les autres sont en ours de finalisation).

Pour autant avec autant de donnée a charge la fait de réaliser l'insertion dans la base cela duree 1h30.
le plus gros fichier fait 1250ko et les autres 5ko.

Je cherche donc realiser les insertions en base par bloc de 50 voir 100 insert .

je me demande quelle solution est la plus pertinante.

modifier la classe: class vls_GTs(object):
pour avoir la classe de class vls_GTs(object): qui convertie les donnes csv.
est une classe class DB_GTs(vls_GTs): charger de faire l'opération en base d'insertion.

[wiztricks]

Je cherche donc realiser les insertions en base par bloc de 50 voir 100 insert.

Pour faire çà, il faut avoir des listes de tuples et utiliser executemany

je me demande quelle solution est la plus pertinante.

modifier la classe: class vls_GTs(object):
pour avoir la classe de class vls_GTs(object): qui convertie les donnes csv.
est une classe class DB_GTs(vls_GTs): charger de faire l'opération en base d'insertion.

Tant que vous alimentez executemany en tuples, ranger votre code en class (ou pas), c'est pas çà qui fera le boulot...

- W

[dedalios]

bonjour ,

mon idee est de découper la class vsl_actes en 2parties.
creer une class bd_actes
qui charge un objet vls_actes

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
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
 
...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
class bd_actes(object):
  les_actes = vls_actes[]
    def __init__(self,liste):

Charger les donnees du fichier lu dans un objet bd_actes via des append(x)

puis transferrer les donnees à la base pour bloc.

Classe ou pas, en fait c'est plus pour améliorer ma compréhension du monde objet.

[wiztricks]

mon idee est de découper la class vsl_actes en 2parties.
creer une class bd_actes qui charge un objet vls_actes

Si vous voulez allez vite, difficile de passer à côté d'executemany...
Et pour passer par là, il faut commencer par respecter/s'aligner avec l'interface proposée....
Ce qui réduit les options qu'on peut (imaginer) avoir.

- W

[dedalios]

Voici la base de mes réflexions , je n'ai pas test pour l'instant ce code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
# 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 
 
 
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 insertion_sqllite(self,Base):
 
        curseur = Base.cursor() # appel au curseur
        data=[self.ACT_CODE,self.ACT_LIBELLE]
 
        rq = """       INSERT 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()  
 
class Les_Actes(object):
    def __init__(self,Nomfichier,Base):
        self.Les_Actes=[]
        self.Nomfichier=Nomfichier
        self.Base=Base
        file = open(self.Nomfichier,  encoding='utf8')
        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)  
                    self.Les_Actes.append(nouvel_acte) 
 
        except OSError:
            print("Problème d'access au fichier :" + self.Nomfichier)
        finally:
            #
            # Fermeture du fichier source
            #
            file.close()             
 
    def __str__(self):  
        resultat =""
        for actes in self.Les_Actes:
            if(actes ==""):
                resultat = str(actes)
            else:
                resultat += "/n" + str(actes)
        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):
        for actes in self.Les_Actes:
            # insrtion
 
            curseur = Base.cursor() # appel au curseur
 
            data=[actes.ACT_CODE,actes.ACT_LIBELLE]
 
            rq = """       INSERT INTO vsl_actes
                            (ACT_CODE, ACT_LIBELLE)
                               VALUES(?, ?);"""
 
            try:
                curseur.executemany(rq,data)
 
            except sqlite3.Error as e:
                print("Problème"+ " :" +   e.args[0]  + " sur commande d'insertion /n" )  
                print(rq)
                print(data)
                Base.rollback()
            else: 
                Base.commit() 
 
 
 
if __name__ == '__main__':
    # Enregistre ce dialecte aupr�s du module csv
    encodage ="utf-8"
    LaBase ="actes.sq3" 
    Base = sqlite3.connect(LaBase)
    csv.register_dialect('excel-fr', ExcelFr())
 
    traiter_actes =  Les_Actes("actes.csv" , Base)
    traiter_actes.table_sqllite(Base)
    traiter_actes.insertion_sqllite(Base)
 
    Base.close()

[wiztricks]

Voici la base de mes réflexions , je n'ai pas test pour l'instant ce code

Certes mais y-a-t-il une question en rapport avec le sujet?

- W

[dedalios]

voici les codes .
sur le principe je lis un fichiercsv .
je transfert les donnees pour appliquer divers correction à un objet de type vls_actes qui est le reflet de la base de donne a produire
chaque lecture charge aussi une liste d'un objet de type Les_Actes(object) qui contient une liste d'objet self.Les_Actes de type vls_actes
hormis la denommination qui pourrait etre différentié entre

le nom de la class Les_Actes(object) et la vauer self.Les_Actes de ce meme objet . Je cherche a comprendre pourquoi le chargement vai execute many ne fonctionne pas

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
# 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 
 
 
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 insertion_sqllite(self,Base):
 
        curseur = Base.cursor() # appel au curseur
        data=[self.ACT_CODE,self.ACT_LIBELLE]
 
        rq = """       INSERT 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()  
 
class Les_Actes(object):
    def __init__(self,Nomfichier,Base):
        self.Les_Actes=[]
        self.Nomfichier=Nomfichier
        self.Base=Base
        file = open(self.Nomfichier,  encoding='utf8')
        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)  
                    self.Les_Actes.append(nouvel_acte) 
 
        except OSError:
            print("Problème d'access au fichier :" + self.Nomfichier)
        finally:
            #
            # Fermeture du fichier source
            #
            file.close()             
 
    def __str__(self):  
        resultat =""
        for actes in self.Les_Actes:
            if(actes ==""):
                resultat = str(actes)
            else:
                resultat += "/n" + str(actes)
        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):
        for actes in self.Les_Actes:
            # insrtion
 
            curseur = Base.cursor() # appel au curseur
 
            data=[actes.ACT_CODE,actes.ACT_LIBELLE]
 
            rq = """       INSERT INTO vsl_actes
                            (ACT_CODE, ACT_LIBELLE)
                               VALUES(?, ?);"""
 
            try:
                curseur.executemany(rq,data)
 
            except sqlite3.Error as e:
                print("Problème"+ " :" +   e.args[0]  + " sur commande d'insertion /n" )  
                print(rq)
                print(data)
                Base.rollback()
            else: 
                Base.commit() 
 
 
 
if __name__ == '__main__':
    # Enregistre ce dialecte aupr�s du module csv
    encodage ="utf-8"
    LaBase ="actes.sq3" 
    Base = sqlite3.connect(LaBase)
    csv.register_dialect('excel-fr', ExcelFr())
 
    traiter_actes =  Les_Actes("actes.csv" , Base)
    traiter_actes.table_sqllite(Base)
    traiter_actes.insertion_sqllite(Base)
 
    Base.close()

Problème :Incorrect number of bindings supplied. The current statement uses 2, and there are 5 supplied.
sur commande d'insertion

INSERT INTO vsl_actes
(ACT_CODE, ACT_LIBELLE)
VALUES(?, ?);
data= ['9BLA6', '9BLA6']

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
# 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 
 
 
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 insertion_sqllite(self,Base):
 
        curseur = Base.cursor() # appel au curseur
        data=[self.ACT_CODE,self.ACT_LIBELLE]
 
        rq = """       INSERT 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()  
 
class Les_Actes(object):
    def __init__(self,Nomfichier,Base):
        self.Les_Actes=[]
        self.Nomfichier=Nomfichier
        self.Base=Base
        file = open(self.Nomfichier,  encoding='utf8')
        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)  
                    self.Les_Actes.append(nouvel_acte) 
 
        except OSError:
            print("Problème d'access au fichier :" + self.Nomfichier)
        finally:
            #
            # Fermeture du fichier source
            #
            file.close()             
 
    def __str__(self):  
        resultat =""
        for actes in self.Les_Actes:
            if(actes ==""):
                resultat =  actes.ACT_CODE  +"/" + actes.ACT_LIBELLE
            else:
                resultat += "\n" + actes.ACT_CODE  +"/" + actes.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):
 
        #for actes in self.Les_Actes:
            # insrtion
 
        curseur = Base.cursor() # appel au curseur
 
        #data=[actes.ACT_CODE,actes.ACT_LIBELLE]
 
        rq = """       INSERT INTO vsl_actes
                        (ACT_CODE, ACT_LIBELLE)
                           VALUES(?, ?);"""
 
        try:
            curseur.executemany(rq,self.Les_Actes)
 
        except sqlite3.Error as e:
            print("Problème"+ " :" +   e.args[0]  + " sur commande d'insertion \n" )  
            print(rq)
 
            Base.rollback()
        else: 
            Base.commit() 
 
 
 
if __name__ == '__main__':
    # Enregistre ce dialecte aupr�s du module csv
    encodage ="utf-8"
    LaBase ="actes.sq3" 
    Base = sqlite3.connect(LaBase)
    csv.register_dialect('excel-fr', ExcelFr())
 
    traiter_actes =  Les_Actes("actes.csv" , Base)
    traiter_actes.table_sqllite(Base)
    #print(traiter_actes)
    traiter_actes.insertion_sqllite(Base)
 
    Base.close()

lorsque je lance ce 2ieme code problème
creer base
Traceback (most recent call last):
File " actes2.py", line 218, in <module>
traiter_actes.insertion_sqllite(Base)
File " actes2.py", line 196, in insertion_sqllite
curseur.executemany(rq,self.Les_Actes)
ValueError: parameters are of unsupported type

[tyrtamos]

Bonjour,

Logiquement, executemany devrait avoir en 2ème argument une liste de listes (ou liste de tuples), chaque sous-liste étant appliquée successivement à la requête SQL. En fait, quand l'erreur dit "and there are 5 supplied", il prend chacun des caractères de '9BLA6'.

[wiztricks]

Salut,

Je cherche a comprendre pourquoi le chargement vai execute many ne fonctionne pas

Dans votre histoire, il y a un Reader qui lit le fichier CSV et produit des enregistrements qui seront cohérents avec le schéma de la BDD et un Writer qui s'occupe d'écrire ces enregistrements et au milieu un machin qui tire les enregistrements du Reader pour les pousser dans le Writer.

Et si on écrit çà pour voir comment çà marche, çà devrait/pourrait ressembler à:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
import csv
import sqlite3
from collections import namedtuple
 
record = namedtuple('record', 'code, libelle')
 
class Reader:
    def __init__(self, file):
        self._reader = csv.reader(file, delimiter=' ')
 
    def get_records(self, count=2):
        records = []
        try:
            for _ in range(count):
                row = next(self._reader)
                records.append(record(int(row[0]), row[1]))
        except StopIteration:
            pass
        except:
            raise
        return records
 
 
class Writer:
    def __init__(self, path=':memory:'):
        cnx = self._cnx = sqlite3.connect(path)
        cnx.execute('''create table if not exists actes(code integer, libelle text);''')
 
    def write(self, records):
        with self._cnx:
            self._cnx.executemany('''insert into actes(code, libelle) values(?,?)''', records)
 
    def dump(self):
        with self._cnx:
            for row in self._cnx.execute('select * from actes'):
                print (row)
 
def load(reader, writer):
    while 1:
 
        records = reader.get_records()
        if not records: break
        writer.write(records)
 
 
if __name__ == '__main__':
    from io import StringIO
 
    actes = ('1 aaa\n'
             '2 bbb\n'
             '3 ccc\n'
             '4 ddd\n'
             '5 ddd\n'
             )
 
    writer = Writer()
    load(Reader(StringIO(actes)), writer)
    writer.dump()

Une fois cette mécanique maîtrisée, "spécialiser" en fonction des différents fichiers et des tables à remplir seront d'autres détails à triturer.

- W

[dedalios]

Que veulent dire ces parties du code ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
from collections import namedtuple
 
record = namedtuple('record', 'code, libelle')

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
class Writer:
    def __init__(self, path=':memory:'):
        cnx = self._cnx = sqlite3.connect(path)

:memory: la base sql est en mémoire , pas de conservation poste traitement ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
    from io import StringIO
 
    actes = ('1 aaa\n'
             '2 bbb\n'
             '3 ccc\n'
             '4 ddd\n'
             '5 ddd\n'
             )

il s'agit d'une simulation du fichier csv?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 StringIO(actes)

[wiztricks]

Salut,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
class Writer:
    def __init__(self, path=':memory:'):
        cnx = self._cnx = sqlite3.connect(path)

:memory: la base sql est en mémoire , pas de conservation poste traitement ?

Est-ce que vous avez essayé avec un fichier?

Je trouve qu'il est plus simple de commencer avec "tout en mémoire", histoire de repartir d'un état "clean" lors des premières mises au point. De même qu'il est plus simple de partir d'un exemple de fichier CSV de quelques lignes.

L'objectif étant d'illustrer le découpage des traitements entre Reader et Writer et l'utilisation d'executemany (et la construction de listes de tuple), y a-t-il besoin de plus?

Que veulent dire ces parties du code ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
from collections import namedtuple
 
record = namedtuple('record', 'code, libelle')

collections et io sont des bibliothèques standards. Il suffit d'ouvrir la documentation pour voir ce que c'est.

- W

[dedalios]

Malheureusement cela n'est pas toujours possible ,définition des données non existante.
Double enregistrement sur les fichiers...

mais merci pour ces infors

[wiztricks]

Malheureusement cela n'est pas toujours possible définition des données non existante.
Double enregistrement sur les fichiers...

Qu'est ce qui n'est pas possible? Utiliser executemany? Faire un brouillon de code avec des données significatives pour s'assurer que le code qui est derrière saura les traiter? Découper les activités en Reader et Writer?

- W

[dedalios]

bonjour

J'ai reprise ce code et j'ai ajouter

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
                if(record(int(row[0]), row[1]) not in records):
                    records.append(record(int(row[0]), row[1]))

ceci dans le but de charger records qu'a la condition de ne pas avoir déjà charge l'information

donc afin que le derniere enregsitrement ne soit pas chargé dans records

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
             '4 ddd\n'
             '4 ddd\n'

LE CODE COMPLET

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
# coding: utf-8  
import csv
import sqlite3
from collections import namedtuple
 
record = namedtuple('record', 'code, libelle')
 
class Reader:
    def __init__(self, file):
        self._reader = csv.reader(file, delimiter=' ')
 
    def get_records(self, count=2):
        records = []
        try:
            for _ in range(count):
                row = next(self._reader)
                if(record(int(row[0]), row[1]) not in records):
                    records.append(record(int(row[0]), row[1]))
 
 
        except StopIteration:
            pass
        except:
            raise
        return records
 
 
class Writer:
    def __init__(self, path=':memory:'):
        cnx = self._cnx = sqlite3.connect(path)
        cnx.execute('''create table if not exists
            actes(code integer, libelle text ,  
            CONSTRAINT code_pk PRIMARY KEY(code));''')
 
    def write(self, records):
        with self._cnx:
            self._cnx.executemany('''insert into actes(code, libelle) values(?,?)''', records)
 
    def dump(self):
        with self._cnx:
            for row in self._cnx.execute('select * from actes'):
                print (row)
 
def load(reader, writer):
    while 1:
 
        records = reader.get_records()
        if not records: break
        writer.write(records)
 
 
if __name__ == '__main__':
    from io import StringIO
 
    actes = ('1 aaa\n'
             '2 bbb\n'
             '3 ccc\n'
             '4 ddd\n'
             '4 ddd\n'
             )
 
    writer = Writer()
    load(Reader(StringIO(actes)), writer)
    writer.dump()

mais voila

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 Traceback (most recent call last):
  File "\src\csvconv.py", line 63, in <module>
    load(Reader(StringIO(actes)), writer)
  File "\src\csvconv.py", line 49, in load
    writer.write(records)
  File "\src\csvconv.py", line 37, in write
    self._cnx.executemany('''insert into actes(code, libelle) values(?,?)''', records)
sqlite3.IntegrityError: UNIQUE constraint failed: actes.code

[wiztricks]

Salut,

J'ai reprise ce code et j'ai ajouter

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
                if(record(int(row[0]), row[1]) not in records):
                    records.append(record(int(row[0]), row[1]))

ceci dans le but de charger records qu'a la condition de ne pas avoir déjà charge l'information

Si vous ne postez pas le code complet pas facile de savoir mais si vous avez respecté le code que j'ai posté, il charge le fichier CSV 2 lignes à la fois et ne stocke pas l'ensemble des records déjà écrits.
Mais peut être que vous voulez dire que "not in" ne fonctionnerait pas avec des listes de tuple?

note: en pratique, avec sqlite3, on utilise INSERT OR IGNORE pour qu'il jette les doublons ou INSERT OR REPLACE pour mettre à jour si.

- W

[dedalios]

Salut,



Si vous ne postez pas le code complet pas facile de savoir mais si vous avez respecté le code que j'ai posté, il charge le fichier CSV 2 lignes à la fois et ne stocke pas l'ensemble des records déjà écrits.
Mais peut être que vous voulez dire que "not in" ne fonctionnerait pas avec des listes de tuple?

note: en pratique, avec sqlite3, on utilise INSERT OR IGNORE pour qu'il jette les doublons ou INSERT OR REPLACE pour mettre à jour si.

- W

Le code complet est poste dans ma demande.
J'ai fait des tests primaires avec les listes simples ou de tuples. Le IN ou sont contraire NOT IN pour vérifier la présence d'un éléments tuple ou autre dans une liste cela fonctionne .
il n'y a aucun problème a tester l'existant d'un tuple dans une liste de tuple .


voici le cas de test primaires

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
from collections import namedtuple
 
enregistrement = namedtuple('enregistrement', 'code, libelle')
 
type_enregistrement  = enregistrement(15,"coucou")
 
print(type_enregistrement.code )
print(type_enregistrement.libelle)
 
z1, z2 = type_enregistrement
print(z1)
 
print(type_enregistrement[0]  )
print(type_enregistrement[1]  )
 
liste_enr =[] 
 
liste_enr.append(  enregistrement(15,"coucou") )
liste_enr.append(  enregistrement(1,"dodo") )
liste_enr.append(  enregistrement(2,"KKK") )
 
if enregistrement(1,"dodo") not  in liste_enr:
    liste_enr.append(  enregistrement(1,"dodo") )
 
if enregistrement(1,"dodo") not in liste_enr:
    liste_enr.append(  enregistrement(2,"KKK")) 
 
for cas in liste_enr:
    print(cas)
 
if enregistrement(1,"dodo")  in liste_enr :
    print("oui")
else:
    print("non")

et le retour des print

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
15
coucou
15
15
coucou
enregistrement(code=15, libelle='coucou')
enregistrement(code=1, libelle='dodo')
enregistrement(code=2, libelle='KKK')
oui

[wiztricks]

Le code complet est poste dans ma demande

Ce qui ne change pas les solutions proposées: utiliser INSERT OR REPLACE ou stocker tous les enregistrements (mais il peut y en avoir beaucoup).

- W

[dedalios]

Ce qui ne change pas les solutions proposées: utiliser INSERT OR REPLACE ou stocker tous les enregistrements (mais il peut y en avoir beaucoup).

- W

Effectivement la solution de charger dans une liste de l'intégralité des enregistrements du fichier csv sous forme de tuple pour pouvoir utiliser le mécanisme d' insertion via executemany oblige a chercher une solution soit de suppression des doublons soit de non chargement des tuples csv dans la liste intémédiaire.

Je peux faire en sorte de traiter l'insertion sql d'utiliser les exception pour traiter les blocages de type "sqlite3.IntegrityError: UNIQUE constraint failed: " pour exclure ces cas.

une question toutefois comment réagit executemany si 50% des tuple à insérer en base provoque une erreur d'intégration pour sqlite3.IntegrityError: UNIQUE constraint failed:.
rejet t'il l'intégralité des données ou uniquement les enregistrements en échecs ?


et j'aimerai bien savoir pourquoi la commande NOT in ne fonctionne pas.

[wiztricks]

une question toutefois comment réagit executemany si 50% des tuple à insérer en base provoque une erreur d'intégration pour sqlite3.IntegrityError: UNIQUE constraint failed:..

Ce n'est pas si compliqué de tester... mais vous n'allez pas gérer l'erreur pour préférer INSERT OR IGNORE ou INSERT OR REPLACE i.e. laisser faire le boulot au SGDB.

et j'aimerai bien savoir pourquoi la commande NOT in ne fonctionne pas.

Partez du principe que "not in" fonctionne... (sinon non seulement çà se saurait mais pas grand monde développerait avec Python).
A partir de là, le soucis est dans votre code.
Relisez le autant de fois que nécessaire, ajouter y des "print",.... pour trouver et comprendre pourquoi.

- W

[dedalios]

Voici le code d'origine

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
import csv
import sqlite3
from collections import namedtuple
 
record = namedtuple('record', 'code, libelle')
 
class Reader:
    def __init__(self, file):
        self._reader = csv.reader(file, delimiter=' ')
 
    def get_records(self, count=1):
        records = []
        try:
            for _ in range(count):
                row = next(self._reader)
                records.append(record(int(row[0]), row[1]))
        except StopIteration:
            pass
        except:
            raise
        return records
 
 
class Writer:
    def __init__(self, path=':memory:'):
        cnx = self._cnx = sqlite3.connect(path)
        cnx.execute('''create table if not exists actes(code integer, libelle text);''')
 
    def write(self, records):
        with self._cnx:
            self._cnx.executemany('''insert into actes(code, libelle) values(?,?)''', records)
 
    def dump(self):
        with self._cnx:
            for row in self._cnx.execute('select * from actes'):
                print (row)
 
def load(reader, writer):
    while 1:
 
        records = reader.get_records()
        if not records: break
        writer.write(records)
 
 
if __name__ == '__main__':
    from io import StringIO
 
    actes = ('1 aaa\n'
             '2 bbb\n'
             '3 ccc\n'
             '4 ddd\n'
             '5 ddd\n'
             '6 ddd\n'
             '15 eeee\n'
             '2 bbb\n'
             '33 qqq\n'
             )
 
    writer = Writer()
    load(Reader(StringIO(actes)), writer)
    writer.dump()

et voici le code modifi

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
# coding: utf-8  
import csv
import sqlite3
from collections import namedtuple
 
record = namedtuple('record', 'code, libelle')
 
class Reader:
    def __init__(self, file):
        self._reader = csv.reader(file, delimiter=' ')
 
    def get_records(self, count=2):
        records = []
        try:
            for _ in range(count):
                row = next(self._reader)
                if(record(int(row[0]), row[1]) not in records):
                    records.append(record(int(row[0]), row[1]))
 
 
        except StopIteration:
            pass
        except:
            raise
        return records
 
 
class Writer:
    def __init__(self, path=':memory:'):
        cnx = self._cnx = sqlite3.connect(path)
        cnx.execute('''create table if not exists
            actes(code integer, libelle text ,  
            CONSTRAINT code_pk PRIMARY KEY(code));''')
 
    def write(self, records):
        with self._cnx:
            self._cnx.executemany('''insert into actes(code, libelle) values(?,?)''', records)
 
    def dump(self):
        with self._cnx:
            for row in self._cnx.execute('select * from actes'):
                print (row)
 
def load(reader, writer):
    while 1:
 
        records = reader.get_records()
        print(records)
        if not records: break
        writer.write(records)
 
 
if __name__ == '__main__':
    from io import StringIO
 
    actes = ('1 aaa\n'
             '2 bbb\n'
             '3 ccc\n'
             '4 ddd\n'
             '4 ddd\n'
             )
 
    writer = Writer()
    load(Reader(StringIO(actes)), writer)
    writer.dump()

Quelles sont les modifications ;

La table sql la notion de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 CONSTRAINT code_pk PRIMARY KEY(code) :

Hors volontairement les donnees inserer contiennent des doubles.

Afin de ne pas charger de données en double dans la liste records j'ai modifié cette classe
Déjà la lecture des données ce fait 1 ligne par 1 ligne .
puis j'ai conditionné le chargement de "records" en cherchant a vérifier si le tuple record existait ou pas dans la liste "records"
Mais visiblement je dommandej l'intégration des données via insert sql me signale qu'il ne pas pas inserer de donnée en doublesur la cle primaire alors que pour moi nous ne devrions pas avoir de donnée en double dans cette liste.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
record = namedtuple('record', 'code, libelle')
 
class Reader:
    def __init__(self, file):
        self._reader = csv.reader(file, delimiter=' ')
 
    def get_records(self, count=1):
        records = []
        try:
            for _ in range(count):
                row = next(self._reader)
                if(record(int(row[0]), row[1]) not in records):
                    records.append(record(int(row[0]), row[1]))
                
                
        except StopIteration:
            pass
        except:
            raise
        return records