forestwalker 0.1__tar.gz

forestwalker-0.1/.gitignore

@@ -0,0 +1,4 @@
+__pycache__
+dist
+docs.out
+venv

forestwalker-0.1/.readthedocs.yml

@@ -0,0 +1,19 @@
+# Read the Docs configuration file
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+# Required
+version: 2
+
+# Set the OS, Python version, and other tools you might need
+build:
+  os: ubuntu-24.04
+  tools:
+    python: "3.13"
+
+# Build documentation in the "docs/" directory with Sphinx
+sphinx:
+   configuration: docs/conf.py
+
+python:
+   install:
+   - requirements: docs/requirements.txt

forestwalker-0.1/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2026 Martin Mareš
+
+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 (including the next
+paragraph) 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.

forestwalker-0.1/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: forestwalker
+Version: 0.1
+Summary: A library for walking JSON-like trees, parsing and validating them.
+Project-URL: Repository, https://github.com/gollux/forestwalker.git
+Project-URL: Documentation, https://forestwalker.readthedocs.io/en/latest/
+Project-URL: Issues, https://github.com/gollux/forestwalker/issues
+Author-email: Martin Mareš <mj@ucw.cz>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: File Formats :: JSON
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# The Forest Walker
+
+Python modules for parsing JSON, TOML, YAML, and similar formats
+produce simple tree structures composed of numbers, strings, Booleans,
+arrays, and dictionaries. These structures are then parsed for the second
+time to produce more Pythonic data structures. This usually involves
+validation of some kind.
+
+We firmly believe that parsing and validation should not be separate
+steps: structure of data should have a single source of truth (doing 
+otherwise opens door to security issues). Also, existing formal descriptions
+of syntax (e.g., JSON schema) are too weak for many purposes and unwieldy
+for others.
+
+Enters the ``forestwalker``. A Python module that makes it easy to traverse
+trees, parse values while checking types, and report invalid data with
+their precise location in the tree.
+
+## License
+
+The Forest Walker was written by Martin Mareš <mj@ucw.cz>.
+It can be freely used and distributed under the MIT License.

forestwalker-0.1/README.md

@@ -0,0 +1,22 @@
+# The Forest Walker
+
+Python modules for parsing JSON, TOML, YAML, and similar formats
+produce simple tree structures composed of numbers, strings, Booleans,
+arrays, and dictionaries. These structures are then parsed for the second
+time to produce more Pythonic data structures. This usually involves
+validation of some kind.
+
+We firmly believe that parsing and validation should not be separate
+steps: structure of data should have a single source of truth (doing 
+otherwise opens door to security issues). Also, existing formal descriptions
+of syntax (e.g., JSON schema) are too weak for many purposes and unwieldy
+for others.
+
+Enters the ``forestwalker``. A Python module that makes it easy to traverse
+trees, parse values while checking types, and report invalid data with
+their precise location in the tree.
+
+## License
+
+The Forest Walker was written by Martin Mareš <mj@ucw.cz>.
+It can be freely used and distributed under the MIT License.

forestwalker-0.1/docs/api.rst

@@ -0,0 +1,7 @@
+API
+===
+
+.. automodule:: forestwalker
+   :members:
+   :show-inheritance:
+   :member-order: bysource

forestwalker-0.1/docs/conf.py

@@ -0,0 +1,29 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# For the full list of built-in configuration values, see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Project information -----------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
+
+project = 'The Forest Walker'
+copyright = '2026, Martin Mareš'
+author = 'Martin Mareš'
+
+# -- General configuration ---------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
+
+extensions = ['sphinx.ext.autodoc']
+
+templates_path = ['_templates']
+exclude_patterns = []
+
+autodoc_inherit_docstrings = False
+
+
+
+# -- Options for HTML output -------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
+
+html_theme = 'alabaster'
+html_static_path = ['_static']

forestwalker-0.1/docs/example1.py

@@ -0,0 +1,15 @@
+from forestwalker import Walker, WalkerError
+
+tree = {
+    'name': 'Robin Hood',
+    'height': 184,
+}
+
+try:
+    root = Walker(tree)
+    with root.enter_object() as obj:
+        name = obj['name'].as_str()
+        height = obj['height'].as_float(100)
+        print(name, height)
+except WalkerError as err:
+    print(f'Parse error: {err}')

forestwalker-0.1/docs/examples.rst

@@ -0,0 +1,13 @@
+Examples
+========
+
+==============
+Object parsing
+==============
+
+The following code parses a simple JSON object (dictionary)
+with two attributes: ``name`` is mandatory, while ``height``
+defaults to 100 if missing. The context manager makes sure
+that the object contains only keys referenced by the parser.
+
+.. literalinclude:: example1.py

forestwalker-0.1/docs/index.rst

@@ -0,0 +1,27 @@
+The Forest Walker
+=================
+
+Python modules for parsing JSON, TOML, YAML, and similar formats
+produce simple tree structures composed of numbers, strings, Booleans,
+arrays, and dictionaries. These structures are then parsed for the second
+time to produce more Pythonic data structures. This usually involves
+validation of some kind.
+
+We firmly believe that parsing and validation should not be separate
+steps: structure of data should have a single source of truth (doing 
+otherwise opens door to security issues). Also, existing formal descriptions
+of syntax (e.g., JSON schema) are too weak for many purposes and unwieldy
+for others.
+
+Enters the ``forestwalker``. A Python module that makes it easy to traverse
+trees, parse values while checking types, and report invalid data with
+their precise location in the tree.
+
+Table of contents:
+
+.. toctree::
+   :maxdepth: 2
+
+   self
+   examples
+   api

forestwalker-0.1/docs/requirements.txt

@@ -0,0 +1,2 @@
+sphinx
+.

forestwalker-0.1/pyproject.toml

@@ -0,0 +1,27 @@
+[project]
+name = "forestwalker"
+description = "A library for walking JSON-like trees, parsing and validating them."
+version = "0.1"
+authors = [ { name = "Martin Mareš", email = "mj@ucw.cz" } ]
+readme = "README.md"
+requires-python = ">= 3.11"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    "Intended Audience :: Developers",
+    "Topic :: File Formats :: JSON",
+]
+license = "MIT"
+license-file = "LICENSE"
+
+[project.urls]
+Repository = "https://github.com/gollux/forestwalker.git"
+Documentation = "https://forestwalker.readthedocs.io/en/latest/"
+Issues = "https://github.com/gollux/forestwalker/issues"
+
+[build-system]
+requires = ["hatchling >= 1.26"]
+build-backend = "hatchling.build"
+
+[pytest]
+testpaths = "tests"

forestwalker-0.1/requirements.txt

@@ -0,0 +1,4 @@
+sphinx
+pytest
+build
+twine

forestwalker-0.1/src/forestwalker/__init__.py

@@ -0,0 +1,380 @@
+# A simple module for walking through a parsed JSON-like file
+# (c) 2023-2026 Martin Mareš <mj@ucw.cz>
+
+from collections.abc import Iterator
+from enum import Enum
+import re
+from typing import Any, Optional, NoReturn, Tuple, Set, Type, TypeVar, Self
+
+
+T = TypeVar('T')
+E = TypeVar('E', bound=Enum)
+
+
+class Walker:
+    """
+        A Walker is a pointer to a particular node of the tree,
+        or possible a missing child node. It also remembers the
+        path to the node.
+    """
+
+    obj: Any
+    """The tree node. :py:class:`MissingValue` if it is a missing node."""
+
+    parent: Optional['Walker'] = None
+    """Walker of the parent node. Used to reconstruct the path."""
+
+    custom_context: str = ""
+
+    def __init__(self, root: Any) -> None:
+        """Create a walker point to the given root of the tree."""
+        self.obj = root
+
+    def raise_error(self, msg) -> NoReturn:
+        """Raise a :py:exc:`WalkerError` on the current node with the given error message."""
+        raise WalkerError(self, msg)
+
+    def is_null(self) -> bool:
+        """Tests if the current node is ``None`` (JSON ``null``)."""
+        return self.obj is None
+
+    def is_str(self) -> bool:
+        """Tests if the current node is a string."""
+        return isinstance(self.obj, str)
+
+    def is_int(self) -> bool:
+        """Tests if the current node is an integer."""
+        return isinstance(self.obj, int)
+
+    def is_number(self) -> bool:
+        """Tests if the current node is an integer or float."""
+        return isinstance(self.obj, int) or isinstance(self.obj, float)
+
+    def is_bool(self) -> bool:
+        """Tests if the current node is a Boolean value."""
+        return isinstance(self.obj, bool)
+
+    def is_missing(self) -> bool:
+        """Tests if the current node is a missing child."""
+        return isinstance(self.obj, MissingValue)
+
+    def is_present(self) -> bool:
+        """Tests if the current node is *not* a missing child."""
+        return not isinstance(self.obj, MissingValue)
+
+    def is_array(self) -> bool:
+        """Tests if the current node is an array."""
+        return isinstance(self.obj, list)
+
+    def is_object(self) -> bool:
+        """Tests if the current node is an object (dictionary)."""
+        return isinstance(self.obj, dict)
+
+    def expect_present(self) -> Self:
+        """Raises an error if the current node is a missing child. Returns itself."""
+        if self.is_missing():
+            self.raise_error('Mandatory key is missing')
+        return self
+
+    def as_type(self, typ: Type[T], msg: str, default: Optional[T] = None) -> T:
+        if isinstance(self.obj, typ):
+            return self.obj
+        elif self.is_missing():
+            if default is None:
+                self.raise_error('Mandatory key is missing')
+            else:
+                return default
+        else:
+            self.raise_error(msg)
+
+    def as_optional_type(self, typ: Type[T], msg: str) -> Optional[T]:
+        if isinstance(self.obj, typ):
+            return self.obj
+        elif self.is_missing():
+            return None
+        else:
+            self.raise_error(msg)
+
+    def as_str(self, default: Optional[str] = None) -> str:
+        """
+            If the current node is a string, returns its value.
+            If it is missing and *default* is given, returns *default*.
+            Otherwise raises :py:exc:`WalkerError`.
+        """
+        return self.as_type(str, 'Expected a string', default)
+
+    def as_int(self, default: Optional[int] = None) -> int:
+        """
+            If the current node is an integer, returns its value.
+            If it is missing and *default* is given, returns *default*.
+            Otherwise raises :py:exc:`WalkerError`.
+        """
+        return self.as_type(int, 'Expected an integer', default)
+
+    def as_float(self, default: Optional[float] = None) -> float:
+        """
+            If the current node is a float, returns its value.
+            If it is an integer, it is cast to a float.
+            If it is missing and *default* is given, returns *default*.
+            Otherwise raises :py:exc:`WalkerError`.
+        """
+        if isinstance(self.obj, int):
+            return float(self.obj)
+        else:
+            return self.as_type(float, 'Expected a number', default)
+
+    def as_bool(self, default: Optional[bool] = None) -> bool:
+        """
+            If the current node is a Boolean, returns its value.
+            If it is missing and *default* is given, returns *default*.
+            Otherwise raises :py:exc:`WalkerError`.
+        """
+        return self.as_type(bool, 'Expected a Boolean value', default)
+
+    def as_enum(self, enum: Type[E], default: Optional[E] = None) -> E:
+        """
+            If the current node is a string, returns its value
+            cast to the given enumeration type (descendant of :py:class:`Enum`).
+            If the node is missing and *default* is given, returns *default*.
+            Otherwise raises :py:exc:`WalkerError`.
+        """
+        if self.is_missing() and default is not None:
+            return default
+        try:
+            return enum(self.as_str())
+        except ValueError:
+            self.raise_error('Must be one of ' + '/'.join(sorted(enum.__members__.values())))  # FIXME: type
+
+    def as_optional_str(self) -> Optional[str]:
+        """
+            If the current node is a string, returns its value.
+            If it is missing, returns ``None``.
+            Otherwise raises :py:exc:`WalkerError`.
+        """
+        return self.as_optional_type(str, 'Expected a string')
+
+    def as_optional_int(self) -> Optional[int]:
+        """
+            If the current node is an integer, returns its value.
+            If it is missing, returns ``None``.
+            Otherwise raises :py:exc:`WalkerError`.
+        """
+        return self.as_optional_type(int, 'Expected an integer')
+
+    def as_optional_float(self) -> Optional[float]:
+        """
+            If the current node is a float, returns its value.
+            If it is an integer, it is cast to a float.
+            If it is missing, returns ``None``.
+            Otherwise raises :py:exc:`WalkerError`.
+        """
+        if isinstance(self.obj, int):
+            return float(self.obj)
+        else:
+            return self.as_optional_type(float, 'Expected a number')
+
+    def as_optional_bool(self) -> Optional[bool]:
+        """
+            If the current node is a Boolean, returns its value.
+            If it is missing, returns ``None``.
+            Otherwise raises :py:exc:`WalkerError`.
+        """
+        return self.as_optional_type(bool, 'Expected a Boolean value')
+
+    def array_values(self) -> Iterator['WalkerInArray']:
+        """
+            Produces an iterator over an array node, which yields :py:class:`WalkerInArray`
+            objects for the elements of the array.
+            If the node is not an array, raises :py:exc:`WalkerError`.
+        """
+        ary = self.as_type(list, 'Expected an array')
+        for i, obj in enumerate(ary):
+            yield WalkerInArray(obj, self, i)
+
+    def object_values(self) -> Iterator['WalkerInObject']:
+        """
+            Produces an iterator over attributes of an object (dictionary), which yields :py:class:`WalkerInObject`
+            objects for the values of the attributes.
+            If the node is not an object, raises :py:exc:`WalkerError`.
+        """
+        dct = self.as_type(dict, 'Expected an object')
+        for key, obj in dct.items():
+            yield WalkerInObject(obj, self, key)
+
+    def object_items(self) -> Iterator[Tuple[str, 'WalkerInObject']]:
+        """
+            Produces an iterator over attributes of an object (dictionary), which yields pairs of the
+            attribute's name and a :py:class:`WalkerInObject` object for the attribute's value.
+            If the node is not an object, raises :py:exc:`WalkerError`.
+        """
+        dct = self.as_type(dict, 'Expected an object')
+        for key, obj in dct.items():
+            yield key, WalkerInObject(obj, self, key)
+
+    def enter_object(self) -> 'ObjectWalker':
+        """
+            Produces an :py:class:`ObjectWalker` for an object (dictionary),
+            which allows indexing of the object's attributes and checking which
+            attributes are missing.
+            If the node is not an object, raises :py:exc:`WalkerError`.
+        """
+        dct = self.as_type(dict, 'Expected an object')
+        return ObjectWalker(dct, self)
+
+    def default_to(self, default) -> 'Walker':    # XXX: Use Self when available
+        """
+            If the current node is missing, make the walker point to *default* instead.
+            Returns itself, so it is possible to write e.g.
+            ``walker.default_to([]).array_values()``.
+        """
+        if self.is_missing():
+            self.obj = default
+        return self
+
+    def context(self) -> str:
+        """Construct a path fragment for the current node."""
+        return 'root'
+
+    def set_custom_context(self, ctx: str) -> None:
+        """Set a string that is appended to the path fragment returned by :py:meth:`context`."""
+        self.custom_context = ctx
+
+
+class WalkerInArray(Walker):
+    """
+        A :py:class:`Walker` referring to an array item.
+        Never constructed directly, use :py:meth:`Walker.array_items` to obtain it.
+    """
+
+    index: int
+    """Position of the item in the array (zero-based)."""
+
+    def __init__(self, obj: Any, parent: Walker, index: int) -> None:
+        super().__init__(obj)
+        self.parent = parent
+        self.index = index
+
+    def context(self) -> str:
+        return f'[{self.index}]'
+
+
+class WalkerInObject(Walker):
+    """
+        A :py:class:`Walker` referring to an object attribute (dictionary item).
+        Never constructed directly, use :py:meth:`Walker.object_values`,
+        :py:meth:`Walker.object_items`, or indexing in :py:meth:`ObjectWalker`
+        to obtain it.
+    """
+
+    key: str
+    """Key of the attribute."""
+
+    def __init__(self, obj: Any, parent: Walker, key: str) -> None:
+        super().__init__(obj)
+        self.parent = parent
+        self.key = key
+
+    def context(self) -> str:
+        if re.fullmatch(r'\w+', self.key):
+            return f'.{self.key}'
+        else:
+            quoted_key = re.sub(r'(\\|")', r'\\\1', self.key)
+            return f'."{quoted_key}"'
+
+    def unexpected(self) -> NoReturn:
+        """Raises a :py:exc:`WalkerError` complaining that this key was not expected."""
+        self.raise_error('Unexpected key')
+
+
+class ObjectWalker(Walker):
+    """
+        A :py:class:`Walker` for inspecting an object (dictionary).
+        In addition to the default walker, it allows indexing of attribute
+        by the square brackets operator. It also remembers which attributes
+        were referenced this way and when used as a context manager, it
+        complains upon exit from the context if the object contains
+        unreferenced attributes.
+
+        Never constructed directly, use :py:meth:`Walker.enter_object`
+        to obtain it.
+    """
+
+    referenced_keys: Set[str]
+    """A set of keys of referenced attributes."""
+
+    def __init__(self, obj: Any, parent: Walker) -> None:
+        super().__init__(obj)
+        assert isinstance(obj, dict)
+        self.parent = parent
+        self.referenced_keys = set()
+
+    def __enter__(self) -> 'ObjectWalker':
+        """Enter a context."""
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback) -> None:
+        """Exit a context, calling :py:meth:`assert_no_other_keys`."""
+        if exc_type is None:
+            self.assert_no_other_keys()
+
+    def context(self) -> str:
+        return ""
+
+    def __contains__(self, key: str) -> bool:
+        """
+            Implements the ``in`` operator for testing if the object contains an
+            attribute with the given key.
+        """
+        return key in self.obj
+
+    def __getitem__(self, key: str) -> WalkerInObject:
+        """
+            Implements the ``[]`` operator for accessing an attribute with
+            the given key. Returns a :py:class:`WalkerInObject` referring to
+            the attribute's value.
+        """
+        if key in self.obj:
+            self.referenced_keys.add(key)
+            return WalkerInObject(self.obj[key], self, key)
+        else:
+            return WalkerInObject(MissingValue(), self, key)
+
+    def assert_no_other_keys(self) -> None:
+        """
+            Checks if the object has attributes not accessed by the ``[]``
+            operator. Raises an :py:exc:`WalkerError` if there are any.
+        """
+        for key, val in self.obj.items():
+            if key not in self.referenced_keys:
+                WalkerInObject(val, self, key).unexpected()
+
+
+class MissingValue:
+    pass
+
+
+class WalkerError(Exception):
+    """An exception for any error occurring during walking the tree."""
+
+    walker: Walker
+    """
+        The walker that raised the exception. Used to reconstruct the path
+        to the erroneous node.
+    """
+
+    msg: str
+    """Error message."""
+
+    def __init__(self, walker: Walker, msg: str) -> None:
+        self.walker = walker
+        self.msg = msg
+
+    def __str__(self) -> str:
+        """Returns a string consisting of the path in the tree and the error message."""
+        contexts = []
+        w: Optional[Walker] = self.walker
+        while w is not None:
+            contexts.append(w.context())
+            contexts.append(w.custom_context)
+            w = w.parent
+        return "".join(reversed(contexts)) + ": " + self.msg

forestwalker-0.1/tests/test_forestwalker.py

@@ -0,0 +1,92 @@
+from forestwalker import Walker, WalkerError
+import unittest
+
+
+class TestWalker(unittest.TestCase):
+
+    def test_is_int(self):
+        self.assertEqual(Walker(42).is_int(), True)
+
+    def test_is_int_not(self):
+        self.assertEqual(Walker('forty-two').is_int(), False)
+
+    def test_as_int(self):
+        self.assertEqual(Walker(42).as_int(), 42)
+
+    def test_as_int_not(self):
+        with self.assertRaises(WalkerError):
+            Walker('forty-two').as_int()
+
+    def test_is_bool(self):
+        self.assertEqual(Walker(False).is_bool(), True)
+
+    def test_array(self):
+        w = Walker([1, 2, 3])
+        b = []
+        for val in w.array_values():
+            b.append(val.as_int())
+        self.assertEqual(b, [1, 2, 3])
+
+    def test_array_not(self):
+        with self.assertRaises(WalkerError):
+            for _ in Walker(42).array_values():
+                pass
+
+    def test_array_context(self):
+        with self.assertRaisesRegex(WalkerError, r'^root\[1]: '):
+            w = Walker([1, None, 3])
+            for val in w.array_values():
+                val.as_int()
+
+    def test_object_values(self):
+        d = {"one": 1, "three": 3, "eleven": 11}
+        w = Walker(d)
+        b = set()
+        for val in w.object_values():
+            b.add(val.as_int())
+        self.assertEqual(b, set(d.values()))
+
+    def test_object_items(self):
+        d = {"one": 1, "three": 3, "eleven": 11}
+        w = Walker(d)
+        b = {}
+        for key, val in w.object_items():
+            b[key] = val.as_int()
+        self.assertEqual(b, d)
+
+    def test_object_values_not(self):
+        with self.assertRaises(WalkerError):
+            for _ in Walker(42).object_values():
+                pass
+
+    def test_complex_context(self):
+        with self.assertRaisesRegex(WalkerError, r'^root\.three\[2]: '):
+            w = Walker({"one": 1, "three": [5, 6, 'huiiii!', 7], "eleven": 11})
+            for key, val in w.object_items():
+                if val.is_array():
+                    for wal in val.array_values():
+                        wal.as_int()
+                else:
+                    val.as_int()
+
+    def test_object_walker_not(self):
+        with self.assertRaises(WalkerError):
+            Walker(42).enter_object()
+
+    def test_object_walker(self):
+        with Walker({'one': 1, 'two': 'dva', 'three': False}).enter_object() as w:
+            self.assertEqual(w['one'].as_int(4), 1)
+            self.assertEqual(w['two'].as_str(), 'dva')
+            self.assertEqual(w['three'].as_bool(), False)
+            self.assertEqual(w['four'].as_int(4), 4)
+
+    def test_object_walker_other(self):
+        with self.assertRaisesRegex(WalkerError, r'^root\.three: Unexpected key$'):
+            with Walker({'one': 1, 'two': 'dva', 'three': False}).enter_object() as w:
+                self.assertEqual(w['one'].as_int(4), 1)
+                self.assertEqual(w['two'].as_str(), 'dva')
+
+    def test_object_walker_missing(self):
+        with self.assertRaisesRegex(WalkerError, r'^root\.five: Mandatory key is missing$'):
+            with Walker({'one': 1, 'two': 'dva', 'three': False}).enter_object() as w:
+                self.assertEqual(w['five'].as_int())

forestwalker-0.1/tools/gen-doc

@@ -0,0 +1,2 @@
+#!/bin/sh
+exec sphinx-build -M html docs docs.out

forestwalker-0.1/tools/release

@@ -0,0 +1,13 @@
+#!/bin/bash
+set -e
+
+rm -rf dist
+python3 -m build
+ls -al dist
+
+echo -n "Enter to upload... "
+read YES
+
+python3 -m twine upload dist/*
+
+echo "Done."