Support string annotations

Fixes #45

Signed-off-by: David Euresti <david@pilot.com>

conftest.py

@@ -0,0 +1,5 @@
+import sys
+
+
+def pytest_ignore_collect(path):
+    return sys.version_info[0] <= 2 and str(path).endswith("__py3.py")

src/attrs_strict/_type_validation.py

@@ -1,6 +1,8 @@
 import collections
 import typing
 
+import attr
+
 from ._commons import is_newtype
 from ._error import (
     AttributeTypeError,
@@ -28,6 +30,15 @@
     # silencing type error so mypy doesn't complain about duplicate import
     from itertools import izip_longest as zip_longest  # type: ignore
 
+try:
+    from typing import ForwardRef  # type: ignore # Not in stubs
+except ImportError:
+    from typing import _ForwardRef as ForwardRef  # type: ignore # Not in stubs
+
+
+class _StringAnnotationError(Exception):
+    """Raised when we find string annotations in a class."""
+
 
 class SimilarTypes:
     Dict = {
@@ -46,6 +57,26 @@ class SimilarTypes:
     Callable = {typing.Callable, Callable}
 
 
+def resolve_types(cls, global_ns=None, local_ns=None):
+    """
+    Resolve any strings and forward annotations in type annotations.
+
+    :param type cls: Class to resolve.
+    :param globalns: Dictionary containing global variables, if needed.
+    :param localns: Dictionary containing local variables, if needed.
+    :raise TypeError: If *cls* is not a class.
+    :raise attr.exceptions.NotAnAttrsClassError: If *cls* is not an ``attrs``
+           class.
+    :raise NameError: If types cannot be resolved because of missing variables.
+
+    """
+    hints = typing.get_type_hints(cls, globalns=global_ns, localns=local_ns)
+    for field in attr.fields(cls):
+        if field.name in hints:
+            # Since fields have been frozen we must work around it.
+            object.__setattr__(field, "type", hints[field.name])
+
+
 def type_validator(empty_ok=True):
     """
     Validates the attributes using the type argument specified. If the
@@ -60,7 +91,11 @@ def _validator(instance, attribute, field):
         if not empty_ok and not field:
             raise EmptyError(field, attribute)
 
-        _validate_elements(attribute, field, attribute.type)
+        try:
+            _validate_elements(attribute, field, attribute.type)
+        except _StringAnnotationError:
+            resolve_types(type(instance))
+            _validate_elements(attribute, field, attribute.type)
 
     return _validator
 
@@ -74,6 +109,11 @@ def _validate_elements(attribute, value, expected_type):
     if base_type == typing.Any:
         return
 
+    if isinstance(base_type, (str, ForwardRef)):
+        # These base_types happen when you have string annotations and cannot
+        # be used in isinstance.
+        raise _StringAnnotationError()
+
     if base_type != typing.Union and not isinstance(  # type: ignore
         value, base_type
     ):

src/attrs_strict/_type_validation.pyi

@@ -1,6 +1,11 @@
 import typing
 import attr
 
+def resolve_types(
+    cls: type,
+    global_ns: typing.Optional[typing.Dict[str, typing.Any]] = None,
+    local_ns: typing.Optional[typing.Dict[str, typing.Any]] = None,
+) -> None: ...
 def type_validator(
     empty_ok: bool = True,
 ) -> typing.Callable[

tests/test_auto_attribs__py3.py

@@ -0,0 +1,54 @@
+from typing import Optional
+
+import attr
+import pytest
+
+from attrs_strict import type_validator
+
+
+@pytest.mark.parametrize(
+    "type_, good_value, bad_value",
+    [(str, "str", 0xBAD), (int, 7, "bad"), (Optional[str], None, 0xBAD)],
+)
+def test_real_types(type_, good_value, bad_value):
+    @attr.s(auto_attribs=True)
+    class Something:
+        value: type_ = attr.ib(validator=type_validator())
+
+    with pytest.raises(ValueError):
+        Something(bad_value)
+
+    x = Something(good_value)
+    with pytest.raises(ValueError):
+        x.value = bad_value
+        attr.validate(x)
+
+
+@attr.s(auto_attribs=True)
+class Child:
+    parent: "Parent" = attr.ib(validator=type_validator())
+
+
+@attr.s(auto_attribs=True)
+class Parent:
+    pass
+
+
+def test_forward_ref():
+    Child(Parent())
+
+    with pytest.raises(ValueError):
+        Child(15)
+
+
+@attr.s(auto_attribs=True)
+class Self:
+    parent: Optional["Self"] = attr.ib(None, validator=type_validator())
+
+
+def test_recursive():
+    Self(Self())
+    Self(Self(None))
+
+    with pytest.raises(ValueError):
+        Self(Self(17))

tox.ini

@@ -31,6 +31,7 @@ commands = pytest \
            --cov-config "{toxinidir}/tox.ini" \
            --junitxml {toxworkdir}/junit.{envname}.xml \
            {posargs:tests}
+rsyncdirs = conftest.py
 
 [testenv:type]
 description = try to merge our types against our source