static-http 0.1.1__py3-none-any.whl

http_here/__init__.py

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

http_here/__main__.py

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

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

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

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

http_here/ranges.py

@@ -0,0 +1,92 @@
+"""Range header parsing helpers for HTTP byte-range handling."""
+
+from __future__ import annotations
+
+class RangeParseError(ValueError):
+    """Raised when a byte range header is malformed."""
+
+
+class UnsatisfiableRangeError(ValueError):
+    """Raised when a syntactically valid range is outside the file bounds."""
+
+
+def _parse_non_negative_int(raw: str) -> int:
+    if raw == "":
+        raise RangeParseError("Malformed range value")
+    if not raw.isdigit():
+        raise RangeParseError("Malformed range value")
+    return int(raw)
+
+
+def parse_range_header(range_header: str, total_size: int) -> tuple[int, int] | None:
+    """Parse a single-byte-range header and return an inclusive byte interval.
+
+    Args:
+        range_header: Raw Range header value, typically ``bytes=start-end``.
+        total_size: Total size of the target file.
+
+    Returns:
+        A ``(start, end)`` tuple if a valid single range was supplied.
+        ``None`` when no range was supplied.
+
+    Raises:
+        RangeParseError: for invalid syntax.
+        UnsatisfiableRangeError: for syntactically valid but unsatisfiable ranges.
+    """
+
+    if not range_header:
+        return None
+
+    if not range_header.startswith("bytes="):
+        raise RangeParseError("Only byte ranges are supported")
+
+    spec = range_header[6:].strip()
+    if not spec:
+        raise RangeParseError("Empty Range header")
+    if "," in spec:
+        raise RangeParseError("Multiple ranges are not supported in v1")
+
+    if spec.count("-") != 1:
+        raise RangeParseError("Malformed range value")
+
+    start_text, end_text = spec.split("-", 1)
+    start_text = start_text.strip()
+    end_text = end_text.strip()
+
+    if total_size < 0:
+        raise RangeParseError("Invalid file size")
+
+    if start_text and end_text:
+        start = _parse_non_negative_int(start_text)
+        end = _parse_non_negative_int(end_text)
+        if start > end:
+            raise RangeParseError("Malformed range value")
+        if total_size == 0 or start >= total_size:
+            raise UnsatisfiableRangeError("Range outside file size")
+        return start, min(end, total_size - 1)
+
+    if start_text:
+        start = _parse_non_negative_int(start_text)
+        if start < 0:
+            raise RangeParseError("Malformed range value")
+        if total_size == 0 or start >= total_size:
+            raise UnsatisfiableRangeError("Range outside file size")
+        return start, total_size - 1
+
+    if not end_text:
+        raise RangeParseError("Malformed range value")
+
+    suffix = _parse_non_negative_int(end_text)
+    if suffix <= 0:
+        raise UnsatisfiableRangeError("Range outside file size")
+    if total_size == 0:
+        raise UnsatisfiableRangeError("Range outside file size")
+    return max(total_size - suffix, 0), total_size - 1
+
+
+def content_range(start: int, end: int, total_size: int) -> str:
+    return f"bytes {start}-{end}/{total_size}"
+
+
+def unsatisfiable_content_range(total_size: int) -> str:
+    return f"bytes */{total_size}"

http_here/server.py

@@ -0,0 +1,221 @@
+"""HTTP server with custom range handling and constrained path mapping."""
+
+from __future__ import annotations
+
+import io
+import os
+import posixpath
+import stat
+import urllib.parse
+from datetime import datetime, timezone
+from email.utils import parsedate_to_datetime
+from http import HTTPStatus
+from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
+from typing import Mapping
+
+from .ranges import RangeParseError, UnsatisfiableRangeError, content_range, parse_range_header, unsatisfiable_content_range
+
+
+class RangeAwareHTTPRequestHandler(SimpleHTTPRequestHandler):
+    """SimpleHTTPRequestHandler variant with single-range support."""
+
+    def __init__(
+        self,
+        *args,
+        directory: str,
+        extra_headers: Mapping[str, str],
+        disable_dir_list: bool,
+        quiet: bool,
+        **kwargs,
+    ) -> None:
+        self._extra_headers = dict(extra_headers)
+        self._disable_dir_list = disable_dir_list
+        self._quiet = quiet
+        super().__init__(*args, directory=directory, **kwargs)
+
+    def _add_custom_headers(self) -> None:
+        for name, value in self._extra_headers.items():
+            self.send_header(name, value)
+
+    def log_message(self, format: str, *args) -> None:
+        if self._quiet:
+            return
+        super().log_message(format, *args)
+
+    def translate_path(self, path: str) -> str | None:
+        # Safe path mapping inspired by SimpleHTTPRequestHandler, with strict traversal defense.
+        path = path.split("?", 1)[0]
+        path = path.split("#", 1)[0]
+        path = urllib.parse.unquote(path)
+        path = path.replace("\\", "/")
+        if "\x00" in path:
+            return None
+
+        path = posixpath.normpath(path)
+        if path == "/":
+            parts: list[str] = []
+        else:
+            parts = []
+            for segment in path.split("/"):
+                if segment in ("", "."):
+                    continue
+                if segment == "..":
+                    continue
+                if ":" in segment:
+                    return None
+                parts.append(segment)
+
+        candidate = self.directory
+        for part in parts:
+            candidate = os.path.join(candidate, part)
+
+        candidate = os.path.normpath(candidate)
+        root = os.path.realpath(self.directory)
+        real_candidate = os.path.realpath(candidate)
+        if os.path.commonpath([real_candidate, root]) != root:
+            return None
+
+        return candidate
+
+    def _handle_unsatisfiable_range(self, size: int) -> None:
+        self.send_response(HTTPStatus.REQUESTED_RANGE_NOT_SATISFIABLE)
+        self.send_header("Content-Range", unsatisfiable_content_range(size))
+        self.send_header("Accept-Ranges", "bytes")
+        self.send_header("Content-Length", "0")
+        self._add_custom_headers()
+        self.end_headers()
+
+    def _write_not_modified(self, path: str, mtime: datetime) -> None:
+        self.send_response(HTTPStatus.NOT_MODIFIED)
+        self.send_header("Accept-Ranges", "bytes")
+        self.send_header("Content-Type", self.guess_type(path))
+        self.send_header("Last-Modified", self.date_time_string(mtime.timestamp()))
+        self.send_header("Content-Length", "0")
+        self._add_custom_headers()
+        self.end_headers()
+
+    def send_head(self) -> io.BufferedIOBase | None:
+        path = self.translate_path(self.path)
+        if path is None:
+            self.send_error(HTTPStatus.BAD_REQUEST, "Invalid request path")
+            return None
+
+        f = None
+
+        if os.path.isdir(path):
+            if not self.path.endswith("/"):
+                self.send_response(HTTPStatus.MOVED_PERMANENTLY)
+                self.send_header("Location", self.path + "/")
+                self._add_custom_headers()
+                self.end_headers()
+                return None
+
+            for index_name in ("index.html", "index.htm"):
+                index_path = os.path.join(path, index_name)
+                if os.path.exists(index_path):
+                    path = index_path
+                    break
+            else:
+                if self._disable_dir_list:
+                    self.send_error(HTTPStatus.FORBIDDEN, "Directory listing is disabled.")
+                    return None
+                return self.list_directory(path)
+
+        ctype = self.guess_type(path)
+        try:
+            f = open(path, "rb")
+        except OSError:
+            self.send_error(HTTPStatus.NOT_FOUND, "File not found")
+            return None
+
+        try:
+            stats = os.fstat(f.fileno())
+            if not stat.S_ISREG(stats.st_mode):
+                f.close()
+                self.send_error(HTTPStatus.NOT_FOUND, "File not found")
+                return None
+
+            file_size = stats.st_size
+            mtime = datetime.fromtimestamp(stats.st_mtime, tz=timezone.utc)
+
+            if_modified_since = self.headers.get("If-Modified-Since")
+            if if_modified_since:
+                parsed = parsedate_to_datetime(if_modified_since)
+                if parsed is not None:
+                    if parsed.tzinfo is None:
+                        parsed = parsed.replace(tzinfo=timezone.utc)
+                    if mtime <= parsed:
+                        self._write_not_modified(path, mtime)
+                        f.close()
+                        return None
+
+            start = end = None
+            range_header = self.headers.get("Range")
+            if range_header:
+                try:
+                    start, end = parse_range_header(range_header, file_size)
+                except UnsatisfiableRangeError as exc:
+                    self._handle_unsatisfiable_range(file_size)
+                    f.close()
+                    return None
+                except RangeParseError as exc:
+                    self.send_error(HTTPStatus.BAD_REQUEST, str(exc))
+                    f.close()
+                    return None
+
+            if start is None:
+                self.send_response(HTTPStatus.OK)
+                self.send_header("Content-Length", str(file_size))
+            else:
+                self.send_response(HTTPStatus.PARTIAL_CONTENT)
+                self.send_header("Content-Range", content_range(start, end, file_size))
+                self.send_header("Content-Length", str(end - start + 1))
+                f.seek(start)
+                f = _RangeFile(f, end - start + 1)
+
+            self.send_header("Content-Type", ctype)
+            self.send_header("Last-Modified", self.date_time_string(stats.st_mtime))
+            self.send_header("Accept-Ranges", "bytes")
+            self._add_custom_headers()
+            self.end_headers()
+            return f
+        except Exception:
+            f.close()
+            raise
+
+
+class _RangeFile:
+    def __init__(self, wrapped: io.BufferedReader, remaining: int) -> None:
+        self._wrapped = wrapped
+        self._remaining = remaining
+
+    def read(self, size: int = -1) -> bytes:
+        if self._remaining <= 0:
+            return b""
+        if size < 0 or size > self._remaining:
+            size = self._remaining
+        data = self._wrapped.read(size)
+        self._remaining -= len(data)
+        return data
+
+    def close(self) -> None:
+        self._wrapped.close()
+
+
+class ThreadedHTTPServer(ThreadingHTTPServer):
+    daemon_threads = True
+    allow_reuse_address = True
+
+
+def make_handler(*, directory: str, extra_headers: Mapping[str, str], disable_dir_list: bool, quiet: bool):
+    def _factory(*args, **kwargs):
+        return RangeAwareHTTPRequestHandler(
+            *args,
+            directory=directory,
+            extra_headers=extra_headers,
+            disable_dir_list=disable_dir_list,
+            quiet=quiet,
+            **kwargs,
+        )
+
+    return _factory

http_here/urls.py

@@ -0,0 +1,96 @@
+"""Utilities for computing and formatting URLs for startup output and helpers."""
+
+from __future__ import annotations
+
+import socket
+from typing import Iterable, List
+
+
+def is_all_interfaces_bind(host: str) -> bool:
+    return host in {"0.0.0.0", "::", "[::]", "::0", "0:0:0:0:0:0:0:0"}
+
+
+def format_url(host: str, port: int) -> str:
+    if ":" in host and not host.startswith("["):
+        host = f"[{host}]"
+    return f"http://{host}:{port}/"
+
+
+def discover_lan_urls() -> List[str]:
+    """Best-effort discovery of likely LAN IPv4 addresses."""
+
+    addresses = []
+    seen = set()
+
+    def _add(addr: str) -> None:
+        if not addr:
+            return
+        if addr.startswith("127.") or addr == "0.0.0.0" or addr.startswith("169.254."):
+            return
+        if addr in seen:
+            return
+        addresses.append(addr)
+        seen.add(addr)
+
+    try:
+        _addrinfo_name = socket.gethostname()
+        for info in socket.getaddrinfo(_addrinfo_name, None, family=socket.AF_INET, type=socket.SOCK_STREAM):
+            _add(info[4][0])
+    except OSError:
+        pass
+
+    try:
+        host_ips = socket.gethostbyname_ex(socket.gethostname())[2]
+        for addr in host_ips:
+            _add(addr)
+    except OSError:
+        pass
+
+    # Common trick: let UDP stack pick the local outbound interface.
+    try:
+        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        try:
+            sock.connect(("1.1.1.1", 80))
+            _add(sock.getsockname()[0])
+        finally:
+            sock.close()
+    except OSError:
+        pass
+
+    return list(addresses)
+
+
+def get_startup_urls(bind_host: str, port: int, discovered_lan: Iterable[str] | None = None) -> list[str]:
+    if discovered_lan is None:
+        discovered_lan = discover_lan_urls()
+
+    urls: list[str] = [format_url(bind_host, port)]
+    if is_all_interfaces_bind(bind_host):
+        urls.append(format_url("localhost", port))
+        for addr in discovered_lan:
+            if addr == "127.0.0.1":
+                continue
+            urls.append(format_url(addr, port))
+
+    deduped = []
+    seen = set()
+    for url in urls:
+        if url in seen:
+            continue
+        deduped.append(url)
+        seen.add(url)
+    return deduped
+
+
+def get_preferred_open_url(bind_host: str, port: int, discovered_lan: Iterable[str] | None = None) -> str:
+    if is_all_interfaces_bind(bind_host):
+        return format_url("localhost", port)
+    return format_url(bind_host, port)
+
+
+def get_preferred_qr_url(bind_host: str, port: int, discovered_lan: Iterable[str] | None = None) -> str:
+    if is_all_interfaces_bind(bind_host):
+        lan = list(discovered_lan or discover_lan_urls())
+        if lan:
+            return format_url(lan[0], port)
+    return get_preferred_open_url(bind_host, port, discovered_lan=discovered_lan)

static_http-0.1.1.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,14 @@
+http_here/__init__.py,sha256=RTLCqUERXziA3dzO6_YyzuSDUOcQvEqoIKC_adggkMw,95
+http_here/__main__.py,sha256=D31U8_ux95qF64EQ8ReT25nabzxh7ped5avpobXz_bM,49
+http_here/cli.py,sha256=LE63OPlxYE8zIN1jwDvQVN983nVZjHB9vbNqVhCRsfg,7440
+http_here/keyboard.py,sha256=blxyeGqtWrWUzrWGmAkhQN2CDf05OyiH6X0g8Xivui8,2532
+http_here/qrcode.py,sha256=ddAAaJ7ijkpNBQB6Y39ObK5lDAotKR5Kpf0JUwJT7H8,2448
+http_here/ranges.py,sha256=5r0p2o4cL_1Qv9MLG19telAPeYS7ao6MM94LBdnD2iQ,3009
+http_here/server.py,sha256=j1e-Ku24zF4q0NA6nyfHqVE533VMdDFPAbqxo1d4tBk,7763
+http_here/urls.py,sha256=P06jCxK1iaZ5qUWBOv4BYfpKyga3Tu5aMuuvxyfGoGY,2827
+static_http-0.1.1.dist-info/licenses/LICENSE,sha256=6X31c82dDlEq9mji2ep8DU8VHrOX5VQwQqVcpEaADdk,1079
+static_http-0.1.1.dist-info/METADATA,sha256=zEo_ZpGXvTRA-Pi4F3dXvfXpy2eTR_8dfyVJt4U6oY8,3536
+static_http-0.1.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+static_http-0.1.1.dist-info/entry_points.txt,sha256=-OIJUNmsv4YypTS9va2U0KUWqBaj3uKp53VdrgSscD0,51
+static_http-0.1.1.dist-info/top_level.txt,sha256=fQXA8E0TJZvED0QXQdjVJ2rgAsE-3SBlaATzkT9fVcU,10
+static_http-0.1.1.dist-info/RECORD,,

static_http-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

static_http-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+static-http = http_here.cli:main

static_http-0.1.1.dist-info/licenses/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.dist-info/top_level.txt

@@ -0,0 +1 @@
+http_here