myvsb-developer-api 1.0.4__tar.gz → 1.0.6__tar.gz

myvsb_developer_api-1.0.6/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: myvsb-developer-api
+Version: 1.0.6
+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"
+Provides-Extra: cli
+Requires-Dist: asyncclick~=8.1; extra == "cli"
+Requires-Dist: coloredlogs~=15.0; extra == "cli"
+Requires-Dist: pygments~=2.18; extra == "cli"
+Requires-Dist: pyyaml~=6.0; extra == "cli"
+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.
+
+## As CLI
+
+The library ships with a command line interface called `skodactl`, which is useful for manually
+testing the API endpoints. Install it together with the CLI dependencies:
+
+```sh
+pip install "myvsb-developer-api[cli]"
+```
+
+You authenticate with your API key, either via the `--api-key` option or the `SKODA_API_KEY`
+environment variable, and address a vehicle by its VIN:
+
+```sh
+skodactl --api-key XXX get-vehicle DMBGF9NY3NF032963
+```
+
+By default, the CLI talks to the production endpoint. Point it at the public test endpoint with
+`--endpoint test`, switch to YAML output with `--format yaml`, or log HTTP requests and responses
+with `--trace`:
+
+```sh
+skodactl --api-key XXX --endpoint test get-vehicle-status DMBGF9NY3NF032963
+SKODA_API_KEY=XXX skodactl --format yaml --trace get-charging DMBGF9NY3NF032963
+```
+
+Remote operations can be started as well:
+
+```sh
+skodactl --api-key XXX start-air-conditioning DMBGF9NY3NF032963 --temperature 21
+```
+
+Run `skodactl --help` for the full list of commands and options.

myvsb_developer_api-1.0.6/README.md

@@ -0,0 +1,36 @@
+# 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.
+
+## As CLI
+
+The library ships with a command line interface called `skodactl`, which is useful for manually
+testing the API endpoints. Install it together with the CLI dependencies:
+
+```sh
+pip install "myvsb-developer-api[cli]"
+```
+
+You authenticate with your API key, either via the `--api-key` option or the `SKODA_API_KEY`
+environment variable, and address a vehicle by its VIN:
+
+```sh
+skodactl --api-key XXX get-vehicle DMBGF9NY3NF032963
+```
+
+By default, the CLI talks to the production endpoint. Point it at the public test endpoint with
+`--endpoint test`, switch to YAML output with `--format yaml`, or log HTTP requests and responses
+with `--trace`:
+
+```sh
+skodactl --api-key XXX --endpoint test get-vehicle-status DMBGF9NY3NF032963
+SKODA_API_KEY=XXX skodactl --format yaml --trace get-charging DMBGF9NY3NF032963
+```
+
+Remote operations can be started as well:
+
+```sh
+skodactl --api-key XXX start-air-conditioning DMBGF9NY3NF032963 --temperature 21
+```
+
+Run `skodactl --help` for the full list of commands and options.

{myvsb_developer_api-1.0.4 → myvsb_developer_api-1.0.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "myvsb-developer-api"
-version = "1.0.4"
+version = "1.0.6"
 authors = [
   { name="net0045", email="stepan.netolicky@vsb.cz" },
 ]
@@ -26,6 +26,9 @@ dependencies = [
 "Homepage" = "https://github.com/mobility-lab-vsb/myvsb-developer-api"
 "Bug Tracker" = "https://github.com/mobility-lab-vsb/myvsb-developer-api/issues"
 
+[project.scripts]
+skodactl = "myskoda_openapi.cli:cli"
+
 [tool.pytest.ini_options]
 pythonpath = ["src/myskoda_openapi"]
 
@@ -35,3 +38,9 @@ test = [
     "pytest-asyncio>=0.23.0",
     "aresponses>=3.0.0",
 ]
+cli = [
+    "asyncclick ~=8.1",
+    "coloredlogs ~=15.0",
+    "pygments ~=2.18",
+    "pyyaml ~=6.0",
+]

myvsb_developer_api-1.0.6/src/myskoda_openapi/api_layer/const.py

@@ -0,0 +1,25 @@
+from enum import StrEnum
+
+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"
+BETA_URL = "https://public.api.connect.skoda-auto.cz"
+
+
+class Endpoints(StrEnum):
+    PRODUCTION = "production"
+    SANDBOX = "sandbox"
+    TEST = "test"
+    BETA = "beta"
+
+    @property
+    def url(self) -> str:
+        return ENDPOINT_URLS[self]
+
+
+ENDPOINT_URLS = {
+    Endpoints.PRODUCTION: PRODUCTION_BASE_URL,
+    Endpoints.SANDBOX: SANDBOX_BASE_URL,
+    Endpoints.TEST: TEST_BASE_URL,
+    Endpoints.BETA: BETA_URL,
+}

{myvsb_developer_api-1.0.4 → myvsb_developer_api-1.0.6}/src/myskoda_openapi/api_layer/open_api_client.py

@@ -1,6 +1,7 @@
 import logging
 from typing import Any, Optional, List
 from aiohttp import ClientSession
+from .const import BETA_URL
 from .rest_api import PostEndpointResult, SkodaRestAPI
 from ..models.vehicle import VehicleResponse, Odometer
 from ..models.vehicle_status import VehicleStatus
@@ -16,8 +17,8 @@ from ..models.configurations import StartAirConditioningConfiguration, StartAuxi
 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)
+    def __init__(self, api_key: str, session: ClientSession, base_url: str = BETA_URL) -> None:
+       self.rest_api = SkodaRestAPI(api_key=api_key, session=session, base_url=base_url)
 
     async def get_vehicle(self, vin: str, include: Optional[List[str]] = None) -> VehicleResponse:
         """Get the actual vehicle data and return the parsed Pydantic model."""

{myvsb_developer_api-1.0.4 → myvsb_developer_api-1.0.6}/src/myskoda_openapi/api_layer/rest_api.py

@@ -46,10 +46,10 @@ class PostEndpointResult:
 class SkodaRestAPI:
     """Rest API client for interacting with the Škoda Open API."""
 
-    def __init__(self, api_key: str, session: ClientSession) -> None:
+    def __init__(self, api_key: str, session: ClientSession, base_url: str = BETA_URL) -> None:
         self._api_key = api_key
         self._session = session
-        self._base_url = BETA_URL  # Default to BETA_URL; can be changed to SANDBOX_BASE_URL or PRODUCTION_BASE_URL as needed.
+        self._base_url = base_url  # Default to BETA_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:

myvsb_developer_api-1.0.6/src/myskoda_openapi/cli/__init__.py

@@ -0,0 +1,125 @@
+"""CLI to test all API functions and models.
+
+Execute with:
+skodactl
+"""
+
+from logging import DEBUG, INFO
+
+import asyncclick as click
+import coloredlogs
+from aiohttp import ClientSession
+from asyncclick.core import Context
+
+from ..api_layer.const import ENDPOINT_URLS, Endpoints
+from ..api_layer.open_api_client import OpenAPIClient
+from .operations import (
+    start_active_ventilation,
+    start_air_conditioning,
+    start_auxiliary_heating,
+    start_charging,
+    stop_active_ventilation,
+    stop_air_conditioning,
+    stop_auxiliary_heating,
+    stop_charging,
+)
+from .requests import (
+    get_active_ventilation,
+    get_air_conditioning,
+    get_auxiliary_heating,
+    get_charging,
+    get_charging_profiles,
+    get_fuel_status,
+    get_odometer,
+    get_parking_position,
+    get_vehicle,
+    get_vehicle_status,
+)
+from .utils import TRACE_CONFIG, Format, StrEnumChoice, print_json, print_yaml
+
+
+@click.group()
+@click.option(
+    "api_key",
+    "--api-key",
+    help="API key used to authenticate against the Skoda API.",
+    required=True,
+    envvar="SKODA_API_KEY",
+)
+@click.option(
+    "endpoint",
+    "--endpoint",
+    help="Select the API endpoint to use.",
+    type=StrEnumChoice(Endpoints),
+    default=Endpoints.BETA,
+)
+@click.option(
+    "output_format",
+    "--format",
+    help="Select the output format. JSON or YAML.",
+    type=StrEnumChoice(Format),
+    default=Format.JSON,
+)
+@click.option("verbose", "--verbose", help="Enable verbose logging.", is_flag=True)
+@click.option("trace", "--trace", help="Enable tracing of HTTP requests.", is_flag=True)
+@click.pass_context
+async def cli(
+    ctx: Context,
+    api_key: str,
+    endpoint: Endpoints,
+    output_format: Format,
+    verbose: bool,
+    trace: bool,
+) -> None:
+    """Interact with the Skoda Open API."""
+    coloredlogs.install(level=DEBUG if verbose or trace else INFO)
+    ctx.ensure_object(dict)
+    ctx.obj["api_key"] = api_key
+    ctx.obj["endpoint"] = endpoint
+    if output_format == Format.JSON:
+        ctx.obj["print"] = print_json
+    elif output_format == Format.YAML:
+        ctx.obj["print"] = print_yaml
+
+    trace_configs = [TRACE_CONFIG] if trace else []
+
+    if ctx.resilient_parsing:
+        return
+
+    session = ClientSession(trace_configs=trace_configs)
+    client = OpenAPIClient(
+        api_key=api_key,
+        session=session,
+        base_url=ENDPOINT_URLS[endpoint],
+    )
+    ctx.obj["client"] = client
+    ctx.obj["session"] = session
+
+    async def _close() -> None:
+        await session.close()
+
+    ctx.call_on_close(_close)
+
+
+cli.add_command(get_active_ventilation)
+cli.add_command(get_air_conditioning)
+cli.add_command(get_auxiliary_heating)
+cli.add_command(get_charging)
+cli.add_command(get_charging_profiles)
+cli.add_command(get_fuel_status)
+cli.add_command(get_odometer)
+cli.add_command(get_parking_position)
+cli.add_command(get_vehicle)
+cli.add_command(get_vehicle_status)
+cli.add_command(start_active_ventilation)
+cli.add_command(start_air_conditioning)
+cli.add_command(start_auxiliary_heating)
+cli.add_command(start_charging)
+cli.add_command(stop_active_ventilation)
+cli.add_command(stop_air_conditioning)
+cli.add_command(stop_auxiliary_heating)
+cli.add_command(stop_charging)
+
+
+if __name__ == "__main__":
+    cli()

myvsb_developer_api-1.0.6/src/myskoda_openapi/cli/__main__.py

@@ -0,0 +1,6 @@
+"""Allow execution with ``python -m myskoda_openapi.cli``."""
+
+from . import cli
+
+if __name__ == "__main__":
+    cli()

myvsb_developer_api-1.0.6/src/myskoda_openapi/cli/operations.py

@@ -0,0 +1,165 @@
+"""Commands for the CLI for operations that can be performed."""
+
+from typing import TYPE_CHECKING, Optional
+
+import asyncclick as click
+from asyncclick.core import Context
+
+from ..models.enums import TemperatureUnit
+from .utils import StrEnumChoice, handle_request
+
+if TYPE_CHECKING:
+    from ..api_layer.open_api_client import OpenAPIClient
+
+TEMPERATURE_UNITS = [TemperatureUnit.CELSIUS, TemperatureUnit.FAHRENHEIT]
+
+
+@click.command()
+@click.argument("vin")
+@click.option(
+    "temperature",
+    "--temperature",
+    type=float,
+    required=True,
+    help="Target temperature for the air conditioning.",
+)
+@click.option(
+    "unit",
+    "--unit",
+    type=StrEnumChoice(TEMPERATURE_UNITS),
+    default=TemperatureUnit.CELSIUS,
+    help="Temperature unit, CELSIUS or FAHRENHEIT.",
+)
+@click.option(
+    "with_external_power",
+    "--with-external-power",
+    is_flag=True,
+    help="Start the air conditioning with external power.",
+)
+@click.pass_context
+async def start_air_conditioning(
+    ctx: Context,
+    vin: str,
+    temperature: float,
+    unit: TemperatureUnit,
+    with_external_power: bool,
+) -> None:
+    """Start the air conditioning with the provided target temperature."""
+    client: OpenAPIClient = ctx.obj["client"]
+    await handle_request(
+        ctx,
+        client.start_air_conditioning,
+        vin,
+        temperature,
+        unit.value,
+        not with_external_power,
+    )
+
+
+@click.command()
+@click.argument("vin")
+@click.pass_context
+async def stop_air_conditioning(ctx: Context, vin: str) -> None:
+    """Stop the air conditioning for the specified VIN."""
+    client: OpenAPIClient = ctx.obj["client"]
+    await handle_request(ctx, client.stop_air_conditioning, vin)
+
+
+@click.command()
+@click.argument("vin")
+@click.option("spin", "--spin", required=True, help="SPIN of the vehicle.")
+@click.option(
+    "duration",
+    "--duration",
+    type=int,
+    default=120,
+    help="Duration of heating in seconds.",
+)
+@click.option(
+    "start_mode",
+    "--start-mode",
+    default="HEATING",
+    help="Start mode, HEATING or VENTILATION.",
+)
+@click.option(
+    "temperature",
+    "--temperature",
+    type=float,
+    required=False,
+    default=None,
+    help="Optional target temperature.",
+)
+@click.option(
+    "unit",
+    "--unit",
+    type=StrEnumChoice(TEMPERATURE_UNITS),
+    default=TemperatureUnit.CELSIUS,
+    help="Temperature unit, CELSIUS or FAHRENHEIT.",
+)
+@click.pass_context
+async def start_auxiliary_heating(
+    ctx: Context,
+    vin: str,
+    spin: str,
+    duration: int,
+    start_mode: str,
+    temperature: Optional[float],
+    unit: TemperatureUnit,
+) -> None:
+    """Start the auxiliary heating for the specified VIN."""
+    client: OpenAPIClient = ctx.obj["client"]
+    await handle_request(
+        ctx,
+        client.start_auxiliary_heating,
+        vin,
+        spin,
+        duration,
+        start_mode,
+        temperature,
+        unit.value,
+    )
+
+
+@click.command()
+@click.argument("vin")
+@click.pass_context
+async def stop_auxiliary_heating(ctx: Context, vin: str) -> None:
+    """Stop the auxiliary heating for the specified VIN."""
+    client: OpenAPIClient = ctx.obj["client"]
+    await handle_request(ctx, client.stop_auxiliary_heating, vin)
+
+
+@click.command()
+@click.argument("vin")
+@click.pass_context
+async def start_active_ventilation(ctx: Context, vin: str) -> None:
+    """Start the active ventilation for the specified VIN."""
+    client: OpenAPIClient = ctx.obj["client"]
+    await handle_request(ctx, client.start_active_ventilation, vin)
+
+
+@click.command()
+@click.argument("vin")
+@click.pass_context
+async def stop_active_ventilation(ctx: Context, vin: str) -> None:
+    """Stop the active ventilation for the specified VIN."""
+    client: OpenAPIClient = ctx.obj["client"]
+    await handle_request(ctx, client.stop_active_ventilation, vin)
+
+
+@click.command()
+@click.argument("vin")
+@click.pass_context
+async def start_charging(ctx: Context, vin: str) -> None:
+    """Start charging for the specified VIN."""
+    client: OpenAPIClient = ctx.obj["client"]
+    await handle_request(ctx, client.start_charging, vin)
+
+
+@click.command()
+@click.argument("vin")
+@click.pass_context
+async def stop_charging(ctx: Context, vin: str) -> None:
+    """Stop charging for the specified VIN."""
+    client: OpenAPIClient = ctx.obj["client"]
+    await handle_request(ctx, client.stop_charging, vin)

myvsb_developer_api-1.0.6/src/myskoda_openapi/cli/requests.py

@@ -0,0 +1,107 @@
+"""Commands dealing with reading data from the Rest API."""
+
+from typing import TYPE_CHECKING
+
+import asyncclick as click
+from asyncclick.core import Context
+
+from .utils import handle_request
+
+if TYPE_CHECKING:
+    from ..api_layer.open_api_client import OpenAPIClient
+
+
+@click.command()
+@click.argument("vin")
+@click.option(
+    "include",
+    "--include",
+    help="Optional field to include in the response. Can be specified multiple times.",
+    multiple=True,
+)
+@click.pass_context
+async def get_vehicle(ctx: Context, vin: str, include: tuple[str, ...]) -> None:
+    """Print info for the specified VIN."""
+    client: OpenAPIClient = ctx.obj["client"]
+    await handle_request(ctx, client.get_vehicle, vin, list(include) or None)
+
+
+@click.command()
+@click.argument("vin")
+@click.pass_context
+async def get_vehicle_status(ctx: Context, vin: str) -> None:
+    """Print the current status for the specified VIN."""
+    client: OpenAPIClient = ctx.obj["client"]
+    await handle_request(ctx, client.get_vehicle_status, vin)
+
+
+@click.command()
+@click.argument("vin")
+@click.pass_context
+async def get_air_conditioning(ctx: Context, vin: str) -> None:
+    """Print the current air conditioning status for the specified VIN."""
+    client: OpenAPIClient = ctx.obj["client"]
+    await handle_request(ctx, client.get_air_conditioning, vin)
+
+
+@click.command()
+@click.argument("vin")
+@click.pass_context
+async def get_parking_position(ctx: Context, vin: str) -> None:
+    """Print the current parking position for the specified VIN."""
+    client: OpenAPIClient = ctx.obj["client"]
+    await handle_request(ctx, client.get_parking_positions, vin)
+
+
+@click.command()
+@click.argument("vin")
+@click.pass_context
+async def get_auxiliary_heating(ctx: Context, vin: str) -> None:
+    """Print the current auxiliary heating status for the specified VIN."""
+    client: OpenAPIClient = ctx.obj["client"]
+    await handle_request(ctx, client.get_auxiliary_heating, vin)
+
+
+@click.command()
+@click.argument("vin")
+@click.pass_context
+async def get_odometer(ctx: Context, vin: str) -> None:
+    """Print the current odometer for the specified VIN."""
+    client: OpenAPIClient = ctx.obj["client"]
+    await handle_request(ctx, client.get_odometer, vin)
+
+
+@click.command()
+@click.argument("vin")
+@click.pass_context
+async def get_charging(ctx: Context, vin: str) -> None:
+    """Print the current charging status for the specified VIN."""
+    client: OpenAPIClient = ctx.obj["client"]
+    await handle_request(ctx, client.get_charging, vin)
+
+
+@click.command()
+@click.argument("vin")
+@click.pass_context
+async def get_active_ventilation(ctx: Context, vin: str) -> None:
+    """Print the current active ventilation status for the specified VIN."""
+    client: OpenAPIClient = ctx.obj["client"]
+    await handle_request(ctx, client.get_active_ventilation, vin)
+
+
+@click.command()
+@click.argument("vin")
+@click.pass_context
+async def get_charging_profiles(ctx: Context, vin: str) -> None:
+    """Print the charging profiles for the specified VIN."""
+    client: OpenAPIClient = ctx.obj["client"]
+    await handle_request(ctx, client.get_charging_profiles, vin)
+
+
+@click.command()
+@click.argument("vin")
+@click.pass_context
+async def get_fuel_status(ctx: Context, vin: str) -> None:
+    """Print the fuel status for the specified VIN."""
+    client: OpenAPIClient = ctx.obj["client"]
+    await handle_request(ctx, client.get_fuel_status, vin)

myvsb_developer_api-1.0.6/src/myskoda_openapi/cli/utils.py

@@ -0,0 +1,110 @@
+"""Utilities for the command line interface."""
+
+import json
+import logging
+import sys
+from collections.abc import Awaitable, Callable
+from enum import Enum, StrEnum
+from types import SimpleNamespace
+from typing import Any
+
+import asyncclick as click
+import yaml
+from aiohttp import ClientSession, TraceConfig
+from aiohttp.tracing import TraceRequestEndParams
+from asyncclick.core import Context
+from pydantic import BaseModel, ValidationError
+from pygments import highlight
+from pygments.formatters import TerminalFormatter
+from pygments.lexer import Lexer
+from pygments.lexers import JsonLexer, YamlLexer
+
+from ..api_layer.exceptions import OpenApiError
+from ..api_layer.rest_api import PostEndpointResult
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class Format(StrEnum):
+    JSON = "json"
+    YAML = "yaml"
+
+
+class StrEnumChoice(click.Choice):
+    """Choice that maps enum values (not names) from the command line to enum members."""
+
+    def normalize_choice(self, choice: object, ctx: Context | None) -> str:
+        if isinstance(choice, Enum):
+            return str(choice.value)
+        return super().normalize_choice(choice, ctx)
+
+
+async def handle_request(
+    ctx: Context,
+    func: Callable[..., Awaitable],
+    *args: Any,
+) -> None:
+    """Handle API requests and perform error handling."""
+    try:
+        result = await func(*args)
+        if isinstance(result, BaseModel):
+            ctx.obj["print"](result.model_dump(mode="json", by_alias=True))
+        elif isinstance(result, PostEndpointResult):
+            ctx.obj["print"](
+                {
+                    "url": result.url,
+                    "status": result.status,
+                    "headers": result.headers,
+                }
+            )
+        elif result is None:
+            ctx.obj["print"]({"status": "ok"})
+        else:
+            ctx.obj["print"](result)
+    except (OpenApiError, ValidationError) as err:
+        status_code = err.status_code if isinstance(err, OpenApiError) else None
+        ctx.obj["print"](
+            {
+                "error": type(err).__name__,
+                "message": str(err),
+                "status_code": status_code,
+            }
+        )
+
+
+def highlight_for_console(text: str, lexer: Lexer) -> str:
+    if sys.stdout.isatty():
+        return highlight(text, lexer, TerminalFormatter())
+    return text
+
+
+def print_json(data: Any) -> None:
+    print(highlight_for_console(json.dumps(data, indent=4, ensure_ascii=False), JsonLexer()))
+
+
+def print_yaml(data: Any) -> None:
+    print(highlight_for_console(yaml.dump(data, allow_unicode=True), YamlLexer()))
+
+
+async def trace_response(
+    _session: ClientSession,
+    _trace_config_ctx: SimpleNamespace,
+    params: TraceRequestEndParams,
+) -> None:
+    """Log response details. Used in aiohttp.TraceConfig."""
+    try:
+        resp_text = await params.response.text()
+    except UnicodeDecodeError:
+        resp_text = "<non-UTF-8 response body>"
+    _LOGGER.debug(
+        "Trace: %s %s - response: %s (%s bytes) %s",
+        params.method,
+        str(params.url)[:60],
+        params.response.status,
+        params.response.content_length,
+        resp_text[:5000],
+    )
+
+
+TRACE_CONFIG = TraceConfig()
+TRACE_CONFIG.on_request_end.append(trace_response)

{myvsb_developer_api-1.0.4 → myvsb_developer_api-1.0.6}/src/myskoda_openapi/models/charging_profiles.py

@@ -35,7 +35,7 @@ class ChargingProfile(BaseModel):
     id: int
     name: str
     settings: ChargingProfileSettings
-    preferredChargingTimes: List[ChargingTime]
+    preferred_charging_times: List[ChargingTime]
     timers: List[Timer]
 
 

{myvsb_developer_api-1.0.4 → myvsb_developer_api-1.0.6}/src/myskoda_openapi/models/configurations.py

@@ -6,9 +6,6 @@ class ConfigurationTargetTemperature(BaseModel):
     temperature_value: float = Field(..., alias="temperatureValue")
     unit_in_car: str = Field("CELSIUS", alias="unitInCar")
 
-    class Config:
-        populate_by_name = True
-
 
 class StartAirConditioningConfiguration(BaseModel):
     """Configuration for starting air conditioning."""
@@ -19,16 +16,10 @@ class StartAirConditioningConfiguration(BaseModel):
         True, alias="airConditioningWithoutExternalPower"
     )
 
-    class Config:
-        populate_by_name = True
-
 
 class StartAuxiliaryHeatingConfiguration(BaseModel):
     """Configuration for starting auxiliary heating."""
     spin: str = Field(..., alias="spin")
     duration_in_seconds: Optional[int] = Field(120, alias="durationInSeconds")
     start_mode: Optional[str] = Field("HEATING", alias="startMode")
-    target_temperature: Optional[ConfigurationTargetTemperature] = Field(None, alias="targetTemperature")
-
-    class Config:
-        populate_by_name = True
+    target_temperature: Optional[ConfigurationTargetTemperature] = Field(None, alias="targetTemperature")

{myvsb_developer_api-1.0.4 → myvsb_developer_api-1.0.6}/src/myskoda_openapi/models/enums.py

@@ -102,6 +102,9 @@ class VehicleErrorState(str, Enum):
     DRIVING_RANGE_UNSUPPORTED = "DRIVING_RANGE_UNSUPPORTED"
     DRIVING_RANGE_DISABLED = "DRIVING_RANGE_DISABLED"
     DRIVING_RANGE_UNAVAILABLE = "DRIVING_RANGE_UNAVAILABLE"
+    FUEL_STATUS_UNSUPPORTED = "FUEL_STATUS_UNSUPPORTED"
+    FUEL_STATUS_DISABLED = "FUEL_STATUS_DISABLED"
+    FUEL_STATUS_UNAVAILABLE = "FUEL_STATUS_UNAVAILABLE"
     ODOMETER_UNSUPPORTED = "ODOMETER_UNSUPPORTED"
     ODOMETER_DISABLED = "ODOMETER_DISABLED"
     ODOMETER_UNAVAILABLE = "ODOMETER_UNAVAILABLE"

myvsb_developer_api-1.0.6/src/myvsb_developer_api.egg-info/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: myvsb-developer-api
+Version: 1.0.6
+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"
+Provides-Extra: cli
+Requires-Dist: asyncclick~=8.1; extra == "cli"
+Requires-Dist: coloredlogs~=15.0; extra == "cli"
+Requires-Dist: pygments~=2.18; extra == "cli"
+Requires-Dist: pyyaml~=6.0; extra == "cli"
+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.
+
+## As CLI
+
+The library ships with a command line interface called `skodactl`, which is useful for manually
+testing the API endpoints. Install it together with the CLI dependencies:
+
+```sh
+pip install "myvsb-developer-api[cli]"
+```
+
+You authenticate with your API key, either via the `--api-key` option or the `SKODA_API_KEY`
+environment variable, and address a vehicle by its VIN:
+
+```sh
+skodactl --api-key XXX get-vehicle DMBGF9NY3NF032963
+```
+
+By default, the CLI talks to the production endpoint. Point it at the public test endpoint with
+`--endpoint test`, switch to YAML output with `--format yaml`, or log HTTP requests and responses
+with `--trace`:
+
+```sh
+skodactl --api-key XXX --endpoint test get-vehicle-status DMBGF9NY3NF032963
+SKODA_API_KEY=XXX skodactl --format yaml --trace get-charging DMBGF9NY3NF032963
+```
+
+Remote operations can be started as well:
+
+```sh
+skodactl --api-key XXX start-air-conditioning DMBGF9NY3NF032963 --temperature 21
+```
+
+Run `skodactl --help` for the full list of commands and options.

{myvsb_developer_api-1.0.4 → myvsb_developer_api-1.0.6}/src/myvsb_developer_api.egg-info/SOURCES.txt

@@ -6,6 +6,11 @@ src/myskoda_openapi/api_layer/exceptions.py
 src/myskoda_openapi/api_layer/open_api_client.py
 src/myskoda_openapi/api_layer/rest_api.py
 src/myskoda_openapi/api_layer/utils.py
+src/myskoda_openapi/cli/__init__.py
+src/myskoda_openapi/cli/__main__.py
+src/myskoda_openapi/cli/operations.py
+src/myskoda_openapi/cli/requests.py
+src/myskoda_openapi/cli/utils.py
 src/myskoda_openapi/models/active_ventilation.py
 src/myskoda_openapi/models/air_conditioning.py
 src/myskoda_openapi/models/auxiliary_heating.py
@@ -22,5 +27,6 @@ src/myskoda_openapi/models/vehicle_status.py
 src/myvsb_developer_api.egg-info/PKG-INFO
 src/myvsb_developer_api.egg-info/SOURCES.txt
 src/myvsb_developer_api.egg-info/dependency_links.txt
+src/myvsb_developer_api.egg-info/entry_points.txt
 src/myvsb_developer_api.egg-info/requires.txt
 src/myvsb_developer_api.egg-info/top_level.txt

myvsb_developer_api-1.0.6/src/myvsb_developer_api.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+skodactl = myskoda_openapi.cli:cli

{myvsb_developer_api-1.0.4 → myvsb_developer_api-1.0.6}/src/myvsb_developer_api.egg-info/requires.txt

@@ -1,6 +1,12 @@
 aiohttp>=3.9.0
 pydantic>=2.5.0
 
+[cli]
+asyncclick~=8.1
+coloredlogs~=15.0
+pygments~=2.18
+pyyaml~=6.0
+
 [test]
 pytest>=9.0.0
 pytest-asyncio>=0.23.0

myvsb_developer_api-1.0.4/PKG-INFO

@@ -1,24 +0,0 @@
-Metadata-Version: 2.4
-Name: myvsb-developer-api
-Version: 1.0.4
-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-1.0.4/README.md

@@ -1,2 +0,0 @@
-# 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-1.0.4/src/myskoda_openapi/api_layer/const.py

@@ -1,4 +0,0 @@
-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"
-BETA_URL = "https://public.api.connect.skoda-auto.cz"

myvsb_developer_api-1.0.4/src/myvsb_developer_api.egg-info/PKG-INFO

@@ -1,24 +0,0 @@
-Metadata-Version: 2.4
-Name: myvsb-developer-api
-Version: 1.0.4
-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.