bsb-json 0.0.0b4__tar.gz → 0.0.0b7__tar.gz

{bsb_json-0.0.0b4 → bsb_json-0.0.0b7}/PKG-INFO

@@ -1,16 +1,17 @@
 Metadata-Version: 2.1
 Name: bsb-json
-Version: 0.0.0b4
+Version: 0.0.0b7
 Summary: JSON parser and utilities for the BSB.
 Author-email: Robin De Schepper <robingilbert.deschepper@unipv.it>
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
-Requires-Dist: bsb-core>=4.0.0b0,<=4.0.0b9999
+Requires-Dist: bsb-core>=4.0.0b6,<=4.0.0b9999
 Requires-Dist: pre-commit~=3.5 ; extra == "dev"
 Requires-Dist: black~=23.11 ; extra == "dev"
 Requires-Dist: isort~=5.12 ; extra == "dev"
-Requires-Dist: bump2version~=1.0 ; extra == "dev"
+Requires-Dist: bump-my-version~=0.18 ; extra == "dev"
+Requires-Dist: bsb-core[parallel] ; extra == "test"
 Requires-Dist: bsb-test>=0.0.0b7,<=0.0.0b9999 ; extra == "test"
 Requires-Dist: coverage~=7.0 ; extra == "test"
 Provides-Extra: dev

{bsb_json-0.0.0b4 → bsb_json-0.0.0b7}/bsb_json/__init__.py

@@ -1,7 +1,7 @@
-"""
-JSON parser and utilities for the BSB.
-"""
-
-from .schema import get_json_schema, get_schema
-
-__version__ = "0.0.0b4"
+"""
+JSON parser and utilities for the BSB.
+"""
+
+from .schema import get_json_schema, get_schema
+
+__version__ = "0.0.0-b7"

{bsb_json-0.0.0b4 → bsb_json-0.0.0b7}/bsb_json/parser.py

@@ -1,334 +1,340 @@
-"""
-JSON parsing module. Built on top of the Python ``json`` module. Adds JSON imports and
-references.
-"""
-
-import json
-import os
-
-import numpy as np
-from bsb.config.parsers import Parser
-from bsb.exceptions import ConfigurationWarning, JsonImportError, JsonReferenceError
-from bsb.reporting import warn
-
-
-def _json_iter(obj):  # pragma: nocover
-    if isinstance(obj, dict):
-        return obj.items()
-    elif isinstance(obj, list):
-        return iter(obj)
-    else:
-        return iter(())
-
-
-class parsed_node:
-    def location(self):
-        return "/" + "/".join(str(part) for part in self._location_parts([]))
-
-    def _location_parts(self, carry):
-        if hasattr(self, "_parent"):
-            self._parent._location_parts(carry)
-            carry.append(self._key)
-        return carry
-
-    def __str__(self):
-        return f"<parsed json config '{super().__str__()}' at '{self.location()}'>"
-
-    def __repr__(self):
-        return super().__str__()
-
-
-def _traverse_wrap(node, iter):
-    for key, value in iter:
-        if type(value) in recurse_handlers:
-            value, iter = recurse_handlers[type(value)](value, node)
-            value._key = key
-            value._parent = node
-            node[key] = value
-            _traverse_wrap(value, iter)
-
-
-class parsed_dict(dict, parsed_node):
-    def merge(self, other):
-        """
-        Recursively merge the values of another dictionary into us
-        """
-        for key, value in other.items():
-            if key in self and isinstance(self[key], dict) and isinstance(value, dict):
-                if not isinstance(self[key], parsed_dict):  # pragma: nocover
-                    self[key] = d = parsed_dict(self[key])
-                    d._key = key
-                    d._parent = self
-                self[key].merge(value)
-            elif isinstance(value, dict):
-                self[key] = d = parsed_dict(value)
-                d._key = key
-                d._parent = self
-                _traverse_wrap(d, d.items())
-            else:
-                if isinstance(value, list):
-                    value = parsed_list(value)
-                    value._key = key
-                    value._parent = self
-                self[key] = value
-
-    def rev_merge(self, other):
-        """
-        Recursively merge ourself onto another dictionary
-        """
-        m = parsed_dict(other)
-        _traverse_wrap(m, m.items())
-        m.merge(self)
-        self.clear()
-        self.update(m)
-        for v in self.values():
-            if hasattr(v, "_parent"):
-                v._parent = self
-
-
-class parsed_list(list, parsed_node):
-    pass
-
-
-class json_ref:
-    def __init__(self, node, doc, ref):
-        self.node = node
-        self.doc = doc
-        self.ref = ref
-
-    def resolve(self, parser, target):
-        del self.node["$ref"]
-        self.node.rev_merge(target)
-
-    def __str__(self):
-        return "<json ref '{}'>".format(
-            ((self.doc + "#") if self.doc else "") + self.ref
-        )
-
-
-class json_imp(json_ref):
-    def __init__(self, node, doc, ref, values):
-        super().__init__(node, doc, ref)
-        self.values = values
-
-    def resolve(self, parser, target):
-        del self.node["$import"]
-        for key in self.values:
-            if key not in target:
-                raise JsonImportError(
-                    "'{}' does not exist in import node '{}'".format(key, self.ref)
-                )
-            if isinstance(target[key], dict):
-                imported = parsed_dict()
-                imported.merge(target[key])
-                imported._key = key
-                imported._parent = self.node
-                if key in self.node:
-                    if isinstance(self.node[key], dict):
-                        imported.merge(self.node[key])
-                    else:
-                        warn(
-                            f"Importkey '{key}' of {self} is ignored because the parent"
-                            f" already contains a key '{key}'"
-                            f" with value '{self.node[key]}'.",
-                            ConfigurationWarning,
-                            stacklevel=3,
-                        )
-                        continue
-                self.node[key] = imported
-            elif isinstance(target[key], list):
-                imported, iter = _prep_list(target[key], self.node)
-                imported._key = key
-                imported._parent = self.node
-                self.node[key] = imported
-                _traverse_wrap(imported, iter)
-            else:
-                self.node[key] = target[key]
-
-
-def _to_json(value):
-    if isinstance(value, np.ndarray):
-        return value.tolist()
-    else:
-        raise TypeError()
-
-
-class JsonParser(Parser):
-    """
-    Parser plugin class to parse JSON configuration files.
-    """
-
-    data_description = "JSON"
-    data_extensions = ("json",)
-    data_syntax = "json"
-
-    def parse(self, content, path=None):
-        # Parses the content. If path is set it's used as the root for the multi-document
-        # features. During parsing the references (refs & imps) are stored. After parsing
-        # the other documents are parsed by the standard json module (so no recursion yet)
-        # After loading all required documents the references are resolved and all values
-        # copied over to their final destination.
-        if isinstance(content, str):
-            content = parsed_dict(json.loads(content))
-        self.root = content
-        self.path = path or os.getcwd()
-        self.is_doc = path and not os.path.isdir(path)
-        self.references = []
-        self.documents = {}
-        self._traverse(content, content.items())
-        self.resolved_documents = {}
-        self._resolve_documents()
-        self._resolve_references()
-        meta = {"path": path}
-        return content, meta
-
-    def generate(self, tree, pretty=False):
-        if pretty:
-            return json.dumps(tree, indent=4, default=_to_json)
-        else:
-            return json.dumps(tree, default=_to_json)
-
-    def _traverse(self, node, iter):
-        # Iterates over all values in `iter` and checks for import keys, recursion or refs
-        # Also wraps all nodes in their `parsed_*` counterparts.
-        for key, value in iter:
-            if self._is_import(key):
-                self._store_import(node)
-            elif type(value) in recurse_handlers:
-                # The recurse handlers wrap the dicts and lists and return appropriate
-                # iterators for them.
-                value, iter = recurse_handlers[type(value)](value, node)
-                # Set some metadata on the wrapped recursable objects.
-                value._key = key
-                value._parent = node
-                # Overwrite the reference to the original object with a reference to the
-                # wrapped object.
-                node[key] = value
-                # Recurse a level deeper
-                self._traverse(value, iter)
-            elif self._is_reference(key):
-                self._store_reference(node, value)
-
-    def _is_reference(self, key):
-        return key == "$ref"
-
-    def _is_import(self, key):
-        return key == "$import"
-
-    def _store_reference(self, node, ref):
-        # Analyzes the reference and creates a ref object from the given data
-        doc = _get_ref_document(ref, self.path)
-        ref = _get_absolute_ref(node, ref)
-        if doc not in self.documents:
-            self.documents[doc] = set()
-        self.documents[doc].add(ref)
-        self.references.append(json_ref(node, doc, ref))
-
-    def _store_import(self, node):
-        # Analyzes the import node and creates a ref object from the given data
-        imp = node["$import"]
-        ref = imp["ref"]
-        doc = _get_ref_document(ref)
-        ref = _get_absolute_ref(node, ref)
-        if doc not in self.documents:
-            self.documents[doc] = set()
-        self.documents[doc].add(ref)
-        if "values" not in imp:
-            e = RuntimeError(f"Import node {node} is missing a 'values' list.")
-            e._bsbparser_show_user = True
-            raise e
-        self.references.append(json_imp(node, doc, ref, imp["values"]))
-
-    def _resolve_documents(self):
-        # Iterates over the list of stored documents parses them and fetches the content
-        # of each reference node.
-        for file, refs in self.documents.items():
-            if file is None:
-                content = self.root
-            else:
-                # We could open another JsonParser to easily recurse.
-                with open(file, "r") as f:
-                    content = json.load(f)
-            try:
-                self.resolved_documents[file] = self._resolve_document(content, refs)
-            except JsonReferenceError as jre:
-                if not file:
-                    raise
-                raise JsonReferenceError(
-                    str(jre) + " in document '{}'".format(file)
-                ) from None
-
-    def _resolve_document(self, content, refs):
-        resolved = {}
-        for ref in refs:
-            resolved[ref] = self._fetch_reference(content, ref)
-        return resolved
-
-    def _fetch_reference(self, content, ref):
-        parts = [p for p in ref.split("/")[1:] if p]
-        n = content
-        loc = ""
-        for part in parts:
-            loc += "/" + part
-            try:
-                n = n[part]
-            except KeyError:
-                raise JsonReferenceError(
-                    "'{}' in JSON reference '{}' does not exist".format(loc, ref)
-                ) from None
-            if not isinstance(n, dict):
-                raise JsonReferenceError(
-                    "JSON references can only point to dictionaries. '{}' is a {}".format(
-                        "{}' in '{}".format(loc, ref) if loc != ref else ref,
-                        type(n).__name__,
-                    )
-                )
-        return n
-
-    def _resolve_references(self):
-        for ref in self.references:
-            target = self.resolved_documents[ref.doc][ref.ref]
-            ref.resolve(self, target)
-
-
-def _prep_dict(node, parent):
-    return parsed_dict(node), node.items()
-
-
-def _prep_list(node, parent):
-    return parsed_list(node), enumerate(node)
-
-
-recurse_handlers = {
-    dict: _prep_dict,
-    parsed_dict: _prep_dict,
-    list: _prep_list,
-    parsed_list: _prep_list,
-}
-
-
-def _get_ref_document(ref, base=None):
-    if "#" not in ref or ref.split("#")[0] == "":
-        return None
-    doc = ref.split("#")[0]
-    if not os.path.isabs(doc):
-        if not base:
-            base = os.getcwd()
-        elif not os.path.isdir(base):
-            base = os.path.dirname(base)
-            if not os.path.exists(base):
-                raise IOError("Can't find reference directory '{}'".format(base))
-        doc = os.path.abspath(os.path.join(base, doc))
-    return doc
-
-
-def _get_absolute_ref(node, ref):
-    ref = ref.split("#")[-1]
-    if ref.startswith("/"):
-        path = ref
-    else:
-        path = os.path.join(node.location(), ref)
-    return os.path.normpath(path).replace(os.path.sep, "/")
-
-
-__plugin__ = JsonParser
+"""
+JSON parsing module. Built on top of the Python ``json`` module. Adds JSON imports and
+references.
+"""
+
+import json
+import os
+
+import numpy as np
+from bsb import ConfigurationParser, ConfigurationWarning, ParserError, warn
+
+
+class JsonImportError(ParserError):
+    pass
+
+
+class JsonReferenceError(ParserError):
+    pass
+
+
+def _json_iter(obj):  # pragma: nocover
+    if isinstance(obj, dict):
+        return obj.items()
+    elif isinstance(obj, list):
+        return iter(obj)
+    else:
+        return iter(())
+
+
+class parsed_node:
+    def location(self):
+        return "/" + "/".join(str(part) for part in self._location_parts([]))
+
+    def _location_parts(self, carry):
+        if hasattr(self, "_parent"):
+            self._parent._location_parts(carry)
+            carry.append(self._key)
+        return carry
+
+    def __str__(self):
+        return f"<parsed json config '{super().__str__()}' at '{self.location()}'>"
+
+    def __repr__(self):
+        return super().__str__()
+
+
+def _traverse_wrap(node, iter):
+    for key, value in iter:
+        if type(value) in recurse_handlers:
+            value, iter = recurse_handlers[type(value)](value, node)
+            value._key = key
+            value._parent = node
+            node[key] = value
+            _traverse_wrap(value, iter)
+
+
+class parsed_dict(dict, parsed_node):
+    def merge(self, other):
+        """
+        Recursively merge the values of another dictionary into us
+        """
+        for key, value in other.items():
+            if key in self and isinstance(self[key], dict) and isinstance(value, dict):
+                if not isinstance(self[key], parsed_dict):  # pragma: nocover
+                    self[key] = d = parsed_dict(self[key])
+                    d._key = key
+                    d._parent = self
+                self[key].merge(value)
+            elif isinstance(value, dict):
+                self[key] = d = parsed_dict(value)
+                d._key = key
+                d._parent = self
+                _traverse_wrap(d, d.items())
+            else:
+                if isinstance(value, list):
+                    value = parsed_list(value)
+                    value._key = key
+                    value._parent = self
+                self[key] = value
+
+    def rev_merge(self, other):
+        """
+        Recursively merge ourself onto another dictionary
+        """
+        m = parsed_dict(other)
+        _traverse_wrap(m, m.items())
+        m.merge(self)
+        self.clear()
+        self.update(m)
+        for v in self.values():
+            if hasattr(v, "_parent"):
+                v._parent = self
+
+
+class parsed_list(list, parsed_node):
+    pass
+
+
+class json_ref:
+    def __init__(self, node, doc, ref):
+        self.node = node
+        self.doc = doc
+        self.ref = ref
+
+    def resolve(self, parser, target):
+        del self.node["$ref"]
+        self.node.rev_merge(target)
+
+    def __str__(self):
+        return "<json ref '{}'>".format(
+            ((self.doc + "#") if self.doc else "") + self.ref
+        )
+
+
+class json_imp(json_ref):
+    def __init__(self, node, doc, ref, values):
+        super().__init__(node, doc, ref)
+        self.values = values
+
+    def resolve(self, parser, target):
+        del self.node["$import"]
+        for key in self.values:
+            if key not in target:
+                raise JsonImportError(
+                    "'{}' does not exist in import node '{}'".format(key, self.ref)
+                )
+            if isinstance(target[key], dict):
+                imported = parsed_dict()
+                imported.merge(target[key])
+                imported._key = key
+                imported._parent = self.node
+                if key in self.node:
+                    if isinstance(self.node[key], dict):
+                        imported.merge(self.node[key])
+                    else:
+                        warn(
+                            f"Importkey '{key}' of {self} is ignored because the parent"
+                            f" already contains a key '{key}'"
+                            f" with value '{self.node[key]}'.",
+                            ConfigurationWarning,
+                            stacklevel=3,
+                        )
+                        continue
+                self.node[key] = imported
+            elif isinstance(target[key], list):
+                imported, iter = _prep_list(target[key], self.node)
+                imported._key = key
+                imported._parent = self.node
+                self.node[key] = imported
+                _traverse_wrap(imported, iter)
+            else:
+                self.node[key] = target[key]
+
+
+def _to_json(value):
+    if isinstance(value, np.ndarray):
+        return value.tolist()
+    else:
+        raise TypeError(f"Can't encode '{value}' ({type(value)})")
+
+
+class JsonParser(ConfigurationParser):
+    """
+    Parser plugin class to parse JSON configuration files.
+    """
+
+    data_description = "JSON"
+    data_extensions = ("json",)
+    data_syntax = "json"
+
+    def parse(self, content, path=None):
+        # Parses the content. If path is set it's used as the root for the multi-document
+        # features. During parsing the references (refs & imps) are stored. After parsing
+        # the other documents are parsed by the standard json module (so no recursion yet)
+        # After loading all required documents the references are resolved and all values
+        # copied over to their final destination.
+        if isinstance(content, str):
+            content = parsed_dict(json.loads(content))
+        self.root = content
+        self.path = path or os.getcwd()
+        self.is_doc = path and not os.path.isdir(path)
+        self.references = []
+        self.documents = {}
+        self._traverse(content, content.items())
+        self.resolved_documents = {}
+        self._resolve_documents()
+        self._resolve_references()
+        meta = {"path": path}
+        return content, meta
+
+    def generate(self, tree, pretty=False):
+        if pretty:
+            return json.dumps(tree, indent=4, default=_to_json)
+        else:
+            return json.dumps(tree, default=_to_json)
+
+    def _traverse(self, node, iter):
+        # Iterates over all values in `iter` and checks for import keys, recursion or refs
+        # Also wraps all nodes in their `parsed_*` counterparts.
+        for key, value in iter:
+            if self._is_import(key):
+                self._store_import(node)
+            elif type(value) in recurse_handlers:
+                # The recurse handlers wrap the dicts and lists and return appropriate
+                # iterators for them.
+                value, iter = recurse_handlers[type(value)](value, node)
+                # Set some metadata on the wrapped recursable objects.
+                value._key = key
+                value._parent = node
+                # Overwrite the reference to the original object with a reference to the
+                # wrapped object.
+                node[key] = value
+                # Recurse a level deeper
+                self._traverse(value, iter)
+            elif self._is_reference(key):
+                self._store_reference(node, value)
+
+    def _is_reference(self, key):
+        return key == "$ref"
+
+    def _is_import(self, key):
+        return key == "$import"
+
+    def _store_reference(self, node, ref):
+        # Analyzes the reference and creates a ref object from the given data
+        doc = _get_ref_document(ref, self.path)
+        ref = _get_absolute_ref(node, ref)
+        if doc not in self.documents:
+            self.documents[doc] = set()
+        self.documents[doc].add(ref)
+        self.references.append(json_ref(node, doc, ref))
+
+    def _store_import(self, node):
+        # Analyzes the import node and creates a ref object from the given data
+        imp = node["$import"]
+        ref = imp["ref"]
+        doc = _get_ref_document(ref)
+        ref = _get_absolute_ref(node, ref)
+        if doc not in self.documents:
+            self.documents[doc] = set()
+        self.documents[doc].add(ref)
+        if "values" not in imp:
+            e = RuntimeError(f"Import node {node} is missing a 'values' list.")
+            e._bsbparser_show_user = True
+            raise e
+        self.references.append(json_imp(node, doc, ref, imp["values"]))
+
+    def _resolve_documents(self):
+        # Iterates over the list of stored documents parses them and fetches the content
+        # of each reference node.
+        for file, refs in self.documents.items():
+            if file is None:
+                content = self.root
+            else:
+                # We could open another JsonParser to easily recurse.
+                with open(file, "r") as f:
+                    content = json.load(f)
+            try:
+                self.resolved_documents[file] = self._resolve_document(content, refs)
+            except JsonReferenceError as jre:
+                if not file:
+                    raise
+                raise JsonReferenceError(
+                    str(jre) + " in document '{}'".format(file)
+                ) from None
+
+    def _resolve_document(self, content, refs):
+        resolved = {}
+        for ref in refs:
+            resolved[ref] = self._fetch_reference(content, ref)
+        return resolved
+
+    def _fetch_reference(self, content, ref):
+        parts = [p for p in ref.split("/")[1:] if p]
+        n = content
+        loc = ""
+        for part in parts:
+            loc += "/" + part
+            try:
+                n = n[part]
+            except KeyError:
+                raise JsonReferenceError(
+                    "'{}' in JSON reference '{}' does not exist".format(loc, ref)
+                ) from None
+            if not isinstance(n, dict):
+                raise JsonReferenceError(
+                    "JSON references can only point to dictionaries. '{}' is a {}".format(
+                        "{}' in '{}".format(loc, ref) if loc != ref else ref,
+                        type(n).__name__,
+                    )
+                )
+        return n
+
+    def _resolve_references(self):
+        for ref in self.references:
+            target = self.resolved_documents[ref.doc][ref.ref]
+            ref.resolve(self, target)
+
+
+def _prep_dict(node, parent):
+    return parsed_dict(node), node.items()
+
+
+def _prep_list(node, parent):
+    return parsed_list(node), enumerate(node)
+
+
+recurse_handlers = {
+    dict: _prep_dict,
+    parsed_dict: _prep_dict,
+    list: _prep_list,
+    parsed_list: _prep_list,
+}
+
+
+def _get_ref_document(ref, base=None):
+    if "#" not in ref or ref.split("#")[0] == "":
+        return None
+    doc = ref.split("#")[0]
+    if not os.path.isabs(doc):
+        if not base:
+            base = os.getcwd()
+        elif not os.path.isdir(base):
+            base = os.path.dirname(base)
+            if not os.path.exists(base):
+                raise IOError("Can't find reference directory '{}'".format(base))
+        doc = os.path.abspath(os.path.join(base, doc))
+    return doc
+
+
+def _get_absolute_ref(node, ref):
+    ref = ref.split("#")[-1]
+    if ref.startswith("/"):
+        path = ref
+    else:
+        path = os.path.join(node.location(), ref)
+    return os.path.normpath(path).replace(os.path.sep, "/")
+
+
+__plugin__ = JsonParser

{bsb_json-0.0.0b4 → bsb_json-0.0.0b7}/bsb_json/schema/__init__.py

@@ -1,85 +1,85 @@
-import json
-import typing
-
-from bsb.config import get_config_attributes
-
-
-def get_json_schema(root):
-    schema = get_schema(root)
-    return json.dumps(schema)
-
-
-def get_schema(root):
-    defs = {}
-    schema = object_schema(root, defs)
-    schema["title"] = "Configuration"
-    schema["description"] = "Automated JSON schema of configuration object"
-    schema["$defs"] = defs
-    return schema
-
-
-def object_schema(obj, defs=None):
-    # Import the scaffold object here to avoid circular imports when the JSON parser is
-    # loaded.
-    from bsb.core import Scaffold
-
-    schema = {"type": "object", "properties": {}}
-    cls = obj.__class__
-    obj_hints = typing.get_type_hints(cls, localns={"Scaffold": Scaffold})
-    obj_attrs = get_config_attributes(cls)
-    for attr, descr in obj_attrs.items():
-        hint = obj_hints.get(attr, str)
-        schema["properties"][attr] = attr_schema(hint, defs)
-
-    return schema
-
-
-def attr_schema(hint, defs=None):
-    if defs is None:
-        defs = {}
-    schema = {}
-    try:
-        is_dict = issubclass(typing.get_origin(hint), dict)
-        is_list = issubclass(typing.get_origin(hint), list)
-    except TypeError:
-        is_dict = False
-        is_list = False
-    if hint is str:
-        schema["type"] = "string"
-    elif hint is int:
-        schema["type"] = "integer"
-    elif hint is float:
-        schema["type"] = "number"
-    elif hint is bool:
-        schema["type"] = "boolean"
-    elif is_list:
-        schema["type"] = "array"
-        schema["items"] = attr_schema(typing.get_args(hint)[0], defs)
-    elif is_dict:
-        schema["type"] = "object"
-        schema["properties"] = {}
-        schema["additionalProperties"] = attr_schema(typing.get_args(hint)[1], defs)
-    else:
-        try:
-            is_node = get_config_attributes(hint)
-        except:
-            is_node = False
-        if is_node:
-            key = defs_key(hint)
-            if key not in defs:
-                defs[key] = object_schema(hint)
-            return schema_def_ref(hint)
-        else:
-            schema["type"] = "object"
-            schema["properties"] = {}
-            schema["description"] = f"Could not determine schema of type {hint}"
-
-    return schema
-
-
-def defs_key(hint):
-    return str(hint.__name__)
-
-
-def schema_def_ref(hint):
-    return {"$ref": f"#/$defs/{defs_key(hint)}"}
+import json
+import typing
+
+from bsb.config import get_config_attributes
+
+
+def get_json_schema(root):
+    schema = get_schema(root)
+    return json.dumps(schema)
+
+
+def get_schema(root):
+    defs = {}
+    schema = object_schema(root, defs)
+    schema["title"] = "Configuration"
+    schema["description"] = "Automated JSON schema of configuration object"
+    schema["$defs"] = defs
+    return schema
+
+
+def object_schema(obj, defs=None):
+    # Import the scaffold object here to avoid circular imports when the JSON parser is
+    # loaded.
+    from bsb.core import Scaffold
+
+    schema = {"type": "object", "properties": {}}
+    cls = obj.__class__
+    obj_hints = typing.get_type_hints(cls, localns={"Scaffold": Scaffold})
+    obj_attrs = get_config_attributes(cls)
+    for attr, descr in obj_attrs.items():
+        hint = obj_hints.get(attr, str)
+        schema["properties"][attr] = attr_schema(hint, defs)
+
+    return schema
+
+
+def attr_schema(hint, defs=None):
+    if defs is None:
+        defs = {}
+    schema = {}
+    try:
+        is_dict = issubclass(typing.get_origin(hint), dict)
+        is_list = issubclass(typing.get_origin(hint), list)
+    except TypeError:
+        is_dict = False
+        is_list = False
+    if hint is str:
+        schema["type"] = "string"
+    elif hint is int:
+        schema["type"] = "integer"
+    elif hint is float:
+        schema["type"] = "number"
+    elif hint is bool:
+        schema["type"] = "boolean"
+    elif is_list:
+        schema["type"] = "array"
+        schema["items"] = attr_schema(typing.get_args(hint)[0], defs)
+    elif is_dict:
+        schema["type"] = "object"
+        schema["properties"] = {}
+        schema["additionalProperties"] = attr_schema(typing.get_args(hint)[1], defs)
+    else:
+        try:
+            is_node = get_config_attributes(hint)
+        except:
+            is_node = False
+        if is_node:
+            key = defs_key(hint)
+            if key not in defs:
+                defs[key] = object_schema(hint)
+            return schema_def_ref(hint)
+        else:
+            schema["type"] = "object"
+            schema["properties"] = {}
+            schema["description"] = f"Could not determine schema of type {hint}"
+
+    return schema
+
+
+def defs_key(hint):
+    return str(hint.__name__)
+
+
+def schema_def_ref(hint):
+    return {"$ref": f"#/$defs/{defs_key(hint)}"}

{bsb_json-0.0.0b4 → bsb_json-0.0.0b7}/bsb_json/templates/__init__.py

@@ -1,7 +1,7 @@
-# Create a class whose instances can, unlike a list, be modified by the plugin system
-class _obj_list(list):
-    pass
-
-
-def __plugin__():
-    return _obj_list(__path__)
+# Create a class whose instances can, unlike a list, be modified by the plugin system
+class _obj_list(list):
+    pass
+
+
+def __plugin__():
+    return _obj_list(__path__)

{bsb_json-0.0.0b4 → bsb_json-0.0.0b7}/bsb_json/templates/skeleton.json

@@ -1,36 +1,36 @@
-{
-  "name": "Skeleton configuration",
-  "storage": {
-    "engine": "hdf5",
-    "root": "network.hdf5"
-  },
-  "network": {
-    "x": 100.0,
-    "y": 100.0,
-    "z": 100.0
-  },
-  "regions": {
-
-  },
-  "partitions": {
-
-  },
-  "cell_types": {
-
-  },
-  "placement": {
-
-  },
-  "after_placement": {
-
-  },
-  "connectivity": {
-
-  },
-  "after_connectivity": {
-
-  },
-  "simulations": {
-
-  }
-}
+{
+  "name": "Skeleton configuration",
+  "storage": {
+    "engine": "hdf5",
+    "root": "network.hdf5"
+  },
+  "network": {
+    "x": 100.0,
+    "y": 100.0,
+    "z": 100.0
+  },
+  "regions": {
+
+  },
+  "partitions": {
+
+  },
+  "cell_types": {
+
+  },
+  "placement": {
+
+  },
+  "after_placement": {
+
+  },
+  "connectivity": {
+
+  },
+  "after_connectivity": {
+
+  },
+  "simulations": {
+
+  }
+}

{bsb_json-0.0.0b4 → bsb_json-0.0.0b7}/bsb_json/templates/starting_example.json

@@ -1,50 +1,50 @@
-{
-  "name": "Starting example",
-  "storage": {
-    "engine": "hdf5",
-    "root": "network.hdf5"
-  },
-  "network": {
-    "x": 400.0,
-    "y": 600.0,
-    "z": 400.0
-  },
-  "partitions": {
-    "base_layer": {
-      "type": "layer",
-      "thickness": 100
-    }
-  },
-  "cell_types": {
-    "base_type": {
-      "spatial": {
-        "radius": 2.5,
-        "density": 3.9e-4
-      },
-      "plotting": {
-        "display_name": "Template cell",
-        "color": "#E62314",
-        "opacity": 0.5
-      }
-    }
-  },
-  "placement": {
-    "example_placement": {
-      "strategy": "bsb.placement.ParticlePlacement",
-      "cell_types": ["base_type"],
-      "partitions": ["base_layer"]
-    }
-  },
-  "after_placement": {
-
-  },
-  "connectivity": {
-
-  },
-  "after_connectivity": {
-
-  },
-  "simulations": {
-
-  }
-}
+{
+  "name": "Starting example",
+  "storage": {
+    "engine": "hdf5",
+    "root": "network.hdf5"
+  },
+  "network": {
+    "x": 400.0,
+    "y": 600.0,
+    "z": 400.0
+  },
+  "partitions": {
+    "base_layer": {
+      "type": "layer",
+      "thickness": 100
+    }
+  },
+  "cell_types": {
+    "base_type": {
+      "spatial": {
+        "radius": 2.5,
+        "density": 3.9e-4
+      },
+      "plotting": {
+        "display_name": "Template cell",
+        "color": "#E62314",
+        "opacity": 0.5
+      }
+    }
+  },
+  "placement": {
+    "example_placement": {
+      "strategy": "bsb.placement.ParticlePlacement",
+      "cell_types": ["base_type"],
+      "partitions": ["base_layer"]
+    }
+  },
+  "after_placement": {
+
+  },
+  "connectivity": {
+
+  },
+  "after_connectivity": {
+
+  },
+  "simulations": {
+
+  }
+}

bsb_json-0.0.0b7/pyproject.toml

@@ -0,0 +1,70 @@
+[build-system]
+requires = ["flit_core >=3.2,<4"]
+build-backend = "flit_core.buildapi"
+
+[project]
+name = "bsb-json"
+authors = [{name = "Robin De Schepper", email = "robingilbert.deschepper@unipv.it"}]
+readme = "README.md"
+license = {file = "LICENSE"}
+classifiers = ["License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)"]
+dynamic = ["version", "description"]
+requires-python = ">=3.8"
+dependencies = ["bsb-core>=4.0.0b6,<=4.0.0b9999"]
+
+[project.entry-points."bsb.config.parsers"]
+json = "bsb_json.parser"
+
+[project.entry-points."bsb.config.templates"]
+json_templates = "bsb_json.templates"
+
+[tool.flit.module]
+name = "bsb_json"
+
+[project.optional-dependencies]
+test = ["bsb-core[parallel]", "bsb-test>=0.0.0b7,<=0.0.0b9999", "coverage~=7.0"]
+dev = [
+    "pre-commit~=3.5",
+    "black~=23.11",
+    "isort~=5.12",
+    "bump-my-version~=0.18"
+]
+
+[tool.isort]
+profile = "black"
+
+[tool.bumpversion]
+current_version = "0.0.0-b7"
+parse = """(?x)
+    (?P<major>0|[1-9]\\d*)\\.
+    (?P<minor>0|[1-9]\\d*)\\.
+    (?P<patch>0|[1-9]\\d*)
+    (?:
+        -                             # dash seperator for pre-release section
+        (?P<pre_l>[a-zA-Z-]+)         # pre-release label
+        (?P<pre_n>0|[1-9]\\d*)        # pre-release version number
+    )?                                # pre-release section is optional
+"""
+serialize = [
+    "{major}.{minor}.{patch}-{pre_l}{pre_n}",
+    "{major}.{minor}.{patch}",
+]
+search = "{current_version}"
+replace = "{new_version}"
+regex = false
+ignore_missing_version = false
+tag = true
+sign_tags = false
+tag_name = "v{new_version}"
+tag_message = "Bump version: {current_version} → {new_version}"
+allow_dirty = false
+commit = true
+message = "Bump version: {current_version} → {new_version}"
+commit_args = "--no-verify"
+
+[tool.bumpversion.parts.pre_l]
+values = ["dev", "a", "b", "rc", "final"]
+optional_value = "final"
+
+[[tool.bumpversion.files]]
+filename = "bsb_json/__init__.py"

bsb_json-0.0.0b4/pyproject.toml

@@ -1,34 +0,0 @@
-[build-system]
-requires = ["flit_core >=3.2,<4"]
-build-backend = "flit_core.buildapi"
-
-[project]
-name = "bsb-json"
-authors = [{name = "Robin De Schepper", email = "robingilbert.deschepper@unipv.it"}]
-readme = "README.md"
-license = {file = "LICENSE"}
-classifiers = ["License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)"]
-dynamic = ["version", "description"]
-requires-python = ">=3.8"
-dependencies = ["bsb-core>=4.0.0b0,<=4.0.0b9999"]
-
-[project.entry-points."bsb.config.parsers"]
-json = "bsb_json.parser"
-
-[project.entry-points."bsb.config.templates"]
-json_templates = "bsb_json.templates"
-
-[tool.flit.module]
-name = "bsb_json"
-
-[project.optional-dependencies]
-test = ["bsb-test>=0.0.0b7,<=0.0.0b9999", "coverage~=7.0"]
-dev = [
-    "pre-commit~=3.5",
-    "black~=23.11",
-    "isort~=5.12",
-    "bump2version~=1.0"
-]
-
-[tool.isort]
-profile = "black"