hyundai-kia-connect-api 3.17.10__tar.gz → 3.18.0__tar.gz

{hyundai_kia_connect_api-3.17.10 → hyundai_kia_connect_api-3.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hyundai_kia_connect_api
-Version: 3.17.10
+Version: 3.18.0
 Summary: Python Boilerplate contains all the boilerplate you need to create a Python package.
 Home-page: https://github.com/fuatakgun/hyundai_kia_connect_api
 Author: Fuat Akgun

{hyundai_kia_connect_api-3.17.10 → hyundai_kia_connect_api-3.18.0}/hyundai_kia_connect_api/ApiImpl.py

@@ -10,7 +10,7 @@ import requests
 
 from .Token import Token
 from .Vehicle import Vehicle
-from .const import *
+from .const import WINDOW_STATE, CHARGE_PORT_ACTION, OrderStatus
 from .utils import get_child_value
 
 _LOGGER = logging.getLogger(__name__)
@@ -57,10 +57,6 @@ class ApiImpl:
         Required for Kia USA as key is session specific"""
         return vehicles
 
-    def get_last_updated_at(self, value) -> dt.datetime:
-        """Convert last updated value of vehicle into into datetime"""
-        pass
-
     def update_vehicle_with_cached_state(self, token: Token, vehicle: Vehicle) -> None:
         """Get cached vehicle data and update Vehicle instance with it"""
         pass

hyundai_kia_connect_api-3.18.0/hyundai_kia_connect_api/ApiImplType1.py

@@ -0,0 +1,314 @@
+import datetime as dt
+from typing import Optional
+
+from .ApiImpl import (
+    ApiImpl,
+)
+from .Token import Token
+from .Vehicle import Vehicle
+
+from .utils import (
+    get_child_value,
+    parse_datetime,
+)
+
+from .const import (
+    DISTANCE_UNITS,
+    ENGINE_TYPES,
+    SEAT_STATUS,
+    TEMPERATURE_UNITS,
+)
+
+USER_AGENT_OK_HTTP: str = "okhttp/3.12.0"
+
+
+class ApiImplType1(ApiImpl):
+    def __init__(self) -> None:
+        """Initialize."""
+
+    def _get_authenticated_headers(
+        self, token: Token, ccs2_support: Optional[int] = None
+    ) -> dict:
+        return {
+            "Authorization": token.access_token,
+            "ccsp-service-id": self.CCSP_SERVICE_ID,
+            "ccsp-application-id": self.APP_ID,
+            "Stamp": self._get_stamp(),
+            "ccsp-device-id": token.device_id,
+            "Host": self.BASE_URL,
+            "Connection": "Keep-Alive",
+            "Accept-Encoding": "gzip",
+            "Ccuccs2protocolsupport": str(ccs2_support or 0),
+            "User-Agent": USER_AGENT_OK_HTTP,
+        }
+
+    def _update_vehicle_properties_ccs2(self, vehicle: Vehicle, state: dict) -> None:
+        if get_child_value(state, "Date"):
+            vehicle.last_updated_at = parse_datetime(
+                get_child_value(state, "Date"), self.data_timezone
+            )
+        else:
+            vehicle.last_updated_at = dt.datetime.now(self.data_timezone)
+
+        vehicle.odometer = (
+            get_child_value(state, "Drivetrain.Odometer"),
+            DISTANCE_UNITS[1],
+        )
+        vehicle.car_battery_percentage = get_child_value(
+            state, "Electronics.Battery.Level"
+        )
+
+        vehicle.engine_is_running = get_child_value(state, "DrivingReady")
+
+        air_temp = get_child_value(
+            state,
+            "Cabin.HVAC.Row1.Driver.Temperature.Value",
+        )
+
+        if air_temp != "OFF":
+            vehicle.air_temperature = (air_temp, TEMPERATURE_UNITS[1])
+
+        defrost_is_on = get_child_value(state, "Body.Windshield.Front.Defog.State")
+        if defrost_is_on in [0, 2]:
+            vehicle.defrost_is_on = False
+        elif defrost_is_on == 1:
+            vehicle.defrost_is_on = True
+
+        steer_wheel_heat = get_child_value(state, "Cabin.SteeringWheel.Heat.State")
+        if steer_wheel_heat in [0, 2]:
+            vehicle.steering_wheel_heater_is_on = False
+        elif steer_wheel_heat == 1:
+            vehicle.steering_wheel_heater_is_on = True
+
+        defrost_rear_is_on = get_child_value(state, "Body.Windshield.Rear.Defog.State")
+        if defrost_rear_is_on in [0, 2]:
+            vehicle.back_window_heater_is_on = False
+        elif defrost_rear_is_on == 1:
+            vehicle.back_window_heater_is_on = True
+
+        # TODO: status.sideMirrorHeat
+
+        vehicle.front_left_seat_status = SEAT_STATUS[
+            get_child_value(state, "Cabin.Seat.Row1.Driver.Climate.State")
+        ]
+
+        vehicle.front_right_seat_status = SEAT_STATUS[
+            get_child_value(state, "Cabin.Seat.Row1.Passenger.Climate.State")
+        ]
+
+        vehicle.rear_left_seat_status = SEAT_STATUS[
+            get_child_value(state, "Cabin.Seat.Row2.Left.Climate.State")
+        ]
+
+        vehicle.rear_right_seat_status = SEAT_STATUS[
+            get_child_value(state, "Cabin.Seat.Row2.Right.Climate.State")
+        ]
+
+        # TODO: status.doorLock
+
+        vehicle.front_left_door_is_open = get_child_value(
+            state, "Cabin.Door.Row1.Driver.Open"
+        )
+        vehicle.front_right_door_is_open = get_child_value(
+            state, "Cabin.Door.Row1.Passenger.Open"
+        )
+        vehicle.back_left_door_is_open = get_child_value(
+            state, "Cabin.Door.Row2.Left.Open"
+        )
+        vehicle.back_right_door_is_open = get_child_value(
+            state, "Cabin.Door.Row2.Right.Open"
+        )
+
+        # TODO: should the windows and trunc also be checked?
+        vehicle.is_locked = not (
+            vehicle.front_left_door_is_open
+            or vehicle.front_right_door_is_open
+            or vehicle.back_left_door_is_open
+            or vehicle.back_right_door_is_open
+        )
+
+        vehicle.hood_is_open = get_child_value(state, "Body.Hood.Open")
+        vehicle.front_left_window_is_open = get_child_value(
+            state, "Cabin.Window.Row1.Driver.Open"
+        )
+        vehicle.front_right_window_is_open = get_child_value(
+            state, "Cabin.Window.Row1.Passenger.Open"
+        )
+        vehicle.back_left_window_is_open = get_child_value(
+            state, "Cabin.Window.Row2.Left.Open"
+        )
+        vehicle.back_right_window_is_open = get_child_value(
+            state, "Cabin.Window.Row2.Right.Open"
+        )
+        vehicle.tire_pressure_rear_left_warning_is_on = bool(
+            get_child_value(state, "Chassis.Axle.Row2.Left.Tire.PressureLow")
+        )
+        vehicle.tire_pressure_front_left_warning_is_on = bool(
+            get_child_value(state, "Chassis.Axle.Row1.Left.Tire.PressureLow")
+        )
+        vehicle.tire_pressure_front_right_warning_is_on = bool(
+            get_child_value(state, "Chassis.Axle.Row1.Right.Tire.PressureLow")
+        )
+        vehicle.tire_pressure_rear_right_warning_is_on = bool(
+            get_child_value(state, "Chassis.Axle.Row2.Right.Tire.PressureLow")
+        )
+        vehicle.tire_pressure_all_warning_is_on = bool(
+            get_child_value(state, "Chassis.Axle.Tire.PressureLow")
+        )
+        vehicle.trunk_is_open = get_child_value(state, "Body.Trunk.Open")
+
+        vehicle.ev_battery_percentage = get_child_value(
+            state, "Green.BatteryManagement.BatteryRemain.Ratio"
+        )
+        vehicle.ev_battery_remain = get_child_value(
+            state, "Green.BatteryManagement.BatteryRemain.Value"
+        )
+        vehicle.ev_battery_capacity = get_child_value(
+            state, "Green.BatteryManagement.BatteryCapacity.Value"
+        )
+        vehicle.ev_battery_soh_percentage = get_child_value(
+            state, "Green.BatteryManagement.SoH.Ratio"
+        )
+        vehicle.ev_battery_is_plugged_in = get_child_value(
+            state, "Green.ChargingInformation.ElectricCurrentLevel.State"
+        )
+        vehicle.ev_battery_is_plugged_in = get_child_value(
+            state, "Green.ChargingInformation.ConnectorFastening.State"
+        )
+        charging_door_state = get_child_value(state, "Green.ChargingDoor.State")
+        if charging_door_state in [0, 2]:
+            vehicle.ev_charge_port_door_is_open = False
+        elif charging_door_state == 1:
+            vehicle.ev_charge_port_door_is_open = True
+
+        vehicle.total_driving_range = (
+            float(
+                get_child_value(
+                    state,
+                    "Drivetrain.FuelSystem.DTE.Total",  # noqa
+                )
+            ),
+            DISTANCE_UNITS[
+                get_child_value(
+                    state,
+                    "Drivetrain.FuelSystem.DTE.Unit",  # noqa
+                )
+            ],
+        )
+
+        if vehicle.engine_type == ENGINE_TYPES.EV:
+            # ev_driving_range is the same as total_driving_range for pure EV
+            vehicle.ev_driving_range = (
+                vehicle.total_driving_range,
+                vehicle.total_driving_range_unit,
+            )
+        # TODO: vehicle.ev_driving_range for non EV
+
+        vehicle.washer_fluid_warning_is_on = get_child_value(
+            state, "Body.Windshield.Front.WasherFluid.LevelLow"
+        )
+
+        vehicle.ev_estimated_current_charge_duration = (
+            get_child_value(state, "Green.ChargingInformation.Charging.RemainTime"),
+            "m",
+        )
+        vehicle.ev_estimated_fast_charge_duration = (
+            get_child_value(state, "Green.ChargingInformation.EstimatedTime.Standard"),
+            "m",
+        )
+        vehicle.ev_estimated_portable_charge_duration = (
+            get_child_value(state, "Green.ChargingInformation.EstimatedTime.ICCB"),
+            "m",
+        )
+        vehicle.ev_estimated_station_charge_duration = (
+            get_child_value(state, "Green.ChargingInformation.EstimatedTime.Quick"),
+            "m",
+        )
+        vehicle.ev_charge_limits_ac = get_child_value(
+            state, "Green.ChargingInformation.TargetSoC.Standard"
+        )
+        vehicle.ev_charge_limits_dc = get_child_value(
+            state, "Green.ChargingInformation.TargetSoC.Quick"
+        )
+        vehicle.ev_v2l_discharge_limit = get_child_value(
+            state, "Green.Electric.SmartGrid.VehicleToLoad.DischargeLimitation.SoC"
+        )
+        vehicle.ev_target_range_charge_AC = (
+            get_child_value(
+                state,
+                "Green.ChargingInformation.DTE.TargetSoC.Standard",  # noqa
+            ),
+            DISTANCE_UNITS[
+                get_child_value(
+                    state,
+                    "Drivetrain.FuelSystem.DTE.Unit",  # noqa
+                )
+            ],
+        )
+        vehicle.ev_target_range_charge_DC = (
+            get_child_value(
+                state,
+                "Green.ChargingInformation.DTE.TargetSoC.Quick",  # noqa
+            ),
+            DISTANCE_UNITS[
+                get_child_value(
+                    state,
+                    "Drivetrain.FuelSystem.DTE.Unit",  # noqa
+                )
+            ],
+        )
+        vehicle.ev_first_departure_enabled = bool(
+            get_child_value(state, "Green.Reservation.Departure.Schedule1.Enable")
+        )
+
+        vehicle.ev_second_departure_enabled = bool(
+            get_child_value(state, "Green.Reservation.Departure.Schedule2.Enable")
+        )
+
+        # TODO: vehicle.ev_first_departure_days --> Green.Reservation.Departure.Schedule1.(Mon,Tue,Wed,Thu,Fri,Sat,Sun) # noqa
+        # TODO: vehicle.ev_second_departure_days --> Green.Reservation.Departure.Schedule2.(Mon,Tue,Wed,Thu,Fri,Sat,Sun) # noqa
+        # TODO: vehicle.ev_first_departure_time --> Green.Reservation.Departure.Schedule1.(Min,Hour) # noqa
+        # TODO: vehicle.ev_second_departure_time --> Green.Reservation.Departure.Schedule2.(Min,Hour) # noqa
+        # TODO: vehicle.ev_off_peak_charge_only_enabled --> unknown settings are in  --> Green.Reservation.OffPeakTime and OffPeakTime2 # noqa
+
+        vehicle.washer_fluid_warning_is_on = get_child_value(
+            state, "Body.Windshield.Front.WasherFluid.LevelLow"
+        )
+        vehicle.brake_fluid_warning_is_on = get_child_value(
+            state, "Chassis.Brake.Fluid.Warning"
+        )
+
+        vehicle.fuel_level = get_child_value(state, "Drivetrain.FuelSystem.FuelLevel")
+        vehicle.fuel_level_is_low = get_child_value(
+            state, "Drivetrain.FuelSystem.LowFuelWarning"
+        )
+        vehicle.air_control_is_on = get_child_value(
+            state, "Cabin.HVAC.Row1.Driver.Blower.SpeedLevel"
+        )
+        vehicle.smart_key_battery_warning_is_on = bool(
+            get_child_value(state, "Electronics.FOB.LowBattery")
+        )
+
+        if get_child_value(state, "Location.GeoCoord.Latitude"):
+            location_last_updated_at = dt.datetime(
+                2000, 1, 1, tzinfo=self.data_timezone
+            )
+            timestamp = get_child_value(state, "Location.TimeStamp")
+            if timestamp is not None:
+                location_last_updated_at = dt.datetime(
+                    year=int(get_child_value(timestamp, "Year")),
+                    month=int(get_child_value(timestamp, "Mon")),
+                    day=int(get_child_value(timestamp, "Day")),
+                    hour=int(get_child_value(timestamp, "Hour")),
+                    minute=int(get_child_value(timestamp, "Min")),
+                    second=int(get_child_value(timestamp, "Sec")),
+                    tzinfo=self.data_timezone,
+                )
+
+            vehicle.location = (
+                get_child_value(state, "Location.GeoCoord.Latitude"),
+                get_child_value(state, "Location.GeoCoord.Longitude"),
+                location_last_updated_at,
+            )
+
+        vehicle.data = state

{hyundai_kia_connect_api-3.17.10 → hyundai_kia_connect_api-3.18.0}/hyundai_kia_connect_api/HyundaiBlueLinkAPIUSA.py

@@ -4,7 +4,6 @@
 
 import logging
 import time
-import re
 import datetime as dt
 import pytz
 import requests
@@ -19,7 +18,7 @@ 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
@@ -235,8 +234,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(
@@ -428,8 +427,9 @@ 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")
@@ -640,28 +640,3 @@ class HyundaiBlueLinkAPIUSA(ApiImpl):
 
     def stop_charge(self, token: Token, vehicle: Vehicle) -> None:
         pass
-
-    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} - last_updated_at - after {value}")
-        return value

{hyundai_kia_connect_api-3.17.10 → hyundai_kia_connect_api-3.18.0}/hyundai_kia_connect_api/KiaUvoAPIUSA.py

@@ -4,7 +4,6 @@
 import datetime as dt
 import logging
 import random
-import re
 import secrets
 import ssl
 import string
@@ -29,7 +28,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__)
 
@@ -278,10 +277,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"),
@@ -515,8 +515,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 +535,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"
 

{hyundai_kia_connect_api-3.17.10 → hyundai_kia_connect_api-3.18.0}/hyundai_kia_connect_api/KiaUvoApiAU.py

@@ -7,7 +7,6 @@ import datetime as dt
 import math
 import logging
 import random
-import re
 import uuid
 from time import sleep
 from urllib.parse import parse_qs, urlparse
@@ -57,6 +56,7 @@ from .utils import (
     get_child_value,
     get_index_into_hex_temp,
     get_hex_temp_into_index,
+    parse_datetime,
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -190,29 +190,11 @@ class KiaUvoApiAU(ApiImplType1):
                 VIN=entry["vin"],
                 timezone=self.data_timezone,
                 engine_type=entry_engine_type,
+                ccu_ccs2_protocol_support=entry["ccuCCS2ProtocolSupport"],
             )
             result.append(vehicle)
         return result
 
-    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_time_from_string(self, value, timesection) -> dt.datetime.time:
         if value is not None:
             lastTwo = int(value[-2:])
@@ -228,15 +210,35 @@ class KiaUvoApiAU(ApiImplType1):
         return value
 
     def update_vehicle_with_cached_state(self, token: Token, vehicle: Vehicle) -> None:
-        status = self._get_cached_vehicle_state(token, vehicle)
-        location = self._get_location(token, vehicle)
-        self._update_vehicle_properties(
-            vehicle,
-            {
-                "status": status,
-                "vehicleLocation": location,
-            },
-        )
+        url = self.SPA_API_URL + "vehicles/" + vehicle.id
+        is_ccs2 = vehicle.ccu_ccs2_protocol_support != 0
+        if is_ccs2:
+            url += "/ccs2/carstatus/latest"
+        else:
+            url += "/status/latest"
+
+        response = requests.get(
+            url,
+            headers=self._get_authenticated_headers(
+                token, vehicle.ccu_ccs2_protocol_support
+            ),
+        ).json()
+
+        _LOGGER.debug(f"{DOMAIN} - get_cached_vehicle_status response: {response}")
+        _check_response_for_errors(response)
+
+        if is_ccs2:
+            state = response["resMsg"]["state"]["Vehicle"]
+            self._update_vehicle_properties_ccs2(vehicle, state)
+        else:
+            location = self._get_location(token, vehicle)
+            self._update_vehicle_properties(
+                vehicle,
+                {
+                    "status": response["resMsg"],
+                    "vehicleLocation": location,
+                },
+            )
 
         if vehicle.engine_type == ENGINE_TYPES.EV:
             try:
@@ -253,8 +255,8 @@ class KiaUvoApiAU(ApiImplType1):
                             """,
                     exc_info=e,
                 )
-            else:
-                self._update_vehicle_drive_info(vehicle, state)
+        else:
+            self._update_vehicle_drive_info(vehicle, state)
 
     def force_refresh_vehicle_state(self, token: Token, vehicle: Vehicle) -> None:
         status = self._get_forced_vehicle_state(token, vehicle)
@@ -287,8 +289,8 @@ class KiaUvoApiAU(ApiImplType1):
 
     def _update_vehicle_properties(self, vehicle: Vehicle, state: dict) -> None:
         if get_child_value(state, "status.time"):
-            vehicle.last_updated_at = self.get_last_updated_at(
-                get_child_value(state, "status.time")
+            vehicle.last_updated_at = parse_datetime(
+                get_child_value(state, "status.time"), self.data_timezone
             )
         else:
             vehicle.last_updated_at = dt.datetime.now(self.data_timezone)
@@ -480,7 +482,7 @@ class KiaUvoApiAU(ApiImplType1):
             vehicle.ev_charge_limits_dc = [
                 x["targetSOClevel"] for x in target_soc_list if x["plugType"] == 0
             ][-1]
-        except:
+        except Exception:
             _LOGGER.debug(f"{DOMAIN} - SOC Levels couldn't be found. May not be an EV.")
         if (
             get_child_value(
@@ -636,8 +638,8 @@ class KiaUvoApiAU(ApiImplType1):
             vehicle.location = (
                 get_child_value(state, "vehicleLocation.coord.lat"),
                 get_child_value(state, "vehicleLocation.coord.lon"),
-                self.get_last_updated_at(
-                    get_child_value(state, "vehicleLocation.time")
+                parse_datetime(
+                    get_child_value(state, "vehicleLocation.time"), self.data_timezone
                 ),
             )
         vehicle.data = state
@@ -647,18 +649,6 @@ class KiaUvoApiAU(ApiImplType1):
         vehicle.power_consumption_30d = get_child_value(state, "consumption30d")
         vehicle.daily_stats = get_child_value(state, "dailyStats")
 
-    def _get_cached_vehicle_state(self, token: Token, vehicle: Vehicle) -> dict:
-        url = self.SPA_API_URL + "vehicles/" + vehicle.id + "/status/latest"
-
-        response = requests.get(
-            url, headers=self._get_authenticated_headers(token)
-        ).json()
-        _LOGGER.debug(f"{DOMAIN} - get_cached_vehicle_status response: {response}")
-        _check_response_for_errors(response)
-        response = response["resMsg"]
-
-        return response
-
     def _get_location(self, token: Token, vehicle: Vehicle) -> dict:
         url = self.SPA_API_URL + "vehicles/" + vehicle.id + "/location/park"
 
@@ -669,7 +659,7 @@ class KiaUvoApiAU(ApiImplType1):
             _LOGGER.debug(f"{DOMAIN} - _get_location response: {response}")
             _check_response_for_errors(response)
             return response["resMsg"]["gpsDetail"]
-        except:
+        except Exception:
             _LOGGER.debug(f"{DOMAIN} - _get_location failed")
             return None