juste un petit post sur git flow que j’utilise dans les gros projets et quand on travaille à plusieurs.
Le principe est simple, des branches et groupes de branches qui ont chacune un rôle spécifique.
La branche master
va correspondre à notre environnement de prod.
la branche develop
va correspondre à la version en développement, tous les développeurs doivent commencer ici pour créer une nouvelle feature.
Les branches feature/*
correspondent à toutes les features. Chaque nouvelle feature est développé dans la branche feature
puis finish dans la develop.
Les branches release/*
correspondent à toutes les releases. On utilise une branche release pour préparer et publier une nouvelle version.
Les branches hotfix/*
correspondent à tous les hotfixes. On utilise une branche hotfix pour créer rapidement un fix et l’appliquer directement sur la branche master
.
brew install git-flow
apt-get install git-flow
wget -q -O - --no-check-certificate https://github.com/nvie/gitflow/raw/develop/contrib/gitflow-installer.sh | bash
Master
au développeurs et uniquement les lead-dev ou chef de projet peuvent créer une release.La meilleure des solutions pour ne pas se prendre la tête avec Git c’est GitKraken
Voici une cheatsheet qui peut être utile : GitKraken Cheat Sheet
Voilà, c’est assez sommaire mais il y a les infos principales pour bien utiliser Git Flow. Je pense que j’éditerai ce post ou en ferait un nouveau sur des cas pratiques rencontrés.
A la prochaine !
]]>aujourd’hui je vais faire un petit tutoriel sur comment faire une application desktop en Python avec PyQt. Pour ceux qui ne connaissent pas Qt, c’est une librairie graphique qui fournit pas mal d’outils sympas pour faire des interfaces graphiques. Vraiment puissant et sympa à utiliser, je le conseille vivement pour des projets de toutes tailles qui ont besoin d’avoir un client desktop.
Une question légitime est “Pourquoi choisir de faire une application desktop en Python ??”. En effet, c’est une bonne question. Dans un premier temps je dirais que le Python est multiplateforme et donc votre application fonctionnera sur Windows, Mac OS X et Linux ayant Python. De plus, personnellement je fais des applications desktop en Python principalement pour venir communiquer en Serial avec des systèmes embarqués (Communication Serial avec une Arduino, MBED ou un micro STM32). Ces applications me permettent d’avoir une interface graphique sympa pour venir configurer une Arduino par exemple. Le langage est vraiment facile à utiliser et performant, et couplé avec pip le gestionnaire de dépendances on fait des projets vraiment propres en un temps record ;).
Maintenant que j’ai introduit le sujet, je vous propose de mettre en place une application très simple avec Python et PyQt ainsi qu’un environnement facile à maintenir.
Pour ceux qui développent sous Linux :
sudo apt-get install pyqt4-dev
sudo apt-get install pyqt4-dev-tools
sudo apt-get install qt4-designer
Pour ceux sous Windows :
Pour ma part, je travaille sous Linux Mint 17.10 et pour coder le super éditeur Sublime Text 3.
Qt Designer est l’outil qui vous permet de construire vos interfaces graphiques aussi appelé GUI (Graphical User Interface) ou simplement UI (User Interface).
A partir de cet outil, vous êtes capable de créer très facilement et rapidement vos interfaces graphique. Du simple drag&drop et le tour est joué ! Ensuite, Qt designer enregistre l’UI au format .ui qui est simplement un format xml spécifique à Qt.
Une fois notre interface réalisée, on peut à partir du fichier .ui réaliser une classe Python pour PyQt. On réalise ceci grâce à pyuic4.
pyuic4 monfichier.ui -o monfichier.py
Et on récupère une classe Python qui correspond à notre UI et qu’on va pouvoir manipuler en Python. Il faut à présent faire un petit scaffolding pour notre projet afin de faciliter l’intégration de l’UI dans notre app.
Je propose un scaffolding comme ceci : (note : en gras les dossiers en italique les fichiers)
Pour expliquer le principe, tous ce qui est lié à mon UI est dans le dossier UI (*.ui, mes classes Python générées à partir des *.ui, ressources tel que Images, …). Mon script build.sh me permet de convertir mon fichier myui.ui en MyUI.py.
build.sh
#!/bin/bash
pyuic4 myui.ui -o MyUI.py
#pyrcc4 ressources.qrc -o Ressources_rc.py
La magie s’opère ensuite dans le fichier MainUI.py ; en effet, je vais créer une classe MainUI qui va hériter de la classe MyUI du fichier MyUI.py
Grâce à ce système, si je fais des modifications sur mon UI via Qt designer, je n’ai qu’à exécuter mon script build.sh pour mettre à jour mon UI.
Le fichier MainUI.py hérite de notre MyUI.py généré depuis le fichier de Qt Designer :
|
|
On peut ici personnaliser notre UI avec des comportements particuliers comme lier un bouton pour ouvrir une boite de dialogue, … On met ici des fonctionnalités liées à l’UI mais pas encore des fonctionnalités liées à l’application en elle même. Les fonctionnalités liées à l’application vont se trouver dans le fichier App.py !
App.py
|
|
On retrouve ici la base de notre application, on injecte la classe avec l’ui afin de pouvoir manipuler les objets de l’interface graphique. La méthode setup permet d’initialiser les connect qui sont des listeners d’événement pour PyQt. On y attache des fonctions callbacks qui seront exécutés si l’événement survient. Par exemple ici j’ai attaché l’événement clicked sur le bouton pushButton à la méthode action de la classe. Dans cette méthode, je remplis le textEdit avec hello world et un compteur.
La class App est le coeur de votre application, c’est là où vous mettez la logique de votre app.
Enfin, il faut le fichier de l’application qui sera à exécuter :
appName.py
|
|
Dans un premier temps, on créé une Qt app puis on instancie notre GUI qui vient du MainUI et enfin on instancie notre classe App en lui injectant le gui et l’app Qt pour qu’elle puisse les manipuler. Le must serait d’instancier la classe MainUI dans un thread et l’App dans un autre thread car si vous avez des fonctions dans la classe App qui prennent du temps ou qui sont bloquantes, cela va freezer l’interface graphique… pas cool… Mais dans la majorité des cas, on clique sur un bouton et on fait une action simple non bloquante dans ce cas là pas besoin de séparer l’App et l’UI dans deux threads différents.
Et voilà, vous n’avez plus qu’à exécuter votre application : python appName.py
Maintenant qu’on a notre application, on voudrait bien en faire un .exe sous Windows afin de livrer une app packagée. Pour cela, il existe l’utilitaire py2exe qui est franchement bien !
Il faut juste créer un fichier setup.py à la racine de notre projet avec la configuration de notre application :
setup.py
|
|
Et ensuite exécuter :
python setup.py py2exe
Attention, cela fonctionne uniquement sous Windows bien entendu et il vous faut Microsoft Visual C++ 2008 : http://www.microsoft.com/fr-FR/download/details.aspx?id=29
Vous avez ensuite un appName.exe et un library.zip que vous pouvez distribuer !
Voici les deux endroits où vous pourrez trouver des informations pour PyQt :
Après n’hésitez pas à chercher sur Google ;)
Voici les sources du projet présenté dans ce post : https://github.com/Nightbr/pyqt-example
Voili voilou ! Si vous avez des questions où des remarques, n’hésitez pas à les poster en commentaire !
]]>Mais dans un premier temps, un petit rappel sur ce qu’est la domotique :
La domotique est l’ensemble des techniques de l’électronique, de physique du bâtiment, d’automatisme, de l’informatique et des télécommunications utilisées dans les bâtiments, plus ou moins “interopérables” et permettant de centraliser le contrôle des différents systèmes et sous-systèmes de la maison et de l’entreprise (chauffage, volets roulants, porte de garage, portail d’entrée, prises électriques, etc.).
Mais qu’est ce que OHA :
Open Home Automation est un projet de domotique Open Source innovant qui permettra de contrôler les équipements de la maison, volets, lampes, chauffages par l’intermédiaire de son smartphone, tablette, PC, Laptop, etc. OHA propose une solution domotique qui ne nécessitera pas de changement important dans les installations de la maison, comme c’est le cas pour les solutions domotiques du marché. De plus chacun (particulier ou entreprise) pourra construire et ajouter son propre équipement connecté grâce à la Centrale Intelligente OHA qui détecte automatiquement les nouveaux équipements domotiques compatibles. OHA n’est pas qu’un simple système domotique propriétaire, c’est un univers d’objets connectés où chacun peut ajouter le sien.
Pour OHA, nous voulions développer un système ouvert offrant une bonne base pour toutes les applications de domotique. Voici un schéma fonctionnel du système :
Cette article présentera globalement le système mais je ferais sûrement d’autre article plus technique qui détaillera les différentes parties du système.
Nous êtions une équipe de 4 personnes (2 personnes sur le logiciel API+client web et 2 personnes sur le reste : développement du daemon python + des modules Arduino). Ce projet a duré environ 6 mois (de Septembre 2014 à Janvier 2015) et nous nous étions fixé comme objectif d’avoir un serveur communicant avec un module simple de lampe connectée.
Voici la maquette finale du système :
Voici quelques vidéos (playlist Youtube) de démonstration qui montrent les fonctionnalités de base de système.
Et sinon comme le système est Open Source, retrouvez tous nos documents sur Dropbox et le code sur notre serveur git :
git OHA Module Core : http://git.nbcorp.fr/oha/oha-module-core
Voilà, ça sera tout pour cette article d’introduction, je vais refaire d’autre article sur le sujet pour présenter l’architecture globale du système, les différents composants (API, Daemon, …).
Si vous avez des questions, n’hésitez pas à les poser en commentaire ;)
]]>