kuhyx/testsAndMisc-archive
1
0
Fork 0
mirror of https://github.com/kuhyx/testsAndMisc-archive.git synced 2026-07-04 12:43:15 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

feat(screen_locker): harden table tennis verification, remove running option

Browse Source 
- Remove 'Running' workout option (too easy to fake)
- Add MIN_TABLE_TENNIS_SETS=15 minimum requirement
- Add MIN_POINTS_PER_SET=11 mathematical cross-check
- Add TABLE_TENNIS_SUBMIT_DELAY=60 (increased from 30)
- Add verification question before unlock (total points/avg/diff)
- Require minimum duration per set (2 min/set)
This commit is contained in:
Krzysztof kuhy Rudnicki 2026-02-02 21:38:52 +01:00
parent 2994be42a8
commit c8c4782271
4 changed files with 887 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
python_pkg/cinema_planner/__init__.py Normal file
View File

@ -0,0 +1 @@
# Cinema Planner package initialization

176
python_pkg/cinema_planner/cinema_plan_2026-01-25.txt Normal file
View File

@ -0,0 +1,176 @@
Generated: 2026-01-25
Movies considered: 27
Buffer time: 0 minutes
Excluded genres: horror
============================================================
OPTIMAL CINEMA SCHEDULES - 2026-01-25
8 movies, 1482 possible combination(s)
============================================================
────────────────────────────────────────────────────────────
OPTION 1:
────────────────────────────────────────────────────────────
1. 10:00 - 11:50 Wielka Warszawska
Duration: 1h 50m (movie starts ~10:15)
[10 min break]
2. 12:00 - 13:27 Szybcy i sprytni
Duration: 1h 27m (movie starts ~12:15)
3. 13:20 - 14:57 Anzu. Kot duch
Duration: 1h 37m (movie starts ~13:35)
[3 min break]
4. 15:00 - 16:38 Psoty
Duration: 1h 38m (movie starts ~15:15)
[12 min break]
5. 16:50 - 18:33 Wysokie i niskie tony
Duration: 1h 43m (movie starts ~17:05)
6. 18:20 - 19:50 90 minut do wolności
Duration: 1h 30m (movie starts ~18:35)
[30 min break]
7. 20:20 - 22:25 Hamnet
Duration: 2h 5m (movie starts ~20:35)
[5 min break]
8. 22:30 - 24:10 Anakonda
Duration: 1h 40m (movie starts ~22:45)
────────────────────────────────────────────────────────────
OPTION 2:
────────────────────────────────────────────────────────────
1. 10:00 - 11:50 Wielka Warszawska
Duration: 1h 50m (movie starts ~10:15)
[10 min break]
2. 12:00 - 13:27 Szybcy i sprytni
Duration: 1h 27m (movie starts ~12:15)
3. 13:20 - 14:57 Anzu. Kot duch
Duration: 1h 37m (movie starts ~13:35)
[13 min break]
4. 15:10 - 16:38 SpongeBob: Klątwa pirata
Duration: 1h 28m (movie starts ~15:25)
[12 min break]
5. 16:50 - 18:33 Wysokie i niskie tony
Duration: 1h 43m (movie starts ~17:05)
6. 18:20 - 19:50 90 minut do wolności
Duration: 1h 30m (movie starts ~18:35)
[30 min break]
7. 20:20 - 22:25 Hamnet
Duration: 2h 5m (movie starts ~20:35)
[5 min break]
8. 22:30 - 24:10 Anakonda
Duration: 1h 40m (movie starts ~22:45)
────────────────────────────────────────────────────────────
OPTION 3:
────────────────────────────────────────────────────────────
1. 10:00 - 11:50 Wielka Warszawska
Duration: 1h 50m (movie starts ~10:15)
[10 min break]
2. 12:00 - 13:27 Szybcy i sprytni
Duration: 1h 27m (movie starts ~12:15)
[3 min break]
3. 13:30 - 15:18 Zwierzogród 2
Duration: 1h 48m (movie starts ~13:45)
4. 15:10 - 16:38 SpongeBob: Klątwa pirata
Duration: 1h 28m (movie starts ~15:25)
[12 min break]
5. 16:50 - 18:33 Wysokie i niskie tony
Duration: 1h 43m (movie starts ~17:05)
6. 18:20 - 19:50 90 minut do wolności
Duration: 1h 30m (movie starts ~18:35)
[30 min break]
7. 20:20 - 22:25 Hamnet
Duration: 2h 5m (movie starts ~20:35)
[5 min break]
8. 22:30 - 24:10 Anakonda
Duration: 1h 40m (movie starts ~22:45)
────────────────────────────────────────────────────────────
OPTION 4:
────────────────────────────────────────────────────────────
1. 10:00 - 11:50 Wielka Warszawska
Duration: 1h 50m (movie starts ~10:15)
[10 min break]
2. 12:00 - 13:27 Szybcy i sprytni
Duration: 1h 27m (movie starts ~12:15)
3. 13:20 - 14:57 Anzu. Kot duch
Duration: 1h 37m (movie starts ~13:35)
[3 min break]
4. 15:00 - 16:38 Psoty
Duration: 1h 38m (movie starts ~15:15)
[12 min break]
5. 16:50 - 18:33 Wysokie i niskie tony
Duration: 1h 43m (movie starts ~17:05)
6. 18:20 - 19:50 90 minut do wolności
Duration: 1h 30m (movie starts ~18:35)
[30 min break]
7. 20:20 - 22:25 Hamnet
Duration: 2h 5m (movie starts ~20:35)
8. 22:15 - 24:02 Dom dobry
Duration: 1h 47m (movie starts ~22:30)
────────────────────────────────────────────────────────────
OPTION 5:
────────────────────────────────────────────────────────────
1. 10:00 - 11:50 Wielka Warszawska
Duration: 1h 50m (movie starts ~10:15)
[10 min break]
2. 12:00 - 13:27 Szybcy i sprytni
Duration: 1h 27m (movie starts ~12:15)
3. 13:20 - 14:57 Anzu. Kot duch
Duration: 1h 37m (movie starts ~13:35)
[13 min break]
4. 15:10 - 16:38 SpongeBob: Klątwa pirata
Duration: 1h 28m (movie starts ~15:25)
[12 min break]
5. 16:50 - 18:33 Wysokie i niskie tony
Duration: 1h 43m (movie starts ~17:05)
6. 18:20 - 19:50 90 minut do wolności
Duration: 1h 30m (movie starts ~18:35)
[30 min break]
7. 20:20 - 22:25 Hamnet
Duration: 2h 5m (movie starts ~20:35)
8. 22:15 - 24:02 Dom dobry
Duration: 1h 47m (movie starts ~22:30)
────────────────────────────────────────────────────────────
... and 1477 more combinations
(use -n to show more, e.g., -n 10)

666
python_pkg/cinema_planner/cinema_planner.py Executable file
View File

@ -0,0 +1,666 @@
#!/usr/bin/env python3
"""Cinema Day Planner - Maximize movies watched in a day.
Supports:
- Cinema City HTML/PDF schedules (auto-parsed)
- Manual input format
Usage:
./cinema_planner.py schedule.html # Parse Cinema City HTML
./cinema_planner.py schedule.pdf # Parse Cinema City PDF
./cinema_planner.py -i # Interactive manual input
./cinema_planner.py movies.txt # Manual format file
"""
import argparse
from contextlib import redirect_stdout
from dataclasses import dataclass, field
from io import StringIO
from pathlib import Path
import re
import sys
# Default genres to exclude (can be overridden with --all-genres)
DEFAULT_EXCLUDED_GENRES = {"horror"}
# Ads duration before movie starts (Cinema City shows ~15 min of ads)
ADS_DURATION = 15
@dataclass
class Movie:
name: str
start_times: list[int]
duration: int
genres: list[str] = field(default_factory=list)
@dataclass
class Screening:
movie: str
start: int # minutes from midnight
end: int # minutes from midnight
def overlaps(self, other: "Screening", buffer: int = 0) -> bool:
# Account for ADS_DURATION grace period - you can arrive late and still catch the movie
# self ends, other starts: self.end vs other.start + ADS_DURATION (actual content start)
# other ends, self starts: other.end vs self.start + ADS_DURATION
return not (
self.end + buffer <= other.start + ADS_DURATION
or other.end + buffer <= self.start + ADS_DURATION
)
def start_str(self) -> str:
return f"{self.start // 60:02d}:{self.start % 60:02d}"
def end_str(self) -> str:
return f"{self.end // 60:02d}:{self.end % 60:02d}"
def parse_time(time_str: str) -> int:
"""Parse time string like '18:20' to minutes from midnight."""
time_str = time_str.strip().replace(".", ":")
match = re.match(r"(\d{1,2}):(\d{2})", time_str)
if not match:
raise ValueError(f"Invalid time format: {time_str}")
hours, minutes = int(match.group(1)), int(match.group(2))
return hours * 60 + minutes
def parse_duration(duration_str: str) -> int:
"""Parse duration like '1h 46m', '1:46', '106m', '110 min', etc."""
duration_str = duration_str.strip().lower()
# Try "X min" format (from Cinema City)
match = re.search(r"(\d+)\s*min", duration_str)
if match:
return int(match.group(1))
hours = 0
minutes = 0
h_match = re.search(r"(\d+)\s*h", duration_str)
m_match = re.search(r"(\d+)\s*m(?!in)", duration_str)
if h_match or m_match:
if h_match:
hours = int(h_match.group(1))
if m_match:
minutes = int(m_match.group(1))
return hours * 60 + minutes
# Try "H:MM" format
match = re.match(r"(\d+):(\d{2})", duration_str)
if match:
return int(match.group(1)) * 60 + int(match.group(2))
# Try pure minutes
match = re.match(r"(\d+)", duration_str)
if match:
return int(match.group(1))
raise ValueError(f"Invalid duration format: {duration_str}")
def parse_manual_line(line: str) -> Movie | None:
"""Parse a manual format line like 'Movie A, 18:20 or 20:50, 1h 46m'."""
line = line.strip()
if not line or line.startswith("#"):
return None
parts = line.split(",")
if len(parts) < 3:
raise ValueError(f"Invalid line format: {line}")
movie = parts[0].strip()
times_str = parts[1].strip()
duration_str = ",".join(parts[2:]).strip()
start_times = []
for time_part in re.split(r"\s+or\s+", times_str, flags=re.IGNORECASE):
start_times.append(parse_time(time_part))
duration = parse_duration(duration_str)
return Movie(movie, start_times, duration)
def extract_date_from_html(content: str) -> str | None:
"""Extract schedule date from Cinema City HTML."""
# Look for date in YYYY-MM-DD format
match = re.search(r"(202\d-\d{2}-\d{2})", content)
if match:
return match.group(1)
return None
def parse_cinema_city_html(filepath: str) -> tuple[list[Movie], str | None]:
"""Parse Cinema City HTML schedule. Returns (movies, date)."""
with open(filepath, encoding="utf-8") as f:
content = f.read()
movies = []
schedule_date = extract_date_from_html(content)
# Split content by movie sections
sections = re.split(r'class="row movie-row', content)
for section in sections[1:]: # Skip first (before any movie)
# Get movie name
name_match = re.search(r'qb-movie-name">([^<]+)<', section)
if not name_match:
continue
movie_name = name_match.group(1).strip()
# Get genres - they appear before the duration, separated by commas
# Pattern: class="mr-sm">Genre1, Genre2 <span
genre_match = re.search(r'class="mr-sm"[^>]*>([^<]+)<\s*span', section)
genres = []
if genre_match:
genre_text = genre_match.group(1).strip()
genres = [g.strip() for g in genre_text.split(",") if g.strip()]
# Get duration
duration_match = re.search(r"(\d+)\s*min", section)
if not duration_match:
continue
duration = int(duration_match.group(1))
# Get screening times - look for time buttons
times = re.findall(r'btn btn-primary btn-lg">\s*(\d{2}:\d{2})\s*<', section)
if not times:
# Try alternate pattern
times = re.findall(r">\s*(\d{2}:\d{2})\s*\(HTTPS://", section)
if times:
start_times = [parse_time(t) for t in times]
# Remove duplicates while preserving order
start_times = list(dict.fromkeys(start_times))
movies.append(Movie(movie_name, start_times, duration, genres))
# Deduplicate movies (same movie might appear multiple times)
seen = set()
unique_movies = []
for movie in movies:
if movie.name not in seen:
seen.add(movie.name)
unique_movies.append(movie)
return unique_movies, schedule_date
def parse_cinema_city_pdf(filepath: str) -> list[Movie]:
"""Parse Cinema City PDF schedule by extracting text."""
try:
import pdfplumber
except ImportError:
# Fallback to basic text extraction
return parse_cinema_city_pdf_basic(filepath)
with pdfplumber.open(filepath) as pdf:
full_text = ""
for page in pdf.pages:
text = page.extract_text()
if text:
full_text += text + "\n"
return parse_cinema_city_text(full_text)
def parse_cinema_city_pdf_basic(filepath: str) -> list[Movie]:
"""Basic PDF parsing using PyMuPDF or falling back to subprocess."""
try:
import fitz # PyMuPDF
doc = fitz.open(filepath)
full_text = ""
for page in doc:
full_text += page.get_text() + "\n"
doc.close()
return parse_cinema_city_text(full_text)
except ImportError:
pass
# Try pdftotext command
import subprocess
try:
result = subprocess.run(
["pdftotext", "-layout", filepath, "-"],
capture_output=True,
text=True,
check=True,
)
return parse_cinema_city_text(result.stdout)
except (subprocess.CalledProcessError, FileNotFoundError):
print("Error: Install pdfplumber, PyMuPDF, or poppler-utils for PDF support")
print(" pip install pdfplumber")
print(" pip install pymupdf")
print(" pacman -S poppler")
sys.exit(1)
def parse_cinema_city_text(text: str) -> list[Movie]:
"""Parse Cinema City schedule from extracted text."""
movies = []
lines = text.split("\n")
current_movie = None
current_duration = None
current_times: list[int] = []
# Patterns for movie titles (all caps, usually)
movie_title_pattern = re.compile(
r"^([A-ZĄĆĘŁŃÓŚŹŻ][A-ZĄĆĘŁŃÓŚŹŻ0-9\s:,\.\-\!\?\(\)]+)$"
)
# Known movie indicators
duration_pattern = re.compile(r"(\d+)\s*min")
time_pattern = re.compile(r"\b(\d{1,2}:\d{2})\b")
i = 0
while i < len(lines):
line = lines[i].strip()
# Check if this looks like a movie title
# Cinema City format: MOVIE TITLE on its own line, followed by genre | duration
if movie_title_pattern.match(line) and len(line) > 3:
# Save previous movie if exists
if current_movie and current_times:
movies.append(
Movie(
current_movie,
list(dict.fromkeys(current_times)),
current_duration or 120,
)
)
# Check next lines for duration
current_movie = line.title() # Convert to title case
current_times = []
current_duration = None
# Look ahead for duration
for j in range(i + 1, min(i + 5, len(lines))):
dur_match = duration_pattern.search(lines[j])
if dur_match:
current_duration = int(dur_match.group(1))
break
# Look for times in current line
if current_movie:
times_in_line = time_pattern.findall(line)
for t in times_in_line:
try:
current_times.append(parse_time(t))
except ValueError:
pass
i += 1
# Save last movie
if current_movie and current_times:
movies.append(
Movie(
current_movie,
list(dict.fromkeys(current_times)),
current_duration or 120,
)
)
return movies
def find_best_schedule(movies: list[Movie], buffer: int) -> list[list[Screening]]:
"""Find ALL schedules that maximize number of movies watched."""
movie_screenings: list[list[Screening]] = []
for movie in movies:
# Schedule times are accurate - arrive at start, leave at start + duration
# (ads are already factored into published times)
screenings = [
Screening(movie.name, start, start + movie.duration)
for start in movie.start_times
]
movie_screenings.append(screenings)
best_count = 0
all_best_schedules: list[list[Screening]] = []
def backtrack(movie_idx: int, current_schedule: list[Screening]):
nonlocal best_count, all_best_schedules
if movie_idx == len(movie_screenings):
if len(current_schedule) > best_count:
best_count = len(current_schedule)
all_best_schedules = [current_schedule.copy()]
elif len(current_schedule) == best_count and best_count > 0:
all_best_schedules.append(current_schedule.copy())
return
# Pruning: can't beat the best
remaining = len(movie_screenings) - movie_idx
if len(current_schedule) + remaining < best_count:
return
# Try each screening of current movie
for screening in movie_screenings[movie_idx]:
conflicts = any(screening.overlaps(s, buffer) for s in current_schedule)
if not conflicts:
current_schedule.append(screening)
backtrack(movie_idx + 1, current_schedule)
current_schedule.pop()
# Also try skipping this movie
backtrack(movie_idx + 1, current_schedule)
backtrack(0, [])
# Sort each schedule by start time and return
return [sorted(schedule, key=lambda s: s.start) for schedule in all_best_schedules]
def print_single_schedule(schedule: list[Screening], schedule_num: int | None = None):
"""Print a single schedule."""
for i, screening in enumerate(schedule, 1):
duration = screening.end - screening.start
hours, mins = divmod(duration, 60)
# Movie starts ~15 min after listed time due to ads
actual_start = screening.start + ADS_DURATION
actual_start_str = f"{actual_start // 60:02d}:{actual_start % 60:02d}"
print(
f" {i}. {screening.start_str()} - {screening.end_str()} {screening.movie}"
)
print(f" Duration: {hours}h {mins}m (movie starts ~{actual_start_str})")
if i < len(schedule):
gap = schedule[i].start - screening.end
if gap > 0:
print(f" [{gap} min break]")
print()
def print_schedules(
schedules: list[list[Screening]],
all_movies: list[str],
date: str | None = None,
max_display: int = 5,
):
"""Print optimal schedules (up to max_display)."""
if not schedules or not schedules[0]:
print("No movies can be scheduled!")
return
num_movies = len(schedules[0])
num_schedules = len(schedules)
print(f"\n{'=' * 60}")
if date:
print(f" OPTIMAL CINEMA SCHEDULES - {date}")
else:
print(" OPTIMAL CINEMA SCHEDULES")
print(f" {num_movies} movies, {num_schedules} possible combination(s)")
print(f"{'=' * 60}\n")
display_count = min(num_schedules, max_display)
for idx, schedule in enumerate(schedules[:display_count], 1):
if num_schedules > 1:
print(f"{'─' * 60}")
print(f" OPTION {idx}:")
print(f"{'─' * 60}\n")
print_single_schedule(schedule)
if num_schedules > display_count:
print(f"{'─' * 60}")
print(f" ... and {num_schedules - display_count} more combinations")
print(" (use -n to show more, e.g., -n 10)")
print()
# Show skipped movies (from first schedule as reference)
scheduled_movies = {s.movie for s in schedules[0]}
skipped = [m for m in all_movies if m not in scheduled_movies]
if skipped and num_schedules == 1:
print(f"{'─' * 60}")
print(f" Skipped movies ({len(skipped)}):")
for movie in skipped:
print(f" - {movie}")
print()
def print_all_movies(movies: list[Movie], date: str | None = None):
"""Print all parsed movies."""
print(f"\n{'─' * 60}")
if date:
print(f" Parsed {len(movies)} movies for {date}:")
else:
print(f" Parsed {len(movies)} movies:")
print(f"{'─' * 60}")
for movie in movies:
times_str = ", ".join(
f"{t//60:02d}:{t%60:02d}" for t in sorted(movie.start_times)
)
genre_str = f" [{', '.join(movie.genres)}]" if movie.genres else ""
print(f" {movie.name} ({movie.duration} min){genre_str}")
print(f" Times: {times_str}")
print()
def main():
parser = argparse.ArgumentParser(
description="Plan your cinema day to watch as many movies as possible.",
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog="""
Supports Cinema City HTML/PDF schedules (auto-detected).
Manual input format (one movie per line):
Movie Title, start_time1 [or start_time2 ...], duration
Example:
Inception, 10:30 or 14:00 or 18:30, 2h 28m
The Matrix, 12:00 or 16:45, 2h 16m
""",
)
parser.add_argument("input_file", nargs="?", help="Input file (HTML/PDF/TXT)")
parser.add_argument(
"-b",
"--buffer",
type=int,
default=0,
help="Buffer time between movies in minutes (default: 0)",
)
parser.add_argument(
"-i",
"--interactive",
action="store_true",
help="Interactive mode - enter movies one by one",
)
parser.add_argument(
"-l",
"--list",
action="store_true",
help="List all parsed movies without scheduling",
)
parser.add_argument(
"-s",
"--select",
type=str,
help="Comma-separated list of movie names to include (partial match)",
)
parser.add_argument(
"-x",
"--exclude",
type=str,
help="Comma-separated list of movie names to exclude (partial match)",
)
parser.add_argument(
"-g",
"--exclude-genre",
type=str,
help="Comma-separated list of genres to exclude (e.g., 'Horror,Thriller')",
)
parser.add_argument(
"--all-genres",
action="store_true",
help="Include all genres (disable default Horror exclusion)",
)
parser.add_argument(
"-o",
"--output",
type=str,
help="Save schedule to file (default: cinema_plan_DATE.txt)",
)
parser.add_argument(
"-n",
"--max-schedules",
type=int,
default=5,
help="Maximum number of schedule options to display (default: 5)",
)
parser.add_argument(
"-m",
"--must-watch",
type=str,
help="Only show schedules containing this movie (partial match)",
)
args = parser.parse_args()
movies = []
schedule_date = None
if args.interactive:
print("Enter movies (empty line to finish):")
print("Format: Title, start1 [or start2 ...], duration")
print("Example: Inception, 10:30 or 14:00, 2h 28m")
print()
while True:
try:
line = input("> ")
except EOFError:
break
if not line.strip():
break
try:
result = parse_manual_line(line)
if result:
movies.append(result)
print(f" Added: {result.name}")
except ValueError as e:
print(f" Error: {e}")
elif args.input_file:
filepath = Path(args.input_file)
suffix = filepath.suffix.lower()
print(f"Parsing: {filepath}")
if suffix == ".html" or suffix == ".htm":
movies, schedule_date = parse_cinema_city_html(str(filepath))
elif suffix == ".pdf":
movies = parse_cinema_city_pdf(str(filepath))
else:
# Assume manual format
with open(filepath) as f:
for line in f:
try:
result = parse_manual_line(line)
if result:
movies.append(result)
except ValueError as e:
print(f"Warning: {e}", file=sys.stderr)
else:
print("Enter movies (Ctrl+D when done):")
for line in sys.stdin:
try:
result = parse_manual_line(line)
if result:
movies.append(result)
except ValueError as e:
print(f"Warning: {e}", file=sys.stderr)
if not movies:
print("No movies found!")
sys.exit(1)
# Filter movies if requested
if args.select:
select_terms = [t.strip().lower() for t in args.select.split(",")]
movies = [m for m in movies if any(t in m.name.lower() for t in select_terms)]
print(f"Selected {len(movies)} movies matching: {args.select}")
if args.exclude:
exclude_terms = [t.strip().lower() for t in args.exclude.split(",")]
movies = [
m for m in movies if not any(t in m.name.lower() for t in exclude_terms)
]
print(f"After name exclusion: {len(movies)} movies")
# Genre filtering
excluded_genres = set()
if not args.all_genres:
excluded_genres.update(DEFAULT_EXCLUDED_GENRES)
if args.exclude_genre:
excluded_genres.update(g.strip().lower() for g in args.exclude_genre.split(","))
if excluded_genres:
before_count = len(movies)
movies = [
m for m in movies if not any(g.lower() in excluded_genres for g in m.genres)
]
filtered_count = before_count - len(movies)
if filtered_count > 0:
print(
f"Excluded {filtered_count} movies by genre: {', '.join(sorted(excluded_genres))}"
)
if args.list:
print_all_movies(movies, schedule_date)
return
print(f"\nOptimizing schedule for {len(movies)} movies...")
print(f"Buffer time between movies: {args.buffer} minutes")
schedules = find_best_schedule(movies, args.buffer)
all_movie_names = [m.name for m in movies]
# Filter schedules if must-watch movie specified
if args.must_watch:
must_watch_lower = args.must_watch.lower()
filtered = [
s
for s in schedules
if any(must_watch_lower in screening.movie.lower() for screening in s)
]
if filtered:
print(
f"Filtered to {len(filtered)} schedules containing '{args.must_watch}'"
)
schedules = filtered
else:
print(f"Warning: No optimal schedules contain '{args.must_watch}'")
print("Showing all schedules instead.")
# Capture output if saving to file
output_buffer = StringIO()
with redirect_stdout(output_buffer):
print_schedules(schedules, all_movie_names, schedule_date, args.max_schedules)
schedule_output = output_buffer.getvalue()
print(schedule_output) # Still show in terminal
# Save to file
if args.output or schedule_date:
if args.output:
output_file = Path(args.output)
else:
output_file = Path(f"cinema_plan_{schedule_date}.txt")
with open(output_file, "w") as f:
f.write(f"Generated: {schedule_date or 'unknown date'}\n")
f.write(f"Movies considered: {len(movies)}\n")
f.write(f"Buffer time: {args.buffer} minutes\n")
if excluded_genres:
f.write(f"Excluded genres: {', '.join(sorted(excluded_genres))}\n")
f.write(schedule_output)
print(f"Schedule saved to: {output_file}")
if __name__ == "__main__":
main()

44
python_pkg/cinema_planner/run.sh Executable file
View File

@ -0,0 +1,44 @@
#!/bin/bash
# Run cinema planner with Cinema City schedule from Downloads
SCRIPT_DIR="$(dirname "$(readlink -f "$0")")"
DOWNLOADS="$HOME/Downloads"
# Show help if requested
if [[ "$1" == "-h" || "$1" == "--help" ]]; then
echo "Usage: ./run.sh [OPTIONS]"
echo ""
echo "Automatically finds Cinema City HTML schedule in ~/Downloads"
echo ""
echo "Options:"
echo " -l, --list List all movies without scheduling"
echo " -x, --exclude Exclude movies by name (comma-separated)"
echo " -g, --exclude-genre Exclude additional genres (comma-separated)"
echo " --all-genres Include all genres (disable Horror auto-exclusion)"
echo " -b, --buffer N Buffer time between movies (default: 0)"
echo " -m, --must-watch Only show schedules containing this movie"
echo " -n, --max-schedules Max number of schedule options to show (default: 5)"
echo ""
echo "Examples:"
echo " ./run.sh # Plan optimal schedule"
echo " ./run.sh -x 'Avatar,Sonic' # Exclude specific movies"
echo " ./run.sh -g 'Thriller,Dramat' # Also exclude Thriller and Drama"
echo " ./run.sh --all-genres # Include Horror movies"
echo " ./run.sh -m 'Hamnet' # Only schedules with Hamnet"
exit 0
fi
# Find the most recent Cinema City HTML file
HTML_FILE=$(find "$DOWNLOADS" -maxdepth 1 -name "Repertuar*.html" -type f -printf '%T@ %p\n' 2>/dev/null | sort -rn | head -1 | cut -d' ' -f2-)
if [ -z "$HTML_FILE" ]; then
echo "No Cinema City schedule found in $DOWNLOADS"
echo "Download the schedule from cinema-city.pl first"
exit 1
fi
echo "Using: $HTML_FILE"
echo ""
# Run the planner with any additional arguments passed to this script
"$SCRIPT_DIR/cinema_planner.py" "$HTML_FILE" "$@"