yacta 0.0.1__tar.gz

yacta-0.0.1/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.3
+Name: yacta
+Version: 0.0.1
+Summary: Yet Another Converter for Text to ANSI
+Author: ars6502
+Author-email: ars6502 <arun.r.sharma@proton.me>
+Requires-Dist: pyhyphen>=4.0.4
+Requires-Dist: typer>=0.24.1
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# Yet Another Converter for Text to ANSI
+
+For documents formatted specifically for terminal/console

yacta-0.0.1/README.md

@@ -0,0 +1,3 @@
+# Yet Another Converter for Text to ANSI
+
+For documents formatted specifically for terminal/console

yacta-0.0.1/pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "yacta"
+version = "0.0.1"
+description = "Yet Another Converter for Text to ANSI"
+readme = "README.md"
+authors = [
+    { name = "ars6502", email = "arun.r.sharma@proton.me" }
+]
+requires-python = ">=3.12"
+dependencies = [
+    "pyhyphen>=4.0.4",
+    "typer>=0.24.1",
+]
+
+[project.scripts]
+yacta = "yacta:cmd.main"
+
+[build-system]
+requires = ["uv_build>=0.11.3,<0.12.0"]
+build-backend = "uv_build"

yacta-0.0.1/src/yacta/__init__.py

@@ -0,0 +1,5 @@
+from .common import *
+
+from .command_block_processor import *
+from .css_parser import *
+from .selector_parser import *

yacta-0.0.1/src/yacta/ansi_builder.py

@@ -0,0 +1,261 @@
+from __future__ import annotations
+import re
+import shlex
+import subprocess
+import sys
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple
+from hyphen import Hyphenator
+from .common import *
+
+ANSI_RE = re.compile(r"\x1b\[[0-9;]*m")
+
+def get_padding(style: Dict[str, object]) -> Tuple[int, int, int, int]:
+    """Return block padding as ``(top, bottom, left, right)`` integers.
+
+    Missing padding declarations default to zero.
+    """
+    return (
+        int(style.get("padding-top", 0)),
+        int(style.get("padding-bottom", 0)),
+        int(style.get("padding-left", 0)),
+        int(style.get("padding-right", 0)),
+    )
+
+
+def get_wrap_width(style: Dict[str, object]) -> Optional[int]:
+    """Return the available text width inside a styled block.
+
+    When ``max-width`` is present, the method subtracts left and right padding to
+    produce the width available to the actual text content. ``None`` means the text
+    should not be wrapped to a specific width.
+    """
+    max_width = style.get("max-width")
+    if max_width is None:
+        return None
+
+    _, _, padding_left, padding_right = get_padding(style)
+    return max(1, int(max_width) - padding_left - padding_right)
+
+class ANSIBuilder:
+    """Build ANSI escape sequences and styled terminal output fragments.
+
+    This class owns all knowledge of how colors, resets, inline emphasis, and
+    padded block output are translated into terminal control sequences. Keeping the
+    logic here makes the rest of the renderer operate mainly on plain text and
+    layout decisions.
+    """
+    RESET = "\033[0m"
+    BOLD = "\033[1m"
+    BOLD_OFF = "\033[22m"
+    STYLE_CODES = {
+        "BOLD": "1",
+        "DIM": "2",
+        "ITALIC": "3",
+        "UNDERLINE": "4",
+        "REVERSE": "7",
+        "BLACK": "30",
+        "RED": "31",
+        "GREEN": "32",
+        "YELLOW": "33",
+        "BLUE": "34",
+        "MAGENTA": "35",
+        "CYAN": "36",
+        "WHITE": "37",
+        "BRIGHT_BLACK": "90",
+        "BRIGHT_RED": "91",
+        "BRIGHT_GREEN": "92",
+        "BRIGHT_YELLOW": "93",
+        "BRIGHT_BLUE": "94",
+        "BRIGHT_MAGENTA": "95",
+        "BRIGHT_CYAN": "96",
+        "BRIGHT_WHITE": "97",
+    }
+
+    def fg(self, rgb: Tuple[int, int, int]) -> str:
+        """Return the ANSI escape sequence for a 24-bit foreground color."""
+        r, g, b = rgb
+        return f"\033[38;2;{r};{g};{b}m"
+
+    def bg(self, rgb: Tuple[int, int, int]) -> str:
+        """Return the ANSI escape sequence for a 24-bit background color."""
+        r, g, b = rgb
+        return f"\033[48;2;{r};{g};{b}m"
+
+    def block_prefix(self, style: Dict[str, object]) -> str:
+        """Build the base ANSI prefix for a rendered block.
+
+        The prefix applies the block-level foreground and background colors defined by
+        a style map. It is prepended to each physical output line in the block and also
+        used after inline resets so block colors continue to apply.
+        """
+        parts: List[str] = []
+        if "color" in style:
+            parts.append(self.fg(style["color"]))  # type: ignore[arg-type]
+        if "background-color" in style:
+            parts.append(self.bg(style["background-color"]))  # type: ignore[arg-type]
+        return "".join(parts)
+
+    def visible_len(self, rendered: str) -> int:
+        """Return the printable width of a rendered string.
+
+        ANSI escape sequences do not occupy terminal columns, so they are removed
+        before counting characters.
+        """
+        return len(ANSI_RE.sub("", rendered))
+
+    def pad_rendered_line(self, rendered: str, target_width: int) -> str:
+        """Pad a rendered string with spaces up to ``target_width`` visible columns.
+
+        The method measures width after stripping ANSI escapes so padding aligns with
+        what the terminal actually displays rather than with the raw string length.
+        """
+        visible = self.visible_len(rendered)
+        return rendered + (" " * max(0, target_width - visible))
+
+    def render_token(self, token: Token, block_prefix: str = "") -> str:
+        """Render a ``Token`` into ANSI text, restoring the block style afterward.
+
+        If the token has inline styles, the method emits a style escape sequence, the
+        token text, and then resets terminal state. When ``block_prefix`` is supplied,
+        it is re-applied after the reset so block colors remain active for the rest of
+        the line.
+        """
+        if not token.styles:
+            return token.text
+
+        codes = [self.STYLE_CODES[style] for style in token.styles]
+        restore = f"{self.RESET}{block_prefix}" if block_prefix else self.RESET
+        return f"\033[{';'.join(codes)}m{token.text}{restore}"
+
+    def render_plain_line(self, parts: List[Token], block_prefix: str) -> str:
+        """Render a sequence of tokens separated by single spaces.
+
+        This preserves the token order exactly as it appears in the wrapped line model
+        and applies inline ANSI styling token by token.
+        """
+        return " ".join(self.render_token(part, block_prefix) for part in parts)
+
+    def justify_rendered_line(self, parts: List[Token], width: int, block_prefix: str) -> str:
+        """Render and justify a non-final line to exactly ``width`` columns.
+
+        Visible spacing is distributed across the gaps between tokens while each token
+        continues to be rendered with its inline styles. The calculation is based on
+        visible character widths rather than raw string lengths.
+        """
+        if not parts:
+            return " " * width
+        if len(parts) == 1:
+            return self.render_token(parts[0], block_prefix)
+
+        total_chars = sum(len(part.text) for part in parts)
+        gaps = len(parts) - 1
+        total_spaces = width - total_chars
+        base, extra = divmod(total_spaces, gaps)
+
+        output: List[str] = []
+        for index, part in enumerate(parts[:-1]):
+            output.append(self.render_token(part, block_prefix))
+            output.append(" " * (base + (1 if index < extra else 0)))
+        output.append(self.render_token(parts[-1], block_prefix))
+        return "".join(output)
+
+    def align_rendered_line(
+        self,
+        rendered: str,
+        visible: str,
+        width: Optional[int],
+        alignment: str,
+    ) -> str:
+        """Apply left, right, or center alignment to a rendered line.
+
+        ``visible`` supplies the plain-text version of the line so alignment can be
+        computed correctly even when ``rendered`` contains ANSI escape sequences.
+        """
+        if width is None:
+            return rendered
+
+        visible_len = len(visible)
+        if visible_len >= width:
+            return rendered
+
+        if alignment == "right":
+            return (" " * (width - visible_len)) + rendered
+        if alignment == "center":
+            left = (width - visible_len) // 2
+            right = width - visible_len - left
+            return (" " * left) + rendered + (" " * right)
+        return rendered + (" " * (width - visible_len))
+
+    def name_prefix(self, style: Dict[str, object]) -> str:
+        """Build the ANSI prefix for description-list labels.
+
+        Description names may use ``name-color`` when present, otherwise they inherit
+        the normal text color. The background color, if any, is always preserved so the
+        label blends into the containing block.
+        """
+        parts: List[str] = []
+        if "name-color" in style:
+            parts.append(self.fg(style["name-color"]))  # type: ignore[arg-type]
+        elif "color" in style:
+            parts.append(self.fg(style["color"]))  # type: ignore[arg-type]
+        if "background-color" in style:
+            parts.append(self.bg(style["background-color"]))  # type: ignore[arg-type]
+        return "".join(parts)
+
+    def render_description_name(self, name: str, style: Dict[str, object], block_prefix: str) -> str:
+        """Render the leading name of a description item in bold, with optional color.
+
+        The generated string resets styling at the end of the label and then restores
+        the surrounding block prefix so subsequent description text continues with the
+        block's normal styling.
+        """
+        name_prefix = self.name_prefix(style)
+        if not name_prefix:
+            return f"{self.BOLD}{name}{self.BOLD_OFF}"
+        return f"{name_prefix}{self.BOLD}{name}{self.RESET}{block_prefix}"
+
+    def render_lines_block(
+        self,
+        rendered_lines: List[str],
+        style: Dict[str, object],
+        visible_lines: Optional[List[str]] = None,
+    ) -> str:
+        """Wrap already-rendered lines in block-level padding and color styling.
+
+        This method is responsible for adding top and bottom blank padding lines, left
+        and right space padding, and the block-level ANSI prefix/reset around every
+        physical output line.
+        """
+        padding_top, padding_bottom, padding_left, padding_right = get_padding(style)
+        prefix = self.block_prefix(style)
+
+        if not rendered_lines:
+            rendered_lines = [""]
+
+        if visible_lines is None:
+            visible_lines = [ANSI_RE.sub("", line) for line in rendered_lines]
+
+        content_width = max(len(line) for line in visible_lines) + padding_left + padding_right
+        blank_line = " " * content_width
+        visible_width = max(len(line) for line in visible_lines)
+
+        lines: List[str] = []
+
+        for _ in range(padding_top):
+            lines.append(f"{prefix}{blank_line}{self.RESET}")
+
+        for rendered_line in rendered_lines:
+            padded = self.pad_rendered_line(rendered_line, visible_width)
+            content_line = f"{' ' * padding_left}{padded}{' ' * padding_right}"
+            lines.append(f"{prefix}{content_line}{self.RESET}")
+
+        for _ in range(padding_bottom):
+            lines.append(f"{prefix}{blank_line}{self.RESET}")
+
+        return "\n".join(lines)
+
+    def render_single_block(self, text: str, style: Dict[str, object]) -> str:
+        """Render a one-line block using the same padding and color rules as multi-line blocks."""
+        return self.render_lines_block([text], style, visible_lines=[ANSI_RE.sub("", text)])
+

yacta-0.0.1/src/yacta/cmd.py

@@ -0,0 +1,33 @@
+import typer
+from typing import Optional
+from .common import *
+
+
+def main():
+    app = typer.Typer()
+
+    @app.command()
+    def run(
+        stylesheet: str = typer.Argument(help="Path to CSS-like stylesheet"),
+        textfile: str = typer.Argument(help="Path to marked-up text file"),
+        language: str = typer.Option(
+            "en_US",
+            "--language",
+            help="Hyphenation language for all non-header selectors (default: en_US)"
+        )
+    ) -> int:
+        """Parse command-line arguments, render the requested files, and return a process exit code.
+        Exit code ``0`` indicates success. ``1`` reports a missing file, and ``2``
+        reports invalid input such as malformed stylesheet values.
+        """
+        try:
+            render_file(stylesheet, textfile, language)
+            return 0
+        except FileNotFoundError as e:
+            print(f"File not found: {e.filename}", file=sys.stderr)
+            return 1
+        except ValueError as e:
+            print(f"Error: {e}", file=sys.stderr)
+            return 2
+
+    app()

yacta-0.0.1/src/yacta/command_block_processor.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+import re
+import shlex
+import subprocess
+import sys
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple
+from hyphen import Hyphenator
+
+COMMAND_BLOCK_OPEN = "{{{"
+COMMAND_BLOCK_CLOSE = "}}}"
+
+
+
+@dataclass(frozen=True)
+class ParsedCommandBlock:
+    """Represent one parsed command-expansion block from the content file.
+
+    ``command`` stores the command line extracted from the opening ``{{{ ...`` line.
+    ``stdin_text`` stores the literal multiline payload found between the opening and
+    closing markers. That payload is later piped to the command's standard input and
+    the resulting standard output is fed back into the normal content parser.
+    """
+    command: str
+    stdin_text: str
+
+
+class CommandBlockProcessor:
+    """Expand ``{{{ command ... }}}`` blocks before normal content parsing begins.
+
+    The processor scans raw input lines for opening markers that include a command on
+    the same line, collects all following lines up to the closing ``}}}`` marker,
+    pipes that collected text to the command's standard input, captures the command's
+    standard output, and reinserts the output lines into the parse stream in place of
+    the original block.
+    """
+    OPEN_RE = re.compile(r"^\s*\{\{\{\s*(?P<command>.*?)\s*$")
+
+    @classmethod
+    def parse_opening_line(cls, line: str) -> Optional[str]:
+        """Return the command embedded in a command-block opening line.
+
+        The opening marker must appear on the same line as the command text, for
+        example ``{{{ sort -r``. Surrounding whitespace is ignored. When the line is
+        not a command-block opener, ``None`` is returned.
+        """
+        match = cls.OPEN_RE.match(line.rstrip("\n"))
+        if not match:
+            return None
+        return match.group("command").strip()
+
+    @staticmethod
+    def is_closing_line(line: str) -> bool:
+        """Return ``True`` when ``line`` is the closing ``}}}`` marker.
+
+        Surrounding whitespace is ignored so the marker can be indented in the input
+        file without affecting recognition.
+        """
+        return line.rstrip("\n").strip() == COMMAND_BLOCK_CLOSE
+
+    @classmethod
+    def parse_block(cls, raw_lines: List[str], start_index: int) -> Tuple[ParsedCommandBlock, int]:
+        """Parse one command block starting at ``start_index``.
+
+        The opening line contributes the command, every following raw line up to the
+        closing marker becomes part of the command's standard input, and the returned
+        integer points to the first source line after the block. A ``ValueError`` is
+        raised for malformed blocks such as an empty command or a missing closing
+        marker.
+        """
+        command = cls.parse_opening_line(raw_lines[start_index])
+        if command is None:
+            raise ValueError("Invalid command block: missing opening '{{{' marker")
+        if not command:
+            raise ValueError("Invalid command block: missing command after '{{{' marker")
+
+        stdin_lines: List[str] = []
+        index = start_index + 1
+
+        while index < len(raw_lines):
+            raw_line = raw_lines[index]
+            if cls.is_closing_line(raw_line):
+                return ParsedCommandBlock(command, "".join(stdin_lines)), index + 1
+
+            stdin_lines.append(raw_line)
+            index += 1
+
+        raise ValueError("Invalid command block: missing closing '}}}'")
+
+    @staticmethod
+    def run_command(command: str, stdin_text: str) -> List[str]:
+        """Execute ``command`` with ``stdin_text`` piped to standard input.
+
+        The command line is split with ``shlex.split`` and executed with
+        ``shell=False`` so arguments are parsed predictably and shell expansion is not
+        applied implicitly. Standard output is returned as a list of raw lines that
+        can be reinserted into the parser input stream. Non-zero exit codes and start
+        failures are reported as ``ValueError`` with the captured error details.
+        """
+        argv = shlex.split(command)
+        if not argv:
+            raise ValueError("Invalid command block: empty command")
+
+        try:
+            completed = subprocess.run(
+                argv,
+                input=stdin_text,
+                text=True,
+                capture_output=True,
+                check=False,
+            )
+        except OSError as e:
+            raise ValueError(f"Command block failed to start: {command}: {e}") from e
+
+        if completed.returncode != 0:
+            stderr = completed.stderr.rstrip("\n")
+            if stderr:
+                raise ValueError(
+                    f"Command block failed with exit code {completed.returncode}: {command}: {stderr}"
+                )
+            raise ValueError(
+                f"Command block failed with exit code {completed.returncode}: {command}"
+            )
+
+        return completed.stdout.splitlines(keepends=True)
+
+    @classmethod
+    def expand_blocks(cls, raw_lines: List[str]) -> List[str]:
+        """Replace every command block in ``raw_lines`` with the command's output.
+
+        The returned list can be fed directly into the rest of the parsing pipeline.
+        Lines that are not part of a command block are preserved unchanged. Command
+        output is inserted verbatim so it can contain normal selector lines, blank
+        lines, or even structural markers such as the two-column delimiters.
+        """
+        expanded: List[str] = []
+        index = 0
+
+        while index < len(raw_lines):
+            command = cls.parse_opening_line(raw_lines[index])
+            if command is None:
+                expanded.append(raw_lines[index])
+                index += 1
+                continue
+
+            block, index = cls.parse_block(raw_lines, index)
+            expanded.extend(cls.run_command(block.command, block.stdin_text))
+
+        return expanded
+