myvsb-developer-api 0.1.2__py3-none-any.whl

myskoda_openapi/api_layer/const.py

@@ -0,0 +1,3 @@
+SANDBOX_BASE_URL = "https://developer.sandbox.connect.skoda-auto.cz"
+PRODUCTION_BASE_URL = "https://developer.connect.skoda-auto.cz"
+TEST_BASE_URL = "https://public.test-api.connect.skoda-auto.cz"

myskoda_openapi/api_layer/exceptions.py

@@ -0,0 +1,37 @@
+from typing import Optional
+
+
+class OpenApiError(Exception):
+    """Obecná chyba při komunikaci se Škoda API."""
+    def __init__(self, message: str, status_code: Optional[int] = None) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+
+
+class OpenApiAuthenticationError(OpenApiError):
+    """Error 401 - Invalid or Expired X-API-Key."""
+    def __init__(self, message: str = "Invalid or expired X-API-Key.") -> None:
+        super().__init__(message, status_code=401)
+
+
+class OpenApiForbiddenError(OpenApiError):
+    """Error 403 - Forbidden access to the requested resource."""
+    def __init__(self, message: str = "Access to the requested resource is forbidden.") -> None:
+        super().__init__(message, status_code=403)
+
+
+class OpenApiVehicleNotFoundError(OpenApiError):
+    """Error 404 - Vehicle with this VIN does not exist."""
+    def __init__(self, message: str = "Vehicle with this VIN does not exist.") -> None:
+        super().__init__(message, status_code=404)
+
+
+class OpenApiRateLimitError(OpenApiError):
+    """Error 429 - Rate limit exceeded or weak 12V battery."""
+    def __init__(self, message: str = "Rate limit exceeded or weak 12V battery.") -> None:
+        super().__init__(message, status_code=429)
+
+class OpenApiServerError(OpenApiError):
+    """Error 500 / 504 - Server error or timeout."""
+    def __init__(self, message: str, status_code: int = 500) -> None:
+        super().__init__(message, status_code=status_code)

myskoda_openapi/api_layer/open_api_client.py

@@ -0,0 +1,118 @@
+import logging
+from typing import Any, Optional, List
+from aiohttp import ClientSession
+from .rest_api import SkodaRestAPI
+from models.vehicle import VehicleResponse
+from models.vehicle_status import VehicleStatus
+
+class OpenAPIClient:
+    """Client for interacting with rest API and used in HomeAssistant."""
+
+    def __init__(self, api_key: str, session: ClientSession) -> None:
+       self.rest_api = SkodaRestAPI(api_key=api_key, session=session)
+
+    async def get_vehicle(self, vin: str, include: Optional[List[str]] = None) -> VehicleResponse:
+        """Get the actual vehicle data and return the parsed Pydantic model."""
+        endpoint_result = await self.rest_api.get_vehicle(vin, include=include)
+        return endpoint_result.result
+    
+    async def get_vehicle_status(self, vin: str, include: Optional[List[str]] = None) -> VehicleStatus:
+        """Get the actual vehicle status and return the parsed Pydantic model."""
+        endpoint_result = await self.rest_api.get_vehicle_status(vin, include=include)
+        return endpoint_result.result
+    
+    async def start_air_conditioning(self, vin: str, temperature: float) -> None:
+        """Starts the air conditioning for the vehicle with the given VIN."""
+        payload = {"targetTemperature": temperature}
+        await self.rest_api.start_air_conditioning(vin, payload=payload)
+    
+    async def stop_air_conditioning(self, vin: str) -> None:
+        """Stops the air_conditioning of the vehicle and return None if it was succesfull else catch an exception in HomeAssistant"""
+        await self.rest_api.stop_air_conditioning(vin)
+
+    async def start_auxiliary_heating(self, vin: str, spin: str, duration_in_seconds: int = 120, start_mode: str = "HEATING", target_temperature: Optional[float] = None, unit: str = "CELSIUS") -> None:
+        """Starts the auxiliary heating for the vehicle with the given VIN."""
+        payload = {
+            "spin": spin,
+            "durationInSeconds": duration_in_seconds,
+            "startMode": start_mode
+        }
+        # If there is target temperature, add it into the payload
+        if target_temperature is not None:
+            payload["targetTemperature"] = {
+                "value": target_temperature,
+                "unit": unit
+            }
+            
+        await self.rest_api.start_auxiliary_heating(vin, payload=payload)
+
+    async def stop_auxiliary_heating(self, vin: str) -> None:
+        """Stops the auxiliary_heating of the vehicle and return None if it was succesfull else catch an exception in HomeAssistant"""
+        await self.rest_api.stop_auxiliary_heating(vin)
+    
+    async def start_active_ventilation(self, vin: str) -> None:
+        """Starts the active_ventilation for the vehicle with the given VIN."""
+        await self.rest_api.start_active_ventilation(vin)
+
+    async def stop_active_ventilation(self, vin: str) -> None:
+        """Stops the active_ventilation of the vehicle and return None if it was succesfull else catch an exception in HomeAssistant"""
+        await self.rest_api.stop_active_ventilation(vin)
+
+    async def start_charging(self, vin: str) -> None:
+        """Starts the charging process for the vehicle with the given VIN."""
+        await self.rest_api.start_charging(vin)
+
+    async def stop_charging(self, vin: str) -> None:
+        """Stops the charging process for the vehicle with the given VIN."""
+        await self.rest_api.stop_charging(vin)
+
+    async def connect(self):
+        """TODO: Implementation of connect mechanism."""
+        pass
+    
+    async def disconnect(self) -> None:
+        """TODO: Implementation of disconnect mechanism."""
+        pass
+    
+    async def verify_spin(self, spin: str) -> bool:
+        """TODO: Implementation of SPIN verification."""
+        pass
+
+    """
+    ======= NOT IMPLEMENTED FUNCTIONS - CAN BE USED SOMETIME IN THE FUTURE =======
+    """
+    async def refresh_auxiliary_heating(self, vin: str) -> None:
+        """Refreshes the auxiliary heating status of the vehicle with the given VIN."""
+        pass
+
+    async def set_reduced_current_limit(self, vin: str) -> None:
+        """Sets the charging current limit (e.g., to REDUCED or MAXIMUM) for the vehicle with the given VIN."""
+        pass
+
+    async def set_seats_heating(self, vin: str) -> None:
+        """Configures the seats heating settings for the vehicle with the given VIN."""
+        pass
+
+    async def start_window_heating(self, vin: str) -> None:
+        """Starts the electric window heating for the vehicle with the given VIN."""
+        pass
+
+    async def stop_window_heating(self, vin: str) -> None:
+        """Stops the window heating of the vehicle and return None if it was succesfull else catch an exception in HomeAssistant."""
+        pass
+
+    async def set_windows_heating(self, vin: str) -> None:
+        """Configures the front and rear windows heating settings for the vehicle with the given VIN."""
+        pass
+
+    async def set_auto_unlock_plug(self, vin: str) -> None:
+        """Sets the automatic unlocking behavior of the charging plug (e.g., PERMANENT or OFF) for the vehicle with the given VIN."""
+        pass
+    async def set_charge_limit(self, vin: str, limit: int) -> None:
+        """Sets the maximum charging limit in percent for the vehicle with the given VIN."""
+        pass
+
+    async def set_target_temperature(self, vin: str, temperature: float) -> None:
+        """Sets the target temperature for AC or auxiliary heating for the vehicle with the given VIN."""
+        pass
+    # TODO: Add more methods for other endpoints as needed

myskoda_openapi/api_layer/rest_api.py

@@ -0,0 +1,257 @@
+import asyncio
+import logging
+from typing import Generic, Optional, TypeVar, Any, List
+from dataclasses import dataclass
+from aiohttp import ClientResponseError, ClientSession
+from .const import SANDBOX_BASE_URL, PRODUCTION_BASE_URL, TEST_BASE_URL
+from models.vehicle import VehicleResponse
+from models.vehicle_status import VehicleStatus
+from models.vehicle import Odometer
+from models.air_conditioning import AirConditioning
+from models.parking_position import ParkingPosition
+from models.auxiliary_heating import AuxiliaryHeating
+from models.charging import Charging
+from models.active_ventilation import ActiveVentilation
+from .exceptions import (
+    OpenApiError,
+    OpenApiAuthenticationError,
+    OpenApiForbiddenError,
+    OpenApiVehicleNotFoundError,
+    OpenApiRateLimitError,
+)
+
+T = TypeVar("T")
+_LOGGER = logging.getLogger(__name__)
+
+class GetEndpointResult(Generic[T]):
+    """Wrapper for the result of a GET request to an endpoint, containing the URL, raw JSON data, and the parsed Pydantic model."""
+    def __init__(self, url: str, raw_json: Any, result: T) -> None:
+        self.url = url
+        self.raw_json = raw_json          
+        self.result = result    # Final Pydantic model after parsing raw Json.
+
+class PostEndpointResult:
+    """Wrapper for the result of a POST request to an endpoint, containing the URL, status code, and headers."""
+    def __init__(self, url: str, status: int, headers: dict) -> None:
+        self.url = url
+        self.status = status
+        self.headers = headers # Užitečné např. pro sledování RateLimit-Remaining nebo X-API-Key-Expires-At
+
+
+class SkodaRestAPI:
+    """Rest API client for interacting with the Škoda Open API."""
+
+    def __init__(self, api_key: str, session: ClientSession) -> None:
+        self._api_key = api_key
+        self._session = session
+        self._base_url = TEST_BASE_URL  # Default to TEST_BASE_URL; can be changed to SANDBOX_BASE_URL or PRODUCTION_BASE_URL as needed.
+        #TODO will be exteded with methods for authorization, token management, and other endpoints as needed.
+
+    async def _make_post_request(self, url: str, json_data: Optional[dict] = None) -> int:
+        """Helper method to make POST requests to the Škoda API."""
+        full_url = f"{self._base_url}{url}"
+        headers = {
+            "X-API-Key": self._api_key,
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+        
+        try:
+            async with self._session.post(full_url, headers=headers, json=json_data) as response:
+                if response.status not in (200, 202):
+                    match response.status:
+                        case 401: raise OpenApiAuthenticationError("Invalid or expired X-API-Key.")
+                        case 403: raise OpenApiForbiddenError("Access forbidden. User not allowed to execute operation.")
+                        case 404: raise OpenApiVehicleNotFoundError("Vehicle with this VIN does not exist.")
+                        case 429: raise OpenApiRateLimitError("Rate limit exceeded or insufficient battery level.")
+                        case 400: raise OpenApiError("Bad request (e.g. validation or VIN issues).")
+                
+                return response.status
+        except Exception as err:
+            if isinstance(err, OpenApiError):
+                raise
+            raise OpenApiError(f"There has been an error when trying to make the POST request: {err}") from err
+
+    async def _make_get_request(self, url: str, params: Optional[dict] = None) -> Any:
+        """Helper method to make GET requests to the Škoda API."""
+        full_url = f"{self._base_url}{url}"
+        headers = {
+            "X-API-Key": self._api_key,
+            "Accept": "application/json",
+        }
+        
+        try:
+            async with self._session.get(full_url, headers=headers, params=params) as response:
+                if response.status not in (200, 202):
+                    match response.status:
+                        case 401: raise OpenApiAuthenticationError("Invalid or expired X-API-Key.") 
+                        case 403: raise OpenApiForbiddenError("Access to the requested resource is forbidden.") 
+                        case 404: raise OpenApiVehicleNotFoundError("Vehicle with this VIN does not exist.") 
+                        case 429: raise OpenApiRateLimitError("Rate limit exceeded or weak 12V battery.") 
+                return await response.json()
+        except Exception as err:
+            raise OpenApiError(f"There has been an error when trying to make the request: {err}") from err
+
+    # =========================================================================
+    # ENDPOINT METHODS - GET
+    # =========================================================================
+    async def get_vehicle(self, vin: str, include: Optional[List[str]] = None) -> GetEndpointResult[VehicleResponse]:
+        """Call the GET /api/v1/vehicles/{vin} endpoint to retrieve vehicle data for a given VIN."""
+        url = f"/api/v1/vehicles/{vin}"
+        params = {}
+        if include:
+            params["include"] = ",".join(include)
+
+        raw_json = await self._make_get_request(url, params=params)
+        
+        # Deserializace raw_json into Pydantic model VehicleResponse
+        full_response = VehicleResponse.model_validate(raw_json)
+        
+        # Pack and retunr the result in GetEndpointResult
+        return GetEndpointResult(url=url, raw_json=raw_json, result=full_response)
+    
+    async def get_vehicle_status(self, vin: str, include: Optional[List[str]] = None) -> GetEndpointResult[Optional[VehicleStatus]]:
+        """Retrieve ONLY the vehicle status by filtering via the 'include' parameter."""
+        url = f"/api/v1/vehicles/{vin}"        
+        # Set the 'include' parameter to 'status' to retrieve only the vehicle status
+        params = {"include": "status"}
+
+        raw_json = await self._make_get_request(url, params=params)
+        # Parse whole response into VehicleResponse model
+        full_response = VehicleResponse.model_validate(raw_json)
+        status_model = full_response.vehicle.status
+        
+        return GetEndpointResult(url=url, raw_json=raw_json, result=status_model)
+    
+    async def get_air_conditioning(self, vin: str, include: Optional[List[str]] = None) -> GetEndpointResult[Optional[AirConditioning]]:
+        """Retrieve ONLY the vehicles air conditioning object by filtering via the 'include' parameter."""
+        url = f"/api/v1/vehicles/{vin}"        
+        params = {"include": "airConditioning"}
+
+        raw_json = await self._make_get_request(url, params=params)
+
+        full_response = VehicleResponse.model_validate(raw_json)
+        status_model = full_response.vehicle.air_conditioning
+        
+        return GetEndpointResult(url=url, raw_json=raw_json, result=status_model)
+    
+    async def get_parking_positions(self, vin: str, include: Optional[List[str]] = None) -> GetEndpointResult[Optional[ParkingPosition]]:
+        """Retrieve ONLY the vehicle parking positions object by filtering via the 'include' parameter."""
+        url = f"/api/v1/vehicles/{vin}"        
+        params = {"include": "parkingPosition"}
+
+        raw_json = await self._make_get_request(url, params=params)
+
+        full_response = VehicleResponse.model_validate(raw_json)
+        status_model = full_response.vehicle.parking_position
+        
+        return GetEndpointResult(url=url, raw_json=raw_json, result=status_model)
+    
+    async def get_auxiliary_heating(self, vin: str, include: Optional[List[str]] = None) -> GetEndpointResult[Optional[AuxiliaryHeating]]:
+        """Retrieve ONLY the vehicle auxiliary heating by filtering via the 'include' parameter."""
+        url = f"/api/v1/vehicles/{vin}"        
+        params = {"include": "auxiliaryHeating"}
+
+        raw_json = await self._make_get_request(url, params=params)
+
+        full_response = VehicleResponse.model_validate(raw_json)
+        status_model = full_response.vehicle.auxiliary_heating
+        
+        return GetEndpointResult(url=url, raw_json=raw_json, result=status_model)
+
+    async def get_odometer(self, vin: str, include: Optional[List[str]] = None) -> GetEndpointResult[Optional[Odometer]]:
+        """Retrieve ONLY the vehicle odometer object by filtering via the 'include' parameter."""
+        url = f"/api/v1/vehicles/{vin}"        
+        params = {"include": "odometer"}
+
+        raw_json = await self._make_get_request(url, params=params)
+
+        full_response = VehicleResponse.model_validate(raw_json)
+        status_model = full_response.vehicle.odometer
+        
+        return GetEndpointResult(url=url, raw_json=raw_json, result=status_model)
+    
+    async def get_charging(self, vin: str, include: Optional[List[str]] = None) -> GetEndpointResult[Optional[Charging]]:
+        """Retrieve ONLY the vehicle charging object by filtering via the 'include' parameter."""
+        url = f"/api/v1/vehicles/{vin}"        
+        params = {"include": "charging"}
+
+        raw_json = await self._make_get_request(url, params=params)
+
+        full_response = VehicleResponse.model_validate(raw_json)
+        status_model = full_response.vehicle.charging
+        
+        return GetEndpointResult(url=url, raw_json=raw_json, result=status_model)
+
+    async def get_active_ventilation(self, vin: str, include: Optional[List[str]] = None) -> GetEndpointResult[Optional[ActiveVentilation]]:
+        """Retrieve ONLY the vehicle active ventilation object by filtering via the 'include' parameter."""
+        url = f"/api/v1/vehicles/{vin}"        
+        params = {"include": "activeVentilation"}
+
+        raw_json = await self._make_get_request(url, params=params)
+
+        full_response = VehicleResponse.model_validate(raw_json)
+        status_model = full_response.vehicle.active_ventilation
+        
+        return GetEndpointResult(url=url, raw_json=raw_json, result=status_model)
+    
+    # =========================================================================
+    # ENDPOINT METHODS - POST
+    # =========================================================================
+    async def start_air_conditioning(self, vin: str, payload: dict) -> PostEndpointResult:
+        """Starts the air conditioning for the vehicle with the given VIN. The payload should contain any necessary parameters for starting the air conditioning."""
+        url = f"/api/v1/vehicles/{vin}/air-conditioning/start"
+        
+        status = await self._make_post_request(url, json_data=payload)
+        return PostEndpointResult(url=url, status=status, headers={})
+    
+    async def stop_air_conditioning(self, vin: str) -> PostEndpointResult:
+        """Stops the air_conditioning for the given VIN"""
+        url = f"/api/v1/vehicles/{vin}/air-conditioning/stop"
+        
+        status = await self._make_post_request(url)
+        return PostEndpointResult(url=url, status=status, headers={})
+    
+    async def start_auxiliary_heating(self, vin: str, payload: dict) -> PostEndpointResult:
+        """Starts the auxiliary heating for the vehicle with the given VIN. The payload should contain any necessary parameters for starting the auxiliary heating."""
+        url = f"/api/v1/vehicles/{vin}/auxiliary-heating/start"
+        
+        status = await self._make_post_request(url, json_data=payload)
+        return PostEndpointResult(url=url, status=status, headers={})
+    
+    async def stop_auxiliary_heating(self, vin: str) -> PostEndpointResult:
+        """Stops the auxiliary heating for the given VIN"""
+        url = f"/api/v1/vehicles/{vin}/auxiliary-heating/stop"
+        
+        status = await self._make_post_request(url)
+        return PostEndpointResult(url=url, status=status, headers={})
+    
+    async def start_active_ventilation(self, vin: str, payload: dict) -> PostEndpointResult:
+        """Starts the active ventilation for the vehicle with the given VIN. The payload should contain any necessary parameters for starting the active ventilation."""
+        url = f"/api/v1/vehicles/{vin}/active-ventilation/start"
+        
+        status = await self._make_post_request(url, json_data=payload)
+        return PostEndpointResult(url=url, status=status, headers={})
+    
+    async def stop_active_ventilation(self, vin: str) -> PostEndpointResult:
+        """Stops the active ventilation for the given VIN"""
+        url = f"/api/v1/vehicles/{vin}/active-ventilation/stop"
+        
+        status = await self._make_post_request(url)
+        return PostEndpointResult(url=url, status=status, headers={})
+    
+    async def start_charging(self, vin: str) -> PostEndpointResult:
+        """Starts the charging process for the vehicle with the given VIN."""
+        url = f"/api/v1/vehicles/{vin}/charging/start"
+        
+        status = await self._make_post_request(url)
+        return PostEndpointResult(url=url, status=status, headers={})
+    
+    async def stop_charging(self, vin: str) -> PostEndpointResult:
+        """Stops the charging process for the given VIN"""
+        url = f"/api/v1/vehicles/{vin}/charging/stop"
+        
+        status = await self._make_post_request(url)
+        return PostEndpointResult(url=url, status=status, headers={})
+    
+    #TODO rest of the methods

myskoda_openapi/models/active_ventilation.py

@@ -0,0 +1,12 @@
+from typing import Optional
+from .base_model import BaseModel
+from .common import TargetTemperature
+from .enums import ( 
+    VentilationState
+)
+
+class ActiveVentilation(BaseModel):
+    """Active ventilation status."""
+    state: VentilationState
+    duration_in_seconds: Optional[int] = None
+    car_captured_timestamp:  Optional[str] = None

myskoda_openapi/models/air_conditioning.py

@@ -0,0 +1,23 @@
+from typing import Optional
+
+from .base_model import BaseModel
+from .common import TargetTemperature
+from .enums import OnOffState, AirConditioningState
+
+
+class WindowHeating(BaseModel):
+    """State of the electric window heating."""
+    enabled: Optional[bool] = None
+    front: Optional[OnOffState] = None
+    rear: Optional[OnOffState] = None
+
+
+class AirConditioning(BaseModel):
+    """Information about the vehicle's air conditioning."""
+    state: AirConditioningState
+    target_temperature: Optional[TargetTemperature] = None
+    estimated_reach_of_target_temperature_at: Optional[str] = None
+    air_conditioning_without_external_power: Optional[bool] = None
+    air_conditioning_at_unlock: Optional[bool] = None
+    window_heating: Optional[WindowHeating] = None
+    car_captured_timestamp: Optional[str] = None

myskoda_openapi/models/auxiliary_heating.py

@@ -0,0 +1,16 @@
+from typing import Optional
+from .base_model import BaseModel
+from .common import TargetTemperature
+from .enums import ( 
+    AuxiliaryHeatingState,
+    AuxiliaryHeatingStartMode,
+)
+
+class AuxiliaryHeating(BaseModel):
+    """Auxiliary heating status."""
+    state: AuxiliaryHeatingState
+    start_mode: Optional[AuxiliaryHeatingStartMode] = None
+    duration_in_seconds: Optional[int] = None
+    target_temperature:  Optional[TargetTemperature] = None
+    estimated_reach_of_target_temperature_at: Optional[str] = None
+    car_captured_timestamp: Optional[str] = None

myskoda_openapi/models/base_model.py

@@ -0,0 +1,13 @@
+from pydantic import BaseModel, ConfigDict
+
+def to_camel_case(snake_str: str) -> str:
+    words = snake_str.split('_')
+    return words[0] + ''.join(x.title() for x in words[1:])
+
+class BaseModel(BaseModel):
+    model_config = ConfigDict(
+        alias_generator=to_camel_case,
+        populate_by_name=True,
+    )
+
+    

myskoda_openapi/models/charging.py

@@ -0,0 +1,44 @@
+from typing import Optional, List
+
+from .base_model import BaseModel
+from .enums import (
+    ChargingState,
+    ChargeType,
+    ChargeMode,
+    ChargeCareModeState,
+    AutoUnlockPlugState,
+    MaxChargeCurrentAcState
+)
+
+class BatteryStatus(BaseModel):
+    """Battery status information."""
+    remaining_cruising_range_in_meters: Optional[int] = None
+    state_of_charge_in_percent: Optional[int] = None
+
+class ChargingStatus(BaseModel):
+    """Charging status information."""
+    charging_rate_in_kilometers_per_hour: Optional[float] = None
+    charge_power_in_kw: Optional[float] = None
+    remaining_time_to_fully_charged_in_minutes: Optional[int] = None
+    fully_charged_at: Optional[str] = None
+    state: Optional[ChargingState] = None
+    charge_type: Optional[ChargeType] = None
+    battery: Optional[BatteryStatus] = None
+
+class ChargingSettings(BaseModel):
+    """Information about charging settings."""
+    target_state_of_charge_in_percent: Optional[int] = None
+    battery_care_mode_target_value_in_percent: Optional[int] = None
+    preferred_charge_mode: Optional[ChargeMode] = None
+    available_charge_modes: Optional[List[ChargeMode]] = None
+    charging_care_mode: Optional[ChargeCareModeState] = None
+    auto_unlock_plug_when_charged: Optional[AutoUnlockPlugState] = None
+    max_charge_current_ac: Optional[MaxChargeCurrentAcState] = None
+    max_charge_current_ac_ampere: Optional[int] = None
+
+class Charging(BaseModel):
+    """Charging represents information about charging and battery settings."""
+    is_vehicle_in_saved_location: bool
+    status: Optional[ChargingStatus] = None
+    settings: Optional[ChargingSettings] = None
+    car_captured_timestamp: Optional[str] = None

myskoda_openapi/models/common.py

@@ -0,0 +1,20 @@
+from datetime import datetime
+from typing import Optional
+from pydantic import Field
+
+from .base_model import BaseModel
+from .enums import ( 
+    TemperatureUnit,
+    VehicleErrorState
+)
+
+
+class TargetTemperature(BaseModel):
+    """Target temperature settings for the vehicle."""
+    value: float
+    unit: TemperatureUnit 
+
+class VehicleError(BaseModel):
+    """Error information related to the vehicle."""
+    type: VehicleErrorState
+    description: str

myskoda_openapi/models/driving_range.py

@@ -0,0 +1,21 @@
+from typing import Optional
+
+from .base_model import BaseModel
+
+
+class EngineRange(BaseModel):
+    """Details of the vehicle's engine range."""
+    engine_type: Optional[str] = None
+    current_soc_in_percent: Optional[int] = None
+    current_fuel_level_in_percent: Optional[int] = None
+    remaining_range_in_km: Optional[int] = None
+
+
+class DrivingRange(BaseModel):
+    """Details of the vehicle's fuel status and driving range."""
+    car_type: Optional[str] = None
+    ad_blue_range: Optional[int] = None
+    total_range_in_km: Optional[int] = None
+    primary_engine_range: Optional[EngineRange] = None
+    secondary_engine_range: Optional[EngineRange] = None
+    car_captured_timestamp: Optional[str] = None

myskoda_openapi/models/enums.py

@@ -0,0 +1,132 @@
+from enum import Enum
+
+class TemperatureUnit(str, Enum):
+    CELSIUS = "CELSIUS"
+    FAHRENHEIT = "FAHRENHEIT"
+    UNKNOWN = "UNKNOWN"
+
+class OnOffState(str, Enum):
+    ON = "ON"
+    OFF = "OFF"
+    UNKNOWN = "UNKNOWN"
+    UNSUPPORTED = "UNSUPPORTED"
+
+class LockState(str, Enum):
+    LOCKED = "LOCKED"
+    UNLOCKED = "UNLOCKED"
+    UNKNOWN = "UNKNOWN"
+
+class OpenCloseState(str, Enum):
+    OPEN = "OPEN"
+    CLOSED = "CLOSED"
+    UNKNOWN = "UNKNOWN"
+    UNSUPPORTED = "UNSUPPORTED"
+
+class YesNoState(str, Enum):
+    YES = "YES"
+    NO = "NO"
+    UNKNOWN = "UNKNOWN"
+
+class DoorsState(str, Enum):
+    YES = "YES"
+    NO = "NO"
+    TRUNK_OPENED = "TRUNK_OPENED"
+    OPENED = "OPENED"
+    UNKNOWN = "UNKNOWN"
+
+class AuxiliaryHeatingState(str, Enum):
+    HEATING = "HEATING"
+    VENTILATION = "VENTILATION"
+    OFF = "OFF"
+    HEATING_AUXILIARY = "HEATING_AUXILIARY"
+    UNKNOWN = "UNKNOWN"
+    UNSUPPORTED = "UNSUPPORTED"
+
+class AuxiliaryHeatingStartMode(str, Enum):
+    HEATING = "HEATING"
+    VENTILATION = "VENTILATION"
+   
+class VentilationState(str, Enum):
+    VENTILATION = "VENTILATION"
+    PREHEATING = "PREHEATING"
+    OFF = "OFF"
+    UNKNOWN = "UNKNOWN"
+    UNSUPPORTED = "UNSUPPORTED"
+
+class HeaterSourceState(str, Enum):
+    AUTOMATIC = "AUTOMATIC"
+    ELECTRIC = "ELECTRIC"
+
+class ChargeType(str, Enum):
+    AC = "AC"
+    DC = "DC"
+    OFF = "OFF"
+
+class ChargingState(str, Enum):
+    CONNECT_CABLE = "CONNECT_CABLE"
+    CHARGING = "CHARGING"
+    CONSERVING = "CONSERVING"
+    READY_FOR_CHARGING = "READY_FOR_CHARGING"
+    DISCHARGING = "DISCHARGING"
+    CHARGING_INTERRUPTED = "CHARGING_INTERRUPTED"
+
+class ChargeMode(str, Enum):
+    MANUAL = "MANUAL"
+    TIMER = "TIMER"
+    TIMER_CHARGING_WITH_CLIMATISATION = "TIMER_CHARGING_WITH_CLIMATISATION"
+    PREFERRED_CHARGING_TIMES = "PREFERRED_CHARGING_TIMES"
+    ONLY_OWN_CURRENT = "ONLY_OWN_CURRENT"
+    IMMEDIATE_DISCHARGING = "IMMEDIATE_DISCHARGING"
+    HOME_STORAGE_CHARGING = "HOME_STORAGE_CHARGING"
+
+class ChargeCareModeState(str, Enum):
+    ACTIVATED = "ACTIVATED"
+    DEACTIVATED = "DEACTIVATED"
+
+class AutoUnlockPlugState(str, Enum):
+    PERMANENT = "PERMANENT"
+    OFF = "OFF"
+
+class MaxChargeCurrentAcState(str, Enum):
+    REDUCED = "REDUCED"
+    MAXIMUM = "MAXIMUM"
+
+class MovementState(str, Enum):
+    IN_MOTION = "IN_MOTION"
+    PARKED = "PARKED"
+
+class VehicleErrorState(str, Enum):
+    VEHICLE_STATUS_UNSUPPORTED = "VEHICLE_STATUS_UNSUPPORTED"
+    VEHICLE_STATUS_DISABLED = "VEHICLE_STATUS_DISABLED"
+    VEHICLE_STATUS_UNAVAILABLE = "VEHICLE_STATUS_UNAVAILABLE"
+    DRIVING_RANGE_UNSUPPORTED = "DRIVING_RANGE_UNSUPPORTED"
+    DRIVING_RANGE_DISABLED = "DRIVING_RANGE_DISABLED"
+    DRIVING_RANGE_UNAVAILABLE = "DRIVING_RANGE_UNAVAILABLE"
+    ODOMETER_UNSUPPORTED = "ODOMETER_UNSUPPORTED"
+    ODOMETER_DISABLED = "ODOMETER_DISABLED"
+    ODOMETER_UNAVAILABLE = "ODOMETER_UNAVAILABLE"
+    PARKING_POSITION_UNSUPPORTED = "PARKING_POSITION_UNSUPPORTED"
+    PARKING_POSITION_DISABLED = "PARKING_POSITION_DISABLED"
+    PARKING_POSITION_UNAVAILABLE = "PARKING_POSITION_UNAVAILABLE"
+    AIR_CONDITIONING_UNSUPPORTED = "AIR_CONDITIONING_UNSUPPORTED"
+    AIR_CONDITIONING_DISABLED = "AIR_CONDITIONING_DISABLED"
+    AIR_CONDITIONING_UNAVAILABLE = "AIR_CONDITIONING_UNAVAILABLE"
+    AUXILIARY_HEATING_UNSUPPORTED = "AUXILIARY_HEATING_UNSUPPORTED"
+    AUXILIARY_HEATING_DISABLED = "AUXILIARY_HEATING_DISABLED"
+    AUXILIARY_HEATING_UNAVAILABLE = "AUXILIARY_HEATING_UNAVAILABLE"
+    ACTIVE_VENTILATION_UNSUPPORTED = "ACTIVE_VENTILATION_UNSUPPORTED"
+    ACTIVE_VENTILATION_DISABLED = "ACTIVE_VENTILATION_DISABLED"
+    ACTIVE_VENTILATION_UNAVAILABLE = "ACTIVE_VENTILATION_UNAVAILABLE"
+    CHARGING_UNSUPPORTED = "CHARGING_UNSUPPORTED"
+    CHARGING_DISABLED = "CHARGING_DISABLED"
+    CHARGING_UNAVAILABLE = "CHARGING_UNAVAILABLE"
+
+class AirConditioningState(str, Enum):
+    OFF = "OFF"
+    COOLING = "COOLING"
+    HEATING = "HEATING"
+    HEATING_AUXILIARY = "HEATING_AUXILIARY"
+    VENTILATION = "VENTILATION"
+    COMPLETED = "COMPLETED"
+    UNKNOWN = "UNKNOWN"
+    UNSUPPORTED = "UNSUPPORTED" 

myskoda_openapi/models/parking_position.py

@@ -0,0 +1,17 @@
+from typing import Optional
+from .base_model import BaseModel
+from .enums import ( 
+    MovementState
+)
+
+class GPRCoordinates(BaseModel):
+    """GPR coordinates of the vehicle."""
+    latitude: float
+    longitude: float
+
+class ParkingPosition(BaseModel):
+    """Parking position information."""
+    state: MovementState
+    gps_coordinates: Optional[GPRCoordinates] = None
+    formatted_address: Optional[str] = None
+

myskoda_openapi/models/vehicle.py

@@ -0,0 +1,41 @@
+from datetime import datetime
+from typing import List, Optional
+from pydantic import Field
+
+from .base_model import BaseModel
+
+from .vehicle_status import VehicleStatus
+from .common import VehicleError
+from .parking_position import ParkingPosition
+from .auxiliary_heating import AuxiliaryHeating
+from .active_ventilation import ActiveVentilation
+from .charging import Charging
+from .driving_range import DrivingRange
+from .air_conditioning import AirConditioning
+
+class Odometer(BaseModel):
+    """Odometer of the vehicle."""
+    mileage_in_km: int
+    car_captured_timestamp: Optional[str]
+
+class VehicleObject(BaseModel):
+    """Pack whole vehicle object into one object for the vehicle."""
+    name: Optional[str] = None
+    vin: str
+    license_plate: Optional[str] = None
+    render_url: Optional[str] = None
+    odometer: Optional[Odometer] = None
+    status: Optional[VehicleStatus] = None
+    parking_position: Optional[ParkingPosition] = None 
+    auxiliary_heating: Optional[AuxiliaryHeating] = None
+    active_ventilation: Optional[ActiveVentilation] = None
+    air_conditioning: Optional[AirConditioning] = None
+    driving_range: Optional[DrivingRange] = None
+    charging: Optional[Charging] = None
+
+class VehicleResponse(BaseModel):
+    """Response object for vehicle data."""
+    vehicle: VehicleObject
+    errors: List[VehicleError] = Field(default_factory=list)
+
+   

myskoda_openapi/models/vehicle_status.py

@@ -0,0 +1,33 @@
+from datetime import datetime
+from typing import Optional
+from pydantic import Field
+
+from .base_model import BaseModel
+from .enums import ( 
+    LockState,
+    DoorsState, 
+    YesNoState, 
+    OpenCloseState, 
+    OnOffState
+)
+
+class OverallVehicleStatus(BaseModel):
+    """Overall status of the vehicle."""
+    doors_locked: DoorsState
+    locked: YesNoState
+    doors: OpenCloseState
+    windows: OpenCloseState
+    lights: OnOffState
+    reliable_lock_status: Optional[LockState] = None
+
+class VehicleStatusDetail(BaseModel):
+    """Status of individual components of the vehicle."""
+    sunroof: OpenCloseState
+    trunk: OpenCloseState
+    bonnet: OpenCloseState
+
+class VehicleStatus(BaseModel):
+    """Pack all the objects into one object for the vehicle status."""
+    overall: OverallVehicleStatus
+    detail: VehicleStatusDetail
+    car_captured_timestamp: Optional[str] = None

myvsb_developer_api-0.1.2.dist-info/METADATA

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: myvsb-developer-api
+Version: 0.1.2
+Summary: Asynchronous Python library for the MyVSB Developer API
+Author-email: net0045 <stepan.netolicky@vsb.cz>
+Project-URL: Homepage, https://github.com/mobility-lab-vsb/myvsb-developer-api
+Project-URL: Bug Tracker, https://github.com/mobility-lab-vsb/myvsb-developer-api/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Framework :: AsyncIO
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.9.0
+Requires-Dist: pydantic>=2.5.0
+Provides-Extra: test
+Requires-Dist: pytest>=9.0.0; extra == "test"
+Requires-Dist: pytest-asyncio>=0.23.0; extra == "test"
+Requires-Dist: aresponses>=3.0.0; extra == "test"
+Dynamic: license-file
+
+# vsb-developer-api
+VSB developer API is a Python library to interact with the new VSB API for connected-vehicle data and remote control of VSB vehicles.

myvsb_developer_api-0.1.2.dist-info/RECORD

@@ -0,0 +1,21 @@
+myskoda_openapi/api_layer/const.py,sha256=akV2Cpvlpk92BFv8QEi4ggMmG5u1p2iVzVqODpJJKd4,196
+myskoda_openapi/api_layer/exceptions.py,sha256=Ue7VO-E7S3aelmx3PhP0f1pxLp3Bd4UhRFsfXq8FGhc,1484
+myskoda_openapi/api_layer/open_api_client.py,sha256=581Ngn5loPTKjPzk1a9lXBH4mnSkRG89f1ufQalR4zc,5592
+myskoda_openapi/api_layer/rest_api.py,sha256=khFH5arVNBOpKx8eSIIL9JdV9kAjcsnbmUz2t6Nf--o,13292
+myskoda_openapi/api_layer/utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+myskoda_openapi/models/active_ventilation.py,sha256=cezsslMRA_uJ4rXZQIf4dLB-rrh4O-xU6-gw71koOt8,343
+myskoda_openapi/models/air_conditioning.py,sha256=YKgIvW-Fhg6eJMurH5Zm7H7WKBummz9-r8KbgtGwpv8,821
+myskoda_openapi/models/auxiliary_heating.py,sha256=-6Xa_ggwXvjWqhV2GB7VWV6AhwkS4hENaQWEsug32hs,568
+myskoda_openapi/models/base_model.py,sha256=CegdMq2ASpixeGMw1QzRfmvRipPwWX4tfmle-rNkEgw,320
+myskoda_openapi/models/charging.py,sha256=NQnxMdzl9EZsOP_M5a7dxGM2upWX3ozH2BSI9XGzioI,1704
+myskoda_openapi/models/common.py,sha256=r41LSkDt5V9OvbT2wdsCu55rv1DcuIsZmxsq3NwaGyE,456
+myskoda_openapi/models/driving_range.py,sha256=qQh39bEWd-Ou3cWb5CoAlmPXeFy8kbgLh4xBKO63vgM,713
+myskoda_openapi/models/enums.py,sha256=yOcqbtGsj1kSyem3nLnBcf0SxSJ32vn2RH3LB-pAppk,4048
+myskoda_openapi/models/parking_position.py,sha256=K_GLaeZqT2Fl7OQ9emAL3D_ohbmfXtc9ykdV3P4NjiY,419
+myskoda_openapi/models/vehicle.py,sha256=3uffRuu2XKUENkRqNZvpV2pCy5Gew2QzTgm09kuqFHE,1384
+myskoda_openapi/models/vehicle_status.py,sha256=GjgzIcQwC73wyq9hVhxKZgNnB1IzGIzi5lCYC4tThkQ,888
+myvsb_developer_api-0.1.2.dist-info/licenses/LICENSE,sha256=JH8dA4ELqb8p0QcClibxxAuMyew7AElvtO3Xgcm4Yzo,1109
+myvsb_developer_api-0.1.2.dist-info/METADATA,sha256=BqgWw8MaZzpX-7oKplXBk5hShxzAntcFOSM1lZQCQ4M,1019
+myvsb_developer_api-0.1.2.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+myvsb_developer_api-0.1.2.dist-info/top_level.txt,sha256=Y4aqNREBD9ZK3NZl-DEL3Au3DMTcmiKJkc8TQGN7bXA,16
+myvsb_developer_api-0.1.2.dist-info/RECORD,,

myvsb_developer_api-0.1.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

myvsb_developer_api-0.1.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mobility Lab @ VSB - Technical University of Ostrava
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

myvsb_developer_api-0.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+myskoda_openapi