bigraph-schema 0.0.62__tar.gz → 0.0.64__tar.gz

{bigraph-schema-0.0.62/bigraph_schema.egg-info → bigraph-schema-0.0.64}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bigraph-schema
-Version: 0.0.62
+Version: 0.0.64
 Summary: A serializable type schema for compositional systems biology
 Home-page: https://github.com/vivarium-collective/bigraph-schema
 Author: Eran Agmon, Ryan Spangler

bigraph-schema-0.0.64/bigraph_schema/edge.py

@@ -0,0 +1,105 @@
+"""
+====
+Edge
+====
+
+Base class for all edges in the bigraph schema.
+"""
+
+def default_wires(schema):
+    """
+    Create default wiring for a schema by connecting each port to a store of the same name.
+    """
+    return {
+        key: [key]
+        for key in schema}
+
+
+class Edge:
+    """
+    Base class for all computational edges in the bigraph schema.
+
+    Edges define the interface between simulation processes and the global state,
+    specifying the structure of input and output ports using bigraph types
+    (e.g., 'float', 'map[float]', 'list[integer]', etc.).
+
+    Upon instantiation, each edge registers its port types with the core.
+    """
+
+    config_schema = {}
+
+    def __init__(self, config=None, core=None):
+        """
+        Initialize the edge with a config and simulation core.
+
+        Args:
+            config (dict): Optional configuration dictionary. Defaults to empty dict.
+            core: The core simulation engine that manages this edge and its types.
+
+        Raises:
+            Exception: If `core` is not provided.
+        """
+        if core is None:
+            raise Exception('must provide a core')
+        self.core = core
+
+        if config is None:
+            config = {}
+
+        self.config = self.core.fill(self.config_schema, config)
+        self.initialize(self.config)
+
+        # Register port types
+        self.register_interface()
+
+    def initialize(self, config):
+        """Optional hook for subclass-specific initialization."""
+        pass
+
+    def initial_state(self):
+        """Return initial state values, if applicable."""
+        return {}
+
+    @staticmethod
+    def generate_state(config=None):
+        """Generate static initial state for user configuration or inspection."""
+        return {}
+
+    def inputs(self):
+        """
+        Return a dictionary mapping input port names to bigraph types.
+
+        Example:
+            {'glucose': 'float', 'biomass': 'map[float]'}
+        """
+        return {}
+
+    def outputs(self):
+        """
+        Return a dictionary mapping output port names to bigraph types.
+
+        Example:
+            {'growth_rate': 'float'}
+        """
+        return {}
+
+    def default_inputs(self):
+        """Generate default wire paths for inputs: {port: [port]}"""
+        return default_wires(self.inputs())
+
+    def default_outputs(self):
+        """Generate default wire paths for outputs: {port: [port]}"""
+        return default_wires(self.outputs())
+
+    def interface(self):
+        """
+        Return combined interface schema as a dict:
+            {
+                'inputs': {port: type, ...},
+                'outputs': {port: type, ...}
+            }
+        """
+        return {
+            'inputs': self.inputs(),
+            'outputs': self.outputs()
+        }

{bigraph-schema-0.0.62 → bigraph-schema-0.0.64}/bigraph_schema/parse.py

@@ -2,12 +2,15 @@
 ======================
 Parse Bigraph Notation
 ======================
+
+Parses and renders bigraph-style type expressions used in schema definitions,
+such as parameterized types, nested trees, merges (`|`), and unions (`~`).
 """
 
 from parsimonious.grammar import Grammar
 from parsimonious.nodes import NodeVisitor
 
-
+# --- Example Expressions -----------------------------------------------------
 parameter_examples = {
     'no-parameters': 'simple',
     'one-parameter': 'parameterized[A]',
@@ -25,7 +28,7 @@ parameter_examples = {
     'units_type': 'length^2*mass/time^1_5',
     'nothing': '()'}
 
-
+# --- Grammar -----------------------------------------------------------------
 parameter_grammar = Grammar(
     """
     expression = merge / union / tree / nothing
@@ -54,46 +57,30 @@ parameter_grammar = Grammar(
     """)
 
 
+# --- Visitor -----------------------------------------------------------------
 class ParameterVisitor(NodeVisitor):
+    """Visitor that walks a parsed tree and builds structured type expressions."""
+
     def visit_expression(self, node, visit):
         return visit[0]
 
-
     def visit_union(self, node, visit):
         head = [visit[0]]
-        tail = [
-            tree['visit'][1]
-            for tree in visit[1]['visit']]
-
-        return {
-            '_union': head + tail}
-
+        tail = [tree['visit'][1] for tree in visit[1]['visit']]
+        return {'_union': head + tail}
 
     def visit_merge(self, node, visit):
         head = [visit[0]]
-        tail = [
-            tree['visit'][1]
-            for tree in visit[1]['visit']]
-
+        tail = [tree['visit'][1] for tree in visit[1]['visit']]
         nodes = head + tail
 
-        if all([
-            isinstance(tree, dict)
-            for tree in nodes]):
-
-            merge = {}
+        if all(isinstance(tree, dict) for tree in nodes):
+            merged = {}
             for tree in nodes:
-                merge.update(tree)
-
-            return merge
-
+                merged.update(tree)
+            return merged
         else:
-            values = []
-            for tree in head + tail:
-                values.append(tree)
-
-            return tuple(values)
-
+            return tuple(nodes)
 
     def visit_tree(self, node, visit):
         return visit[0]
@@ -102,34 +89,23 @@ class ParameterVisitor(NodeVisitor):
         return visit[0]
 
     def visit_group(self, node, visit):
-        # return visit[1]
-        if isinstance(visit[1], (list, tuple, dict)):
-            return visit[1]
-        else:
-            return tuple([visit[1]])
+        group_value = visit[1]
+        return group_value if isinstance(group_value, (list, tuple, dict)) else (group_value,)
 
     def visit_nest(self, node, visit):
-        return {
-            visit[0]: visit[2]}
+        return {visit[0]: visit[2]}
 
     def visit_type_name(self, node, visit):
         type_name = visit[0]
         type_parameters = visit[1]['visit']
-        if len(type_parameters) > 0:
-            type_parameters = type_parameters[0]
-            return [type_name, type_parameters]
-        else:
-            return type_name
+        if type_parameters:
+            return [type_name, type_parameters[0]]
+        return type_name
 
     def visit_parameter_list(self, node, visit):
-        first_type = [visit[1]]
-        rest_types = [
-            inner['visit'][1]
-            for inner in visit[2]['visit']]
-
-        parameters = first_type + rest_types
-
-        return parameters
+        first = [visit[1]]
+        rest = [inner['visit'][1] for inner in visit[2]['visit']]
+        return first + rest
 
     def visit_symbol(self, node, visit):
         return node.text
@@ -138,67 +114,52 @@ class ParameterVisitor(NodeVisitor):
         return {}
 
     def generic_visit(self, node, visit):
-        return {
-            'node': node,
-            'visit': visit,
-        }
-
+        return {'node': node, 'visit': visit}
 
+# --- API ---------------------------------------------------------------------
 def parse_expression(expression):
-    parse = parameter_grammar.parse(expression)
+    """
+    Parse a bigraph-style type expression into a structured Python object.
+    """
+    parsed = parameter_grammar.parse(expression)
     visitor = ParameterVisitor()
-    type_parameters = visitor.visit(parse)
-
-    return type_parameters
-
+    return visitor.visit(parsed)
 
 def is_type_expression(expression):
-    return len(expression) == 2 and isinstance(expression[1], list)
-
+    """
+    Return True if the expression is a parameterized type list.
+    """
+    return isinstance(expression, list) and len(expression) == 2 and isinstance(expression[1], list)
 
 def render_expression(expression):
+    """
+    Render a structured type expression back into a bigraph-style string.
+    """
     if isinstance(expression, str):
         return expression
-
     elif isinstance(expression, list):
         type_name, parameters = expression
-        render = ','.join([
-            render_expression(parameter)
-            for parameter in parameters])
-        return f'{type_name}[{render}]'
-
+        inner = ','.join(render_expression(p) for p in parameters)
+        return f'{type_name}[{inner}]'
     elif isinstance(expression, tuple):
-        render = '|'.join([
-            render_expression(subexpression)
-            for subexpression in expression])
-        return f'({render})'
-
+        return '(' + '|'.join(render_expression(e) for e in expression) + ')'
     elif isinstance(expression, dict):
-        parts = []
         if '_union' in expression:
-            parts = [
-                render_expression(part)
-                for part in expression['_union']]
-            return '~'.join(parts)
+            return '~'.join(render_expression(p) for p in expression['_union'])
         else:
-            for key, tree in expression.items():
-                render = render_expression(tree)
-                parts.append(f'{key}:{render}')
+            parts = [f'{k}:{render_expression(v)}' for k, v in expression.items()]
+            return f'({ "|".join(parts) })'
+    return str(expression)  # fallback for unknown structures
 
-            inner = '|'.join(parts)
-            return f'({inner})'
-
-
-# Test the functions
+# --- Debugging/Testing ---------------------------------------------------------
 def test_parse_parameters():
-    for key, example in parameter_examples.items():
-        types = parse_expression(example)
-
-        print(f'{key}: {example}')
-        if types:
-            print(f'  {types}')
-            print(f'  {render_expression(types)}')
-
+    """Test parsing and rendering for all example expressions."""
+    for label, expr in parameter_examples.items():
+        parsed = parse_expression(expr)
+        print(f'{label}: {expr}')
+        if parsed:
+            print(f'  Parsed: {parsed}')
+            print(f'  Rendered: {render_expression(parsed)}')
 
 if __name__ == '__main__':
-    test_parse_parameters()
+    test_parse_parameters()

bigraph-schema-0.0.64/bigraph_schema/registry.py

@@ -0,0 +1,287 @@
+"""
+========
+Registry
+========
+
+Utilities for managing registry entries, hierarchical state structures,
+deep merging, and schema cleaning. Includes the `Registry` class for storing
+type declarations or functions by key.
+"""
+
+import inspect
+import copy
+import collections
+import traceback
+import functools
+import numpy as np
+import pytest
+from pprint import pformat as pf
+
+from bigraph_schema.protocols import local_lookup_module, function_module
+
+# --- Merge Utilities ---------------------------------------------------------
+
+def deep_merge_copy(dct, merge_dct):
+    """Return a deep copy of `dct` with `merge_dct` deeply merged into it."""
+    return deep_merge(copy.deepcopy(dct), merge_dct)
+
+def deep_merge(dct, merge_dct):
+    """
+    Deep merge `merge_dct` into `dct`, modifying `dct` in-place.
+
+    Nested dictionaries are recursively merged.
+    """
+    if dct is None:
+        dct = {}
+    if merge_dct is None:
+        merge_dct = {}
+    if not isinstance(merge_dct, dict):
+        return merge_dct
+
+    for k, v in merge_dct.items():
+        if (k in dct and isinstance(dct[k], dict)
+                and isinstance(v, collections.abc.Mapping)):
+            deep_merge(dct[k], v)
+        else:
+            dct[k] = v
+    return dct
+
+def validate_merge(state, dct, merge_dct):
+    """
+    Like `deep_merge`, but raises an exception if values conflict and are not in `state`.
+    """
+    dct = dct or {}
+    merge_dct = merge_dct or {}
+    state = state or {}
+
+    for k, v in merge_dct.items():
+        if (k in dct and isinstance(dct[k], dict)
+                and isinstance(v, collections.abc.Mapping)):
+            if k not in state:
+                state[k] = {}
+            validate_merge(state[k], dct[k], v)
+        else:
+            if k in state:
+                dct[k] = state[k]
+            elif k in dct and dct[k] != v:
+                raise Exception(f'cannot merge dicts at key "{k}":\n{dct}\n{merge_dct}')
+            else:
+                dct[k] = v
+    return dct
+
+# --- Tree Path Utilities -----------------------------------------------------
+
+def establish_path(tree, path, top=None, cursor=()):
+    """
+    Create or traverse a path in a nested dictionary (tree structure).
+    """
+    if tree is None:
+        tree = {}
+    if top is None:
+        top = tree
+    if path is None or len(path) == 0:
+        return tree
+    if isinstance(path, str):
+        path = (path,)
+    head = path[0]
+    if head == '..':
+        if len(cursor) == 0:
+            raise Exception(f'trying to travel above the top of the tree: {path}')
+        return establish_path(top, cursor[:-1])
+    if head not in tree:
+        tree[head] = {}
+    return establish_path(tree[head], path[1:], top=top, cursor=cursor + (head,))
+
+def set_path(tree, path, value, top=None, cursor=None):
+    """
+    Set `value` at the given `path` in a tree-like dictionary.
+    """
+    if value is None:
+        return None
+    if len(path) == 0:
+        return value
+    final = path[-1]
+    destination = establish_path(tree, path[:-1])
+    destination[final] = value
+    return tree
+
+def set_star_path(tree, path, value, top=None, cursor=()):
+    """
+    Set a value at a wildcard (`*`) path, filling in multiple keys.
+    """
+    if tree is None:
+        tree = {}
+    if top is None:
+        top = tree
+    if isinstance(path, str):
+        path = (path,)
+    if len(path) == 0:
+        return tree
+
+    head, tail = path[0], path[1:]
+    if head == '..':
+        if len(cursor) == 0:
+            raise Exception(f'trying to travel above the top of the tree: {path}')
+        return set_star_path(top, cursor[:-1], value)
+    elif head == '*':
+        for key in value:
+            tree[key] = set_star_path({}, tail, value[key], cursor=(key,))
+        return top
+    else:
+        if len(tail) == 0:
+            tree[head] = value
+        else:
+            if head not in tree:
+                tree[head] = {}
+            set_star_path(tree[head], tail, value, top=top, cursor=cursor + (head,))
+        return top
+
+def transform_path(tree, path, transform):
+    """
+    Apply a transformation function to a value at a specific path in a tree.
+    """
+    before = establish_path(tree, path)
+    after = transform(before)
+    return set_path(tree, path, after)
+
+def hierarchy_depth(hierarchy, path=()):
+    """
+    Recursively collect all node paths in a hierarchy.
+    """
+    base = {}
+    for key, inner in hierarchy.items():
+        down = path + (key,)
+        if is_schema_key(key):
+            base[path] = inner
+        elif isinstance(inner, dict) and 'instance' not in inner:
+            base.update(hierarchy_depth(inner, down))
+        else:
+            base[down] = inner
+    return base
+
+# --- Schema Tools ------------------------------------------------------------
+
+def remove_omitted(before, after, tree):
+    """
+    Remove keys from `tree` that exist in `before` but not in `after`.
+    """
+    if isinstance(before, dict):
+        if not isinstance(tree, dict):
+            raise Exception(f'trying to remove an entry from non-dict: {tree}')
+        if not isinstance(after, dict):
+            return after
+        for key, down in before.items():
+            if not key.startswith('_'):
+                if key not in after:
+                    tree.pop(key, None)
+                else:
+                    tree[key] = remove_omitted(down, after[key], tree[key])
+    return tree
+
+def is_schema_key(key):
+    """Check if a key is a schema key (starts with underscore)."""
+    return isinstance(key, str) and key.startswith('_')
+
+def non_schema_keys(schema):
+    """Return list of non-schema keys from a dictionary."""
+    return [k for k in schema if not is_schema_key(k)]
+
+def strip_schema_keys(state):
+    """
+    Recursively remove all schema keys from a dictionary.
+    """
+    if isinstance(state, dict):
+        return {k: strip_schema_keys(v) for k, v in state.items() if not is_schema_key(k)}
+    return state
+
+def type_parameter_key(schema, key):
+    """Check if a key is a special parameter override."""
+    return key.strip('_') not in schema.get('_type_parameters', []) and key.startswith('_')
+
+def default(type, default):
+    """Return a schema dictionary with a type and default."""
+    return {'_type': type, '_default': default}
+
+# --- Registry ----------------------------------------------------------------
+
+class Registry:
+    """
+    A registry for managing keyed objects or functions (e.g., schema types).
+
+    Supports registering items under multiple keys, deep merging for dicts,
+    and loading functions by string-qualified names.
+    """
+
+    def __init__(self, function_keys=None):
+        self.registry = {}
+        self.main_keys = set()
+        self.function_keys = set(function_keys or [])
+
+    def register(self, key, item, alternate_keys=(), strict=False):
+        """
+        Register an item under a key (and optional alternate keys).
+        Optionally enforce strict uniqueness.
+
+        If the item is a dict and already registered, a deep merge is attempted.
+        """
+        keys = [key] + list(alternate_keys)
+
+        for registry_key in keys:
+            if registry_key in self.registry:
+                if item != self.registry[registry_key]:
+                    if strict:
+                        raise Exception(
+                            f'Registry conflict for {registry_key}: {self.registry[registry_key]} vs {item}')
+                    elif isinstance(item, dict):
+                        self.registry[registry_key] = deep_merge(self.registry[registry_key], item)
+                    else:
+                        self.registry[registry_key] = item
+            else:
+                self.registry[registry_key] = item
+
+        self.main_keys.add(key)
+
+    def register_function(self, function):
+        """
+        Register a function by name or function object.
+
+        Returns:
+            (function_name, module_key)
+        """
+        if isinstance(function, str):
+            module_key = function
+            found = self.find(module_key) or local_lookup_module(module_key)
+            if found is None:
+                raise Exception(f'Function "{module_key}" not found for type data')
+        elif inspect.isfunction(function):
+            found = function
+            module_key = function_module(found)
+        else:
+            raise TypeError(f'Unsupported function type: {type(function)}')
+
+        function_name = module_key.split('.')[-1]
+        self.register(function_name, found)
+        self.register(module_key, found)
+
+        return function_name, module_key
+
+    def register_multiple(self, schemas, strict=False):
+        """Register multiple schemas from a dictionary of {key: item}."""
+        for key, schema in schemas.items():
+            self.register(key, schema, strict=strict)
+
+    def find(self, key):
+        """Retrieve an item from the registry by key (or None)."""
+        return self.registry.get(key)
+
+    def access(self, key):
+        """Alias for `find()`."""
+        return self.find(key)
+
+    def list(self):
+        """List all primary (non-alternate) keys in the registry."""
+        return list(self.main_keys)
+
+    def validate(self, item):
+        """Stub for validation logic (currently always True)."""
+        return True

{bigraph-schema-0.0.62 → bigraph-schema-0.0.64}/bigraph_schema/type_functions.py

@@ -399,24 +399,21 @@ def apply_map(schema, current, update, top_schema, top_state, path, core=None):
                     del result[remove_key]
 
         elif key not in current:
-            # This supports adding without the '_add' key, if the key is not in
+            # # This supports adding without the '_add' key, if the key is not in
             #   the state
-            _, generated_state, top_schema, top_state = core._generate_recur(
-                value_type,
-                update_value,
-                top_schema=top_schema,
-                top_state=top_state,
-                path=path + [key])
-
-            result[key] = generated_state
-
-            # generated_schema, generated_state = core.generate(
+            # _, generated_state, top_schema, top_state = core._generate_recur(
             #     value_type,
-            #     update_value)
+            #     update_value,
+            #     top_schema=top_schema,
+            #     top_state=top_state,
+            #     path=path + [key])
 
             # result[key] = generated_state
 
+            # # Or raise an exception
             # raise Exception(f'trying to update a key that does not exist:\n  value: {current}\n  update: {update}')
+
+            pass
         else:
             result[key] = core.apply_update(
                 value_type,

{bigraph-schema-0.0.62 → bigraph-schema-0.0.64/bigraph_schema.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bigraph-schema
-Version: 0.0.62
+Version: 0.0.64
 Summary: A serializable type schema for compositional systems biology
 Home-page: https://github.com/vivarium-collective/bigraph-schema
 Author: Eran Agmon, Ryan Spangler

{bigraph-schema-0.0.62 → bigraph-schema-0.0.64}/pyproject.toml

@@ -1,8 +1,13 @@
 [project]
 name = "bigraph-schema"
-version = "0.0.62"
+version = "0.0.64"
 description = "A serializable type schema for compositional systems biology"
 readme = "README.md"
+requires-python = ">=3.7"
+authors = [
+  {name = "Eran Agmon"},
+  {name = "Ryan Spangler"}
+]
 dependencies = [
     "fire",
     "numpy",

{bigraph-schema-0.0.62 → bigraph-schema-0.0.64}/setup.py

@@ -1,7 +1,7 @@
 from setuptools import setup, find_packages
 
 
-VERSION = '0.0.62'
+VERSION = '0.0.64'
 
 
 with open("README.md", "r") as readme:

bigraph-schema-0.0.62/bigraph_schema/edge.py

@@ -1,59 +0,0 @@
-"""
-====
-Edge
-====
-
-Base class for all edges in the bigraph schema.
-"""
-
-class Edge:
-    config_schema = {}
-
-
-    def __init__(self, config=None, core=None):
-        if core is None:
-            raise Exception('must provide a core')
-
-        self.core = core
-
-        if config is None:
-            config = {}
-
-        self.config = self.core.fill(
-            self.config_schema,
-            config)
-
-        self.initialize(self.config)
-
-
-    def initialize(self, config):
-        pass
-
-
-    def initial_state(self):
-        """The initial state of the edge, which is passed to the core."""
-        return {}
-
-
-    @staticmethod
-    def generate_state(config=None):  # TODO -- config could have a schema
-        """
-        Generate an initial state statically, without any instance-specific config.
-        This could be used to create user-configured initial states based on the Edge's requirements.
-        """
-        return {}
-
-
-    def inputs(self):
-        return {}
-
-
-    def outputs(self):
-        return {}
-
-
-    def interface(self):
-        """Returns the schema for this type"""
-        return {
-            'inputs': self.inputs(),
-            'outputs': self.outputs()}

bigraph-schema-0.0.62/bigraph_schema/registry.py

@@ -1,412 +0,0 @@
-"""
-========
-Registry
-========
-"""
-
-import inspect
-import copy
-import collections
-import pytest
-import traceback
-import functools
-import numpy as np
-
-from pprint import pformat as pf
-
-from bigraph_schema.protocols import local_lookup_module, function_module
-
-
-
-def deep_merge_copy(dct, merge_dct):
-    return deep_merge(copy.deepcopy(dct), merge_dct)
-
-
-def deep_merge(dct, merge_dct):
-    """
-    Recursive dict merge
-
-    This mutates dct - the contents of merge_dct are added to dct (which is
-    also returned).
-
-    If you want to keep dct you could use deep_merge_copy
-    """
-    if dct is None:
-        dct = {}
-    if merge_dct is None:
-        merge_dct = {}
-    if not isinstance(merge_dct, dict):
-        return merge_dct
-
-    for k, v in merge_dct.items():
-        if (k in dct and isinstance(dct[k], dict)
-                and isinstance(merge_dct[k], collections.abc.Mapping)):
-            deep_merge(dct[k], merge_dct[k])
-        else:
-            dct[k] = merge_dct[k]
-    return dct
-
-
-def validate_merge(state, dct, merge_dct):
-    """
-    Recursive dict merge
-
-    This mutates dct - the contents of merge_dct are added to dct (which is
-    also returned).
-
-    If you want to keep dct you could call it like
-    deep_merge(copy.deepcopy(dct), merge_dct)
-    """
-    dct = dct or {}
-    merge_dct = merge_dct or {}
-    state = state or {}
-
-    for k, v in merge_dct.items():
-        if (k in dct and isinstance(dct[k], dict)
-                and isinstance(merge_dct[k], collections.abc.Mapping)):
-            if k not in state:
-                state[k] = {}
-
-            validate_merge(
-                state[k],
-                dct[k],
-                merge_dct[k])
-        else:
-            if k in state:
-                dct[k] = state[k]
-            elif k in dct:
-                if dct[k] != merge_dct[k]:
-                    raise Exception(f'cannot merge dicts at key "{k}":\n{dct}\n{merge_dct}')
-            else:
-                dct[k] = merge_dct[k]
-    return dct
-
-
-def establish_path(tree, path, top=None, cursor=()):
-    """
-    Given a tree and a path in the tree that may or may not yet exist, add
-    nodes along the path and return the final node which is now at the given
-    path.
-
-    Args:
-    - tree: the tree we are establishing a path in
-    - path: where the new subtree will be located in the tree
-    - top: (None) a reference to the top of the tree
-    - cursor: (()) the current location we are visiting in the tree
-
-    Returns:
-    - node: the new node of the tree that exists at the given path
-    """
-
-    if tree is None:
-        tree = {}
-
-    if top is None:
-        top = tree
-    if path is None or path == ():
-        return tree
-    elif len(path) == 0:
-        return tree
-    else:
-        if isinstance(path, str):
-            path = (path,)
-
-        head = path[0]
-        if head == '..':
-            if len(cursor) == 0:
-                raise Exception(
-                    f'trying to travel above the top of the tree: {path}')
-            else:
-                return establish_path(
-                    top,
-                    cursor[:-1])
-        else:
-            if head not in tree:
-                tree[head] = {}
-            return establish_path(
-                tree[head],
-                path[1:],
-                top=top,
-                cursor=tuple(cursor) + (head,))
-
-
-def set_path(tree, path, value, top=None, cursor=None):
-    """
-    Given a tree, a path, and a value, sets the location
-    in the tree corresponding to the path to the given value
-
-    Args:
-    - tree: the tree we are setting a value in
-    - path: where the new value will be located in the tree
-    - value: the value to set at the given path in the tree
-    - top: (None) a reference to the top of the tree
-    - cursor: (()) the current location we are visiting in the tree
-
-    Returns:
-    - node: the new node of the tree that exists at the given path
-    """
-
-    if value is None:
-        return None
-    if len(path) == 0:
-        return value
-
-    final = path[-1]
-    towards = path[:-1]
-    destination = establish_path(tree, towards)
-    destination[final] = value
-    return tree
-
-
-def set_star_path(tree, path, value, top=None, cursor=()):
-    if tree is None:
-        tree = {}
-    if top is None:
-        top = tree
-    if path is None or len(path) == 0:
-        return tree
-    else:
-        if isinstance(path, str):
-            path = (path,)
-
-        head = path[0]
-        tail = path[1:]
-
-        if head == '..':
-            if len(cursor) == 0:
-                raise Exception(
-                    f'trying to travel above the top of the tree: {path}')
-            else:
-                return set_star_path(
-                    top,
-                    cursor[:-1],
-                    value)
-        elif head == '*':
-            for key in value:
-                tree[key] = set_star_path(
-                    {},
-                    tail,
-                    value[key],
-                    cursor=(key,))
-            return top
-        else:
-            if len(tail) == 0:
-                tree[head] = value
-                return top
-            else:
-                if head not in tree:
-                    tree[head] = {}
-                return set_star_path(
-                    tree[head],
-                    tail,
-                    value,
-                    top=top,
-                    cursor=tuple(cursor) + (head,))
-
-
-def transform_path(tree, path, transform):
-    """
-    Given a tree, a path, and a transform (function), mutate the tree by
-    replacing the subtree at the path by whatever is returned from applying the
-    transform to the existing value.
-
-    Args:
-    - tree: the tree we are setting a value in
-    - path: where the new value will be located in the tree
-    - transform: the function to apply to whatever currently lives at the given
-      path in the tree
-
-    Returns:
-    - node: the node of the tree that exists at the given path
-    """
-    before = establish_path(tree, path)
-    after = transform(before)
-
-    return set_path(tree, path, after)
-
-
-def hierarchy_depth(hierarchy, path=()):
-    """
-    Create a mapping of every path in the hierarchy to the node living at
-    that path in the hierarchy.
-    """
-
-    base = {}
-
-    for key, inner in hierarchy.items():
-        down = tuple(path + (key,))
-        if is_schema_key(key):
-            base[path] = inner
-        elif isinstance(inner, dict) and 'instance' not in inner:
-            base.update(hierarchy_depth(inner, down))
-        else:
-            base[down] = inner
-
-    return base
-
-
-def remove_omitted(before, after, tree):
-    """
-    Removes anything in tree that was in before but not in after
-    """
-
-    if isinstance(before, dict):
-        if not isinstance(tree, dict):
-            raise Exception(
-                f'trying to remove an entry from something that is not a dict: {tree}')
-
-        if not isinstance(after, dict):
-            return after
-
-        for key, down in before.items():
-            if not key.startswith('_'):
-                if key not in after:
-                    if key in tree:
-                        del tree[key]
-                else:
-                    tree[key] = remove_omitted(
-                        down,
-                        after[key],
-                        tree[key])
-
-    return tree
-
-
-def is_schema_key(key):
-    return isinstance(key, str) and key.startswith('_')
-
-
-def non_schema_keys(schema):
-    """
-    Filters out schema keys with the underscore prefix
-    """
-    return [
-        element
-        for element in schema.keys()
-        if not is_schema_key(element)]
-
-
-def strip_schema_keys(state):
-    """
-    remove schema keys from a state dictionary, including nested dictionaries
-    """
-    if isinstance(state, dict):
-        output = {}
-        for key, value in state.items():
-            if not is_schema_key(key):
-                output[key] = strip_schema_keys(value)
-    else:
-        output = state
-    return output
-
-
-def type_parameter_key(schema, key):
-    return key.strip('_') not in schema.get('_type_parameters', []) and key.startswith('_')
-
-
-def default(type, default):
-    return {
-        '_type': type,
-        '_default': default}
-
-
-class Registry(object):
-    """
-    A Registry holds a collection of functions or objects
-    """
-
-    def __init__(self, function_keys=None):
-        function_keys = function_keys or []
-        self.registry = {}
-        self.main_keys = set([])
-        self.function_keys = set(function_keys)
-
-    def register(self, key, item, alternate_keys=tuple(), strict=False):
-        """
-        Add an item to the registry.
-
-        Args:
-        - key: Item key.
-        - item: The item to add.
-        - alternate_keys: Additional keys under which to register the item.
-          These keys will not be included in the list returned by
-          ``Registry.list()``. This may be useful if you want to be able to
-          look up an item in the registry under multiple keys.
-        - strict (bool): Disallow re-registration, overriding existing keys.
-          False by default.
-        """
-
-        # check that registered function have the required function keys
-        # TODO -- make this work to check the function keys
-        if callable(item) and self.function_keys:
-            sig = inspect.signature(item)
-            sig_keys = set(sig.parameters.keys())
-            # assert all(
-            #     key in self.function_keys for key in sig_keys), f"Function '{item.__name__}' keys {sig_keys} are not all " \
-            #                                                     f"in the function_keys {self.function_keys}"
-
-        keys = [key]
-        keys.extend(alternate_keys)
-        for registry_key in keys:
-            if registry_key in self.registry:
-                if item != self.registry[registry_key]:
-                    if strict:
-                        raise Exception(
-                            'registry already contains an entry for {}: {} --> {}'.format(
-                                registry_key, self.registry[key], item))
-                    elif isinstance(item, dict):
-                        self.registry[registry_key] = deep_merge(
-                            self.registry[registry_key],
-                            item)
-                    else:
-                        self.registry[registry_key] = item
-
-            else:
-                self.registry[registry_key] = item
-        self.main_keys.add(key)
-
-
-    def register_function(self, function):
-        if isinstance(function, str):
-            module_key = function
-            found = self.find(module_key)
-
-            if found is None:
-                found = local_lookup_module(
-                    module_key)
-
-                if found is None:
-                    raise Exception(
-                        f'function "{module_key}" not found for type data')
-
-        elif inspect.isfunction(function):
-            found = function
-            module_key = function_module(found)
-
-        function_name = module_key.split('.')[-1]
-        self.register(function_name, found)
-        self.register(module_key, found)
-
-        return function_name, module_key
-
-
-    def register_multiple(self, schemas, strict=False):
-        for key, schema in schemas.items():
-            self.register(key, schema, strict=strict)
-
-    def find(self, key):
-        return self.registry.get(key)
-
-
-    def access(self, key):
-        """
-        get an item by key from the registry.
-        """
-
-        return self.find(key)
-
-    def list(self):
-        return list(self.main_keys)
-
-    def validate(self, item):
-        return True