pste 0.2.0__tar.gz

pste-0.2.0/.gitignore

@@ -0,0 +1,10 @@
+__pycache__/
+*.pyc
+.env
+data/
+dist/
+.venv/
+*.egg-info/
+*.egg
+.pytest_cache/
+build/

pste-0.2.0/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: pste
+Version: 0.2.0
+Summary: Command-line client for pste, a self-hosted paste server inspired by sprunge
+Project-URL: Homepage, https://github.com/crognlie/pste
+Project-URL: Repository, https://github.com/crognlie/pste
+License: MIT
+Keywords: cli,paste,pastebin,sprunge
+Requires-Python: >=3.11
+Requires-Dist: pygments>=2.17
+Requires-Dist: requests>=2.31
+Provides-Extra: test
+Requires-Dist: pytest>=8.0; extra == 'test'
+Requires-Dist: responses>=0.25; extra == 'test'
+Description-Content-Type: text/markdown
+
+# pste
+
+Command-line client for [pste-server](../server/), a self-hosted paste server inspired by [sprunge](http://sprunge.us).
+
+## Installation
+
+```bash
+pip install pste
+# or
+pipx install pste
+```
+
+## Configuration
+
+Set `PSTE_URL` to the bookmark URL printed by `pste-admin key add` on the server — the same URL you'd save in a browser to use the web form:
+
+```bash
+export PSTE_URL="https://pste.example.com/?key=your-api-key"
+```
+
+## Usage
+
+```bash
+# Create a paste from stdin
+echo "hello world" | pste
+pste < file.txt
+cat file.txt | pste
+
+# Create with options
+echo "hello" | pste -s              # single-view (deleted after first read)
+echo "hello" | pste -e 7d           # expires in 7 days
+echo "hello" | pste -e 2W           # expires in 2 weeks
+pste -l python < script.py          # explicit syntax highlighting language
+pste -l < script.py                 # auto-detect language (Pygments, >0.5 confidence)
+
+# Fetch a paste (by ID or full URL)
+pste AB1234
+pste https://pste.example.com/AB1234
+pste https://pste.example.com/AB1234?python   # ?lang is stripped; always fetches plain text
+```
+
+## Language flag behaviour
+
+| Invocation | What is sent | URL returned |
+|---|---|---|
+| `pste` (no `-l`) | nothing | plain URL |
+| `pste -l python` | `lang=python` | `https://host/AB1234?python` |
+| `pste -l` (no value) | `auto_detect=1` | `https://host/AB1234?python` if detected, else plain URL |
+
+When a `?<lang>` URL is returned, opening it in a browser shows Pygments-highlighted HTML with table line numbers (Ctrl-A selects only the code) and a Copy button. Fetching via `pste` always strips the `?lang` and returns plain text.
+
+## Expiry format
+
+`-e`/`--expire` accepts an integer followed by a unit:
+- `H` — hours
+- `D` — days
+- `W` — weeks
+- `M` — minutes
+
+Examples: `24H`, `7D`, `2W`, `30M`

pste-0.2.0/README.md

@@ -0,0 +1,60 @@
+# pste
+
+Command-line client for [pste-server](../server/), a self-hosted paste server inspired by [sprunge](http://sprunge.us).
+
+## Installation
+
+```bash
+pip install pste
+# or
+pipx install pste
+```
+
+## Configuration
+
+Set `PSTE_URL` to the bookmark URL printed by `pste-admin key add` on the server — the same URL you'd save in a browser to use the web form:
+
+```bash
+export PSTE_URL="https://pste.example.com/?key=your-api-key"
+```
+
+## Usage
+
+```bash
+# Create a paste from stdin
+echo "hello world" | pste
+pste < file.txt
+cat file.txt | pste
+
+# Create with options
+echo "hello" | pste -s              # single-view (deleted after first read)
+echo "hello" | pste -e 7d           # expires in 7 days
+echo "hello" | pste -e 2W           # expires in 2 weeks
+pste -l python < script.py          # explicit syntax highlighting language
+pste -l < script.py                 # auto-detect language (Pygments, >0.5 confidence)
+
+# Fetch a paste (by ID or full URL)
+pste AB1234
+pste https://pste.example.com/AB1234
+pste https://pste.example.com/AB1234?python   # ?lang is stripped; always fetches plain text
+```
+
+## Language flag behaviour
+
+| Invocation | What is sent | URL returned |
+|---|---|---|
+| `pste` (no `-l`) | nothing | plain URL |
+| `pste -l python` | `lang=python` | `https://host/AB1234?python` |
+| `pste -l` (no value) | `auto_detect=1` | `https://host/AB1234?python` if detected, else plain URL |
+
+When a `?<lang>` URL is returned, opening it in a browser shows Pygments-highlighted HTML with table line numbers (Ctrl-A selects only the code) and a Copy button. Fetching via `pste` always strips the `?lang` and returns plain text.
+
+## Expiry format
+
+`-e`/`--expire` accepts an integer followed by a unit:
+- `H` — hours
+- `D` — days
+- `W` — weeks
+- `M` — minutes
+
+Examples: `24H`, `7D`, `2W`, `30M`

pste-0.2.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pste"
+version = "0.2.0"
+description = "Command-line client for pste, a self-hosted paste server inspired by sprunge"
+readme = "README.md"
+license = {text = "MIT"}
+keywords = ["pastebin", "paste", "sprunge", "cli"]
+requires-python = ">=3.11"
+dependencies = [
+    "requests>=2.31",
+    "pygments>=2.17",
+]
+
+[project.urls]
+Homepage = "https://github.com/crognlie/pste"
+Repository = "https://github.com/crognlie/pste"
+
+[project.optional-dependencies]
+test = ["pytest>=8.0", "responses>=0.25"]
+
+[project.scripts]
+pste = "pste.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pste"]

pste-0.2.0/src/pste/cli.py

@@ -0,0 +1,179 @@
+import argparse
+import os
+import re
+import sys
+from datetime import datetime, timedelta, timezone
+from urllib.parse import parse_qs, urlparse
+
+import requests
+
+TTL_RE = re.compile(r"^(\d+)([MmWwDdHh])$")
+_UNIT_SECONDS = {
+    "H": 3600,
+    "D": 86400,
+    "W": 7 * 86400,
+    "M": 60,
+}
+
+_TIMEOUT = 10
+_URL_ERROR = (
+    "error: PSTE_URL not set — set it to your pste bookmark URL, "
+    "e.g. https://pste.example.com/?key=your-key"
+)
+
+
+def _parse_pste_url():
+    """Return (server, api_key) from PSTE_URL, or (None, None) if unset."""
+    raw = os.environ.get("PSTE_URL", "").strip()
+    if not raw:
+        return None, None
+    parsed = urlparse(raw)
+    key = parse_qs(parsed.query).get("key", [None])[0]
+    server = f"{parsed.scheme}://{parsed.netloc}".rstrip("/")
+    return server, key
+
+
+def _parse_ttl(value: str) -> str:
+    """Parse TTL string like '7d', '2W', '48H'; return ISO8601 UTC expires_at."""
+    m = TTL_RE.match(value)
+    if not m:
+        print(f"error: invalid expire format {value!r} (expected e.g. 7d, 2W, 48H, 3M)", file=sys.stderr)
+        sys.exit(1)
+    n, unit = int(m.group(1)), m.group(2).upper()
+    dt = datetime.now(timezone.utc) + timedelta(seconds=n * _UNIT_SECONDS[unit])
+    return dt.strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _validate_lang(lang: str) -> str:
+    from pygments.lexers import get_lexer_by_name
+    from pygments.util import ClassNotFound
+    try:
+        get_lexer_by_name(lang)
+    except ClassNotFound:
+        print(f"error: unknown language/lexer {lang!r}", file=sys.stderr)
+        sys.exit(1)
+    return lang
+
+
+def _fetch_paste(url: str) -> int:
+    try:
+        resp = requests.get(url, timeout=_TIMEOUT)
+    except requests.exceptions.ConnectTimeout:
+        print("error: http connection timed out", file=sys.stderr)
+        return 1
+    except requests.exceptions.ReadTimeout:
+        print("error: http request timed out", file=sys.stderr)
+        return 1
+
+    if resp.status_code == 404:
+        print(f"error: paste not found", file=sys.stderr)
+        return 1
+    if resp.status_code != 200:
+        print(f"error: server returned HTTP {resp.status_code}", file=sys.stderr)
+        return 1
+
+    print(resp.text.rstrip())
+    return 0
+
+
+def _create_paste(content: str, args, server: str, api_key: str) -> int:
+    data = {"pste": content}
+    if args.single_view:
+        data["single_view"] = "1"
+    if args.expire:
+        data["expires_at"] = _parse_ttl(args.expire)
+    if args.lang is None:
+        pass  # no -l flag: no lang, no auto-detection
+    elif args.lang == "":
+        data["auto_detect"] = "1"  # -l with no value: request auto-detection
+    else:
+        data["lang"] = _validate_lang(args.lang)  # -l python: explicit lang
+
+    try:
+        resp = requests.post(
+            server + "/",
+            data=data,
+            headers={"Authorization": f"Bearer {api_key}"},
+            timeout=_TIMEOUT,
+        )
+    except requests.exceptions.ConnectTimeout:
+        print("error: http connection timed out", file=sys.stderr)
+        return 1
+    except requests.exceptions.ReadTimeout:
+        print("error: http request timed out", file=sys.stderr)
+        return 1
+
+    if resp.status_code == 401:
+        print("error: authentication failed — check your API key", file=sys.stderr)
+        return 1
+    if resp.status_code == 403:
+        print("error: API key is disabled", file=sys.stderr)
+        return 1
+    if resp.status_code != 200:
+        print(f"error: server returned HTTP {resp.status_code}: {resp.text.strip()}", file=sys.stderr)
+        return 1
+
+    print(resp.text.strip())
+    return 0
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Upload text from stdin to a pste server. "
+            "If [id] is provided, the paste is fetched instead."
+        ),
+        epilog="environment variables:\n  PSTE_URL  server URL with API key, e.g. https://pste.example.com/?key=your-key",
+        formatter_class=argparse.RawTextHelpFormatter,
+    )
+    parser.add_argument("id", nargs="?", help="Fetch paste by ID or full URL")
+    parser.add_argument("-s", "--single-view", action="store_true", help="Single-view paste")
+    parser.add_argument("-e", "--expire", metavar="TTL", help="Expiry: e.g. 7D, 2W, 48H, 30M (M=minutes)")
+    parser.add_argument(
+        "-l", "--lang", "--language",
+        metavar="LEXER", nargs="?", const="", default=None,
+        help="Syntax highlighting language (omit value to auto-detect)",
+    )
+    args = parser.parse_args()
+
+    if args.id is not None:
+        # Fetch mode
+        if args.single_view or args.expire or args.lang is not None:
+            print("error: -s/-e/-l flags are not valid when fetching a paste", file=sys.stderr)
+            return 1
+
+        paste_id = args.id
+        if paste_id.startswith("http"):
+            # Strip any ?lang query string — bare GET always returns plain text
+            parsed = urlparse(paste_id)
+            clean_url = parsed._replace(query="").geturl()
+            return _fetch_paste(clean_url)
+
+        # Bare ID — need server from PSTE_URL
+        server, _ = _parse_pste_url()
+        if not server:
+            print(_URL_ERROR, file=sys.stderr)
+            return 1
+        return _fetch_paste(f"{server}/{paste_id}")
+
+    # Create mode — read from stdin
+    server, api_key = _parse_pste_url()
+    if not server or not api_key:
+        print(_URL_ERROR, file=sys.stderr)
+        return 1
+
+    try:
+        content = sys.stdin.read()
+    except UnicodeDecodeError as e:
+        print(f"error: {e}", file=sys.stderr)
+        return 2
+
+    if not content:
+        print("error: empty input", file=sys.stderr)
+        return 1
+
+    return _create_paste(content, args, server, api_key)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

pste-0.2.0/tests/test_cli.py

@@ -0,0 +1,328 @@
+import io
+import sys
+
+import pytest
+import responses as rsps_lib
+
+from pste.cli import _parse_ttl, _validate_lang, main
+
+
+SERVER = "http://pste.example.com"
+PSTE_URL = f"{SERVER}/?key=testkey"
+
+
+@pytest.fixture(autouse=True)
+def _env(monkeypatch):
+    monkeypatch.setenv("PSTE_URL", PSTE_URL)
+
+
+# ---------------------------------------------------------------------------
+# TTL parsing
+# ---------------------------------------------------------------------------
+
+def test_parse_ttl_valid_formats():
+    for fmt in ("7d", "7D", "2W", "2w", "48H", "48h", "3M", "3m"):
+        result = _parse_ttl(fmt)
+        assert result.endswith("Z")
+        assert "T" in result
+
+
+def test_parse_ttl_invalid_exits():
+    with pytest.raises(SystemExit):
+        _parse_ttl("badformat")
+
+
+def test_parse_ttl_invalid_fraction_exits():
+    with pytest.raises(SystemExit):
+        _parse_ttl("1.5d")
+
+
+# ---------------------------------------------------------------------------
+# Lang validation
+# ---------------------------------------------------------------------------
+
+def test_validate_lang_known():
+    assert _validate_lang("python") == "python"
+
+
+def test_validate_lang_unknown_exits():
+    with pytest.raises(SystemExit):
+        _validate_lang("notareallexer12345")
+
+
+# ---------------------------------------------------------------------------
+# Fetch mode
+# ---------------------------------------------------------------------------
+
+@rsps_lib.activate
+def test_fetch_by_id_success(monkeypatch, capsys):
+    monkeypatch.setattr(sys, "argv", ["pste", "ABC123"])
+    rsps_lib.add(rsps_lib.GET, f"{SERVER}/ABC123", body="hello world\n", status=200)
+    rc = main()
+    assert rc == 0
+    assert "hello world" in capsys.readouterr().out
+
+
+@rsps_lib.activate
+def test_fetch_404(monkeypatch, capsys):
+    monkeypatch.setattr(sys, "argv", ["pste", "ZZZZZZ"])
+    rsps_lib.add(rsps_lib.GET, f"{SERVER}/ZZZZZZ", status=404)
+    rc = main()
+    assert rc == 1
+    assert "not found" in capsys.readouterr().err
+
+
+@rsps_lib.activate
+def test_fetch_server_error(monkeypatch, capsys):
+    monkeypatch.setattr(sys, "argv", ["pste", "ABC123"])
+    rsps_lib.add(rsps_lib.GET, f"{SERVER}/ABC123", status=500)
+    rc = main()
+    assert rc == 1
+    assert "500" in capsys.readouterr().err
+
+
+def test_fetch_timeout(monkeypatch, capsys):
+    import requests.exceptions
+    monkeypatch.setattr(sys, "argv", ["pste", "ABC123"])
+    with rsps_lib.RequestsMock() as r:
+        r.add(rsps_lib.GET, f"{SERVER}/ABC123", body=requests.exceptions.ConnectTimeout())
+        rc = main()
+    assert rc == 1
+    assert "timed out" in capsys.readouterr().err
+
+
+@rsps_lib.activate
+def test_fetch_from_full_url_no_pste_url_needed(monkeypatch, capsys):
+    """Full URL can be fetched without PSTE_URL set."""
+    monkeypatch.delenv("PSTE_URL", raising=False)
+    monkeypatch.setattr(sys, "argv", ["pste", f"{SERVER}/ABC123"])
+    rsps_lib.add(rsps_lib.GET, f"{SERVER}/ABC123", body="content\n", status=200)
+    rc = main()
+    assert rc == 0
+    assert "content" in capsys.readouterr().out
+
+
+@rsps_lib.activate
+def test_fetch_full_url_with_lang_query_stripped(monkeypatch, capsys):
+    """Full URL ending in ?python is stripped before the GET request."""
+    monkeypatch.setattr(sys, "argv", ["pste", f"{SERVER}/ABC123?python"])
+    rsps_lib.add(rsps_lib.GET, f"{SERVER}/ABC123", body="plain content\n", status=200)
+    rc = main()
+    assert rc == 0
+    assert "plain content" in capsys.readouterr().out
+    # Confirm the request was made without the query string
+    assert rsps_lib.calls[0].request.url == f"{SERVER}/ABC123"
+
+
+def test_fetch_by_id_no_pste_url(monkeypatch, capsys):
+    monkeypatch.delenv("PSTE_URL", raising=False)
+    monkeypatch.setattr(sys, "argv", ["pste", "ABC123"])
+    rc = main()
+    assert rc == 1
+    assert "PSTE_URL" in capsys.readouterr().err
+
+
+def test_fetch_flags_rejected_in_fetch_mode(monkeypatch, capsys):
+    monkeypatch.setattr(sys, "argv", ["pste", "-s", "ABC123"])
+    rc = main()
+    assert rc == 1
+    assert "not valid" in capsys.readouterr().err
+
+
+def test_fetch_bare_l_flag_rejected_in_fetch_mode(monkeypatch, capsys):
+    """-l with no value is still a flag and must be rejected in fetch mode."""
+    monkeypatch.setattr(sys, "argv", ["pste", "-l", "ABC123"])
+    # -l consumes ABC123 as the lang value, leaving no positional ID → create mode
+    # but stdin is empty → error
+    monkeypatch.setattr(sys, "stdin", io.StringIO(""))
+    rc = main()
+    assert rc == 1
+
+
+# ---------------------------------------------------------------------------
+# Create mode
+# ---------------------------------------------------------------------------
+
+@rsps_lib.activate
+def test_create_success(monkeypatch, capsys):
+    monkeypatch.setattr(sys, "argv", ["pste"])
+    monkeypatch.setattr(sys, "stdin", io.StringIO("hello world"))
+    rsps_lib.add(rsps_lib.POST, f"{SERVER}/", body=f"{SERVER}/AB1234\n", status=200)
+    rc = main()
+    assert rc == 0
+    assert "AB1234" in capsys.readouterr().out
+
+
+@rsps_lib.activate
+def test_create_sends_auth_header(monkeypatch):
+    monkeypatch.setattr(sys, "argv", ["pste"])
+    monkeypatch.setattr(sys, "stdin", io.StringIO("hello"))
+    rsps_lib.add(rsps_lib.POST, f"{SERVER}/", body=f"{SERVER}/AB1234\n", status=200)
+    main()
+    assert rsps_lib.calls[0].request.headers["Authorization"] == "Bearer testkey"
+
+
+def test_create_no_pste_url(monkeypatch, capsys):
+    monkeypatch.delenv("PSTE_URL", raising=False)
+    monkeypatch.setattr(sys, "argv", ["pste"])
+    monkeypatch.setattr(sys, "stdin", io.StringIO("hello"))
+    rc = main()
+    assert rc == 1
+    assert "PSTE_URL" in capsys.readouterr().err
+
+
+@rsps_lib.activate
+def test_create_auth_failure(monkeypatch, capsys):
+    monkeypatch.setattr(sys, "argv", ["pste"])
+    monkeypatch.setattr(sys, "stdin", io.StringIO("hello"))
+    rsps_lib.add(rsps_lib.POST, f"{SERVER}/", status=401)
+    rc = main()
+    assert rc == 1
+    assert "authentication" in capsys.readouterr().err
+
+
+@rsps_lib.activate
+def test_create_disabled_key(monkeypatch, capsys):
+    monkeypatch.setattr(sys, "argv", ["pste"])
+    monkeypatch.setattr(sys, "stdin", io.StringIO("hello"))
+    rsps_lib.add(rsps_lib.POST, f"{SERVER}/", status=403)
+    rc = main()
+    assert rc == 1
+    assert "disabled" in capsys.readouterr().err
+
+
+@rsps_lib.activate
+def test_create_server_error(monkeypatch, capsys):
+    monkeypatch.setattr(sys, "argv", ["pste"])
+    monkeypatch.setattr(sys, "stdin", io.StringIO("hello"))
+    rsps_lib.add(rsps_lib.POST, f"{SERVER}/", status=500, body="oops")
+    rc = main()
+    assert rc == 1
+    assert "500" in capsys.readouterr().err
+
+
+def test_create_empty_stdin(monkeypatch, capsys):
+    monkeypatch.setattr(sys, "argv", ["pste"])
+    monkeypatch.setattr(sys, "stdin", io.StringIO(""))
+    rc = main()
+    assert rc == 1
+    assert "empty" in capsys.readouterr().err
+
+
+@rsps_lib.activate
+def test_create_single_view_flag(monkeypatch):
+    monkeypatch.setattr(sys, "argv", ["pste", "-s"])
+    monkeypatch.setattr(sys, "stdin", io.StringIO("secret"))
+    rsps_lib.add(rsps_lib.POST, f"{SERVER}/", body=f"{SERVER}/AB1234\n", status=200)
+    main()
+    assert "single_view=1" in rsps_lib.calls[0].request.body
+
+
+@rsps_lib.activate
+def test_create_explicit_lang_flag(monkeypatch, capsys):
+    """-l python sends lang=python and prints the ?python URL."""
+    monkeypatch.setattr(sys, "argv", ["pste", "-l", "python"])
+    monkeypatch.setattr(sys, "stdin", io.StringIO("print('hi')"))
+    rsps_lib.add(rsps_lib.POST, f"{SERVER}/", body=f"{SERVER}/AB1234?python\n", status=200)
+    rc = main()
+    assert rc == 0
+    body = rsps_lib.calls[0].request.body
+    assert "lang=python" in body
+    assert "auto_detect" not in body
+    assert "AB1234?python" in capsys.readouterr().out
+
+
+@rsps_lib.activate
+def test_create_lang_auto_detect_bare_flag(monkeypatch, capsys):
+    """-l with no value sends auto_detect=1 (not lang=); prints returned URL."""
+    monkeypatch.setattr(sys, "argv", ["pste", "-l"])
+    monkeypatch.setattr(sys, "stdin", io.StringIO("print('hi')"))
+    rsps_lib.add(rsps_lib.POST, f"{SERVER}/", body=f"{SERVER}/AB1234?python\n", status=200)
+    rc = main()
+    assert rc == 0
+    body = rsps_lib.calls[0].request.body
+    assert "auto_detect=1" in body
+    assert "lang=" not in body
+    assert "AB1234?python" in capsys.readouterr().out
+
+
+@rsps_lib.activate
+def test_create_no_lang_flag_sends_neither(monkeypatch):
+    """No -l flag: neither lang nor auto_detect is sent."""
+    monkeypatch.setattr(sys, "argv", ["pste"])
+    monkeypatch.setattr(sys, "stdin", io.StringIO("hello"))
+    rsps_lib.add(rsps_lib.POST, f"{SERVER}/", body=f"{SERVER}/AB1234\n", status=200)
+    main()
+    body = rsps_lib.calls[0].request.body
+    assert "lang=" not in body
+    assert "auto_detect" not in body
+
+
+@rsps_lib.activate
+def test_create_expire_flag(monkeypatch):
+    monkeypatch.setattr(sys, "argv", ["pste", "-e", "7d"])
+    monkeypatch.setattr(sys, "stdin", io.StringIO("hello"))
+    rsps_lib.add(rsps_lib.POST, f"{SERVER}/", body=f"{SERVER}/AB1234\n", status=200)
+    main()
+    assert "expires_at=" in rsps_lib.calls[0].request.body
+
+
+def test_fetch_read_timeout(monkeypatch, capsys):
+    import responses as rsps_lib2
+    import requests
+    monkeypatch.setattr(sys, "argv", ["pste", "AB1234"])
+    with rsps_lib2.RequestsMock() as rsps:
+        rsps.add(rsps_lib2.GET, f"{SERVER}/AB1234", body=requests.exceptions.ReadTimeout())
+        rc = main()
+    assert rc == 1
+    assert "timed out" in capsys.readouterr().err
+
+
+def test_fetch_connect_timeout(monkeypatch, capsys):
+    import responses as rsps_lib2
+    import requests
+    monkeypatch.setattr(sys, "argv", ["pste", "AB1234"])
+    with rsps_lib2.RequestsMock() as rsps:
+        rsps.add(rsps_lib2.GET, f"{SERVER}/AB1234", body=requests.exceptions.ConnectTimeout())
+        rc = main()
+    assert rc == 1
+    assert "timed out" in capsys.readouterr().err
+
+
+def test_create_read_timeout(monkeypatch, capsys):
+    import responses as rsps_lib2
+    import requests
+    monkeypatch.setattr(sys, "argv", ["pste"])
+    monkeypatch.setattr(sys, "stdin", io.StringIO("hello"))
+    with rsps_lib2.RequestsMock() as rsps:
+        rsps.add(rsps_lib2.POST, f"{SERVER}/", body=requests.exceptions.ReadTimeout())
+        rc = main()
+    assert rc == 1
+    assert "timed out" in capsys.readouterr().err
+
+
+def test_create_connect_timeout(monkeypatch, capsys):
+    import responses as rsps_lib2
+    import requests
+    monkeypatch.setattr(sys, "argv", ["pste"])
+    monkeypatch.setattr(sys, "stdin", io.StringIO("hello"))
+    with rsps_lib2.RequestsMock() as rsps:
+        rsps.add(rsps_lib2.POST, f"{SERVER}/", body=requests.exceptions.ConnectTimeout())
+        rc = main()
+    assert rc == 1
+    assert "timed out" in capsys.readouterr().err
+
+
+def test_create_unicode_decode_error(monkeypatch, capsys):
+    """UnicodeDecodeError on stdin.read() returns exit code 2."""
+    import io
+
+    class _BadStdin:
+        def read(self):
+            raise UnicodeDecodeError("utf-8", b"", 0, 1, "invalid")
+
+    monkeypatch.setattr(sys, "argv", ["pste"])
+    monkeypatch.setattr(sys, "stdin", _BadStdin())
+    rc = main()
+    assert rc == 2
+    assert "error" in capsys.readouterr().err