adb-qr 0.1.0__tar.gz

adb_qr-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,22 @@
+name: Release
+
+on:
+  push:
+    tags: ["v*"]
+
+jobs:
+  pypi:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write   # PyPI trusted publishing (OIDC)
+      contents: write   # gh release create
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+      - run: uv build
+      - run: uv publish --trusted-publishing always
+      - name: Create GitHub release
+        run: gh release create "$GITHUB_REF_NAME" dist/* --generate-notes
+        env:
+          GH_TOKEN: ${{ github.token }}

adb_qr-0.1.0/.gitignore

@@ -0,0 +1,4 @@
+__pycache__/
+*.egg-info/
+dist/
+.venv/

adb_qr-0.1.0/LICENSE

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

adb_qr-0.1.0/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.4
+Name: adb-qr
+Version: 0.1.0
+Summary: Pair Android devices for wireless ADB by QR code -- discovery via adb's own mDNS, so it works even in WSL2, containers and VMs
+Project-URL: Repository, https://github.com/aleixrodriala/adb-qr
+Project-URL: Issues, https://github.com/aleixrodriala/adb-qr/issues
+Author-email: Aleix <aleixrodriala@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: adb,android,mdns,qr-code,wireless-debugging,wsl2
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Debuggers
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Requires-Dist: qrcode>=7
+Description-Content-Type: text/markdown
+
+# adb-qr
+
+Pair your Android phone for wireless debugging by scanning a QR code in your
+terminal — like Android Studio's *"Pair device with QR code"*, but for the
+CLI. No typing pairing codes, no looking up IPs and ports.
+
+![adb-qr pairing session](docs/demo.png)
+
+## Why another QR-pairing tool?
+
+Existing tools ([adb-wireless](https://github.com/teamclouday/adb-wireless),
+[adb-qr](https://github.com/oosawy/adb-qr), and friends) run their **own**
+mDNS listener to discover the phone after it scans the QR. That works on a
+native host — and silently fails inside **WSL2, containers, and VMs**, where
+LAN multicast never reaches the virtualized network. The QR renders, the
+phone scans it, and then... nothing.
+
+`adb-qr` doesn't listen for mDNS at all. It asks the **adb server itself**
+what it sees (`adb mdns services`), so discovery happens wherever the server
+runs. On WSL2, point it at the Windows `adb.exe` (it does this automatically)
+and the Windows side — which *can* see your LAN — does the discovery. The
+same trick means zero networking dependencies on any platform: if `adb`
+works, `adb-qr` works.
+
+## Install
+
+With [uv](https://docs.astral.sh/uv/) (recommended):
+
+```sh
+uv tool install git+https://github.com/aleixrodriala/adb-qr
+```
+
+With [pipx](https://pipx.pypa.io/):
+
+```sh
+pipx install git+https://github.com/aleixrodriala/adb-qr
+```
+
+Or run it once without installing anything:
+
+```sh
+uvx --from git+https://github.com/aleixrodriala/adb-qr adb-qr
+```
+
+### Requirements
+
+- Android **platform-tools 31+** on the host that has network visibility
+  (on WSL2: install them on **Windows**; `adb-qr` finds `adb.exe` by itself)
+- A phone on **Android 11+**, on the same Wi-Fi as that host
+- Python 3.10+ (handled for you by `uv`/`pipx`)
+
+## Usage
+
+```
+adb-qr                # show QR, wait for scan, pair, connect
+adb-qr --pair-only    # stop after pairing (adb usually auto-connects anyway)
+adb-qr --timeout 300  # wait longer for the scan
+adb-qr --no-invert    # flip QR colors if your phone won't scan it
+adb-qr --adb /path/to/adb   # explicit adb binary (env var ADB works too)
+```
+
+On the phone: **Settings → Developer options → Wireless debugging →
+Pair device with QR code**, and point the camera at your terminal.
+
+## How it works
+
+The QR encodes `WIFI:T:ADB;S:<name>;P:<password>;;` — the same payload
+Android Studio generates. When the phone scans it:
+
+1. The phone starts advertising an `_adb-tls-pairing._tcp` mDNS service
+   whose instance name is the `<name>` from the QR.
+2. `adb-qr` polls `adb mdns services` until that service shows up, then runs
+   `adb pair <ip>:<port> <password>`.
+3. After pairing, the phone's `_adb-tls-connect._tcp` service is used to
+   `adb connect` (recent adb versions often auto-connect on their own —
+   `adb-qr` detects that too and gets out of the way).
+
+## Troubleshooting
+
+- **QR won't scan** — try `--no-invert`; some terminal color schemes render
+  the QR with polarity a given camera dislikes.
+- **Times out waiting for scan** — the phone must be on the same network as
+  the machine where the *adb server* runs. On WSL2 that machine is Windows,
+  not the WSL VM. Corporate/guest Wi-Fi often blocks mDNS entirely.
+- **`adb mdns check` fails** — `adb-qr` force-enables the openscreen mDNS
+  backend (`ADB_MDNS_OPENSCREEN=1`) and restarts the server once; if it still
+  fails, update platform-tools.
+- **Paired but not connected** — run `adb connect <ip>:<port>` with the port
+  shown on the phone's Wireless debugging screen (it differs from the
+  pairing port).
+
+## Prior art
+
+The pair-by-QR flow was pioneered for the terminal by
+[teamclouday/adb-wireless](https://github.com/teamclouday/adb-wireless).
+`adb-qr` exists because none of the existing tools survive WSL2's NAT — and
+delegating discovery to the adb server turned out to make the whole thing
+simpler, too.
+
+## License
+
+MIT

adb_qr-0.1.0/README.md

@@ -0,0 +1,102 @@
+# adb-qr
+
+Pair your Android phone for wireless debugging by scanning a QR code in your
+terminal — like Android Studio's *"Pair device with QR code"*, but for the
+CLI. No typing pairing codes, no looking up IPs and ports.
+
+![adb-qr pairing session](docs/demo.png)
+
+## Why another QR-pairing tool?
+
+Existing tools ([adb-wireless](https://github.com/teamclouday/adb-wireless),
+[adb-qr](https://github.com/oosawy/adb-qr), and friends) run their **own**
+mDNS listener to discover the phone after it scans the QR. That works on a
+native host — and silently fails inside **WSL2, containers, and VMs**, where
+LAN multicast never reaches the virtualized network. The QR renders, the
+phone scans it, and then... nothing.
+
+`adb-qr` doesn't listen for mDNS at all. It asks the **adb server itself**
+what it sees (`adb mdns services`), so discovery happens wherever the server
+runs. On WSL2, point it at the Windows `adb.exe` (it does this automatically)
+and the Windows side — which *can* see your LAN — does the discovery. The
+same trick means zero networking dependencies on any platform: if `adb`
+works, `adb-qr` works.
+
+## Install
+
+With [uv](https://docs.astral.sh/uv/) (recommended):
+
+```sh
+uv tool install git+https://github.com/aleixrodriala/adb-qr
+```
+
+With [pipx](https://pipx.pypa.io/):
+
+```sh
+pipx install git+https://github.com/aleixrodriala/adb-qr
+```
+
+Or run it once without installing anything:
+
+```sh
+uvx --from git+https://github.com/aleixrodriala/adb-qr adb-qr
+```
+
+### Requirements
+
+- Android **platform-tools 31+** on the host that has network visibility
+  (on WSL2: install them on **Windows**; `adb-qr` finds `adb.exe` by itself)
+- A phone on **Android 11+**, on the same Wi-Fi as that host
+- Python 3.10+ (handled for you by `uv`/`pipx`)
+
+## Usage
+
+```
+adb-qr                # show QR, wait for scan, pair, connect
+adb-qr --pair-only    # stop after pairing (adb usually auto-connects anyway)
+adb-qr --timeout 300  # wait longer for the scan
+adb-qr --no-invert    # flip QR colors if your phone won't scan it
+adb-qr --adb /path/to/adb   # explicit adb binary (env var ADB works too)
+```
+
+On the phone: **Settings → Developer options → Wireless debugging →
+Pair device with QR code**, and point the camera at your terminal.
+
+## How it works
+
+The QR encodes `WIFI:T:ADB;S:<name>;P:<password>;;` — the same payload
+Android Studio generates. When the phone scans it:
+
+1. The phone starts advertising an `_adb-tls-pairing._tcp` mDNS service
+   whose instance name is the `<name>` from the QR.
+2. `adb-qr` polls `adb mdns services` until that service shows up, then runs
+   `adb pair <ip>:<port> <password>`.
+3. After pairing, the phone's `_adb-tls-connect._tcp` service is used to
+   `adb connect` (recent adb versions often auto-connect on their own —
+   `adb-qr` detects that too and gets out of the way).
+
+## Troubleshooting
+
+- **QR won't scan** — try `--no-invert`; some terminal color schemes render
+  the QR with polarity a given camera dislikes.
+- **Times out waiting for scan** — the phone must be on the same network as
+  the machine where the *adb server* runs. On WSL2 that machine is Windows,
+  not the WSL VM. Corporate/guest Wi-Fi often blocks mDNS entirely.
+- **`adb mdns check` fails** — `adb-qr` force-enables the openscreen mDNS
+  backend (`ADB_MDNS_OPENSCREEN=1`) and restarts the server once; if it still
+  fails, update platform-tools.
+- **Paired but not connected** — run `adb connect <ip>:<port>` with the port
+  shown on the phone's Wireless debugging screen (it differs from the
+  pairing port).
+
+## Prior art
+
+The pair-by-QR flow was pioneered for the terminal by
+[teamclouday/adb-wireless](https://github.com/teamclouday/adb-wireless).
+`adb-qr` exists because none of the existing tools survive WSL2's NAT — and
+delegating discovery to the adb server turned out to make the whole thing
+simpler, too.
+
+## License
+
+MIT

adb_qr-0.1.0/adb_qr.py

@@ -0,0 +1,244 @@
+#!/usr/bin/env -S uv run --script --quiet
+# /// script
+# requires-python = ">=3.10"
+# dependencies = ["qrcode>=7"]
+# ///
+"""Pair an Android device for wireless ADB by scanning a QR code in the terminal.
+
+Like Android Studio's "Pair device with QR code", but for the CLI:
+
+  1. Show a QR encoding ``WIFI:T:ADB;S:<name>;P:<password>;;``
+  2. The phone scans it (Developer options > Wireless debugging > Pair device
+     with QR code) and starts advertising an ``_adb-tls-pairing._tcp`` mDNS
+     service named ``<name>``.
+  3. We discover it and run ``adb pair ip:port password``.
+  4. We find the device's ``_adb-tls-connect._tcp`` service (or let adb's
+     auto-connect kick in) and ``adb connect``.
+
+Unlike other QR-pairing tools, discovery is delegated to the adb server
+itself (``adb mdns services``) instead of an in-process zeroconf listener.
+That makes it work in places where LAN multicast never reaches the tool --
+WSL2, containers, VMs -- as long as the adb server runs somewhere with real
+network visibility (on WSL2: the Windows adb.exe).
+"""
+
+from __future__ import annotations
+
+__version__ = "0.1.0"
+
+import argparse
+import glob
+import os
+import secrets
+import shutil
+import string
+import subprocess
+import sys
+import time
+
+import qrcode
+
+PAIR_SVC = "_adb-tls-pairing"
+CONNECT_SVC = "_adb-tls-connect"
+WIN_ADB_GLOB = "/mnt/c/Users/*/AppData/Local/Android/Sdk/platform-tools/adb.exe"
+
+
+def is_wsl() -> bool:
+    try:
+        with open("/proc/version") as f:
+            return "microsoft" in f.read().lower()
+    except OSError:
+        return False
+
+
+def find_adb(override: str | None) -> str:
+    if override:
+        return override
+    if os.environ.get("ADB"):
+        return os.environ["ADB"]
+    if is_wsl():
+        # Prefer the Windows adb: its server runs on the Windows side, where
+        # LAN multicast is visible. A Linux adb inside WSL2 sits behind NAT
+        # and its mDNS discovery comes up empty.
+        exe = shutil.which("adb.exe") or next(iter(glob.glob(WIN_ADB_GLOB)), None)
+        if exe:
+            return exe
+        linux_adb = shutil.which("adb")
+        if linux_adb:
+            print(
+                "warning: no Windows adb.exe found, falling back to Linux adb -- "
+                "mDNS discovery will likely fail inside WSL2. Install "
+                "platform-tools on the Windows side for reliable pairing.",
+                file=sys.stderr,
+            )
+            return linux_adb
+    else:
+        found = shutil.which("adb")
+        if found:
+            return found
+        home = os.path.expanduser("~")
+        candidates = [
+            os.path.join(home, "Library", "Android", "sdk", "platform-tools", "adb"),
+            os.path.join(home, "Android", "Sdk", "platform-tools", "adb"),
+        ]
+        if os.environ.get("LOCALAPPDATA"):
+            candidates.append(
+                os.path.join(
+                    os.environ["LOCALAPPDATA"],
+                    "Android", "Sdk", "platform-tools", "adb.exe",
+                )
+            )
+        for p in candidates:
+            if os.path.exists(p):
+                return p
+    sys.exit("adb not found -- install Android platform-tools or pass --adb /path/to/adb")
+
+
+def adb_env() -> dict[str, str]:
+    # ADB_MDNS_OPENSCREEN=1 forces the built-in mdns backend on older
+    # platform-tools; harmless on recent versions where it is the default.
+    env = {**os.environ, "ADB_MDNS_OPENSCREEN": "1"}
+    if is_wsl():
+        # WSLENV makes the variable cross the WSL->Windows interop boundary,
+        # so the adb *server* (a Windows process) actually sees it.
+        env["WSLENV"] = (os.environ.get("WSLENV", "") + ":ADB_MDNS_OPENSCREEN/u").lstrip(":")
+    return env
+
+
+def run_adb(adb_path: str, *args: str, timeout: int = 60) -> subprocess.CompletedProcess:
+    return subprocess.run(
+        [adb_path, *args], capture_output=True, text=True, env=adb_env(), timeout=timeout
+    )
+
+
+def mdns_services(adb_path: str) -> list[tuple[str, str, str, int]]:
+    """Parse `adb mdns services` into (instance, service_type, ip, port) rows."""
+    out = run_adb(adb_path, "mdns", "services").stdout
+    rows = []
+    for line in out.splitlines():
+        line = line.rstrip("\r")
+        parts = line.split("\t") if "\t" in line else line.split()
+        if len(parts) < 3 or not parts[1].startswith("_adb-tls-"):
+            continue
+        instance, svc, endpoint = parts[0], parts[1], parts[2]
+        ip, _, port = endpoint.rpartition(":")
+        if ip and port.isdigit():
+            rows.append((instance, svc, ip, int(port)))
+    return rows
+
+
+def ensure_mdns(adb_path: str) -> None:
+    check = run_adb(adb_path, "mdns", "check")
+    if "daemon version" in check.stdout:
+        return
+    # The server may have been started without mdns enabled; restart it with
+    # our environment and try once more.
+    run_adb(adb_path, "kill-server")
+    check = run_adb(adb_path, "mdns", "check")
+    if "daemon version" in check.stdout:
+        return
+    msg = (check.stdout + check.stderr).strip()
+    if "unknown command" in msg or "usage:" in msg.lower():
+        sys.exit(
+            "this adb is too old for `adb mdns services` -- update Android "
+            "platform-tools (31+): https://developer.android.com/tools/releases/platform-tools"
+        )
+    sys.exit(f"adb mdns unavailable: {msg}")
+
+
+def print_qr(text: str, invert: bool) -> None:
+    qr = qrcode.QRCode(border=2)
+    qr.add_data(text)
+    qr.print_ascii(invert=invert)
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(
+        prog="adb-qr",
+        description="Pair (and connect) an Android device over wireless ADB by QR code.",
+    )
+    ap.add_argument("--adb", help="path to the adb binary (default: autodetect; env ADB also works)")
+    ap.add_argument("--timeout", type=int, default=120, metavar="SECONDS",
+                    help="how long to wait for the phone to scan (default: 120)")
+    ap.add_argument("--pair-only", action="store_true",
+                    help="stop after pairing; don't wait for a connection")
+    ap.add_argument("--no-invert", action="store_true",
+                    help="flip QR colors if your scanner struggles on this terminal background")
+    ap.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    args = ap.parse_args()
+
+    adb_path = find_adb(args.adb)
+    ensure_mdns(adb_path)
+
+    name = f"adbqr-{secrets.token_hex(4)}"
+    alphabet = string.ascii_letters + string.digits
+    password = "".join(secrets.choice(alphabet) for _ in range(12))
+
+    print_qr(f"WIFI:T:ADB;S:{name};P:{password};;", invert=not args.no_invert)
+    print("On the phone: Developer options > Wireless debugging > Pair device with QR code")
+    print(f"Waiting for scan (up to {args.timeout}s)... ", end="", flush=True)
+
+    # Phase 1: after scanning, the phone advertises _adb-tls-pairing named
+    # after the QR's S: field. Match on that; if some device doesn't echo the
+    # name back, fall back to a lone pairing service (the password still
+    # guards against pairing with the wrong device).
+    pair_ip = pair_port = None
+    deadline = time.monotonic() + args.timeout
+    try:
+        while time.monotonic() < deadline:
+            pairing = [r for r in mdns_services(adb_path) if r[1].startswith(PAIR_SVC)]
+            match = [r for r in pairing if r[0] == name] or (
+                pairing if len(pairing) == 1 else []
+            )
+            if match:
+                _, _, pair_ip, pair_port = match[0]
+                break
+            time.sleep(1)
+    except KeyboardInterrupt:
+        print("\ninterrupted")
+        return 130
+    if not pair_ip:
+        print("\nTimed out: the phone never appeared in `adb mdns services`.")
+        print("Make sure it is on the same network as the machine running the adb")
+        print("server (on WSL2 that's Windows, not the WSL VM) and try again.")
+        return 1
+    print(f"found {pair_ip}:{pair_port}")
+
+    res = run_adb(adb_path, "pair", f"{pair_ip}:{pair_port}", password)
+    if "Successfully paired" not in res.stdout:
+        print(f"Pairing failed: {(res.stdout + res.stderr).strip()}", file=sys.stderr)
+        return 1
+    print(res.stdout.strip())
+    if args.pair_only:
+        return 0
+
+    # Phase 2: connect. Recent adb auto-connects to paired devices it sees
+    # via mDNS, so watch `adb devices` while also trying an explicit connect
+    # against the device's _adb-tls-connect service.
+    deadline = time.monotonic() + 30
+    try:
+        while time.monotonic() < deadline:
+            devices = run_adb(adb_path, "devices").stdout
+            connected = [
+                line for line in devices.splitlines()
+                if line.strip().endswith("device") and (pair_ip in line or CONNECT_SVC in line)
+            ]
+            if connected:
+                print(f"Connected: {connected[0].split()[0]}")
+                return 0
+            for _, svc, ip, port in mdns_services(adb_path):
+                if svc.startswith(CONNECT_SVC) and ip == pair_ip:
+                    res = run_adb(adb_path, "connect", f"{ip}:{port}")
+                    print(res.stdout.strip())
+            time.sleep(1)
+    except KeyboardInterrupt:
+        print("\ninterrupted (already paired -- `adb connect` manually if needed)")
+        return 130
+
+    print("Paired, but no connection after 30s -- run `adb connect <ip>:<port>` with")
+    print("the port shown on the phone's Wireless debugging screen.")
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

adb_qr-0.1.0/docs/make_demo.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env -S uv run --script --quiet
+# /// script
+# requires-python = ">=3.10"
+# dependencies = ["qrcode>=7", "rich>=13"]
+# ///
+"""Regenerate the README demo image.
+
+This writes demo.svg; rasterize it with a real browser so the embedded
+webfont renders the QR's half-block glyphs correctly (cairosvg mangles them):
+
+    chrome --headless=new --screenshot=demo.png --window-size=2038,1272 \
+           --hide-scrollbars --virtual-time-budget=10000 file://.../demo.svg
+"""
+
+import io
+import pathlib
+
+import qrcode
+from rich.console import Console
+
+qr = qrcode.QRCode(border=2)
+qr.add_data("WIFI:T:ADB;S:adbqr-3f9a17c2;P:kP4mW9xQz2Lr;;")
+buf = io.StringIO()
+qr.print_ascii(out=buf, invert=True)
+
+console = Console(record=True, width=82)
+console.print("[bold green]$[/] [bold]adb-qr[/]")
+console.print(buf.getvalue().rstrip("\n"), markup=False, highlight=False)
+console.print("On the phone: Developer options > Wireless debugging > Pair device with QR code")
+console.print("Waiting for scan (up to 120s)... [cyan]found 192.168.1.42:40331[/]")
+console.print("[green]Successfully paired to 192.168.1.42:40331 \\[guid=adb-1A2B3C4D-aBcDeF][/]")
+console.print("[bold green]Connected: 192.168.1.42:44915[/]")
+console.save_svg(str(pathlib.Path(__file__).parent / "demo.svg"), title="adb-qr")

adb_qr-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[project]
+name = "adb-qr"
+version = "0.1.0"
+description = "Pair Android devices for wireless ADB by QR code -- discovery via adb's own mDNS, so it works even in WSL2, containers and VMs"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+dependencies = ["qrcode>=7"]
+authors = [{ name = "Aleix", email = "aleixrodriala@gmail.com" }]
+keywords = ["adb", "android", "wireless-debugging", "qr-code", "wsl2", "mdns"]
+classifiers = [
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development :: Debuggers",
+    "Topic :: Utilities",
+]
+
+[project.urls]
+Repository = "https://github.com/aleixrodriala/adb-qr"
+Issues = "https://github.com/aleixrodriala/adb-qr/issues"
+
+[project.scripts]
+adb-qr = "adb_qr:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+include = ["adb_qr.py"]

adb_qr-0.1.0/uv.lock

@@ -0,0 +1,35 @@
+version = 1
+revision = 3
+requires-python = ">=3.10"
+
+[[package]]
+name = "adb-qr"
+version = "0.1.0"
+source = { editable = "." }
+dependencies = [
+    { name = "qrcode" },
+]
+
+[package.metadata]
+requires-dist = [{ name = "qrcode", specifier = ">=7" }]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "qrcode"
+version = "8.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8f/b2/7fc2931bfae0af02d5f53b174e9cf701adbb35f39d69c2af63d4a39f81a9/qrcode-8.2.tar.gz", hash = "sha256:35c3f2a4172b33136ab9f6b3ef1c00260dd2f66f858f24d88418a015f446506c", size = 43317, upload-time = "2025-05-01T15:44:24.726Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dd/b8/d2d6d731733f51684bbf76bf34dab3b70a9148e8f2cef2bb544fccec681a/qrcode-8.2-py3-none-any.whl", hash = "sha256:16e64e0716c14960108e85d853062c9e8bba5ca8252c0b4d0231b9df4060ff4f", size = 45986, upload-time = "2025-05-01T15:44:22.781Z" },
+]