roadshow 0.1.0__tar.gz

roadshow-0.1.0/LICENSE.md

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright (c) `2026` `Tucker Beck`
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

roadshow-0.1.0/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: roadshow
+Version: 0.1.0
+Summary: A reusable framework for interactive Python demos
+Author: Tucker Beck
+Author-email: Tucker Beck <tucker.beck@gmail.com>
+License-File: LICENSE.md
+Requires-Dist: py-buzz>=9.0.1
+Requires-Dist: rich>=14.0
+Requires-Dist: typer>=0.24.1
+Requires-Python: >=3.11
+Project-URL: homepage, https://github.com/dusktreader/roadshow
+Project-URL: source, https://github.com/dusktreader/roadshow
+Project-URL: changelog, https://github.com/dusktreader/roadshow/blob/main/CHANGELOG.md
+Description-Content-Type: text/markdown
+
+[![Latest Version](https://img.shields.io/pypi/v/roadshow?label=pypi-version&logo=python&style=plastic)](https://pypi.org/project/roadshow/)
+[![Python Versions](https://img.shields.io/python/required-version-toml?tomlFilePath=https%3A%2F%2Fraw.githubusercontent.com%2Fdusktreader%2Froadshow%2Fmain%2Fpyproject.toml&style=plastic&logo=python&label=python-versions)](https://www.python.org/)
+[![Build Status](https://github.com/dusktreader/roadshow/actions/workflows/main.yml/badge.svg)](https://github.com/dusktreader/roadshow/actions/workflows/main.yml)
+[![Documentation Status](https://github.com/dusktreader/roadshow/actions/workflows/docs.yml/badge.svg)](https://dusktreader.github.io/roadshow/)
+
+
+![roadshow-logo](https://github.com/dusktreader/roadshow/blob/main/docs/source/static/roadshow-text.png)
+
+Roadshow makes it easy to demonstrate your project's capabilities in a cli with rich output.
+
+[Documentation](http://dusktreader.github.io/roadshow/)
+
+
+## Super-quick Start
+
+Requires: Python 3.11 to 3.15
+
+Install through pip:
+
+```shell
+pip install roadshow
+```
+
+
+## Documentation
+
+The complete documentation can be found at the
+[roadshow home page](https://dusktreader.github.io/roadshow)
+
+
+## Demo
+
+To see the features in action, you can run the demo in an isolated environment with `uv`:
+
+```text
+uvx roadshow-demo
+```

roadshow-0.1.0/README.md

@@ -0,0 +1,37 @@
+[![Latest Version](https://img.shields.io/pypi/v/roadshow?label=pypi-version&logo=python&style=plastic)](https://pypi.org/project/roadshow/)
+[![Python Versions](https://img.shields.io/python/required-version-toml?tomlFilePath=https%3A%2F%2Fraw.githubusercontent.com%2Fdusktreader%2Froadshow%2Fmain%2Fpyproject.toml&style=plastic&logo=python&label=python-versions)](https://www.python.org/)
+[![Build Status](https://github.com/dusktreader/roadshow/actions/workflows/main.yml/badge.svg)](https://github.com/dusktreader/roadshow/actions/workflows/main.yml)
+[![Documentation Status](https://github.com/dusktreader/roadshow/actions/workflows/docs.yml/badge.svg)](https://dusktreader.github.io/roadshow/)
+
+
+![roadshow-logo](https://github.com/dusktreader/roadshow/blob/main/docs/source/static/roadshow-text.png)
+
+Roadshow makes it easy to demonstrate your project's capabilities in a cli with rich output.
+
+[Documentation](http://dusktreader.github.io/roadshow/)
+
+
+## Super-quick Start
+
+Requires: Python 3.11 to 3.15
+
+Install through pip:
+
+```shell
+pip install roadshow
+```
+
+
+## Documentation
+
+The complete documentation can be found at the
+[roadshow home page](https://dusktreader.github.io/roadshow)
+
+
+## Demo
+
+To see the features in action, you can run the demo in an isolated environment with `uv`:
+
+```text
+uvx roadshow-demo
+```

roadshow-0.1.0/pyproject.toml

@@ -0,0 +1,87 @@
+[project]
+name = "roadshow"
+version = "0.1.0"
+description = "A reusable framework for interactive Python demos"
+readme = "README.md"
+license-files = ["LICENSE.md"]
+requires-python = ">=3.11"
+dependencies = [
+    "py-buzz>=9.0.1",
+    "rich>=14.0",
+    "typer>=0.24.1",
+]
+
+[[project.authors]]
+name = "Tucker Beck"
+email = "tucker.beck@gmail.com"
+
+[project.urls]
+homepage = "https://github.com/dusktreader/roadshow"
+source = "https://github.com/dusktreader/roadshow"
+changelog = "https://github.com/dusktreader/roadshow/blob/main/CHANGELOG.md"
+
+[project.scripts]
+roadshow-demo = "roadshow_demo.main:main"
+
+[dependency-groups]
+dev = [
+    "debugpy>=1.8",
+    "ipython>=8.18",
+    "mkdocstrings[python]>=0.29",
+    "pyclean>=3.1",
+    "pygments>=2.19",
+    "pytest>=8.3",
+    "pytest-bdd>=7.0",
+    "pytest-cov>=6.0",
+    "pytest-mock>=3.14",
+    "pytest-pretty>=1.2",
+    "pytest-random-order>=1.1",
+    "ruff>=0.11",
+    "ty>=0.0",
+    "typos>=1.31",
+    "zensical>=0.1.0",
+]
+
+[tool.uv]
+package = true
+
+[tool.pytest.ini_options]
+addopts = [
+    "--random-order",
+    "--cov=src/roadshow",
+    "--cov-report=term-missing",
+    "--cov-fail-under=85",
+    "--cov-report=xml:.coverage.xml",
+    "--junitxml=.junit.xml",
+    "--override-ini=junit_family=legacy",
+]
+testpaths = ["tests"]
+python_files = [
+    "test_*.py",
+    "*_steps.py",
+]
+markers = [
+    "integration: Integration tests that exercise the real package with no mocking",
+    "unit: Fast unit tests with all external dependencies mocked",
+]
+
+[tool.ruff]
+line-length = 120
+src = [
+    "src/roadshow",
+    "tests",
+    "src/roadshow_demo",
+]
+
+[tool.ruff.lint.per-file-ignores]
+"src/roadshow/core.py" = ["BLE001"]
+
+[tool.ruff.format]
+docstring-code-format = true
+
+[tool.typos.default]
+extend-ignore-identifiers-re = []
+
+[build-system]
+requires = ["uv-build>=0.1.0"]
+build-backend = "uv_build"

roadshow-0.1.0/pyproject.toml.orig

@@ -0,0 +1,89 @@
+[project]
+name = "roadshow"
+version = "0.1.0"
+description = "A reusable framework for interactive Python demos"
+authors = [
+    {name = "Tucker Beck", email ="tucker.beck@gmail.com"},
+]
+readme = "README.md"
+license-files = ["LICENSE.md"]
+
+requires-python = ">=3.11"
+dependencies = [
+    "py-buzz>=9.0.1",
+    "rich>=14.0",
+    "typer>=0.24.1",
+]
+
+
+[project.urls]
+homepage = "https://github.com/dusktreader/roadshow"
+source = "https://github.com/dusktreader/roadshow"
+changelog = "https://github.com/dusktreader/roadshow/blob/main/CHANGELOG.md"
+
+
+[project.scripts]
+roadshow-demo = "roadshow_demo.main:main"
+
+
+
+[dependency-groups]
+dev = [
+    "debugpy>=1.8",
+    "ipython>=8.18",
+    "mkdocstrings[python]>=0.29",
+    "pyclean>=3.1",
+    "pygments>=2.19",
+    "pytest>=8.3",
+    "pytest-bdd>=7.0",
+    "pytest-cov>=6.0",
+    "pytest-mock>=3.14",
+    "pytest-pretty>=1.2",
+    "pytest-random-order>=1.1",
+    "ruff>=0.11",
+    "ty>=0.0",
+    "typos>=1.31",
+    "zensical>=0.1.0",
+]
+
+
+[tool.uv]
+package = true
+
+
+[tool.pytest.ini_options]
+addopts = [
+    "--random-order",
+    "--cov=src/roadshow",
+    "--cov-report=term-missing",
+    "--cov-fail-under=85",
+    "--cov-report=xml:.coverage.xml",
+    "--junitxml=.junit.xml",
+    "--override-ini=junit_family=legacy",
+]
+testpaths = ["tests"]
+python_files = ["test_*.py", "*_steps.py"]
+markers = [
+    "integration: Integration tests that exercise the real package with no mocking",
+    "unit: Fast unit tests with all external dependencies mocked",
+]
+
+
+[tool.ruff]
+line-length = 120
+src = ["src/roadshow", "tests", "src/roadshow_demo"]
+
+[tool.ruff.lint.per-file-ignores]
+"src/roadshow/core.py" = ["BLE001"]
+
+[tool.ruff.format]
+docstring-code-format = true
+
+
+[tool.typos.default]
+extend-ignore-identifiers-re = []
+
+
+[build-system]
+requires = ["uv-build>=0.1.0"]
+build-backend = "uv_build"

roadshow-0.1.0/src/roadshow/__init__.py

@@ -0,0 +1,19 @@
+from roadshow.app import Roadshow
+from roadshow.core import DemoDetails, DemoFunction, DemoResult, capture_demo, decompose_demo, demo, discover_demos
+from roadshow.errors import RoadshowError
+from roadshow.version import get_version
+
+__version__ = get_version()
+
+__all__ = [
+    "DemoDetails",
+    "DemoFunction",
+    "DemoResult",
+    "Roadshow",
+    "RoadshowError",
+    "__version__",
+    "capture_demo",
+    "decompose_demo",
+    "demo",
+    "discover_demos",
+]

roadshow-0.1.0/src/roadshow/app.py

@@ -0,0 +1,144 @@
+"""Build and run tagged demo applications."""
+
+from __future__ import annotations
+
+import pkgutil
+from collections import defaultdict
+from importlib import import_module
+from types import ModuleType
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.prompt import Confirm
+
+from roadshow.core import _DEMO_FEATURE_ATTRIBUTE, DemoFunction, discover_demos
+from roadshow.errors import RoadshowError
+from roadshow.render import display_demo
+
+
+class Roadshow:
+    """Discover tagged demos in a package and expose them through a Typer CLI."""
+
+    def __init__(self, package: str | ModuleType, *, title: str | None = None):
+        """Create a Roadshow app for one package or module."""
+        self.package = package
+        self.package_name = package if isinstance(package, str) else package.__name__
+        self.title = title or self.package_name
+
+    def discover(self) -> dict[str, list[DemoFunction]]:
+        """Import the package's modules and group their demos by feature tag."""
+        if isinstance(self.package, str):
+            with RoadshowError.handle_errors(f"Could not import demo package {self.package!r}"):
+                root_module = import_module(self.package)
+        else:
+            root_module = self.package
+
+        modules = [root_module]
+        package_path = getattr(root_module, "__path__", None)
+        if package_path is not None:
+            with RoadshowError.handle_errors(f"Could not discover demo modules in {root_module.__name__!r}"):
+                module_infos = list(pkgutil.walk_packages(package_path, f"{root_module.__name__}."))
+            for module_info in module_infos:
+                with RoadshowError.handle_errors(f"Could not import demo module {module_info.name!r}"):
+                    modules.append(import_module(module_info.name))
+
+        feature_map: defaultdict[str, list[DemoFunction]] = defaultdict(list)
+        for module in modules:
+            for function in discover_demos(module):
+                feature = function.__dict__[_DEMO_FEATURE_ATTRIBUTE]
+                feature_map[feature].append(function)
+
+        return {
+            feature: sorted(demos, key=lambda function: (function.__module__, function.__name__))
+            for feature, demos in sorted(feature_map.items())
+        }
+
+    def run(self) -> None:
+        """Start the Typer CLI for this Roadshow app."""
+        typer.run(self.start)
+
+    def start(
+        self,
+        feature: Annotated[
+            list[str] | None,
+            typer.Option(
+                "--feature",
+                "-f",
+                help="Features to run. Repeat this option to select multiple features; omit it to run all features.",
+            ),
+        ] = None,
+        non_interactive: Annotated[
+            bool,
+            typer.Option("--non-interactive", help="Run all selected demos without prompts."),
+        ] = False,
+    ) -> None:
+        """Run the selected demo features and report captured failures."""
+        all_features = self.discover()
+        selected_features = list(dict.fromkeys(feature or all_features))
+        unknown_features = sorted(set(selected_features) - all_features.keys())
+        if unknown_features:
+            available = ", ".join(all_features) or "none"
+            raise typer.BadParameter(f"Unknown feature tag(s): {', '.join(unknown_features)}. Available: {available}")
+
+        greeting_lines = [
+            f"This program shows the demos available in `{self.title}`.",
+            "",
+            "Selected features:",
+        ]
+        for selected_feature in selected_features:
+            greeting_lines.append(f"- `{selected_feature}`")
+            greeting_lines.extend(f"  - `{function.__name__}()`" for function in all_features[selected_feature])
+        if not selected_features:
+            greeting_lines.append("- No tagged demos found.")
+
+        console = Console()
+        console.print(
+            Panel(
+                Markdown("\n".join(greeting_lines)),
+                title=f"[green]Welcome to {self.title}[/green]",
+                title_align="left",
+                padding=1,
+                border_style="green",
+            )
+        )
+        console.print()
+        console.print()
+        if not non_interactive and not Confirm.ask("Would you like to continue?", default=True):
+            return
+
+        demos_to_run = [
+            (selected_feature, function)
+            for selected_feature in selected_features
+            for function in all_features[selected_feature]
+        ]
+        total_demos = len(demos_to_run)
+        failed = False
+        for demo_number, (selected_feature, function) in enumerate(demos_to_run, start=1):
+            console.clear()
+            result = display_demo(
+                function,
+                console,
+                label=selected_feature,
+                progress=(demo_number, total_demos),
+            )
+            failed |= not result.succeeded
+            if not non_interactive and not Confirm.ask("Would you like to continue?", default=True):
+                break
+
+        console.clear()
+        console.print(
+            Panel(
+                f"Thanks for checking out {self.title}.",
+                title="[green]Done[/green]",
+                title_align="left",
+                padding=1,
+                border_style="green",
+            )
+        )
+        console.print()
+        console.print()
+        if failed and non_interactive:
+            raise typer.Exit(1)

roadshow-0.1.0/src/roadshow/core.py

@@ -0,0 +1,208 @@
+"""Discover, inspect, and capture Python demo functions."""
+
+from __future__ import annotations
+
+import ast
+import inspect
+import io
+import os
+import sys
+import tempfile
+import textwrap
+from collections.abc import Callable, Sequence
+from contextlib import ExitStack, redirect_stderr, redirect_stdout
+from dataclasses import dataclass
+from pathlib import Path
+from types import FunctionType, ModuleType
+from unittest.mock import patch
+
+from roadshow.errors import RoadshowError
+
+DemoFunction = FunctionType
+
+
+@dataclass(frozen=True)
+class DemoDetails:
+    """Store the displayable parts of a demo function."""
+
+    module: str
+    name: str
+    docstring: str
+    source: str
+
+
+@dataclass
+class DemoResult:
+    """Store output and failures captured while running a demo."""
+
+    error: Exception | None = None
+    stdout: str | None = None
+    stderr: str | None = None
+    exit_code: int | str | None = None
+
+    @property
+    def succeeded(self) -> bool:
+        """Return whether the demo completed without an error or nonzero exit."""
+        return self.error is None and self.exit_code in (None, 0)
+
+
+_DEMO_FEATURE_ATTRIBUTE = "__roadshow_feature__"
+_DEMO_BEFORE_ATTRIBUTE = "__roadshow_before__"
+_DEMO_AFTER_ATTRIBUTE = "__roadshow_after__"
+_DEMO_INPUT_TEXT_ATTRIBUTE = "__roadshow_input_text__"
+_DEMO_ARGV_ATTRIBUTE = "__roadshow_argv__"
+
+
+def demo(
+    feature: str,
+    *,
+    before: Callable[[], object] | None = None,
+    after: Callable[[], object] | None = None,
+    input_text: str = "",
+    argv: Sequence[str] = (),
+) -> Callable[[DemoFunction], DemoFunction]:
+    """Mark a function as a demo and attach its feature, hooks, and input fixtures."""
+    RoadshowError.require_condition(
+        isinstance(feature, str) and feature and feature == feature.strip(),
+        "A demo feature must be a non-empty string without surrounding whitespace",
+    )
+    RoadshowError.require_condition(before is None or callable(before), "A demo before hook must be callable")
+    RoadshowError.require_condition(after is None or callable(after), "A demo after hook must be callable")
+    RoadshowError.require_condition(isinstance(input_text, str), "A demo's input_text must be a string")
+    RoadshowError.require_condition(
+        isinstance(argv, Sequence) and not isinstance(argv, (str, bytes)) and all(isinstance(arg, str) for arg in argv),
+        "A demo's argv must be a sequence of strings",
+    )
+    demo_argv = tuple(argv)
+
+    def decorate(function: DemoFunction) -> DemoFunction:
+        function.__dict__[_DEMO_FEATURE_ATTRIBUTE] = feature
+        function.__dict__[_DEMO_BEFORE_ATTRIBUTE] = before
+        function.__dict__[_DEMO_AFTER_ATTRIBUTE] = after
+        function.__dict__[_DEMO_INPUT_TEXT_ATTRIBUTE] = input_text
+        function.__dict__[_DEMO_ARGV_ATTRIBUTE] = demo_argv
+        return function
+
+    return decorate
+
+
+def discover_demos(module: ModuleType) -> list[DemoFunction]:
+    """Return featured demo functions defined in a module, sorted by name."""
+    demos = [
+        member
+        for _, member in inspect.getmembers(module, inspect.isfunction)
+        if member.__module__ == module.__name__ and getattr(member, _DEMO_FEATURE_ATTRIBUTE, None)
+    ]
+    return sorted(demos, key=lambda function: function.__name__)
+
+
+def decompose_demo(function: DemoFunction) -> DemoDetails:
+    """Extract a demo function's docstring and executable body."""
+    docstring = RoadshowError.enforce_defined(
+        inspect.getdoc(function),
+        f"Demo function {function.__name__!r} has no docstring",
+    )
+
+    source_lines, _ = inspect.getsourcelines(function)
+    source_text = textwrap.dedent("".join(source_lines))
+    syntax_tree = ast.parse(source_text)
+    function_node = RoadshowError.enforce_defined(
+        next(
+            (
+                node
+                for node in syntax_tree.body
+                if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) and node.name == function.__name__
+            ),
+            None,
+        ),
+        f"Could not locate the source for demo function {function.__name__!r}",
+    )
+
+    body = function_node.body
+    if (
+        body
+        and isinstance(body[0], ast.Expr)
+        and isinstance(body[0].value, ast.Constant)
+        and isinstance(body[0].value.value, str)
+    ):
+        body = body[1:]
+
+    source = "\n".join(ast.unparse(statement) for statement in body)
+    if source:
+        source += "\n"
+
+    return DemoDetails(
+        module=function.__module__.rsplit(".", maxsplit=1)[-1],
+        name=function.__name__,
+        docstring=docstring,
+        source=source,
+    )
+
+
+def capture_demo(
+    function: DemoFunction,
+    *,
+    input_text: str | None = None,
+    argv: Sequence[str] | None = None,
+    isolate_home: bool = True,
+) -> DemoResult:
+    """Run a demo while capturing standard streams, input, and process exit."""
+    configured_input_text: str = function.__dict__.get(_DEMO_INPUT_TEXT_ATTRIBUTE, "")
+    configured_argv: Sequence[str] = function.__dict__.get(_DEMO_ARGV_ATTRIBUTE, ())
+    effective_input_text = configured_input_text if input_text is None else input_text
+    effective_argv = configured_argv if argv is None else argv
+    result = DemoResult()
+    stdout = io.StringIO()
+    stderr = io.StringIO()
+    stdin = io.StringIO(effective_input_text)
+
+    before = function.__dict__.get(_DEMO_BEFORE_ATTRIBUTE)
+    after = function.__dict__.get(_DEMO_AFTER_ATTRIBUTE)
+    with ExitStack() as stack:
+        stack.enter_context(redirect_stdout(stdout))
+        stack.enter_context(redirect_stderr(stderr))
+        stack.enter_context(patch.object(sys, "stdin", stdin))
+        stack.enter_context(patch.object(sys, "argv", [function.__name__, *effective_argv]))
+
+        try:
+            try:
+                if before is not None:
+                    before()
+                with ExitStack() as environment_stack:
+                    if isolate_home:
+                        temporary_home = environment_stack.enter_context(
+                            tempfile.TemporaryDirectory(prefix="roadshow-")
+                        )
+                        home = Path(temporary_home)
+                        cache_home = home / ".cache"
+                        config_home = home / ".config"
+                        state_home = home / ".local" / "state"
+                        for path in (cache_home, config_home, state_home):
+                            path.mkdir(parents=True, exist_ok=True)
+                        environment_stack.enter_context(
+                            patch.dict(
+                                os.environ,
+                                {
+                                    "HOME": temporary_home,
+                                    "USERPROFILE": temporary_home,
+                                    "XDG_CACHE_HOME": str(cache_home),
+                                    "XDG_CONFIG_HOME": str(config_home),
+                                    "XDG_STATE_HOME": str(state_home),
+                                    "COLUMNS": "80",
+                                },
+                            )
+                        )
+
+                    function()
+            finally:
+                if after is not None:
+                    after()
+        except SystemExit as exited:
+            code = exited.code
+            result.exit_code = 0 if code is None else code if isinstance(code, (int, str)) else str(code)
+        except Exception as error:
+            result.error = error
+
+    result.stdout = stdout.getvalue() or None
+    result.stderr = stderr.getvalue() or None
+    return result

roadshow-0.1.0/src/roadshow/errors.py

@@ -0,0 +1,7 @@
+"""Define Roadshow's base exception type."""
+
+from buzz import Buzz
+
+
+class RoadshowError(Buzz):
+    """Base class for errors raised by Roadshow."""

roadshow-0.1.0/src/roadshow/main.py

@@ -0,0 +1,10 @@
+"""Provide the Roadshow version command."""
+
+from roadshow.version import get_version
+
+__version__ = get_version()
+
+
+def main() -> None:
+    """Print the installed Roadshow version."""
+    print(f"roadshow {__version__}")

roadshow-0.1.0/src/roadshow/render.py

@@ -0,0 +1,126 @@
+"""Render demo descriptions and captured output with Rich."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+from rich.console import Console, Group
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.rule import Rule
+from rich.syntax import Syntax
+from rich.text import Text
+
+from roadshow.core import DemoFunction, DemoResult, capture_demo, decompose_demo
+
+
+def display_demo(
+    function: DemoFunction,
+    console: Console,
+    *,
+    label: str | None = None,
+    input_text: str | None = None,
+    argv: Sequence[str] | None = None,
+    isolate_home: bool = True,
+    progress: tuple[int, int] | None = None,
+) -> DemoResult:
+    """Display a demo and its captured result, optionally showing progress in the outer panel."""
+    details = decompose_demo(function)
+    result = capture_demo(function, input_text=input_text, argv=argv, isolate_home=isolate_home)
+    parts = [
+        Markdown(details.docstring),
+        Rule(characters=" "),
+        Rule(characters=" "),
+        Panel(
+            Syntax(details.source or "pass\n", "python", line_numbers=True),
+            title=f"Source for [yellow]{details.name}()[/yellow]",
+            title_align="left",
+            expand=False,
+            padding=1,
+            border_style="yellow",
+        ),
+    ]
+
+    if result.stdout:
+        parts.extend(
+            [
+                Rule(characters=" "),
+                Rule(characters=" "),
+                Panel(
+                    Text(result.stdout.rstrip()),
+                    title=f"Captured stdout from [yellow]{details.name}()[/yellow]",
+                    title_align="left",
+                    expand=False,
+                    padding=1,
+                    border_style="green",
+                ),
+            ]
+        )
+    if result.stderr:
+        parts.extend(
+            [
+                Rule(characters=" "),
+                Rule(characters=" "),
+                Panel(
+                    Text(result.stderr.rstrip()),
+                    title=f"Captured stderr from [yellow]{details.name}()[/yellow]",
+                    title_align="left",
+                    expand=False,
+                    padding=1,
+                    border_style="yellow",
+                ),
+            ]
+        )
+    if result.error is not None:
+        exception = Text()
+        exception.append(result.error.__class__.__name__, style="red")
+        exception.append(": ")
+        exception.append(str(result.error), style="yellow")
+        parts.extend(
+            [
+                Rule(characters=" "),
+                Rule(characters=" "),
+                Panel(
+                    exception,
+                    title=f"[red]Uncaught exception[/red] from [yellow]{details.name}()[/yellow]",
+                    title_align="left",
+                    expand=False,
+                    padding=1,
+                    border_style="red",
+                ),
+            ]
+        )
+    if result.exit_code is not None:
+        exit_style = "green" if result.exit_code in (0, "0") else "red"
+        parts.extend(
+            [
+                Rule(characters=" "),
+                Rule(characters=" "),
+                Panel(
+                    Text(str(result.exit_code), style=exit_style),
+                    title=f"Exit code from [yellow]{details.name}()[/yellow]",
+                    title_align="left",
+                    expand=False,
+                    padding=1,
+                    border_style=exit_style,
+                ),
+            ]
+        )
+
+    display_title = (
+        f"[green]{label}[/green]: [yellow]{details.name}()[/yellow]" if label else f"[yellow]{details.name}()[/yellow]"
+    )
+    console.print(
+        Panel(
+            Group(*parts),
+            title=display_title,
+            title_align="left",
+            subtitle=f"Demo {progress[0]} of {progress[1]}" if progress is not None else None,
+            subtitle_align="left",
+            padding=1,
+            border_style="blue",
+        )
+    )
+    console.print(Rule(characters=" "))
+    console.print(Rule(characters=" "))
+    return result

roadshow-0.1.0/src/roadshow/version.py

@@ -0,0 +1,24 @@
+import tomllib
+from importlib import metadata
+
+
+def get_version_from_metadata() -> str:
+    return metadata.version(__package__ or __name__)
+
+
+def get_version_from_pyproject() -> str:
+    with open("pyproject.toml", "rb") as file:
+        return tomllib.load(file)["project"]["version"]
+
+
+def get_version() -> str:
+    try:
+        return get_version_from_metadata()
+    except metadata.PackageNotFoundError:
+        try:
+            return get_version_from_pyproject()
+        except (FileNotFoundError, KeyError):
+            return "unknown"
+
+
+__version__ = get_version()