Creative Applications › Code Implementation

import re
import string


def get_last_vowel_sound(word):
    """Approximate rhyme detection by extracting the final vowel cluster + consonants."""
    word = word.lower().strip(string.punctuation)
    # Find the last vowel group and everything after it
    match = re.search(r"[aeiou][^aeiou]*$", word)
    if match:
        return match.group()
    return word[-2:]  # fallback


def analyze_rhyme_scheme(poem_lines):
    """
    Analyze the rhyme scheme of a poem.
    Returns a string like 'ABAB' or 'AABB'.
    """
    endings = []
    for line in poem_lines:
        line = line.strip()
        if not line:
            continue
        words = line.split()
        if words:
            endings.append(get_last_vowel_sound(words[-1]))

    # Map each unique sound to a letter
    sound_to_letter = {}
    current_letter = ord("A")
    scheme = []

    for sound in endings:
        # Check if this sound rhymes with any existing category
        matched = False
        for existing_sound, letter in sound_to_letter.items():
            if sound == existing_sound:
                scheme.append(chr(letter))
                matched = True
                break
        if not matched:
            sound_to_letter[sound] = current_letter
            scheme.append(chr(current_letter))
            current_letter += 1

    return "".join(scheme)


# Example: Analyze a Shakespearean sonnet opening
sonnet_opening = [
    "Shall I compare thee to a summer's day?",
    "Thou art more lovely and more temperate:",
    "Rough winds do shake the darling buds of May,",
    "And summer's lease hath all too short a date:",
]

scheme = analyze_rhyme_scheme(sonnet_opening)

import subprocess

subprocess.run(["uv", "pip", "install", "cmudict"], capture_output=True)

import cmudict as cmudict_lib

# Load CMU Pronouncing Dictionary once at module level
_cmu_dict = cmudict_lib.dict()


def count_syllables(word):
    """Count syllables using the CMU Pronouncing Dictionary."""
    word_clean = word.lower().strip(string.punctuation)
    entries = _cmu_dict.get(word_clean, None)
    if entries:
        # Count stress markers (0, 1, 2) in the first pronunciation
        return sum(1 for phoneme in entries[0] if phoneme[-1].isdigit())
    # Fallback: count vowel groups
    return len(re.findall(r"[aeiou]+", word_clean, re.IGNORECASE)) or 1


def count_line_syllables(line):
    """Count total syllables in a line of poetry."""
    words = line.split()
    return sum(count_syllables(w) for w in words)


# Test on haiku
haiku = [
    "An old silent pond",
    "A frog jumps into the pond",
    "Splash! Silence again",
]

syllable_counts = [count_line_syllables(line) for line in haiku]

from dataclasses import dataclass
from typing import List


@dataclass
class StoryBeat:
    act: int
    beat_name: str
    description: str
    questions: List[str]


def generate_three_act_structure(
    protagonist: str, goal: str, obstacle: str, theme: str
) -> List[StoryBeat]:
    """Generate a three-act story structure outline."""

    beats = [
        StoryBeat(
            1,
            "Opening Image",
            f"Establish {protagonist}'s ordinary world before the story begins.",
            [
                f"What does {protagonist}'s normal life look like?",
                "What tone does the story set visually?",
            ],
        ),
        StoryBeat(
            1,
            "Inciting Incident",
            f"{protagonist} encounters a disruption that makes {goal} necessary.",
            [
                "What event forces the story into motion?",
                "Why can't the protagonist ignore this?",
            ],
        ),
        StoryBeat(
            1,
            "First Plot Point",
            f"{protagonist} commits to pursuing {goal}, crossing into a new world.",
            [
                "What decision locks the protagonist into the story?",
                "What is at stake if they fail?",
            ],
        ),
        StoryBeat(
            2,
            "Rising Action",
            f"{protagonist} faces increasingly difficult challenges as {obstacle} intensifies.",
            [
                f"How does {obstacle} escalate?",
                "What does the protagonist learn about themselves?",
            ],
        ),
        StoryBeat(
            2,
            "Midpoint",
            f"A false victory or major revelation reframes {protagonist}'s understanding.",
            [
                "What changes the protagonist's strategy?",
                "What truth do they confront?",
            ],
        ),
        StoryBeat(
            2,
            "Dark Night of the Soul",
            f"{protagonist} appears to have lost everything. The theme of '{theme}' is most sharply tested.",
            [
                "What is the protagonist's lowest point?",
                f"How does '{theme}' challenge them here?",
            ],
        ),
        StoryBeat(
            3,
            "Climax",
            f"{protagonist} confronts {obstacle} directly, armed with new understanding.",
            [
                "How does the protagonist apply what they've learned?",
                "What must they sacrifice or accept?",
            ],
        ),
        StoryBeat(
            3,
            "Resolution",
            f"The consequences of {protagonist}'s choices settle. The theme of '{theme}' is affirmed or subverted.",
            [
                "How has the world changed?",
                f"What does the story say about '{theme}'?",
            ],
        ),
    ]

    return beats


# Example story
beats = generate_three_act_structure(
    protagonist="a linguist who discovers her translation algorithm is being used for surveillance",
    goal="expose the misuse without destroying her life's work",
    obstacle="a powerful corporation and her own complicity in what happened",
    theme="the responsibility of tool-makers for how their tools are used",
)

import numpy as np


def compute_style_features(text: str) -> dict:
    """Extract stylometric features from a text sample."""
    sentences = re.split(r"[.!?]+", text)
    sentences = [s.strip() for s in sentences if s.strip()]
    words = text.split()

    # Basic features
    avg_sentence_length = (
        np.mean([len(s.split()) for s in sentences]) if sentences else 0
    )
    word_lengths = [
        len(w.strip(string.punctuation))
        for w in words
        if w.strip(string.punctuation)
    ]
    avg_word_length = np.mean(word_lengths) if word_lengths else 0

    # Vocabulary richness (type-token ratio)
    unique_words = set(w.lower().strip(string.punctuation) for w in words)
    ttr = len(unique_words) / len(words) if words else 0

    # Punctuation density
    punct_count = sum(1 for c in text if c in string.punctuation)
    punct_density = punct_count / len(text) if text else 0

    # Sentence length variance (consistency vs. variety)
    sent_lengths = [len(s.split()) for s in sentences]
    sent_variance = (
        float(np.var(sent_lengths)) if len(sent_lengths) > 1 else 0.0
    )

    return {
        "avg_sentence_length": round(avg_sentence_length, 1),
        "avg_word_length": round(avg_word_length, 2),
        "type_token_ratio": round(ttr, 3),
        "punct_density": round(punct_density, 3),
        "sentence_length_variance": round(sent_variance, 1),
        "sentence_count": len(sentences),
        "word_count": len(words),
    }


# Compare three distinct prose styles
styles = {
    "Minimalist (Carver-like)": """
        He drove her to work. She didn't say thank you. He didn't expect it.
        Outside, it was raining. He sat in the car for a while after she went in.
        He thought about calling his brother. He didn't.
    """,
    "Maximalist (Proust-like)": """
        The morning light, that particular quality of autumn morning light which falls
        not so much upon the world as through it, transforming even the most ordinary
        surfaces, the kitchen table, the worn linoleum, the steam rising from her cup,
        into something that seemed, in those first moments before thought properly
        established itself, almost unbearably tender and irretrievably past.
    """,
    "Technical/Analytical": """
        The algorithm processes input tokens sequentially. Each token is mapped to an
        embedding vector. These vectors are combined using attention weights. The output
        layer produces probability distributions over the vocabulary. Training minimizes
        cross-entropy loss.
    """,
}

features = {name: compute_style_features(text) for name, text in styles.items()}