Discussion :

[flipflip]

Bonjour à tous,

Je bricole de plus en plus en python et cette fois je m'attaque aux class (je dev plus en php) et surtout j'essaie d'organiser mon projet. J'écris un programme pour automatiser la création de fichier pdf à partir de fichier csv extrait d'un ERP. La base en là mais je bloque sur le passage d'une variable d'une class à une autre.

Lorsque je lance le programme j'ai :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
{'root': '/home/xxxxx/Scripts', 'source': '/import', 'export': '/export', 'assets': '/assets', 'font': 'helvetica', 'font_size': 10, 'marge_all': 85, 'marge_left': 10, 'marge_top': 10, 'marge_right': 10}
 
Traceback (most recent call last):
  File "/home/xxx/Scripts/x3topdf/./main.py", line 94, in <module>
    main(sys.argv)
  File "/home/xxx/Scripts/x3topdf/./main.py", line 85, in main
    pdf.add_page()
  File "/home/xxx/.local/lib/python3.10/site-packages/fpdf/fpdf.py", line 787, in add_page
    self.header()
  File "/home/xxx/Scripts/x3topdf/modules/pdf.py", line 6, in header
    self.image(config['root'] + "/" + config['assets'] + "/logo.png", 10, 8, 33)
NameError: name 'config' is not defined

Si je comprends bien, l'objet config n'est pas accessible dans la class PDF, mais c'est ici que s'arrête mes connaissances python Est-ce que vous avez des pistes pour que je puisse continuer l'écriture du programme ?

Merci d'avance.

Structure

Code :

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

1
2
3
4
5
+main.py
+config.json
+modules/
+-- tools.py
+-- pdf.py

main.py

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
#!/usr/bin/python
# -*- coding: utf-8 -*-
 
import sys, datetime, csv
from modules.tools import tools
from modules.pdf import PDF
 
def createVar(f, v):
    globals()[f] = v
 
def main(argv=None):
    config = tools.loadConfig()
    print(config)
    pdf = PDF()
    pdf.set_font(config['font'], size=config['font_size'])
    pdf.set_margin(config['marge_all'])
    pdf.set_margins(config['marge_left'], config['marge_top'], config['marge_right'])
 
    file = csv.DictReader(open(config['root'] + "/" + config['source'] + "/FACHIL21040400.csv", "r"), delimiter="|")
[...]
 
if __name__ == "__main__":
        main(sys.argv)

tools.py

Code :

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

1
2
3
4
5
6
7
8
9
10
11
import json
 
class tools:
    def loadConfig():
        try:
            with open('./config.json', 'r') as fichier:
                config = json.load(fichier)
            return config
        except FileNotFoundError:
            print("Fichier de configuration illisible")
            exit(1)

pdf.py

Code :

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

1
2
3
4
5
6
7
8
9
10
# https://pyfpdf.github.io/fpdf2/fpdf/fpdf.html
from fpdf import FPDF
 
class PDF(FPDF):
    def header(self):
        self.image(config['root'] + "/" + config['assets'] + "/logo.png", 10, 8, 33)
        self.set_font(config['font'], "B", 11)
        self.cell(60)
[...]
Tronqué car l'erreur est présente dès le début

[Arioch]

Bonjour,

dans ton code, config n'est pas un objet mais un dictionnaire retourné par une méthode de la classe Tools que tu n'importe pas dans ton pdf.py.

Dans ton pdf.py, je rajouterai ces deux lignes là :

Code :

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

1
2
3
4
5
6
from fpdf import FPDF
from modules.tools import tools  # ICI
 
class PDF(FPDF):
    def header(self):
        config = tools.loadConfig()  # ET LA

[wiztricks]

Salut,

Lorsque vous appelez une fonction, il est tout à fait possible de lui passer un argument comme "config"... et sans maîtriser ce genre de concept basique galère de vous compliquer la vie avec classes et modules.

- W

[flipflip]

Merci pour vos réponses.

dans ton code, config n'est pas un objet mais un dictionnaire retourné par une méthode de la classe Tools que tu n'importe pas dans ton pdf.py.

C'est exactement ce que je voulais dire

Dans ton pdf.py, je rajouterai ces deux lignes là :

J'y ai bien pensé et cela marche, mais je ne trouve pas très optimisé de relancer la lecture du fichier de configuration alors qu'il a déjà été lu dans le fichier main.py pour y récupérer d'autres paramètres. Du coup il me paraissait plus logique de faire transiter le dictionnaire dans les class où il sera nécessaire.

Lorsque vous appelez une fonction, il est tout à fait possible de lui passer un argument comme "config"... et sans maîtriser ce genre de concept basique galère de vous compliquer la vie avec classes et modules.

Je ne cherche pas à faire passer des arguments dans une fonction (sujet maîtrisé) mais d'une class à une autre.

Dans main.py en modifiant

Code :

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

1
2
3
4
5
6
7
def main(argv=None):
    config = Tools.loadConfig()
    print(config)
    pdf = PDF()
    pdf.set_font(config['font'], size=config['font_size'])
    pdf.set_margin(config['marge_all'])
    pdf.set_margins(config['marge_left'], config['marge_top'], config['marge_right'])

Par

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def main(argv=None):
    config = Tools.loadConfig()
    print(config)
    pdf = PDF(config)
    pdf.set_font(config['font'], size=config['font_size'])
    pdf.set_margin(config['marge_all'])
    pdf.set_margins(config['marge_left'], config['marge_top'], config['marge_right'])

fichier pdf.py
class PDF(config):
    def header(self):
        self.image(config['root'] + "/" + config['assets'] + "/logo.png", 10, 8, 33)
        self.set_font(config['font'], "B", 11)
        self.cell(60)

J'obtiens

Code :

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

1
2
3
4
5
6
Traceback (most recent call last):
  File "/home/xxxx/Scripts/pdf/./main.py", line 6, in <module>
    from modules.pdf import PDF
  File "/home/xxxx/Scripts/ppdf/modules/pdf.py", line 4, in <module>
    class PDF(config):
NameError: name 'config' is not defined

Ma class "tools" comporte la méthode loadConfig charger de lire un fichier de configuration que j'attribue au dictionnaire "config" dans main.py et l'idée est que ce dictionnaire soit utilisable de partout dans mon programme.

[wiztricks]

Je ne cherche pas à faire passer des arguments dans une fonction (sujet maîtrisé) mais d'une class à une autre.

Si vous ne comprenez pas que c'est du pareil au même c'est que vous ne maîtrisez pas encore...
Rien ne vous empêche d'écrire:

Code :

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

1
2
3
4
def main(argv=None):
    config = Tools.loadConfig()
    print(config)
    pdf = PDF(config)

Puis de récupérer l'argument dans l'initialisation de l'instance:

Code :

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

1
2
3
4
5
6
7
8
class PDF(FPDF):
    def __init__(config):
         self.config = config
         super().__init__()
 
    def header(self):
         config = self.config
         ...

- W

[Sve@r]

Bonjour

J'y ai bien pensé et cela marche, mais je ne trouve pas très optimisé de relancer la lecture du fichier de configuration alors qu'il a déjà été lu dans le fichier main.py pour y récupérer d'autres paramètres. Du coup il me paraissait plus logique de faire transiter le dictionnaire dans les class où il sera nécessaire.

Discussion assez classique qu'on généralise de la façon suivante: vaut-il mieux calculer une valeur n fois ou la mémoriser pour l'utiliser n fois. La réponse dépend du temps de calcul, de la taille de la valeur, de la puissance de l'ordi et surtout du fait si le résultat du calcul évolue dans le temps.

Je ne cherche pas à faire passer des arguments dans une fonction (sujet maîtrisé) mais d'une class à une autre.

Une classe ce n'est pas actif. On ne peut pas y passer des éléments (quoique avec les métaclasses... mais bon, c'est un autre sujet).
Une classe c'est juste une description d'un objet. Ensuite, une fois la description faite, tu peux l'instancier (créer une variable de cette classe). Là tu obtiens un élément actif (la variable).
Cette variable possède des attributs (des valeurs caractérisant l'objet) et des méthodes (des fonctions ayant une action dans l'objet). Et ces méthodes (ces fonctions) peuvent recevoir des paramètres (des arguments). Donc ce n'est pas la classe qui reçoit des arguments mais les méthodes que tu invoques pour les instances que tu as crées. Ainsi comme le dit Wiztricks, c'est exactement la même chose.
Certes il y a une subtilité à la création car quand tu écris par exemple var=toto(123) ("toto" étant une classe) tu as l'impression de passer "123" à la classe mais en réalité, tu passes "123" à la méthode "__init__()" de la classe, méthode qui est automatiquement appelée chaque fois qu'on instancie une classe. Donc var=toto(123) se lit en réalité var=toto.__init__(123).

Pour en revenir à ton truc, une fois que tu as le contenu de ta config d'un côté (exemple config = tools.loadConfig()) et un objet "toto" devant utiliser cette configuration dans une de ses méthodes (exemple la méthode "useConfig()"), alors tu peux

1. instancier toto => var=toto()
2. utiliser la méthode en lui passant la config => var.useConfig(config)
3. Et si tu n'as pas besoin d'utiliser "var" plus d'une fois, tu peux alors instancier en ram et utiliser cette instance à sa création => toto().useConfig(config). Bien entendu, dans ce cas, vu que l'instanciation "toto()" n'est pas sauvegardé dans une variable, l'effet de cette instruction disparait à la fin de la ligne. Mais parfois ça suffit.
4. Et si maintenant cet objet est un objet dédié à être associé à cette configuration, alors comme le montre wiztricks, tu peux passer cette configuration à l'instanciation => var=toto(config)

[flipflip]

A la lumière de vos explications Wiztricks et Sve@r je décoche la case maîtrisé sur la ligne "fonctions et class"

Moyennant petite correction cela marche. J'en ai profité pour ajouter un dictionnaire à passer à ma fonction

main.py

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
#!/usr/bin/python
# -*- coding: utf-8 -*-
 
import sys, datetime, csv
from modules.tools import Tools
from modules.pdf import PDF
 
fields = {}
def createVar(f, v):
    fields[f] = v
 
def main(argv=None):
    config = Tools.loadConfig()
    file = csv.DictReader(open(config['root'] + "/" + config['source'] + "/FACHIL21040400.csv", "r"), delimiter="|")
 
field = ['une liste de valeur...']
 
    if field != "":
        # Créé la liste des variables avec la liste field
        # pour ajouter un champ il faut l'insérer dans la liste à la
        # même position que dans le fichier csv
        for f,v in zip(field, file.fieldnames):
            createVar(f, v)
 
        pdf = PDF(config, fields)
        pdf.set_font(config['font'], size=config['font_size'])
        pdf.set_margin(config['marge_all'])
        pdf.set_margins(config['marge_left'], config['marge_top'], config['marge_right'])
        pdf.alias_nb_pages()
        pdf.add_page()
 
        for i in range (1, 41):
            pdf.cell(0, 5, f"Printing ligne {i}", 0, 1)
        pdf.output(config['root'] + "/" + config['export'] + "/tuto2.pdf")
    else:
        print("Pas de fichier à générer")
 
if __name__ == "__main__":
        main(sys.argv)

pdf.py

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
# https://pyfpdf.github.io/fpdf2/fpdf/fpdf.html
from fpdf import FPDF
 
class PDF(FPDF):
    def __init__(self, config, fields):
        self.config = config
        self.fields = fields
        super().__init__()
 
    def header(self):
        config = self.config
        fields = self.fields
 
        self.image(config['root'] + "/" + config['assets'] + "/logo.png", 10, 8, 33)
        self.set_font(config['font'], "B", 11)
        self.cell(60)
        if fields['s_invtyp'] == "1":
            self.cell(30, 5, "Facture", 1, 0, "C")
        elif fields['s_invtyp'] == "2":
            self.cell(30, 5, "Avoir", 1, 0, "C")
[...]

Merci pour votre aide Messieurs.

[Sve@r]

A la lumière de vos explications Wiztricks et Sve@r je décoche la case maîtrisé sur la ligne "fonctions et class"

Et voilà comment toutes nos illusions s'effondrent...

Moyennant petite correction cela marche.

Hum. Une variable "field", une autre "fields", une fonction "createVar()" qui utilise le dictionnaire "fields" en tant que globale (fuck l'indépendance des fonctions), une variable "file" qui fout en l'air la fonction "file()". Plus des instructions un peu semées à la manière du petit poucet (une instruction, une fonction, deux instructions, etc etc etc)...

if field != "":

if field:.

Code python :

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

1
2
for f,v in zip(field, file.fieldnames):
	createVar(f, v)

fields=dict(zip(field, file.fieldnames)) (quant à l'utilité de la fonction "createVar()"...)

self.image(config['root'] + "/" + config['assets'] + "/logo.png", 10, 8, 33)

self.image(os.path.join(config['root'], config['assets'], "logo.png"), 10, 8, 33).

Code python :

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

1
2
3
4
if fields['s_invtyp'] == "1":
	self.cell(30, 5, "Facture", 1, 0, "C")
elif fields['s_invtyp'] == "2":
	self.cell(30, 5, "Avoir", 1, 0, "C")

self.cell(30, 5, {"1" : "Facture", "2" : "Avoir"}[fields['s_invtyp']], 1, 0, "C")

[papajoker]

bonjour

Dans main.py en modifiant

Code :

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

1
2
3
def main(argv=None):
    config = Tools.loadConfig()
    pdf = PDF()

Par

Code :

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

1
2
3
4
5
6
7
8
9
10
def main(argv=None):
    config = Tools.loadConfig()
    pdf = PDF(config)

fichier pdf.py
class PDF(config):
    def header(self):
        self.image(config['root'] + "/" + config['assets'] + "/logo.png", 10, 8, 33)
        self.set_font(config['font'], "B", 11)
        self.cell(60)

Pour une personne qui fait du php, j'ai l'impression que tu ne connais pas du tout la poo ?
Ecrire "class PDF(config):", c'est comme en php : on indique que la classe PDF hérite de config
Comme en php, si on désire ajouter une valeur dans l'objet, c'est dans le constructeur ; en python c'est .__init__(parametres)

----------
Avoir une class tools dans ton fichier tools.py n'a ici pas de sens : pour python déjà tout est object (différence avec php) et ici tu vas créer un objet dans un objet avec en plus une seule méthode qui devrait être statique dans ton cas
En fait, si tu désires un code objet, il serait plus logique d'avoir une class config (attribut caché? le json data) avec entre autre des méthodes get_cvs_filename() et get_pdf_filename() ou get_dir_asset()

[flipflip]

Sve@r, merci pour ces corrections, je vois que j'ai encore beaucoup à apprendre en Python. Toutes tes remarques m'ont permis de commencer le ménage et de mieux comprendre deux ou trois trucs.

createVar() me servait à remplir le dictionnaire qui me donnait la correspondance entre le nom du champ et la valeur dans le fichier. Tu l'a réduit à

Code :

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

fields=dict(zip(field, file.fieldnames))

Ce qui est bien plus simple et propre.

Papajoker, je fais du php mais je n'ai pas dis que j'étais bon
J'ai créé une class tools qui pour le moment contient uniquement une méthode mais il est clair que je vais en ajouter au fur et à mesure de l'avancement du projet.

[Sve@r]

createVar() me servait à remplir le dictionnaire qui me donnait la correspondance entre le nom du champ et la valeur dans le fichier.

Je n'avais pas demandé à quoi elle servait (je l'avais bien vu à quoi elle servait), j'ai parlé de son utilité. Parce que même si la méthode dict() n'avait pas été applicable ici, créer une fonction pour juste remplacer fields[k]=valeur par createVar(k, valeur)...
Pour créer une fonction il faut que celle-ci apporte une plus-value. Par exemple la fonction aurait été (un tout petit peu) plus justifiée si elle avait exercé un certain contrôle sur la valeur (exemple refuser une valeur négative). Bref ce genre de réflexe viendra avec l'habitude.