linerepeat 0.1.0__py3-none-any.whl

linerepeat/__init__.py

@@ -0,0 +1,4 @@
+from linerepeat.cli import app
+
+if __name__ == "__main__":
+    app()

linerepeat/cli.py

@@ -0,0 +1,84 @@
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from linerepeat.repeat import *
+from linerepeat.stream import *
+
+app = typer.Typer(add_completion=False)
+
+
+@app.command()
+def linerepeat(
+    count: Annotated[
+        int,
+        typer.Argument(
+            min=1,
+            help="How many times to repeat.",
+        ),
+    ],
+    input_file: Annotated[
+        Path | None,
+        typer.Option(
+            "-i",
+            "--input",
+            exists=True,
+            dir_okay=False,
+            readable=True,
+            writable=True,
+            help="Edit this file in place instead of reading stdin.",
+        ),
+    ] = None,
+    output_file: Annotated[
+        Path | None,
+        typer.Option(
+            "-o",
+            "--output",
+            dir_okay=False,
+            help="Write here instead of stdout. Can't be used with --input.",
+        ),
+    ] = None,
+    separator: Annotated[
+        str,
+        typer.Option(
+            "-s",
+            "--separator",
+            help="Line placed between repeats.",
+        ),
+    ] = "",
+    mode: Annotated[
+        Mode,
+        typer.Option(
+            "-m",
+            "--mode",
+            help="Repeat single lines or blocks.",
+        ),
+    ] = Mode.LINE,
+    till: Annotated[
+        int,
+        typer.Option(
+            "-t",
+            "--till",
+            help="Lines per block (block mode).",
+        ),
+    ] = 0,
+):
+
+    if input_file is not None and output_file is not None:
+        raise typer.BadParameter(
+            "can't be used with --input, which edits the file in place.",
+            param_hint="--output",
+        )
+
+    # Open input (stdin or file) and process with repeat()
+    with open_input(input_file) as src:
+        try:
+            result = repeat(src, count, separator=separator, mode=mode, till=till)
+        except ValueError as e:
+            raise typer.BadParameter(str(e)) from e
+
+        # Write output to stdout, file, or back to input file
+        with open_output(input_path=input_file, output_path=output_file) as out:
+            write_lines(out, result)
+

linerepeat/repeat.py

@@ -0,0 +1,70 @@
+from collections.abc import Iterable, Iterator
+from enum import StrEnum
+from itertools import islice
+from itertools import repeat as _times
+
+
+class Mode(StrEnum):
+    LINE = "line"
+    BLOCK = "block"
+
+
+def _clean(lines: Iterable[str]) -> Iterator[str]:
+    """Strip trailing newlines and skip empty lines."""
+    for line in lines:
+        s = line.rstrip("\n\r")
+        if s.strip():
+            yield s
+
+
+def _chunks(items: Iterator[str], size: int) -> Iterator[list[str]]:
+    """
+    Group items into chunks of the given size.
+
+    Args:
+        items: Iterator of items to chunk.
+        size: Number of items per chunk.
+
+    Yields:
+        Lists of items, each up to 'size' long.
+    """
+    while chunk := list(islice(items, size)):
+        yield chunk
+
+
+def _generate(lines, count, separator, mode, till) -> Iterator[str]:
+    """
+    In LINE mode: each line is repeated 'count' times, with separator between.
+    In BLOCK mode: lines are grouped into blocks of 'till' lines, then each
+    block is repeated 'count' times with separator between blocks.
+    """
+    first = True
+    if mode == Mode.LINE:
+        for line in lines:
+            if not first:
+                yield separator
+            first = False
+            yield from _times(line, count)
+    else:
+        for block in _chunks(lines, till):
+            for _ in range(count):
+                if not first:
+                    yield separator
+                first = False
+                yield from block
+
+
+def repeat(
+    lines: Iterable[str],
+    count: int,
+    *,
+    separator: str = "",
+    mode: Mode = Mode.LINE,
+    till: int = 0,
+) -> Iterator[str]:
+
+    if count < 1:
+        raise ValueError("count must be at least 1.")
+    if mode == Mode.BLOCK and till < 2:
+        raise ValueError("till must be at least 2 in block mode.")
+    return _generate(_clean(lines), count, separator, mode, till)

linerepeat/stream.py

@@ -0,0 +1,87 @@
+import os
+import shutil
+import sys
+import tempfile
+from collections.abc import Generator, Iterable
+from contextlib import contextmanager
+from pathlib import Path
+from typing import TextIO
+
+
+@contextmanager
+def open_input(path: Path | None) -> Generator[TextIO]:
+    """Open an input file or stdin."""
+    if path is None:
+        yield sys.stdin
+    else:
+        with path.open(encoding="utf-8") as f:
+            yield f
+
+
+@contextmanager
+def open_output(
+    *,
+    input_path: Path | None,
+    output_path: Path | None,
+) -> Generator[TextIO]:
+    """
+    Open an output destination based on arguments.
+
+    Priority:
+    1. If input_path is given: edit that file in place.
+    2. Else if output_path is given: write to that file.
+    3. Else: write to stdout.
+
+    Yields:
+        Open file handle for writing.
+    """
+
+    if input_path is not None:
+        with _replace_in_place(input_path) as f:
+            yield f
+    elif output_path is not None:
+        with output_path.open("w", encoding="utf-8") as f:
+            yield f
+    else:
+        yield sys.stdout
+
+
+@contextmanager
+def _replace_in_place(path: Path) -> Generator[TextIO]:
+    """
+    Replace a file by writing to a temp file first then swap it.
+
+    Args:
+        path: File to replace.
+
+    Yields:
+        Open temp file handle for writing.
+    """
+    target = path.resolve()
+    fd, tmp_name = tempfile.mkstemp(
+        dir=target.parent,
+        prefix=f".{target.name}.",
+        suffix=".tmp",
+    )
+
+    tmp = Path(tmp_name)
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as f:
+            yield f
+        shutil.copymode(target, tmp)
+        os.replace(tmp, target)
+    except BaseException:
+        tmp.unlink(missing_ok=True)  # Clean up temp file on any error
+        raise
+
+
+def write_lines(out: TextIO, lines: Iterable[str]) -> None:
+    """
+    Write lines to an output stream, adding newline after each.
+
+    Args:
+        out: Output file handle.
+        lines: Lines to write.
+    """
+    out.writelines(f"{line}\n" for line in lines)
+

linerepeat-0.1.0.dist-info/METADATA

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: linerepeat
+Version: 0.1.0
+Summary: A small CLI tool for repeating lines
+Keywords: cli,text,lines,repeat,typer
+Author: Abdullah Alhamdi
+Author-email: Abdullah Alhamdi <trymemain.pb.hug@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Utilities
+Classifier: Environment :: Console
+Requires-Dist: typer>=0.27.3
+Requires-Python: >=3.14
+Project-URL: Repository, https://github.com/cqveman/linerepeat
+Project-URL: Issues, https://github.com/cqveman/linerepeat/issues
+Description-Content-Type: text/markdown
+
+# linerepeat
+
+A small CLI tool for repeating lines from stdin or files. Useful for generating test data, creating separators, duplicating content, or any task where you need to repeat text patterns.
+
+**Features:**
+- **Line mode** (default): Repeat each input line N times
+- **Block mode**: Repeat groups of lines as blocks
+- **Custom separators**: Add delimiters between input line groups
+- **Flexible I/O**: Read from stdin/files, write to stdout/files
+
+## Install
+
+### From PyPI
+```bash
+pip install linerepeat
+```
+
+### Pre-built Binaries
+Download the latest `linerepeat` binary (Linux) or `linerepeat.exe` (Windows) from [GitHub Releases](https://github.com/cqveman/linerepeat/releases).
+
+## Usage
+
+```console
+$ linerepeat [OPTIONS] {count}
+```
+
+**Arguments:**
+
+* `count`: How many times to repeat.  [required]
+
+**Options:**
+
+* `-i, --input <file>`: Edit this file in place instead of reading stdin.
+* `-o, --output <file>`: Write here instead of stdout. Can't be used with --input.
+* `-s, --separator <str>`: Line placed between repeats.
+* `-m, --mode <line|block>`: Repeat single lines or blocks.  [default: line]
+* `-t, --till <int>`: Lines per block (block mode).  [default: 0]
+* `--help`: Show this message and exit.
+
+## Examples
+
+```bash
+# Repeat each line 3 times (single line - no separator printed)
+echo "hello" | linerepeat 3
+# hello
+# hello
+# hello
+
+# With multiple input lines, separator goes BETWEEN lines
+echo -e "a\nb" | linerepeat 2 -s "---"
+# a
+# a
+# ---
+# b
+# b
+
+# Block mode with separator between blocks
+echo -e "line1\nline2\nline3\nline4" | linerepeat 2 -m block -t 2 -s "==="
+# line1
+# line2
+# ===
+# line1
+# line2
+# ===
+# line3
+# line4
+# ===
+# line3
+# line4
+
+# In-place: duplicate every line in a file
+linerepeat 2 -i file.txt
+```
+
+## License
+
+MIT

linerepeat-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+linerepeat/__init__.py,sha256=qFBngyNSMJmQkLqHmg_7Qdfsj1luWFrnoqTNAQjcnS4,69
+linerepeat/cli.py,sha256=Wj9TrbphG4Cn9fSLmeAoz4JpffF_rEttJpEztdEfwhA,2108
+linerepeat/repeat.py,sha256=a0MhnC4mICYXc1AF33Tupi-6XokHikWaHAWeIBZIprc,1887
+linerepeat/stream.py,sha256=jXIkMLoY7y_u-DwDCWoCTOMk0ED9PaDa0ErEInBI4W4,2041
+linerepeat-0.1.0.dist-info/licenses/LICENSE,sha256=CnFMEubZ7OsHq09PjFlPXpUK1a0XoWxmpvytO_38FCI,1068
+linerepeat-0.1.0.dist-info/WHEEL,sha256=1dD_GoEqEIxQ7VnrUExgdj_eExY4b4UgfR0iBlGKVac,80
+linerepeat-0.1.0.dist-info/entry_points.txt,sha256=hV4ekhXNleapYp0Sl2JbfDCLRTCIfYu_5GtNvFbW0S8,51
+linerepeat-0.1.0.dist-info/METADATA,sha256=qpZi9j5Km-Mx-eohcNr6rPDskBiLhDIakf2Hf5UEv8k,2515
+linerepeat-0.1.0.dist-info/RECORD,,

linerepeat-0.1.0.dist-info/WHEEL

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

linerepeat-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+linerepeat = linerepeat.cli:app
+

linerepeat-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2026 Abdullah Alhamdi
+
+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.