hyundai-kia-connect-api 3.17.6__py2.py3-none-any.whl → 3.32.0__py2.py3-none-any.whl

hyundai_kia_connect_api/{HyundaiBlueLinkAPIUSA.py → HyundaiBlueLinkApiUSA.py}

@@ -4,13 +4,16 @@
 
 import logging
 import time
-import re
 import datetime as dt
 import pytz
 import requests
+import certifi
+
 from requests.adapters import HTTPAdapter
 from urllib3.util.ssl_ import create_urllib3_context
 
+from hyundai_kia_connect_api.exceptions import APIError
+
 from .const import (
     DOMAIN,
     VEHICLE_LOCK_ACTION,
@@ -19,10 +22,17 @@ from .const import (
     TEMPERATURE_UNITS,
     ENGINE_TYPES,
 )
-from .utils import get_child_value, get_float
+from .utils import get_child_value, get_float, parse_datetime
 from .ApiImpl import ApiImpl, ClimateRequestOptions
 from .Token import Token
-from .Vehicle import DailyDrivingStats, Vehicle
+from .Vehicle import (
+    DailyDrivingStats,
+    DayTripCounts,
+    DayTripInfo,
+    MonthTripInfo,
+    TripInfo,
+    Vehicle,
+)
 
 
 CIPHERS = "DEFAULT@SECLEVEL=1"
@@ -43,7 +53,7 @@ class cipherAdapter(HTTPAdapter):
 
     def init_poolmanager(self, *args, **kwargs):
         kwargs["ssl_context"] = self._setup_ssl_context()
-
+        kwargs["ca_certs"] = certifi.where()
         return super().init_poolmanager(*args, **kwargs)
 
     def proxy_manager_for(self, *args, **kwargs):
@@ -52,8 +62,8 @@ class cipherAdapter(HTTPAdapter):
         return super().proxy_manager_for(*args, **kwargs)
 
 
-class HyundaiBlueLinkAPIUSA(ApiImpl):
-    """HyundaiBlueLinkAPIUSA"""
+class HyundaiBlueLinkApiUSA(ApiImpl):
+    """HyundaiBlueLinkApiUSA"""
 
     # initialize with a timestamp which will allow the first fetch to occur
     last_loc_timestamp = dt.datetime.now(pytz.utc) - dt.timedelta(hours=3)
@@ -235,8 +245,8 @@ class HyundaiBlueLinkAPIUSA(ApiImpl):
         return None
 
     def _update_vehicle_properties(self, vehicle: Vehicle, state: dict) -> None:
-        vehicle.last_updated_at = self.get_last_updated_at(
-            get_child_value(state, "vehicleStatus.dateTime")
+        vehicle.last_updated_at = parse_datetime(
+            get_child_value(state, "vehicleStatus.dateTime"), self.data_timezone
         )
         vehicle.total_driving_range = (
             get_child_value(
@@ -376,6 +386,22 @@ class HyundaiBlueLinkAPIUSA(ApiImpl):
         vehicle.ev_battery_is_plugged_in = get_child_value(
             state, "vehicleStatus.evStatus.batteryPlugin"
         )
+        vehicle.ev_charging_power = get_child_value(
+            state, "vehicleStatus.evStatus.batteryPower.batteryStndChrgPower"
+        )
+        ChargeDict = get_child_value(
+            state, "vehicleStatus.evStatus.reservChargeInfos.targetSOClist"
+        )
+        try:
+            vehicle.ev_charge_limits_ac = [
+                x["targetSOClevel"] for x in ChargeDict if x["plugType"] == 1
+            ][-1]
+            vehicle.ev_charge_limits_dc = [
+                x["targetSOClevel"] for x in ChargeDict if x["plugType"] == 0
+            ][-1]
+        except Exception:
+            _LOGGER.debug(f"{DOMAIN} - SOC Levels couldn't be found. May not be an EV.")
+
         vehicle.ev_driving_range = (
             get_child_value(
                 state,
@@ -428,14 +454,41 @@ class HyundaiBlueLinkAPIUSA(ApiImpl):
             vehicle.location = (
                 get_child_value(state, "vehicleStatus.vehicleLocation.coord.lat"),
                 get_child_value(state, "vehicleStatus.vehicleLocation.coord.lon"),
-                self.get_last_updated_at(
-                    get_child_value(state, "vehicleStatus.vehicleLocation.time")
+                parse_datetime(
+                    get_child_value(state, "vehicleStatus.vehicleLocation.time"),
+                    self.data_timezone,
                 ),
             )
         vehicle.air_control_is_on = get_child_value(state, "vehicleStatus.airCtrlOn")
 
+        # fill vehicle.daily_stats
         tripStats = []
         tripDetails = get_child_value(state, "evTripDetails.tripdetails") or {}
+
+        # compute more digits for distance mileage using odometer and overrule distance
+        previous_odometer = None
+        for trip in reversed(tripDetails):
+            odometer = get_child_value(trip, "odometer.value")
+            if previous_odometer and odometer:
+                delta_odometer = odometer - previous_odometer
+                if delta_odometer >= 0.0:
+                    trip["distance"] = delta_odometer
+            previous_odometer = odometer
+
+        # overrule odometer with more accuracy from last trip
+        if (
+            previous_odometer
+            and vehicle.odometer
+            and previous_odometer > vehicle.odometer
+        ):
+            _LOGGER.debug(
+                f"Overruling odometer: {previous_odometer:.1f} old: {vehicle.odometer:.1f}"  # noqa
+            )
+            vehicle.odometer = (
+                previous_odometer,
+                DISTANCE_UNITS[3],
+            )
+
         for trip in tripDetails:
             processedTrip = DailyDrivingStats(
                 date=dt.datetime.strptime(trip["startdate"], "%Y-%m-%d %H:%M:%S.%f"),
@@ -446,13 +499,185 @@ class HyundaiBlueLinkAPIUSA(ApiImpl):
                 battery_care_consumption=get_child_value(trip, "batterycare"),
                 regenerated_energy=get_child_value(trip, "regen"),
                 distance=get_child_value(trip, "distance"),
+                distance_unit=vehicle.odometer_unit,
             )
             tripStats.append(processedTrip)
 
         vehicle.daily_stats = tripStats
 
+        # remember trips, store state
+        trips = []
+        for trip in tripDetails:
+            yyyymmdd_hhmmss = trip["startdate"]  # remember full date
+            drive_time = int(get_child_value(trip["mileagetime"], "value"))
+            idle_time = int(get_child_value(trip["duration"], "value")) - drive_time
+            processed_trip = TripInfo(
+                hhmmss=yyyymmdd_hhmmss,
+                drive_time=int(drive_time / 60),  # convert seconds to minutes
+                idle_time=int(idle_time / 60),  # convert seconds to minutes
+                distance=float(trip["distance"]),
+                avg_speed=get_child_value(trip["avgspeed"], "value"),
+                max_speed=int(get_child_value(trip["maxspeed"], "value")),
+            )
+            trips.append(processed_trip)
+
+        _LOGGER.debug(f"_update_vehicle_properties filled_trips: {trips}")
+        if len(trips) > 0:
+            state["filled_trips"] = trips
+
         vehicle.data = state
 
+    def update_month_trip_info(
+        self,
+        token,
+        vehicle,
+        yyyymm_string,
+    ) -> None:
+        """
+        feature only available for some regions.
+        Updates the vehicle.month_trip_info for the specified month.
+
+        Default this information is None:
+
+        month_trip_info: MonthTripInfo = None
+        """
+        _LOGGER.debug(f"update_month_trip_info: {yyyymm_string}")
+        vehicle.month_trip_info = None
+
+        if vehicle.data is None or "filled_trips" not in vehicle.data:
+            _LOGGER.debug(f"filled_trips is empty: {vehicle.data}")
+            return  # nothing to fill
+
+        trips = vehicle.data["filled_trips"]
+
+        month_trip_info: MonthTripInfo = None
+        month_trip_info_count = 0
+
+        for trip in trips:
+            date_str = trip.hhmmss
+            yyyymm = date_str[0:4] + date_str[5:7]
+            if yyyymm == yyyymm_string:
+                if month_trip_info_count == 0:
+                    month_trip_info = MonthTripInfo(
+                        yyyymm=yyyymm_string,
+                        summary=TripInfo(
+                            drive_time=trip.drive_time,
+                            idle_time=trip.idle_time,
+                            distance=trip.distance,
+                            avg_speed=trip.avg_speed,
+                            max_speed=trip.max_speed,
+                        ),
+                        day_list=[],
+                    )
+                    month_trip_info_count = 1
+                else:
+                    # increment totals for month (for the few trips available)
+                    month_trip_info_count += 1
+                    summary = month_trip_info.summary
+                    summary.drive_time += trip.drive_time
+                    summary.idle_time += trip.idle_time
+                    summary.distance += trip.distance
+                    summary.avg_speed += trip.avg_speed
+                    summary.max_speed = max(trip.max_speed, summary.max_speed)
+
+                month_trip_info.summary.avg_speed /= month_trip_info_count
+                month_trip_info.summary.avg_speed = round(
+                    month_trip_info.summary.avg_speed, 1
+                )
+
+                # also fill DayTripCount
+                yyyymmdd = yyyymm + date_str[8:10]
+                day_trip_found = False
+                for day in month_trip_info.day_list:
+                    if day.yyyymmdd == yyyymmdd:
+                        day.trip_count += 1
+                        day_trip_found = True
+
+                if not day_trip_found:
+                    month_trip_info.day_list.append(
+                        DayTripCounts(yyyymmdd=yyyymmdd, trip_count=1)
+                    )
+
+        vehicle.month_trip_info = month_trip_info
+
+    def update_day_trip_info(
+        self,
+        token,
+        vehicle,
+        yyyymmdd_string,
+    ) -> None:
+        """
+        feature only available for some regions.
+        Updates the vehicle.day_trip_info information for the specified day.
+
+        Default this information is None:
+
+        day_trip_info: DayTripInfo = None
+        """
+        _LOGGER.debug(f"update_day_trip_info: {yyyymmdd_string}")
+        vehicle.day_trip_info = None
+
+        if vehicle.data is None or "filled_trips" not in vehicle.data:
+            _LOGGER.debug(f"filled_trips is empty: {vehicle.data}")
+            return  # nothing to fill
+
+        trips = vehicle.data["filled_trips"]
+        _LOGGER.debug(f"filled_trips: {trips}")
+
+        day_trip_info: DayTripInfo = None
+        day_trip_info_count = 0
+
+        for trip in trips:
+            date_str = trip.hhmmss
+            yyyymmdd = date_str[0:4] + date_str[5:7] + date_str[8:10]
+            _LOGGER.debug(f"update_day_trip_info: {yyyymmdd} trip: {trip}")
+            if yyyymmdd == yyyymmdd_string:
+                if day_trip_info_count == 0:
+                    day_trip_info = DayTripInfo(
+                        yyyymmdd=yyyymmdd_string,
+                        summary=TripInfo(
+                            drive_time=trip.drive_time,
+                            idle_time=trip.idle_time,
+                            distance=trip.distance,
+                            avg_speed=trip.avg_speed,
+                            max_speed=trip.max_speed,
+                        ),
+                        trip_list=[],
+                    )
+                    day_trip_info_count = 1
+                else:
+                    # increment totals for month (for the few trips available)
+                    day_trip_info_count += 1
+                    summary = day_trip_info.summary
+                    summary.drive_time += trip.drive_time
+                    summary.idle_time += trip.idle_time
+                    summary.distance += trip.distance
+                    summary.avg_speed += trip.avg_speed
+                    summary.max_speed = max(trip.max_speed, summary.max_speed)
+
+                day_trip_info.summary.avg_speed /= day_trip_info_count
+                day_trip_info.summary.avg_speed = round(
+                    day_trip_info.summary.avg_speed, 1
+                )
+
+                # also fill TripInfo
+                hhmmss = date_str[11:13] + date_str[14:16] + date_str[17:19]
+                day_trip_info.trip_list.append(
+                    TripInfo(
+                        hhmmss=hhmmss,
+                        drive_time=trip.drive_time,
+                        idle_time=trip.idle_time,
+                        distance=trip.distance,
+                        avg_speed=trip.avg_speed,
+                        max_speed=trip.max_speed,
+                    )
+                )
+                _LOGGER.debug(
+                    f"update_day_trip_info: trip_list result: {day_trip_info.trip_list}"
+                )
+
+        vehicle.day_trip_info = day_trip_info
+
     def update_vehicle_with_cached_state(self, token: Token, vehicle: Vehicle) -> None:
         state = {}
         state["vehicleDetails"] = self._get_vehicle_details(token, vehicle)
@@ -538,6 +763,8 @@ class HyundaiBlueLinkAPIUSA(ApiImpl):
         elif action == VEHICLE_LOCK_ACTION.UNLOCK:
             url = self.API_URL + "rcs/rdo/on"
             _LOGGER.debug(f"{DOMAIN} - Calling unlock")
+        else:
+            raise APIError(f"Invalid action value: {action}")
 
         headers = self._get_vehicle_headers(token, vehicle)
         headers["APPCLOUD-VIN"] = vehicle.VIN
@@ -636,32 +863,65 @@ class HyundaiBlueLinkAPIUSA(ApiImpl):
         _LOGGER.debug(f"{DOMAIN} - Stop engine response: {response.text}")
 
     def start_charge(self, token: Token, vehicle: Vehicle) -> None:
-        pass
+        if vehicle.engine_type != ENGINE_TYPES.EV:
+            return {}
+
+        _LOGGER.debug(f"{DOMAIN} - Start charging..")
+
+        url = self.API_URL + "evc/charge/start"
+        headers = self._get_vehicle_headers(token, vehicle)
+        _LOGGER.debug(f"{DOMAIN} - Start charging headers: {headers}")
+
+        response = self.sessions.post(url, headers=headers)
+        _LOGGER.debug(
+            f"{DOMAIN} - Start charge response status code: {response.status_code}"
+        )
+        _LOGGER.debug(f"{DOMAIN} - Start charge response: {response.text}")
 
     def stop_charge(self, token: Token, vehicle: Vehicle) -> None:
-        pass
+        if vehicle.engine_type != ENGINE_TYPES.EV:
+            return {}
 
-    def get_last_updated_at(self, value) -> dt.datetime:
-        _LOGGER.debug(f"{DOMAIN} - last_updated_at - before {value}")
-        if value is None:
-            value = dt.datetime(2000, 1, 1, tzinfo=self.data_timezone)
-        else:
-            value = (
-                value.replace("-", "")
-                .replace("T", "")
-                .replace(":", "")
-                .replace("Z", "")
-            )
-            m = re.match(r"(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})", value)
-            value = dt.datetime(
-                year=int(m.group(1)),
-                month=int(m.group(2)),
-                day=int(m.group(3)),
-                hour=int(m.group(4)),
-                minute=int(m.group(5)),
-                second=int(m.group(6)),
-                tzinfo=self.data_timezone,
-            )
+        _LOGGER.debug(f"{DOMAIN} - Stop charging..")
+
+        url = self.API_URL + "evc/charge/stop"
+        headers = self._get_vehicle_headers(token, vehicle)
+        _LOGGER.debug(f"{DOMAIN} - Stop charging headers: {headers}")
+
+        response = self.sessions.post(url, headers=headers)
+        _LOGGER.debug(
+            f"{DOMAIN} - Stop charge response status code: {response.status_code}"
+        )
+        _LOGGER.debug(f"{DOMAIN} - Stop charge response: {response.text}")
 
-        _LOGGER.debug(f"{DOMAIN} - last_updated_at - after {value}")
-        return value
+    def set_charge_limits(
+        self, token: Token, vehicle: Vehicle, ac: int, dc: int
+    ) -> str:
+        if vehicle.engine_type != ENGINE_TYPES.EV:
+            return {}
+
+        _LOGGER.debug(f"{DOMAIN} - Setting charge limits..")
+        url = self.API_URL + "evc/charge/targetsoc/set"
+        headers = self._get_vehicle_headers(token, vehicle)
+        _LOGGER.debug(f"{DOMAIN} - Setting charge limits: {headers}")
+
+        data = {
+            "targetSOClist": [
+                {
+                    "plugType": 0,
+                    "targetSOClevel": int(dc),
+                },
+                {
+                    "plugType": 1,
+                    "targetSOClevel": int(ac),
+                },
+            ]
+        }
+
+        _LOGGER.debug(f"{DOMAIN} - Setting charge limits body: {data}")
+
+        response = self.sessions.post(url, json=data, headers=headers)
+        _LOGGER.debug(
+            f"{DOMAIN} - Setting charge limits response status code: {response.status_code}"  # noqa
+        )
+        _LOGGER.debug(f"{DOMAIN} - Setting charge limits: {response.text}")