ooga booga

Author: AWeirdDev

README.md

@@ -3,14 +3,18 @@
 
 `exacting` is a picky dataclass runtime utility collection, making sure all type annotations are followed.
 
-Yes, **type hints are always on.** No hidden stuff.
+Essentially... **THE** go-to option for dataclasses. heh.
+
+**Key features**:
+
+- **100% static typing.** Because I hate nothing too.
+- Up to **10x faster** than [`pydantic`](https://pydantic.dev)! (Them: 60ms, us: 6~9ms)
 
 ## Examples
 ```python
-from exacting import exact
+from exacting import Exact
 
-@exact
-class Person:
+class Person(Exact):
     name: str
     age: int
 
@@ -26,18 +30,17 @@ Person(name="John", age=1.23)
 # Thankfully, `exacting` gives us an error message:
 # 
 # TypeError:
-# During validation of dataclass Person, a type error occurred: -
+# During validation of dataclass 'Person' at attribute 'age', a type error occurred:
 # (isinstance) Expected <class 'int'>, got: <class 'float'>
-# ...at attribute 'age'
 ```
 
-Also, you can type anything! (Almost.) Cool.
+Also, you can type anything! Almost.
 
 ```python
 @exact
 class Stuff:
-    banana: str | int | bool
     apple: Optional[str]
+    banana: str | int | bool
 
 # ...they all work!
 ```

pyproject.toml

@@ -4,6 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "exacting"
+dependencies = ["typing-extensions"]
 requires-python = ">=3.8"
 classifiers = [
     "Programming Language :: Rust",

python/exacting/__init__.py

@@ -18,6 +18,7 @@
     DataclassType,
     NoneType,
     AnyType,
+    AnnotatedType,
 )
 from .dc import get_etypes_for_dc, get_etype_from_type
 
@@ -41,6 +42,7 @@
     "DictType",
     "UnionType",
     "DataclassType",
+    "AnnotatedType",
     "NoneType",
     "AnyType",
     "get_etypes_for_dc",

python/exacting/core.py

@@ -1,4 +1,5 @@
 from typing import TYPE_CHECKING, Callable, List, Type, TypeVar
+from typing_extensions import dataclass_transform
 
 import dataclasses
 from dataclasses import asdict, dataclass, is_dataclass
@@ -28,6 +29,7 @@ def get_exact_error_message(errors: List[str]) -> str:
 
 def get_exact_init(dc: Type) -> Callable:
     etypes = get_etypes_for_dc(dc)
+    dc.__exact_types__ = etypes
 
     def init(self, *args, **kwargs):
         covered = len(args) + len(kwargs)
@@ -115,16 +117,17 @@ def wrapper(t):
     exact = _patch()
 
 
-class Exact:
-    """This `Exact` model appends additional functionalities to the current dataclass.
+@dataclass_transform()
+class _ModelKwOnly: ...
 
+
+class Exact(_ModelKwOnly):
+    """
     All the APIs are prefixed with `exact_` to add clarity.
     """
 
-    def __init__(self):
-        raise NotImplementedError(
-            "The class `Exact` should not be initialized directly, but inherited."
-        )
+    def __init_subclass__(cls) -> None:
+        setattr(cls, "__init__", get_exact_init(dataclass(cls)))
 
     def exact_as_dict(self):
         """Creates a dictionary representation of this dataclass instance.

python/exacting/dc.py

@@ -7,6 +7,7 @@
 
 from .types import Dataclass
 from .etypes import (
+    AnnotatedType,
     BaseType,
     DataclassType,
     DictType,
@@ -51,6 +52,10 @@ def get_etype_from_type(typ: Type) -> BaseType:
         return DictType(
             get_etype_from_type(typ.__args__[0]), get_etype_from_type(typ.__args__[1])
         )
+    elif origin is typing.Annotated:
+        return AnnotatedType(
+            get_etype_from_type(typ.__args__[0]), list(typ.__metadata__)
+        )
 
     raise TypeError(f"Unknown type: {typ!r}")
 

python/exacting/etypes.py

@@ -292,7 +292,9 @@ def __init__(self, name: str, target: typing.Dict[str, BaseType]):
 
     def validate(self, x: Any) -> TypeResult[Any]:
         if not is_dataclass(x):
-            raise TypeError(f"Expected dataclass instance, got: {x!r}")
+            return TypeResult(
+                errors=[f"Expected dataclass instance ({self.name!r}), got: {x!r}"]
+            )
 
         for name, etype in self.target.items():
             item = getattr(x, name)
@@ -314,3 +316,15 @@ def validate(self, x: Any) -> TypeResult[Any]:
 
     def __repr__(self) -> str:
         return self.name
+
+
+class AnnotatedType(BaseType[Any]):
+    target: BaseType
+    items: typing.List[Any]
+
+    def __init__(self, target: BaseType, items: typing.List[Any]):
+        self.target = target
+        self.items = items
+
+    def validate(self, x: Any) -> TypeResult[Any]:
+        return self.target.validate(x)

setup.py

@@ -0,0 +1,14 @@
+from setuptools import setup
+from Cython.Build import cythonize
+
+setup(
+    name="python/exacting/",
+    ext_modules=cythonize(
+        [
+            "python/exacting/etypes.py",
+            "python/exacting/dc.py",
+            "python/exacting/core.py",
+        ]
+    ),
+    package_dir={"": "python"},
+)

test.py

@@ -1,23 +0,0 @@
-from dataclasses import dataclass
-from typing import Optional
-from exacting import Exact, exact
-
-
-@exact
-class Experience(Exact):
-    title: str
-    years: Optional[int] = None
-
-
-@exact
-class Person(Exact):
-    name: str
-    age: int
-    experiences: list[Experience]
-
-
-Person(
-    name="John",
-    age=123,
-    experiences=[Experience(title=b"WHEN I POOPPED OFF", years=123)],
-)

test_pydantic.py

@@ -0,0 +1,129 @@
+import time
+from typing import Union
+from exacting import Exact
+
+start = time.perf_counter()
+
+
+class AnotherDataclass(Exact):
+    id: int
+    payload: str
+    flag: bool
+    checksum: bytes
+
+
+class Config(Exact):
+    retries: int
+    timeout: float
+    use_ssl: bool
+    endpoint: str
+
+
+class Metadata(Exact):
+    tags: list[str]
+    created_at: str
+    version: Union[str, int]
+    notes: Union[None, str, bytes]
+
+
+class NestedLevelThree(Exact):
+    data: list[AnotherDataclass]
+    metadata: Metadata
+    value: Union[int, float, str, bool]
+    binary: bytes
+
+
+class NestedLevelTwo(Exact):
+    name: str
+    configs: list[Config]
+    children: list[NestedLevelThree]
+    stats: dict[str, Union[int, float]]
+    optional_info: Union[str, None, AnotherDataclass]
+
+
+class NestedLevelOne(Exact):
+    key: str
+    nested: NestedLevelTwo
+    mixed_list: list[Union[str, int, AnotherDataclass]]
+    fallback: Union[AnotherDataclass, bool]
+    retry_limit: int
+
+
+class UltimateRoot(Exact):
+    identifier: str
+    deep: list[NestedLevelOne]
+    extra: dict[str, list[AnotherDataclass]]
+    settings: Config
+    blob: Union[bytes, str, list[Union[str, bytes]]]
+    flags: list[bool]
+
+
+test_data = UltimateRoot(
+    identifier="root-001",
+    deep=[
+        NestedLevelOne(
+            key="level-one-a",
+            nested=NestedLevelTwo(
+                name="level-two-a",
+                configs=[
+                    Config(
+                        retries=3,
+                        timeout=1.5,
+                        use_ssl=True,
+                        endpoint="https://api.service",
+                    ),
+                    Config(
+                        retries=5,
+                        timeout=2.0,
+                        use_ssl=False,
+                        endpoint="http://backup.service",
+                    ),
+                ],
+                children=[
+                    NestedLevelThree(
+                        data=[
+                            AnotherDataclass(
+                                id=1, payload="data-1", flag=True, checksum=b"\x01\x02"
+                            ),
+                            AnotherDataclass(
+                                id=2, payload="data-2", flag=False, checksum=b"\x03\x04"
+                            ),
+                        ],
+                        metadata=Metadata(
+                            tags=["alpha", "beta"],
+                            created_at="2023-04-01T12:00:00Z",
+                            version="v1.0",
+                            notes=b"Some binary notes",
+                        ),
+                        value=True,
+                        binary=b"\x99\x88",
+                    )
+                ],
+                stats={"requests": 1234, "load": 0.85},
+                optional_info=AnotherDataclass(
+                    id=99, payload="optional", flag=True, checksum=b"\xff"
+                ),
+            ),
+            mixed_list=[
+                "string",
+                42,
+                AnotherDataclass(id=77, payload="mixed", flag=False, checksum=b"\xab"),
+            ],
+            fallback=True,
+            retry_limit=10,
+        )
+    ],
+    extra={
+        "groupA": [
+            AnotherDataclass(id=3, payload="x", flag=True, checksum=b"\xde"),
+            AnotherDataclass(id=4, payload="y", flag=False, checksum=b"\xad"),
+        ]
+    },
+    settings=Config(
+        retries=1, timeout=0.5, use_ssl=True, endpoint="https://fast.service"
+    ),
+    blob=[b"chunk1", b"chunk2", "fallback text"],
+    flags=[True, False, True],
+)
+
+print((time.perf_counter() - start) * 1000, "ms")