Revue de presse Inno #9

Spécial PyCon Canada 2017 (Suite !)

Que retenir de la dernière PyCon Canada ? Quelques éléments de réponse avec les développeurs de l’équipe Innovation de Savoir-faire Linux !

Conférence ‘Double Click: Continue Building Better CLIs’

Par Kévin Barralon

Cette conférence donnée lors de la PyCon Canada visait à présenter Click, un package Python permettant de créer des CLIs (Commande Line Interface) en peu de lignes de code.

L’utilisation est simple et intuitive : la configuration d’une commande passe essentiellement par l’ajout de décorateurs à votre fonction.

Par exemple, voici une fonction simple chargée de répéter un nom passé en argument :

# hello.py
import click

@click.command()
@click.option('--count', default=1, type=int, help='Number of greetings.')
@click.option('--name', prompt='Your name',
              help='The person to greet.')
def hello(count, name):
    for _ in range(count):
        click.echo(f'Hello {name}!') # Syntaxe de Python 3.6 !

if __name__ == '__main__':
    hello()

En quelques lignes de codes, vous avez créé une commande qui :

  • prend une option --count avec une valeur par défaut de 1 et dont le type exigé est un integer.
  • prend une option --name qui permet grâce à l’argument prompt passé dans votre décorateur de proposer à l’utilisateur de renseigner son nom.

Ces valeurs sont transmises directement aux paramètres count et name de la fonction décorée. Ci-dessous le code pour lancer la commande dans votre terminal :

python3 test.py --count=3

Your name: Casimir
Hello Casimir!
Hello Casimir!
Hello Casimir!

L’autre point intéressant (et pratique également !) est que si vous passez l’option --help à l’appel de votre fichier, vous obtenez l’affichage de la Docstring de votre fonction, ainsi que les informations pour chaque option fournies grâce à l’argument help passé dans vos décorateurs :

python3 hello.py --help

Usage: test.py [OPTIONS]

Simple program that greets NAME for a total of COUNT times.

Options:
--count INTEGER Number of greetings.
--name TEXT The person to greet.
--help Show this message and exit.

Plutôt que de passer des options à votre commande, vous pouvez également définir des arguments. Pour l’exemple :

@click.command()
@click.argument('filename')
def touch(filename):
    click.echo(filename)

Puis :

python3 touch.py foo.txt
foo.txt # Résultat

Comme vous pouvez le constater, les possibilités de Click sont vraiment nombreuses. Quelques unes en supplément pour l’occasion :

  • possibilité d’ajouter l’argument multiple=True dans votre décorateur @click.option qui vous renverra un tuple des options passées à l’appel de votre commande.
  • ajouter un callback en argument du @click.option qui changera le comportement de votre commande (par exemple pour définir des règles de validations sur-mesures).
  • de passer des variables d’environnement à votre décorateur (ex: envar="USERNAME").
  • définir un nombre limité ou illimité d’arguments qui retourneront un tuple.
  • ajouter une méthode File en guise de type dans votre décorateur (par exemple : @click.argument('input', type=click.File('rb'))) qui se chargera également d’ouvrir votre fichier et de le fermer automatiquement.

La liste de toutes les possibilités offertes par le package est disponible dans la documentation, très bien faite par ailleurs.

Bonus !

La conférence sur f-strings a vraiment motivé les troupes ! Voici un article de Maxime qui fait écho à celui de Sébastien la semaine dernière :

Les f-strings, qu’est-ce que ça mange en hiver?

Par Maxime Dupuis

Les chaînes de caractères-f, ou f-strings, sont une nouvelle façon de faire de l’interpolation en Python. Elles se définissent en mettant un f (ou F) en amont de la déclaration d’une chaîne de caractères : f'Ma chaîne f'.

Elles sont très semblable en comportement aux chaînes patrons (template strings) en JavaScript qui, elles, sont définies en utilisant le caractère `.

L’utilité des f-strings vient du fait qu’elles peuvent contenir des variables qui seront automatiquement interpolées avec les valeurs des variables locales définies du même nom :

>>> age = 42
>>> prenom = 'Maxime'
>>> f"Je m'appelle {prenom} et j'ai {age} ans"
"Je m'appelle Maxime et j'ai 42 ans"
>>> # L'utilisation d'une variable non-définie nous donnera une erreur de type NameError :
>>> f"{nondefini}"
Traceback (most recent call last):
File "", line 1, in
NameError: name 'nondefini' is not defined

Là où l’utilisation de chaînes de caractères-f devient intéressante est notamment du fait que ce type de chaînes est très rapide ! Si on les compare aux autres façons de créer des chaînes en Python, on a :

python3.6 -m timeit -c 'age=42; prenom="Maxime"; f"Mon nom est {prenom} et mon age est {age} ans"'
10000000 loops, best of 3: 0.172 usec per loop
python3.6 -m timeit -c 'age=42; prenom="Maxime"; "Mon nom est {prenom} et mon age est {age} ans".format(prenom=prenom, age=age)'
1000000 loops, best of 3: 0.714 usec per loop
python3.6 -m timeit -c 'age=42; prenom="Maxime"; "Mon nom est %s et mon age est %s ans" % (prenom, age)'
1000000 loops, best of 3: 0.283 usec per loop
python3.6 -m timeit -c 'age=42; prenom="Maxime"; "Mon nom est " + prenom + " et mon age est " + str(age) + " ans"'
1000000 loops, best of 3: 0.449 usec per loop
python3.6 -m timeit -c 'from string import Template; age=42; prenom="Maxime"; Template("Mon nom est $prenom et mon age est $age").substitute(prenom=prenom, age=age)'
100000 loops, best of 3: 8.75 usec per loop

Mais l’utilité des f-strings ne réside pas uniquement dans sa rapidité : Il est également possible d’appeler des fonctions, faire du traitement, et toutes autres choses :

>>> total = 10.0
>>> taxes = 1.15
>>> f'Total: {total + taxes}'
'Total: 11.15'
>>> prenom = 'Maxime'
>>> f'Mon nom est {prenom.upper()}'
'Mon nom est MAXIME'

Si cela vous intéresse et que vous n’avez pas encore découvert toutes les nouveautés que Python 3.6 peut vous offrir, consultez les notes de version : «What’s New In Python 3.6».

Mobilité

SwiftGen

Par Thibault Wittemberg

Lorsque nous développons une application iOS, nous avons régulièrement besoin d’accéder à des ressources. La façon traditionnelle pour les utiliser dans le code est de les instancier avec leurs identifiants (chaînes de caractères) :

let avatar = UIImage(named: ‘darthVader’) // gets the ‘darthVader’ image from the assets folder
let name = NSLocalizedString (‘darthVader’, comment: ‘’) // gets the localized string with the key ‘darthVader’ from the Localizable.strings file

Il en va de même pour les fonts, les storyboards et les couleurs.

Pour rappel, Swift se veut un langage assez strict sur la gestion des types et favorise la détection d’erreurs lors de la phase de compilation plutôt que lors de la phase d’exécution. Ceci étant, que se passe-t-il si l’une des ressources que l’on souhaite instancier n’est pas trouvée à l’exécution ? Puisque cette instantiation se base sur une chaine de caractères, elle est soumise à des erreurs (fautes de frappe par exemple).

La solution ? L’outil Swiftgen, qui nous permet de sécuriser cette manipulation :

  • Il évite les erreurs de frappes,
  • Il permet la complétion syntaxique,
  • Il assure que la ressource existe au moment de la compilation.

Son principe de fonctionnement est le suivant :

  • L’exécutable « Swiftgen » est installé sur le poste de développement (soit via Homebrew soit via CocoaPods),
  • Une phase de build custom lance cet exécutable lors de chaque compilation,
  • Swiftgen parcours les ressources du projet et génère le code Swift les représentant de façon « type safe ».

Les identifiants des ressources seront ainsi transformés en « enum » dont l’utilisation est bien plus sécurisée et facile. Notre exemple deviendrait :

let avatar = Asset.darthVader.image
let name = L10n.darthVader

Il est même possible de customiser les templates qui serviront à la génération du code si l’on souhaite appliquer un coding style différent de celui offert par défaut.

Lorsqu’il est combiné au framework « Reusable » (du même auteur), nous disposons d’outils quasiment indispensables (et que nous mettons en place systématiquement chez Savoir-faire Linux) et dont on souhaiterait disposer par défaut dans l’environnement de développement d’Apple.

Swiftgen est pensé pour être intégré à l’environnement d’intégration continue d’un projet (l’exécutable peut être embarqué dans une dépendance CocoaPods, évitant ainsi de l’installer sur la machine de build).

Contribution

Nouvelle version de savoirfairelinux/num2words 0.5.6

Par Ernesto Ortiz

Cinq mois depuis la version précédente de num2words v0.5.5, cinq mois vraiment actifs.

Beaucoup de nouveaux contributeurs ont apporté de grandes améliorations et ont ajouté un support pour de nouvelles langues !
Voici quelques-uns des nouveaux changements avec des « remerciements spéciaux » aux contributeurs !

  • Num2words a changé les conventions de codage pour suivre PEP8,
    La couverture du code a beaucoup augmenté et nous avons besoin de votre aide pour continuer à améliorer cela, alors regardez les problèmes,
  • Maintenant, nous pouvons utiliser d’autres convertisseurs to_currency, to_year, to_ordinal_num,
  • Merci à Tufan Kaynak d’avoir apporté son soutien à la localisation turque,
  • Merci à Jesús Leganés-Combarro d’avoir soutenu la localisation franco-algérienne,
  • Merci à Armin Oliya pour son soutien à la localisation néerlandaise,
  • Merci à Sergio Zholudov pour son soutien à la localisation ukrainienne,
  • Remerciements à Blaž Bregar pour son soutien à la localisation slovène,
  • Merci à Mārtiņš Šulcs d’avoir apporté de nombreuses améliorations au code de base, aux fonctionnalités de to_currency et plus encore !

Un merci spécial à tous ceux qui ont pris le temps de signaler de nouveaux problèmes, de faire une pull request et de partager leur temps dans ce projet !

Vous pouvez vérifier la nouvelle version dans :

Revue de presse Inno #8

Spécial PyCon Canada 2017

Un numéro spécial PyCon cette semaine ! Fier commanditaire de la PyCon Canada 2017 qui se déroulait du 18 au 21 novembre à Montréal, Savoir-faire Linux vous partage dans cette nouvelle édition, les retours de nos spécialistes Python qui étaient sur place.

PyCon 2017

L’équipe de Savoir-faire Linux à la Pycon

Tutoriel : Writing Tests that Write Themselves ! Par David Kua

Par Ernesto Rodriguez Ortiz

Vous allez aimer la puissance des tests basés sur les propriétés !

Je viens de découvrir les tests basés sur les propriétés lors de la récente PyCon Canada 2017. Un grand merci à David Kua qui a préparé, présenté et partagé avec nous un excellent tutoriel autour des tests basés sur les propriétés en utilisant la librairie Hypothesis (Welcome to Hypothesis!). Le test basé sur les propriétés a été popularisé par la bibliothèque Haskell Quickcheck. Une belle découverte donc, qui me fait désormais oublier les contraintes liées aux tests !

Comment ça marche ?

L’hypothèse génère des données aléatoires correspondant à vos spécifications et vérifiant que votre garantie est toujours valable pour chaque cas de test. Regardez cet exemple vraiment simple :

# FILE NAME division.py

#! / usr / bin / env python
# - * - codage: utf-8 - * -

from hypothesis import given, settings
import hypothesis.strategies as st


# On a écris ces deux lignes trop vite ...
def division (x, y):
    retour x / y


# Hypothèse va nous montrer nos erreurs ...
@given (st.integers (), st.integers ())
@settings (max_examples = 1000)
def test_commutativity_pbt (x, y):
    affirmer la division (x, y) * y == x

Ensuite, lancez :

pytest --hypothesis-show-statistics division.py

Vous devriez voir comment Hypothesis a trouvé le cas :

ZeroDivisionError: division by zero

C’est un outil vraiment puissant, surtout si vous feuilletez l’excellent tutoriel de David Kua et consultez la documentation de Hypothesis.

Closing Keynote – Mariatta Wijaya

Par Sébastien Blin

Lors de la conférence de clôture, Mariatta Wijaya – Core Developer de Python – nous a présenté Python 3.6, en mettant de l’avant une PEP de cette version : la PEP 498: Literal String Interpolation. Mariatta est revenue sur l’histoire de cette PEP, en partant du courriel reçu de la liste de diffusion, il y a quelques années. Les “f-string” permettent d’améliorer la construction de chaînes de caractères contenant des variables, le tout de manière plus performante et plus lisible que l’opérateur % ou la fonction str.format :

>>> import datetime
>>> name = 'Fred'
>>> age = 50
>>> anniversary = datetime.date(1991, 10, 12)

>>> f'My name is {name}, my age next year is {age+1}, my anniversary is {anniversary:%A, %B %d, %Y}.'
'My name is Fred, my age next year is 51, my anniversary is Saturday, October 12, 1991.'

>>> f'He said his name is {name!r}.'
"He said his name is 'Fred'."

Elle a ensuite énoncé les autres PEP releasées avec Python 3.6 (dont la PEP 628 pour math.tau, qui n’existe pas, mais tau vaut 6.28). La liste complète des PEPs pour Python 3.6 est visible ici : Python 3.6 Release Schedule.

Dans tous les cas, Mariatta nous invite à passer à Python 3.6, dès aujourd’hui, ainsi qu’à contribuer à l’évolution de ce langage, au travers l’écriture de PEPs, sur ce dépôt Github.

Contributions

GitHub dévoile son outil de discussion par équipe

Par Romain Bertozzi

La contribution au logiciel libre, c’est avant tout du partage où la communication prend une place essentielle. Dans ce contexte, GitHub a annoncé lundi 20 novembre dernier, le déploiement de discussions par équipe avec Introducing Team discussions.

L’idée est de soulager les issues et pull requests de conversations dont certaines n’ont pas forcément leur place. Ces issues et PR gagneront donc en efficacité et en lisibilité.

De plus, ces nouvelles discussions, publiques ou privées, auront leurs URLs dédiées et pourront être efficacement partagées et citées. Chez Savoir-faire Linux, nous accueillons cette nouvelle avec enthousiasme.

Nous pensons en effet que cela amènera plus de clarté aux échanges qui façonnent la direction d’un projet. La centralisation et la facilité de partage des discussions sont des atouts qui permettront de favoriser la transparence et la pérennité des échanges.

Reste à voir comment cette fonctionnalité sera adoptée par les utilisateurs de Github, et si ces mêmes utilisateurs ne disposent pas déjà d’alternatives et d’habitudes bien ancrées.

Revue de presse Inno #3

Développement Web

PyCon 2017

Par Jacob Cook 

La PyCon Canada arrive à grands pas, c’est la plus importante conférence canadienne du monde Python qui aura lieu à Montréal cette année, du 18 au
21 novembre.
  
En tant qu’entreprise de développement logiciel bien ancrée dans les communautés Python et Django de Montréal, Savoir-faire Linux y
enverra un nombre important de ses développeurs. Pour les deux premières journées de la conférence, il y aura des keynotes et des 

discours sur les développements les plus utiles dans la communauté Python, et aussi plus généralement dans le développement logiciel de nos jours. Le dimanche 19 à 11h50, je vais présenter un panel sur les façons les plus efficaces de créer une application Django qui profite de la puissance front-end de React. Avec des présentations fortes intéressantes prévues, et 70 % des billets déjà vendus, la PyCon Canada de cette année s’annonce comme la plus grande de toute son histoire !

Communautés et Projets libres

#Hacktoberfest ou comment un projet libre en dormance est maintenant plus actif que jamais

Par Samuel Sirois

Istvan Szalaï et moi souhaitaient redémarrer un projet libre en dormance que nous avions démarré l’été dernier: RingMe.js.

Pour nous motiver un peu, Istvan a proposé d’inscrire le projet dans le cadre de l’initiative Hacktoberfert de DigitalOcean. Plus une forme de ludification de la contribution pour nous deux que pour attirer des bidouilleurs•euses à contribuer au projet, (nous avons eu la surprise de voir des contributeurs proposer du code) apportant des solutions à des tâches, anomalies et fonctionnalités auxquelles l’étiquette #Hacktoberfest a été ajoutée.

La clef du succès ?

Quelques hypothèses :

  • Les tâches, anomalies et nouvelles fonctionnalités sont précises, simples et d’envergure raisonnables (merci Istvan);
  • Le JavaScript est un language sexy en 2017;
  • La base de code est suffisamment simple et embryonnaires pour qu’il soit facile à de nouvelles•aux contributrices•eurs de comprendre le code et de proposer une solution cohérente;
  • Les fichiers README, CONTRIBUTING et des gabarits de soumission de code sont présents dans le projet (merci Emmanuel);
  • Les animateurs (Istvan et moi) essaient de répondre aux demandes de contributions et aux questions dans les 48 heures;
  • #Hacktoberfest est un événement Web populaire.

Merci à:

Merci à Istvan d’avoir eu l’idée d’inscrire ce projet au #Hacktoberfest.

Merci à Jacob de nous aider à valider des demandes de contributions de façon efficace grâce à sa connaissance de l’écosystème JavaScript moderne.

Merci à toutes les contributrices•eurs au projet (en date de publication de cet article):

Mobilité

Secret: Psss…  Sais tu comment fonctionne le Android View State storing ? 

Par Loïc Siret

Qui n’a jamais éprouvé des difficultés ou des comportements « bizarres » lors du stockage/restauration de vues personnalisées ?

Voici un article de elye qui explique le système de sauvegarde des vues et comment s’affranchir de ces problèmes : A must know secret about Android View State storing mechanism!

Érudit, un savoir à cultiver… librement

Premier diffuseur de ressources francophones en sciences humaines et sociales en Amérique du Nord, Érudit s’est refait une beauté en 2017. Fruit d’un travail d’un an et demi, cette refonte technique et visuelle offre de nouvelles fonctionnalités, auxquelles notre expert Python Morgan Aubert s’est fait un grand plaisir de contribuer.

En accès libre
Avant d’aborder cette refonte, revenons un petit peu en arrière. En 1998, les Presses de l’Université de Montréal lancent Érudit, plateforme de ressources pour les sciences humaines et sociales. Six ans plus tard, en 2004, elle bénéficie du soutien d’un consortium unissant l’Université de Montréal, l’Université Laval et l’Université du Québec à Montréal. Cette union renforce Érudit dans sa mission de diffuser en accès libre du contenu de haut niveau dans plus de 30 disciplines : des revues savantes et culturelles, des livres, des actes, des mémoires, des thèses ainsi que des rapports de recherche.

Ce volume conséquent de plus de 200 000 documents fait de la plateforme un acteur de référence pour la recherche francophone, contribuant au partage du savoir et encourageant par là même la publication scientifique en français sur le territoire nord-américain. En 2016, le compteur des consultations est monté 21 millions !

Par ailleurs, Érudit s’est engagé dès sa création envers l’utilisation des logiciels libres : son environnement de travail, son infrastructure et ses services reposent sur des logiciels libres. Directeur des technologies du consortium, Davin Baragiotta insiste sur le fait d’avoir «la capacité d’utiliser des technologies développées/maintenues par des tiers, d’y contribuer au besoin -comme on a pu le faire- et de mettre à disposition notre propre code en vue d’une réutilisation complète ou partielle par des tiers. C’est une culture technique de partage et de collaboration qui permet d’avoir une meilleure capacité de développement et de maintenance de nos TI. Aussi, d’un point de vue organisationnel, cette approche technique s’inscrit dans une culture plus large d’ouverture, de collaboration et de partenariat. Essentiellement, Érudit met en valeur des contenus scientifiques et culturels que l’on veut voir d’avantage diffusés en Open Access. »

Lors des travaux préliminaires de la refonte, le projet visait à doter Érudit d’une plateforme moderne qui permettra une évolution continue et une extension des fonctionnalités. Il s’agissait donc de réécrire la plateforme en Python/Django en remplacement de Cocoon/Drupal/WordPress, mais en gardant la même couverture fonctionnelle. C’est dans ce contexte que notre expert Morgan Aubert a travaillé en tant consultant développeur Python. Il y a fait du développement back end et front end, en utilisant le framework web Django, alors que les développements front end impliquaient Javascript et Sass.

Bonjour Morgan, quels ont été les défis techniques auxquels tu as confronté pour cette plateforme ?
L’un des principaux défis technologiques était lié au gros volume de données à importer, traiter, présenter et servir sur la plateforme. En effet, la plateforme Érudit met à disposition plus de 200 000 documents savants et culturels. Avant d’être visibles sur la plateforme Erudit.org, ces documents doivent être importés depuis différentes sources de données – ce qui implique plusieurs protocoles sous-jacents (par exemple Fedora Commons, un système de gestion de bibliothèques numériques, ou encore OAI-PMH, Open Archive Initiative Protocol for Metadata Harvesting, un protocole permettant l’échange de métadonnées provenant de sources diverses). Gérer un tel volume de document impliquait également d’anticiper les différents usages de la plateforme afin d’assurer une navigation fluide et performante pour les utilisateur d’ Erudit.org.

Il y avait également d’autres défis : assurer une certaine rétro-compatibilité entre l’ancienne plateforme et la nouvelle, qu’il s’agisse de redirections entres les anciennes URLs et les nouvelles, ou des techniques de conservation de l’indexation des documents Érudit dans Google et Google Scholar (https://scholar.google.ca/). Un autre défi consistait à permettre la collecte de métriques de consultations de documents en vue de produire des statistiques dans divers formats, et ainsi représenter ces statistiques de consultation de documents savants ou culturels avec des outils tel que COUNTER, ou des webservices, qui implémentent plusieurs normes de webservices liés à la récupération de données de consultation de documents savants ou culturels tel que Schemas for the Standardized Usage Statistics Harvesting Initiative (SUSHI).

Et quelle fut la partie de ton travail la plus intéressante ?
L’objectif de la plateforme Erudit.org s’inscrit dans une dynamique très vertueuse; le fait d’effectuer des travaux de conception et de développement sur la nouvelle version de cette plateforme était ainsi très valorisant. Outre les travaux liés à la mise en place de cette nouvelle application avec le cadriciel Django, l’un des aspects les plus intéressants de cette mission de plusieurs mois était lié aux spécificités mêmes de la plateforme : le fait de découvrir les spécificités techniques et exigences du milieu universitaire/bibliothécaire était particulièrement intéressant. Qu’il s’agisse de protocoles d’échange de métadonnées, de technologies de gestion de bibliothèques numériques ou de normes de présentation de citations, c’est un milieu qui vient avec son lot de problématiques techniques, d’enjeux technologiques… et de solutions libres. J’ai d’ailleurs été amené à réaliser plusieurs contributions lors de mon mandat, notamment dans le cadre de l’utilisation d’outils Python proposant des mécanismes d’interactions avec des technologies de gestion de bibliothèques numériques tels que eulfedora pour Fedora Commons .

Christophe Villemer, vice-président de Savoir-faire Linux, rebondit sur ces contributions : «en apportant notre expertise Python/Django à ce projet d’envergure, nous avons pu à la fois participer au développement d’un moteur de recherche important pour la communauté scientifique et offrir de nouvelles ressources à celle des technologies open source destinées à la gestion documentaire. Ce qui correspond parfaitement à la philosophie de notre entreprise».


Une version bêta

Complété à l’interne, le nouvel Érudit est encore en version bêta, et au cours de l’année de nouvelles fonctionnalités seront graduellement intégrées au site. Dans l’esprit des technologies ouvertes, vous pouvez contribuer à l’amélioration de la plateforme en signalant tout bogue à l’adresse bogue@erudit.org, et vous pouvez aller consulter le projet sur github, où Érudit a même son propre dépôt.

En attendant ces améliorations, libre à vous d’aller consulter la plateforme de recherches et trouver une multitude de ressources sur le logiciel libre, entre les thèses, les mémoires de maîtrise, les articles de revue savante ou culturelle, vous aurez l’embarras du choix…

Comment Ring communique avec les appareils connectés #IoT

light-bulb - IoTQuand vous sortez de chez vous, êtes-vous sûr que les lumières sont éteintes? Avec Ring, vous pouvez le vérifier en vidéo et régler votre éclairage simplement en envoyant un message texte. De quoi faire des économies d’énergie!

En moins d’une heure, Adrien Béraud, développeur chez Savoir-faire Linux, a monté un dispositif lui permettant de contrôler l’éclairage de son salon alors qu’il est au bureau. Il a configuré le compte Ring de son ordinateur domestique pour accepter automatiquement chaque appel et peut ainsi l’appeler pour voir en temps réel, en vidéo, son salon à distance. Il peut alors vérifier si les lumières sont allumées et, au besoin, les éteindre en utilisant le module de clavardage de Ring!

Un dispositif simple, monté avec du matériel libre

Arduino - IoTAdrien a d’abord relié les lampes de son salon à Internet, en utilisant un système connecté Particle Core (de type Arduino) et une carte d’extension relais (Relay Shield). Comme son éclairage est associé à un circuit va-et-vient, il peut facilement contrôler les lumières, même en cas de panne Internet ou en cas de problème avec le relais. Il a ensuite ajouté les quelques lignes de code fournies dans la documentation du relais pour connecter le dispositif à Internet.

Avec quelques lignes de commande, vos lampes sont connectées

Une fois la connexion établie, il a inséré une ligne de commande dans le terminal de son ordinateur Linux. Par exemple, pour éteindre (LOW) la première lampe (r1) :

curl https://api.particle.io/v1/devices/0123456789abcdef/relay -d access_token=123412341234 -d params=r1,LOW

Le contrôle des lumières par le clavardage de Ring peut ensuite se faire avec ce script Python :

#!/usr/bin/env python3
import re, json, http.client, urllib.parse
from controler import DRingCtrl

PARTICLE_API_TOKEN = '[your_api_token_here]'
PARTICLE_REQ_URI = '/v1/devices/[your_device_id_here]/relay'
PARTICLE_REQ_RE = re.compile('^(r[0-4],(?:HIGH|LOW))$')

class LightRingController(DRingCtrl):
    def __init__(self):
        super().__init__("LightController")

    def tryParticleReq(self, params):
        try:
            conn = http.client.HTTPSConnection('api.particle.io')
            p = urllib.parse.urlencode({'access_token': PARTICLE_API_TOKEN, 'params': params})
            conn.request("POST", PARTICLE_REQ_URI, p, {"Content-type": "application/x-www-form-urlencoded", "Accept": "text/plain"})
            ret = json.loads(conn.getresponse().read().decode())['return_value']
        finally:
            conn.close()
        return ret

    def onIncomingMessage(self, callid, ufrom, message):
        super().onIncomingMessage(callid, ufrom, message)
        msg = message['text/plain']
        res = re.search(PARTICLE_REQ_RE, msg)
        if res:
            op = res.group(0)
            print('Command:', op)
            ret = self.tryParticleReq(op)
            self.callmanager.sendTextMessage(callid, {'text/plain':'Got: '+str(ret)}, False)

if __name__ == "__main__":
    ctrl = LightRingController()
    ctrl.run()

L’Internet des objets: des possibilités infinies

De nombreux usages sont possibles, du plus simple au plus complexe. Par exemple, un appel Ring peut être directement associé à la mise en marche de votre éclairage, avec ce simple script :

#...

class LightRingController(DRingCtrl):

    #...

    def onCallStateChanged(self, callid, state, statecode):
        super().onCallStateChanged(callid, state, statecode)
        if state == "HUNGUP":
            self.tryParticleReq('r1,LOW')
        elif state == "CURRENT":
            self.tryParticleReq('r1,HIGH')

Imaginez alors ce que vous pourriez faire si votre logiciel Ring était relié à votre chauffage ou à la porte de votre garage… Les perspectives sont infinies!

Vous avez des idées à partager ? Laissez un commentaire!