bigraph-schema 0.0.11__tar.gz → 0.0.12__tar.gz

{bigraph-schema-0.0.11 → bigraph-schema-0.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bigraph-schema
-Version: 0.0.11
+Version: 0.0.12
 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.11 → bigraph-schema-0.0.12}/bigraph_schema/registry.py

@@ -156,6 +156,26 @@ def establish_path(tree, path, top=None, cursor=()):
                 cursor=cursor + (head,))
 
 
+def set_path(tree, path, value, top=None, cursor=None):
+    if value is None:
+        return None
+    final = path[-1]
+    towards = path[:-1]
+    destination = establish_path(tree, towards)
+    destination[final] = value
+    return tree
+
+
+def remove_path(tree, path):
+    if path is None or len(path) == 0:
+        return None
+
+    upon = get_path(tree, path[:-1])
+    if upon is not None:
+        del upon[path[-1]]
+    return tree
+
+
 class Registry(object):
     def __init__(self):
         """A Registry holds a collection of functions or objects."""

{bigraph-schema-0.0.11 → bigraph-schema-0.0.12}/bigraph_schema/schema.py

@@ -3,7 +3,7 @@ import pprint
 import pytest
 
 from bigraph_schema.parse import parse_expression
-from bigraph_schema.registry import Registry, TypeRegistry, RegistryRegistry, type_schema_keys, optional_schema_keys, deep_merge, get_path, establish_path, non_schema_keys
+from bigraph_schema.registry import Registry, TypeRegistry, RegistryRegistry, type_schema_keys, optional_schema_keys, deep_merge, get_path, establish_path, set_path, remove_path, non_schema_keys
 from bigraph_schema.units import units, render_units_type, parse_dimensionality
 
 
@@ -151,6 +151,10 @@ class SchemaTypes():
                 schema.get('_bindings'),
                 self)
 
+        elif isinstance(schema, str) or isinstance(schema, list):
+            schema = self.access(schema)
+            state = self.apply_update(schema, state, update)
+
         elif isinstance(update, dict):
             for key, branch in update.items():
                 if key not in schema:
@@ -162,10 +166,8 @@ class SchemaTypes():
                         branch)
 
                     state[key] = subupdate
-
         else:
-            schema = self.access(schema)
-            state = self.apply_update(schema, state, update)
+            raise Exception(f'trying to apply update\n  {update}\nto state\n  {state}\nwith schema\n{schema}, but the update is not a dict')
 
         return state
 
@@ -338,6 +340,126 @@ class SchemaTypes():
             state=state)
 
 
+    def ports_and_wires(self, schema, instance, edge_path):
+        found = self.access(schema)
+
+        edge_schema = get_path(found, edge_path)
+        ports = edge_schema.get('_ports')
+        edge_state = get_path(instance, edge_path)
+        wires = edge_state.get('wires')
+        
+        return ports, wires
+    
+
+    def project_state(self, schema, wires, instance, path):
+        result = {}
+        if isinstance(wires, str):
+            wires = [wires]
+        if isinstance(wires, list):
+            result = get_path(instance, path + wires)
+        elif isinstance(wires, dict):
+            result = {
+                port_key: self.project_state(
+                    schema[port_key],
+                    wires[port_key],
+                    instance,
+                    path)
+                for port_key in wires}
+        else:
+            raise Exception(f'trying to project state with these ports:\n{ports}\nbut not sure what these wires are:\n{wires}')
+
+        return result
+        
+
+    def project(self, schema, instance, edge_path=()):
+        '''
+        project the state of the current instance into a form
+        the edge expects, based on its ports
+        '''
+
+        if schema is None:
+            return None
+        if instance is None:
+            instance = self.default(schema)
+
+        ports, wires = self.ports_and_wires(schema, instance, edge_path=edge_path)
+
+        if ports is None:
+            return None
+        if wires is None:
+            return None
+
+        return self.project_state(
+            ports,
+            wires,
+            instance,
+            edge_path[:-1])
+
+
+    def invert_state(self, ports, wires, path, states):
+        result = {}
+
+        if isinstance(wires, str):
+            wires = [wires]
+
+        if isinstance(wires, list):
+            destination = path + wires
+            result = set_path(
+                result,
+                destination,
+                states)
+
+        elif isinstance(wires, dict):
+            branches = [
+                self.invert_state(
+                    ports.get(key),
+                    wires[key],
+                    path,
+                    states.get(key))
+                for key in wires.keys()]
+
+            branches = [
+                branch
+                for branch in branches
+                if branch is not None and list(branch)[0][1] is not None]
+
+            result = {}
+            for branch in branches:
+                deep_merge(result, branch)
+        else:
+            raise Exception(
+                f'inverting state\n  {state}\naccording to ports schema\n  {schema}\nbut wires are not recognized\n  {wires}')
+
+        return result
+
+
+    def invert(self, schema, instance, edge_path, states):
+        '''
+        given states from the perspective of an edge (through
+          it's ports), produce states aligned to the tree
+          the wires point to.
+          (inverse of project)
+        '''
+
+        if schema is None:
+            return None
+        if instance is None:
+            instance = self.default(schema)
+
+        ports, wires = self.ports_and_wires(schema, instance, edge_path)
+
+        if ports is None:
+            return None
+        if wires is None:
+            return None
+
+        return self.invert_state(
+            ports,
+            wires,
+            edge_path[:-1],
+            states)
+        
+
     def link_place(self, place, link):
         pass
 
@@ -355,20 +477,18 @@ class SchemaTypes():
         return {}
 
 
-    def query(self, schema, state, redex):
+    def query(self, schema, instance, redex):
         subschema = {}
         return subschema
 
 
-    def substitute(self, schema, state, reactum):
-        return state
-
-
-    def react(self, schema, redex, reactum):
+    def react(self, schema, instance, redex, reactum):
         return {}
 
 
 def accumulate(current, update, bindings, types):
+    if update is None:
+        import ipdb; ipdb.set_trace()
     return current + update
 
 def concatenate(current, update, bindings, types):
@@ -455,7 +575,28 @@ def evaluate(code, bindings, types):
 
 # TODO: make these work
 def apply_tree(current, update, bindings, types):
-    pass
+    if isinstance(update, dict):
+        if current is None:
+            current = {}
+        for key, branch in update.items():
+            if key == '_add':
+                current.update(branch)
+            elif key == '_remove':
+                current = remove_path(current, branch)
+            else:
+                current[key] = apply_tree(
+                    current.get(key),
+                    branch,
+                    bindings,
+                    types)
+
+        return current
+    else:
+        leaf_type = bindings['leaf']
+        if current is None:
+            current = types.default(leaf_type)
+        return types.apply(leaf_type, current, update)
+
 
 def divide_tree(tree, bindings, types):
     result = [{}, {}]
@@ -1012,58 +1153,44 @@ def test_fill_from_parse(base_types):
                 'port A': ['a']}}}
 
 
-def test_fill_in_disconnected_port(base_types):
-    test_schema = {
-        'edge1': {
-            '_type': 'edge',
-            '_ports': {
-                '1': {'_type': 'float'}}}}
-
-    test_state = {}
-
-
-def test_fill_type_mismatch(base_types):
-    test_schema = {
-        'a': {'_type': 'int', '_value': 2},
-        'edge1': {
-            '_type': 'edge',
-            '_ports': {
-                '1': {'_type': 'float'},
-                '2': {'_type': 'float'}},
-            'wires': {
-                '1': ['..', 'a'],
-                '2': ['a']},
-            'a': 5}}
-
-
-def test_edge_type_mismatch(base_types):
-    test_schema = {
-        'edge1': {
-            '_type': 'edge',
-            '_ports': {
-                '1': {'_type': 'float'}},
-            'wires': {
-                '1': ['..', 'a']}},
-        'edge2': {
-            '_type': 'edge',
-            '_ports': {
-                '1': {'_type': 'int'}},
-            'wires': {
-                '1': ['..', 'a']}}}
-
-
-def test_fill_nested_store(base_types):
-    test_schema = {
-        'edge1': {
-            '_type': 'edge',
-            '_ports': {
-                '1': {'_type': 'float'},
-            },
-            'wires': {
-                '1': ['somewhere', 'down', 'this', 'path']
-            },
-        },
-    }    
+# def test_fill_in_disconnected_port(base_types):
+#     test_schema = {
+#         'edge1': {
+#             '_type': 'edge',
+#             '_ports': {
+#                 '1': {'_type': 'float'}}}}
+
+#     test_state = {}
+
+
+# def test_fill_type_mismatch(base_types):
+#     test_schema = {
+#         'a': {'_type': 'int', '_value': 2},
+#         'edge1': {
+#             '_type': 'edge',
+#             '_ports': {
+#                 '1': {'_type': 'float'},
+#                 '2': {'_type': 'float'}},
+#             'wires': {
+#                 '1': ['..', 'a'],
+#                 '2': ['a']},
+#             'a': 5}}
+
+
+# def test_edge_type_mismatch(base_types):
+#     test_schema = {
+#         'edge1': {
+#             '_type': 'edge',
+#             '_ports': {
+#                 '1': {'_type': 'float'}},
+#             'wires': {
+#                 '1': ['..', 'a']}},
+#         'edge2': {
+#             '_type': 'edge',
+#             '_ports': {
+#                 '1': {'_type': 'int'}},
+#             'wires': {
+#                 '1': ['..', 'a']}}}
 
 
 def test_establish_path(base_types):
@@ -1128,13 +1255,8 @@ def test_expected_schema(base_types):
 
     dual_process_schema = {
         'process1': 'edge[port1:float|port2:int]',
-        # 'process1': {
-        #     '_ports': {
-        #         'port1': 'float',
-        #         'port2': 'int',
-        #     },
-        # },
         'process2': {
+            '_type': 'edge',
             '_ports': {
                 'port1': 'float',
                 'port2': 'int',
@@ -1151,12 +1273,6 @@ def test_expected_schema(base_types):
         # 'store1': 'process1:edge[port1:float|port2:int]|process2[port1:float|port2:int]',
         'store1': 'dual_process',
         'process3': 'edge[dual_process]'}
-    #     'process3': {
-    #         '_ports': {
-    #             'port1': 'dual_process'
-    #         }
-    #     }
-    # }
 
     test_state = {
         'store1': {
@@ -1208,56 +1324,36 @@ def test_expected_schema(base_types):
 
 
 def test_link_place(base_types):
+    # TODO: this form is more fundamental than the compressed/inline dict form,
+    #   and we should probably derive that from this form
+
     bigraph = {
         'nodes': {
-            'v0': {
-                '_type': 'int',
-                '_value': 0},
-            'v1': {
-                '_type': 'int',
-                '_value': 1},
-            'v2': {
-                '_type': 'int',
-                '_value': 2},
-            'v3': {
-                '_type': 'int',
-                '_value': 3},
-            'v4': {
-                '_type': 'int',
-                '_value': 4},
-            'v5': {
-                '_type': 'int',
-                '_value': 5},
-            'e0': {
-                '_type': 'edge[e0-0:int|e0-1:int|e0-2:int]',
-                'wires': {
-                    'e0-0': 'v0',
-                    'e0-1': 'v1',
-                    'e0-2': 'v4'}},
+            'v0': 'int',
+            'v1': 'int',
+            'v2': 'int',
+            'v3': 'int',
+            'v4': 'int',
+            'v5': 'int',
+            'e0': 'edge[e0-0:int|e0-1:int|e0-2:int]',
             'e1': {
-                '_type': 'edge[e1-0:int|e2-0:int]',
+                '_type': 'edge',
                 '_ports': {
                     'e1-0': 'int',
-                    'e2-0': 'int'},
-                'wires': {
-                    'e1-0': 'v3',
-                    'e1-1': 'v1'}},
+                    'e2-0': 'int'}},
             'e2': {
-                '_type': 'edge[e2-0:int|e2-1:int|e2-2:int]',
-                'wires': {
-                    'e2-0': 'v3',
-                    'e2-1': 'v4',
-                    'e2-2': 'v5'}}},
+                '_type': 'edge[e2-0:int|e2-1:int|e2-2:int]'}},
+
         'place': {
-            'v0': {
-                'v1': {},
-                'v2': {
-                    'v3': {}}},
-            'v4': {
-                'v5': {}},
-            'e0': {},
-            'e1': {},
-            'e2': {}},
+            'v0': None,
+            'v1': 'v0',
+            'v2': 'v0',
+            'v3': 'v2',
+            'v4': None,
+            'v5': 'v4',
+            'e0': None,
+            'e1': None,
+            'e2': None},
 
         'link': {
             'e0': {
@@ -1267,23 +1363,44 @@ def test_link_place(base_types):
             'e1': {
                 'e1-0': 'v3',
                 'e1-1': 'v1'},
+            'e2': {
+                'e2-0': 'v3',
+                'e2-1': 'v4',
+                'e2-2': 'v5'}},
+
+        'state': {
+            'v0': '1',
+            'v1': '1',
+            'v2': '2',
+            'v3': '3',
+            'v4': '5',
+            'v5': '8',
+            'e0': {
+                'wires': {
+                    'e0-0': 'v0',
+                    'e0-1': 'v1',
+                    'e0-2': 'v4'}},
+            'e1': {
+                'wires': {
+                    'e1-0': 'v3',
+                    'e1-1': 'v1'}},
             'e2': {
                 'e2-0': 'v3',
                 'e2-1': 'v4',
                 'e2-2': 'v5'}}}
 
-    placegraph = {
+    placegraph = { # schema
         'v0': {
-            'v1': {},
+            'v1': int,
             'v2': {
-                'v3': {}}},
+                'v3': int}},
         'v4': {
-            'v5': {}},
-        'e0': 'int',
-        'e1': 'int',
-        'e2': 'int'}
+            'v5': int},
+        'e0': 'edge',
+        'e1': 'edge',
+        'e2': 'edge'}
 
-    hypergraph = {
+    hypergraph = { # edges
         'e0': {
             'e0-0': 'v0',
             'e0-1': 'v1',
@@ -1380,6 +1497,8 @@ def test_serialize_deserialize(cube_types):
 def test_project(cube_types):
     schema = {
         'edge1': {
+            # '_type': 'edge[1:int|2:float|3:string|4:tree[int]]',
+            # '_type': 'edge',
             '_type': 'edge',
             '_ports': {
                 '1': 'int',
@@ -1403,15 +1522,12 @@ def test_project(cube_types):
     # TODO: support overriding various type methods
     instance = {
         'edge1': {
-            # '_type': 'edge[1:int|2:float|3:string|4:tree[int]]',
-            # '_type': 'edge',
             'wires': {
                 '1': ['a0', 'a0.0'],
                 '2': ['a0', 'a0.1'],
                 '3': ['a0', 'a0.2', 'a0.2.0'],
                 '4': ['a1']}},
         'a1': {
-            '_type': 'tree[int]',
             'branch1': {
                 'branch2': 11,
                 'branch3': 22},
@@ -1419,11 +1535,28 @@ def test_project(cube_types):
 
     instance = cube_types.fill(schema, instance)
     
-    # TODO: does project require the schema?
-    states = cube_types.project(schema, instance, ['edge1'])
-    update = cube_types.inverse(schema, states, ['edge1'])
+    states = cube_types.project(
+        schema,
+        instance,
+        ['edge1'])
 
-    assert update == {}
+    update = cube_types.invert(
+        schema,
+        instance,
+        ['edge1'],
+        states)
+
+    assert update == {
+        'a0': {
+            'a0.0': 0,
+            'a0.1': 0.0,
+            'a0.2': {
+                'a0.2.0': ''}},
+        'a1': {
+            'branch1': {
+                'branch2': 11,
+                'branch3': 22},
+            'branch4': 44}}
 
     updated_instance = cube_types.apply(
         schema,
@@ -1432,18 +1565,44 @@ def test_project(cube_types):
 
     add_update = {
         '4': {
+            'branch6': 111,
+            'branch1': {
+                '_add': {
+                    'branch7': 4444},
+                '_remove': ['branch2']},
             '_add': {
-                'branch5': 55}}}
+                'branch5': 55},
+            '_remove': ['branch4']}}
 
-    inverted_update = cube_types.inverse(
+    inverted_update = cube_types.invert(
         schema,
-        add_update,
-        ['edge1'])
+        instance,
+        ['edge1'],
+        add_update)
 
-    added_branch = cube_types.apply(
+    modified_branch = cube_types.apply(
         schema,
-        inverted_update,
-        ['edge1'])
+        instance,
+        inverted_update)
+
+    assert modified_branch == {
+        'a0': {
+            'a0.0': 0,
+            'a0.1': 0.0,
+            'a0.2': {
+                'a0.2.0': ''}},
+        'a1': {
+            'branch1': {
+                'branch7': 4444,
+                'branch3': 44},
+            'branch5': 55,
+            'branch6': 111},
+        'edge1': {
+            'wires': {
+                '1': ['a0', 'a0.0'],
+                '2': ['a0', 'a0.1'],
+                '3': ['a0', 'a0.2', 'a0.2.0'],
+                '4': ['a1']}}}
 
 
 if __name__ == '__main__':
@@ -1461,4 +1620,4 @@ if __name__ == '__main__':
     test_fill_in_missing_nodes(types)
     test_fill_from_parse(types)
     test_serialize_deserialize(types)
-    # test_project(types)
+    test_project(types)

{bigraph-schema-0.0.11 → bigraph-schema-0.0.12}/bigraph_schema.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bigraph-schema
-Version: 0.0.11
+Version: 0.0.12
 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.11 → bigraph-schema-0.0.12}/setup.py

@@ -2,7 +2,7 @@ import re
 from setuptools import setup, find_packages
 
 
-VERSION = '0.0.11'
+VERSION = '0.0.12'
 
 
 with open("README.md", "r") as readme: