jsonlogic-py 0.1__tar.gz

jsonlogic_py-0.1/LICENSE.txt

@@ -0,0 +1,7 @@
+Copyright 2023-2024 Lawrence Livermore National Laboratory
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

jsonlogic_py-0.1/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.1
+Name: jsonlogic-py
+Version: 0.1
+Summary: A Python package that emits JSON Logic
+Author: Peter Pirkelbauer, Seth Bromberger
+Project-URL: Homepage, https://github.com/MetallData/jsonlogic
+Project-URL: Issues, https://github.com/MetallData/jsonlogic/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: coverage; extra == "dev"
+Requires-Dist: json-logic-qubit; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+
+## jsonlogic.py - JSON Logic expression generator
+
+This package provides functionality to express JSON Logic using standard Python datastructures.
+
+An example:
+
+```python
+>>> from jsonlogic import Variable
+>>> v1 = Variable('var1')
+>>> v2 = Variable('var2')
+>>> e = (v1 < v2)
+>>> print(e)
+{"<": [{"var": "var1"}, {"var": "var2"}]}
+>>> print (v1 < 3)
+{"<": [{"var": "var1"}, 3]}
+>>> print ( (v1 < 3) & (v1 > v2))
+{"and": [{"<": [{"var": "var1"}, 3]}, {">": [{"var": "var1"}, {"var": "var2"}]}]}
+>>> print ( (v1 < 3) & ~(v1 > v2)))  # ~ is "not"
+{"and": [{"<": [{"var": "v1"}, 3]}, {"not": [{">": [{"var": "v1"}, {"var": "v2"}]}]}]}
+```

jsonlogic_py-0.1/README.md

@@ -0,0 +1,20 @@
+## jsonlogic.py - JSON Logic expression generator
+
+This package provides functionality to express JSON Logic using standard Python datastructures.
+
+An example:
+
+```python
+>>> from jsonlogic import Variable
+>>> v1 = Variable('var1')
+>>> v2 = Variable('var2')
+>>> e = (v1 < v2)
+>>> print(e)
+{"<": [{"var": "var1"}, {"var": "var2"}]}
+>>> print (v1 < 3)
+{"<": [{"var": "var1"}, 3]}
+>>> print ( (v1 < 3) & (v1 > v2))
+{"and": [{"<": [{"var": "var1"}, 3]}, {">": [{"var": "var1"}, {"var": "var2"}]}]}
+>>> print ( (v1 < 3) & ~(v1 > v2)))  # ~ is "not"
+{"and": [{"<": [{"var": "v1"}, 3]}, {"not": [{">": [{"var": "v1"}, {"var": "v2"}]}]}]}
+```

jsonlogic_py-0.1/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools >= 68.0.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "jsonlogic-py"
+version = "0.1"
+authors = [
+  { name="Peter Pirkelbauer"}, { name="Seth Bromberger"}
+]
+description="A Python package that emits JSON Logic"
+readme = "README.md"
+dynamic = ["dependencies", "optional-dependencies"]
+requires-python = ">=3.10"
+classifiers = [
+        "Development Status :: 3 - Alpha",
+        "Programming Language :: Python :: 3",
+        "Intended Audience :: Science/Research",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent"
+]
+
+[tool.setuptools.dynamic]
+dependencies = {file = ["requirements.txt"]}
+optional-dependencies = {dev = {file = ["requirements-dev.txt"] }}
+
+
+[project.urls]
+Homepage = "https://github.com/MetallData/jsonlogic"
+Issues = "https://github.com/MetallData/jsonlogic/issues"

jsonlogic_py-0.1/requirements-dev.txt

@@ -0,0 +1,5 @@
+pytest
+coverage
+json-logic-qubit
+flake8
+mypy

jsonlogic_py-0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

jsonlogic_py-0.1/src/jsonlogic/__init__.py

@@ -0,0 +1,128 @@
+""" JSONLogic emitters """
+
+from __future__ import annotations
+from typing import Any
+import json
+from .operations import Operation, jl_operations
+from .errors import JsonLogicArgumentError
+from .classes import Entity
+from .jsontypes import PyJsonType, deduce_type
+
+
+class Operand(Entity):
+    """An abstract base class representing an JSONLogic operand"""
+
+    def __new__(cls, *_, **__):
+        for dunder, op in jl_operations.items():
+            setattr(cls, dunder, lambda self, *x, o=op: Expression(o, self, *x))
+        return super().__new__(cls)
+
+    def prepare(self) -> Any:
+        """prepares the structure for json by converting it into something that can be dumped"""
+        raise NotImplementedError()
+
+    def to_json(self) -> str:
+        """represents the object as JSON"""
+        return json.dumps(self.prepare())
+
+    def __str__(self):
+        return self.to_json()
+
+
+class Literal(Operand):
+    """A JSONLogic literal."""
+
+    def __init__(self, val: PyJsonType | Literal, docstr: str | None = None):
+        super().__init__()
+        self._rawval: PyJsonType = val._rawval if isinstance(val, Literal) else val
+
+        self.type = deduce_type(val)
+        if docstr is not None:
+            self.__doc__ = docstr
+
+    def __repr__(self):
+        return str(self.type)
+
+    def __str__(self):
+        return str(self.type)
+
+    def prepare(self) -> PyJsonType:
+        return self.type.prepare()
+
+
+class Variable(Operand):
+    """A JSONLogic variable"""
+
+    def __init__(self, var: str, docstr: str | None = None):
+        super().__init__()
+        self.var = var
+        if docstr is not None:
+            self.__doc__ = docstr
+
+    def prepare(self):
+        return {"var": self.var}
+
+
+class Expression(Operand):
+    """A JSONLogic expression"""
+
+    def __init__(
+        self,
+        op: Operation,
+        o1: Variable | Expression,
+        *on: Operand | PyJsonType,
+    ):
+        super().__init__()
+        # if op is None then this expression is just a native Selector held in o1.
+        self.op = op
+        self.o1 = o1
+        if op.arity is not None and len(on) != op.arity - 1:
+            raise JsonLogicArgumentError(
+                f"incorrect number of arguments for {op}: wanted {op.arity}, got {len(on) + 1}"
+            )
+        # add the remaining variables, casting them to Literals if they're not Variables, Expressions, or Literals.
+        self.on = tuple(Literal(o) if not isinstance(o, Operand) else o for o in on)
+
+    def prepare(self):
+        return {
+            str(self.op): [self.o1.prepare()]
+            + list(x.prepare() if isinstance(x, Operand) else x for x in self.on)
+        }
+
+
+# class Type(ABC):
+#     """The abstract base class for all JSONLogic Types"""
+
+# def __init__(self, value):
+#     _value = value
+
+
+# class Number(Type, float):
+#     """Type representing a JSONLogic number"""
+
+
+# class String(Type, str):
+#     """Type representing a JSONLogic string"""
+
+
+# class Object(Type, dict):
+#     """Type representing a JSONLogic object (map)"""
+
+
+# class Bool(Type):
+#     """Type representing a JSONLogic boolean"""
+
+#     def __init__(self, value):
+#         self.
+
+
+# class Array(Type, list):
+#     """Type representing a JSONLogic array (list)"""
+
+
+# class Null(Type, NoneType):
+#     """Type representing a JSONLogic null"""
+
+
+# class _Any(Type, Any):
+#     """Type representing any JSONLogic type"""

jsonlogic_py-0.1/src/jsonlogic/classes.py

@@ -0,0 +1,8 @@
+# pylint: disable=too-few-public-methods
+""" Abstract base class for JsonLogic """
+
+from abc import ABC
+
+
+class Entity(ABC):
+    """The abstract base class for all JSONLogic entities"""

jsonlogic_py-0.1/src/jsonlogic/errors.py

@@ -0,0 +1,9 @@
+""" Error classes for jsonlogic """
+
+
+class JsonLogicError(Exception):
+    """top-level error for JsonLogic"""
+
+
+class JsonLogicArgumentError(JsonLogicError):
+    """raised when there is a problem with an argument to an expression."""

jsonlogic_py-0.1/src/jsonlogic/jsontypes.py

@@ -0,0 +1,89 @@
+# pylint: disable=too-few-public-methods
+
+""" JSON typing classes and functions """
+
+from __future__ import annotations
+from abc import ABC
+import warnings
+
+from typing import Any
+
+PyJsonType = int | float | bool | str | list | dict
+
+
+class JsonType(ABC):
+    """The abstract base class for JSON types"""
+
+    typename = "UNDEFINED"
+
+    def __init__(self, val):
+        self.val = val
+
+    def __str__(self):
+        return f"[{self.typename}]{self.val}"
+
+    def prepare(self) -> PyJsonType:
+        """Prepares the type for JSON serialization"""
+        raise NotImplementedError("class has not defined prepare()")
+
+
+class JsonNumber(JsonType):
+    """A JSON Number type"""
+
+    typename = "Number"
+
+    def prepare(self):
+        return int(self.val) if isinstance(self.val, int) else float(self.val)
+
+
+class JsonBool(JsonType):
+    """A JSON Boolean type"""
+
+    typename = "Boolean"
+
+    def prepare(self) -> bool:
+        return bool(self.val)
+
+
+class JsonStr(JsonType):
+    """A JSON String type"""
+
+    typename = "String"
+
+    def prepare(self) -> str:
+        return str(self.val)
+
+
+class JsonArray(JsonType):
+    """A JSON Array type"""
+
+    typename = "Array"
+
+    def prepare(self) -> list:
+        return list(self.val)
+
+
+class JsonObj(JsonType):
+    """A JSON Object type"""
+
+    typename = "Object"
+
+    def prepare(self) -> dict:
+        return dict(self.val)
+
+
+def deduce_type(val: Any) -> JsonType:
+    """Given a value, try to deduce the json datatype. Default is string."""
+    if isinstance(val, bool):
+        return JsonBool(val)
+    if isinstance(val, (float, int)):
+        return JsonNumber(val)
+    if isinstance(val, list):
+        return JsonArray(val)
+    if isinstance(val, dict):
+        return JsonObj(val)
+    if not isinstance(val, str):
+        warnings.warn(
+            f"cannot deduce type of {val} ({type(val)}); assuming string", UserWarning
+        )
+    return JsonStr(str(val))

jsonlogic_py-0.1/src/jsonlogic/operations.py

@@ -0,0 +1,90 @@
+# Copyright 2020 Lawrence Livermore National Security, LLC and other CLIPPy Project Developers.
+# See the top-level COPYRIGHT file for details.
+#
+# SPDX-License-Identifier: MIT
+
+""" Holds the expression building code. """
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable
+from .classes import Entity
+
+
+@dataclass
+class Operation(Entity):
+    """A JSONLogic operation"""
+
+    op: str
+    arity: int | None  # None means unlimited
+
+    def __repr__(self):
+        return self.op
+
+    def __str__(self):
+        return str(self.op)
+
+
+_jl_lt = Operation("<", 2)
+_jl_le = Operation("<=", 2)
+_jl_eq = Operation("==", 2)
+_jl_ne = Operation("!=", 2)
+_jl_gt = Operation(">", 2)
+_jl_ge = Operation(">=", 2)
+_jl_add = Operation("+", 2)
+_jl_sub = Operation("-", 2)
+_jl_mul = Operation("*", 2)
+_jl_matmul = Operation("@", 2)
+_jl_truediv = Operation("/", 2)
+_jl_floordiv = Operation("//", 2)
+_jl_mod = Operation("%", 2)
+_jl_divmod = Operation("divmod", 2)
+_jl_pow = Operation("**", 2)
+_jl_lshift = Operation("<<", 2)
+_jl_rshift = Operation(">>", 2)
+_jl_and = Operation("and", 2)  # single &
+_jl_not = Operation("not", 1)
+_jl_xor = Operation("^", 2)
+_jl_or = Operation("or", 2)  # single |
+# _jl_contains = Operation():
+#     raise NotImplementedError("syntax a in b is not supported. Use b.contains(a) instead.")
+#     # will not work when written as "x in set",
+#     #   b/c the in-operator always converts the result to bool
+#     #   https://stackoverflow.com/questions/38542543/functionality-of-python-in-vs-contains
+#     #   https://bugs.python.org/issue16011
+#     # return Expression("in", o, self)
+
+# # to be modeled after Pandas' str.contains
+_jl_contains = Operation("in", 2)
+_jl_regex = Operation("regex", 2)
+
+# string and array concatenation
+_jl_cat = Operation("cat", None)
+
+jl_operations: dict[str, Operation | Callable[..., Operation]] = {
+    "__lt__": _jl_lt,
+    "__le__": _jl_le,
+    "__eq__": _jl_eq,
+    "__ne__": _jl_ne,
+    "__gt__": _jl_gt,
+    "__ge__": _jl_ge,
+    "__add__": _jl_add,
+    "__sub__": _jl_sub,
+    "__mul__": _jl_mul,
+    "__matmul__": _jl_matmul,
+    "__truediv__": _jl_truediv,
+    "__floordiv__": _jl_floordiv,
+    "__mod__": _jl_mod,
+    "__divmod__": _jl_divmod,
+    "__pow__": _jl_pow,
+    "__lshift__": _jl_lshift,
+    "__rshift__": _jl_rshift,
+    "__and__": _jl_and,
+    "__xor__": _jl_xor,
+    "__or__": _jl_or,
+    "__invert__": _jl_not,
+    "contains": _jl_contains,
+    "regex": _jl_regex,
+    "cat": _jl_cat,
+}

jsonlogic_py-0.1/src/jsonlogic_py.egg-info/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.1
+Name: jsonlogic-py
+Version: 0.1
+Summary: A Python package that emits JSON Logic
+Author: Peter Pirkelbauer, Seth Bromberger
+Project-URL: Homepage, https://github.com/MetallData/jsonlogic
+Project-URL: Issues, https://github.com/MetallData/jsonlogic/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: coverage; extra == "dev"
+Requires-Dist: json-logic-qubit; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+
+## jsonlogic.py - JSON Logic expression generator
+
+This package provides functionality to express JSON Logic using standard Python datastructures.
+
+An example:
+
+```python
+>>> from jsonlogic import Variable
+>>> v1 = Variable('var1')
+>>> v2 = Variable('var2')
+>>> e = (v1 < v2)
+>>> print(e)
+{"<": [{"var": "var1"}, {"var": "var2"}]}
+>>> print (v1 < 3)
+{"<": [{"var": "var1"}, 3]}
+>>> print ( (v1 < 3) & (v1 > v2))
+{"and": [{"<": [{"var": "var1"}, 3]}, {">": [{"var": "var1"}, {"var": "var2"}]}]}
+>>> print ( (v1 < 3) & ~(v1 > v2)))  # ~ is "not"
+{"and": [{"<": [{"var": "v1"}, 3]}, {"not": [{">": [{"var": "v1"}, {"var": "v2"}]}]}]}
+```

jsonlogic_py-0.1/src/jsonlogic_py.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE.txt
+README.md
+pyproject.toml
+requirements-dev.txt
+requirements.txt
+src/jsonlogic/__init__.py
+src/jsonlogic/classes.py
+src/jsonlogic/errors.py
+src/jsonlogic/jsontypes.py
+src/jsonlogic/operations.py
+src/jsonlogic_py.egg-info/PKG-INFO
+src/jsonlogic_py.egg-info/SOURCES.txt
+src/jsonlogic_py.egg-info/dependency_links.txt
+src/jsonlogic_py.egg-info/requires.txt
+src/jsonlogic_py.egg-info/top_level.txt
+test/test_classes.py
+test/test_jsonlogic.py
+test/test_types.py

jsonlogic_py-0.1/src/jsonlogic_py.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

jsonlogic_py-0.1/src/jsonlogic_py.egg-info/requires.txt

@@ -0,0 +1,7 @@
+
+[dev]
+pytest
+coverage
+json-logic-qubit
+flake8
+mypy

jsonlogic_py-0.1/src/jsonlogic_py.egg-info/top_level.txt

@@ -0,0 +1 @@
+jsonlogic

jsonlogic_py-0.1/test/test_classes.py

@@ -0,0 +1,66 @@
+import pytest
+import sys
+
+sys.path.append("src")
+
+from jsonlogic import Expression, Variable, Literal, Operand, Operation
+from jsonlogic.classes import Entity
+from dataclasses import dataclass
+
+
+@pytest.fixture
+def op1():
+    return Operation("op1", 1)
+
+
+@pytest.fixture
+def op2():
+    return Operation("op2", 2)
+
+
+@pytest.fixture
+def v1():
+    return Variable("var1", "docstring for var1")
+
+
+@pytest.fixture
+def v2():
+    return Variable("var2")
+
+
+@pytest.fixture
+def l1():
+    return Literal(5, "docstring for literal")
+
+
+@pytest.fixture
+def l2():
+    return Literal("stringliteral")
+
+
+def test_expression(op1, op2, v1, v2, l1, l2):
+    e = Expression(op1, v1)
+    assert e.to_json() == str(e) == '{"op1": [{"var": "var1"}]}'
+
+    e = Expression(op2, v1, v2)
+    assert e.to_json() == str(e) == '{"op2": [{"var": "var1"}, {"var": "var2"}]}'
+
+    e = Expression(op2, v1, l1)
+    assert e.to_json() == str(e) == '{"op2": [{"var": "var1"}, 5]}'
+
+
+def test_operations():
+    o = Operation("foo", 1)
+    assert repr(o) == "foo"
+    assert str(o) == "foo"
+
+
+def test_literals(l1, l2):
+    assert repr(l1) == str(l1) == "[Number]5"
+    assert repr(l2) == str(l2) == "[String]stringliteral"
+
+
+def test_operand():
+    o = Operand()
+    with pytest.raises(NotImplementedError):
+        o.prepare()

jsonlogic_py-0.1/test/test_jsonlogic.py

@@ -0,0 +1,126 @@
+import pytest
+import sys
+
+sys.path.append("src")
+
+from json_logic import jsonLogic
+
+import jsonlogic as jl
+from jsonlogic.errors import JsonLogicArgumentError
+from dataclasses import dataclass
+
+
+@dataclass
+class TV(dict):
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def __getitem__(self, val):
+        return self.get(val)[1]
+
+    def getname(self, val):
+        return self.get(val)[0]
+
+
+@pytest.fixture
+def _i():
+    return TV({n: (f"var{n}", jl.Variable(f"var{n}")) for n in range(1, 5)})
+
+
+@pytest.fixture
+def _f():
+    fs = [1.1, 2.0, 2.1, 2.2, 3.3, 4.4]
+    return TV({n: (f"var{int(n*10)}", jl.Variable(f"var{int(n*10)}")) for n in fs})
+
+
+@pytest.fixture
+def _s():
+    ss = ["a", "b", "c", "d", "e"]
+    return TV({n: (f"var{n}", jl.Variable(f"var{n}")) for n in ss})
+
+
+def assert_op(e: jl.Expression, d):
+    assert jsonLogic(e.prepare(), d)
+
+
+def test_lt_gt_ne(_s, _i, _f):
+    test_int = [
+        _i[1] < _i[2],
+        _i[1] <= _i[1],
+        _i[1] <= _i[2],
+        _i[2] > _i[1],
+        _i[2] >= _i[1],
+        _i[2] >= _i[2],
+        _i[1] != _i[2],
+    ]
+    test_float = [
+        _f[1.1] < _f[2.0],
+        _f[2.0] <= _f[2.0],
+        _f[2.0] <= _f[2.1],
+        _f[4.4] >= _f[2.1],
+        _f[4.4] != _f[2.2],
+    ]
+    test_str = {
+        _s["a"] < _s["b"],
+        _s["a"] <= _s["a"],
+        _s["b"] > _s["a"],
+        _s["b"] >= _s["b"],
+        _s["a"] != _s["b"],
+    }
+
+    for t in test_int:
+        d = {_i.getname(k): k for k in _i}
+        assert len(d) > 0
+        assert_op(t, d)
+
+    for t in test_float:
+        d = {_f.getname(k): k for k in _f}
+        assert_op(t, d)
+
+    for t in test_str:
+        d = {_s.getname(k): k for k in _s}
+        assert_op(t, d)
+
+
+def test_eq_add_mul_truediv_floordiv(_i, _f):
+    test_int = [
+        _i[1] + 1 == _i[2],
+        _i[2] + 2 == _i[4],
+        _i[2] + _i[2] == _i[4],
+        _i[2] * 2 == _i[4],
+        _i[2] * _i[2] == _i[4],
+    ]
+    test_float = [
+        _f[1.1] + 1.1 == _f[2.2],
+        _f[2.2] + 2.2 == _f[4.4],
+        _f[2.2] + _f[2.2] == _f[4.4],
+        _f[2.2] * 2 == _f[4.4],
+        _f[2.2] * _f[2.0] == _f[4.4],
+    ]
+
+    for t in test_int:
+        d = {_i.getname(k): k for k in _i}
+        assert_op(t, d)
+
+    for t in test_float:
+        d = {_f.getname(k): k for k in _f}
+        assert_op(t, d)
+
+
+def test_bad_args():
+    with pytest.raises(JsonLogicArgumentError):
+        o = jl.Operation("foo", 1)
+        v = jl.Variable("var1")
+        jl.Expression(o, v, 1)
+
+
+def test_operations():
+    o = jl.Operation("foo", 1)
+    assert repr(o) == "foo"
+    assert str(o) == "foo"
+
+
+# def test_float_eq_add_mul_truediv_floordiv(var1, var2, var4, var5, data_float):
+#     for t in tests:
+#         assert_op(t, data_float)

jsonlogic_py-0.1/test/test_types.py

@@ -0,0 +1,85 @@
+import warnings
+import sys
+import pytest
+
+sys.path.append('src')
+from jsonlogic.jsontypes import JsonArray, JsonBool, JsonNumber, JsonStr, JsonObj, deduce_type, PyJsonType, JsonType
+
+
+def test_bool():
+    b = JsonBool(True)
+    assert b.typename == 'Boolean'
+    assert b.val is True
+    assert isinstance(b.val, bool)
+    assert str(b) == "[Boolean]True"
+    assert b.prepare() is True
+
+
+def test_int():
+    b = JsonNumber(10)
+    assert b.typename == 'Number'
+    assert b.val == 10
+    assert isinstance(b.val, int)
+    assert str(b) == "[Number]10"
+    assert b.prepare() == 10
+
+
+def test_float():
+    b = JsonNumber(10.1)
+    assert b.typename == 'Number'
+    assert b.val == 10.1
+    assert isinstance(b.val, float)
+    assert str(b) == "[Number]10.1"
+    assert b.prepare() == 10.1
+
+
+def test_dict():
+    d = {'a': 1, 'b': 2}
+    b = JsonObj(d)
+    assert b.typename == 'Object'
+    assert b.val == d
+    assert isinstance(b.val, dict)
+    assert str(b).startswith("[Object]")
+    assert b.prepare() == d
+
+
+def test_str():
+    b = JsonStr("hello")
+    assert b.typename == 'String'
+    assert b.val == "hello"
+    assert isinstance(b.val, str)
+    assert str(b).startswith("[String]")
+    assert b.prepare() == "hello"
+
+
+def test_list():
+    d = [1, 2, 3, 4, 5]
+    b = JsonArray(d)
+    assert b.typename == 'Array'
+    assert b.val == d
+    assert isinstance(b.val, list)
+    assert str(b).startswith("[Array]")
+    assert b.prepare() == d
+
+
+def test_deduce():
+    assert isinstance(deduce_type(True), JsonBool)
+    assert isinstance(deduce_type(10), JsonNumber)
+    assert isinstance(deduce_type(10.1), JsonNumber)
+    assert isinstance(deduce_type({'a': 1}), JsonObj)
+    assert isinstance(deduce_type(""), JsonStr)
+    assert isinstance(deduce_type([]), JsonArray)
+
+    with pytest.warns(UserWarning, match=r"cannot deduce type.*"):
+        assert isinstance(deduce_type(complex(1, 2)), JsonStr)
+
+
+def test_jsontype():
+    class TestType(JsonType):
+        pass
+
+    tt = TestType(10)
+    assert tt.typename == "UNDEFINED"
+    assert str(tt) == "[UNDEFINED]10"
+    with pytest.raises(NotImplementedError):
+        tt.prepare()