AttributeError: 'module' object has no attribute 'exc_info'

**hlmhv** · 05/03/2023, 22h19

Envoyé par papajoker

Tu parles ici de pascal donc pas notre problème

Dans le second cas, je ne parle que de lancer un seul TProcess ! ensuite, on utilise que input et output. Et oui, surtout en graphique il faut éviter les blocages (attente de output), mais ici c'est une question purement pascal. En python on sait faire, si pascal non, alors c'est lui le jouet.

Hmm il me semble que le problème de l'accès à un fichier disque est universel, mais oublions cela et je vais voir demain comment suivre ton idée..

**papajoker** · 06/03/2023, 08h37

Envoyé par hlmhv

un fichier disque est universel

Certainement pas dans ton cas

Je t'avais indiqué la solution "universelle" dans l'autre sujet

Après, puisque c'est pascal qui lance ton script python, et je suppose le ferme lorsqu'il se ferme, la solution client/serveur est universelle. (tu n'as jamais fait de client/serveur en 40 ans de code ????? Toujours préféré l'échange de fichiers dans les 2 sens

)
Créer un serveur http en python et ton pascal fait de simples requetes http après l'avoir lancé. Pour moi, la solution certainement la plus simple/universelle. Mais si tu n'as jamais fait d'api web, peut-être pas si simple pour toi ? (existe d'autres protocoles que le simple http mais je ne connais pas assez pascal pour savoir ce qu'il supporte - oops pas celui-ci)

**hlmhv** · 06/03/2023, 10h02

Envoyé par papajoker

Certainement pas dans ton cas

Je t'avais indiqué la solution "universelle" dans l'autre sujet

Après, puisque c'est pascal qui lance ton script python, et je suppose le ferme lorsqu'il se ferme, la solution client/serveur est universelle. (tu n'as jamais fait de client/serveur en 40 ans de code ????? Toujours préféré l'échange de fichiers dans les 2 sens

)
Créer un serveur http en python et ton pascal fait de simples requetes http après l'avoir lancé. Pour moi, la solution certainement la plus simple/universelle. Mais si tu n'as jamais fait d'api web, peut-être pas si simple pour toi ? (existe d'autres protocoles que le simple http mais je ne connais pas assez pascal pour savoir ce qu'il supporte - oops pas celui-ci)

Non je n'ai jamais créé de serveur http car je n'en ai jamais eu besoin: mes logiciels géraient des BD locales donc pas besoin d'autre chose que Pascal & Paradox (je sais çà date!

).
En fait je me suis sans doute très mal exprimé: Pascal ne lance PAS Python: je lance un fichier .py, un .exe et je tente de les faire dialoguer via un fichier texte.
Je constate que finalement Python fait son job dans sa version actuelle: c'est l'autre qui n'aime pas ouvrir des fichiers..

Enfin merci hein?

**papajoker** · 06/03/2023, 10h24

Donc , en fait l'histoire d'input n'avait aucun sens

Et puisque tu dis lancer python toujours avant, alors c'est encore plus logique que python soit un serveur

je n'ai jamais ... finalement Python fait son job dans sa version actuelle

Avant ta première fois, tu n'avais jamais utilisé paradox ... heureusement qu'à l'époque, tu avais un autre état d'esprit car tu pouvais aussi utiliser ta solution universelle les fichiers maison.
Je te signale qu'il y a encore quelques jours, tu n'avais encore jamais codé en python et cela ne t'a pas arrêté

je n'ai jamais créé de serveur http

je m'en doute car Delphi/Laz n'est certainement pas fait pour cela. python intègre déjà un mini serveur http

Et existe des libs pour faire des api. Il faut comprendre que python n'a pratiquement pas de limites alors que delphi/Laz est une solution extrêmement limitée.

EDIT

Comme l'exemple précédent avec input, un mini mini serveur http qui commande un moteur
- on donne les ordres par POST
- on consulte états par GET

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
#!/bin/env python
from http.server import BaseHTTPRequestHandler, HTTPServer
 
class Moteur:
    def __init__(self) -> None:
        self.direction = "?"
    # def stop(), def start() ...
moteur = Moteur()
'''
on pourrait avoir plusieurs moteurs et des url du type /moteur/1/stop ou  /stop/moteur/4
'''
 
class Serveur(BaseHTTPRequestHandler):
 
    def _set_response(self):
        self.send_response(200)
        self.send_header('Content-type', 'text/json')
        self.end_headers()
 
    def write_json(self, text, ok=True):
        response = f"{{'result': '{'OK' if ok else 'ERROR'}', 'message': '{text}'}}\n"
        self.wfile.write(response.encode())
 
    def do_GET(self):
        self._set_response()
        if self.path == "/direction":
            response = f"truc tourne en ce moment à {moteur.direction}"
            self.write_json(response)
            return
        if self.path == "/droite":
            response = f"{'OK' if moteur.direction=='droite' else 'NON'}"
            self.write_json(response)
            return
        if self.path == "/gauche":
            response = f"{'OK' if moteur.direction=='gauche' else 'NON'}"
            self.write_json(response)
            return
 
        if self.path == "/quit":   # plutot dans POST...
            exit(0)
 
        if self.path:
            self.write_json(f"{self.path} commande GET inconnue...", False)
 
 
    def do_POST(self):
        content_length = int(self.headers['Content-Length'])
        post_data = self.rfile.read(content_length).decode('utf-8')
        self._set_response()
        if self.path in ("/droite", "/gauche"):
            moteur.direction = self.path[1:]
            # moteur.tourner(post_data);
            self.write_json(f"truc a bien tourné à {moteur.direction} avec `{post_data}`.")
            return
 
        if self.path:
            self.write_json(f"{self.path} commande POST inconnue!")
 
 
def run(server_class=HTTPServer, handler_class=Serveur, port=8080):
    httpd = server_class(('', port), handler_class)
    try:
        httpd.serve_forever()
    except KeyboardInterrupt:
        pass
    httpd.server_close()
 
 
if __name__ == '__main__':
    run()

exemple (sous linux)
avec pascal: interroger: TFpHttpClient.Get('http://127.0.0.1:8080/direction') et pour lancer une commande TFpHttpClient.POST(url, lesdatas)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
curl http://127.0.0.1:8080/direction
{'result': 'ok', 'message': 'truc tourne en ce moment à ?'}
curl http://127.0.0.1:8080/droite -X POST --data-binary 'blablaetbla'
{'result': 'ok', 'message': 'truc a bien tourné à droite avec `blablaetbla`.'}
curl http://127.0.0.1:8080/direction
{'result': 'ok', 'message': 'truc tourne en ce moment à droite'}
curl http://127.0.0.1:8080/gauche
{'result': 'ok', 'message': 'NON'}
curl http://127.0.0.1:8080/toto
{'result': 'ERROR', 'message': '/toto commande GET inconnue...'}
curl http://127.0.0.1:8080/quit    # pour fermer le serveur

ps: existe des lib python pour faire des api http, mais ici j'ai voulu sans mais c'est le même principe (simple)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
@app.post("/moteurs/{moteur_id}/vitesse/{vitesse}")
async def set_vitesse(moteur_id, vitesse):
    moteurs[moteur_id].vitesse = vitesse
    return { 'vitesse': moteurs[moteur_id].get_vitesse() }
 
@app.get("/moteurs/{moteur_id}/vitesse")
async def get_vitesse(moteur_id):
    return { 'vitesse': moteurs[moteur_id].get_vitesse() }
 
@app.get("/moteurs")
async def set_vitesse(moteur_id, vitesse):
    return { 'count': len(moteurs), 'moteurs': [m.name for m in moteurs]}

On peut voir que, pour le codeur, le seul véritable travail supplémentaire d'utiliser un serveur http est de définir nous même l'api que vont partager les 2 applications (urls et usage)

**umfred** · 06/03/2023, 18h17

Perso, je ne comprends pas l'intérêt du passage par python entre Lazarus et la brique lego. Je vois mal ce que python peut faire que lazarus ne pourrai pas faire (même si je connais pas trop lazarus).
Pour moi il y a un code dans la brique (donc micro python) qui interagit avec l'extérieur (comment ? Entrées/sorties? port de communication ?)
Et UN code côté PC qui envoie les commandes adéquates à la brique. Pourquoi faire compliqué quand on peut faire simple ?

Précise peut-être quelle brique et ce que tu veux pouvoir lui faire faire côté PC, bref le but de ton projet

**papajoker** · 06/03/2023, 20h32

Et en regardant vite fait (enfin) le framework, je me rends compte que tu utilises une lib micro-python alors que tu nous disais que c'était ok avec python ???
https://www.ev3dev.org/docs/programming-languages/
Cela veut dire que avant de débuter ton Gui , tu n'as même pas testé ev3 ?

Et amusant (*), existe un serveur web dans cette lib ... ce qui ne m'étonne pas du tout puisque c'est un moyen de communication standard.

Envoyé par umfred

Je vois mal ce que python peut faire que lazarus ne pourrai pas faire

Vu la lib (et ces portages en différents langages) donnée dans mon premier lien, la porter en pascal va demander beaucoup de compétences

Si j'ai bien compris, il faut lire/écrire dans des fichiers virtuels (donc ne fonctionne que sous linux?)

**hlmhv** · 08/03/2023, 11h58

Envoyé par papajoker

Donc , en fait l'histoire d'input n'avait aucun sens

Et puisque tu dis lancer python toujours avant, alors c'est encore plus logique que python soit un serveur

Avant ta première fois, tu n'avais jamais utilisé paradox ... heureusement qu'à l'époque, tu avais un autre état d'esprit car tu pouvais aussi utiliser ta solution universelle les fichiers maison.

Rigole pas: je l'ai fait! J'ai eu dans ma vie des moments de dêche +++ et acheter Paradox était lourd, du coup j'ai créé à l'époque un système de BD qui fonctionnait bien.. pour ce que je lui demandais çàd gérer deux tables liées, quelques centaines d'items contenant chacun 1 ou 2k de données..

Bon, mon PC avait 512k de ram et un HD de 30 Mo, aussi. Fallait être économe!

Ceci dit, dans le problème qui m'occupe Python & Lazarus sont tous deux serveurs et serveur puisqu'il y a échange: Lazarus donne des commandes, Python les reçoit.. mais python envoie aussi un accusé de réception ou les data demandés par Lazarus!
Mais deux fichiers de dialogue distincts bien sûr..

Envoyé par papajoker

je m'en doute car Delphi/Laz n'est certainement pas fait pour cela. python intègre déjà un mini serveur http

Et existe des libs pour faire des api. Il faut comprendre que python n'a pratiquement pas de limites alors que delphi/Laz est une solution extrêmement limitée.

J'en suis bien conscient et si je disposais d'un RAD graphique pour Python je me passerais de Lazarus! Je n'ai aucun a priori contre python même si je suis un peu dérouté par sa syntaxe. Par exemple je me sens bcp plus sécure en Pascal où les variables sont déclarées avant leur utilisation ce que je trouve très confortant.

Envoyé par papajoker

EDIT

Comme l'exemple précédent avec input, un mini mini serveur http qui commande un moteur
- on donne les ordres par POST
- on consulte états par GET

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
#!/bin/env python
from http.server import BaseHTTPRequestHandler, HTTPServer
 
class Moteur:
    def __init__(self) -> None:
        self.direction = "?"
    # def stop(), def start() ...
moteur = Moteur()
'''
on pourrait avoir plusieurs moteurs et des url du type /moteur/1/stop ou  /stop/moteur/4
'''
 
class Serveur(BaseHTTPRequestHandler):
 
    def _set_response(self):
        self.send_response(200)
        self.send_header('Content-type', 'text/json')
        self.end_headers()
 
    def write_json(self, text, ok=True):
        response = f"{{'result': '{'OK' if ok else 'ERROR'}', 'message': '{text}'}}\n"
        self.wfile.write(response.encode())
 
    def do_GET(self):
        self._set_response()
        if self.path == "/direction":
            response = f"truc tourne en ce moment à {moteur.direction}"
            self.write_json(response)
            return
        if self.path == "/droite":
            response = f"{'OK' if moteur.direction=='droite' else 'NON'}"
            self.write_json(response)
            return
        if self.path == "/gauche":
            response = f"{'OK' if moteur.direction=='gauche' else 'NON'}"
            self.write_json(response)
            return
 
        if self.path == "/quit":   # plutot dans POST...
            exit(0)
 
        if self.path:
            self.write_json(f"{self.path} commande GET inconnue...", False)
 
 
    def do_POST(self):
        content_length = int(self.headers['Content-Length'])
        post_data = self.rfile.read(content_length).decode('utf-8')
        self._set_response()
        if self.path in ("/droite", "/gauche"):
            moteur.direction = self.path[1:]
            # moteur.tourner(post_data);
            self.write_json(f"truc a bien tourné à {moteur.direction} avec `{post_data}`.")
            return
 
        if self.path:
            self.write_json(f"{self.path} commande POST inconnue!")
 
 
def run(server_class=HTTPServer, handler_class=Serveur, port=8080):
    httpd = server_class(('', port), handler_class)
    try:
        httpd.serve_forever()
    except KeyboardInterrupt:
        pass
    httpd.server_close()
 
 
if __name__ == '__main__':
    run()

exemple (sous linux)
avec pascal: interroger: TFpHttpClient.Get('http://127.0.0.1:8080/direction') et pour lancer une commande TFpHttpClient.POST(url, lesdatas)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
curl http://127.0.0.1:8080/direction
{'result': 'ok', 'message': 'truc tourne en ce moment à ?'}
curl http://127.0.0.1:8080/droite -X POST --data-binary 'blablaetbla'
{'result': 'ok', 'message': 'truc a bien tourné à droite avec `blablaetbla`.'}
curl http://127.0.0.1:8080/direction
{'result': 'ok', 'message': 'truc tourne en ce moment à droite'}
curl http://127.0.0.1:8080/gauche
{'result': 'ok', 'message': 'NON'}
curl http://127.0.0.1:8080/toto
{'result': 'ERROR', 'message': '/toto commande GET inconnue...'}
curl http://127.0.0.1:8080/quit    # pour fermer le serveur

ps: existe des lib python pour faire des api http, mais ici j'ai voulu sans mais c'est le même principe (simple)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
@app.post("/moteurs/{moteur_id}/vitesse/{vitesse}")
async def set_vitesse(moteur_id, vitesse):
    moteurs[moteur_id].vitesse = vitesse
    return { 'vitesse': moteurs[moteur_id].get_vitesse() }
 
@app.get("/moteurs/{moteur_id}/vitesse")
async def get_vitesse(moteur_id):
    return { 'vitesse': moteurs[moteur_id].get_vitesse() }
 
@app.get("/moteurs")
async def set_vitesse(moteur_id, vitesse):
    return { 'count': len(moteurs), 'moteurs': [m.name for m in moteurs]}

On peut voir que, pour le codeur, le seul véritable travail supplémentaire d'utiliser un serveur http est de définir nous même l'api que vont partager les 2 applications (urls et usage)

Alors là, BRAVO!
A priori la bonne solution.
Maintenant - et tu n'y es pour rien - je dois étudier ton code avec attention car je pénètre dans un domaine totalement inconnu pour moi. J'avoue très humblement que je ne pensais pas devoir utiliser un HTTP pour gérer un moteur!

Merci pour ton aide, je vais lire cela!

**umfred** · 09/03/2023, 12h54

Je réitère ma question (peut-être passée inaperçu)

Tu as dis

Brique Lego <--> Python sur PC <--> 2 fichiers d'échange (commande & réponse) <--> Lazarus.

que j'interpréte:
brique lego (on vient d'appendre que c'est une brique moteur, on avance) <=> PC <=> python <=>lazarus

Questions: tu interfaces comment ton moteur avec ton moteur ? interfaçage à la brique moteur ou via la brique EV3 de contrôle (et donc dans le mode de contrôle à distance) ?
Et dans ce cas-là, peut-être avoir beaucoup (?) de petits programmes python qui réalisent des choses basiques (avec passage et envoi/affichage de paramètres éventuellement) et utiliser Lazarus comme centralisateur qui fait exécuter les petits programmes nécessaires pour commander/récupérer les infos.

Et il n'y a qu'un serveur dans ce qui a été proposé: le serveur python. Lazarus est un client qui s'y connecte et y envoie des requêtes auxquelles le serveur python répond par une action côté Lego et/ou message en retour de la requête.

**hlmhv** · 09/03/2023, 15h19

Envoyé par umfred

Je réitère ma question (peut-être passée inaperçu)

Tu as dis

que j'interpréte:
brique lego (on vient d'appendre que c'est une brique moteur, on avance) <=> PC <=> python <=>lazarus

Questions: tu interfaces comment ton moteur avec ton moteur ? interfaçage à la brique moteur ou via la brique EV3 de contrôle (et donc dans le mode de contrôle à distance) ?

Et dans ce cas-là, peut-être avoir beaucoup (?) de petits programmes python qui réalisent des choses basiques (avec passage et envoi/affichage de paramètres éventuellement) et utiliser Lazarus comme centralisateur qui fait exécuter les petits programmes nécessaires pour commander/récupérer les infos.

Et il n'y a qu'un serveur dans ce qui a été proposé: le serveur python. Lazarus est un client qui s'y connecte et y envoie des requêtes auxquelles le serveur python répond par une action côté Lego et/ou message en retour de la requête.

C'est exactement cela: via la brique EV3. Laquelle n'est plus dans son état natif: j'ai changé son OS pour Debian Linux adapté (https://www.ev3dev.org/), ce qui me donne accès aux objets (moteurs, senseurs..).
Et comme je désire avoir un pupitre de commande graphique, je le crèe via Lazarus.
Maintenant que je peux faire communiquer la brique avec le PC, je suis content!

Soit dit en passant je pourrais maintenant faire exactement la même chose sans la brique, mais avec un Raspberry + BrickPi. Je les ai aussi, faudra que je réfléchisse à coupler tout ce cheptel..

**papajoker** · 09/03/2023, 19h58

Si maintenant tu es sous linux ...

Envoyé par papajoker

la porter en pascal va demander beaucoup de compétences

Si j'ai bien compris, il faut lire/écrire dans des fichiers virtuels (donc ne fonctionne que sous linux?)

Tu dois avoir ces répertoires virtuels ? donc comme les libs python et autres langages, il te suffit de directement lire/écrire dans le répertoire en pascal. C'était la première chose donnée dans le lien que je t'avais donné.

The drivers use sysfs to interact with user space (user space is anything outside of the kernel). Each hardware device is represented by a directory in sysfs called a device node. Each device node has attributes that are represented by files. You monitor and control the hardware by reading and writing these attribute files.

ps: peut-être qu'il faut a la limite la lib python mais uniquement pour monter ce répertoire virtuel ?

-----------
Note , pour info uniquement:

je ne pensais pas devoir utiliser un HTTP pour gérer un moteur!

Si tu désirais une solution "plus pro", tu pouvais voir GRPC mais la mise en œuvre n'est pas forcément simple et les libs pascal sont encore figées au siècle dernier donc ne connait pas... (ici c'est une surcouche à http, on appelle plus une url mais une fonction virtuelle à laquelle on passe des paramètres comme toute fonction) un Cousin du CORBA bien connu chez delphi

AttributeError: 'module' object has no attribute 'exc_info'

Python

Discussions similaires

Partager

Partager