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

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

@@ -1,12 +1,10 @@
 Metadata-Version: 2.1
 Name: bigraph-schema
-Version: 0.0.55
+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
 Author-email: agmon.eran@gmail.com, ryan.spangler@gmail.com
-License: UNKNOWN
-Platform: UNKNOWN
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -53,5 +51,3 @@ This resource will guide you through the core concepts and methods, helping you
 ## License
 
 Bigraph-schema is open-source software released under the [Apache 2 License](https://github.com/vivarium-collective/bigraph-schema/blob/main/LICENSE).
-
-

bigraph-schema-0.0.55/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.55 → bigraph-schema-0.0.57}/bigraph_schema/type_functions.py

@@ -75,6 +75,7 @@ import typing
 from typing import NewType, Union, Mapping, List, Dict, Optional, Callable
 from dataclasses import field, make_dataclass
 
+from bigraph_schema import get_path, set_path
 from bigraph_schema.units import units, render_units_type
 from bigraph_schema.registry import (
     is_schema_key, non_schema_keys, type_parameter_key, deep_merge, hierarchy_depth, establish_path
@@ -1083,8 +1084,50 @@ def serialize_edge(schema, value, core):
 def serialize_enum(schema, value, core):
     return value
 
+def recur_serialize_schema(schema, core, path=None, parents=None):
+    """ Serialize schema to a string """
+    path = path or []
+    parents = parents or []
+    schema_id = id(schema)
+
+    if schema_id in parents:
+        index = parents.index(schema_id)
+        reference = path[:index]
+        output = '/'.join(reference)
+        return f'/{output}'
+
+    if isinstance(schema, str):
+        return schema
+
+    elif isinstance(schema, tuple):
+        inner = [
+            recur_serialize_schema(
+                schema=element,
+                core=core,
+                path=path+[index],
+                parents=parents+[schema_id])
+            for index, element in enumerate(schema)]
+
+        return inner
+
+    elif isinstance(schema, dict):
+        inner = {}
+        for key in schema:
+            subschema = recur_serialize_schema(
+                schema=schema[key],
+                core=core,
+                path=path+[key],
+                parents=parents+[schema_id])
+            inner[key] = subschema
+
+        return inner
+
+    else:
+        return schema
+
 def serialize_schema(schema, state, core):
-    return state
+    """ Serialize schema to a string """
+    return recur_serialize_schema(schema=state, core=core)
 
 def serialize_array(schema, value, core):
     """ Serialize numpy array to list """
@@ -1229,6 +1272,9 @@ def deserialize_maybe(schema, encoded, core):
 
         return core.deserialize(value_type, encoded)
 
+def deserialize_quote(schema, state, core):
+    return state
+
 def deserialize_boolean(schema, encoded, core) -> bool:
     if encoded == 'true':
         return True
@@ -1278,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):
@@ -1313,8 +1371,52 @@ def deserialize_array(schema, encoded, core):
 def deserialize_edge(schema, encoded, core):
     return encoded
 
+def recur_deserialize_schema(schema, core, top_state=None, path=None):
+    top_state = top_state or schema
+    path = path or []
+
+    if isinstance(schema, dict):
+        subschema = {}
+        for key, value in schema.items():
+            subschema[key] = recur_deserialize_schema(
+                value,
+                core,
+                top_state=top_state,
+                path=path+[key])
+
+        return subschema
+
+    elif isinstance(schema, list):
+        subschema = []
+        for index, value in enumerate(schema):
+            subschema.append(
+                recur_deserialize_schema(
+                    value,
+                    core,
+                    top_state=top_state,
+                    path=path+[index]))
+
+        return tuple(subschema)
+
+    elif isinstance(schema, str):
+        if schema.startswith('/'):  # this is a reference to another schema
+            local_path = schema.split('/')[1:]
+            reference = get_path(top_state, local_path)
+
+            set_path(
+                tree=top_state,
+                path=path,
+                value=reference)
+
+            return reference
+        else:
+            return schema
+    else:
+        return schema
+
+
 def deserialize_schema(schema, state, core):
-    return state
+    return recur_deserialize_schema(schema=state, core=core)
 
 
 # =========================
@@ -1463,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] = {}
 
@@ -2047,22 +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):
+            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):
@@ -2076,10 +2197,6 @@ def default_quote(schema, core):
         return None
 
 
-def deserialize_quote(schema, state, core):
-    return state
-
-
 def generate_map(core, schema, state, top_schema=None, top_state=None, path=None):
     schema = schema or {}
     state = state or core.default(schema)
@@ -2191,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 {}
@@ -2322,9 +2444,45 @@ def sort_any(core, schema, state):
 
     return merged_schema, merged_state
 
+
 def sort_quote(core, schema, state):
     return schema, state
 
+
+def sort_map(core, schema, state):
+    if not isinstance(schema, dict):
+        schema = core.find(schema)
+    if not isinstance(state, dict):
+        return schema, state
+
+    merged_schema = {}
+    merged_state = {}
+
+    value_schema = core.find_parameter(
+        schema,
+        'value')
+
+    for key in union_keys(schema, state):
+        if is_schema_key(key):
+            if key in state:
+                merged_schema[key] = core.merge_schemas(
+                    schema.get(key, {}),
+                    state[key])
+            else:
+                merged_schema[key] = schema[key]
+        else:
+            subschema, merged_state[key] = core.sort(
+                schema.get(key, {}),
+                state.get(key, None))
+            if subschema:
+                value_schema = core.merge_schemas(
+                    value_schema,
+                    subschema)
+                # merged_schema[key] = subschema
+
+    return merged_schema, merged_state
+
+
 def find_union_type(core, schema, state):
     parameters = core.parameters_for(schema)
 
@@ -2341,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
+
+    raise Exception(f'could not resolve type with union:\n{update}\nunion:\n{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)
 
-#             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'cannot resolve types when updating\ncurrent type: {schema}\nupdate type: {update}')
 
-#             schema['_leaf'] = leaf_schema
-#         else:
-#             for key, subupdate in
+        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 schema
+    return outcome
 
 
 # ==========================
@@ -2584,6 +2785,7 @@ base_types = {
         '_slice': slice_map,
         '_fold': fold_map,
         '_divide': divide_map,
+        '_sort': sort_map,
         '_type_parameters': ['value'],
         '_description': 'flat mapping from keys of strings to values of any type'},
 
@@ -2599,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'},
 
@@ -2635,7 +2837,7 @@ base_types = {
 
     'path': {
         '_type': 'path',
-        '_inherit': 'list[string]',
+        '_inherit': 'list[string~integer]',
         '_apply': apply_path},
 
     'wires': {
@@ -2714,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.55 → 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):
@@ -349,20 +353,10 @@ class TypeSystem(Registry):
                 registry_type = self.retrieve(
                     schema['_type'])
 
-                # found = self.resolve(
-                #     registry_type,
-                #     schema)
-
                 found = self.merge_schemas(
                     registry_type,
                     schema)
 
-                # found = schema.copy()
-
-                # for key, value in registry_type.items():
-                #     if  key == '_type' or key not in found:
-                #         found[key] = value
-
             else:
                 found = {
                    key: self.access(
@@ -973,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)
 
@@ -986,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:
@@ -994,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)
@@ -1018,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
 
 
@@ -1326,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
@@ -1610,7 +1590,7 @@ class TypeSystem(Registry):
                 if inner_view is not None:
                     result[port_key] = inner_view
         else:
-            raise Exception(f'trying to project state with these ports:\n{schema}\nbut not sure what these wires are:\n{wires}')
+            raise Exception(f'trying to view state with these ports:\n{schema}\nbut not sure what these wires are:\n{wires}')
 
         return result
 

{bigraph-schema-0.0.55 → 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.55 → bigraph-schema-0.0.57/bigraph_schema.egg-info}/PKG-INFO

@@ -1,12 +1,10 @@
 Metadata-Version: 2.1
 Name: bigraph-schema
-Version: 0.0.55
+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
 Author-email: agmon.eran@gmail.com, ryan.spangler@gmail.com
-License: UNKNOWN
-Platform: UNKNOWN
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -53,5 +51,3 @@ This resource will guide you through the core concepts and methods, helping you
 ## License
 
 Bigraph-schema is open-source software released under the [Apache 2 License](https://github.com/vivarium-collective/bigraph-schema/blob/main/LICENSE).
-
-

{bigraph-schema-0.0.55 → 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.55 → bigraph-schema-0.0.57}/setup.py

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