bigraph-schema 1.0.0__py3-none-any.whl

bigraph_schema/methods/infer.py

@@ -0,0 +1,217 @@
+from plum import dispatch
+import numpy as np
+from numpy.random.mtrand import RandomState
+import traceback
+
+from types import NoneType
+from dataclasses import replace
+
+from bigraph_schema.schema import (
+    Node,
+    Union,
+    Tuple,
+    Boolean,
+    Number,
+    Integer,
+    Float,
+    Delta,
+    Nonnegative,
+    NPRandom,
+    String,
+    Enum,
+    Wrap,
+    Maybe,
+    Overwrite,
+    List,
+    Map,
+    Tree,
+    Array,
+    Key,
+    Path,
+    Wires,
+    Schema,
+    Link,
+)
+
+
+from bigraph_schema.methods.serialize import serialize
+from bigraph_schema.methods.realize import realize
+
+MISSING_TYPES = {}
+
+
+def set_default(schema, value):
+    if value is not None:
+        serialized = serialize(schema, value)
+        if isinstance(serialized, dict) and '_default' in serialized:
+            serialized = serialized['_default']
+
+        if isinstance(schema, Node):
+            schema = replace(schema, _default=serialized)
+        elif isinstance(schema, dict):
+            schema['_default'] = serialized
+
+    return schema
+
+@dispatch
+def infer(core,
+          value: (int | np.int32 | np.int64 |
+                  np.dtypes.Int32DType | np.dtypes.Int64DType),
+          path: tuple = ()):
+    schema = Integer()
+    return set_default(schema, value), []
+
+@dispatch
+def infer(core, value: bool, path: tuple = ()):
+    schema = Boolean()
+    return set_default(schema, value), []
+
+@dispatch
+def infer(core,
+          value: (float | np.float32 | np.float64 |
+                  np.dtypes.Float32DType | np.dtypes.Float64DType),
+          path: tuple = ()):
+    schema = Float()
+    return set_default(schema, value), []
+
+@dispatch
+def infer(core, value: str, path: tuple = ()):
+    schema = String()
+    return set_default(schema, value), []
+
+@dispatch
+def infer(core, value: np.ndarray, path: tuple = ()):
+    schema = Array(
+        _shape=value.shape,
+        _data=value.dtype) # Dtype(_fields=value.dtype))
+
+    return set_default(schema, value), []
+
+@dispatch
+def infer(core, value: RandomState, path: tuple = ()):
+    state = value.get_state()
+    data, merges = infer(core, state)
+    schema = NPRandom(state=data)
+
+    return set_default(schema, value), merges
+
+@dispatch
+def infer(core, value: list, path: tuple = ()):
+    merges = []
+    if len(value) > 0:
+        element, merges = infer(
+            core,
+            value[0],
+            path+('_element',))
+    else:
+        element = Node()
+    
+    schema = List(_element=element)
+    return set_default(schema, value), merges
+
+@dispatch
+def infer(core, value: tuple, path: tuple = ()):
+    result = []
+    merges = []
+    for index, item in enumerate(value):
+        if isinstance(item, np.str_):
+            result.append(item)
+        else:
+            inner, submerges = infer(core, item, path+(index,))
+            merges += submerges
+            result.append(inner)
+
+    schema = Tuple(_values=result)
+    return set_default(schema, value), merges
+
+@dispatch
+def infer(core, value: NoneType, path: tuple = ()):
+    schema = Maybe(_value=Node())
+    return set_default(schema, value), []
+
+@dispatch
+def infer(core, value: set, path: tuple = ()):
+    return infer(
+        core,
+        list(value),
+        path)
+
+
+def separate_keys(d):
+    schema = {}
+    state = {}
+    for key, value in d.items():
+        if key.startswith('_'):
+            schema[key] = value
+        else:
+            state[key] = value
+
+    return schema, state
+
+@dispatch
+def infer(core, value: dict, path: tuple = ()):
+    if '_type' in value:
+        schema_keys, state = separate_keys(value)
+        schema = core.access_type(schema_keys)
+        merges = []
+
+        return set_default(schema, state), merges
+
+    elif '_default' in value:
+        return infer(core, value['_default'])
+
+    else:
+        subvalues = {}
+        distinct_subvalues = []
+        merges = []
+        for key, subvalue in value.items():
+            subvalues[key], submerges = infer(
+                core,
+                subvalue,
+                path+(key,))
+            merges += submerges
+
+            if len(distinct_subvalues) < 2 and subvalues[key] not in distinct_subvalues:
+                distinct_subvalues.append(
+                    subvalues[key])
+
+        if len(distinct_subvalues) == 1 and len(subvalues) > 1:
+            map_value = distinct_subvalues[0]
+            schema = Map(_value=map_value)
+            return set_default(schema, value), merges
+        else:
+            # return Place(_default=value, _subnodes=subvalues)
+            return subvalues, merges
+
+@dispatch
+def infer(core, value: object, path: tuple = ()):
+    type_name = str(type(value))
+
+    value_keys = value.__dict__.keys()
+    value_schema = {}
+
+    merges = []
+
+    for key in value_keys:
+        if not key.startswith('_'):
+            try:
+                value_schema[key], submerges = infer(
+                    core,
+                    getattr(value, key),
+                    path + (key,))
+                merges += submerges
+
+            except Exception as e:
+                traceback.print_exc()
+                print(e)
+
+                if type_name not in MISSING_TYPES:
+                    MISSING_TYPES[type_name] = set([])
+
+                MISSING_TYPES[type_name].add(
+                    path)
+
+                value_schema[key] = Node()
+
+    return value_schema, merges
+

bigraph_schema/methods/jump.py

@@ -0,0 +1,432 @@
+from plum import dispatch
+import numpy as np
+
+from dataclasses import replace, dataclass
+
+from bigraph_schema.schema import (
+    Node,
+    Atom,
+    Empty,
+    Union,
+    Tuple,
+    Boolean,
+    Number,
+    Integer,
+    Float,
+    Delta,
+    Nonnegative,
+    String,
+    Enum,
+    Wrap,
+    Maybe,
+    Overwrite,
+    List,
+    Map,
+    Tree,
+    Array,
+    Key,
+    Path,
+    Wires,
+    Schema,
+    Link,
+    Star,
+    Index,
+    Jump,
+    convert_path,
+    walk_path,
+)
+
+from bigraph_schema.methods import default, check, serialize, resolve
+
+
+@dispatch
+def jump(schema: Empty, state, to, context):
+    return schema, None
+
+
+@dispatch
+def jump(schema: Maybe, state, to, context):
+    if state is None:
+        return Empty(), state
+    else:
+        return jump(schema._value, state, to, context)
+
+
+@dispatch
+def jump(schema: Wrap, state, to, context):
+    return jump(schema._value, state, to, context)
+
+
+@dispatch
+def jump(schema: Union, state, to, context):
+    for option in schema._options:
+        if check(option, state):
+            return jump(option, state, to, context)
+    return Empty(), None
+
+
+@dispatch
+def jump(schema: Tuple, state, to: Key, context):
+    index = Index(int(to._value))
+    return jump(schema, state, index, context)
+
+
+@dispatch
+def jump(schema: Tuple, state, to: Index, context):
+    return traverse(
+        schema._values[to._value],
+        state[to._value],
+        context['subpath'],
+        context)
+
+
+@dispatch
+def jump(schema: Tuple, state, to: Star, context):
+    value_schemas = []
+    values = []
+
+    for index, value in enumerate(schema._values):
+        subvalue_schema, subvalue = traverse(
+            value,
+            state[index],
+            context['subpath'],
+            context)
+
+        value_schemas.append(subvalue_schema)
+        values.append(subvalue)
+
+    subschema = Tuple(_values=value_schemas)
+    substate = tuple(values)
+
+    return subschema, substate
+
+
+@dispatch
+def jump(schema: Tuple, state, to: Jump, context):
+    # TODO: find general way to format exceptions (!)
+    raise Exception(f'cannot lookup index "{to._value}" in tuple {state}\ncontext:\n{context}')
+
+
+@dispatch
+def jump(schema: List, state, to: Key, context):
+    index = Index(int(to._value))
+    return jump(schema, state, index, context)
+
+
+@dispatch
+def jump(schema: List, state, to: Index, context):
+    return traverse(
+        schema._element,
+        state[to._value],
+        context['subpath'],
+        context)
+
+
+@dispatch
+def jump(schema: List, state, to: Star, context):
+    subelement = Node()
+    elements = []
+
+    for index, value in state:
+        subvalue_schema, subvalue = traverse(
+            schema._element,
+            state[index],
+            context['subpath'],
+            context)
+
+        subelement = resolve(subelement, subvalue_schema)
+        elements.append(subvalue)
+
+    subschema = List(_element=subelement)
+    return subschema, elements
+
+
+@dispatch
+def jump(schema: List, state, to: Jump, context):
+    raise Exception(f'cannot lookup index "{to._value}" in list {state}\ncontext:\n{context}')
+
+
+@dispatch
+def jump(schema: Map, state, to: Index, context):
+    key = Key(str(to._value))
+    return jump(schema, state, key, context)
+
+
+@dispatch
+def jump(schema: Map, state, to: Key, context):
+    state = state or {}
+
+    return traverse(
+        schema._value,
+        state.get(to._value),
+        context['subpath'],
+        context)
+
+
+@dispatch
+def jump(schema: Map, state, to: Star, context):
+    value_schema = Node()
+    values = {}
+
+    for key, value in state.items():
+        index = serialize(schema._key, key)
+        subvalue_schema, subvalue = traverse(
+            schema._value,
+            state[index],
+            context['subpath'],
+            context)
+
+        value_schema = resolve(value_schema, subvalue_schema)
+        values[index] = subvalue
+
+    subschema = Map(_key=schema._key, _value=value_schema)
+    return subschema, values
+
+
+@dispatch
+def jump(schema: Map, state, to: Jump, context):
+    key = serialize(schema._key, to._value)
+    return jump(schema, state, Key(_value=key), context)
+
+
+@dispatch
+def jump(schema: Tree, state, to: Key, context):
+    down = state[to._value]
+
+    subschema = schema
+    if check(schema._leaf, down):
+        subschema = schema._leaf
+
+    return traverse(
+        subschema,
+        down,
+        context['subpath'],
+        context)
+
+
+@dispatch
+def jump(schema: Tree, state, to: Star, context):
+    leaf_schema = Node()
+    branches = {}
+
+    for key, branch in state.items():
+        subschema = schema
+        if check(schema._leaf, branch):
+            subschema = schema._leaf
+
+        branch_schema, branch_value = traverse(
+            subschema,
+            branch,
+            context['subpath'],
+            context)
+
+        leaf_schema = resolve(leaf_schema, branch_schema)
+        branches[key] = branch_value
+
+    subschema = Tree(_leaf=leaf_schema)
+    return subschema, branches
+
+
+@dispatch
+def jump(schema: Tree, state, to: Jump, context):
+    raise Exception(f'cannot lookup key "{to._value}" in tree {state}\ncontext:\n{context}')
+
+
+@dispatch
+def jump(schema: Atom, state, to, context):
+    if to._value:
+        raise Exception(f'cannot jump in atom - key is "{to._value}" but state is an atom:\n{state}')
+    else:
+        return schema, state
+
+
+def jump_link(schema: Link, state, to: Key, context):
+    key = to._value
+    if key in ['inputs', 'outputs']:
+        if not key in state:
+            raise Exception(f'no "{key}" key in state to jump to:\n{state}')
+
+        puts_schema = getattr(schema, f'_{key}')
+        wires_schema = getattr(schema, key)
+        subcontext = dict(context, **{
+            'ports_key': key,
+            'link_path': context['path'][:-1],
+            f'_{key}': puts_schema})
+
+        return traverse(
+            wires_schema,
+            state[key],
+            context['subpath'],
+            subcontext)
+
+    elif hasattr(schema, key):
+        subschema = getattr(schema, key)
+        return traverse(
+            subschema,
+            state.get(key),
+            context['subpath'],
+            context)
+
+    else:
+        return jump(Node(), state, to, context)
+
+
+@dispatch
+def jump(schema: Link, state, to: Key, context):
+    return jump_link(schema, state, to, context)
+
+@dispatch
+def jump(schema: Wires, state, to: Key, context):
+    key = to._value
+
+    if not key in state:
+        raise Exception(f'no entry "{key}" for wires:\n{state}')
+
+    substate = state[key]
+    if isinstance(substate, list):
+        outer_path = context['link_path'][:-1]
+        subpath = tuple(convert_path(substate)) + tuple(context['subpath'])
+        target_path = outer_path + subpath
+        subcontext = dict(context, **{
+            'path': outer_path,
+            'subpath': subpath})
+
+        return traverse(
+            context['schema'],
+            context['state'],
+            target_path,
+            subcontext)
+        
+    else:
+        return traverse(
+            schema,
+            substate,
+            context['subpath'],
+            context)
+
+@dispatch
+def jump(schema: Node, state, to: Star, context):
+    value_schema = {}
+    values = {}
+
+    for key, value in schema.__dataclass_fields__:
+        if key in state:
+            subschema, subvalue = traverse(
+                getattr(schema, key),
+                state[key],
+                context['subpath'],
+                context)
+
+            value_schema[key] = subschema
+            values[key] = subvalue
+        else:
+            raise Exception(f'traverse: no key "{key}" in state {state} at path {context["path"]}')
+
+    return value_schema, values
+
+
+@dispatch
+def jump(schema: Array, state, to: Jump, context):
+    index = to._value
+    if isinstance(index, int) and index < schema._shape[0]:
+        subschema = replace(schema, **{'_shape': schema._shape[1:]})
+        return traverse(
+            subschema,
+            state[index],
+            context['subpath'],
+            context)
+    else:
+        raise Exception(f'traverse: no index {index} in array state {state} at path {context["path"]}')
+
+
+@dispatch
+def jump(schema: Array, state, to: Star, context):
+    results = []
+    subschema = replace(schema, **{'_shape': schema._shape[1:]})
+    for index, row in enumerate(state):
+        result_schema, result_state = traverse(
+            subschema,
+            row,
+            context['subpath'],
+            context)
+        results.append(result_state)
+        
+    if isinstance(subschema, Array):
+        result_shape = (schema._shape[0],) + tuple(result_schema._shape)
+        subschema = replace(schema, **{'_shape': result_shape})
+        return subschema, np.array(results)
+    else:
+        # TODO: handle array data of different types
+        import ipdb; ipdb.set_trace()
+
+
+@dispatch
+def jump(schema: Node, state, to: Jump, context):
+    key = to._value
+    if key in state:
+        return traverse(
+            getattr(schema, key),
+            state[key],
+            context['subpath'],
+            context)
+    else:
+        raise Exception(f'traverse: no key "{key}" in state {state} at path {context["path"]}')
+
+
+@dispatch
+def jump(schema: Node, state, to, context):
+    raise Exception(f'cannot lookup key "{to._value}" in state {state}\ncontext:\n{context}')
+
+
+@dispatch
+def jump(schema: dict, state, to: Key, context):
+    state = state or {}
+    key = to._value
+
+    if key in schema:
+        return traverse(
+            schema[key],
+            state.get(key),
+            context['subpath'],
+            context)
+
+    elif key in state:
+        return None, state[key]
+
+    else:
+        return Empty(), None
+
+
+@dispatch
+def jump(schema: dict, state, to: Star, context):
+    value_schema = {}
+    values = {}
+
+    for key in schema:
+        if key in state:
+            subschema, subvalue = traverse(
+                schema[key],
+                state[key],
+                context['subpath'],
+                context)
+
+            value_schema[key] = subschema
+            values[key] = subvalue
+
+    return value_schema, values
+
+
+@dispatch
+def jump(schema: dict, state, to: Jump, context):
+    raise Exception(f'cannot lookup key "{to._value}" in state {state}\ncontext:\n{context}')
+
+
+def traverse(schema, state, path, context):
+    if path:
+        to = path[0]
+        subpath = path[1:]
+        subcontext = walk_path(context, to, subpath)
+
+        return jump(schema, state, to, subcontext)
+    else:
+        return schema, state