qrcody 1.8.1__tar.gz

qrcody-1.8.1/LICENSE

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

qrcody-1.8.1/PKG-INFO

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: qrcody
+Version: 1.8.1
+Summary: Standalone Python port of the qrcody SVG QR rendering engine (styled pixels/eyes/frames)
+Author: Matt Troutman
+Author-email: Matt Troutman <git@trtmn.com>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Dist: segno>=1.6
+Requires-Dist: cairosvg>=2.7 ; extra == 'png'
+Requires-Python: >=3.11
+Provides-Extra: png
+Description-Content-Type: text/markdown
+
+# qrcody
+
+Standalone Python port of [qrcody](https://qrcody.trtmn.io)'s styled QR code SVG
+rendering engine — square/rounded/dots/blob/bars/squircle pixel styles, styled
+finder eyes and pupils, gradients, and framed export (perimeter / scan-me /
+scan bands). No browser, no server — pure functions in, SVG string out.
+
+This is a hand-port of `src/lib/buildSVG.js` from the qrcody web app. The
+rendering logic itself has no DOM dependency in the original (it already runs
+inside a Cloudflare Worker), so the two implementations produce visually
+equivalent output, though exact numeric string formatting may differ slightly
+(e.g. `500` vs `500.0`) — SVG renderers treat these identically.
+
+## Install
+
+```bash
+uv add qrcody
+# or, for PNG export too:
+uv add "qrcody[png]"
+```
+
+PNG export uses [cairosvg](https://cairosvg.org/), which needs the native
+Cairo library installed on the system (`brew install cairo` on macOS,
+`apt install libcairo2` on Debian/Ubuntu).
+
+## Library usage
+
+```python
+from qrcody import DEFAULT, build_svg, build_framed_svg
+
+settings = {
+    **DEFAULT,
+    "text": "https://example.com",
+    "pixels_style": "dots",
+    "eyes_style": "circle",
+    "frame": "scan-me",
+    "frame_text": "Scan me",
+}
+
+qr_svg = build_svg(settings)
+framed = build_framed_svg(qr_svg, settings)
+svg_string = framed["svg"]  # framed["w"] / framed["h"] give the output dimensions
+```
+
+For PNG (requires the `png` extra):
+
+```python
+from qrcody.png import svg_to_png
+
+png_bytes = svg_to_png(svg_string, width=1000)
+```
+
+## CLI
+
+```bash
+qrcody --url "https://example.com" --pixels squircle --frame perimeter -o qr.svg
+qrcody --url "https://example.com" --pixels dots --eyes circle -o qr.png
+```
+
+Run `qrcody --help` for the full flag list — it mirrors the qrcody `/api/qr`
+HTTP API parameters (see the qrcody repo's `functions/api/qr.js` and
+`public/openapi.yaml`).
+
+## Settings dict
+
+All keys from `qrcody.DEFAULT` (see `defaults.py`) are recognized;
+unspecified keys fall back to their default. Notable ones:
+
+| Key | Values |
+|---|---|
+| `pixels_style` | `square` / `rounded` / `dots` / `blob` / `bars-h` / `bars-v` / `squircle` |
+| `eyes_style` | `square` / `rounded` / `circle` / `leaf` / `squircle` |
+| `pupils_style` | `square` / `rounded` / `circle` / `squircle` |
+| `corners_style` | `none` / `round` / `extra-round` / `squircle` |
+| `frame` | `none` / `perimeter` / `scan-me` / `scan` |
+| `correction_level` | `L` / `M` / `Q` / `H` |
+
+## Development
+
+```bash
+uv sync --extra png
+uv run pytest
+uv run ruff check .
+```
+
+## Known gaps vs. the JS implementation
+
+- **Logo embedding** (`logo` / `logo_scale` settings) is supported in
+  `build_svg` the same way as the JS version — pass a data URI as `logo`.
+  There is no server-side "fetch a logo URL" helper here (that lives in the
+  qrcody Cloudflare Worker's SSRF-hardened fetch, which is deployment-specific
+  and out of scope for this package).
+- No automated JS/Python golden-file parity test yet — the port was done by
+  hand against `src/lib/buildSVG.js` and verified with a matching unit test
+  suite, but the two aren't diffed against each other in CI. If the JS
+  renderer changes, this package needs a manual re-sync.
+
+## Note on the package name
+
+This package is published as `qrcody` on PyPI, distinct from the `qrcody`
+npm/web app it's ported from — there's no npm/PyPI namespace collision since
+they're different registries.

qrcody-1.8.1/README.md

@@ -0,0 +1,102 @@
+# qrcody
+
+Standalone Python port of [qrcody](https://qrcody.trtmn.io)'s styled QR code SVG
+rendering engine — square/rounded/dots/blob/bars/squircle pixel styles, styled
+finder eyes and pupils, gradients, and framed export (perimeter / scan-me /
+scan bands). No browser, no server — pure functions in, SVG string out.
+
+This is a hand-port of `src/lib/buildSVG.js` from the qrcody web app. The
+rendering logic itself has no DOM dependency in the original (it already runs
+inside a Cloudflare Worker), so the two implementations produce visually
+equivalent output, though exact numeric string formatting may differ slightly
+(e.g. `500` vs `500.0`) — SVG renderers treat these identically.
+
+## Install
+
+```bash
+uv add qrcody
+# or, for PNG export too:
+uv add "qrcody[png]"
+```
+
+PNG export uses [cairosvg](https://cairosvg.org/), which needs the native
+Cairo library installed on the system (`brew install cairo` on macOS,
+`apt install libcairo2` on Debian/Ubuntu).
+
+## Library usage
+
+```python
+from qrcody import DEFAULT, build_svg, build_framed_svg
+
+settings = {
+    **DEFAULT,
+    "text": "https://example.com",
+    "pixels_style": "dots",
+    "eyes_style": "circle",
+    "frame": "scan-me",
+    "frame_text": "Scan me",
+}
+
+qr_svg = build_svg(settings)
+framed = build_framed_svg(qr_svg, settings)
+svg_string = framed["svg"]  # framed["w"] / framed["h"] give the output dimensions
+```
+
+For PNG (requires the `png` extra):
+
+```python
+from qrcody.png import svg_to_png
+
+png_bytes = svg_to_png(svg_string, width=1000)
+```
+
+## CLI
+
+```bash
+qrcody --url "https://example.com" --pixels squircle --frame perimeter -o qr.svg
+qrcody --url "https://example.com" --pixels dots --eyes circle -o qr.png
+```
+
+Run `qrcody --help` for the full flag list — it mirrors the qrcody `/api/qr`
+HTTP API parameters (see the qrcody repo's `functions/api/qr.js` and
+`public/openapi.yaml`).
+
+## Settings dict
+
+All keys from `qrcody.DEFAULT` (see `defaults.py`) are recognized;
+unspecified keys fall back to their default. Notable ones:
+
+| Key | Values |
+|---|---|
+| `pixels_style` | `square` / `rounded` / `dots` / `blob` / `bars-h` / `bars-v` / `squircle` |
+| `eyes_style` | `square` / `rounded` / `circle` / `leaf` / `squircle` |
+| `pupils_style` | `square` / `rounded` / `circle` / `squircle` |
+| `corners_style` | `none` / `round` / `extra-round` / `squircle` |
+| `frame` | `none` / `perimeter` / `scan-me` / `scan` |
+| `correction_level` | `L` / `M` / `Q` / `H` |
+
+## Development
+
+```bash
+uv sync --extra png
+uv run pytest
+uv run ruff check .
+```
+
+## Known gaps vs. the JS implementation
+
+- **Logo embedding** (`logo` / `logo_scale` settings) is supported in
+  `build_svg` the same way as the JS version — pass a data URI as `logo`.
+  There is no server-side "fetch a logo URL" helper here (that lives in the
+  qrcody Cloudflare Worker's SSRF-hardened fetch, which is deployment-specific
+  and out of scope for this package).
+- No automated JS/Python golden-file parity test yet — the port was done by
+  hand against `src/lib/buildSVG.js` and verified with a matching unit test
+  suite, but the two aren't diffed against each other in CI. If the JS
+  renderer changes, this package needs a manual re-sync.
+
+## Note on the package name
+
+This package is published as `qrcody` on PyPI, distinct from the `qrcody`
+npm/web app it's ported from — there's no npm/PyPI namespace collision since
+they're different registries.

qrcody-1.8.1/pyproject.toml

@@ -0,0 +1,30 @@
+[project]
+name = "qrcody"
+version = "1.8.1"
+description = "Standalone Python port of the qrcody SVG QR rendering engine (styled pixels/eyes/frames)"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.11"
+dependencies = ["segno>=1.6"]
+
+[[project.authors]]
+name = "Matt Troutman"
+email = "git@trtmn.com"
+
+[project.optional-dependencies]
+png = ["cairosvg>=2.7"]
+
+[project.scripts]
+qrcody = "qrcody.cli:main"
+
+[build-system]
+requires = ["uv_build>=0.11.7,<0.12.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "pytest>=8",
+    "ruff>=0.6",
+    "defusedxml>=0.7",
+]

qrcody-1.8.1/pyproject.toml.orig

@@ -0,0 +1,31 @@
+[project]
+name = "qrcody"
+version = "1.8.1"
+description = "Standalone Python port of the qrcody SVG QR rendering engine (styled pixels/eyes/frames)"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    { name = "Matt Troutman", email = "git@trtmn.com" }
+]
+requires-python = ">=3.11"
+dependencies = [
+    "segno>=1.6",
+]
+
+[project.optional-dependencies]
+png = ["cairosvg>=2.7"]
+
+[project.scripts]
+qrcody = "qrcody.cli:main"
+
+[build-system]
+requires = ["uv_build>=0.11.7,<0.12.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "pytest>=8",
+    "ruff>=0.6",
+    "defusedxml>=0.7",
+]

qrcody-1.8.1/src/qrcody/__init__.py

@@ -0,0 +1,16 @@
+"""qrcody-render — styled QR code SVG rendering, ported from the qrcody web app."""
+
+from .defaults import CORNERS_STYLES, CORRECTION_LEVELS, DEFAULT, EYE_STYLES, FRAME_STYLES, PIXELS_STYLES, PUPIL_STYLES
+from .svg import build_framed_svg, build_svg
+
+__all__ = [
+    "build_svg",
+    "build_framed_svg",
+    "DEFAULT",
+    "PIXELS_STYLES",
+    "EYE_STYLES",
+    "PUPIL_STYLES",
+    "CORNERS_STYLES",
+    "FRAME_STYLES",
+    "CORRECTION_LEVELS",
+]

qrcody-1.8.1/src/qrcody/cli.py

@@ -0,0 +1,70 @@
+"""Command-line QR generator: qrcody-render --url ... --pixels squircle -o out.svg"""
+
+import argparse
+import sys
+
+from .defaults import CORNERS_STYLES, CORRECTION_LEVELS, DEFAULT, EYE_STYLES, FRAME_STYLES, PIXELS_STYLES, PUPIL_STYLES
+from .svg import build_framed_svg, build_svg
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="qrcody-render", description="Generate a styled QR code as SVG or PNG.")
+    p.add_argument("--url", required=True, help="The URL/text to encode.")
+    p.add_argument("-o", "--output", required=True, help="Output file path (.svg or .png).")
+    p.add_argument("--bg", default=DEFAULT["color"], help="Background color, hex.")
+    p.add_argument("--fg", default=None, help="Foreground/module color, hex. Defaults to auto contrast.")
+    p.add_argument("--transparent", action="store_true")
+    p.add_argument("--cl", default=DEFAULT["correction_level"], choices=CORRECTION_LEVELS, help="Error correction level.")
+    p.add_argument("--pixels", default=DEFAULT["pixels_style"], choices=PIXELS_STYLES)
+    p.add_argument("--eyes", default=DEFAULT["eyes_style"], choices=EYE_STYLES)
+    p.add_argument("--pupils", default=DEFAULT["pupils_style"], choices=PUPIL_STYLES)
+    p.add_argument("--corners", default=DEFAULT["corners_style"], choices=CORNERS_STYLES)
+    p.add_argument("--border", type=int, default=DEFAULT["border"])
+    p.add_argument("--frame", default=DEFAULT["frame"], choices=FRAME_STYLES)
+    p.add_argument("--frame-color", default=DEFAULT["frame_color"])
+    p.add_argument("--frame-text", default=DEFAULT["frame_text"])
+    p.add_argument("--frame-padding", type=int, default=DEFAULT["frame_padding"])
+    p.add_argument("--png-width", type=int, default=1000, help="PNG output width in px (ignored for SVG).")
+    return p
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = _build_parser().parse_args(argv)
+
+    settings = {
+        **DEFAULT,
+        "text": args.url,
+        "color": args.bg,
+        "fg_color": args.fg,
+        "transparent": args.transparent,
+        "correction_level": args.cl,
+        "pixels_style": args.pixels,
+        "eyes_style": args.eyes,
+        "pupils_style": args.pupils,
+        "corners_style": args.corners,
+        "border": args.border,
+        "frame": args.frame,
+        "frame_color": args.frame_color,
+        "frame_text": args.frame_text,
+        "frame_padding": args.frame_padding,
+    }
+
+    qr_svg = build_svg(settings)
+    framed = build_framed_svg(qr_svg, settings)
+    svg = framed["svg"]
+
+    if args.output.lower().endswith(".png"):
+        from .png import svg_to_png
+
+        with open(args.output, "wb") as f:
+            f.write(svg_to_png(svg, width=args.png_width))
+    else:
+        with open(args.output, "w") as f:
+            f.write(svg)
+
+    print(f"Wrote {args.output}", file=sys.stderr)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

qrcody-1.8.1/src/qrcody/colors.py

@@ -0,0 +1,10 @@
+"""Contrast color helper — mirrors src/utils/color.js."""
+
+
+def get_contrast_color(hex_color: str) -> str:
+    """Pick black or white for best contrast against a hex background color."""
+    r = int(hex_color[1:3], 16)
+    g = int(hex_color[3:5], 16)
+    b = int(hex_color[5:7], 16)
+    luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255
+    return "#000000" if luminance > 0.45 else "#ffffff"

qrcody-1.8.1/src/qrcody/defaults.py

@@ -0,0 +1,45 @@
+"""Style enums and default settings — mirrors src/lib/defaults.js."""
+
+PIXELS_STYLES = ["square", "rounded", "dots", "blob", "bars-h", "bars-v", "squircle"]
+EYE_STYLES = ["square", "rounded", "circle", "leaf", "squircle"]
+PUPIL_STYLES = ["square", "rounded", "circle", "squircle"]
+CORNERS_STYLES = ["none", "round", "extra-round", "squircle"]
+FRAME_STYLES = ["none", "perimeter", "scan-me", "scan"]
+CORRECTION_LEVELS = ["L", "M", "Q", "H"]
+
+DEFAULT = {
+    "text": "https://qrcody.trtmn.io",
+    "correction_level": "Q",
+    "color": "#ffffff",
+    "fg_color": "#000000",
+    "transparent": False,
+    "corners_style": "squircle",
+    "pixels_style": "squircle",
+    "eyes_style": "squircle",
+    "pupils_style": "squircle",
+    # 0-100: controls the superellipse exponent (corner curvature).
+    "corners_squircle_radius": 50,
+    "pixels_squircle_radius": 50,
+    "eyes_squircle_radius": 50,
+    "pupils_squircle_radius": 50,
+    "border": 60,
+    "logo": None,
+    "logo_scale": 0.2,
+    "fg_gradient": False,
+    "fg_gradient_from": "#0b61cb",
+    "fg_gradient_to": "#00a7bd",
+    "fg_gradient_angle": 45,
+    "bg_gradient": False,
+    "bg_gradient_from": "#0b61cb",
+    "bg_gradient_to": "#00a7bd",
+    "bg_gradient_angle": 45,
+    "frame_gradient": False,
+    "frame_gradient_from": "#0b61cb",
+    "frame_gradient_to": "#00a7bd",
+    "frame_gradient_angle": 45,
+    "frame": "perimeter",
+    "frame_color": "#000000",
+    "frame_text": "",
+    "frame_padding": 10,
+    "frame_text_size": 16,
+}

qrcody-1.8.1/src/qrcody/matrix.py

@@ -0,0 +1,27 @@
+"""QR matrix generation — wraps `segno` (Python equivalent of the JS `qrcode-generator`)."""
+
+import segno
+
+_ERROR_LEVELS = {"L": "l", "M": "m", "Q": "q", "H": "h"}
+
+
+class QRMatrix:
+    """A generated QR code's module grid, with the same `is_dark`/`module_count` shape as buildSVG.js expects."""
+
+    def __init__(self, text: str, correction_level: str = "Q") -> None:
+        level = _ERROR_LEVELS.get((correction_level or "Q").upper(), "q")
+        qr = segno.make(text or " ", micro=False, error=level)
+        self._rows = [bytearray(row) for row in qr.matrix]
+        self.module_count = len(self._rows)
+
+    def is_dark(self, r: int, c: int) -> bool:
+        if r < 0 or c < 0 or r >= self.module_count or c >= self.module_count:
+            return False
+        return bool(self._rows[r][c] & 0x1)
+
+
+def make_matrix(text: str, correction_level: str = "Q") -> QRMatrix:
+    try:
+        return QRMatrix(text, correction_level)
+    except Exception:
+        return QRMatrix("https://example.com", "H")

qrcody-1.8.1/src/qrcody/png.py

@@ -0,0 +1,11 @@
+"""Optional SVG -> PNG rasterization. Requires the `png` extra (cairosvg)."""
+
+
+def svg_to_png(svg: str, width: int | None = None) -> bytes:
+    try:
+        import cairosvg
+    except ImportError as e:
+        raise ImportError(
+            "PNG export requires the 'png' extra: pip install 'qrcody-render[png]'"
+        ) from e
+    return cairosvg.svg2png(bytestring=svg.encode("utf-8"), output_width=width)

qrcody-1.8.1/src/qrcody/squircle.py

@@ -0,0 +1,42 @@
+"""Superellipse (squircle) path builder — mirrors src/lib/squircle.js.
+
+The "radius" parameter (0-100) controls the superellipse exponent `n` directly:
+  radius 0   -> n = 3  (most rounded, closest to a circle)
+  radius 50  -> n = 6  (balanced squircle)
+  radius 100 -> n = 10 (tightest corner curvature, closest to a square)
+
+This changes how sharp/soft the corners are, not the size of the squircle
+within its bounding box (the path always fills the box).
+"""
+
+import math
+
+_N_MIN = 3
+_N_MAX = 10
+
+
+def _radius_to_n(radius: float) -> float:
+    t = max(0.0, min(100.0, radius)) / 100
+    return _N_MIN + t * (_N_MAX - _N_MIN)
+
+
+def squircle_path(x: float, y: float, w: float, h: float, radius: float = 50) -> str:
+    n = _radius_to_n(radius)
+    cx = x + w / 2
+    cy = y + h / 2
+    rx = w / 2
+    ry = h / 2
+    # More steps at lower n (rounder = more arc length per corner), fewer
+    # at higher n (square-ish = arc length dominated by sides).
+    steps = 128 if n < 5 else 96
+    exp = 2 / n
+    parts = []
+    for i in range(steps + 1):
+        t = (i / steps) * math.pi * 2
+        cos_t, sin_t = math.cos(t), math.sin(t)
+        px = math.copysign(abs(cos_t) ** exp, cos_t) * rx
+        py = math.copysign(abs(sin_t) ** exp, sin_t) * ry
+        xi, yi = cx + px, cy + py
+        parts.append(f"M {xi:.2f},{yi:.2f}" if i == 0 else f"L {xi:.2f},{yi:.2f}")
+    parts.append("Z")
+    return " ".join(parts)

qrcody-1.8.1/src/qrcody/svg.py

@@ -0,0 +1,447 @@
+"""QR SVG rendering core — mirrors src/lib/buildSVG.js.
+
+Pure functions: a settings dict in, an SVG string out. No I/O, no rasterization.
+"""
+
+import math
+import re
+
+from .colors import get_contrast_color
+from .matrix import make_matrix
+from .squircle import squircle_path
+from .svg_paths import per_corner_path
+from .xml_utils import escape_xml
+
+CORNER_RX = {"none": 0, "round": 30, "extra-round": 70}
+
+_QR_SIZE = 1000
+
+
+def _rect_path(x: float, y: float, w: float, h: float) -> str:
+    return f"M {x},{y} H {x + w} V {y + h} H {x} Z"
+
+
+def _rounded_path(x: float, y: float, w: float, h: float, r: float) -> str:
+    r = min(r, w / 2, h / 2)
+    return (
+        f"M {x + r},{y} L {x + w - r},{y} Q {x + w},{y} {x + w},{y + r} "
+        f"L {x + w},{y + h - r} Q {x + w},{y + h} {x + w - r},{y + h} "
+        f"L {x + r},{y + h} Q {x},{y + h} {x},{y + h - r} "
+        f"L {x},{y + r} Q {x},{y} {x + r},{y} Z"
+    )
+
+
+def _leaf_path(x: float, y: float, w: float, h: float, r: float, pointed: str) -> str:
+    r_b = min(r, w / 2, h / 2)
+    r_t = r_b * 0.1
+    if pointed == "br":
+        return (
+            f"M {x + r_b},{y} L {x + w - r_b},{y} Q {x + w},{y} {x + w},{y + r_b} "
+            f"L {x + w},{y + h - r_t} Q {x + w},{y + h} {x + w - r_t},{y + h} "
+            f"L {x + r_b},{y + h} Q {x},{y + h} {x},{y + h - r_b} "
+            f"L {x},{y + r_b} Q {x},{y} {x + r_b},{y} Z"
+        )
+    if pointed == "bl":
+        return (
+            f"M {x + r_b},{y} L {x + w - r_b},{y} Q {x + w},{y} {x + w},{y + r_b} "
+            f"L {x + w},{y + h - r_b} Q {x + w},{y + h} {x + w - r_b},{y + h} "
+            f"L {x + r_t},{y + h} Q {x},{y + h} {x},{y + h - r_t} "
+            f"L {x},{y + r_b} Q {x},{y} {x + r_b},{y} Z"
+        )
+    if pointed == "tr":
+        return (
+            f"M {x + r_b},{y} L {x + w - r_t},{y} Q {x + w},{y} {x + w},{y + r_t} "
+            f"L {x + w},{y + h - r_b} Q {x + w},{y + h} {x + w - r_b},{y + h} "
+            f"L {x + r_b},{y + h} Q {x},{y + h} {x},{y + h - r_b} "
+            f"L {x},{y + r_b} Q {x},{y} {x + r_b},{y} Z"
+        )
+    return _rounded_path(x, y, w, h, r_b)
+
+
+# ── Finder pattern rendering (eyes + pupils) ─────────────────────────────────
+
+
+def _render_pupil(pupils_style, px2, py2, inner3, grad_fill, pupils_squircle_radius):
+    if pupils_style == "circle":
+        pcx = px2 + inner3 / 2
+        pcy = py2 + inner3 / 2
+        return f'<circle cx="{pcx}" cy="{pcy}" r="{inner3 * 0.52}" fill="{grad_fill}"/>'
+    if pupils_style == "rounded":
+        return f'<rect x="{px2}" y="{py2}" width="{inner3}" height="{inner3}" rx="{inner3 * 0.2}" fill="{grad_fill}"/>'
+    if pupils_style == "squircle":
+        d = squircle_path(px2, py2, inner3, inner3, pupils_squircle_radius if pupils_squircle_radius is not None else 50)
+        return f'<path d="{d}" fill="{grad_fill}"/>'
+    return f'<rect x="{px2}" y="{py2}" width="{inner3}" height="{inner3}" fill="{grad_fill}"/>'
+
+
+def _render_eye(eyes_style, pupils_style, ex, ey, ms, pointed, grad_fill, grad_stroke, eyes_squircle_radius, pupils_squircle_radius):
+    outer = 7 * ms
+    inner3 = 3 * ms
+    sep = 5 * ms
+    outer_r = outer * 0.28
+    r_sep = max(0, outer_r - ms * 0.55)
+    cx = ex + outer / 2
+    cy = ey + outer / 2
+    px2 = ex + 2 * ms
+    py2 = ey + 2 * ms
+
+    pupil = _render_pupil(pupils_style, px2, py2, inner3, grad_fill, pupils_squircle_radius)
+
+    if eyes_style == "circle":
+        ring_r = outer / 2 - ms / 2
+        return f'<circle cx="{cx}" cy="{cy}" r="{ring_r}" fill="none" stroke="{grad_stroke}" stroke-width="{ms}"/>{pupil}'
+
+    if eyes_style == "leaf":
+        outer_d = _leaf_path(ex, ey, outer, outer, outer_r, pointed)
+    elif eyes_style == "squircle":
+        outer_d = squircle_path(ex, ey, outer, outer, eyes_squircle_radius if eyes_squircle_radius is not None else 50)
+    elif eyes_style == "rounded":
+        outer_d = _rounded_path(ex, ey, outer, outer, outer_r)
+    else:
+        outer_d = _rect_path(ex, ey, outer, outer)
+
+    if eyes_style == "square" or r_sep <= 0:
+        sep_d = _rect_path(ex + ms, ey + ms, sep, sep)
+    elif eyes_style == "squircle":
+        sep_d = squircle_path(ex + ms, ey + ms, sep, sep, eyes_squircle_radius if eyes_squircle_radius is not None else 50)
+    else:
+        sep_d = _rounded_path(ex + ms, ey + ms, sep, sep, r_sep)
+
+    return f'<path d="{outer_d} {sep_d}" fill="{grad_fill}" fill-rule="evenodd"/>{pupil}'
+
+
+def _render_finder_patterns(qr, module_count, ms, pad, in_finder, get_finder_origin, eyes_style, pupils_style, grad_fill, grad_stroke, eyes_squircle_radius, pupils_squircle_radius):
+    out = []
+    drawn = set()
+    for r in range(module_count):
+        for c in range(module_count):
+            if not qr.is_dark(r, c) or not in_finder(r, c):
+                continue
+            origin = get_finder_origin(r, c)
+            key = (origin["row"], origin["col"])
+            if key not in drawn:
+                drawn.add(key)
+                ex = pad + origin["col"] * ms
+                ey = pad + origin["row"] * ms
+                out.append(_render_eye(eyes_style, pupils_style, ex, ey, ms, origin["pointed"], grad_fill, grad_stroke, eyes_squircle_radius, pupils_squircle_radius))
+    return "".join(out)
+
+
+# ── Card background ──────────────────────────────────────────────────────────
+
+
+def _render_background(size, corners_style, bg_fill, transparent, corners_squircle_radius):
+    if transparent:
+        return ""
+    if corners_style == "squircle":
+        d = squircle_path(0, 0, size, size, corners_squircle_radius if corners_squircle_radius is not None else 50)
+        return f'<path d="{d}" fill="{bg_fill}"/>'
+    bg_rx = CORNER_RX.get(corners_style, 0)
+    if bg_rx > 0:
+        return f'<rect width="{size}" height="{size}" rx="{bg_rx}" fill="{bg_fill}"/>'
+    return f'<rect width="{size}" height="{size}" fill="{bg_fill}"/>'
+
+
+# ── QR data modules (all pixel styles) ───────────────────────────────────────
+
+
+def _render_data_modules(dark_set, has_dark, module_count, ms, pad, pixels_style, grad_fill, pixels_squircle_radius):
+    out = []
+
+    if pixels_style == "bars-h":
+        for r in range(module_count):
+            start = -1
+            for c in range(module_count + 1):
+                if c < module_count and has_dark(r, c):
+                    if start == -1:
+                        start = c
+                elif start != -1:
+                    x = pad + start * ms
+                    w = (c - start) * ms
+                    bh = ms * 0.62
+                    by = pad + r * ms + (ms - bh) / 2
+                    out.append(f'<rect x="{x}" y="{by}" width="{w}" height="{bh}" rx="{bh * 0.38}" fill="{grad_fill}"/>')
+                    start = -1
+    elif pixels_style == "bars-v":
+        for c in range(module_count):
+            start = -1
+            for r in range(module_count + 1):
+                if r < module_count and has_dark(r, c):
+                    if start == -1:
+                        start = r
+                elif start != -1:
+                    y = pad + start * ms
+                    h = (r - start) * ms
+                    bw = ms * 0.62
+                    bx = pad + c * ms + (ms - bw) / 2
+                    out.append(f'<rect x="{bx}" y="{y}" width="{bw}" height="{h}" rx="{bw * 0.38}" fill="{grad_fill}"/>')
+                    start = -1
+    elif pixels_style == "blob":
+        blob_r = ms * 0.38
+        d_parts = []
+        for key in dark_set:
+            r, c = key // 1000, key % 1000
+            x = pad + c * ms - 0.25
+            y = pad + r * ms - 0.25
+            w = ms + 0.5
+            h = ms + 0.5
+            top = has_dark(r - 1, c)
+            bottom = has_dark(r + 1, c)
+            left = has_dark(r, c - 1)
+            right = has_dark(r, c + 1)
+            tl = 0 if (top or left) else blob_r
+            tr = 0 if (top or right) else blob_r
+            br = 0 if (bottom or right) else blob_r
+            bl = 0 if (bottom or left) else blob_r
+            d_parts.append(per_corner_path(x, y, w, h, tl, tr, br, bl))
+        if d_parts:
+            out.append(f'<path d="{" ".join(d_parts)}" fill="{grad_fill}"/>')
+    elif pixels_style == "dots":
+        for key in dark_set:
+            r, c = key // 1000, key % 1000
+            out.append(f'<circle cx="{pad + c * ms + ms / 2}" cy="{pad + r * ms + ms / 2}" r="{ms * 0.45}" fill="{grad_fill}"/>')
+    elif pixels_style == "rounded":
+        for key in dark_set:
+            r, c = key // 1000, key % 1000
+            sz = ms * 0.82
+            off = (ms - sz) / 2
+            out.append(f'<rect x="{pad + c * ms + off}" y="{pad + r * ms + off}" width="{sz}" height="{sz}" rx="{sz * 0.28}" fill="{grad_fill}"/>')
+    elif pixels_style == "squircle":
+        for key in dark_set:
+            r, c = key // 1000, key % 1000
+            sz = ms * 0.86
+            off = (ms - sz) / 2
+            d = squircle_path(pad + c * ms + off, pad + r * ms + off, sz, sz, pixels_squircle_radius if pixels_squircle_radius is not None else 50)
+            out.append(f'<path d="{d}" fill="{grad_fill}"/>')
+    else:
+        for r in range(module_count):
+            start = -1
+            for c in range(module_count + 1):
+                if c < module_count and has_dark(r, c):
+                    if start == -1:
+                        start = c
+                elif start != -1:
+                    out.append(f'<rect x="{pad + start * ms - 1}" y="{pad + r * ms - 1}" width="{(c - start) * ms + 2}" height="{ms + 2}" fill="{grad_fill}"/>')
+                    start = -1
+
+    return "".join(out)
+
+
+# ── Center logo overlay ──────────────────────────────────────────────────────
+
+
+def _render_logo(logo, draw_size, scale, center_x, center_y, clear_radius, bg_fill):
+    if not logo:
+        return ""
+    logo_size = draw_size * scale
+    logo_x = center_x - logo_size / 2
+    logo_y = center_y - logo_size / 2
+    return (
+        f'<circle cx="{center_x}" cy="{center_y}" r="{clear_radius}" fill="{bg_fill}"/>'
+        f'<image x="{logo_x}" y="{logo_y}" width="{logo_size}" height="{logo_size}" preserveAspectRatio="xMidYMid meet" href="{logo}"/>'
+    )
+
+
+def _gradient_def(gradient_id: str, angle: float, from_color: str, to_color: str) -> str:
+    rad = math.radians(angle)
+    x1 = f"{50 - math.cos(rad) * 50}%"
+    y1 = f"{50 - math.sin(rad) * 50}%"
+    x2 = f"{50 + math.cos(rad) * 50}%"
+    y2 = f"{50 + math.sin(rad) * 50}%"
+    frm = from_color or "#0b61cb"
+    to = to_color or "#00a7bd"
+    return (
+        f'<linearGradient id="{gradient_id}" x1="{x1}" y1="{y1}" x2="{x2}" y2="{y2}" '
+        f'gradientUnits="userSpaceOnUse"><stop offset="0%" stop-color="{frm}"/>'
+        f'<stop offset="100%" stop-color="{to}"/></linearGradient>'
+    )
+
+
+def build_svg(settings: dict) -> str:
+    text = settings.get("text")
+    correction_level = settings.get("correction_level")
+    color = settings.get("color")
+    fg_color = settings.get("fg_color")
+    border = settings.get("border")
+    pixels_style = settings.get("pixels_style")
+    eyes_style = settings.get("eyes_style")
+    pupils_style = settings.get("pupils_style")
+    corners_style = settings.get("corners_style")
+    transparent = settings.get("transparent")
+    logo = settings.get("logo")
+    logo_scale = settings.get("logo_scale")
+    fg_gradient = settings.get("fg_gradient")
+    fg_gradient_from = settings.get("fg_gradient_from")
+    fg_gradient_to = settings.get("fg_gradient_to")
+    fg_gradient_angle = settings.get("fg_gradient_angle")
+    bg_gradient = settings.get("bg_gradient")
+    bg_gradient_from = settings.get("bg_gradient_from")
+    bg_gradient_to = settings.get("bg_gradient_to")
+    bg_gradient_angle = settings.get("bg_gradient_angle")
+    corners_squircle_radius = settings.get("corners_squircle_radius")
+    pixels_squircle_radius = settings.get("pixels_squircle_radius")
+    eyes_squircle_radius = settings.get("eyes_squircle_radius")
+    pupils_squircle_radius = settings.get("pupils_squircle_radius")
+
+    background = "none" if transparent else color
+    fg = fg_color or get_contrast_color(color)
+    data_gradient = bool(fg_gradient)
+    grad_fill = "url(#dg)" if data_gradient else fg
+    grad_stroke = "url(#dg)" if data_gradient else fg
+    bg_grad_enabled = bool(bg_gradient) and not transparent
+    bg_fill = "url(#bgGrad)" if bg_grad_enabled else background
+
+    qr = make_matrix(text or " ", correction_level or "H")
+
+    module_count = qr.module_count
+    size = _QR_SIZE
+    pad = max(int(border) if border is not None else 0, 10)
+    draw_size = size - pad * 2
+    ms = draw_size / module_count
+
+    scale = logo_scale if logo_scale is not None else 0.2
+    clear_radius = draw_size * scale * 0.62 if logo else 0
+    center_x = size / 2
+    center_y = size / 2
+
+    def in_finder(r, c):
+        return (r < 7 and c < 7) or (r < 7 and c >= module_count - 7) or (r >= module_count - 7 and c < 7)
+
+    def get_finder_origin(r, c):
+        if r < 7 and c < 7:
+            return {"row": 0, "col": 0, "pointed": "br"}
+        if r < 7 and c >= module_count - 7:
+            return {"row": 0, "col": module_count - 7, "pointed": "bl"}
+        return {"row": module_count - 7, "col": 0, "pointed": "tr"}
+
+    dark_set = set()
+    for r in range(module_count):
+        for c in range(module_count):
+            if not qr.is_dark(r, c) or in_finder(r, c):
+                continue
+            if logo and clear_radius > 0:
+                mx = pad + c * ms + ms / 2
+                my = pad + r * ms + ms / 2
+                if math.sqrt((mx - center_x) ** 2 + (my - center_y) ** 2) < clear_radius:
+                    continue
+            dark_set.add(r * 1000 + c)
+
+    def has_dark(r, c):
+        return 0 <= r < module_count and 0 <= c < module_count and (r * 1000 + c) in dark_set
+
+    els = [_render_background(size, corners_style, bg_fill, transparent, corners_squircle_radius)]
+
+    els.append(_render_finder_patterns(
+        qr, module_count, ms, pad, in_finder, get_finder_origin,
+        eyes_style, pupils_style, grad_fill, grad_stroke, eyes_squircle_radius, pupils_squircle_radius,
+    ))
+
+    els.append(_render_data_modules(dark_set, has_dark, module_count, ms, pad, pixels_style, grad_fill, pixels_squircle_radius))
+
+    els.append(_render_logo(logo, draw_size, scale, center_x, center_y, clear_radius, bg_fill))
+
+    bg_grad_def = _gradient_def("bgGrad", bg_gradient_angle if bg_gradient_angle is not None else 45, bg_gradient_from, bg_gradient_to) if bg_grad_enabled else ""
+    if data_gradient:
+        dg_def = _gradient_def("dg", fg_gradient_angle if fg_gradient_angle is not None else 45, fg_gradient_from, fg_gradient_to)
+        defs = f"<defs>{dg_def}{bg_grad_def}</defs>"
+    elif bg_grad_enabled:
+        defs = f"<defs>{bg_grad_def}</defs>"
+    else:
+        defs = ""
+
+    return f'<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 {size} {size}">{defs}{"".join(els)}</svg>'
+
+
+_SVG_OPEN_RE = re.compile(r"^<svg[^>]*>")
+_SVG_CLOSE_RE = re.compile(r"</svg>$")
+
+
+def build_framed_svg(qr_svg: str, settings: dict) -> dict:
+    frame = settings.get("frame") or "none"
+    color = settings.get("color") or "#ffffff"
+    transparent = settings.get("transparent")
+    bg = "none" if transparent else color
+    fg = settings.get("fg_color") or get_contrast_color(color)
+    frame_gradient = bool(settings.get("frame_gradient"))
+    frame_fill = "url(#frameGrad)" if frame_gradient else (settings.get("frame_color") or bg)
+    frame_bg = frame_fill
+    # Label text must contrast against the frame's own background, not the QR
+    # body's — they're independently configurable and often differ.
+    if frame_gradient:
+        fc = get_contrast_color(settings.get("frame_gradient_from") or settings.get("frame_gradient_to") or "#000000")
+    else:
+        fc = fg if frame_bg == "none" else get_contrast_color(frame_bg)
+
+    inner = _SVG_CLOSE_RE.sub("", _SVG_OPEN_RE.sub("", qr_svg))
+    s = _QR_SIZE
+    display_fp = settings.get("frame_padding")
+    display_fp = 24 if display_fp is None else display_fp
+    sp = round(display_fp * (s / 360))
+    corner_rx = CORNER_RX.get(settings.get("corners_style") or "none", 0)
+    corners_style = settings.get("corners_style") or "none"
+    corners_squircle_radius = settings.get("corners_squircle_radius")
+
+    def squircle_clip(w, h, clip_id):
+        d = squircle_path(0, 0, w, h, corners_squircle_radius if corners_squircle_radius is not None else 50)
+        return f'<clipPath id="{clip_id}"><path d="{d}" /></clipPath>'
+
+    def mk_svg(w, h, body):
+        ns = 'xmlns="http://www.w3.org/2000/svg"'
+        frame_grad_def = ""
+        if frame_gradient:
+            angle = settings.get("frame_gradient_angle")
+            angle = 45 if angle is None else angle
+            frame_grad_def = _gradient_def("frameGrad", angle, settings.get("frame_gradient_from"), settings.get("frame_gradient_to"))
+        if corners_style == "squircle":
+            return f'<svg {ns} width="{w}" height="{h}" viewBox="0 0 {w} {h}"><defs>{squircle_clip(w, h, "cr")}{frame_grad_def}</defs><g clip-path="url(#cr)">{body}</g></svg>'
+        rx = round(corner_rx * (w / _QR_SIZE)) if corner_rx > 0 else 0
+        if rx > 0:
+            return f'<svg {ns} width="{w}" height="{h}" viewBox="0 0 {w} {h}"><defs><clipPath id="cr"><rect width="{w}" height="{h}" rx="{rx}"/></clipPath>{frame_grad_def}</defs><g clip-path="url(#cr)">{body}</g></svg>'
+        return f'<svg {ns} width="{w}" height="{h}" viewBox="0 0 {w} {h}"><defs>{frame_grad_def}</defs>{body}</svg>'
+
+    def bg_rect(w, h):
+        return f'<rect width="{w}" height="{h}" fill="{frame_bg}"/>' if frame_bg != "none" else ""
+
+    def bg_shape(w, h):
+        if frame_bg == "none":
+            return ""
+        if corners_style == "squircle":
+            d = squircle_path(0, 0, w, h, corners_squircle_radius if corners_squircle_radius is not None else 50)
+            return f'<path d="{d}" fill="{frame_bg}"/>'
+        return f'<rect width="{w}" height="{h}" fill="{frame_bg}"/>'
+
+    if frame == "none":
+        return {"svg": mk_svg(s, s, inner), "w": s, "h": s}
+
+    if frame == "perimeter":
+        w = h = s + sp * 2
+        body = f'{bg_shape(w, h)}<g transform="translate({sp},{sp})">{inner}</g>'
+        return {"svg": mk_svg(w, h, body), "w": w, "h": h}
+
+    frame_text_size = settings.get("frame_text_size")
+    frame_text_size = 16 if frame_text_size is None else frame_text_size
+    fs = round(frame_text_size * (s / 360))
+    # Band must be tall enough for the font regardless of frame padding.
+    band_h = max(round(sp * 3.2), round(fs * 1.6))
+
+    def make_icon_text_row(w, b_h, band_y, label):
+        cy = band_y + b_h / 2
+        return f'<text x="{w / 2}" y="{cy + fs * 0.38}" text-anchor="middle" font-family="system-ui,-apple-system,sans-serif" font-size="{fs}" font-weight="400" fill="{fc}">{label}</text>'
+
+    if frame == "scan-me":
+        hh = band_h
+        w, h = s + sp * 2, s + hh + sp
+        label = escape_xml(settings.get("frame_text") or "Scan me")
+        row = make_icon_text_row(w, hh, 0, label)
+        body = f'{bg_rect(w, h)}{row}<g transform="translate({sp},{hh})">{inner}</g>'
+        return {"svg": mk_svg(w, h, body), "w": w, "h": h}
+
+    if frame == "scan":
+        fh = band_h
+        w, h = s + sp * 2, s + sp + fh
+        label = escape_xml(settings.get("frame_text") or "Scan")
+        row = make_icon_text_row(w, fh, s + sp, label)
+        body = f'{bg_rect(w, h)}<g transform="translate({sp},{sp})">{inner}</g>{row}'
+        return {"svg": mk_svg(w, h, body), "w": w, "h": h}
+
+    return {"svg": mk_svg(s, s, inner), "w": s, "h": s}

qrcody-1.8.1/src/qrcody/svg_paths.py

@@ -0,0 +1,19 @@
+"""Per-corner rounded rect path builder — mirrors src/utils/svgPaths.js."""
+
+
+def per_corner_path(x: float, y: float, w: float, h: float, tl: float, tr: float, br: float, bl: float) -> str:
+    """Build an SVG path `d` string for a rect with independently controllable corner radii.
+
+    A radius of 0 for a given corner renders it sharp instead of curved.
+    """
+    p = [f"M {x + tl},{y}"]
+    p.append(f"L {x + w - tr},{y}")
+    p.append(f"Q {x + w},{y} {x + w},{y + tr}" if tr > 0 else f"L {x + w},{y}")
+    p.append(f"L {x + w},{y + h - br}")
+    p.append(f"Q {x + w},{y + h} {x + w - br},{y + h}" if br > 0 else f"L {x + w},{y + h}")
+    p.append(f"L {x + bl},{y + h}")
+    p.append(f"Q {x},{y + h} {x},{y + h - bl}" if bl > 0 else f"L {x},{y + h}")
+    p.append(f"L {x},{y + tl}")
+    p.append(f"Q {x},{y} {x + tl},{y}" if tl > 0 else f"L {x},{y}")
+    p.append("Z")
+    return " ".join(p)

qrcody-1.8.1/src/qrcody/xml_utils.py

@@ -0,0 +1,13 @@
+"""XML escaping — mirrors src/utils/xml.js."""
+
+
+def escape_xml(s: object) -> str:
+    """Escape XML/HTML-special characters for safe interpolation into SVG markup."""
+    return (
+        str(s)
+        .replace("&", "&")
+        .replace("<", "&lt;")
+        .replace(">", "&gt;")
+        .replace('"', "&quot;")
+        .replace("'", "&apos;")
+    )