yo...

Author: AWeirdDev

_setup.py

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

python/exacting/__init__.py

@@ -1,4 +1,5 @@
 from .core import Exact, exact
+from .fields import field
 from .types import ValidationError
 from .validators import (
     AnnotatedV,
@@ -40,5 +41,6 @@
     "StrV",
     "UnionV",
     "Validator",
-    "unsafe"
+    "unsafe",
+    "field"
 ]

python/exacting/core.py

@@ -10,7 +10,7 @@
 from .result import Result
 from .utils import get_field_value, unsafe_mode
 
-from .exacting import py_to_bytes
+from .exacting import bytes_to_py, json_to_py, jsonc_to_py, py_to_bytes
 
 
 def get_exact_init(dc: DataclassType):
@@ -88,19 +88,51 @@ def __init_subclass__(cls) -> None:
         exact(cls)
 
     def exact_as_dict(self) -> Dict[str, Any]:
-        """Get this model instance as dictionary."""
+        """Get this model instance as a dictionary."""
         return asdict(self)
 
     def exact_as_json(self) -> str:
         """Get this model instance as JSON."""
         return json.dumps(self.exact_as_dict())
 
     def exact_as_bytes(self) -> bytes:
-        """Get this model instance as bytes with `rkyv`."""
+        """Get this model instance as bytes with `rkyv`.
+
+        This may **not** be super efficient.
+        """
         return py_to_bytes(self.exact_as_dict())
 
     @classmethod
     def exact_from_dict(cls, d: Dict[str, Any]) -> Self:
+        """(exacting) Get this model from a raw dictionary."""
+        res = cls.__validator__.validate(d, from_dict=True)
+        res.raise_for_err()
+        return res.unwrap()
+
+    @classmethod
+    def exact_from_json(cls, raw: str, /, *, strict: bool = True) -> Self:
+        """(exacting) Get this model from raw JSON.
+
+        When strict mode is set to `False`, you could use JSON with comments
+        and more modern features.
+
+        Args:
+            raw (str): The raw JSON data.
+            strict (bool): Whether to turn strict mode on.
+        """
+        if strict:
+            d = json_to_py(raw)
+        else:
+            d = jsonc_to_py(raw)
+
+        res = cls.__validator__.validate(d, from_dict=True)
+        res.raise_for_err()
+        return res.unwrap()
+
+    @classmethod
+    def exact_from_bytes(cls, raw: bytes) -> Self:
+        """(exacting) Get this model from raw bytes."""
+        d = bytes_to_py(raw)
         res = cls.__validator__.validate(d, from_dict=True)
         res.raise_for_err()
         return res.unwrap()

python/exacting/fields.py

@@ -0,0 +1,52 @@
+import dataclasses as std_dc
+from dataclasses import MISSING
+
+from typing import Any, Callable, List, Type, TypeVar, Union
+
+from .validators import Validator, MinMaxV, RegexV
+from .types import _Optional
+
+T = TypeVar("T")
+
+
+class ExactField:
+    validators: List[Validator]
+
+    def __init__(self, validators: List[Validator]):
+        self.validators = validators
+
+
+def field(
+    typ: _Optional[Type[T]] = MISSING,
+    *,
+    default: _Optional[T] = MISSING,
+    default_factory: _Optional[Callable[[], T]] = MISSING,
+    hash: _Optional[bool] = MISSING,
+    regex: _Optional[str] = MISSING,
+    minv: _Optional[Union[int, float]] = MISSING,
+    maxv: _Optional[Union[int, float]] = MISSING,
+) -> Any:
+    validators = []
+    if regex is not MISSING:
+        validators.append(RegexV(regex))
+
+    if minv is not MISSING or maxv is not MISSING:
+        validators.append(MinMaxV(minv, maxv))
+
+    if default is not MISSING:
+        return std_dc.field(
+            default=default,
+            metadata={"exact": ExactField(validators)},
+            hash=None if hash is MISSING else hash,
+        )
+    elif default_factory is not MISSING:
+        return std_dc.field(
+            default_factory=default_factory,
+            metadata={"exact": ExactField(validators)},
+            hash=None if hash is MISSING else hash,
+        )
+    else:
+        return std_dc.field(
+            metadata={"exact": ExactField(validators)},
+            hash=None if hash is MISSING else hash,
+        )

python/exacting/types.py

@@ -1,6 +1,6 @@
 import dataclasses as std_dc
 
-from typing import Any, Dict, Protocol, Type, Union
+from typing import Any, Dict, Protocol, Type, TypeVar, Union
 
 
 class Dataclass(Protocol):
@@ -13,7 +13,7 @@ class Dataclass(Protocol):
 class _Indexable:
     def __getitem__(self, k: str): ...
     def __setitem__(self, k: str, data: Any): ...
-    def get(self, k: str): ...
+    def get(self, k: str) -> Any: ...
     def as_dict(self) -> dict: ...
     def as_dc(self) -> Dataclass: ...
 
@@ -67,3 +67,7 @@ def indexable(item: Any) -> "_Indexable":
 
 class ValidationError(RuntimeError):
     """Validation error for `exacting`."""
+
+
+T = TypeVar("T")
+_Optional = Union[T, std_dc._MISSING_TYPE]

python/exacting/validator_map.py

@@ -1,8 +1,9 @@
 import dataclasses
 from dataclasses import is_dataclass
+from weakref import ref
+
 from types import NoneType, UnionType
 from typing import Annotated, Any, Dict, Literal, Union, get_origin, get_type_hints
-from weakref import ref
 
 from .validators import (
     AnnotatedV,

python/exacting/validators.py

@@ -1,12 +1,12 @@
 from abc import ABC
-from dataclasses import is_dataclass
-from typing import Any, Dict, List, Type, TypeVar
+from dataclasses import MISSING, is_dataclass
+from typing import Any, Dict, List, Type, TypeVar, Union
 from weakref import ReferenceType
 
-
-from .types import DataclassType, indexable
+from .types import DataclassType, indexable, _Optional
 from .result import Result
 from .utils import get_field_value, unsafe
+from .exacting import Regex
 
 T = TypeVar("T")
 
@@ -256,7 +256,18 @@ def validate(self, value: Any, **options) -> Result:
                     f"During validation of dataclass {self!r} at field {name!r}, got:"
                 )
 
-            data[name] = field_res.unwrap()
+            field_value = field_res.unwrap()
+
+            ef = field.metadata.get("exact")
+            if ef:
+                validator_items: List[Validator] = ef.validators
+                for item in validator_items:
+                    fv_res = item.validate(field_value)
+                    if not fv_res.is_ok():
+                        return fv_res
+                    field_value = fv_res.unwrap()
+
+            data[name] = field_value
 
         if options.get("from_dict"):
             with unsafe():
@@ -271,3 +282,66 @@ def __repr__(self):
         if dc is None:
             raise RuntimeError("Weakref is gone")
         return dc.__name__
+
+
+class RegexV(Validator):
+    regex: Regex
+    pattern: str
+
+    def __init__(self, pattern: str):
+        self.regex = Regex(pattern)
+        self.pattern = pattern
+
+    def validate(self, value: Any, **options) -> "Result":
+        res = expect(str, value)
+        if not res.is_ok():
+            return res
+
+        data = res.unwrap()
+        if not self.regex.validate(data):
+            return Result.Err(f"Regex validation {self.pattern!r} on str failed")
+
+        return Result.Ok(data)
+
+
+class MinMaxV(Validator):
+    minv: _Optional[Union[int, float]]
+    maxv: _Optional[Union[int, float]]
+
+    def __init__(
+        self,
+        minv: _Optional[Union[int, float]] = MISSING,
+        maxv: _Optional[Union[int, float]] = MISSING,
+    ):
+        self.minv = minv
+        self.maxv = maxv
+
+    def validate(self, value: Any, **options) -> "Result":
+        if hasattr(value, "__len__"):
+            ln = len(value)
+            if self.minv is not MISSING:
+                if ln < self.minv:
+                    return Result.Err(f"Expected min length of {self.minv}, got {ln}")
+            if self.maxv is not MISSING:
+                if ln > self.maxv:
+                    return Result.Err(f"Expected max length of {self.minv}, got {ln}")
+
+        elif hasattr(value, "__lt__") and hasattr(value, "__gt__"):
+            if self.minv is not MISSING:
+                if value < self.minv:
+                    return Result.Err(
+                        f"Expected min value of {self.minv}, got {value!r}"
+                    )
+
+            if self.maxv is not MISSING:
+                if value > self.maxv:
+                    return Result.Err(
+                        f"Expected max value of {self.minv}, got {value!r}"
+                    )
+
+        else:
+            return Result.Err(
+                f"Neither len(), >, or < can be tested for type {type(value)}"
+            )
+
+        return Result.Ok(value)

test.py

@@ -1,24 +1,16 @@
-from typing import Annotated, Literal
-from exacting import Exact, unsafe
+from exacting import Exact, field
 
 
-class Comment(Exact):
-    user: str
-    title: str
-    stars: int
-    body: str | None = None
+class Stuff(Exact):
+    cool: bool
 
 
-class Place(Exact):
-    name: str
-    location: str
-    comments: list[Comment]
+class Comment(Exact):
+    user: str
+    stars: int = field(minv=1, maxv=5)
+    stuff: Stuff
 
 
-with unsafe():
-    d = Place.__unsafe_init__(
-        name="McDonald's",
-        location="McDonald's Rd.",
-        comments=[Comment.__unsafe_init__(user="Waltuh", title="ITBOY", stars=2)],
-    ).exact_as_dict()
-print(Place.exact_from_dict(d))
+b = Comment(user="Waltuh", stars=3, stuff=Stuff(cool=True)).exact_as_bytes()
+print(b)
+print(Comment.exact_from_bytes(b))