Automatically detect the true Python type of a string and cast it

autocast.py

"""
Automatically detect the true Python type of a string and cast it to the correct type.

Based on https://github.com/cgreer/cgAutoCast/blob/master/cgAutoCast.py
"""

import contextlib
from typing import Any


def boolify(s: str) -> bool:
    """Convert a string to a boolean."""
    if s in {"True", "true"}:
        return True
    if s in {"False", "false"}:
        return False
    raise ValueError("Not Boolean Value!")


def noneify(s: str) -> None:
    """Convert a string to None."""
    if s == "None":
        return None
    raise ValueError("Not None Value!")


def listify(s: str) -> list:
    """
    Convert a string representation of a list into list of homogenous basic types.

    Type of elements in list is determined via first element. Successive elements are
    cast to that type.

    Args:
        s: String representation of a list.

    Raises:
        ValueError: If string does not represent a list.
        TypeError: If string does not represent a list of homogenous basic types.

    Returns:
        List of homogenous basic types.
    """
    if "," not in s:
        raise ValueError("Not a List")

    # derive the type of the variable
    str_list = s.split(",")
    element_caster = str
    for caster in (boolify, int, float, noneify, element_caster):
        with contextlib.suppress(ValueError):
            caster(str_list[0])  # type: ignore[operator]
            element_caster = caster  # type: ignore[assignment]
            break
    # cast all elements
    try:
        return [element_caster(x) for x in str_list]
    except ValueError as e:
        raise TypeError("Autocasted list must be all same type") from e


def autocast_value(var: Any) -> Any:
    """
    Guess the string representation of the variable's type.

    Args:
        var: Value to autocast.

    Returns:
        The autocasted value.
    """
    if not isinstance(var, str):  # don't need to guess non-string types
        return var

    # guess string representation of var
    for caster in (boolify, int, float, noneify, listify):
        with contextlib.suppress(ValueError):
            return caster(var)  # type: ignore[operator]

    return var

test_autocast.py

"""Tests for the autocast module."""
import pytest
from pytest import param

from archeion import autocast


@pytest.mark.parametrize(
    "value, expected",
    [
        param("true", True, id="true"),
        param("false", False, id="false"),
        param("True", True, id="True"),
        param("False", False, id="False"),
    ],
)
def test_boolify_valid(value: str, expected: bool) -> None:
    """Test the boolify function."""
    assert autocast.boolify(value) == expected


@pytest.mark.parametrize(
    "value",
    [
        param(1, id="int"),
        param("string", id="str"),
    ],
)
def test_boolify_invalid(value):
    """Test the boolify function."""
    with pytest.raises(ValueError):
        autocast.boolify(value)


def test_noneify():
    """noneify should return None if the string is None."""
    assert autocast.noneify("None") is None
    with pytest.raises(ValueError):
        autocast.noneify("0")


@pytest.mark.parametrize(
    "value,expected",
    [
        param("1,2,3,4", [1, 2, 3, 4], id="int"),
        param("s,t,r", ["s", "t", "r"], id="str"),
        param("1.1,2,3.14", [1.1, 2.0, 3.14], id="float"),
        param("True,False,true,false", [True, False, True, False], id="bool"),
        param("None,None,None", [None, None, None], id="none"),
    ],
)
def test_listify_valid(value, expected):
    """Test the listify function."""
    assert autocast.listify(value) == expected


def test_listify_invalid():
    """Every element of the list should be the same type."""
    with pytest.raises(TypeError):
        autocast.listify("True,1,None")

    with pytest.raises(ValueError):
        autocast.listify("I am not a list")


@pytest.mark.parametrize(
    "value,expected",
    [
        param("true", True, id="true"),
        param("false", False, id="false"),
        param("True", True, id="True"),
        param("False", False, id="False"),
        param("1,2,3,4", [1, 2, 3, 4], id="int-list"),
        param("s,t,r", ["s", "t", "r"], id="str-list"),
        param("1", 1, id="int"),
        param("1.0", 1.0, id="float"),
        param(1, 1, id="real-int"),
    ],
)
def test_autocast_value(value, expected):
    """Test basic functionality of autocast_value."""
    assert autocast.autocast_value(value) == expected