Fix miscellaneous issues

Dockerfile

@@ -4,4 +4,4 @@ RUN python3 -m pip install --upgrade pip
 COPY dist/*.whl dist/
 RUN python3 -m pip install `ls -1 dist/*.whl`
 COPY tests/*.py tests/
-RUN cd tests && python3 -m unittest
+RUN python3 -m unittest discover

MANIFEST.in

@@ -0,0 +1 @@
+recursive-include tests *.py

mypy.ini

@@ -0,0 +1,9 @@
+[mypy]
+check_untyped_defs = True
+disallow_untyped_calls = True
+disallow_untyped_decorators = True
+disallow_untyped_defs = True
+ignore_missing_imports = True
+show_column_numbers = True
+warn_redundant_casts = True
+warn_unused_ignores = True

strong_typing/auxiliary.py

@@ -58,7 +58,7 @@ def typeannotation(
     ...
 
 
-@dataclass_transform()
+@dataclass_transform(eq_default=True, order_default=False)
 def typeannotation(
     cls: Optional[Type[T]] = None, *, eq: bool = True, order: bool = False
 ) -> Union[Type[T], Callable[[Type[T]], Type[T]]]:
@@ -88,31 +88,27 @@ def wrap(cls: Type[T]) -> Type[T]:
 
 
 @typeannotation
-@dataclass(frozen=True)
 class Alias:
     "Alternative name of a property, typically used in JSON serialization."
 
     name: str
 
 
 @typeannotation
-@dataclass(frozen=True)
 class Signed:
     "Signedness of an integer type."
 
     is_signed: bool
 
 
 @typeannotation
-@dataclass(frozen=True)
 class Storage:
     "Number of bytes the binary representation of an integer type takes, e.g. 4 bytes for an int32."
 
     bytes: int
 
 
 @typeannotation
-@dataclass(frozen=True)
 class IntegerRange:
     "Minimum and maximum value of an integer. The range is inclusive."
 
@@ -121,7 +117,6 @@ class IntegerRange:
 
 
 @typeannotation
-@dataclass(frozen=True)
 class Precision:
     "Precision of a floating-point value."
 
@@ -134,7 +129,6 @@ def integer_digits(self) -> int:
 
 
 @typeannotation
-@dataclass(frozen=True)
 class TimePrecision:
     """
     Precision of a timestamp or time interval.
@@ -146,23 +140,27 @@ class TimePrecision:
 
 
 @typeannotation
-@dataclass(frozen=True)
+class Length:
+    "Exact length of a string."
+
+    value: int
+
+
+@typeannotation
 class MinLength:
     "Minimum length of a string."
 
     value: int
 
 
 @typeannotation
-@dataclass(frozen=True)
 class MaxLength:
     "Maximum length of a string."
 
     value: int
 
 
 @typeannotation
-@dataclass(frozen=True)
 class SpecialConversion:
     "Indicates that the annotated type is subject to custom conversion rules."
 

strong_typing/inspection.py

@@ -621,11 +621,16 @@ def run(
         :returns: Types referenced by the given type or special form.
         """
 
-        if typ in self.graph:
+        if typ is type(None) or typ is Any:
             return
 
-        if typ is type(None):
-            return
+        if isinstance(typ, type):
+            self.graph[cls].add(typ)
+
+            if typ in self.graph:
+                return
+
+            self.graph[typ] = set()
 
         metadata = getattr(typ, "__metadata__", None)
         if metadata is not None:
@@ -641,23 +646,24 @@ def run(
             evaluated_type = evaluate_type(typ, module)
             return self.run(evaluated_type, cls, module)
 
-        # type is a regular type
+        # type is a special form
         origin = typing.get_origin(typ)
-        if origin in [list, dict, set, tuple, Union]:
+        if origin in [list, dict, frozenset, set, tuple, Union]:
             for arg in typing.get_args(typ):
                 self.run(arg, cls, module)
             return
         elif origin is Literal:
             return
+
+        # type is a regular type
         elif is_dataclass_type(typ) or is_type_enum(typ) or isinstance(typ, type):
-            self.graph[cls].add(typ)
-            self.graph[typ] = set()
+            context = sys.modules[typ.__module__]
             if is_dataclass_type(typ):
                 for field in dataclass_fields(typ):
-                    self.run(field.type, typ, sys.modules[typ.__module__])
+                    self.run(field.type, typ, context)
             else:
                 for field_name, field_type in get_resolved_hints(typ).items():
-                    self.run(field_type, typ, sys.modules[typ.__module__])
+                    self.run(field_type, typ, context)
             return
 
         raise TypeError(f"expected: type-like; got: {typ}")
@@ -933,7 +939,7 @@ def check(self, typ: TypeLike, obj: Any) -> bool:
 
 
 def check_recursive(
-    obj: T,
+    obj: object,
     /,
     *,
     pred: Optional[Callable[[Type[T], T], bool]] = None,
@@ -943,8 +949,7 @@ def check_recursive(
     """
     Checks if a predicate applies to all nested member properties of an object recursively.
 
-    :param typ: The type to recurse into.
-    :param obj: The object to inspect recursively. Must be an instance of the given type.
+    :param obj: The object to inspect recursively.
     :param pred: The predicate to test on member properties. Takes a property type and a property value.
     :param type_pred: Constrains the check to properties of an expected type. Properties of other types pass automatically.
     :param value_pred: Verifies a condition on member property values (of an expected type).
@@ -976,4 +981,4 @@ def check_recursive(
     elif pred is None:
         pred = lambda typ, obj: True
 
-    return RecursiveChecker(pred).check(type(obj), obj)  # type: ignore
+    return RecursiveChecker(pred).check(type(obj), obj)

tests/test_deserialization.py

@@ -3,7 +3,10 @@
 import uuid
 from typing import Dict, List, Literal, Optional, Set, Union
 
-from test_sample_types import (
+from strong_typing.exception import JsonKeyError, JsonTypeError, JsonValueError
+from strong_typing.serialization import json_to_object, object_to_json
+
+from .sample_types import (
     UID,
     BinaryValueWrapper,
     ClassA,
@@ -20,9 +23,6 @@
     Suit,
 )
 
-from strong_typing.exception import JsonKeyError, JsonTypeError, JsonValueError
-from strong_typing.serialization import json_to_object, object_to_json
-
 
 def test_function() -> None:
     pass

tests/test_docstring.py

@@ -6,10 +6,10 @@
 from dataclasses import dataclass
 from typing import Optional, TypeVar
 
-from test_sample_exceptions import CustomException
-
 from strong_typing.docstring import has_default_docstring, has_docstring, parse_type
 
+from .sample_exceptions import CustomException
+
 T = TypeVar("T")
 
 

tests/test_inspection.py

@@ -3,9 +3,7 @@
 import sys
 import unittest
 from dataclasses import dataclass
-from typing import Dict, List, NamedTuple, Optional, Set, Tuple, Union
-
-from test_sample_types import CompositeDataclass, NestedDataclass, SimpleDataclass
+from typing import Any, Dict, List, NamedTuple, Optional, Set, Tuple, Union
 
 from strong_typing.auxiliary import Annotated, typeannotation
 from strong_typing.inspection import (
@@ -26,6 +24,8 @@
     unwrap_union_types,
 )
 
+from .sample_types import CompositeDataclass, NestedDataclass, SimpleDataclass
+
 
 class Side(enum.Enum):
     "An enumeration with string values."
@@ -70,9 +70,14 @@ class TestInspection(unittest.TestCase):
     def test_simple(self) -> None:
         module = sys.modules[self.__module__]
         self.assertSetEqual(get_referenced_types(type(None), module), set())
+        self.assertSetEqual(get_referenced_types(Any, module), set())
         self.assertSetEqual(get_referenced_types(int, module), set([int]))
         self.assertSetEqual(get_referenced_types(Optional[str], module), set([str]))
         self.assertSetEqual(get_referenced_types(List[str], module), set([str]))
+        self.assertSetEqual(get_referenced_types(List[List[str]], module), set([str]))
+        self.assertSetEqual(
+            get_referenced_types(List[Optional[str]], module), set([str])
+        )
         self.assertSetEqual(
             get_referenced_types(Dict[int, bool], module), set([int, bool])
         )

tests/test_performance.py

@@ -5,10 +5,10 @@
 import uuid
 from dataclasses import dataclass
 
-from test_timer import Timer
-
 from strong_typing.serialization import json_to_object, object_to_json
 
+from .timer import Timer
+
 
 def time_today(time_of_day: datetime.time) -> datetime.datetime:
     return datetime.datetime.combine(

tests/test_schema.py

@@ -4,18 +4,6 @@
 import uuid
 from typing import Any, Dict, List, Set, Tuple, Union
 
-from test_sample_types import (
-    UID,
-    AnnotatedSimpleDataclass,
-    BinaryTree,
-    Side,
-    SimpleDataclass,
-    SimpleTypedNamedTuple,
-    SimpleValueWrapper,
-    Suit,
-    ValueExample,
-)
-
 from strong_typing.auxiliary import Annotated, IntegerRange, Precision, int32, uint64
 from strong_typing.core import JsonType
 from strong_typing.schema import (
@@ -27,6 +15,18 @@
     get_class_docstrings,
 )
 
+from .sample_types import (
+    UID,
+    AnnotatedSimpleDataclass,
+    BinaryTree,
+    Side,
+    SimpleDataclass,
+    SimpleTypedNamedTuple,
+    SimpleValueWrapper,
+    Suit,
+    ValueExample,
+)
+
 
 class TestSchema(unittest.TestCase):
     def test_schema(self) -> None:

tests/test_serialization.py

@@ -4,7 +4,12 @@
 import uuid
 from typing import Dict
 
-from test_sample_types import (
+from strong_typing.core import JsonType
+from strong_typing.exception import JsonValueError
+from strong_typing.schema import validate_object
+from strong_typing.serialization import object_to_json
+
+from .sample_types import (
     UID,
     AnnotatedSimpleDataclass,
     BinaryValueWrapper,
@@ -23,11 +28,6 @@
     Suit,
 )
 
-from strong_typing.core import JsonType
-from strong_typing.exception import JsonValueError
-from strong_typing.schema import validate_object
-from strong_typing.serialization import object_to_json
-
 
 def test_function() -> None:
     pass