sier2 0.40__tar.gz → 1.0.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sier2
-Version: 0.40
+Version: 1.0.0
 Summary: Blocks of code that are executed in dags
 Author: Algol60
 Author-email: algol60 <algol60@users.noreply.github.com>

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

@@ -1,6 +1,6 @@
 [project]
 name = "sier2"
-version = "0.40"
+version = "1.0.0"
 description = "Blocks of code that are executed in dags"
 authors = [
     {name="Algol60", email="algol60 <algol60@users.noreply.github.com>"}

{sier2-0.40 → 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.

{sier2-0.40 → 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)
 
@@ -304,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
@@ -340,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.
 
@@ -403,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-0.40 → sier2-1.0.0}/src/sier2/panel/_panel.py

@@ -4,9 +4,11 @@ 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
@@ -252,7 +254,7 @@ 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,
@@ -302,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.
@@ -464,4 +478,4 @@ class PanelDag(Dag):
         _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()