Enregistrer une liste de commande pour les reexecute plus tard

Version imprimable

Bonjour,
j'ai un petit soucis avec EVAL(),
Objectif: enregistrer des commandes dans un fichier, puis les exécuter plus tard, dans le même ordre et avec les même paramètres.(record/play)
voila mon script

Code:

1
2
3
4
5
6
7
8
 
class Myclass():
	def funct_1(self):
		print "function one"
 
	def funct_2(self, param1):
		x = parm1 + 1
		print x

puis:

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
 
import Myclass
 
 class Saver(): 
	def __init__(self):
		global _obj
		_obj = Myclass()
 
	def getListCmd(self):
        """Recupere la liste des commandes a enregistre
        """
        cmd = []
        m_cmd =""
        print """
                tapez les commandes  que vous voulez rajouter au fichie
               """
        while (m_cmd != "end"):
            m_cmd = raw_input(sys.ps1)
            if m_cmd != "end":
                m_dict = _obj.__class__.__dict__
 
                list_cmd = eval(m_cmd,m_dict)
                cmd.append(list_cmd)
                self.log.info("add test %s "%list_cmd)
        return cmd
 
    def save(self,m_file):       
        fichier = open(m_file, "wb")
        self.log.info("Creat record file %s "%m_file)
        self.list_scenario_record =  self.getListCmd()
        cPickle.dump(self.list_scenario_record, fichier)
        self.log.info("End record ")
        fichier.close()

en executant , j'ai ce message d'erreur:

Citation:

TypeError: funct_1() takes exactly 1 argument (0 given)

ben le seul argument est "self" donc sans argument .
avez vous une idée???

27/10/2010, 12h50
kango

bonjour,

lorsqu'on appelle une méthode de classe, implicitement le premier argument ( désigné self) est automatiquement relié à l'instance de la classe manipulée. Si tu appelles la méthode indépendamment de l'instance alors cette liaison n'est pas effectuée.

en gros:

si:

Code:

m = MyClass()

alors:

Code:

m.func_1()

et

Code:

MyClass.func_1(m)

sont équivalents.

Ici, ton eval prend en argument le dictionnaire de la classe Myclass, ce qui permet de rendre la fonction func_1 disponible. Pour autant eval ne sait pas sur quelle instance doit s'exécuter la fonction, d'où le message d'erreur.
27/10/2010, 14h07
rosty38

ok merci
simple précis et concis
27/10/2010, 14h16
rosty38

en fait , j'avais bien creer un objet

Citation:

_obj = Myclass()

et j'utilise bien les attributs de cette objet

Citation:

m_dict = _obj.__class__.__dict__
list_cmd = eval(m_cmd,m_dict)

j'ai enchanté trop rapidement :aie:
27/10/2010, 14h38
wiztricks

Salut,

Juste pour infos, il y a deux bibliothèques/modules Python qui sont peut être à regarder/utiliser dans ce cas.

cmd: permet de construire des interfaces de type commandes voir exemple de D.Hellmann
C'est adapté pour construire une interface "détachée" du code qui exécutera les commandes.

code: permet de construire un interpréteur Python et de le contrôler. Il y a plein d'exemples sur Google mais ils sont assez limités.

Dans les deux cas, on contrôle ce qui a été tapé et rejouer peut se résumer à sauvegarder les bonnes commandes pour les rejouer.

Une autre stratégie pourrait être de sauvegarder la séquence des commandes côté "code" mais cela demande de créer une interface supplémentaire (entre les "strings" tapées par l'utilisateur et ce qui sera, in fine, exécuté).
- W
27/10/2010, 15h23
rosty38

disant que je m'approche du but, je ne comprends pas pourquoi il considère pas _obj comme objet :?

Bonjour,
je me permet de relancer, car je ne comprend toujours pas pourquoi je n'arrive pas a récupéré la liste des mothode d'une instance de classe.
voila j'ai réécris le script:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
class TestEval:   
 
    Name = "BaseClass"
    # __init__ is a class constructor    
    def __init__(self, arg1, arg2):
        # These values are created
        # when the class is instantiated.
        self.value1 = arg1
        self.value2 = arg2
 
    def display(self):
        print self.Name
        print self.value1
        print self.value2

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
import TestEvalMod
 
class GetEval:
 
    def getListCmd(self):               
        #creation de l'objet 
        global _obj
        _obj = TestEvalMod.TestEval(1,2)
        m_dict = _obj.__dict__        
        print m_dict
 
a = GetEval()
a.getListCmd()

et voila le resultat:

Citation:

D:\brouillon>python GetEval.py
{'value2': 2, 'value1': 1}

28/10/2010, 12h01
wiztricks

Salut,

Citation:

je me permet de relancer, car je ne comprend toujours pas pourquoi je n'arrive pas a récupéré la liste des mothode d'une instance de classe.

modules, class et instances ont tous leurs __dict__
Imaginez que la classe TestEval sous classe d'autres classes A, B, C

Chacune aura son __dict__ et une instance de TestEval aura son propre __dict_ dans lequel pourront être rangées attributs et méthodes associée à l'instance.

Lorsque l'interpréteur essaie de trouver à quoi correspond un attribut, il regardera dans le __dict__ de l'instance, s'il ne trouve rien il ira voir dans celui de la classe.

Maintenant par rapport à ce que j'ai compris de ce que vous souhaitiez faire:
1 - vous récupérez un identifiant tapé à la console,
2 - si la méthode correspondante existe, vous l'exécutez et affichez son retour ou vous affichez une erreur

Les fonction hasattr, getattr,... "savent" comment utiliser les informations dans la hiérarchie de __dict__ associée à un objet et sont largement suffisante pour faire ce que vous voulez.

Ce que çà ne fait pas c'est retourner la liste de... mais pour autant que cela vous soit utile ici, regardez le module inspect.
Bon courage,
- W

je pense que j'ai pas bien expliqué le probleme , je reprends,
voila ce que j'ai fais jusqu'a maintenant:

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
 
obj = module.MyClass() # MyClass contient les methodes qu'on peut exécuter (function_name)
 
function_name = 'function_1' #nom de la methode a ecéxuté 
tests_function_1=[]
tests_function_1.append([function_name, (parm1, parm2)])
function_name = 'function_2'
tests_function_2=[]
tests_function_2.append([function_name, (parm8, parm9)])
 
tests_all = [] \
    + tests_function_1 \
	+ tests_function_2 \
    + []
 
def run(tests = tests_all):
    pass_count = 0
    fail_count = 0
    rest_count = len(tests)
    for test_item in tests:
        print '-' * 60
        f_name, f_args = test_item
        ## Get the function object
        func = getattr(obj, f_name, None)
        # Check if function exists
        if not func:
            log.error("ERROR: test function '%s' doesn't exist" % f_name)
            continue
        # Run the test
        try:
            log.info("RUNNING: test function '%s%s'" % (f_name, str(f_args)))
            rest_count = rest_count - 1
            ## Call the test function
            if not f_args:
                func()         ## No arguments
 
            else:
                func(*f_args)  ## Many arguments    
            pass_count = pass_count + 1
        except KeyboardInterrupt:
            break
        except:
            # An error occured
            log.warn("WARNING: test function '%s' failed" % f_name)
            fail_count = fail_count + 1
    log.info('=' * 60)
    log.info("Results: ran %d tests, %d pass, %d fail, %d remaining" %
            (len(tests), pass_count, fail_count, rest_count))
    log.info('=' * 60)
 
def main():
    run()

donc je rentre les fonctions sous le format:

Citation:

[nom de la fonction, (paramètre, paramètres, ...)]

et sa marche, maintenant je souhaite rentrer la liste des fonctions sous le format standard

Citation:

nom_fonction(paramètre, paramètres, ...)

je ne sais pas si vous avez compris l'objectif de ma démarche
en tout cas merci infiniment pour vos interventions toujours aussi constructives.

28/10/2010, 16h57
rosty38

j'ai trouvé :),
en fait il suffit juste de faire un:

Citation:

exec(self.obj.commande)

merci a tous