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

hyundai_kia_connect_api/{KiaUvoAPIUSA.py → KiaUvoApiUSA.py}

@@ -4,7 +4,6 @@
 import datetime as dt
 import logging
 import random
-import re
 import secrets
 import ssl
 import string
@@ -12,6 +11,7 @@ import time
 import typing
 from datetime import datetime
 
+import certifi
 import pytz
 import requests
 from requests import RequestException, Response
@@ -29,7 +29,7 @@ from .const import (
     TEMPERATURE_UNITS,
     VEHICLE_LOCK_ACTION,
 )
-from .utils import get_child_value
+from .utils import get_child_value, parse_datetime
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -41,7 +41,9 @@ class KiaSSLAdapter(HTTPAdapter):
         context = create_urllib3_context(
             ciphers="DEFAULT:@SECLEVEL=1", ssl_version=ssl.PROTOCOL_TLSv1_2
         )
+        context.options |= 0x4
         kwargs["ssl_context"] = context
+        kwargs["ca_certs"] = certifi.where()
         return super().init_poolmanager(*args, **kwargs)
 
 
@@ -104,8 +106,8 @@ def request_with_logging(func):
     return request_with_logging_wrapper
 
 
-class KiaUvoAPIUSA(ApiImpl):
-    """KiaUvoAPIUSA"""
+class KiaUvoApiUSA(ApiImpl):
+    """KiaUvoApiUSA"""
 
     def __init__(self, region: int, brand: int, language) -> None:
         self.LANGUAGE: str = language
@@ -122,8 +124,14 @@ class KiaUvoAPIUSA(ApiImpl):
 
         self.BASE_URL: str = "api.owners.kia.com"
         self.API_URL: str = "https://" + self.BASE_URL + "/apigw/v1/"
-        self.session = requests.Session()
-        self.session.mount("https://", KiaSSLAdapter())
+        self._session = None
+
+    @property
+    def session(self):
+        if not self._session:
+            self._session = requests.Session()
+            self._session.mount("https://", KiaSSLAdapter())
+        return self._session
 
     def api_headers(self) -> dict:
         offset = time.localtime().tm_gmtoff / 60 / 60
@@ -278,10 +286,11 @@ class KiaUvoAPIUSA(ApiImpl):
 
     def _update_vehicle_properties(self, vehicle: Vehicle, state: dict) -> None:
         """Get cached vehicle data and update Vehicle instance with it"""
-        vehicle.last_updated_at = self.get_last_updated_at(
+        vehicle.last_updated_at = parse_datetime(
             get_child_value(
                 state, "lastVehicleInfo.vehicleStatusRpt.vehicleStatus.syncDate.utc"
-            )
+            ),
+            self.data_timezone,
         )
         vehicle.odometer = (
             get_child_value(state, "vehicleConfig.vehicleDetail.vehicle.mileage"),
@@ -417,7 +426,7 @@ class KiaUvoAPIUSA(ApiImpl):
             vehicle.ev_charge_limits_dc = [
                 x["targetSOClevel"] for x in ChargeDict if x["plugType"] == 0
             ][-1]
-        except:
+        except Exception:
             _LOGGER.debug(f"{DOMAIN} - SOC Levels couldn't be found. May not be an EV.")
 
         vehicle.ev_driving_range = (
@@ -515,8 +524,9 @@ class KiaUvoAPIUSA(ApiImpl):
             vehicle.location = (
                 get_child_value(state, "lastVehicleInfo.location.coord.lat"),
                 get_child_value(state, "lastVehicleInfo.location.coord.lon"),
-                self.get_last_updated_at(
-                    get_child_value(state, "lastVehicleInfo.location.syncDate.utc")
+                parse_datetime(
+                    get_child_value(state, "lastVehicleInfo.location.syncDate.utc"),
+                    self.data_timezone,
                 ),
             )
 
@@ -534,25 +544,6 @@ class KiaUvoAPIUSA(ApiImpl):
 
         vehicle.data = state
 
-    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:
-            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} - last_updated_at - after {value}")
-        return value
-
     def _get_cached_vehicle_state(self, token: Token, vehicle: Vehicle) -> dict:
         url = self.API_URL + "cmm/gvi"
 
@@ -629,6 +620,59 @@ class KiaUvoAPIUSA(ApiImpl):
 
         return response.headers["Xid"]
 
+    def _seat_settings(self, level) -> dict:
+        # See const.SEAT_STATUS for the list and descriptions of levels.
+        #
+        # The values were determined empirically, see https://github.com/Hyundai-Kia-Connect/kia_uvo/issues/718
+        if level == 8:  # High heat
+            return {
+                "heatVentType": 1,
+                "heatVentLevel": 4,
+                "heatVentStep": 1,
+            }
+        elif level == 7:  # Medium heat
+            return {
+                "heatVentType": 1,
+                "heatVentLevel": 3,
+                "heatVentStep": 2,
+            }
+        elif level == 6:  # Low heat
+            return {
+                "heatVentType": 1,
+                "heatVentLevel": 2,
+                "heatVentStep": 3,
+            }
+        elif level == 5:  # High cool
+            return {
+                "heatVentType": 2,
+                "heatVentLevel": 4,
+                "heatVentStep": 1,
+            }
+        elif level == 4:  # Medium cool
+            return {
+                "heatVentType": 2,
+                "heatVentLevel": 3,
+                "heatVentStep": 2,
+            }
+        elif level == 3:  # Low cool
+            return {
+                "heatVentType": 2,
+                "heatVentLevel": 2,
+                "heatVentStep": 3,
+            }
+        elif level == 1:  # Generically on, let's assume high heat
+            return {
+                "heatVentType": 1,
+                "heatVentLevel": 4,
+                "heatVentStep": 1,
+            }
+        else:  # Off
+            return {
+                "heatVentType": 0,
+                "heatVentLevel": 1,
+                "heatVentStep": 0,
+            }
+
     def start_climate(
         self, token: Token, vehicle: Vehicle, options: ClimateRequestOptions
     ) -> str:
@@ -647,93 +691,45 @@ class KiaUvoAPIUSA(ApiImpl):
             options.defrost = False
         if options.duration is None:
             options.duration = 5
-        if options.front_left_seat is None:
-            options.front_left_seat = 0
-        if options.front_right_seat is None:
-            options.front_right_seat = 0
-        if options.rear_left_seat is None:
-            options.rear_left_seat = 0
-        if options.rear_right_seat is None:
-            options.rear_right_seat = 0
-
-        front_left_heatVentType = 0
-        front_right_heatVentType = 0
-        rear_left_heatVentType = 0
-        rear_right_heatVentType = 0
-        front_left_heatVentLevel = 0
-        front_right_heatVentLevel = 0
-        rear_left_heatVentLevel = 0
-        rear_right_heatVentLevel = 0
-
-        # heated
-        if options.front_left_seat in (6, 7, 8):
-            front_left_heatVentType = 1
-            front_left_heatVentLevel = options.front_left_seat - 4
-        if options.front_right_seat in (6, 7, 8):
-            front_right_heatVentType = 1
-            front_right_heatVentLevel = options.front_right_seat - 4
-        if options.rear_left_seat in (6, 7, 8):
-            rear_left_heatVentType = 1
-            rear_left_heatVentLevel = options.rear_left_seat - 4
-        if options.rear_right_seat in (6, 7, 8):
-            rear_right_heatVentType = 1
-            rear_right_heatVentLevel = options.rear_right_seat - 4
-
-        # ventilated
-        if options.front_left_seat in (3, 4, 5):
-            front_left_heatVentType = 2
-            front_left_heatVentLevel = options.front_left_seat - 1
-        if options.front_right_seat in (3, 4, 5):
-            front_right_heatVentType = 2
-            front_right_heatVentLevel = options.front_right_seat - 1
-        if options.rear_left_seat in (3, 4, 5):
-            rear_left_heatVentType = 2
-            rear_left_heatVentLevel = options.rear_left_seat - 1
-        if options.rear_right_seat in (3, 4, 5):
-            rear_right_heatVentType = 2
-            rear_right_heatVentLevel = options.rear_right_seat - 1
+        if options.steering_wheel is None:
+            options.steering_wheel = 0
 
         body = {
             "remoteClimate": {
-                "airCtrl": options.climate,
                 "airTemp": {
                     "unit": 1,
                     "value": str(options.set_temp),
                 },
+                "airCtrl": options.climate,
                 "defrost": options.defrost,
                 "heatingAccessory": {
-                    "rearWindow": int(options.heating),
-                    "sideMirror": int(options.heating),
-                    "steeringWheel": int(options.heating),
+                    "rearWindow": 1 if options.heating in [1, 2, 4] else 0,
+                    "sideMirror": 1 if options.heating in [1, 4] else 0,
+                    "steeringWheel": 1 if options.steering_wheel in [1, 2] else 0,
+                    "steeringWheelStep": options.steering_wheel,
                 },
                 "ignitionOnDuration": {
                     "unit": 4,
                     "value": options.duration,
                 },
-                "heatVentSeat": {
-                    "driverSeat": {
-                        "heatVentType": front_left_heatVentType,
-                        "heatVentLevel": front_left_heatVentLevel,
-                        "heatVentStep": 1,
-                    },
-                    "passengerSeat": {
-                        "heatVentType": front_right_heatVentType,
-                        "heatVentLevel": front_right_heatVentLevel,
-                        "heatVentStep": 1,
-                    },
-                    "rearLeftSeat": {
-                        "heatVentType": rear_left_heatVentType,
-                        "heatVentLevel": rear_left_heatVentLevel,
-                        "heatVentStep": 1,
-                    },
-                    "rearRightSeat": {
-                        "heatVentType": rear_right_heatVentType,
-                        "heatVentLevel": rear_right_heatVentLevel,
-                        "heatVentStep": 1,
-                    },
-                },
-            }
+            },
         }
+
+        # Kia seems to now be checking if you can set the heated/vented seats at
+        # the car level only add to body if the option is not none for any of
+        # the seats
+        if (
+            options.front_left_seat is not None
+            or options.front_right_seat is not None
+            or options.rear_left_seat is not None
+            or options.rear_right_seat is not None
+        ):
+            body["remoteClimate"]["heatVentSeat"] = {
+                "driverSeat": self._seat_settings(options.front_left_seat),
+                "passengerSeat": self._seat_settings(options.front_right_seat),
+                "rearLeftSeat": self._seat_settings(options.rear_left_seat),
+                "rearRightSeat": self._seat_settings(options.rear_right_seat),
+            }
         _LOGGER.debug(f"{DOMAIN} - Planned start_climate payload: {body}")
         response = self.post_request_with_logging_and_active_session(
             token=token, url=url, json_body=body, vehicle=vehicle

hyundai_kia_connect_api/Vehicle.py

@@ -1,12 +1,13 @@
-# pylint:disable=missing-class-docstring,missing-function-docstring,wildcard-import,unused-wildcard-import,invalid-name
+# pylint:disable=missing-class-docstring,missing-function-docstring,wildcard-import,unused-wildcard-import,invalid-name,logging-fstring-interpolation
 """Vehicle class"""
+
 import logging
 import datetime
 import typing
 from dataclasses import dataclass, field
 
-from .utils import get_float
-from .const import *
+from .utils import get_float, get_safe_local_datetime
+from .const import DISTANCE_UNITS
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -16,9 +17,9 @@ class TripInfo:
     """Trip Info"""
 
     hhmmss: str = None  # will not be filled by summary
-    drive_time: int = None
-    idle_time: int = None
-    distance: int = None
+    drive_time: int = None  # minutes
+    idle_time: int = None  # minutes
+    distance: float = None
     avg_speed: float = None
     max_speed: int = None
 
@@ -59,10 +60,8 @@ class DailyDrivingStats:
     onboard_electronics_consumption: int = None
     battery_care_consumption: int = None
     regenerated_energy: int = None
-    # distance is expressed in (I assume) whatever unit the vehicle is
-    # configured in. KMs (rounded) in my case
-    distance: int = None
-    distance_unit = DISTANCE_UNITS[1]  # set to kms by default
+    distance: float = None
+    distance_unit: str = DISTANCE_UNITS[1]  # set to kms by default
 
 
 @dataclass
@@ -93,8 +92,10 @@ class Vehicle:
 
     car_battery_percentage: int = None
     engine_is_running: bool = None
-    last_updated_at: datetime.datetime = None
+
+    _last_updated_at: datetime.datetime = None
     timezone: datetime.timezone = datetime.timezone.utc  # default UTC
+
     dtc_count: typing.Union[int, None] = None
     dtc_descriptions: typing.Union[dict, None] = None
 
@@ -155,9 +156,13 @@ class Vehicle:
     # EV fields (EV/PHEV)
 
     ev_charge_port_door_is_open: typing.Union[bool, None] = None
+    ev_charging_power: typing.Union[float, None] = None  # Charging power in kW
 
     ev_charge_limits_dc: typing.Union[int, None] = None
     ev_charge_limits_ac: typing.Union[int, None] = None
+    ev_charging_current: typing.Union[int, None] = (
+        None  # Europe feature only, ac charging current limit
+    )
     ev_v2l_discharge_limit: typing.Union[int, None] = None
 
     # energy consumed and regenerated since the vehicle was paired with the account
@@ -169,11 +174,61 @@ class Vehicle:
     # expressed in watt-hours (Wh)
     power_consumption_30d: float = None  # Europe feature only
 
-    # Europe feature only
-    daily_stats: list[DailyDrivingStats] = field(default_factory=list)
+    # feature only available for some regions (getter/setter for sorting)
+    _daily_stats: list[DailyDrivingStats] = field(default_factory=list)
 
-    month_trip_info: MonthTripInfo = None  # Europe feature only
-    day_trip_info: DayTripInfo = None  # Europe feature only
+    @property
+    def daily_stats(self):
+        return self._daily_stats
+
+    @daily_stats.setter
+    def daily_stats(self, value):
+        result = value
+        if result is not None and len(result) > 0:  # sort on decreasing date
+            _LOGGER.debug(f"before daily_stats: {result}")
+            result.sort(reverse=True, key=lambda k: k.date)
+            _LOGGER.debug(f"after  daily_stats: {result}")
+        self._daily_stats = result
+
+    # feature only available for some regions (getter/setter for sorting)
+    _month_trip_info: MonthTripInfo = None
+
+    @property
+    def month_trip_info(self):
+        return self._month_trip_info
+
+    @month_trip_info.setter
+    def month_trip_info(self, value):
+        result = value
+        if (
+            result is not None
+            and hasattr(result, "day_list")
+            and len(result.day_list) > 0
+        ):  # sort on increasing yyyymmdd
+            _LOGGER.debug(f"before month_trip_info: {result}")
+            result.day_list.sort(key=lambda k: k.yyyymmdd)
+            _LOGGER.debug(f"after  month_trip_info: {result}")
+        self._month_trip_info = result
+
+    # feature only available for some regions (getter/setter for sorting)
+    _day_trip_info: DayTripInfo = None
+
+    @property
+    def day_trip_info(self):
+        return self._day_trip_info
+
+    @day_trip_info.setter
+    def day_trip_info(self, value):
+        result = value
+        if (
+            result is not None
+            and hasattr(result, "trip_list")
+            and len(result.trip_list) > 0
+        ):  # sort on descending hhmmss
+            _LOGGER.debug(f"before day_trip_info: {result}")
+            result.trip_list.sort(reverse=True, key=lambda k: k.hhmmss)
+            _LOGGER.debug(f"after day_trip_info: {result}")
+        self._day_trip_info = result
 
     ev_battery_percentage: int = None
     ev_battery_soh_percentage: int = None
@@ -219,10 +274,26 @@ class Vehicle:
     ev_first_departure_time: typing.Union[datetime.time, None] = None
     ev_second_departure_time: typing.Union[datetime.time, None] = None
 
+    ev_first_departure_climate_enabled: typing.Union[bool, None] = None
+    ev_second_departure_climate_enabled: typing.Union[bool, None] = None
+
+    _ev_first_departure_climate_temperature: typing.Union[float, None] = None
+    _ev_first_departure_climate_temperature_value: typing.Union[float, None] = None
+    _ev_first_departure_climate_temperature_unit: typing.Union[str, None] = None
+
+    _ev_second_departure_climate_temperature: typing.Union[float, None] = None
+    _ev_second_departure_climate_temperature_value: typing.Union[float, None] = None
+    _ev_second_departure_climate_temperature_unit: typing.Union[str, None] = None
+
+    ev_first_departure_climate_defrost: typing.Union[bool, None] = None
+    ev_second_departure_climate_defrost: typing.Union[bool, None] = None
+
     ev_off_peak_start_time: typing.Union[datetime.time, None] = None
     ev_off_peak_end_time: typing.Union[datetime.time, None] = None
     ev_off_peak_charge_only_enabled: typing.Union[bool, None] = None
 
+    ev_schedule_charge_enabled: typing.Union[bool, None] = None
+
     # IC fields (PHEV/HEV/IC)
     _fuel_driving_range: float = None
     _fuel_driving_range_value: float = None
@@ -243,8 +314,12 @@ class Vehicle:
 
     @geocode.setter
     def geocode(self, value):
-        self._geocode_name = value[0]
-        self._geocode_address = value[1]
+        if value:
+            self._geocode_name = value[0]
+            self._geocode_address = value[1]
+        else:
+            self._geocode_name = None
+            self._geocode_address = None
 
     @property
     def total_driving_range(self):
@@ -280,6 +355,26 @@ class Vehicle:
         self._last_service_distance_unit = value[1]
         self._last_service_distance = value[0]
 
+    @property
+    def last_updated_at(self):
+        return self._last_updated_at
+
+    @last_updated_at.setter
+    def last_updated_at(self, value):
+        # workaround for: Timestamp of "last_updated_at" sensor is wrong #931
+        # https://github.com/Hyundai-Kia-Connect/kia_uvo/issues/931#issuecomment-2381569934
+        newest_updated_at = get_safe_local_datetime(value)
+        previous_updated_at = self._last_updated_at
+        if newest_updated_at and previous_updated_at:  # both filled
+            if newest_updated_at < previous_updated_at:
+                utcoffset = newest_updated_at.utcoffset()
+                newest_updated_at_corrected = newest_updated_at + utcoffset
+                if newest_updated_at_corrected >= previous_updated_at:
+                    newest_updated_at = newest_updated_at_corrected
+                if newest_updated_at < previous_updated_at:
+                    newest_updated_at = previous_updated_at  # keep old because newer
+        self._last_updated_at = newest_updated_at
+
     @property
     def location_latitude(self):
         return self._location_latitude
@@ -305,7 +400,7 @@ class Vehicle:
     def location(self, value):
         self._location_latitude = value[0]
         self._location_longitude = value[1]
-        self._location_last_set_time = value[2]
+        self._location_last_set_time = get_safe_local_datetime(value[2])
 
     @property
     def odometer(self):
@@ -330,7 +425,7 @@ class Vehicle:
     def air_temperature(self, value):
         self._air_temperature_value = value[0]
         self._air_temperature_unit = value[1]
-        self._air_temperature = value[0]
+        self._air_temperature = value[0] if value[0] != "OFF" else None
 
     @property
     def ev_driving_range(self):
@@ -414,6 +509,34 @@ class Vehicle:
         self._ev_target_range_charge_DC_unit = value[1]
         self._ev_target_range_charge_DC = value[0]
 
+    @property
+    def ev_first_departure_climate_temperature(self):
+        return self._ev_first_departure_climate_temperature
+
+    @property
+    def ev_first_departure_climate_temperature_unit(self):
+        return self._ev_first_departure_climate_temperature_unit
+
+    @ev_first_departure_climate_temperature.setter
+    def ev_first_departure_climate_temperature(self, value):
+        self._ev_first_departure_climate_temperature_value = value[0]
+        self._ev_first_departure_climate_temperature_unit = value[1]
+        self._ev_first_departure_climate_temperature = value[0]
+
+    @property
+    def ev_second_departure_climate_temperature(self):
+        return self._ev_second_departure_climate_temperature
+
+    @property
+    def ev_second_departure_climate_temperature_unit(self):
+        return self._ev_second_departure_climate_temperature_unit
+
+    @ev_second_departure_climate_temperature.setter
+    def ev_second_departure_climate_temperature(self, value):
+        self._ev_second_departure_climate_temperature_value = value[0]
+        self._ev_second_departure_climate_temperature_unit = value[1]
+        self._ev_second_departure_climate_temperature = value[0]
+
     @property
     def fuel_driving_range(self):
         return self._fuel_driving_range