bigraph-schema 0.0.56__tar.gz → 0.0.57__tar.gz

{bigraph-schema-0.0.56/bigraph_schema.egg-info → bigraph-schema-0.0.57}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bigraph-schema
-Version: 0.0.56
+Version: 0.0.57
 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.56/bigraph_schema/type_system_tests.py → bigraph-schema-0.0.57/bigraph_schema/tests.py

@@ -838,7 +838,7 @@ def test_inherits_from(core):
 
     assert core.inherits_from(
         'tree[path]',
-        'tree[list[string]]')
+        'tree[list[string~integer]]')
 
     assert not core.inherits_from(
         'tree[path]',
@@ -2342,8 +2342,6 @@ def fix_test_slice_edge(core):
 
     schema, state = core.generate(initial_schema, initial_state)
 
-    import ipdb; ipdb.set_trace()
-
     inner_schema, inner_state = core.slice(
         schema,
         state,
@@ -2381,6 +2379,58 @@ def fix_test_complex_wiring(core):
     assert state['AAAA']['AAAAA']['d'] == 0.0
 
 
+def test_tree_equivalence(core):
+    initial_state = {
+        'store1': {
+            'store1.1': '1.0'}}
+
+    # create a nested store type and register it
+    store11 = {
+        'store1.1': {
+            '_type': 'float',
+            '_default': '1.0'}}
+
+    core.register('store1.1', store11)
+
+    # create a tree schema that uses this type
+    store_tree = {
+        '_type': 'tree',
+        '_leaf': 'store1.1'}
+
+    # interpret the state as a simple tree of float
+    store_schema, store_state = core.generate(
+        'tree[float]',
+        initial_state)
+
+    # use the nested type to fill in the state
+    tree_schema, tree_state = core.generate(
+        store_tree,
+        {'store1': None})
+
+    # use the nested type but with an empty dict instead
+    fill_schema, fill_state = core.generate(
+        store_tree,
+        {'store1': {}})
+
+    # supply the whole schema at once instead of registering
+    inline_schema, inline_state = core.generate({
+        '_type': 'tree',
+        '_leaf': {
+            'store1.1': {
+                '_type': 'float',
+                '_default': '1.0'}}},
+        {'store1': {}})
+
+    # here is the state we expect from each of these calls
+    # to generate
+    target_state = {
+        'store1': {
+            'store1.1': 1.0}}
+
+    # all of the resulting generated states are the same
+    assert store_state == tree_state == fill_state == inline_state == target_state
+
+
 if __name__ == '__main__':
     core = TypeSystem()
     core = register_test_types(core)
@@ -2432,5 +2482,6 @@ if __name__ == '__main__':
     test_merge(core)
     test_remove_omitted(core)
     test_union_key_error(core)
+    test_tree_equivalence(core)
     # test_slice_edge(core)
     # test_complex_wiring(core)

{bigraph-schema-0.0.56 → bigraph-schema-0.0.57}/bigraph_schema/type_functions.py

@@ -1324,8 +1324,20 @@ def deserialize_map(schema, encoded, core=None):
                 subvalue) if not is_schema_key(key) else subvalue
             for key, subvalue in encoded.items()}
 
+
+def enum_list(enum_schema):
+    return [
+        enum_schema[f'_{parameter}']
+        for parameter in enum_schema['_type_parameters']]
+
+
 def deserialize_enum(schema, state, core):
-    return state  # TODO check this
+    enum = enum_list(schema)
+    if state in enum:
+        return state
+    else:
+        raise Exception(f'{state} not in enum: {enum}')
+
 
 def deserialize_array(schema, encoded, core):
     if isinstance(encoded, np.ndarray):
@@ -1553,6 +1565,19 @@ def slice_tree(schema, state, path, core):
 
             return slice_schema, slice_state
 
+        if not state:
+            default = core.default(
+                leaf_type)
+            try:
+                down_schema, down_state = core.slice(
+                    leaf_type,
+                    default,
+                    path)
+
+                if down_state:
+                    return down_schema, down_state
+            except:
+                state = {}
         if not head in state:
             state[head] = {}
 
@@ -2137,24 +2162,28 @@ def generate_any(core, schema, state, top_schema=None, top_state=None, path=None
 
                 generated_state[key] = substate
 
-        if path:
-            top_schema, top_state = core.set_slice(
-                top_schema,
-                top_state,
-                path,
-                generated_schema,
-                generated_state)
-        else:
-            top_state = core.merge_recur(
-                top_schema,
-                top_state,
-                generated_state)
-
     else:
         if not core.check(schema, state):
-            state = core.deserialize(schema, state)
+            deserialized_state = core.deserialize(schema, state)
+            if core.check(schema, deserialized_state):
+                state = deserialized_state
+            else:
+                raise Exception(f'cannot generate {state} as {schema}')
         generated_schema, generated_state = schema, state
 
+    if path:
+        top_schema, top_state = core.set_slice(
+            top_schema,
+            top_state,
+            path,
+            generated_schema,
+            generated_state)
+    else:
+        top_state = core.merge_recur(
+            top_schema,
+            top_state,
+            generated_state)
+
     return generated_schema, generated_state, top_schema, top_state
 
 def generate_quote(core, schema, state, top_schema=None, top_state=None, path=None):
@@ -2279,13 +2308,18 @@ def generate_tree(core, schema, state, top_schema=None, top_state=None, path=Non
             elif key in schema:
                 generate_schema[key] = schema[key]
             else:
-                raise Exception(' the impossible has occurred now is the time for celebration')
+                raise Exception('the impossible has occurred now is the time for celebration')
     else:
-        generate_schema = schema
-        generate_state = state
+        generate_schema, generate_state, top_schema, top_state = core.generate_recur(
+            leaf_type,
+            state,
+            top_schema=top_schema,
+            top_state=top_state,
+            path=path)
 
     return generate_schema, generate_state, top_schema, top_state
 
+
 def generate_ports(core, schema, wires, top_schema=None, top_state=None, path=None):
     schema = schema or {}
     wires = wires or {}
@@ -2465,56 +2499,99 @@ def find_union_type(core, schema, state):
 # Each function handles a specific type of schema and ensures that updates are resolved correctly.
 
 def resolve_any(schema, update, core):
-    schema = schema or {}
+    if not schema or schema == 'any':
+        return update
+    if not update or update == 'any':
+        return schema
+
+    if isinstance(schema, str):
+        schema = core.access(schema)
+
     outcome = schema.copy()
 
     for key, subschema in update.items():
         if key == '_type' and key in outcome:
-            if outcome[key] != subschema:
-                if core.inherits_from(outcome[key], subschema):
+            if schema[key] != subschema:
+                if core.inherits_from(schema[key], subschema):
                     continue
-                elif core.inherits_from(subschema, outcome[key]):
+                elif core.inherits_from(subschema, schema[key]):
                     outcome[key] = subschema
                 else:
                     raise Exception(f'cannot resolve types when updating\ncurrent type: {schema}\nupdate type: {update}')
 
-        elif not key in outcome or type_parameter_key(update, key):
+        elif not key in schema or type_parameter_key(schema, key):
             if subschema:
                 outcome[key] = subschema
         else:
             outcome[key] = core.resolve_schemas(
-                outcome.get(key),
+                schema.get(key),
                 subschema)
 
     return outcome
 
-# def resolve_tree(schema, update, core):
-#     if isinstance(update, dict):
-#         leaf_schema = schema.get('_leaf', {})
 
-#         if '_type' in update:
-#             if update['_type'] == 'map':
-#                 value_schema = update.get('_value', {})
-#                 leaf_schema = core.resolve_schemas(
-#                     leaf_schema,
-#                     value_schema)
+def resolve_union(schema, update, core):
+    if '_type' in schema and schema['_type'] == 'union':
+        union_type, resolve_type = schema, update
+    elif '_type' in update and update['_type'] == 'union':
+        union_type, resolve_type = update, schema
+    else:
+        raise Exception(f'empty union?\n{schema}\n{update}')
+
+    if '_type_parameters' in union_type:
+        parameters = union_type['_type_parameters']
+    else:
+        raise Exception(f'no type parameters in union?\n{union_type}')
+
+    for parameter in parameters:
+        parameter_key = f'_{parameter}'
+        parameter_type = union_type[parameter_key]
+        try:
+            resolved = core.resolve(
+                parameter_type,
+                resolve_type)
+            return union_type
+        except Exception as e:
+            pass
 
-#             elif update['_type'] == 'tree':
-#                 for key, subschema in update.items():
-#                     if not key.startswith('_'):
-#                         leaf_schema = core.resolve_schemas(
-#                             leaf_schema,
-#                             subschema)
-#             else:
-#                 leaf_schema = core.resolve_schemas(
-#                     leaf_schema,
-#                     update)
+    raise Exception(f'could not resolve type with union:\n{update}\nunion:\n{schema}')
 
-#             schema['_leaf'] = leaf_schema
-#         else:
-#             for key, subupdate in
 
-#     return schema
+def resolve_tree(schema, update, core):
+    if not schema or schema == 'any':
+        return update
+    if not update or update == 'any':
+        return schema
+
+    outcome = schema.copy()
+
+    for key, subschema in update.items():
+        if key == '_type' and key in outcome:
+            if outcome[key] != subschema:
+                if core.inherits_from(outcome[key], subschema):
+                    continue
+                elif core.inherits_from(subschema, outcome[key]):
+                    outcome[key] = subschema
+                else:
+                    leaf_type = core.find_parameter(
+                        schema,
+                        'leaf')
+
+                    return core.resolve(
+                        leaf_type,
+                        update)
+
+                    # raise Exception(f'cannot resolve types when updating\ncurrent type: {schema}\nupdate type: {update}')
+
+        elif not key in outcome or type_parameter_key(update, key):
+            if subschema:
+                outcome[key] = subschema
+        else:
+            outcome[key] = core.resolve_schemas(
+                outcome.get(key),
+                subschema)
+
+    return outcome
 
 
 # ==========================
@@ -2724,7 +2801,7 @@ base_types = {
         '_dataclass': dataclass_tree,
         '_fold': fold_tree,
         '_divide': divide_tree,
-        # '_resolve': resolve_tree,
+        '_resolve': resolve_tree,
         '_type_parameters': ['leaf'],
         '_description': 'mapping from str to some type in a potentially nested form'},
 
@@ -2760,7 +2837,7 @@ base_types = {
 
     'path': {
         '_type': 'path',
-        '_inherit': 'list[string]',
+        '_inherit': 'list[string~integer]',
         '_apply': apply_path},
 
     'wires': {
@@ -2839,4 +2916,5 @@ registry_types = {
         '_deserialize': deserialize_union,
         '_dataclass': dataclass_union,
         '_fold': fold_union,
+        '_resolve': resolve_union,
         '_description': 'union of a set of possible types'}}

{bigraph-schema-0.0.56 → bigraph-schema-0.0.57}/bigraph_schema/type_system.py

@@ -274,6 +274,10 @@ class TypeSystem(Registry):
     def merge_schemas(self, current, update):
         if current == update:
             return update
+        if current is None:
+            return update
+        if update is None:
+            return current
         if not isinstance(current, dict):
             return update
         if not isinstance(update, dict):
@@ -963,6 +967,9 @@ class TypeSystem(Registry):
 
 
     def resolve_schemas(self, initial_current, initial_update):
+        if initial_current == initial_update:
+            return initial_current
+
         current = self.access(initial_current)
         update = self.access(initial_update)
 
@@ -976,7 +983,7 @@ class TypeSystem(Registry):
             outcome = update
 
         elif '_type' in current and '_type' in update and current['_type'] == update['_type']:
-            outcome = current.copy()
+            outcome = {}
 
             for key in update:
                 if key == '_type_parameters' and '_type_parameters' in current:
@@ -984,23 +991,27 @@ class TypeSystem(Registry):
                         parameter_key = f'_{parameter}'
                         if parameter in current['_type_parameters']:
                             if parameter_key in current:
-                                outcome[parameter_key] = self.resolve_schemas(
-                                    current[parameter_key],
-                                    update[parameter_key])
+                                if parameter_key in update:
+                                    outcome[parameter_key] = self.resolve_schemas(
+                                        current[parameter_key],
+                                        update[parameter_key])
+                                else:
+                                    outcome[parameter_key] = current[parameter_key]
                             elif parameter_key in update:
                                 outcome[parameter_key] = update[parameter_key]
-                            # else:
-                            #     outcome[parameter_key] = {}
                         else:
                             outcome[parameter_key] = update[parameter_key]
-                elif key not in outcome or type_parameter_key(current, key):
-                    key_update = update[key]
-                    if key_update:
-                        outcome[key] = key_update
-                else:
+                elif key not in current or type_parameter_key(current, key):
+                    if update[key]:
+                        outcome[key] = update[key]
+                    else:
+                        outcome[key] = current.get(key)
+                elif key in current and current[key]:
                     outcome[key] = self.resolve_schemas(
-                        outcome.get(key),
+                        current[key],
                         update[key])
+                else:
+                    outcome[key] = update[key]
 
         elif '_type' in update and '_type' not in current:
             outcome = self.resolve(update, current)
@@ -1008,26 +1019,6 @@ class TypeSystem(Registry):
         else:
             outcome = self.resolve(current, update)
 
-        # elif '_type' in current:
-        #     outcome = self.resolve(current, update)
-
-        # elif '_type' in update:
-        #     outcome = self.resolve(update, current)
-
-        # else:
-        #     outcome = self.resolve(current, update)
-        #     outcome = current.copy()
-
-        #     for key in update:
-        #         if not key in outcome or is_schema_key(update, key):
-        #             key_update = update[key]
-        #             if key_update:
-        #                 outcome[key] = key_update
-        #         else:
-        #             outcome[key] = self.resolve_schemas(
-        #                 outcome.get(key),
-        #                 update[key])
-
         return outcome
 
 
@@ -1316,7 +1307,6 @@ class TypeSystem(Registry):
 
 
     def set_slice(self, schema, state, path, target_schema, target_state, defer=False):
-
         '''
         Makes a local modification to the schema/state at the path, and
         returns the top_schema and top_state

{bigraph-schema-0.0.56 → bigraph-schema-0.0.57}/bigraph_schema/utilities.py

@@ -146,7 +146,6 @@ def lookup_dtype(data_name):
 
 
 def read_datatype(data_schema):
-    print(f'reading datatype from {data_schema}')
     return lookup_dtype(
         data_schema['_type'])
 

{bigraph-schema-0.0.56 → bigraph-schema-0.0.57/bigraph_schema.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bigraph-schema
-Version: 0.0.56
+Version: 0.0.57
 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.56 → bigraph-schema-0.0.57}/bigraph_schema.egg-info/SOURCES.txt

@@ -7,9 +7,9 @@ bigraph_schema/edge.py
 bigraph_schema/parse.py
 bigraph_schema/protocols.py
 bigraph_schema/registry.py
+bigraph_schema/tests.py
 bigraph_schema/type_functions.py
 bigraph_schema/type_system.py
-bigraph_schema/type_system_tests.py
 bigraph_schema/units.py
 bigraph_schema/utilities.py
 bigraph_schema.egg-info/PKG-INFO

{bigraph-schema-0.0.56 → bigraph-schema-0.0.57}/setup.py

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