bigraph-schema 1.0.0__py3-none-any.whl

bigraph_schema/methods/default.py

@@ -0,0 +1,204 @@
+from plum import dispatch
+import numpy as np
+
+from bigraph_schema.schema import (
+    Node,
+    Empty,
+    Union,
+    Tuple,
+    Boolean,
+    Number,
+    Integer,
+    Float,
+    Delta,
+    Nonnegative,
+    String,
+    Enum,
+    Wrap,
+    Maybe,
+    Overwrite,
+    List,
+    Map,
+    Tree,
+    Array,
+    Key,
+    Path,
+    Wires,
+    Protocol,
+    LocalProtocol,
+    Schema,
+    Link,
+)
+
+
+@dispatch
+def default(schema: None):
+    return None
+
+@dispatch
+def default(schema: Empty):
+    return None
+
+@dispatch
+def default(schema: Wrap):
+    if schema._default is not None:
+        return schema._default
+    else:
+        return default(schema._value)
+
+@dispatch
+def default(schema: Union):
+    if schema._default is not None:
+        return schema._default
+    else:
+        return default(schema._options[0])
+
+@dispatch
+def default(schema: Tuple):
+    if schema._default is not None:
+        return schema._default
+    else:
+        return [
+            default(subschema)
+            for subschema in schema._values]
+
+@dispatch
+def default(schema: Boolean):
+    if schema._default is not None:
+        return schema._default
+    else:
+        return False
+
+@dispatch
+def default(schema: Integer):
+    if schema._default is not None:
+        return schema._default
+    else:
+        return 0
+
+@dispatch
+def default(schema: Float):
+    if schema._default is not None:
+        return schema._default
+    else:
+        return 0.0
+
+@dispatch
+def default(schema: String):
+    if schema._default is not None:
+        return schema._default
+    else:
+        return ''
+
+@dispatch
+def default(schema: Enum):
+    if schema._default is not None:
+        return schema._default
+    else:
+        return schema._values[0]
+
+@dispatch
+def default(schema: List):
+    if schema._default is not None:
+        return schema._default
+    else:
+        return []
+
+@dispatch
+def default(schema: Map):
+    if schema._default is not None:
+        return schema._default
+    else:
+        return {}
+
+@dispatch
+def default(schema: Tree):
+    if schema._default is not None:
+        return schema._default
+    else:
+        return {}
+
+
+@dispatch
+def default(schema: Array):
+    if schema._default is not None:
+        return schema._default
+    else:
+        return np.zeros(
+            schema._shape,
+            dtype=schema._data)
+
+def default_wires(schema, path=None):
+    path = path or []
+
+    if isinstance(schema, dict):
+        result = {}
+        for key, subschema in schema.items():
+            subpath = path+[key]
+            result[key] = default_wires(
+                subschema,
+                subpath)
+        return result
+
+    elif isinstance(schema, Node):
+        return path
+
+
+@dispatch
+def default(schema: Protocol):
+    if schema._default is not None:
+        return schema._default
+    else:
+        return {
+            'protocol': 'local',
+            'data': 'edge'}
+
+def default_link(schema: Link):
+    if schema._default: 
+        return schema._default
+    else:
+        return {
+            'address': default(schema.address) or 'local:edge',
+            'config': default(schema.config) or {},
+            '_inputs': schema._inputs,
+            '_outputs': schema._outputs,
+            'inputs': default(schema.inputs) or default_wires(schema._inputs),
+            'outputs': default(schema.outputs) or default_wires(schema._outputs)}
+
+@dispatch
+def default(schema: Link):
+    return default_link(schema)
+
+def is_schema_key(key):
+    return isinstance(key, str) and key.startswith('_')
+
+@dispatch
+def default(schema: dict):
+    if '_default' in schema: 
+        return schema['_default']
+    else:
+        result = {}
+        for key in schema:
+            if not is_schema_key(key):
+                if isinstance(schema[key], float):
+                    import ipdb; ipdb.set_trace()
+                inner = default(
+                    schema[key])
+                result[key] = inner
+
+        return result
+
+@dispatch
+def default(schema: Node):
+    if schema._default is not None:
+        return schema._default
+    else:
+        result = {}
+        for key in schema.__dataclass_fields__:
+            if not is_schema_key(key):
+                inner = default(
+                    getattr(schema, key))
+                result[key] = inner
+
+        return result
+

bigraph_schema/methods/generalize.py

@@ -0,0 +1,309 @@
+import copy
+from plum import dispatch
+import numpy as np
+
+from dataclasses import replace, dataclass
+
+from bigraph_schema.schema import (
+    Node,
+    Empty,
+    Union,
+    Tuple,
+    Boolean,
+    Number,
+    Integer,
+    Float,
+    Delta,
+    Nonnegative,
+    String,
+    Enum,
+    Wrap,
+    Maybe,
+    Overwrite,
+    List,
+    Map,
+    Tree,
+    Array,
+    Key,
+    Path,
+    Wires,
+    Schema,
+    Link,
+)
+
+
+from bigraph_schema.methods.default import default
+from bigraph_schema.methods.resolve import resolve
+from bigraph_schema.methods.merge import merge, merge_update
+
+
+NODE_INSTANCE = Node()
+
+def generalize_subclass(subclass, superclass):
+    if superclass == NODE_INSTANCE:
+        return subclass
+    result = {}
+    for key in superclass.__dataclass_fields__:    
+        if key == '_default':
+            result[key] = superclass._default or subclass._default
+        else:
+            subattr = getattr(subclass, key)
+            if not key.startswith('_'):
+                superattr = getattr(superclass, key)
+                try:
+                    outcome = generalize(subattr, superattr)
+                except Exception as e:
+                    raise Exception(f'\ncannot generalize subtypes for attribute \'{key}\':\n{subattr}\n{superattr}\n\n  due to\n{e}')
+                result[key] = outcome
+            else:
+                result[key] = subattr
+    generalized = type(superclass)(**result)
+    return generalized
+
+
+@dispatch
+def generalize(current: Integer, update: Float):
+    if not update._default:
+        update._default = current._default
+    return update
+
+@dispatch
+def generalize(current: Float, update: Integer):
+    if not current._default:
+        current._default = update._default
+    return current
+
+@dispatch
+def generalize(current: Empty, update: Node):
+    return update
+
+@dispatch
+def generalize(current: Node, update: Empty):
+    return current
+
+@dispatch
+def generalize(current: Wrap, update: Wrap):
+    value = generalize(current._value, update._value)
+    return value
+    # if type(current) == type(update):
+    #     return type(current)(_value=value)
+    # elif issubclass(current_type, update_type):
+    #     return generalize_subclass(current, update)
+    # elif issubclass(update_type, current_type):
+    #     return generalize_subclass(update, current)
+    # else:
+    #     return update
+
+@dispatch
+def generalize(current: Wrap, update: Node):
+    value = generalize(current._value, update)
+    return value
+
+@dispatch
+def generalize(current: Node, update: Wrap):
+    value = generalize(current, update._value)
+    return value
+
+@dispatch
+def generalize(current: Node, update: Node):
+    current_type = type(current)
+    update_type = type(update)
+    if current_type == update_type or issubclass(current_type, update_type):
+        return generalize_subclass(current, update)
+    elif issubclass(update_type, current_type):
+        return generalize_subclass(update, current)
+    else:
+        raise Exception(f'\ncannot generalize types:\n{current}\n{update}\n')
+
+
+def generalize_node_dict(current: Node, update: dict):
+    fields = set(current.__dataclass_fields__)
+    keys = set(update.keys())
+
+    if len(keys.difference(fields)) > 0:
+        return update
+    else:
+        return current
+
+
+@dispatch
+def generalize(current: Array, update: dict):
+    for key in update:
+        if not (isinstance(key, int) and key < current._shape[0]):
+            if key != '*':
+                return generalize_node_dict(current, update)
+
+    return current
+
+
+@dispatch
+def generalize(current: Map, update: dict):
+    result = current._value
+
+    try:
+        for key, value in update.items():
+            result = generalize(result, value)
+        generalized = replace(current, _value=result)
+
+    except:
+        # upgrade from map to struct schema
+        map_default = default(current)
+        generalized = {
+            key: current._value
+            for key in map_default}
+        generalized.update(update)
+
+    schema = merge_update(generalized, current, update)
+    return schema
+
+
+@dispatch
+def generalize(current: dict, update: Map):
+    result = update._value
+
+    try:
+        for key, value in current.items():
+            result = generalize(result, value)
+        generalized = replace(update, _value=result)
+
+    except:
+        # upgrade from map to struct schema
+        map_default = default(update)
+        generalized = {
+            key: update._value
+            for key in map_default}
+        current.update(generalized)
+
+    schema = merge_update(generalized, current, update)
+    return schema
+
+@dispatch
+def generalize(current: Tree, update: Map):
+    value = current._leaf
+    leaf = update._value
+    update_leaf = generalize(leaf, value)
+    result = copy.copy(current)
+    generalized = replace(result, _leaf=update_leaf)
+
+    schema = merge_update(generalized, current, update)
+    return schema
+
+@dispatch
+def generalize(current: Tree, update: Tree):
+    current_leaf = current._leaf
+    update_leaf = update._leaf
+    generalized = generalize(current_leaf, update_leaf)
+    result = replace(current, _leaf=generalized)
+
+    schema = merge_update(result, current, update)
+    return schema
+
+@dispatch
+def generalize(current: Tree, update: Node):
+    leaf = current._leaf
+    try:
+        generalized = generalize(leaf, update)
+    except:
+        raise(f'update schema is neither a tree or a leaf:\n{current}\n{update}')
+
+    replace(current, _leaf=generalized)
+    return current
+
+@dispatch
+def generalize(current: Tree, update: dict):
+    result = copy.copy(current)
+    leaf = current._leaf
+    for key, value in update.items():
+        try:
+            leaf = generalize(leaf, value)
+        except:
+            result = generalize(result, value)
+    generalized = replace(result, _leaf=leaf)
+
+    schema = merge_update(generalized, current, update)
+    return schema
+
+
+@dispatch
+def generalize(current: dict, update: dict):
+    result = {}
+    all_keys = set(current.keys()).union(set(update.keys()))
+    for key in all_keys:
+        try:
+            value = generalize(
+                current.get(key),
+                update.get(key))
+        except Exception as e:
+            raise Exception(f'\ncannot generalize subtypes for key \'{key}\':\n{current}\n{update}\n\n  due to\n{e}')
+
+        result[key] = value
+    return result
+
+
+@dispatch
+def generalize(current: Node, update: dict):
+    return generalize_node_dict(current, update)
+
+
+@dispatch
+def generalize(current: dict, update: Node):
+    fields = set(update.__dataclass_fields__)
+    keys = set(current.keys())
+
+    if len(keys.difference(fields)) > 0:
+        return current
+    else:
+        return update
+
+# @dispatch
+# def generalize(current: dict, update: Node):
+#     fields = set(update.__dataclass_fields__)
+#     keys = set(current.keys())
+
+#     for key in keys.intersect(fields):
+#         getattr(update, key)
+    
+    
+
+@dispatch
+def generalize(current: list, update: list):
+    return tuple(update)
+
+
+@dispatch
+def generalize(current: String, update: Node):
+    if current._default:
+        update._default = current._default
+    return update
+
+@dispatch
+def generalize(current: String, update: Wrap):
+    return generalize(current, update._value)
+
+@dispatch
+def generalize(current: String, update: String):
+    if update._default or not current._default:
+        return update
+    else:
+        return current
+
+@dispatch
+def generalize(current: Node, update: String):
+    if update._default:
+        current._default = update._default
+    return current
+
+@dispatch
+def generalize(current: Empty, update: Empty):
+    return update
+
+@dispatch
+def generalize(current, update):
+    if current is None or not current:
+        return update
+    elif update is None or not update:
+        return current
+    else:
+        raise Exception(f'\ncannot generalize types, not schemas:\n{current}\n{update}\n')
+
+

bigraph_schema/methods/handle_parameters.py

@@ -0,0 +1,182 @@
+from plum import dispatch
+import numpy as np
+import numpy.lib.format as nf
+
+from types import NoneType
+from dataclasses import replace
+
+from bigraph_schema.schema import (
+    Node,
+    Union,
+    Tuple,
+    Boolean,
+    Number,
+    Integer,
+    Float,
+    Complex,
+    Delta,
+    Nonnegative,
+    NPRandom,
+    String,
+    Enum,
+    Wrap,
+    Maybe,
+    Overwrite,
+    List,
+    Map,
+    Tree,
+    Array,
+    Key,
+    Path,
+    Wires,
+    Schema,
+    Link,
+    schema_dtype,
+)
+
+# aligning parameters takes them from positioned arguments and gives them keys
+# in a dict.
+
+# reifying the schema takes a dict of representations and turns them into schemas
+# according to the parameters
+
+# handling parameters combines these operations to go from positioned arguments to schemas
+
+# we need aligning when parsing, but only reifying when inferring from state
+# hence the distinction here
+
+def schema_keys(schema):
+    keys = []
+    for key in schema.__dataclass_fields__:
+        if key.startswith('_'):
+            keys.append(key)
+
+    return keys
+
+@dispatch
+def align_parameters(schema: Tuple, parameters):
+    return {
+        '_values': parameters}
+
+@dispatch
+def align_parameters(schema: Enum, parameters):
+    return {
+        '_values': parameters}
+
+@dispatch
+def align_parameters(schema: Union, parameters):
+    return {
+        '_options': parameters}
+
+@dispatch
+def align_parameters(schema: Map, parameters):
+    align = {}
+
+    if len(parameters) == 1:
+        align['_value'] = parameters[0]
+    elif len(parameters) == 2:
+        align['_key'], align['_value'] = parameters
+
+    return align
+
+@dispatch
+def align_parameters(schema: Array, parameters):
+    return {
+        '_shape': parameters[0],
+        '_data': parameters[1]}
+
+@dispatch
+def align_parameters(schema: Link, parameters):
+    align = {
+        '_inputs': parameters[0],
+        '_outputs': parameters[1]}
+
+    return align
+
+@dispatch
+def align_parameters(schema: Node, parameters):
+    align = {}
+    keys = schema_keys(schema)[1:]
+    for key, parameter in zip(keys, parameters):
+        align[key] = parameter
+    return align
+
+@dispatch
+def align_parameters(schema, parameters):
+    raise Exception(f'unknown parameters for schema {schema}: {parameters}')
+
+@dispatch
+def reify_schema(core, schema: Enum, parameters):
+    if '_values' in parameters:
+        schema._values = parameters['_values']
+    return schema
+
+@dispatch
+def reify_schema(core, schema: Array, parameters):
+    if '|' in parameters.get('_shape', ''):
+        import ipdb; ipdb.set_trace()
+
+    schema._shape = tuple([
+        int(value)
+        for value in parameters.get('_shape', (1,))])
+
+    data = parameters.get('_data', 'float')
+    data_schema = core.access(data)
+    # if isinstance(data, Node):
+    #     data = core.render(data)
+    # schema._data = nf.descr_to_dtype(data)
+    dtype = schema_dtype(data)
+    if isinstance(dtype, Array):
+        schema = replace(schema, **{'_shape': schema._shape + dtype._shape})
+    else:
+        schema._data = dtype
+
+    return schema
+
+@dispatch
+def reify_schema(core, schema: Union, parameters):
+    return replace(schema, **parameters)
+
+
+def reify_schema_link(core, schema, parameters):
+    if 'address' in parameters:
+        schema.address = core.access(parameters['address'])
+    if 'config' in parameters:
+        schema.config = core.access(parameters['config'])
+    if 'inputs' in parameters:
+        schema.inputs = core.access(parameters['inputs'])
+    if 'outputs' in parameters:
+        schema.outputs = core.access(parameters['outputs'])
+    if '_inputs' in parameters:
+        schema._inputs = core.access(parameters['_inputs'])
+    if '_outputs' in parameters:
+        schema._outputs = core.access(parameters['_outputs'])
+
+    return schema
+
+@dispatch
+def reify_schema(core, schema: Link, parameters):
+    return reify_schema_link(core, schema, parameters)
+
+@dispatch
+def reify_schema(core, schema: Node, parameters):
+    for key, parameter in parameters.items():
+        subkey = core.access(parameter)
+
+        if hasattr(schema, key):
+            field = getattr(schema, key)
+            resolve = core.resolve(field, subkey)
+        else:
+            resolve = subkey
+
+        setattr(schema, key, resolve)
+
+    return schema
+
+@dispatch
+def reify_schema(core, schema, parameters):
+    import ipdb; ipdb.set_trace()
+
+def handle_parameters(core, schema, parameters):
+    align = align_parameters(schema, parameters)
+    return reify_schema(core, schema, align)