sier2 0.23__tar.gz → 0.29__tar.gz

{sier2-0.23 → sier2-0.29}/PKG-INFO

@@ -1,23 +1,18 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: sier2
-Version: 0.23
+Version: 0.29
 Summary: Blocks of code that are executed in dags
-Author: algol60
-Author-email: algol60@users.noreply.github.com
-Requires-Python: >=3.11,<4.0
-Classifier: Intended Audience :: Developers
-Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
+Author: Algol60
+Author-email: algol60 <algol60@users.noreply.github.com>
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Software Development :: Libraries
-Requires-Dist: holoviews (>=1.19.0)
-Requires-Dist: panel (>=1.4.4)
-Requires-Dist: param (>=2.1.0)
+Project-URL: Homepage, https://github.com/algol60/sier2
 Description-Content-Type: text/x-rst
 
 Sier2

{sier2-0.23 → sier2-0.29}/pyproject.toml

@@ -1,8 +1,10 @@
-[tool.poetry]
+[project]
 name = "sier2"
-version = "0.23"
+version = "0.29"
 description = "Blocks of code that are executed in dags"
-authors = ["algol60 <algol60@users.noreply.github.com>"]
+authors = [
+    {name="Algol60", email="algol60 <algol60@users.noreply.github.com>"}
+]
 readme = "README.rst"
 packages = [{include = "sier2", from = "src"}]
 classifiers = [
@@ -16,7 +18,7 @@ classifiers = [
     "Topic :: Software Development :: Libraries"
 ]
 
-[tool.poetry.dependencies]
+[dependencies]
 python = "^3.11"
 
 holoviews = ">=1.19.0"
@@ -26,7 +28,8 @@ param = ">=2.1.0"
 [[tool.mypy.overrides]]
 module = [
     "holoviews",
-    "param"
+    "param",
+    "networkx",
 ]
 ignore_missing_imports = true
 
@@ -34,5 +37,5 @@ ignore_missing_imports = true
 Homepage = "https://github.com/algol60/sier2"
 
 [build-system]
-requires = ["poetry-core"]
+requires = ["poetry-core>=2.1.1"]
 build-backend = "poetry.core.masonry.api"

{sier2-0.23 → sier2-0.29}/src/sier2/__init__.py

@@ -1,4 +1,4 @@
-from ._block import Block, InputBlock, BlockError, BlockValidateError
+from ._block import Block, BlockError, BlockValidateError
 from ._dag import Connection, Dag, BlockState
 from ._library import Library, Info
 from ._version import __version__

{sier2-0.23 → sier2-0.29}/src/sier2/_block.py

@@ -27,6 +27,19 @@ class BlockState(StrEnum):
     INTERRUPTED = 'INTERRUPTED'
     ERROR = 'ERROR'
 
+_PAUSE_EXECUTION_DOC = '''If True, a block executes in two steps.
+
+When the block is executed by a dag, the dag first sets the input
+params, then calls ``prepare()``. Execution of the dag then stops.
+
+The dag is then restarted using ``dag.execute_after_input(input_block)``.
+(An input block must be specified because it is not required that the
+same input block be used immediately.) This causes the block's
+``execute()`` method to be called without resetting the input params.
+
+Dag execution then continues as normal.
+'''
+
 class Block(param.Parameterized):
     """The base class for blocks.
 
@@ -49,16 +62,19 @@ class Block(param.Parameterized):
                 print(f'New value is {self.value_in}')
     """
 
+    block_pause_execution = param.Boolean(default=False, label='Pause execution', doc=_PAUSE_EXECUTION_DOC)
+
     _block_state = param.String(default=BlockState.READY)
 
     SIER2_KEY = '_sier2__key'
 
-    def __init__(self, *args, continue_label='Continue', **kwargs):
+    def __init__(self, *args, block_pause_execution=False, continue_label='Continue', **kwargs):
         super().__init__(*args, **kwargs)
 
         if not self.__doc__:
             raise BlockError(f'Class {self.__class__} must have a docstring')
 
+        self.block_pause_execution = block_pause_execution
         self.continue_label = continue_label
         # self._block_state = BlockState.READY
         self.logger = _logger.get_logger(self.name)
@@ -77,7 +93,7 @@ class Block(param.Parameterized):
 
         # self._block_context = _EmptyContext()
 
-        self._progress = None
+        # self._progress = None
 
     @classmethod
     def block_key(cls):
@@ -95,6 +111,17 @@ class Block(param.Parameterized):
 
         return f'{im.__name__}.{cls.__qualname__}'
 
+    def prepare(self):
+        """If blockpause_execution is True, called by a dag before calling ``execute()```.
+
+        This gives the block author an opportunity to validate the
+        input params and set up a user inteface.
+
+        After the dag restarts on this block, ``execute()`` will be called.
+        """
+
+        pass
+
     def execute(self, *_, **__):
         """This method is called when one or more of the input parameters causes an event.
 
@@ -113,24 +140,24 @@ class Block(param.Parameterized):
         # print(f'** EXECUTE {self.__class__=}')
         pass
 
-    def __panel__(self):
-        """A default Panel component.
+    # def __panel__(self):
+    #     """A default Panel component.
 
-        When run in a Panel context, a block will typically implement
-        its own __panel__() method. If it doesn't, this method will be
-        used as a default. When a block without a __panel__() is wrapped
-        in a Card, self.progress will be assigned a pn.indicators.Progress()
-        widget which is returned here. The Panel context will make it active
-        before executing the block, and non-active after executing the block.
-        (Why not have a default Progress()? Because we don't want any
-        Panel-related code in the core implementation.)
+    #     When run in a Panel context, a block will typically implement
+    #     its own __panel__() method. If it doesn't, this method will be
+    #     used as a default. When a block without a __panel__() is wrapped
+    #     in a Card, self.progress will be assigned a pn.indicators.Progress()
+    #     widget which is returned here. The Panel context will make it active
+    #     before executing the block, and non-active after executing the block.
+    #     (Why not have a default Progress()? Because we don't want any
+    #     Panel-related code in the core implementation.)
 
-        If the block implements __panel__(), this will obviously be overridden.
+    #     If the block implements __panel__(), this will obviously be overridden.
 
-        When run in non-Panel context, this will remain unused.
-        """
+    #     When run in non-Panel context, this will remain unused.
+    #     """
 
-        return self._progress
+    #     return self._progress
 
     def __call__(self, **kwargs) -> dict[str, Any]:
         """Allow a block to be called directly."""
@@ -150,45 +177,45 @@ class Block(param.Parameterized):
 
         return result
 
-class InputBlock(Block):
-    """A ``Block`` that accepts user input.
+# class InputBlock(Block):
+#     """A ``Block`` that accepts user input.
 
-    An ``InputBlock`` executes in two steps().
+#     An ``InputBlock`` executes in two steps().
 
-    When the block is executed by a dag, the dag first sets the input
-     params, then calls ``prepare()``. Execution of the dag then stops.
+#     When the block is executed by a dag, the dag first sets the input
+#      params, then calls ``prepare()``. Execution of the dag then stops.
 
-    The dag is then restarted using ``dag.execute_after_input(input_block)``.
-    (An input block must be specified because it is not required that the
-    same input block be used immediately.) This causes the block's
-    ``execute()`` method to be called without resetting the input params.
+#     The dag is then restarted using ``dag.execute_after_input(input_block)``.
+#     (An input block must be specified because it is not required that the
+#     same input block be used immediately.) This causes the block's
+#     ``execute()`` method to be called without resetting the input params.
 
-    Dag execution then continues as normal.
-    """
+#     Dag execution then continues as normal.
+#     """
 
-    def __init__(self, *args, continue_label='Continue', **kwargs):
-        super().__init__(*args, continue_label=continue_label, **kwargs)
-        self._block_state = BlockState.INPUT
+#     def __init__(self, *args, continue_label='Continue', **kwargs):
+#         super().__init__(*args, continue_label=continue_label, **kwargs)
+#         self._block_state = BlockState.INPUT
 
-    def prepare(self):
-        """Called by a dag before calling ``execute()```.
+#     def prepare(self):
+#         """Called by a dag before calling ``execute()```.
 
-        This gives the block author an opportunity to validate the
-        input params and set up a user inteface.
+#         This gives the block author an opportunity to validate the
+#         input params and set up a user inteface.
 
-        After the dag restarts on this block, ``execute()`` will be called.
-        """
+#         After the dag restarts on this block, ``execute()`` will be called.
+#         """
 
-        pass
+#         pass
 
 class BlockValidateError(BlockError):
-    """Raised if ``InputBlock.prepare()`` or ``Block.execute()`` determines that input data is invalid.
+    """Raised if ``Block.prepare()`` or ``Block.execute()`` determines that input data is invalid.
 
     If this exception is raised, it will be caught by the executing dag.
     The dag will not set its stop flag, no stacktrace will be displayed,
     and the error message will be displayed.
     """
 
-    def __init__(self, block_name: str, error: str):
+    def __init__(self, *, block_name: str, error: str):
         super().__init__(error)
         self.block_name = block_name

{sier2-0.23 → sier2-0.29}/src/sier2/_dag.py

@@ -1,8 +1,10 @@
-from ._block import Block, InputBlock, BlockError, BlockValidateError, BlockState
+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 importlib.metadata import entry_points
 import threading
+import sys
 from typing import Any
 
 # By default, loops in a dag aren't allowed.
@@ -67,10 +69,11 @@ class _BlockContext:
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         if exc_type is None:
-            self.block._block_state = BlockState.WAITING if isinstance(self.block, InputBlock) else BlockState.SUCCESSFUL
+            self.block._block_state = BlockState.WAITING if self.block.block_pause_execution else BlockState.SUCCESSFUL
         elif exc_type is KeyboardInterrupt:
             self.block_state._block_state = BlockState.INTERRUPTED
-            self.dag._stopper.event.set()
+            if not self.dag._is_pyodide:
+                self.dag._stopper.event.set()
             print(f'KEYBOARD INTERRUPT IN BLOCK {self.name}')
         else:
             state = BlockState.ERROR
@@ -87,7 +90,8 @@ class _BlockContext:
 
                 # msg = f'While in {self.block.name}.execute(): {exc_val}'
                 # LOGGER.exception(msg)
-                self.dag._stopper.event.set()
+                if not self.dag._is_pyodide:
+                    self.dag._stopper.event.set()
 
                 if not issubclass(exc_type, BlockError):
                     # Convert non-BlockErrors in the block to a BlockError.
@@ -113,16 +117,51 @@ class _Stopper:
     def __repr__(self):
         return f'stopped={self.is_stopped}'
 
+def _find_logging():
+    PLUGIN_GROUP = 'sier2.logging'
+    library = entry_points(group=PLUGIN_GROUP)
+    if (liblen:=len(library))==0:
+        # There is no logging plugin, so return a dummy.
+        #
+        return lambda f, *args, **kwargs: f
+    elif liblen>1:
+        raise BlockError(f'More than one plugin for {PLUGIN_GROUP}')
+
+    ep = next(iter(library))
+    try:
+        logging_func = ep.load()
+
+        return logging_func
+    except AttributeError as e:
+        e.add_note(f'While attempting to load logging function {ep.value}')
+        raise BlockError(e)
+
+# A marker from Dag.execute_after_input() to tell Dag.execute()
+# that this a restart.
+#
+_RESTART = ':restart:'
+
 class Dag:
     """A directed acyclic graph of blocks."""
 
-    def __init__(self, *, site: str='Block', title: str, doc: str):
+    def __init__(self, *, site: str='Block', title: str, doc: str, author: dict[str, str]=None):
         self._block_pairs: list[tuple[Block, Block]] = []
-        self._stopper = _Stopper()
+
         self.site = site
         self.title = title
         self.doc = doc
 
+        if author is not None:
+            if 'name' in author and 'email' in author:
+                self.author = {'name': author['name', 'email': author: 'email']}
+            else:
+                raise ValueError('Author must contain name and email keys')
+        else:
+            self.author = None
+
+        if not self._is_pyodide:
+            self._stopper = _Stopper()
+
         # We watch output params to be notified when they are set.
         # Events are queued here.
         #
@@ -132,6 +171,14 @@ class Dag:
         #
         self._block_context = _BlockContext
 
+        # Set up the logging hook.
+        #
+        self.logging = _find_logging()
+
+    @property
+    def _is_pyodide(self) -> bool:
+        return '_pyodide' in sys.modules
+
     def _for_each_once(self):
         """Yield each connected block once."""
 
@@ -144,13 +191,13 @@ class Dag:
 
     def stop(self):
         """Stop further execution of Block instances in this dag."""
-
-        self._stopper.event.set()
+        if not self._is_pyodide:
+            self._stopper.event.set()
 
     def unstop(self):
         """Enable further execution of Block instances in this dag."""
-
-        self._stopper.event.clear()
+        if not self._is_pyodide:
+            self._stopper.event.clear()
 
     def connect(self, src: Block, dst: Block, *connections: Connection):
         if any(not isinstance(c, Connection) for c in connections):
@@ -231,7 +278,7 @@ class Dag:
                 item.values[inp] = new
                 self._block_queue.append(item)
 
-    def execute_after_input(self, block: InputBlock, *, dag_logger=None):
+    def execute_after_input(self, block: Block, *, dag_logger=None):
         """Execute the dag after running ``prepare()`` in an input block.
 
         After prepare() executes, and the user has possibly
@@ -243,23 +290,23 @@ class Dag:
 
         Parameters
         ----------
-        block: InputBlock
+        block: Block
             The block to restart the dag at.
         dag_logger:
             A logger adapter that will accept log messages.
         """
 
-        if not isinstance(block, InputBlock):
-            raise BlockError(f'A dag can only restart an InputBlock, not {block.name}')
+        if not block.block_pause_execution:
+            raise BlockError(f'A dag can only restart a paused Block, not {block.name}')
 
-        # Prime the block queue, using an empty input param values dict
+        # Prime the block queue, using _RESTART
         # to indicate that this is a restart, and Block.execute()
         # must be called.
         #
-        self._block_queue.appendleft(_InputValues(block, {}))
+        self._block_queue.appendleft(_InputValues(block, {_RESTART: True}))
         self.execute(dag_logger=dag_logger)
 
-    def execute(self, *, dag_logger=None):
+    def execute(self, *, dag_logger=None) -> Block|None:
         """Execute the dag.
 
         The dag is executed by iterating through the block event queue
@@ -267,38 +314,54 @@ class Dag:
         update the destination block's input parameters and call
         that block's execute() method.
 
-        If the current destination block is an ``InputBlock``,
+        If the current destination block's ``block_pause_execution` is True,
         the loop will call ``block.prepare()` instead of ``block.execute()``,
-        then stop. The dag can then be restarted with
-        ``dag.execute_after_input()``.
-
-        To start the dag, there must be something in the event queue -
-        the dag must be "primed". A block must have updated at least one
-        output param before the dag's execute() is called. Calling
-        ``dag.execute()`` will then execute the dag starting with
-        the blocks connected to the first block.
+        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.
+
+        To start the dag, either:
+        - there must be something in the event queue - the dag must be "primed". A block must have updated at least one output param before the dag's execute() is called;
+        - the first block in the dag must be an input block (block_pause_execution=True).
+
+        Calling ``dag.execute()`` will then execute the dag starting with the relevant block.
         """
 
+        if not self._block_queue:
+            # If there aren't any blocks on the queue, find the first block in the dag.
+            # If this block is an input block, put it on the queue.
+            #
+            sorted_blocks = self.get_sorted()
+            if sorted_blocks:
+                first = sorted_blocks[0]
+                if first.block_pause_execution:
+                    self._block_queue.appendleft(_InputValues(first, {}))
+
         if not self._block_queue:
             # Attempting to execute a dag with no updates is probably a mistake.
             #
             raise BlockError('Nothing to execute')
 
+        self.logging(None, sier2_dag_=self)
+
         can_execute = True
         while self._block_queue:
             # print(len(self._block_queue), self._block_queue)
             # The user has set the "stop executing" flag.
             # Continue to set params, but don't execute anything
             #
-            if self._stopper.is_stopped:
-                can_execute = False
+            if not self._is_pyodide:
+                if self._stopper.is_stopped:
+                    can_execute = False
 
             item = self._block_queue.popleft()
+            is_restart = item.values.pop(_RESTART, False)
             try:
                 item.dst.param.update(item.values)
             except ValueError as e:
                 msg = f'While in {item.dst.name} setting a parameter: {e}'
-                self._stopper.event.set()
+                if not self._is_pyodide:
+                    self._stopper.event.set()
                 raise BlockError(msg) from e
 
             # Execute the block.
@@ -306,18 +369,27 @@ class Dag:
             # unless this is after the user has selected the "Continue"
             # button.
             #
-            is_input_block = isinstance(item.dst, InputBlock)
+            is_input_block = item.dst.block_pause_execution
             if can_execute:
                 with self._block_context(block=item.dst, dag=self, dag_logger=dag_logger) as g:
+
+                    logging_params = {
+                        'sier2_dag_': self,
+                        '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 item.values:
-                        g.prepare()
+                    if is_input_block and not is_restart:# and item.values:
+                        self.logging(g.prepare, **logging_params)()
                     else:
-                        g.execute()
+                        self.logging(g.execute, **logging_params)()
 
-            if is_input_block and item.values:
+            # 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
                 # want to be setting the input params of further blocks
@@ -326,7 +398,9 @@ class Dag:
                 # This possibly leaves items on the queue, which will be
                 # executed on the next call to execute().
                 #
-                break
+                return item.dst
+
+        return None
 
     def disconnect(self, g: Block) -> None:
         """Disconnect block g from other blocks.
@@ -372,7 +446,7 @@ class Dag:
 
         return None
 
-    def get_sorted(self):
+    def get_sorted(self) -> list[Block]:
         """Return the blocks in this dag in topological order.
 
         This is useful for arranging the blocks in a GUI, for example.
@@ -611,7 +685,7 @@ def _has_cycle(block_pairs: list[tuple[Block, Block]]):
 
     return len(remaining)>0
 
-def _get_sorted(block_pairs: list[tuple[Block, Block]]):
+def _get_sorted(block_pairs: list[tuple[Block, Block]]) -> list[Block]:
     ordered, remaining = topological_sort(block_pairs)
 
     if remaining:

{sier2-0.23 → sier2-0.29}/src/sier2/_library.py

@@ -24,6 +24,29 @@ def docstring(func) -> str:
 
     return doc.split('\n')[0].strip()
 
+def _import_item(key):
+    """Look up an object by key.
+
+    The returned object may be a class (if a Block key) or a function (if a dag key).
+
+    See the Entry points specification at
+    https://packaging.python.org/en/latest/specifications/entry-points/#entry-points.
+    """
+
+    modname, qualname_separator, qualname = key.partition(':')
+    try:
+        obj = importlib.import_module(modname)
+        if qualname_separator:
+            for attr in qualname.split('.'):
+                obj = getattr(obj, attr)
+
+        return obj
+    except ModuleNotFoundError as e:
+        msg = str(e)
+        if not qualname_separator:
+            msg = f'{msg}. Is there a \':\' missing?'
+        raise BlockError(msg)
+
 def _find_blocks():
     yield from _find('blocks')
 
@@ -143,8 +166,6 @@ class Library:
         if not issubclass(block_class, Block):
             print(f'{key} is not a Block')
 
-        # if not key:
-        #     key = block_class.block_key()
         key_ = key if key else block_class.block_key()
 
         if key_ in _block_library:
@@ -161,9 +182,7 @@ class Library:
             raise BlockError(f'Block name {key} is not in the library')
 
         if _block_library[key] is None:
-            ix = key.rfind('.')
-            m = importlib.import_module(key[:ix])
-            cls = getattr(m, key[ix+1:])
+            cls = _import_item(key)
             if not issubclass(cls, Block):
                 raise BlockError(f'{key} is not a block')
 
@@ -188,9 +207,7 @@ class Library:
             raise BlockError(f'Dag name {key} is not in the library')
 
         if key in _dag_library:
-            ix = key.rfind('.')
-            m = importlib.import_module(key[:ix])
-            func = getattr(m, key[ix+1:])
+            func = _import_item(key)
             dag = func()
             if not isinstance(dag, Dag):
                 raise BlockError(f'{key} is not a dag')

{sier2-0.23 → sier2-0.29}/src/sier2/panel/_panel.py

@@ -4,8 +4,9 @@ import html
 import panel as pn
 import sys
 import threading
+from typing import Callable
 
-from sier2 import Block, InputBlock, BlockValidateError, BlockState, Dag, BlockError
+from sier2 import Block, BlockValidateError, BlockState, Dag, BlockError
 from .._dag import _InputValues
 from ._feedlogger import getDagPanelLogger, getBlockPanelLogger
 from ._panel_util import _get_state_color, dag_doc
@@ -22,7 +23,26 @@ INFO_SVG = '''<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" vie
 </svg>
 '''
 
-pn.extension('floatpanel', inline=True, nthreads=NTHREADS, loading_spinner='bar', notifications=True)
+if '_pyodide' in sys.modules:
+    # Pyodide (to be specific, WASM) doesn't allow threads.
+    # Specifying one thread for panel for some reason tries to start one, so we need to rely on the default.
+    #
+    pn.extension(
+        'floatpanel',
+        inline=True,
+        loading_spinner='bar',
+        notifications=True,
+    )
+else:
+    pn.extension(
+        'floatpanel',
+        inline=True,
+        nthreads=NTHREADS,
+        loading_spinner='bar',
+        notifications=True,
+    )
+
+
 
 def _hms(sec):
     h, sec = divmod(int(sec), 3600)
@@ -54,26 +74,27 @@ class _PanelContext:
         block_logger = getBlockPanelLogger(self.block.name)
         self.block.logger = block_logger
 
-        if self.block._progress:
-            self.block._progress.active = True
+        # if self.block._progress:
+        #     self.block._progress.active = True
 
         return self.block
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         delta = (datetime.now() - self.t0).total_seconds()
 
-        if self.block._progress:
-            self.block._progress.active = False
+        # if self.block._progress:
+        #     self.block._progress.active = False
 
         if exc_type is None:
-            state = BlockState.WAITING if isinstance(self.block, InputBlock) else BlockState.SUCCESSFUL
+            state = BlockState.WAITING if self.block.block_pause_execution else BlockState.SUCCESSFUL
             self.block._block_state = state
             if self.dag_logger:
                 self.dag_logger.info(f'after {_hms(delta)}', block_name=self.block.name, block_state=state.value)
         elif isinstance(exc_type, KeyboardInterrupt):
             state = BlockState.INTERRUPTED
             self.block_state._block_state = state
-            self.dag._stopper.event.set()
+            if not self.dag._is_pyodide:
+                self.dag._stopper.event.set()
             if self.dag_logger:
                 self.dag_logger.exception(f'KEYBOARD INTERRUPT after {_hms(delta)}', block_name=self.block.name, block_state=state)
         else:
@@ -88,13 +109,13 @@ class _PanelContext:
                     )
 
                 # msg = f'While in {self.block.name}.execute(): {exc_val}'
-                self.dag._stopper.event.set()
+                if not self.dag._is_pyodide:
+                    self.dag._stopper.event.set()
 
                 if not issubclass(exc_type, BlockError):
                     # Convert the error in the block to a BlockError.
                     #
                     raise BlockError(f'Block {self.block.name}: {str(exc_val)}') from exc_val
-
         return False
 
 def _quit(session_context):
@@ -116,7 +137,7 @@ def interrupt_thread(tid, exctype):
         #
         ctypes.pythonapi.PyThreadState_SetAsyncExc(ctypes.c_ulong(tid), None)
         raise SystemError('PyThreadState_SetAsyncExc failed')
-        
+
 def _prepare_to_show(dag: Dag):
     # Replace the default text-based context with the panel-based context.
     #
@@ -227,6 +248,13 @@ def _show_dag(dag: Dag):
 
     pn.state.on_session_destroyed(_quit)
 
+    # Execute the dag.
+    # Since this is a panel dag, we expect the first block to be an input nlock.
+    # This ensures that the first block's prepare() method is called.
+    # If the first block is not an input block, it must be primed, just like a plain dag.
+    #
+    dag.execute()
+
     template.show(threaded=False)
 
 def _serveable_dag(dag: Dag):
@@ -236,8 +264,25 @@ def _serveable_dag(dag: Dag):
 
     pn.state.on_session_destroyed(_quit)
 
+    # Execute the dag.
+    # Since this is a panel dag, we expect the first block to be an input nlock.
+    # This ensures that the first block's prepare() method is called.
+    # If the first block is not an input block, it must be primed, just like a plain dag.
+    #
+    dag.execute()
+
     template.servable()
 
+def _default_panel(self) -> Callable[[Block], pn.Param]:
+    """Provide a default __panel__() implementation for blocks that don't have one.
+
+    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)
+
 class BlockCard(pn.Card):
     """A custom card to wrap around a block.
 
@@ -274,19 +319,22 @@ class BlockCard(pn.Card):
         # inspect the class and display the param attributes.
         # This is obviously not what we want.
         #
-        # Instead, we want to display an indefinite progress bar.
-        # The Panel context manager will activate and deactivate it.
+        # We just want to display the in_ params.
         #
         has_panel = '__panel__' in w.__class__.__dict__
         if not has_panel:
-            w._progress = pn.indicators.Progress(
-                name='Block progress',
-                bar_color='primary',
-                active=False,
-                value=-1
-            )
+            # w._progress = pn.indicators.Progress(
+            #     name='Block progress',
+            #     bar_color='primary',
+            #     active=False,
+            #     value=-1
+            # )
+
+            # Go go gadget descriptor protocol.
+            #
+            w.__panel__ = _default_panel.__get__(w)
 
-        if isinstance(w, InputBlock):
+        if w.block_pause_execution:
             # This is an input block, so add a 'Continue' button.
             #
             def on_continue(_event):
@@ -296,8 +344,9 @@ class BlockCard(pn.Card):
                 # current values on the queue.
                 # If their values are already there, it doesn't matter.
                 #
-                w.param.trigger(*w._block_out_params)
                 parent_template.main[0].loading = True
+                w.param.trigger(*w._block_out_params)
+
                 try:
                     if dag_logger:
                         dag_logger.info('', block_name=None, block_state=None)
@@ -320,7 +369,6 @@ class BlockCard(pn.Card):
                         pn.state.notifications.error(notif, duration=0)
                 finally:
                     parent_template.main[0].loading = False
-
             c_button = pn.widgets.Button(name=w.continue_label, button_type='primary')
             c_button.on_click(on_continue)