Merge pull request #10 from PinnLabs/5-improve-type-casting

Improve type casting

Author: castroofelipee

.gitignore

@@ -206,4 +206,4 @@ marimo/_static/
 marimo/_lsp/
 __marimo__/
 
-DS_Store
+.DS_Store

src/venvalid/utils.py

@@ -2,27 +2,70 @@
 from datetime import datetime
 from decimal import Decimal
 from pathlib import Path
+from typing import Any, Optional, Type
 
 
-def _cast(value: str, expected_type: type) -> object:
+def _cast(
+    value: str, expected_type: Type, *, datetime_format: Optional[str] = None
+) -> Any:
     v = value.strip()
 
     if expected_type is bool:
-        return v.lower() in ("1", "true", "yes", "on")
+        truthy = {"1", "true", "yes", "on"}
+        falsy = {"0", "false", "no", "off"}
+        val_lower = v.lower()
+        if val_lower in truthy:
+            return True
+        elif val_lower in falsy:
+            return False
+        else:
+            raise ValueError(f"Invalid boolean value: {v}")
+
     if expected_type is list:
+        if not v:
+            return []
+        if v.startswith("[") and v.endswith("]"):
+            try:
+                parsed = json.loads(v)
+                if not isinstance(parsed, list):
+                    raise ValueError(f"Expected list, got {type(parsed).__name__}")
+                return parsed
+            except json.JSONDecodeError as e:
+                raise ValueError(f"Invalid JSON for list: {v}") from e
         return [item.strip() for item in v.split(",")]
-    if expected_type is dict:
+
+    if expected_type in (dict, list):
         try:
-            return json.loads(v)
+            parsed = json.loads(v)
+            if not isinstance(parsed, expected_type):
+                raise ValueError(
+                    f"Expected {expected_type.__name__}, got {type(parsed).__name__}"
+                )
+            return parsed
         except json.JSONDecodeError as e:
-            raise ValueError(f"Invalid JSON for dict: {v}") from e
+            raise ValueError(f"Invalid JSON for {expected_type.__name__}: {v}") from e
+
     if expected_type is Path:
         return Path(v)
+
     if expected_type is Decimal:
-        return Decimal(v)
+        try:
+            return Decimal(v)
+        except Exception as e:
+            raise ValueError(f"Invalid Decimal value: {v}") from e
+
     if expected_type is datetime:
         try:
             return datetime.fromisoformat(v)
-        except ValueError as e:
-            raise ValueError(f"Invalid ISO datetime: {v}") from e
-    return expected_type(v)
+        except ValueError:
+            if datetime_format:
+                try:
+                    return datetime.strptime(v, datetime_format)
+                except ValueError as e:
+                    raise ValueError(f"Invalid datetime format: {v}") from e
+            raise ValueError(f"Invalid ISO datetime: {v}")
+
+    try:
+        return expected_type(v)
+    except Exception as e:
+        raise ValueError(f"Cannot cast '{v}' to {expected_type.__name__}") from e

tests/test_utils.py

@@ -16,23 +16,28 @@
         ("yes", True),
         ("on", True),
         ("false", False),
+        ("False", False),
         ("0", False),
         ("no", False),
         ("off", False),
-        ("", False),
-        ("maybe", False),  # unexpected value
     ],
 )
-def test_cast_bool(val, expected):
+def test_cast_bool_valid(val, expected):
     assert _cast(val, bool) == expected
 
 
+@pytest.mark.parametrize("val", ["", "maybe", "truth", "none"])
+def test_cast_bool_invalid(val):
+    with pytest.raises(ValueError):
+        _cast(val, bool)
+
+
 def test_cast_list_normal():
     assert _cast("a,b , c", list) == ["a", "b", "c"]
 
 
 def test_cast_list_empty():
-    assert _cast("", list) == [""]
+    assert _cast("", list) == []
 
 
 def test_cast_path():
@@ -45,14 +50,20 @@ def test_cast_decimal_valid():
 
 
 def test_cast_decimal_invalid():
-    with pytest.raises(Exception):
+    with pytest.raises(ValueError):
         _cast("abc", Decimal)
 
 
-def test_cast_datetime_valid():
+def test_cast_datetime_valid_iso():
     assert _cast("2024-01-01T10:00:00", datetime) == datetime(2024, 1, 1, 10, 0, 0)
 
 
+def test_cast_datetime_valid_custom_format():
+    val = "01-02-2025 15:30"
+    fmt = "%d-%m-%Y %H:%M"
+    assert _cast(val, datetime, datetime_format=fmt) == datetime(2025, 2, 1, 15, 30)
+
+
 def test_cast_datetime_invalid():
     with pytest.raises(ValueError):
         _cast("not-a-date", datetime)
@@ -62,7 +73,11 @@ def test_cast_dict_valid():
     assert _cast('{"debug": true, "port": 8000}', dict) == {"debug": True, "port": 8000}
 
 
-def test_cast_dict_invalid():
+def test_cast_list_json_valid():
+    assert _cast('["a", "b", "c"]', list) == ["a", "b", "c"]
+
+
+def test_cast_dict_invalid_json():
     with pytest.raises(ValueError):
         _cast("{not: valid}", dict)
 
@@ -89,11 +104,11 @@ def test_cast_float_valid():
 
 
 class Dummy:
-    pass
+    def __init__(self, v):
+        raise TypeError("Cannot instantiate Dummy with value")
 
 
 def test_cast_unknown_type():
     val = "123"
-    dummy_type = Dummy
-    with pytest.raises(TypeError):
-        _cast(val, dummy_type)
+    with pytest.raises(ValueError):
+        _cast(val, Dummy)