bigraph-schema 1.0.0__py3-none-any.whl

bigraph_schema/edge.py

@@ -0,0 +1,138 @@
+"""
+====
+Edge
+====
+
+Base class for all edges in the bigraph schema.
+"""
+
+def default_wires(schema):
+    """
+    Create default wiring for a schema by connecting each port to a store of the same name.
+    """
+    return {
+        key: [key]
+        for key in schema}
+
+
+class Edge:
+    """
+    Base class for all computational edges in the bigraph schema.
+
+    Edges define the interface between simulation processes and the global state,
+    specifying the structure of input and output ports using bigraph types
+    (e.g., 'float', 'map[float]', 'list[integer]', etc.).
+
+    Upon instantiation, each edge registers its port types with the core.
+    """
+
+    config_schema = {}
+
+    def __init__(self, config=None, core=None):
+        """
+        Initialize the edge with a config and simulation core.
+
+        Args:
+            config (dict): Optional configuration dictionary. Defaults to empty dict.
+            core: The core simulation engine that manages this edge and its types.
+
+        Raises:
+            Exception: If `core` is not provided.
+        """
+        if core is None:
+            raise Exception('must provide a core')
+        self.core = core
+
+        if config is None:
+            config = {}
+
+        self._config = self.core.fill(self.config_schema, config)
+        self._composition = 'edge'
+        self._state = {}
+
+        self.initialize(
+            self._config)
+
+
+    @property
+    def config(self):
+        return self._config
+
+    @config.setter
+    def config(self, config):
+        self._config = config
+
+    @property
+    def composition(self):
+        return self._composition
+
+    @composition.setter
+    def composition(self, composition):
+        self._composition = composition
+
+    @property
+    def state(self):
+        return self._state
+
+    @state.setter
+    def state(self, state):
+        self._state = state
+
+    def initialize(self, config):
+        """Optional hook for subclass-specific initialization."""
+        pass
+
+    def initial_state(self):
+        """Return initial state values, if applicable."""
+        return {}
+
+    @staticmethod
+    def generate_state(config=None):
+        """Generate static initial state for user configuration or inspection."""
+        return {}
+
+    def inputs(self):
+        """
+        Return a dictionary mapping input port names to bigraph types.
+
+        Example:
+            {'glucose': 'float', 'biomass': 'map[float]'}
+        """
+        return {}
+
+    def outputs(self):
+        """
+        Return a dictionary mapping output port names to bigraph types.
+
+        Example:
+            {'growth_rate': 'float'}
+        """
+        return {}
+
+    def default_config(self):
+        """ get the default of the config_schema for this edge """
+        return self.core.default(
+            self.config_schema)
+
+    def default_inputs(self):
+        """Generate default wire paths for inputs: {port: [port]}"""
+        return default_wires(self.inputs())
+
+    def default_outputs(self):
+        """Generate default wire paths for outputs: {port: [port]}"""
+        return default_wires(self.outputs())
+
+    def interface(self):
+        """
+        Return combined interface schema as a dict:
+            {
+                'inputs': {port: type, ...},
+                'outputs': {port: type, ...}
+            }
+        """
+        return {
+            'inputs': self.inputs(),
+            'outputs': self.outputs()
+        }
+
+

bigraph_schema/methods/__init__.py

@@ -0,0 +1,12 @@
+from bigraph_schema.methods.infer import infer, set_default
+from bigraph_schema.methods.default import default, default_link
+from bigraph_schema.methods.resolve import resolve
+from bigraph_schema.methods.generalize import generalize
+from bigraph_schema.methods.check import check
+from bigraph_schema.methods.validate import validate
+from bigraph_schema.methods.serialize import serialize, render, wrap_default
+from bigraph_schema.methods.realize import realize, realize_link, load_protocol, load_local_protocol
+from bigraph_schema.methods.merge import merge, merge_update
+from bigraph_schema.methods.jump import jump, traverse
+from bigraph_schema.methods.handle_parameters import schema_keys, align_parameters, reify_schema, handle_parameters
+from bigraph_schema.methods.apply import apply

bigraph_schema/methods/apply.py

@@ -0,0 +1,276 @@
+from plum import dispatch
+import numpy as np
+
+from bigraph_schema.schema import (
+    Node,
+    Atom,
+    Union,
+    Tuple,
+    Boolean,
+    Or,
+    And,
+    Xor,
+    Number,
+    Integer,
+    Float,
+    Delta,
+    Nonnegative,
+    String,
+    Enum,
+    Wrap,
+    Maybe,
+    Overwrite,
+    List,
+    Map,
+    Tree,
+    Array,
+    Key,
+    Path,
+    Wires,
+    Schema,
+    Link,
+)
+
+
+@dispatch
+def apply(schema: Maybe, state, update, path):
+    if state is None:
+        if update is not None:
+            return update, []
+    elif update is None:
+        return state, []
+    else:
+        return apply(schema._value, state, update, path)
+
+
+@dispatch
+def apply(schema: Wrap, state, update, path):
+    return apply(schema._value, state, update, path)
+
+
+@dispatch
+def apply(schema: Overwrite, state, update, path):
+    return update, []
+
+
+@dispatch
+def apply(schema: Union, state, update, path):
+    found = None
+    for option in schema._options:
+        if check(option, state) and check(option, update):
+            found = option
+            break
+
+    if found is not None:
+        return apply(found, state, update, path)
+    else:
+        return update, []
+
+
+@dispatch
+def apply(schema: Tuple, state, update, path):
+    merges = []
+    result = []
+    for index, value in enumerate(schema._values):
+        if index < len(state):
+            if update and index < len(update):
+                substate, submerges = apply(
+                    value,
+                    state[index],
+                    update[index],
+                    path+(index,))
+                result.append(substate)
+                merges += submerges
+            else:
+                result.append(state[index])
+        elif index < len(update):
+            result.append(update[index])
+        else:
+            result.append(default(value))
+
+    return tuple(result), merges
+
+
+@dispatch
+def apply(schema: List, state, update, path):
+    merges = []
+    if isinstance(update, dict):
+        if '_remove' in update:
+            indexes = update['_remove']
+            if indexes == 'all':
+                result = []
+            else:
+                result = [
+                    item
+                    for index, item in enumerate(state)
+                    if index not in indexes]
+        if '_add' in update:
+            result += update['_add']
+    else:
+        result = state + update
+
+    return result, merges
+
+
+@dispatch
+def apply(schema: Map, state, update, path):
+    result = state.copy()
+    merges = []
+
+    if update is None:
+        return state, merges
+
+    if '_add' in update:
+        add_update = update['_add']
+        if isinstance(add_update, list):
+            for add_key, add_value in update['_add']:
+                result[add_key] = add_value
+        elif isinstance(add_update, dict):
+            for add_key, add_value in update['_add'].items():
+                result[add_key] = add_value
+
+    for key, value in result.items():
+        if key in update:
+            result[key], submerges = apply(
+                schema._value,
+                value,
+                update[key],
+                path+(key,))
+            merges += submerges
+
+    if '_remove' in update:
+        for remove_key in update['_remove']:
+            if remove_key in result:
+                del result[remove_key]
+
+    return result, merges
+
+
+@dispatch
+def apply(schema: Tree, state, update, path):
+    if check(schema._leaf, state):
+        return apply(schema._leaf, state, update, path)
+
+    result = state.copy()
+    if '_remove' in update:
+        for remove_key in update['_remove']:
+            del result[remove_key]
+
+    if '_add' in update:
+        for add_key, add_value in update['_add']:
+            result[add_key] = add_value
+
+    for key, value in result:
+        if key in update:
+            result[key], submerges = apply(
+                schema,
+                value,
+                update[key],
+                path+(key,))
+            merges += submerges
+
+    return result, merges
+
+
+@dispatch
+def apply(schema: Atom, state, update, path):
+    if update is None:
+        return state, []
+    if state is None:
+        return update, []
+
+    return (state + update), []
+
+
+@dispatch
+def apply(schema: String, state, update, path):
+    return update, []
+
+@dispatch
+def apply(schema: Boolean, state, update, path):
+    return update, []
+
+
+@dispatch
+def apply(schema: Or, state, update, path):
+    return state or update, []
+
+
+@dispatch
+def apply(schema: And, state, update, path):
+    return state and update, []
+
+
+@dispatch
+def apply(schema: Xor, state, update, path):
+    return (state or update) and not (state and update), []
+
+
+@dispatch
+def apply(schema: Array, state, update, path):
+    index = tuple([
+        slice(0, dimension)
+        for dimension in update.shape])
+    state[index] += update
+    return state, []
+
+@dispatch
+def apply(schema: dict, state: np.ndarray, update, path):
+    merges = []
+    for key, subschema in schema.items():
+        if key in update:
+            substate = update[key]
+            state[key], submerges = apply(subschema, state[key], substate, path+(key,))
+            merges += submerges
+    return state, merges
+                
+
+@dispatch
+def apply(schema: dict, state, update, path):
+    if update is None:
+        return state, []
+    if state is None:
+        return update, []
+
+    merges = []
+    result = {}
+
+    for key, subschema in schema.items():
+        if key in ('_inherit',):
+            continue
+
+        if key not in state:
+            continue
+
+        result[key], submerges = apply(
+            subschema,
+            state.get(key),
+            update.get(key),
+            path+(key,))
+        merges += submerges
+
+    for key in state.keys():
+        if not key in result and not key in schema:
+            result[key] = state[key]
+
+    return result, merges
+
+
+@dispatch
+def apply(schema: Node, state, update, path):
+    merges = []
+    if isinstance(state, dict) and isinstance(update, dict):
+        result = {}
+        for key in schema.__dataclass_fields__:
+            subschema = getattr(schema, key)
+            result[key], submerges = apply(
+                subschema,
+                state.get(key),
+                update.get(key),
+                path+(key,))
+            merges += submerges
+
+    else:
+        result = update
+
+    return result, merges

bigraph_schema/methods/check.py

@@ -0,0 +1,213 @@
+from plum import dispatch
+import numpy as np
+
+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,
+)
+
+
+@dispatch
+def check(schema: Empty, state):
+    return state is None
+
+
+@dispatch
+def check(schema: Maybe, state):
+    if state is None:
+        return True
+    else:
+        return check(schema._value, state)
+
+
+@dispatch
+def check(schema: Wrap, state):
+    return check(schema._value, state)
+
+
+@dispatch
+def check(schema: Union, state):
+    for option in schema._options:
+        if check(option, state):
+            return True
+
+    return False
+
+
+@dispatch
+def check(schema: Tuple, state):
+    if not isinstance(state, (list, tuple)):
+        return False
+
+    elif len(schema._values) == len(state):
+        return all([
+            check(subschema, value)
+            for subschema, value in zip(schema._values, state)])
+
+    else:
+        return False
+
+
+@dispatch
+def check(schema: Boolean, state):
+    return isinstance(state, bool)
+
+
+@dispatch
+def check(schema: Integer, state):
+    return isinstance(state, int)
+
+
+@dispatch
+def check(schema: Float, state):
+    return isinstance(state, float)
+
+
+@dispatch
+def check(schema: Nonnegative, state):
+    return state >= 0
+
+
+@dispatch
+def check(schema: String, state):
+    return isinstance(state, str)
+
+
+@dispatch
+def check(schema: Enum, state):
+    if not isinstance(state, str):
+        return False
+
+    return state in schema._values
+
+
+@dispatch
+def check(schema: List, state):
+    if not isinstance(state, (list, tuple)):
+        return False
+
+    return all([
+        check(schema._element, element)
+        for element in state])
+
+
+@dispatch
+def check(schema: Map, state):
+    if not isinstance(state, dict):
+        return False
+
+    all_values = all([
+        check(schema._value, value)
+        for value in state.values()])
+
+    if isinstance(schema._key, String):
+        return all_values
+
+    else:
+        # if the keys are not strings, we must realize
+        # them all to tell if they pass the check?
+        # - this seems expensive?
+        all_keys = all([
+            # TODO: if realize needs core this will fail
+            #   does that matter?
+            check(schema._key, realize(None, schema._key, key))
+            for key in state.keys()])
+
+        return all_keys and all_values
+
+
+@dispatch
+def check(schema: Tree, state):
+    if check(schema._leaf, state):
+        return True
+
+    elif isinstance(state, dict):
+        return all([
+            isinstance(key, str) and check(schema, branch)
+            for key, branch in state.items()])
+    else:
+        return False
+
+
+
+
+@dispatch
+def check(schema: Array, state):
+    if not isinstance(state, np.ndarray):
+        return False
+
+    shape_match = tuple(schema._shape) == state.shape
+    data_match = schema._data == state.dtype
+
+    return shape_match and data_match
+
+
+@dispatch
+def check(schema: Key, state):
+    return isinstance(state, int) or isinstance(state, str)
+
+
+@dispatch
+def check(schema: Node, state):
+    fields = [
+        field
+        for field in schema.__dataclass_fields__
+        if not field.startswith('_')]
+
+    if fields:
+        if isinstance(state, dict):
+            for key in schema.__dataclass_fields__:
+                if not key.startswith('_'):
+                    if key not in state:
+                        return False
+                    else:
+                        down = check(
+                            getattr(schema, key),
+                            state[key])
+                        if down is False:
+                            return False
+            return True
+        else:
+            return False
+    else:
+        return True
+
+
+@dispatch
+def check(schema: dict, state):
+    for key, subschema in schema.items():
+        if key not in state:
+            continue
+            # return False
+        elif not check(subschema, state[key]):
+            return False
+
+    return True
+
+
+@dispatch
+def check(schema, state):
+    raise Exception(f'not a valid schema: {schema}')