"""Groepeer posts tot reeksen (novels) op auteur, titel en next-links.""" from __future__ import annotations from collections import defaultdict from dataclasses import dataclass, field from typing import Iterable from .links import Link, extract_links, links_from_ids from .normalize import display_series_title, is_oneshot, is_story_post, normalize_title, slug @dataclass class Post: id: str title: str author: str created_utc: int permalink: str flair: str | None over_18: bool = False score: int = 0 is_self: bool = True next_ids: tuple[str, ...] = () prev_ids: tuple[str, ...] = () first_ids: tuple[str, ...] = () all_linked_ids: tuple[str, ...] = () links: tuple[Link, ...] = () wiki_path: str | None = None @property def norm_title(self) -> str: return normalize_title(self.title) @classmethod def from_reddit(cls, raw: dict) -> Post | None: pid = (raw.get("id") or "").strip().lower() if not pid: return None author = raw.get("author") or "[deleted]" title = raw.get("title") or "" url = raw.get("url") or "" permalink = raw.get("permalink") or "" if not permalink and "/comments/" in url: permalink = "/r/" + url.split("/r/", 1)[-1] if "/r/" in url else f"/r/HFY/comments/{pid}/" if not permalink: permalink = f"/r/HFY/comments/{pid}/" if permalink.startswith("http"): permalink = "/r/" + permalink.split("/r/", 1)[-1] if "/r/" in permalink else f"/r/HFY/comments/{pid}/" if not permalink.startswith("/"): permalink = f"/r/HFY/comments/{pid}/" if "is_self" in raw: is_self = bool(raw["is_self"]) else: # Arctic Shift accepteert is_self niet als fields=; een externe url is een link-post. is_self = (not url) or ("reddit.com/" in url) or url.startswith("/r/") flair = raw.get("link_flair_text") created = int(raw.get("created_utc") or raw.get("created") or 0) links = extract_links(raw.get("selftext") or raw.get("selftext_html") or "") return cls( id=pid, title=title, author=author, created_utc=created, permalink=permalink, flair=flair, over_18=bool(raw.get("over_18")), score=int(raw.get("score") or 0), is_self=is_self, next_ids=links.next_ids, prev_ids=links.prev_ids, first_ids=links.first_ids, all_linked_ids=links.all_ids, links=links.links or links_from_ids(links.next_ids, links.prev_ids, links.first_ids, links.all_ids), ) @dataclass class Novel: id: str name: str author: str chapters: list[Post] = field(default_factory=list) flair: str | None = None over_18: bool = False oneshot: bool = False wiki_path: str | None = None @property def updated_utc(self) -> int: return max((c.created_utc for c in self.chapters), default=0) @property def created_utc(self) -> int: return min((c.created_utc for c in self.chapters), default=0) @property def path(self) -> str: return f"series/{self.id}" class _UnionFind: def __init__(self, items: Iterable[str]) -> None: self.parent = {i: i for i in items} def find(self, x: str) -> str: p = self.parent.setdefault(x, x) if p != x: self.parent[x] = self.find(p) return self.parent[x] def union(self, a: str, b: str) -> None: ra, rb = self.find(a), self.find(b) if ra != rb: self.parent[rb] = ra def filter_story_posts(posts: Iterable[Post]) -> list[Post]: return [p for p in posts if is_story_post(p.flair, p.is_self, p.title) and p.author not in {"[deleted]", "[removed]"}] def cluster_posts(posts: Iterable[Post]) -> list[Novel]: """Groepeer op (auteur, genormaliseerde titel) en merge via next/prev van dezelfde auteur.""" items = filter_story_posts(posts) if not items: return [] by_id = {p.id: p for p in items} uf = _UnionFind(by_id) # 1. Zelfde auteur + dezelfde genormaliseerde titel. groups: dict[tuple[str, str], list[str]] = defaultdict(list) for p in items: key = p.norm_title or f"__id_{p.id}" groups[(p.author.lower(), key)].append(p.id) for ids in groups.values(): head = ids[0] for other in ids[1:]: uf.union(head, other) # 2. Expliciete next/prev/first-links tussen posts van dezelfde auteur. def maybe_merge(src: Post, target_id: str) -> None: dst = by_id.get(target_id) if not dst: return if src.author.lower() != dst.author.lower(): return uf.union(src.id, dst.id) for p in items: for tid in p.next_ids + p.prev_ids + p.first_ids: maybe_merge(p, tid) clustered: dict[str, list[Post]] = defaultdict(list) for p in items: clustered[uf.find(p.id)].append(p) novels: list[Novel] = [] for members in clustered.values(): members.sort(key=lambda p: (p.created_utc, p.id)) first = members[0] name = display_series_title([m.title for m in members]) # Stabiel id: de oudste post. Zo blijft een reeks herkenbaar als er hoofdstukken bijkomen. nid = first.id flair = next((m.flair for m in members if m.flair), first.flair) novel = Novel( id=nid, name=name, author=first.author, chapters=members, flair=flair, over_18=any(m.over_18 for m in members), oneshot=is_oneshot(flair, len(members)), ) novels.append(novel) novels.sort(key=lambda n: n.updated_utc, reverse=True) return novels def merge_novels(existing: list[Novel], incoming: list[Novel]) -> list[Novel]: """Voeg een incrementele update samen: posts met hetzelfde id winnen van de nieuwe batch.""" posts: dict[str, Post] = {} for novel in existing + incoming: for ch in novel.chapters: posts[ch.id] = ch return cluster_posts(posts.values())