bigraph-schema 0.0.38__tar.gz → 0.0.42__tar.gz

{bigraph-schema-0.0.38/bigraph_schema.egg-info → bigraph-schema-0.0.42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bigraph-schema
-Version: 0.0.38
+Version: 0.0.42
 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.38 → bigraph-schema-0.0.42}/bigraph_schema/__init__.py

@@ -1,2 +1,2 @@
 from bigraph_schema.type_system import TypeSystem, Edge
-from bigraph_schema.registry import get_path, establish_path, set_path, transform_path, deep_merge, validate_merge
+from bigraph_schema.registry import get_path, establish_path, set_path, transform_path, deep_merge, validate_merge, default

{bigraph-schema-0.0.38 → bigraph-schema-0.0.42}/bigraph_schema/parse.py

@@ -20,6 +20,8 @@ parameter_examples = {
     'typed_parameters': 'edge[a:int|b:(x:length|y:float),v[zz:float|xx:what]]',
     'inputs_and_outputs': 'edge[input1:float|input2:int,output1:float|output2:int]',
     'tuple': 'what[is,happening|(with:yellow|this:green)|this:now]',
+    'single': 'hello[(3),over]',
+    'double': 'hello[(3|4),over]',
     'units_type': 'length^2*mass/time^1_5'}
 
 
@@ -98,10 +100,15 @@ class ParameterVisitor(NodeVisitor):
         return visit[0]
 
     def visit_group(self, node, visit):
-        return visit[1]
+        # return visit[1]
+        if isinstance(visit[1], (list, tuple, dict)):
+            return visit[1]
+        else:
+            return tuple([visit[1]])
 
     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]

{bigraph-schema-0.0.38 → bigraph-schema-0.0.42}/bigraph_schema/registry.py

@@ -9,7 +9,7 @@ import copy
 import collections
 import pytest
 import traceback
-
+import functools
 import numpy as np
 
 from pprint import pformat as pf
@@ -44,6 +44,8 @@ optional_schema_keys = set([
 
 type_schema_keys = required_schema_keys | optional_schema_keys
 
+SYMBOL_TYPES = ['enum']
+
 TYPE_FUNCTION_KEYS = [
     '_apply',
     '_check',
@@ -90,7 +92,7 @@ def non_schema_keys(schema):
     return [
         element
         for element in schema.keys()
-        if not element.startswith('_')]
+        if not is_schema_key(element)]
 
             
 def type_merge(dct, merge_dct, path=tuple(), merge_supers=False):
@@ -295,6 +297,26 @@ def transform_path(tree, path, transform):
     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
@@ -336,6 +358,12 @@ def remove_path(tree, path):
     return tree
 
 
+def default(type, default):
+    return {
+        '_type': type,
+        '_default': default}
+
+
 class Registry(object):
     """A Registry holds a collection of functions or objects"""
 
@@ -359,6 +387,7 @@ class Registry(object):
         """
 
         # 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())
@@ -375,11 +404,13 @@ class Registry(object):
                         raise Exception(
                             'registry already contains an entry for {}: {} --> {}'.format(
                                 registry_key, self.registry[key], item))
-
-                    else:
+                    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)
@@ -388,7 +419,7 @@ class Registry(object):
     def register_function(self, function):
         if isinstance(function, str):
             module_key = function
-            found = self.access(module_key)
+            found = self.find(module_key)
 
             if found is None:
                 found = local_lookup_module(
@@ -396,7 +427,7 @@ class Registry(object):
 
                 if found is None:
                     raise Exception(
-                        f'function "{subschema}" not found for type data:\n  {pf(schema)}')
+                        f'function "{module_key}" not found for type data')
 
         elif inspect.isfunction(function):
             found = function
@@ -413,12 +444,16 @@ class Registry(object):
         for key, schema in schemas.items():
             self.register(key, schema, force=force)
 
+    def find(self, key):
+        return self.registry.get(key)
+        
+
     def access(self, key):
         """
         get an item by key from the registry.
         """
 
-        return self.registry.get(key)
+        return self.find(key)
 
     def list(self):
         return list(self.main_keys)
@@ -582,7 +617,23 @@ def divide_any(schema, state, values, core):
             for _ in range(divisions)]
 
 
-def is_schema_key(schema, key):
+def is_schema_key(key):
+    return isinstance(key, str) and key.startswith('_')
+
+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('_')
 
 
@@ -599,7 +650,7 @@ def resolve_any(schema, update, core):
                 else:
                     raise Exception(f'cannot resolve types when updating\ncurrent type: {schema}\nupdate type: {update}')
 
-        elif not key in outcome or is_schema_key(update, key):
+        elif not key in outcome or type_parameter_key(update, key):
             if subschema:
                 outcome[key] = subschema
         else:
@@ -812,7 +863,7 @@ def deserialize_any(schema, state, core):
         tree = {}
 
         for key, value in state.items():
-            if key.startswith('_'):
+            if is_schema_key(key):
                 decoded = value
             else:
                 decoded = core.deserialize(
@@ -848,27 +899,35 @@ def merge_any(schema, current_state, new_state, core):
     # overwrites in place!
     # TODO: this operation could update the schema (by merging a key not
     #   already in the schema) but that is not represented currently....
+    merge_state = None
+
     if is_empty(current_state):
-        return new_state
+        merge_state = new_state
 
     elif is_empty(new_state):
-        return current_state
+        merge_state = current_state
     
     elif isinstance(new_state, dict):
         if isinstance(current_state, dict):
             for key, value in new_state.items():
-                if key.startswith('_'):
+                if is_schema_key(key):
                     current_state[key] = value
                 else:
                     current_state[key] = core.merge(
                         schema.get(key),
                         current_state.get(key),
                         value)
-            return current_state
+            merge_state = current_state
         else:
-            return new_state
+            merge_state = new_state
     else:
-        return new_state
+        merge_state = new_state
+
+    return merge_state
+
+    # return core.deserialize(
+    #     schema,
+    #     merge_state)
 
 
 def bind_any(schema, state, key, subschema, substate, core):
@@ -1193,7 +1252,7 @@ class TypeRegistry(Registry):
         """
 
         if isinstance(schema, str):
-            schema = self.access(schema)
+            schema = self.find(schema)
         schema = copy.deepcopy(schema)
 
         if '_type' not in schema:
@@ -1219,20 +1278,22 @@ class TypeRegistry(Registry):
             for subkey, subschema in schema.items():
                 parameters = schema.get('_type_parameters', [])
                 if subkey in TYPE_FUNCTION_KEYS or is_method_key(subkey, parameters):
-                    registry = self.find_registry(
-                        subkey)
+                    registry = self.find_registry(subkey)
                     function_name, module_key = registry.register_function(subschema)
 
                     schema[subkey] = function_name
 
                 elif subkey not in type_schema_keys:
-                    lookup = self.access(subschema)
-                    if lookup is None:
-                        raise Exception(
-                            f'trying to register a new type ({key}), '
-                            f'but it depends on a type ({subkey}) which is not in the registry')
+                    if schema['_type'] in SYMBOL_TYPES:
+                        schema[subkey] = subschema
                     else:
-                        schema[subkey] = lookup
+                        lookup = self.find(subschema)
+                        if lookup is None:
+                            raise Exception(
+                                f'trying to register a new type ({key}), '
+                                f'but it depends on a type ({subkey}) which is not in the registry')
+                        else:
+                            schema[subkey] = lookup
         else:
             raise Exception(
                 f'all type definitions must be dicts '
@@ -1252,7 +1313,7 @@ class TypeRegistry(Registry):
             for type_parameter in type_parameters}
 
 
-    def access(self, schema):
+    def find(self, schema):
         """
         expand the schema to its full type information from the type registry
         """
@@ -1290,7 +1351,10 @@ class TypeRegistry(Registry):
                    key: self.access(branch)
                    for key, branch in schema.items()}
 
-        elif isinstance(schema, tuple):
+        elif isinstance(schema, (tuple, int)):
+            if isinstance(schema, int):
+                schema = tuple([schema])
+
             tuple_schema = {
                 '_type': 'tuple',
                 '_type_parameters': []}
@@ -1336,17 +1400,28 @@ class TypeRegistry(Registry):
                     traceback.print_exc()
                     
         return found
-    
+
+    def access(self, schema):
+        if isinstance(schema, str):
+            return self.access_str(schema)
+        else:
+            return self.find(schema)
+
+    @functools.lru_cache(maxsize=None)
+    def access_str(self, schema):
+        return self.find(schema)
+
     def retrieve(self, schema):
         """
         like access(schema) but raises an exception if nothing is found
         """
 
-        found = self.access(schema)
+        found = self.find(schema)
         if found is None:
             raise Exception(f'schema not found for type: {schema}')
         return found
 
+
     def lookup(self, type_key, attribute):
         return self.access(type_key).get(attribute)