mirror of
https://github.com/kuhyx/praca_magisterska.git
synced 2026-07-04 12:03:01 +02:00
332 lines
13 KiB
Python
332 lines
13 KiB
Python
#!/usr/bin/env python3
|
||
"""
|
||
Anki Generator - Modular approach with 3 combinable strategies.
|
||
|
||
Usage:
|
||
python anki_generator.py [options]
|
||
|
||
Options:
|
||
--filter Apply strict filtering (answers > 100 chars)
|
||
--extract Use improved extraction algorithm
|
||
--main-only Only generate main exam questions (45 comprehensive cards)
|
||
|
||
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
|
||
"""
|
||
|
||
import os
|
||
import re
|
||
import argparse
|
||
from pathlib import Path
|
||
|
||
# =============================================================================
|
||
# SHARED UTILITIES
|
||
# =============================================================================
|
||
|
||
def clean_text(text):
|
||
"""Clean and format text for Anki."""
|
||
if not text:
|
||
return ""
|
||
text = re.sub(r'\*\*(.+?)\*\*', r'<b>\1</b>', text)
|
||
text = re.sub(r'(?<!\*)\*([^*]+)\*(?!\*)', r'<i>\1</i>', text)
|
||
text = text.replace('\t', ' ')
|
||
text = text.replace('"', '"')
|
||
text = re.sub(r' +', ' ', text)
|
||
return text.strip()
|
||
|
||
def get_file_metadata(filepath):
|
||
"""Extract question number and subject from filename."""
|
||
filename = os.path.basename(filepath)
|
||
match = re.match(r'(\d+)-(.+)\.md', filename)
|
||
num = match.group(1) if match else "00"
|
||
|
||
with open(filepath, 'r', encoding='utf-8') as f:
|
||
content = f.read()
|
||
|
||
subj_match = re.search(r'Przedmiot:\s*(\w+)', content)
|
||
subject = subj_match.group(1) if subj_match else "Ogólne"
|
||
|
||
return num, subject, content
|
||
|
||
def get_main_question(content):
|
||
"""Extract the main exam question."""
|
||
q_match = re.search(r'## Pytanie\s*\n\s*\*\*["\']?(.+?)["\']?\*\*', content, re.DOTALL)
|
||
if q_match:
|
||
return re.sub(r'\s+', ' ', q_match.group(1).strip())
|
||
return None
|
||
|
||
# =============================================================================
|
||
# APPROACH 1: STRICT FILTERING
|
||
# =============================================================================
|
||
|
||
def apply_strict_filter(cards, min_length=100):
|
||
"""Filter cards to only include those with answers > min_length characters."""
|
||
return [c for c in cards if len(c['back']) > min_length]
|
||
|
||
# =============================================================================
|
||
# APPROACH 2: BETTER EXTRACTION
|
||
# =============================================================================
|
||
|
||
def extract_structured_content(body):
|
||
"""Improved extraction - multiple content types with better formatting."""
|
||
parts = []
|
||
|
||
# 1. Definitions
|
||
def_match = re.search(r'#### Definicja[^\n]*\n([^\n#]+)', body)
|
||
if def_match:
|
||
parts.append(f"<b>Definicja:</b> {def_match.group(1).strip()}")
|
||
|
||
# 2. Bullet points with bold terms
|
||
bullets = re.findall(r'[-•]\s*\*\*([^*]+)\*\*[:\s-]*([^\n]*)', body)
|
||
for term, desc in bullets[:5]:
|
||
if desc.strip():
|
||
parts.append(f"• <b>{term}</b>: {desc.strip()}")
|
||
else:
|
||
parts.append(f"• <b>{term}</b>")
|
||
|
||
# 3. Key-value patterns
|
||
if len(parts) < 2:
|
||
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()}"
|
||
if entry not in parts:
|
||
parts.append(entry)
|
||
|
||
# 4. Paragraphs as fallback
|
||
if not parts:
|
||
paras = [p.strip() for p in body.split('\n\n')
|
||
if p.strip() and not p.startswith('```') and not p.startswith('|') and len(p.strip()) > 30]
|
||
for p in paras[:2]:
|
||
parts.append(p[:300])
|
||
|
||
return '<br>'.join([clean_text(p) for p in parts]) if parts else None
|
||
|
||
def extract_cards_better(filepath):
|
||
"""Extract cards with improved algorithm."""
|
||
num, subject, content = get_file_metadata(filepath)
|
||
base_tags = f"egzamin pyt{num} {subject}"
|
||
cards = []
|
||
|
||
# Main question
|
||
main_q = get_main_question(content)
|
||
if main_q:
|
||
answer_match = re.search(r'## 📚 Odpowiedź główna\s*\n(.+?)(?=\n## [^<5E>]|\Z)', content, re.DOTALL)
|
||
if answer_match:
|
||
answer = extract_structured_content(answer_match.group(1))
|
||
if answer:
|
||
cards.append({'front': clean_text(main_q), 'back': answer, 'tags': f"{base_tags} main"})
|
||
|
||
# Detail sections
|
||
sections = re.findall(r'^### (?:\d+\.\s*)?([^\n]+)\n((?:(?!^### ).)*)', content, re.MULTILINE | re.DOTALL)
|
||
for header, body in sections:
|
||
header = header.strip()
|
||
if 'Przykład' in header or '"' in header or 'Mnemonic' in header or len(body) < 50:
|
||
continue
|
||
|
||
answer = extract_structured_content(body)
|
||
if answer:
|
||
cards.append({'front': f"Wyjaśnij: {clean_text(header)}", 'back': answer, 'tags': f"{base_tags} detail"})
|
||
|
||
return cards
|
||
|
||
def extract_cards_basic(filepath):
|
||
"""Basic extraction - simpler algorithm."""
|
||
num, subject, content = get_file_metadata(filepath)
|
||
base_tags = f"egzamin pyt{num} {subject}"
|
||
cards = []
|
||
|
||
# Main question - just headers
|
||
main_q = get_main_question(content)
|
||
if main_q:
|
||
answer_match = re.search(r'## 📚 Odpowiedź główna\s*\n(.+?)(?=\n## |\Z)', content, re.DOTALL)
|
||
if answer_match:
|
||
headers = re.findall(r'^### (?:\d+\.\s*)?(.+)$', answer_match.group(1), re.MULTILINE)
|
||
if headers:
|
||
answer = '<ul>' + ''.join([f'<li>{clean_text(h)}</li>' for h in headers[:6]]) + '</ul>'
|
||
cards.append({'front': clean_text(main_q), 'back': answer, 'tags': f"{base_tags} main"})
|
||
|
||
# Detail sections - first paragraph only
|
||
sections = re.findall(r'^### (?:\d+\.\s*)?([^\n]+)\n((?:(?!^### ).)*)', 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:
|
||
continue
|
||
|
||
paras = [p.strip() for p in body.split('\n\n') if p.strip() and not p.startswith('```')]
|
||
if paras:
|
||
answer = clean_text(paras[0][:400])
|
||
cards.append({'front': f"Wyjaśnij: {clean_text(header)}", 'back': answer, 'tags': f"{base_tags} detail"})
|
||
|
||
return cards
|
||
|
||
# =============================================================================
|
||
# APPROACH 3: MAIN QUESTIONS ONLY
|
||
# =============================================================================
|
||
|
||
def extract_main_only(filepath):
|
||
"""Extract only the main exam question with comprehensive answer."""
|
||
num, subject, content = get_file_metadata(filepath)
|
||
base_tags = f"egzamin pyt{num} {subject} main"
|
||
|
||
main_q = get_main_question(content)
|
||
if not main_q:
|
||
return []
|
||
|
||
# Build comprehensive answer from multiple sections
|
||
answer_parts = []
|
||
|
||
# Get main answer section
|
||
answer_match = re.search(r'## 📚 Odpowiedź główna\s*\n(.+?)(?=\n## [^<5E>]|\Z)', content, re.DOTALL)
|
||
if answer_match:
|
||
section = answer_match.group(1)
|
||
|
||
# Get all ### headers with their first substantive content
|
||
headers = re.findall(r'^### (?:\d+\.\s*)?([^\n]+)\n((?:(?!^### ).)*)', section, 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:
|
||
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()
|
||
|
||
if key_point:
|
||
answer_parts.append(f"<b>{header}</b>: {key_point}")
|
||
|
||
if answer_parts:
|
||
answer = '<br><br>'.join([clean_text(p) for p in answer_parts])
|
||
return [{'front': clean_text(main_q), 'back': answer, 'tags': base_tags}]
|
||
|
||
return []
|
||
|
||
# =============================================================================
|
||
# MAIN GENERATOR
|
||
# =============================================================================
|
||
|
||
def generate_anki(use_filter=False, use_better_extract=False, main_only=False):
|
||
"""Generate Anki deck with specified approaches."""
|
||
odpowiedzi_dir = Path("/home/kuchy/praca_magisterska/pytania/odpowiedzi")
|
||
|
||
# Determine output filename based on options
|
||
suffix_parts = []
|
||
if use_filter:
|
||
suffix_parts.append("filter")
|
||
if use_better_extract:
|
||
suffix_parts.append("extract")
|
||
if main_only:
|
||
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")
|
||
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)
|
||
|
||
# Approach 1: Apply filtering if requested
|
||
if use_filter:
|
||
all_cards = apply_strict_filter(all_cards, min_length=100)
|
||
|
||
# Remove duplicates
|
||
seen = set()
|
||
unique = []
|
||
for c in all_cards:
|
||
key = c['front'][:80]
|
||
if key not in seen:
|
||
seen.add(key)
|
||
unique.append(c)
|
||
|
||
# Write output
|
||
with open(output_file, 'w', encoding='utf-8') as f:
|
||
f.write(f"#separator:Tab\n#html:true\n#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()
|
||
|
||
return output_file
|
||
|
||
def main():
|
||
parser = argparse.ArgumentParser(description="Generate Anki flashcards with modular approaches")
|
||
parser.add_argument('--filter', action='store_true', help='Approach 1: Strict filtering (>100 chars)')
|
||
parser.add_argument('--extract', action='store_true', help='Approach 2: Better extraction algorithm')
|
||
parser.add_argument('--main-only', action='store_true', help='Approach 3: Main exam questions only')
|
||
parser.add_argument('--all-combinations', action='store_true', help='Generate all 7 combinations')
|
||
|
||
args = parser.parse_args()
|
||
|
||
if args.all_combinations:
|
||
# Generate all 7 combinations
|
||
print("=" * 60)
|
||
print("Generating all 7 combinations...")
|
||
print("=" * 60 + "\n")
|
||
|
||
combinations = [
|
||
(True, False, False), # 1: Filter only
|
||
(False, True, False), # 2: Extract only
|
||
(False, False, True), # 3: Main only
|
||
(True, True, False), # 4: Filter + Extract
|
||
(True, False, True), # 5: Filter + Main
|
||
(False, True, True), # 6: Extract + Main
|
||
(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)
|
||
else:
|
||
generate_anki(
|
||
use_filter=args.filter,
|
||
use_better_extract=args.extract,
|
||
main_only=args.main_only
|
||
)
|
||
|
||
if __name__ == "__main__":
|
||
main()
|