import logging
from typing import Dict
from datetime import datetime
from pathlib import Path
from zoneinfo import ZoneInfo
import yaml
from PIL import Image, ImageDraw
from .fonts.fonts import Fonts
from .scheduler import Scheduler
from .renderer import JinjaRenderer
from todays_paper_web.storage import Storage
from todays_paper_web.widgets import DataSource, View, ImageType
_LOGGER = logging.getLogger(__name__)
[docs]
class Generator:
def __init__(self, name: str, storage: Storage):
self._config: Dict = yaml.safe_load(storage.getConfig(name)) or {}
self._debugging = False
self._name = name
self._scheduler = None
self._sources = {}
self._storage: Storage = storage
self._timezone = ZoneInfo(
self._config.get("settings", {}).get("timezone", "UTC")
)
self._timestamp = datetime.now(self._timezone)
for name, config in self._config.get("sources", {}).items():
self._sources[name] = DataSource.get(
config.get("source"), config.get("params", {})
)
@property
def timezone(self) -> ZoneInfo:
return self._timezone
@property
def debugging(self) -> bool:
return self._debugging
@debugging.setter
def debugging(self, debugging) -> None:
self._debugging = debugging
[docs]
def getCurrentScreen(self) -> tuple[datetime, str, datetime]:
if not self._scheduler:
self._scheduler = Scheduler(
self._config.get("scheduler", {}), self._timezone
)
return self._scheduler.getCurrentScreen()
[docs]
def getNextScreen(self, skip: int = 0) -> tuple[datetime, str]:
if not self._scheduler:
self._scheduler = Scheduler(
self._config.get("scheduler", {}), self._timezone
)
return self._scheduler.getNextScreen(skip)
[docs]
def renderScreen(self, screenName: str) -> ImageType:
screens = self._config.get("screens", {})
width = screens.get("width", 0)
height = screens.get("height", 0)
if not width or not height:
_LOGGER.error("Screen size is not defined")
return None
config = screens.get(screenName)
if not config:
_LOGGER.error("Could not find screen %s", screenName)
return None
renderer = JinjaRenderer(config, self._sources, self._storage, self._name)
renderer.debugging = self.debugging
tree = renderer.render(width, height, self._timestamp)
if not tree:
_LOGGER.error("Could not render screen %s", screenName)
return None
view = View.get(
"screen",
None,
tree.attrib | {"width": width, "height": height},
self._storage,
self._name,
)
view.element = tree
img = view.render()
rotate = screens.get("rotate", 0)
if rotate:
img = img.rotate(rotate, expand=True)
return img
[docs]
def renderErrorScreen(self, screenName: str, error: Exception) -> ImageType:
"""Render a screen telling the user that rendering of screenName failed"""
screens = self._config.get("screens", {})
width = screens.get("width", 0)
height = screens.get("height", 0)
if not width or not height:
raise RuntimeError("Screen size is not defined")
img = Image.new("RGB", (width, height), "white")
draw = ImageDraw.Draw(img)
margin = width // 15
maxWidth = width - 2 * margin
titleFont = Fonts.load("FiraSans", height // 15)
textFont = Fonts.load("FiraSans", height // 30)
y = margin
draw.text((margin, y), "Could not render screen", font=titleFont, fill="black")
y += int(titleFont.size * 1.6)
lines = [
f"Screen: {screenName}",
f"Time: {self._timestamp.strftime('%Y-%m-%d %H:%M')}",
"",
*_wrapText(f"{type(error).__name__}: {error}", textFont, maxWidth),
]
for line in lines:
if y + textFont.size > height - margin:
break
draw.text((margin, y), line, font=textFont, fill="black")
y += int(textFont.size * 1.3)
rotate = screens.get("rotate", 0)
if rotate:
img = img.rotate(rotate, expand=True)
return img
[docs]
def setTimestamp(self, timestamp: datetime) -> None:
self._timestamp = timestamp
for _, source in self._sources.items():
source.timestamp = timestamp
def _wrapText(text: str, font, maxWidth: int) -> list[str]:
lines = []
for paragraph in text.splitlines() or [""]:
line = ""
for word in paragraph.split(" "):
candidate = f"{line} {word}" if line else word
if font.getlength(candidate) <= maxWidth:
line = candidate
continue
if line:
lines.append(line)
# Break words that do not fit on a line of their own (e.g. URLs)
line = ""
for char in word:
if line and font.getlength(line + char) > maxWidth:
lines.append(line)
line = ""
line += char
lines.append(line)
return lines