bigraph-schema 1.0.0__py3-none-any.whl

bigraph_schema/methods/validate.py

@@ -0,0 +1,249 @@
+from pprint import pformat as pf
+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,
+)
+
+from bigraph_schema.methods.check import check
+from bigraph_schema.methods.serialize import render
+
+
+@dispatch
+def validate(core, schema: Empty, state):
+    if state is not None:
+        return f'Empty schema is not empty:\n\n{pf(state)}\n\n'
+
+
+@dispatch
+def validate(core, schema: Maybe, state):
+    if state is not None:
+        return validate(core, schema._value, state)
+
+
+@dispatch
+def validate(core, schema: Wrap, state):
+    return validate(core, schema._value, state)
+
+
+@dispatch
+def validate(core, schema: Union, state):
+    for option in schema._options:
+        result = validate(core, option, state)
+        if not result:
+            return result
+
+    return f'Union values did not match state:\n\n{pf(render(schema))}\n\n{pf(state)}\n\n'
+
+
+def filter_nones(results):
+    return [
+        result
+        for result in results
+        if result is not None]
+
+@dispatch
+def validate(core, schema: Tuple, state):
+    if not isinstance(state, (list, tuple)):
+        return f'Tuple schema requires tuple values:\n\n{pf(render(schema))}\n\nnot:\n\n{pf(state)}\n\n'
+
+    elif len(schema._values) == len(state):
+        results = filter_nones([
+            validate(core, subschema, value)
+            for subschema, value in zip(schema._values, state)])
+
+        if results:
+            return results
+
+    else:
+        return f'Tuple schema and state are different lengths:\n\n{pf(render(schema))}\n\n{pf(state)}\n\n'
+
+
+@dispatch
+def validate(core, schema: Boolean, state):
+    if not isinstance(state, bool):
+        return f'Boolean schema but state is not boolean:\n\nschema: {pf(render(schema))}\n\nstate: {pf(state)}\n\n'
+
+
+@dispatch
+def validate(core, schema: Integer, state):
+    if not isinstance(state, int):
+        return f'Integer schema but state is not an integer:\n\nschema: {pf(render(schema))}\n\nstate: {pf(state)}\n\n'
+
+
+@dispatch
+def validate(core, schema: Float, state):
+    if not isinstance(state, float):
+        return f'Float schema but state is not a float:\n\nschema: {pf(render(schema))}\n\nstate: {pf(state)}\n\n'
+
+
+@dispatch
+def validate(core, schema: Nonnegative, state):
+    if state < 0:
+        return f'Nonnegative schema but state is negative:\n\nschema: {pf(render(schema))}\n\nstate: {pf(state)}\n\n'
+
+
+@dispatch
+def validate(core, schema: String, state):
+    if not isinstance(state, str):
+        return f'Float schema but state is not a float:\n\nschema: {pf(render(schema))}\n\nstate: {pf(state)}\n\n'
+
+
+@dispatch
+def validate(core, schema: Enum, state):
+    if not isinstance(state, str):
+        return f'Enum schema but state is not a string:\n\nschema: {pf(render(schema))}\n\nstate: {pf(state)}\n\n'
+
+    if not state in schema._values:
+        return f'Enum schema but state is not in the enumeration:\n\nschema: {pf(render(schema))}\n\nstate: {pf(state)}\n\n'
+
+
+@dispatch
+def validate(core, schema: List, state):
+    if not isinstance(state, (list, tuple)):
+        return f'List schema but state is not a list:\n\nschema: {pf(render(schema))}\n\nstate: {pf(state)}\n\n'
+
+    results = filter_nones([
+        validate(core, schema._element, element)
+        for element in state])
+
+    if results:
+        return results
+
+@dispatch
+def validate(core, schema: Map, state):
+    if not isinstance(state, dict):
+        return f'Map schema but state is not a map:\n\nschema: {pf(render(schema))}\n\nstate: {pf(state)}\n\n'
+
+    results = filter_nones([
+        validate(core, schema._value, value)
+        for value in state.values()])
+
+    if results:
+        return results
+
+    elif not isinstance(schema._key, String):
+        results = filter_nones([
+            validate(
+                core,
+                schema._key,
+                realize(
+                    core,
+                    schema._key,
+                    key))
+            for key in state.keys()])
+
+        if results:
+            return results
+
+
+@dispatch
+def validate(core, schema: Tree, state):
+    leaf_validate = validate(core, schema._leaf, state)
+
+    if leaf_validate:
+        if isinstance(state, dict):
+            results = filter_nones([
+                validate(core, schema, branch)
+                for key, branch in state.items()])
+            if results:
+                return f'Tree schema but state matches neither leaf nor tree:\n\nschema: {pf(render(schema))}\n\nstate: {pf(state)}\n\n'
+
+        else:
+            return f'Tree schema but state matches neither leaf nor tree:\n\nschema: {pf(render(schema))}\n\nstate: {pf(state)}\n\n'
+
+
+@dispatch
+def validate(core, schema: Array, state):
+    if not isinstance(state, np.ndarray):
+        return f'Array schema but state is not an array:\n\nschema: {pf(render(schema))}\n\nstate: {pf(state)}\n\n'
+
+    shape_match = tuple(schema._shape) == state.shape
+    data_match = schema._data == state.dtype
+
+    if not shape_match:
+        return f'Array schema but shape does not match:\n\nschema: {pf(render(schema))}\n\nstate: {pf(state)}\n\n'
+    if not data_match:
+        return f'Array schema but data does not match:\n\nschema: {pf(render(schema))}\n\nstate: {pf(state)}\n\n'
+
+
+@dispatch
+def validate(core, schema: Key, state):
+    if not isinstance(state, int) or isinstance(state, str):
+        return f'Key schema but state is not a key:\n\nschema: {pf(render(schema))}\n\nstate: {pf(state)}\n\n'
+
+
+@dispatch
+def validate(core, schema: Node, state):
+    fields = [
+        field
+        for field in schema.__dataclass_fields__
+        if not field.startswith('_')]
+
+    if fields:
+        if isinstance(state, dict):
+            result = {}
+            for key in schema.__dataclass_fields__:
+                if not key.startswith('_'):
+                    if key not in state:
+                        return f'Node schema but key "{key}" is not in state:\n\nschema: {pf(render(schema))}\n\nstate: {pf(state)}\n\n'
+                    else:
+                        down = validate(
+                            core, 
+                            getattr(schema, key),
+                            state[key])
+
+                        if down:
+                            result[key] = down
+            if result:
+                return result
+        else:
+            subcheck = check(schema, state)
+            if not subcheck:
+                return f'Node schema but state does not match:\n\nschema: {pf(render(schema))}\n\nstate: {pf(state)}\n\n'
+
+
+@dispatch
+def validate(core, schema: dict, state):
+    result = {}
+    for key, subschema in schema.items():
+        if key not in state:
+            continue
+            # result[key] = f'Schema has key "{key}" but state does not:\n\nschema: {pf(render(schema))}\n\nstate: {pf(state)}\n\n'
+        else:
+            subresult = validate(core, subschema, state[key])
+            if subresult:
+                result[key] = subresult
+
+    if result:
+        return result
+
+
+@dispatch
+def validate(core, schema, state):
+    return f'Schema and state are not known:\n\nschema: {pf(render(schema))}\n\nstate: {pf(state)}\n\n'

bigraph_schema/package/__init__.py

@@ -0,0 +1 @@
+from bigraph_schema.package.discover import discover_packages

bigraph_schema/package/discover.py

@@ -0,0 +1,122 @@
+import importlib
+import importlib.metadata
+import pkgutil
+import inspect
+from typing import Dict, List, Tuple, Set, Type
+
+from bigraph_schema import Edge
+
+
+def find_edges(mapping, module_name=None):
+    discovered = []
+    for _, cls in mapping:
+        # Only classes defined in this module (not imported into it)
+        if not inspect.isclass(cls):
+            continue
+
+        if module_name and cls.__module__ != module_name:
+            continue
+
+        if not issubclass(cls, Edge) or cls is Edge:
+            continue
+
+        # Use the true module path for a stable registration key
+        fq_name = f"{cls.__module__}.{cls.__name__}"
+        discovered.append((fq_name, cls))
+
+    return discovered
+
+
+def recursive_dynamic_import(
+    core,
+    module,
+    visited: Set[str] | None = None,
+) -> tuple[object, List[tuple[str, Type[Edge]]]]:
+    if visited is None:
+        visited = set()
+
+    if inspect.ismodule(module):
+        adjusted = module.__name__
+        if adjusted in visited:
+            return core, [], visited
+
+        visited.add(adjusted)
+
+    if isinstance(module, str):
+        adjusted = core.distributions_packages.get(module, module)
+        if adjusted in visited:
+            return core, [], visited
+        visited.add(adjusted)
+
+        try:
+            module = importlib.import_module(adjusted)
+
+        except ModuleNotFoundError as e:
+            # e.name is the missing module name
+            # If the missing name IS the module we tried to import, then it's truly not found.
+            # Otherwise, it's a dependency import failure inside that module.
+            print(f"module `{adjusted}` not found during dynamic import")
+
+    # Allow module to register types into core
+    if hasattr(module, "register_types"):
+        core = module.register_types(core)
+
+    mapping = inspect.getmembers(module, inspect.isclass)
+    discovered = find_edges(mapping)
+
+    # Recurse into submodules if this is a package
+    if hasattr(module, "__path__"):
+        for _, subname, _ in pkgutil.iter_modules(module.__path__):
+            submod = f"{adjusted}.{subname}"
+            core, sub_discovered, visited = recursive_dynamic_import(
+                core, submod, visited=visited)
+            discovered.extend(sub_discovered)
+
+    return core, discovered, visited
+
+
+def is_process_library(dist: importlib.metadata.Distribution) -> bool:
+    if dist.metadata["Name"] == "bigraph-schema":
+        return True
+    reqs = dist.requires or []
+    return any("bigraph-schema" in r for r in reqs)
+
+
+def load_local_modules(core, top=None) -> tuple[object, List[tuple[str, Type[Edge]]]]:
+    processes = []
+    visited = set([])
+
+    for dist_name in core.distributions_packages:
+        dist = importlib.metadata.distribution(dist_name)
+        if not is_process_library(dist):
+            continue
+
+        core, found, visited = recursive_dynamic_import(
+            core,
+            dist_name,
+            visited=visited)
+
+        processes.extend(found)
+
+    if top:
+        for key, value in top.items():
+            if inspect.isclass(value) and issubclass(value, Edge):
+                processes.append((key, value))
+
+            if key == 'register_types':
+                core = value(core)
+
+    return core, processes
+
+
+def discover_packages(core, top=None):
+    core, discovered = load_local_modules(core, top=top)
+
+    for fq_name, edge_cls in discovered:
+        core.register_link(fq_name, edge_cls)
+
+        short = fq_name.split(".")[-1]
+        if short not in core.link_registry:
+            core.register_link(short, edge_cls)
+
+    return core

bigraph_schema/parse.py

@@ -0,0 +1,183 @@
+"""
+======================
+Parse Bigraph Notation
+======================
+
+Parses and renders bigraph-style type expressions used in schema definitions,
+such as parameterized types, nested trees, merges (`|`), and unions (`~`).
+"""
+
+from parsimonious.grammar import Grammar
+from parsimonious.nodes import NodeVisitor
+
+# --- Example Expressions -----------------------------------------------------
+parameter_examples = {
+    'no-parameters': 'simple',
+    'one-parameter': 'parameterized[A]',
+    'three-parameters': 'parameterized[A,B,C]',
+    'nested-parameters': 'nested[outer[inner]]',
+    'multiple-nested-parameters': 'nested[outer[inner],other,later[on,there[is],more]]',
+    'bars': 'a|b|c|zzzz',
+    'union': 'a~b~c~zzzz',
+    'typed': 'a:field[yellow,tree,snake]|b:(x:earth|y:cloud|z:sky)',
+    'typed_parameters': 'edge[a:int|b:(x:length|y:float),v[zz:float|xx:what]]',
+    'inputs_and_outputs': 'edge[input1:float|input2:int,output1:float|output2:int]',
+    'tuple': 'what[is,happening|(with:yellow|this:green)|this:now]',
+    'single': 'hello[(3),over]',
+    'double': 'hello[(3|4),over{owiehf;a832hf9237fh!@#(&$A(HFO@I#}]',
+    'double_default': 'hello[(3|4),over]{3,3,3,3,3}',
+    'units_type': 'length^2*mass/time^1_5',
+    'nothing': '()'}
+
+# --- Grammar -----------------------------------------------------------------
+parameter_grammar = Grammar(
+    """
+    expression = merge / union / tree / nothing
+    merge = tree (bar tree)+
+    union = tree (tilde tree)+
+    tree = bigraph / type_name
+    bigraph = group / nest
+    group = paren_left expression paren_right
+    nest = symbol colon tree
+    type_name = symbol parameter_list? default_block?
+    parameter_list = square_left expression (comma expression)* square_right
+    default_block = curly_left default curly_right
+    default = ~r"[^}]*"
+    symbol = ~r"[\\w\\d-_/<>*&^%$#@!`+ ]+"
+    dot = "."
+    colon = ":"
+    bar = "|"
+    paren_left = "("
+    paren_right = ")"
+    square_left = "["
+    square_right = "]"
+    curly_left = "{"
+    curly_right = "}"
+    comma = ","
+    tilde = "~"
+    not_newline = ~r"[^\\n\\r]"*
+    newline = ~"[\\n\\r]+"
+    ws = ~r"\\s*"
+    nothing = ""
+    """)
+
+
+# --- Visitor -----------------------------------------------------------------
+class ParameterVisitor(NodeVisitor):
+    """Visitor that walks a parsed tree and builds structured type expressions."""
+
+    def visit_expression(self, node, visit):
+        return visit[0]
+
+    def visit_union(self, node, visit):
+        head = [visit[0]]
+        tail = [tree['visit'][1] for tree in visit[1]['visit']]
+        return {'_union': head + tail}
+
+    def visit_merge(self, node, visit):
+        head = [visit[0]]
+        tail = [tree['visit'][1] for tree in visit[1]['visit']]
+        nodes = head + tail
+
+        if all(isinstance(tree, dict) for tree in nodes):
+            merged = {}
+            for tree in nodes:
+                merged.update(tree)
+            return merged
+        else:
+            return tuple(nodes)
+
+    def visit_tree(self, node, visit):
+        return visit[0]
+
+    def visit_bigraph(self, node, visit):
+        return visit[0]
+
+    def visit_group(self, node, visit):
+        group_value = visit[1]
+        return group_value if isinstance(group_value, (list, tuple, dict)) else (group_value,)
+
+    def visit_nest(self, node, visit):
+        return {visit[0]: visit[2]}
+
+    def visit_type_name(self, node, visit):
+        type_name = visit[0]
+        type_parameters = visit[1]['visit']
+        if type_parameters:
+            return [type_name, type_parameters[0]]
+        return type_name
+
+    def visit_parameter_list(self, node, visit):
+        first = [visit[1]]
+        rest = [inner['visit'][1] for inner in visit[2]['visit']]
+        return first + rest
+
+    def visit_symbol(self, node, visit):
+        return node.text
+
+    def visit_nothing(self, node, visit):
+        return {}
+
+    def generic_visit(self, node, visit):
+        return {'node': node, 'visit': visit}
+
+# --- API ---------------------------------------------------------------------
+def parsed_leftmost_leaf(parsed):
+    if len(parsed.children) == 0:
+        return parsed
+    else:
+        return parsed_leftmost_leaf(parsed.children[0])
+
+def visit_expression(expression, visitor):
+    parsed = parameter_grammar.parse(expression)
+    leaf = parsed_leftmost_leaf(parsed)
+    if hasattr(leaf, 'match') and leaf.match[0] == expression:
+        return expression
+    else:
+        return visitor.visit(parsed)
+
+def parse_expression(expression):
+    """
+    Parse a bigraph-style type expression into a structured Python object.
+    """
+    visitor = ParameterVisitor()
+    return visit_expression(expression, visitor)
+
+def is_type_expression(expression):
+    """
+    Return True if the expression is a parameterized type list.
+    """
+    return isinstance(expression, list) and len(expression) == 2 and isinstance(expression[1], list)
+
+def render_expression(expression):
+    """
+    Render a structured type expression back into a bigraph-style string.
+    """
+    if isinstance(expression, str):
+        return expression
+    elif isinstance(expression, list):
+        type_name, parameters = expression
+        inner = ','.join(render_expression(p) for p in parameters)
+        return f'{type_name}[{inner}]'
+    elif isinstance(expression, tuple):
+        return '(' + '|'.join(render_expression(e) for e in expression) + ')'
+    elif isinstance(expression, dict):
+        if '_union' in expression:
+            return '~'.join(render_expression(p) for p in expression['_union'])
+        else:
+            parts = [f'{k}:{render_expression(v)}' for k, v in expression.items()]
+            return f'({ "|".join(parts) })'
+    return str(expression)  # fallback for unknown structures
+
+# --- Debugging/Testing ---------------------------------------------------------
+def test_parse_parameters():
+    """Test parsing and rendering for all example expressions."""
+    for label, expr in parameter_examples.items():
+        parsed = parse_expression(expr)
+        print(f'{label}: {expr}')
+        if parsed:
+            print(f'  Parsed: {parsed}')
+            print(f'  Rendered: {render_expression(parsed)}')
+
+if __name__ == '__main__':
+    test_parse_parameters()

bigraph_schema/protocols.py

@@ -0,0 +1,57 @@
+"""
+=========
+Protocols
+=========
+
+This module contains the protocols for retrieving processes from address.
+"""
+
+import sys
+import inspect
+import importlib
+
+
+def function_module(function):
+    """
+    Retrieves the fully qualified name of a given function.
+    """
+    module = inspect.getmodule(function)
+
+    return f'{module.__name__}.{function.__name__}'
+
+
+def local_lookup_module(address):
+    """Local Module Protocol
+
+    Retrieves local module
+    """
+    if '.' in address:
+        module_name, class_name = address.rsplit('.', 1)
+        module = importlib.import_module(module_name)
+        return getattr(module, class_name)
+    else:
+        module = sys.modules[__name__]
+        if hasattr(module, address):
+            return getattr(sys.modules[__name__], address)
+
+
+def local_lookup_registry(core, address):
+    """Process Registry Protocol
+
+    Retrieves from the process registry
+    """
+    return core.link_registry.get(address)
+
+
+def local_lookup(core, address):
+    """Local Lookup Protocol
+
+    Retrieves local processes, from the process registry or from a local module
+    """
+    if address[0] == '!':
+        instantiate = local_lookup_module(address[1:])
+    else:
+        instantiate = local_lookup_registry(core, address)
+    return instantiate
+
+