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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: static-http
-Version: 0.1.4
+Version: 0.1.5
 Summary: A temporary dependency-free static HTTP server with byte-range support.
 Author: John Paul Ellis
 License-Expression: MIT

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "static-http"
-version = "0.1.4"
+version = "0.1.5"
 description = "A temporary dependency-free static HTTP server with byte-range support."
 readme = "README.md"
 requires-python = ">=3.10"

{static_http-0.1.4 → 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.4"
+__version__ = "0.1.5"

{static_http-0.1.4 → static_http-0.1.5}/src/http_here/qrcode.py

@@ -36,37 +36,28 @@ def _gf_mul(x: int, y: int) -> int:
     return result
 
 
-def _gf_pow(x: int, power: int) -> int:
-    result = 1
-    for _ in range(power):
-        result = _gf_mul(result, x)
-    return result
-
-
 def _generator_poly(degree: int) -> list[int]:
-    result = [1]
-    for i in range(degree):
-        result = _poly_mul(result, [1, _gf_pow(2, i)])
-    return result
-
-
-def _poly_mul(left: list[int], right: list[int]) -> list[int]:
-    result = [0] * (len(left) + len(right) - 1)
-    for i, left_value in enumerate(left):
-        for j, right_value in enumerate(right):
-            result[i + j] ^= _gf_mul(left_value, right_value)
+    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]:
-    generator = _generator_poly(degree)
-    result = data + [0] * degree
-    for i, value in enumerate(data):
-        if value == 0:
-            continue
-        for j, coefficient in enumerate(generator):
-            result[i + j] ^= _gf_mul(coefficient, value)
-    return result[-degree:]
+    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:
@@ -139,7 +130,6 @@ def _draw_function_patterns(matrix: list[list[bool | None]], function: list[list
         _set_function(matrix, function, 6, i, i % 2 == 0)
         _set_function(matrix, function, i, 6, i % 2 == 0)
 
-    _set_function(matrix, function, size - 8, 8, True)
     _draw_format_bits(matrix, function, 0)
 
 
@@ -199,44 +189,24 @@ def _format_bits(mask: int) -> int:
 def _draw_format_bits(matrix: list[list[bool | None]], function: list[list[bool]], mask: int) -> None:
     bits = _format_bits(mask)
     size = len(matrix)
-    positions_a = [
-        (8, 0),
-        (8, 1),
-        (8, 2),
-        (8, 3),
-        (8, 4),
-        (8, 5),
-        (8, 7),
-        (8, 8),
-        (7, 8),
-        (5, 8),
-        (4, 8),
-        (3, 8),
-        (2, 8),
-        (1, 8),
-        (0, 8),
-    ]
-    positions_b = [
-        (size - 1, 8),
-        (size - 2, 8),
-        (size - 3, 8),
-        (size - 4, 8),
-        (size - 5, 8),
-        (size - 6, 8),
-        (size - 7, 8),
-        (8, size - 8),
-        (8, size - 7),
-        (8, size - 6),
-        (8, size - 5),
-        (8, size - 4),
-        (8, size - 3),
-        (8, size - 2),
-        (8, size - 1),
-    ]
-    for i, (row, col) in enumerate(positions_a):
-        _set_function(matrix, function, row, col, ((bits >> i) & 1) == 1)
-    for i, (row, col) in enumerate(positions_b):
-        _set_function(matrix, function, row, col, ((bits >> i) & 1) == 1)
+    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:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: static-http
-Version: 0.1.4
+Version: 0.1.5
 Summary: A temporary dependency-free static HTTP server with byte-range support.
 Author: John Paul Ellis
 License-Expression: MIT

{static_http-0.1.4 → static_http-0.1.5}/tests/test_qrcode.py

@@ -45,6 +45,65 @@ def test_qr_known_format_bits_and_version_selection() -> None:
     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()