static-http 0.1.3__tar.gz → 0.1.5__tar.gz

{static_http-0.1.3 → static_http-0.1.5}/PKG-INFO

@@ -1,15 +1,16 @@
 Metadata-Version: 2.4
 Name: static-http
-Version: 0.1.3
+Version: 0.1.5
 Summary: A temporary dependency-free static HTTP server with byte-range support.
 Author: John Paul Ellis
-License: MIT
+License-Expression: 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: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{static_http-0.1.3 → static_http-0.1.5}/pyproject.toml

@@ -1,23 +1,25 @@
 [build-system]
-requires = ["setuptools>=68", "wheel"]
+requires = ["setuptools>=77", "wheel"]
 build-backend = "setuptools.build_meta"
 
 [project]
 name = "static-http"
-version = "0.1.3"
+version = "0.1.5"
 description = "A temporary dependency-free static HTTP server with byte-range support."
 readme = "README.md"
 requires-python = ">=3.10"
-license = { text = "MIT" }
+license = "MIT"
+license-files = ["LICENSE"]
 authors = [{ name = "John Paul Ellis" }]
 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",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
   "Topic :: Internet :: WWW/HTTP :: HTTP Servers",
 ]
 

{static_http-0.1.3 → static_http-0.1.5}/src/http_here/__init__.py

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

static_http-0.1.5/src/http_here/qrcode.py

@@ -0,0 +1,350 @@
+"""Minimal terminal QR rendering without external dependencies."""
+
+from __future__ import annotations
+
+import shutil
+import sys
+from typing import TextIO
+
+
+_ECC_CODEWORDS = {
+    1: 7,
+    2: 10,
+    3: 15,
+    4: 20,
+}
+_DATA_CODEWORDS = {
+    1: 19,
+    2: 34,
+    3: 55,
+    4: 80,
+}
+_ANSI_BLACK = "\x1b[40m"
+_ANSI_WHITE = "\x1b[107m"
+_ANSI_RESET = "\x1b[0m"
+
+
+def _gf_mul(x: int, y: int) -> int:
+    result = 0
+    while y:
+        if y & 1:
+            result ^= x
+        y >>= 1
+        x <<= 1
+        if x & 0x100:
+            x ^= 0x11D
+    return result
+
+
+def _generator_poly(degree: int) -> list[int]:
+    result = [0] * degree
+    result[-1] = 1
+    root = 1
+    for _ in range(degree):
+        for i in range(degree):
+            result[i] = _gf_mul(result[i], root)
+            if i + 1 < degree:
+                result[i] ^= result[i + 1]
+        root = _gf_mul(root, 0x02)
+    return result
+
+
+def _reed_solomon(data: list[int], degree: int) -> list[int]:
+    divisor = _generator_poly(degree)
+    result = [0] * degree
+    for byte in data:
+        factor = byte ^ result.pop(0)
+        result.append(0)
+        for i, coefficient in enumerate(divisor):
+            result[i] ^= _gf_mul(coefficient, factor)
+    return result
+
+
+def _append_bits(bits: list[int], value: int, length: int) -> None:
+    for i in range(length - 1, -1, -1):
+        bits.append((value >> i) & 1)
+
+
+def _choose_version(data: bytes) -> int:
+    needed_bits = 4 + 8 + len(data) * 8
+    for version, data_codewords in _DATA_CODEWORDS.items():
+        if needed_bits <= data_codewords * 8:
+            return version
+    raise ValueError("URL is too long for the built-in QR renderer")
+
+
+def _encode_data(data: bytes, version: int) -> list[int]:
+    bits: list[int] = []
+    _append_bits(bits, 0b0100, 4)  # Byte mode.
+    _append_bits(bits, len(data), 8)
+    for byte in data:
+        _append_bits(bits, byte, 8)
+
+    capacity = _DATA_CODEWORDS[version] * 8
+    _append_bits(bits, 0, min(4, capacity - len(bits)))
+    while len(bits) % 8:
+        bits.append(0)
+
+    pad = [0xEC, 0x11]
+    pad_index = 0
+    while len(bits) < capacity:
+        _append_bits(bits, pad[pad_index % 2], 8)
+        pad_index += 1
+
+    return [int("".join(str(bit) for bit in bits[i : i + 8]), 2) for i in range(0, len(bits), 8)]
+
+
+def _set_function(matrix: list[list[bool | None]], function: list[list[bool]], row: int, col: int, dark: bool) -> None:
+    matrix[row][col] = dark
+    function[row][col] = True
+
+
+def _draw_finder(matrix: list[list[bool | None]], function: list[list[bool]], top: int, left: int) -> None:
+    size = len(matrix)
+    for r in range(-1, 8):
+        for c in range(-1, 8):
+            row = top + r
+            col = left + c
+            if not (0 <= row < size and 0 <= col < size):
+                continue
+            dark = 0 <= r <= 6 and 0 <= c <= 6 and (r in (0, 6) or c in (0, 6) or (2 <= r <= 4 and 2 <= c <= 4))
+            _set_function(matrix, function, row, col, dark)
+
+
+def _draw_alignment(matrix: list[list[bool | None]], function: list[list[bool]], center: int) -> None:
+    for r in range(-2, 3):
+        for c in range(-2, 3):
+            dark = max(abs(r), abs(c)) != 1
+            _set_function(matrix, function, center + r, center + c, dark)
+
+
+def _draw_function_patterns(matrix: list[list[bool | None]], function: list[list[bool]], version: int) -> None:
+    size = len(matrix)
+    _draw_finder(matrix, function, 0, 0)
+    _draw_finder(matrix, function, 0, size - 7)
+    _draw_finder(matrix, function, size - 7, 0)
+    if version > 1:
+        _draw_alignment(matrix, function, size - 7)
+
+    for i in range(8, size - 8):
+        _set_function(matrix, function, 6, i, i % 2 == 0)
+        _set_function(matrix, function, i, 6, i % 2 == 0)
+
+    _draw_format_bits(matrix, function, 0)
+
+
+def _mask(mask: int, row: int, col: int) -> bool:
+    if mask == 0:
+        return (row + col) % 2 == 0
+    if mask == 1:
+        return row % 2 == 0
+    if mask == 2:
+        return col % 3 == 0
+    if mask == 3:
+        return (row + col) % 3 == 0
+    if mask == 4:
+        return (row // 2 + col // 3) % 2 == 0
+    if mask == 5:
+        return (row * col) % 2 + (row * col) % 3 == 0
+    if mask == 6:
+        return ((row * col) % 2 + (row * col) % 3) % 2 == 0
+    return ((row + col) % 2 + (row * col) % 3) % 2 == 0
+
+
+def _draw_codewords(matrix: list[list[bool | None]], function: list[list[bool]], codewords: list[int], mask: int) -> None:
+    bits = [(codeword >> i) & 1 for codeword in codewords for i in range(7, -1, -1)]
+    bit_index = 0
+    size = len(matrix)
+    row = size - 1
+    direction = -1
+    col = size - 1
+
+    while col > 0:
+        if col == 6:
+            col -= 1
+        while 0 <= row < size:
+            for offset in range(2):
+                c = col - offset
+                if function[row][c]:
+                    continue
+                bit = bit_index < len(bits) and bits[bit_index] == 1
+                bit_index += 1
+                matrix[row][c] = bit ^ _mask(mask, row, c)
+            row += direction
+        row -= direction
+        direction = -direction
+        col -= 2
+
+
+def _format_bits(mask: int) -> int:
+    data = (0b01 << 3) | mask  # Error correction level L.
+    value = data << 10
+    generator = 0b10100110111
+    for i in range(14, 9, -1):
+        if (value >> i) & 1:
+            value ^= generator << (i - 10)
+    return (((data << 10) | value) ^ 0b101010000010010) & 0x7FFF
+
+
+def _draw_format_bits(matrix: list[list[bool | None]], function: list[list[bool]], mask: int) -> None:
+    bits = _format_bits(mask)
+    size = len(matrix)
+    for i in range(15):
+        dark = ((bits >> i) & 1) == 1
+
+        if i < 6:
+            _set_function(matrix, function, i, 8, dark)
+        elif i < 8:
+            _set_function(matrix, function, i + 1, 8, dark)
+        else:
+            _set_function(matrix, function, size - 15 + i, 8, dark)
+
+        if i < 8:
+            _set_function(matrix, function, 8, size - i - 1, dark)
+        elif i == 8:
+            _set_function(matrix, function, 8, 7, dark)
+        else:
+            _set_function(matrix, function, 8, 14 - i, dark)
+
+    _set_function(matrix, function, size - 8, 8, True)
+
+
+def _penalty(matrix: list[list[bool | None]]) -> int:
+    size = len(matrix)
+    penalty = 0
+    for row in range(size):
+        run_color = matrix[row][0]
+        run_length = 1
+        for col in range(1, size):
+            if matrix[row][col] == run_color:
+                run_length += 1
+            else:
+                if run_length >= 5:
+                    penalty += run_length - 2
+                run_color = matrix[row][col]
+                run_length = 1
+        if run_length >= 5:
+            penalty += run_length - 2
+
+    for col in range(size):
+        run_color = matrix[0][col]
+        run_length = 1
+        for row in range(1, size):
+            if matrix[row][col] == run_color:
+                run_length += 1
+            else:
+                if run_length >= 5:
+                    penalty += run_length - 2
+                run_color = matrix[row][col]
+                run_length = 1
+        if run_length >= 5:
+            penalty += run_length - 2
+
+    for row in range(size - 1):
+        for col in range(size - 1):
+            color = matrix[row][col]
+            if color == matrix[row + 1][col] == matrix[row][col + 1] == matrix[row + 1][col + 1]:
+                penalty += 3
+
+    dark = sum(1 for row in matrix for cell in row if cell)
+    total = size * size
+    penalty += abs(dark * 20 - total * 10) // total * 10
+    return penalty
+
+
+def _build_matrix(data: str) -> list[list[bool]]:
+    payload = data.encode("utf-8")
+    version = _choose_version(payload)
+    size = version * 4 + 17
+    data_codewords = _encode_data(payload, version)
+    codewords = data_codewords + _reed_solomon(data_codewords, _ECC_CODEWORDS[version])
+
+    best_matrix: list[list[bool | None]] | None = None
+    best_penalty: int | None = None
+    for mask in range(8):
+        matrix: list[list[bool | None]] = [[None for _ in range(size)] for _ in range(size)]
+        function = [[False for _ in range(size)] for _ in range(size)]
+        _draw_function_patterns(matrix, function, version)
+        _draw_codewords(matrix, function, codewords, mask)
+        _draw_format_bits(matrix, function, mask)
+        penalty = _penalty(matrix)
+        if best_penalty is None or penalty < best_penalty:
+            best_matrix = matrix
+            best_penalty = penalty
+
+    if best_matrix is None:
+        raise AssertionError("QR matrix was not generated")
+    return [[bool(cell) for cell in row] for row in best_matrix]
+
+
+def _format_plain_block_matrix(matrix: list[list[bool]]) -> list[str]:
+    border = 4
+    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 _format_ansi_block_matrix(matrix: list[list[bool]]) -> list[str]:
+    border = 4
+    light_row = _ANSI_WHITE + (" " * ((len(matrix) + border * 2) * 2)) + _ANSI_RESET
+    lines: list[str] = [light_row for _ in range(border)]
+
+    for row in matrix:
+        line = [_ANSI_WHITE + ("  " * border)]
+        last_color = _ANSI_WHITE
+        for cell in row:
+            color = _ANSI_BLACK if cell else _ANSI_WHITE
+            if color != last_color:
+                line.append(color)
+                last_color = color
+            line.append("  ")
+        if last_color != _ANSI_WHITE:
+            line.append(_ANSI_WHITE)
+        line.append("  " * border)
+        line.append(_ANSI_RESET)
+        lines.append("".join(line))
+
+    lines.extend(light_row for _ in range(border))
+    return lines
+
+
+def _supports_ansi(stream: TextIO) -> bool:
+    isatty = getattr(stream, "isatty", None)
+    return bool(isatty and isatty())
+
+
+def render_qr(url: str, *, stream: TextIO | None = None) -> bool:
+    """Render a terminal QR code for ``url``."""
+
+    if stream is None:
+        stream = sys.stdout
+
+    try:
+        matrix = _build_matrix(url)
+    except ValueError as exc:
+        stream.write(f"{exc}\n")
+        return False
+
+    terminal = shutil.get_terminal_size((80, 24))
+    required_columns = (len(matrix) + 8) * 2
+    if terminal.columns < required_columns:
+        stream.write(f"Terminal too narrow to render QR code. Need at least {required_columns} columns.\n")
+        return False
+
+    formatter = _format_ansi_block_matrix if _supports_ansi(stream) else _format_plain_block_matrix
+    for line in formatter(matrix):
+        stream.write(f"{line}\n")
+    stream.write(f"{url}\n")
+    return True

{static_http-0.1.3 → static_http-0.1.5}/src/http_here/server.py

@@ -2,12 +2,11 @@
 
 from __future__ import annotations
 
-import io
 import html
+import io
 import os
-import sys
-import posixpath
 import stat
+import sys
 import urllib.parse
 from datetime import datetime, timezone
 from email.utils import parsedate_to_datetime
@@ -56,6 +55,20 @@ class RangeAwareHTTPRequestHandler(SimpleHTTPRequestHandler):
             return False
         return segment.startswith(".")
 
+    def _has_hidden_attribute(self, path: str) -> bool:
+        if self._show_hidden:
+            return False
+        hidden_flag = getattr(stat, "FILE_ATTRIBUTE_HIDDEN", 0)
+        if not hidden_flag:
+            return False
+        try:
+            return bool(os.stat(path).st_file_attributes & hidden_flag)
+        except (AttributeError, OSError):
+            return False
+
+    def _is_hidden_entry(self, name: str, path: str) -> bool:
+        return self._is_hidden(name) or self._has_hidden_attribute(path)
+
     def translate_path(self, path: str) -> str | None:
         # Safe path mapping inspired by SimpleHTTPRequestHandler, with strict traversal defense.
         path = path.split("?", 1)[0]
@@ -65,25 +78,23 @@ class RangeAwareHTTPRequestHandler(SimpleHTTPRequestHandler):
         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 self._is_hidden(segment):
-                    return None
-                if ":" in segment:
-                    return None
-                parts.append(segment)
+        parts = []
+        for segment in path.split("/"):
+            if segment in ("", "."):
+                continue
+            if segment == "..":
+                return None
+            if self._is_hidden(segment):
+                return None
+            if ":" in segment:
+                return None
+            parts.append(segment)
 
         candidate = self.directory
         for part in parts:
             candidate = os.path.join(candidate, part)
+            if self._has_hidden_attribute(candidate):
+                return None
 
         candidate = os.path.normpath(candidate)
         root = os.path.realpath(self.directory)
@@ -119,9 +130,11 @@ class RangeAwareHTTPRequestHandler(SimpleHTTPRequestHandler):
         f = None
 
         if os.path.isdir(path):
-            if not self.path.endswith("/"):
+            parts = urllib.parse.urlsplit(self.path)
+            if not parts.path.endswith("/"):
+                location = urllib.parse.urlunsplit(("", "", parts.path + "/", parts.query, parts.fragment))
                 self.send_response(HTTPStatus.MOVED_PERMANENTLY)
-                self.send_header("Location", self.path + "/")
+                self.send_header("Location", location)
                 self._add_custom_headers()
                 self.end_headers()
                 return None
@@ -156,7 +169,10 @@ class RangeAwareHTTPRequestHandler(SimpleHTTPRequestHandler):
 
             if_modified_since = self.headers.get("If-Modified-Since")
             if if_modified_since:
-                parsed = parsedate_to_datetime(if_modified_since)
+                try:
+                    parsed = parsedate_to_datetime(if_modified_since)
+                except (IndexError, OverflowError, TypeError, ValueError):
+                    parsed = None
                 if parsed is not None:
                     if parsed.tzinfo is None:
                         parsed = parsed.replace(tzinfo=timezone.utc)
@@ -200,20 +216,13 @@ class RangeAwareHTTPRequestHandler(SimpleHTTPRequestHandler):
             raise
 
     def list_directory(self, path: str) -> io.BytesIO | None:
-        if self._show_hidden:
-            return super().list_directory(path)
-
         try:
             listdir = os.listdir(path)
         except OSError:
             self.send_error(HTTPStatus.NOT_FOUND, "No permission to list directory")
             return None
 
-        listdir = [entry for entry in listdir if not self._is_hidden(entry)]
-        if not listdir:
-            self.send_error(HTTPStatus.NOT_FOUND, "No visible files")
-            return None
-
+        listdir = [entry for entry in listdir if not self._is_hidden_entry(entry, os.path.join(path, entry))]
         listdir.sort(key=lambda a: a.lower())
         r = []
 
@@ -255,6 +264,7 @@ class RangeAwareHTTPRequestHandler(SimpleHTTPRequestHandler):
         self.send_response(HTTPStatus.OK)
         self.send_header("Content-Type", f"text/html; charset={enc}")
         self.send_header("Content-Length", str(len(encoded)))
+        self._add_custom_headers()
         self.end_headers()
         return f
 

{static_http-0.1.3 → static_http-0.1.5}/src/static_http.egg-info/PKG-INFO

@@ -1,15 +1,16 @@
 Metadata-Version: 2.4
 Name: static-http
-Version: 0.1.3
+Version: 0.1.5
 Summary: A temporary dependency-free static HTTP server with byte-range support.
 Author: John Paul Ellis
-License: MIT
+License-Expression: 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: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

static_http-0.1.5/tests/test_qrcode.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+import io
+from collections import namedtuple
+
+import pytest
+
+from http_here import qrcode
+
+
+class _TtyStringIO(io.StringIO):
+    def isatty(self) -> bool:
+        return True
+
+
+def test_qr_renders_on_wide_terminal() -> None:
+    fake_size = namedtuple("Size", "columns lines")(80, 24)
+    monkeypatch = pytest.MonkeyPatch()
+    monkeypatch.setattr(qrcode.shutil, "get_terminal_size", lambda fallback=(80, 24): fake_size)
+    out = io.StringIO()
+    try:
+        assert qrcode.render_qr("http://localhost:8080/", stream=out)
+    finally:
+        monkeypatch.undo()
+    assert out.getvalue().strip() != ""
+
+
+def test_qr_uses_forced_terminal_contrast_on_tty() -> None:
+    fake_size = namedtuple("Size", "columns lines")(80, 24)
+    monkeypatch = pytest.MonkeyPatch()
+    monkeypatch.setattr(qrcode.shutil, "get_terminal_size", lambda fallback=(80, 24): fake_size)
+    out = _TtyStringIO()
+    try:
+        assert qrcode.render_qr("http://localhost:8080/", stream=out)
+    finally:
+        monkeypatch.undo()
+    rendered = out.getvalue()
+    assert "\x1b[40m" in rendered
+    assert "\x1b[107m" in rendered
+
+
+def test_qr_known_format_bits_and_version_selection() -> None:
+    assert f"{qrcode._format_bits(0):015b}" == "111011111000100"
+    assert len(qrcode._build_matrix("http://localhost:8080/")) == 25
+    assert len(qrcode._build_matrix("http://192.168.1.205:8080/")) == 25
+
+
+def test_reed_solomon_matches_known_version_2_l_codewords() -> None:
+    data = qrcode._encode_data(b"http://localhost:8080/", 2)
+
+    assert data == [
+        65,
+        102,
+        135,
+        71,
+        71,
+        3,
+        162,
+        242,
+        246,
+        198,
+        246,
+        54,
+        22,
+        198,
+        134,
+        247,
+        55,
+        67,
+        163,
+        131,
+        3,
+        131,
+        2,
+        240,
+        236,
+        17,
+        236,
+        17,
+        236,
+        17,
+        236,
+        17,
+        236,
+        17,
+    ]
+    assert qrcode._reed_solomon(data, qrcode._ECC_CODEWORDS[2]) == [224, 235, 163, 25, 95, 161, 5, 47, 66, 94]
+
+
+def test_format_bits_use_dark_module_and_second_copy_positions() -> None:
+    size = 25
+    matrix = [[None for _ in range(size)] for _ in range(size)]
+    function = [[False for _ in range(size)] for _ in range(size)]
+
+    qrcode._draw_function_patterns(matrix, function, 2)
+    qrcode._draw_format_bits(matrix, function, 4)
+    bits = qrcode._format_bits(4)
+
+    assert matrix[size - 8][8] is True
+    assert matrix[0][8] == bool(bits & 1)
+    assert matrix[8][size - 1] == bool(bits & 1)
+    assert matrix[8][7] == bool((bits >> 8) & 1)
+    assert matrix[size - 1][8] == bool(bits & 1)
+    assert function[size - 8][8] is True
+
+
+def test_qr_warns_when_terminal_too_narrow() -> None:
+    fake_size = namedtuple("Size", "columns lines")(20, 24)
+    monkeypatch = pytest.MonkeyPatch()
+    monkeypatch.setattr(qrcode.shutil, "get_terminal_size", lambda fallback=(80, 24): fake_size)
+    out = io.StringIO()
+    try:
+        assert not qrcode.render_qr("http://localhost:8080/", stream=out)
+    finally:
+        monkeypatch.undo()
+    assert "too narrow" in out.getvalue().lower()

{static_http-0.1.3 → static_http-0.1.5}/tests/test_server.py

@@ -1,13 +1,12 @@
 from __future__ import annotations
 
 import contextlib
+from http.client import HTTPResponse
 import threading
 import urllib.error
 import urllib.request
 from pathlib import Path
 
-from http.client import HTTPResponse
-
 import pytest
 
 from http_here import server
@@ -101,8 +100,11 @@ def test_headers_and_directory_listing_controls(tmp_path: Path) -> None:
         list_url = _http_url(srv, "/")
         with urllib.request.urlopen(list_url) as resp:
             assert resp.status == 200
+            assert resp.headers["Access-Control-Allow-Origin"] == "*"
+            assert resp.headers["Cache-Control"] == "no-store"
             body = resp.read()
             assert b"a b.txt" in body or b"a+b.txt" in body
+            assert b".hidden.txt" not in body
 
         req = urllib.request.Request(_http_url(srv, "/a%20b.txt"))
         with urllib.request.urlopen(req) as resp:
@@ -115,6 +117,11 @@ def test_headers_and_directory_listing_controls(tmp_path: Path) -> None:
             urllib.request.urlopen(_http_url(srv, "/.hidden.txt"))
         assert exc.value.code in {400, 404}
 
+        invalid_date = urllib.request.Request(_http_url(srv, "/a%20b.txt"), headers={"If-Modified-Since": "not a date"})
+        with urllib.request.urlopen(invalid_date) as resp:
+            assert resp.status == 200
+            assert resp.read() == b"space"
+
     with _running_server(
         tmp_path,
         extra_headers={},
@@ -126,7 +133,7 @@ def test_headers_and_directory_listing_controls(tmp_path: Path) -> None:
         assert exc.value.code == 403
 
 
-def test_show_hidden_flag_exposes_hidden_entries(tmp_path: Path) -> None:
+def test_show_hidden_handler_option_exposes_hidden_entries(tmp_path: Path) -> None:
     (tmp_path / ".hidden.txt").write_bytes(b"secret")
 
     with _running_server(
@@ -149,6 +156,7 @@ def test_show_hidden_flag_exposes_hidden_entries(tmp_path: Path) -> None:
 
 def test_path_traversal_cannot_escape_root(tmp_path: Path) -> None:
     (tmp_path / "inside.txt").write_bytes(b"inside")
+    (tmp_path / "outside.txt").write_bytes(b"fake-outside")
     (tmp_path.parent / "outside.txt").write_bytes(b"outside")
 
     with _running_server(
@@ -163,8 +171,31 @@ def test_path_traversal_cannot_escape_root(tmp_path: Path) -> None:
 
         with pytest.raises(urllib.error.HTTPError) as exc:
             urllib.request.urlopen(_http_url(srv, "/%2e%2e/outside.txt"))
-        assert exc.value.code in {400, 404}
+        assert exc.value.code == 400
 
         with pytest.raises(urllib.error.HTTPError) as exc:
             urllib.request.urlopen(_http_url(srv, "/inside%5c.txt"))
         assert exc.value.code in {400, 404, 200}
+
+
+def test_directory_redirect_preserves_query_string(tmp_path: Path) -> None:
+    (tmp_path / "dir").mkdir()
+
+    class NoRedirect(urllib.request.HTTPRedirectHandler):
+        def redirect_request(self, req, fp, code, msg, headers, newurl):  # noqa: ANN001
+            return None
+
+    opener = urllib.request.build_opener(NoRedirect)
+    with _running_server(
+        tmp_path,
+        extra_headers={},
+        disable_dir_list=False,
+        quiet=True,
+    ) as srv:
+        with pytest.raises(urllib.error.HTTPError) as exc:
+            opener.open(_http_url(srv, "/dir?download=1"))
+        assert exc.value.code == 301
+        assert exc.value.headers["Location"] == "/dir/?download=1"
+
+        with urllib.request.urlopen(_http_url(srv, "/dir/?download=1")) as resp:
+            assert resp.status == 200

static_http-0.1.3/src/http_here/qrcode.py

@@ -1,81 +0,0 @@
-"""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

static_http-0.1.3/tests/test_qrcode.py

@@ -1,32 +0,0 @@
-from __future__ import annotations
-
-import io
-from collections import namedtuple
-
-import pytest
-
-from http_here import qrcode
-
-
-def test_qr_renders_on_wide_terminal() -> None:
-    fake_size = namedtuple("Size", "columns lines")(80, 24)
-    monkeypatch = pytest.MonkeyPatch()
-    monkeypatch.setattr(qrcode.shutil, "get_terminal_size", lambda fallback=(80, 24): fake_size)
-    out = io.StringIO()
-    try:
-        assert qrcode.render_qr("http://localhost:8080/", stream=out)
-    finally:
-        monkeypatch.undo()
-    assert out.getvalue().strip() != ""
-
-
-def test_qr_warns_when_terminal_too_narrow() -> None:
-    fake_size = namedtuple("Size", "columns lines")(20, 24)
-    monkeypatch = pytest.MonkeyPatch()
-    monkeypatch.setattr(qrcode.shutil, "get_terminal_size", lambda fallback=(80, 24): fake_size)
-    out = io.StringIO()
-    try:
-        assert not qrcode.render_qr("http://localhost:8080/", stream=out)
-    finally:
-        monkeypatch.undo()
-    assert "too narrow" in out.getvalue().lower()