xdfetch 0.2.0__tar.gz → 0.2.1__tar.gz

{xdfetch-0.2.0 → xdfetch-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: xdfetch
-Version: 0.2.0
+Version: 0.2.1
 Summary: Download crossword puzzles and convert them to .xd
 Project-URL: Homepage, https://github.com/century-arcade/xdfetch
 Project-URL: Repository, https://github.com/century-arcade/xdfetch
@@ -189,7 +189,7 @@ The series xdfetch knows how to fetch are rows of
 `crosswordclub.daily`, `crosswordclub.themed`, `vox.daily`, `vulture.daily`,
 `walrus.weekly`, `defector.weekly`, `kingfeatures.thomas-joseph`,
 `kingfeatures.eugene-sheffer`, `kingfeatures.premier-sunday`, `wsj.daily`,
-`bostonglobe.sunday`, `bostonglobe.mini`, `puzzmo.daily`, `puzzmo.mini`, `puzzmo.big`.
+`bostonglobe.sunday`, `bostonglobe.mini`.
 `xdfetch list` prints them all.
 
 A row's columns, of which only `id` and `adapter` are required:
@@ -233,8 +233,7 @@ Three more fetch from platforms that also carry several outlets' puzzles:
 - `puzzlr`, PZLR: `tenant` is the publisher's slug, and `offset` the days added to the
   date asked for to get the date PZLR files the puzzle under. `copyright` is written when
   the puzzle carries none.
-- `puzzmo`, Puzzmo: `team` and `queue` name a publisher's queue, or `finder` names one of
-  Puzzmo's own series (`crossword`, `crossword/mini`, `crossword/big`).
+- `puzzmo`, Puzzmo: `team` and `queue` name a publisher's queue.
 
 Adapters return each file as the outlet served it; converting is a separate step.
 

{xdfetch-0.2.0 → xdfetch-0.2.1}/README.md

@@ -164,7 +164,7 @@ The series xdfetch knows how to fetch are rows of
 `crosswordclub.daily`, `crosswordclub.themed`, `vox.daily`, `vulture.daily`,
 `walrus.weekly`, `defector.weekly`, `kingfeatures.thomas-joseph`,
 `kingfeatures.eugene-sheffer`, `kingfeatures.premier-sunday`, `wsj.daily`,
-`bostonglobe.sunday`, `bostonglobe.mini`, `puzzmo.daily`, `puzzmo.mini`, `puzzmo.big`.
+`bostonglobe.sunday`, `bostonglobe.mini`.
 `xdfetch list` prints them all.
 
 A row's columns, of which only `id` and `adapter` are required:
@@ -208,8 +208,7 @@ Three more fetch from platforms that also carry several outlets' puzzles:
 - `puzzlr`, PZLR: `tenant` is the publisher's slug, and `offset` the days added to the
   date asked for to get the date PZLR files the puzzle under. `copyright` is written when
   the puzzle carries none.
-- `puzzmo`, Puzzmo: `team` and `queue` name a publisher's queue, or `finder` names one of
-  Puzzmo's own series (`crossword`, `crossword/mini`, `crossword/big`).
+- `puzzmo`, Puzzmo: `team` and `queue` name a publisher's queue.
 
 Adapters return each file as the outlet served it; converting is a separate step.
 

{xdfetch-0.2.0 → xdfetch-0.2.1}/tests/test_puzzmo.py

@@ -287,7 +287,7 @@ def test_date_not_in_queue_is_a_miss(registry, http):
 
 @responses.activate
 def test_queue_and_graphql_errors(registry, http):
-    responses.add(responses.GET, LIST, json={"errors": ["FORBIDDEN_TEAM"]})
+    responses.add(responses.GET, LIST, json={"errors": ["no"]})
     a = adapter.PuzzmoAdapter(registry["bostonglobe.sunday"], http)
     with pytest.raises(FetchError, match="queue list is not as expected"):
         a.targets(SUNDAY)
@@ -320,75 +320,6 @@ def test_team_registry_rows(registry):
     assert mini.since == dt.date(2026, 6, 1)
 
 
-# --- Puzzmo's own series, by date ---
-
-
-def test_own_series_registry_rows(registry):
-    assert registry["puzzmo.daily"].params == {"finder": "crossword"}
-    assert registry["puzzmo.daily"].since == dt.date(2023, 10, 16)
-    assert registry["puzzmo.mini"].params == {"finder": "crossword/mini"}
-    assert registry["puzzmo.mini"].since == dt.date(2025, 10, 1)
-    assert registry["puzzmo.big"].params == {"finder": "crossword/big"}
-    assert registry["puzzmo.big"].days == frozenset({0})
-
-
-@responses.activate
-def test_gameplay_by_date(registry, http):
-    responses.add(responses.POST, adapter.PLAY, body=DAILY)
-    a = adapter.PuzzmoAdapter(registry["puzzmo.mini"], http)
-    (t,) = a.targets(NOV9)
-    assert t.filename == "puzzmo.mini-2026-11-09.json"
-    assert t.url == adapter.PLAY
-    assert a.fetch(t).data == DAILY
-    req = responses.calls[0].request
-    sent = posted(req)
-    assert sent["variables"]["finderKey"] == "today:/2026-11-09/crossword/mini"
-    assert "startOrFindGameplay" in sent["query"]
-    assert req.headers["Puzzmo-Gameplay-Id"]
-    assert "startOrFindGameplay" in a.describe()
-
-
-@responses.activate
-def test_gameplay_id_is_one_per_run(registry, http):
-    responses.add(responses.POST, adapter.PLAY, body=DAILY)
-    a = adapter.PuzzmoAdapter(registry["puzzmo.daily"], http)
-    for day in (NOV9, NOV9 - dt.timedelta(days=1)):
-        a.fetch(a.targets(day)[0])
-    ids = {c.request.headers["Puzzmo-Gameplay-Id"] for c in responses.calls}
-    assert len(ids) == 1
-    assert adapter.PuzzmoAdapter(registry["puzzmo.daily"], http)._gameplay_id not in ids
-
-
-@responses.activate
-def test_gameplay_no_puzzle_is_a_miss(registry, http):
-    answer = {"data": {"startOrFindGameplay": {"__typename": "ErrorableResponse", "message": "No puzzle found"}}}
-    responses.add(responses.POST, adapter.PLAY, json=answer)
-    a = adapter.PuzzmoAdapter(registry["puzzmo.big"], http)
-    (t,) = a.targets(NOV9)
-    with pytest.raises(NotFound, match="today:/2026-11-09/crossword/big"):
-        a.fetch(t)
-
-
-@responses.activate
-def test_gameplay_other_errors(registry, http):
-    a = adapter.PuzzmoAdapter(registry["puzzmo.daily"], http)
-    (t,) = a.targets(NOV9)
-    answer = {"data": {"startOrFindGameplay": {"__typename": "ErrorableResponse", "message": "Slow down"}}}
-    responses.add(responses.POST, adapter.PLAY, json=answer)
-    with pytest.raises(FetchError, match="Slow down"):
-        a.fetch(t)
-    responses.replace(responses.POST, adapter.PLAY, json={"errors": [{"message": "bad"}], "data": None})
-    with pytest.raises(FetchError, match="bad"):
-        a.fetch(t)
-    responses.replace(responses.POST, adapter.PLAY, body="<html>")
-    with pytest.raises(FetchError, match="not JSON"):
-        a.fetch(t)
-    empty = {"data": {"startOrFindGameplay": {"__typename": "HasGamePlayed", "gamePlayed": {"puzzle": {}}}}}
-    responses.replace(responses.POST, adapter.PLAY, json=empty)
-    with pytest.raises(FetchError, match="no puzzle text"):
-        a.fetch(t)
-
-
 # --- the converter: a team queue's answer ---
 
 

{xdfetch-0.2.0 → xdfetch-0.2.1}/tests/test_registry.py

@@ -84,9 +84,6 @@ PUBLIC_IDS = [
     "wsj.daily",
     "bostonglobe.sunday",
     "bostonglobe.mini",
-    "puzzmo.daily",
-    "puzzmo.mini",
-    "puzzmo.big",
 ]
 
 

{xdfetch-0.2.0 → xdfetch-0.2.1}/xdfetch/__init__.py

@@ -1,5 +1,5 @@
 """xdfetch: fetch crossword puzzles as their outlets serve them, and convert them to .xd."""
 
-__version__ = "0.2.0"
+__version__ = "0.2.1"
 
 USER_AGENT = f"xdfetch/{__version__} (+https://github.com/century-arcade/xdfetch)"

xdfetch-0.2.1/xdfetch/adapters/puzzmo.py

@@ -0,0 +1,103 @@
+"""The `puzzmo` adapter: a publisher's team queues on Puzzmo (the Boston Globe's crosswords).
+
+params:
+  team    the team slug on Puzzmo, e.g. boston-globe-amlaj
+  queue   the queue, default crossword
+  days    how many days back one list request covers, default 10 (Puzzmo serves up to 50)
+
+- GET https://api.puzzmo.com/team/v1/<team>/queues/<queue>/puzzles?startDate=<date>&days=<n>
+  lists the queue's puzzles from that date back (`days` must be positive; up to 50 are
+  returned): id, name, publishDate, authors. The list is read once per run for the dates it
+  covers. A queue can hold more than one series (the Globe's `crossword` queue holds its
+  Sunday crossword and the Universal crossword on the other days); the row's calendar says
+  which days to ask for.
+- POST https://api.puzzmo.com/graphql with { puzzle(id: "<id>") { id name puzzle } } returns the
+  puzzle; its `puzzle` field is the puzzle as xd text in Puzzmo's dialect. The response is
+  saved as served, named <id>-YYYY-MM-DD.json by the list's publishDate.
+
+A publisher's row needs the team slug and queue name, which its player page uses.
+"""
+
+from __future__ import annotations
+
+import datetime as dt
+import json
+
+from ..http import FetchError, NotFound
+from .base import Adapter, Fetched, Target
+
+TEAM = "https://api.puzzmo.com/team/v1/{team}/queues/{queue}/puzzles?startDate={date}&days={days}"
+GRAPHQL = "https://api.puzzmo.com/graphql"
+
+
+class PuzzmoAdapter(Adapter):
+    name = "puzzmo"
+    interval = 3.0
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._listed: dict[dt.date, dict] = {}
+        self._asked: set[dt.date] = set()
+
+    def list_url(self, date: dt.date) -> str:
+        return TEAM.format(
+            team=self.outlet.param("team"),
+            queue=self.outlet.params.get("queue", "crossword"),
+            date=date.isoformat(),
+            days=self.outlet.params.get("days", "10"),
+        )
+
+    def listed(self, date: dt.date) -> dict | None:
+        """The queue's record for the date, listing from that date back once per run."""
+        if date not in self._listed and date not in self._asked:
+            self._asked.add(date)
+            url = self.list_url(date)
+            r = self.http.get(url, interval=self.interval)
+            try:
+                puzzles = r.json()["puzzles"]
+            except (ValueError, KeyError, TypeError) as e:
+                raise FetchError(f"queue list is not as expected: {e}", url=url) from e
+            for p in puzzles:
+                try:
+                    day = dt.date.fromisoformat(p["publishDate"])
+                except (KeyError, ValueError, TypeError):
+                    continue
+                self._listed.setdefault(day, p)
+        return self._listed.get(date)
+
+    def targets(self, date: dt.date) -> list[Target]:
+        filename = f"{self.outlet.id}-{date.isoformat()}.json"
+        rec = self.listed(date)
+        if rec is None:
+            raise NotFound(f"no puzzle dated {date} in the {self.outlet.param('team')} queue", url=self.list_url(date))
+        note = f"{date}: {rec.get('name', '')!r} by {', '.join(a.get('name', '') for a in rec.get('authors') or [])}"
+        return [Target(url=GRAPHQL, filename=filename, note=note, headers={"X-Puzzle-Id": rec["id"]})]
+
+    def fetch(self, target: Target) -> Fetched:
+        puzzle_id = target.headers.get("X-Puzzle-Id", "")
+        clean = puzzle_id.replace('"', "")
+        query = f'{{ puzzle(id: "{clean}") {{ id name puzzle }} }}'
+        r = self.http.post(target.url, json={"query": query}, interval=self.interval)
+        try:
+            body = json.loads(r.content)
+            puzzle = body["data"]["puzzle"]
+        except (ValueError, KeyError, TypeError) as e:
+            raise FetchError(f"GraphQL answer is not a puzzle: {e}", url=target.url) from e
+        if not puzzle or not puzzle.get("puzzle"):
+            raise NotFound(f"no puzzle text for {puzzle_id}", url=target.url)
+        return Fetched(data=r.content, url=target.url, content_type="application/json", filename=target.filename)
+
+    def describe(self) -> str:
+        team = self.outlet.param("team")
+        queue = self.outlet.params.get("queue", "crossword")
+        text = (
+            f"The outlet plays its puzzles from Puzzmo. Its `{queue}` queue on Puzzmo's team API "
+            f"(`https://api.puzzmo.com/team/v1/{team}/queues/{queue}/puzzles?startDate=<date>&days=<n>`) lists "
+            f"the puzzles by date. Each file is the answer to the GraphQL query "
+            f'`{{ puzzle(id: "<id>") {{ id name puzzle }} }}` posted to `{GRAPHQL}`, saved as served; its '
+            f"`puzzle` field is the puzzle as xd text in Puzzmo's dialect. Files are named by the queue's "
+            f"publishDate."
+        )
+        if self.outlet.notes:
+            text += " " + self.outlet.notes
+        return text

{xdfetch-0.2.0 → xdfetch-0.2.1}/xdfetch/outlets.tsv

@@ -30,6 +30,3 @@ kingfeatures.premier-sunday	gamedist	feed=hearst_premier-sunday-crossword dash=-
 wsj.daily	puzzlr	tenant=wsj offset=-1 'copyright=© The Wall Street Journal'	mon-sat		America/New_York	-18	1,2,3,4	https://www.wsj.com/news/puzzle		yes	The Wall Street Journal's crossword, Monday to Saturday, from PZLR, the platform the paper's player runs on; each file is the answer to the player's own request for the date. Files are named by the print date; PZLR dates a puzzle by its online release, the day before (offset=-1), and has it up by the morning of that day. Friday's contest puzzle is served without its answers until the contest closes on Sunday night: it is written with every white square an X until a re-fetch (through day 4) has the answers. Payloads from before PZLR's 2026 format change carry no circles or rebus squares.
 bostonglobe.sunday	puzzmo	team=boston-globe-amlaj queue=crossword	sun	2024-02-25	America/New_York	3	1,2	https://www.bostonglobe.com/games/crossword/		yes	The Boston Globe Magazine's Sunday crossword, by Brendan Emmett Quigley and Joon Pahk in alternate weeks, from the Globe's crossword queue on Puzzmo, where the Globe's player gets its puzzles. The queue also holds the Universal crossword Monday to Saturday, which is not fetched here (see universal.daily). Files are named by the queue's publishDate.
 bostonglobe.mini	puzzmo	team=boston-globe-amlaj queue=crossword-mini	daily	2026-06-01	America/New_York	3	1,2	https://www.bostonglobe.com/games/mini-crossword/		yes	The Globe's daily mini, a 5x5, from the team's crossword-mini queue on Puzzmo. Puzzmo names each one by its date (Tue, Nov 3, 2026); the title is that date written out (Tuesday, November 3, 2026).
-puzzmo.daily	puzzmo	finder=crossword	daily	2023-10-16	America/New_York	3	1,2	https://www.puzzmo.com/		yes	Puzzmo's own daily crossword, edited by Brian Callahan; sizes vary (11x11, 12x10). Each clue has a hint (A1 ^hint: ...) in the file as served; the .xd doesn't carry them. Fetched the way xword-dl fetches Puzzmo.
-puzzmo.mini	puzzmo	finder=crossword/mini	daily	2025-10-01	America/New_York	3	1,2	https://www.puzzmo.com/		yes	Puzzmo's own daily mini, from Puzzmo Mini Crossword #1 on 2025-10-01; not always 5x5 (9x5 on 2026-11-01). The file as served also has a Line Breaks section (where the player may wrap each clue), which the .xd doesn't need. Some days have Schrödinger squares, written as rebus squares holding both letters (1=E|K), with the clue once per reading. Fetched the way xword-dl fetches Puzzmo.
-puzzmo.big	puzzmo	finder=crossword/big	mon	2025-01-13	America/New_York	3	1,2	https://www.puzzmo.com/		yes	Puzzmo's Big crossword, a 15x15 played over three days from a Monday (its dailyTitle says "Nov 2-4, 2026"), filed under that Monday: every other Monday from 2025-01-13, the first Monday of each month from 2025-07-07, and every other Monday again from 2026-01-05. The other Mondays are misses. Fetched the way xword-dl fetches Puzzmo.

xdfetch-0.2.0/xdfetch/adapters/puzzmo.py

@@ -1,187 +0,0 @@
-"""The `puzzmo` adapter: a publisher's team queues on Puzzmo (the Boston Globe's crosswords),
-and Puzzmo's own crosswords by date.
-
-params:
-  team    the team slug on Puzzmo, e.g. boston-globe-amlaj
-  queue   the queue, default crossword
-  days    how many days back one list request covers, default 10 (Puzzmo serves up to 50)
-  finder  instead of team: one of Puzzmo's own series, as the part of its play URL after the
-          date: `crossword` (the daily), `crossword/mini`, `crossword/big`
-
-Team queues:
-
-- GET https://api.puzzmo.com/team/v1/<team>/queues/<queue>/puzzles?startDate=<date>&days=<n>
-  lists the queue's puzzles from that date back (`days` must be positive; up to 50 are
-  returned): id, name, publishDate, authors. The list is read once per run for the dates it
-  covers. A queue can hold more than one series (the Globe's `crossword` queue holds its
-  Sunday crossword and the Universal crossword on the other days); the row's calendar says
-  which days to ask for.
-- POST https://api.puzzmo.com/graphql with { puzzle(id: "<id>") { id name puzzle } } returns the
-  puzzle; its `puzzle` field is the puzzle as xd text in Puzzmo's dialect. The response is
-  saved as served, named <id>-YYYY-MM-DD.json by the list's publishDate.
-
-A publisher's row needs the team slug and queue name, which its player page uses.
-
-Puzzmo's own series (`finder=`), the way xword-dl gets them: the play screen's query,
-`startOrFindGameplay(finderKey: "today:/<date>/<finder>")`, posted to
-https://www.puzzmo.com/_api/prod/graphql with a `Puzzmo-Gameplay-Id` header. That id is
-made up, a random one per run, as the play screen makes one for an anonymous player. A date
-with no puzzle answers `ErrorableResponse` "No puzzle found": a miss. The response is saved
-as served, named <id>-YYYY-MM-DD.json by the date asked for.
-"""
-
-from __future__ import annotations
-
-import datetime as dt
-import json
-import secrets
-
-from ..http import FetchError, NotFound
-from .base import Adapter, Fetched, Target
-
-TEAM = "https://api.puzzmo.com/team/v1/{team}/queues/{queue}/puzzles?startDate={date}&days={days}"
-GRAPHQL = "https://api.puzzmo.com/graphql"
-PLAY = "https://www.puzzmo.com/_api/prod/graphql?PlayGameScreenQuery"
-# The play screen's query (PlayGameScreenQuery), asking for every field of the puzzle that the
-# site's own query asks for, less what is about the viewer or the session (their gameplay,
-# tutorial state, leaderboards) and the game's asset paths, plus shortDescription. Kept in full
-# in the saved file so a field the converter doesn't use yet is there later. The byline and
-# editor the site shows are publishingName, else name.
-USER = "{ id name username usernameID publishingName }"
-GAMEPLAY = (
-    "query PlayGameScreenQuery($finderKey: String!, $gameContext: StartGameContext!) { "
-    "startOrFindGameplay(finderKey: $finderKey, context: $gameContext) { __typename "
-    "... on ErrorableResponse { message failed success } "
-    "... on HasGamePlayed { gamePlayed { puzzle { "
-    "id name emoji puzzle slug gameID variantID subvariantID dailyTitle shortDescription "
-    "difficulty difficultyPointsCap seriesNumber gameNameOverride accessOverride forceSettings "
-    "thumbnailWidth thumbnailHeight "
-    f"author authors {USER} editor editors {USER} puzmoEditor {USER} "
-    "source { id name displayName url formatString } "
-    "game { id slug displayName gameCreatorName } "
-    "featuredInDaily { id daily { id day } } "
-    "submissionVersion { id submission { id status slug queue { id slug } } } "
-    "} } } } }"
-)
-
-
-class PuzzmoAdapter(Adapter):
-    name = "puzzmo"
-    interval = 3.0
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self._listed: dict[dt.date, dict] = {}
-        self._asked: set[dt.date] = set()
-        self._gameplay_id = secrets.token_urlsafe(21)
-
-    @property
-    def finder(self) -> str:
-        return self.outlet.params.get("finder", "").strip("/")
-
-    def list_url(self, date: dt.date) -> str:
-        return TEAM.format(
-            team=self.outlet.param("team"),
-            queue=self.outlet.params.get("queue", "crossword"),
-            date=date.isoformat(),
-            days=self.outlet.params.get("days", "10"),
-        )
-
-    def listed(self, date: dt.date) -> dict | None:
-        """The queue's record for the date, listing from that date back once per run."""
-        if date not in self._listed and date not in self._asked:
-            self._asked.add(date)
-            url = self.list_url(date)
-            r = self.http.get(url, interval=self.interval)
-            try:
-                puzzles = r.json()["puzzles"]
-            except (ValueError, KeyError, TypeError) as e:
-                raise FetchError(f"queue list is not as expected: {e}", url=url) from e
-            for p in puzzles:
-                try:
-                    day = dt.date.fromisoformat(p["publishDate"])
-                except (KeyError, ValueError, TypeError):
-                    continue
-                self._listed.setdefault(day, p)
-        return self._listed.get(date)
-
-    def targets(self, date: dt.date) -> list[Target]:
-        filename = f"{self.outlet.id}-{date.isoformat()}.json"
-        if self.finder:
-            key = f"today:/{date.isoformat()}/{self.finder}"
-            return [Target(url=PLAY, filename=filename, note=key, headers={"X-Finder-Key": key})]
-        rec = self.listed(date)
-        if rec is None:
-            raise NotFound(f"no puzzle dated {date} in the {self.outlet.param('team')} queue", url=self.list_url(date))
-        note = f"{date}: {rec.get('name', '')!r} by {', '.join(a.get('name', '') for a in rec.get('authors') or [])}"
-        return [Target(url=GRAPHQL, filename=filename, note=note, headers={"X-Puzzle-Id": rec["id"]})]
-
-    def fetch(self, target: Target) -> Fetched:
-        if "X-Finder-Key" in target.headers:
-            return self.fetch_gameplay(target)
-        puzzle_id = target.headers.get("X-Puzzle-Id", "")
-        clean = puzzle_id.replace('"', "")
-        query = f'{{ puzzle(id: "{clean}") {{ id name puzzle }} }}'
-        r = self.http.post(target.url, json={"query": query}, interval=self.interval)
-        try:
-            body = json.loads(r.content)
-            puzzle = body["data"]["puzzle"]
-        except (ValueError, KeyError, TypeError) as e:
-            raise FetchError(f"GraphQL answer is not a puzzle: {e}", url=target.url) from e
-        if not puzzle or not puzzle.get("puzzle"):
-            raise NotFound(f"no puzzle text for {puzzle_id}", url=target.url)
-        return Fetched(data=r.content, url=target.url, content_type="application/json", filename=target.filename)
-
-    def fetch_gameplay(self, target: Target) -> Fetched:
-        key = target.headers["X-Finder-Key"]
-        payload = {
-            "operationName": "PlayGameScreenQuery",
-            "query": GAMEPLAY,
-            "variables": {"finderKey": key, "gameContext": {"partnerSlug": None, "pingOwnerForMultiplayer": True}},
-        }
-        r = self.http.post(
-            target.url, json=payload, headers={"Puzzmo-Gameplay-Id": self._gameplay_id}, interval=self.interval
-        )
-        try:
-            body = json.loads(r.content)
-        except ValueError as e:
-            raise FetchError(f"gameplay answer is not JSON: {e}", url=target.url) from e
-        try:
-            answer = body["data"]["startOrFindGameplay"]
-            kind = answer["__typename"]
-        except (KeyError, TypeError) as e:
-            errors = body.get("errors") if isinstance(body, dict) else None
-            raise FetchError(f"gameplay answer is not as expected: {errors or e}", url=target.url) from e
-        if kind == "ErrorableResponse":
-            message = answer.get("message") or ""
-            if "no puzzle found" in message.lower():
-                raise NotFound(f"Puzzmo has no {key}", url=target.url)
-            raise FetchError(f"Puzzmo answered {message!r} for {key}", url=target.url)
-        puzzle = (answer.get("gamePlayed") or {}).get("puzzle") or {}
-        if not puzzle.get("puzzle"):
-            raise FetchError(f"no puzzle text for {key}", url=target.url)
-        return Fetched(data=r.content, url=target.url, content_type="application/json", filename=target.filename)
-
-    def describe(self) -> str:
-        if self.finder:
-            text = (
-                f"Puzzmo's own puzzle, the one played at `https://www.puzzmo.com/puzzle/<date>/{self.finder}`. "
-                f"Each file is the answer to the play screen's GraphQL query, `startOrFindGameplay(finderKey: "
-                f'"today:/<date>/{self.finder}")`, posted to `{PLAY}` (the way xword-dl fetches Puzzmo), '
-                f"saved as served; its `puzzle` field is the puzzle as xd text in Puzzmo's dialect. Files are "
-                f"named by the date asked for."
-            )
-        else:
-            team = self.outlet.param("team")
-            queue = self.outlet.params.get("queue", "crossword")
-            text = (
-                f"The outlet plays its puzzles from Puzzmo. Its `{queue}` queue on Puzzmo's team API "
-                f"(`https://api.puzzmo.com/team/v1/{team}/queues/{queue}/puzzles?startDate=<date>&days=<n>`) lists "
-                f"the puzzles by date. Each file is the answer to the GraphQL query "
-                f'`{{ puzzle(id: "<id>") {{ id name puzzle }} }}` posted to `{GRAPHQL}`, saved as served; its '
-                f"`puzzle` field is the puzzle as xd text in Puzzmo's dialect. Files are named by the queue's "
-                f"publishDate."
-            )
-        if self.outlet.notes:
-            text += " " + self.outlet.notes
-        return text