Shipping v1.2.0

georideapilib/api.py

@@ -5,24 +5,27 @@ Georide api lib
 
 import json
 import logging
+
 import requests
-from georideapilib.objects import (
-    GeoRideTracker, 
-    GeoRideAccount, 
-    GeoRideUser,  
-    GeoRideTrackerTrip,  
-    GeoRideTrackerPosition, 
-    GeoRideSharedTrip,
-    GeoRideTrackerBeacon
-)
 
 from georideapilib.exception import (
     LoginException,
     SeverException,
     UnauthorizedException
 )
+from georideapilib.objects import (
+    GeoRideTracker,
+    GeoRideAccount,
+    GeoRideUser,
+    GeoRideTrackerTrip,
+    GeoRideTrackerPosition,
+    GeoRideSharedTrip,
+    GeoRideTrackerBeacon,
+    GeoRideMaintenance
+)
 
-GEORIDE_API_HOST = "https://api.georide.fr"
+GEORIDE_API_HOST = "https://api.georide.com"
+GEORIDE_SOCKET_HOST = "https://socket.georide.com"
 GEORIDE_API_ENDPOINT_LOGIN = "/user/login"
 GEORIDE_API_ENDPOINT_NEW_TOKEN = "/user/new-token"
 GEORIDE_API_ENDPOINT_LOGOUT = "/user/logout"
@@ -40,20 +43,25 @@ GEORIDE_API_ENDPOINT_TRACKER_ALARM_OFF = "/tracker/{trackerId}/sonor-alarm/off"
 GEORIDE_API_ENDPOINT_TRACKER_ALARM_ON = "/tracker/{trackerId}/sonor-alarm/on"
 GEORIDE_API_ENDPOINT_TRACKER_ECO_MODE_OFF = "/tracker/{trackerId}/eco-mode/off"
 GEORIDE_API_ENDPOINT_TRACKER_ECO_MODE_ON = "/tracker/{trackerId}/eco-mode/on"
+GEORIDE_API_ENDPOINT_TRACKER_DELETE_MAINTENANCE = "/tracker/{trackerId}/maintenance/{maintenanceId}"
+GEORIDE_API_ENDPOINT_TRACKER_MAINTENANCE = "/tracker/{trackerId}/maintenance"
 
 _SESSION = requests.Session()
 _LOGGER = logging.getLogger(__name__)
 
+
 def get_authorisation_token(email, password):
     """ return an authorization token or no"""
     data = {"email": email, "password": password}
     encoded_data = json.dumps(data).encode('utf-8')
 
-    response = _SESSION.post( 
-        GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_LOGIN,
+    response = _send_request(
+        "POST",
+        GEORIDE_API_ENDPOINT_LOGIN,
+        token=None,
         data=encoded_data,
-        headers={'Content-Type': 'application/json'})
-    
+    )
+
     if response.status_code == 200:
         _LOGGER.debug("Login success")
         response_data = response.json()
@@ -63,63 +71,68 @@ def get_authorisation_token(email, password):
         raise LoginException(get_authorisation_token, "Login failed")
     else:
         _LOGGER.error("Georide login, http error code: %s", response.status_code)
-        raise SeverException(get_authorisation_token, 
+        raise SeverException(get_authorisation_token,
                              "Georide login, http error code: {}".format(response.status_code))
     return account
 
 
 def renew_token(token):
     """ renew the authorization token """
-    headers = {"Authorization": "Bearer " + token}
-    response = _SESSION.get(
-        GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_NEW_TOKEN,
-        headers=headers)
+    response = _send_request(
+        "GET",
+        GEORIDE_API_ENDPOINT_NEW_TOKEN,
+        token
+    )
     if response.status_code == 200:
         _LOGGER.debug("Token updated")
         response_data = response.json()
         new_token = response_data['authToken']
     elif response.status_code == 401:
-        _LOGGER.warnning("Renew token refused")
+        _LOGGER.warning("Renew token refused")
         raise UnauthorizedException(renew_token, "Renew token refused")
     else:
         _LOGGER.error("Georide login, http error code: %s", response.status_code)
-        raise SeverException(renew_token, 
+        raise SeverException(renew_token,
                              "Georide login, http error code: {}".format(response.status_code))
     return new_token
 
+
 def revoke_token(token):
     """ invalidate the authorization token """
-    headers = {"Authorization": "Bearer " + token}
-    response = _SESSION.post(
-        GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_LOGOUT,
-        headers=headers)
+    response = _send_request(
+        "POST",
+        GEORIDE_API_ENDPOINT_LOGOUT,
+        token
+    )
     if response.status_code == 401:
-        _LOGGER.warnning("Token allready revoked")
+        _LOGGER.warning("Token already revoked")
         raise UnauthorizedException(revoke_token, "Token allready revoked")
     if response.status_code == 403:
-        _LOGGER.warnning("Token allready revoked")
+        _LOGGER.warning("Token already revoked")
         return False
     return True
 
 
 def get_user(token):
     """ get the georide user info """
-    headers = {"Authorization": "Bearer " + token}
-    response = _SESSION.get(
-        GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_USER,
-        headers=headers)
+    response = _send_request(
+        "GET",
+        GEORIDE_API_ENDPOINT_USER,
+        token
+    )
     response_data = response.json()
     _LOGGER.debug(response_data)
     account = GeoRideUser.from_json(response_data)
-    return account  
+    return account
+
 
 def get_trackers(token):
     """ get user trackers """
-
-    headers = {"Authorization": "Bearer " + token}
-    response = _SESSION.get(
-        GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_TRACKERS,
-        headers=headers)
+    response = _send_request(
+        "GET",
+        GEORIDE_API_ENDPOINT_TRACKERS,
+        token
+    )
 
     response_data = response.json()
     trackers = []
@@ -128,13 +141,14 @@ def get_trackers(token):
         trackers.append(GeoRideTracker.from_json(json_tracker))
     return trackers
 
+
 def get_tracker_beacons(token, tracker_id):
     """ get user trackers """
-
-    headers = {"Authorization": "Bearer " + token}
-    response = _SESSION.get(
-        GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_TRACKER_BEACON.format(trackerId=str(tracker_id)),
-        headers=headers)
+    response = _send_request(
+        "GET",
+        GEORIDE_API_ENDPOINT_TRACKER_BEACON.format(trackerId=str(tracker_id)),
+        token
+    )
 
     response_data = response.json()
     trackers_beacons = []
@@ -145,13 +159,15 @@ def get_tracker_beacons(token, tracker_id):
             trackers_beacons.append(GeoRideTrackerBeacon.from_json(json_tracker_beacon))
     return trackers_beacons
 
+
 def get_trips(token, tracker_id, from_date, to_date):
     """ return all trips between two dates """
-    headers = {"Authorization": "Bearer " + token}
-    response = _SESSION.get(
-        GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_TRIPS.format(trackerId=str(tracker_id)),
-        params={'from': from_date, 'to': to_date},
-        headers=headers)
+    response = _send_request(
+        "GET",
+        GEORIDE_API_ENDPOINT_TRIPS.format(trackerId=str(tracker_id)),
+        token,
+        {'from': from_date, 'to': to_date}
+    )
 
     response_data = response.json()
     trips = []
@@ -160,13 +176,15 @@ def get_trips(token, tracker_id, from_date, to_date):
             trips.append(GeoRideTrackerTrip.from_json(json_trip))
     return trips
 
+
 def get_positions(token, tracker_id, from_date, to_date):
-    """ return all trips between two dates """
-    headers = {"Authorization": "Bearer " + token}
-    response = _SESSION.get(
-        GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_POSITIONS.format(trackerId=str(tracker_id)),
-        params={'from': from_date, 'to': to_date},
-        headers=headers)
+    """ return positions from dates """
+    response = _send_request(
+        "GET",
+        GEORIDE_API_ENDPOINT_POSITIONS.format(trackerId=str(tracker_id)),
+        token,
+        {'from': from_date, 'to': to_date}
+    )
 
     response_data = response.json()
     positions = []
@@ -175,20 +193,24 @@ def get_positions(token, tracker_id, from_date, to_date):
             positions.append(GeoRideTrackerPosition.from_json(json_position))
     return positions
 
+
 def share_a_trip_by_trip_id(token, tracker_id, trip_id):
     """ share trip by trip id """
     return _share_a_trip(token, tracker_id, trip_id=trip_id)
 
+
 def share_a_trip_by_date(token, tracker_id, from_date, to_date):
     """ share trips between two dates """
     return _share_a_trip(token, tracker_id, from_date=from_date, to_date=to_date)
 
+
 def share_a_trip_by_trip_merge_id(token, tracker_id, trip_merged_id):
     """ share trip by trip merged id """
     return _share_a_trip(token, tracker_id, trip_merged_id=trip_merged_id)
 
-def _share_a_trip(token, tracker_id, trip_id=None, from_date=None, # pylint: disable= R0913
-                  to_date=None, trip_merged_id=None): 
+
+def _share_a_trip(token, tracker_id, trip_id=None, from_date=None,  # pylint: disable= R0913
+                  to_date=None, trip_merged_id=None):
     """ share trip by trib_id or between two dates or trip_merged_id """
     data = None
     if trip_id is not None:
@@ -200,91 +222,156 @@ def _share_a_trip(token, tracker_id, trip_id=None, from_date=None, # pylint: dis
 
     encoded_data = json.dumps(data).encode('utf-8')
 
-    headers = {
-        "Authorization": "Bearer " + token,
-        'Content-Type': 'application/json'
-    }
-    response = _SESSION.post(
-        GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_TRIP_SHARE.format(trackerId=str(tracker_id)),
-        data=encoded_data,
-        headers=headers)
+    response = _send_request(
+        "POST",
+        GEORIDE_API_ENDPOINT_TRIP_SHARE.format(trackerId=str(tracker_id)),
+        token,
+        data=encoded_data
+    )
 
     response_data = response.json()
     if response.status_code == 200:
         return GeoRideSharedTrip.from_json(response_data)
     return None
 
+
 def lock_tracker(token, tracker_id):
     """ used to lock a tracker """
-    headers = {"Authorization": "Bearer " + token}
-    response = _SESSION.post(
-        GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_LOCK.format(trackerId=str(tracker_id)),
-        headers=headers)
+    response = _send_request(
+        "POST",
+        GEORIDE_API_ENDPOINT_LOCK.format(trackerId=str(tracker_id)),
+        token
+    )
     if response.status_code != 204:
         return False
     return True
 
+
 def unlock_tracker(token, tracker_id):
     """ used to unlock a tracker """
-    headers = {"Authorization": "Bearer " + token}
-    response = _SESSION.post(
-        GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_UNLOCK.format(trackerId=str(tracker_id)),
-        headers=headers)
+    response = _send_request(
+        "POST",
+        GEORIDE_API_ENDPOINT_UNLOCK.format(trackerId=str(tracker_id)),
+        token
+    )
     if response.status_code != 204:
         return False
     return True
 
+
 def toogle_lock_tracker(token, tracker_id):
     """ used to toggle lock a tracker """
-    headers = {"Authorization": "Bearer " + token}
-    response = _SESSION.post(
-        GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_TOGGLE_LOCK.format(trackerId=str(tracker_id)),
-        headers=headers)
+    response = _send_request(
+        "POST",
+        GEORIDE_API_ENDPOINT_TOGGLE_LOCK.format(trackerId=str(tracker_id)),
+        token
+    )
     response_data = response.json()
     return response_data['locked']
 
+
 def change_tracker_siren_state(token, tracker_id, state: bool):
-    """ used to toggle lock a tracker """
-    headers = {"Authorization": "Bearer " + token}
-    response = None
-    if state == True:
-        response = _SESSION.post(
-            GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_TRACKER_ALARM_ON.format(trackerId=str(tracker_id)),
-            headers=headers)
-    else:
-        response = _SESSION.post(
-            GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_TRACKER_ALARM_OFF.format(trackerId=str(tracker_id)),
-            headers=headers)
+    """ used to change siren state """
+    endpoint = (GEORIDE_API_ENDPOINT_TRACKER_ALARM_ON.format(trackerId=str(tracker_id))) if state \
+        else (GEORIDE_API_ENDPOINT_TRACKER_ALARM_OFF.format(trackerId=str(tracker_id)))
+    response = _send_request(
+        "POST",
+        endpoint,
+        token
+    )
     if response.status_code != 204:
         return False
     return True
 
+
 def change_tracker_eco_mode_state(token, tracker_id, state: bool):
-    """ used to toggle lock a tracker """
-    headers = {"Authorization": "Bearer " + token}
-    response = None
-    if state == True:
-        response = _SESSION.post(
-            GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_TRACKER_ECO_MODE_ON.format(trackerId=str(tracker_id)),
-            headers=headers)
-    else:
-        response = _SESSION.post(
-            GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_TRACKER_ECO_MODE_OFF.format(trackerId=str(tracker_id)),
-            headers=headers)
+    """ used to toggle eco mode state """
+    endpoint = (GEORIDE_API_ENDPOINT_TRACKER_ECO_MODE_ON.format(trackerId=str(tracker_id))) if state \
+        else (GEORIDE_API_ENDPOINT_TRACKER_ECO_MODE_OFF.format(trackerId=str(tracker_id)))
+    response = _send_request(
+        "POST",
+        endpoint,
+        token
+    )
+
     if response.status_code != 204:
         return False
     return True
 
+
+def add_or_update_maintenance(token, tracker_id, maintenance_json):
+    """ used to add or update a maintenance """
+    response = _send_request(
+        "POST",
+        GEORIDE_API_ENDPOINT_TRACKER_MAINTENANCE.format(trackerId=str(tracker_id)),
+        token,
+        data=maintenance_json
+    )
+
+    if response.status_code == 204:
+        return True
+    return False
+
+
+def delete_maintenance(token, tracker_id, maintenance_id):
+    """ used to add or update a maintenance """
+    response = _send_request(
+        "DELETE",
+        GEORIDE_API_ENDPOINT_TRACKER_DELETE_MAINTENANCE.format(
+            trackerId=str(tracker_id),
+            maintenanceId=str(maintenance_id)
+        ),
+        token
+    )
+
+    if response.status_code == 204:
+        return True
+    return False
+
+
+def get_maintenances_for_tracker(token, tracker_id):
+    """ used to retrieve maintenances """
+    response = _send_request(
+        "GET",
+        GEORIDE_API_ENDPOINT_TRACKER_MAINTENANCE.format(trackerId=str(tracker_id)),
+        token
+    )
+
+    response_data = response.json()
+    maintenances = []
+    if response.status_code == 200:
+        for maintenance in response_data['maintenanceList']:
+            maintenances.append(GeoRideMaintenance.from_json(maintenance))
+        return maintenances
+    else:
+        return None
+
+
 def shutdown_tracker(token, tracker_id):
     """ used to toggle lock a tracker """
-    headers = {"Authorization": "Bearer " + token}
-    response = _SESSION.post(
-        GEORIDE_API_HOST + GEORIDE_API_ENDPOINT_SHUTDOWN_TRACKER.format(trackerId=str(tracker_id)),
-        headers=headers)
+    response = _send_request(
+        "POST",
+        GEORIDE_API_ENDPOINT_SHUTDOWN_TRACKER.format(trackerId=str(tracker_id)),
+        token
+    )
     response_data = response.json()
     if response.status_code == 200:
         return response_data['locked']
     return None
 
+
+def _send_request(method, endpoint, token, params=None, data=None):
+    headers = {"Authorization": "Bearer " + token, "Content-Type": "application/json"} if token else {
+        "Content-Type": "application/json"}
+    endpoint_url = GEORIDE_API_HOST + endpoint
+
+    if method == "POST":
+        return _SESSION.post(endpoint_url, data=data, headers=headers)
+    elif method == "GET":
+        return _SESSION.get(endpoint_url, params=params, headers=headers)
+    elif method == "DELETE":
+        return _SESSION.delete(endpoint_url, headers=headers)
+
+
 if __name__ == '__main__':
     print("Not a main module")

georideapilib/objects/GeoRideAccount.py

@@ -11,7 +11,7 @@ class GeoRideAccount:
     """ Account object representation """ 
     def __init__(self, account_id, email, is_admin, auth_token):
         self._account_id = account_id
-        self._email = emailgit 
+        self._email = email
         self._is_admin = is_admin
         self._auth_token = auth_token
 

georideapilib/objects/GeoRideMaintenance.py

@@ -0,0 +1,100 @@
+import json
+import logging
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class GeoRideMaintenance:
+
+    def __init__(self,
+                 name,
+                 lastMaintenanceDistance,
+                 everyMaintenance,
+                 lastMaintenanceDate=None,
+                 id=None,
+                 todo=None,
+                 trackerId=None,
+                 dateUnitType=None,
+                 createdAt=None,
+                 updatedAt=None):
+        self.id = id
+        self.name = name
+        self.todo = todo
+        self.trackerId = trackerId
+        self.lastMaintenanceDistance = lastMaintenanceDistance
+        self.lastMaintenanceDate = lastMaintenanceDate
+        self.dateUnitType = dateUnitType
+        self.everyMaintenance = everyMaintenance
+        self.createdAt = createdAt
+        self.updatedAt = updatedAt
+
+    @property
+    def get_id(self):
+        return self.id
+
+    @property
+    def get_name(self):
+        return self.name
+
+    @property
+    def get_todo(self):
+        return self.todo
+
+    @property
+    def tracker_id(self):
+        return self.trackerId
+
+    @property
+    def last_maintenance_distance(self):
+        return self.lastMaintenanceDistance
+
+    @property
+    def last_maintenance_date(self):
+        return self.lastMaintenanceDate
+
+    @property
+    def date_unit_type(self):
+        return self.dateUnitType
+
+    @property
+    def every_maintenance(self):
+        return self.everyMaintenance
+
+    @property
+    def created_at(self):
+        return self.createdAt
+
+    @property
+    def updated_at(self):
+        return self.updatedAt
+
+    def to_distance_maintenance_json(self):
+        return json.dumps({
+            "name": self.name,
+            "everyMaintenance": self.everyMaintenance,
+            "lastMaintenanceDistance": self.lastMaintenanceDistance
+        }).encode("utf-8")
+
+    def to_date_maintenance_json(self):
+        return json.dumps({
+            "name": self.name,
+            "everyMaintenance": self.everyMaintenance,
+            "lastMaintenanceDate": self.lastMaintenanceDate,
+            "dateUnitType": self.dateUnitType
+        }).encode("utf-8")
+
+    @staticmethod
+    def from_json(json_obj):
+        """return new object fromjson"""
+        return GeoRideMaintenance(
+            name=json_obj['name'],
+            id=json_obj['id'],
+            todo=json_obj['todo'],
+            trackerId=json_obj['trackerId'],
+            lastMaintenanceDistance=json_obj['lastMaintenanceDistance'],
+            lastMaintenanceDate=json_obj['lastMaintenanceDate'],
+            dateUnitType=json_obj['dateUnitType'],
+            everyMaintenance=json_obj['everyMaintenance'],
+            createdAt=json_obj['createdAt'],
+            updatedAt=json_obj['updatedAt']
+        )

georideapilib/objects/GeoRideTracker.py

@@ -462,7 +462,7 @@ class GeoRideTracker(metaclass=JsonMgtMetaClass): # pylint: disable=R0904,R0902
         return self._ecall_crash_mode
 
     @property
-    def _ssistance_theft_activated(self):
+    def assistance_theft_activated(self):
         """ assistanceTheftActivated property """
         return self._assistance_theft_activated
 
@@ -495,26 +495,26 @@ class GeoRideTracker(metaclass=JsonMgtMetaClass): # pylint: disable=R0904,R0902
             cls.json_field_protect(json,'isOldTracker', False),
             cls.json_field_protect(json,'autoLockFreezedTo'),
             cls.json_field_protect(json,'fixtime'),
-            json['role'], # Mandatory
-            json['lastPaymentDate'],# Mandatory
+            cls.json_field_protect(json,'role', "owner"),
+            cls.json_field_protect(json,'lastPaymentDate', None),
             cls.json_field_protect(json,'giftCardId'),
             cls.json_field_protect(json,'expires'),
             cls.json_field_protect(json,'activationDate'),
-            json['odometer'],#Mandatory
+            cls.json_field_protect(json,'odometer', False),
             cls.json_field_protect(json,'isStolen', False),
             cls.json_field_protect(json,'isCrashed', False),
             cls.json_field_protect(json,'crashDetectionDisabled'),
-            json['speed'], # Mandatory
-            json['moving'], # Mandatory
+            cls.json_field_protect(json,'speed', 0), # Mandatory
+            cls.json_field_protect(json,'moving', False),
             cls.json_field_protect(json,'positionId', -1),
-            json['latitude'], # Mandatory
-            json['longitude'], # Mandatory
+            cls.json_field_protect(json,'latitude', 47.0),
+            cls.json_field_protect(json,'longitude', -1.0),
             cls.json_field_protect(json,'altitude', 0),
             cls.json_field_protect(json,'lockedPositionId'),
             cls.json_field_protect(json,'lockedLatitude'),
             cls.json_field_protect(json,'lockedLongitude'),
-            json['isLocked'], # Mandatory
-            json['canSeePosition'],# Mandatory
+            cls.json_field_protect(json,'isLocked', False),
+            cls.json_field_protect(json,'canSeePosition', False),
             cls.json_field_protect(json,'canLock', False),
             cls.json_field_protect(json,'canUnlock', False),
             cls.json_field_protect(json,'canShare', False),
@@ -523,7 +523,7 @@ class GeoRideTracker(metaclass=JsonMgtMetaClass): # pylint: disable=R0904,R0902
             cls.json_field_protect(json,'canSeeStatistics', False),
             cls.json_field_protect(json,'canSendBrokenDownSignal', False),
             cls.json_field_protect(json,'canSendStolenSignal', False),
-            json['status'],# Mandatory
+            cls.json_field_protect(json,'status', 'unknown'),
             cls.json_field_protect(json,'subscriptionId', -1),
             cls.json_field_protect(json,'externalBatteryVoltage', -1.0),
             cls.json_field_protect(json,'internalBatteryVoltage', -1.0),
@@ -543,7 +543,12 @@ class GeoRideTracker(metaclass=JsonMgtMetaClass): # pylint: disable=R0904,R0902
             cls.json_field_protect(json,'softwareVersion', 1),
             cls.json_field_protect(json,'hasBeacon', False),
             cls.json_field_protect(json,'hasOutdatedBeacons', False),
-            cls.json_field_protect(json,'eCallActivated', False)
+            cls.json_field_protect(json,'eCallActivated', False),
+            cls.json_field_protect(json,'eCallCrashMode'),
+            cls.json_field_protect(json,'assistanceTheftActivated'),
+            cls.json_field_protect(json,'model'),
+            cls.json_field_protect(json,'businessModel'),
+            cls.json_field_protect(json,'hasTheftCaseOpened'),
         )
 
     def update_all_data(self, tracker):

georideapilib/objects/__init__.py

@@ -8,4 +8,5 @@ from .GeoRideTrackerBeacon import *
 from .GeoRideTrackerPosition import *
 from .GeoRideTrackerTrip import *
 from .GeoRideUser import *
+from .GeoRideMaintenance import *
 

georideapilib/socket.py

@@ -2,11 +2,11 @@
 import logging
 import socketio
 
-from georideapilib.api import GEORIDE_API_HOST
+from georideapilib.api import GEORIDE_SOCKET_HOST
 
 _LOGGER = logging.getLogger(__name__)
 
-sio = socketio.Client(reconnection=True) # pylint: disable=C0103
+sio = socketio.Client(reconnection=True, reconnection_attempts=5, reconnection_delay=1000, reconnection_delay_max=5000, randomization_factor=0.5) # pylint: disable=C0103
 
 @sio.on('connect')
 def on_connect():
@@ -104,8 +104,9 @@ class GeoRideSocket():
     def connect(self, auth_token):
         """ connect to the georide socket"""
         if self._initialised is not False:
-            sio.connect(GEORIDE_API_HOST, headers={'token': auth_token})
+            sio.connect(GEORIDE_SOCKET_HOST, headers={'token': auth_token})
             sio.wait()
+
         else:
             _LOGGER.error("Please call init() before")
         

setup.py

@@ -19,22 +19,22 @@ CURRENT_DIR = os.path.dirname(__file__)
 setup(
     name='georideapilib',
     packages=['georideapilib', 'georideapilib.objects'],  # this must be the same as the name above
-    version='0.9.1',
+    version='1.2.0',
     description='Lib to control GeoRide tracker devices with theire rest api',
     author='Matthieu DUVAL',
     author_email='georideapilib@duval-dev.fr',
     # use the URL to the github repo
     url='https://github.com/hacf/georide-api',
-    download_url='https://codeload.github.com/hacf/georide-api/tar.gz/0.9.1',
+    download_url='https://codeload.github.com/hacf/georide-api/tar.gz/1.0.0',
     keywords=['rest', 'georide', 'api', 'grutier', 'GeoRide'],  # arbitrary keywords
     classifiers=[],
     install_requires=["python-socketio[client]==4.6.1"],
     tests_require=[
         'pytest>=3.7',
-        'pytest-pep8',
+        'pytest-pep8',  
         'pytest-cov',
         'python-coveralls',
         'pylint',
         'coverage>=4.4'
     ]
-)
+)