bigraph-schema 0.0.45__tar.gz → 0.0.46__tar.gz

{bigraph-schema-0.0.45/bigraph_schema.egg-info → bigraph-schema-0.0.46}/PKG-INFO

@@ -1,10 +1,12 @@
 Metadata-Version: 2.1
 Name: bigraph-schema
-Version: 0.0.45
+Version: 0.0.46
 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
@@ -52,3 +54,5 @@ 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.45 → bigraph-schema-0.0.46}/bigraph_schema/registry.py

@@ -43,6 +43,10 @@ optional_schema_keys = set([
 type_schema_keys = required_schema_keys | optional_schema_keys
 
 
+def deep_merge_copy(dct, merge_dct):
+    return deep_merge(copy.deepcopy(dct), merge_dct)
+
+
 def deep_merge(dct, merge_dct):
     """Recursive dict merge
     
@@ -347,9 +351,9 @@ class Registry(object):
         return function_name, module_key
 
 
-    def register_multiple(self, schemas, force=False):
+    def register_multiple(self, schemas, strict=False):
         for key, schema in schemas.items():
-            self.register(key, schema, force=force)
+            self.register(key, schema, strict=strict)
 
     def find(self, key):
         return self.registry.get(key)

{bigraph-schema-0.0.45 → bigraph-schema-0.0.46}/bigraph_schema/type_system.py

@@ -220,6 +220,41 @@ def visit_method(schema, state, method, values, core):
     return result
 
 
+def generate_quote(core, schema, state, top_schema=None, top_state=None, path=None):
+    return schema, state, top_schema, top_state
+
+
+def sort_quote(core, schema, state):
+    return schema, state
+
+
+def sort_any(core, schema, state):
+    if not isinstance(schema, dict):
+        schema = core.find(schema)
+    if not isinstance(state, dict):
+        return schema, state
+
+    merged_schema = {}
+    merged_state = {}
+
+    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:
+                merged_schema[key] = subschema
+
+    return merged_schema, merged_state
+
+
 def fold_any(schema, state, method, values, core):
     if isinstance(state, dict):
         result = {}
@@ -613,46 +648,14 @@ def is_empty(value):
         return False
 
 
-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):
-        merge_state = new_state
-
-    elif is_empty(new_state):
-        merge_state = current_state
-    
-    elif isinstance(new_state, dict):
-        if isinstance(current_state, dict):
-            for key, value in new_state.items():
-                if is_schema_key(key):
-                    current_state[key] = value
-                else:
-                    current_state[key] = core.merge(
-                        schema.get(key),
-                        current_state.get(key),
-                        value)
-            merge_state = current_state
-        else:
-            merge_state = new_state
-    else:
-        merge_state = new_state
-
-    return merge_state
-
-    # return core.deserialize(
-    #     schema,
-    #     merge_state)
-
-
 def bind_any(schema, state, key, subschema, substate, core):
     result_schema = core.resolve_schemas(
           schema,
           {key: subschema})
 
+    if state is None:
+        state = {}
+
     state[key] = substate
 
     return result_schema, state
@@ -877,7 +880,8 @@ def union_keys(schema, state):
 
 def generate_any(core, schema, state, top_schema=None, top_state=None, path=None):
     schema = schema or {}
-    state = state or core.default(schema)
+    if is_empty(state):
+        state = core.default(schema)
     top_schema = top_schema or schema
     top_state = top_state or state
     path = path or []
@@ -925,7 +929,10 @@ def generate_any(core, schema, state, top_schema=None, top_state=None, path=None
                 generated_schema,
                 generated_state)
         else:
-            top_schema, top_state = generated_schema, generated_state
+            top_state = core.merge_recur(
+                top_schema,
+                top_state,
+                generated_state)
 
     else:
         generated_schema, generated_state = schema, state
@@ -945,16 +952,21 @@ registry_types = {
         '_slice': slice_any,
         '_apply': apply_any,
         '_check': check_any,
+        '_sort': sort_any,
         '_generate': generate_any,
         '_serialize': serialize_any,
         '_deserialize': deserialize_any,
         '_dataclass': dataclass_any,
         '_resolve': resolve_any,
         '_fold': fold_any,
-        '_merge': merge_any,
         '_bind': bind_any,
         '_divide': divide_any},
 
+    'quote': {
+        '_type': 'quote',
+        '_generate': generate_quote,
+        '_sort': sort_quote},
+
     'tuple': {
         '_type': 'tuple',
         '_default': default_tuple,
@@ -1198,32 +1210,18 @@ class TypeSystem(Registry):
         return merged
 
 
-    def merge_schema_keys(self, schema, state):
-        if not isinstance(schema, dict):
-            schema = self.find(schema)
-        if not isinstance(state, dict):
-            return schema, state
-    
-        merged_schema = {}
-        merged_state = {}
-
-        for key in union_keys(schema, state):
-            if is_schema_key(key):
-                if key in state:
-                    merged_schema[key] = self.merge_schemas(
-                        schema.get(key, {}),
-                        state[key])
-                else:
-                    merged_schema[key] = schema[key]
-            else:
-                subschema, merged_state[key] = self.merge_schema_keys(
-                    schema.get(key, {}),
-                    state.get(key, None))
+    def sort(self, schema, state):
+        schema = self.access(schema)
 
-                if subschema:
-                    merged_schema[key] = subschema
+        sort_function = self.choose_method(
+            schema,
+            state,
+            'sort')
 
-        return merged_schema, merged_state
+        return sort_function(
+            self,
+            schema,
+            state)
 
 
     def exists(self, type_key):
@@ -1279,7 +1277,7 @@ class TypeSystem(Registry):
                 found = {
                    key: self.access(
                        branch,
-                       strict=strict)
+                       strict=strict) if key != '_default' else branch
                    for key, branch in schema.items()}
 
         elif isinstance(schema, int):
@@ -1573,7 +1571,6 @@ class TypeSystem(Registry):
                 pipes = '|'.join(colons)
                 return f'({pipes})'
         else:
-            print(f'no representation for {schema}')
             return str(schema)
 
 
@@ -1886,9 +1883,14 @@ class TypeSystem(Registry):
                     for parameter in update['_type_parameters']:
                         parameter_key = f'_{parameter}'
                         if parameter in current['_type_parameters']:
-                            outcome[parameter_key] = self.resolve_schemas(
-                                current[parameter_key],
-                                update[parameter_key])
+                            if parameter_key in current:
+                                outcome[parameter_key] = self.resolve_schemas(
+                                    current[parameter_key],
+                                    update[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):
@@ -2134,19 +2136,45 @@ class TypeSystem(Registry):
         return self.set_update(schema, state, update)
 
 
-    def merge(self, schema, current_state, new_state):
-        schema = self.access(schema)
+    def merge_recur(self, schema, state, update):
+        if is_empty(schema):
+            merge_state = update
 
-        merge_function = self.choose_method(
-            schema,
-            new_state,
-            'merge')
+        elif is_empty(update):
+            merge_state = state
+
+        elif isinstance(update, dict):
+            if isinstance(state, dict):
+                for key, value in update.items():
+                    if is_schema_key(key):
+                        state[key] = value
+                    else:
+                        if isinstance(schema, str):
+                            schema = self.access(schema)
+
+                        state[key] = self.merge_recur(
+                            schema.get(key),
+                            state.get(key),
+                            value)
+                merge_state = state
+            else:
+                merge_state = update
+        else:
+            merge_state = update
+
+        return merge_state
 
-        return merge_function(
+
+    def merge(self, schema, state, path, update_schema, update_state, defer=False):
+        top_schema, top_state = self.set_slice(
             schema,
-            current_state,
-            new_state,
-            self)
+            state,
+            path,
+            update_schema,
+            update_state,
+            defer)
+
+        return self.generate(top_schema, top_state)
 
 
     def bind(self, schema, state, key, target_schema, target_state):
@@ -2167,12 +2195,25 @@ 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
+        '''
+
         if len(path) == 0:
-            return schema, self.merge(
+            # deal with paths of length 0
+            # this should never happen?
+            merged_schema = self.resolve_schemas(
                 schema,
+                target_schema)
+
+            merged_state = deep_merge(
                 state,
                 target_state)
 
+            return merged_schema, merged_state
+
         elif len(path) == 1:
             key = path[0]
             destination_schema, destination_state = self.slice(
@@ -2185,13 +2226,13 @@ class TypeSystem(Registry):
                 target_schema)
 
             if not defer:
-                result_state = self.merge(
+                result_state = self.merge_recur(
                     final_schema,
                     destination_state,
                     target_state)
 
             else:
-                result_state = self.merge(
+                result_state = self.merge_recur(
                     final_schema,
                     target_state,
                     destination_state)
@@ -2566,6 +2607,9 @@ class TypeSystem(Registry):
                             for parameter in current['_type_parameters']:
                                 parameter_key = f'_{parameter}'
                                 if parameter_key in question:
+                                    if parameter_key not in current:
+                                        return False
+
                                     if not self.equivalent(current[parameter_key], question[parameter_key]):
                                         return False
                         else:
@@ -2719,7 +2763,7 @@ class TypeSystem(Registry):
                         top_schema,
                         compound_schema)
 
-                    top_state = self.merge(
+                    top_state = self.merge_recur(
                         top_schema,
                         compound_state,
                         top_state)
@@ -2874,32 +2918,32 @@ class TypeSystem(Registry):
         
 
     def generate_recur(self, schema, state, top_schema=None, top_state=None, path=None):
-        merged_schema, merged_state = self.merge_schema_keys(
-            schema,
-            state)
-
         found = self.retrieve(
-            merged_schema)
+            schema)
 
         generate_function = self.choose_method(
             found,
-            merged_state,
+            state,
             'generate')
 
         return generate_function(
             self,
             found,
-            merged_state,
+            state,
             top_schema=top_schema,
             top_state=top_state,
             path=path)
 
 
     def generate(self, schema, state):
-        _, _, top_schema, top_state = self.generate_recur(
+        merged_schema, merged_state = self.sort(
             schema,
             state)
 
+        _, _, top_schema, top_state = self.generate_recur(
+            merged_schema,
+            merged_state)
+
         return top_schema, top_state
 
 
@@ -3365,11 +3409,11 @@ def apply_map(schema, current, update, core=None):
     for key, update_value in update.items():
         if key == '_add':
             for addition_key, addition in update_value.items():
-                filled = core.hydrate(
+                generated_schema, generated_state = core.generate(
                     value_type,
                     addition)
 
-                result[addition_key] = filled
+                result[addition_key] = generated_state
 
         elif key == '_remove':
             for remove_key in update_value:
@@ -3378,10 +3422,11 @@ def apply_map(schema, current, update, core=None):
 
         elif key not in current:
             # This supports adding without the '_add' key, if the key is not in the state
-            filled = core.hydrate(
+            generated_schema, generated_state = core.generate(
                 value_type,
                 update_value)
-            result[key] = filled
+
+            result[key] = generated_state
 
             # raise Exception(f'trying to update a key that does not exist:\n  value: {current}\n  update: {update}')
         else:
@@ -3706,7 +3751,9 @@ def generate_map(core, schema, state, top_schema=None, top_state=None, path=None
     # generated_schema = {}
     # generated_state = {}
 
-    generated_schema, generated_state = core.merge_schema_keys(
+    # TODO: can we assume this was already sorted at the top level?
+
+    generated_schema, generated_state = core.sort(
         schema,
         state)
 
@@ -3719,7 +3766,7 @@ def generate_map(core, schema, state, top_schema=None, top_state=None, path=None
                 schema.get(key))
 
         else:
-            subschema = schema.get(key)
+            subschema = schema.get(key, value_type)
             substate = state.get(key)
 
             subschema = core.merge_schemas(
@@ -3747,14 +3794,17 @@ def generate_tree(core, schema, state, top_schema=None, top_state=None, path=Non
         schema,
         'leaf')
 
-    if core.check(state, leaf_type):
+    leaf_is_any = leaf_type == 'any' or (isinstance(leaf_type, dict) and leaf_type.get('_type') == 'any')
+
+    if not leaf_is_any and core.check(leaf_type, 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)
-    else:
+
+    elif isinstance(state, dict):
         generate_schema = {}
         generate_state = {}
 
@@ -3797,6 +3847,9 @@ def generate_tree(core, schema, state, top_schema=None, top_state=None, path=Non
                 generate_schema[key] = schema[key]
             else:
                 raise Exception(' the impossible has occurred now is the time for celebration')
+    else:
+        generate_schema = schema
+        generate_state = state
 
     return generate_schema, generate_state, top_schema, top_state
 
@@ -3821,7 +3874,8 @@ def generate_ports(core, schema, wires, top_schema=None, top_state=None, path=No
                 port_key)
 
         if isinstance(subwires, dict):
-            top_schema, top_state = core.generate_ports(
+            top_schema, top_state = generate_ports(
+                core,
                 port_schema,
                 subwires,
                 top_schema=top_schema,
@@ -3853,7 +3907,7 @@ def generate_edge(core, schema, state, top_schema=None, top_state=None, path=Non
     top_state = top_state or state
     path = path or []
 
-    generate_schema, generate_state, top_schema, top_state = generate_any(
+    generated_schema, generated_state, top_schema, top_state = generate_any(
         core,
         schema,
         state,
@@ -3861,17 +3915,25 @@ def generate_edge(core, schema, state, top_schema=None, top_state=None, path=Non
         top_state=top_state,
         path=path)
 
+    deserialized_state = core.deserialize(
+        generated_schema,
+        generated_state)
+
+    merged_schema, merged_state = core.sort(
+        generated_schema,
+        deserialized_state)
+
     top_schema, top_state = core.set_slice(
         top_schema,
         top_state,
         path,
-        generate_schema,
-        generate_state)
+        merged_schema,
+        merged_state)
 
     for port_key in ['inputs', 'outputs']:
-        port_schema = generate_schema.get(
+        port_schema = merged_schema.get(
             f'_{port_key}', {})
-        ports = generate_state.get(
+        ports = merged_state.get(
             port_key, {})
 
         top_schema, top_state = generate_ports(
@@ -3882,7 +3944,7 @@ def generate_edge(core, schema, state, top_schema=None, top_state=None, path=Non
             top_state=top_state,
             path=path)
 
-    return generate_schema, generate_state, top_schema, top_state
+    return merged_schema, merged_state, top_schema, top_state
 
 
 def apply_edge(schema, current, update, core):
@@ -4455,12 +4517,13 @@ def default_enum(schema, core):
 
 
 def default_edge(schema, core):
-    return {
-        # '_type': schema['_type'],
-        'inputs': core.default(
-            schema['inputs']),
-        'outputs': core.default(
-            schema['outputs'])}
+    edge = {}
+    for key in schema:
+        if not is_schema_key(key):
+            edge[key] = core.default(
+                schema[key])
+
+    return edge
 
 
 base_type_library = {
@@ -6489,7 +6552,7 @@ def test_merge(core):
                 'x': {
                     'o': 99999.11}}}}
 
-    result = core.merge(
+    result = core.merge_recur(
         current_schema,
         current_state,
         merge_state)
@@ -6942,9 +7005,59 @@ def test_edge_cycle(core):
     # print(diff(schema_from_schema, schema_from_state))
     # print(diff(state_from_schema, state_from_state))
 
+    if schema_from_schema != schema_from_state:
+        print(diff(schema_from_schema, schema_from_state))
+
+    if state_from_schema != state_from_state:
+        print(diff(state_from_schema, state_from_state))
+
     assert schema_from_schema == schema_from_state
     assert state_from_schema == state_from_state
 
+    for key in ['A', 'B', 'C']:
+        for result in [schema_from_schema, state_from_schema, schema_from_state, state_from_state]:
+            assert key in result
+
+
+def test_merge(core):
+    schema = {
+        'A': 'float',
+        'B': 'enum[one,two,three]',
+        'units': 'map[float]'}
+
+    state = {
+        'C': {
+            '_type': 'enum[x,y,z]',
+            '_default': 'y'},
+        'units': {
+            'x': 11.1111,
+            'y': 22.833333}}
+
+    generated_schema, generated_state = core.generate(
+        schema,
+        state)
+
+    edge_state = {
+        '_type': 'edge',
+        '_inputs': {
+            'input': 'float'},
+        '_outputs': {
+            'output': 'float'},
+        'inputs': {
+            'input': ['A']},
+        'outputs': {
+            'output': ['D']}}
+
+    top_schema, top_state = core.merge(
+        generated_schema,
+        generated_state,
+        ['edge'],
+        {},
+        edge_state)
+
+    assert 'D' in top_state
+    assert top_schema['D']['_type'] == 'float'
+
 
 if __name__ == '__main__':
     core = TypeSystem()
@@ -6994,3 +7107,4 @@ if __name__ == '__main__':
     test_representation(core)
     test_generate(core)
     test_edge_cycle(core)
+    test_merge(core)

{bigraph-schema-0.0.45 → bigraph-schema-0.0.46/bigraph_schema.egg-info}/PKG-INFO

@@ -1,10 +1,12 @@
 Metadata-Version: 2.1
 Name: bigraph-schema
-Version: 0.0.45
+Version: 0.0.46
 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
@@ -52,3 +54,5 @@ 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.45 → bigraph-schema-0.0.46}/bigraph_schema.egg-info/SOURCES.txt

@@ -1,15 +1,7 @@
-.gitignore
 AUTHORS.md
-CLA.md
-CODE_OF_CONDUCT.md
-CONTRIBUTING.md
 LICENSE
 README.md
-pytest.ini
-release.sh
 setup.py
-.github/workflows/notebook_to_html.yml
-.github/workflows/pytest.yml
 bigraph_schema/__init__.py
 bigraph_schema/data.py
 bigraph_schema/parse.py
@@ -22,10 +14,4 @@ bigraph_schema.egg-info/PKG-INFO
 bigraph_schema.egg-info/SOURCES.txt
 bigraph_schema.egg-info/dependency_links.txt
 bigraph_schema.egg-info/requires.txt
-bigraph_schema.egg-info/top_level.txt
-notebooks/core.ipynb
-notebooks/demo.ipynb
-notebooks/images/place-link.png
-notebooks/images/reaction-after.png
-notebooks/images/reaction-before.png
-notebooks/images/redex-reactum.png
+bigraph_schema.egg-info/top_level.txt

{bigraph-schema-0.0.45 → bigraph-schema-0.0.46}/setup.py

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