Upload generator.py with huggingface_hub

generator.py

@@ -0,0 +1,341 @@
+"""Procedural story generator — the "not in the world" dataset engine.
+
+Each call to ``generate_story`` synthesises a unique fable by sampling from
+combinatorial pools of realms, creatures, archetypes, magic systems, and plot
+scaffolds, then weaving the chosen ingredients through natural-language
+templates. Because the pools are large and the templates branch on sampled
+attributes, the space of possible stories is astronomically larger than the
+target corpus size — so every generated fable is essentially unique.
+
+A small fraction of stories (``curated_fraction``) draw their moral from a
+hand-written list of public-domain-style aphorisms, blending synthetic
+structure with curated linguistic flavour. No external data is downloaded.
+"""
+
+from __future__ import annotations
+
+import random
+import re
+from typing import List, Tuple
+
+from .config import DATA
+
+# ---------------------------------------------------------------------------
+# Word pools — the combinatorial ingredient shelf
+# ---------------------------------------------------------------------------
+REALMS: List[str] = [
+    "the Glasslands", "the Hollow Mountain", "the Verdant Mire", "the Sunken City",
+    "the Ashen Coast", "the Ember Steppes", "the Whispering Tundra",
+    "the Obsidian Reach", "the Mossy Hollow", "the Crystal Vale",
+    "the Forgotten Sky", "the Pale Marshlands", "the Bramblewilds",
+    "the Singing Caverns", "the Coral Reaches", "the Duskwood",
+    "the Glittering Dunes", "the Frozen Hollow", "the Lacquered Lake",
+    "the Stargrove", "the Tidemarsh", "the Vexing Cliffs",
+    "the Lantern Fields", "the Quiet Reaches", "the Bone Hollow",
+    "the Saltwood", "the Copper Hills", "the Indigo Wilds",
+]
+
+CREATURES: List[str] = [
+    "a mossback tortoise", "a will-o-wisp", "a glimmer-fox", "a hollow crow",
+    "a stone-hearted golem", "a tide serpent", "a lantern moth",
+    "a frost salamander", "a whisper-hare", "a bramble cat",
+    "a copperfin koi", "a glass spider", "a storm owl", "a mirror stag",
+    "a moss wyrm", "a sun-bleached heron", "a velvet viper",
+    "a mist lynx", "a rust badger", "a gilded beetle",
+    "a paper crane", "a salt-crab", "a hollow wolf", "a moon-calf",
+    "a thorn lizard", "a vapour eel", "a cinder rat", "a dusk moth",
+]
+
+ARCHETYPES: List[str] = [
+    "a lonely lantern-keeper", "an exiled cartographer",
+    "a wandering apothecary", "a river-tongue translator",
+    "a forgotten heir", "a hedge inventor",
+    "a tide-reader", "a soft-spoken blacksmith",
+    "a wandering musician", "a half-blind archivist",
+    "a reluctant ferryman", "a child of the marshes",
+    "a retired monster-hunter", "a dream-stitched seamstress",
+    "a clockwork tinkerer", "a wandering judge",
+    "a stone-carver", "a comet-watcher", "a toll-keeper",
+    "a knot-weaver", "a wind-listener", "a mirror-polisher",
+]
+
+MAGIC_SYSTEMS: List[str] = [
+    "binding spoken promises", "weaving light into thread",
+    "reading the tides of memory", "singing iron to sleep",
+    "bargaining with shadows", "knitting wounds with song",
+    "borrowing the eyes of birds", "steaming lies into the air",
+    "freezing moments in glass", "trading years for favours",
+    "whispering to roots and stone", "summoning rain from grief",
+    "folding distance like paper", "pouring courage into water",
+    "binding names to candles", "weighing hearts with starlight",
+]
+
+# ---------------------------------------------------------------------------
+# Plot scaffolds — each yields a coherent narrative arc
+# ---------------------------------------------------------------------------
+# Every scaffold takes a single ``ctx`` dict with keys:
+#   hero_full, hero_bare, creature_full, creature_bare, realm, magic, rng
+# ``*_full`` includes the leading article ("a wind-listener"), used for first
+# mention; ``*_bare`` strips it ("wind-listener") for natural reuse later.
+# Returning a list of clause fragments, joined + capitalised by the caller.
+
+
+def _cap(text: str) -> str:
+    """Capitalise the first letter of a sentence."""
+    return text[0].upper() + text[1:] if text else text
+
+
+def _sentence_join(parts: List[str]) -> str:
+    """Join clause fragments into sentences, capitalising each sentence start."""
+    text = " ".join(p.strip() for p in parts if p.strip())
+    text = re.sub(r"\s+", " ", text)
+    return _cap(text)
+
+
+def _quest(ctx):
+    rng = ctx["rng"]
+    hero = ctx["hero_full"]
+    creature_full = ctx["creature_full"]
+    realm, magic = ctx["realm"], ctx["magic"]
+    target = rng.choice(["a stolen song", "a lost name", "a sunken key",
+                         "a broken crown", "a silver seed",
+                         "a forgotten map", "a glass heart"])
+    obstacle = rng.choice([
+        "the river that forgot how to flow",
+        "a bridge woven only from apologies",
+        "a field where spoken lies turn to stone",
+        "a gate that opens only to grief",
+        "a forest that eats the names of strangers",
+    ])
+    return [
+        f"One morning {hero} set out across {realm} to recover {target}.",
+        f"The path was barred by {creature_full}, who guarded {obstacle}.",
+        f"Remembering the old art of {magic}, {hero} offered a bargain.",
+        "The bargain was accepted, though it cost more than expected.",
+        f"In the end {hero} carried {target} home, lighter than before.",
+    ]
+
+
+def _betrayal(ctx):
+    rng = ctx["rng"]
+    hero = ctx["hero_full"]
+    creature_full = ctx["creature_full"]
+    realm, magic = ctx["realm"], ctx["magic"]
+    ally_full = rng.choice(ARCHETYPES)
+    if ally_full == hero:
+        ally_full = "an old companion"
+    secret = rng.choice([
+        "had been hiding the true name of the realm",
+        "had sold the village's silence for safe passage",
+        "was never mortal to begin with",
+        "had been shaping the hero's dreams for years",
+    ])
+    return [
+        f"For years {hero} and {ally_full} shared the work of {realm}.",
+        f"Then {creature_full} appeared at the door with a confession.",
+        f"It seemed the companion {secret}.",
+        f"{_cap(hero)} answered not with anger but with {magic}.",
+        "What was broken could not be mended, only understood.",
+    ]
+
+
+def _discovery(ctx):
+    rng = ctx["rng"]
+    hero = ctx["hero_full"]
+    creature_full = ctx["creature_full"]
+    realm, magic = ctx["realm"], ctx["magic"]
+    found = rng.choice([
+        "a sealed letter from a dead king",
+        "a door standing in the middle of an empty field",
+        "a well that whispered in a forgotten tongue",
+        "a child's drawing of a place that did not exist",
+        "a clock running backwards",
+        "a mirror showing a room that was not there",
+    ])
+    return [
+        f"While walking the edges of {realm}, {hero} found {found}.",
+        "At first it seemed harmless, even quaint.",
+        f"But {creature_full} would not come near it, and would say why.",
+        f"Slowly {hero} understood the old craft of {magic} was the only key.",
+        "What was uncovered could not be buried again.",
+    ]
+
+
+def _transformation(ctx):
+    rng = ctx["rng"]
+    hero = ctx["hero_full"]
+    creature_full = ctx["creature_full"]
+    realm, magic = ctx["realm"], ctx["magic"]
+    change = rng.choice([
+        "into a creature of bark and slow water",
+        "into someone who could not be remembered",
+        "into a keeper of small, impossible fires",
+        "into a version of themselves ten years younger",
+        "into a bridge between two feuding villages",
+    ])
+    return [
+        f"On the longest night of the year, {hero} changed {change}.",
+        f"The folk of {realm} did not know whether to mourn or rejoice.",
+        f"Only {creature_full} seemed unsurprised, and waited patiently.",
+        f"To learn to live in this new shape, {hero} studied {magic}.",
+        "Some changes, once made, choose not to be undone.",
+    ]
+
+
+def _meeting(ctx):
+    rng = ctx["rng"]
+    hero = ctx["hero_full"]
+    creature_full = ctx["creature_full"]
+    realm, magic = ctx["realm"], ctx["magic"]
+    stranger_full = rng.choice(ARCHETYPES)
+    if stranger_full == hero:
+        stranger_full = "a hooded traveller"
+    bargain = rng.choice([
+        "a year of silence in exchange for one true answer",
+        "their shadow, traded for safe passage home",
+        "three questions, no more and no less",
+        "the memory of their first love",
+        "a single seed from the heart-tree",
+    ])
+    return [
+        f"At the boundary of {realm}, {hero} met {stranger_full}.",
+        f"The stranger offered a bargain: {bargain}.",
+        f"{_cap(creature_full)} watched from the reeds and said nothing.",
+        f"{_cap(hero)} weighed the cost in the old way of {magic}.",
+        "Whatever was decided, both walked away changed.",
+    ]
+
+
+# Registry of plot scaffolds — referenced by the engine via random.choice.
+SCAFFOLDS = [_quest, _betrayal, _discovery, _transformation, _meeting]
+
+# ---------------------------------------------------------------------------
+# Curated morals — public-domain-style aphorisms (hand-written, no source)
+# ---------------------------------------------------------------------------
+MORALS: List[str] = [
+    "A kindness given in secret returns when it is most needed.",
+    "The cost of a thing is rarely its price.",
+    "What we cannot name, we cannot truly keep.",
+    "A road walked twice is never the same road.",
+    "Patience is the quietest form of courage.",
+    "The smallest promise weighs the most.",
+    "Even the lost have a direction; it is simply not ours.",
+    "To listen is to lend someone a piece of your life.",
+    "A wound ignored does not heal; it waits.",
+    "We are remembered not for what we took, but what we carried.",
+    "The map is not the land, but it can break your heart.",
+    "Silence, like salt, preserves and ruins in equal measure.",
+    "Grief is the tuition the living pay for love.",
+    "A door closed in kindness is still a door closed.",
+    "The brave are seldom the loudest.",
+    "Old debts do not rust.",
+    "Mercy costs nothing but the will to give it.",
+    "The longest journey is the one postponed.",
+    "What fires forge, fires also test.",
+    "Truth travels slowly, but it does travel.",
+    "Beware the bargain that costs only your silence.",
+    "The hand that feeds the wolf still feeds the wolf.",
+    "Hope is a habit, not a feeling.",
+    "Even shattered glass once held the morning.",
+    "You cannot outrun the name you have earned.",
+]
+
+# ---------------------------------------------------------------------------
+# Engine
+# ---------------------------------------------------------------------------
+class StoryGenerator:
+    """Procedurally generates unique fables."""
+
+    def __init__(self, seed: int = DATA.seed) -> None:
+        self.rng = random.Random(seed)
+
+    # ------------------------------------------------------------------
+    def sample_ingredients(self) -> dict:
+        """Sample hero/creature/realm/magic and return a scaffold context dict."""
+        hero_full = self.rng.choice(ARCHETYPES)
+        creature_full = self.rng.choice(CREATURES)
+        realm = self.rng.choice(REALMS)
+        magic = self.rng.choice(MAGIC_SYSTEMS)
+        return {
+            "hero_full": hero_full,
+            "creature_full": creature_full,
+            "realm": realm,
+            "magic": magic,
+            "rng": self.rng,
+        }
+
+    def _opening(self, hero_full: str, realm: str) -> str:
+        templates = [
+            f"In {realm} there lived {hero_full}.",
+            f"Long ago, when {realm} was still young, {hero_full} kept a quiet life.",
+            f"Few in {realm} knew the name of {hero_full}, but those who did did not forget.",
+            f"This is the story of {hero_full}, and of the trouble that found them in {realm}.",
+            f"To understand {realm}, you must first understand {hero_full}.",
+        ]
+        return self.rng.choice(templates)
+
+    def generate_story(self, index: int) -> dict:
+        """Generate a single fable. Returns a dict with text + metadata."""
+        ctx = self.sample_ingredients()
+        scaffold = self.rng.choice(SCAFFOLDS)
+        body = scaffold(ctx)
+
+        # curated moral on a fraction of stories, else a synthesised one
+        if self.rng.random() < DATA.curated_fraction:
+            moral = self.rng.choice(MORALS)
+            moral_source = "curated"
+        else:
+            moral = self._synthesised_moral()
+            moral_source = "synthetic"
+
+        text = (
+            self._opening(ctx["hero_full"], ctx["realm"])
+            + " " + _sentence_join(body)
+            + " " + moral
+        )
+        return {
+            "id": index,
+            "text": text.strip(),
+            "hero": ctx["hero_full"],
+            "creature": ctx["creature_full"],
+            "realm": ctx["realm"],
+            "magic": ctx["magic"],
+            "scaffold": scaffold.__name__.lstrip("_"),
+            "moral_source": moral_source,
+            "moral": moral,
+        }
+
+    def _synthesised_moral(self) -> str:
+        """Build a fresh aphorism from fragments (keeps vocab diverse)."""
+        subject = self.rng.choice([
+            "the keeper of the path", "a stranger in need",
+            "those who listen", "the patient heart",
+            "the one who waits", "a stubborn hope",
+            "an unspoken name", "a quiet promise",
+        ])
+        verb = self.rng.choice([
+            "outlasts", "outlives", "finds", "remembers",
+            "rewrites", "redeems", "outwaits", "unmakes",
+        ])
+        obj = self.rng.choice([
+            "the loudest storm",
+            "the cleverest lie",
+            "the sharpest blade",
+            "the deepest wound",
+            "the longest winter",
+            "the brightest crown",
+            "the swiftest river",
+        ])
+        return f"In the end, {subject} {verb} {obj}."
+
+    # ------------------------------------------------------------------
+    def generate_batch(self, n: int, start_index: int = 0) -> List[dict]:
+        return [self.generate_story(start_index + i) for i in range(n)]
+
+
+def estimate_combination_space() -> int:
+    """Lower bound on the number of distinct ingredient combos."""
+    return (
+        len(ARCHETYPES) * len(CREATURES) * len(REALMS) * len(MAGIC_SYSTEMS) *
+        len(SCAFFOLDS)
+    )