linpuzs 0.1.0__tar.gz

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

@@ -0,0 +1,74 @@
+# Every push to main publishes a new minor version to PyPI: v0.1.0, v0.2.0, v0.3.0, ...
+#
+# The version lives only in git tags (hatch-vcs reads it at build time), so
+# nothing is committed back to main. Uploads use PyPI trusted publishing, which
+# must be configured on pypi.org for this repo, this file (release.yml) and the
+# "pypi" environment.
+
+name: Release
+
+on:
+  push:
+    branches: [main]
+
+concurrency:
+  group: release
+  cancel-in-progress: false
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      contents: write # push the tag and create the GitHub release
+      id-token: write # trusted publishing to PyPI
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0 # all tags, to find the latest version
+
+      - uses: astral-sh/setup-uv@v6
+
+      - name: Test
+        run: |
+          uv sync
+          uv run pytest -q
+
+      - name: Pick the next version
+        id: version
+        run: |
+          # Re-running on an already released commit reuses its tag.
+          existing=$(git tag --points-at HEAD --list 'v*' | head -n1)
+          if [ -n "$existing" ]; then
+            echo "tag=$existing" >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+          latest=$(git tag --list 'v*.*.*' --sort=-v:refname | head -n1)
+          if [ -z "$latest" ]; then
+            next="v0.1.0"
+          else
+            IFS=. read -r major minor _ <<< "${latest#v}"
+            next="v${major}.$((minor + 1)).0"
+          fi
+          echo "tag=$next" >> "$GITHUB_OUTPUT"
+          echo "Releasing $next (previous: ${latest:-none})"
+
+      - name: Build
+        run: |
+          git tag "${{ steps.version.outputs.tag }}" 2>/dev/null || true
+          rm -rf dist
+          uv build
+          ls dist
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          skip-existing: true
+
+      - name: Push tag and create GitHub release
+        env:
+          GH_TOKEN: ${{ github.token }}
+          TAG: ${{ steps.version.outputs.tag }}
+        run: |
+          git push origin "$TAG"
+          gh release view "$TAG" >/dev/null 2>&1 || gh release create "$TAG" dist/* --generate-notes

linpuzs-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.py[cod]
+.venv/
+dist/
+build/
+*.egg-info/
+.pytest_cache/
+.DS_Store

linpuzs-0.1.0/LICENSE

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

linpuzs-0.1.0/PKG-INFO

@@ -0,0 +1,81 @@
+Metadata-Version: 2.5
+Name: linpuzs
+Version: 0.1.0
+Summary: LinkedIn puzzle solver: screenshots your phone over ADB, solves the daily game, and taps in the answer.
+License: MIT License
+        
+        Copyright (c) 2026 Pratyush
+        
+        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.
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: numpy>=1.26
+Requires-Dist: pillow>=10.0
+Requires-Dist: questionary>=2.0
+Requires-Dist: rich>=13.7
+Description-Content-Type: text/markdown
+
+# linpuzs: Linkedin Puzzle Solver
+
+For when you want the streak but not the 4 minutes of staring at coloured squares.
+
+Plug in your Android phone, open today's LinkedIn puzzle and run `linpuzs`. It grabs a screenshot over ADB, figures out the board, solves it, and taps the answer in for you, usually in a few seconds.
+
+### Supported games
+
+| Game | Goal | How the answer is entered |
+| --- | --- | --- |
+| 👑 Queens | One crown in every row, column and colour region, none touching | Double-tap each crown cell |
+| 🌗 Tango | Fill with suns and moons: balanced rows and columns, no three in a row, respect `=` and `×` | Tap each empty cell (once for sun, twice for moon) |
+| 〰️ Zip | One path through every cell, passing the numbered dots in order | One continuous drag |
+| 🔢 Mini Sudoku | 1-6 once in every row, column and 2×3 box | Tap the cell, then the number pad |
+| 🧵 Patches | Split the grid into rectangles matching each clue's shape and size | Drag across each patch |
+
+## Setup
+
+Requires [uv](https://docs.astral.sh/uv/) and `adb` (Android platform-tools) on your PATH, with USB debugging enabled on the phone.
+
+```bash
+uv sync
+uv run linpuzs
+```
+
+## Usage
+
+```
+linpuzs                      interactive: pick device (if several) → pick game → solve
+linpuzs -g queens            solve one game without the menu
+linpuzs -s SERIAL            use a specific device
+linpuzs -n                   dry run: solve, but don't touch the screen
+linpuzs --list               show games and solver status
+```
+
+**Dry run:** `linpuzs -n` (or `--dry-run`) reads the board from your phone, solves it and prints the solved board in the terminal, without tapping anything.
+
+## Tests
+
+No phone needed. Each game has two test files:
+
+- `tests/test_<game>.py` checks the real screenshot in `media/example/`.
+- `tests/test_<game>_fuzz.py` draws random boards the way the app does, solves them, and replays the touches.
+
+```bash
+uv run pytest -q                                      # everything (~1-2 min)
+uv run pytest -q tests/test_zip.py                    # one game's screenshot tests
+```

linpuzs-0.1.0/README.md

@@ -0,0 +1,48 @@
+# linpuzs: Linkedin Puzzle Solver
+
+For when you want the streak but not the 4 minutes of staring at coloured squares.
+
+Plug in your Android phone, open today's LinkedIn puzzle and run `linpuzs`. It grabs a screenshot over ADB, figures out the board, solves it, and taps the answer in for you, usually in a few seconds.
+
+### Supported games
+
+| Game | Goal | How the answer is entered |
+| --- | --- | --- |
+| 👑 Queens | One crown in every row, column and colour region, none touching | Double-tap each crown cell |
+| 🌗 Tango | Fill with suns and moons: balanced rows and columns, no three in a row, respect `=` and `×` | Tap each empty cell (once for sun, twice for moon) |
+| 〰️ Zip | One path through every cell, passing the numbered dots in order | One continuous drag |
+| 🔢 Mini Sudoku | 1-6 once in every row, column and 2×3 box | Tap the cell, then the number pad |
+| 🧵 Patches | Split the grid into rectangles matching each clue's shape and size | Drag across each patch |
+
+## Setup
+
+Requires [uv](https://docs.astral.sh/uv/) and `adb` (Android platform-tools) on your PATH, with USB debugging enabled on the phone.
+
+```bash
+uv sync
+uv run linpuzs
+```
+
+## Usage
+
+```
+linpuzs                      interactive: pick device (if several) → pick game → solve
+linpuzs -g queens            solve one game without the menu
+linpuzs -s SERIAL            use a specific device
+linpuzs -n                   dry run: solve, but don't touch the screen
+linpuzs --list               show games and solver status
+```
+
+**Dry run:** `linpuzs -n` (or `--dry-run`) reads the board from your phone, solves it and prints the solved board in the terminal, without tapping anything.
+
+## Tests
+
+No phone needed. Each game has two test files:
+
+- `tests/test_<game>.py` checks the real screenshot in `media/example/`.
+- `tests/test_<game>_fuzz.py` draws random boards the way the app does, solves them, and replays the touches.
+
+```bash
+uv run pytest -q                                      # everything (~1-2 min)
+uv run pytest -q tests/test_zip.py                    # one game's screenshot tests
+```

linpuzs-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[project]
+name = "linpuzs"
+dynamic = ["version"]  # from the latest vX.Y.Z git tag, see .github/workflows/release.yml
+description = "LinkedIn puzzle solver: screenshots your phone over ADB, solves the daily game, and taps in the answer."
+readme = "README.md"
+license = { file = "LICENSE" }
+requires-python = ">=3.10"
+dependencies = [
+    "rich>=13.7",
+    "questionary>=2.0",
+    "pillow>=10.0",
+    "numpy>=1.26",
+]
+
+[project.scripts]
+linpuzs = "linpuzs.cli:main"
+
+[dependency-groups]
+dev = ["pytest>=8.0"]
+
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+source = "vcs"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/linpuzs"]

linpuzs-0.1.0/scripts/make_digits.py

@@ -0,0 +1,50 @@
+"""Cut 0-9 digit templates (LinkedIn's game font) out of the Zip example screenshot.
+
+    uv run python scripts/make_digits.py
+
+The numbers below are what the example board shows; each dot's glyphs are
+paired with the digits of its number. Writes src/linpuzs/util/digits.npz.
+"""
+
+from pathlib import Path
+
+import numpy as np
+from PIL import Image
+
+from linpuzs.solvers.zip import LINE_RGB, LINE_TOLERANCE, dot_ink
+from linpuzs.util.digits import split_glyphs
+from linpuzs.util.vision import find_grid
+
+ROOT = Path(__file__).parents[1]
+EXAMPLE = ROOT / "media" / "example" / "zip.png"
+OUT = ROOT / "src" / "linpuzs" / "util" / "digits.npz"
+
+# (row, col) -> number, as shown in media/example/zip.png
+KNOWN = {
+    (1, 0): 11, (1, 1): 9, (1, 4): 4, (1, 5): 12,
+    (2, 1): 10, (2, 5): 5,
+    (3, 0): 8, (3, 4): 3,
+    (4, 0): 7, (4, 1): 1, (4, 4): 2, (4, 5): 6,
+}  # fmt: skip
+
+
+def main() -> None:
+    a = np.asarray(Image.open(EXAMPLE).convert("RGB"))
+    grid = find_grid(np.abs(a.astype(int) - LINE_RGB).max(axis=2) <= LINE_TOLERANCE)
+    assert grid is not None
+    templates: dict[str, np.ndarray] = {}
+    for (r, c), number in KNOWN.items():
+        (y0, y1), (x0, x1) = grid.row_spans[r], grid.col_spans[c]
+        ink = dot_ink(a[y0:y1, x0:x1])
+        glyphs = split_glyphs(ink) if ink is not None else None
+        digits = str(number)
+        assert glyphs is not None and len(glyphs) == len(digits), (r, c, number)
+        for d, g in zip(digits, glyphs):
+            templates.setdefault(d, g)
+    assert sorted(templates) == list("0123456789"), sorted(templates)
+    np.savez_compressed(OUT, **templates)
+    print(f"wrote {OUT.relative_to(ROOT)}: " + ", ".join(f"{d} {t.shape[1]}×{t.shape[0]}" for d, t in sorted(templates.items())))
+
+
+if __name__ == "__main__":
+    main()

linpuzs-0.1.0/src/linpuzs/__init__.py

@@ -0,0 +1,8 @@
+"""linpuzs: LinkedIn puzzle solver."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("linpuzs")
+except PackageNotFoundError:  # running from a source tree that isn't installed
+    __version__ = "0.0.0"

linpuzs-0.1.0/src/linpuzs/__main__.py

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

linpuzs-0.1.0/src/linpuzs/actions.py

@@ -0,0 +1,39 @@
+"""Touch actions a solver asks the device to perform, in screen pixel coordinates."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Tap:
+    x: int
+    y: int
+
+
+@dataclass(frozen=True)
+class Swipe:
+    x1: int
+    y1: int
+    x2: int
+    y2: int
+    duration_ms: int = 100
+
+
+@dataclass(frozen=True)
+class Drag:
+    """A single continuous stroke through a list of points (e.g. drawing a path)."""
+
+    points: tuple[tuple[int, int], ...]
+
+    def __post_init__(self):
+        if len(self.points) < 2:
+            raise ValueError("Drag needs at least two points")
+
+
+@dataclass(frozen=True)
+class Wait:
+    ms: int
+
+
+Action = Tap | Swipe | Drag | Wait

linpuzs-0.1.0/src/linpuzs/cli.py

@@ -0,0 +1,165 @@
+"""`linpuzs` entry point."""
+
+from __future__ import annotations
+
+import argparse
+
+import questionary
+from questionary import Choice, Style
+
+from linpuzs import __version__, runner
+from linpuzs.solvers import GAMES, SolverError, get_solver, solver_for
+from linpuzs.ui import ACCENT, banner, console, device_table, games_table, session_summary, stats_panel
+from linpuzs.util.adb import AdbDevice, AdbError, Device, adb_path, list_devices
+
+PROMPT_STYLE = Style(
+    [
+        ("qmark", f"fg:{ACCENT} bold"),
+        ("pointer", f"fg:{ACCENT} bold"),
+        ("highlighted", f"fg:{ACCENT} bold"),
+        ("selected", "fg:green"),
+        ("disabled", "fg:#666666 italic"),
+    ]
+)
+
+QUIT = "__quit__"
+
+
+def parse_args(argv: list[str] | None) -> argparse.Namespace:
+    p = argparse.ArgumentParser(prog="linpuzs", description="Solve LinkedIn daily puzzles on your phone over ADB.")
+    p.add_argument("-s", "--serial", help="ADB device serial to use (skips the device prompt)")
+    p.add_argument("-g", "--game", choices=list(GAMES), help="Game to solve (skips the game menu)")
+    p.add_argument("-n", "--dry-run", action="store_true", help="Solve but don't send any touches")
+    p.add_argument("--list", action="store_true", help="List games and exit")
+    p.add_argument("--no-banner", action="store_true", help="Skip the ASCII banner")
+    p.add_argument("-V", "--version", action="version", version=f"linpuzs {__version__}")
+    return p.parse_args(argv)
+
+
+def pick_device(serial: str | None) -> AdbDevice | None:
+    if adb_path() is None:
+        console.print("[red]✗[/] [bold]adb[/] not found on PATH. Install Android platform-tools and try again.")
+        return None
+
+    with console.status("Looking for ADB devices…"):
+        devices = list_devices()
+
+    ready = [d for d in devices if d.is_ready]
+    not_ready = [d for d in devices if not d.is_ready]
+    for d in not_ready:
+        hint = "accept the USB debugging prompt on the phone" if d.state == "unauthorized" else "reconnect it"
+        console.print(f"[yellow]![/] {d.serial} is [yellow]{d.state}[/]: {hint}.")
+
+    if serial:
+        match = next((d for d in ready if d.serial == serial), None)
+        if match is None:
+            console.print(f"[red]✗[/] Device [bold]{serial}[/] is not connected and ready.")
+            return None
+        return _connected(match)
+
+    if not ready:
+        console.print("[red]✗[/] No ADB device found. Plug in your phone with USB debugging enabled.")
+        return None
+    if len(ready) == 1:
+        return _connected(ready[0])
+
+    console.print(device_table(ready))
+    chosen = questionary.select(
+        "Multiple devices connected. Which one?",
+        choices=[Choice(d.label(), value=d) for d in ready],
+        style=PROMPT_STYLE,
+    ).ask()
+    return _connected(chosen) if chosen else None
+
+
+def _connected(d: Device) -> AdbDevice:
+    console.print(f"[green]✓[/] Connected to [bold]{d.model}[/] [dim]({d.serial})[/]")
+    return AdbDevice(d)
+
+
+def pick_game() -> str | None:
+    choices = []
+    for g in GAMES.values():
+        ready = solver_for(g.slug) is not None
+        choices.append(
+            Choice(
+                f"{g.icon}  {g.name:<12} {g.tagline}",
+                value=g.slug,
+                disabled=None if ready else "coming soon",
+            )
+        )
+    choices.append(Choice("👋  Quit", value=QUIT))
+    return questionary.select("Which puzzle?", choices=choices, style=PROMPT_STYLE).ask()
+
+
+def solve_once(slug: str, device: AdbDevice, args: argparse.Namespace) -> runner.RunResult | None:
+    game = GAMES[slug]
+    if not args.game:
+        ok = questionary.confirm(
+            f"Open {game.name} on your phone so the board is visible. Ready?",
+            default=True,
+            style=PROMPT_STYLE,
+        ).ask()
+        if not ok:
+            return None
+
+    solver = get_solver(slug)
+    with console.status(f"{game.icon}  Solving {game.name}…", spinner="dots") as status:
+        try:
+            result = runner.run(
+                solver,
+                device,
+                dry_run=args.dry_run,
+                on_stage=lambda s: status.update(f"{game.icon}  {game.name}: {s}…"),
+            )
+        except (SolverError, AdbError) as e:
+            console.print(f"[red]✗[/] {game.name} failed: {e}")
+            return None
+
+    console.print(stats_panel(result))
+    return result
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = parse_args(argv)
+
+    if not args.no_banner:
+        banner()
+
+    if args.list:
+        console.print(games_table())
+        return 0
+
+    try:
+        device = pick_device(args.serial)
+    except AdbError as e:
+        console.print(f"[red]✗[/] {e}")
+        return 1
+    if device is None:
+        return 1
+
+    if args.game and solver_for(args.game) is None:
+        console.print(f"[yellow]![/] No solver for {GAMES[args.game].name} yet.")
+        return 1
+    if not args.game and not any(solver_for(s) for s in GAMES):
+        console.print(games_table())
+        console.print("[yellow]![/] No solvers are implemented yet. Check back soon.")
+        return 0
+
+    results: list[runner.RunResult] = []
+    try:
+        if args.game:
+            if r := solve_once(args.game, device, args):
+                results.append(r)
+        else:
+            console.print()
+            while (slug := pick_game()) not in (None, QUIT):
+                if r := solve_once(slug, device, args):
+                    results.append(r)
+                console.print()
+    except KeyboardInterrupt:
+        console.print("\n[dim]Interrupted.[/]")
+
+    session_summary(results)
+    console.print(f"[{ACCENT}]Bye![/]")
+    return 0 if results or not args.game else 1

linpuzs-0.1.0/src/linpuzs/runner.py

@@ -0,0 +1,60 @@
+"""Runs a solver end to end against a device, timing each stage."""
+
+from __future__ import annotations
+
+import time
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from typing import Any, Callable
+
+from linpuzs.actions import Action
+from linpuzs.solvers import Solver
+from linpuzs.util.adb import AdbDevice
+
+STAGES = ("screenshot", "parse", "solve", "plan", "perform")
+
+
+@dataclass
+class RunResult:
+    solver: Solver
+    timings: dict[str, float] = field(default_factory=dict)
+    puzzle: Any = None
+    solution: Any = None
+    actions: list[Action] = field(default_factory=list)
+    dry_run: bool = False
+
+    @property
+    def total(self) -> float:
+        return sum(self.timings.values())
+
+
+def run(
+    solver: Solver,
+    device: AdbDevice,
+    *,
+    dry_run: bool = False,
+    on_stage: Callable[[str], None] = lambda _: None,
+) -> RunResult:
+    result = RunResult(solver=solver, dry_run=dry_run)
+
+    @contextmanager
+    def stage(name: str):
+        on_stage(name)
+        t0 = time.perf_counter()
+        yield
+        result.timings[name] = time.perf_counter() - t0
+
+    with stage("screenshot"):
+        img = device.screenshot()
+
+    with stage("parse"):
+        result.puzzle = solver.parse(img)
+    with stage("solve"):
+        result.solution = solver.solve(result.puzzle)
+    with stage("plan"):
+        result.actions = solver.plan(result.puzzle, result.solution)
+    if not dry_run:
+        with stage("perform"):
+            device.perform(result.actions)
+
+    return result

linpuzs-0.1.0/src/linpuzs/solvers/__init__.py

@@ -0,0 +1,66 @@
+"""Game catalog and solver registry.
+
+To add a solver, create a module in this package and decorate the class:
+
+    @register("queens")
+    class QueensSolver(Solver[Board, list[Cell]]):
+        ...
+
+Modules here are imported automatically, so nothing else needs wiring up.
+"""
+
+from __future__ import annotations
+
+import importlib
+import pkgutil
+
+from linpuzs.solvers.base import GameInfo, Solver, SolverError
+
+__all__ = ["GAMES", "GameInfo", "Solver", "SolverError", "get_solver", "register", "solver_for"]
+
+# Every LinkedIn game we know about, in menu order. Ones without a registered
+# solver show up as "coming soon".
+GAMES: dict[str, GameInfo] = {
+    g.slug: g
+    for g in [
+        GameInfo("queens", "Queens", "One crown per row, column and colour region", "👑"),
+        GameInfo("tango", "Tango", "Balance suns and moons across the grid", "🌗"),
+        GameInfo("zip", "Zip", "Draw one path through every cell, in order", "〰️"),
+        GameInfo("mini-sudoku", "Mini Sudoku", "6×6 sudoku", "🔢"),
+        GameInfo("patches", "Patches", "Split the grid into shaped, sized patches", "🧵"),
+    ]
+}
+
+_REGISTRY: dict[str, type[Solver]] = {}
+
+
+def register(slug: str):
+    if slug not in GAMES:
+        raise KeyError(f"Unknown game {slug!r}; add it to GAMES first")
+
+    def deco(cls: type[Solver]) -> type[Solver]:
+        cls.game = GAMES[slug]
+        _REGISTRY[slug] = cls
+        return cls
+
+    return deco
+
+
+def _discover() -> None:
+    for mod in pkgutil.iter_modules(__path__):
+        if mod.name != "base":
+            importlib.import_module(f"{__name__}.{mod.name}")
+
+
+def solver_for(slug: str) -> type[Solver] | None:
+    return _REGISTRY.get(slug)
+
+
+def get_solver(slug: str) -> Solver:
+    cls = solver_for(slug)
+    if cls is None:
+        raise KeyError(f"No solver for {slug!r} yet")
+    return cls()
+
+
+_discover()