457 lines
13 KiB
Python
457 lines
13 KiB
Python
# WARNING: ce code s'appuie sur une API découverte par rétro-ingénérie.
|
||
# Il peut cesser de fonctionner sans préavis.
|
||
|
||
# TODO:
|
||
##
|
||
|
||
from urllib import request
|
||
from http.cookiejar import CookieJar
|
||
from urllib.parse import urlencode
|
||
from urllib.error import HTTPError
|
||
|
||
authors = (
|
||
'Gilles "Almtesh" Émilien MOREL',
|
||
)
|
||
name = 'homesfr pour Python 3'
|
||
version = '1.3'
|
||
|
||
# Modes utilisables
|
||
MODE_OFF = 0
|
||
MODE_CUSTOM = 1
|
||
MODE_ON = 2
|
||
|
||
# Types de capteurs
|
||
PRESENCE_DETECTOR = 'PIR_DETECTOR' # https://boutique.home.sfr.fr/detecteur-de-mouvement
|
||
MAGNETIC_OPENNING_DETECTOR = 'MAGNETIC' # https://boutique.home.sfr.fr/detecteur-d-ouverture-de-porte-ou-fenetre
|
||
SMOKE_DETECTOR = 'SMOKE' # https://boutique.home.sfr.fr/detecteur-de-fumee
|
||
SIREN = 'SIREN' # https://boutique.home.sfr.fr/sirene-interieure (et peut-être https://boutique.home.sfr.fr/sirene-exterieure)
|
||
REMOTE_CONTROLER = 'REMOTE' # https://boutique.home.sfr.fr/telecommande
|
||
KEYPAD_CONTROLER = 'KEYPAD' # https://boutique.home.sfr.fr/clavier-de-commande
|
||
PRESENCE_CAMERA_DETECTOR = 'PIR_CAMERA' # https://boutique.home.sfr.fr/camera
|
||
|
||
base_url = 'https://home.sfr.fr'
|
||
|
||
# Authentification
|
||
auth_path = '/mysensors'
|
||
auth_ok_url = 'https://home.sfr.fr/logged'
|
||
auth_post_url = 'https://boutique.home.sfr.fr/authentification'
|
||
auth_referer = 'https://boutique.home.sfr.fr/authentification?back=service'
|
||
auth_user_field = 'email'
|
||
auth_pass_field = 'passwd'
|
||
auth_extra_fields = {'back': 'service', 'token_sso': '', 'error_sso': '', 'SubmitLogin': 'OK'}
|
||
auth_logout_path = '/deconnexion'
|
||
|
||
# Chemin pour la liste des capteurs
|
||
sensors_list = '/mysensors'
|
||
|
||
# Chemin pour les alertes
|
||
alerts_path = '/listalert'
|
||
|
||
# Détection
|
||
mode_get_path = '/mysensors'
|
||
mode_get_label = 'alarm_mode'
|
||
mode_set_path = '/alarmmode'
|
||
mode_set_field = 'action' # Name for GET field
|
||
mode_off = 'OFF' # Value for off
|
||
mode_custom = 'CUSTOM' # Value for custom
|
||
mode_on = 'ON' # Value for on
|
||
|
||
# Cémera
|
||
cameras_list = '/homescope/mycams'
|
||
camera_snapshot = '/homescope/snapshot?size=4'
|
||
camera_snapshot_mac = 'mac'
|
||
camera_video = '/homescope/flv'
|
||
camera_video_mac = 'mac'
|
||
camera_recordings_list = '/listenr'
|
||
camera_recordings_delete = '/delenr'
|
||
camera_recordings_start = '/homescope/record'
|
||
camera_recordings_stop = '/homescope/stoprecord'
|
||
camera_recordings_mac = 'mac'
|
||
camera_get_config_path = '/homescope/camsettings'
|
||
camera_get_config_mac = 'mac'
|
||
camera_get_config_flip = 'FLIP'
|
||
camera_get_config_leds = 'LEDMODE'
|
||
camera_get_config_petmode = 'pet_mode'
|
||
camera_get_config_recording = 'rec24'
|
||
camera_get_config_privacy = 'privacy'
|
||
camera_get_config_name = 'NAME'
|
||
camera_set_config_path = '/homescope/camsettings'
|
||
camera_set_config_mac = 'mac'
|
||
camera_set_config_flip = 'flip'
|
||
camera_set_config_leds = 'led_mode'
|
||
camera_set_config_petmode = 'pet_mode'
|
||
camera_set_config_recording = 'rec24'
|
||
# Le paramètre privacy se gère avec le bouton derrière la caméra.
|
||
camera_set_config_name = 'name'
|
||
|
||
# Capteurs
|
||
sensors_list = '/mysensors'
|
||
sensors_label = 'Sensor'
|
||
sensors_label_id = 'id'
|
||
sensors_mac_field = 'deviceMac'
|
||
sensors_type_field = 'deviceType'
|
||
sensors_model_field = 'deviceModel'
|
||
sensors_version_field = 'deviceVersion'
|
||
sensors_name_field = 'name'
|
||
sensors_longname_field = 'long_name'
|
||
sensors_namegender_field = 'name_gender'
|
||
sensors_batterylevel_field = 'batteryLevel'
|
||
sensors_signal_field = 'signalLevel'
|
||
sensors_status_field = 'status'
|
||
sensors_status_value_ok = 'OK'
|
||
|
||
# Fil d'événements
|
||
logs_path = '/getlog?page=1&nbparpage=10000' # je pense qu'on récupère tous les événements avec cette valeur
|
||
logs_labels = 'LOG'
|
||
|
||
|
||
def bytes2file (b):
|
||
'''
|
||
Retourne une classe semblable à un fichier contant b
|
||
'''
|
||
from io import BytesIO
|
||
r = BytesIO ()
|
||
r.write (b)
|
||
r.seek (0)
|
||
return (r)
|
||
|
||
|
||
def bytes2image (b):
|
||
'''
|
||
Retourne une Image PIL contenant l'image donnée en b
|
||
'''
|
||
from PIL import Image
|
||
f = bytes2file (b)
|
||
r = Image.open (f)
|
||
return (r)
|
||
|
||
|
||
def get_xml_tree (fp):
|
||
'''
|
||
Retourne une variable itérable contenant les données d'un arbre XML
|
||
'''
|
||
def build_tree (element):
|
||
if tuple (element) == ():
|
||
return (element.tag, dict (element.items ()), element.text)
|
||
else:
|
||
sub = []
|
||
for i in element:
|
||
sub.append (build_tree (i))
|
||
return (element.tag, dict (element.items ()), sub)
|
||
from xml.etree import ElementTree as ET
|
||
fp.seek (0)
|
||
root = ET.parse (fp).getroot ()
|
||
return (build_tree (root))
|
||
|
||
|
||
class HomeSFR ():
|
||
def __init__ (self, username = None, password = None, cookies = None, debug = False, autologin = True):
|
||
'''
|
||
Instancie la classe avec un identifiant et un mot de passe, ou des cookies
|
||
On peut définir les identifiants et les cookies, la classe utilisera les cookies par défaut et les identifiants si on n'est pas connecté
|
||
debug fourni des informations supplémentaires sur la sortie standard, s'il est à False, cette classe n'envoie rien sur la sortie standard
|
||
'''
|
||
self.DEBUG = debug
|
||
if self.DEBUG:
|
||
print (name + ' ' + version)
|
||
print ('Auteurs:')
|
||
for i in authors:
|
||
print (' - ' + i)
|
||
if username is not None:
|
||
print ('initalisé avec l\'identifiant ' + username)
|
||
if cookies is not None:
|
||
print ('initialisé avec des cookies')
|
||
print ('debug = ' + str (debug))
|
||
print ('autologin = ' + str (autologin))
|
||
|
||
if (username is None or password is None) and cookies is None:
|
||
raise TypeError ('Vous devez définir des identifiant ou des cookies !')
|
||
self.username = username
|
||
self.password = password
|
||
if self.username is not None and self.password is not None:
|
||
self.autologin = autologin
|
||
else:
|
||
self.autologin = False
|
||
if cookies is None:
|
||
self.cookies = CookieJar ()
|
||
elif type (cookies) == CookieJar:
|
||
self.cookies = cookies
|
||
else:
|
||
raise TypeError ('Les cookies doivent être de type CookieJar !')
|
||
self.opener = request.build_opener (request.HTTPCookieProcessor (self.cookies))
|
||
|
||
def __str__ (self):
|
||
'''
|
||
Returne des informations sur l'état de l'instance
|
||
'''
|
||
if self.username is not None:
|
||
return (name + ' ' + version + '\nUtilisateur : ' + self.username + '\nDebug : ' + str (self.DEBUG))
|
||
else:
|
||
return (name + ' ' + version + '\nUtilisateur : Inconnu, authentifié avec des cookies.\nDebug : ' + str (self.DEBUG))
|
||
|
||
def test_login (self):
|
||
'''
|
||
Retourne l'état de l'authentification
|
||
'''
|
||
try:
|
||
if self.DEBUG:
|
||
print ('Test de l\'authentification')
|
||
self.opener.open (base_url + auth_path)
|
||
except HTTPError:
|
||
if self.DEBUG:
|
||
print ('Non connecté')
|
||
return (False)
|
||
if self.DEBUG:
|
||
print ('Connecté')
|
||
return (True)
|
||
|
||
def login (self):
|
||
'''
|
||
S'authentifier auprès du service
|
||
Retourne True si c'est réussi, False sinon
|
||
Si seuls les cookies sont définis, la méthode retournera False, même si nous sommes authentifiés, pour savoir si on est authentifiés, utiliser test_login ()
|
||
'''
|
||
if self.username is not None and self.password is not None:
|
||
self.opener.open (auth_referer)
|
||
data = auth_extra_fields
|
||
data [auth_user_field] = self.username
|
||
data [auth_pass_field] = self.password
|
||
data = bytes (urlencode (data), 'UTF8')
|
||
if self.DEBUG:
|
||
print ('Cookies ' + str (len (self.cookies)))
|
||
print ('Envoi de ' + str (data))
|
||
a = self.opener.open (auth_post_url, data = data)
|
||
if self.DEBUG:
|
||
print ('Authentification redirigée vers ' + a.geturl ())
|
||
return (a.geturl () == auth_ok_url)
|
||
else:
|
||
return (False)
|
||
|
||
def get_or_autologin (self, url, data = None):
|
||
'''
|
||
Fais une requête, si une erreur 403 est retourné, tente une authentification automatiquement (si réglé dans le paramètre autologin), sinon lève une exception
|
||
'''
|
||
try:
|
||
return (self.opener.open (url, data = data))
|
||
except HTTPError as e:
|
||
if '403' in str (e) and self.autologin:
|
||
self.login ()
|
||
return (self.opener.open (url, data = data))
|
||
else:
|
||
raise e
|
||
|
||
def logout (self):
|
||
'''
|
||
Se déconnecter
|
||
L'instance devrait être supprimée après l'appel de cette fonction
|
||
'''
|
||
if self.DEBUG:
|
||
print ('Demande de déconnexion')
|
||
self.opener.open (base_url + auth_logout_path)
|
||
if self.DEBUG:
|
||
print ('Destruction des cookies')
|
||
del self.cookies
|
||
self.cookies = None
|
||
return (None)
|
||
|
||
def get_cookies (self):
|
||
'''
|
||
Récupérer les cookies
|
||
Il est recommandé de supprimer l'instance après cette fonction
|
||
'''
|
||
return (self.cookies)
|
||
|
||
def set_mode (self, mode):
|
||
'''
|
||
Modifie le mode de détection
|
||
'''
|
||
if mode == MODE_OFF:
|
||
m = mode_off
|
||
elif mode == MODE_CUSTOM:
|
||
m = mode_custom
|
||
elif mode == MODE_ON:
|
||
m = mode_on
|
||
else:
|
||
if self.DEBUG:
|
||
print ('Vous devriez utiliser les constantes MODE_OFF, MODE_ON et MODE_CUSTOM.')
|
||
raise ValueError
|
||
r = base_url + mode_set_path + '?' + mode_set_field + '=' + m
|
||
if self.DEBUG:
|
||
print ('Demande ' + r)
|
||
self.get_or_autologin (r)
|
||
return (True)
|
||
|
||
def get_mode (self):
|
||
'''
|
||
Retourne le mode de détection
|
||
'''
|
||
r = base_url + mode_get_path
|
||
if self.DEBUG:
|
||
print ('Demande ' + r)
|
||
a = bytes2file (self.get_or_autologin (r).read ())
|
||
b = get_xml_tree (a) [1]
|
||
c = b [mode_get_label]
|
||
if self.DEBUG:
|
||
print ('Mode de détection ' + c)
|
||
if (c == mode_off):
|
||
return (MODE_OFF)
|
||
if (c == mode_custom):
|
||
return (MODE_CUSTOM)
|
||
if (c == mode_on):
|
||
return (MODE_ON)
|
||
return (None)
|
||
|
||
def list_sensors (self):
|
||
'''
|
||
Retourne une liste des IDs des capteurs
|
||
'''
|
||
r = base_url + sensors_list
|
||
a = bytes2file (self.get_or_autologin (r).read ())
|
||
b = get_xml_tree (a)
|
||
r = []
|
||
for i in b [2]:
|
||
try:
|
||
r.append (i [1] [sensors_label_id])
|
||
except KeyError:
|
||
pass
|
||
return (list (r))
|
||
|
||
def get_sensor (self, id):
|
||
'''
|
||
Retourne un objet Sensor à partir de l'ID
|
||
'''
|
||
r = Sensor (id, self.get_or_autologin)
|
||
r.refresh ()
|
||
return (r)
|
||
|
||
def get_all_sensors (self):
|
||
'''
|
||
Retourne un tuple d'objet Sensor contenant tous les capteurs
|
||
'''
|
||
r = []
|
||
for i in self.list_sensors ():
|
||
r.append (self.get_sensor (i))
|
||
return (tuple (r))
|
||
|
||
|
||
class Sensor ():
|
||
def __init__ (self, id, get_or_autologin):
|
||
|
||
self.id = id
|
||
self.sensor_dict = None
|
||
self.get_or_autologin = get_or_autologin
|
||
|
||
def refresh (self):
|
||
'''
|
||
Mets à jour les données du capteur
|
||
'''
|
||
|
||
r = base_url + sensors_list
|
||
self.sensor_dict = None
|
||
for i in get_xml_tree (bytes2file (self.get_or_autologin (r).read ())) [2]:
|
||
if i [0] == sensors_label and i [1] [sensors_label_id] == self.id:
|
||
self.sensor_dict = i [2]
|
||
break
|
||
|
||
def get_raw (self):
|
||
'''
|
||
Retourne les données brutes du capteur
|
||
'''
|
||
return (self.sensor_dict)
|
||
|
||
def get_value (self, lst, key):
|
||
for i in lst:
|
||
if i [0] == key:
|
||
return (i [2])
|
||
raise KeyError ()
|
||
|
||
def get_mac (self):
|
||
'''
|
||
Retourne l'adresse matérielle du capteur, s'il en a une
|
||
'''
|
||
return (self.get_value (self.sensor_dict, sensors_mac_field))
|
||
|
||
def get_type (self):
|
||
'''
|
||
Retourne le type du capteur
|
||
Les types sont ceux définis dans les constantes
|
||
'''
|
||
return (self.get_value (self.sensor_dict, sensors_type_field))
|
||
|
||
def get_model (self):
|
||
'''
|
||
Retourne le modèle du capteur
|
||
'''
|
||
return (self.get_value (self.sensor_dict, sensors_model_field))
|
||
|
||
def get_version (self):
|
||
'''
|
||
Retourne la version du capteur
|
||
'''
|
||
return (self.get_value (self.sensor_dict, sensors_version_field))
|
||
|
||
def get_name (self):
|
||
'''
|
||
Retourne le nom du capteur
|
||
'''
|
||
return (self.get_value (self.sensor_dict, sensors_name_field))
|
||
|
||
def get_longname (self):
|
||
'''
|
||
Retourne un nom long du capteur composé de son type en français et de son nom
|
||
'''
|
||
return (self.get_value (self.sensor_dict, sensors_longname_field))
|
||
|
||
def get_namegender (self):
|
||
'''
|
||
Retourne le genre du nom du type de capteur en français
|
||
M pour masculin et F pour féminin
|
||
'''
|
||
return (self.get_value (self.sensor_dict, sensors_namegender_field))
|
||
|
||
def get_batterylevel (self):
|
||
'''
|
||
Retourne le niveau de batterie sur 10
|
||
Toute autre valeur doit être considérée comme venant d'un capteur n'ayant pas de batterie
|
||
'''
|
||
return (int (self.get_value (self.sensor_dict, sensors_batterylevel_field)))
|
||
|
||
def get_signal (self):
|
||
'''
|
||
Retourne le niveau de signal sur 10
|
||
Tout autre valeur est pour un capteur connecté par câble
|
||
'''
|
||
return (int (self.get_value (self.sensor_dict, sensors_signal_field)))
|
||
|
||
def get_status (self):
|
||
'''
|
||
Retourne True si le capteur est considéré comme opérationnel par le système
|
||
'''
|
||
return (self.get_value (self.sensor_dict, sensors_status_field) == sensors_status_value_ok)
|
||
|
||
def get_camera_snapshot (self):
|
||
'''
|
||
Retourne une capture de la caméra dans un objet PIL.Image
|
||
'''
|
||
r = base_url + camera_snapshot + '&' + camera_snapshot_mac + '=' + self.get_mac ()
|
||
a = bytes2image (self.get_or_autologin (r).read ())
|
||
return (a)
|
||
|
||
def get_camera_petmode (self):
|
||
'''
|
||
Gets the pet mode value
|
||
Pet mode is a setting on movement sensibility, to avoid trigger on pet movements
|
||
'''
|
||
return (self.sensor_dict [camera_get_config_petmode] == '1')
|
||
|
||
def get_camera_recording (self):
|
||
'''
|
||
Gets if the camera records or not
|
||
'''
|
||
return (self.sensor_dict [camera_get_config_recording] == '1')
|
||
|
||
def get_camera_privacy (self):
|
||
'''
|
||
Gets if the camera records or not
|
||
'''
|
||
return (self.sensor_dict [camera_get_config_privacy] == '1') |