bigraph-schema 0.0.60__tar.gz → 0.0.62__tar.gz

{bigraph-schema-0.0.60 → bigraph-schema-0.0.62}/.gitignore

@@ -11,4 +11,7 @@ __pycache__
 lib/
 *.ipynb_checkpoints/
 dist/
-bigraph_schema.egg-info/
+bigraph_schema.egg-info/
+.devenv*
+.devenv/
+devenv.lock

{bigraph-schema-0.0.60/bigraph_schema.egg-info → bigraph-schema-0.0.62}/PKG-INFO

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

@@ -3,6 +3,6 @@ from bigraph_schema.registry import (
     strip_schema_keys, type_parameter_key, non_schema_keys, set_path, transform_path)
 from bigraph_schema.utilities import get_path, visit_method
 from bigraph_schema.edge import Edge
-from bigraph_schema.type_system import TypeSystem, type_schema_keys, resolve_path
+from bigraph_schema.type_system import TypeSystem
 from bigraph_schema.protocols import local_lookup_module
-from bigraph_schema.type_functions import FUNCTION_TYPE, METHOD_TYPE
+from bigraph_schema.type_functions import FUNCTION_TYPE, METHOD_TYPE, type_schema_keys, resolve_path

{bigraph-schema-0.0.60 → bigraph-schema-0.0.62}/bigraph_schema/registry.py

@@ -23,10 +23,13 @@ def deep_merge_copy(dct, merge_dct):
 
 
 def deep_merge(dct, merge_dct):
-    """Recursive dict merge
-    
-    This mutates dct - the contents of merge_dct are added to dct (which is also returned).
-    If you want to keep dct you could call it like deep_merge(copy.deepcopy(dct), merge_dct)
+    """
+    Recursive dict merge
+
+    This mutates dct - the contents of merge_dct are added to dct (which is
+    also returned).
+
+    If you want to keep dct you could use deep_merge_copy
     """
     if dct is None:
         dct = {}
@@ -45,10 +48,14 @@ def deep_merge(dct, merge_dct):
 
 
 def validate_merge(state, dct, merge_dct):
-    """Recursive dict merge
-    
-    This mutates dct - the contents of merge_dct are added to dct (which is also returned).
-    If you want to keep dct you could call it like deep_merge(copy.deepcopy(dct), merge_dct)
+    """
+    Recursive dict merge
+
+    This mutates dct - the contents of merge_dct are added to dct (which is
+    also returned).
+
+    If you want to keep dct you could call it like
+    deep_merge(copy.deepcopy(dct), merge_dct)
     """
     dct = dct or {}
     merge_dct = merge_dct or {}
@@ -77,16 +84,16 @@ def validate_merge(state, dct, merge_dct):
 
 def establish_path(tree, path, top=None, cursor=()):
     """
-    Given a tree and a path in the tree that may or may not yet exist,
-    add nodes along the path and return the final node which is now at the
-    given path.
-    
+    Given a tree and a path in the tree that may or may not yet exist, add
+    nodes along the path and return the final node which is now at the given
+    path.
+
     Args:
     - tree: the tree we are establishing a path in
     - path: where the new subtree will be located in the tree
     - top: (None) a reference to the top of the tree
     - cursor: (()) the current location we are visiting in the tree
-    
+
     Returns:
     - node: the new node of the tree that exists at the given path
     """
@@ -127,14 +134,14 @@ def set_path(tree, path, value, top=None, cursor=None):
     """
     Given a tree, a path, and a value, sets the location
     in the tree corresponding to the path to the given value
-    
+
     Args:
     - tree: the tree we are setting a value in
     - path: where the new value will be located in the tree
     - value: the value to set at the given path in the tree
     - top: (None) a reference to the top of the tree
     - cursor: (()) the current location we are visiting in the tree
-    
+
     Returns:
     - node: the new node of the tree that exists at the given path
     """
@@ -199,14 +206,16 @@ def set_star_path(tree, path, value, top=None, cursor=()):
 
 def transform_path(tree, path, transform):
     """
-    Given a tree, a path, and a transform (function), mutate the tree by replacing the subtree at the path by whatever 
-    is returned from applying the transform to the existing value.
-    
+    Given a tree, a path, and a transform (function), mutate the tree by
+    replacing the subtree at the path by whatever is returned from applying the
+    transform to the existing value.
+
     Args:
     - tree: the tree we are setting a value in
     - path: where the new value will be located in the tree
-    - transform: the function to apply to whatever currently lives at the given path in the tree
-    
+    - transform: the function to apply to whatever currently lives at the given
+      path in the tree
+
     Returns:
     - node: the node of the tree that exists at the given path
     """
@@ -278,7 +287,9 @@ def non_schema_keys(schema):
 
 
 def strip_schema_keys(state):
-    """remove schema keys from a state dictionary, including nested dictionaries"""
+    """
+    remove schema keys from a state dictionary, including nested dictionaries
+    """
     if isinstance(state, dict):
         output = {}
         for key, value in state.items():
@@ -300,7 +311,9 @@ def default(type, default):
 
 
 class Registry(object):
-    """A Registry holds a collection of functions or objects"""
+    """
+    A Registry holds a collection of functions or objects
+    """
 
     def __init__(self, function_keys=None):
         function_keys = function_keys or []
@@ -315,10 +328,12 @@ class Registry(object):
         Args:
         - key: Item key.
         - item: The item to add.
-        - alternate_keys: Additional keys under which to register the item. These keys will not be included in the list
-            returned by ``Registry.list()``. This may be useful if you want to be able to look up an item in the
-            registry under multiple keys.
-        - strict (bool): Disallow re-registration, overriding existing keys. False by default.
+        - alternate_keys: Additional keys under which to register the item.
+          These keys will not be included in the list returned by
+          ``Registry.list()``. This may be useful if you want to be able to
+          look up an item in the registry under multiple keys.
+        - strict (bool): Disallow re-registration, overriding existing keys.
+          False by default.
         """
 
         # check that registered function have the required function keys
@@ -367,7 +382,7 @@ class Registry(object):
         elif inspect.isfunction(function):
             found = function
             module_key = function_module(found)
-        
+
         function_name = module_key.split('.')[-1]
         self.register(function_name, found)
         self.register(module_key, found)
@@ -381,7 +396,7 @@ class Registry(object):
 
     def find(self, key):
         return self.registry.get(key)
-        
+
 
     def access(self, key):
         """

{bigraph-schema-0.0.60 → bigraph-schema-0.0.62}/bigraph_schema/tests.py

@@ -7,10 +7,11 @@ import pprint
 import numpy as np
 from dataclasses import asdict
 
-from bigraph_schema import TypeSystem, local_lookup_module
+from bigraph_schema import local_lookup_module, TypeSystem
 from bigraph_schema.type_functions import (
-    divide_longest, base_types, accumulate, to_string, deserialize_integer, apply_schema, data_module)
-from bigraph_schema.utilities import compare_dicts, NONE_SYMBOL
+        accumulate, base_types, data_module, deserialize_integer,
+        divide_longest, to_string)
+from bigraph_schema.utilities import compare_dicts, NONE_SYMBOL, state_instance
 from bigraph_schema.units import units
 from bigraph_schema.registry import establish_path, remove_omitted
 
@@ -21,7 +22,30 @@ def core():
     return register_test_types(core)
 
 
+def register_test_types(core):
+    """
+    defines the test schemas
+    """
+    register_cube(core)
+
+    core.register('compartment', {
+        'counts': 'tree[float]',
+        'inner': 'tree[compartment]'})
+
+    core.register('metaedge', {
+        '_inherit': 'edge',
+        '_inputs': {
+            'before': 'metaedge'},
+        '_outputs': {
+            'after': 'metaedge'}})
+
+    return core
+
+
 def register_cube(core):
+    """
+    adds an additional simple schema for the test fixture
+    """
     cube_schema = {
         'shape': {
             '_type': 'shape',
@@ -50,24 +74,24 @@ def register_cube(core):
     return core
 
 
-def register_test_types(core):
-    register_cube(core)
+def test_basic_types(core):
+    assert core.find('integer')
+    assert core.find('cube')['depth']['_type'] == 'integer'
 
-    core.register('compartment', {
-        'counts': 'tree[float]',
-        'inner': 'tree[compartment]'})
-
-    core.register('metaedge', {
-        '_inherit': 'edge',
-        '_inputs': {
-            'before': 'metaedge'},
-        '_outputs': {
-            'after': 'metaedge'}})
 
-    return core
+def test_update_types(core):
+    core.update_types({'A': "payload"})
+    desc =  "a placeholder type with no structure"
+    core.update_types({'A': {'_description':desc}})
+    assert core.access('A') == {'_type': 'payload', '_description': desc}
 
 
 def test_reregister_type(core):
+    """
+    register raises an exception if replacing a schema with strict
+
+    it replaces the schema if not strict
+    """
     core.register('A', {'_default': 'a'})
     with pytest.raises(Exception) as e:
         core.register(
@@ -79,6 +103,18 @@ def test_reregister_type(core):
     assert core.access('A')['_default'] == 'b'
 
 
+def test_merge_schemas(core):
+    a = {'foo': {'bar': [1],
+                 'baz': [2]}}
+    b = {'foo': {'bar': 3},
+         'baz': 12}
+
+    assert core.merge_schemas(a, b) == \
+            {'foo': {'bar': 3,
+                     'baz': [2]},
+             'baz': 12}
+
+
 def test_generate_default(core):
     int_default = core.default(
         {'_type': 'integer'}
@@ -126,6 +162,15 @@ def test_apply_update(core):
 
 
 def print_schema_validation(core, library, should_pass):
+    """
+    validate_schema returns nothing for a valid schema declaration
+
+    this helper function makes clearer reports out of the test
+    failures
+
+    this is also why running the file outside pytest prints out
+    a huge wall of text
+    """
     for key, declaration in library.items():
         report = core.validate_schema(declaration)
         if len(report) == 0:
@@ -605,7 +650,8 @@ def test_link_place(core):
 
 def test_units(core):
     schema_length = {
-        'distance': {'_type': 'length'}}
+        'distance': {
+            '_type': 'length'}}
 
     state = {'distance': 11 * units.meter}
     update = {'distance': -5 * units.feet}
@@ -838,7 +884,7 @@ def test_inherits_from(core):
 
     assert core.inherits_from(
         'tree[path]',
-        'tree[list[string~integer]]')
+        'tree[list[mark]]')
 
     assert not core.inherits_from(
         'tree[path]',
@@ -1368,106 +1414,108 @@ def test_maybe_type(core):
 
 
 def test_tuple_type(core):
-    schema = {
+    schemas = [{
         '_type': 'tuple',
         '_type_parameters': ['0', '1', '2'],
         '_0': 'string',
-        '_1': 'int',
-        '_2': 'map[maybe[float]]'}
+        '_1': 'integer',
+        '_2': 'map[maybe[float]]'},
 
-    schema = ('string', 'int', 'map[maybe[float]]')
-    schema = 'tuple[string,int,map[maybe[float]]]'
-    schema = 'string|integer|map[maybe[float]]'
+        ('string', 'integer', 'map[maybe[float]]'),
+        'tuple[string,integer,map[maybe[float]]]',
+        'string|integer|map[maybe[float]]']
 
-    state = (
-        'aaaaa',
-        13, {
-            'a': 1.1,
-            'b': None})
+    for schema in schemas:
+        state = (
+            'aaaaa',
+            13, {
+                'a': 1.1,
+                'b': None})
 
-    update = (
-        'bbbbbb',
-        10, {
-            'a': 33.33,
-            'b': 4.44444})
+        update = (
+            'bbbbbb',
+            10, {
+                'a': 33.33,
+                'b': 4.44444})
 
-    assert core.check(schema, state)
-    assert core.check(schema, update)
-    assert not core.check(schema, 15)
+        assert core.check(schema, state)
+        assert core.check(schema, update)
+        assert not core.check(schema, 15)
 
-    result = core.apply(
-        schema,
-        state,
-        update)
+        result = core.apply(
+            schema,
+            state,
+            update)
 
-    assert len(result) == 3
-    assert result[0] == update[0]
-    assert result[1] == 23
-    assert result[2]['a'] == 34.43
-    assert result[2]['b'] == update[2]['b']
+        assert len(result) == 3
+        assert result[0] == update[0]
+        assert result[1] == 23
+        assert result[2]['a'] == 34.43
+        assert result[2]['b'] == update[2]['b']
 
-    encode = core.serialize(schema, state)
-    assert encode[2]['b'] == NONE_SYMBOL
-    assert encode[1] == '13'
+        encode = core.serialize(schema, state)
+        assert encode[2]['b'] == NONE_SYMBOL
+        assert encode[1] == '13'
 
-    decode = core.deserialize(schema, encode)
-    assert decode == state
+        decode = core.deserialize(schema, encode)
+        assert decode == state
 
-    tuple_type = core.access('(3|4|10)')
-    assert '_2' in tuple_type
-    assert tuple_type['_2'] == '10'
+        tuple_type = core.access('(3|4|10)')
+        assert '_2' in tuple_type
+        assert tuple_type['_2'] == '10'
 
-    tuple_type = core.access('tuple[9,float,7]')
-    assert '_2' in tuple_type
-    assert tuple_type['_2'] == '7'
+        tuple_type = core.access('tuple[9,float,7]')
+        assert '_2' in tuple_type
+        assert tuple_type['_2'] == '7'
 
 
 def test_union_type(core):
-    schema = {
+    schemas = [{
         '_type': 'union',
         '_type_parameters': ['0', '1', '2'],
         '_0': 'string',
         '_1': 'integer',
-        '_2': 'map[maybe[float]]'}
+        '_2': 'map[maybe[float]]'},
 
-    schema = 'string~integer~map[maybe[float]]'
+        'string~integer~map[maybe[float]]']
 
-    state = {
-        'a': 1.1,
-        'b': None}
+    for schema in schemas:
+        state = {
+            'a': 1.1,
+            'b': None}
 
-    update = {
-        'a': 33.33,
-        'b': 4.44444}
+        update = {
+            'a': 33.33,
+            'b': 4.44444}
 
-    assert core.check(schema, state)
-    assert core.check(schema, update)
-    assert core.check(schema, 15)
+        assert core.check(schema, state)
+        assert core.check(schema, update)
+        assert core.check(schema, 15)
 
-    wrong_state = {
-        'a': 1.1,
-        'b': None}
+        wrong_state = {
+            'a': 1.1,
+            'b': None}
 
-    wrong_update = 'a different type'
+        wrong_update = 'a different type'
 
-    assert core.check(schema, wrong_state)
-    assert core.check(schema, wrong_update)
+        assert core.check(schema, wrong_state)
+        assert core.check(schema, wrong_update)
 
-    # TODO: deal with union apply of different types
+        # TODO: deal with union apply of different types
 
-    result = core.apply(
-        schema,
-        state,
-        update)
+        result = core.apply(
+            schema,
+            state,
+            update)
 
-    assert result['a'] == 34.43
-    assert result['b'] == update['b']
+        assert result['a'] == 34.43
+        assert result['b'] == update['b']
 
-    encode = core.serialize(schema, state)
-    assert encode['b'] == NONE_SYMBOL
+        encode = core.serialize(schema, state)
+        assert encode['b'] == NONE_SYMBOL
 
-    decode = core.deserialize(schema, encode)
-    assert decode == state
+        decode = core.deserialize(schema, encode)
+        assert decode == state
 
 
 def test_union_values(core):
@@ -1992,27 +2040,6 @@ def test_set_slice(core):
             1])[1] == 33
 
 
-def from_state(dataclass, state):
-    if hasattr(dataclass, '__dataclass_fields__'):
-        fields = dataclass.__dataclass_fields__
-        state = state or {}
-
-        init = {}
-        for key, field in fields.items():
-            substate = from_state(
-                field.type,
-                state.get(key))
-            init[key] = substate
-        instance = dataclass(**init)
-    # elif get_origin(dataclass) in [typing.Union, typing.Mapping]:
-    #     instance = state
-    else:
-        instance = state
-        # instance = dataclass(state)
-
-    return instance
-
-
 def test_dataclass(core):
     simple_schema = {
         'a': 'float',
@@ -2023,7 +2050,7 @@ def test_dataclass(core):
     # TODO: accept just a string instead of only a path
     simple_dataclass = core.dataclass(
         simple_schema,
-        ['simple'])
+        'simple')
 
     simple_state = {
         'a': 88.888,
@@ -2037,10 +2064,14 @@ def test_dataclass(core):
         c=True,
         x='what')
 
-    simple_from = from_state(
+    simple_from = state_instance(
         simple_dataclass,
         simple_state)
 
+    default_simple = core.default_instance(
+        simple_schema,
+        'simple_default')
+
     nested_schema = {
         'a': {
             'a': {
@@ -2050,7 +2081,7 @@ def test_dataclass(core):
 
     nested_dataclass = core.dataclass(
         nested_schema,
-        ['nested'])
+        'nested')
 
     nested_state = {
         'a': {
@@ -2066,7 +2097,7 @@ def test_dataclass(core):
                 b=3.3333),
             5555.55))
 
-    nested_from = from_state(
+    nested_from = state_instance(
         nested_dataclass,
         nested_state)
 
@@ -2079,7 +2110,7 @@ def test_dataclass(core):
 
     complex_dataclass = core.dataclass(
         complex_schema,
-        ['complex'])
+        'complex')
 
     complex_state = {
         'a': {
@@ -2103,7 +2134,7 @@ def test_dataclass(core):
                         'OOO': ['..', '..', 'a', 'w']}}},
             'e': np.zeros((3, 4, 10))}}
 
-    complex_from = from_state(
+    complex_from = state_instance(
         complex_dataclass,
         complex_state)
 
@@ -2121,6 +2152,7 @@ def test_enum_type(core):
         'planet',
         'enum[mercury,venus,earth,mars,jupiter,saturn,neptune]')
 
+    # this is equivalent to the above (TODO: test this)
     # core.register('planet', {
     #     '_type': 'enum',
     #     '_type_parameters': ['0', '1', '2', '3', '4', '5', '6'],
@@ -2247,8 +2279,8 @@ def test_generate(core):
             '_type': 'enum[x,y,z]',
             '_default': 'y'},
         'units': {
-            'x': 11.1111,
-            'y': 22.833333}}
+            'meters': 11.1111,
+            'seconds': 22.833333}}
 
     generated_schema, generated_state = core.generate(
         schema,
@@ -2257,8 +2289,8 @@ def test_generate(core):
     assert generated_state['A'] == 0.0
     assert generated_state['B'] == 'one'
     assert generated_state['C'] == 'y'
-    assert generated_state['units']['y'] == 22.833333
-    assert 'x' not in generated_schema['units']
+    assert generated_state['units']['seconds'] == 22.833333
+    assert 'meters' not in generated_schema['units']
 
 
 def test_edge_cycle(core):
@@ -2382,6 +2414,14 @@ def test_union_key_error(core):
         result = generate_method(core, schema, state)
 
 
+def test_update_removed(core):
+    schema = 'map[float]'
+    state = {
+        'a': 11.11,
+        'b': 12.2222,
+        'c': 13.33333333}
+
+
 def fix_test_slice_edge(core):
     initial_schema = {
         'edge': {
@@ -2504,6 +2544,7 @@ if __name__ == '__main__':
     core = TypeSystem()
     core = register_test_types(core)
 
+    test_basic_types(core)
     test_reregister_type(core)
     test_generate_default(core)
     test_apply_update(core)
@@ -2554,6 +2595,8 @@ if __name__ == '__main__':
     test_union_key_error(core)
     test_tree_equivalence(core)
     test_star_view_project(core)
+    test_update_removed(core)
+    test_merge_schemas(core)
 
     # test_slice_edge(core)
     # test_complex_wiring(core)