userun 0.1.0__tar.gz

userun-0.1.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.3
+Name: userun
+Version: 0.1.0
+Summary: Add your description here
+Author: Edward Boswell
+Author-email: Edward Boswell <thememium@gmail.com>
+Requires-Dist: asyncio>=4.0.0
+Requires-Dist: usecli>=0.1.48
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+

userun-0.1.0/pyproject.toml

@@ -0,0 +1,54 @@
+[project]
+name = "userun"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+authors = [{ name = "Edward Boswell", email = "thememium@gmail.com" }]
+requires-python = ">=3.12"
+dependencies = [
+    "asyncio>=4.0.0",
+    "usecli>=0.1.48",
+]
+
+[project.scripts]
+userun = "usecli:main"
+
+[build-system]
+requires = ["uv_build>=0.10.2,<0.11.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+  "deptry>=0.24.0",
+  "isort>=8.0.1",
+  "poethepoet>=0.42.1",
+  "pytest>=9.0.2",
+  "ruff>=0.15.5",
+  "ty>=0.0.21",
+  "usechange>=0.1.28",
+]
+
+[tool.deptry]
+known_first_party = ["userun"]
+
+[tool.deptry.per_rule_ignores]
+DEP002 = ["asyncio"]
+DEP005 = ["asyncio"]
+
+[tool.poe.tasks]
+dev = "uv run main.py"
+clean-full = "sh -c 'uv run isort . && uv run ruff check . --fix && uv run ruff format . && uv run deptry . && uv run ty check'"
+clean = "sh -c 'uv run isort . && uv run ruff format .'"
+test = "uv run pytest tests/ -v"
+sort = "uv run isort ."
+lint = "uv run ruff check ."
+format = "uv run ruff format ."
+deptry = "uv deptry ."
+typecheck = "uv run ty check"
+release = "uv run usechange release"
+
+concurrent-demo = "uv run userun concurrent -n server,lint,test \"python3 -m http.server 8000\" \"uv run poe lint\" \"uv run poe test\""
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["src*"]

userun-0.1.0/src/userun/__init__.py

@@ -0,0 +1,2 @@
+def main() -> None:
+    print("Hello from userun!")

userun-0.1.0/src/userun/cli/commands/concurrent_command.py

@@ -0,0 +1,323 @@
+"""ConcurrentCommand - CLI command."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import re
+from dataclasses import dataclass
+from typing import TextIO
+
+from usecli import Argument, BaseCommand, Option, console, theme
+
+
+class ConcurrentCommand(BaseCommand):
+    def signature(self) -> str:
+        return "concurrent"
+
+    def description(self) -> str:
+        return "Run multiple commands concurrently"
+
+    def aliases(self) -> list[str]:
+        return ["conc"]
+
+    @dataclass(frozen=True)
+    class CommandSpec:
+        index: int
+        command: str
+        prefix: str
+
+    @staticmethod
+    def parse_csv(value: str | None) -> list[str]:
+        if value is None or not isinstance(value, str):
+            return []
+        items = [item.strip() for item in value.split(",")]
+        return [item for item in items if item]
+
+    @staticmethod
+    def resolve_color(name: str) -> str | None:
+        normalized = name.strip().lower()
+        if not normalized:
+            return None
+        palette = {
+            "primary": theme.ANSI.PRIMARY,
+            "secondary": theme.ANSI.SECONDARY,
+            "accent": theme.ANSI.ACCENT,
+            "blue": theme.ANSI.BLUE,
+            "green": theme.ANSI.GREEN,
+            "yellow": theme.ANSI.YELLOW,
+            "red": theme.ANSI.RED,
+            "foreground": theme.ANSI.FOREGROUND,
+            "foreground-muted": theme.ANSI.FOREGROUND_MUTED,
+            "foreground_muted": theme.ANSI.FOREGROUND_MUTED,
+            "gray": theme.ANSI.FOREGROUND_MUTED,
+            "grey": theme.ANSI.FOREGROUND_MUTED,
+            "white": theme.ANSI.FOREGROUND,
+            "cyan": theme.ANSI.PRIMARY,
+            "magenta": theme.ANSI.ACCENT,
+            "purple": theme.ANSI.ACCENT,
+        }
+        return palette.get(normalized)
+
+    async def stream_output(
+        self, stream: asyncio.StreamReader, prefix: str, output: TextIO
+    ) -> None:
+        while True:
+            line = await stream.readline()
+            if not line:
+                break
+            text = line.decode(errors="replace")
+            if not text.endswith("\n"):
+                text = f"{text}\n"
+            output.write(f"{prefix}{text}")
+            output.flush()
+
+    @staticmethod
+    def strip_ansi(text: str) -> str:
+        return re.sub(r"\x1b\[[0-9;]*m", "", text)
+
+    def build_prefixes(
+        self,
+        commands: list[str],
+        *,
+        names: list[str] | None = None,
+        colors: list[str] | None = None,
+        prefix_format: str | None = None,
+        no_prefix: bool = False,
+        no_color: bool = False,
+    ) -> list[str]:
+        if no_prefix:
+            return [""] * len(commands)
+
+        default_colors = [
+            theme.ANSI.PRIMARY,
+            theme.ANSI.SECONDARY,
+            theme.ANSI.ACCENT,
+            theme.ANSI.BLUE,
+            theme.ANSI.GREEN,
+            theme.ANSI.YELLOW,
+        ]
+        resolved_colors = colors or []
+        palette = resolved_colors or default_colors
+        reset = "" if no_color else theme.ANSI.RESET
+
+        index_width = len(str(max(len(commands) - 1, 0)))
+        prefixes: list[str] = []
+        for index in range(len(commands)):
+            name = ""
+            if names and index < len(names):
+                name = names[index]
+            label = name if name else f"{index:{index_width}d}"
+            format_value = {
+                "index": index,
+                "name": name or str(index),
+                "label": label,
+            }
+            raw_prefix = None
+            if prefix_format:
+                try:
+                    raw_prefix = prefix_format.format_map(format_value)
+                except (KeyError, ValueError):
+                    raw_prefix = None
+            if raw_prefix is None:
+                raw_prefix = f"[{label}]"
+
+            if no_color or not palette:
+                prefixes.append(f"{raw_prefix} ")
+                continue
+            color = palette[index % len(palette)]
+            prefixes.append(f"{color}{raw_prefix}{reset} ")
+        return prefixes
+
+    async def run_command(
+        self,
+        spec: CommandSpec,
+        queue: asyncio.Queue[str | None],
+        *,
+        failure_event: asyncio.Event | None = None,
+        process_registry: dict[int, asyncio.subprocess.Process] | None = None,
+        registry_lock: asyncio.Lock | None = None,
+        subprocess_color: bool = True,
+    ) -> int:
+        env = None
+        if subprocess_color:
+            env = os.environ.copy()
+            env.update(
+                {
+                    "FORCE_COLOR": "1",
+                    "CLICOLOR_FORCE": "1",
+                    "RICH_FORCE_TERMINAL": "1",
+                    "TERM": env.get("TERM", "xterm-256color"),
+                }
+            )
+        process = await asyncio.create_subprocess_shell(
+            spec.command,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            env=env,
+        )
+        if process_registry is not None and registry_lock is not None:
+            async with registry_lock:
+                process_registry[spec.index] = process
+        await queue.put(f"{spec.prefix}started: {spec.command}\n")
+
+        async def read_and_queue(stream: asyncio.StreamReader) -> None:
+            while True:
+                line = await stream.readline()
+                if not line:
+                    break
+                text = line.decode(errors="replace")
+                if not text.endswith("\n"):
+                    text = f"{text}\n"
+                if not subprocess_color:
+                    text = self.strip_ansi(text)
+                await queue.put(f"{spec.prefix}{text}")
+
+        tasks: list[asyncio.Task[None]] = []
+        if process.stdout is not None:
+            tasks.append(asyncio.create_task(read_and_queue(process.stdout)))
+        if process.stderr is not None:
+            tasks.append(asyncio.create_task(read_and_queue(process.stderr)))
+
+        return_code = await process.wait()
+        if tasks:
+            await asyncio.gather(*tasks)
+        await queue.put(
+            f"{spec.prefix}exited with code {return_code}: {spec.command}\n"
+        )
+        if process_registry is not None and registry_lock is not None:
+            async with registry_lock:
+                process_registry.pop(spec.index, None)
+        if failure_event is not None and return_code != 0:
+            failure_event.set()
+        return return_code
+
+    async def run_all(
+        self,
+        commands: list[str],
+        *,
+        names: list[str] | None = None,
+        colors: list[str] | None = None,
+        prefix_format: str | None = None,
+        no_prefix: bool = False,
+        no_color: bool = False,
+        kill_others: bool = False,
+        subprocess_color: bool = True,
+    ) -> list[int]:
+        prefixes = self.build_prefixes(
+            commands,
+            names=names,
+            colors=colors,
+            prefix_format=prefix_format,
+            no_prefix=no_prefix,
+            no_color=no_color,
+        )
+        specs = [
+            self.CommandSpec(index=index, command=command, prefix=prefixes[index])
+            for index, command in enumerate(commands)
+        ]
+        queue: asyncio.Queue[str | None] = asyncio.Queue()
+        failure_event = asyncio.Event() if kill_others else None
+        process_registry: dict[int, asyncio.subprocess.Process] = {}
+        registry_lock = asyncio.Lock()
+
+        async def writer() -> None:
+            while True:
+                item = await queue.get()
+                if item is None:
+                    break
+                console.print(item, end="", markup=False, highlight=False)
+
+        writer_task = asyncio.create_task(writer())
+        results_task = asyncio.gather(
+            *(
+                self.run_command(
+                    spec,
+                    queue,
+                    failure_event=failure_event,
+                    process_registry=process_registry,
+                    registry_lock=registry_lock,
+                    subprocess_color=subprocess_color,
+                )
+                for spec in specs
+            )
+        )
+
+        if kill_others and failure_event is not None:
+            await failure_event.wait()
+            async with registry_lock:
+                for process in process_registry.values():
+                    if process.returncode is None:
+                        process.terminate()
+
+        results = await results_task
+        await queue.put(None)
+        await writer_task
+        return list(results)
+
+    def handle(
+        self,
+        commands: list[str] = Argument(
+            ..., help="Commands to run concurrently. Quote each command."
+        ),
+        names: str | None = Option(
+            None,
+            "--names",
+            "-n",
+            help="Comma-separated names to label each command.",
+        ),
+        colors: str | None = Option(
+            None,
+            "--colors",
+            "-c",
+            help="Comma-separated color names for prefixes.",
+        ),
+        kill_others: bool = Option(
+            False,
+            "--kill-others",
+            "-k",
+            help="Stop remaining commands when a command exits non-zero.",
+        ),
+        prefix_format: str | None = Option(
+            None,
+            "--prefix-format",
+            "-p",
+            help="Custom prefix format using {index}, {name}, {label}.",
+        ),
+        no_prefix: bool = Option(
+            False,
+            "--no-prefix",
+            help="Disable output prefixes.",
+        ),
+        no_color: bool = Option(
+            False,
+            "--no-color",
+            help="Disable ANSI colors in prefixes.",
+        ),
+        subprocess_color: bool = Option(
+            True,
+            "--subprocess-color/--no-subprocess-color",
+            help="Enable or disable ANSI colors from subprocess output.",
+        ),
+    ) -> None:
+        name_list = self.parse_csv(names)
+        color_names = self.parse_csv(colors)
+        resolved_colors: list[str] = []
+        for color_name in color_names:
+            resolved = self.resolve_color(color_name)
+            if resolved:
+                resolved_colors.append(resolved)
+        exit_codes = asyncio.run(
+            self.run_all(
+                commands,
+                names=name_list,
+                colors=resolved_colors,
+                prefix_format=prefix_format,
+                no_prefix=no_prefix,
+                no_color=no_color,
+                kill_others=kill_others,
+                subprocess_color=subprocess_color,
+            )
+        )
+        if any(code != 0 for code in exit_codes):
+            raise SystemExit(1)

userun-0.1.0/src/userun/cli/templates/command.py.j2

@@ -0,0 +1,67 @@
+"""{{ class_name }} - CLI command."""
+
+from __future__ import annotations
+
+from usecli import Argument, BaseCommand, Confirm, Menu, Option, Prompt, console, theme
+
+
+class {{ class_name }}(BaseCommand):
+    def signature(self) -> str:
+        return "{{ command_name }}"
+
+    def description(self) -> str:
+        return "Description for {{ command_name }} command"
+
+    # def aliases(self) -> list[str]:
+    #    return [{{ command_name[:3] }}]
+
+    def handle(
+        self,
+        name: str = Argument(..., help="An example argument"),
+        verbose: bool = Option(False, "--verbose", "-v", help="Enable verbose output"),
+    ) -> None:
+        console.print(
+            f"[bold {theme.SUCCESS}]Executing {{ command_name }}[/bold {theme.SUCCESS}]"
+        )
+        console.print(f"Hello, {name}!")
+
+        if verbose:
+            console.print("[dim]Verbose mode enabled[/dim]")
+
+        # Example: Text input prompt
+        favorite_color = Prompt.ask(
+            "What's your favorite color?",
+            choices=["red", "green", "blue", "yellow"],
+        )
+        console.print(
+            f"You chose: [bold {theme.ACCENT}]{favorite_color}[/bold {theme.ACCENT}]"
+        )
+
+        # Example: Confirmation prompt (only when verbose)
+        if verbose:
+            if not Confirm.ask("Do you want to continue?"):
+                console.print(f"[{theme.WARNING}]Cancelled by user[/{theme.WARNING}]")
+                return
+            console.print(f"[{theme.SUCCESS}]Proceeding...[/{theme.SUCCESS}]")
+
+        # Example: Single-select menu
+        single_choice = Menu.select(
+            ["Option A", "Option B", "Option C"],
+            title="Pick one option:",
+        )
+        if single_choice:
+            console.print(f"You selected: {single_choice}")
+
+        # Example: Multi-select menu
+        multi_choices = Menu.multi_select(
+            ["Feature 1", "Feature 2", "Feature 3", "Feature 4"],
+            title="Select multiple features (space to select, enter to confirm):",
+        )
+        if multi_choices:
+            console.print(f"You selected {len(multi_choices)} features:")
+            for choice in multi_choices:
+                console.print(f"  - {choice}")
+
+        console.print(
+            f"[bold {theme.PRIMARY}]Command completed![/bold {theme.PRIMARY}]"
+        )

userun-0.1.0/src/userun/cli/themes/default.toml

@@ -0,0 +1,29 @@
+[colors]
+# Core semantic colors
+primary = "#60D7FF"
+secondary = "#5EFF87"
+accent = "#F5FE53"
+
+success = "#5EFF87" # Green
+error = "#FE686B"   # Red
+warning = "#F5FE53" # Yellow
+info = "#60D7FF"    # Teal / Blue
+
+# Text
+foreground = "#FFFFFF"       # Text
+foreground_muted = "#BBBBBB" # Subtext
+
+# Surfaces
+background = "#000000"   # Base
+border = "#60D7FF"       # Surface 
+border_focus = "#5EFF87" # Focus Ring
+
+# UI semantics
+command = "#60D7FF"
+option = "#60D7FF"
+link = "#60D7FF"
+prompt = "#5EFF87"
+
+panel_primary = "#5EFF87"
+panel_secondary = "#60D7FF"
+panel_accent = "#F5FE53"

userun-0.1.0/src/userun/cli/title.txt

@@ -0,0 +1,7 @@
+                         ▀██▀▀█▄                     
+ ▄▄▄ ▄▄▄   ▄▄▄▄    ▄▄▄▄   ██   ██  ▄▄▄ ▄▄▄  ▄▄ ▄▄▄   
+  ██  ██  ██▄ ▀  ▄█▄▄▄██  ██▀▀█▀    ██  ██   ██  ██  
+  ██  ██  ▄ ▀█▄▄ ██       ██   █▄   ██  ██   ██  ██  
+  ▀█▄▄▀█▄ █▀▄▄█▀  ▀█▄▄▄▀ ▄██▄  ▀█▀  ▀█▄▄▀█▄ ▄██▄ ██▄ 
+
+ █████▓▓▓▓▓▒▒▒▒▒░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▒▓▓▓▓▓█████

userun-0.1.0/src/userun/cli/usecli.config.toml

@@ -0,0 +1,14 @@
+[usecli]
+command_name = "userun"
+title = "userun"
+title_file = "title.txt"
+title_font = "ansi_shadow"
+description = "A python command runner for concurrent runs."
+commands_dir = "commands"
+templates_dir = "templates"
+themes_dir = "themes"
+theme = "default"
+hide_init = true
+hide_inspire = true
+hide_make_command = false
+hide_make_theme = true