Variable entre class

Version imprimable

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:

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:

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

main.py

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#!/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:

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:

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

05/04/2022, 12h03
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:

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
05/04/2022, 13h26
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

Merci pour vos réponses.

Citation:

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 ;)

Citation:

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.

Citation:

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:

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:

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:

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.

05/04/2022, 14h33
wiztricks
Citation:

Envoyé par flipflip

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:

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:

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
05/04/2022, 15h16
Sve@r
Bonjour

Citation:

Envoyé par flipflip

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.

Citation:

Envoyé par flipflip

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)

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:

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:

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.

05/04/2022, 18h22
Sve@r
Citation:

Envoyé par 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" ;)

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

Citation:

Envoyé par flipflip

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)...

Citation:

Envoyé par flipflip

if field != "":

if field:.
Citation:
Envoyé par flipflip

Code:

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()"...)

Citation:

Envoyé par flipflip

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).
Citation:
Envoyé par flipflip

Code:

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")

bonjour
Citation:
Envoyé par flipflip
Dans main.py en modifiant
Code:

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

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 :aie:
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()

06/04/2022, 17h05
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:

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.
06/04/2022, 18h29
Sve@r

Citation:

Envoyé par flipflip

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.