validating 0.0.3__tar.gz → 0.0.5__tar.gz

{validating-0.0.3 → validating-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: validating
-Version: 0.0.3
+Version: 0.0.5
 Summary: Provides a lightweight `attr()` descriptor factory that adds runtime validation to dataclass fields.
 Project-URL: Documentation, https://github.com/Chitaoji/validating/blob/main/README.md
 Project-URL: Repository, https://github.com/Chitaoji/validating/
@@ -181,6 +181,12 @@ class EvenNumber:
 This project falls under the BSD 3-Clause License.
 
 ## History
+### v0.0.5
+* Added `typing.dataclass_transform` metadata to `validating.dataclass` (with `attr` and `dataclasses.Field` specifiers) to improve IDE/static-analysis support, including better Pylance hints.
+
+### v0.0.4
+* Updated error messages when validating typed dicts.
+
 ### v0.0.3
 * Improved support for `PEP 585` generics with quoted builtin annotations (for example `list["int"]`) to ensure consistent runtime type validation.
 

{validating-0.0.3 → validating-0.0.5}/README.md

@@ -165,6 +165,12 @@ class EvenNumber:
 This project falls under the BSD 3-Clause License.
 
 ## History
+### v0.0.5
+* Added `typing.dataclass_transform` metadata to `validating.dataclass` (with `attr` and `dataclasses.Field` specifiers) to improve IDE/static-analysis support, including better Pylance hints.
+
+### v0.0.4
+* Updated error messages when validating typed dicts.
+
 ### v0.0.3
 * Improved support for `PEP 585` generics with quoted builtin annotations (for example `list["int"]`) to ensure consistent runtime type validation.
 

{validating-0.0.3 → validating-0.0.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "validating"
-version = "0.0.3"
+version = "0.0.5"
 dependencies = []
 requires-python = ">=3.13"
 authors = [

{validating-0.0.3 → validating-0.0.5}/src/validating/datacls.py

@@ -10,7 +10,7 @@ from dataclasses import Field
 from dataclasses import dataclass as _stdlib_dataclass
 from functools import partial
 from inspect import signature
-from typing import Any, Callable, overload
+from typing import Any, Callable, dataclass_transform, overload
 
 from .valid_attr import AttrValidator, attr
 from .valid_func import validate
@@ -52,6 +52,7 @@ def dataclass[T](
     weakref_slot: bool = False,
     validate_methods: bool = False,
 ) -> Callable[[type[T]], type[T]]: ...
+@dataclass_transform(field_specifiers=(attr, Field))
 def dataclass(
     cls: type | None = None,
     /,

{validating-0.0.3 → validating-0.0.5}/src/validating/valid_attr.py

@@ -7,8 +7,8 @@ NOTE: this module is private. All functions and objects are available in the mai
 
 """
 
-import sys
 import builtins
+import sys
 from ast import (
     Attribute,
     If,
@@ -43,6 +43,7 @@ except ImportError:  # pragma: no cover - Python < 3.11
 try:  # pragma: no cover - available on modern Python versions
     from typing import is_typeddict
 except ImportError:  # pragma: no cover - compatibility fallback
+
     def is_typeddict(type_hint: Any) -> bool:
         return bool(
             isinstance(type_hint, type)
@@ -51,6 +52,7 @@ except ImportError:  # pragma: no cover - compatibility fallback
             and hasattr(type_hint, "__optional_keys__")
         )
 
+
 __all__ = ["attr"]
 
 
@@ -686,7 +688,11 @@ class _TypeCheckingImportCollector(NodeVisitor):
         if isinstance(test, Name):
             return test.id == "TYPE_CHECKING"
         if isinstance(test, Attribute):
-            return isinstance(test.value, Name) and test.value.id == "typing" and test.attr == "TYPE_CHECKING"
+            return (
+                isinstance(test.value, Name)
+                and test.value.id == "typing"
+                and test.attr == "TYPE_CHECKING"
+            )
         return False
 
     def _consume_type_checking_stmt(self, stmt: Any) -> None:
@@ -774,7 +780,7 @@ def isoftype(
                 return None
         except TypeError:
             pass
-        return _format_isoftype_error(
+        return _format_expected_error(
             path, f"{type_hint!r}, got {type(value)!r} instead"
         )
 
@@ -782,7 +788,7 @@ def isoftype(
         union_errors = [isoftype(value, arg, name, path) for arg in args]
         if any(error is None for error in union_errors):
             return None
-        return _format_isoftype_error(
+        return _format_expected_error(
             path,
             f"one of {args}, got {value.__class__!r} instead",
         )
@@ -790,7 +796,7 @@ def isoftype(
     if origin is Literal:
         if value in args:
             return None
-        return _format_isoftype_error(path, f"one of {args!r}, got {value!r} instead")
+        return _format_expected_error(path, f"one of {args!r}, got {value!r} instead")
 
     if origin is Unpack:
         (unpacked_type,) = args
@@ -799,7 +805,7 @@ def isoftype(
     if origin is list:
         (elem_type,) = args
         if not isinstance(value, list):
-            return _format_isoftype_error(path, f"a list, got {type(value)!r} instead")
+            return _format_expected_error(path, f"a list, got {type(value)!r} instead")
         for idx, elem in enumerate(value):
             elem_error = isoftype(elem, elem_type, name, f"{name}[{idx}]")
             if elem_error is not None:
@@ -810,7 +816,7 @@ def isoftype(
         if len(args) == 2 and args[1] is ...:
             (elem_type, _) = args
             if not isinstance(value, tuple):
-                return _format_isoftype_error(
+                return _format_expected_error(
                     path, f"a tuple, got {type(value)!r} instead"
                 )
             for idx, elem in enumerate(value):
@@ -820,7 +826,7 @@ def isoftype(
             return None
 
         if not isinstance(value, tuple) or len(value) != len(args):
-            return _format_isoftype_error(
+            return _format_expected_error(
                 path,
                 f"a tuple with {len(args)} elements, got {type(value)!r} with "
                 f"length {len(value) if isinstance(value, tuple) else 'N/A'} instead",
@@ -834,7 +840,7 @@ def isoftype(
     if origin is dict:
         key_t, val_t = args
         if not isinstance(value, dict):
-            return _format_isoftype_error(path, f"a dict, got {type(value)!r} instead")
+            return _format_expected_error(path, f"a dict, got {type(value)!r} instead")
         for key, val in value.items():
             key_error = isoftype(key, key_t, name, f"{name}.keys() element {key!r}")
             if key_error is not None:
@@ -847,7 +853,7 @@ def isoftype(
     if origin is set:
         (elem_type,) = args
         if not isinstance(value, set):
-            return _format_isoftype_error(path, f"a set, got {type(value)!r} instead")
+            return _format_expected_error(path, f"a set, got {type(value)!r} instead")
         for elem in value:
             elem_path = f"{path} element {elem!r}" if path else f"element {elem!r}"
             elem_error = isoftype(elem, elem_type, name, elem_path)
@@ -858,12 +864,18 @@ def isoftype(
     raise NotImplementedError(f"Unsupported type hint: {type_hint}")
 
 
-def _format_isoftype_error(path: str, detail: str) -> str:
+def _format_expected_error(path: str, detail: str) -> str:
     if path:
         return f"{path} expected {detail}"
     return f"expected {detail}"
 
 
+def _format_error(path: str, detail: str) -> str:
+    if path:
+        return f"{path} {detail}"
+    return detail
+
+
 def _validate_typed_dict(
     value: object,
     type_hint: Any,
@@ -871,7 +883,7 @@ def _validate_typed_dict(
     path: str,
 ) -> Optional[str]:
     if not isinstance(value, dict):
-        return _format_isoftype_error(path, f"a dict, got {type(value)!r} instead")
+        return _format_expected_error(path, f"a dict, got {type(value)!r} instead")
 
     annotations = getattr(type_hint, "__annotations__", {})
     required_keys = set(getattr(type_hint, "__required_keys__", set()))
@@ -881,12 +893,12 @@ def _validate_typed_dict(
     missing = sorted(required_keys - set(value))
     if missing:
         keys = ", ".join(repr(k) for k in missing)
-        return _format_isoftype_error(path, f"missing required keys: {keys}")
+        return _format_error(path, f"missing required keys: {keys}")
 
     extra = sorted(set(value) - allowed_keys)
     if extra:
         keys = ", ".join(repr(k) for k in extra)
-        return _format_isoftype_error(path, f"unexpected keys: {keys}")
+        return _format_error(path, f"got unexpected keys: {keys}")
 
     for key, annotated in annotations.items():
         if key not in value:

{validating-0.0.3 → validating-0.0.5}/test.py

@@ -22,6 +22,12 @@ from src.validating import (
 
 
 class TestAttrWithDataclasses(unittest.TestCase):
+    def test_validating_dataclass_exposes_dataclass_transform_metadata(self):
+        metadata = getattr(validating_dataclass, "__dataclass_transform__", None)
+        self.assertIsNotNone(metadata)
+        self.assertIn("field_specifiers", metadata)
+        self.assertIn(attr, metadata["field_specifiers"])
+
     def test_validating_dataclass_can_validate_public_methods(self):
         @validating_dataclass(validate_methods=True)
         class Config: