sier2 0.35__tar.gz → 0.40__tar.gz

{sier2-0.35 → sier2-0.40}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sier2
-Version: 0.35
+Version: 0.40
 Summary: Blocks of code that are executed in dags
 Author: Algol60
 Author-email: algol60 <algol60@users.noreply.github.com>
@@ -12,7 +12,7 @@ Classifier: Intended Audience :: Science/Research
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Software Development :: Libraries
-Project-URL: Homepage, https://github.com/algol60/sier2
+Project-URL: Homepage, https://github.com/sier2/sier2
 Description-Content-Type: text/x-rst
 
 Sier2
@@ -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.35 → sier2-0.40}/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.35 → sier2-0.40}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sier2"
-version = "0.35"
+version = "0.40"
 description = "Blocks of code that are executed in dags"
 authors = [
     {name="Algol60", email="algol60 <algol60@users.noreply.github.com>"}
@@ -21,20 +21,17 @@ classifiers = [
 [dependencies]
 python = "^3.11"
 
-holoviews = ">=1.19.0"
-panel = ">=1.4.4"
+panel = ">=1.6.3"
 param = ">=2.1.0"
 
 [[tool.mypy.overrides]]
 module = [
-    "holoviews",
-    "param",
-    "networkx",
+    "param"
 ]
 ignore_missing_imports = true
 
 [project.urls]
-Homepage = "https://github.com/algol60/sier2"
+Homepage = "https://github.com/sier2/sier2"
 
 [build-system]
 requires = ["poetry-core>=2.1.1"]

{sier2-0.35 → sier2-0.40}/src/sier2/_block.py

@@ -41,6 +41,20 @@ same input block be used immediately.) This causes the block's
 Dag execution then continues as normal.
 '''
 
+_VISIBLE_DOC = '''If True, the block will be visible in a GUI.
+
+A block may not need to be visible in a dag with a GUI. For example,
+it may be applying a pre-defined filter, or running an algorithm that
+takes an indeterminate amount of time. Setting this parameter to False
+tells the GUI not display this block. Dag execution will otherwise
+proceed as normal.
+
+This is also useful if a GUI application only requires a single block.
+A dag requires at least two blocks, because blocks can only be added
+by connecting them to another block. By making one block a "dummy"
+that is not visible, the GUI effectivly has a single block.
+'''
+
 class Block(param.Parameterized):
     """The base class for blocks.
 
@@ -82,17 +96,20 @@ class Block(param.Parameterized):
     """
 
     block_pause_execution = param.Boolean(default=False, label='Pause execution', doc=_PAUSE_EXECUTION_DOC)
+    block_visible = param.Boolean(default=True, label='Display block', doc=_VISIBLE_DOC)
 
     _block_state = param.String(default=BlockState.READY)
 
     SIER2_KEY = '_sier2__key'
 
-    def __init__(self, *args, block_pause_execution: bool=False, block_doc: str|None=None, continue_label='Continue', **kwargs):
+    def __init__(self, *args, block_pause_execution: bool=False, block_visible: bool=True, block_doc: str|None=None, continue_label='Continue', **kwargs):
         """
         Parameters
         ----------
         block_pause_execution: bool
             If True, ``prepare()`` is called and dag execution stops.
+        block_visible: bool
+            If True (the default), the block will be visible in a GUI.
         block_doc: str|None
             Markdown documentation that may displayed in the user interface.
         """
@@ -102,6 +119,7 @@ class Block(param.Parameterized):
             raise BlockError(f'Class {self.__class__} must have a docstring')
 
         self.block_pause_execution = block_pause_execution
+        self.block_visible = block_visible
         self.block_doc = block_doc
         self.continue_label = continue_label
         # self._block_state = BlockState.READY
@@ -119,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.35 → sier2-0.40}/src/sier2/_config.py

@@ -13,9 +13,37 @@ from typing import Any
 CONFIG_UPDATE = 'config_update'
 
 def _default_config_file():
+    """Determine the location of the config file sier2.ini.
+
+    If the environment variable ``SIER2_INI`` is set,
+    it specifies the path of the config file.
+
+    Otherwise, if Windows, use ``$env:APPDATA/sier2/sier2.ini``.
+
+    Otherwise, if ``XDG_CONFIG_HOME`` is set, use ``$XDG_CONFIG_HOME/sier2/sier2.ini``.
+
+    Otherwise, use ``$HOME/.config/sier2/sier2.ini``.
+
+    If not using ``SIER2_INI``, the ``sier2`` directory will be created
+    if it does not exist.
+
+    TODO don't create the sier2 directory until the ini file is written.
+    """
+
+    # If a config file has been explicitly set in an environment variable,
+    # use it.
+    #
+    ini = os.environ.get('SIER2_INI', None)
+    if ini:
+        return Path(ini)
+
     if os.name=='nt':
+        # Windows.
+        #
         prdir = Path(os.environ['APPDATA']) / 'sier2'
     else:
+        # Linux.
+        #
         prdir = os.environ.get('XDG_CONFIG_HOME', None)
         if prdir:
             prdir = Path(prdir)

{sier2-0.35 → sier2-0.40}/src/sier2/_dag.py

@@ -1,7 +1,6 @@
 from ._block import Block, BlockError, BlockValidateError, BlockState
 from dataclasses import dataclass, field #, KW_ONLY, field
-from collections import defaultdict, deque
-import holoviews as hv
+from collections import deque
 from importlib.metadata import entry_points
 import threading
 import sys
@@ -220,6 +219,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')
@@ -578,75 +586,6 @@ class Dag:
             'connections': connections
         }
 
-    def hv_graph(self):
-        """Build a HoloViews Graph 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 = self._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 no 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()
-
-        src_names = [g.name for g in src]
-        dst_names = [g.name for g in dst]
-        g = hv.Graph(((src_names, dst_names),))
-
-        return hv.element.graphs.layout_nodes(g, layout=layout)
-
 def topological_sort(pairs):
     """Implement a topological sort as described at
     `Topological sorting <https://en.wikipedia.org/wiki/Topological_sorting>`_.

sier2-0.40/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.35 → sier2-0.40}/src/sier2/panel/_panel.py

@@ -6,11 +6,14 @@ import sys
 import threading
 from typing import Callable
 
+import param.parameterized as paramp
+
 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 html_graph
 
 NTHREADS = 2
 
@@ -247,13 +250,18 @@ def _prepare_to_show(dag: Dag):
         card = pn.Card(pn.pane.Markdown(doc, sizing_mode='stretch_width'), header=pn.Row(name_text), sizing_mode='stretch_width')
         cards.append(card)
 
-    cards.extend(BlockCard(parent_template=template, dag=dag, w=gw, dag_logger=dag_logger) for gw in dag.get_sorted())
+    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.sidebar.append(
         pn.Column(
             switch,
-            pn.panel(dag.hv_graph().opts(invert_yaxis=True, xaxis=None, yaxis=None)),
+            # pn.panel(dag.hv_graph().opts(invert_yaxis=True, xaxis=None, yaxis=None)),
+            pn.Row(
+                pn.panel(html_graph(dag)), 
+                max_width=400, 
+                max_height=200,
+            ),
             log_feed,
             info_fp_holder
         )
@@ -428,10 +436,30 @@ 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)