mirror of
https://github.com/kuhyx/testsAndMisc-archive.git
synced 2026-07-04 13:23:01 +02:00
Krzysztof kuhy Rudnicki
2a61619001
- Replace module-level globals with _mp_state dict (PLW0603) - Use hashlib.sha256 instead of md5 (S324) - Use secrets.randbelow instead of random.randrange (S311) - Use tempfile.gettempdir() instead of hardcoded /tmp (S108) - Replace assert statements with RuntimeError (S101)
358 lines
9.7 KiB
Python
Executable File
358 lines
9.7 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
"""Anki flashcard generator for Warsaw districts.
|
|
|
|
Generates Anki-compatible flashcard decks with maps showing individual
|
|
Warsaw districts (dzielnice) with their borders using real boundary data
|
|
from OpenStreetMap.
|
|
|
|
Usage:
|
|
# Generate Anki cards for all Warsaw districts
|
|
python -m python_pkg.anki_decks.warsaw_districts.warsaw_districts_anki
|
|
|
|
# Specify custom output file
|
|
python -m python_pkg.anki_decks.warsaw_districts.warsaw_districts_anki \
|
|
--output warsaw.apkg
|
|
|
|
Output:
|
|
Creates a self-contained .apkg file that can be directly imported into Anki.
|
|
The file includes all images embedded, so no manual file copying is needed.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
import hashlib
|
|
from io import BytesIO
|
|
from pathlib import Path
|
|
import secrets
|
|
import sys
|
|
import tempfile
|
|
from typing import TYPE_CHECKING
|
|
|
|
import genanki
|
|
import geopandas as gpd
|
|
import matplotlib.pyplot as plt
|
|
|
|
if TYPE_CHECKING:
|
|
from collections.abc import Sequence
|
|
|
|
from matplotlib.figure import Figure
|
|
|
|
|
|
# Path to GeoJSON file with Warsaw district boundaries
|
|
GEOJSON_PATH = Path(__file__).parent / "warszawa-dzielnice.geojson"
|
|
|
|
|
|
def load_district_data() -> gpd.GeoDataFrame:
|
|
"""Load Warsaw district boundaries from GeoJSON.
|
|
|
|
Returns:
|
|
GeoDataFrame with district boundaries.
|
|
"""
|
|
if not GEOJSON_PATH.exists():
|
|
msg = f"GeoJSON file not found at {GEOJSON_PATH}"
|
|
raise FileNotFoundError(msg)
|
|
|
|
gdf = gpd.read_file(GEOJSON_PATH)
|
|
# Filter out the "Warszawa" entry (whole city) and keep only districts
|
|
return gdf[gdf["name"] != "Warszawa"].copy()
|
|
|
|
|
|
def get_district_names() -> list[str]:
|
|
"""Get list of all district names from GeoJSON data.
|
|
|
|
Returns:
|
|
Sorted list of district names.
|
|
"""
|
|
gdf = load_district_data()
|
|
return sorted(gdf["name"].tolist())
|
|
|
|
|
|
# Load district names from actual data
|
|
WARSAW_DISTRICTS = get_district_names()
|
|
|
|
|
|
# 18 unique distinct colors for all Warsaw districts
|
|
# Chosen to be visually distinct from each other in both light and dark modes
|
|
DISTRICT_COLORS = [
|
|
"#E74C3C", # Red
|
|
"#3498DB", # Blue
|
|
"#2ECC71", # Emerald green
|
|
"#9B59B6", # Purple
|
|
"#F39C12", # Orange
|
|
"#1ABC9C", # Turquoise
|
|
"#E91E63", # Pink
|
|
"#00BCD4", # Cyan
|
|
"#8BC34A", # Light green
|
|
"#FF5722", # Deep orange
|
|
"#673AB7", # Deep purple
|
|
"#FFEB3B", # Yellow
|
|
"#795548", # Brown
|
|
"#607D8B", # Blue grey
|
|
"#CDDC39", # Lime
|
|
"#FF9800", # Amber
|
|
"#4CAF50", # Green
|
|
"#03A9F4", # Light blue
|
|
]
|
|
|
|
|
|
def create_district_map(district_name: str) -> Figure:
|
|
"""Create a map showing Warsaw with one district highlighted.
|
|
|
|
The map shows Warsaw as a plain shape (no internal district borders)
|
|
with only the target district highlighted in color with a bold border.
|
|
This makes it harder to guess the district using contextual cues.
|
|
|
|
Args:
|
|
district_name: Name of the district to highlight.
|
|
|
|
Returns:
|
|
A matplotlib Figure object.
|
|
"""
|
|
# Load all district data
|
|
gdf = load_district_data()
|
|
|
|
# Create figure with transparent background
|
|
fig, ax = plt.subplots(figsize=(10, 10))
|
|
ax.set_aspect("equal")
|
|
ax.axis("off")
|
|
fig.patch.set_alpha(0)
|
|
ax.patch.set_alpha(0)
|
|
|
|
# Find the target district
|
|
target = gdf[gdf["name"] == district_name]
|
|
if len(target) == 0:
|
|
msg = f"District {district_name} not found in data"
|
|
raise ValueError(msg)
|
|
|
|
# Create unified Warsaw shape by dissolving all districts
|
|
warsaw_unified = gdf.union_all()
|
|
|
|
# Plot Warsaw as a plain gray shape (no internal borders)
|
|
warsaw_gdf = gpd.GeoDataFrame(geometry=[warsaw_unified], crs=gdf.crs)
|
|
warsaw_gdf.plot(ax=ax, color="#D5D8DC", alpha=0.6)
|
|
warsaw_gdf.boundary.plot(ax=ax, color="#2C3E50", linewidth=2)
|
|
|
|
# Assign colors to districts based on sorted names for consistency
|
|
sorted_names = sorted(gdf["name"].tolist())
|
|
color_map = {
|
|
name: DISTRICT_COLORS[i % len(DISTRICT_COLORS)]
|
|
for i, name in enumerate(sorted_names)
|
|
}
|
|
|
|
# Highlight only the target district with bright color and bold border
|
|
fill_color = color_map[district_name]
|
|
target.plot(ax=ax, color=fill_color, alpha=0.9)
|
|
target.boundary.plot(ax=ax, color="#1A1A1A", linewidth=4)
|
|
|
|
# Set tight layout
|
|
ax.set_xlim(gdf.total_bounds[0], gdf.total_bounds[2])
|
|
ax.set_ylim(gdf.total_bounds[1], gdf.total_bounds[3])
|
|
|
|
return fig
|
|
|
|
|
|
def generate_district_image_bytes(district_name: str) -> bytes:
|
|
"""Generate a district map image as bytes.
|
|
|
|
Args:
|
|
district_name: Name of the district to visualize.
|
|
|
|
Returns:
|
|
PNG image data as bytes.
|
|
"""
|
|
fig = create_district_map(district_name)
|
|
|
|
# Save to bytes buffer
|
|
buf = BytesIO()
|
|
fig.savefig(buf, format="png", bbox_inches="tight", dpi=150)
|
|
plt.close(fig)
|
|
buf.seek(0)
|
|
|
|
return buf.read()
|
|
|
|
|
|
def generate_anki_package(
|
|
deck_name: str = "Warsaw Districts",
|
|
) -> genanki.Package:
|
|
"""Generate Anki package (.apkg) for Warsaw districts.
|
|
|
|
Args:
|
|
deck_name: Name for the Anki deck.
|
|
|
|
Returns:
|
|
genanki.Package object ready to be written to file.
|
|
"""
|
|
# Create a unique model ID based on deck name
|
|
model_id_hash = hashlib.sha256(
|
|
f"warsaw_districts_{deck_name}".encode()
|
|
)
|
|
model_id = int(model_id_hash.hexdigest()[:8], 16)
|
|
|
|
# Define the note model (card template) with centered styling
|
|
card_css = """
|
|
.card {
|
|
font-family: Arial, sans-serif;
|
|
font-size: 24px;
|
|
text-align: center;
|
|
color: #333;
|
|
background-color: #fff;
|
|
}
|
|
.card.night_mode {
|
|
color: #eee;
|
|
background-color: #2f2f2f;
|
|
}
|
|
.map-container {
|
|
display: flex;
|
|
justify-content: center;
|
|
align-items: center;
|
|
min-height: 80vh;
|
|
}
|
|
.map-container img {
|
|
max-width: 100%;
|
|
max-height: 80vh;
|
|
object-fit: contain;
|
|
}
|
|
.answer-text {
|
|
font-size: 32px;
|
|
font-weight: bold;
|
|
margin-top: 20px;
|
|
color: #2C3E50;
|
|
}
|
|
.card.night_mode .answer-text {
|
|
color: #ECF0F1;
|
|
}
|
|
"""
|
|
|
|
my_model = genanki.Model(
|
|
model_id,
|
|
"Warsaw District Model",
|
|
fields=[
|
|
{"name": "DistrictMap"},
|
|
{"name": "DistrictName"},
|
|
],
|
|
templates=[
|
|
{
|
|
"name": "Card 1",
|
|
"qfmt": '<div class="map-container">{{DistrictMap}}</div>',
|
|
"afmt": '<div class="map-container">{{DistrictMap}}</div>'
|
|
'<hr id="answer">'
|
|
'<div class="answer-text">{{DistrictName}}</div>',
|
|
},
|
|
],
|
|
css=card_css,
|
|
)
|
|
|
|
# Create a unique deck ID based on deck name
|
|
deck_id = secrets.randbelow(1 << 30) + (1 << 30)
|
|
|
|
# Create the deck
|
|
my_deck = genanki.Deck(deck_id, deck_name)
|
|
|
|
# Store media files
|
|
media_files = []
|
|
|
|
# Generate notes for each district
|
|
for district_name in WARSAW_DISTRICTS:
|
|
# Generate image
|
|
image_data = generate_district_image_bytes(district_name)
|
|
|
|
# Create unique filename
|
|
filename = f"{district_name.replace(' ', '_').replace('-', '_')}.png"
|
|
|
|
# Create note
|
|
note = genanki.Note(
|
|
model=my_model,
|
|
fields=[
|
|
f'<img src="{filename}">',
|
|
district_name,
|
|
],
|
|
tags=["geography", "warsaw", "poland"],
|
|
)
|
|
|
|
my_deck.add_note(note)
|
|
|
|
# Save image data to temporary file for packaging
|
|
temp_path = Path(tempfile.gettempdir()) / filename
|
|
temp_path.write_bytes(image_data)
|
|
media_files.append(str(temp_path))
|
|
|
|
# Create package
|
|
package = genanki.Package(my_deck)
|
|
package.media_files = media_files
|
|
|
|
return package
|
|
|
|
|
|
def main(argv: Sequence[str] | None = None) -> int:
|
|
"""Main entry point.
|
|
|
|
Args:
|
|
argv: Command line arguments.
|
|
|
|
Returns:
|
|
Exit code.
|
|
"""
|
|
parser = argparse.ArgumentParser(
|
|
description="Generate Anki flashcards for Warsaw districts.",
|
|
formatter_class=argparse.RawDescriptionHelpFormatter,
|
|
epilog=__doc__,
|
|
)
|
|
|
|
parser.add_argument(
|
|
"--output",
|
|
"-o",
|
|
type=str,
|
|
default=None,
|
|
help="Output file path (default: warsaw_districts.apkg)",
|
|
)
|
|
parser.add_argument(
|
|
"--deck-name",
|
|
"-d",
|
|
type=str,
|
|
default="Warsaw Districts",
|
|
help="Name for the Anki deck (default: 'Warsaw Districts')",
|
|
)
|
|
|
|
args = parser.parse_args(argv)
|
|
|
|
# Determine output path
|
|
output_path = Path(args.output) if args.output else Path("warsaw_districts.apkg")
|
|
|
|
try:
|
|
num_districts = len(WARSAW_DISTRICTS)
|
|
sys.stdout.write(
|
|
f"Generating flashcards for {num_districts} Warsaw districts...\n"
|
|
)
|
|
sys.stdout.write("Using real district boundaries from OpenStreetMap data.\n")
|
|
|
|
# Generate the package
|
|
package = generate_anki_package(args.deck_name)
|
|
|
|
# Write to file
|
|
package.write_to_file(str(output_path))
|
|
|
|
sys.stdout.write("\n")
|
|
sys.stdout.write("=" * 60 + "\n")
|
|
sys.stdout.write("FLASHCARD GENERATION COMPLETE\n")
|
|
sys.stdout.write("=" * 60 + "\n")
|
|
sys.stdout.write(f"Districts: {num_districts}\n")
|
|
sys.stdout.write(f"Output file: {output_path.absolute()}\n")
|
|
sys.stdout.write("\n")
|
|
sys.stdout.write("To import into Anki:\n")
|
|
sys.stdout.write(" 1. Open Anki\n")
|
|
sys.stdout.write(" 2. File -> Import\n")
|
|
sys.stdout.write(f" 3. Select: {output_path.absolute()}\n")
|
|
sys.stdout.write(" 4. Click Import\n")
|
|
sys.stdout.write("\n")
|
|
sys.stdout.write("All images are embedded in the .apkg file!\n")
|
|
except (OSError, ValueError) as e:
|
|
sys.stderr.write(f"Error: {e}\n")
|
|
return 1
|
|
else:
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main())
|