lol im tired

Author: AWeirdDev

README.md

@@ -105,4 +105,44 @@ Normally, when you use the parameters passed in example (2) above, the Python `d
 
 It's worth noting that error generations are *lazy*, which means once Exacting finds out about a problem about a dataclass, it raises a `ValidationError`. This saves a lot of computation time if you have a larger model.
 
+![praise pydantic](https://github.com/user-attachments/assets/c322bff2-2624-479d-9967-7184580b36c1)
+
+Yeah, we also got fields! Use it like how you'd expect it. Quite literally, lol.
+
+```python
+from exacting import Exact, field
+
+
+def create_ai_slop():
+    return "tick tock"
+
+class Comment(Exact):
+    user: str = field(regex="^@.+$")
+    stars: int = field(minv=1, maxv=5)
+    body: str = field(default_factory=create_ai_slop)
+
+# ✅ OK, exacting is HYPED
+Comment(
+    user="@waltuh",
+    stars=5
+)
+
+# ❌ Hell nawh, exacting holdin' you at gunpoint
+Comment(
+    user="ooga booga",  # Regex validation '^@.+$' on str failed
+    stars=-1,  # Expected min value of 1, got -1
+    body=None  # Expected type <class 'str'>, got <class 'NoneType'>
+)
+```
+
+Woah! That's a lot of code to process. To put it simply, exacting supports:
+
+- **Regex** validation on `str`
+- **Min/max** validation on value (e.g., `int`, `float`) or length (e.g., `str`, `list`)
+- **Default** values or factory! Y'know, the old `dataclasses` way, mmmMMM
+- This is extra, but **custom** validation! You can make your own if you like
+
+![praise pydantic, exactign sucks](https://github.com/user-attachments/assets/5969c54a-14d0-4023-9f80-b89ae9ea8374)
+
+Kind of, but somehow native performance is way better than Rust. Take a look at this.
 

python/exacting/core.py

@@ -84,6 +84,8 @@ class _Dc: ...
 
 
 class Exact(_Dc, _Internals):
+    """Represents a dataclass with runtime type checks."""
+
     def __init_subclass__(cls) -> None:
         exact(cls)
 

python/exacting/validators.py

@@ -264,7 +264,9 @@ def validate(self, value: Any, **options) -> Result:
                 for item in validator_items:
                     fv_res = item.validate(field_value)
                     if not fv_res.is_ok():
-                        return fv_res
+                        return fv_res.trace(
+                            f"During validation of dataclass {self!r} at field {name!r}, got:"
+                        )
                     field_value = fv_res.unwrap()
 
             data[name] = field_value

val_exacting.py

@@ -0,0 +1,69 @@
+import time
+import random
+import string
+from exacting import Exact, field
+
+
+def gen_str(length: int) -> str:
+    return "".join(random.choices(string.ascii_letters, k=length))
+
+
+class Meta(Exact):
+    liked: bool = field()
+    flags: list[str] = field()
+
+
+class Reply(Exact):
+    user: str = field()
+    content: str = field()
+    metadata: Meta
+
+
+class Comment(Exact):
+    user: str = field()
+    stars: int = field(minv=1, maxv=5)
+    body: str | None
+    replies: list[Reply]
+
+
+class Place(Exact):
+    name: str
+    location: str
+    comments: list[Comment]
+    metadata: Meta
+
+
+def gen_reply():
+    return Reply(
+        user="@" + gen_str(5),
+        content=gen_str(20),
+        metadata=Meta(
+            liked=random.choice([True, False]),
+            flags=[gen_str(3) for _ in range(random.randint(0, 3))],
+        ),
+    )
+
+
+def gen_comment():
+    return Comment(
+        user="@" + gen_str(5),
+        stars=random.randint(1, 5),
+        body=gen_str(40),
+        replies=[gen_reply() for _ in range(random.randint(1, 3))],
+    )
+
+
+def gen_place():
+    return Place(
+        name=gen_str(10),
+        location=gen_str(20),
+        comments=[gen_comment() for _ in range(100)],
+        metadata=Meta(liked=True, flags=["safe"]),
+    )
+
+
+start = time.perf_counter()
+place = gen_place()
+end = time.perf_counter()
+
+print(f"{(end - start) * 1000} ms")

val_pydantic.py

@@ -0,0 +1,70 @@
+import time
+import random
+import string
+from pydantic import BaseModel, Field
+from typing import List, Optional
+
+
+def gen_str(length: int) -> str:
+    return "".join(random.choices(string.ascii_letters, k=length))
+
+
+class Meta(BaseModel):
+    liked: bool
+    flags: List[str]
+
+
+class Reply(BaseModel):
+    user: str = Field()
+    content: str
+    metadata: Meta
+
+
+class Comment(BaseModel):
+    user: str = Field()
+    stars: int = Field(..., ge=1, le=5)
+    body: Optional[str]
+    replies: List[Reply]
+
+
+class Place(BaseModel):
+    name: str
+    location: str
+    comments: List[Comment]
+    metadata: Meta
+
+
+def gen_reply() -> Reply:
+    return Reply(
+        user="@" + gen_str(5),
+        content=gen_str(20),
+        metadata=Meta(
+            liked=random.choice([True, False]),
+            flags=[gen_str(3) for _ in range(random.randint(0, 3))],
+        ),
+    )
+
+
+def gen_comment() -> Comment:
+    return Comment(
+        user="@" + gen_str(5),
+        stars=random.randint(1, 5),
+        body=gen_str(40),
+        replies=[gen_reply() for _ in range(random.randint(1, 3))],
+    )
+
+
+def gen_place() -> Place:
+    return Place(
+        name=gen_str(10),
+        location=gen_str(20),
+        comments=[gen_comment() for _ in range(100)],
+        metadata=Meta(liked=True, flags=["safe"]),
+    )
+
+
+start = time.perf_counter()
+place = gen_place()
+end = time.perf_counter()
+
+print(f"{(end - start) * 1000} ms")