From d488c872037489096e626f5fc98d070cbb9b5e61 Mon Sep 17 00:00:00 2001
From: Krzysztof kuhy Rudnicki <krzysztofrudnicki0@gmail.com>
Date: Fri, 13 Mar 2026 20:52:27 +0100
Subject: [PATCH] refactor(praca_magisterska_video): fix ruff violations and
 remove noqa from diagram generators

- Add type annotations, docstrings, and constants
- Remove commented-out code and print statements
- Fix all lint issues in 11 generate_images files
---
 .../generate_images/anki_approach_1.py        |   30 +-
 .../generate_images/anki_approach_2.py        |   29 +-
 .../generate_images/anki_generator.py         |  248 ++--
 .../generate_agent_diagrams.py                |  654 ++++++----
 .../generate_images/generate_anki.py          |  280 +++--
 .../generate_images/generate_anki_final.py    |  445 ++++---
 .../generate_images/generate_anki_v2.py       |   71 +-
 .../generate_images/generate_anki_v3.py       |  369 +++---
 .../generate_automata_diagrams.py             |  784 +++++++-----
 .../generate_normalization_diagrams.py        |  106 +-
 .../generate_pubsub_diagrams.py               | 1056 ++++++++++++-----
 11 files changed, 2726 insertions(+), 1346 deletions(-)

diff --git a/python_pkg/praca_magisterska_video/generate_images/anki_approach_1.py b/python_pkg/praca_magisterska_video/generate_images/anki_approach_1.py
index 5031538..005eebc 100755
--- a/python_pkg/praca_magisterska_video/generate_images/anki_approach_1.py
+++ b/python_pkg/praca_magisterska_video/generate_images/anki_approach_1.py
@@ -7,11 +7,17 @@
 
 from __future__ import annotations
 
+import logging
 from pathlib import Path
 import re
 
+logger = logging.getLogger(__name__)
 
-def clean_text(text) -> str:
+MIN_BODY_LENGTH = 50
+MIN_ANSWER_LENGTH = 100
+
+
+def clean_text(text: str) -> str:
     """Clean text."""
     if not text:
         return ""
@@ -23,7 +29,7 @@ def clean_text(text) -> str:
     return text.strip()
 
 
-def extract_cards(filepath) -> list[dict[str, str]]:
+def extract_cards(filepath: str) -> list[dict[str, str]]:
     """Extract cards."""
     with Path(filepath).open(encoding="utf-8") as f:
         content = f.read()
@@ -68,10 +74,10 @@ def extract_cards(filepath) -> list[dict[str, str]]:
         content,
         re.MULTILINE | re.DOTALL,
     )
-    for header, body in sections:
-        header = header.strip()
-        body = body.strip()
-        if len(body) < 50:
+    for raw_header, raw_body in sections:
+        header = raw_header.strip()
+        body = raw_body.strip()
+        if len(body) < MIN_BODY_LENGTH:
             continue
 
         # Get first paragraph
@@ -102,8 +108,10 @@ def main() -> None:
     for md_file in sorted(odpowiedzi_dir.glob("*.md")):
         all_cards.extend(extract_cards(md_file))
 
-    # APPROACH 1: Strict filtering - only cards with answer > 100 chars
-    filtered_cards = [c for c in all_cards if len(c["back"]) > 100]
+    # APPROACH 1: Strict filtering - only cards with answer > threshold
+    filtered_cards = [
+        c for c in all_cards if len(c["back"]) > MIN_ANSWER_LENGTH
+    ]
 
     # Remove duplicates
     seen = set()
@@ -120,7 +128,11 @@ def main() -> None:
         for c in unique:
             f.write(f"{c['front']}\t{c['back']}\t{c['tags']}\n")
 
-    print(f"✅ Approach 1 (Strict Filter): {len(unique)} cards -> {output_file.name}")
+    logger.info(
+        "Approach 1 (Strict Filter): %d cards -> %s",
+        len(unique),
+        output_file.name,
+    )
 
 
 if __name__ == "__main__":
diff --git a/python_pkg/praca_magisterska_video/generate_images/anki_approach_2.py b/python_pkg/praca_magisterska_video/generate_images/anki_approach_2.py
index 98d459b..ad229ab 100755
--- a/python_pkg/praca_magisterska_video/generate_images/anki_approach_2.py
+++ b/python_pkg/praca_magisterska_video/generate_images/anki_approach_2.py
@@ -7,11 +7,17 @@
 
 from __future__ import annotations
 
+import logging
 from pathlib import Path
 import re
 
+logger = logging.getLogger(__name__)
 
-def clean_text(text) -> str:
+MIN_PARA_LENGTH = 30
+MIN_BODY_LENGTH = 50
+
+
+def clean_text(text: str) -> str:
     """Clean text."""
     if not text:
         return ""
@@ -23,7 +29,7 @@ def clean_text(text) -> str:
     return text.strip()
 
 
-def extract_structured_content(body) -> str | None:
+def extract_structured_content(body: str) -> str | None:
     """Better extraction - look for multiple content types."""
     parts = []
 
@@ -54,15 +60,14 @@ def extract_structured_content(body) -> str | None:
             if p.strip()
             and not p.startswith("```")
             and not p.startswith("|")
-            and len(p.strip()) > 30
+            and len(p.strip()) > MIN_PARA_LENGTH
         ]
-        for p in paras[:2]:
-            parts.append(p[:300])
+        parts.extend(p[:300] for p in paras[:2])
 
     return "<br>".join([clean_text(p) for p in parts]) if parts else None
 
 
-def extract_cards(filepath) -> list[dict[str, str]]:
+def extract_cards(filepath: str) -> list[dict[str, str]]:
     """Extract cards."""
     with Path(filepath).open(encoding="utf-8") as f:
         content = f.read()
@@ -99,9 +104,9 @@ def extract_cards(filepath) -> list[dict[str, str]]:
         content,
         re.MULTILINE | re.DOTALL,
     )
-    for header, body in sections:
-        header = header.strip()
-        if "Przykład" in header or '"' in header or len(body) < 50:
+    for raw_header, body in sections:
+        header = raw_header.strip()
+        if "Przykład" in header or '"' in header or len(body) < MIN_BODY_LENGTH:
             continue
 
         answer = extract_structured_content(body)
@@ -143,8 +148,10 @@ def main() -> None:
         for c in unique:
             f.write(f"{c['front']}\t{c['back']}\t{c['tags']}\n")
 
-    print(
-        f"✅ Approach 2 (Better Extraction): {len(unique)} cards -> {output_file.name}"
+    logger.info(
+        "Approach 2 (Better Extraction): %d cards -> %s",
+        len(unique),
+        output_file.name,
     )
 
 
diff --git a/python_pkg/praca_magisterska_video/generate_images/anki_generator.py b/python_pkg/praca_magisterska_video/generate_images/anki_generator.py
index a62f6c6..d057477 100755
--- a/python_pkg/praca_magisterska_video/generate_images/anki_generator.py
+++ b/python_pkg/praca_magisterska_video/generate_images/anki_generator.py
@@ -7,31 +7,41 @@ Usage:
 Options:
     --filter      Apply strict filtering (answers > 100 chars)
     --extract     Use improved extraction algorithm
-    --main-only   Only generate main exam questions (45 comprehensive cards)
+    --main-only   Only generate main exam questions
 
 Combinations:
-    python anki_generator.py                           # Basic extraction, no filter
-    python anki_generator.py --filter                  # Approach 1: Strict filter only
-    python anki_generator.py --extract                 # Approach 2: Better extraction only
-    python anki_generator.py --main-only               # Approach 3: Main questions only
-    python anki_generator.py --filter --extract        # Approach 4: Filter + Better extraction
-    python anki_generator.py --filter --main-only      # Approach 5: Filter + Main only
-    python anki_generator.py --extract --main-only     # Approach 6: Better extraction + Main only
-    python anki_generator.py --filter --extract --main-only  # Approach 7: All three
+    python anki_generator.py
+    python anki_generator.py --filter
+    python anki_generator.py --extract
+    python anki_generator.py --main-only
+    python anki_generator.py --filter --extract
+    python anki_generator.py --filter --main-only
+    python anki_generator.py --extract --main-only
+    python anki_generator.py --filter --extract --main-only
 """
 
 from __future__ import annotations
 
 import argparse
+import logging
 from pathlib import Path
 import re
 
+logger = logging.getLogger(__name__)
+
+MIN_PARTS_THRESHOLD = 2
+MIN_BODY_LENGTH = 50
+MIN_PARA_LENGTH = 30
+SHORT_THRESHOLD = 50
+MEDIUM_THRESHOLD = 150
+DEFAULT_MIN_ANSWER_LENGTH = 100
+
 # =============================================================================
 # SHARED UTILITIES
 # =============================================================================
 
 
-def clean_text(text) -> str:
+def clean_text(text: str) -> str:
     """Clean and format text for Anki."""
     if not text:
         return ""
@@ -43,7 +53,7 @@ def clean_text(text) -> str:
     return text.strip()
 
 
-def get_file_metadata(filepath) -> tuple[str, str, str]:
+def get_file_metadata(filepath: str) -> tuple[str, str, str]:
     """Extract question number and subject from filename."""
     filename = Path(filepath).name
     match = re.match(r"(\d+)-(.+)\.md", filename)
@@ -58,7 +68,7 @@ def get_file_metadata(filepath) -> tuple[str, str, str]:
     return num, subject, content
 
 
-def get_main_question(content) -> str | None:
+def get_main_question(content: str) -> str | None:
     """Extract the main exam question."""
     q_match = re.search(
         r'## Pytanie\s*\n\s*\*\*["\']?(.+?)["\']?\*\*', content, re.DOTALL
@@ -73,7 +83,10 @@ def get_main_question(content) -> str | None:
 # =============================================================================
 
 
-def apply_strict_filter(cards, min_length=100) -> list[dict[str, str]]:
+def apply_strict_filter(
+    cards: list[dict[str, str]],
+    min_length: int = DEFAULT_MIN_ANSWER_LENGTH,
+) -> list[dict[str, str]]:
     """Filter cards to only include those with answers > min_length characters."""
     return [c for c in cards if len(c["back"]) > min_length]
 
@@ -83,7 +96,7 @@ def apply_strict_filter(cards, min_length=100) -> list[dict[str, str]]:
 # =============================================================================
 
 
-def extract_structured_content(body) -> str | None:
+def extract_structured_content(body: str) -> str | None:
     """Improved extraction - multiple content types with better formatting."""
     parts = []
 
@@ -101,7 +114,7 @@ def extract_structured_content(body) -> str | None:
             parts.append(f"• <b>{term}</b>")
 
     # 3. Key-value patterns
-    if len(parts) < 2:
+    if len(parts) < MIN_PARTS_THRESHOLD:
         kvs = re.findall(r"\*\*([^*\n]+)\*\*\s*[--:]\s*([^\n*]{10,150})", body)
         for k, v in kvs[:4]:
             entry = f"<b>{k.strip()}</b>: {v.strip()}"
@@ -116,15 +129,14 @@ def extract_structured_content(body) -> str | None:
             if p.strip()
             and not p.startswith("```")
             and not p.startswith("|")
-            and len(p.strip()) > 30
+            and len(p.strip()) > MIN_PARA_LENGTH
         ]
-        for p in paras[:2]:
-            parts.append(p[:300])
+        parts.extend(p[:300] for p in paras[:2])
 
     return "<br>".join([clean_text(p) for p in parts]) if parts else None
 
 
-def extract_cards_better(filepath) -> list[dict[str, str]]:
+def extract_cards_better(filepath: str) -> list[dict[str, str]]:
     """Extract cards with improved algorithm."""
     num, subject, content = get_file_metadata(filepath)
     base_tags = f"egzamin pyt{num} {subject}"
@@ -153,13 +165,13 @@ def extract_cards_better(filepath) -> list[dict[str, str]]:
         content,
         re.MULTILINE | re.DOTALL,
     )
-    for header, body in sections:
-        header = header.strip()
+    for raw_header, body in sections:
+        header = raw_header.strip()
         if (
             "Przykład" in header
             or '"' in header
             or "Mnemonic" in header
-            or len(body) < 50
+            or len(body) < MIN_BODY_LENGTH
         ):
             continue
 
@@ -176,7 +188,7 @@ def extract_cards_better(filepath) -> list[dict[str, str]]:
     return cards
 
 
-def extract_cards_basic(filepath) -> list[dict[str, str]]:
+def extract_cards_basic(filepath: str) -> list[dict[str, str]]:
     """Basic extraction - simpler algorithm."""
     num, subject, content = get_file_metadata(filepath)
     base_tags = f"egzamin pyt{num} {subject}"
@@ -212,10 +224,10 @@ def extract_cards_basic(filepath) -> list[dict[str, str]]:
         content,
         re.MULTILINE | re.DOTALL,
     )
-    for header, body in sections:
-        header = header.strip()
-        body = body.strip()
-        if len(body) < 50 or "Przykład" in header:
+    for raw_header, raw_body in sections:
+        header = raw_header.strip()
+        body = raw_body.strip()
+        if len(body) < MIN_BODY_LENGTH or "Przykład" in header:
             continue
 
         paras = [
@@ -241,7 +253,28 @@ def extract_cards_basic(filepath) -> list[dict[str, str]]:
 # =============================================================================
 
 
-def extract_main_only(filepath) -> list[dict[str, str]]:
+def _extract_key_point(body: str) -> str | None:
+    """Extract a key point from a section body."""
+    # Try to get a definition or first bullet
+    def_match = re.search(
+        r"Rozpoznawana klasa języków\s*\n\s*\*\*([^*]+)\*\*", body
+    )
+    if def_match:
+        return def_match.group(1).strip()
+
+    bullets = re.findall(r"[-•]\s*\*\*([^*]+)\*\*[:\s-]*([^\n]*)", body)
+    if bullets:
+        term, desc = bullets[0]
+        return f"{term}: {desc.strip()}" if desc.strip() else term
+
+    para_match = re.search(r"\n\n([^#\n\-•|`][^\n]{20,150})", body)
+    if para_match:
+        return para_match.group(1).strip()
+
+    return None
+
+
+def extract_main_only(filepath: str) -> list[dict[str, str]]:
     """Extract only the main exam question with comprehensive answer."""
     num, subject, content = get_file_metadata(filepath)
     base_tags = f"egzamin pyt{num} {subject} main"
@@ -255,7 +288,9 @@ def extract_main_only(filepath) -> list[dict[str, str]]:
 
     # Get main answer section
     answer_match = re.search(
-        r"## 📚 Odpowiedź główna\s*\n(.+?)(?=\n## [^�]|\Z)", content, re.DOTALL
+        r"## 📚 Odpowiedź główna\s*\n(.+?)(?=\n## [^�]|\Z)",
+        content,
+        re.DOTALL,
     )
     if answer_match:
         section = answer_match.group(1)
@@ -267,32 +302,16 @@ def extract_main_only(filepath) -> list[dict[str, str]]:
             re.MULTILINE | re.DOTALL,
         )
 
-        for header, body in headers[:5]:
-            header = header.strip()
-            if "Przykład" in header or "Mnemonic" in header or '"' in header:
+        for raw_header, body in headers[:5]:
+            header = raw_header.strip()
+            if (
+                "Przykład" in header
+                or "Mnemonic" in header
+                or '"' in header
+            ):
                 continue
 
-            # Get key point from this section
-            key_point = None
-
-            # Try to get a definition or first bullet
-            def_match = re.search(
-                r"Rozpoznawana klasa języków\s*\n\s*\*\*([^*]+)\*\*", body
-            )
-            if def_match:
-                key_point = def_match.group(1).strip()
-
-            if not key_point:
-                bullets = re.findall(r"[-•]\s*\*\*([^*]+)\*\*[:\s-]*([^\n]*)", body)
-                if bullets:
-                    term, desc = bullets[0]
-                    key_point = f"{term}: {desc.strip()}" if desc.strip() else term
-
-            if not key_point:
-                para_match = re.search(r"\n\n([^#\n\-•|`][^\n]{20,150})", body)
-                if para_match:
-                    key_point = para_match.group(1).strip()
-
+            key_point = _extract_key_point(body)
             if key_point:
                 answer_parts.append(f"<b>{header}</b>: {key_point}")
 
@@ -308,9 +327,58 @@ def extract_main_only(filepath) -> list[dict[str, str]]:
 # =============================================================================
 
 
-def generate_anki(use_filter=False, use_better_extract=False, main_only=False) -> Path:
+def _collect_cards(
+    odpowiedzi_dir: Path,
+    *,
+    use_better_extract: bool,
+    main_only: bool,
+) -> list[dict[str, str]]:
+    """Collect cards from all files using the specified approach."""
+    all_cards = []
+    for md_file in sorted(odpowiedzi_dir.glob("*.md")):
+        if main_only:
+            cards = extract_main_only(md_file)
+        elif use_better_extract:
+            cards = extract_cards_better(md_file)
+        else:
+            cards = extract_cards_basic(md_file)
+        all_cards.extend(cards)
+    return all_cards
+
+
+def _log_statistics(unique: list[dict[str, str]], output_file: Path) -> None:
+    """Log quality statistics for the generated cards."""
+    lengths = [len(c["back"]) for c in unique]
+    short = sum(1 for length in lengths if length < SHORT_THRESHOLD)
+    medium = sum(
+        1
+        for length in lengths
+        if SHORT_THRESHOLD <= length < MEDIUM_THRESHOLD
+    )
+    good = sum(
+        1 for length in lengths if length >= MEDIUM_THRESHOLD
+    )
+
+    logger.info("Generated: %s", output_file.name)
+    logger.info("   Cards: %d", len(unique))
+    logger.info(
+        "   Quality: %d short / %d medium / %d good",
+        short,
+        medium,
+        good,
+    )
+
+
+def generate_anki(
+    *,
+    use_filter: bool = False,
+    use_better_extract: bool = False,
+    main_only: bool = False,
+) -> Path:
     """Generate Anki deck with specified approaches."""
-    odpowiedzi_dir = Path("/home/kuchy/praca_magisterska/pytania/odpowiedzi")
+    odpowiedzi_dir = Path(
+        "/home/kuchy/praca_magisterska/pytania/odpowiedzi"
+    )
 
     # Determine output filename based on options
     suffix_parts = []
@@ -322,30 +390,25 @@ def generate_anki(use_filter=False, use_better_extract=False, main_only=False) -
         suffix_parts.append("main")
     suffix = "_".join(suffix_parts) if suffix_parts else "basic"
 
-    output_file = Path(f"/home/kuchy/praca_magisterska/pytania/anki_{suffix}.txt")
+    output_file = Path(
+        f"/home/kuchy/praca_magisterska/pytania/anki_{suffix}.txt"
+    )
     deck_name = f"Egzamin_{suffix.replace('_', '+')}"
 
-    all_cards = []
-
-    for md_file in sorted(odpowiedzi_dir.glob("*.md")):
-        if main_only:
-            # Approach 3: Only main questions
-            cards = extract_main_only(md_file)
-        elif use_better_extract:
-            # Approach 2: Better extraction
-            cards = extract_cards_better(md_file)
-        else:
-            # Basic extraction
-            cards = extract_cards_basic(md_file)
-
-        all_cards.extend(cards)
+    all_cards = _collect_cards(
+        odpowiedzi_dir,
+        use_better_extract=use_better_extract,
+        main_only=main_only,
+    )
 
     # Approach 1: Apply filtering if requested
     if use_filter:
-        all_cards = apply_strict_filter(all_cards, min_length=100)
+        all_cards = apply_strict_filter(
+            all_cards, min_length=DEFAULT_MIN_ANSWER_LENGTH
+        )
 
     # Remove duplicates
-    seen = set()
+    seen: set[str] = set()
     unique = []
     for c in all_cards:
         key = c["front"][:80]
@@ -355,20 +418,14 @@ def generate_anki(use_filter=False, use_better_extract=False, main_only=False) -
 
     # Write output
     with Path(output_file).open("w", encoding="utf-8") as f:
-        f.write(f"#separator:Tab\n#html:true\n#notetype:Basic\n#deck:{deck_name}\n\n")
+        f.write(
+            "#separator:Tab\n#html:true\n"
+            f"#notetype:Basic\n#deck:{deck_name}\n\n"
+        )
         for c in unique:
             f.write(f"{c['front']}\t{c['back']}\t{c['tags']}\n")
 
-    # Statistics
-    lengths = [len(c["back"]) for c in unique]
-    short = sum(1 for l in lengths if l < 50)
-    medium = sum(1 for l in lengths if 50 <= l < 150)
-    good = sum(1 for l in lengths if l >= 150)
-
-    print(f"✅ Generated: {output_file.name}")
-    print(f"   Cards: {len(unique)}")
-    print(f"   Quality: {short} short / {medium} medium / {good} good")
-    print()
+    _log_statistics(unique, output_file)
 
     return output_file
 
@@ -397,9 +454,9 @@ def main() -> None:
 
     if args.all_combinations:
         # Generate all 7 combinations
-        print("=" * 60)
-        print("Generating all 7 combinations...")
-        print("=" * 60 + "\n")
+        logger.info("=" * 60)
+        logger.info("Generating all 7 combinations...")
+        logger.info("=" * 60)
 
         combinations = [
             (True, False, False),  # 1: Filter only
@@ -411,9 +468,22 @@ def main() -> None:
             (True, True, True),  # 7: All three
         ]
 
-        for i, (f, e, m) in enumerate(combinations, 1):
-            print(f"--- Combination {i} (filter={f}, extract={e}, main={m}) ---")
-            generate_anki(use_filter=f, use_better_extract=e, main_only=m)
+        for i, (f_flag, e_flag, m_flag) in enumerate(
+            combinations, 1
+        ):
+            logger.info(
+                "--- Combination %d (filter=%s, extract=%s,"
+                " main=%s) ---",
+                i,
+                f_flag,
+                e_flag,
+                m_flag,
+            )
+            generate_anki(
+                use_filter=f_flag,
+                use_better_extract=e_flag,
+                main_only=m_flag,
+            )
     else:
         generate_anki(
             use_filter=args.filter,
diff --git a/python_pkg/praca_magisterska_video/generate_images/generate_agent_diagrams.py b/python_pkg/praca_magisterska_video/generate_images/generate_agent_diagrams.py
index 0e9acdf..14c60a2 100755
--- a/python_pkg/praca_magisterska_video/generate_images/generate_agent_diagrams.py
+++ b/python_pkg/praca_magisterska_video/generate_images/generate_agent_diagrams.py
@@ -12,15 +12,24 @@ All: A4-compatible, B&W, 300 DPI, laser-printer-friendly.
 
 from __future__ import annotations
 
+from dataclasses import dataclass
+import logging
+from pathlib import Path
+from typing import TYPE_CHECKING
+
 import matplotlib as mpl
 
 mpl.use("Agg")
-from pathlib import Path
 
 import matplotlib.patches as mpatches
 from matplotlib.patches import FancyBboxPatch
 import matplotlib.pyplot as plt
 
+if TYPE_CHECKING:
+    from matplotlib.axes import Axes
+
+logger = logging.getLogger(__name__)
+
 DPI = 300
 BG = "white"
 LN = "black"
@@ -36,85 +45,160 @@ GRAY4 = "#F5F5F5"
 GRAY5 = "#C0C0C0"
 
 
+@dataclass(frozen=True)
+class BoxStyle:
+    """Optional styling for boxes."""
+
+    fill: str = "white"
+    lw: float = 1.2
+    fontsize: float = FS
+    fontweight: str = "normal"
+    ha: str = "center"
+    va: str = "center"
+    rounded: bool = True
+
+
+@dataclass(frozen=True)
+class ArrowCfg:
+    """Optional config for arrows."""
+
+    lw: float = 1.2
+    style: str = "->"
+    color: str = LN
+    label: str = ""
+    label_offset: float = 0.12
+
+
+@dataclass(frozen=True)
+class DashedArrowCfg:
+    """Optional config for dashed arrows."""
+
+    lw: float = 1.0
+    color: str = LN
+    label: str = ""
+    label_offset: float = 0.12
+
+
 def draw_box(
-    ax,
-    x,
-    y,
-    w,
-    h,
-    text,
-    fill="white",
-    lw=1.2,
-    fontsize=FS,
-    fontweight="normal",
-    ha="center",
-    va="center",
-    rounded=True,
+    ax: Axes,
+    pos: tuple[float, float],
+    size: tuple[float, float],
+    text: str,
+    style: BoxStyle | None = None,
 ) -> None:
     """Draw box."""
-    if rounded:
+    s = style or BoxStyle()
+    x, y = pos
+    w, h = size
+    if s.rounded:
         rect = FancyBboxPatch(
-            (x, y), w, h, boxstyle="round,pad=0.05", lw=lw, edgecolor=LN, facecolor=fill
+            (x, y),
+            w,
+            h,
+            boxstyle="round,pad=0.05",
+            lw=s.lw,
+            edgecolor=LN,
+            facecolor=s.fill,
         )
     else:
-        rect = mpatches.Rectangle((x, y), w, h, lw=lw, edgecolor=LN, facecolor=fill)
+        rect = mpatches.Rectangle(
+            (x, y),
+            w,
+            h,
+            lw=s.lw,
+            edgecolor=LN,
+            facecolor=s.fill,
+        )
     ax.add_patch(rect)
     ax.text(
         x + w / 2,
         y + h / 2,
         text,
-        ha=ha,
-        va=va,
-        fontsize=fontsize,
-        fontweight=fontweight,
+        ha=s.ha,
+        va=s.va,
+        fontsize=s.fontsize,
+        fontweight=s.fontweight,
         wrap=True,
     )
 
 
 def draw_arrow(
-    ax, x1, y1, x2, y2, lw=1.2, style="->", color=LN, label="", label_offset=0.12
+    ax: Axes,
+    start: tuple[float, float],
+    end: tuple[float, float],
+    cfg: ArrowCfg | None = None,
 ) -> None:
     """Draw arrow."""
+    c = cfg or ArrowCfg()
     ax.annotate(
         "",
-        xy=(x2, y2),
-        xytext=(x1, y1),
-        arrowprops={"arrowstyle": style, "color": color, "lw": lw},
+        xy=end,
+        xytext=start,
+        arrowprops={
+            "arrowstyle": c.style,
+            "color": c.color,
+            "lw": c.lw,
+        },
     )
-    if label:
-        mx, my = (x1 + x2) / 2, (y1 + y2) / 2 + label_offset
-        ax.text(mx, my, label, ha="center", va="bottom", fontsize=6.5, color=color)
+    if c.label:
+        mx = (start[0] + end[0]) / 2
+        my = (start[1] + end[1]) / 2 + c.label_offset
+        ax.text(
+            mx,
+            my,
+            c.label,
+            ha="center",
+            va="bottom",
+            fontsize=6.5,
+            color=c.color,
+        )
 
 
 def draw_dashed_arrow(
-    ax, x1, y1, x2, y2, lw=1.0, color=LN, label="", label_offset=0.12
+    ax: Axes,
+    start: tuple[float, float],
+    end: tuple[float, float],
+    cfg: DashedArrowCfg | None = None,
 ) -> None:
     """Draw dashed arrow."""
+    c = cfg or DashedArrowCfg()
     ax.annotate(
         "",
-        xy=(x2, y2),
-        xytext=(x1, y1),
+        xy=end,
+        xytext=start,
         arrowprops={
             "arrowstyle": "->",
-            "color": color,
-            "lw": lw,
+            "color": c.color,
+            "lw": c.lw,
             "linestyle": "dashed",
         },
     )
-    if label:
-        mx, my = (x1 + x2) / 2, (y1 + y2) / 2 + label_offset
-        ax.text(mx, my, label, ha="center", va="bottom", fontsize=6.5, color=color)
+    if c.label:
+        mx = (start[0] + end[0]) / 2
+        my = (start[1] + end[1]) / 2 + c.label_offset
+        ax.text(
+            mx,
+            my,
+            c.label,
+            ha="center",
+            va="bottom",
+            fontsize=6.5,
+            color=c.color,
+        )
 
 
-# ─── DIAGRAM 1: See-Think-Act Cycle ──────────────────────────────
+# --- DIAGRAM 1: See-Think-Act Cycle ---
 def draw_see_think_act() -> None:
     """Draw see think act."""
-    fig, ax = plt.subplots(1, 1, figsize=(7, 4.5), facecolor=BG)
+    fig, ax = plt.subplots(
+        1, 1, figsize=(7, 4.5), facecolor=BG
+    )
     ax.set_xlim(0, 7)
     ax.set_ylim(0, 4.5)
     ax.axis("off")
     ax.set_title(
-        "Cykl agenta upostaciowionego: Percepcja → Deliberacja → Akcja",
+        "Cykl agenta upostaciowionego:"
+        " Percepcja \u2192 Deliberacja \u2192 Akcja",
         fontsize=FS_TITLE,
         fontweight="bold",
         pad=10,
@@ -135,7 +219,8 @@ def draw_see_think_act() -> None:
     ax.text(
         3.5,
         0.7,
-        "ŚRODOWISKO FIZYCZNE\n(przeszkody, obiekty, ludzie)",
+        "\u015aRODOWISKO FIZYCZNE\n"
+        "(przeszkody, obiekty, ludzie)",
         ha="center",
         va="center",
         fontsize=FS,
@@ -167,18 +252,17 @@ def draw_see_think_act() -> None:
     bw = 1.4
     bh = 0.7
     by = 2.2
+    bold_fs8 = BoxStyle(
+        fill=GRAY2, fontsize=8, fontweight="bold"
+    )
 
     # SEE
     draw_box(
         ax,
-        0.8,
-        by,
-        bw,
-        bh,
+        (0.8, by),
+        (bw, bh),
         "SEE\n(Percepcja)",
-        fill=GRAY2,
-        fontsize=8,
-        fontweight="bold",
+        bold_fs8,
     )
     ax.text(
         1.5,
@@ -193,14 +277,12 @@ def draw_see_think_act() -> None:
     # THINK
     draw_box(
         ax,
-        2.8,
-        by,
-        bw,
-        bh,
+        (2.8, by),
+        (bw, bh),
         "THINK\n(Deliberacja)",
-        fill=GRAY3,
-        fontsize=8,
-        fontweight="bold",
+        BoxStyle(
+            fill=GRAY3, fontsize=8, fontweight="bold"
+        ),
     )
     ax.text(
         3.5,
@@ -214,7 +296,11 @@ def draw_see_think_act() -> None:
 
     # ACT
     draw_box(
-        ax, 4.8, by, bw, bh, "ACT\n(Akcja)", fill=GRAY2, fontsize=8, fontweight="bold"
+        ax,
+        (4.8, by),
+        (bw, bh),
+        "ACT\n(Akcja)",
+        bold_fs8,
     )
     ax.text(
         5.5,
@@ -228,17 +314,43 @@ def draw_see_think_act() -> None:
 
     # Arrows between phases
     draw_arrow(
-        ax, 0.8 + bw, by + bh / 2, 2.8, by + bh / 2, lw=1.5, label="dane sensoryczne"
+        ax,
+        (0.8 + bw, by + bh / 2),
+        (2.8, by + bh / 2),
+        ArrowCfg(lw=1.5, label="dane sensoryczne"),
     )
     draw_arrow(
-        ax, 2.8 + bw, by + bh / 2, 4.8, by + bh / 2, lw=1.5, label="komendy sterujące"
+        ax,
+        (2.8 + bw, by + bh / 2),
+        (4.8, by + bh / 2),
+        ArrowCfg(
+            lw=1.5, label="komendy steruj\u0105ce"
+        ),
     )
 
     # Arrows to/from environment
-    draw_arrow(ax, 1.5, 1.2, 1.5, by, lw=1.3, label="odczyt", label_offset=0.08)
-    draw_arrow(ax, 5.5, by, 5.5, 1.2, lw=1.3, label="działanie", label_offset=0.08)
+    draw_arrow(
+        ax,
+        (1.5, 1.2),
+        (1.5, by),
+        ArrowCfg(
+            lw=1.3,
+            label="odczyt",
+            label_offset=0.08,
+        ),
+    )
+    draw_arrow(
+        ax,
+        (5.5, by),
+        (5.5, 1.2),
+        ArrowCfg(
+            lw=1.3,
+            label="dzia\u0142anie",
+            label_offset=0.08,
+        ),
+    )
 
-    # Feedback loop arrow (from ACT back to environment back to SEE)
+    # Feedback loop arrow
     ax.annotate(
         "",
         xy=(1.5, 1.15),
@@ -254,7 +366,8 @@ def draw_see_think_act() -> None:
     ax.text(
         3.5,
         0.35,
-        "← sprzężenie zwrotne (efekt akcji zmienia środowisko) →",
+        "\u2190 sprz\u0119\u017cenie zwrotne"
+        " (efekt akcji zmienia \u015brodowisko) \u2192",
         ha="center",
         va="center",
         fontsize=6,
@@ -262,21 +375,28 @@ def draw_see_think_act() -> None:
     )
 
     fig.tight_layout()
-    path = str(Path(OUTPUT_DIR) / "agent_see_think_act.png")
-    fig.savefig(path, dpi=DPI, bbox_inches="tight", facecolor=BG)
+    path = str(
+        Path(OUTPUT_DIR) / "agent_see_think_act.png"
+    )
+    fig.savefig(
+        path, dpi=DPI, bbox_inches="tight", facecolor=BG
+    )
     plt.close(fig)
-    print(f"  ✓ {path}")
+    logger.info("  \u2713 %s", path)
 
 
-# ─── DIAGRAM 2: 3T Architecture ─────────────────────────────────
+# --- DIAGRAM 2: 3T Architecture ---
 def draw_3t_architecture() -> None:
     """Draw 3t architecture."""
-    fig, ax = plt.subplots(1, 1, figsize=(7, 5.5), facecolor=BG)
+    fig, ax = plt.subplots(
+        1, 1, figsize=(7, 5.5), facecolor=BG
+    )
     ax.set_xlim(0, 7)
     ax.set_ylim(0, 5.5)
     ax.axis("off")
     ax.set_title(
-        "Architektura 3T sterownika robota (3-Layer Architecture)",
+        "Architektura 3T sterownika robota"
+        " (3-Layer Architecture)",
         fontsize=FS_TITLE,
         fontweight="bold",
         pad=10,
@@ -288,46 +408,52 @@ def draw_3t_architecture() -> None:
             "name": "WARSTWA 3: PLANNER\n(Deliberacja)",
             "time": "sekundy \u2013 minuty",
             "fill": GRAY1,
-            "example": 'Cel: "Jed\u017a do kuchni po kubek"\nPlanowanie trasy A \u2192 B \u2192 C',
-            "tech": "Planowanie symboliczne\nA*, graf zada\u0144",
+            "example": (
+                'Cel: "Jed\u017a do kuchni po kubek"\n'
+                "Planowanie trasy A \u2192 B \u2192 C"
+            ),
         },
         {
             "y": 2.6,
             "name": "WARSTWA 2: SEQUENCER\n(Wykonawca)",
             "time": "100 ms \u2013 sekundy",
             "fill": GRAY2,
-            "example": "Sekwencja: Jed\u017a do drzwi \u2192\nOtw\u00f3rz \u2192 Jed\u017a do blatu \u2192 Chwy\u0107",
-            "tech": "FSM, Behavior Trees\nkoordynacja zachowa\u0144",
+            "example": (
+                "Sekwencja: Jed\u017a do drzwi \u2192\n"
+                "Otw\u00f3rz \u2192 Jed\u017a do blatu"
+                " \u2192 Chwy\u0107"
+            ),
         },
         {
             "y": 1.2,
             "name": "WARSTWA 1: CONTROLLER\n(Reaktywny)",
             "time": "milisekundy",
             "fill": GRAY3,
-            "example": "PID: utrzymaj pr\u0119dko\u015b\u0107 0.5 m/s\nUnikaj kolizji (emergency stop)",
-            "tech": "PID, regulacja\nbezpo\u015brednie I/O",
+            "example": (
+                "PID: utrzymaj pr\u0119dko\u015b\u0107"
+                " 0.5 m/s\n"
+                "Unikaj kolizji (emergency stop)"
+            ),
         },
     ]
 
     bw = 4.0
     bh = 0.85
 
-    for _i, layer in enumerate(layers):
+    for layer in layers:
         y = layer["y"]
-        # Main layer box
         draw_box(
             ax,
-            0.3,
-            y,
-            bw,
-            bh,
+            (0.3, y),
+            (bw, bh),
             layer["name"],
-            fill=layer["fill"],
-            fontsize=8,
-            fontweight="bold",
+            BoxStyle(
+                fill=layer["fill"],
+                fontsize=8,
+                fontweight="bold",
+            ),
         )
 
-        # Time label (left)
         ax.text(
             0.15,
             y + bh / 2,
@@ -345,33 +471,38 @@ def draw_3t_architecture() -> None:
             },
         )
 
-        # Example (right side)
-        draw_box(ax, 4.5, y, 2.3, bh, layer["example"], fill="white", fontsize=6.5)
+        draw_box(
+            ax,
+            (4.5, y),
+            (2.3, bh),
+            layer["example"],
+            BoxStyle(fontsize=6.5),
+        )
 
-        # Technology used
-        # ax.text(4.5 + 1.15, y - 0.12, layer["tech"], ha='center', va='top',
-        #         fontsize=5.5, fontstyle='italic', color='#555555')
-
-    # Arrows between layers (downward = commands, upward = status)
+    # Arrows between layers
     for i in range(len(layers) - 1):
         y_top = layers[i]["y"]
         y_bot = layers[i + 1]["y"] + 0.85
-        # Command arrow (down)
-        draw_arrow(
-            ax, 1.8, y_top, 1.8, y_bot, lw=1.3, label="polecenia ↓", label_offset=0.02
-        )
-        # Status arrow (up)
         draw_arrow(
             ax,
-            2.8,
-            y_bot,
-            2.8,
-            y_top,
-            lw=1.0,
-            style="->",
-            color="#666666",
-            label="↑ status",
-            label_offset=0.02,
+            (1.8, y_top),
+            (1.8, y_bot),
+            ArrowCfg(
+                lw=1.3,
+                label="polecenia \u2193",
+                label_offset=0.02,
+            ),
+        )
+        draw_arrow(
+            ax,
+            (2.8, y_bot),
+            (2.8, y_top),
+            ArrowCfg(
+                lw=1.0,
+                color="#666666",
+                label="\u2191 status",
+                label_offset=0.02,
+            ),
         )
 
     # Environment at bottom
@@ -389,22 +520,27 @@ def draw_3t_architecture() -> None:
     ax.text(
         0.3 + bw / 2,
         0.6,
-        "SPRZĘT: silniki, czujniki, efektory",
+        "SPRZ\u0118T: silniki, czujniki, efektory",
         ha="center",
         va="center",
         fontsize=7,
         fontstyle="italic",
     )
 
-    # Arrow from controller to hardware
-    draw_arrow(ax, 2.3, 1.2, 2.3, 0.9, lw=1.3)
+    draw_arrow(
+        ax, (2.3, 1.2), (2.3, 0.9), ArrowCfg(lw=1.3)
+    )
 
     # Abstraction label on the right
     ax.annotate(
         "",
         xy=(6.9, 4.8),
         xytext=(6.9, 0.5),
-        arrowprops={"arrowstyle": "<->", "color": "#888888", "lw": 1.0},
+        arrowprops={
+            "arrowstyle": "<->",
+            "color": "#888888",
+            "lw": 1.0,
+        },
     )
     ax.text(
         6.95,
@@ -418,33 +554,43 @@ def draw_3t_architecture() -> None:
     )
 
     fig.tight_layout()
-    path = str(Path(OUTPUT_DIR) / "agent_3t_architecture.png")
-    fig.savefig(path, dpi=DPI, bbox_inches="tight", facecolor=BG)
+    path = str(
+        Path(OUTPUT_DIR) / "agent_3t_architecture.png"
+    )
+    fig.savefig(
+        path, dpi=DPI, bbox_inches="tight", facecolor=BG
+    )
     plt.close(fig)
-    print(f"  ✓ {path}")
+    logger.info("  \u2713 %s", path)
 
 
-# ─── DIAGRAM 3: Behavior Tree Example ────────────────────────────
+# --- DIAGRAM 3: Behavior Tree Example ---
 def draw_behavior_tree() -> None:
     """Draw behavior tree."""
-    fig, ax = plt.subplots(1, 1, figsize=(7.5, 4.5), facecolor=BG)
+    fig, ax = plt.subplots(
+        1, 1, figsize=(7.5, 4.5), facecolor=BG
+    )
     ax.set_xlim(0, 7.5)
     ax.set_ylim(0, 4.5)
     ax.axis("off")
     ax.set_title(
-        "Behavior Tree: robot przenoszący obiekt (pick-and-place)",
+        "Behavior Tree: robot przenosz\u0105cy"
+        " obiekt (pick-and-place)",
         fontsize=FS_TITLE,
         fontweight="bold",
         pad=10,
     )
 
-    # Node positions: (x, y, text, shape_type)
-    # shape_type: 'seq' = sequence (→), 'sel' = selector (?), 'act' = action, 'cond' = condition
-
-    def draw_bt_node(ax, x, y, text, ntype="act", w=1.0, h=0.45) -> tuple[float, float]:
+    def draw_bt_node(
+        pos: tuple[float, float],
+        text: str,
+        ntype: str = "act",
+        size: tuple[float, float] = (1.0, 0.45),
+    ) -> tuple[float, float]:
         """Draw a behavior tree node."""
+        x, y = pos
+        w, h = size
         if ntype == "seq":
-            # Sequence = box with →
             rect = FancyBboxPatch(
                 (x - w / 2, y - h / 2),
                 w,
@@ -458,14 +604,13 @@ def draw_behavior_tree() -> None:
             ax.text(
                 x,
                 y,
-                f"→ {text}",
+                f"\u2192 {text}",
                 ha="center",
                 va="center",
                 fontsize=7,
                 fontweight="bold",
             )
         elif ntype == "sel":
-            # Selector = box with ?
             rect = FancyBboxPatch(
                 (x - w / 2, y - h / 2),
                 w,
@@ -486,7 +631,6 @@ def draw_behavior_tree() -> None:
                 fontweight="bold",
             )
         elif ntype == "cond":
-            # Condition = diamond-ish / oval with dashed border
             rect = FancyBboxPatch(
                 (x - w / 2, y - h / 2),
                 w,
@@ -499,7 +643,13 @@ def draw_behavior_tree() -> None:
             )
             ax.add_patch(rect)
             ax.text(
-                x, y, text, ha="center", va="center", fontsize=6.5, fontstyle="italic"
+                x,
+                y,
+                text,
+                ha="center",
+                va="center",
+                fontsize=6.5,
+                fontstyle="italic",
             )
         else:  # action
             rect = FancyBboxPatch(
@@ -512,53 +662,121 @@ def draw_behavior_tree() -> None:
                 facecolor=GRAY1,
             )
             ax.add_patch(rect)
-            ax.text(x, y, text, ha="center", va="center", fontsize=6.5)
+            ax.text(
+                x,
+                y,
+                text,
+                ha="center",
+                va="center",
+                fontsize=6.5,
+            )
         return x, y
 
-    # Root: Sequence "Przenieś obiekt"
-    root = draw_bt_node(ax, 3.75, 3.8, "Przenieś obiekt", "seq", w=1.6)
+    # Root: Sequence "Przenies obiekt"
+    root = draw_bt_node(
+        (3.75, 3.8), "Przenie\u015b obiekt", "seq",
+        (1.6, 0.45),
+    )
 
     # Level 2 children
-    find = draw_bt_node(ax, 1.2, 2.8, "Znajdź obiekt", "sel", w=1.3)
-    nav = draw_bt_node(ax, 3.75, 2.8, "Jedź do obiektu", "act", w=1.3)
-    pick = draw_bt_node(ax, 6.3, 2.8, "Chwyć i dostarcz", "seq", w=1.4)
+    find = draw_bt_node(
+        (1.2, 2.8), "Znajd\u017a obiekt", "sel",
+        (1.3, 0.45),
+    )
+    nav = draw_bt_node(
+        (3.75, 2.8), "Jed\u017a do obiektu", "act",
+        (1.3, 0.45),
+    )
+    pick = draw_bt_node(
+        (6.3, 2.8), "Chwy\u0107 i dostarcz", "seq",
+        (1.4, 0.45),
+    )
 
     # Arrows from root
-    draw_arrow(ax, root[0], root[1] - 0.225, find[0], find[1] + 0.225, lw=1.0)
-    draw_arrow(ax, root[0], root[1] - 0.225, nav[0], nav[1] + 0.225, lw=1.0)
-    draw_arrow(ax, root[0], root[1] - 0.225, pick[0], pick[1] + 0.225, lw=1.0)
+    arrow_thin = ArrowCfg(lw=1.0)
+    for child in (find, nav, pick):
+        draw_arrow(
+            ax,
+            (root[0], root[1] - 0.225),
+            (child[0], child[1] + 0.225),
+            arrow_thin,
+        )
 
-    # Level 3: children of "Znajdź obiekt" (selector)
-    vis = draw_bt_node(ax, 0.55, 1.7, "Widzę\nobiekt?", "cond", w=0.85, h=0.5)
-    scan = draw_bt_node(ax, 1.85, 1.7, "Skanuj\notoczenie", "act", w=0.85, h=0.5)
-    draw_arrow(ax, find[0], find[1] - 0.225, vis[0], vis[1] + 0.25, lw=0.8)
-    draw_arrow(ax, find[0], find[1] - 0.225, scan[0], scan[1] + 0.25, lw=0.8)
+    # Level 3: children of "Znajdz obiekt"
+    arrow_08 = ArrowCfg(lw=0.8)
+    vis = draw_bt_node(
+        (0.55, 1.7), "Widz\u0119\nobiekt?", "cond",
+        (0.85, 0.5),
+    )
+    scan = draw_bt_node(
+        (1.85, 1.7), "Skanuj\notoczenie", "act",
+        (0.85, 0.5),
+    )
+    for child in (vis, scan):
+        draw_arrow(
+            ax,
+            (find[0], find[1] - 0.225),
+            (child[0], child[1] + 0.25),
+            arrow_08,
+        )
 
-    # Level 3: children of "Chwyć i dostarcz" (sequence)
-    grasp = draw_bt_node(ax, 5.4, 1.7, "Chwyć\nobject", "act", w=0.85, h=0.5)
-    deliver = draw_bt_node(ax, 6.5, 1.7, "Jedź do\ncelu", "act", w=0.85, h=0.5)
-    release = draw_bt_node(ax, 7.2, 1.7, "Puść", "act", w=0.55, h=0.5)
-    draw_arrow(ax, pick[0], pick[1] - 0.225, grasp[0], grasp[1] + 0.25, lw=0.8)
-    draw_arrow(ax, pick[0], pick[1] - 0.225, deliver[0], deliver[1] + 0.25, lw=0.8)
-    draw_arrow(ax, pick[0], pick[1] - 0.225, release[0], release[1] + 0.25, lw=0.8)
+    # Level 3: children of "Chwyt i dostarcz"
+    pick_children = [
+        draw_bt_node(
+            (5.4, 1.7), "Chwy\u0107\nobject", "act",
+            (0.85, 0.5),
+        ),
+        draw_bt_node(
+            (6.5, 1.7), "Jed\u017a do\ncelu", "act",
+            (0.85, 0.5),
+        ),
+        draw_bt_node(
+            (7.2, 1.7), "Pu\u015b\u0107", "act",
+            (0.55, 0.5),
+        ),
+    ]
+    for child in pick_children:
+        draw_arrow(
+            ax,
+            (pick[0], pick[1] - 0.225),
+            (child[0], child[1] + 0.25),
+            arrow_08,
+        )
 
     # Legend
     leg_y = 0.5
-    draw_bt_node(ax, 0.8, leg_y, "→ Sequence", "seq", w=1.1, h=0.35)
-    draw_bt_node(ax, 2.3, leg_y, "? Selector", "sel", w=1.0, h=0.35)
-    draw_bt_node(ax, 3.6, leg_y, "Akcja", "act", w=0.8, h=0.35)
-    draw_bt_node(ax, 4.8, leg_y, "Warunek", "cond", w=0.8, h=0.35)
+    draw_bt_node(
+        (0.8, leg_y), "\u2192 Sequence", "seq",
+        (1.1, 0.35),
+    )
+    draw_bt_node(
+        (2.3, leg_y), "? Selector", "sel",
+        (1.0, 0.35),
+    )
+    draw_bt_node(
+        (3.6, leg_y), "Akcja", "act", (0.8, 0.35)
+    )
+    draw_bt_node(
+        (4.8, leg_y), "Warunek", "cond", (0.8, 0.35)
+    )
 
     ax.text(
-        0.3, leg_y, "Legenda:", ha="left", va="center", fontsize=6.5, fontweight="bold"
+        0.3,
+        leg_y,
+        "Legenda:",
+        ha="left",
+        va="center",
+        fontsize=6.5,
+        fontweight="bold",
     )
 
     # Execution note
     ax.text(
         3.75,
         0.05,
-        "Wykonanie: od lewej do prawej. Sequence (→) = wszystkie po kolei. "
-        "Selector (?) = pierwszy sukces.",
+        "Wykonanie: od lewej do prawej."
+        " Sequence (\u2192) = wszystkie po kolei."
+        " Selector (?) = pierwszy sukces.",
         ha="center",
         va="center",
         fontsize=6,
@@ -567,21 +785,28 @@ def draw_behavior_tree() -> None:
     )
 
     fig.tight_layout()
-    path = str(Path(OUTPUT_DIR) / "agent_behavior_tree.png")
-    fig.savefig(path, dpi=DPI, bbox_inches="tight", facecolor=BG)
+    path = str(
+        Path(OUTPUT_DIR) / "agent_behavior_tree.png"
+    )
+    fig.savefig(
+        path, dpi=DPI, bbox_inches="tight", facecolor=BG
+    )
     plt.close(fig)
-    print(f"  ✓ {path}")
+    logger.info("  \u2713 %s", path)
 
 
-# ─── DIAGRAM 4: BDI Model ────────────────────────────────────────
+# --- DIAGRAM 4: BDI Model ---
 def draw_bdi_model() -> None:
     """Draw bdi model."""
-    fig, ax = plt.subplots(1, 1, figsize=(7, 4), facecolor=BG)
+    fig, ax = plt.subplots(
+        1, 1, figsize=(7, 4), facecolor=BG
+    )
     ax.set_xlim(0, 7)
     ax.set_ylim(0, 4)
     ax.axis("off")
     ax.set_title(
-        "Model BDI agenta (Beliefs-Desires-Intentions)",
+        "Model BDI agenta"
+        " (Beliefs-Desires-Intentions)",
         fontsize=FS_TITLE,
         fontweight="bold",
         pad=10,
@@ -589,9 +814,12 @@ def draw_bdi_model() -> None:
 
     bw = 1.6
     bh = 1.4
+    bold8 = BoxStyle(
+        fill=GRAY1, fontsize=8, fontweight="bold"
+    )
 
     # BELIEFS box
-    draw_box(ax, 0.3, 1.3, bw, bh, "", fill=GRAY1, fontsize=8, fontweight="bold")
+    draw_box(ax, (0.3, 1.3), (bw, bh), "", bold8)
     ax.text(
         0.3 + bw / 2,
         1.3 + bh - 0.15,
@@ -604,14 +832,26 @@ def draw_bdi_model() -> None:
     ax.text(
         0.3 + bw / 2,
         1.3 + bh / 2 - 0.1,
-        "(wiedza o \u015bwiecie)\n\n\u2022 mapa pokoju\n\u2022 pozycja robota\n\u2022 drzwi zamkni\u0119te\n\u2022 bateria: 45%",
+        "(wiedza o \u015bwiecie)\n\n"
+        "\u2022 mapa pokoju\n"
+        "\u2022 pozycja robota\n"
+        "\u2022 drzwi zamkni\u0119te\n"
+        "\u2022 bateria: 45%",
         ha="center",
         va="center",
         fontsize=6.5,
     )
 
     # DESIRES box
-    draw_box(ax, 2.7, 1.3, bw, bh, "", fill=GRAY2, fontsize=8, fontweight="bold")
+    draw_box(
+        ax,
+        (2.7, 1.3),
+        (bw, bh),
+        "",
+        BoxStyle(
+            fill=GRAY2, fontsize=8, fontweight="bold"
+        ),
+    )
     ax.text(
         2.7 + bw / 2,
         1.3 + bh - 0.15,
@@ -624,14 +864,26 @@ def draw_bdi_model() -> None:
     ax.text(
         2.7 + bw / 2,
         1.3 + bh / 2 - 0.1,
-        "(cele agenta)\n\n• dostarczyć paczkę\n  do pokoju 5\n• naładować baterię\n• unikać kolizji",
+        "(cele agenta)\n\n"
+        "\u2022 dostarczy\u0107 paczk\u0119\n"
+        "  do pokoju 5\n"
+        "\u2022 na\u0142adowa\u0107 bateri\u0119\n"
+        "\u2022 unika\u0107 kolizji",
         ha="center",
         va="center",
         fontsize=6.5,
     )
 
     # INTENTIONS box
-    draw_box(ax, 5.1, 1.3, bw, bh, "", fill=GRAY3, fontsize=8, fontweight="bold")
+    draw_box(
+        ax,
+        (5.1, 1.3),
+        (bw, bh),
+        "",
+        BoxStyle(
+            fill=GRAY3, fontsize=8, fontweight="bold"
+        ),
+    )
     ax.text(
         5.1 + bw / 2,
         1.3 + bh - 0.15,
@@ -644,7 +896,11 @@ def draw_bdi_model() -> None:
     ax.text(
         5.1 + bw / 2,
         1.3 + bh / 2 - 0.1,
-        "(aktualny plan)\n\n→ jedź do drzwi\n  bocznych\n→ otwórz drzwi\n→ wjedź do pokoju 5",
+        "(aktualny plan)\n\n"
+        "\u2192 jed\u017a do drzwi\n"
+        "  bocznych\n"
+        "\u2192 otw\u00f3rz drzwi\n"
+        "\u2192 wjed\u017a do pokoju 5",
         ha="center",
         va="center",
         fontsize=6.5,
@@ -653,26 +909,26 @@ def draw_bdi_model() -> None:
     # Arrows
     draw_arrow(
         ax,
-        0.3 + bw,
-        1.3 + bh / 2 + 0.15,
-        2.7,
-        1.3 + bh / 2 + 0.15,
-        lw=1.3,
-        label="informuje",
-        label_offset=0.08,
+        (0.3 + bw, 1.3 + bh / 2 + 0.15),
+        (2.7, 1.3 + bh / 2 + 0.15),
+        ArrowCfg(
+            lw=1.3,
+            label="informuje",
+            label_offset=0.08,
+        ),
     )
     draw_arrow(
         ax,
-        2.7 + bw,
-        1.3 + bh / 2 + 0.15,
-        5.1,
-        1.3 + bh / 2 + 0.15,
-        lw=1.3,
-        label="filtruje → wybiera",
-        label_offset=0.08,
+        (2.7 + bw, 1.3 + bh / 2 + 0.15),
+        (5.1, 1.3 + bh / 2 + 0.15),
+        ArrowCfg(
+            lw=1.3,
+            label="filtruje \u2192 wybiera",
+            label_offset=0.08,
+        ),
     )
 
-    # Feedback from intentions back to beliefs (update)
+    # Feedback: intentions back to beliefs
     ax.annotate(
         "",
         xy=(0.3 + bw / 2, 1.3),
@@ -699,18 +955,18 @@ def draw_bdi_model() -> None:
     # Sensor input arrow
     draw_arrow(
         ax,
-        0.3 + bw / 2,
-        3.5,
-        0.3 + bw / 2,
-        1.3 + bh,
-        lw=1.3,
-        label="percepcja (sensory)",
-        label_offset=0.05,
+        (0.3 + bw / 2, 3.5),
+        (0.3 + bw / 2, 1.3 + bh),
+        ArrowCfg(
+            lw=1.3,
+            label="percepcja (sensory)",
+            label_offset=0.05,
+        ),
     )
     ax.text(
         0.3 + bw / 2,
         3.55,
-        "ŚRODOWISKO",
+        "\u015aRODOWISKO",
         ha="center",
         va="bottom",
         fontsize=7,
@@ -726,13 +982,13 @@ def draw_bdi_model() -> None:
     # Action output arrow
     draw_arrow(
         ax,
-        5.1 + bw / 2,
-        1.3 + bh,
-        5.1 + bw / 2,
-        3.5,
-        lw=1.3,
-        label="akcja (efektory)",
-        label_offset=0.05,
+        (5.1 + bw / 2, 1.3 + bh),
+        (5.1 + bw / 2, 3.5),
+        ArrowCfg(
+            lw=1.3,
+            label="akcja (efektory)",
+            label_offset=0.05,
+        ),
     )
     ax.text(
         5.1 + bw / 2,
@@ -752,16 +1008,18 @@ def draw_bdi_model() -> None:
 
     fig.tight_layout()
     path = str(Path(OUTPUT_DIR) / "agent_bdi_model.png")
-    fig.savefig(path, dpi=DPI, bbox_inches="tight", facecolor=BG)
+    fig.savefig(
+        path, dpi=DPI, bbox_inches="tight", facecolor=BG
+    )
     plt.close(fig)
-    print(f"  ✓ {path}")
+    logger.info("  \u2713 %s", path)
 
 
-# ─── MAIN ────────────────────────────────────────────────────────
+# --- MAIN ---
 if __name__ == "__main__":
-    print("Generating PYTANIE 15 diagrams...")
+    logger.info("Generating PYTANIE 15 diagrams...")
     draw_see_think_act()
     draw_3t_architecture()
     draw_behavior_tree()
     draw_bdi_model()
-    print("Done! All diagrams saved to", OUTPUT_DIR)
+    logger.info("Done! All diagrams saved to %s", OUTPUT_DIR)
diff --git a/python_pkg/praca_magisterska_video/generate_images/generate_anki.py b/python_pkg/praca_magisterska_video/generate_images/generate_anki.py
index 3fcd66b..1cfd7c7 100755
--- a/python_pkg/praca_magisterska_video/generate_images/generate_anki.py
+++ b/python_pkg/praca_magisterska_video/generate_images/generate_anki.py
@@ -6,18 +6,27 @@ Creates a tab-separated file compatible with Anki import.
 
 from __future__ import annotations
 
+import logging
 from pathlib import Path
 import re
 
+logger = logging.getLogger(__name__)
 
-def extract_question_and_answer(filepath) -> list[dict[str, str]]:
-    """Extract main question and key answer points from a markdown file."""
+MIN_BODY_LENGTH = 50
+MIN_DEFINITION_LENGTH = 20
+MAX_DEFINITION_LENGTH = 200
+MIN_BULLET_COUNT = 5
+MIN_SUBSECTION_LENGTH = 5
+MIN_FORMULA_LENGTH = 20
+
+
+def _get_metadata(
+    filepath: str,
+) -> tuple[str, str, str, str, str]:
+    """Extract metadata from file."""
     with Path(filepath).open(encoding="utf-8") as f:
         content = f.read()
 
-    cards = []
-
-    # Extract file number for tagging
     filename = Path(filepath).name
     match = re.match(r"(\d+)-(.+)\.md", filename)
     if match:
@@ -27,13 +36,13 @@ def extract_question_and_answer(filepath) -> list[dict[str, str]]:
         num = "00"
         topic = "unknown"
 
-    # Extract main title (usually contains the question)
     title_match = re.search(r"^# (.+)$", content, re.MULTILINE)
     title = title_match.group(1) if title_match else "Unknown"
 
-    # Extract the main question from ## Pytanie section
     question_match = re.search(
-        r'## Pytanie\s*\n\s*\*\*["\']?(.+?)["\']?\*\*', content, re.DOTALL
+        r'## Pytanie\s*\n\s*\*\*["\']?(.+?)["\']?\*\*',
+        content,
+        re.DOTALL,
     )
     if question_match:
         main_question = question_match.group(1).strip()
@@ -41,124 +50,207 @@ def extract_question_and_answer(filepath) -> list[dict[str, str]]:
     else:
         main_question = title
 
-    # Extract subject/przedmiot
-    subject_match = re.search(r"Przedmiot:\s*(\w+)", content)
-    subject = subject_match.group(1) if subject_match else "Ogólne"
+    return num, topic, title, main_question, content
 
-    # Create main question card - extract key sections for answer
-    answer_parts = []
 
-    # Look for main answer section
+def _extract_main_card(
+    content: str,
+    main_question: str,
+    subject: str,
+    num: str,
+    topic: str,
+) -> list[dict[str, str]]:
+    """Extract the main question card."""
+    answer_parts: list[str] = []
+
     main_answer = re.search(
-        r"## 📚 Odpowiedź główna\s*\n(.+?)(?=\n## |\n---\s*\n## |\Z)",
+        r"## 📚 Odpowiedź główna\s*\n(.+?)"
+        r"(?=\n## |\n---\s*\n## |\Z)",
         content,
         re.DOTALL,
     )
     if main_answer:
         answer_text = main_answer.group(1)
-        # Extract key points, definitions, headers
         headers = re.findall(r"### (.+)", answer_text)
-        for h in headers[:5]:  # Limit to first 5 headers
-            answer_parts.append(f"• {h}")
+        answer_parts.extend(f"• {h}" for h in headers[:5])
 
-    # Also extract key definitions if present
-    definitions = re.findall(r"\*\*([^*]+)\*\*\s*[--:]\s*([^*\n]+)", content)
+    definitions = re.findall(
+        r"\*\*([^*]+)\*\*\s*[--:]\s*([^*\n]+)", content
+    )
     for term, definition in definitions[:3]:
-        if len(definition) > 20 and len(definition) < 200:
-            answer_parts.append(f"• {term}: {definition.strip()}")
+        if (
+            len(definition) > MIN_DEFINITION_LENGTH
+            and len(definition) < MAX_DEFINITION_LENGTH
+        ):
+            answer_parts.append(
+                f"• {term}: {definition.strip()}"
+            )
 
-    # If we found answer parts, create main card
-    if answer_parts:
-        answer_html = "<br>".join(answer_parts[:8])  # Limit answer length
-        cards.append(
-            {
-                "question": main_question,
-                "answer": answer_html,
-                "tags": f"egzamin_magisterski pytanie_{num} {subject} {topic}",
-            }
+    if not answer_parts:
+        return []
+
+    answer_html = "<br>".join(answer_parts[:8])
+    return [
+        {
+            "question": main_question,
+            "answer": answer_html,
+            "tags": (
+                f"egzamin_magisterski pytanie_{num}"
+                f" {subject} {topic}"
+            ),
+        }
+    ]
+
+
+def _extract_subsection_answer(body_clean: str) -> str | None:
+    """Extract answer text from a subsection body."""
+    bullets = re.findall(
+        r"[-•]\s*\*\*(.+?)\*\*[:\s]*([^\n]+)?", body_clean
+    )
+    if bullets:
+        return "<br>".join(
+            f"• {b[0]}: {b[1].strip()}" if b[1] else f"• {b[0]}"
+            for b in bullets[:MIN_BULLET_COUNT]
         )
 
-    # Extract sub-questions and key concepts as additional cards
-    # Look for ### headers with explanations
+    paragraphs = [
+        p.strip()
+        for p in body_clean.split("\n\n")
+        if p.strip()
+        and not p.startswith("```")
+        and not p.startswith("|")
+    ]
+    if paragraphs:
+        first_para = paragraphs[0]
+        first_para = re.sub(r"\*\*(.+?)\*\*", r"\1", first_para)
+        first_para = re.sub(r"\*(.+?)\*", r"\1", first_para)
+        return first_para[:400]
+
+    return None
+
+
+def _extract_sub_cards(
+    content: str,
+    title: str,
+    subject: str,
+    num: str,
+    topic: str,
+) -> list[dict[str, str]]:
+    """Extract sub-concept cards."""
+    cards: list[dict[str, str]] = []
     subsections = re.findall(
-        r"### (\d+\.\s+)?(.+?)\n\n(.+?)(?=\n### |\n## |\n---|\Z)", content, re.DOTALL
+        r"### (\d+\.\s+)?(.+?)\n\n(.+?)"
+        r"(?=\n### |\n## |\n---|\Z)",
+        content,
+        re.DOTALL,
     )
 
     for _, header, body in subsections:
-        if len(header) < 5 or header.startswith("Przykład"):
-            continue
-
-        # Extract first substantive paragraph or key points
-        body_clean = body.strip()
-
-        # Skip very short or code-only sections
-        if len(body_clean) < 50:
-            continue
-
-        # Extract bullet points or first paragraph
-        bullets = re.findall(r"[-•]\s*\*\*(.+?)\*\*[:\s]*([^\n]+)?", body_clean)
-        if bullets:
-            answer_text = "<br>".join(
-                [
-                    f"• {b[0]}: {b[1].strip()}" if b[1] else f"• {b[0]}"
-                    for b in bullets[:5]
-                ]
-            )
-        else:
-            # Get first meaningful paragraph
-            paragraphs = [
-                p.strip()
-                for p in body_clean.split("\n\n")
-                if p.strip() and not p.startswith("```") and not p.startswith("|")
-            ]
-            if paragraphs:
-                first_para = paragraphs[0]
-                # Clean markdown
-                first_para = re.sub(r"\*\*(.+?)\*\*", r"\1", first_para)
-                first_para = re.sub(r"\*(.+?)\*", r"\1", first_para)
-                answer_text = first_para[:400]
-            else:
-                continue
-
-        # Create sub-concept card
-        sub_question = f"Co to jest {header}?" if not header.endswith("?") else header
         if (
-            "Charakterystyka" in header
-            or "Definicja" in header
-            or "Właściwości" in header
+            len(header) < MIN_SUBSECTION_LENGTH
+            or header.startswith("Przykład")
         ):
-            # These are answer-type headers, reframe
-            parent_topic = title.replace("Pytanie", "").strip(": 0123456789")
-            sub_question = f"{header} - {parent_topic}"
+            continue
+
+        body_clean = body.strip()
+        if len(body_clean) < MIN_BODY_LENGTH:
+            continue
+
+        answer_text = _extract_subsection_answer(body_clean)
+        if not answer_text:
+            continue
+
+        sub_question = (
+            f"Co to jest {header}?"
+            if not header.endswith("?")
+            else header
+        )
+
+        if any(
+            kw in header
+            for kw in ("Charakterystyka", "Definicja", "Właściwości")
+        ):
+            parent = title.replace("Pytanie", "").strip(
+                ": 0123456789"
+            )
+            sub_question = f"{header} - {parent}"
 
         cards.append(
             {
                 "question": sub_question,
                 "answer": answer_text,
-                "tags": f"egzamin_magisterski pytanie_{num} {subject} {topic} szczegoly",
+                "tags": (
+                    f"egzamin_magisterski pytanie_{num}"
+                    f" {subject} {topic} szczegoly"
+                ),
             }
         )
 
-    # Extract key formulas/definitions as separate cards
+    return cards
+
+
+def _extract_formula_cards(
+    content: str,
+    subject: str,
+    num: str,
+) -> list[dict[str, str]]:
+    """Extract formula/definition cards."""
+    cards: list[dict[str, str]] = []
     formulas = re.findall(
-        r"\*\*([A-Za-z\s]+(?:formuła|wzór|twierdzenie|definicja|lemat))\*\*[:\s]*\n?(.+?)(?=\n\n|\n\*\*|\Z)",
+        r"\*\*([A-Za-z\s]+"
+        r"(?:formuła|wzór|twierdzenie|definicja|lemat))"
+        r"\*\*[:\s]*\n?(.+?)(?=\n\n|\n\*\*|\Z)",
         content,
         re.IGNORECASE | re.DOTALL,
     )
     for formula_name, formula_content in formulas:
-        if len(formula_content) > 20:
+        if len(formula_content) > MIN_FORMULA_LENGTH:
             cards.append(
                 {
                     "question": f"Podaj {formula_name.strip()}",
                     "answer": formula_content.strip()[:300],
-                    "tags": f"egzamin_magisterski pytanie_{num} {subject} formuly",
+                    "tags": (
+                        f"egzamin_magisterski pytanie_{num}"
+                        f" {subject} formuly"
+                    ),
                 }
             )
 
     return cards
 
 
-def clean_for_anki(text) -> str:
+def extract_question_and_answer(
+    filepath: str,
+) -> list[dict[str, str]]:
+    """Extract main question and key answer points from a markdown file."""
+    num, topic, title, main_question, content = _get_metadata(
+        filepath
+    )
+
+    subject_match = re.search(r"Przedmiot:\s*(\w+)", content)
+    subject = (
+        subject_match.group(1) if subject_match else "Ogólne"
+    )
+
+    cards: list[dict[str, str]] = []
+    cards.extend(
+        _extract_main_card(
+            content, main_question, subject, num, topic
+        )
+    )
+    cards.extend(
+        _extract_sub_cards(
+            content, title, subject, num, topic
+        )
+    )
+    cards.extend(
+        _extract_formula_cards(content, subject, num)
+    )
+
+    return cards
+
+
+def clean_for_anki(text: str) -> str:
     """Clean text for Anki import - escape special characters."""
     # Replace tabs with spaces
     text = text.replace("\t", "    ")
@@ -187,13 +279,13 @@ def main() -> None:
 
     # Process each file
     for md_file in sorted(odpowiedzi_dir.glob("*.md")):
-        print(f"Processing: {md_file.name}")
+        logger.info("Processing: %s", md_file.name)
         try:
             cards = extract_question_and_answer(md_file)
             all_cards.extend(cards)
-            print(f"  -> Extracted {len(cards)} cards")
-        except Exception as e:
-            print(f"  -> Error: {e}")
+            logger.info("  -> Extracted %d cards", len(cards))
+        except (ValueError, OSError) as e:
+            logger.info("  -> Error: %s", e)
 
     # Write Anki file with headers
     with Path(output_file).open("w", encoding="utf-8") as f:
@@ -211,13 +303,13 @@ def main() -> None:
             tags = card["tags"]
             f.write(f"{front}\t{back}\t{tags}\n")
 
-    print(f"\n✅ Created {len(all_cards)} flashcards")
-    print(f"📁 Output: {output_file}")
-    print("\nTo import into Anki:")
-    print("1. Open Anki → File → Import")
-    print("2. Select the .txt file")
-    print("3. Verify 'Allow HTML' is checked")
-    print("4. Click Import")
+    logger.info("Created %d flashcards", len(all_cards))
+    logger.info("Output: %s", output_file)
+    logger.info("To import into Anki:")
+    logger.info("1. Open Anki -> File -> Import")
+    logger.info("2. Select the .txt file")
+    logger.info("3. Verify 'Allow HTML' is checked")
+    logger.info("4. Click Import")
 
 
 if __name__ == "__main__":
diff --git a/python_pkg/praca_magisterska_video/generate_images/generate_anki_final.py b/python_pkg/praca_magisterska_video/generate_images/generate_anki_final.py
index 7435559..9d36391 100755
--- a/python_pkg/praca_magisterska_video/generate_images/generate_anki_final.py
+++ b/python_pkg/praca_magisterska_video/generate_images/generate_anki_final.py
@@ -6,11 +6,22 @@ Creates tab-separated file for Anki import with proper HTML formatting.
 
 from __future__ import annotations
 
+import logging
 from pathlib import Path
 import re
 
+logger = logging.getLogger(__name__)
 
-def clean_text(text) -> str:
+MIN_HEADER_LENGTH = 3
+MIN_MATCH_LENGTH = 10
+MIN_BODY_LENGTH = 50
+MIN_QA_LENGTH = 30
+MAX_CONTENT_LENGTH = 300
+MAX_ANSWER_LENGTH = 400
+MAX_COMPARISON_ITEMS = 6
+
+
+def clean_text(text: str) -> str:
     """Clean and format text for Anki."""
     if not text:
         return ""
@@ -28,7 +39,7 @@ def clean_text(text) -> str:
     return text.strip()
 
 
-def format_list(items, numbered=False) -> str:
+def format_list(items: list[str], *, numbered: bool = False) -> str:
     """Format a list of items as HTML."""
     if not items:
         return ""
@@ -43,119 +54,148 @@ def format_list(items, numbered=False) -> str:
     return html
 
 
-def extract_from_file(filepath) -> list[dict[str, str]]:
-    """Extract flashcard data from a markdown file."""
+def _get_file_metadata(
+    filepath: str,
+) -> tuple[str, str, str]:
+    """Extract metadata from file."""
     with Path(filepath).open(encoding="utf-8") as f:
         content = f.read()
 
-    cards = []
-
-    # Get file metadata
     filename = Path(filepath).name
     match = re.match(r"(\d+)-(.+)\.md", filename)
     num = match.group(1) if match else "00"
-    match.group(2).replace("-", "_") if match else "unknown"
 
-    # Extract subject
     subj_match = re.search(r"Przedmiot:\s*(\w+)", content)
     subject = subj_match.group(1) if subj_match else "Ogólne"
 
-    # Base tags
-    base_tags = f"egzamin_magisterski pyt{num} {subject}"
+    return num, subject, content
 
-    # =====================================================
-    # CARD TYPE 1: Main Exam Question
-    # =====================================================
+
+def _extract_main_question_card(
+    content: str, base_tags: str,
+) -> list[dict[str, str]]:
+    """Extract the main exam question card."""
     q_match = re.search(
-        r'## Pytanie\s*\n\s*\*\*["\']?(.+?)["\']?\*\*', content, re.DOTALL
+        r'## Pytanie\s*\n\s*\*\*["\']?(.+?)["\']?\*\*',
+        content,
+        re.DOTALL,
     )
-    if q_match:
-        main_q = re.sub(r"\s+", " ", q_match.group(1).strip())
+    if not q_match:
+        return []
 
-        # Extract key topics from main answer
-        answer_match = re.search(
-            r"## 📚 Odpowiedź główna\s*\n(.+?)(?=\n## [�🎯]|\n---\s*\n## |\Z)",
-            content,
-            re.DOTALL,
+    main_q = re.sub(r"\s+", " ", q_match.group(1).strip())
+    answer_match = re.search(
+        r"## 📚 Odpowiedź główna\s*\n(.+?)"
+        r"(?=\n## [📚🎯]|\n---\s*\n## |\Z)",
+        content,
+        re.DOTALL,
+    )
+    if not answer_match:
+        return []
+
+    answer_section = answer_match.group(1)
+    headers = re.findall(
+        r"^### (?:\d+\.\s*)?(.+)$",
+        answer_section,
+        re.MULTILINE,
+    )
+    headers = [
+        h.strip()
+        for h in headers
+        if len(h.strip()) > MIN_HEADER_LENGTH
+    ][:6]
+
+    if not headers:
+        return []
+
+    answer_html = (
+        "<b>Kluczowe zagadnienia:</b>" + format_list(headers)
+    )
+    return [
+        {
+            "front": clean_text(main_q),
+            "back": answer_html,
+            "tags": f"{base_tags} pytanie_glowne",
+        }
+    ]
+
+
+def _make_question_text(header: str) -> str:
+    """Generate a question from a section header."""
+    if "Definicja" in header or "Co to" in header:
+        return (
+            f"Co to jest:"
+            f" {header.replace('Definicja', '').strip()}?"
         )
-        if answer_match:
-            answer_section = answer_match.group(1)
-            # Get main headers
-            headers = re.findall(
-                r"^### (?:\d+\.\s*)?(.+)$", answer_section, re.MULTILINE
+    if "Charakterystyka" in header:
+        stripped = header.replace("Charakterystyka", "").strip()
+        return f"Scharakteryzuj: {stripped}"
+    if header.endswith("?"):
+        return header
+    return f"Omów: {header}"
+
+
+def _extract_body_parts(body: str) -> list[str]:
+    """Extract structured answer parts from a section body."""
+    answer_parts: list[str] = []
+
+    subheaders = re.findall(r"^#### (.+)$", body, re.MULTILINE)
+    if subheaders:
+        answer_parts.extend(subheaders[:4])
+
+    bullets = re.findall(
+        r"[-•]\s*\*\*([^*]+)\*\*[:\s-]*([^\n]+)?", body
+    )
+    for term, desc in bullets[:5]:
+        if desc:
+            answer_parts.append(
+                f"<b>{term}</b>: {desc.strip()}"
             )
-            headers = [h.strip() for h in headers if len(h.strip()) > 3][:6]
+        else:
+            answer_parts.append(f"<b>{term}</b>")
 
-            if headers:
-                answer_html = "<b>Kluczowe zagadnienia:</b>" + format_list(headers)
-                cards.append(
-                    {
-                        "front": clean_text(main_q),
-                        "back": answer_html,
-                        "tags": f"{base_tags} pytanie_glowne",
-                    }
-                )
+    if not answer_parts:
+        paras = [
+            p.strip()
+            for p in body.split("\n\n")
+            if p.strip()
+            and not p.strip().startswith("```")
+            and not p.strip().startswith("|")
+        ]
+        if paras:
+            first = paras[0]
+            if len(first) > MAX_CONTENT_LENGTH:
+                first = first[:MAX_CONTENT_LENGTH] + "..."
+            answer_parts.append(first)
 
-    # =====================================================
-    # CARD TYPE 2: Subsection Cards (detailed concepts)
-    # =====================================================
-    # Find all ### sections
+    return answer_parts
+
+
+def _extract_subsection_cards(
+    content: str, base_tags: str,
+) -> list[dict[str, str]]:
+    """Extract subsection detail cards."""
+    cards: list[dict[str, str]] = []
     sections = re.findall(
-        r"^### (?:\d+\.\s*)?(.+?)\n((?:(?!^###).)+)", content, re.MULTILINE | re.DOTALL
+        r"^### (?:\d+\.\s*)?(.+?)\n((?:(?!^###).)+)",
+        content,
+        re.MULTILINE | re.DOTALL,
     )
 
-    for header, body in sections:
-        header = header.strip()
-        body = body.strip()
+    for raw_header, raw_body in sections:
+        header = raw_header.strip()
+        body = raw_body.strip()
 
-        # Skip very short sections or example sections
-        if len(body) < 50 or header.lower().startswith("przykład"):
+        if (
+            len(body) < MIN_BODY_LENGTH
+            or header.lower().startswith("przykład")
+        ):
             continue
 
-        # Extract key information from body
-        answer_parts = []
-
-        # Look for #### sub-headers
-        subheaders = re.findall(r"^#### (.+)$", body, re.MULTILINE)
-        if subheaders:
-            answer_parts.extend(subheaders[:4])
-
-        # Look for bullet points with bold terms
-        bullets = re.findall(r"[-•]\s*\*\*([^*]+)\*\*[:\s-]*([^\n]+)?", body)
-        for term, desc in bullets[:5]:
-            if desc:
-                answer_parts.append(f"<b>{term}</b>: {desc.strip()}")
-            else:
-                answer_parts.append(f"<b>{term}</b>")
-
-        # If no structured content, get first paragraph
-        if not answer_parts:
-            paras = [
-                p.strip()
-                for p in body.split("\n\n")
-                if p.strip()
-                and not p.strip().startswith("```")
-                and not p.strip().startswith("|")
-            ]
-            if paras:
-                first = paras[0]
-                # Limit length
-                if len(first) > 300:
-                    first = first[:300] + "..."
-                answer_parts.append(first)
+        answer_parts = _extract_body_parts(body)
 
         if answer_parts:
-            # Determine card type
-            if "Definicja" in header or "Co to" in header:
-                q = f"Co to jest: {header.replace('Definicja', '').strip()}?"
-            elif "Charakterystyka" in header:
-                q = f"Scharakteryzuj: {header.replace('Charakterystyka', '').strip()}"
-            elif header.endswith("?"):
-                q = header
-            else:
-                q = f"Omów: {header}"
-
-            # Format answer
+            question = _make_question_text(header)
             if len(answer_parts) > 1:
                 answer_html = format_list(answer_parts)
             else:
@@ -163,15 +203,20 @@ def extract_from_file(filepath) -> list[dict[str, str]]:
 
             cards.append(
                 {
-                    "front": clean_text(q),
+                    "front": clean_text(question),
                     "back": answer_html,
                     "tags": f"{base_tags} szczegoly",
                 }
             )
 
-    # =====================================================
-    # CARD TYPE 3: Algorithms/Formulas
-    # =====================================================
+    return cards
+
+
+def _extract_algo_cards(
+    content: str, base_tags: str,
+) -> list[dict[str, str]]:
+    """Extract algorithm/formula cards."""
+    cards: list[dict[str, str]] = []
     algo_patterns = [
         r"#### Złożoność(?:\s+czasowa)?\s*\n(.+?)(?=\n####|\n###|\Z)",
         r"Złożoność:\s*\*\*([^*]+)\*\*",
@@ -179,85 +224,137 @@ def extract_from_file(filepath) -> list[dict[str, str]]:
 
     for pattern in algo_patterns:
         matches = re.findall(pattern, content, re.DOTALL)
-        for match in matches[:2]:
-            if len(match) > 10:
-                # Find context - which algorithm?
+        for algo_match in matches[:2]:
+            if len(algo_match) > MIN_MATCH_LENGTH:
                 algo_context = re.search(
-                    r"### (\d+\.\s*)?(.+?)(?=\n)", content[: content.find(match)]
+                    r"### (\d+\.\s*)?(.+?)(?=\n)",
+                    content[: content.find(algo_match)],
                 )
                 if algo_context:
                     algo_name = algo_context.group(2).strip()
                     cards.append(
                         {
-                            "front": f"Jaka jest złożoność algorytmu/metody: {algo_name}?",
-                            "back": clean_text(match.strip()[:200]),
+                            "front": (
+                                "Jaka jest złożoność"
+                                f" algorytmu/metody: {algo_name}?"
+                            ),
+                            "back": clean_text(
+                                algo_match.strip()[:200]
+                            ),
                             "tags": f"{base_tags} zlozonosc",
                         }
                     )
                     break
 
-    # =====================================================
-    # CARD TYPE 4: Comparisons (when file contains comparisons)
-    # =====================================================
+    return cards
+
+
+def _extract_comparison_cards(
+    content: str, base_tags: str, num: str,
+) -> list[dict[str, str]]:
+    """Extract comparison cards."""
     compare_match = re.search(
         r"## .*(Porównanie|Zestawienie|vs).*\n(.+?)(?=\n## |\Z)",
         content,
         re.DOTALL | re.IGNORECASE,
     )
-    if compare_match:
-        compare_section = compare_match.group(2)
-        # Extract comparison items
-        items = re.findall(r"\|\s*\*\*([^|*]+)\*\*\s*\|([^|]+)\|", compare_section)
-        if items:
-            comparison_html = "<table><tr><th>Aspekt</th><th>Wartość</th></tr>"
-            for aspect, value in items[:6]:
-                comparison_html += f"<tr><td>{clean_text(aspect)}</td><td>{clean_text(value)}</td></tr>"
-            comparison_html += "</table>"
+    if not compare_match:
+        return []
 
-            # Get comparison title
-            title_match = re.search(
-                r"## .*(Porównanie|Zestawienie).*?(\w+.*?(?:vs|i|oraz).*?\w+)",
-                compare_match.group(0),
-                re.IGNORECASE,
-            )
-            if title_match:
-                cards.append(
-                    {
-                        "front": f"Porównaj kluczowe różnice w temacie: pytanie {num}",
-                        "back": comparison_html,
-                        "tags": f"{base_tags} porownanie",
-                    }
-                )
+    compare_section = compare_match.group(2)
+    items = re.findall(
+        r"\|\s*\*\*([^|*]+)\*\*\s*\|([^|]+)\|",
+        compare_section,
+    )
+    if not items:
+        return []
 
-    # =====================================================
-    # CARD TYPE 5: Q&A from practice questions section
-    # =====================================================
-    qa_section = re.search(r"## 🎓 Pytania.*?\n(.+?)(?=\n## |\Z)", content, re.DOTALL)
-    if qa_section:
-        qa_content = qa_section.group(1)
-        # Find Q&A pairs
-        qas = re.findall(
-            r'### Q\d+:?\s*["\']?(.+?)["\']?\s*\n.*?Odpowiedź:\s*\n?(.+?)(?=\n### |\Z)',
-            qa_content,
-            re.DOTALL,
+    comparison_html = (
+        "<table><tr><th>Aspekt</th><th>Wartość</th></tr>"
+    )
+    for aspect, value in items[:MAX_COMPARISON_ITEMS]:
+        comparison_html += (
+            f"<tr><td>{clean_text(aspect)}</td>"
+            f"<td>{clean_text(value)}</td></tr>"
         )
-        for q, a in qas[:3]:
-            q = re.sub(r"\s+", " ", q.strip())
-            a = a.strip()
-            if len(a) > 30:
-                # Limit answer length
-                a_lines = a.split("\n")
-                a_short = "\n".join(a_lines[:5])
-                if len(a_short) > 400:
-                    a_short = a_short[:400] + "..."
+    comparison_html += "</table>"
 
-                cards.append(
-                    {
-                        "front": clean_text(q),
-                        "back": clean_text(a_short).replace("\n", "<br>"),
-                        "tags": f"{base_tags} egzamin_praktyka",
-                    }
-                )
+    title_match = re.search(
+        r"## .*(Porównanie|Zestawienie)"
+        r".*?(\w+.*?(?:vs|i|oraz).*?\w+)",
+        compare_match.group(0),
+        re.IGNORECASE,
+    )
+    if not title_match:
+        return []
+
+    return [
+        {
+            "front": (
+                "Porównaj kluczowe różnice"
+                f" w temacie: pytanie {num}"
+            ),
+            "back": comparison_html,
+            "tags": f"{base_tags} porownanie",
+        }
+    ]
+
+
+def _extract_qa_cards(
+    content: str, base_tags: str,
+) -> list[dict[str, str]]:
+    """Extract Q&A practice cards."""
+    cards: list[dict[str, str]] = []
+    qa_section = re.search(
+        r"## 🎓 Pytania.*?\n(.+?)(?=\n## |\Z)",
+        content,
+        re.DOTALL,
+    )
+    if not qa_section:
+        return cards
+
+    qa_content = qa_section.group(1)
+    qas = re.findall(
+        r"### Q\d+:?\s*[\"']?(.+?)[\"']?\s*\n"
+        r".*?Odpowiedź:\s*\n?(.+?)(?=\n### |\Z)",
+        qa_content,
+        re.DOTALL,
+    )
+    for raw_q, raw_a in qas[:3]:
+        question = re.sub(r"\s+", " ", raw_q.strip())
+        answer = raw_a.strip()
+        if len(answer) > MIN_QA_LENGTH:
+            a_lines = answer.split("\n")
+            a_short = "\n".join(a_lines[:5])
+            if len(a_short) > MAX_ANSWER_LENGTH:
+                a_short = a_short[:MAX_ANSWER_LENGTH] + "..."
+
+            cards.append(
+                {
+                    "front": clean_text(question),
+                    "back": clean_text(a_short).replace(
+                        "\n", "<br>"
+                    ),
+                    "tags": f"{base_tags} egzamin_praktyka",
+                }
+            )
+
+    return cards
+
+
+def extract_from_file(filepath: str) -> list[dict[str, str]]:
+    """Extract flashcard data from a markdown file."""
+    num, subject, content = _get_file_metadata(filepath)
+    base_tags = f"egzamin_magisterski pyt{num} {subject}"
+
+    cards: list[dict[str, str]] = []
+    cards.extend(_extract_main_question_card(content, base_tags))
+    cards.extend(_extract_subsection_cards(content, base_tags))
+    cards.extend(_extract_algo_cards(content, base_tags))
+    cards.extend(
+        _extract_comparison_cards(content, base_tags, num)
+    )
+    cards.extend(_extract_qa_cards(content, base_tags))
 
     return cards
 
@@ -272,13 +369,13 @@ def main() -> None:
     all_cards = []
 
     for md_file in sorted(odpowiedzi_dir.glob("*.md")):
-        print(f"Processing: {md_file.name}", end=" ")
+        logger.info("Processing: %s", md_file.name)
         try:
             cards = extract_from_file(md_file)
             all_cards.extend(cards)
-            print(f"→ {len(cards)} cards")
-        except Exception as e:
-            print(f"→ ERROR: {e}")
+            logger.info("  -> %d cards", len(cards))
+        except (ValueError, OSError) as e:
+            logger.info("  -> ERROR: %s", e)
 
     # Remove potential duplicates (same front)
     seen = set()
@@ -306,23 +403,25 @@ def main() -> None:
 
             f.write(f"{front}\t{back}\t{tags}\n")
 
-    print(f"\n{'=' * 50}")
-    print(f"✅ Generated {len(unique_cards)} unique flashcards")
-    print(f"📁 Saved to: {output_file}")
-    print(f"{'=' * 50}")
-    print("\n📋 IMPORT INSTRUCTIONS:")
-    print("─" * 40)
-    print("Anki Desktop:")
-    print("  1. File → Import")
-    print("  2. Select: anki_egzamin_magisterski.txt")
-    print("  3. Verify: Fields separated by Tab")
-    print("  4. Check: Allow HTML in fields")
-    print("  5. Click Import")
-    print()
-    print("AnkiWeb / AnkiDroid:")
-    print("  1. First import on Anki Desktop")
-    print("  2. Click Sync to upload to AnkiWeb")
-    print("  3. Sync on mobile to download")
+    logger.info("=" * 50)
+    logger.info(
+        "Generated %d unique flashcards", len(unique_cards)
+    )
+    logger.info("Saved to: %s", output_file)
+    logger.info("=" * 50)
+    logger.info("IMPORT INSTRUCTIONS:")
+    logger.info("-" * 40)
+    logger.info("Anki Desktop:")
+    logger.info("  1. File -> Import")
+    logger.info("  2. Select: anki_egzamin_magisterski.txt")
+    logger.info("  3. Verify: Fields separated by Tab")
+    logger.info("  4. Check: Allow HTML in fields")
+    logger.info("  5. Click Import")
+    logger.info("")
+    logger.info("AnkiWeb / AnkiDroid:")
+    logger.info("  1. First import on Anki Desktop")
+    logger.info("  2. Click Sync to upload to AnkiWeb")
+    logger.info("  3. Sync on mobile to download")
 
 
 if __name__ == "__main__":
diff --git a/python_pkg/praca_magisterska_video/generate_images/generate_anki_v2.py b/python_pkg/praca_magisterska_video/generate_images/generate_anki_v2.py
index c659fc2..fe4425b 100755
--- a/python_pkg/praca_magisterska_video/generate_images/generate_anki_v2.py
+++ b/python_pkg/praca_magisterska_video/generate_images/generate_anki_v2.py
@@ -6,12 +6,16 @@ Creates a tab-separated file compatible with Anki import.
 
 from __future__ import annotations
 
+import logging
 from pathlib import Path
 import re
-import traceback
+
+logger = logging.getLogger(__name__)
+
+MIN_HEADER_WORDS = 3
 
 
-def extract_main_question(content, filename) -> str:
+def extract_main_question(content: str, filename: str) -> str:
     """Extract the main exam question from the file."""
     # Extract the main question from ## Pytanie section
     question_match = re.search(
@@ -26,13 +30,13 @@ def extract_main_question(content, filename) -> str:
     return title_match.group(1) if title_match else filename
 
 
-def extract_subject(content) -> str:
+def extract_subject(content: str) -> str:
     """Extract the subject code."""
     subject_match = re.search(r"Przedmiot:\s*(\w+)", content)
     return subject_match.group(1) if subject_match else "Ogólne"
 
 
-def extract_key_points(content) -> list[str]:
+def extract_key_points(content: str) -> list[str]:
     """Extract key points from the main answer section."""
     points = []
 
@@ -51,14 +55,14 @@ def extract_key_points(content) -> list[str]:
     headers = re.findall(r"^### (.+)$", answer_text, re.MULTILINE)
     for h in headers[:6]:
         # Clean header
-        h = re.sub(r"\d+\.\s*", "", h).strip()
-        if h and len(h) > 3:
-            points.append(h)
+        cleaned = re.sub(r"\d+\.\s*", "", h).strip()
+        if cleaned and len(cleaned) > MIN_HEADER_WORDS:
+            points.append(cleaned)
 
     return points
 
 
-def extract_definitions(content) -> list[tuple[str, str]]:
+def extract_definitions(content: str) -> list[tuple[str, str]]:
     """Extract key definitions from the content."""
     definitions = []
 
@@ -66,9 +70,9 @@ def extract_definitions(content) -> list[tuple[str, str]]:
     pattern = r"\*\*([^*\n]+)\*\*\s*[--:]\s*([^*\n]{20,150})"
     matches = re.findall(pattern, content)
 
-    for term, definition in matches:
-        term = term.strip()
-        definition = definition.strip()
+    for raw_term, raw_def in matches:
+        term = raw_term.strip()
+        definition = raw_def.strip()
         # Filter out non-definition patterns
         if (
             term
@@ -81,7 +85,7 @@ def extract_definitions(content) -> list[tuple[str, str]]:
     return definitions[:5]
 
 
-def clean_html(text) -> str:
+def clean_html(text: str) -> str:
     """Convert markdown to HTML and clean for Anki."""
     if not text:
         return ""
@@ -101,7 +105,7 @@ def clean_html(text) -> str:
     return text.strip()
 
 
-def process_file(filepath) -> list[dict[str, str]]:
+def process_file(filepath: str) -> list[dict[str, str]]:
     """Process a single file and return flashcards."""
     with Path(filepath).open(encoding="utf-8") as f:
         content = f.read()
@@ -111,11 +115,7 @@ def process_file(filepath) -> list[dict[str, str]]:
     # Extract metadata
     filename = Path(filepath).name
     match = re.match(r"(\d+)-(.+)\.md", filename)
-    if match:
-        num = match.group(1)
-        match.group(2).replace("-", "_")
-    else:
-        num = "00"
+    num = match.group(1) if match else "00"
 
     subject = extract_subject(content)
     main_question = extract_main_question(content, filename)
@@ -156,14 +156,13 @@ def main() -> None:
 
     # Process each file
     for md_file in sorted(odpowiedzi_dir.glob("*.md")):
-        print(f"Processing: {md_file.name}")
+        logger.info("Processing: %s", md_file.name)
         try:
             cards = process_file(md_file)
             all_cards.extend(cards)
-            print(f"  -> {len(cards)} cards")
-        except Exception as e:
-            print(f"  -> Error: {e}")
-            traceback.print_exc()
+            logger.info("  -> %d cards", len(cards))
+        except (ValueError, OSError):
+            logger.exception("  -> Error processing file")
 
     # Write Anki-compatible file
     with Path(output_file).open("w", encoding="utf-8") as f:
@@ -186,16 +185,22 @@ def main() -> None:
 
             f.write(f"{front}\t{back}\t{tags}\n")
 
-    print(f"\n✅ Created {len(all_cards)} flashcards")
-    print(f"📁 Output: {output_file}")
-    print("\n=== Import Instructions ===")
-    print("1. Open Anki desktop → File → Import")
-    print("2. Select: anki_egzamin_magisterski.txt")
-    print("3. Set 'Fields separated by: Tab'")
-    print("4. Check 'Allow HTML in fields'")
-    print("5. Map: Field 1 → Front, Field 2 → Back, Field 3 → Tags")
-    print("6. Click Import")
-    print("\nFor AnkiWeb/AnkiDroid: Sync after importing on desktop")
+    logger.info("Created %d flashcards", len(all_cards))
+    logger.info("Output: %s", output_file)
+    logger.info("=== Import Instructions ===")
+    logger.info("1. Open Anki desktop -> File -> Import")
+    logger.info("2. Select: anki_egzamin_magisterski.txt")
+    logger.info("3. Set 'Fields separated by: Tab'")
+    logger.info("4. Check 'Allow HTML in fields'")
+    logger.info(
+        "5. Map: Field 1 -> Front, Field 2 -> Back,"
+        " Field 3 -> Tags"
+    )
+    logger.info("6. Click Import")
+    logger.info(
+        "For AnkiWeb/AnkiDroid:"
+        " Sync after importing on desktop"
+    )
 
 
 if __name__ == "__main__":
diff --git a/python_pkg/praca_magisterska_video/generate_images/generate_anki_v3.py b/python_pkg/praca_magisterska_video/generate_images/generate_anki_v3.py
index 148729c..f86effd 100755
--- a/python_pkg/praca_magisterska_video/generate_images/generate_anki_v3.py
+++ b/python_pkg/praca_magisterska_video/generate_images/generate_anki_v3.py
@@ -3,11 +3,18 @@
 
 from __future__ import annotations
 
+import logging
 from pathlib import Path
 import re
 
+logger = logging.getLogger(__name__)
 
-def clean_text(text) -> str:
+MIN_PARA_LENGTH = 20
+MAX_PARA_LENGTH = 400
+MIN_BODY_LENGTH = 80
+
+
+def clean_text(text: str) -> str:
     """Clean text for Anki."""
     if not text:
         return ""
@@ -19,7 +26,7 @@ def clean_text(text) -> str:
     return text.strip()
 
 
-def extract_real_answer(content, section_name) -> str | None:
+def extract_real_answer(content: str, section_name: str) -> str | None:
     """Extract actual content from a section, not just headers."""
     # Find the section
     pattern = rf"### (?:\d+\.\s*)?{re.escape(section_name)}\s*\n((?:(?!^### ).)+)"
@@ -52,19 +59,21 @@ def extract_real_answer(content, section_name) -> str | None:
             for p in body.split("\n\n")
             if p.strip() and not p.startswith("```") and not p.startswith("|")
         ]
-        for p in paras[:2]:
-            if len(p) > 20 and len(p) < 400:
-                lines.append(p)
+        lines.extend(
+            p for p in paras[:2]
+            if len(p) > MIN_PARA_LENGTH and len(p) < MAX_PARA_LENGTH
+        )
 
     return "<br>".join(lines[:6]) if lines else None
 
 
-def extract_cards(filepath) -> list[dict[str, str]]:
-    """Extract flashcards from a file."""
+def _read_file_metadata(
+    filepath: str | Path,
+) -> tuple[str, str, str | None]:
+    """Read file and extract metadata."""
     with Path(filepath).open(encoding="utf-8") as f:
         content = f.read()
 
-    cards = []
     filename = Path(filepath).name
     match = re.match(r"(\d+)-(.+)\.md", filename)
     num = match.group(1) if match else "00"
@@ -73,182 +82,228 @@ def extract_cards(filepath) -> list[dict[str, str]]:
     subject = subj_match.group(1) if subj_match else "Ogólne"
     base_tags = f"egzamin_magisterski pyt{num} {subject}"
 
-    # Get main question
     q_match = re.search(
-        r'## Pytanie\s*\n\s*\*\*["\']?(.+?)["\']?\*\*', content, re.DOTALL
+        r'## Pytanie\s*\n\s*\*\*["\']?(.+?)["\']?\*\*',
+        content,
+        re.DOTALL,
+    )
+    main_question = (
+        re.sub(r"\s+", " ", q_match.group(1).strip()) if q_match else None
     )
-    main_question = re.sub(r"\s+", " ", q_match.group(1).strip()) if q_match else None
 
-    # ===============================================
-    # MAIN CARD: Question with REAL answer summary
-    # ===============================================
-    if main_question:
-        # Build a real answer from the main sections
-        answer_parts = []
+    return content, base_tags, main_question
 
-        # For automata question - extract key facts about each automaton
-        if "automat" in main_question.lower() or "maszyn" in main_question.lower():
-            # FA
-            fa_match = re.search(
-                r"Automat Skończony.*?Rozpoznawana klasa języków\s*\n\s*\*\*([^*]+)\*\*",
-                content,
-                re.DOTALL,
+
+def _extract_automata_facts(content: str) -> list[str]:
+    """Extract automata-specific facts."""
+    parts: list[str] = []
+    automata = [
+        ("Automat Skończony", "FA"),
+        ("Automat ze Stosem", "PDA"),
+        ("Maszyna Turinga", "TM"),
+    ]
+    for name, abbrev in automata:
+        pattern = (
+            rf"{name}.*?Rozpoznawana klasa języków"
+            r"\s*\n\s*\*\*([^*]+)\*\*"
+        )
+        match = re.search(pattern, content, re.DOTALL)
+        if match:
+            parts.append(
+                f"<b>{name} ({abbrev})</b>: "
+                f"{match.group(1).strip()}"
             )
-            if fa_match:
-                answer_parts.append(
-                    f"<b>Automat Skończony (FA)</b>: {fa_match.group(1).strip()}"
-                )
+    return parts
 
-            # PDA
-            pda_match = re.search(
-                r"Automat ze Stosem.*?Rozpoznawana klasa języków\s*\n\s*\*\*([^*]+)\*\*",
-                content,
-                re.DOTALL,
-            )
-            if pda_match:
-                answer_parts.append(
-                    f"<b>Automat ze Stosem (PDA)</b>: {pda_match.group(1).strip()}"
-                )
 
-            # TM
-            tm_match = re.search(
-                r"Maszyna Turinga.*?Rozpoznawana klasa języków\s*\n\s*\*\*([^*]+)\*\*",
-                content,
-                re.DOTALL,
-            )
-            if tm_match:
-                answer_parts.append(
-                    f"<b>Maszyna Turinga (TM)</b>: {tm_match.group(1).strip()}"
-                )
+def _extract_generic_facts(content: str) -> list[str]:
+    """Extract generic definitions and summaries."""
+    parts: list[str] = []
+    key_patterns = [
+        r"#### Definicja\s*\n([^\n#]+)",
+        r"#### Charakterystyka\s*\n([^\n#]+)",
+        r"\*\*Definicja[:\s]*\*\*\s*([^\n]+)",
+    ]
+    for pattern in key_patterns:
+        parts.extend(
+            found.strip()
+            for found in re.findall(pattern, content)[:3]
+            if len(found) > MIN_PARA_LENGTH
+        )
+    return parts
 
-        # Generic extraction if specific didn't work
-        if not answer_parts:
-            # Look for key definitions/summaries
-            key_patterns = [
-                r"#### Definicja\s*\n([^\n#]+)",
-                r"#### Charakterystyka\s*\n([^\n#]+)",
-                r"\*\*Definicja[:\s]*\*\*\s*([^\n]+)",
-            ]
-            for pattern in key_patterns:
-                for match in re.findall(pattern, content)[:3]:
-                    if len(match) > 20:
-                        answer_parts.append(match.strip())
 
-        # Still nothing? Get first substantive paragraph from main answer
-        if not answer_parts:
-            main_answer = re.search(
-                r"## 📚 Odpowiedź główna\s*\n(.+?)(?=\n## |\Z)", content, re.DOTALL
-            )
-            if main_answer:
-                # Skip headers, get actual content
-                text = main_answer.group(1)
-                paras = re.findall(r"\n\n([^#\n][^\n]{50,300})", text)
-                answer_parts = paras[:3]
+def _extract_first_paragraphs(content: str) -> list[str]:
+    """Extract first substantive paragraphs from main answer."""
+    main_answer = re.search(
+        r"## 📚 Odpowiedź główna\s*\n(.+?)(?=\n## |\Z)",
+        content,
+        re.DOTALL,
+    )
+    if not main_answer:
+        return []
+    text = main_answer.group(1)
+    paras = re.findall(r"\n\n([^#\n][^\n]{50,300})", text)
+    return paras[:3]
 
-        if answer_parts:
-            answer = "<br><br>".join([clean_text(p) for p in answer_parts])
-            cards.append(
-                {
-                    "front": clean_text(main_question),
-                    "back": answer,
-                    "tags": f"{base_tags} pytanie_glowne",
-                }
+
+def _build_main_card(
+    content: str,
+    main_question: str | None,
+    base_tags: str,
+) -> dict[str, str] | None:
+    """Build the main question card."""
+    if not main_question:
+        return None
+
+    answer_parts: list[str] = []
+    if (
+        "automat" in main_question.lower()
+        or "maszyn" in main_question.lower()
+    ):
+        answer_parts = _extract_automata_facts(content)
+
+    if not answer_parts:
+        answer_parts = _extract_generic_facts(content)
+
+    if not answer_parts:
+        answer_parts = _extract_first_paragraphs(content)
+
+    if not answer_parts:
+        return None
+
+    answer = "<br><br>".join(
+        clean_text(p) for p in answer_parts
+    )
+    return {
+        "front": clean_text(main_question),
+        "back": answer,
+        "tags": f"{base_tags} pytanie_glowne",
+    }
+
+
+def _extract_section_content(body: str) -> list[str]:
+    """Extract content lines from a section body."""
+    answer_lines: list[str] = []
+
+    def_match = re.search(
+        r"#### Definicja[^\n]*\n([^\n#]+(?:\n[^\n#]+)?)", body,
+    )
+    if def_match:
+        answer_lines.append(def_match.group(1).strip())
+
+    char_match = re.search(
+        r"#### Charakterystyka\s*\n((?:[-•][^\n]+\n?)+)", body,
+    )
+    if char_match:
+        bullets = re.findall(
+            r"[-•]\s*\*\*([^*]+)\*\*[:\s]*([^\n]*)",
+            char_match.group(1),
+        )
+        for term, desc in bullets[:4]:
+            answer_lines.append(
+                f"• <b>{term}</b>: {desc.strip()}"
+                if desc
+                else f"• <b>{term}</b>"
             )
 
-    # ===============================================
-    # CONCEPT CARDS: Specific topics with real content
-    # ===============================================
-    # Find all ### sections and extract their actual content
+    if not answer_lines:
+        bullets = re.findall(
+            r"[-•]\s*\*\*([^*]+)\*\*[:\s]*([^\n]*)", body,
+        )
+        for term, desc in bullets[:5]:
+            answer_lines.append(
+                f"• <b>{term}</b>: {desc.strip()}"
+                if desc
+                else f"• <b>{term}</b>"
+            )
+
+    if not answer_lines:
+        first_para = re.search(
+            r"^([^#\n\-•|`][^\n]{30,250})", body, re.MULTILINE,
+        )
+        if first_para:
+            answer_lines.append(first_para.group(1))
+
+    return answer_lines
+
+
+def _build_concept_cards(
+    content: str, base_tags: str,
+) -> list[dict[str, str]]:
+    """Build concept cards from ### sections."""
+    cards: list[dict[str, str]] = []
     sections = re.findall(
         r"^### (?:\d+\.\s*)?([^\n]+)\n((?:(?!^### ).)*)",
         content,
         re.MULTILINE | re.DOTALL,
     )
 
-    for header, body in sections:
-        header = header.strip()
-        body = body.strip()
+    for raw_header, raw_body in sections:
+        header = raw_header.strip()
+        body = raw_body.strip()
 
-        # Skip short sections, mnemonics, examples
         if (
-            len(body) < 80
+            len(body) < MIN_BODY_LENGTH
             or "Przykład" in header
             or "Mnemonic" in header
             or '"' in header
         ):
             continue
 
-        # Extract real content
-        answer_lines = []
-
-        # Get definition if present
-        def_match = re.search(r"#### Definicja[^\n]*\n([^\n#]+(?:\n[^\n#]+)?)", body)
-        if def_match:
-            answer_lines.append(def_match.group(1).strip())
-
-        # Get characterization
-        char_match = re.search(r"#### Charakterystyka\s*\n((?:[-•][^\n]+\n?)+)", body)
-        if char_match:
-            bullets = re.findall(
-                r"[-•]\s*\*\*([^*]+)\*\*[:\s]*([^\n]*)", char_match.group(1)
-            )
-            for term, desc in bullets[:4]:
-                answer_lines.append(
-                    f"• <b>{term}</b>: {desc.strip()}" if desc else f"• <b>{term}</b>"
-                )
-
-        # Get bullet points if no structured content yet
+        answer_lines = _extract_section_content(body)
         if not answer_lines:
-            bullets = re.findall(r"[-•]\s*\*\*([^*]+)\*\*[:\s]*([^\n]*)", body)
-            for term, desc in bullets[:5]:
-                answer_lines.append(
-                    f"• <b>{term}</b>: {desc.strip()}" if desc else f"• <b>{term}</b>"
-                )
+            continue
 
-        # Get first paragraph if still nothing
-        if not answer_lines:
-            first_para = re.search(r"^([^#\n\-•|`][^\n]{30,250})", body, re.MULTILINE)
-            if first_para:
-                answer_lines.append(first_para.group(1))
+        question = (
+            header if header.endswith("?") else f"Wyjaśnij: {header}"
+        )
+        answer = "<br>".join(
+            clean_text(line) for line in answer_lines
+        )
+        cards.append(
+            {
+                "front": clean_text(question),
+                "back": answer,
+                "tags": f"{base_tags} szczegoly",
+            }
+        )
 
-        if answer_lines:
-            question = f"Wyjaśnij: {header}" if not header.endswith("?") else header
-            answer = "<br>".join([clean_text(l) for l in answer_lines])
+    return cards
 
-            cards.append(
-                {
-                    "front": clean_text(question),
-                    "back": answer,
-                    "tags": f"{base_tags} szczegoly",
-                }
-            )
 
-    # ===============================================
-    # Q&A CARDS: From practice questions section
-    # ===============================================
+def _build_qa_cards(
+    content: str, base_tags: str,
+) -> list[dict[str, str]]:
+    """Build Q&A practice cards."""
+    cards: list[dict[str, str]] = []
     qa_matches = re.findall(
-        r'### Q\d+:\s*["\']?([^"\'?\n]+)\?*["\']?\s*\n.*?Odpowiedź:\s*\n(.+?)(?=\n### |\n## |\Z)',
+        r'### Q\d+:\s*["\']?([^"\'?\n]+)\?*["\']?\s*\n'
+        r".*?Odpowiedź:\s*\n(.+?)(?=\n### |\n## |\Z)",
         content,
         re.DOTALL,
     )
 
-    for question, answer in qa_matches[:5]:
-        question = question.strip()
-        answer = answer.strip()
+    for raw_question, raw_answer in qa_matches[:5]:
+        question = raw_question.strip()
+        answer_text = raw_answer.strip()
 
-        # Clean up answer - get first meaningful part
-        answer_lines = answer.split("\n")
-        clean_answer = []
-        for line in answer_lines[:6]:
-            line = line.strip()
-            if line and not line.startswith("```") and not line.startswith("|"):
-                clean_answer.append(line)
+        answer_lines = answer_text.split("\n")
+        clean_answer = [
+            stripped
+            for raw_line in answer_lines[:6]
+            if (stripped := raw_line.strip())
+            and not stripped.startswith("```")
+            and not stripped.startswith("|")
+        ]
 
         if clean_answer:
             cards.append(
                 {
                     "front": clean_text(question + "?"),
-                    "back": "<br>".join([clean_text(l) for l in clean_answer]),
+                    "back": "<br>".join(
+                        clean_text(line) for line in clean_answer
+                    ),
                     "tags": f"{base_tags} qa",
                 }
             )
@@ -256,6 +311,20 @@ def extract_cards(filepath) -> list[dict[str, str]]:
     return cards
 
 
+def extract_cards(filepath: str | Path) -> list[dict[str, str]]:
+    """Extract flashcards from a file."""
+    content, base_tags, main_question = _read_file_metadata(filepath)
+
+    cards: list[dict[str, str]] = []
+    main_card = _build_main_card(content, main_question, base_tags)
+    if main_card:
+        cards.append(main_card)
+
+    cards.extend(_build_concept_cards(content, base_tags))
+    cards.extend(_build_qa_cards(content, base_tags))
+    return cards
+
+
 def main() -> None:
     """Main."""
     odpowiedzi_dir = Path("/home/kuchy/praca_magisterska/pytania/odpowiedzi")
@@ -266,13 +335,13 @@ def main() -> None:
     all_cards = []
 
     for md_file in sorted(odpowiedzi_dir.glob("*.md")):
-        print(f"Processing: {md_file.name}", end=" ")
+        logger.info("Processing: %s", md_file.name)
         try:
             cards = extract_cards(md_file)
             all_cards.extend(cards)
-            print(f"→ {len(cards)} cards")
-        except Exception as e:
-            print(f"→ ERROR: {e}")
+            logger.info("  -> %d cards", len(cards))
+        except (ValueError, OSError):
+            logger.exception("  -> Error processing file")
 
     # Remove duplicates
     seen = set()
@@ -299,8 +368,12 @@ def main() -> None:
             tags = card["tags"]
             f.write(f"{front}\t{back}\t{tags}\n")
 
-    print(f"\n✅ Generated {len(unique_cards)} flashcards")
-    print(f"📁 Output: {output_file}")
+    logger.info(
+        "Generated %d unique cards from %d total",
+        len(unique_cards),
+        len(all_cards),
+    )
+    logger.info("Output: %s", output_file)
 
 
 if __name__ == "__main__":
diff --git a/python_pkg/praca_magisterska_video/generate_images/generate_automata_diagrams.py b/python_pkg/praca_magisterska_video/generate_images/generate_automata_diagrams.py
index c07f7ba..54353f8 100755
--- a/python_pkg/praca_magisterska_video/generate_images/generate_automata_diagrams.py
+++ b/python_pkg/praca_magisterska_video/generate_images/generate_automata_diagrams.py
@@ -9,14 +9,25 @@
 All: A4-compatible, B&W, 300 DPI, laser-printer-friendly.
 """
 
+from __future__ import annotations
+
+from dataclasses import dataclass
+import logging
+from pathlib import Path
+from typing import TYPE_CHECKING
+
 import matplotlib as mpl
 
 mpl.use("Agg")
-from pathlib import Path
 
 import matplotlib.patches as mpatches
 import matplotlib.pyplot as plt
 
+if TYPE_CHECKING:
+    from matplotlib.axes import Axes
+
+logger = logging.getLogger(__name__)
+
 DPI = 300
 BG = "white"
 LN = "black"
@@ -36,26 +47,82 @@ LIGHT_RED = "#F8D7DA"
 LIGHT_BLUE = "#D6EAF8"
 LIGHT_YELLOW = "#FFF9C4"
 
+INNER_RATIO = 0.82
+ARROW_OFFSET = 0.4
+LOOP_RAD = 1.8
+LOOP_OFFSET = 0.12
+LOOP_LABEL_OFFSET = 0.35
+MUTATION_SCALE = 12
+HEAD_MARKER_FONTSIZE = 8
+
+
+@dataclass(frozen=True)
+class StateStyle:
+    """Optional styling for automaton state circles."""
+
+    accepting: bool = False
+    initial: bool = False
+    fillcolor: str = "white"
+    fontsize: float = FS
+
+
+@dataclass(frozen=True)
+class ArrowStyle:
+    """Optional styling for curved arrows."""
+
+    connectionstyle: str = "arc3,rad=0.3"
+    fontsize: float = FS_SMALL
+    label_offset: tuple[float, float] = (0, 0)
+
+
+@dataclass(frozen=True)
+class LoopStyle:
+    """Optional styling for self-loops."""
+
+    direction: str = "top"
+    fontsize: float = FS_SMALL
+
 
 def draw_state_circle(
-    ax, x, y, r, label, accepting=False, initial=False, fillcolor="white", fontsize=FS
+    ax: Axes,
+    pos: tuple[float, float],
+    r: float,
+    label: str,
+    style: StateStyle | None = None,
 ) -> None:
     """Draw an automaton state circle."""
+    s = style or StateStyle()
+    x, y = pos
     circle = plt.Circle(
-        (x, y), r, fill=True, facecolor=fillcolor, edgecolor=LN, linewidth=1.5, zorder=3
+        (x, y),
+        r,
+        fill=True,
+        facecolor=s.fillcolor,
+        edgecolor=LN,
+        linewidth=1.5,
+        zorder=3,
     )
     ax.add_patch(circle)
-    if accepting:
+    if s.accepting:
         inner = plt.Circle(
-            (x, y), r * 0.82, fill=False, edgecolor=LN, linewidth=1.2, zorder=3
+            (x, y),
+            r * INNER_RATIO,
+            fill=False,
+            edgecolor=LN,
+            linewidth=1.2,
+            zorder=3,
         )
         ax.add_patch(inner)
-    if initial:
+    if s.initial:
         ax.annotate(
             "",
             xy=(x - r, y),
-            xytext=(x - r - 0.4, y),
-            arrowprops={"arrowstyle": "->", "color": LN, "lw": 1.5},
+            xytext=(x - r - ARROW_OFFSET, y),
+            arrowprops={
+                "arrowstyle": "->",
+                "color": LN,
+                "lw": 1.5,
+            },
             zorder=4,
         )
     ax.text(
@@ -64,25 +131,23 @@ def draw_state_circle(
         label,
         ha="center",
         va="center",
-        fontsize=fontsize,
+        fontsize=s.fontsize,
         fontweight="bold",
         zorder=5,
     )
 
 
 def draw_curved_arrow(
-    ax,
-    x1,
-    y1,
-    x2,
-    y2,
-    label,
-    _r=0.25,
-    connectionstyle="arc3,rad=0.3",
-    fontsize=FS_SMALL,
-    label_offset=(0, 0),
+    ax: Axes,
+    start: tuple[float, float],
+    end: tuple[float, float],
+    label: str,
+    style: ArrowStyle | None = None,
 ) -> None:
     """Draw a curved arrow between points with label."""
+    s = style or ArrowStyle()
+    x1, y1 = start
+    x2, y2 = end
     ax.annotate(
         "",
         xy=(x2, y2),
@@ -91,19 +156,19 @@ def draw_curved_arrow(
             "arrowstyle": "->",
             "color": LN,
             "lw": 1.2,
-            "connectionstyle": connectionstyle,
+            "connectionstyle": s.connectionstyle,
         },
         zorder=2,
     )
-    mx = (x1 + x2) / 2 + label_offset[0]
-    my = (y1 + y2) / 2 + label_offset[1]
+    mx = (x1 + x2) / 2 + s.label_offset[0]
+    my = (y1 + y2) / 2 + s.label_offset[1]
     ax.text(
         mx,
         my,
         label,
         ha="center",
         va="center",
-        fontsize=fontsize,
+        fontsize=s.fontsize,
         fontstyle="italic",
         zorder=5,
         bbox={
@@ -115,15 +180,23 @@ def draw_curved_arrow(
     )
 
 
-def draw_self_loop(ax, x, y, r, label, direction="top", fontsize=FS_SMALL) -> None:
+def draw_self_loop(
+    ax: Axes,
+    pos: tuple[float, float],
+    r: float,
+    label: str,
+    style: LoopStyle | None = None,
+) -> None:
     """Draw a self-loop on a state."""
-    if direction == "top":
+    s = style or LoopStyle()
+    x, y = pos
+    if s.direction == "top":
         loop = mpatches.FancyArrowPatch(
-            (x - 0.12, y + r),
-            (x + 0.12, y + r),
-            connectionstyle="arc3,rad=-1.8",
+            (x - LOOP_OFFSET, y + r),
+            (x + LOOP_OFFSET, y + r),
+            connectionstyle=f"arc3,rad=-{LOOP_RAD}",
             arrowstyle="->",
-            mutation_scale=12,
+            mutation_scale=MUTATION_SCALE,
             lw=1.2,
             color=LN,
             zorder=2,
@@ -131,21 +204,21 @@ def draw_self_loop(ax, x, y, r, label, direction="top", fontsize=FS_SMALL) -> No
         ax.add_patch(loop)
         ax.text(
             x,
-            y + r + 0.35,
+            y + r + LOOP_LABEL_OFFSET,
             label,
             ha="center",
             va="center",
-            fontsize=fontsize,
+            fontsize=s.fontsize,
             fontstyle="italic",
             zorder=5,
         )
-    elif direction == "bottom":
+    elif s.direction == "bottom":
         loop = mpatches.FancyArrowPatch(
-            (x - 0.12, y - r),
-            (x + 0.12, y - r),
-            connectionstyle="arc3,rad=1.8",
+            (x - LOOP_OFFSET, y - r),
+            (x + LOOP_OFFSET, y - r),
+            connectionstyle=f"arc3,rad={LOOP_RAD}",
             arrowstyle="->",
-            mutation_scale=12,
+            mutation_scale=MUTATION_SCALE,
             lw=1.2,
             color=LN,
             zorder=2,
@@ -153,11 +226,11 @@ def draw_self_loop(ax, x, y, r, label, direction="top", fontsize=FS_SMALL) -> No
         ax.add_patch(loop)
         ax.text(
             x,
-            y - r - 0.35,
+            y - r - LOOP_LABEL_OFFSET,
             label,
             ha="center",
             va="center",
-            fontsize=fontsize,
+            fontsize=s.fontsize,
             fontstyle="italic",
             zorder=5,
         )
@@ -169,7 +242,10 @@ def draw_self_loop(ax, x, y, r, label, direction="top", fontsize=FS_SMALL) -> No
 def draw_fa_recognition() -> None:
     """FA state diagram + step-by-step trace for 'baab'."""
     _fig, axes = plt.subplots(
-        1, 2, figsize=(11.69, 4), gridspec_kw={"width_ratios": [1, 1.3]}
+        1,
+        2,
+        figsize=(11.69, 4),
+        gridspec_kw={"width_ratios": [1, 1.3]},
     )
 
     # --- Left: State diagram ---
@@ -179,69 +255,99 @@ def draw_fa_recognition() -> None:
     ax.set_aspect("equal")
     ax.axis("off")
     ax.set_title(
-        'DFA — diagram stanów\nL = {słowa nad {a,b} kończące się na "ab"}',
+        "DFA — diagram stanów\n"
+        'L = {słowa nad {a,b} kończące się na "ab"}',
         fontsize=FS_TITLE,
         fontweight="bold",
         pad=10,
     )
 
-    R = 0.35
-    # States positions
-    states = {"q₀": (0.8, 0.5), "q₁": (2.8, 0.5), "q₂": (4.8, 0.5)}
+    state_r = 0.35
+    states = {
+        "q₀": (0.8, 0.5),
+        "q₁": (2.8, 0.5),
+        "q₂": (4.8, 0.5),
+    }
 
-    draw_state_circle(ax, *states["q₀"], R, "q₀", initial=True)
-    draw_state_circle(ax, *states["q₁"], R, "q₁")
-    draw_state_circle(ax, *states["q₂"], R, "q₂", accepting=True, fillcolor=LIGHT_GREEN)
+    draw_state_circle(
+        ax,
+        states["q₀"],
+        state_r,
+        "q₀",
+        StateStyle(initial=True),
+    )
+    draw_state_circle(ax, states["q₁"], state_r, "q₁")
+    draw_state_circle(
+        ax,
+        states["q₂"],
+        state_r,
+        "q₂",
+        StateStyle(
+            accepting=True, fillcolor=LIGHT_GREEN
+        ),
+    )
 
     # Transitions
     # q₀ --a--> q₁
     draw_curved_arrow(
         ax,
-        states["q₀"][0] + R,
-        states["q₀"][1] + 0.05,
-        states["q₁"][0] - R,
-        states["q₁"][1] + 0.05,
+        (states["q₀"][0] + state_r, states["q₀"][1] + 0.05),
+        (states["q₁"][0] - state_r, states["q₁"][1] + 0.05),
         "a",
-        connectionstyle="arc3,rad=0.15",
-        label_offset=(0, 0.25),
+        ArrowStyle(
+            connectionstyle="arc3,rad=0.15",
+            label_offset=(0, 0.25),
+        ),
     )
     # q₁ --b--> q₂
     draw_curved_arrow(
         ax,
-        states["q₁"][0] + R,
-        states["q₁"][1] + 0.05,
-        states["q₂"][0] - R,
-        states["q₂"][1] + 0.05,
+        (states["q₁"][0] + state_r, states["q₁"][1] + 0.05),
+        (states["q₂"][0] - state_r, states["q₂"][1] + 0.05),
         "b",
-        connectionstyle="arc3,rad=0.15",
-        label_offset=(0, 0.25),
+        ArrowStyle(
+            connectionstyle="arc3,rad=0.15",
+            label_offset=(0, 0.25),
+        ),
     )
     # q₂ --a--> q₁
     draw_curved_arrow(
         ax,
-        states["q₂"][0] - R,
-        states["q₂"][1] - 0.05,
-        states["q₁"][0] + R,
-        states["q₁"][1] - 0.05,
+        (states["q₂"][0] - state_r, states["q₂"][1] - 0.05),
+        (states["q₁"][0] + state_r, states["q₁"][1] - 0.05),
         "a",
-        connectionstyle="arc3,rad=0.15",
-        label_offset=(0, -0.3),
+        ArrowStyle(
+            connectionstyle="arc3,rad=0.15",
+            label_offset=(0, -0.3),
+        ),
     )
     # q₂ --b--> q₀
     draw_curved_arrow(
         ax,
-        states["q₂"][0] - 0.2,
-        states["q₂"][1] - R,
-        states["q₀"][0] + 0.2,
-        states["q₀"][1] - R,
+        (states["q₂"][0] - 0.2, states["q₂"][1] - state_r),
+        (states["q₀"][0] + 0.2, states["q₀"][1] - state_r),
         "b",
-        connectionstyle="arc3,rad=0.4",
-        label_offset=(0, -0.4),
+        ArrowStyle(
+            connectionstyle="arc3,rad=0.4",
+            label_offset=(0, -0.4),
+        ),
     )
     # q₀ --b--> q₀ (self-loop)
-    draw_self_loop(ax, *states["q₀"], R, "b", direction="top")
+    draw_self_loop(
+        ax,
+        states["q₀"],
+        state_r,
+        "b",
+        LoopStyle(direction="top"),
+    )
     # q₁ --a--> q₁ (self-loop)
-    draw_self_loop(ax, *states["q₁"], R, "a", direction="top")
+    draw_self_loop(
+        ax,
+        states["q₁"],
+        state_r,
+        "a",
+        LoopStyle(direction="top"),
+    )
 
     # Legend
     ax.text(
@@ -251,18 +357,31 @@ def draw_fa_recognition() -> None:
         fontsize=FS_SMALL,
         ha="left",
         va="center",
-        bbox={"boxstyle": "round,pad=0.3", "facecolor": GRAY4, "edgecolor": GRAY3},
+        bbox={
+            "boxstyle": "round,pad=0.3",
+            "facecolor": GRAY4,
+            "edgecolor": GRAY3,
+        },
     )
 
     # --- Right: Step-by-step trace ---
     ax2 = axes[1]
     ax2.axis("off")
     ax2.set_title(
-        'Ślad wykonania — wejście: "baab"', fontsize=FS_TITLE, fontweight="bold", pad=10
+        'Ślad wykonania — wejście: "baab"',
+        fontsize=FS_TITLE,
+        fontweight="bold",
+        pad=10,
     )
 
     trace_data = [
-        ["Krok", "Czytam", "Stan przed", "Przejście", "Stan po"],
+        [
+            "Krok",
+            "Czytam",
+            "Stan przed",
+            "Przejście",
+            "Stan po",
+        ],
         ["—", "—", "q₀ (start)", "—", "q₀"],
         ["1", "b", "q₀", "δ(q₀, b) = q₀", "q₀"],
         ["2", "a", "q₀", "δ(q₀, a) = q₁", "q₁"],
@@ -277,7 +396,7 @@ def draw_fa_recognition() -> None:
         loc="center",
         bbox=[0.05, 0.15, 0.9, 0.75],
     )
-    table.auto_set_font_size(False)
+    table.auto_set_font_size(auto=False)
     table.set_fontsize(FS)
     for (row, _col), cell in table.get_celld().items():
         cell.set_edgecolor(GRAY3)
@@ -297,7 +416,11 @@ def draw_fa_recognition() -> None:
         fontsize=FS + 1,
         fontweight="bold",
         transform=ax2.transAxes,
-        bbox={"boxstyle": "round,pad=0.4", "facecolor": LIGHT_GREEN, "edgecolor": LN},
+        bbox={
+            "boxstyle": "round,pad=0.4",
+            "facecolor": LIGHT_GREEN,
+            "edgecolor": LN,
+        },
     )
 
     plt.tight_layout()
@@ -308,16 +431,19 @@ def draw_fa_recognition() -> None:
         facecolor=BG,
     )
     plt.close()
-    print("  ✓ fa_recognition_example.png")
+    logger.info("  ✓ fa_recognition_example.png")
 
 
 # ============================================================
 # 2. PDA Recognition Example — PDA for aⁿbⁿ
 # ============================================================
 def draw_pda_recognition() -> None:
-    """PDA state diagram + step-by-step trace with stack visualization for 'aabb'."""
+    """PDA state diagram + step-by-step trace with stack."""
     _fig, axes = plt.subplots(
-        1, 2, figsize=(11.69, 5.5), gridspec_kw={"width_ratios": [1, 1.4]}
+        1,
+        2,
+        figsize=(11.69, 5.5),
+        gridspec_kw={"width_ratios": [1, 1.4]},
     )
 
     # --- Left: State diagram ---
@@ -333,66 +459,107 @@ def draw_pda_recognition() -> None:
         pad=10,
     )
 
-    R = 0.38
-    states = {"q₀": (0.8, 0.5), "q₁": (2.8, 0.5), "q₂": (4.8, 0.5)}
+    state_r = 0.38
+    states = {
+        "q₀": (0.8, 0.5),
+        "q₁": (2.8, 0.5),
+        "q₂": (4.8, 0.5),
+    }
 
-    draw_state_circle(ax, *states["q₀"], R, "q₀", initial=True)
-    draw_state_circle(ax, *states["q₁"], R, "q₁")
-    draw_state_circle(ax, *states["q₂"], R, "q₂", accepting=True, fillcolor=LIGHT_GREEN)
+    draw_state_circle(
+        ax,
+        states["q₀"],
+        state_r,
+        "q₀",
+        StateStyle(initial=True),
+    )
+    draw_state_circle(ax, states["q₁"], state_r, "q₁")
+    draw_state_circle(
+        ax,
+        states["q₂"],
+        state_r,
+        "q₂",
+        StateStyle(
+            accepting=True, fillcolor=LIGHT_GREEN
+        ),
+    )
 
     # q₀ --b,A/ε--> q₁
     draw_curved_arrow(
         ax,
-        states["q₀"][0] + R,
-        states["q₀"][1],
-        states["q₁"][0] - R,
-        states["q₁"][1],
+        (states["q₀"][0] + state_r, states["q₀"][1]),
+        (states["q₁"][0] - state_r, states["q₁"][1]),
         "b, A → ε\n(pop A)",
-        connectionstyle="arc3,rad=0.0",
-        label_offset=(0, 0.4),
+        ArrowStyle(
+            connectionstyle="arc3,rad=0.0",
+            label_offset=(0, 0.4),
+        ),
     )
     # q₁ --ε,Z₀/Z₀--> q₂
     draw_curved_arrow(
         ax,
-        states["q₁"][0] + R,
-        states["q₁"][1],
-        states["q₂"][0] - R,
-        states["q₂"][1],
+        (states["q₁"][0] + state_r, states["q₁"][1]),
+        (states["q₂"][0] - state_r, states["q₂"][1]),
         "ε, Z₀ → Z₀\n(akceptuj)",
-        connectionstyle="arc3,rad=0.0",
-        label_offset=(0, 0.45),
+        ArrowStyle(
+            connectionstyle="arc3,rad=0.0",
+            label_offset=(0, 0.45),
+        ),
     )
     # q₀ self-loop: a, Z₀/AZ₀ and a, A/AA
     draw_self_loop(
-        ax, *states["q₀"], R, "a, Z₀ → AZ₀\na, A → AA\n(push A)", direction="top"
+        ax,
+        states["q₀"],
+        state_r,
+        "a, Z₀ → AZ₀\na, A → AA\n(push A)",
+        LoopStyle(direction="top"),
     )
     # q₁ self-loop: b, A/ε
-    draw_self_loop(ax, *states["q₁"], R, "b, A → ε\n(pop A)", direction="top")
+    draw_self_loop(
+        ax,
+        states["q₁"],
+        state_r,
+        "b, A → ε\n(pop A)",
+        LoopStyle(direction="top"),
+    )
 
     # Key explanation
     ax.text(
         0.3,
         -1.3,
-        "Notacja: symbol_wejścia, szczyt_stosu → nowy_szczyt\n"
-        "ε = brak symbolu (przejście spontaniczne lub pusty stos)",
+        "Notacja: symbol_wejścia, szczyt_stosu"
+        " → nowy_szczyt\n"
+        "ε = brak symbolu "
+        "(przejście spontaniczne lub pusty stos)",
         fontsize=FS_SMALL,
         ha="left",
         va="center",
-        bbox={"boxstyle": "round,pad=0.3", "facecolor": GRAY4, "edgecolor": GRAY3},
+        bbox={
+            "boxstyle": "round,pad=0.3",
+            "facecolor": GRAY4,
+            "edgecolor": GRAY3,
+        },
     )
 
     # --- Right: Step trace with stack ---
     ax2 = axes[1]
     ax2.axis("off")
     ax2.set_title(
-        'Ślad wykonania z wizualizacją stosu — wejście: "aabb"',
+        "Ślad wykonania z wizualizacją stosu"
+        ' — wejście: "aabb"',
         fontsize=FS_TITLE,
         fontweight="bold",
         pad=10,
     )
 
     trace_data = [
-        ["Krok", "Czytam", "Stan", "Stos (szczyt→)", "Operacja"],
+        [
+            "Krok",
+            "Czytam",
+            "Stan",
+            "Stos (szczyt→)",
+            "Operacja",
+        ],
         ["start", "—", "q₀", "[Z₀]", "—"],
         ["1", "a", "q₀", "[A, Z₀]", "push A"],
         ["2", "a", "q₀", "[A, A, Z₀]", "push A"],
@@ -416,7 +583,7 @@ def draw_pda_recognition() -> None:
         loc="center",
         bbox=[0.02, 0.08, 0.96, 0.82],
     )
-    table.auto_set_font_size(False)
+    table.auto_set_font_size(auto=False)
     table.set_fontsize(FS)
     for (row, _col), cell in table.get_celld().items():
         cell.set_edgecolor(GRAY3)
@@ -430,14 +597,20 @@ def draw_pda_recognition() -> None:
     ax2.text(
         0.5,
         0.0,
-        'Wynik: q₂ ∈ F, stos=[Z₀] → "aabb" AKCEPTOWANE ✓\n'
-        'Intuicja: 2x push A (za "aa") + 2x pop A (za "bb") = stos pusty = OK',
+        "Wynik: q₂ ∈ F, stos=[Z₀]"
+        ' → "aabb" AKCEPTOWANE ✓\n'
+        'Intuicja: 2x push A (za "aa") '
+        '+ 2x pop A (za "bb") = stos pusty = OK',
         ha="center",
         va="center",
         fontsize=FS,
         fontweight="bold",
         transform=ax2.transAxes,
-        bbox={"boxstyle": "round,pad=0.4", "facecolor": LIGHT_GREEN, "edgecolor": LN},
+        bbox={
+            "boxstyle": "round,pad=0.4",
+            "facecolor": LIGHT_GREEN,
+            "edgecolor": LN,
+        },
     )
 
     plt.tight_layout()
@@ -448,7 +621,7 @@ def draw_pda_recognition() -> None:
         facecolor=BG,
     )
     plt.close()
-    print("  ✓ pda_recognition_example.png")
+    logger.info("  ✓ pda_recognition_example.png")
 
 
 # ============================================================
@@ -468,16 +641,23 @@ def draw_lba_recognition() -> None:
         pad=10,
     )
 
-    CELL_W = 0.9
-    CELL_H = 0.7
-    TAPE_X0 = 1.5
-    HEAD_COLOR = "#FFD700"
+    cell_w = 0.9
+    cell_h = 0.7
+    tape_x0 = 1.5
+    head_color = "#FFD700"
 
-    def draw_tape(y, cells, head_pos, label, step_label="") -> None:
-        """Draw a tape row with cells, head position highlighted."""
+    def draw_tape(
+        tape_y: float,
+        cells: list[tuple[str, str]],
+        head_pos: int | None,
+        label: str,
+        *,
+        step_label: str = "",
+    ) -> None:
+        """Draw a tape row with cells, head highlighted."""
         ax.text(
             0.2,
-            y + CELL_H / 2,
+            tape_y + cell_h / 2,
             label,
             ha="right",
             va="center",
@@ -485,44 +665,53 @@ def draw_lba_recognition() -> None:
             fontweight="bold",
         )
         for i, (sym, color) in enumerate(cells):
-            x = TAPE_X0 + i * CELL_W
-            fc = HEAD_COLOR if i == head_pos else color
+            x = tape_x0 + i * cell_w
+            fc = head_color if i == head_pos else color
             rect = mpatches.FancyBboxPatch(
-                (x, y),
-                CELL_W,
-                CELL_H,
+                (x, tape_y),
+                cell_w,
+                cell_h,
                 boxstyle="round,pad=0.03",
                 lw=1.2,
                 edgecolor=LN,
                 facecolor=fc,
             )
             ax.add_patch(rect)
+            bold = (
+                "bold"
+                if sym in ("X", "Y", "Z")
+                else "normal"
+            )
             ax.text(
-                x + CELL_W / 2,
-                y + CELL_H / 2,
+                x + cell_w / 2,
+                tape_y + cell_h / 2,
                 sym,
                 ha="center",
                 va="center",
                 fontsize=FS + 2,
-                fontweight="bold" if sym in ("X", "Y", "Z") else "normal",
+                fontweight=bold,
                 family="monospace",
             )
         if head_pos is not None:
-            hx = TAPE_X0 + head_pos * CELL_W + CELL_W / 2
+            hx = (
+                tape_x0
+                + head_pos * cell_w
+                + cell_w / 2
+            )
             ax.annotate(
                 "▼",
-                xy=(hx, y + CELL_H),
-                xytext=(hx, y + CELL_H + 0.25),
+                xy=(hx, tape_y + cell_h),
+                xytext=(hx, tape_y + cell_h + 0.25),
                 ha="center",
                 va="bottom",
-                fontsize=8,
+                fontsize=HEAD_MARKER_FONTSIZE,
                 color="black",
             )
         if step_label:
-            sx = TAPE_X0 + 6 * CELL_W + 0.5
+            sx = tape_x0 + 6 * cell_w + 0.5
             ax.text(
                 sx,
-                y + CELL_H / 2,
+                tape_y + cell_h / 2,
                 step_label,
                 ha="left",
                 va="center",
@@ -534,54 +723,84 @@ def draw_lba_recognition() -> None:
                 },
             )
 
-    W = "white"
-    MK = GRAY1  # marked cell color
+    white = "white"
+    mk = GRAY1  # marked cell color
 
     # Row 1: Initial tape
-    y = 9.0
+    tape_y = 9.0
     draw_tape(
-        y,
-        [("a", W), ("a", W), ("b", W), ("b", W), ("c", W), ("c", W)],
+        tape_y,
+        [
+            ("a", white),
+            ("a", white),
+            ("b", white),
+            ("b", white),
+            ("c", white),
+            ("c", white),
+        ],
         0,
         "Początek",
-        "taśma = [a, a, b, b, c, c], głowica na 0",
+        step_label=(
+            "taśma = [a, a, b, b, c, c], głowica na 0"
+        ),
     )
 
     # Row 2: After marking first 'a'
-    y = 7.8
+    tape_y = 7.8
     draw_tape(
-        y,
-        [("X", MK), ("a", W), ("b", W), ("b", W), ("c", W), ("c", W)],
+        tape_y,
+        [
+            ("X", mk),
+            ("a", white),
+            ("b", white),
+            ("b", white),
+            ("c", white),
+            ("c", white),
+        ],
         1,
         "R1, krok 1",
-        "zaznacz a→X, szukaj b",
+        step_label="zaznacz a→X, szukaj b",
     )
 
     # Row 3: After marking first 'b'
-    y = 6.6
+    tape_y = 6.6
     draw_tape(
-        y,
-        [("X", MK), ("a", W), ("Y", MK), ("b", W), ("c", W), ("c", W)],
+        tape_y,
+        [
+            ("X", mk),
+            ("a", white),
+            ("Y", mk),
+            ("b", white),
+            ("c", white),
+            ("c", white),
+        ],
         3,
         "R1, krok 2",
-        "zaznacz b→Y, szukaj c",
+        step_label="zaznacz b→Y, szukaj c",
     )
 
     # Row 4: After marking first 'c'
-    y = 5.4
+    tape_y = 5.4
     draw_tape(
-        y,
-        [("X", MK), ("a", W), ("Y", MK), ("b", W), ("Z", MK), ("c", W)],
+        tape_y,
+        [
+            ("X", mk),
+            ("a", white),
+            ("Y", mk),
+            ("b", white),
+            ("Z", mk),
+            ("c", white),
+        ],
         0,
         "R1, krok 3",
-        "zaznacz c→Z, wróć na początek",
+        step_label="zaznacz c→Z, wróć na początek",
     )
 
     # Runda 2 header
-    y = 4.5
+    tape_y = 4.5
     ax.text(
-        TAPE_X0 + 3 * CELL_W,
-        y + 0.3,
+        tape_x0 + 3 * cell_w,
+        tape_y + 0.3,
         "═══ RUNDA 2 ═══",
         ha="center",
         va="center",
@@ -591,53 +810,81 @@ def draw_lba_recognition() -> None:
     )
 
     # Row 5: After marking second 'a'
-    y = 3.6
+    tape_y = 3.6
     draw_tape(
-        y,
-        [("X", MK), ("X", MK), ("Y", MK), ("b", W), ("Z", MK), ("c", W)],
+        tape_y,
+        [
+            ("X", mk),
+            ("X", mk),
+            ("Y", mk),
+            ("b", white),
+            ("Z", mk),
+            ("c", white),
+        ],
         2,
         "R2, krok 1",
-        "pomiń X, zaznacz a→X, szukaj b",
+        step_label="pomiń X, zaznacz a→X, szukaj b",
     )
 
     # Row 6: After marking second 'b'
-    y = 2.4
+    tape_y = 2.4
     draw_tape(
-        y,
-        [("X", MK), ("X", MK), ("Y", MK), ("Y", MK), ("Z", MK), ("c", W)],
+        tape_y,
+        [
+            ("X", mk),
+            ("X", mk),
+            ("Y", mk),
+            ("Y", mk),
+            ("Z", mk),
+            ("c", white),
+        ],
         4,
         "R2, krok 2",
-        "pomiń Y, zaznacz b→Y, szukaj c",
+        step_label="pomiń Y, zaznacz b→Y, szukaj c",
     )
 
     # Row 7: After marking second 'c'
-    y = 1.2
+    tape_y = 1.2
     draw_tape(
-        y,
-        [("X", MK), ("X", MK), ("Y", MK), ("Y", MK), ("Z", MK), ("Z", MK)],
+        tape_y,
+        [
+            ("X", mk),
+            ("X", mk),
+            ("Y", mk),
+            ("Y", mk),
+            ("Z", mk),
+            ("Z", mk),
+        ],
         None,
         "R2, krok 3",
-        "zaznacz c→Z, wróć na początek",
+        step_label="zaznacz c→Z, wróć na początek",
     )
 
     # Result
-    y = 0.0
+    tape_y = 0.0
     ax.text(
-        TAPE_X0 + 3 * CELL_W,
-        y + 0.3,
-        'Wszystko zaznaczone → q_acc → "aabbcc" AKCEPTOWANE ✓',
+        tape_x0 + 3 * cell_w,
+        tape_y + 0.3,
+        "Wszystko zaznaczone → q_acc"
+        ' → "aabbcc" AKCEPTOWANE ✓',
         ha="center",
         va="center",
         fontsize=FS + 1,
         fontweight="bold",
-        bbox={"boxstyle": "round,pad=0.4", "facecolor": LIGHT_GREEN, "edgecolor": LN},
+        bbox={
+            "boxstyle": "round,pad=0.4",
+            "facecolor": LIGHT_GREEN,
+            "edgecolor": LN,
+        },
     )
 
     # Key
     ax.text(
-        TAPE_X0 + 6 * CELL_W + 0.5,
-        y + 0.3,
-        'Ograniczenie LBA:\ngłowica ≤ 6 komórek\n(= |w| = |"aabbcc"|)',
+        tape_x0 + 6 * cell_w + 0.5,
+        tape_y + 0.3,
+        "Ograniczenie LBA:\n"
+        "głowica ≤ 6 komórek\n"
+        '(= |w| = |"aabbcc"|)',
         ha="left",
         va="center",
         fontsize=FS_SMALL,
@@ -656,36 +903,44 @@ def draw_lba_recognition() -> None:
         facecolor=BG,
     )
     plt.close()
-    print("  ✓ lba_recognition_example.png")
+    logger.info("  ✓ lba_recognition_example.png")
 
 
 # ============================================================
 # 4. TM Recognition Example — TM for 0ⁿ1ⁿ
 # ============================================================
 def draw_tm_recognition() -> None:
-    """TM tape visualization for 0ⁿ1ⁿ with infinite tape shown."""
+    """TM tape visualization for 0ⁿ1ⁿ with infinite tape."""
     _fig, ax = plt.subplots(1, 1, figsize=(11.69, 6.5))
     ax.set_xlim(-0.5, 13)
     ax.set_ylim(-1, 10.5)
     ax.axis("off")
     ax.set_title(
         "TM — rozpoznawanie 0ⁿ1ⁿ (n=2)\n"
-        "Strategia: zaznacz jedno 0 i jedno 1 w każdej rundzie",
+        "Strategia: zaznacz jedno 0 i jedno 1"
+        " w każdej rundzie",
         fontsize=FS_TITLE,
         fontweight="bold",
         pad=10,
     )
 
-    CELL_W = 0.9
-    CELL_H = 0.7
-    TAPE_X0 = 1.5
-    HEAD_COLOR = "#FFD700"
+    cell_w = 0.9
+    cell_h = 0.7
+    tape_x0 = 1.5
+    head_color = "#FFD700"
 
-    def draw_tape(y, cells, head_pos, label, step_label="") -> None:
+    def draw_tape(
+        tape_y: float,
+        cells: list[tuple[str, str]],
+        head_pos: int | None,
+        label: str,
+        *,
+        step_label: str = "",
+    ) -> None:
         """Draw tape."""
         ax.text(
             0.2,
-            y + CELL_H / 2,
+            tape_y + cell_h / 2,
             label,
             ha="right",
             va="center",
@@ -693,16 +948,16 @@ def draw_tm_recognition() -> None:
             fontweight="bold",
         )
         for i, (sym, color) in enumerate(cells):
-            x = TAPE_X0 + i * CELL_W
-            fc = HEAD_COLOR if i == head_pos else color
+            x = tape_x0 + i * cell_w
+            fc = head_color if i == head_pos else color
             lw = 1.2
             ls = "-"
             if sym == "⊔":
                 ls = "--"
             rect = mpatches.FancyBboxPatch(
-                (x, y),
-                CELL_W,
-                CELL_H,
+                (x, tape_y),
+                cell_w,
+                cell_h,
                 boxstyle="round,pad=0.03",
                 lw=lw,
                 edgecolor=LN,
@@ -710,43 +965,51 @@ def draw_tm_recognition() -> None:
                 linestyle=ls,
             )
             ax.add_patch(rect)
+            bold = (
+                "bold" if sym in ("X", "Y") else "normal"
+            )
+            clr = GRAY3 if sym == "⊔" else LN
             ax.text(
-                x + CELL_W / 2,
-                y + CELL_H / 2,
+                x + cell_w / 2,
+                tape_y + cell_h / 2,
                 sym,
                 ha="center",
                 va="center",
                 fontsize=FS + 2,
-                fontweight="bold" if sym in ("X", "Y") else "normal",
+                fontweight=bold,
                 family="monospace",
-                color=GRAY3 if sym == "⊔" else LN,
+                color=clr,
             )
         # ∞ arrow
-        last_x = TAPE_X0 + len(cells) * CELL_W
+        last_x = tape_x0 + len(cells) * cell_w
         ax.annotate(
             "→ ∞",
-            xy=(last_x + 0.3, y + CELL_H / 2),
+            xy=(last_x + 0.3, tape_y + cell_h / 2),
             fontsize=FS,
             ha="left",
             va="center",
             color=GRAY3,
         )
         if head_pos is not None:
-            hx = TAPE_X0 + head_pos * CELL_W + CELL_W / 2
+            hx = (
+                tape_x0
+                + head_pos * cell_w
+                + cell_w / 2
+            )
             ax.annotate(
                 "▼",
-                xy=(hx, y + CELL_H),
-                xytext=(hx, y + CELL_H + 0.25),
+                xy=(hx, tape_y + cell_h),
+                xytext=(hx, tape_y + cell_h + 0.25),
                 ha="center",
                 va="bottom",
-                fontsize=8,
+                fontsize=HEAD_MARKER_FONTSIZE,
                 color="black",
             )
         if step_label:
-            sx = TAPE_X0 + 8 * CELL_W + 0.8
+            sx = tape_x0 + 8 * cell_w + 0.8
             ax.text(
                 sx,
-                y + CELL_H / 2,
+                tape_y + cell_h / 2,
                 step_label,
                 ha="left",
                 va="center",
@@ -758,45 +1021,37 @@ def draw_tm_recognition() -> None:
                 },
             )
 
-    W = "white"
-    MK = GRAY1
-    BL = "#F0F0F0"  # blank cell
+    white = "white"
+    mk = GRAY1
+    bl = "#F0F0F0"  # blank cell
 
-    # Row 1: Initial
-    y = 9.0
-    draw_tape(
-        y,
-        [("0", W), ("0", W), ("1", W), ("1", W), ("⊔", BL), ("⊔", BL), ("⊔", BL)],
-        0,
-        "Początek",
-        "taśma = [0,0,1,1,⊔,⊔,...∞]",
-    )
-
-    # Row 2: Mark first 0
-    y = 7.8
-    draw_tape(
-        y,
-        [("X", MK), ("0", W), ("1", W), ("1", W), ("⊔", BL), ("⊔", BL), ("⊔", BL)],
-        1,
-        "R1, krok 1",
-        "zaznacz 0→X, idź w prawo",
-    )
-
-    # Row 3: Skip to first 1, mark it
-    y = 6.6
-    draw_tape(
-        y,
-        [("X", MK), ("0", W), ("Y", MK), ("1", W), ("⊔", BL), ("⊔", BL), ("⊔", BL)],
-        0,
-        "R1, krok 2",
-        "zaznacz 1→Y, wróć na początek",
-    )
+    tape_rows = [
+        (9.0, [("0", white), ("0", white), ("1", white),
+               ("1", white), ("⊔", bl), ("⊔", bl), ("⊔", bl)],
+         0, "Początek", "taśma = [0,0,1,1,⊔,⊔,...∞]"),
+        (7.8, [("X", mk), ("0", white), ("1", white),
+               ("1", white), ("⊔", bl), ("⊔", bl), ("⊔", bl)],
+         1, "R1, krok 1", "zaznacz 0→X, idź w prawo"),
+        (6.6, [("X", mk), ("0", white), ("Y", mk),
+               ("1", white), ("⊔", bl), ("⊔", bl), ("⊔", bl)],
+         0, "R1, krok 2", "zaznacz 1→Y, wróć na początek"),
+        (4.8, [("X", mk), ("X", mk), ("Y", mk),
+               ("1", white), ("⊔", bl), ("⊔", bl), ("⊔", bl)],
+         2, "R2, krok 1", "pomiń X, zaznacz 0→X"),
+        (3.6, [("X", mk), ("X", mk), ("Y", mk),
+               ("Y", mk), ("⊔", bl), ("⊔", bl), ("⊔", bl)],
+         0, "R2, krok 2", "pomiń Y, zaznacz 1→Y, wróć"),
+        (2.4, [("X", mk), ("X", mk), ("Y", mk),
+               ("Y", mk), ("⊔", bl), ("⊔", bl), ("⊔", bl)],
+         None, "Sprawdzenie",
+         "brak niezaznaczonych → q_acc"),
+    ]
 
     # Runda 2 header
-    y = 5.8
+    runda2_y = 5.8
     ax.text(
-        TAPE_X0 + 3.5 * CELL_W,
-        y + 0.3,
+        tape_x0 + 3.5 * cell_w,
+        runda2_y + 0.3,
         "═══ RUNDA 2 ═══",
         ha="center",
         va="center",
@@ -804,56 +1059,37 @@ def draw_tm_recognition() -> None:
         fontweight="bold",
     )
 
-    # Row 4: Mark second 0
-    y = 4.8
-    draw_tape(
-        y,
-        [("X", MK), ("X", MK), ("Y", MK), ("1", W), ("⊔", BL), ("⊔", BL), ("⊔", BL)],
-        2,
-        "R2, krok 1",
-        "pomiń X, zaznacz 0→X",
-    )
-
-    # Row 5: Mark second 1
-    y = 3.6
-    draw_tape(
-        y,
-        [("X", MK), ("X", MK), ("Y", MK), ("Y", MK), ("⊔", BL), ("⊔", BL), ("⊔", BL)],
-        0,
-        "R2, krok 2",
-        "pomiń Y, zaznacz 1→Y, wróć",
-    )
-
-    # Row 6: Check — all marked
-    y = 2.4
-    draw_tape(
-        y,
-        [("X", MK), ("X", MK), ("Y", MK), ("Y", MK), ("⊔", BL), ("⊔", BL), ("⊔", BL)],
-        None,
-        "Sprawdzenie",
-        "brak niezaznaczonych → q_acc",
-    )
+    for row_y, cells, head, lbl, step in tape_rows:
+        draw_tape(
+            row_y, cells, head, lbl, step_label=step
+        )
 
     # Result + TM vs LBA comparison
-    y = 0.8
+    tape_y = 0.8
     ax.text(
-        TAPE_X0 + 3.5 * CELL_W,
-        y + 0.3,
+        tape_x0 + 3.5 * cell_w,
+        tape_y + 0.3,
         '"0011" AKCEPTOWANE ✓',
         ha="center",
         va="center",
         fontsize=FS + 1,
         fontweight="bold",
-        bbox={"boxstyle": "round,pad=0.4", "facecolor": LIGHT_GREEN, "edgecolor": LN},
+        bbox={
+            "boxstyle": "round,pad=0.4",
+            "facecolor": LIGHT_GREEN,
+            "edgecolor": LN,
+        },
     )
 
-    y = -0.3
+    tape_y = -0.3
     ax.text(
-        TAPE_X0 + 3.5 * CELL_W,
-        y + 0.3,
-        "Różnica TM vs LBA: taśma TM jest nieskończona (⊔ → ∞)\n"
+        tape_x0 + 3.5 * cell_w,
+        tape_y + 0.3,
+        "Różnica TM vs LBA: taśma TM jest "
+        "nieskończona (⊔ → ∞)\n"
         "LBA: głowica ograniczona do |w| komórek\n"
-        "TM: głowica może wyjść POZA wejście i pisać na pustych ⊔",
+        "TM: głowica może wyjść POZA wejście "
+        "i pisać na pustych ⊔",
         ha="center",
         va="center",
         fontsize=FS_SMALL,
@@ -872,16 +1108,18 @@ def draw_tm_recognition() -> None:
         facecolor=BG,
     )
     plt.close()
-    print("  ✓ tm_recognition_example.png")
+    logger.info("  ✓ tm_recognition_example.png")
 
 
 # ============================================================
 # Main
 # ============================================================
 if __name__ == "__main__":
-    print("Generating automata diagrams for PYTANIE 1...")
+    logger.info(
+        "Generating automata diagrams for PYTANIE 1..."
+    )
     draw_fa_recognition()
     draw_pda_recognition()
     draw_lba_recognition()
     draw_tm_recognition()
-    print(f"\nAll diagrams saved to {OUTPUT_DIR}/")
+    logger.info("All diagrams saved to %s/", OUTPUT_DIR)
diff --git a/python_pkg/praca_magisterska_video/generate_images/generate_normalization_diagrams.py b/python_pkg/praca_magisterska_video/generate_images/generate_normalization_diagrams.py
index ccc0e3e..27a554b 100755
--- a/python_pkg/praca_magisterska_video/generate_images/generate_normalization_diagrams.py
+++ b/python_pkg/praca_magisterska_video/generate_images/generate_normalization_diagrams.py
@@ -7,6 +7,8 @@ Designed for A4 laser printer output (300 DPI, black & white).
 
 from __future__ import annotations
 
+import logging
+
 import matplotlib as mpl
 
 mpl.use("Agg")
@@ -20,6 +22,8 @@ if TYPE_CHECKING:
     from matplotlib.axes import Axes
     from matplotlib.figure import Figure
 
+logger = logging.getLogger(__name__)
+
 OUTPUT_DIR = str(Path(__file__).resolve().parent / "img")
 Path(OUTPUT_DIR).mkdir(parents=True, exist_ok=True)
 
@@ -33,19 +37,35 @@ FIXED_COLOR = "#D0F0D0"  # light green-ish gray for fixed
 FD_ARROW_COLOR = "#444444"
 
 
+def _compute_col_widths(
+    headers: list[str],
+    rows: list[list[str]],
+) -> list[float]:
+    """Auto-calculate column widths based on content."""
+    col_widths: list[float] = []
+    for c in range(len(headers)):
+        max_len = len(headers[c])
+        for r in rows:
+            if c < len(r):
+                max_len = max(max_len, len(str(r[c])))
+        col_widths.append(max(max_len * 0.08 + 0.1, 0.5))
+    return col_widths
+
+
 def draw_table(
-    ax,
-    x,
-    y,
-    title,
-    headers,
-    rows,
-    col_widths=None,
-    highlight_cols=None,
-    highlight_rows=None,
-    highlight_cells=None,
-    strikethrough_cells=None,
-    title_fontsize=9,
+    ax: Axes,
+    x: float,
+    y: float,
+    title: str,
+    headers: list[str],
+    rows: list[list[str]],
+    *,
+    col_widths: list[float] | None = None,
+    highlight_cols: set[int] | None = None,
+    highlight_rows: set[int] | None = None,
+    highlight_cells: set[tuple[int, int]] | None = None,
+    strikethrough_cells: set[tuple[int, int]] | None = None,
+    title_fontsize: int = 9,
 ) -> tuple[float, float]:
     """Draw a single table on the axes at position (x, y).
 
@@ -66,18 +86,10 @@ def draw_table(
     Returns:
         (width, height) of the drawn table
     """
-    n_cols = len(headers)
     n_rows = len(rows)
 
     if col_widths is None:
-        # Auto-calculate based on content
-        col_widths = []
-        for c in range(n_cols):
-            max_len = len(headers[c])
-            for r in rows:
-                if c < len(r):
-                    max_len = max(max_len, len(str(r[c])))
-            col_widths.append(max(max_len * 0.08 + 0.1, 0.5))
+        col_widths = _compute_col_widths(headers, rows)
 
     row_height = 0.22
     total_width = sum(col_widths)
@@ -172,7 +184,10 @@ def draw_table(
     return total_width, total_height + 0.25  # extra for title
 
 
-def create_figure(width_inches=11.69, height_inches=8.27) -> tuple[Figure, Axes]:
+def create_figure(
+    width_inches: float = 11.69,
+    height_inches: float = 8.27,
+) -> tuple[Figure, Axes]:
     """Create A4 landscape figure."""
     fig, ax = plt.subplots(1, 1, figsize=(width_inches, height_inches), dpi=DPI)
     ax.set_xlim(0, width_inches)
@@ -182,7 +197,16 @@ def create_figure(width_inches=11.69, height_inches=8.27) -> tuple[Figure, Axes]
     return fig, ax
 
 
-def add_arrow(ax, x1, y1, x2, y2, label="", color="black") -> None:
+def add_arrow(
+    ax: Axes,
+    x1: float,
+    y1: float,
+    x2: float,
+    y2: float,
+    label: str = "",
+    *,
+    color: str = "black",
+) -> None:
     """Draw an arrow with optional label."""
     ax.annotate(
         "",
@@ -205,7 +229,15 @@ def add_arrow(ax, x1, y1, x2, y2, label="", color="black") -> None:
 
 
 def add_label(
-    ax, x, y, text, fontsize=8, color="black", ha="left", style="normal"
+    ax: Axes,
+    x: float,
+    y: float,
+    text: str,
+    *,
+    fontsize: int = 8,
+    color: str = "black",
+    ha: str = "left",
+    style: str = "normal",
 ) -> None:
     """Add a text label."""
     ax.text(
@@ -289,7 +321,10 @@ def draw_0nf() -> None:
         ax,
         0.8,
         1.2,
-        "Zaleznosci funkcyjne:  StID -> Imie, WydzialID    |    WydzialID -> NazwaWydzialu",
+        (
+            "Zaleznosci funkcyjne:  StID -> Imie, WydzialID"
+            "    |    WydzialID -> NazwaWydzialu"
+        ),
         fontsize=8,
         color="#333333",
     )
@@ -297,7 +332,10 @@ def draw_0nf() -> None:
         ax,
         0.8,
         0.9,
-        "  KursID -> NazwaKursu    |    (StID,KursID) -> Prowadzacy    |    Prowadzacy -> KursID",
+        (
+            "  KursID -> NazwaKursu    |    (StID,KursID)"
+            " -> Prowadzacy    |    Prowadzacy -> KursID"
+        ),
         fontsize=8,
         color="#333333",
     )
@@ -309,7 +347,7 @@ def draw_0nf() -> None:
         pad_inches=0.2,
     )
     plt.close(fig)
-    print("Generated: nf_0nf_table.png")
+    logger.info("Generated: nf_0nf_table.png")
 
 
 # ============================================================
@@ -399,7 +437,10 @@ def draw_1nf() -> None:
         ax,
         0.5,
         1.5,
-        "             Imie, WydzialID, NazwaWydzialu zaleza TYLKO od StID (czesc klucza).",
+        (
+            "             Imie, WydzialID, NazwaWydzialu"
+            " zaleza TYLKO od StID (czesc klucza)."
+        ),
         fontsize=9,
         color="black",
     )
@@ -419,7 +460,7 @@ def draw_1nf() -> None:
         pad_inches=0.2,
     )
     plt.close(fig)
-    print("Generated: nf_1nf_tables.png")
+    logger.info("Generated: nf_1nf_tables.png")
 
 
 # ============================================================
@@ -477,7 +518,10 @@ def draw_2nf() -> None:
         ax,
         0.3,
         3.3,
-        "KROK: Rozbito czesc. zaleznosci — atrybuty zalezne od czesci klucza wydzielone.",
+        (
+            "KROK: Rozbito czesc. zaleznosci"
+            " — atrybuty zalezne od czesci klucza wydzielone."
+        ),
         fontsize=9,
     )
     add_label(
@@ -528,7 +572,7 @@ def draw_2nf() -> None:
         pad_inches=0.2,
     )
     plt.close(fig)
-    print("Generated: nf_2nf_tables.png")
+    logger.info("Generated: nf_2nf_tables.png")
 
 
 # ============================================================
diff --git a/python_pkg/praca_magisterska_video/generate_images/generate_pubsub_diagrams.py b/python_pkg/praca_magisterska_video/generate_images/generate_pubsub_diagrams.py
index 3a0f2d8..e7c80e4 100755
--- a/python_pkg/praca_magisterska_video/generate_images/generate_pubsub_diagrams.py
+++ b/python_pkg/praca_magisterska_video/generate_images/generate_pubsub_diagrams.py
@@ -12,18 +12,29 @@
     7. Exactly-once.
 
 All: A4-width, B&W, 300 DPI, laser-printer-friendly.
-One diagram per image — no cramming.
+One diagram per image -- no cramming.
 """
 
+from __future__ import annotations
+
+from dataclasses import dataclass
+import logging
+from pathlib import Path
+from typing import TYPE_CHECKING
+
 import matplotlib as mpl
 
 mpl.use("Agg")
-from pathlib import Path
 
 import matplotlib.patches as mpatches
 from matplotlib.patches import FancyBboxPatch
 import matplotlib.pyplot as plt
 
+if TYPE_CHECKING:
+    from matplotlib.axes import Axes
+
+logger = logging.getLogger(__name__)
+
 DPI = 300
 BG = "white"
 LN = "black"
@@ -40,108 +51,207 @@ GRAY4 = "#F5F5F5"
 GRAY5 = "#C0C0C0"
 
 
+@dataclass(frozen=True)
+class BoxStyle:
+    """Optional styling for boxes."""
+
+    fill: str = "white"
+    lw: float = 1.2
+    fontsize: float = FS
+    fontweight: str = "normal"
+    ha: str = "center"
+    va: str = "center"
+    rounded: bool = True
+
+
+@dataclass(frozen=True)
+class ArrowCfg:
+    """Config for arrows."""
+
+    lw: float = 1.2
+    style: str = "->"
+    color: str = LN
+    label: str = ""
+    label_offset: float = 0.15
+    label_fs: float = 8
+
+
+@dataclass(frozen=True)
+class DashedCfg:
+    """Config for dashed arrows."""
+
+    lw: float = 1.0
+    color: str = LN
+    label: str = ""
+    label_offset: float = 0.15
+    label_fs: float = 8
+
+
 def draw_box(
-    ax,
-    x,
-    y,
-    w,
-    h,
-    text,
-    fill="white",
-    lw=1.2,
-    fontsize=FS,
-    fontweight="normal",
-    ha="center",
-    va="center",
-    rounded=True,
+    ax: Axes,
+    pos: tuple[float, float],
+    size: tuple[float, float],
+    text: str,
+    style: BoxStyle | None = None,
 ) -> None:
     """Draw box."""
-    if rounded:
+    s = style or BoxStyle()
+    x, y = pos
+    w, h = size
+    if s.rounded:
         rect = FancyBboxPatch(
-            (x, y), w, h, boxstyle="round,pad=0.05", lw=lw, edgecolor=LN, facecolor=fill
+            (x, y),
+            w,
+            h,
+            boxstyle="round,pad=0.05",
+            lw=s.lw,
+            edgecolor=LN,
+            facecolor=s.fill,
         )
     else:
-        rect = mpatches.Rectangle((x, y), w, h, lw=lw, edgecolor=LN, facecolor=fill)
+        rect = mpatches.Rectangle(
+            (x, y),
+            w,
+            h,
+            lw=s.lw,
+            edgecolor=LN,
+            facecolor=s.fill,
+        )
     ax.add_patch(rect)
     ax.text(
         x + w / 2,
         y + h / 2,
         text,
-        ha=ha,
-        va=va,
-        fontsize=fontsize,
-        fontweight=fontweight,
+        ha=s.ha,
+        va=s.va,
+        fontsize=s.fontsize,
+        fontweight=s.fontweight,
         wrap=True,
     )
 
 
 def draw_arrow(
-    ax,
-    x1,
-    y1,
-    x2,
-    y2,
-    lw=1.2,
-    style="->",
-    color=LN,
-    label="",
-    label_offset=0.15,
-    label_fs=8,
+    ax: Axes,
+    start: tuple[float, float],
+    end: tuple[float, float],
+    cfg: ArrowCfg | None = None,
 ) -> None:
     """Draw arrow."""
+    c = cfg or ArrowCfg()
     ax.annotate(
         "",
-        xy=(x2, y2),
-        xytext=(x1, y1),
-        arrowprops={"arrowstyle": style, "color": color, "lw": lw},
+        xy=end,
+        xytext=start,
+        arrowprops={
+            "arrowstyle": c.style,
+            "color": c.color,
+            "lw": c.lw,
+        },
     )
-    if label:
-        mx, my = (x1 + x2) / 2, (y1 + y2) / 2 + label_offset
-        ax.text(mx, my, label, ha="center", va="bottom", fontsize=label_fs, color=color)
+    if c.label:
+        mx = (start[0] + end[0]) / 2
+        my = (start[1] + end[1]) / 2 + c.label_offset
+        ax.text(
+            mx,
+            my,
+            c.label,
+            ha="center",
+            va="bottom",
+            fontsize=c.label_fs,
+            color=c.color,
+        )
 
 
 def draw_dashed_arrow(
-    ax, x1, y1, x2, y2, lw=1.0, color=LN, label="", label_offset=0.15, label_fs=8
+    ax: Axes,
+    start: tuple[float, float],
+    end: tuple[float, float],
+    cfg: DashedCfg | None = None,
 ) -> None:
     """Draw dashed arrow."""
+    c = cfg or DashedCfg()
     ax.annotate(
         "",
-        xy=(x2, y2),
-        xytext=(x1, y1),
+        xy=end,
+        xytext=start,
         arrowprops={
             "arrowstyle": "->",
-            "color": color,
-            "lw": lw,
+            "color": c.color,
+            "lw": c.lw,
             "linestyle": "dashed",
         },
     )
-    if label:
-        mx, my = (x1 + x2) / 2, (y1 + y2) / 2 + label_offset
-        ax.text(mx, my, label, ha="center", va="bottom", fontsize=label_fs, color=color)
+    if c.label:
+        mx = (start[0] + end[0]) / 2
+        my = (start[1] + end[1]) / 2 + c.label_offset
+        ax.text(
+            mx,
+            my,
+            c.label,
+            ha="center",
+            va="bottom",
+            fontsize=c.label_fs,
+            color=c.color,
+        )
 
 
-def draw_cross(ax, x, y, size=0.15, lw=2.5, color="black") -> None:
+def draw_cross(
+    ax: Axes,
+    pos: tuple[float, float],
+    size: float = 0.15,
+    lw: float = 2.5,
+    color: str = "black",
+) -> None:
     """Draw cross."""
-    ax.plot([x - size, x + size], [y - size, y + size], color=color, lw=lw)
-    ax.plot([x - size, x + size], [y + size, y - size], color=color, lw=lw)
-
-
-def draw_check(ax, x, y, size=0.15, lw=2.5, color="black") -> None:
-    """Draw check."""
-    ax.plot([x - size, x - size * 0.2], [y, y - size * 0.7], color=color, lw=lw)
+    x, y = pos
     ax.plot(
-        [x - size * 0.2, x + size], [y - size * 0.7, y + size * 0.5], color=color, lw=lw
+        [x - size, x + size],
+        [y - size, y + size],
+        color=color,
+        lw=lw,
+    )
+    ax.plot(
+        [x - size, x + size],
+        [y + size, y - size],
+        color=color,
+        lw=lw,
     )
 
 
-def save(fig, name) -> None:
+def draw_check(
+    ax: Axes,
+    pos: tuple[float, float],
+    size: float = 0.15,
+    lw: float = 2.5,
+    color: str = "black",
+) -> None:
+    """Draw check."""
+    x, y = pos
+    ax.plot(
+        [x - size, x - size * 0.2],
+        [y, y - size * 0.7],
+        color=color,
+        lw=lw,
+    )
+    ax.plot(
+        [x - size * 0.2, x + size],
+        [y - size * 0.7, y + size * 0.5],
+        color=color,
+        lw=lw,
+    )
+
+
+def save(fig: plt.Figure, name: str) -> None:
     """Save."""
     plt.tight_layout()
     fig.savefig(
-        str(Path(OUTPUT_DIR) / name), dpi=DPI, bbox_inches="tight", facecolor=BG
+        str(Path(OUTPUT_DIR) / name),
+        dpi=DPI,
+        bbox_inches="tight",
+        facecolor=BG,
     )
     plt.close(fig)
-    print(f"  ✓ {name}")
+    logger.info("  \u2713 %s", name)
 
 
 # ============================================================
@@ -155,84 +265,107 @@ def draw_sub_topic() -> None:
     ax.set_aspect("equal")
     ax.axis("off")
     ax.set_title(
-        "Subskrypcja topic-based — routing po nazwie tematu",
+        "Subskrypcja topic-based"
+        " \u2014 routing po nazwie tematu",
         fontsize=FS_TITLE,
         fontweight="bold",
         pad=12,
     )
 
-    # Publisher + messages
-    draw_box(
-        ax, 0.2, 3.2, 2.4, 1.1, "Publisher", fill=GRAY1, fontsize=10, fontweight="bold"
+    bold10 = BoxStyle(
+        fill=GRAY1, fontsize=10, fontweight="bold"
     )
-    draw_box(ax, 0.3, 1.8, 2.2, 0.8, 'topic: "orders"', fill=GRAY4, fontsize=8)
-    draw_box(ax, 0.3, 0.7, 2.2, 0.8, 'topic: "payments"', fill=GRAY4, fontsize=8)
+    fs85 = BoxStyle(fill=GRAY1, fontsize=8.5)
 
-    # Broker
+    draw_box(
+        ax, (0.2, 3.2), (2.4, 1.1), "Publisher", bold10
+    )
     draw_box(
         ax,
-        4.2,
-        1.5,
-        2.8,
-        2.2,
+        (0.3, 1.8),
+        (2.2, 0.8),
+        'topic: "orders"',
+        BoxStyle(fill=GRAY4, fontsize=8),
+    )
+    draw_box(
+        ax,
+        (0.3, 0.7),
+        (2.2, 0.8),
+        'topic: "payments"',
+        BoxStyle(fill=GRAY4, fontsize=8),
+    )
+
+    draw_box(
+        ax,
+        (4.2, 1.5),
+        (2.8, 2.2),
         "BROKER\n\ntopic routing",
-        fill=GRAY2,
-        fontsize=10,
-        fontweight="bold",
+        BoxStyle(
+            fill=GRAY2, fontsize=10, fontweight="bold"
+        ),
     )
 
-    # Subscribers
     draw_box(
         ax,
-        8.5,
-        3.8,
-        3.0,
-        1.0,
+        (8.5, 3.8),
+        (3.0, 1.0),
         'Subscriber A\nsubskrybuje: "orders"',
-        fill=GRAY1,
-        fontsize=8.5,
+        fs85,
     )
     draw_box(
         ax,
-        8.5,
-        2.2,
-        3.0,
-        1.0,
+        (8.5, 2.2),
+        (3.0, 1.0),
         'Subscriber B\nsubskrybuje: "payments"',
-        fill=GRAY1,
-        fontsize=8.5,
+        fs85,
     )
     draw_box(
         ax,
-        8.5,
-        0.6,
-        3.0,
-        1.0,
+        (8.5, 0.6),
+        (3.0, 1.0),
         'Subscriber C\nsubskrybuje: "orders"',
-        fill=GRAY1,
-        fontsize=8.5,
+        fs85,
     )
 
-    # Arrows: publisher → broker
-    draw_arrow(ax, 2.6, 2.2, 4.2, 2.8, label_fs=8)
-    draw_arrow(ax, 2.6, 1.1, 4.2, 2.2, label_fs=8)
+    fs8 = ArrowCfg(label_fs=8)
+    draw_arrow(ax, (2.6, 2.2), (4.2, 2.8), fs8)
+    draw_arrow(ax, (2.6, 1.1), (4.2, 2.2), fs8)
 
-    # Arrows: broker → subscribers
-    draw_arrow(ax, 7.0, 3.4, 8.5, 4.2, label='"orders"', label_fs=8)
-    draw_arrow(ax, 7.0, 2.6, 8.5, 2.7, label='"payments"', label_fs=8)
-    draw_arrow(ax, 7.0, 2.2, 8.5, 1.2, label='"orders"', label_fs=8)
+    draw_arrow(
+        ax,
+        (7.0, 3.4),
+        (8.5, 4.2),
+        ArrowCfg(label='"orders"', label_fs=8),
+    )
+    draw_arrow(
+        ax,
+        (7.0, 2.6),
+        (8.5, 2.7),
+        ArrowCfg(label='"payments"', label_fs=8),
+    )
+    draw_arrow(
+        ax,
+        (7.0, 2.2),
+        (8.5, 1.2),
+        ArrowCfg(label='"orders"', label_fs=8),
+    )
 
-    # Explanation
     ax.text(
         6.0,
         0.1,
-        "Subscriber deklaruje nazwę tematu. Broker kieruje wiadomości\n"
-        "do WSZYSTKICH subscriberów danego tematu. Najprostszy model.",
+        "Subscriber deklaruje nazw\u0119 tematu."
+        " Broker kieruje wiadomo\u015bci\n"
+        "do WSZYSTKICH subscriber\u00f3w"
+        " danego tematu. Najprostszy model.",
         ha="center",
         va="bottom",
         fontsize=8.5,
         style="italic",
-        bbox={"boxstyle": "round,pad=0.3", "facecolor": GRAY4, "edgecolor": GRAY3},
+        bbox={
+            "boxstyle": "round,pad=0.3",
+            "facecolor": GRAY4,
+            "edgecolor": GRAY3,
+        },
     )
 
     save(fig, "pubsub_sub_topic.png")
@@ -249,69 +382,107 @@ def draw_sub_content() -> None:
     ax.set_aspect("equal")
     ax.axis("off")
     ax.set_title(
-        "Subskrypcja content-based — filtrowanie po treści wiadomości",
+        "Subskrypcja content-based"
+        " \u2014 filtrowanie po tre\u015bci wiadomo\u015bci",
         fontsize=FS_TITLE,
         fontweight="bold",
         pad=12,
     )
 
-    # Publisher + message
+    bold10 = BoxStyle(
+        fill=GRAY1, fontsize=10, fontweight="bold"
+    )
     draw_box(
-        ax, 0.2, 3.5, 2.4, 1.1, "Publisher", fill=GRAY1, fontsize=10, fontweight="bold"
+        ax, (0.2, 3.5), (2.4, 1.1), "Publisher", bold10
     )
     draw_box(
         ax,
-        0.2,
-        1.8,
-        2.4,
-        1.2,
+        (0.2, 1.8),
+        (2.4, 1.2),
         'price: 150\ntype: "book"\ncategory: "IT"',
-        fill=GRAY4,
-        fontsize=8.5,
+        BoxStyle(fill=GRAY4, fontsize=8.5),
     )
 
-    # Broker
     draw_box(
         ax,
-        4.0,
-        2.0,
-        3.0,
-        2.5,
-        "BROKER\n\newaluuje filtry\nkażdego subscribera",
-        fill=GRAY2,
-        fontsize=9,
-        fontweight="bold",
+        (4.0, 2.0),
+        (3.0, 2.5),
+        "BROKER\n\newaluuje filtry\n"
+        "ka\u017cdego subscribera",
+        BoxStyle(
+            fill=GRAY2, fontsize=9, fontweight="bold"
+        ),
     )
 
-    # Subscribers with filters
+    fs9 = BoxStyle(fill=GRAY1, fontsize=9)
     draw_box(
-        ax, 8.5, 4.2, 3.2, 1.0, "Sub A\nfiltr: price > 100", fill=GRAY1, fontsize=9
+        ax,
+        (8.5, 4.2),
+        (3.2, 1.0),
+        "Sub A\nfiltr: price > 100",
+        fs9,
     )
     draw_box(
-        ax, 8.5, 2.6, 3.2, 1.0, 'Sub B\nfiltr: type = "food"', fill=GRAY1, fontsize=9
+        ax,
+        (8.5, 2.6),
+        (3.2, 1.0),
+        'Sub B\nfiltr: type = "food"',
+        fs9,
+    )
+    draw_box(
+        ax,
+        (8.5, 1.0),
+        (3.2, 1.0),
+        "Sub C\nfiltr: price < 50",
+        fs9,
     )
-    draw_box(ax, 8.5, 1.0, 3.2, 1.0, "Sub C\nfiltr: price < 50", fill=GRAY1, fontsize=9)
 
-    # Arrows
-    draw_arrow(ax, 2.6, 2.4, 4.0, 3.0)
-    draw_arrow(ax, 7.0, 4.0, 8.5, 4.6, label="150 > 100  ✓  dostarczono", label_fs=8)
-    draw_dashed_arrow(
-        ax, 7.0, 3.2, 8.5, 3.1, label='"book" ≠ "food"  ✗  odrzucono', label_fs=8
+    draw_arrow(ax, (2.6, 2.4), (4.0, 3.0))
+    draw_arrow(
+        ax,
+        (7.0, 4.0),
+        (8.5, 4.6),
+        ArrowCfg(
+            label="150 > 100  \u2713  dostarczono",
+            label_fs=8,
+        ),
     )
     draw_dashed_arrow(
-        ax, 7.0, 2.5, 8.5, 1.6, label="150 < 50  ✗  odrzucono", label_fs=8
+        ax,
+        (7.0, 3.2),
+        (8.5, 3.1),
+        DashedCfg(
+            label='"book" \u2260 "food"'
+            "  \u2717  odrzucono",
+            label_fs=8,
+        ),
+    )
+    draw_dashed_arrow(
+        ax,
+        (7.0, 2.5),
+        (8.5, 1.6),
+        DashedCfg(
+            label="150 < 50  \u2717  odrzucono",
+            label_fs=8,
+        ),
     )
 
     ax.text(
         6.0,
         0.2,
-        "Broker analizuje TREŚĆ wiadomości i ewaluuje predykaty.\n"
-        "Bardziej elastyczny niż topic-based, ale wolniejszy (koszt ewaluacji).",
+        "Broker analizuje TRE\u015a\u0106 wiadomo\u015bci"
+        " i ewaluuje predykaty.\n"
+        "Bardziej elastyczny ni\u017c topic-based,"
+        " ale wolniejszy (koszt ewaluacji).",
         ha="center",
         va="bottom",
         fontsize=8.5,
         style="italic",
-        bbox={"boxstyle": "round,pad=0.3", "facecolor": GRAY4, "edgecolor": GRAY3},
+        bbox={
+            "boxstyle": "round,pad=0.3",
+            "facecolor": GRAY4,
+            "edgecolor": GRAY3,
+        },
     )
 
     save(fig, "pubsub_sub_content.png")
@@ -328,95 +499,153 @@ def draw_sub_type() -> None:
     ax.set_aspect("equal")
     ax.axis("off")
     ax.set_title(
-        "Subskrypcja type-based — routing po typie (klasie) obiektu",
+        "Subskrypcja type-based"
+        " \u2014 routing po typie (klasie) obiektu",
         fontsize=FS_TITLE,
         fontweight="bold",
         pad=12,
     )
 
-    # Publisher
+    bold10 = BoxStyle(
+        fill=GRAY1, fontsize=10, fontweight="bold"
+    )
     draw_box(
-        ax, 0.2, 4.2, 2.4, 1.1, "Publisher", fill=GRAY1, fontsize=10, fontweight="bold"
+        ax, (0.2, 4.2), (2.4, 1.1), "Publisher", bold10
     )
 
-    # Messages
-    draw_box(ax, 0.1, 2.8, 2.6, 0.9, "new OrderEvent()", fill=GRAY4, fontsize=9)
-    draw_box(ax, 0.1, 1.5, 2.6, 0.9, "new PaymentEvent()", fill=GRAY4, fontsize=9)
-
-    # Broker
+    fs9_g4 = BoxStyle(fill=GRAY4, fontsize=9)
     draw_box(
         ax,
-        4.0,
-        2.3,
-        3.0,
-        2.4,
-        "BROKER\n\nrouting po\ntypie klasy",
-        fill=GRAY2,
-        fontsize=10,
-        fontweight="bold",
+        (0.1, 2.8),
+        (2.6, 0.9),
+        "new OrderEvent()",
+        fs9_g4,
+    )
+    draw_box(
+        ax,
+        (0.1, 1.5),
+        (2.6, 0.9),
+        "new PaymentEvent()",
+        fs9_g4,
     )
 
-    # Subscribers
-    draw_box(ax, 8.5, 4.8, 3.2, 1.0, "Sub A\n→ OrderEvent", fill=GRAY1, fontsize=9)
-    draw_box(ax, 8.5, 3.2, 3.2, 1.0, "Sub B\n→ PaymentEvent", fill=GRAY1, fontsize=9)
-    draw_box(ax, 8.5, 1.6, 3.2, 1.0, "Sub C\n→ Event (base)", fill=GRAY1, fontsize=9)
+    draw_box(
+        ax,
+        (4.0, 2.3),
+        (3.0, 2.4),
+        "BROKER\n\nrouting po\ntypie klasy",
+        BoxStyle(
+            fill=GRAY2, fontsize=10, fontweight="bold"
+        ),
+    )
 
-    # Arrows
-    draw_arrow(ax, 2.7, 3.2, 4.0, 3.8)
-    draw_arrow(ax, 2.7, 2.0, 4.0, 3.0)
-    draw_arrow(ax, 7.0, 4.3, 8.5, 5.2, label="OrderEvent", label_fs=8)
-    draw_arrow(ax, 7.0, 3.5, 8.5, 3.7, label="PaymentEvent", label_fs=8)
-    draw_arrow(ax, 7.0, 3.0, 8.5, 2.2, label="oba (dziedziczenie!)", label_fs=8)
+    fs9 = BoxStyle(fill=GRAY1, fontsize=9)
+    draw_box(
+        ax,
+        (8.5, 4.8),
+        (3.2, 1.0),
+        "Sub A\n\u2192 OrderEvent",
+        fs9,
+    )
+    draw_box(
+        ax,
+        (8.5, 3.2),
+        (3.2, 1.0),
+        "Sub B\n\u2192 PaymentEvent",
+        fs9,
+    )
+    draw_box(
+        ax,
+        (8.5, 1.6),
+        (3.2, 1.0),
+        "Sub C\n\u2192 Event (base)",
+        fs9,
+    )
+
+    draw_arrow(ax, (2.7, 3.2), (4.0, 3.8))
+    draw_arrow(ax, (2.7, 2.0), (4.0, 3.0))
+    draw_arrow(
+        ax,
+        (7.0, 4.3),
+        (8.5, 5.2),
+        ArrowCfg(label="OrderEvent", label_fs=8),
+    )
+    draw_arrow(
+        ax,
+        (7.0, 3.5),
+        (8.5, 3.7),
+        ArrowCfg(label="PaymentEvent", label_fs=8),
+    )
+    draw_arrow(
+        ax,
+        (7.0, 3.0),
+        (8.5, 2.2),
+        ArrowCfg(
+            label="oba (dziedziczenie!)", label_fs=8
+        ),
+    )
 
-    # Class hierarchy inset
     hx, hy = 0.5, 0.0
     draw_box(
         ax,
-        hx + 2.0,
-        hy + 0.2,
-        1.8,
-        0.6,
+        (hx + 2.0, hy + 0.2),
+        (1.8, 0.6),
         "Event",
-        fill=GRAY3,
-        fontsize=8,
-        fontweight="bold",
+        BoxStyle(
+            fill=GRAY3, fontsize=8, fontweight="bold"
+        ),
     )
-    draw_box(ax, hx + 0.0, hy + 0.2, 1.8, 0.6, "OrderEvent", fill=GRAY4, fontsize=7.5)
-    draw_box(ax, hx + 4.0, hy + 0.2, 2.0, 0.6, "PaymentEvent", fill=GRAY4, fontsize=7.5)
-    draw_arrow(
+    draw_box(
         ax,
-        hx + 2.9,
-        hy + 0.2,
-        hx + 0.9,
-        hy + 0.2,
-        lw=1.0,
-        style="->",
-        label="extends",
-        label_offset=-0.3,
-        label_fs=7,
+        (hx, hy + 0.2),
+        (1.8, 0.6),
+        "OrderEvent",
+        BoxStyle(fill=GRAY4, fontsize=7.5),
+    )
+    draw_box(
+        ax,
+        (hx + 4.0, hy + 0.2),
+        (2.0, 0.6),
+        "PaymentEvent",
+        BoxStyle(fill=GRAY4, fontsize=7.5),
     )
     draw_arrow(
         ax,
-        hx + 2.9,
-        hy + 0.2,
-        hx + 5.0,
-        hy + 0.2,
-        lw=1.0,
-        style="->",
-        label="extends",
-        label_offset=-0.3,
-        label_fs=7,
+        (hx + 2.9, hy + 0.2),
+        (hx + 0.9, hy + 0.2),
+        ArrowCfg(
+            lw=1.0,
+            label="extends",
+            label_offset=-0.3,
+            label_fs=7,
+        ),
+    )
+    draw_arrow(
+        ax,
+        (hx + 2.9, hy + 0.2),
+        (hx + 5.0, hy + 0.2),
+        ArrowCfg(
+            lw=1.0,
+            label="extends",
+            label_offset=-0.3,
+            label_fs=7,
+        ),
     )
 
     ax.text(
         9.5,
         0.5,
-        "Sub C subskrybuje bazowy Event\n→ otrzymuje WSZYSTKIE podtypy",
+        "Sub C subskrybuje bazowy Event\n"
+        "\u2192 otrzymuje WSZYSTKIE podtypy",
         ha="center",
         va="center",
         fontsize=8.5,
         style="italic",
-        bbox={"boxstyle": "round,pad=0.3", "facecolor": GRAY4, "edgecolor": GRAY3},
+        bbox={
+            "boxstyle": "round,pad=0.3",
+            "facecolor": GRAY4,
+            "edgecolor": GRAY3,
+        },
     )
 
     save(fig, "pubsub_sub_type.png")
@@ -433,34 +662,58 @@ def draw_sub_hierarchical() -> None:
     ax.set_aspect("equal")
     ax.axis("off")
     ax.set_title(
-        "Subskrypcja hierarchiczna (wildcards) — wzorce tematów",
+        "Subskrypcja hierarchiczna (wildcards)"
+        " \u2014 wzorce temat\u00f3w",
         fontsize=FS_TITLE,
         fontweight="bold",
         pad=12,
     )
 
-    # Topic tree
+    bold10 = BoxStyle(
+        fill=GRAY2, fontsize=10, fontweight="bold"
+    )
     draw_box(
-        ax, 4.5, 5.8, 2.4, 0.8, "sensors/", fill=GRAY2, fontsize=10, fontweight="bold"
+        ax, (4.5, 5.8), (2.4, 0.8), "sensors/", bold10
     )
 
-    draw_box(ax, 1.5, 4.2, 2.4, 0.8, "temperature/", fill=GRAY3, fontsize=9)
-    draw_box(ax, 7.5, 4.2, 2.4, 0.8, "humidity/", fill=GRAY3, fontsize=9)
+    fs9_g3 = BoxStyle(fill=GRAY3, fontsize=9)
+    draw_box(
+        ax,
+        (1.5, 4.2),
+        (2.4, 0.8),
+        "temperature/",
+        fs9_g3,
+    )
+    draw_box(
+        ax,
+        (7.5, 4.2),
+        (2.4, 0.8),
+        "humidity/",
+        fs9_g3,
+    )
 
-    draw_box(ax, 0.2, 2.8, 1.8, 0.7, "room1", fill=GRAY4, fontsize=8.5)
-    draw_box(ax, 2.4, 2.8, 1.8, 0.7, "room2", fill=GRAY4, fontsize=8.5)
-    draw_box(ax, 6.8, 2.8, 1.8, 0.7, "room1", fill=GRAY4, fontsize=8.5)
-    draw_box(ax, 9.0, 2.8, 1.8, 0.7, "room2", fill=GRAY4, fontsize=8.5)
+    fs85_g4 = BoxStyle(fill=GRAY4, fontsize=8.5)
+    draw_box(
+        ax, (0.2, 2.8), (1.8, 0.7), "room1", fs85_g4
+    )
+    draw_box(
+        ax, (2.4, 2.8), (1.8, 0.7), "room2", fs85_g4
+    )
+    draw_box(
+        ax, (6.8, 2.8), (1.8, 0.7), "room1", fs85_g4
+    )
+    draw_box(
+        ax, (9.0, 2.8), (1.8, 0.7), "room2", fs85_g4
+    )
 
-    # Tree edges
-    draw_arrow(ax, 5.7, 5.8, 2.7, 5.0, lw=1.0)
-    draw_arrow(ax, 5.7, 5.8, 8.7, 5.0, lw=1.0)
-    draw_arrow(ax, 2.2, 4.2, 1.1, 3.5, lw=1.0)
-    draw_arrow(ax, 3.2, 4.2, 3.3, 3.5, lw=1.0)
-    draw_arrow(ax, 8.2, 4.2, 7.7, 3.5, lw=1.0)
-    draw_arrow(ax, 9.2, 4.2, 9.9, 3.5, lw=1.0)
+    thin = ArrowCfg(lw=1.0)
+    draw_arrow(ax, (5.7, 5.8), (2.7, 5.0), thin)
+    draw_arrow(ax, (5.7, 5.8), (8.7, 5.0), thin)
+    draw_arrow(ax, (2.2, 4.2), (1.1, 3.5), thin)
+    draw_arrow(ax, (3.2, 4.2), (3.3, 3.5), thin)
+    draw_arrow(ax, (8.2, 4.2), (7.7, 3.5), thin)
+    draw_arrow(ax, (9.2, 4.2), (9.9, 3.5), thin)
 
-    # Full paths
     ax.text(
         1.1,
         2.4,
@@ -480,21 +733,47 @@ def draw_sub_hierarchical() -> None:
         style="italic",
     )
 
-    # Wildcard examples
     ax.text(
-        0.3, 1.5, "Wzorce subskrypcji (MQTT-style):", fontsize=10, fontweight="bold"
+        0.3,
+        1.5,
+        "Wzorce subskrypcji (MQTT-style):",
+        fontsize=10,
+        fontweight="bold",
     )
 
     patterns = [
-        ('"sensors/temperature/room1"', "→ TYLKO room1", "(dokładne dopasowanie)"),
-        ('"sensors/temperature/*"', "→ room1, room2", "( * = jeden poziom)"),
-        ('"sensors/#"', "→ WSZYSTKO", "( # = dowolna głębokość)"),
+        (
+            '"sensors/temperature/room1"',
+            "\u2192 TYLKO room1",
+            "(dok\u0142adne dopasowanie)",
+        ),
+        (
+            '"sensors/temperature/*"',
+            "\u2192 room1, room2",
+            "( * = jeden poziom)",
+        ),
+        (
+            '"sensors/#"',
+            "\u2192 WSZYSTKO",
+            "( # = dowolna g\u0142\u0119boko\u015b\u0107)",
+        ),
     ]
     for i, (pat, result, note) in enumerate(patterns):
         yy = 0.9 - i * 0.55
-        ax.text(0.5, yy, pat, fontsize=9, fontweight="bold", fontfamily="monospace")
-        ax.text(7.0, yy, result, fontsize=9, fontweight="bold")
-        ax.text(9.5, yy, note, fontsize=8, style="italic")
+        ax.text(
+            0.5,
+            yy,
+            pat,
+            fontsize=9,
+            fontweight="bold",
+            fontfamily="monospace",
+        )
+        ax.text(
+            7.0, yy, result, fontsize=9, fontweight="bold"
+        )
+        ax.text(
+            9.5, yy, note, fontsize=8, style="italic"
+        )
 
     save(fig, "pubsub_sub_hierarchical.png")
 
@@ -510,54 +789,119 @@ def draw_qos_at_most_once() -> None:
     ax.set_aspect("equal")
     ax.axis("off")
     ax.set_title(
-        'QoS: At-most-once — „wyślij i zapomnij" (0 lub 1 dostarczenie)',
+        "QoS: At-most-once"
+        " \u2014 \u201ewy\u015blij i zapomnij\u201d"
+        " (0 lub 1 dostarczenie)",
         fontsize=FS_TITLE,
         fontweight="bold",
         pad=12,
     )
 
-    # Actors
     px, bx, sx = 1.0, 4.8, 8.5
     pw, bw, sw = 2.0, 2.2, 2.0
     bh = 0.8
-    draw_box(
-        ax, px, 5.0, pw, bh, "Publisher", fill=GRAY1, fontsize=10, fontweight="bold"
+    bold10_g1 = BoxStyle(
+        fill=GRAY1, fontsize=10, fontweight="bold"
+    )
+    bold10_g2 = BoxStyle(
+        fill=GRAY2, fontsize=10, fontweight="bold"
     )
-    draw_box(ax, bx, 5.0, bw, bh, "Broker", fill=GRAY2, fontsize=10, fontweight="bold")
     draw_box(
-        ax, sx, 5.0, sw, bh, "Subscriber", fill=GRAY1, fontsize=10, fontweight="bold"
+        ax, (px, 5.0), (pw, bh), "Publisher", bold10_g1
+    )
+    draw_box(
+        ax, (bx, 5.0), (bw, bh), "Broker", bold10_g2
+    )
+    draw_box(
+        ax,
+        (sx, 5.0),
+        (sw, bh),
+        "Subscriber",
+        bold10_g1,
     )
 
-    # Timelines
     for xc in [px + pw / 2, bx + bw / 2, sx + sw / 2]:
-        ax.plot([xc, xc], [5.0, 1.2], color=GRAY3, lw=1, linestyle=":")
+        ax.plot(
+            [xc, xc],
+            [5.0, 1.2],
+            color=GRAY3,
+            lw=1,
+            linestyle=":",
+        )
 
     # Scenario A: success
     y = 4.3
-    ax.text(0.2, y + 0.15, "Scenariusz A:", fontsize=8.5, fontweight="bold")
-    draw_arrow(ax, px + pw / 2, y, bx + bw / 2, y, label="MSG", label_fs=9)
-    draw_arrow(ax, bx + bw / 2, y - 0.6, sx + sw / 2, y - 0.6, label="MSG", label_fs=9)
-    draw_check(ax, sx + sw / 2 + 0.4, y - 0.6, size=0.18)
-    ax.text(sx + sw / 2 + 0.7, y - 0.6, "OK", fontsize=9, fontweight="bold")
+    ax.text(
+        0.2,
+        y + 0.15,
+        "Scenariusz A:",
+        fontsize=8.5,
+        fontweight="bold",
+    )
+    msg9 = ArrowCfg(label="MSG", label_fs=9)
+    draw_arrow(
+        ax, (px + pw / 2, y), (bx + bw / 2, y), msg9
+    )
+    draw_arrow(
+        ax,
+        (bx + bw / 2, y - 0.6),
+        (sx + sw / 2, y - 0.6),
+        msg9,
+    )
+    draw_check(ax, (sx + sw / 2 + 0.4, y - 0.6), size=0.18)
+    ax.text(
+        sx + sw / 2 + 0.7,
+        y - 0.6,
+        "OK",
+        fontsize=9,
+        fontweight="bold",
+    )
 
     # Scenario B: lost
     y = 2.6
-    ax.text(0.2, y + 0.15, "Scenariusz B:", fontsize=8.5, fontweight="bold")
-    draw_arrow(ax, px + pw / 2, y, bx + bw / 2, y, label="MSG", label_fs=9)
-    draw_dashed_arrow(ax, bx + bw / 2, y - 0.6, 7.5, y - 0.6)
-    draw_cross(ax, 7.8, y - 0.6, size=0.2)
-    ax.text(8.2, y - 0.55, "UTRACONA", fontsize=9, fontweight="bold")
-    ax.text(8.2, y - 1.0, "(brak retransmisji)", fontsize=8, style="italic")
+    ax.text(
+        0.2,
+        y + 0.15,
+        "Scenariusz B:",
+        fontsize=8.5,
+        fontweight="bold",
+    )
+    draw_arrow(
+        ax, (px + pw / 2, y), (bx + bw / 2, y), msg9
+    )
+    draw_dashed_arrow(
+        ax, (bx + bw / 2, y - 0.6), (7.5, y - 0.6)
+    )
+    draw_cross(ax, (7.8, y - 0.6), size=0.2)
+    ax.text(
+        8.2,
+        y - 0.55,
+        "UTRACONA",
+        fontsize=9,
+        fontweight="bold",
+    )
+    ax.text(
+        8.2,
+        y - 1.0,
+        "(brak retransmisji)",
+        fontsize=8,
+        style="italic",
+    )
 
-    # Summary
     ax.text(
         6.0,
         0.5,
-        "Brak ACK, brak retransmisji. Najszybszy. Use case: logi, metryki, telemetria.",
+        "Brak ACK, brak retransmisji."
+        " Najszybszy. Use case:"
+        " logi, metryki, telemetria.",
         ha="center",
         va="center",
         fontsize=9,
-        bbox={"boxstyle": "round,pad=0.4", "facecolor": GRAY4, "edgecolor": GRAY3},
+        bbox={
+            "boxstyle": "round,pad=0.4",
+            "facecolor": GRAY4,
+            "edgecolor": GRAY3,
+        },
     )
 
     save(fig, "pubsub_qos_at_most_once.png")
@@ -574,7 +918,9 @@ def draw_qos_at_least_once() -> None:
     ax.set_aspect("equal")
     ax.axis("off")
     ax.set_title(
-        'QoS: At-least-once — „powtarzaj aż potwierdzą" (≥1 dostarczenie)',
+        "QoS: At-least-once"
+        " \u2014 \u201epowtarzaj a\u017c potwierdz\u0105\u201d"
+        " (\u22651 dostarczenie)",
         fontsize=FS_TITLE,
         fontweight="bold",
         pad=12,
@@ -583,70 +929,142 @@ def draw_qos_at_least_once() -> None:
     bx, bw = 3.5, 2.2
     sx, sw = 8.0, 2.2
     bh = 0.8
-    draw_box(ax, bx, 5.5, bw, bh, "Broker", fill=GRAY2, fontsize=10, fontweight="bold")
     draw_box(
-        ax, sx, 5.5, sw, bh, "Subscriber", fill=GRAY1, fontsize=10, fontweight="bold"
+        ax,
+        (bx, 5.5),
+        (bw, bh),
+        "Broker",
+        BoxStyle(
+            fill=GRAY2, fontsize=10, fontweight="bold"
+        ),
+    )
+    draw_box(
+        ax,
+        (sx, 5.5),
+        (sw, bh),
+        "Subscriber",
+        BoxStyle(
+            fill=GRAY1, fontsize=10, fontweight="bold"
+        ),
     )
 
-    # Timelines
     for xc in [bx + bw / 2, sx + sw / 2]:
-        ax.plot([xc, xc], [5.5, 0.8], color=GRAY3, lw=1, linestyle=":")
+        ax.plot(
+            [xc, xc],
+            [5.5, 0.8],
+            color=GRAY3,
+            lw=1,
+            linestyle=":",
+        )
 
     # Step 1: send MSG
     y1 = 4.8
-    draw_arrow(ax, bx + bw / 2, y1, sx + sw / 2, y1, label="MSG #1", label_fs=9)
-    draw_check(ax, sx + sw + 0.2, y1, size=0.15)
+    draw_arrow(
+        ax,
+        (bx + bw / 2, y1),
+        (sx + sw / 2, y1),
+        ArrowCfg(label="MSG #1", label_fs=9),
+    )
+    draw_check(ax, (sx + sw + 0.2, y1), size=0.15)
     ax.text(sx + sw + 0.5, y1, "odebrano", fontsize=8)
 
     # Step 2: ACK lost
     y2 = 3.9
-    draw_dashed_arrow(ax, sx + sw / 2, y2, bx + bw + 1.2, y2)
-    ax.text((bx + bw / 2 + sx + sw / 2) / 2, y2 + 0.18, "ACK", fontsize=9)
-    draw_cross(ax, bx + bw + 0.8, y2, size=0.18)
-    ax.text(bx + 0.3, y2 - 0.35, "ACK utracony!", fontsize=8.5, style="italic")
+    draw_dashed_arrow(
+        ax,
+        (sx + sw / 2, y2),
+        (bx + bw + 1.2, y2),
+    )
+    ax.text(
+        (bx + bw / 2 + sx + sw / 2) / 2,
+        y2 + 0.18,
+        "ACK",
+        fontsize=9,
+    )
+    draw_cross(ax, (bx + bw + 0.8, y2), size=0.18)
+    ax.text(
+        bx + 0.3,
+        y2 - 0.35,
+        "ACK utracony!",
+        fontsize=8.5,
+        style="italic",
+    )
 
-    # Step 3: timeout → retry
+    # Step 3: timeout -> retry
     y3 = 2.9
     ax.text(
-        bx + bw / 2, y3 + 0.45, "timeout...", fontsize=8.5, style="italic", ha="center"
+        bx + bw / 2,
+        y3 + 0.45,
+        "timeout...",
+        fontsize=8.5,
+        style="italic",
+        ha="center",
+    )
+    draw_arrow(
+        ax,
+        (bx + bw / 2, y3),
+        (sx + sw / 2, y3),
+        ArrowCfg(label="MSG #1 (retry)", label_fs=9),
+    )
+    draw_check(ax, (sx + sw + 0.2, y3), size=0.15)
+    ax.text(
+        sx + sw + 0.5,
+        y3,
+        "odebrano\n(ponownie!)",
+        fontsize=8,
     )
-    draw_arrow(ax, bx + bw / 2, y3, sx + sw / 2, y3, label="MSG #1 (retry)", label_fs=9)
-    draw_check(ax, sx + sw + 0.2, y3, size=0.15)
-    ax.text(sx + sw + 0.5, y3, "odebrano\n(ponownie!)", fontsize=8)
 
     # Step 4: ACK ok
     y4 = 2.0
-    draw_arrow(ax, sx + sw / 2, y4, bx + bw / 2, y4, label="ACK", label_fs=9)
-    draw_check(ax, bx + bw / 2 - 0.5, y4, size=0.18)
+    draw_arrow(
+        ax,
+        (sx + sw / 2, y4),
+        (bx + bw / 2, y4),
+        ArrowCfg(label="ACK", label_fs=9),
+    )
+    draw_check(ax, (bx + bw / 2 - 0.5, y4), size=0.18)
 
     # Duplicate bracket
     ax.annotate(
         "",
         xy=(sx + sw + 1.3, y1),
         xytext=(sx + sw + 1.3, y3),
-        arrowprops={"arrowstyle": "<->", "color": "black", "lw": 1.2},
+        arrowprops={
+            "arrowstyle": "<->",
+            "color": "black",
+            "lw": 1.2,
+        },
     )
     ax.text(
         sx + sw + 1.6,
         (y1 + y3) / 2,
-        "DUPLIKAT!\nSubscriber\notrzymał 2x",
+        "DUPLIKAT!\nSubscriber\notrzyma\u0142 2x",
         fontsize=9,
         ha="left",
         va="center",
         fontweight="bold",
-        bbox={"boxstyle": "round,pad=0.25", "facecolor": GRAY4, "edgecolor": GRAY3},
+        bbox={
+            "boxstyle": "round,pad=0.25",
+            "facecolor": GRAY4,
+            "edgecolor": GRAY3,
+        },
     )
 
-    # Summary
     ax.text(
         6.0,
         0.5,
-        "Broker czeka na ACK, retransmituje po timeout. Mogą być duplikaty!\n"
-        "Use case: zamówienia, płatności (subscriber musi być idempotentny).",
+        "Broker czeka na ACK, retransmituje"
+        " po timeout. Mog\u0105 by\u0107 duplikaty!\n"
+        "Use case: zam\u00f3wienia, p\u0142atno\u015bci"
+        " (subscriber musi by\u0107 idempotentny).",
         ha="center",
         va="center",
         fontsize=9,
-        bbox={"boxstyle": "round,pad=0.4", "facecolor": GRAY4, "edgecolor": GRAY3},
+        bbox={
+            "boxstyle": "round,pad=0.4",
+            "facecolor": GRAY4,
+            "edgecolor": GRAY3,
+        },
     )
 
     save(fig, "pubsub_qos_at_least_once.png")
@@ -663,7 +1081,8 @@ def draw_qos_exactly_once() -> None:
     ax.set_aspect("equal")
     ax.axis("off")
     ax.set_title(
-        "QoS: Exactly-once — 4-krokowy handshake (dokładnie 1 dostarczenie)",
+        "QoS: Exactly-once \u2014 4-krokowy"
+        " handshake (dok\u0142adnie 1 dostarczenie)",
         fontsize=FS_TITLE,
         fontweight="bold",
         pad=12,
@@ -672,30 +1091,65 @@ def draw_qos_exactly_once() -> None:
     bx, bw = 2.5, 2.2
     sx, sw = 7.5, 2.2
     bh = 0.8
-    draw_box(ax, bx, 6.0, bw, bh, "Broker", fill=GRAY2, fontsize=10, fontweight="bold")
     draw_box(
-        ax, sx, 6.0, sw, bh, "Subscriber", fill=GRAY1, fontsize=10, fontweight="bold"
+        ax,
+        (bx, 6.0),
+        (bw, bh),
+        "Broker",
+        BoxStyle(
+            fill=GRAY2, fontsize=10, fontweight="bold"
+        ),
+    )
+    draw_box(
+        ax,
+        (sx, 6.0),
+        (sw, bh),
+        "Subscriber",
+        BoxStyle(
+            fill=GRAY1, fontsize=10, fontweight="bold"
+        ),
     )
 
-    # Timelines
     for xc in [bx + bw / 2, sx + sw / 2]:
-        ax.plot([xc, xc], [6.0, 1.0], color=GRAY3, lw=1, linestyle=":")
+        ax.plot(
+            [xc, xc],
+            [6.0, 1.0],
+            color=GRAY3,
+            lw=1,
+            linestyle=":",
+        )
 
-    # 4-step handshake
     steps = [
-        (5.2, "right", "PUBLISH  (msg_id=42)", "Broker wysyła wiadomość"),
+        (
+            5.2,
+            "right",
+            "PUBLISH  (msg_id=42)",
+            "Broker wysy\u0142a wiadomo\u015b\u0107",
+        ),
         (
             4.2,
             "left",
-            "PUBREC  (otrzymałem id=42)",
-            "Sub potwierdza odbiór, zapisuje id",
+            "PUBREC  (otrzyma\u0142em id=42)",
+            "Sub potwierdza odbi\u00f3r,"
+            " zapisuje id",
+        ),
+        (
+            3.2,
+            "right",
+            "PUBREL  (mo\u017cesz przetworzy\u0107)",
+            "Broker zwalnia wiadomo\u015b\u0107",
+        ),
+        (
+            2.2,
+            "left",
+            "PUBCOMP  (zako\u0144czone)",
+            "Sub potwierdza przetworzenie",
         ),
-        (3.2, "right", "PUBREL  (możesz przetworzyć)", "Broker zwalnia wiadomość"),
-        (2.2, "left", "PUBCOMP  (zakończone)", "Sub potwierdza przetworzenie"),
     ]
 
-    for i, (y, direction, label, desc) in enumerate(steps):
-        # Step number
+    for i, (y, direction, label, desc) in enumerate(
+        steps
+    ):
         ax.text(
             bx + bw / 2 - 0.7,
             y,
@@ -704,29 +1158,54 @@ def draw_qos_exactly_once() -> None:
             fontweight="bold",
             ha="center",
             va="center",
-            bbox={"boxstyle": "circle,pad=0.18", "facecolor": GRAY3, "edgecolor": LN},
+            bbox={
+                "boxstyle": "circle,pad=0.18",
+                "facecolor": GRAY3,
+                "edgecolor": LN,
+            },
         )
 
         if direction == "right":
-            draw_arrow(ax, bx + bw / 2, y, sx + sw / 2, y, label=label, label_fs=9)
+            draw_arrow(
+                ax,
+                (bx + bw / 2, y),
+                (sx + sw / 2, y),
+                ArrowCfg(label=label, label_fs=9),
+            )
         else:
-            draw_arrow(ax, sx + sw / 2, y, bx + bw / 2, y, label=label, label_fs=9)
+            draw_arrow(
+                ax,
+                (sx + sw / 2, y),
+                (bx + bw / 2, y),
+                ArrowCfg(label=label, label_fs=9),
+            )
 
-        # Side description
         ax.text(
-            sx + sw + 0.3, y, desc, fontsize=8, ha="left", va="center", style="italic"
+            sx + sw + 0.3,
+            y,
+            desc,
+            fontsize=8,
+            ha="left",
+            va="center",
+            style="italic",
         )
 
-    # Summary
     ax.text(
         6.0,
         0.6,
-        "Deduplikacja po msg_id. Sub nie przetwarza przed PUBREL.\n"
-        "Najkosztowniejszy (4 pakiety). Use case: transakcje finansowe, krytyczne zdarzenia.",
+        "Deduplikacja po msg_id."
+        " Sub nie przetwarza przed PUBREL.\n"
+        "Najkosztowniejszy (4 pakiety)."
+        " Use case: transakcje finansowe,"
+        " krytyczne zdarzenia.",
         ha="center",
         va="center",
         fontsize=9,
-        bbox={"boxstyle": "round,pad=0.4", "facecolor": GRAY4, "edgecolor": GRAY3},
+        bbox={
+            "boxstyle": "round,pad=0.4",
+            "facecolor": GRAY4,
+            "edgecolor": GRAY3,
+        },
     )
 
     save(fig, "pubsub_qos_exactly_once.png")
@@ -736,7 +1215,10 @@ def draw_qos_exactly_once() -> None:
 # Main
 # ============================================================
 if __name__ == "__main__":
-    print("Generating Pub/Sub diagrams (7 separate images)...")
+    logger.info(
+        "Generating Pub/Sub diagrams"
+        " (7 separate images)..."
+    )
     draw_sub_topic()
     draw_sub_content()
     draw_sub_type()
@@ -744,4 +1226,4 @@ if __name__ == "__main__":
     draw_qos_at_most_once()
     draw_qos_at_least_once()
     draw_qos_exactly_once()
-    print("Done!")
+    logger.info("Done!")