Discussion :

[Invité]

Bonjour,

Je m'amuse avec SpeechRecognition pour en faire un Cortana en moins bien mais ma passion c'est de réinventer la roue !
Bref, j'aimerais répéter la dernière commande que j'ai transmise vocalement à mon script. J'utilise une liste et lambda mais je me demande si je fais les choses correctement.

Exemple bidon :

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
commands = []
 
def main_thread(audio):
    if audio == 'toto':
        func = lambda : do_something_1(1,2,3)
    elif audio == 'tata':
        func = lambda : do_something_2("a","b")
    elif audio == 'répète':
        commands[-1]()
 
    func()
    command.append(func)
 
def do_something_1(arg1, arg2, arg3):
    '''do something'''
    return True
 
def do_something_2(arg1, arg2):
    '''do something else'''
    return False

Je ne vois pas d'autres manières de faire... Dites-moi comment vous auriez géré la chose si le cœur vous en dit !?

Merci d'avance et bonne soirée/journée !

[Sve@r]

Bonjour

Dites-moi comment vous auriez géré la chose si le cœur vous en dit !?

C'est juste un souci de persistance des valeur entre chaque appel (style le "static" du C). Ca ce résoud assez facilement.

Si tu ne veux pas en passer par l'objet, alors moi je passerais par un attribut de fonction (ce qui "lie" visuellement la variable avec la fonction)

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
from functools import partial
 
def main_thread(audio):
	if audio == 'toto':
		func=partial(do_something_1, 1,2,3)
		main_thread.history.append(func)
	elif audio == 'tata':
		func=partial(do_something_2, "a","b")
		main_thread.history.append(func)
	elif audio == 'répète':
		func=main_thread.history.pop()
	func()
# main_thread()
 
def do_something_1(arg1, arg2, arg3):
	'''do something'''
	print(arg1, arg2, arg3)
	return True
 
def do_something_2(arg1, arg2):
	'''do something else'''
	print(arg1, arg2)
	return False
 
main_thread.history=list()

Remarque qq part ça reste de l'objet (une fonction étant un objet)...

[Invité]

Merci pour ta réponse, je vais me pencher un peu sur functools que je n'utilise jamais.

Par contre squatter la fonction j'en connais un ou deux qui ne devrait pas être content ! Et puis le pop() ça m'empêcher de "re-répéter"...

Je n'ai pas compris le "Si tu ne veux pas en passer par l'objet", il faudrait que je passe par une class dans l'idéal ?

[Sve@r]

Par contre squatter la fonction j'en connais un ou deux qui ne devrait pas être content !

Sisi, c'est autorisé. La fonction c'est un objet donc tu as le droit de lui créer des attributs.

Et puis le pop() ça m'empêcher de "re-répéter"...

Une fois que le principe est montré...

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
def main_thread(audio):
	if audio == 'toto':
		func=partial(do_something_1, 1,2,3)
		main_thread.history.append((audio, func))
		func()
	elif audio == 'tata':
		func=partial(do_something_2, "a","b")
		main_thread.history.append((audio, func))
		func()
	elif audio == "history":
		print(tuple("%d: %s" % (i, x[0]) for (i, x) in enumerate(main_thread.history)))
	elif isinstance(audio, int):
		(label, func)=main_thread.history[audio]
		print("repeat %d (%s)" % (audio, label))
		func()
# main_thread()

Je n'ai pas compris le "Si tu ne veux pas en passer par l'objet", il faudrait que je passe par une class dans l'idéal ?

A la base il n'y a rien d'obligé. Mais avec une classe tu peux commencer une vraie gestion...

[Invité]

Sisi, c'est autorisé. La fonction c'est un objet donc tu as le droit de lui créer des attributs.

Hum, ok ! Je pensais que c'était déconseillé comme pour les instances de classe.

A la base il n'y a rien d'obligé. Mais avec une classe tu peux commencer une vraie gestion...

Okay ! Ca me paraît un peu lourd à mettre en œuvre pour le moment.

Merci encore.

[fred1599]

Hum, ok ! Je pensais que c'était déconseillé comme pour les instances de classe.

Déconseillé pour des fonctions de modules dont tu ne connais pas les détails d'implémentation...

[Invité]

Dacodac !

[Sve@r]

Hum, ok ! Je pensais que c'était déconseillé comme pour les instances de classe.

C'est vrai que depuis P3, on peut faire autrement. Sauf que j'ai encore du mal à voir comment appliquer l'exemple de ce tuto à ton cas...

[edit]Ok, j'y suis arrivé, sans squatter la fonction

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
from functools import partial
 
def thread():
	def action(m):
		nonlocal h
		if m == "toto":
			func=partial(do_something_1, 1, 2, 3)
			h.append((m, func))
			func()
		elif m == "titi":
			func=partial(do_something_2, "x", "y")
			h.append((m, func))
			func()
		elif m == "history":
			print(tuple("%d: %s" % (i, x[0]) for (i, x) in enumerate(h)))
		elif isinstance(m, int):
			(label, func)=h[m]
			print("repeat %d (%s)" % (m, label))
			func()
		# if
	# action()
	h=list()
	return action
# thread()
 
def do_something_1(arg1, arg2, arg3):
	'''do something'''
	print(arg1, arg2, arg3)
	return True
 
def do_something_2(arg1, arg2):
	'''do something else'''
	print(arg1, arg2)
	return False
 
audio=thread()
audio("toto")
audio("titi")
audio("titi")
audio("toto")
audio("history")
audio(-1)
audio(2)

L'astuce c'est que la fonction qu'on appelle (thread) se contente d'initialiser l'historique et de renvoyer une autre fonction qui, elle, fera appel à cet historique lorsqu'elle sera appelée.
Ensuite, quand on appelle l'item créé (audio) on appelle en réalité la fonction "action".

[Invité]

Ben ta méthode est bien je trouve mais pourquoi utiliser une liste, une simple variable (genre last_commande) suffirait, non ?

Oui mais je ne sais pas du tout où je vais donc je prévois large ! ^^

---

Oki doki Sve@r !

[josmiley]

Pourquoi pas un 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
actions = {"toto":lambda:do_something1(1,2,3),
           "tata":lambda:do_something2("a","b")}
 
def main_thread(audio):
    action = actions.get(audio)
    if action:
        actions["répète"] = action
        action()
    else:
        do_default()
 
 
def do_default():
    print("pas compris ou rien à répéter ")
 
def do_something1(*args):
    print(*args)
 
main_thread("toto")
main_thread("répète")

Peut être même qu'un générateur aurait fait l'affaire.

[fred1599]

Il y a aussi possibilité avec les dictionnaires comme dis par @josmiley,

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
def func_1(): return 1
 
def func_2(): return 42
 
 
def execute_command(audio):
    if audio == "repeat" and commands["repeat"] is not None:
        func = commands["repeat"]
        commands["repeat"] = None
        return func()
 
     if audio == "repeat" and commands["repeat"] is None:
        return None
 
     if audio in commands:
        commands["repeat"] = commands[audio]
        return commands[audio]()
 
    return None
 
 
commands = {
    "toto": func_1,
    "tata": func_2,
    "repeat": None
}
 
assert execute_command("repeat") is None
assert execute_command("tata") == 42
assert commands["repeat"].__name__ == "func_2"
assert execute_command("repeat") == 42
assert commands["repeat"] is None
assert execute_command("tata") == 42
assert execute_command("toto") == 1
assert commands["repeat"].__name__ == "func_1"
assert execute_command("repeat") == 1

[papajoker]

bonjour

Ca me paraît un peu lourd à mettre en œuvre pour le moment.

Oui, le bon mot est bien "le moment" : Puisque tu ne sais pas où tu vas, il n'est pas encore possible de définir des classes. Autant rester avec un code facilement remplaçable (et pas forcément propre "pour le moment"). Donc, pour moi, ta question me semble beaucoup trop anticipée.

Si tu as besoin d'un historique, tu peux aussi regarder du côté des décorateurs ?

Puisque tu désires ratisser "large", il serait bien d'envisager comme commande 2 mots (lancer/fermer navigateur...). Si tu as le dernier python, la nouvelle forme switch case peut être intéressante pour ton cas.

[Invité]

@papajoker

Je prends note de tout ça !

Je me demandais si en faite c'était pas plus logique de passer du temps à concevoir un plan d'action plutôt que de partir tout azimut. Dis autrement réfléchir à l'architecture du script en amont. Mais pour le coup python serait bien moins amusant à mes yeux. Vive la bidouille !

J'ai peu de connaissance sur les décorateurs, j'en ai utilisé deux ou trois fois sans comprendre ce que je faisais. Je viens de lire un article à ce sujet, ça me paraît plus clair mais pas assez pour voir comment exploiter ça.

J'utilise déjà des commandes avec plusieurs mots, google est assez fort pour reconnaître ce qu'on raconte ! =)

Pour le match case je ne sais pas si c'est bien adapté car j'ai des instructions du genre if 'coupe le son' in texte et des elif 'plus fort' in text or (('augmente' in text or 'monte' in text) and ('son' in text or 'volume' in text or 'audio' in text)). Peut-on utiliser match et case avec in ?

Merci pour vos participations, je suis un peu rassuré je n'ai pas loupé un truc évident ! =)

[papajoker]

Pour le match case je ne sais pas si

Pas fort en recherche web

Petit exemple avec de quoi s'amuser

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
 
def executer(commandes):
    print("\t\t\t\t#quoi  faire de : ", commandes, "?")
    match commandes:
        case ['avancer', direction] if direction == "arrière":
            print("Avancer vers l'", direction, "???????")
        case ['avancer', direction] if direction in ['droite', 'gauche']:
            print("Tourner vers la ", direction)
        case ['avancer', direction] :
            print("Avancer a l'aveuglette vers ", direction)
        case 'avancer':
            print("Avancer vers nulle part !")
        case ['reculer', direction]:
            print("reculer: ", direction)
        case [action, 'le son', *hauteur] if action in ['augmente', 'coupe']:
            print(f'sur le son : {action.upper()}R de :', hauteur)
        case [action, 'le son']:
            print(f'sur le son,  MAUVAISE COMMANDE: {action.upper()}')
        case [action, sur, *params]: # if sur in ('volume','son')
            print("appel à function volume(action, params) qui fait un autre match case en interne")
        case _:
            print("?? commande inconnue :", commandes)
 
# commande :tuple = decouper_ordonner('augmenter le volume de 50 pourcent environ')
# executer(commande)
executer(('avancer','droite'))
executer(('avancer','gauche'))
executer(('avancer','avant'))
executer('avancer')
executer(('reculer', 'droite'))
executer('reculer')  # non géré
executer(('avancer','arrière')) # gère l'erreur
executer(('a', 'b'))
executer(('augmente','le son'))
executer(('augmente','le son', '10%'))
executer(('coupe','le son'))
executer(('éteindre','le son'))

Pour les décorateurs, ici l'idée est juste de ne pas polluer le code métier avec cette histoire d'historique

[Invité]

Oh la vache c'est un sacré bordel ! Je crois que je vais rester sur mon if 'toto' in text !

[papajoker]

Oh la vache c'est un sacré bordel !

??? j'attends ton code simple qui peut gérer ces 8 commandes très simples ...

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
def executer(commande):
    commandes = [ s for s in commande.split() if len(s)>2 or s.isdigit()]
    match commandes:
        case [action, objet, *params] if objet in ('volume','son'):
            try:
                param = int(params[0]) if params else 10
            except ValueError:
                param = 10
            param = param if action == "augmenter" else param*-1
            if action == "couper": param = -100
            print(f"set_volume({param})")
 
        case ['rechercher',*params] |\
             ['recherche', *params] if 'web' in params:
            print(f"navigateur('http://chercheettrouve.fr?q={'&'.join(params)})")
 
        case ['rechercher',*params] | ['recherche', *params]:
            print(f"find('{' & '.join(params)}')")
 
        case ['fermer', programme]:
            print(f"kill(get_pid('{programme}'))")
 
        case _:
            print("?? commande vovale inconnue :", commandes)
 
 
executer('augmenter le son')
executer('augmenter le son de 15 pourcent')
executer('baisser le volume de 44 pourcent')
executer('couper le son')
executer('fermer python')
executer('rechercher sur le web un tuto python')
executer('recherche web un tuto protocol zéro')
executer('recherche bash python')

je vais rester sur mon if 'toto' in text !

mais match/case peut très bien utiliser cette syntaxe (fait ici pour détecter les commandes volume/son)

[Invité]

Ben c'est le bordel dans le sens que c'est pas facilement lisible.

Code :

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

1
2
3
4
5
case ['rechercher',*params] |\
     ['recherche', *params] if 'web' in params:
 
#commands = r.recognize_google(audio, language="fr-FR")
elif 'recherche' in commands and 'web' in commands:

Et si plus compliqué :

Code :

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

1
2
3
4
5
6
commands = 'recherches sur le web si toto habite sur la planète mars'
for w in ('recherche', 'web', 'toto', 'planète', 'mars'):
    if w not in commands:
        break
else:
    print('Oui')

PS : Ou plus mieux :

Code :

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

all(w in commands for w in ('recherche', 'web', 'toto', 'planète', 'mars'))

[papajoker]

Tu ne me sembles pas trop objectif ... ici, tu ne réponds pas en ne donnant QUE les 2 exemples les plus simples (ta demande était sur le volume). Il est clair que pour une structure simple, match/case est surdimensionné. Je suppose que tu désires avoir 50 commandes dont certaines complexes ?
ps: ton second exemple : rien à voir avec le mien beaucoup plus simple : recherche de mots sur le web et autre commande* distincte sur disque dur, toi, je ne vois pas de (simulation de) commande* mais juste un parcours des mots
* : oui, mes commandes ne sont que des "print"

De plus, tu ne sembles pas avoir lu la doc

case ['rechercher',*params] | ['recherche', *params] if 'web' in params: pas top ok mais existe d'autres formes ! Mais en fonction de ton besoin (et si j'écris toutes les formes, tu vas justement me dire que c'est trop compliqué )

case [('cherche'|'chercher'|'recherche'), *params]:.
ou, ce qui me semble plus réaliste suivant ta demande (commandes vocales) :

Code :

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

1
2
cles_recherche = ('trouver','cherche','chercher','recherche','rechercher') # lire depuis params de l'app
   case cles_recherche as action, *params: print(action, params)

Pas de regex dans la condition case (type case [regex,autre]) mais il est possible dans match d'avoir le résultat d'une regex

[wiztricks]

Je ne vois pas d'autres manières de faire... Dites-moi comment vous auriez géré la chose si le cœur vous en dit !?

On étudie le command pattern pour en comprendre la structure, comment l'adapter à son code et les simplifications dans sa réalisation avec Python.

- W