bsb-json 4.0.0rc2__py3-none-any.whl → 4.2.0__py3-none-any.whl

bsb_json/__init__.py

@@ -4,4 +4,4 @@ JSON parser and utilities for the BSB.
 
 from .schema import get_json_schema, get_schema
 
-__version__ = "4.0.0-rc2"
+__version__ = "4.2.0"

bsb_json/parser.py

@@ -1,340 +1,49 @@
-"""
-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
+"""
+JSON parsing module. Built on top of the Python ``json`` module. Adds JSON imports and
+references.
+"""
+
+import json
+
+import numpy as np
+from bsb.config.parsers import ConfigurationParser, ParsesReferences
+
+
+def _json_iter(obj):  # pragma: nocover
+    if isinstance(obj, dict):
+        return obj.items()
+    elif isinstance(obj, list):
+        return iter(obj)
+    else:
+        return iter(())
+
+
+def _to_json(value):
+    if isinstance(value, np.ndarray):
+        return value.tolist()
+    else:
+        raise TypeError(f"Can't encode '{value}' ({type(value)})")
+
+
+class JsonParser(ParsesReferences, ConfigurationParser):
+    """
+    Parser plugin class to parse JSON configuration files.
+    """
+
+    data_description = "JSON"
+    data_extensions = ("json",)
+    data_syntax = "json"
+
+    def parse(self, content, path=None):
+        if isinstance(content, str):
+            content = json.loads(content)
+        return content, {"meta": path}
+
+    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)
+
+
+__plugin__ = JsonParser

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/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/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": {
+
+  }
+}