pyigr 2026.9.114__tar.gz

pyigr-2026.9.114/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.3
+Name: pyigr
+Version: 2026.9.114
+Summary: Add your description here
+Requires-Dist: networkx
+Requires-Dist: dask ; extra == 'exec-dask'
+Requires-Dist: dask[distributed] ; extra == 'exec-daskdist'
+Requires-Python: >=3.14
+Provides-Extra: exec-dask
+Provides-Extra: exec-daskdist
+Description-Content-Type: text/markdown
+
+Python in a Graph
+
+# Why?
+
+My (author) motivation is to be able to generally describe systems that respond to change.
+
+
+Related (but not the same):
+- reactive programming libraries:
+Doesn't focus on a 'state'
+- dynamical systems [pathsim](https://docs.pathsim.org/):
+This library doesn't, at the face of it, look like it can do what pathsim does, 
+but I think sim descriptions could be mapped somehow.
+
+DAG exec:
+- pipefunc
+state with no deps. useful as is but you can farm out tasks as you wish.
+
+
+# How?
+
+Rules/functions are repeatedly applied to a 'state' (dict)
+until there are no more changes.
+w
+## 1. Specify
+
+Rules initializer:
+```python
+def __init__(self, state: state = {}, *, log: bool = False): ...
+```
+Function registration:
+```python
+def register(self, argmap: argmap = {}): ...
+```
+
+```python
+import state_rules.main as rm
+
+r = rm.Rules({'x':1}, log=True)
+@r.register({
+    # input
+    'x': 'x' # created by default from func sig if not specified
+    # output
+    'return': 'x', # default is funcname.
+    # for multiple outputs,
+    # can be a dict that updates state: return: { }
+     })
+def f(x):
+    return x+x # {'x': x+x, 'x+x':x+x } # will be inserted to state
+```
+
+## 2. Run
+
+The run function signature:
+```python
+def run(self, maxiter=10, *, stopping: Callable[[state], bool] | None = None): ...
+```
+
+```python
+r.run(5)
+r.log
+```
+```python
+[
+Iteration(i=0, state={'x': 1})
+Iteration(i=1, state={'x': 2})
+Iteration(i=2, state={'x': 4})
+Iteration(i=3, state={'x': 8})
+Iteration(i=4, state={'x': 16})
+Iteration(i=5, state={'x': 32})
+]
+```
+
+# Tips
+
+- The state is a (flat) dictionary but you can use a fancy dotted dict if you want more structure.
+Then, use use a function to get at a key.
+- Cache function calls (yourself) as functions will get repeatedly called with the same input.
+- Use `stopping` critereon to early stop before `maxiter`.

pyigr-2026.9.114/README.md

@@ -0,0 +1,79 @@
+Python in a Graph
+
+# Why?
+
+My (author) motivation is to be able to generally describe systems that respond to change.
+
+
+Related (but not the same):
+- reactive programming libraries:
+Doesn't focus on a 'state'
+- dynamical systems [pathsim](https://docs.pathsim.org/):
+This library doesn't, at the face of it, look like it can do what pathsim does, 
+but I think sim descriptions could be mapped somehow.
+
+DAG exec:
+- pipefunc
+state with no deps. useful as is but you can farm out tasks as you wish.
+
+
+# How?
+
+Rules/functions are repeatedly applied to a 'state' (dict)
+until there are no more changes.
+w
+## 1. Specify
+
+Rules initializer:
+```python
+def __init__(self, state: state = {}, *, log: bool = False): ...
+```
+Function registration:
+```python
+def register(self, argmap: argmap = {}): ...
+```
+
+```python
+import state_rules.main as rm
+
+r = rm.Rules({'x':1}, log=True)
+@r.register({
+    # input
+    'x': 'x' # created by default from func sig if not specified
+    # output
+    'return': 'x', # default is funcname.
+    # for multiple outputs,
+    # can be a dict that updates state: return: { }
+     })
+def f(x):
+    return x+x # {'x': x+x, 'x+x':x+x } # will be inserted to state
+```
+
+## 2. Run
+
+The run function signature:
+```python
+def run(self, maxiter=10, *, stopping: Callable[[state], bool] | None = None): ...
+```
+
+```python
+r.run(5)
+r.log
+```
+```python
+[
+Iteration(i=0, state={'x': 1})
+Iteration(i=1, state={'x': 2})
+Iteration(i=2, state={'x': 4})
+Iteration(i=3, state={'x': 8})
+Iteration(i=4, state={'x': 16})
+Iteration(i=5, state={'x': 32})
+]
+```
+
+# Tips
+
+- The state is a (flat) dictionary but you can use a fancy dotted dict if you want more structure.
+Then, use use a function to get at a key.
+- Cache function calls (yourself) as functions will get repeatedly called with the same input.
+- Use `stopping` critereon to early stop before `maxiter`.

pyigr-2026.9.114/pyproject.toml

@@ -0,0 +1,25 @@
+[project]
+name = "pyigr"
+version = "2026.9.114"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.14"
+dependencies = ["networkx"]
+
+[project.optional-dependencies]
+exec-dask = ["dask"]
+exec-daskdist = ["dask[distributed]"]
+
+[dependency-groups]
+dev = [
+    "fire",
+    "marimo",
+    "pyzmq",
+    "ipdb",
+    "python-box",
+    "wrapt",
+]
+
+[build-system]
+requires = ["uv_build"]
+build-backend = "uv_build"

pyigr-2026.9.114/pyproject.toml.orig

@@ -0,0 +1,25 @@
+[project]
+name = "pyigr"
+version = "2026.9.114"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.14"
+dependencies = [    
+    'networkx'  # v3 has no deps
+]
+[project.optional-dependencies]
+exec-dask = ['dask']
+exec-daskdist = ['dask[distributed]']
+
+[dependency-groups]
+dev = [
+    'fire',
+    "marimo", "pyzmq",'ipdb',
+    # examples
+    'python-box', 'wrapt', 
+]
+
+
+[build-system]
+requires = ["uv_build"]
+build-backend = "uv_build"

pyigr-2026.9.114/src/pyigr/__init__.py

@@ -0,0 +1 @@
+from .struct.graph import Rules

pyigr-2026.9.114/src/pyigr/connect.py

@@ -0,0 +1,538 @@
+# this seems like a 'low' level primitive
+# (to build on)
+from typing import Any, Self, Callable, Iterable
+
+class types:
+    state_key = int | str # hashable?
+    state = dict[state_key, Any]
+    type var = str
+    type argpos = int
+    from typing import Any, Literal
+    returnkey = Literal['return']
+    multioutkeys = tuple | list | set | frozenset
+    argmap = dict[var | argpos | returnkey , state_key | multioutkeys ]
+
+
+class Data:
+    def dataclass(c):
+        from dataclasses import dataclass
+        return dataclass(frozen=True)(c)
+
+    @dataclass
+    class F: # just represents a copy to be 1:1 with Block
+        # use wrapt?
+        from typing import Callable
+        f: Callable
+        i: int
+        #def __repr__(self) -> str: # cant use in dict key if this is here! why?!
+        from functools import cached_property
+        @cached_property
+        def name(self):
+            f = self.f
+            _ = repr(f)
+            _ = _.strip('"').strip("'")
+            if _.startswith('<') and _.endswith('>'):
+                mod = (f"{f.__module__}.") if (f.__module__ != '__main__') else ''
+                return f"{mod}{f.__name__}"
+            else:
+                return _
+        
+        from functools import cached_property
+        @cached_property
+        def parameters(self):
+            from inspect import signature
+            return signature(self.f).parameters
+        # cannot set another name for cached_property
+        # params = parameters
+        @cached_property 
+        def params(self): return self.parameters
+
+        @property
+        def signature(self):
+            from inspect import signature
+            return signature(self.f)
+        sig = signature
+        
+            
+        def __call__(self, *p, **k):
+            return self.f(*p, **k)
+
+        
+        @property
+        def __name__(self): return self.f.__name__
+        @property
+        def __module__(self):   return self.f.__module__
+
+    @dataclass
+    class Arg:
+        fidx: int
+        name: types.var
+
+    from collections import namedtuple as _
+    IO = _('IO', ['input', 'output'])
+    del _
+
+##
+# def uniqe_var. part of uuid is probably unique enough for a repr
+##
+
+
+class Rules:
+    def __init__(self,
+            state: types.state = {}, *,
+                name = None,
+                log: bool=False):
+        self.state = state
+        self.funcs = []
+        self.log = [] if log is True else False
+        self.ops = [] # tracking ops on this. should make it easier to convert
+        self.name = name
+    
+    def __repr__(self):
+        # the arrow thing is for when this can be viewed as a 'function'
+        name = self.name if self.name else self.__class__.__name__
+        if self.name:
+            _ = map(set, self.io)
+            i,o = map(lambda _: '{}' if not _ else repr(_), _)
+            _ = f"{name}({i}→{o})"
+            return _
+        else:
+            return repr(super().__init__())
+
+    def _add_op(self,  selfop, **kwargs):
+        # chk args
+        from copy import deepcopy as cp
+        try:
+            kwargs = cp(kwargs)
+        except:  # idk
+            from copy import copy
+            kwargs = copy(kwargs)
+        # check that all needed args are mapped
+        from inspect import signature as sig
+        sig(selfop).bind(**kwargs)
+        self.ops.append(
+            (selfop, kwargs)
+        )
+
+    def add_func(self, f, argmap: types.argmap = {}):
+        self._add_op(self.add_func, f=f, argmap=argmap)
+        f = Data.F(f, len(self.funcs)) #
+        if not argmap:
+            argmap = {p:p for p in f.parameters}
+        # replace pos with kwargs
+        for i, p in enumerate(f.parameters):
+            if (i in argmap) and (p in argmap):
+                raise KeyError(f'conflicting arguments: positional {i} and keyword {p} refer to the same argument.')
+            else:
+                if p not in argmap:
+                    argmap[p] = p
+                if i in argmap:
+                    argmap.pop(i)
+        for a in argmap:
+            if isinstance(a, int):
+                raise KeyError(f'positional argument {a} is not mapped.')
+        # just try to, to raise exception if issue
+        f.signature.bind(**{a:None for a in argmap if a!='return'})
+
+        if 'return' not in argmap:
+            argmap['return'] = f"{f.name}[{f.i}]" # f'{f.__module__}.{f.__name__}()'
+
+        _ = self.FMap(
+                f =  f,
+                argmap = {fa:sk  for fa,sk in argmap.items() if (fa != 'return') },
+                return_statekeys = {
+                    argmap['return'],} if not isinstance(argmap['return'], types.multioutkeys)
+                    else argmap['return'] ,)
+        self.funcs.append(_)
+        return _
+    register_func = add_func
+    class FMap:
+        def __init__(self, *, f, argmap, return_statekeys):
+            self.f, self.argmap, self.return_statekeys = f, argmap, return_statekeys
+        def __repr__(self):
+            from types import SimpleNamespace as NS
+            _ = NS(f=self.f,
+                    argmap=self.argmap,
+                    return_statekeys=self.return_statekeys)
+            _ = repr(_)
+            _ = _.replace('namespace', self.__class__.__name__)
+            return _
+    def register(self, argmap: types.argmap = {}, ):
+        """decorator """ 
+        if callable(argmap): # case when no (parens) used @register
+            f = argmap
+            argmap = {} # the default
+            self.add_func(f)
+            return f
+        else:
+            def decorator(f, argmap=argmap):
+                self.add_func(f, argmap=argmap)
+                return f
+            return decorator
+
+
+    def data(self: Self):
+        rules = self
+        for i, f in enumerate(rules.funcs):
+            fn = f.f
+            oz = f.return_statekeys
+            yield Data.Block(i=i,
+                f = fn,
+                iz = frozenset(f.argmap.keys()),
+                oz = frozenset(oz))
+            for arg, statekey in f.argmap.items():
+                yield Data.VarMap(i = i,
+                    f = fn,
+                    arg = arg,
+                    state_key = statekey
+                )
+        for k,v in rules.state.items():
+            yield Data.State(k=k,v=v)
+
+    def graph(self: Self)-> Data.Graph:
+        """networkx-compatible data structure"""
+        # intent to be 'data'/serialization
+        trm = Data.Graph.terms
+        Node = Data.Graph.Node
+        Graph = Data.Graph
+        Arg = Data.Arg
+        def nodes(rules=self):
+            self = rules
+            for k,v in self.state.items():
+                yield k,\
+                        {trm.types.type: trm.types.state.state,
+                         trm.label: str(k),
+                        trm.types.state.value: v}
+            for fi, fb in enumerate(self.funcs):
+                yield Node(fb.f, trm.types.f.function),\
+                    {trm.types.type:    trm.types.f.function,
+                     trm.label: fb.f.name,
+                     trm.types.f.i: fi,
+                     trm.value: fb.f.f,
+                     }
+                # inputs
+                for farg, statekey in fb.argmap.items():
+                    if statekey not in self.state:
+                        yield statekey,\
+                                {trm.types.type: trm.types.state.state,
+                                trm.label: str(statekey) }
+                    yield Node( Arg(fi, farg), trm.types.f.arg),\
+                            {trm.types.type: trm.types.f.arg,
+                             trm.label: str(farg),
+                             trm.value: farg,
+                             }
+                # outputs
+                for rsk in fb.return_statekeys:
+                    if rsk not in self.state:
+                        yield rsk,\
+                            {trm.types.type: trm.types.state.state}
+        
+
+        def edges(rules=self):
+            ed = {} # edge dict
+            def add(src, dst, attribs={}, ed=ed):
+                if src not in ed:
+                    ed[src] = {}
+                #assert(dst not in ed[src])
+                ed[src][dst] = attribs
+                return ed
+
+            for fi, fb in enumerate(rules.funcs):
+                # state -> arg
+                for farg, statekey in fb.argmap.items():
+                    src = statekey
+                    dst = Node(Arg(fi, farg),   trm.types.f.    arg)
+                    add(src, dst,
+                        {trm.types.type: trm.types.f.binding.input,
+                        trm.types.f.function: fb.f.f },)
+                # func -> state
+                for rsk in fb.return_statekeys:
+                    src = Node(fb.f,        trm.types.f.    function)
+                    dst = rsk
+                    add(src, dst,
+                        {trm.types.type: trm.types.f.binding.output,
+                        trm.types.f.function: fb.f.f})
+            return ed
+        
+        return Graph(
+            nodes={n:a for n,a in nodes()},
+            edges=edges())
+    #data = graph
+    
+    
+
+    def __add__(self, other: Self): return self.add(other)
+    def add(self, other):
+        self._add_op(self.add, other=other)
+
+        common = frozenset(self.state) & frozenset(other.state)
+        for c in common:
+            if self.state[c] != other.state[c]:
+                raise ValueError(f'state clash for key {c}: {self.state[c]}!={other.state[c]}')
+        from copy import deepcopy as copy
+        new = copy(self)
+        new.log = []  # clear this though 
+        new.ops = []
+        new.funcs.extend(other.funcs)
+        new.state.update(other.state)
+        return new
+
+    # running
+    
+    def _apply(self, state: types.state):
+        s = state
+        for fm in self.funcs:
+            try:# can be binded?
+                _ = {a:s[sk] for a,sk in fm.argmap.items()  }
+            except KeyError:
+                continue
+            _ = fm.f.f(**_) # take the inner f for performance
+            # special case
+            # the intent is to not output
+            # could skip func app but could be a useful thing
+            if not fm.return_statekeys:
+                continue
+            elif isinstance(_, dict):
+                for sk in fm.return_statekeys:
+                    assert(sk in _)
+                s.update(_)
+            else: # make one
+                _ = dict.fromkeys(fm.return_statekeys, _)
+                s.update(_)
+            yield fm, s
+
+    def _chk_binding(self):
+        returns = set()
+        for fm in self.funcs:
+            returns.update(fm.return_statekeys)
+        for fm in self.funcs:
+            for a,sk in fm.argmap.items():
+                if          (sk in self.state) or (sk in returns): ...
+                else: raise KeyError(f'{fm.f.name}{a} will not be bound.')
+    def _chk_flow(self):
+        # no circles
+        # chk distinct inputs outputs
+        ...
+
+    
+    @property
+    def io(self):  # io?
+        # self._chk_binding() need to?
+        _ = (fb.argmap.values() for fb in self.funcs)
+        fins = []
+        for os in _: fins.extend(os)
+        fins = frozenset(fins)
+        _ = (fb.return_statekeys for fb in self.funcs)
+        fouts = []
+        for iz in _: fouts.extend(iz)
+        fouts = frozenset(fouts)
+        return Data.IO(
+                input=fins   - fouts,
+                output     = fouts - fins) # neat
+
+
+    def run(self,
+            maxiter = 10, *,
+                stopping: Callable[[types.state], bool] | None = None,
+                check: set|list|tuple|frozenset = ('binding',), # 'flow'),
+                print_log:bool = False, # TODO: print i
+                cache=True, # starting to think this a good default TODO
+                ):
+        for chk in check: getattr(self, '_chk_'+chk)()
+        i = self.i = 0
+        from types import SimpleNamespace as NS
+        class Iteration(NS):    pass
+
+        from copy import deepcopy as copy
+        # shallow vs deep copy? deep more general. shallow for simple objects.
+        # maybe no performance loss if state is shallow.
+        if self.log is not False:
+            self.log.append(Iteration(i=i, state=copy(self.state)))
+        if stopping is not None:
+            if stopping(self.state): return self.state
+
+        # this could just use python's setters and getters.
+        # but i think there's more control with the below
+        while True:
+            if i >= maxiter:
+                from warnings import warn
+                warn('Reached iteration limit!')
+                break
+            # alt. is to 'old*hash*' == new*hash* to potentially avoid copying
+            oldstate = copy(self.state)
+            s = self.state
+            for f,s in self._apply(self.state):
+                if self.log is not False:
+                    self.log.append(
+                        Iteration(i=i+1,
+                            state=copy(s),
+                            rule=f,) )
+                if stopping is not None:
+                    if stopping(s): return s
+            self.state = newstate = s
+
+            if newstate == oldstate: # b/c of this, have to copy
+                break
+            else:
+                i = i+1
+                newstate = oldstate
+                continue
+            
+        return self.state
+
+    def __call__(self, *,
+            _maxiter=999, _stopping=None,
+            _check = {'binding', 'flow' },
+            _print_log=False,
+            **state) -> types.state:
+        """treat the machine as a function:
+        Keyword arguments will update the state.
+        If a dictionary with the key 'state' is passed,
+        its value will update the state.
+        (So to have a 'state' key with a dictionary, you can nest it: (state={'x': 3, 'state': 5})
+        """
+        # should cache functions?
+        if 'state' in state:
+            assert(isinstance(state['state'], types.state))
+            self.state.update(state.pop('state'))
+        else:    
+            self.state.update(**state)
+        _ = self.run(
+                maxiter=_maxiter, stopping=_stopping,
+                check=_check,
+                print_log=_print_log)
+        return self.state
+
+
+
+class Graph:
+    """
+    networkx compatible data
+    """
+    # but keep the state values separate
+
+    class types:
+        from dataclasses import dataclass
+        @dataclass(frozen=True)
+        class Node:    # need to uniquify
+            from typing import Any
+            obj: Any
+            type: str # != 'state' for convenience
+
+
+    class terms:
+        class types:
+            type =  'type'
+            class f:
+                function = 'function'
+                i = 'i'  # func idx
+                arg =   'arg'
+                class binding:
+                    binding = 'binding'
+                    input = 'input'
+                    output = 'output'
+            class state:
+                state = 'state'
+                value = 'value'        
+        value = 'value'
+        label = 'label'
+
+    def __init__(self, rules: Rules):
+        self.rules = rules
+        self.graph = self.types.DiGraph()
+        self.nodes = self.graph.nodes
+        self.edges = self.graph.edges
+
+
+    @property
+    def state(self) -> dict:
+        return {
+            s:self.nodes[self.terms.types.state.value]
+            for s in self.nodes
+            if self.terms.types.state.value in self.nodes }
+
+
+    def add_state(self, k, v: Any=None):
+        attrs = {self.terms.types.state.value: v} if v is not None
+        self.graph.add_node(k, )
+        return k, attrs
+        
+
+    def add_argmap(self, fm: Rules.FMap):
+        ...
+
+
+    def xgraph(self: Self)-> Data.Graph:
+        """networkx-compatible data structure"""
+        # intent to be 'data'/serialization
+        trm = Data.Graph.terms
+        Node = Data.Graph.Node
+        Graph = Data.Graph
+        Arg = Data.Arg
+        def nodes(rules=self):
+            self = rules
+            for k,v in self.state.items():
+                yield k,\
+                        {trm.types.type: trm.types.state.state,
+                         trm.label: str(k),
+                        trm.types.state.value: v}
+            for fi, fb in enumerate(self.funcs):
+                yield Node(fb.f, trm.types.f.function),\
+                    {trm.types.type:    trm.types.f.function,
+                     trm.label: fb.f.name,
+                     trm.types.f.i: fi,
+                     trm.value: fb.f.f,
+                     }
+                # inputs
+                for farg, statekey in fb.argmap.items():
+                    if statekey not in self.state:
+                        yield statekey,\
+                                {trm.types.type: trm.types.state.state,
+                                trm.label: str(statekey) }
+                    yield Node( Arg(fi, farg), trm.types.f.arg),\
+                            {trm.types.type: trm.types.f.arg,
+                             trm.label: str(farg),
+                             trm.value: farg,
+                             }
+                # outputs
+                for rsk in fb.return_statekeys:
+                    if rsk not in self.state:
+                        yield rsk,\
+                            {trm.types.type: trm.types.state.state}
+        
+
+        def edges(rules=self):
+            ed = {} # edge dict
+            def add(src, dst, attribs={}, ed=ed):
+                if src not in ed:
+                    ed[src] = {}
+                #assert(dst not in ed[src])
+                ed[src][dst] = attribs
+                return ed
+
+            for fi, fb in enumerate(rules.funcs):
+                # state -> arg
+                for farg, statekey in fb.argmap.items():
+                    src = statekey
+                    dst = Node(Arg(fi, farg),   trm.types.f.    arg)
+                    add(src, dst,
+                        {trm.types.type: trm.types.f.binding.input,
+                        trm.types.f.function: fb.f.f },)
+                # func -> state
+                for rsk in fb.return_statekeys:
+                    src = Node(fb.f,        trm.types.f.    function)
+                    dst = rsk
+                    add(src, dst,
+                        {trm.types.type: trm.types.f.binding.output,
+                        trm.types.f.function: fb.f.f})
+            return ed
+        
+        return Graph(
+            nodes={n:a for n,a in nodes()},
+            edges=edges())
+
+# class Running
+# run
+
+# class Tasks:
+#  for topo sort.

pyigr-2026.9.114/src/pyigr/exec/dask.py

@@ -0,0 +1,44 @@
+# meant to create more executable forms
+from ..rules import Rules as _
+class Rules(_):
+    
+    def __call__(self, **k):
+        self.state.update(k)
+
+    def set_return(self):
+        allouts
+
+
+
+def tasks(rules: Rules):
+    from dask.task_spec import Task, DataNode, TaskRef
+    #              why none?
+    _ = {k: DataNode(None, v) for k,v in rules.state.items()}
+    def order_args(f, argmap):
+        from inspect import signature as sig
+        _ = sig(f).parameters
+        _ = (argmap[p] for p in _)
+        _ = map(TaskRef, _)
+        _ = tuple(_)
+        return _
+    #   assuming not split
+    _ = _ | \
+        {fm.return_statekey: Task(i, fm.f, *order_args(fm.f, fm.argmap) ) for i,fm in enumerate(rules.funcs) }
+    
+    def split_output(): ...
+
+    return _
+
+
+
+def test(rules: Rules):
+    ts = tasks(rules)
+    #_ = Task(None, f, 3,4 )
+    #from dask.distributed import Client
+    from dask.threaded import get
+    #c = Client(processes=False)
+    return get(ts, ['x', 'y', 'f' ] )
+    #return c.get(_, 'x' )
+    _ = _()
+    return _
+    #for k,v 

pyigr-2026.9.114/src/pyigr/exec/readme.md

@@ -0,0 +1 @@
+meant for exec targets

pyigr-2026.9.114/src/pyigr/exec/state.py

@@ -0,0 +1,3 @@
+# just print out vars
+# typing from graph
+

pyigr-2026.9.114/src/pyigr/struct/graph.py

@@ -0,0 +1,120 @@
+from ..rules import Rules as _Rules, Data as data
+
+class Rules(_Rules):
+    def mermaid(self, log_idx=-1):
+        return mermaid(self, log_idx=log_idx)
+    
+    def _display_(self):
+        _ = mermaid(self)
+        from marimo import mermaid as md
+        _ = md(_)
+        return _
+
+
+def networkx(rules: _Rules):
+    from networkx import DiGraph
+    _ = DiGraph()
+    rd = rules.graph()
+    _.add_nodes_from(rd.nodes.items())
+    # cant add directly??
+    #_.add_edges_from(rd.edges)
+    for s in rd.edges:
+        for d in rd.edges[s]:
+            _.add_edge(s, d, **rd.edges[s][d] if rd.edges[s][d] else {})
+    return _
+
+
+def frepr(f):
+    try:
+        f = f.f
+    except:
+        f = f
+    _ = repr(f)
+    _ = _.strip('"').strip("'")
+    if _.startswith('<') and _.endswith('>'):
+        mod = (f"{f.__module__}.") if (f.__module__ != '__main__') else ''
+        return f"{mod}{f.__name__}"
+    else:
+        return _
+
+
+def value_repr(v):
+    _ = str(v)
+    _ = _.strip('"').strip('"')
+    ml = 20
+    if len(_)>ml:
+        _ = _[:ml]
+        _ = _+'...'
+    return _
+
+
+def mermaid(rules: Rules, log_idx=-1):
+    if log_idx == -1:
+        state = rules.state
+    else:
+        state = rules.log[log_idx].state
+    # really wanted svelte flow
+    #---
+    # title: repr(rules)
+    # ---
+    # flowchart TD
+    #     input
+    #     A((A)) -->|i1|f
+    #     A((A)) -->|i2|f
+    #     output
+    #     f -->o1((o1))
+    #     f -->o2((o2))
+    from functools import cache
+    @cache
+    def part(n, type, id=id, ):
+        v = val
+        if type == 'f':
+            return f"{type}{id(n)}[\\{ frepr(n) }/]"
+        if type in {'s', 'o'}:
+            return f'so{id(n)}@{{shape: stadium, label: "{frepr(n)+val(n, type, )}" }}'
+        if type == 'i':
+            return f"|{repr(n).strip('"').strip("'")}|"
+        raise Exception('not handled')
+
+    def val(n, type, ):
+        if type =='f':
+            return ''
+        elif n not in state:
+            return ''
+        v = state[n]
+        v = value_repr(v)
+        v = v.replace("'", "\\'")
+        v = '='+v
+        return v
+
+    def parts(r: data.Block | data.VarMap | _Rules):
+        if isinstance(r, data.Block):
+            block = r
+            for o in block.oz:
+                yield f"{part((block.f), 'f')}-->{part(o, 'o')}"
+            if not block.iz:
+                yield part((block.f), 'f')
+        elif isinstance(r, data.VarMap):
+            vm = r
+            yield f"{part(vm.state_key, 's')}-->{part(vm.arg, 'i')}{part(vm.f, 'f')}"
+        elif isinstance(r, data.State):
+            if not rules.funcs:
+                yield f"{part(r.k, 's')}"
+        else:
+            assert(isinstance(r, _Rules))
+            for d in r.data():
+                yield from parts(d)
+    
+    _ = parts(rules)
+    _ = '\n'.join(_)
+    _ = f"""
+    ---
+    title: {repr(rules).strip('"').strip("'").strip('<').strip('>')}
+    ---
+    flowchart TD
+    {_}
+    """
+    _ = (l.strip() for l in _.split('\n') if l.strip())
+    _ = '\n'.join(_)
+    return _
+

pyigr-2026.9.114/src/pyigr/vis/mermaid.py

@@ -0,0 +1,109 @@
+from ..rules import Rules
+
+
+def mermaid(rules: Rules, log_idx=-1):
+    if log_idx == -1 and (len(rules.log)==0):
+        state = rules.state
+    else:
+        state = rules.log[log_idx].state
+    # really wanted svelte flow
+    #---
+    # title: repr(rules)
+    # ---
+    # flowchart TD
+    #     input
+    #     A((A)) -->|i1|f
+    #     A((A)) -->|i2|f
+    #     output
+    #     f -->o1((o1))
+    #     f -->o2((o2))
+
+    def repr(o):
+        for n in {'name', 'label', }:
+            if hasattr(o, n):
+                return getattr(o, n)
+        return o.__repr__()
+        
+
+    from ..rules import Data
+    terms = Data.Graph.terms
+    from functools import cache
+    @cache
+    def part(n, type, id=id, label=None ):
+        if label is None:
+            label = repr(n).strip('"').strip("'")
+        if type == terms.types.f.function:
+            return f'{type}{id(n)}[\\"{ label }"/]'
+        if type in {terms.types.state.state, }:
+            return f'{type}{id(n)}@{{shape: stadium, label: "{label+val(n, type, )}" }}'
+        if type == terms.types.f.arg :
+            return f'{type}{id(n)}@{{shape: flip-tri, label: "{label }" }}'
+        raise Exception('not handled')
+
+    def val(n, type, ):
+        if type == terms.types.f.function:
+            return ''
+        elif n not in state:
+            return ''
+        v = state[n]
+        v = value_repr(v)
+        v = v.replace("'", "\\'")
+        v = '='+v
+        return v
+
+
+    g = networkx(rules)
+    def data():
+        from types import SimpleNamespace as ns
+        for ne, d in g.nodes.items():
+            yield ns(t='n', ne=ne, d=d) #
+        for ne, d in g.edges.items():
+            yield ns(t='e', ne=ne, d=d)
+
+    def parts():
+        def type(n):
+            _ = g.nodes[n][terms.types.type]
+            return _
+
+        for d in data():
+            # nodes
+            if d.t == 'n':
+                yield part(d.ne, d.d['type'] )
+            else:# edges
+                assert(d.t == 'e')
+                src, dst = d.ne
+                st, dt = type(src), type(dst)
+                if d.d[terms.types.type] == terms.types.f.binding.input:
+                    yield f"{part(src, st)}-->{part(dst, dt )}"
+                #if d.d[terms.types.type] == terms.types.f.binding.input:
+                #    yield f"{part(src, st)}-->"{part(dst, dt )}"
+
+        # if isinstance(r, data.Block):
+        #     block = r
+        #     for o in block.oz:
+        #         yield f"{part((block.f), 'f')}-->{part(o, 'o')}"
+        #     if not block.iz:
+        #         yield part((block.f), 'f')
+        # elif isinstance(r, data.VarMap):
+        #     vm = r
+        #     yield f"{part(vm.state_key, 's')}-->{part(vm.arg, 'i')}{part(vm.f, 'f')}"
+        # elif isinstance(r, data.State):
+        #     if not rules.funcs:
+        #         yield f"{part(r.k, 's')}"
+        # else:
+        #     assert(isinstance(r, _Rules))
+        #     for d in r.data():
+        #         yield from parts(d)
+    
+    _ = parts()
+    _ = '\n'.join(_)
+    _ = f"""
+    ---
+    title: {repr(rules).strip('"').strip("'").strip('<').strip('>')}
+    ---
+    flowchart TD
+    {_}
+    """
+    _ = (l.strip() for l in _.split('\n') if l.strip())
+    _ = '\n'.join(_)
+    return _