sier2 0.37__tar.gz → 1.0.0__tar.gz

{sier2-0.37 → sier2-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sier2
-Version: 0.37
+Version: 1.0.0
 Summary: Blocks of code that are executed in dags
 Author: Algol60
 Author-email: algol60 <algol60@users.noreply.github.com>
@@ -23,7 +23,7 @@ a processing dag pipeline. Blocks are an improvement on libraries;
 if you have a library, you still need to build an application.
 Blocks are pieces of an application, you just have to connect them.
 
-See the ``examples`` directory for examples.
+See the ``examples`` directory in the ``sier2-tutorial`` repository for examples.
 
 Description
 -----------
@@ -49,11 +49,11 @@ A typical block implementation looks like this.
     class Increment(Block):
         """A block that adds one to the input value."""
 
-        int_in = param.Integer(label='The input', doc='An integer')
-        int_out = param.Integer(label='The output', doc='The incremented value')
+        in_int = param.Integer(label='The input', doc='An integer')
+        out_int = param.Integer(label='The output', doc='The incremented value')
 
         def execute(self):
-            self.int_out = self.int_in + 1
+            self.out_int = self.in_int + 1
 
 See the examples in ``examples`` (Python scripts) and ``examples-panel`` (scripts that use `Panel <https://panel.holoviz.org/>`_ as a UI).
 

{sier2-0.37 → sier2-1.0.0}/README.rst

@@ -6,7 +6,7 @@ a processing dag pipeline. Blocks are an improvement on libraries;
 if you have a library, you still need to build an application.
 Blocks are pieces of an application, you just have to connect them.
 
-See the ``examples`` directory for examples.
+See the ``examples`` directory in the ``sier2-tutorial`` repository for examples.
 
 Description
 -----------
@@ -32,11 +32,11 @@ A typical block implementation looks like this.
     class Increment(Block):
         """A block that adds one to the input value."""
 
-        int_in = param.Integer(label='The input', doc='An integer')
-        int_out = param.Integer(label='The output', doc='The incremented value')
+        in_int = param.Integer(label='The input', doc='An integer')
+        out_int = param.Integer(label='The output', doc='The incremented value')
 
         def execute(self):
-            self.int_out = self.int_in + 1
+            self.out_int = self.in_int + 1
 
 See the examples in ``examples`` (Python scripts) and ``examples-panel`` (scripts that use `Panel <https://panel.holoviz.org/>`_ as a UI).
 

{sier2-0.37 → sier2-1.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sier2"
-version = "0.37"
+version = "1.0.0"
 description = "Blocks of code that are executed in dags"
 authors = [
     {name="Algol60", email="algol60 <algol60@users.noreply.github.com>"}
@@ -21,7 +21,7 @@ classifiers = [
 [dependencies]
 python = "^3.11"
 
-panel = ">=1.4.4"
+panel = ">=1.6.3"
 param = ">=2.1.0"
 
 [[tool.mypy.overrides]]

{sier2-0.37 → sier2-1.0.0}/src/sier2/_block.py

@@ -70,7 +70,7 @@ class Block(param.Parameterized):
     There are three kinds of parameters:
     * Input parameters start with ``in_``. These parameters are set before a block is executed.
     * Output parameters start with ``out_``. The block sets these in its ``execute()`` method.
-    * Block parameters start with ``block_``. THese are reserved for use by blocks.
+    * Block parameters start with ``block_``. These are reserved for use by blocks.
 
     A typical block will have at least one input parameter, and an ``execute()``
     method that is called when an input parameter value changes.
@@ -137,10 +137,6 @@ class Block(param.Parameterized):
         #
         self._block_out_params = []
 
-        # self._block_context = _EmptyContext()
-
-        # self._progress = None
-
     @classmethod
     def block_key(cls):
         """The unique key of this block class.

{sier2-0.37 → sier2-1.0.0}/src/sier2/_dag.py

@@ -38,9 +38,7 @@ class _InputValues:
     dst: Block
 
     # The values to be set before the block executes.
-    # For a normal block, values will be non-empty when execute() is called.
-    # For an input block, if values is non-empty, prepare()
-    # will be called, else execute() will be called
+    # Values will be non-empty when execute() is called.
     #
     values: dict[str, Any] = field(default_factory=dict)
 
@@ -219,6 +217,15 @@ class Dag:
         if any(not isinstance(c, Connection) for c in connections):
             raise BlockError('All arguments must be Connection instances')
 
+        # Because this is probably the first place that the Block instance is used,
+        # this is a convenient place to check that the block was correctly initialised.
+        #
+        # Pick an arbitrary attribute that should be present.
+        #
+        for b in src, dst:
+            if not hasattr(b, 'block_doc'):
+                raise BlockError(f'Did you call super().__init__() in {b}?')
+
         if _DISALLOW_CYCLES:
             if _has_cycle(self._block_pairs + [(src, dst)]):
                 raise BlockError('This connection would create a cycle')
@@ -295,7 +302,7 @@ class Dag:
                 self._block_queue.append(item)
 
     def execute_after_input(self, block: Block, *, dag_logger=None):
-        """Execute the dag after running ``prepare()`` in an input block.
+        """Execute the dag after running ``prepare()``.
 
         After prepare() executes, and the user has possibly
         provided input, the dag must continue with execute() in the
@@ -331,8 +338,8 @@ class Dag:
         that block's execute() method.
 
         If the current destination block's ``block_pause_execution` is True,
-        the loop will call ``block.prepare()` instead of ``block.execute()``,
-        then stop; execute() will return the block that is puased on.
+        the loop will call ``block.prepare()``, then stop; execute() 
+        will return the block that is puased on.
         The dag can then be restarted with ``dag.execute_after_input()``,
         using the paused block as the parameter.
 
@@ -394,17 +401,17 @@ class Dag:
                         'sier2_block_': f'{item.dst}'
                     }
 
-                    # If this is an input block, and there are input
-                    # values, call prepare() if it exists.
-                    #
-                    if is_input_block and not is_restart:# and item.values:
+                    # If we need to wait for a user, just run prepare().
+                    # If we are restarting, just run execute().
+                    # Otherwise, run both.
+                    if is_input_block and not is_restart:
                         self.logging(g.prepare, **logging_params)()
+                    elif is_restart:
+                        self.logging(g.execute, **logging_params)()
                     else:
+                        self.logging(g.prepare, **logging_params)()
                         self.logging(g.execute, **logging_params)()
 
-            # print(f'{is_input_block=}')
-            # print(f'{is_restart=}')
-            # print(f'{item.values=}')
             if is_input_block and not is_restart:# and item.values:
                 # If the current destination block requires user input,
                 # stop executing the dag immediately, because we don't

sier2-1.0.0/src/sier2/panel/_chart.py

@@ -0,0 +1,313 @@
+# Generate a dag chart.
+# We stick to raw python/html here to keep sier's dependencies to a minimum, 
+# even if other libraries would be easier to get plots from.
+#
+
+from sier2 import Block, Dag
+
+
+import panel as pn
+import math
+
+class HTMLGraph:
+    """A class to generate network graph visualizations using Panel HTML pane"""
+    
+    def __init__(self, width=400, height=400, background="#f8f9fa"):
+        self.width = width
+        self.height = height
+        self.background = background
+        self.nodes = {}
+        self.edges = []
+        self.node_styles = {
+            "default": {
+                "background-color": "#4a86e8",
+                "color": "black",
+                "border": "none",
+                "font-weight": "bold"
+            },
+            "input": {
+                "background-color": "#f2df0c",
+                "color": "black",
+                "font-weight": "bold"
+            }
+        }
+        self.edge_styles = {
+            "default": {
+                "background-color": "#666",
+                "height": "2px"
+            }
+        }
+    
+    def add_node_style(self, style_name, style_dict):
+        """Add a new node style"""
+        self.node_styles[style_name] = style_dict
+    
+    def add_edge_style(self, style_name, style_dict):
+        """Add a new edge style"""
+        self.edge_styles[style_name] = style_dict
+        
+    def add_node(self, node_id, label, x=None, y=None, style="default"):
+        """Add a node to the graph"""
+        # If no position specified, assign random position
+        if x is None:
+            x = random.randint(50, self.width - 50)
+        if y is None:
+            y = random.randint(50, self.height - 50)
+            
+        self.nodes[node_id] = {
+            "label": label,
+            "x": x,
+            "y": y,
+            "style": style
+        }
+    
+    def add_edge(self, source_id, target_id, label=None, style="default"):
+        """Add an edge between two nodes"""
+        if source_id in self.nodes and target_id in self.nodes:
+            self.edges.append({
+                "source": source_id,
+                "target": target_id,
+                "label": label,
+                "style": style
+            })
+    
+    # def layout_circle(self, center_x=None, center_y=None, radius=None):
+    #     """Arrange nodes in a circle"""
+    #     if center_x is None:
+    #         center_x = self.width / 2
+    #     if center_y is None:
+    #         center_y = self.height / 2
+    #     if radius is None:
+    #         radius = min(self.width, self.height) / 3
+            
+    #     node_ids = list(self.nodes.keys())
+    #     for i, node_id in enumerate(node_ids):
+    #         angle = 2 * math.pi * i / len(node_ids)
+    #         self.nodes[node_id]["x"] = center_x + radius * math.cos(angle)
+    #         self.nodes[node_id]["y"] = center_y + radius * math.sin(angle)
+    
+    def generate_html(self):
+        """Generate HTML representation of the network graph"""
+        html = f"""
+        <style>
+          .graph-container {{
+            position: relative;
+            width: {self.width}px;
+            height: {self.height}px;
+            background-color: {self.background};
+            border: 1px solid #ddd;
+            overflow: hidden;
+          }}
+          
+          .node {{
+            position: absolute;
+            width: 60px;
+            height: 60px;
+            border-radius: 50%;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            text-align: center;
+            font-size: 14px;
+            box-shadow: 0 2px 5px rgba(0,0,0,0.2);
+            cursor: pointer;
+            transform-origin: center;
+            transition: transform 0.2s ease, box-shadow 0.2s ease;
+            z-index: 10;
+          }}
+          
+          # .node:hover {{
+          #   transform: scale(1.1);
+          #   box-shadow: 0 4px 8px rgba(0,0,0,0.3);
+          #   z-index: 20;
+          # }}
+          
+          .edge {{
+            position: absolute;
+            height: 2px;
+            transform-origin: left center;
+            z-index: 5;
+          }}
+          
+          .edge-label {{
+            position: absolute;
+            background-color: white;
+            padding: 2px 6px;
+            border-radius: 3px;
+            font-size: 12px;
+            box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+            z-index: 15;
+          }}
+        </style>
+        
+        <div class="graph-container">
+        """
+        
+        # Add edges first (so they're behind nodes)
+        for edge in self.edges:
+            source = self.nodes[edge["source"]]
+            target = self.nodes[edge["target"]]
+            
+            # Calculate edge properties
+            x1, y1 = source["x"], source["y"]
+            x2, y2 = target["x"], target["y"]
+            
+            # Calculate length and angle
+            length = math.sqrt((x2 - x1)**2 + (y2 - y1)**2)
+            angle = math.atan2(y2 - y1, x2 - x1) * (180 / math.pi)
+            
+            # Get style properties
+            style_props = self.edge_styles[edge["style"]]
+            style_attr = "; ".join([f"{k}: {v}" for k, v in style_props.items()])
+            
+            # Create edge element
+            html += f"""
+            <div class="edge" 
+                 style="width: {length}px; 
+                        left: {x1}px; 
+                        top: {y1}px; 
+                        transform: rotate({angle}deg);
+                        {style_attr}">
+            </div>
+            """
+            
+            # Add edge label if specified
+            if edge["label"]:
+                # Position label at the middle of the edge
+                label_x = (x1 + x2) / 2 - 15
+                label_y = (y1 + y2) / 2 - 10
+                
+                html += f"""
+                <div class="edge-label" style="left: {label_x}px; top: {label_y}px;">
+                    {edge["label"]}
+                </div>
+                """
+        
+        # Add nodes
+        for node_id, node in self.nodes.items():
+            # Get style properties
+            style_props = self.node_styles[node["style"]]
+            style_attr = "; ".join([f"{k}: {v}" for k, v in style_props.items()])
+            
+            # Create node element
+            html += f"""
+            <div class="node" id="node-{node_id}" 
+                 style="left: {node['x'] - 30}px; 
+                        top: {node['y'] - 30}px;
+                        {style_attr}"
+                 onclick="highlightNode('{node_id}')">
+                {node["label"]}
+            </div>
+            """
+        
+        # # Add some basic interactivity with JavaScript
+        # html += """
+        # <script>
+        # function highlightNode(nodeId) {
+        #     // Reset all nodes
+        #     const nodes = document.querySelectorAll('.node');
+        #     nodes.forEach(n => n.style.transform = 'scale(1)');
+            
+        #     // Highlight the selected node
+        #     const node = document.getElementById('node-' + nodeId);
+        #     node.style.transform = 'scale(1.2)';
+        # }
+        # </script>
+        # """
+        
+        html += "</div>"
+        return html
+    
+    def get_pane(self, width=None, height=None):
+        """Get a Panel pane with the graph"""
+        if width is None:
+            width = self.width + 50
+        if height is None:
+            height = self.height + 50
+            
+        return pn.pane.HTML(self.generate_html(), width=width, height=height)
+        
+def html_graph(dag: Dag):
+    """Build a Bokeh figure to visualise the block connections."""
+
+    src: list[Block] = []
+    dst: list[Block] = []
+
+    def build_layers():
+        """Traverse the block pairs and organise them into layers.
+
+        The first layer contains the root (no input) nodes.
+        """
+
+        ranks = {}
+        remaining = dag._block_pairs[:]
+
+        # Find the root nodes and assign them a layer.
+        #
+        src[:], dst[:] = zip(*remaining)
+        S = list(set([s for s in src if s not in dst]))
+        for s in S:
+            ranks[s.name] = 0
+
+        n_layers = 1
+        while remaining:
+            for s, d in remaining:
+                if s.name in ranks:
+                    # This destination could be from sources at different layers.
+                    # Make sure the deepest one is used.
+                    #
+                    ranks[d.name] = max(ranks.get(d.name, 0), ranks[s.name] + 1)
+                    n_layers = max(n_layers, ranks[d.name])
+
+            remaining = [(s,d) for s,d in remaining if d.name not in ranks]
+
+        return n_layers, ranks
+
+    def layout():
+        """Arrange the graph nodes."""
+
+        max_width = 0
+
+        # Arrange the graph y by layer from top to bottom.
+        # For x, for now we start at 0 and +1 in each layer.
+        #
+        yx = {y:0 for y in ranks.values()}
+        gxy = {}
+        for g, y in ranks.items():
+            gxy[g] = [yx[y], y]
+            yx[y] += 1
+            max_width = max(max_width, yx[y])
+
+        # Balance out the x in each layer.
+        #
+        for y in range(n_layers+1):
+            layer = {name: xy for name,xy in gxy.items() if xy[1]==y}
+            if len(layer)<max_width:
+                for x, (name, xy) in enumerate(layer.items(), 1):
+                    gxy[name][0] = x/max_width
+
+        return gxy
+
+    graph = HTMLGraph()
+
+    n_layers, ranks = build_layers()
+
+    ly = layout()
+
+    max_layer_width = max([ly[n][0] for n in ly.keys()])
+        
+    vertical_scale = graph.height / (n_layers + 2)
+    horizontal_scale = graph.width / (max_layer_width + 2)
+
+    for node in ly.keys():
+        graph.add_node(
+            node, node, 
+            x=(ly[node][0] + 1) * horizontal_scale, 
+            y=(ly[node][1] + 1) * vertical_scale,
+            style='default' if not dag.block_by_name(node).block_pause_execution else 'input'
+        )
+
+    for s, d in dag._block_pairs:
+        graph.add_edge(s.name, d.name)
+
+    return graph.get_pane()

{sier2-0.37 → sier2-1.0.0}/src/sier2/panel/_panel.py

@@ -4,14 +4,18 @@ import html
 import panel as pn
 import sys
 import threading
+import warnings
 from typing import Callable
 
+import param.parameterized as paramp
+from param.parameters import DataFrame
+
 from sier2 import Block, BlockValidateError, BlockState, Dag, BlockError
 from .._dag import _InputValues
 from .._util import trim
 from ._feedlogger import getDagPanelLogger, getBlockPanelLogger
 from ._panel_util import _get_state_color, dag_doc
-from ._chart import bokeh_graph
+from ._chart import html_graph
 
 NTHREADS = 2
 
@@ -250,12 +254,16 @@ def _prepare_to_show(dag: Dag):
 
     cards.extend(BlockCard(parent_template=template, dag=dag, w=gw, dag_logger=dag_logger) for gw in dag.get_sorted() if gw.block_visible)
 
-    template.main.append(pn.Column(*cards))
+    template.main.append(pn.panel(pn.Column(*cards)))
     template.sidebar.append(
         pn.Column(
             switch,
             # pn.panel(dag.hv_graph().opts(invert_yaxis=True, xaxis=None, yaxis=None)),
-            pn.Row(pn.panel(bokeh_graph(dag)), max_width=400, max_height=200),
+            pn.Row(
+                pn.panel(html_graph(dag)), 
+                max_width=400, 
+                max_height=200,
+            ),
             log_feed,
             info_fp_holder
         )
@@ -296,14 +304,26 @@ def _serveable_dag(dag: Dag):
     template.servable()
 
 def _default_panel(self) -> Callable[[Block], pn.Param]:
-    """Provide a default __panel__() implementation for blocks that don't have one.
+    """Provide a default __panel__() implementation for blocks that don't have one.param.parameters.
 
     This default will display the in_ parameters.
     """
-
+    
     in_names = [name for name in self.param.values() if name.startswith('in_')]
 
-    return pn.Param(self, parameters=in_names, show_name=False)
+    # Check if we need tabulator installed.
+    # Ostensibly param uses the DataFrame widget if the tabulator extension isn't present,
+    # but this doesn't seem to work properly.
+    #
+    if any([isinstance(self.param[name], DataFrame) for name in in_names]):
+        if 'tabulator' not in pn.extension._loaded_extensions:
+            tabulator_warning = f'One of your blocks ({self.__class__.__name__}) requires Tabulator, a panel extension for showing data frames. You should explicitly load this with "pn.extension(\'tabulator\')" in your block'
+            warnings.warn(tabulator_warning)
+            pn.extension('tabulator')
+
+    param_pane = pn.Param(self, parameters=in_names, show_name=False)
+
+    return param_pane
 
 class BlockCard(pn.Card):
     """A custom card to wrap around a block.
@@ -430,12 +450,32 @@ class BlockCard(pn.Card):
 
         self.header[-1] = self._get_state_light(_get_state_color(_block_state))
 
+def _sier2_label_formatter(pname: str):
+    """Default formatter to turn parameter names into appropriate widget labels.
+
+    Make labels nicer for Panel.
+
+    Panel uses the label to display a caption for the corresponding input widgets.
+    The default label is taken from the name of the param, which means the default
+    caption starts with "In ".
+
+    Removes the "in_" prefix from input parameters, then passes the param name
+    to paramp.default_label_formatter.
+    """
+
+    if pname.startswith('in_'):
+        pname = pname[3:]
+
+    return paramp.default_label_formatter(pname)
+
 class PanelDag(Dag):
     def __init__(self, *, site: str='Panel Dag', title: str, doc: str):
         super().__init__(site=site, title=title, doc=doc)
 
+        paramp.label_formatter = _sier2_label_formatter
+
     def show(self):
         _show_dag(self)
 
     def servable(self):
-        _serveable_dag(self)
+        _serveable_dag(self)

sier2-1.0.0/src/sier2/panel/tabulator_test.py

@@ -0,0 +1,25 @@
+from sier2 import Block, Connection
+from sier2.panel import PanelDag
+import param
+import time
+import pandas as pd 
+import panel as pn
+   
+class StartBlock(Block):
+    """Starts the test dag"""
+
+    out_data = param.DataFrame()
+
+    def execute(self):
+        time.sleep(3)
+        self.out_data = pd.DataFrame({'A':[1,2,3,4], 'B':[5,6,7,8]})
+
+class FinishBlock(Block):
+    """Finishes the test dag"""
+    in_data = param.DataFrame()
+
+sb = StartBlock(block_pause_execution=True)
+fb = FinishBlock()
+dag = PanelDag(doc='test', title='test')
+dag.connect(sb, fb, Connection('out_data', 'in_data'))
+dag.show()

sier2-0.37/src/sier2/panel/_chart.py

@@ -1,106 +0,0 @@
-# Generate a dag chart.
-#
-
-from sier2 import Block, Dag
-
-from bokeh.plotting import figure, show, ColumnDataSource, curdoc, output_notebook
-from bokeh.models import HoverTool
-
-from bokeh.resources import INLINE
-output_notebook(resources=INLINE)
-
-def bokeh_graph(dag: Dag):
-    """Build a Bokeh figure to visualise the block connections."""
-
-    src: list[Block] = []
-    dst: list[Block] = []
-
-    def build_layers():
-        """Traverse the block pairs and organise them into layers.
-
-        The first layer contains the root (no input) nodes.
-        """
-
-        ranks = {}
-        remaining = dag._block_pairs[:]
-
-        # Find the root nodes and assign them a layer.
-        #
-        src[:], dst[:] = zip(*remaining)
-        S = list(set([s for s in src if s not in dst]))
-        for s in S:
-            ranks[s.name] = 0
-
-        n_layers = 1
-        while remaining:
-            for s, d in remaining:
-                if s.name in ranks:
-                    # This destination could be from sources at different layers.
-                    # Make sure the deepest one is used.
-                    #
-                    ranks[d.name] = max(ranks.get(d.name, 0), ranks[s.name] + 1)
-                    n_layers = max(n_layers, ranks[d.name])
-
-            remaining = [(s,d) for s,d in remaining if d.name not in ranks]
-
-        return n_layers, ranks
-
-    def layout():
-        """Arrange the graph nodes."""
-
-        max_width = 0
-
-        # Arrange the graph y by layer from top to bottom.
-        # For x, for now we start at 0 and +1 in each layer.
-        #
-        yx = {y:0 for y in ranks.values()}
-        gxy = {}
-        for g, y in ranks.items():
-            gxy[g] = [yx[y], y]
-            yx[y] += 1
-            max_width = max(max_width, yx[y])
-
-        # Balance out the x in each layer.
-        #
-        for y in range(n_layers+1):
-            layer = {name: xy for name,xy in gxy.items() if xy[1]==y}
-            if len(layer)<max_width:
-                for x, (name, xy) in enumerate(layer.items(), 1):
-                    gxy[name][0] = x/max_width
-
-        return gxy
-
-    n_layers, ranks = build_layers()
-
-    ly = layout()
-
-    linexs = []
-    lineys = []
-    for s, d in dag._block_pairs:
-        print(s.name, d.name)
-        linexs.append((ly[s.name][0], ly[d.name][0]))
-        lineys.append((ly[s.name][1], ly[d.name][1]))
-
-    xs, ys = zip(*ly.values())
-
-    c_source = ColumnDataSource({
-        'xs': xs,
-        'ys': ys,
-        'names': list(ly.keys())
-    })
-    l_source = ColumnDataSource({
-        'linexs': linexs,
-        'lineys': lineys
-    })
-
-    curdoc().theme = 'dark_minimal'
-    p = figure(tools='pan,wheel_zoom,box_zoom,reset', height=300, width=300)
-    p.axis.visible = False
-    p.xgrid.visible = False
-    p.ygrid.visible = False
-    p.y_range.flipped = True # y-axis goes down instead of up.
-    l = p.multi_line(xs='linexs', ys='lineys', source=l_source)
-    c = p.circle(x='xs', y='ys', radius=0.05, line_color='black', fill_color='steelblue', hover_fill_color='#7f7f7f', source=c_source)
-    p.add_tools(HoverTool(tooltips=[('Block', '@names')], renderers=[c]))
-
-    return p