static-http 0.1.1__tar.gz

static_http-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 http-here contributors
+
+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.

static_http-0.1.1/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: static-http
+Version: 0.1.1
+Summary: A temporary dependency-free static HTTP server with byte-range support.
+Author: static-http contributors
+License: MIT
+Keywords: http,server,static-http,static,range,cli
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: build>=1; extra == "dev"
+Requires-Dist: twine>=5; extra == "dev"
+Dynamic: license-file
+
+# static-http
+
+`static-http` is a tiny dependency-free Python utility that starts a temporary static HTTP server in the current directory with byte-range support for quick local workflows.
+
+It is intentionally focused on temporary file serving for local development, manual testing, media playback, and archive inspection.
+
+## Why this exists
+
+`python -m http.server` is excellent for quick sharing but does not implement byte-range request handling. `static-http` fills that gap with a small CLI that keeps the behavior predictable and easy to reason about.
+
+## Install
+
+```powershell
+uvx static-http
+pipx run static-http
+python -m pip install static-http
+```
+
+## Quick start
+
+```powershell
+static-http
+```
+
+```powershell
+uvx static-http
+```
+
+By default:
+
+- Serves the current working directory.
+- Binds to `0.0.0.0`.
+- Listens on port `8080`.
+- Uses a threaded HTTP server.
+- Handles `GET`, `HEAD`, and single-range requests.
+
+## CLI
+
+`static-http` supports these options:
+
+- `-p, --port PORT` — listening port. `0` requests an OS-assigned port.
+- `-d, --directory PATH` — root directory to serve. Default is the current directory.
+- `-b, --bind ADDRESS` — bind address. Default is `0.0.0.0`.
+- `--localhost-only` — equivalent to `--bind 127.0.0.1`.
+- `--cors` — adds `Access-Control-Allow-Origin: *`.
+- `--header "Name: Value"` — repeatable custom headers.
+- `--no-dir-list` — disable directory listing responses when no index file exists.
+- `--open` — open the server URL in the default browser after startup.
+- `--qr` — render a terminal QR code for the server URL.
+- `--no-cache` — send `Cache-Control: no-store`.
+- `--quiet` — suppress per-request logs.
+- `--verbose` — print detailed startup/binding information.
+- `--version` — print package version and exit.
+
+## Examples
+
+```powershell
+static-http --open
+static-http --qr
+static-http --no-cache
+static-http --quiet
+static-http --verbose
+static-http --port 9000 --cors
+static-http --no-dir-list
+```
+
+## Shutdown
+
+Press `Q` or `q` in the focused terminal to stop the server. `Ctrl+C` also triggers a graceful shutdown.
+
+## Range support
+
+`GET` requests support single byte ranges with examples:
+
+```bash
+curl -H "Range: bytes=0-99" http://localhost:8080/video.mp4 -o part.bin
+curl -H "Range: bytes=100-" http://localhost:8080/video.mp4 -o tail.bin
+curl -H "Range: bytes=-500" http://localhost:8080/video.mp4 -o suffix.bin
+```
+
+The server returns `206 Partial Content` for satisfiable ranges, `416 Range Not Satisfiable` when the range is outside the file, and `400 Bad Request` for invalid range syntax.
+
+## Security note
+
+`static-http` is intentionally a **temporary** local development/file-serving tool, not a production web server.
+
+## License
+
+MIT

static_http-0.1.1/README.md

@@ -0,0 +1,89 @@
+# static-http
+
+`static-http` is a tiny dependency-free Python utility that starts a temporary static HTTP server in the current directory with byte-range support for quick local workflows.
+
+It is intentionally focused on temporary file serving for local development, manual testing, media playback, and archive inspection.
+
+## Why this exists
+
+`python -m http.server` is excellent for quick sharing but does not implement byte-range request handling. `static-http` fills that gap with a small CLI that keeps the behavior predictable and easy to reason about.
+
+## Install
+
+```powershell
+uvx static-http
+pipx run static-http
+python -m pip install static-http
+```
+
+## Quick start
+
+```powershell
+static-http
+```
+
+```powershell
+uvx static-http
+```
+
+By default:
+
+- Serves the current working directory.
+- Binds to `0.0.0.0`.
+- Listens on port `8080`.
+- Uses a threaded HTTP server.
+- Handles `GET`, `HEAD`, and single-range requests.
+
+## CLI
+
+`static-http` supports these options:
+
+- `-p, --port PORT` — listening port. `0` requests an OS-assigned port.
+- `-d, --directory PATH` — root directory to serve. Default is the current directory.
+- `-b, --bind ADDRESS` — bind address. Default is `0.0.0.0`.
+- `--localhost-only` — equivalent to `--bind 127.0.0.1`.
+- `--cors` — adds `Access-Control-Allow-Origin: *`.
+- `--header "Name: Value"` — repeatable custom headers.
+- `--no-dir-list` — disable directory listing responses when no index file exists.
+- `--open` — open the server URL in the default browser after startup.
+- `--qr` — render a terminal QR code for the server URL.
+- `--no-cache` — send `Cache-Control: no-store`.
+- `--quiet` — suppress per-request logs.
+- `--verbose` — print detailed startup/binding information.
+- `--version` — print package version and exit.
+
+## Examples
+
+```powershell
+static-http --open
+static-http --qr
+static-http --no-cache
+static-http --quiet
+static-http --verbose
+static-http --port 9000 --cors
+static-http --no-dir-list
+```
+
+## Shutdown
+
+Press `Q` or `q` in the focused terminal to stop the server. `Ctrl+C` also triggers a graceful shutdown.
+
+## Range support
+
+`GET` requests support single byte ranges with examples:
+
+```bash
+curl -H "Range: bytes=0-99" http://localhost:8080/video.mp4 -o part.bin
+curl -H "Range: bytes=100-" http://localhost:8080/video.mp4 -o tail.bin
+curl -H "Range: bytes=-500" http://localhost:8080/video.mp4 -o suffix.bin
+```
+
+The server returns `206 Partial Content` for satisfiable ranges, `416 Range Not Satisfiable` when the range is outside the file, and `400 Bad Request` for invalid range syntax.
+
+## Security note
+
+`static-http` is intentionally a **temporary** local development/file-serving tool, not a production web server.
+
+## License
+
+MIT

static_http-0.1.1/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "static-http"
+version = "0.1.1"
+description = "A temporary dependency-free static HTTP server with byte-range support."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "static-http contributors" }]
+dependencies = []
+keywords = ["http", "server", "static-http", "static", "range", "cli"]
+classifiers = [
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Topic :: Internet :: WWW/HTTP :: HTTP Servers",
+]
+
+[project.scripts]
+static-http = "http_here.cli:main"
+
+[project.optional-dependencies]
+dev = [
+  "pytest>=8",
+  "build>=1",
+  "twine>=5",
+]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+addopts = "-ra"

static_http-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

static_http-0.1.1/src/http_here/__init__.py

@@ -0,0 +1,3 @@
+"""Utilities for running a dependency-free local static HTTP server."""
+
+__version__ = "0.1.1"

static_http-0.1.1/src/http_here/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+
+raise SystemExit(main())

static_http-0.1.1/src/http_here/cli.py

@@ -0,0 +1,243 @@
+"""CLI entrypoint and lifecycle management for static-http."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+import threading
+import webbrowser
+from pathlib import Path
+
+from . import __version__
+from .keyboard import start_quit_watcher
+from . import qrcode as qrcode_module
+from . import urls
+from .server import ThreadedHTTPServer, make_handler
+
+
+def _parse_port(raw: str) -> int:
+    try:
+        value = int(raw)
+    except ValueError as exc:
+        raise argparse.ArgumentTypeError("Port must be an integer") from exc
+    if value < 0 or value > 65535:
+        raise argparse.ArgumentTypeError("Port must be between 0 and 65535")
+    return value
+
+
+def _parse_directory(raw: str) -> str:
+    candidate = Path(raw).expanduser()
+    if not candidate.exists():
+        raise argparse.ArgumentTypeError(f"Directory does not exist: {candidate}")
+    if not candidate.is_dir():
+        raise argparse.ArgumentTypeError(f"Not a directory: {candidate}")
+    return str(candidate.resolve())
+
+
+def _parse_header(raw: str) -> tuple[str, str]:
+    if ":" not in raw:
+        raise argparse.ArgumentTypeError("Header must use Name: Value format")
+    name, value = raw.split(":", 1)
+    name = name.strip()
+    value = value.strip()
+    if not name:
+        raise argparse.ArgumentTypeError("Header name cannot be empty")
+    if ":" in name:
+        raise argparse.ArgumentTypeError("Header name must not contain ':'")
+    if "\r" in name or "\n" in name or "\r" in value or "\n" in value:
+        raise argparse.ArgumentTypeError("Header values may not contain CR or LF")
+    return name, value
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="static-http", description="Serve static files with byte-range support.")
+    parser.add_argument(
+        "-p",
+        "--port",
+        type=_parse_port,
+        default=8080,
+        help="Port to listen on (0 for an OS-assigned ephemeral port).",
+    )
+    parser.add_argument(
+        "-d",
+        "--directory",
+        type=_parse_directory,
+        default=str(Path.cwd()),
+        help="Directory to serve.",
+    )
+
+    bind_group = parser.add_mutually_exclusive_group()
+    bind_group.add_argument(
+        "-b",
+        "--bind",
+        default="0.0.0.0",
+        help="Address to bind.",
+    )
+    bind_group.add_argument(
+        "--localhost-only",
+        action="store_true",
+        help="Bind only to 127.0.0.1.",
+    )
+
+    parser.add_argument(
+        "--cors",
+        action="store_true",
+        help="Add Access-Control-Allow-Origin: *.",
+    )
+    parser.add_argument(
+        "--header",
+        action="append",
+        type=_parse_header,
+        default=[],
+        metavar="\"Name: Value\"",
+        help='Add a response header. Repeatable.',
+    )
+    parser.add_argument(
+        "--no-dir-list",
+        action="store_true",
+        help="Disable directory listing when no index file exists.",
+    )
+    parser.add_argument(
+        "--open",
+        action="store_true",
+        help="Open the server URL in a browser after startup.",
+    )
+    parser.add_argument(
+        "--qr",
+        action="store_true",
+        help="Render a terminal QR code for the chosen URL.",
+    )
+    parser.add_argument(
+        "--no-cache",
+        action="store_true",
+        help="Send Cache-Control: no-store.",
+    )
+
+    quiet_verbose_group = parser.add_mutually_exclusive_group()
+    quiet_verbose_group.add_argument(
+        "--quiet",
+        action="store_true",
+        help="Suppress per-request logs.",
+    )
+    quiet_verbose_group.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Print extra startup and binding information.",
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=__version__,
+    )
+    return parser
+
+
+def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+    if args.localhost_only:
+        args.bind = "127.0.0.1"
+    return args
+
+
+def build_response_headers(*, cors: bool, no_cache: bool, headers: list[tuple[str, str]]) -> dict[str, str]:
+    merged: dict[str, str] = {}
+    if cors:
+        merged["Access-Control-Allow-Origin"] = "*"
+    if no_cache:
+        merged["Cache-Control"] = "no-store"
+
+    for name, value in headers:
+        merged[name] = value
+    return merged
+
+
+def main(argv: list[str] | None = None) -> int:
+    try:
+        args = parse_args(argv)
+    except SystemExit as exc:
+        if exc.code is None:
+            return 0
+        return int(exc.code) if isinstance(exc.code, int) else 2
+
+    root = str(Path(args.directory).resolve())
+    bind_host = args.bind
+    bind_port = args.port
+
+    response_headers = build_response_headers(cors=args.cors, no_cache=args.no_cache, headers=args.header)
+
+    handler = make_handler(
+        directory=root,
+        extra_headers=response_headers,
+        disable_dir_list=args.no_dir_list,
+        quiet=args.quiet,
+    )
+
+    try:
+        server = ThreadedHTTPServer((bind_host, bind_port), handler)
+    except OSError as exc:
+        print(f"Could not bind {bind_host}:{bind_port}: {exc}", file=sys.stderr)
+        return 1
+
+    actual_bind = server.server_address[0]
+    actual_port = server.server_address[1]
+    discovered_lan = urls.discover_lan_urls() if urls.is_all_interfaces_bind(actual_bind) else []
+    startup_urls = urls.get_startup_urls(actual_bind, actual_port, discovered_lan=discovered_lan)
+
+    print(f"Serving {root} at:")
+    for item in startup_urls:
+        if item:
+            print(f"  {item}")
+    print("Press Q to quit.")
+
+    if args.verbose:
+        print(f"Root directory: {root}")
+        print(f"Bound address: {actual_bind}")
+        print(f"Port: {actual_port}")
+        if discovered_lan:
+            print("Discovered LAN URLs:")
+            for item in discovered_lan:
+                print(f"  http://{item}:{actual_port}/")
+
+    shutdown_event = threading.Event()
+
+    def _shutdown() -> None:
+        if shutdown_event.is_set():
+            return
+        shutdown_event.set()
+        print("Shutting down.")
+        threading.Thread(target=server.shutdown, name="static-http-shutdown", daemon=True).start()
+
+    server_thread = threading.Thread(target=server.serve_forever, kwargs={"poll_interval": 0.5}, name="static-http-server", daemon=True)
+    server_thread.start()
+
+    open_url = urls.get_preferred_open_url(actual_bind, actual_port, discovered_lan=discovered_lan)
+    if args.open:
+        try:
+            if not webbrowser.open(open_url):
+                print(f"Warning: could not open browser for {open_url}", file=sys.stderr)
+        except Exception as exc:
+            print(f"Warning: could not open browser: {exc}", file=sys.stderr)
+
+    if args.qr:
+        qr_url = urls.get_preferred_qr_url(actual_bind, actual_port, discovered_lan=discovered_lan)
+        if not qrcode_module.render_qr(qr_url):
+            print(f"Warning: QR code could not be rendered for {qr_url}", file=sys.stderr)
+
+    stop_event, needs_enter = start_quit_watcher(_shutdown)
+    if needs_enter:
+        print("Press q then Enter to quit.")
+
+    try:
+        while not shutdown_event.wait(0.25):
+            pass
+    except KeyboardInterrupt:
+        _shutdown()
+        while not shutdown_event.wait(0.25):
+            pass
+
+    stop_event.set()
+    server_thread.join(timeout=2.0)
+    server.server_close()
+    return 0

static_http-0.1.1/src/http_here/keyboard.py

@@ -0,0 +1,86 @@
+"""Cross-platform keyboard watcher for ``q`` / ``Q`` shutdown."""
+
+from __future__ import annotations
+
+import sys
+import threading
+
+
+def start_quit_watcher(on_quit) -> tuple[threading.Event, bool]:
+    """Start monitoring for a single-key quit command.
+
+    Returns:
+        A tuple of ``(stop_event, needs_enter_confirmation)``.
+    """
+
+    stop_event = threading.Event()
+
+    # Windows single-key path.
+    try:
+        import msvcrt  # type: ignore[import-not-found]
+
+        def _watch() -> None:
+            while not stop_event.is_set():
+                if msvcrt.kbhit():
+                    ch = msvcrt.getwch()
+                    if ch.lower() == "q":
+                        if not stop_event.is_set():
+                            stop_event.set()
+                            on_quit()
+                if stop_event.wait(0.1):
+                    return
+
+        thread = threading.Thread(target=_watch, name="http-here-keyboard", daemon=True)
+        thread.start()
+        return stop_event, False
+    except Exception:
+        pass
+
+    # POSIX raw terminal path.
+    try:
+        import os
+        import select
+        import termios
+        import tty
+
+        if not sys.stdin.isatty():
+            raise RuntimeError("stdin is not a tty")
+
+        def _watch() -> None:
+            fd = sys.stdin.fileno()
+            old = termios.tcgetattr(fd)
+            try:
+                tty.setraw(fd)
+                while not stop_event.is_set():
+                    ready, _, _ = select.select([fd], [], [], 0.1)
+                    if not ready:
+                        continue
+                    ch = os.read(fd, 1).decode(errors="ignore")
+                    if ch.lower() == "q":
+                        stop_event.set()
+                        on_quit()
+            finally:
+                try:
+                    termios.tcsetattr(fd, termios.TCSADRAIN, old)
+                except Exception:
+                    pass
+
+        thread = threading.Thread(target=_watch, name="http-here-keyboard", daemon=True)
+        thread.start()
+        return stop_event, False
+    except Exception:
+        pass
+
+    # Fallback path input mode.
+    def _watch() -> None:
+        for line in sys.stdin:
+            if stop_event.is_set():
+                return
+            if line.strip().lower() == "q":
+                stop_event.set()
+                on_quit()
+                return
+
+    thread = threading.Thread(target=_watch, name="http-here-keyboard", daemon=True)
+    thread.start()
+    return stop_event, True

static_http-0.1.1/src/http_here/qrcode.py

@@ -0,0 +1,81 @@
+"""Minimal terminal QR rendering without external dependencies."""
+
+from __future__ import annotations
+
+import hashlib
+import shutil
+import sys
+from typing import TextIO
+
+
+def _draw_finder(matrix: list[list[bool]], top: int, left: int) -> None:
+    for r in range(7):
+        for c in range(7):
+            if r in (0, 6) or c in (0, 6) or (2 <= r <= 4 and 2 <= c <= 4):
+                matrix[top + r][left + c] = True
+            elif r in (1, 5) or c in (1, 5):
+                matrix[top + r][left + c] = False
+
+
+def _build_matrix(data: str) -> list[list[bool]]:
+    size = 25
+    matrix: list[list[bool | None]] = [[None for _ in range(size)] for _ in range(size)]
+    _draw_finder(matrix, 0, 0)
+    _draw_finder(matrix, 0, size - 7)
+    _draw_finder(matrix, size - 7, 0)
+
+    bits = [bit == "1" for bit in "".join(f"{b:08b}" for b in hashlib.sha256(data.encode("utf-8")).digest())]
+    bit_index = 0
+    for row in range(size):
+        for col in range(size):
+            if matrix[row][col] is not None:
+                continue
+            if bit_index < len(bits):
+                matrix[row][col] = bits[bit_index]
+                bit_index += 1
+                continue
+            matrix[row][col] = ((row * 31 + col) % 2) == 0
+
+    return [list(row) for row in matrix]
+
+
+def _format_block_matrix(matrix: list[list[bool]]) -> list[str]:
+    # Add quiet zone around the code.
+    border = 2
+    width = len(matrix)
+    lines: list[str] = []
+    for _ in range(border):
+        lines.append(" " * ((width + border * 2) * 2))
+
+    for row in matrix:
+        line = "  " * border
+        for cell in row:
+            line += "██" if cell else "  "
+        line += "  " * border
+        lines.append(line)
+
+    for _ in range(border):
+        lines.append(" " * ((width + border * 2) * 2))
+    return lines
+
+
+def render_qr(url: str, *, stream: TextIO | None = None) -> bool:
+    """Render a terminal QR-like code for ``url``.
+
+    Returns True when content was printed, otherwise False.
+    """
+
+    if stream is None:
+        stream = sys.stdout
+
+    terminal = shutil.get_terminal_size((80, 24))
+    # Use a fixed width to avoid truncation on narrow terminals.
+    if terminal.columns < 60:
+        stream.write("Terminal too narrow to render QR code.\n")
+        return False
+
+    matrix = _build_matrix(url)
+    for line in _format_block_matrix(matrix):
+        stream.write(f"{line}\n")
+    stream.write(f"{url}\n")
+    return True