rewrite

Author: AWeirdDev

python/exacting/exacting.pyi

@@ -1,14 +1,12 @@
 from typing import Any
 
-
 def json_to_py(json: str) -> Any:
     """Convert raw JSON to Python data types.
 
     Args:
         json (str): The JSON data.
     """
 
-
 def jsonc_to_py(json: str) -> Any:
     """Convert raw JSON to Python data bytes while allowing comments,
     trailing commas, object keys without quotes, single quoted strings and more.
@@ -20,7 +18,6 @@ def jsonc_to_py(json: str) -> Any:
         json (str): The JSONC data.
     """
 
-
 class Regex:
     def __init__(self, m: str): ...
     def validate(self, input: str) -> bool:
@@ -33,10 +30,8 @@ class Regex:
             RuntimeError: Rust-side error.
         """
 
-
 def py_to_bytes(data: Any) -> bytes:
     """Convert Python data to bytes."""
 
-
 def bytes_to_py(data: bytes) -> Any:
     """Convert bytes to Python data."""

python/exacting/types.py

@@ -0,0 +1,117 @@
+import dataclasses as std_dc
+
+from collections import deque
+from typing import Any, Dict, Generic, Optional, Protocol, Type, TypeVar, Union
+
+T = TypeVar("T")
+
+
+class Result(Generic[T]):
+    """Represents a result."""
+
+    ok_data: Optional[T]
+    errors: Optional["deque[str]"]  # O(1)
+
+    def __init__(self, okd: Optional[T], errors: Optional["deque[str]"]):
+        self.ok_data = okd
+        self.errors = errors
+
+    @classmethod
+    def Ok(cls, data: T) -> "Result[T]":
+        return cls(data, None)
+
+    @classmethod
+    def Err(cls, *errors: str) -> "Result[T]":
+        return cls(None, deque(errors))
+
+    def unwrap(self) -> T:
+        """Unwrap the OK data."""
+        # cheap operation lmfao
+        return self.ok_data  # type: ignore
+
+    def unwrap_err(self) -> "deque[str]":
+        """Unwrap the Err data."""
+        # AGAIN. lmfao! you gotta be responsible.
+        return self.errors  # type: ignore
+
+    def is_ok(self) -> bool:
+        """CALL."""
+        return not self.errors
+
+    def trace(self, upper: str) -> "Result[T]":
+        if self.errors is not None:
+            self.errors.appendleft("indent")
+            self.errors.appendleft(upper)
+            self.errors.append("unindent")
+
+        return self
+
+    @classmethod
+    def trace_below(cls, upper: str, *items: str) -> "Result[T]":
+        errors = deque(items)
+        errors.appendleft("indent")
+        errors.appendleft(upper)
+        errors.append("unindent")
+
+        return cls(okd=None, errors=errors)
+
+    def __repr__(self) -> str:
+        if self.is_ok():
+            return f"Result.Ok({self.unwrap()!r})"
+        else:
+            return f"Result.Err({self.unwrap_err()!r})"
+
+
+class Dataclass(Protocol):
+    __dataclass_fields__: Dict[str, std_dc.Field]
+
+
+DataclassType = Union[Type[Dataclass], Any]
+
+
+class _Indexable:
+    def __getitem__(self, k: str): ...
+    def __setitem__(self, k: str, data: Any): ...
+    def as_dict(self) -> dict: ...
+    def as_dc(self) -> Dataclass: ...
+
+
+class _DefinitelyDict(_Indexable):
+    def __init__(self, d: Dict):
+        self.data = d
+
+    def __getitem__(self, k: str):
+        self.data[k]
+
+    def __setitem__(self, k: str, data: Any):
+        self.data[k] = data
+
+    def as_dict(self) -> dict:
+        return self.data
+
+    def as_dc(self) -> Dataclass:
+        raise TypeError("This indexable is not a dataclass but a dict")
+
+
+class _DefinitelyDataclass(_Indexable):
+    def __init__(self, dc: Dataclass):
+        self.dc = dc
+
+    def __getitem__(self, k: str):
+        return getattr(self.dc, k)
+
+    def __setitem__(self, k: str, data: Any):
+        setattr(self.dc, k, data)
+
+    def as_dict(self):
+        raise TypeError("This indexable is not a dict but a dataclass")
+
+    def as_dc(self) -> Dataclass:
+        return self.dc
+
+
+def indexable(item: Any) -> "_Indexable":
+    if isinstance(item, dict):
+        return _DefinitelyDict(item)
+    else:
+        return _DefinitelyDataclass(item)

python/exacting/validator_map.py

@@ -0,0 +1,92 @@
+import dataclasses
+from dataclasses import is_dataclass
+from types import NoneType, UnionType
+from typing import Annotated, Any, Dict, Literal, Union, get_origin
+from weakref import ref
+
+from .validators import (
+    AnnotatedV,
+    AnyV,
+    BoolV,
+    BytesV,
+    DataclassV,
+    DictV,
+    FloatV,
+    IntV,
+    ListV,
+    LiteralV,
+    NoneV,
+    StrV,
+    UnionV,
+    Validator,
+)
+from .types import DataclassType
+
+NONEV = NoneV()
+STRV = StrV()
+INTV = IntV()
+FLOATV = FloatV()
+BOOLV = BoolV()
+BYTESV = BytesV()
+ANYV = AnyV()
+
+
+def get_validator(typ: Any) -> Validator:
+    if typ is None or isinstance(typ, NoneType) or typ is NoneType:
+        return NONEV
+    if typ is str:
+        return STRV
+    if typ is int:
+        return INTV
+    if typ is float:
+        return FLOATV
+    if typ is bool:
+        return BOOLV
+    if typ is bytes:
+        return BYTESV
+    if typ is Any:
+        return ANYV
+
+    if is_dataclass(typ):
+        return get_dc_validator(typ)
+
+    origin = get_origin(typ)
+    if origin is list:
+        return ListV(get_validator(typ.__args__[0]))
+    if origin is dict:
+        return DictV(get_validator(typ.__args__[0]), get_validator(typ.__args__[1]))
+    if origin is Union or origin is UnionType:
+        return union(*typ.__args__)
+    if origin is Literal:
+        return LiteralV(typ.__args__)
+    if origin is Annotated:
+        return AnnotatedV(typ.__args__[0], typ.__metadata__)
+
+    raise TypeError(
+        f"Unknown type: {typ!r} (no type validator available at this moment)"
+    )
+
+
+def union(*items) -> Validator:
+    if len(items) == 1:
+        return get_validator(items[0])
+    return UnionV(get_validator(items[0]), union(*items[1:]))
+
+
+def get_map_for_dc(dc: DataclassType) -> Dict[str, Validator]:
+    vmap = {}
+    _FIELD = getattr(dataclasses, "_FIELD")
+
+    for field in dc.__dataclass_fields__.values():
+        if getattr(field, "_field_type") is not _FIELD:
+            raise NotImplementedError(
+                "Currently, exacting only supports regular fields :(\n"
+                f"...at field {field.name!r}, dataclass {dc!r}"
+            )
+        vmap[field.name] = get_validator(field.type)
+
+    return vmap
+
+
+def get_dc_validator(dc: DataclassType) -> DataclassV:
+    return DataclassV(ref(dc), get_map_for_dc(dc))