Discussion :

[quentinb56]

Bonjour,

Je ne souhaite pas installer de librairies et je les ai donc téléchargé et placé dans un répertoire lib de mon projet.



Cependant je suis obligé de renseigner le path à chaque reprises et dans chacune de mes classes.
Auriez-vous une solution pour gérer cela ?

J'ai remarqué dans certains projets que les gens géraient les imports dans les __init__ de chaque packages.
Est ce une bonne pratique et cela me permettrait t'il de faire une seule fois le path et ensuite d'appeler via from . import ou from .. import ?

Ma seconde question ...

Mon programme possède deux classes qui héritent de Thread.

Ma première classe est un serveur web sous Flask.
La seconde classe est un serveur Socket.

L'idée est la suivante. Lorsque l'utilisateur réalise une action, celle-ci est transmise à tous les clients qui écoutent le serveur socket.

Pour cela mon serveur web doit pouvoir accéder aux fonctions du serveur Socket.

Cependant je ne peux pas importer mon serveur socket dans mon serveur web si non je suis en présence d'une boucle (les deux serveurs étant tous deux appelés dans un seul serveur).

Ci-joint mon code (qui n'est qu'une ébauche), j'ai trouvé une solution qui ne me plait pas... J'ai passé mon objet serveur socket à ma classe serveur Flask (partie commentée dans mon code)

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
#!/usr/bin/env python -B
# -*- coding: utf-8 -*-
 
from utils.debugger import printer
from controller.server.zWeb import ZwebServer
from controller.server.zSocket import ZsocketServer
 
class ZServeurMain():
    def __init__(self, pArgs):
        printer('__init__()', __file__)
        self.args = pArgs
        #self.runSocketServer()
        self.runWebServer()
 
        print 'Démarrage des deux serveurs'
        self.zWeb.join()
        print 'Extinction du server web'
        #self.zSocket.set_isRunning(False)
        #self.zSocket.join()
        print 'stop all thread'
        exit(0)
 
    def runWebServer(self):
        printer('runWebServer()', __file__)
        #self.zWeb = ZwebServer(self.zSocket,'', self.args.get_web_port())
        self.zWeb = ZwebServer(None,'', self.args.get_web_port())
        self.zWeb.start()
 
    def runSocketServer(self):
        printer('runSocketServer()', __file__)
        self.zSocket = ZsocketServer('',5000)
        self.zSocket.start()

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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
#/usr/bin/env python
# -*- coding:utf-8 -*-
 
import os
import sys
import socket, select
 
from threading import Thread
from utils.debugger import printer
from utils.utilsFonction import init_var
from utils.globals import RECV_BUFFER, DEFAULT_SOC_PORT, DEFAULT_SOC_HOST
 
HOST = DEFAULT_SOC_HOST
PORT = DEFAULT_SOC_PORT
 
class ZsocketServer(Thread):
 
    def __init__(self, pHost, pPort):
        printer('__init__()', __file__)
 
        global HOST, PORT
        HOST = init_var(HOST,pHost)
        PORT = init_var(PORT,pPort)
 
        Thread.__init__(self)
 
        self.isRunning = True
        self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.server_socket.bind((HOST, PORT))
        self.server_socket.listen(10)
        self.connection_list = []
        self.connection_list.append(self.server_socket)
 
    def run(self):
        while self.isRunning:
            print 'on boucle'
            read_sockets,write_sockets,error_sockets = select.select(self.connection_list,[],[])
            print 'on boucle 1'
            for sock in read_sockets:
                if sock == self.server_socket:
                    sockfd, addr = self.server_socket.accept()
                    self.connection_list.append(sockfd)
                    print "Client (%s, %s) connected" % addr
 
                    self.broadcast_data(sockfd, "essai")
                else:
                    try:
                        data = sock.recv(RECV_BUFFER)
                        if data:
                            self.broadcast_data(sock, "\r" + '<' + str(sock.getpeername()) + '> ' + data)
                    except:
                        self.broadcast_data(sock, "Client (%s, %s) is offline" % addr)
                        print "Client (%s, %s) is offline" % addr
                        sock.close()
                        self.connection_list.remove(sock)
                        continue
        print 'fermeture socket'
        self.server_socket.close()
 
    def broadcast_data (self, sock, message):
        for socket in self.connection_list:
            if socket != self.server_socket and socket != sock :
                try :
                    socket.send(message)
                except :
                    socket.close()
                    self.connection_list.remove(socket)
 
    def transmitte_order(self, message):
        for socket in self.connection_list:
            if socket != self.server_socket:
                try :
                    socket.send(message)
                except:
                    socket.close()
                    self.connection_list.remove(socket)
 
    def get_isRunning(self):
        return self.isRunning
 
    def set_isRunning(self, pValue):
        self.isRunning = pValue
        print 'passage à {}'.format(pValue)

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
#/usr/bin/env python
# -*- coding:utf-8 -*-
 
import os
import sys
 
sys.path.append(os.path.abspath('{}/../../../../lib/'.format(os.path.realpath(__file__))))
 
from flask import Flask, request, render_template, make_response
from threading import Thread
from utils.debugger import printer
from utils.utilsFonction import init_var
from utils.globals import DEFAULT_WEB_HOST, DEFAULT_WEB_PORT
 
print os.path.abspath('{}/../../../view/templates'.format(os.path.realpath(__file__)))
app = Flask(__name__, template_folder=os.path.abspath('{}/../../../view/templates'.format(os.path.realpath(__file__))))
 
HOST = DEFAULT_WEB_HOST
PORT = DEFAULT_WEB_PORT
SOCKET = None
 
class ZwebServer(Thread):
 
	def __init__(self, pSocket, pHost, pPort):
		printer('__init__()', __file__)
 
		global HOST, PORT, SOCKET
		HOST = init_var(HOST,pHost)
		PORT = init_var(PORT,pPort)
		SOCKET = init_var(SOCKET,pSocket)
		Thread.__init__(self)
 
	def run(self):
		app.run(host=HOST, port=PORT)
 
        @app.route('/shutdown', methods=['GET', 'POST'])
	def shutdown():
		shutdown_server()
		return 'Server shutting down...'
 
        @app.route('/', methods=['GET', 'POST'])
	def pg_accueil():
	    return 'Accueil !'
 
        @app.route('/acc')
	def pg_acc():
		return render_template('accueil.html')
 
        @app.route('/transmit', methods=['GET', 'POST'])
	def pg_transmitte():
		SOCKET.transmitte_order('test')
		return 'Transmit !'
 
        @app.errorhandler(404)
	def ma_page_404(error):
		return "Ma jolie page error 404"
 
 
def shutdown_server():
	func = request.environ.get('werkzeug.server.shutdown')
	if func is None:
		raise RuntimeError('Not running with the Werkzeug Server')
	func()

Je suis à l'écoute de toutes les critiques possibles sur mon code pour pouvoir l'améliorer !!!

En vous remerciant d'avance.

Cordialement Quentin

[wiztricks]

Cependant je suis obligé de renseigner le path à chaque reprises et dans chacune de mes classes.
Auriez-vous une solution pour gérer cela ?

renseigner la variable d'environnement PYTHONPATH ou utiliser un virtualenv?

J'ai remarqué dans certains projets que les gens géraient les imports dans les __init__ de chaque packages.
Est ce une bonne pratique et cela me permettrait t'il de faire une seule fois le path et ensuite d'appeler via from . import ou from .. import ?

"import" charge un package s'il n'est pas déjà chargé et définit une ou plusieurs variables globales associé aux objets importés.
La portée d'une variable globale étant limité au module, çà ne devrait pas changer grand chose.

Ma seconde question ...

Désolé j'ai rien compris.

- W

[quentinb56]

Code :

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

sys.path.append(os.path.abspath('{}/../../../../lib/'.format(os.path.realpath(__file__))))

Je donne la localisation du répertoire des librairies à utiliser. Je n'utilise pas de virtualenv.

Je souhaite comme je le disais éviter de devoir répéter dans plusieurs classes cette ligne (sans à avoir à installer les librairies)

pour ma seconde question.

Je pense que le code parle de lui même.

Il s'agit de deux classes qui héritent de Thread, l'exécution est donc parallèle. L'une des deux classes à besoins de l'autre pour exécuter certaines de ces méthodes.

Je souhaite donc lancer des fonctions dans mon serveur web (exemple : def pg_transmitte() qui appelle transmitte_order() en évitant de passer en paramètre de la classe la seconde classe.

[wiztricks]

Code :

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

sys.path.append(os.path.abspath('{}/../../../../lib/'.format(os.path.realpath(__file__))))

Je donne la localisation du répertoire des librairies à utiliser. Je n'utilise pas de virtualenv.

C'est bien dommage. Il vous reste donc à envisager d'utiliser PYTHONPATH.

Je pense que le code parle de lui même.

Le problème n'est pas le code mais l'impression que vous donnez de ré-inventer les SocketIO.
Soit vous ne connaissez pas et vous vous lancez à coder un truc sans avoir fait le tour de l'état de l'art, soit vous avez la prétention de réaliser une meilleure implémentation, soit vous pensez que vous n'avez pas besoin de tout çà et qu'écrire un truc sur un coin de table sera bien suffisant.

Je souhaite donc lancer des fonctions dans mon serveur web (exemple : def pg_transmitte() qui appelle transmitte_order() en évitant de passer en paramètre de la classe la seconde classe.

Dans le cas de communication thread à thread, appeler la méthode d'un autre thread c'est comme envoyer un message.
Et si vous ne savez pas à qui/comment l'envoyer, çà ne pourra pas fonctionner. Mais vous pouvez le déposer dans une Queue lue par le thread destinataire.

- W

[quentinb56]

Je ne souhaitais pas donner l'impression de ré-inventer la roue, je n'en ai pas la prétention ni les capacités (mais contrairement à certaines personnes j'en ai conscience).

Il ne s'agit pas de ma première remarque envers tes réponses qui manquent de diplomaties. Tu oublies régulièrement que tu n'as pas toujours eu ses connaissances et que tu as débuté en tant que qu'initié.

Je suis à la recherche de remarques constructives qui me permettront d'appréhender mes erreurs. Ma manière de coder n'est pas la meilleure mais comme indiqué dans le premier post je recherche des conseils et des avis constructifs.

En l'occurence je sais à qui/ et ou l'envoyer mais ne sait pas comment le mettre en oeuvre.

Le message est émis par les méthodes du thread du serveur web.
Le message est émis à des méthodes du thread du serveur de socket.

Comment mettre en place une pile FIFO pour qu'elle soit accessible par les deux threads ?

Merci du temps que tu accordes au sujet, avec plus de diplomaties les débutants ne seraient pas résignés à coder d'une mauvaise manière par peur d'être pris pour cible par un membre qui relèvera l'emploi inapproprié d'un mot... ou de mauvaises méthodes

A bonne entendeur !

[wiztricks]

Je ne souhaitais pas donner l'impression de ré-inventer la roue, je n'en ai pas la prétention ni les capacités (mais contrairement à certaines personnes j'en ai conscience).

Il ne s'agit pas de ma première remarque envers tes réponses qui manquent de diplomaties. Tu oublies régulièrement que tu n'as pas toujours eu ses connaissances et que tu as débuté en tant que qu'initié.

Vous n'êtes pas en train d’essayer de faire l'exercice d'un tuto mais de réaliser un vrai projet où il serait mieux d'avoir un peu plus que les compétences d'un débutant pour le mener à bien.

Comment mettre en place une pile FIFO pour qu'elle soit accessible par les deux threads ?

Je vous ai déjà indiqué le module Queue.

- W

[quentinb56]

Petit retour sur les solutions apportées.

Le module Queue :

Le module doit être passé en paramètre de mes deux classes (jusque la pas de soucis).



Cependant je ne vois pas comment l'implémenter par la suite dans mon code...
Je suis en présence d'une boucle while qui reste ensuite bloqué sur mon select.

Si mon autre thread remplit l'objet Queue comment celui ci pourrait il être lu dans la boucle si je reste à l'arrêt sur le select ?

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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
#/usr/bin/env python
# -*- coding:utf-8 -*-
 
import os
import sys
import socket, select
 
from threading import Thread
from utils.debugger import printer
from utils.utilsFonction import init_var
from utils.globals import RECV_BUFFER, DEFAULT_SOC_PORT, DEFAULT_SOC_HOST
 
HOST = DEFAULT_SOC_HOST
PORT = DEFAULT_SOC_PORT
 
class ZsocketServer(Thread):
 
    def __init__(self, pHost, pPort):
        printer('__init__()', __file__)
 
        global HOST, PORT
        HOST = init_var(HOST,pHost)
        PORT = init_var(PORT,pPort)
 
        Thread.__init__(self)
 
        self.isRunning = True
        self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.server_socket.bind((HOST, PORT))
        self.server_socket.listen(10)
        self.connection_list = []
        self.connection_list.append(self.server_socket)
 
    def run(self):
        while self.isRunning:
            print 'on boucle'
            read_sockets,write_sockets,error_sockets = select.select(self.connection_list,[],[])
            print 'on boucle 1'
            for sock in read_sockets:
                if sock == self.server_socket:
                    sockfd, addr = self.server_socket.accept()
                    self.connection_list.append(sockfd)
                    print "Client (%s, %s) connected" % addr
 
                    self.broadcast_data(sockfd, "essai")
                else:
                    try:
                        data = sock.recv(RECV_BUFFER)
                        if data:
                            self.broadcast_data(sock, "\r" + '<' + str(sock.getpeername()) + '> ' + data)
                    except:
                        self.broadcast_data(sock, "Client (%s, %s) is offline" % addr)
                        print "Client (%s, %s) is offline" % addr
                        sock.close()
                        self.connection_list.remove(sock)
                        continue
        print 'fermeture socket'
        self.server_socket.close()
 
    def broadcast_data (self, sock, message):
        for socket in self.connection_list:
            if socket != self.server_socket and socket != sock :
                try :
                    socket.send(message)
                except :
                    socket.close()
                    self.connection_list.remove(socket)
 
    def transmitte_order(self, message):
        for socket in self.connection_list:
            if socket != self.server_socket:
                try :
                    socket.send(message)
                except:
                    socket.close()
                    self.connection_list.remove(socket)
 
    def get_isRunning(self):
        return self.isRunning
 
    def set_isRunning(self, pValue):
        self.isRunning = pValue
        print 'passage à {}'.format(pValue)

Merci d'avance.

Cordialement Quentin.

[quentinb56]

Pour la solution du pythonpath :



Il s'agit de la solution que j'avais mis en place.

Le principal inconvénient est que je dois le rappeler dans chacune de mes pages (scripts).

Il y a aussi cette solution.



Cette commande peut être réaliser dans le __init__ du projet mais la portée n'est pas à l'exécution du programme mais du terminal si je ne me trompe pas... Ce qui me pose problème.

J'avais émis l'idée de réaliser la première solution que j'évoquais dans mon __init__ et d'ensuite appeler toutes les librairies du projet dans l' __init__ en augmentant sa portée dans chacun des sous-dossiers appelant de la manière suivante les librairies.

Code :

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

from .. import nom_lib

Cette solution n'est pas élégante mais je la préfère à celle d'appeler sys.path.append dans chaque scripts.

Qu'en pensez vous ?

[wiztricks]

Si mon autre thread remplit l'objet Queue comment celui ci pourrait il être lu dans la boucle si je reste à l'arrêt sur le select ?

select accepte un timeout qui permet d'en sortir (queue.get aussi d'ailleurs).

Cette commande peut être réaliser dans le __init__ du projet mais la portée n'est pas à l'exécution du programme mais du terminal si je ne me trompe pas... Ce qui me pose problème.

__init__ ne contient que des instructions Python. export PYTHONPATH... c'est du bash. Si vous ne voulez pas l'exécuter à chaque fois, il suffit de la mettre dans .bashrc (par exemple).

- W

[quentinb56]

Merci pour les réponses je m'en vais regarder le timeout du Select !!

Pour le __init__ ne puis je pas réaliser la commande à l'aide de os.system ?

[wiztricks]

Pour le __init__ ne puis je pas réaliser la commande à l'aide de os.system ?

Autant écrire sys.path.append(...)...
De toutes façons, il y a plein de solutions... Donc c'est comme vous voulez.
Personnellement, j'essaie d'utiliser des solutions "standards".
Ce qui évite d'avoir à les documenter pour éviter de patauger quand on essaie de s'y retrouver 6 mois plus tard.
Dans votre cas, une solution "standard" (et déjà documentée dans flask) est de passer par un virtualenv.

- W

[quentinb56]

Je me permets de relancer sur un autre sujet, au besoin j'ouvrirais un nouveau poste.

Avec SQLAlchemy je rencontre un problème dont je n'arrive pas à déterminer l'origine...

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
#!/usr/bin/env python -B
# -*- coding: utf-8 -*-
 
from . import create_engine
from . import declarative_base
from . import scoped_session, sessionmaker
 
import os
import sys
 
dbPath = os.path.abspath('{}/../../../db/'.format(os.path.realpath(__file__)))
 
engine = create_engine('sqlite:///{}/database.sqlite3'.format(dbPath), convert_unicode=True, echo=True)
db_session = scoped_session(sessionmaker(autocommit=False,
                                         autoflush=False,
                                         bind=engine))
Base = declarative_base()
Base.query = db_session.query_property()
 
def init_db():
    print 'init_db'
 
    #db_session.remove()
    Base.metadata.drop_all(bind=engine)
 
    from model.user import User
    #Base.metadata.create_all(bind=engine)
 
    # Create the fixtures
    #user = User(name='Quentin')
    #db_session.add(user)
 
    #db_session.commit()
 
    for user in db_session.query(User).all():
        print "ID : {0} , USER : {1}".format(user.id, user.name)

Mon drop_all ne fonctionne pas et surtout mon echo ne me dit absolument rien ...

Une idée ?

[wiztricks]

Mon drop_all ne fonctionne pas et surtout mon echo ne me dit absolument rien ...

Une idée ?

Est-ce que çà fonctionne avec une version de Python/Sqlalchemy supportée?
Dit autrement est-ce que vous n'êtes pas en train d'avoir un problème qui n'existe plus?

Et si cette méthode là ne fonctionne pas, vous pouvez essayer d'en explorer d'autres...

- W

[quentinb56]

Python : 2.7
SqlAlchemy : 1.1.10

J'ai commencé à regarder par ca mais je n'ai pas vu de problèmes répertoriés .

Certaines personnes parlaient de problèmes de transactions encore en cours mais à priori le problème ne vient pas de la

[quentinb56]

J'ai trouvé la solution (corrigé mon problème).

J'effectuais le drop_all avant l'import des classes models.

En effectuant le drop_all après l'import cela fonctionne.

Pour le timeout du select maintenant cela fonctionne beaucoup mieux !

[quentinb56]

Bonjour,

Nouveau soucis, je profite du post existant.

Ci-joint deux sites sur lesquels je me basais pour comprendre SqlAlchemy

https://realpython.com/blog/python/p...flask-part-ii/

https://github.com/miguelgrinberg/fl.../app/models.py

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
#!/usr/bin/env python -B
# -*- coding: utf-8 -*-
 
from controller.database import Base
from controller.database import login_manager
from controller import Integer, Column, String, Boolean, DateTime
from controller import generate_password_hash, check_password_hash, UserMixin, AnonymousUserMixin
from controller import hybrid_property
 
import hashlib
 
class User(UserMixin, Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    username = Column(String, nullable=False, unique=True)
    password_hash = Column(String, nullable=False)
    actived = Column(Boolean, default=False)
    last_connection = Column(DateTime)
 
    @property
    def password(self):
        raise AttributeError('password is not a readable attribute')
 
    @password.setter
    def password(self, password):
        self.password_hash = generate_password_hash(password)
 
    def verify_password(self, password):
        return check_password_hash(self.password_hash, password)

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
#!/usr/bin/env python -B
# -*- coding: utf-8 -*-
 
from . import create_engine
from . import declarative_base
from . import scoped_session, sessionmaker
from . import LoginManager
 
import os
import sys
 
dbPath = os.path.abspath('{}/../../../db/'.format(os.path.realpath(__file__)))
 
engine = create_engine('sqlite:///{}/database.sqlite3'.format(dbPath), convert_unicode=True, echo=False)
db_session = scoped_session(sessionmaker(autocommit=False,
                                         autoflush=False,
                                         bind=engine))
Base = declarative_base()
Base.query = db_session.query_property()
 
login_manager = LoginManager()
login_manager.session_protection = 'strong'
login_manager.login_view = 'auth.login'
 
def init_db():
    print 'init_db'
 
    #Base.metadata.drop_all(bind=engine)
 
    from model.user import User
 
    #Base.metadata.drop_all(bind=engine)
 
    Base.metadata.create_all(bind=engine)
 
    # Create the fixtures
    user = User(username='Quentin2', password_hash='Toto')
    db_session.add(user)
 
    db_session.commit()
 
    for user in db_session.query(User).all():
        print "ID : {0} , USER : {1}, PASSWORD : {2}".format(user.id, user.username, user.password_hash)

Donc voici mon problème.

J'essaie de faire en sorte que mon password soit de suite modifié lors de la création.

Auriez-vous une idée de la raison pour laquelle mon password n'est pas hashé ?

[bistouille]

Ton setter se nomme password il me semble, ce serait plus logique d'utiliser password dans la création de ton user et non password_hash.

Mais ce serait plus judicieux de faire comme dans les exemples sur lesquels tu t'appuies, ie _password et setter, getter password qui affecteront _password

[quentinb56]

Merci pour ta réponse. En effet ma syntaxe n'est pas correcte mais je ne fais que des bouts de codes pour savoir ce dont je suis capable et définir par la suite l'architecture que je pourrais me permettre de mettre en place.

Je prends note de ta remarque et j'effectuerai le test demain mais je ne pense pas que renommer ma variable corrigerait mon soucis non ?

[quentinb56]

Suite à la modification j'ai maintenant le message suivant :

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
71
72
73
File "/Users/quentin/Documents/GestOpti/bin/__main__.py", line 9, in <module>
 
    main()
 
  File "/Users/quentin/Documents/GestOpti/bin/__init__.py", line 11, in main
 
    gMain = GServeurMain()
 
  File "/Users/quentin/Documents/GestOpti/bin/controller/server/gServerMain.py", line 15, in __init__
 
    init_db()
 
  File "/Users/quentin/Documents/GestOpti/bin/controller/database.py", line 37, in init_db
 
    user = User(username='Quentin2', password='Toto')
 
  File "<string>", line 4, in __init__
 
  File "/Users/quentin/Documents/GestOpti/lib/sqlalchemy/orm/state.py", line 414, in _initialize_instance
 
    manager.dispatch.init_failure(self, args, kwargs)
 
  File "/Users/quentin/Documents/GestOpti/lib/sqlalchemy/util/langhelpers.py", line 66, in __exit__
 
    compat.reraise(exc_type, exc_value, exc_tb)
 
  File "/Users/quentin/Documents/GestOpti/lib/sqlalchemy/orm/state.py", line 411, in _initialize_instance
 
    return manager.original_init(*mixed[1:], **kwargs)
 
  File "/Users/quentin/Documents/GestOpti/lib/sqlalchemy/ext/declarative/base.py", line 658, in _declarative_constructor
 
    setattr(self, k, kwargs[k])
 
  File "/Users/quentin/Documents/GestOpti/bin/model/user.py", line 26, in password
 
    self.password = generate_password_hash(password)
 
 File "/Users/quentin/Documents/GestOpti/bin/model/user.py", line 26, in password
 
    self.password = generate_password_hash(password)
 
  File "/Users/quentin/Documents/GestOpti/bin/model/user.py", line 26, in password
 
    self.password = generate_password_hash(password)
 
  File "/Users/quentin/Documents/GestOpti/bin/model/user.py", line 26, in password
 
    self.password = generate_password_hash(password)
 
  File "/Users/quentin/Documents/GestOpti/lib/werkzeug/security.py", line 230, in generate_password_hash
 
    h, actual_method = _hash_internal(method, salt, password)
 
  File "/Users/quentin/Documents/GestOpti/lib/werkzeug/security.py", line 192, in _hash_internal
 
    hashfunc=hash_func)
 
  File "/Users/quentin/Documents/GestOpti/lib/werkzeug/security.py", line 64, in pbkdf2_hex
 
    rv = pbkdf2_bin(data, salt, iterations, keylen, hashfunc)
 
  File "/Users/quentin/Documents/GestOpti/lib/werkzeug/security.py", line 104, in pbkdf2_bin
 
    keylen)
 
  File "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/hashlib.py", line 212, in pbkdf2_hmac
 
    prev = prf(prev)
 
  File "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/hashlib.py", line 193, in prf
 
    icpy.update(msg)

[bistouille]

Je prends note de ta remarque et j'effectuerai le test demain mais je ne pense pas que renommer ma variable corrigerait mon soucis non ?

C'est plus par convention et rigueur, et c'est bien plus facile de se dire qu'un setter et getter sont en relations avec un même nom de variable préfixé d'un underscore, qu'avec un nom sommaire chaque fois.
Après chacun fait comme il le sent

Pour ton erreur, j'ai l'impression que tu as utilisé le même nom pour ta variable interne et publique, il doit y avoir un mécanisme derrière qui empêche la récursion infinie, car c'est normalement ce qui se passe quand on fait ce genre de chose.

Code :

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

self.password = generate_password_hash(password)

Tu dois affecter self._password et non self.password, et bien évidemment, ta variable de classe doit se nommer _password.

Code :

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

_password = Column(String, nullable=False)