oop

Author: AWeirdDev

Cargo.lock

@@ -9,6 +9,9 @@ name = "exacting"
 crate-type = ["cdylib"]
 
 [dependencies]
-arcstr = "1.2.0"
-crossbeam = "0.8.4"
-pyo3 = "0.25.0"
+anyhow = "1.0.98"
+ijson = "0.1.4"
+pyo3 = { version = "0.25.0", features = ["anyhow"] }
+serde = "1.0.219"
+serde_json = "1.0.140"
+serde_json5 = "0.2.1"

Cargo.toml

@@ -1,10 +1,11 @@
 from typing import TYPE_CHECKING, Callable, List, Type, TypeVar
-from typing_extensions import dataclass_transform
+from typing_extensions import Self, dataclass_transform
 
 import dataclasses
 from dataclasses import asdict, dataclass, is_dataclass
 
 from .dc import get_etypes_for_dc
+from .exacting import json as ejson  # type: ignore
 
 T = TypeVar("T", bound=Type)
 
@@ -36,7 +37,7 @@ def init(self, *args, **kwargs):
 
         if covered != len(etypes):
             raise ValueError(
-                f"(dataclass {dc.__name__!r}) Expected to cover {len(etypes)} parameters, but got {covered}"
+                f"(dataclass {dc.__name__!r}) Expected to cover {len(etypes)} parameter(s), but got {covered}"
             )
 
         if args:
@@ -130,10 +131,55 @@ 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.
+        """(exacting) Creates a dictionary representation of this dataclass instance.
 
         Raises:
             AssertionError: Expected a dataclass
         """
         assert is_dataclass(self)
         return asdict(self)
+
+    @classmethod
+    def exact_from_json(cls, raw: str, *, strict: bool = True) -> Self:
+        """(exacting) Initialize this dataclass model from JSON.
+
+        When `strict` is set to `False`, exacting uses JSON5, allowing comments,
+        trailing commas, object keys without quotes, single quoted strings and more.
+
+        Example:
+
+        ```python
+        class Person(Exact):
+            name: str
+            age: int
+
+        # strict mode (default)
+        Person.exact_from_json(\"\"\"
+        {
+            "name": "Harry",
+            "age": 23
+        }
+        \"\"\")
+
+        # lenient :)
+        Person.exact_from_json(\"\"\"
+        {
+            /*
+                hell yeah!
+            */
+            name: "Walter",
+            age: 23, // <- trailing commas? yeah!
+        }
+        \"\"\", strict=False)
+        ```
+
+        Args:
+            raw (str): The raw JSON.
+            strict (bool): Whether to use strict mode.
+        """
+        if strict:
+            data = ejson.json_to_py(raw)
+        else:
+            data = ejson.jsonc_to_py(raw)
+
+        return cls(**data)

python/exacting/core.py

@@ -0,0 +1 @@
+from . import json as json

python/exacting/exacting.pyi

@@ -0,0 +1,21 @@
+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.
+
+    Uses JSON5:
+    > JSON5 is a superset of JSON with an expanded syntax including some productions from ECMAScript 5.1.
+
+    Args:
+        json (str): The JSONC data.
+    """

python/exacting/exacting/__init__.pyi

@@ -1,6 +1,121 @@
-use pyo3::prelude::*;
+use pyo3::{
+    exceptions,
+    prelude::*,
+    types::{ PyBool, PyDict, PyFloat, PyInt, PyList, PyNone, PyString },
+};
+
+use ijson::{ IValue, ValueType };
+
+#[pyfunction]
+fn json_to_py(py: Python, json: &str) -> PyResult<Py<PyAny>> {
+    let value = match serde_json::from_str::<IValue>(json) {
+        Ok(d) => d,
+        Err(e) => {
+            return Err(
+                exceptions::PyRuntimeError::new_err(format!("Failed to load JSON:\n{:#?}", e))
+            );
+        }
+    };
+    ivalue_to_py(py, value)
+}
+
+#[pyfunction]
+fn jsonc_to_py(py: Python, json: &str) -> PyResult<Py<PyAny>> {
+    let value = match serde_json5::from_str::<IValue>(json) {
+        Ok(d) => d,
+        Err(e) => {
+            return Err(
+                exceptions::PyRuntimeError::new_err(format!("Failed to load JSONC:\n{:#?}", e))
+            );
+        }
+    };
+    ivalue_to_py(py, value)
+}
+
+fn ivalue_to_py(py: Python, value: IValue) -> PyResult<Py<PyAny>> {
+    match value.type_() {
+        ValueType::Array => {
+            let list = PyList::empty(py);
+            let Ok(array) = value.into_array() else {
+                return Err(exceptions::PyRuntimeError::new_err("Failed to convert into array"));
+            };
+
+            for item in array {
+                let value = ivalue_to_py(py, item)?;
+                list.append(value)?;
+            }
+
+            Ok(list.unbind().into())
+        }
+        ValueType::Bool => {
+            let b = PyBool::new(py, value.to_bool().unwrap());
+            Ok(unsafe { Py::from_borrowed_ptr_or_opt(py, b.as_ptr()).unwrap() })
+        }
+        ValueType::Null => {
+            let none = PyNone::get(py);
+            Ok(unsafe { Py::from_borrowed_ptr_or_opt(py, none.as_ptr()).unwrap() })
+        }
+        ValueType::Number => {
+            let Ok(number) = value.into_number() else {
+                return Err(exceptions::PyRuntimeError::new_err("Failed to convert into number"));
+            };
+
+            if number.has_decimal_point() {
+                Ok(PyFloat::new(py, number.to_f64().unwrap()).unbind().into())
+            } else {
+                Ok(PyInt::new(py, number.to_i64().unwrap()).unbind().into())
+            }
+        }
+        ValueType::Object => {
+            let Ok(object) = value.into_object() else {
+                return Err(exceptions::PyRuntimeError::new_err("Failed to convert into object"));
+            };
+
+            let dict = PyDict::new(py);
+            for (key, value) in object {
+                dict.set_item(key.as_str(), ivalue_to_py(py, value)?)?;
+            }
+
+            Ok(dict.unbind().into())
+        }
+        ValueType::String => {
+            let Ok(s) = value.into_string() else {
+                return Err(exceptions::PyRuntimeError::new_err("Failed to convert into string"));
+            };
+            Ok(PyString::new(py, s.as_str()).unbind().into())
+        }
+    }
+}
+
+// #[derive(FromPyObject)]
+// enum AnyPy {
+//     List(Py<PyList>),
+//     Dict(Py<PyDict>),
+//     Str(String),
+//     Bool(bool),
+//     None(Py<PyNone>),
+//     Int(i64),
+//     Float(f64),
+// }
 
 #[pymodule]
-fn exacting(m: &Bound<'_, PyModule>) -> PyResult<()> {
-    Ok(())
+mod exacting {
+    use super::*;
+
+    #[pymodule]
+    mod json {
+        use super::*;
+
+        #[pymodule_init]
+        fn init(m: &Bound<'_, PyModule>) -> PyResult<()> {
+            m.add_function(wrap_pyfunction!(json_to_py, m)?)?;
+            m.add_function(wrap_pyfunction!(jsonc_to_py, m)?)?;
+            Ok(())
+        }
+    }
+
+    #[pymodule_init]
+    fn init(_m: &Bound<'_, PyModule>) -> PyResult<()> {
+        Ok(())
+    }
 }

python/exacting/exacting/json.pyi

@@ -0,0 +1,21 @@
+from exacting import Exact
+
+
+class Person(Exact):
+    name: str
+    age: int
+
+
+d = Person.exact_from_json(
+    """
+{
+    /*
+        hell yeah!
+    */
+    name: "Walter",
+    age: 23, // <- yeah, just do whatever!
+}
+""",
+    strict=False,
+)
+print(d)