notebookvb

SběrDatRůzné/DailyStr8ts/NOTES.md

@@ -1,13 +1,21 @@
 # DailyStr8ts — technické poznámky
 
-Skript `stahni_str8ts.py` stahuje denní Str8ts puzzle jako PDF ze https://www.solitaire.org/daily-str8ts/ a odesílá emailem.
+## Přehled skriptů
+
+| Skript | Popis |
+|--------|-------|
+| `stahni_str8ts.py` | Stahuje denní puzzle jako PDF z webu, odesílá emailem |
+| `preskumaj_str8ts.py` | Průzkumný — vytáhne `gameLevels` z JS kontextu stránky |
+| `vykresli_puzzle.py` | Generuje vlastní PDF z dat v MySQL (reportlab, vektorové) |
+| `vykresli_velikosti.py` | Testovací — jedno puzzle v 17 velikostech (18–2 cm) |
+| `create_puzzles_table.sql` | DDL pro tabulku `puzzle.puzzles` |
+
+## Stahování z webu (`stahni_str8ts.py`)
 
 **Výstup:** `U:\Dropbox\!!!Days\Downloads Z230\yyyy-mm-dd Daily Str8ts puzzle.pdf`
 
 **Příjemci:** vladimir.buzalka@buzalka.cz, alica.buzalkova@buzalka.cz
 
-## Jak to funguje (klíčové)
-
 Stránka `game.php` má funkci `Game.printDaily()` která:
 1. Vytvoří skrytý `<iframe id="printFrame">` v DOM
 2. Zapíše do něj puzzle HTML přes `contentWindow.document.write()` — všechny 3 obtížnosti (Easy, Medium, Hard)
@@ -21,8 +29,54 @@ Stránka `game.php` má funkci `Game.printDaily()` která:
 - Přidáme `<base href="https://www.solitaire.org/daily-str8ts/">` pro obrázky
 - Načteme HTML do nové stránky a uložíme jako `page.pdf()`
 
+## Datová struktura `gameLevels`
+
+JS objekt `gameLevels` obsahuje puzzle pro všechny dny roku, klíčované jako `gameLevels[difficulty]["MM-DD"]`.
+
+Každý záznam má 3 stringy po 81 znacích (9×9 mřížka, po řádcích):
+
+| Pole | Význam |
+|------|--------|
+| `puzzle` | Zadání: `1`–`9` = předvyplněné číslo, `.` = prázdná buňka |
+| `bw` | Mapa barev: `0` = bílá buňka, `1` = černá buňka |
+| `solution` | Řešení: `1`–`9` = číslo, `.` = černá bez čísla |
+
+## MySQL tabulka `puzzle.puzzles`
+
+Univerzální tabulka pro Str8ts, Sudoku i další puzzle typy.
+
+```sql
+CREATE TABLE puzzles (
+    id INT AUTO_INCREMENT PRIMARY KEY,
+    game_type VARCHAR(30) NOT NULL,       -- 'str8ts', 'sudoku', 'killer_sudoku'
+    difficulty VARCHAR(20) NOT NULL,       -- 'easy', 'medium', 'hard'
+    puzzle_date DATE NOT NULL,
+    puzzle VARCHAR(200) NOT NULL,          -- zadání (81 znaků pro 9×9)
+    solution VARCHAR(200) DEFAULT NULL,
+    extra JSON DEFAULT NULL,              -- specifika typu (bw mapa, cage definice...)
+    source VARCHAR(100) DEFAULT NULL,
+    fetched_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    UNIQUE KEY uq_puzzle (game_type, difficulty, puzzle_date)
+);
+```
+
+Pro Str8ts se do `extra` ukládá `{"bw": "001100011..."}`.
+
+## Generování vlastního PDF (`vykresli_puzzle.py`)
+
+- Knihovna: **reportlab** — vektorová grafika, plynule škálovatelná
+- Zvolená velikost: **11×11 cm**, 2 puzzle nad sebou na A4
+- Černé buňky: `c.rect(fill=1)`, žlutá čísla na černé, černá čísla na bílé
+- Str8ts nemá 3×3 bloky → všechny čáry mřížky stejně silné
+
 ## Co nefunguje (neopakovat)
 
 - `page.pdf()` na hlavní stránce → uvítací obrazovka, ne puzzle
 - `context.expect_page()` → žádný popup se neotevírá
 - Override `window.print` → Game volá `contentWindow.print()`, ne `window.print()`
+
+## Co zbývá
+
+- Zabudovat extrakci + MySQL insert do `stahni_str8ts.py`
+- Nahradit stahované PDF z webu vlastním generovaným
+- Rozšířit na další typy puzzle (Sudoku, Killer Sudoku)

SběrDatRůzné/DailyStr8ts/create_puzzles_table.sql

@@ -0,0 +1,13 @@
+CREATE TABLE IF NOT EXISTS puzzles (
+    id INT AUTO_INCREMENT PRIMARY KEY,
+    game_type VARCHAR(30) NOT NULL,
+    difficulty VARCHAR(20) NOT NULL,
+    puzzle_date DATE NOT NULL,
+    puzzle VARCHAR(200) NOT NULL,
+    solution VARCHAR(200) DEFAULT NULL,
+    extra JSON DEFAULT NULL,
+    source VARCHAR(100) DEFAULT NULL,
+    fetched_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+
+    UNIQUE KEY uq_puzzle (game_type, difficulty, puzzle_date)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

SběrDatRůzné/DailyStr8ts/preskumaj_str8ts.py

@@ -0,0 +1,137 @@
+"""
+Průzkumný skript: připojí se na solitaire.org/daily-str8ts/ a vytáhne
+surová JS data o puzzle (gameLevels, Game objekt) PŘED generováním PDF.
+"""
+
+import asyncio
+import json
+import sys
+
+sys.stdout.reconfigure(encoding="utf-8")
+
+from playwright.async_api import async_playwright
+
+URL = "https://www.solitaire.org/daily-str8ts/"
+
+
+async def main():
+    async with async_playwright() as p:
+        browser = await p.chromium.launch(headless=True)
+        context = await browser.new_context(viewport={"width": 1280, "height": 900})
+
+        # Krok 1: načti hlavní stránku a najdi iframe s hrou
+        page = await context.new_page()
+        print(f"Načítám {URL} ...")
+        await page.goto(URL, wait_until="networkidle", timeout=60_000)
+
+        game_url = None
+        for frame in page.frames:
+            if frame.url != page.url and frame.url.strip() not in ("", "about:blank"):
+                game_url = frame.url
+                print(f"  Nalezen iframe: {game_url}")
+                break
+
+        if not game_url:
+            iframe_src = await page.get_attribute("iframe", "src")
+            if iframe_src:
+                game_url = (
+                    iframe_src
+                    if iframe_src.startswith("http")
+                    else f"https://www.solitaire.org{iframe_src}"
+                )
+                print(f"  Iframe src z DOM: {game_url}")
+
+        await page.close()
+
+        # Krok 2: otevři URL hry přímo
+        game_page = await context.new_page()
+        target_url = game_url if game_url else URL
+        print(f"Načítám hru: {target_url} ...")
+        await game_page.goto(target_url, wait_until="networkidle", timeout=60_000)
+
+        # --- Průzkum: co je dostupné v JS kontextu ---
+
+        # 1) gameLevels
+        print("\n=== gameLevels ===")
+        game_levels = await game_page.evaluate("""() => {
+            if (typeof gameLevels !== 'undefined') return JSON.stringify(gameLevels, null, 2);
+            return null;
+        }""")
+        if game_levels:
+            print(game_levels[:3000])
+            if len(game_levels) > 3000:
+                print(f"... (celkem {len(game_levels)} znaků)")
+        else:
+            print("  gameLevels není definováno")
+
+        # 2) Game objekt — klíče
+        print("\n=== Game objekt — klíče ===")
+        game_keys = await game_page.evaluate("""() => {
+            if (typeof Game !== 'undefined') {
+                return Object.keys(Game);
+            }
+            return null;
+        }""")
+        if game_keys:
+            print(json.dumps(game_keys, indent=2))
+        else:
+            print("  Game není definováno")
+
+        # 3) Game objekt — vlastnosti které nejsou funkce
+        print("\n=== Game — datové vlastnosti ===")
+        game_data = await game_page.evaluate("""() => {
+            if (typeof Game === 'undefined') return null;
+            const result = {};
+            for (const key of Object.keys(Game)) {
+                const val = Game[key];
+                if (typeof val !== 'function') {
+                    try {
+                        result[key] = JSON.parse(JSON.stringify(val));
+                    } catch(e) {
+                        result[key] = String(val);
+                    }
+                }
+            }
+            return result;
+        }""")
+        if game_data:
+            txt = json.dumps(game_data, indent=2, ensure_ascii=False)
+            print(txt[:5000])
+            if len(txt) > 5000:
+                print(f"... (celkem {len(txt)} znaků)")
+        else:
+            print("  žádná data")
+
+        # 4) Zkusit další globální proměnné
+        print("\n=== Další globální proměnné ===")
+        globals_check = await game_page.evaluate("""() => {
+            const names = ['puzzleData', 'dailyPuzzle', 'gameData', 'levels',
+                           'puzzle', 'boardData', 'board', 'grid', 'cells'];
+            const found = {};
+            for (const name of names) {
+                if (typeof window[name] !== 'undefined') {
+                    found[name] = typeof window[name];
+                }
+            }
+            return found;
+        }""")
+        print(json.dumps(globals_check, indent=2))
+
+        # 5) Zdrojový kód Game.printDaily
+        print("\n=== Game.printDaily — zdrojový kód ===")
+        print_src = await game_page.evaluate("""() => {
+            if (typeof Game !== 'undefined' && typeof Game.printDaily === 'function') {
+                return Game.printDaily.toString();
+            }
+            return null;
+        }""")
+        if print_src:
+            print(print_src[:3000])
+        else:
+            print("  Game.printDaily neexistuje")
+
+        await browser.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

SběrDatRůzné/DailyStr8ts/stahni_str8ts.py

@@ -1,24 +1,40 @@
 """
-Stáhne daily Str8ts puzzle jako PDF ze solitaire.org a uloží do stejné složky.
-Název souboru: yyyy-mm-dd Daily Str8ts puzzle.pdf
+Stáhne daily Str8ts puzzle data ze solitaire.org, uloží do MySQL,
+vygeneruje vlastní PDF (reportlab) a odešle emailem.
 """
 
 import asyncio
+import json
 import sys
+
 sys.stdout.reconfigure(encoding="utf-8")
 sys.stderr.reconfigure(encoding="utf-8")
+
 from datetime import date
 from pathlib import Path
 
 from playwright.async_api import async_playwright
+import os
+
+from reportlab.lib import colors
+from reportlab.lib.pagesizes import A4
+from reportlab.lib.units import cm
+from reportlab.pdfbase import pdfmetrics
+from reportlab.pdfbase.ttfonts import TTFont
+from reportlab.pdfgen.canvas import Canvas
+
+_fonts_dir = os.path.join(os.environ.get("WINDIR", r"C:\Windows"), "Fonts")
+pdfmetrics.registerFont(TTFont("Arial", os.path.join(_fonts_dir, "arial.ttf")))
+pdfmetrics.registerFont(TTFont("ArialBold", os.path.join(_fonts_dir, "arialbd.ttf")))
 
 sys.path.insert(0, str(Path(__file__).parent.parent.parent / "Knihovny"))
 from EmailMessagingGraph import send_mail
+from mysql_db import connect_mysql
 from najdi_dropbox import get_dropbox_root
 
 OUTPUT_DIR = Path(get_dropbox_root()) / "!!!Days" / "Downloads Z230"
 URL = "https://www.solitaire.org/daily-str8ts/"
-RECIPIENT = ["vladimir.buzalka@buzalka.cz", "alica.buzalkova@buzalka.cz"]
+RECIPIENT = ["vladimir.buzalka@buzalka.cz"]  # TODO: vrátit alica.buzalkova@buzalka.cz
 
 EMAIL_BODY = """Str8ts — pravidla
 
@@ -33,22 +49,138 @@ Hrací pole 9×9, každá buňka je buď bílá nebo černá.
 Rozdíl od Sudoku: nemusíš vyplnit 1–9 do každé skupiny — jen zajistit, že čísla v každé skupině tvoří „straight" (jako v pokeru).
 """
 
+GRID = 9
+BOARD_CM = 11
+BOARD = BOARD_CM * cm
+CELL = BOARD / GRID
+DIFFICULTIES = ["easy", "medium", "hard"]
 
-async def main():
-    today = date.today().strftime("%Y-%m-%d")
-    output_path = OUTPUT_DIR / f"{today} Daily Str8ts puzzle.pdf"
 
-    if output_path.exists():
-        print(f"Soubor již existuje: {output_path}")
-        return
+# --- PDF generování ---
 
+def draw_str8ts(c: Canvas, x0: float, y0: float, puzzle: str, bw: str, title: str = ""):
+    font_size = CELL * 0.55
+
+    if title:
+        c.setFont("ArialBold", 12)
+        c.drawString(x0, y0 + 5, title)
+
+    for idx in range(81):
+        row, col = divmod(idx, 9)
+        cell_x = x0 + col * CELL
+        cell_y = y0 - (row + 1) * CELL
+        cx = cell_x + CELL / 2
+        cy = cell_y + CELL * 0.3
+        is_black = bw[idx] == "1"
+        ch = puzzle[idx]
+
+        if is_black:
+            c.setFillColor(colors.black)
+            c.rect(cell_x, cell_y, CELL, CELL, fill=1, stroke=0)
+
+        if ch in "123456789":
+            c.setFillColor(colors.yellow if is_black else colors.black)
+            c.setFont("ArialBold", font_size)
+            c.drawCentredString(cx, cy, ch)
+            c.setFillColor(colors.black)
+
+    for i in range(GRID + 1):
+        c.setLineWidth(0.8)
+        c.line(x0, y0 - i * CELL, x0 + BOARD, y0 - i * CELL)
+        c.line(x0 + i * CELL, y0, x0 + i * CELL, y0 - BOARD)
+
+
+def draw_str8ts_small(c: Canvas, x0: float, y0: float, board_cm: float,
+                      solution: str, bw: str, title: str = ""):
+    board = board_cm * cm
+    cell = board / GRID
+    font_size = cell * 0.55
+
+    if title:
+        c.setFont("ArialBold", 8)
+        c.drawString(x0, y0 + 4, title)
+
+    for idx in range(81):
+        row, col = divmod(idx, 9)
+        cell_x = x0 + col * cell
+        cell_y = y0 - (row + 1) * cell
+        cx = cell_x + cell / 2
+        cy = cell_y + cell * 0.3
+        is_black = bw[idx] == "1"
+        ch = solution[idx]
+
+        if is_black:
+            c.setFillColor(colors.black)
+            c.rect(cell_x, cell_y, cell, cell, fill=1, stroke=0)
+
+        if ch in "123456789":
+            c.setFillColor(colors.yellow if is_black else colors.black)
+            c.setFont("ArialBold", max(font_size, 4))
+            c.drawCentredString(cx, cy, ch)
+            c.setFillColor(colors.black)
+
+    for i in range(GRID + 1):
+        c.setLineWidth(0.5)
+        c.line(x0, y0 - i * cell, x0 + board, y0 - i * cell)
+        c.line(x0 + i * cell, y0, x0 + i * cell, y0 - board)
+
+
+def generate_pdf(output_path: Path, puzzles: list[dict], title_date: str):
+    """puzzles = [{"difficulty": ..., "puzzle": ..., "bw": ..., "solution": ...}, ...]"""
+    page_w, page_h = A4
+    x0 = (page_w - BOARD) / 2
+    c = Canvas(str(output_path), pagesize=A4)
+
+    # Stránky se zadáním — 2 puzzle nad sebou
+    for i in range(0, len(puzzles), 2):
+        page_puzzles = puzzles[i:i + 2]
+        for j, p in enumerate(page_puzzles):
+            y0 = page_h - 2 * cm - j * (BOARD + 3 * cm)
+            draw_str8ts(c, x0, y0, p["puzzle"], p["bw"], p["difficulty"].capitalize())
+        c.showPage()
+
+    # Poslední stránka — řešení 6×6 cm
+    sol_cm = 6
+    sol_board = sol_cm * cm
+    gap = 1.5 * cm
+    sol_x0 = (page_w - sol_board) / 2
+    c.setFont("ArialBold", 14)
+    c.drawCentredString(page_w / 2, page_h - 2 * cm, "Řešení")
+    y_cursor = page_h - 3.5 * cm
+    for p in puzzles:
+        draw_str8ts_small(c, sol_x0, y_cursor, sol_cm, p["solution"], p["bw"],
+                          p["difficulty"].capitalize())
+        y_cursor -= sol_board + gap
+    c.showPage()
+
+    c.save()
+
+
+# --- MySQL ---
+
+def save_to_mysql(puzzle_date: str, puzzles: list[dict]):
+    conn = connect_mysql(database="puzzle")
+    cur = conn.cursor()
+    for p in puzzles:
+        cur.execute(
+            "INSERT IGNORE INTO puzzles (game_type, difficulty, puzzle_date, puzzle, solution, extra, source) "
+            "VALUES (%s, %s, %s, %s, %s, %s, %s)",
+            ("str8ts", p["difficulty"], puzzle_date, p["puzzle"], p["solution"],
+             json.dumps({"bw": p["bw"]}), "solitaire.org"),
+        )
+    inserted = cur.rowcount
+    cur.close()
+    conn.close()
+    return inserted
+
+
+# --- Extrakce z webu ---
+
+async def fetch_puzzles(mmdd: str) -> list[dict]:
     async with async_playwright() as p:
         browser = await p.chromium.launch(headless=True)
-        context = await browser.new_context(
-            viewport={"width": 1280, "height": 900},
-        )
+        context = await browser.new_context(viewport={"width": 1280, "height": 900})
 
-        # Krok 1: načti hlavní stránku a zjisti URL iframu s hrou
         page = await context.new_page()
         print(f"Načítám {URL} ...")
         await page.goto(URL, wait_until="networkidle", timeout=60_000)
@@ -57,61 +189,68 @@ async def main():
         for frame in page.frames:
             if frame.url != page.url and frame.url.strip() not in ("", "about:blank"):
                 game_url = frame.url
-                print(f"  Nalezen iframe: {game_url}")
                 break
 
         if not game_url:
-            # Zkus najít iframe src přímo v DOM
             iframe_src = await page.get_attribute("iframe", "src")
             if iframe_src:
                 game_url = iframe_src if iframe_src.startswith("http") else f"https://www.solitaire.org{iframe_src}"
-                print(f"  Iframe src z DOM: {game_url}")
 
         await page.close()
 
-        # Krok 2: otevři URL hry
         game_page = await context.new_page()
         target_url = game_url if game_url else URL
-        print(f"Načítám hru přímo: {target_url} ...")
+        print(f"Načítám hru: {target_url} ...")
         await game_page.goto(target_url, wait_until="networkidle", timeout=60_000)
 
-        # Game.printDaily() vytvoří iframe #printFrame a zapíše do něj puzzle HTML
-        await game_page.evaluate("Game.printDaily()")
-        await game_page.wait_for_timeout(1_000)
+        data = await game_page.evaluate("""(key) => {
+            const result = {};
+            for (const diff of ['easy', 'medium', 'hard']) {
+                if (gameLevels[diff] && gameLevels[diff][key]) {
+                    result[diff] = gameLevels[diff][key];
+                }
+            }
+            return result;
+        }""", mmdd)
 
-        # Přečti HTML přímo z iframu
-        iframe_html = await game_page.evaluate("""() => {
-            const iframe = document.getElementById('printFrame');
-            if (!iframe) return null;
-            try {
-                return iframe.contentDocument.documentElement.outerHTML;
-            } catch(e) { return null; }
-        }""")
-
-        if not iframe_html:
-            raise RuntimeError("Nepodařilo se získat HTML z #printFrame")
-
-        print(f"  iframe HTML zachycen ({len(iframe_html)} znaků), ukládám PDF...")
-
-        # Přidej base URL aby se načetly obrázky (img/black.png, img/title.jpg)
-        base_url = "https://www.solitaire.org/daily-str8ts/"
-        iframe_html = iframe_html.replace("<head>", f'<head><base href="{base_url}">', 1)
-
-        # Načti HTML do nové stránky a ulož jako PDF
-        pdf_page = await context.new_page()
-        await pdf_page.set_content(iframe_html, wait_until="networkidle")
-        await pdf_page.wait_for_timeout(500)
-
-        await pdf_page.pdf(
-            path=str(output_path),
-            format="A4",
-            print_background=True,
-            margin={"top": "10mm", "bottom": "10mm", "left": "10mm", "right": "10mm"},
-        )
-
-        print(f"PDF uloženo: {output_path}")
         await browser.close()
 
+    puzzles = []
+    for diff in DIFFICULTIES:
+        if diff in data:
+            puzzles.append({
+                "difficulty": diff,
+                "puzzle": data[diff]["puzzle"],
+                "bw": data[diff]["bw"],
+                "solution": data[diff]["solution"],
+            })
+    return puzzles
+
+
+# --- Main ---
+
+async def main():
+    today = date.today()
+    today_str = today.strftime("%Y-%m-%d")
+    mmdd = today.strftime("%m-%d")
+    output_path = OUTPUT_DIR / f"{today_str} Daily Str8ts puzzle.pdf"
+
+    if output_path.exists():
+        print(f"Soubor již existuje: {output_path}")
+        return
+
+    puzzles = await fetch_puzzles(mmdd)
+    if not puzzles:
+        raise RuntimeError(f"Žádná data pro {mmdd}")
+
+    print(f"Staženo {len(puzzles)} puzzle pro {today_str}")
+
+    inserted = save_to_mysql(today_str, puzzles)
+    print(f"MySQL: vloženo {inserted} nových řádků")
+
+    generate_pdf(output_path, puzzles, today_str)
+    print(f"PDF uloženo: {output_path}")
+
     send_mail(
         to=RECIPIENT,
         subject="Posílám dnešní Str8ts puzzle v příloze",

SběrDatRůzné/DailyStr8ts/vykresli_puzzle.py

@@ -0,0 +1,94 @@
+"""
+Vykreslí Str8ts puzzle do PDF z dat v MySQL tabulce puzzles.
+Formát: 2 puzzle nad sebou na A4, velikost 11×11 cm.
+"""
+
+import json
+import sys
+from pathlib import Path
+
+sys.stdout.reconfigure(encoding="utf-8")
+sys.path.insert(0, str(Path(__file__).parent.parent.parent / "Knihovny"))
+
+from reportlab.lib import colors
+from reportlab.lib.pagesizes import A4
+from reportlab.lib.units import cm
+from reportlab.pdfgen.canvas import Canvas
+
+from mysql_db import connect_mysql
+
+OUTPUT = Path(__file__).parent / "test_grid2.pdf"
+
+GRID = 9
+BOARD_CM = 11
+BOARD = BOARD_CM * cm
+CELL = BOARD / GRID
+
+
+def draw_str8ts(c: Canvas, x0: float, y0: float, puzzle: str, bw: str, title: str = ""):
+    font_size = CELL * 0.55
+
+    if title:
+        c.setFont("Helvetica-Bold", 12)
+        c.drawString(x0, y0 + 5, title)
+
+    for idx in range(81):
+        row, col = divmod(idx, 9)
+        cell_x = x0 + col * CELL
+        cell_y = y0 - (row + 1) * CELL
+        cx = cell_x + CELL / 2
+        cy = cell_y + CELL * 0.3
+        is_black = bw[idx] == "1"
+        ch = puzzle[idx]
+
+        if is_black:
+            c.setFillColor(colors.black)
+            c.rect(cell_x, cell_y, CELL, CELL, fill=1, stroke=0)
+
+        if ch in "123456789":
+            c.setFillColor(colors.yellow if is_black else colors.black)
+            c.setFont("Helvetica-Bold", font_size)
+            c.drawCentredString(cx, cy, ch)
+            c.setFillColor(colors.black)
+
+    for i in range(GRID + 1):
+        c.setLineWidth(0.8)
+        c.line(x0, y0 - i * CELL, x0 + BOARD, y0 - i * CELL)
+        c.line(x0 + i * CELL, y0, x0 + i * CELL, y0 - BOARD)
+
+
+def main():
+    conn = connect_mysql(database="puzzle")
+    cur = conn.cursor()
+    cur.execute(
+        "SELECT difficulty, puzzle, extra FROM puzzles "
+        "WHERE game_type='str8ts' AND puzzle_date='2026-05-08' "
+        "ORDER BY FIELD(difficulty, 'easy', 'medium', 'hard')"
+    )
+    rows = cur.fetchall()
+    cur.close()
+    conn.close()
+
+    if not rows:
+        print("Žádná data pro dnešek.")
+        return
+
+    page_w, page_h = A4
+    x0 = (page_w - BOARD) / 2
+    c = Canvas(str(OUTPUT), pagesize=A4)
+
+    # 2 puzzle na stránku
+    for i in range(0, len(rows), 2):
+        page_rows = rows[i:i + 2]
+        for j, (difficulty, puzzle, extra) in enumerate(page_rows):
+            bw = json.loads(extra)["bw"]
+            y0 = page_h - 2 * cm - j * (BOARD + 3 * cm)
+            draw_str8ts(c, x0, y0, puzzle, bw, difficulty.capitalize())
+        c.showPage()
+
+    c.save()
+    print(f"PDF uloženo: {OUTPUT}")
+
+
+if __name__ == "__main__":
+    main()

SběrDatRůzné/DailyStr8ts/vykresli_velikosti.py

@@ -0,0 +1,94 @@
+"""
+Vykreslí jedno Str8ts puzzle v různých velikostech (18×18 cm až 2×2 cm),
+každou velikost na samostatnou stránku A4, vycentrované.
+"""
+
+import json
+import sys
+from pathlib import Path
+
+sys.stdout.reconfigure(encoding="utf-8")
+sys.path.insert(0, str(Path(__file__).parent.parent.parent / "Knihovny"))
+
+from reportlab.lib import colors
+from reportlab.lib.pagesizes import A4
+from reportlab.lib.units import cm
+from reportlab.pdfgen.canvas import Canvas
+
+from mysql_db import connect_mysql
+
+OUTPUT = Path(__file__).parent / "str8ts_velikosti.pdf"
+GRID = 9
+
+
+def draw_str8ts(c: Canvas, x0: float, y0: float, cell: float,
+                puzzle: str, bw: str, title: str = ""):
+    board = GRID * cell
+    font_size = cell * 0.55
+
+    if title:
+        c.setFont("Helvetica-Bold", 12)
+        c.drawCentredString(x0 + board / 2, y0 + 5, title)
+
+    for idx in range(81):
+        row, col = divmod(idx, 9)
+        cell_x = x0 + col * cell
+        cell_y = y0 - (row + 1) * cell
+        cx = cell_x + cell / 2
+        cy = cell_y + cell * 0.3
+        is_black = bw[idx] == "1"
+        ch = puzzle[idx]
+
+        if is_black:
+            c.setFillColor(colors.black)
+            c.rect(cell_x, cell_y, cell, cell, fill=1, stroke=0)
+
+        if ch in "123456789":
+            c.setFillColor(colors.yellow if is_black else colors.black)
+            c.setFont("Helvetica-Bold", max(font_size, 4))
+            c.drawCentredString(cx, cy, ch)
+            c.setFillColor(colors.black)
+
+    for i in range(GRID + 1):
+        c.setLineWidth(0.8)
+        c.line(x0, y0 - i * cell, x0 + board, y0 - i * cell)
+        c.line(x0 + i * cell, y0, x0 + i * cell, y0 - board)
+
+
+def main():
+    conn = connect_mysql(database="puzzle")
+    cur = conn.cursor()
+    cur.execute(
+        "SELECT puzzle, extra FROM puzzles "
+        "WHERE game_type='str8ts' AND difficulty='easy' AND puzzle_date='2026-05-08'"
+    )
+    row = cur.fetchone()
+    cur.close()
+    conn.close()
+
+    if not row:
+        print("Žádná data.")
+        return
+
+    puzzle = row[0]
+    bw = json.loads(row[1])["bw"]
+
+    page_w, page_h = A4
+    c = Canvas(str(OUTPUT), pagesize=A4)
+
+    for size_cm in range(18, 1, -1):
+        board = size_cm * cm
+        cell = board / GRID
+        x0 = (page_w - board) / 2
+        y0 = (page_h + board) / 2
+
+        title = f"Str8ts Easy — {size_cm}×{size_cm} cm"
+        draw_str8ts(c, x0, y0, cell, puzzle, bw, title)
+        c.showPage()
+
+    c.save()
+    print(f"PDF uloženo: {OUTPUT}  ({18 - 2} stránek)")
+
+
+if __name__ == "__main__":
+    main()