perf

Author: AWeirdDev

README.md

@@ -9,7 +9,7 @@ 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)
+- Generally **faster** than [`pydantic`](https://pydantic.dev)!
 
 ![i aint lying about static typing](https://github.com/user-attachments/assets/875517ff-5dd5-4b63-98fa-e1218ff00627)
 
@@ -144,5 +144,6 @@ Woah! That's a lot of code to process. To put it simply, exacting supports:
 
 ![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.
+Kind of, but somehow native performance is way better than Rust. That is, exacting is *generally* faster than Pydantic on a few benchmarks. Woooosh
 
+Anyway, thanks for hopping onto this quick tour, you can [read the docs](https://aweirddev.github.io/exacting) if you'd like.

_setup.py

@@ -5,6 +5,7 @@
     name="python/exacting/",
     ext_modules=cythonize(
         [
+            "python/exacting/result.py",
         ]
     ),
     package_dir={"": "python"},

python/exacting/core.py

@@ -1,7 +1,7 @@
 import json
 from dataclasses import MISSING, asdict, dataclass
 
-from typing import Any, Dict, Type
+from typing import TYPE_CHECKING, Any, Dict, Type
 from typing_extensions import Self, dataclass_transform
 
 from .validators import DataclassV, Validator
@@ -21,7 +21,7 @@ def init(self, **kwargs):
             value = get_field_value(kwargs.get(field.name, MISSING), field)
             setattr(self, field.name, value)
 
-        validator: Validator = getattr(dc, "__validator__")
+        validator: Validator = self.__validator__
         res: Result = validator.validate(self)
         res.raise_for_err()
 
@@ -60,34 +60,44 @@ def exact(cls: Type) -> DataclassType:
     return dc
 
 
-class _Internals:
-    __validator__: DataclassV
+if TYPE_CHECKING:
 
-    @classmethod
-    def __unsafe_init__(cls, **kwargs) -> Self:
-        """Unsafely initialize the dataclass with no-brain filling.
+    class _Internals:
+        __validator__: DataclassV
 
-        Example:
+        @classmethod
+        def __unsafe_init__(cls, **kwargs) -> Self:
+            """Unsafely initialize the dataclass with no-brain filling.
 
-        ```python
-        from exacting import unsafe
+            Example:
 
-        with unsafe():
-            SomeDataclass.__unsafe_init__(**kwargs)
-        ```
-        """
-        raise NotImplementedError()
+            ```python
+            from exacting import unsafe
 
+            with unsafe():
+                SomeDataclass.__unsafe_init__(**kwargs)
+            ```
+            """
+            raise NotImplementedError()
 
-@dataclass_transform(kw_only_default=True)
-class _Dc: ...
+    @dataclass_transform(kw_only_default=True)
+    class _Dc: ...
+
+else:
+
+    class _Dc: ...
+
+    class _Internals: ...
 
 
 class Exact(_Dc, _Internals):
     """Represents a dataclass with runtime type checks."""
 
-    def __init_subclass__(cls) -> None:
-        exact(cls)
+    def __init__(self, **kwargs):
+        get_exact_init(self)(self, **kwargs)
+
+    def __init_subclass__(cls):
+        dataclass(cls)
 
     def exact_as_dict(self) -> Dict[str, Any]:
         """Get this model instance as a dictionary."""

python/exacting/result.py

@@ -6,7 +6,7 @@
 T = TypeVar("T")
 
 
-def build_error(errors: deque[str]) -> str:
+def build_error(errors: "deque[str]") -> str:
     text = "\n"
     indent_level = 0
 

python/exacting/validators.py

@@ -260,7 +260,8 @@ def validate(self, value: Any, **options) -> Result:
 
             ef = field.metadata.get("exact")
             if ef:
-                validator_items: List[Validator] = ef.validators
+                # validator_items: List[Validator]
+                validator_items = ef.validators
                 for item in validator_items:
                     fv_res = item.validate(field_value)
                     if not fv_res.is_ok():

val_exacting.py

@@ -6,64 +6,3 @@
 
 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

@@ -9,32 +9,96 @@ def gen_str(length: int) -> str:
     return "".join(random.choices(string.ascii_letters, k=length))
 
 
-class Meta(BaseModel):
+class MetaP(BaseModel):
     liked: bool
     flags: List[str]
 
 
-class Reply(BaseModel):
+class ReplyP(BaseModel):
     user: str = Field()
     content: str
-    metadata: Meta
+    metadata: MetaP
 
 
-class Comment(BaseModel):
+class CommentP(BaseModel):
     user: str = Field()
     stars: int = Field(..., ge=1, le=5)
     body: Optional[str]
-    replies: List[Reply]
+    replies: List[ReplyP]
+
+
+class PlaceP(BaseModel):
+    name: str
+    location: str
+    comments: List[CommentP]
+    metadata: MetaP
+
+
+def gen_reply() -> ReplyP:
+    return ReplyP(
+        user="@" + gen_str(5),
+        content=gen_str(20),
+        metadata=MetaP(
+            liked=random.choice([True, False]),
+            flags=[gen_str(3) for _ in range(random.randint(0, 3))],
+        ),
+    )
+
+
+def gen_comment() -> CommentP:
+    return CommentP(
+        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() -> PlaceP:
+    return PlaceP(
+        name=gen_str(10),
+        location=gen_str(20),
+        comments=[gen_comment() for _ in range(100)],
+        metadata=MetaP(liked=True, flags=["safe"]),
+    )
+
+
+start = time.perf_counter()
+for i in range(10):
+    gen_place()
+end = time.perf_counter()
+
+print(f"{(end - start) * 1000} ms")
+
+from exacting import Exact, field
 
-class Place(BaseModel):
+
+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]
+    comments: list[Comment]
     metadata: Meta
 
 
-def gen_reply() -> Reply:
+def gen_reply2():
     return Reply(
         user="@" + gen_str(5),
         content=gen_str(20),
@@ -45,26 +109,27 @@ def gen_reply() -> Reply:
     )
 
 
-def gen_comment() -> Comment:
+def gen_comment2():
     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))],
+        replies=[gen_reply2() for _ in range(random.randint(1, 3))],
     )
 
 
-def gen_place() -> Place:
+def gen_place2():
     return Place(
         name=gen_str(10),
         location=gen_str(20),
-        comments=[gen_comment() for _ in range(100)],
+        comments=[gen_comment2() for _ in range(100)],
         metadata=Meta(liked=True, flags=["safe"]),
     )
 
 
 start = time.perf_counter()
-place = gen_place()
+for i in range(10):
+    gen_place2()
 end = time.perf_counter()
 
 print(f"{(end - start) * 1000} ms")