toml-test-decoder

#!/usr/bin/env python3

# SPDX-FileCopyrightText: 2024 Pablo Martinez Bernal (elpekenin)
#
# SPDX-License-Identifier: MIT

"""Utility used for testing against the TOML specification suite (toml-test)."""

# NOTE: We have a CLI-like interface and we dont care about PyLint preference for naming
# pylint: disable=invalid-name

from __future__ import annotations

import json
import sys
import warnings
from pathlib import Path
from typing import TypeAlias, TypedDict, TypeVar

K = TypeVar("K")
V = TypeVar("V")
TaggedVal: TypeAlias = (
    "Tagged | list[Tagged] | dict[K, Tagged] | list[TaggedVal] | dict[K, TaggedVal]"
)

# this prints to stdout, which breaks toml-test
warnings.filterwarnings(action="ignore")

THIS = Path(__file__).parent
sys.path.insert(0, str(THIS))

# NOTE: We have to hack sys.path so that the library gets found when toml-test runs from
# anywhere, because of that we can't have this import at the very top of the file
import toml  # noqa: E402


class Tagged(TypedDict):
    """A tagged value is type+value (in strings)."""

    type: str
    value: str


def type_name(val: object) -> str:
    """Convert Python's types into string, with a couple special cases."""
    type_ = type(val)
    return {
        int: "integer",
        str: "string",
    }.get(type_, type_.__name__)


def val_repr(val: object) -> str:
    """Convert values to strings."""
    # not needed?
    if isinstance(val, str):
        return val

    return str(val)


def add_type(val: object) -> Tagged:
    """Represent the type and value of a variable in a string."""
    return {
        "type": type_name(val),
        "value": val_repr(val),
    }


def add_types_dict(data: dict[K, V]) -> dict[K, TaggedVal]:
    """Tag values in a dict, not the dict itself nor the keys."""
    return {key: add_types(val) for key, val in data.items()}


def add_types_list(data: list[V]) -> list[TaggedVal]:
    """List themselves do not be tagged, their values do."""
    return [add_types(val) for val in data]


def add_types(data: object) -> TaggedVal:
    """Add type tag to any kind of value."""
    if isinstance(data, dict):
        return add_types_dict(data)

    if isinstance(data, list):
        return add_types_list(data)

    return add_type(data)


def main() -> int:
    """Entrypoint of the test suite.

    Read from stdin and try to parse it.

    On success, write type-tagged structure on stdout + exit(0)
    On fail, optionally write to stderr + exit(1)
    """
    try:
        parsed = toml.load(sys.stdin)
    except toml.TOMLError as exception:
        sys.stderr.write(str(exception))
        sys.stderr.write("\n")
        return 1

    typed = add_types_dict(parsed.data)
    json.dump(typed, sys.stdout)
    sys.stdout.write("\n")
    return 0


if __name__ == "__main__":
    sys.exit(main())