runall 0.1.0__tar.gz

runall-0.1.0/.gitignore

@@ -0,0 +1,45 @@
+# Python-generated files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Packaging and build artifacts
+build/
+dist/
+wheels/
+*.egg-info/
+*.egg
+.eggs/
+
+# Virtual environments
+.venv/
+venv/
+env/
+
+# Test, coverage, and tooling caches
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.tox/
+.nox/
+.coverage
+.coverage.*
+htmlcov/
+
+# Environment files and secrets
+.env
+.env.*
+!.env.example
+
+# Editor and OS files
+.idea/
+.vscode/
+*.swp
+.DS_Store
+Thumbs.db
+
+# Runtime output
+/output/
+/err/
+
+PUBLISHING.md

runall-0.1.0/.python-version

@@ -0,0 +1 @@
+3.14

runall-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Roberto Fernandes Tavares Neto
+
+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.

runall-0.1.0/PKG-INFO

@@ -0,0 +1,160 @@
+Metadata-Version: 2.5
+Name: runall
+Version: 0.1.0
+Summary: Run functions registered by @runthat decorator with a set of progress bars.
+Project-URL: Homepage, https://github.com/tavaresneto/pyrunall
+Project-URL: Repository, https://github.com/tavaresneto/pyrunall
+Project-URL: Issues, https://github.com/tavaresneto/pyrunall/issues
+Author: Roberto Fernandes Tavares Neto
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: textual>=8.2.8
+Description-Content-Type: text/markdown
+
+# runall
+
+`runall` is a Python package that runs shell commands over a set of input files
+and displays the progress in a terminal user interface (TUI). Commands are
+declared as ordinary Python functions registered with the `@runthat` decorator.
+For every function, the interface shows a progress bar (the bar of the function
+that is currently running is highlighted in orange) and a scrolling list of the
+files that have been processed.
+
+## Features
+
+- Registers any number of command-building functions with a single decorator.
+- Selects input files with a glob pattern.
+- Displays one progress bar per function and a running list of processed files.
+- Writes the standard output of every command to a CSV file per function.
+- Logs each executed command and its standard error output to a separate file.
+
+## Requirements
+
+- Python 3.10 or later
+- [Textual](https://textual.textualize.io/) 8.2.8 or later (installed automatically)
+- [uv](https://docs.astral.sh/uv/) (recommended for development)
+
+## Installation
+
+```sh
+pip install runall
+```
+
+```sh
+uv add runall
+```
+
+## Usage
+
+1. Create a configuration dictionary (see [Configuration](#configuration)).
+2. Decorate one or more functions with `@runthat(config=config)`. Each function
+   receives the path of an input file and returns the shell command to execute.
+3. Start the interface with `RunAllApp(config).run()`.
+
+For every input file, `runall` executes each registered function in the order in
+which it was defined. The commands run sequentially.
+
+### Example
+
+The complete example below is available in `examples/demo.py`. It registers three
+functions that each wait five seconds and then print one line:
+
+```python
+# from runall.config import CONFIG
+from runall.tui import RunAllApp, runthat
+
+config = {
+    "runthat": {},
+    "input_dir": "instances/ht0_*.txt",
+    "output_dir": "output",
+    "output_preffix": "out_",
+    "output_header": "execucao,arquivo",
+    "err_dir": "err",
+}
+
+@runthat(config=config)
+def exec1(filename: str) -> str:
+    return f'sleep 5;echo "[1] {filename}"'
+
+
+@runthat(config=config)
+def exec2(filename: str) -> str:
+    return f'sleep 5;echo "[2] {filename}"'
+
+
+@runthat(config=config)
+def exec3(filename: str) -> str:
+    return f'sleep 5;echo "[3] {filename}"'
+
+
+def main() -> None:
+    RunAllApp(config).run()
+
+
+if __name__ == "__main__":
+    main()
+```
+
+Run it from the repository root, so that the relative paths in the configuration
+resolve correctly:
+
+```sh
+uv run python examples/demo.py
+```
+
+## Configuration
+
+The configuration is a plain dictionary with the following keys:
+
+| Key              | Description                                                                                  |
+| ---------------- | -------------------------------------------------------------------------------------------- |
+| `runthat`        | Registry of decorated functions. Start it as an empty dictionary; `@runthat` fills it in.    |
+| `input_dir`      | Glob pattern that selects the input files, for example `instances/ht0_*.txt`.                |
+| `output_dir`     | Directory that receives the standard output of each function.                                |
+| `output_preffix` | Prefix of every output file name. The key keeps its original spelling.                       |
+| `output_header`  | Header line written once at the top of each newly created output file.                       |
+| `err_dir`        | Directory that receives the executed commands and their standard error output.               |
+
+A default configuration is also available as `runall.CONFIG`.
+
+## Output files
+
+For a function named `exec1` and the configuration above, `runall` writes:
+
+- `output/out_exec1.csv`: the header line followed by the standard output of every
+  execution of `exec1`.
+- `err/out_exec1.csv`: for every execution, the line `$ <command>` followed by
+  the standard error output of the command, if any.
+
+Both files are opened in append mode, so results accumulate across runs. Remove
+the output directories before a run to start from a clean state. Commands should
+print lines that match the columns of `output_header`.
+
+## Security considerations
+
+Commands are executed through the shell (`shell=True`), and the file name is
+inserted into the command string that your function returns. Quote file names
+(for example with `shlex.quote`) if they may contain spaces or shell
+metacharacters, and never register commands built from untrusted input.
+
+The exit status of a command is not treated as an error: a failing command is
+recorded in the error log and processing continues with the next command.
+
+## Project layout
+
+```text
+src/runall/
+├── __init__.py    Public API: CONFIG, discover_input_files, runthat
+├── config.py      Default configuration
+├── processor.py   Input file discovery
+└── tui.py         The @runthat decorator and the RunAllApp interface
+examples/
+└── demo.py        Complete usage example
+instances/         Sample input files used by the example
+```
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file
+for details.

runall-0.1.0/README.md

@@ -0,0 +1,146 @@
+# runall
+
+`runall` is a Python package that runs shell commands over a set of input files
+and displays the progress in a terminal user interface (TUI). Commands are
+declared as ordinary Python functions registered with the `@runthat` decorator.
+For every function, the interface shows a progress bar (the bar of the function
+that is currently running is highlighted in orange) and a scrolling list of the
+files that have been processed.
+
+## Features
+
+- Registers any number of command-building functions with a single decorator.
+- Selects input files with a glob pattern.
+- Displays one progress bar per function and a running list of processed files.
+- Writes the standard output of every command to a CSV file per function.
+- Logs each executed command and its standard error output to a separate file.
+
+## Requirements
+
+- Python 3.10 or later
+- [Textual](https://textual.textualize.io/) 8.2.8 or later (installed automatically)
+- [uv](https://docs.astral.sh/uv/) (recommended for development)
+
+## Installation
+
+```sh
+pip install runall
+```
+
+```sh
+uv add runall
+```
+
+## Usage
+
+1. Create a configuration dictionary (see [Configuration](#configuration)).
+2. Decorate one or more functions with `@runthat(config=config)`. Each function
+   receives the path of an input file and returns the shell command to execute.
+3. Start the interface with `RunAllApp(config).run()`.
+
+For every input file, `runall` executes each registered function in the order in
+which it was defined. The commands run sequentially.
+
+### Example
+
+The complete example below is available in `examples/demo.py`. It registers three
+functions that each wait five seconds and then print one line:
+
+```python
+# from runall.config import CONFIG
+from runall.tui import RunAllApp, runthat
+
+config = {
+    "runthat": {},
+    "input_dir": "instances/ht0_*.txt",
+    "output_dir": "output",
+    "output_preffix": "out_",
+    "output_header": "execucao,arquivo",
+    "err_dir": "err",
+}
+
+@runthat(config=config)
+def exec1(filename: str) -> str:
+    return f'sleep 5;echo "[1] {filename}"'
+
+
+@runthat(config=config)
+def exec2(filename: str) -> str:
+    return f'sleep 5;echo "[2] {filename}"'
+
+
+@runthat(config=config)
+def exec3(filename: str) -> str:
+    return f'sleep 5;echo "[3] {filename}"'
+
+
+def main() -> None:
+    RunAllApp(config).run()
+
+
+if __name__ == "__main__":
+    main()
+```
+
+Run it from the repository root, so that the relative paths in the configuration
+resolve correctly:
+
+```sh
+uv run python examples/demo.py
+```
+
+## Configuration
+
+The configuration is a plain dictionary with the following keys:
+
+| Key              | Description                                                                                  |
+| ---------------- | -------------------------------------------------------------------------------------------- |
+| `runthat`        | Registry of decorated functions. Start it as an empty dictionary; `@runthat` fills it in.    |
+| `input_dir`      | Glob pattern that selects the input files, for example `instances/ht0_*.txt`.                |
+| `output_dir`     | Directory that receives the standard output of each function.                                |
+| `output_preffix` | Prefix of every output file name. The key keeps its original spelling.                       |
+| `output_header`  | Header line written once at the top of each newly created output file.                       |
+| `err_dir`        | Directory that receives the executed commands and their standard error output.               |
+
+A default configuration is also available as `runall.CONFIG`.
+
+## Output files
+
+For a function named `exec1` and the configuration above, `runall` writes:
+
+- `output/out_exec1.csv`: the header line followed by the standard output of every
+  execution of `exec1`.
+- `err/out_exec1.csv`: for every execution, the line `$ <command>` followed by
+  the standard error output of the command, if any.
+
+Both files are opened in append mode, so results accumulate across runs. Remove
+the output directories before a run to start from a clean state. Commands should
+print lines that match the columns of `output_header`.
+
+## Security considerations
+
+Commands are executed through the shell (`shell=True`), and the file name is
+inserted into the command string that your function returns. Quote file names
+(for example with `shlex.quote`) if they may contain spaces or shell
+metacharacters, and never register commands built from untrusted input.
+
+The exit status of a command is not treated as an error: a failing command is
+recorded in the error log and processing continues with the next command.
+
+## Project layout
+
+```text
+src/runall/
+├── __init__.py    Public API: CONFIG, discover_input_files, runthat
+├── config.py      Default configuration
+├── processor.py   Input file discovery
+└── tui.py         The @runthat decorator and the RunAllApp interface
+examples/
+└── demo.py        Complete usage example
+instances/         Sample input files used by the example
+```
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file
+for details.

runall-0.1.0/examples/demo.py

@@ -0,0 +1,70 @@
+"""Demonstration of ``runall`` with three simulated commands.
+
+Run this script from the repository root so that the relative paths in the
+configuration resolve correctly::
+
+    uv run python examples/demo.py
+
+Each registered function waits five seconds and then prints a line that
+identifies the function and the input file. The results are appended to
+``output/`` and the executed commands to ``err/``.
+"""
+
+# from runall.config import CONFIG
+from runall.tui import RunAllApp, runthat
+
+config = {
+    "runthat": {},
+    "input_dir": "instances/ht0_*.txt",
+    "output_dir": "output",
+    "output_preffix": "out_",
+    "output_header": "execucao,arquivo",
+    "err_dir": "err",
+}
+
+@runthat(config=config)
+def exec1(filename: str) -> str:
+    """Build the first simulated command.
+
+    Args:
+        filename: Path of the input file.
+
+    Returns:
+        A shell command that sleeps and then prints a line tagged ``[1]``.
+    """
+    return f'sleep 5;echo "[1] {filename}"'
+
+
+@runthat(config=config)
+def exec2(filename: str) -> str:
+    """Build the second simulated command.
+
+    Args:
+        filename: Path of the input file.
+
+    Returns:
+        A shell command that sleeps and then prints a line tagged ``[2]``.
+    """
+    return f'sleep 5;echo "[2] {filename}"'
+
+
+@runthat(config=config)
+def exec3(filename: str) -> str:
+    """Build the third simulated command.
+
+    Args:
+        filename: Path of the input file.
+
+    Returns:
+        A shell command that sleeps and then prints a line tagged ``[3]``.
+    """
+    return f'sleep 5;echo "[3] {filename}"'
+
+
+def main() -> None:
+    """Launch the terminal interface with the registered commands."""
+    RunAllApp(config).run()
+
+
+if __name__ == "__main__":
+    main()

runall-0.1.0/instances/ht0_a.txt

@@ -0,0 +1 @@
+foo

runall-0.1.0/instances/ht0_b.txt

@@ -0,0 +1 @@
+bar

runall-0.1.0/instances/ht0_c.txt

@@ -0,0 +1 @@
+baz

runall-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "runall"
+version = "0.1.0"
+description = "Run functions registered by @runthat decorator with a set of progress bars."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Roberto Fernandes Tavares Neto" }]
+requires-python = ">=3.10"
+dependencies = [
+    "textual>=8.2.8"
+]
+
+[project.urls]
+Homepage = "https://github.com/tavaresneto/pyrunall"
+Repository = "https://github.com/tavaresneto/pyrunall"
+Issues = "https://github.com/tavaresneto/pyrunall/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/runall"]

runall-0.1.0/src/runall/__init__.py

@@ -0,0 +1,20 @@
+"""Run shell commands over a set of input files with a terminal progress display.
+
+The ``runall`` package lets a user register Python functions with the
+:func:`runthat` decorator. Each registered function receives the path of an
+input file and returns a shell command. The command is executed for every
+input file that matches a glob pattern, while a Textual-based terminal user
+interface (:class:`runall.tui.RunAllApp`) displays one progress bar per
+registered function and a running list of the processed files.
+
+Public names:
+    CONFIG: A default configuration dictionary.
+    discover_input_files: Resolves the input files described by a configuration.
+    runthat: Decorator that registers a function in a configuration.
+"""
+
+from .config import CONFIG
+from .processor import discover_input_files
+from .tui import runthat
+
+__all__ = ["CONFIG", "discover_input_files", "runthat"]

runall-0.1.0/src/runall/config.py

@@ -0,0 +1,28 @@
+"""Default configuration for the ``runall`` package.
+
+A configuration is a plain dictionary. The same structure may be defined by
+the user and passed to :func:`runall.tui.runthat` and
+:class:`runall.tui.RunAllApp`.
+"""
+
+CONFIG = {
+    "runthat": {},
+    "input_dir": "instances/ht0_*.txt",
+    "output_dir": "output",
+    "output_preffix": "out_",
+    "output_header": "execucao,arquivo",
+    "err_dir": "err",
+}
+"""Default configuration dictionary.
+
+Keys:
+    runthat: Registry that maps function names to the wrapped callables. It is
+        populated by the :func:`runall.tui.runthat` decorator.
+    input_dir: Glob pattern that selects the input files.
+    output_dir: Directory that receives the standard output of each command.
+    output_preffix: Prefix of every output file name. The key name keeps its
+        historical spelling.
+    output_header: Header line written once at the top of each new output file.
+    err_dir: Directory that receives the executed commands and their standard
+        error output.
+"""

runall-0.1.0/src/runall/processor.py

@@ -0,0 +1,22 @@
+"""Discovery of the input files that ``runall`` processes."""
+
+import glob
+
+from .config import CONFIG
+
+
+def discover_input_files(config: dict | None = None) -> list[str]:
+    """Return the input files that match the configured glob pattern.
+
+    Args:
+        config: Configuration dictionary whose ``"input_dir"`` entry holds the
+            glob pattern. When ``None``, the default
+            :data:`runall.config.CONFIG` is used.
+
+    Returns:
+        The matching paths in lexicographic order. The list is empty when no
+        file matches the pattern.
+    """
+    if config is None:
+        config = CONFIG
+    return sorted(glob.glob(config["input_dir"]))