| from __future__ import annotations |
|
|
| import hashlib |
| import html |
| import json |
| import os |
| import re |
| from functools import lru_cache |
| from typing import Any |
|
|
|
|
| APP_TITLE = "Trollsona" |
| APP_SUBTITLE = "Summon the little menace living behind your respectable personality." |
| TRACK_NAME = "An Adventure in Thousand Token Wood" |
| DEFAULT_MODEL_ID = "RthItalia/nano_compact_3b_qkvfp16" |
| DEFAULT_FALLBACK_MODEL_ID = "Qwen/Qwen2.5-0.5B-Instruct" |
| MAX_PROFILE_CHARS = 700 |
| MAX_NAME_CHARS = 36 |
|
|
|
|
| def parse_bool_env(name: str, default: bool) -> bool: |
| raw_value = os.getenv(name) |
| if raw_value is None: |
| return default |
| normalized = raw_value.strip().lower() |
| if normalized in {"1", "true", "yes", "on"}: |
| return True |
| if normalized in {"0", "false", "no", "off"}: |
| return False |
| return default |
|
|
|
|
| def parse_int_env(name: str, default: int, min_value: int, max_value: int) -> int: |
| raw_value = os.getenv(name) |
| if raw_value is None: |
| return default |
| try: |
| value = int(raw_value) |
| except ValueError: |
| return default |
| return max(min_value, min(max_value, value)) |
|
|
|
|
| MODEL_ID = os.getenv("TROLLSONA_MODEL_ID", DEFAULT_MODEL_ID) |
| FALLBACK_MODEL_ID = os.getenv("TROLLSONA_FALLBACK_MODEL_ID", DEFAULT_FALLBACK_MODEL_ID) |
| MODEL_ENABLED = parse_bool_env("TROLLSONA_ENABLE_MODEL", default=False) |
| MAX_NEW_TOKENS = parse_int_env("TROLLSONA_MAX_NEW_TOKENS", 200, 32, 512) |
|
|
|
|
| PERSONA_STYLES = { |
| "Back-Alley Oracle": { |
| "flavor": "candlelit prophecy from a very suspicious side street", |
| "noun_pool": ["Candle", "Omen", "Alley", "Brass", "Whisper", "Ledger"], |
| }, |
| "Basement Prince": { |
| "flavor": "royal delusion wrapped in dust, snacks, and old cables", |
| "noun_pool": ["Basement", "Velvet", "Outlet", "Throne", "Snack", "Static"], |
| }, |
| "Forest Heckler": { |
| "flavor": "mossy woodland sarcasm with a pocket full of bad advice", |
| "noun_pool": ["Moss", "Root", "Twig", "Bog", "Fern", "Stump"], |
| }, |
| "Union Goblin": { |
| "flavor": "petty workplace grievance with ceremonial clipboard energy", |
| "noun_pool": ["Clause", "Mug", "Breakroom", "Badge", "Staple", "Shift"], |
| }, |
| "Dungeon Intern": { |
| "flavor": "overworked dungeon bureaucracy and unpaid dramatic labor", |
| "noun_pool": ["Ledger", "Torch", "Mop", "Key", "Goblet", "Trapdoor"], |
| }, |
| "Mall Witch": { |
| "flavor": "food-court divination with lip gloss and thunder", |
| "noun_pool": ["Kiosk", "Charm", "Receipt", "Fountain", "Mascara", "Pretzel"], |
| }, |
| "Parking Lot Philosopher": { |
| "flavor": "deep truths delivered beside a dented shopping cart", |
| "noun_pool": ["Asphalt", "Cart", "Neon", "Cone", "Puddle", "Keychain"], |
| }, |
| "Saint of Bad Decisions": { |
| "flavor": "holy nonsense for people who turn errands into lore", |
| "noun_pool": ["Halo", "Candle", "Excuse", "Relic", "Errand", "Confetti"], |
| }, |
| "Meme Caporegime": { |
| "flavor": "old-neighborhood swagger filtered through cursed screenshots", |
| "noun_pool": ["Pixel", "Prophecy", "Caption", "Scroll", "Vibe", "Echo"], |
| }, |
| } |
|
|
| SPICE_LABELS = { |
| 1: "tiny pinch", |
| 2: "polite sting", |
| 3: "back-room heckle", |
| 4: "crispy little judgment", |
| 5: "full dossier incident", |
| } |
|
|
| BLOCKED_PATTERNS = [ |
| r"\bkill yourself\b", |
| r"\bkys\b", |
| r"\bself[- ]?harm\b", |
| r"\bsuicide\b", |
| r"\bhate\b", |
| r"\bidiot\b", |
| r"\bstupid\b", |
| r"\bmoron\b", |
| r"\bdumb\b", |
| r"\bloser\b", |
| r"\bugly\b", |
| r"\bworthless\b", |
| r"\bsubhuman\b", |
| r"\bslur\b", |
| r"\bterrorist\b", |
| r"\bsexual\b", |
| r"\bexplicit\b", |
| r"\bprotected class\b", |
| ] |
|
|
| PROTECTED_TARGETING_PATTERNS = [ |
| r"\bbecause of your race\b", |
| r"\bbecause of your religion\b", |
| r"\bbecause of your gender\b", |
| r"\bbecause of your sexuality\b", |
| r"\bbecause of your disability\b", |
| r"\bbecause of your nationality\b", |
| r"\bbecause of your ethnicity\b", |
| ] |
|
|
| SAFE_REPLY = ( |
| "The dossier hissed, smoked, and refused to punch down. " |
| "Final harmless verdict: your chaos has excellent posture and a suspicious little hat." |
| ) |
| SAFE_ADVICE = "Make the next useful move before you decorate the excuse." |
|
|
| PRESET_DOSSIERS = [ |
| { |
| "button": "Mira - coffee-built UI oracle", |
| "values": ( |
| "Mira", |
| "I overbuild side projects, drink too much coffee, and love weird UI.", |
| "Back-Alley Oracle", |
| 3, |
| True, |
| ), |
| }, |
| { |
| "button": "Alex - label-system dungeon clerk", |
| "values": ( |
| "Alex", |
| "I start productivity systems and then reorganize the labels forever.", |
| "Dungeon Intern", |
| 4, |
| True, |
| ), |
| }, |
| { |
| "button": "Sam - tiny-game screenshot boss", |
| "values": ( |
| "Sam", |
| "I make tiny games, forget lunch, and name variables like ancient spells.", |
| "Meme Caporegime", |
| 2, |
| False, |
| ), |
| }, |
| ] |
|
|
|
|
| def stable_int(*parts: str) -> int: |
| payload = "||".join(parts).encode("utf-8", errors="ignore") |
| return int(hashlib.sha256(payload).hexdigest()[:12], 16) |
|
|
|
|
| def clean_text(value: Any, max_chars: int) -> str: |
| text = "" if value is None else str(value) |
| text = re.sub(r"\s+", " ", text).strip() |
| return text[:max_chars] |
|
|
|
|
| def clamp_spice(value: Any) -> int: |
| try: |
| spice = int(value) |
| except (TypeError, ValueError): |
| spice = 3 |
| return max(1, min(5, spice)) |
|
|
|
|
| def compute_cringe_score(profile: str, persona: str, spice: int) -> int: |
| base = stable_int(profile.lower(), persona.lower(), str(spice)) % 61 |
| return max(0, min(100, 22 + base + (spice * 3))) |
|
|
|
|
| def cringe_label(score: int) -> str: |
| if score < 35: |
| return "barely haunted" |
| if score < 60: |
| return "noticeably cursed" |
| if score < 82: |
| return "dossier-grade cringe" |
| return "full goblin canon event" |
|
|
|
|
| def build_prompt( |
| user_name: str, |
| profile: str, |
| persona: str, |
| spice: int, |
| include_advice: bool, |
| score: int, |
| ) -> str: |
| style = PERSONA_STYLES.get(persona, PERSONA_STYLES["Forest Heckler"]) |
| advice_rule = "Include one practical useful_advice sentence." if include_advice else ( |
| "Set useful_advice to a short note that advice was disabled." |
| ) |
| return f""" |
| You are Trollsona, a theatrical troll alter-ego generator. |
| Track: {TRACK_NAME}. |
| |
| Your job is to transform the user's self-description into a funny, slightly grotesque, |
| whimsical troll persona. Make it feel like a stained-paper character dossier that was |
| dictated by a back-alley fortune teller, stamped by a petty clerk, and lightly heckled |
| by an italo-american cousin who has opinions but not cruelty. |
| |
| Return only valid minified JSON with these fields: |
| trollsona_name, troll_reply, useful_advice, cringe_score, cringe_score_label. |
| |
| Objective: |
| - Make the result absurd, memorable, specific, and theatrical. |
| - Make trollsona_name sound like a summoned character, not a username. |
| - Keep it roasty, not hateful. |
| - Keep the humor sharp but warm: playful sting, never humiliation. |
| |
| Style rules: |
| - Write in vivid, punchy English. |
| - Use occasional light italo-american flavor, but sparingly. |
| - Good flavor examples: "listen, paisan", "madone", "capisce". |
| - Do not overuse slang or turn the voice into a caricature. |
| - Use grotesque but charming imagery: candle wax, receipts, tiny crowns, haunted binders, |
| dented carts, snack dust, side quests, suspicious paperwork. |
| - No generic roast bot voice. |
| - No generic assistant copy, no filler, no disclaimers, no moralizing. |
| - troll_reply must be the strongest comedic line, 1-3 short sentences max. |
| - useful_advice must contain one real insight in 1 sentence max. |
| |
| Humor boundaries: |
| - Roast only habits, vibe, overthinking, productivity rituals, startup energy, |
| internet behavior, wording, or harmless personal lore. |
| - Never attack protected characteristics or identity. |
| - Never insult appearance, race, ethnicity, religion, disability, nationality, |
| gender, sexuality, trauma, mental health, or protected traits. |
| - Never include threats, self-harm, sexual content, profanity, or slurs. |
| - Never punch down. |
| |
| User name: {user_name or "Anonymous traveler"} |
| User profile: {profile or "No profile supplied."} |
| Persona: {persona} |
| Persona flavor: {style["flavor"]} |
| Spice level: {spice}/5 ({SPICE_LABELS[spice]}) |
| Use this exact deterministic cringe_score: {score} |
| Use this matching cringe_score_label: {cringe_label(score)} |
| {advice_rule} |
| """.strip() |
|
|
|
|
| def is_safe_text(text: str) -> bool: |
| normalized = text.lower() |
| for pattern in BLOCKED_PATTERNS + PROTECTED_TARGETING_PATTERNS: |
| if re.search(pattern, normalized): |
| return False |
| return True |
|
|
|
|
| def fallback_trollsona( |
| user_name: str, |
| profile: str, |
| persona: str, |
| spice: int, |
| include_advice: bool, |
| reason: str, |
| ) -> dict[str, Any]: |
| style = PERSONA_STYLES.get(persona, PERSONA_STYLES["Forest Heckler"]) |
| seed = stable_int(user_name.lower(), profile.lower(), persona.lower(), str(spice)) |
| adjectives = ["Velvet", "Candle", "Ashen", "Brass", "Crooked", "Sainted", "Static"] |
| titles = [ |
| "Overthinker in Residence", |
| "Snack Baron of Almost", |
| "Dossier Clerk", |
| "Chaos Notary", |
| "Sidequest Duke", |
| "Patron Saint of Later", |
| ] |
| noun = style["noun_pool"][seed % len(style["noun_pool"])] |
| adjective = adjectives[(seed // 7) % len(adjectives)] |
| title = titles[(seed // 13) % len(titles)] |
|
|
| safe_name = re.sub(r"[^A-Za-z0-9 ]+", "", user_name).strip()[:MAX_NAME_CHARS] |
| name_prefix = safe_name.title() if safe_name else adjective |
| trollsona_name = f"{name_prefix} {noun}-{title}" |
|
|
| roast_templates = [ |
| "Listen, paisan: your vibe is a candlelit side quest that opened twelve tabs, found a tiny crown, and called it destiny.", |
| "Your aura says main character, but your calendar is dressed like a haunted binder asking for rent.", |
| "You are one dramatic cape away from turning a normal errand into a village ordinance.", |
| "Your brain is a basement tavern where every idea demands a theme song, a snack bowl, and a separate invoice.", |
| "Madone, you carry the confidence of a bridge troll charging tolls in vibes and loose receipts.", |
| "You alphabetize chaos, misplace the alphabet, then file a complaint with the moon.", |
| ] |
| advice_templates = [ |
| "Pick one task, make it smaller, and finish that version before you rename the kingdom.", |
| "Write the next concrete step in one sentence, then do only that step. Capisce?", |
| "Keep the weird idea, but give it a deadline and a visible done state.", |
| "Trade one dramatic plan for one shipped artifact before the candles burn out.", |
| "Use the chaos as seasoning, not as project management.", |
| ] |
|
|
| score = compute_cringe_score(profile, persona, spice) |
| reply = roast_templates[(seed // 17 + spice) % len(roast_templates)] |
| advice = advice_templates[(seed // 23 + spice) % len(advice_templates)] |
| if not include_advice: |
| advice = "Truth withheld. The dossier clerk stamps the page and looks away." |
|
|
| return { |
| "trollsona_name": trollsona_name, |
| "troll_reply": reply, |
| "useful_advice": advice, |
| "cringe_score": score, |
| "cringe_score_label": cringe_label(score), |
| "include_advice": include_advice, |
| "runtime": f"model_id={MODEL_ID}; fallback_model_id={FALLBACK_MODEL_ID}; model_enabled={MODEL_ENABLED}", |
| "source": "deterministic_fallback", |
| "fallback_reason": reason, |
| } |
|
|
|
|
| @lru_cache(maxsize=1) |
| def load_model() -> tuple[Any | None, Any | None, str, str]: |
| if not MODEL_ENABLED: |
| return ( |
| None, |
| None, |
| "model disabled by TROLLSONA_ENABLE_MODEL", |
| f"model_id={MODEL_ID}; fallback_model_id={FALLBACK_MODEL_ID}; device=disabled", |
| ) |
|
|
| try: |
| import torch |
| from transformers import AutoModelForCausalLM, AutoTokenizer |
| except Exception as exc: |
| return ( |
| None, |
| None, |
| f"model dependencies unavailable: {type(exc).__name__}: {exc}", |
| f"model_id={MODEL_ID}; fallback_model_id={FALLBACK_MODEL_ID}; device=unavailable", |
| ) |
|
|
| failures: list[str] = [] |
|
|
| def load_tokenizer(candidate_id: str) -> Any: |
| tokenizer = AutoTokenizer.from_pretrained( |
| candidate_id, |
| use_fast=True, |
| trust_remote_code=True, |
| ) |
| if tokenizer.pad_token_id is None and tokenizer.eos_token is not None: |
| tokenizer.pad_token = tokenizer.eos_token |
| return tokenizer |
|
|
| def load_cuda_model(candidate_id: str) -> Any: |
| load_attempts = [ |
| { |
| "trust_remote_code": True, |
| "device_map": "cuda", |
| "dtype": torch.float16, |
| "low_cpu_mem_usage": True, |
| }, |
| { |
| "trust_remote_code": True, |
| "device_map": "cuda", |
| "torch_dtype": torch.float16, |
| "low_cpu_mem_usage": True, |
| }, |
| { |
| "trust_remote_code": True, |
| "torch_dtype": torch.float16, |
| "low_cpu_mem_usage": True, |
| }, |
| ] |
| last_error: Exception | None = None |
| for kwargs in load_attempts: |
| try: |
| model = AutoModelForCausalLM.from_pretrained(candidate_id, **kwargs) |
| if "device_map" not in kwargs: |
| model = model.to("cuda") |
| return model |
| except Exception as exc: |
| last_error = exc |
| if last_error is not None: |
| raise last_error |
| raise RuntimeError("CUDA model load failed without exception") |
|
|
| def load_cpu_model(candidate_id: str) -> Any: |
| try: |
| return AutoModelForCausalLM.from_pretrained( |
| candidate_id, |
| trust_remote_code=True, |
| low_cpu_mem_usage=True, |
| ) |
| except TypeError: |
| return AutoModelForCausalLM.from_pretrained(candidate_id, trust_remote_code=True) |
|
|
| candidates = [ |
| {"role": "primary", "model_id": MODEL_ID, "requires_cuda": True}, |
| {"role": "fallback_model", "model_id": FALLBACK_MODEL_ID, "requires_cuda": False}, |
| ] |
|
|
| seen_model_ids: set[str] = set() |
| for candidate in candidates: |
| candidate_id = str(candidate["model_id"]).strip() |
| if not candidate_id or candidate_id in seen_model_ids: |
| continue |
| seen_model_ids.add(candidate_id) |
| role = str(candidate["role"]) |
| requires_cuda = bool(candidate["requires_cuda"]) |
|
|
| if requires_cuda and not torch.cuda.is_available(): |
| failures.append(f"{role} {candidate_id}: CUDA unavailable") |
| continue |
|
|
| try: |
| tokenizer = load_tokenizer(candidate_id) |
| if torch.cuda.is_available(): |
| model = load_cuda_model(candidate_id) |
| device = "cuda" |
| else: |
| model = load_cpu_model(candidate_id) |
| device = "cpu" |
| model.eval() |
| torch.manual_seed(0) |
| if torch.cuda.is_available(): |
| torch.cuda.manual_seed_all(0) |
| fallback_note = "; ".join(failures) |
| status = "model loaded" if not fallback_note else f"model loaded after fallback: {fallback_note}" |
| runtime = ( |
| f"model_id={candidate_id}; role={role}; device={device}; " |
| f"cuda_available={torch.cuda.is_available()}" |
| ) |
| return tokenizer, model, status, runtime |
| except Exception as exc: |
| failures.append(f"{role} {candidate_id}: {type(exc).__name__}: {exc}") |
|
|
| failure_text = " | ".join(failures) if failures else "no model candidates configured" |
| runtime = ( |
| f"model_id={MODEL_ID}; fallback_model_id={FALLBACK_MODEL_ID}; " |
| f"cuda_available={torch.cuda.is_available()}" |
| ) |
| return None, None, f"model load failed: {failure_text}", runtime |
|
|
|
|
| def format_generation_prompt(tokenizer: Any, prompt: str) -> str: |
| try: |
| if getattr(tokenizer, "chat_template", None): |
| return tokenizer.apply_chat_template( |
| [{"role": "user", "content": prompt}], |
| tokenize=False, |
| add_generation_prompt=True, |
| ) |
| except Exception: |
| return prompt |
| return prompt |
|
|
|
|
| def generation_temperature(spice: int) -> float: |
| return round(0.48 + (clamp_spice(spice) * 0.08), 2) |
|
|
|
|
| def model_device(model: Any) -> Any: |
| target_device = getattr(model, "device", None) |
| if target_device is not None and str(target_device) != "meta": |
| return target_device |
| try: |
| return next(model.parameters()).device |
| except Exception: |
| return None |
|
|
|
|
| def generate_with_model(prompt: str, spice: int) -> tuple[str | None, str, str]: |
| tokenizer, model, status, runtime = load_model() |
| if tokenizer is None or model is None: |
| return None, status, runtime |
|
|
| try: |
| import torch |
|
|
| model_prompt = format_generation_prompt(tokenizer, prompt) |
| inputs = tokenizer(model_prompt, return_tensors="pt", truncation=True, max_length=1536) |
| target_device = model_device(model) |
| if target_device is not None: |
| inputs = {key: value.to(target_device) for key, value in inputs.items()} |
|
|
| seed = stable_int(prompt, str(spice), runtime) % (2**31) |
| torch.manual_seed(seed) |
| if hasattr(torch, "cuda") and torch.cuda.is_available(): |
| torch.cuda.manual_seed_all(seed) |
|
|
| with torch.no_grad(): |
| output_ids = model.generate( |
| **inputs, |
| max_new_tokens=MAX_NEW_TOKENS, |
| do_sample=True, |
| temperature=generation_temperature(spice), |
| num_beams=1, |
| repetition_penalty=1.1, |
| pad_token_id=tokenizer.eos_token_id, |
| ) |
| prompt_len = inputs["input_ids"].shape[-1] |
| generated_ids = output_ids[0][prompt_len:] |
| return tokenizer.decode(generated_ids, skip_special_tokens=True).strip(), status, runtime |
| except Exception as exc: |
| return None, f"model generation failed: {type(exc).__name__}: {exc}", runtime |
|
|
|
|
| def parse_loose_model_fields(raw_text: str) -> dict[str, str]: |
| fields: dict[str, str] = {} |
| for field in ["trollsona_name", "troll_reply", "useful_advice", "cringe_score_label"]: |
| pattern = rf'"{field}"\s*:\s*"((?:\\.|[^"\\])*)' |
| match = re.search(pattern, raw_text or "", flags=re.DOTALL) |
| if not match: |
| continue |
| try: |
| value = json.loads(f'"{match.group(1)}"') |
| except json.JSONDecodeError: |
| value = match.group(1) |
| fields[field] = str(value) |
| return fields |
|
|
|
|
| def coerce_model_result( |
| parsed: dict[str, Any], |
| fallback: dict[str, Any], |
| score: int, |
| include_advice: bool, |
| fallback_reason: str, |
| runtime: str, |
| ) -> dict[str, Any] | None: |
| result = dict(fallback) |
| field_limits = { |
| "trollsona_name": 80, |
| "troll_reply": 360, |
| "useful_advice": 280, |
| "cringe_score_label": 80, |
| } |
| used_fields: list[str] = [] |
| missing_fields: list[str] = [] |
|
|
| for field, limit in field_limits.items(): |
| value = clean_text(parsed.get(field), limit) |
| if value and is_safe_text(value): |
| result[field] = value |
| used_fields.append(field) |
| else: |
| missing_fields.append(field) |
|
|
| if not used_fields: |
| return None |
|
|
| result["cringe_score"] = score |
| result["include_advice"] = include_advice |
| result["source"] = "transformers_model" |
| result["runtime"] = runtime |
| if missing_fields: |
| partial_reason = f"model output partial; fallback filled: {', '.join(missing_fields)}" |
| result["fallback_reason"] = ( |
| f"{fallback_reason}; {partial_reason}" if fallback_reason else partial_reason |
| ) |
| else: |
| result["fallback_reason"] = fallback_reason |
| return result |
|
|
|
|
| def parse_model_output( |
| raw_text: str, |
| fallback: dict[str, Any], |
| score: int, |
| include_advice: bool, |
| fallback_reason: str, |
| runtime: str, |
| ) -> dict[str, Any] | None: |
| decoder = json.JSONDecoder() |
| parsed = None |
| for match in re.finditer(r"\{", raw_text or ""): |
| try: |
| candidate, _ = decoder.raw_decode(raw_text[match.start() :]) |
| except json.JSONDecodeError: |
| continue |
| if isinstance(candidate, dict): |
| parsed = candidate |
| break |
|
|
| if parsed is None: |
| parsed = parse_loose_model_fields(raw_text) |
|
|
| return coerce_model_result(parsed, fallback, score, include_advice, fallback_reason, runtime) |
|
|
|
|
| def repair_model_output( |
| raw_text: str, |
| fallback: dict[str, Any], |
| fallback_reason: str, |
| runtime: str, |
| ) -> dict[str, Any] | None: |
| repaired_reply = clean_text(raw_text, 360) |
| repaired_reply = re.sub(r"^```(?:json)?|```$", "", repaired_reply).strip() |
| if not repaired_reply or repaired_reply.startswith("{"): |
| return None |
| if not is_safe_text(repaired_reply): |
| return None |
|
|
| result = dict(fallback) |
| result["troll_reply"] = repaired_reply |
| result["source"] = "transformers_model_repaired" |
| result["runtime"] = runtime |
| repair_reason = "model output was not valid JSON and was repaired" |
| result["fallback_reason"] = f"{fallback_reason}; {repair_reason}" if fallback_reason else repair_reason |
| return result |
|
|
|
|
| def safety_guard(result: dict[str, Any], fallback: dict[str, Any]) -> dict[str, Any]: |
| fields = [ |
| result.get("trollsona_name", ""), |
| result.get("troll_reply", ""), |
| result.get("useful_advice", ""), |
| result.get("cringe_score_label", ""), |
| ] |
| if not all(is_safe_text(str(field)) for field in fields): |
| guarded = dict(fallback) |
| guarded["troll_reply"] = SAFE_REPLY |
| guarded["useful_advice"] = SAFE_ADVICE |
| guarded["fallback_reason"] = "safety guard replaced unsafe output" |
| return guarded |
| return result |
|
|
|
|
| def render_card(result: dict[str, Any]) -> str: |
| esc = {key: html.escape(str(value)) for key, value in result.items()} |
| score = max(0, min(100, int(result.get("cringe_score", 0)))) |
| useful_advice = clean_text(result.get("useful_advice", ""), 280) |
| show_advice = bool(result.get("include_advice", True)) and bool(useful_advice) |
| advice_tile = ( |
| f""" |
| <div class="trollsona-tile"> |
| <div class="trollsona-label">A USEFUL SLAP</div> |
| <div class="trollsona-value">{html.escape(useful_advice)}</div> |
| </div> |
| """.rstrip() |
| if show_advice |
| else "" |
| ) |
| grid_class = "trollsona-grid" if show_advice else "trollsona-grid trollsona-grid-single" |
| return f""" |
| <div class="trollsona-card"> |
| <div class="dossier-kicker">THE SUMMONED MENACE</div> |
| <h2>{esc["trollsona_name"]}</h2> |
| <div class="trollsona-mainline">{esc["troll_reply"]}</div> |
| <div class="{grid_class}"> |
| {advice_tile} |
| <div class="trollsona-tile"> |
| <div class="trollsona-label">GOBLIN METER</div> |
| <div class="meter-shell" aria-label="Goblin meter {score} out of 100"> |
| <div class="meter-fill" style="width: {score}%"></div> |
| </div> |
| <div class="trollsona-value">{score}/100 - {esc["cringe_score_label"]}</div> |
| </div> |
| </div> |
| </div> |
| """.strip() |
|
|
|
|
| def render_cursed_paperwork(result: dict[str, Any]) -> str: |
| source = clean_text(result.get("source", "unknown"), 80) |
| runtime = clean_text(result.get("runtime", "runtime unavailable"), 260) |
| fallback_reason = clean_text(result.get("fallback_reason", ""), 180) |
| if not fallback_reason: |
| fallback_reason = "No fallback note." |
| return ( |
| f"**Source:** `{source}` \n" |
| f"**Runtime:** `{runtime}` \n" |
| f"**Fallback note:** {fallback_reason}" |
| ) |
|
|
|
|
| def render_empty_card() -> str: |
| return """ |
| <div class="empty-dossier"> |
| <div class="dossier-kicker">The dossier is sealed</div> |
| <h2>No menace has signed the paperwork yet.</h2> |
| <p>Feed the booth a little lore, pick a resident menace, and pull the handle.</p> |
| </div> |
| """.strip() |
|
|
|
|
| def load_preset(index: int) -> tuple[str, str, str, int, bool]: |
| return PRESET_DOSSIERS[index]["values"] |
|
|
|
|
| def generate_trollsona( |
| user_name: str, |
| profile: str, |
| persona: str, |
| spice: int, |
| include_advice: bool, |
| ) -> tuple[str, dict[str, Any], str]: |
| user_name = clean_text(user_name, MAX_NAME_CHARS) |
| profile = clean_text(profile, MAX_PROFILE_CHARS) |
| persona = persona if persona in PERSONA_STYLES else "Forest Heckler" |
| spice = clamp_spice(spice) |
| include_advice = bool(include_advice) |
|
|
| fallback = fallback_trollsona( |
| user_name=user_name, |
| profile=profile, |
| persona=persona, |
| spice=spice, |
| include_advice=include_advice, |
| reason="model unavailable or output invalid", |
| ) |
|
|
| score = compute_cringe_score(profile, persona, spice) |
| prompt = build_prompt(user_name, profile, persona, spice, include_advice, score) |
| raw_text, model_status, runtime = generate_with_model(prompt, spice) |
| model_fallback_reason = "" if model_status == "model loaded" else model_status |
|
|
| result = None |
| if raw_text: |
| result = parse_model_output( |
| raw_text=raw_text, |
| fallback=fallback, |
| score=score, |
| include_advice=include_advice, |
| fallback_reason=model_fallback_reason, |
| runtime=runtime, |
| ) |
| if result is None: |
| result = repair_model_output(raw_text, fallback, model_fallback_reason, runtime) |
|
|
| if result is None: |
| result = dict(fallback) |
| result["fallback_reason"] = model_status |
| result["runtime"] = runtime |
|
|
| result = safety_guard(result, fallback) |
| return render_card(result), result, render_cursed_paperwork(result) |
|
|
|
|
| def build_demo() -> Any: |
| import gradio as gr |
|
|
| css = "" |
| css_path = os.path.join(os.path.dirname(__file__), "assets", "style.css") |
| if os.path.exists(css_path): |
| with open(css_path, "r", encoding="utf-8") as handle: |
| css = handle.read() |
|
|
| with gr.Blocks(title=APP_TITLE, css=css) as demo: |
| gr.HTML( |
| f""" |
| <section class="ritual-hero"> |
| <div class="hero-mark">Trollsona</div> |
| <h1>{APP_TITLE}</h1> |
| <p>{APP_SUBTITLE}</p> |
| <div class="badge-row"> |
| <span>Build Small Hackathon</span> |
| <span>Small model</span> |
| <span>Safe grotesque humor</span> |
| <span>{TRACK_NAME}</span> |
| </div> |
| </section> |
| """.strip() |
| ) |
|
|
| with gr.Row(elem_classes=["ritual-layout"]): |
| with gr.Column(scale=1, elem_classes=["summoning-panel"]): |
| gr.HTML('<div class="panel-heading">The summoning booth</div>') |
| user_name = gr.Textbox( |
| label="What do they call you?", |
| placeholder="Mira", |
| max_lines=1, |
| ) |
| profile = gr.Textbox( |
| label="Confess your little lore", |
| placeholder="I overbuild side projects, drink too much coffee, and love weird UI.", |
| lines=5, |
| max_lines=7, |
| ) |
| persona = gr.Dropdown( |
| label="Pick your resident menace", |
| choices=list(PERSONA_STYLES.keys()), |
| value="Back-Alley Oracle", |
| ) |
| spice = gr.Slider( |
| label="How hard should it sting?", |
| minimum=1, |
| maximum=5, |
| value=3, |
| step=1, |
| ) |
| include_advice = gr.Checkbox(label="Slip in one useful truth", value=True) |
| generate_button = gr.Button("Summon Trollsona", variant="primary") |
|
|
| with gr.Column(scale=1, elem_classes=["dossier-stage"]): |
| card_output = gr.HTML(value=render_empty_card()) |
| debug_state = gr.State() |
| with gr.Accordion("See the cursed paperwork", open=False): |
| debug_output = gr.Markdown( |
| value=( |
| "**Source:** `not summoned` \n" |
| "**Runtime:** `not summoned` \n" |
| "**Fallback note:** The dossier clerk is still asleep." |
| ) |
| ) |
|
|
| generate_button.click( |
| fn=generate_trollsona, |
| inputs=[user_name, profile, persona, spice, include_advice], |
| outputs=[card_output, debug_state, debug_output], |
| ) |
|
|
| with gr.Accordion("Stolen dossiers", open=False): |
| gr.HTML('<div class="preset-note">Tap a stolen dossier to pre-fill the booth.</div>') |
| with gr.Row(elem_classes=["preset-row"]): |
| for preset_index, preset in enumerate(PRESET_DOSSIERS): |
| preset_button = gr.Button( |
| preset["button"], |
| variant="secondary", |
| elem_classes=["preset-card"], |
| ) |
| preset_button.click( |
| fn=lambda index=preset_index: load_preset(index), |
| inputs=[], |
| outputs=[user_name, profile, persona, spice, include_advice], |
| ) |
|
|
| return demo |
|
|
|
|
| demo = None if parse_bool_env("TROLLSONA_SKIP_UI_BUILD", default=False) else build_demo() |
|
|
|
|
| if __name__ == "__main__": |
| (demo or build_demo()).launch() |
|
|
