Discussion :

[Aelurus_]

Bonjour à tous,

bon dans la suite du post précédent, ma question porte sur le passage de paramètres à un script que je souhaite compiler. Le script compilé aura pour fonction de lire un fichier CSV et d'exporter le tracé des données.
Je souhaite pouvoir via un fichier.py ou autre donner les diverses infos pour générer le ou les graphiques. Pour l'instant je passe un dictionnaire définit dans un fichier externe que je charge via

Code :

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

from Info_Graph import *

Le fichier Info_Graph.py contient mon dictionnaire.

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
info_graph=(
    #graph 0
    {
    "Titre":"rrr",
    "col_temp":None,
    "ylabel":'Température [°C]',
    "xlabel":'Durée [s]',
    "xlimits":{'left':0 ,'right': None},
    "ylimits":{'bottom':5,'top':None},
    #"ylimits":[0,12],##y axes limits [min,max] None, sans '' ou ""
    "data0":"Tc2",#"non de la colonne à tracer"
    "data1":"Tc1",#"non de la colonne à tracer"
    "data2":"Tc4",
    "data3":"Tc3",
    "data4":"",
    "data5":"",
    "data6":"",
    "data7":"",
    "data8":"",
    },#fin
    )

J'ai l'impression que la méthode n'est pas très propre et je doute qu'avec une compilation cela fonctionne.

Ma première idée serait de charger les infos du dictionnaire via un read dir, comme pour le fichier CSV.

Auriez un conseil ou une direction sur la méthode à utiliser. Pour l'instant mes recherches me donnent le module configparser. Il y a peut être plus simple pour mon besoin.

Merci

[wiztricks]

Salut,

Vous avez le choix entre lire un fichier .py (en passant à côté d'import), faire de la structure un fichier JSON, ou effectivement passer par un fichier .INI (ce que mange configparser).

Dans tous les cas, ce sont des fichiers "texte" que l'utilisateur pourra modifier avec un éditeur simple.

Si c'est un utilisateur lambda, vous allez reste dans les fichiers .INI parce qu'il a, à priori, plus l'habitude de travailler avec. Si l'utilisateur est un peu moins lambda, un fichier JSON sera plus simple à transformer en objets Python.
Passer par des fichiers .INI ou JSON à aussi l'avantage d'une étape de validation du contenu (à la lecture) et de limiter les bêtises qu'on pourrait faire si on propose un fichier .py (qui pourra exécuter du code à votre insu).

Pour le reste, c'est vous qui codez...

- W

[Aelurus_]

Bonjour Wiztricks,
effectivement le fichier .INI me plait bien.

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
# -*- coding: ANSI -*-
[Graph_0]
Titre       : rrr
col_temp    : None
ylabel      : Température [°C]
xlabel      : Durée [s]
xminlimits  :  0
xmaxlimits  :  None
ylimits     :  'bottom'  :  5 'top'  :  None
#nom		#Nom de la colonne à tracer
data0       : Tc2
data1       : Tc1
data2       : Tc4
data3       : Tc3
data4       : 
data5       : 
data6       : 
data7       :  
data8       :  
 
#######################
 
[Graph_1]
Titre       : rrr
col_temp    : None
ylabel      : Température [°C]
xlabel      : Durée [s]
xlimits     :  {'left'  :  0 'right'  :   None}
ylimits     :  {'bottom'  :  5'top'  :  None}
 
data0       : Tc2
data1       : Tc1
data2       : Tc4
data3       : Tc3
data4       : 
data5       : 
data6       : 
data7       :  
data8       :

Pour faire mon dictionnaire

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
from configparser import ConfigParser
parser = ConfigParser() 
parser.read('GraphConfig.ini') 
 
sec = parser.sections()
info_graph = list()
for i,sections in enumerate(sec):     
    graph ={"Graph": sections}
    for name, value in parser.items(sections):     
        graph[name] = value
        None
    info_graph.append(graph)
 
print(info_graph)

Et je m'aperçois qu'il me faut tester mes valeurs int() pour les avoir comme t'elle. Et je me retrouve à devoir gerer mon None à la construction du dictionnaire... Car je récupere pour l'instant que du str(), et None est NoneType.
Bon le traitement semble assez proche de la précédente solution...
Je suppose qu'avec JSON c'est la même punition?

[Sve@r]

Bonjour

Auriez un conseil ou une direction sur la méthode à utiliser. Pour l'instant mes recherches me donnent le module configparser. Il y a peut être plus simple pour mon besoin.

J'ai eu le même souci quand j'ai commencé à faire de vrais projets en Python, à savoir "comment stocker un environnement de dev" (donc un truc qui peut évoluer en fonction de l'avancement du projet) et "comment avoir un environnement utilisateur" (donc un truc que l'utilisateur peut modifier)

Pour l'environnement de dev, j'ai carrément créé un objet que j'ai nommé "cEnv". Puis je lui y ai mis des attributs et méthodes qui me permettaient d'initialiser ou nettoyer l'arborescence
Exemple

Code python :

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
# Objet pour gérer l'environnement du logiciel
class cEnv:
	"Gestion de l'environnement du logiciel"
 
	# Variables statiques
	appli="xxx"							# Nom application
	version="0.2"							# N° de version
	release=""								# N° de release
	dbname="bdd_xxx_v2"					# Nom bdd
	masterBdd=True							# Identifié comme "masterBdd"
	modeDevel=True							# En développement (None = Arrêt)
	langageDefault="fr"						# Langage par défaut
	instanceMax=1							# Nb max exécutions (0 = infini)
	subWindowMax=3							# Nb max profondeurs sous-fenêtres
	porteeMax=200000						# Portée maximale
	imageExtension=("jpg", "png", "gif", "bmp")
											# Liste des extensions de type "image"
 
	# Constructeur objet
	def __init__(
			self,							# Instance objet
			argv):							# Arguments du programme
 
		# Récupération de l'environnement
		self.argv=argv
 
		# Répertoire de travail
		self.wdir=dirName(argv[0])
 
		# Répertoire temporaire
		self.tmp=tempfile.gettempdir()
		if self.tmp == self.wdir:
			self.tmp=os.path.join(self.wdir, "tmp")
		if not os.path.isdir(self.tmp):
			raise IOError("%s n'existe pas ou n'est pas un répertoire" % self.tmp)
 
		# Liste Pièces-jointes
		self._listePJ=list()
 
		# Uname
		self.host=socket.gethostname()
		self.ip=socket.gethostbyname(self.host)
	# __init__()
 
	# Fermeture objet
	def close(
			self):							# Instance objet
 
		# Nettoyage des pièces-jointes
		for pj in self._listePJ:
			try:
				os.remove(pj)
			except OSError:
				pass
			# try
		# for
	# close()
# cEnv

Et pour l'environnement utilisateur, là j'ai utilisé configparser, qui est super pratique et j'ai même créé un objet qui l'enrobe de trucs perso (avec valeurs par défaut etc).

[Aelurus_]

Salut Sve@r,

Bonjour

Et pour l'environnement utilisateur, là j'ai utilisé configparser, qui est super pratique et j'ai même créé un objet qui l'enrobe de trucs perso (avec valeurs par défaut etc).

Je ne veux à ce niveau (heureusement pour moi), que gérer une interaction utilisateur. J'aime bien me faire des outils portable et autonome.

Je pense avoir résolu cette interaction avec la gestion des None :

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
import matplotlib.pyplot as plt
 
from configparser import ConfigParser
parser = ConfigParser() 
parser.read('GraphConfig.ini') 
 
sec = parser.sections()
info_graph = list()
for i,sections in enumerate(sec):     
    graph ={"Graph": sections}
    for name, value in parser.items(sections):     
        try : 
            graph[name] = float(value)
        except :
            graph[name] = value            
 
    info_graph.append(graph)
 
ylim = (info_graph[0]["yminlimits"],info_graph[0]["ymaxlimits"])
xlim = (info_graph[0]["xminlimits"],info_graph[0]["xmaxlimits"])
 
def f(a,b):       
    if a == 'None':
        a = None
    else:
        a = float(a)
#
    if b == 'None':
        b = None
    else:
        b = float(b)
    return(a,b)
 
 
plt.plot([3,5,6,12,15,21],[-1,16,3.4,3,8,13], label =info_graph[0]["data0"])
plt.xlabel(info_graph[0]["xlabel"])
plt.ylabel(info_graph[0]["ylabel"])
plt.ylim(f(*ylim))
plt.xlim(f(*xlim))
plt.legend(loc='best', ncol=2,fancybox=True)
plt.show()

Bon la solution me semble fonctionnel, merci Wiz pour tes exemples. Je vais retourner les relir et me plonger dans le tutos que tu as donné. J'arriverais surement à mieux comprendre ce que je viens d'écrire (le pourquoi, je veux dire) .