sier2 0.35__tar.gz → 0.37__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sier2
-Version: 0.35
+Version: 0.37
 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

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

@@ -1,6 +1,6 @@
 [project]
 name = "sier2"
-version = "0.35"
+version = "0.37"
 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"
 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.37}/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

{sier2-0.35 → sier2-0.37}/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.37}/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
@@ -578,75 +577,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.37/src/sier2/panel/_chart.py

@@ -0,0 +1,106 @@
+# 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

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

@@ -11,6 +11,7 @@ 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
 
 NTHREADS = 2
 
@@ -247,13 +248,14 @@ 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(bokeh_graph(dag)), max_width=400, max_height=200),
             log_feed,
             info_fp_holder
         )