puild 0.1.0__py3-none-any.whl

puild/__init__.py

@@ -0,0 +1,19 @@
+from puild.command import Command, Pipeline, Result, is_dry_run, set_dry_run
+from puild.fs import copy, find_files, mkdir, needs_rebuild, rm
+from puild.logging import is_quiet, log_action, set_quiet
+
+__all__ = [
+    "Command",
+    "Pipeline",
+    "Result",
+    "copy",
+    "find_files",
+    "is_dry_run",
+    "is_quiet",
+    "log_action",
+    "mkdir",
+    "needs_rebuild",
+    "rm",
+    "set_dry_run",
+    "set_quiet",
+]

puild/command.py

@@ -0,0 +1,508 @@
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+import threading
+import time
+from collections.abc import Iterable, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Literal, Self, overload
+
+from puild.logging import log_action
+
+_DRY_RUN = False
+
+
+def set_dry_run(dry_run: bool) -> None:
+    """Set global dry-run mode."""
+    global _DRY_RUN
+    _DRY_RUN = dry_run
+
+
+def is_dry_run() -> bool:
+    """Check if dry-run mode is enabled."""
+    return _DRY_RUN
+
+
+@dataclass
+class Result[T: bytes | str]:
+    cmd: str
+    args: list[str]
+    cwd: str
+    stdout: T
+    stderr: T
+    return_code: int
+
+    @property
+    def ok(self) -> bool:
+        """Return True if command succeeded (return_code == 0)."""
+        return self.return_code == 0
+
+    def exit_for_error(self, message: str | None = None) -> None:
+        """Exit the process if the command failed with a non-zero exit code."""
+        if self.return_code != 0:
+            if message:
+                log_action("Error", message, "red")
+            sys.exit(self.return_code)
+
+    def unwrap(self) -> T:
+        """Return stdout if command succeeded, otherwise exit with the return code."""
+        self.exit_for_error()
+        return self.stdout
+
+
+class Command:
+    def __init__(
+        self,
+        cmd: str | Path,
+        *args: str | Path | Sequence[str | Path],
+    ) -> None:
+        self._cmd = str(cmd)
+        self._args: list[str] = []
+        self._env: dict[str, str] = {}
+        self._cwd: str = "."
+        self._redirect_stdout: Path | None = None
+        self._redirect_append: bool = False
+
+        for arg in args:
+            if isinstance(arg, (list, tuple)):
+                self._args.extend(str(a) for a in arg)
+            else:
+                self._args.append(str(arg))
+
+    def copy(self) -> Command:
+        """Return a shallow copy of the command."""
+        cmd = Command(self._cmd, *self._args)
+        cmd._env = self._env.copy()
+        cmd._cwd = self._cwd
+        cmd._redirect_stdout = self._redirect_stdout
+        cmd._redirect_append = self._redirect_append
+        return cmd
+
+    def arg(self, *args: str | Path) -> Self:
+        """Append one or more positional arguments to the command."""
+        for a in args:
+            self._args.append(str(a))
+        return self
+
+    def args(self, args: Iterable[str | Path]) -> Self:
+        """Append an iterable of arguments to the command."""
+        for a in args:
+            self._args.append(str(a))
+        return self
+
+    def env(
+        self,
+        key_or_dict: str | dict[str, str],
+        value: str | None = None,
+    ) -> Self:
+        """Set environment variables for the command."""
+        if isinstance(key_or_dict, dict):
+            for k, v in key_or_dict.items():
+                self._env[str(k)] = str(v)
+        elif value is not None:
+            self._env[str(key_or_dict)] = str(value)
+        return self
+
+    def cwd(self, path: str | Path) -> Self:
+        """Set default working directory for this command."""
+        self._cwd = str(path)
+        return self
+
+    def to_list(self) -> list[str]:
+        """Convert command and arguments to a list of strings."""
+        return [self._cmd] + self._args
+
+    def __repr__(self) -> str:
+        return f"Command({self.to_list()!r})"
+
+    def __or__(self, other: Command | Pipeline) -> Pipeline:
+        if isinstance(other, Command):
+            return Pipeline([self, other])
+        elif isinstance(other, Pipeline):
+            return Pipeline([self, *other.commands])
+
+    def __gt__(self, target: str | Path) -> Command:
+        """Redirect stdout to file (overwrite): cmd > 'output.txt'"""
+        cmd = self.copy()
+        cmd._redirect_stdout = Path(target)
+        cmd._redirect_append = False
+        return cmd
+
+    def __rshift__(self, target: str | Path) -> Command:
+        """Redirect stdout to file (append): cmd >> 'output.txt'"""
+        cmd = self.copy()
+        cmd._redirect_stdout = Path(target)
+        cmd._redirect_append = True
+        return cmd
+
+    @overload
+    def run(
+        self,
+        *,
+        cwd: str | Path | None = None,
+        text: Literal[False] = False,
+        log: bool = True,
+        capture: bool = True,
+        stream: bool = False,
+        env: dict[str, str] | None = None,
+        input: bytes | None = None,
+        check: bool = False,
+        dry_run: bool | None = None,
+    ) -> Result[bytes]: ...
+
+    @overload
+    def run(
+        self,
+        *,
+        cwd: str | Path | None = None,
+        text: Literal[True],
+        log: bool = True,
+        capture: bool = True,
+        stream: bool = False,
+        env: dict[str, str] | None = None,
+        input: str | None = None,
+        check: bool = False,
+        dry_run: bool | None = None,
+    ) -> Result[str]: ...
+
+    @overload
+    def run(
+        self,
+        *,
+        cwd: str | Path | None = None,
+        text: bool = False,
+        log: bool = True,
+        capture: bool = True,
+        stream: bool = False,
+        env: dict[str, str] | None = None,
+        input: Any = None,
+        check: bool = False,
+        dry_run: bool | None = None,
+    ) -> Result[Any]: ...
+
+    def run(
+        self,
+        *,
+        cwd: str | Path | None = None,
+        text: bool = False,
+        log: bool = True,
+        capture: bool = True,
+        stream: bool = False,
+        env: dict[str, str] | None = None,
+        input: Any = None,
+        check: bool = False,
+        dry_run: bool | None = None,
+    ) -> Result[Any]:
+        effective_cwd = str(cwd) if cwd is not None else self._cwd
+        is_dry = _DRY_RUN if dry_run is None else dry_run
+
+        cmd_display = " ".join(self.to_list())
+        if self._redirect_stdout:
+            op = ">>" if self._redirect_append else ">"
+            cmd_display = f"{cmd_display} {op} {self._redirect_stdout}"
+
+        if log:
+            if effective_cwd != ".":
+                log_action("CD", effective_cwd, "yellow")
+            if is_dry:
+                log_action("Dry-Run", cmd_display, "cyan")
+            else:
+                log_action("Run", cmd_display, "blue")
+
+        empty_out = "" if text else b""
+        if is_dry:
+            return Result(
+                cmd=self._cmd,
+                args=self._args,
+                cwd=effective_cwd,
+                stdout=empty_out,
+                stderr=empty_out,
+                return_code=0,
+            )
+
+        merged_env = os.environ.copy()
+        if self._env:
+            merged_env.update(self._env)
+        if env:
+            merged_env.update(env)
+
+        start = time.perf_counter()
+
+        if self._redirect_stdout:
+            mode = "a" if self._redirect_append else "w"
+            if not text:
+                mode += "b"
+            parent = self._redirect_stdout.parent
+            if parent and not parent.exists():
+                parent.mkdir(parents=True, exist_ok=True)
+            with open(self._redirect_stdout, mode) as f:
+                res = subprocess.run(
+                    self.to_list(),
+                    cwd=effective_cwd,
+                    text=text,
+                    env=merged_env,
+                    input=input,
+                    stdout=f,
+                    stderr=subprocess.PIPE if capture else None,
+                )
+            stdout_res = empty_out
+            stderr_res = res.stderr if capture and res.stderr is not None else empty_out
+            return_code = res.returncode
+        elif stream:
+            stdout_res, stderr_res, return_code = self._run_stream(
+                cmd_list=self.to_list(),
+                cwd=effective_cwd,
+                text=text,
+                env=merged_env,
+                input_data=input,
+            )
+        elif capture:
+            res = subprocess.run(
+                self.to_list(),
+                cwd=effective_cwd,
+                text=text,
+                env=merged_env,
+                input=input,
+                capture_output=True,
+            )
+            stdout_res = res.stdout
+            stderr_res = res.stderr
+            return_code = res.returncode
+        else:
+            res = subprocess.run(
+                self.to_list(),
+                cwd=effective_cwd,
+                text=text,
+                env=merged_env,
+                input=input,
+                capture_output=False,
+            )
+            stdout_res = empty_out
+            stderr_res = empty_out
+            return_code = res.returncode
+
+        elapsed = time.perf_counter() - start
+
+        if log:
+            if return_code != 0:
+                err_msg = (
+                    stderr_res
+                    if isinstance(stderr_res, str)
+                    else stderr_res.decode("utf-8", errors="replace")
+                )
+                log_action("Failed", err_msg.strip() or f"Exit code {return_code}", "red")
+            else:
+                log_action("Success", f"Took {elapsed:.3f}s", "green")
+
+        result = Result(
+            cmd=self._cmd,
+            args=self._args,
+            cwd=effective_cwd,
+            stdout=stdout_res,
+            stderr=stderr_res,
+            return_code=return_code,
+        )
+
+        if check:
+            result.exit_for_error()
+
+        return result
+
+    def _run_stream(
+        self,
+        cmd_list: list[str],
+        cwd: str,
+        text: bool,
+        env: dict[str, str],
+        input_data: Any,
+    ) -> tuple[Any, Any, int]:
+        stdin_setting = subprocess.PIPE if input_data is not None else None
+        proc = subprocess.Popen(
+            cmd_list,
+            cwd=cwd,
+            text=text,
+            env=env,
+            stdin=stdin_setting,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+
+        if input_data is not None and proc.stdin:
+            if text and isinstance(input_data, str):
+                proc.stdin.write(input_data)
+            elif not text and isinstance(input_data, bytes):
+                proc.stdin.write(input_data)
+            proc.stdin.close()
+
+        stdout_chunks: list[Any] = []
+        stderr_chunks: list[Any] = []
+
+        def reader(pipe, chunks, dest_stream):
+            if pipe is None:
+                return
+            try:
+                if text:
+                    for line in iter(pipe.readline, ""):
+                        chunks.append(line)
+                        dest_stream.write(line)
+                        dest_stream.flush()
+                else:
+                    target = getattr(dest_stream, "buffer", dest_stream)
+                    for line in iter(pipe.readline, b""):
+                        chunks.append(line)
+                        target.write(line)
+                        target.flush()
+            finally:
+                pipe.close()
+
+        t_out = threading.Thread(
+            target=reader, args=(proc.stdout, stdout_chunks, sys.stdout)
+        )
+        t_err = threading.Thread(
+            target=reader, args=(proc.stderr, stderr_chunks, sys.stderr)
+        )
+        t_out.start()
+        t_err.start()
+
+        proc.wait()
+        t_out.join()
+        t_err.join()
+
+        if text:
+            return "".join(stdout_chunks), "".join(stderr_chunks), proc.returncode
+        else:
+            return b"".join(stdout_chunks), b"".join(stderr_chunks), proc.returncode
+
+
+class Pipeline:
+    def __init__(self, commands: list[Command]) -> None:
+        self.commands: list[Command] = commands
+
+    def __or__(self, other: Command | Pipeline) -> Pipeline:
+        if isinstance(other, Command):
+            return Pipeline([*self.commands, other])
+        elif isinstance(other, Pipeline):
+            return Pipeline([*self.commands, *other.commands])
+        return NotImplemented
+
+    def __repr__(self) -> str:
+        return f"Pipeline({self.commands!r})"
+
+    def run(
+        self,
+        *,
+        cwd: str | Path = ".",
+        text: bool = True,
+        log: bool = True,
+        input: str | bytes | None = None,
+        check: bool = False,
+        dry_run: bool | None = None,
+    ) -> Result[Any]:
+        is_dry = _DRY_RUN if dry_run is None else dry_run
+        cmd_display = " | ".join(" ".join(c.to_list()) for c in self.commands)
+        effective_cwd = str(cwd)
+
+        if log:
+            if effective_cwd != ".":
+                log_action("CD", effective_cwd, "yellow")
+            if is_dry:
+                log_action("Dry-Run", cmd_display, "cyan")
+            else:
+                log_action("Run", cmd_display, "blue")
+
+        empty_out = "" if text else b""
+        if is_dry or not self.commands:
+            return Result(
+                cmd=cmd_display,
+                args=[],
+                cwd=effective_cwd,
+                stdout=empty_out,
+                stderr=empty_out,
+                return_code=0,
+            )
+
+        start = time.perf_counter()
+        processes: list[subprocess.Popen] = []
+
+        for i, cmd in enumerate(self.commands):
+            is_first = i == 0
+            is_last = i == len(self.commands) - 1
+
+            if is_first:
+                stdin = subprocess.PIPE if input is not None else None
+            else:
+                stdin = processes[-1].stdout
+
+            stdout = subprocess.PIPE
+
+            merged_env = os.environ.copy()
+            if cmd._env:
+                merged_env.update(cmd._env)
+
+            proc = subprocess.Popen(
+                cmd.to_list(),
+                cwd=effective_cwd,
+                stdin=stdin,
+                stdout=stdout,
+                stderr=subprocess.PIPE,
+                text=text,
+                env=merged_env,
+            )
+
+            if not is_first and processes[-1].stdout:
+                processes[-1].stdout.close()
+
+            processes.append(proc)
+
+        last_proc = processes[-1]
+        if input is not None and processes[0].stdin:
+            stdout_res, stderr_res = last_proc.communicate(input=input if len(processes) == 1 else None)
+            if len(processes) > 1 and processes[0].stdin:
+                # If there are multiple processes, send input to first
+                try:
+                    if text and isinstance(input, str):
+                        processes[0].stdin.write(input)
+                    elif not text and isinstance(input, bytes):
+                        processes[0].stdin.write(input)
+                    processes[0].stdin.close()
+                except BrokenPipeError:
+                    pass
+                stdout_res, stderr_res = last_proc.communicate()
+        else:
+            stdout_res, stderr_res = last_proc.communicate()
+
+        for p in processes[:-1]:
+            if p.stderr:
+                p.stderr.close()
+            p.wait()
+
+        elapsed = time.perf_counter() - start
+        return_code = last_proc.returncode
+
+        if log:
+            if return_code != 0:
+                err_msg = (
+                    stderr_res
+                    if isinstance(stderr_res, str)
+                    else stderr_res.decode("utf-8", errors="replace")
+                )
+                log_action("Failed", err_msg.strip() or f"Exit code {return_code}", "red")
+            else:
+                log_action("Success", f"Took {elapsed:.3f}s", "green")
+
+        result = Result(
+            cmd=cmd_display,
+            args=[],
+            cwd=effective_cwd,
+            stdout=stdout_res,
+            stderr=stderr_res,
+            return_code=return_code,
+        )
+
+        if check:
+            result.exit_for_error()
+
+        return result

puild/fs.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+import shutil
+from collections.abc import Iterable
+from pathlib import Path
+
+from puild.logging import log_action
+
+
+def _to_path_list(item: str | Path | Iterable[str | Path]) -> list[Path]:
+    if isinstance(item, (str, Path)):
+        return [Path(item)]
+    return [Path(p) for p in item]
+
+
+def needs_rebuild(
+    target: str | Path | Iterable[str | Path],
+    sources: str | Path | Iterable[str | Path],
+    *,
+    log: bool = False,
+) -> bool:
+    """Check if target needs to be rebuilt based on source modification times.
+
+    Returns True if:
+    - Any target file does not exist.
+    - Any source file is newer than the oldest target file.
+
+    Returns False if:
+    - All targets exist and are newer than all source files.
+    """
+    targets = _to_path_list(target)
+    src_list = _to_path_list(sources)
+
+    targets_display = ", ".join(str(t) for t in targets)
+
+    # If any target does not exist, we must rebuild
+    missing_targets = [t for t in targets if not t.exists()]
+    if missing_targets:
+        if log:
+            log_action("Rebuild", f"{targets_display} (target missing)", "yellow")
+        return True
+
+    # If no sources are specified, target exists so no rebuild
+    if not src_list:
+        if log:
+            log_action("Up-to-date", targets_display, "green")
+        return False
+
+    # Check for missing sources
+    for s in src_list:
+        if not s.exists():
+            raise FileNotFoundError(f"Source file does not exist: {s}")
+
+    oldest_target_mtime = min(t.stat().st_mtime for t in targets)
+    newest_source_mtime = max(s.stat().st_mtime for s in src_list)
+
+    if newest_source_mtime > oldest_target_mtime:
+        if log:
+            log_action("Rebuild", f"{targets_display} (sources modified)", "yellow")
+        return True
+
+    if log:
+        log_action("Up-to-date", targets_display, "green")
+    return False
+
+
+def mkdir(
+    path: str | Path,
+    *,
+    parents: bool = True,
+    exist_ok: bool = True,
+    log: bool = True,
+) -> Path:
+    """Create a directory with parents and exist_ok enabled by default."""
+    p = Path(path)
+    p.mkdir(parents=parents, exist_ok=exist_ok)
+    if log:
+        log_action("Mkdir", str(p), "blue")
+    return p
+
+
+def rm(
+    path: str | Path,
+    *,
+    recursive: bool = True,
+    missing_ok: bool = True,
+    log: bool = True,
+) -> None:
+    """Remove a file or directory."""
+    p = Path(path)
+    if not p.exists():
+        if missing_ok:
+            return
+        raise FileNotFoundError(f"Path does not exist: {p}")
+
+    if p.is_dir():
+        if recursive:
+            shutil.rmtree(p)
+        else:
+            p.rmdir()
+    else:
+        p.unlink()
+
+    if log:
+        log_action("Remove", str(p), "yellow")
+
+
+def copy(
+    src: str | Path,
+    dst: str | Path,
+    *,
+    log: bool = True,
+) -> Path:
+    """Copy a file or directory to a destination."""
+    src_path = Path(src)
+    dst_path = Path(dst)
+
+    if not src_path.exists():
+        raise FileNotFoundError(f"Source does not exist: {src_path}")
+
+    if src_path.is_dir():
+        shutil.copytree(src_path, dst_path, dirs_exist_ok=True)
+    else:
+        if dst_path.is_dir():
+            shutil.copy2(src_path, dst_path / src_path.name)
+        else:
+            dst_path.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(src_path, dst_path)
+
+    if log:
+        log_action("Copy", f"{src_path} -> {dst_path}", "blue")
+
+    return dst_path
+
+
+def find_files(
+    directory: str | Path = ".",
+    pattern: str = "*",
+    *,
+    recursive: bool = True,
+) -> list[Path]:
+    """Find files matching pattern in directory."""
+    dir_path = Path(directory)
+    if recursive:
+        matches = dir_path.rglob(pattern)
+    else:
+        matches = dir_path.glob(pattern)
+
+    return sorted([p for p in matches if p.is_file()])

puild/logging.py

@@ -0,0 +1,30 @@
+from typing import Literal
+from rich import print as rich_print
+
+ActionColor = Literal["red", "green", "yellow", "blue", "magenta", "cyan", "white"]
+
+_QUIET = False
+
+
+def set_quiet(quiet: bool) -> None:
+    """Set global quiet mode for logging."""
+    global _QUIET
+    _QUIET = quiet
+
+
+def is_quiet() -> bool:
+    """Check if quiet mode is enabled."""
+    return _QUIET
+
+
+def log_action(
+    action_name: str,
+    action_message: str,
+    action_color: ActionColor = "white",
+) -> None:
+    """Print a formatted action log line if quiet mode is not enabled."""
+    if _QUIET:
+        return
+    rich_print(
+        f"[bold {action_color}]{action_name:>10}[/bold {action_color}]: {action_message}"
+    )

puild-0.1.0.dist-info/METADATA

@@ -0,0 +1,113 @@
+Metadata-Version: 2.3
+Name: puild
+Version: 0.1.0
+Summary: A lightweight, modern build tool and command runner for Python.
+Requires-Dist: rich>=15.0.0
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+
+# puild
+
+A lightweight, modern build tool and command runner for Python.
+
+## Features
+
+- **Command Runner:** Run system commands with fluent argument construction, rich logging, and typed results.
+- **Pipelines & Redirection:** Shell-like piping (`cmd1 | cmd2`) and redirection (`cmd > "file.txt"`).
+- **Streaming & Live Output:** Real-time stdout/stderr streaming while capturing output into typed [`Result`](src/puild/command.py) objects.
+- **Dry-run & Quiet Modes:** Preview commands before execution or silence logs during scripts and testing.
+- **Build Primitives:** Timestamp-based rebuild detection (`needs_rebuild`) and filesystem helpers (`mkdir`, `rm`, `copy`, `find_files`).
+
+## Quickstart
+
+### 1. Basic Command Execution
+
+```python
+from puild import Command
+
+# Direct instantiation
+cmd = Command("gcc", "-Wall", "-O2", "main.c", "-o", "bin/app")
+res = cmd.run(text=True)
+
+if not res.ok:
+    res.exit_for_error()
+```
+
+### 2. Fluent Argument Builder & Environment
+
+```python
+from puild import Command
+
+cmd = (
+    Command("gcc")
+    .arg("-Wall")
+    .arg("-O2")
+    .args(["main.c", "-o", "bin/app"])
+    .env("CFLAGS", "-march=native")
+    .cwd("src")
+)
+
+res = cmd.run(text=True)
+print(res.stdout)
+```
+
+### 3. Piping and File Redirection
+
+```python
+from puild import Command
+
+# Pipe between commands
+pipe = Command("cat", "access.log") | Command("grep", "ERROR")
+res = pipe.run(text=True)
+
+# File redirection
+cmd = Command("echo", "build completed") > "build.log"
+cmd.run()
+
+# Append to file
+cmd = Command("echo", "second step completed") >> "build.log"
+cmd.run()
+```
+
+### 4. Live Streaming Output
+
+Stream output to stdout/stderr in real-time while still capturing the result:
+
+```python
+from puild import Command
+
+cmd = Command("pytest", "-v")
+res = cmd.run(stream=True, text=True)
+```
+
+### 5. Incremental Builds (`needs_rebuild`)
+
+Skip compiling when targets are already up-to-date:
+
+```python
+from puild import Command, needs_rebuild, find_files
+
+sources = find_files("src", "*.c")
+target = "build/app"
+
+if needs_rebuild(target, sources, log=True):
+    Command("gcc", *sources, "-o", target).run(check=True)
+```
+
+### 6. Filesystem Helpers
+
+```python
+from puild import mkdir, rm, copy, find_files
+
+# Create directories
+mkdir("build/bin")
+
+# Find files
+c_files = find_files("src", "*.c", recursive=True)
+
+# Copy files or directories
+copy("src/config.json", "build/config.json")
+
+# Remove files or directories
+rm("build", recursive=True)
+```

puild-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+puild/__init__.py,sha256=XZK5V-ErbJfUE1-B2BPtKAn-Tl1qHchDsv2wTSxQMRM,421
+puild/command.py,sha256=mW0R38rDMqUxsNU4Sg3v60MRko7WezyOZ8MPW-Lq7D4,15543
+puild/fs.py,sha256=FnBhvAjBHeExu7RmsSJ6zQPoHaP90PcnhfgqXXF5vWQ,3833
+puild/logging.py,sha256=QxKf264EaIirqmuF6GtSpvn_Iu4yeKt4soA71jdmPXM,704
+puild-0.1.0.dist-info/WHEEL,sha256=e4_1dyBeezi8ZjfxrZ3bnVOxFDa3ksqVqH0jTHkUZ3k,81
+puild-0.1.0.dist-info/entry_points.txt,sha256=DV6220xDkXY5EEdPoOm4-VU5y0U715MCFla7MxECz1k,65
+puild-0.1.0.dist-info/METADATA,sha256=8yvOWd7epkyoDLm2wE1wN1HMja7mnwgC5EVZQlKCcTQ,2669
+puild-0.1.0.dist-info/RECORD,,

puild-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.12.19
+Root-Is-Purelib: true
+Tag: py3-none-any

puild-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+puild = puild.main:main
+run = puild.main:main
+