passiveaggressive 0.1.0__py3-none-any.whl

passiveaggressive/__init__.py

@@ -0,0 +1,21 @@
+"""passiveaggressive — turn polite messages into subtly passive-aggressive ones.
+
+>>> from passiveaggressive import translate
+>>> translate("Please update the documentation.", seed=1)  # doctest: +ELLIPSIS
+'...documentation...'
+"""
+
+from .templates import INTENSITIES, STYLES
+from .translator import email, rewrite, signoff, subject, translate
+
+__all__ = [
+    "translate",
+    "rewrite",
+    "email",
+    "subject",
+    "signoff",
+    "STYLES",
+    "INTENSITIES",
+]
+
+__version__ = "0.1.0"

passiveaggressive/cli.py

@@ -0,0 +1,64 @@
+"""Command-line entry point. Installed as the ``passiveaggressive`` script.
+
+Run ``passiveaggressive --help`` for the full rundown.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from .templates import INTENSITIES, STYLES
+from .translator import translate
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="passiveaggressive",
+        description="Convert a polite message into a subtly passive-aggressive one.",
+    )
+    parser.add_argument("text", help="The original, polite message to transform.")
+    parser.add_argument(
+        "--style",
+        choices=STYLES,
+        default="coworker",
+        help="Who's supposedly sending this (default: coworker).",
+    )
+    parser.add_argument(
+        "--intensity",
+        type=int,
+        choices=INTENSITIES,
+        default=3,
+        help="How annoyed they are, 1-5 (default: 3).",
+    )
+    parser.add_argument(
+        "--seed",
+        type=int,
+        default=None,
+        help="Set this to get the same output every time.",
+    )
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Parse args, translate, print. Returns an exit code."""
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    try:
+        result = translate(
+            args.text,
+            style=args.style,
+            intensity=args.intensity,
+            seed=args.seed,
+        )
+    except (TypeError, ValueError) as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        return 1
+
+    print(result)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

passiveaggressive/templates.py

@@ -0,0 +1,307 @@
+"""All the phrase banks live here.
+
+Everything's hand-written and organized by ``style`` (who's supposedly
+sending the message) and ``intensity`` (how annoyed they are). If you
+want to add a new style or tweak the wording, this is the only file
+you need to touch — the logic in translator.py doesn't care what the
+phrases actually say. Keep it office-friendly: mildly annoyed, never
+actually mean.
+"""
+
+from __future__ import annotations
+
+from typing import Final
+
+#: Supported style names.
+STYLES: Final[tuple[str, ...]] = (
+    "coworker",
+    "manager",
+    "customer_support",
+    "british",
+    "parent",
+    "teacher",
+)
+
+#: Supported intensity levels (1 = barely-there politeness, 5 = maximum sarcasm).
+INTENSITIES: Final[tuple[int, ...]] = (1, 2, 3, 4, 5)
+
+# ---------------------------------------------------------------------------
+# Prefixes — the opening clause that sets the tone. style -> intensity -> options.
+# ---------------------------------------------------------------------------
+
+PREFIXES: Final[dict[str, dict[int, tuple[str, ...]]]] = {
+    "coworker": {
+        1: (
+            "Just a gentle reminder,",
+            "Whenever you have a chance,",
+            "Quick note,",
+            "Just popping this back up,",
+        ),
+        2: (
+            "Just checking in,",
+            "Circling back on this,",
+            "Not to nag, but",
+            "Following up here,",
+        ),
+        3: (
+            "Just following up since this seems to have been overlooked,",
+            "Bumping this one more time,",
+            "Not sure if this got buried, but",
+            "Coming back to this again,",
+        ),
+        4: (
+            "Hate to keep bringing this up, but",
+            "This is now my third time mentioning it, and",
+            "Just so it doesn't get lost again,",
+            "Following up, as this seems to keep slipping,",
+        ),
+        5: (
+            "No rush at all, as always, but",
+            "Truly in no hurry, yet somehow still asking,",
+            "Not that it matters at this point, but",
+            "Just a friendly nudge for the fourth time,",
+        ),
+    },
+    "manager": {
+        1: (
+            "Whenever you get a moment,",
+            "Just wanted to touch base,",
+            "For your awareness,",
+            "Just a heads up,",
+        ),
+        2: (
+            "Just checking in on this again since I haven't seen an update,",
+            "Wanted to follow up on where this stands,",
+            "Circling back for visibility,",
+            "Touching base once more,",
+        ),
+        3: (
+            "I'll need an update on this soon,",
+            "This is still pending on my end,",
+            "Wanted to flag that this hasn't moved,",
+            "Coming back around on this open item,",
+        ),
+        4: (
+            "I've mentioned this a couple of times now, and",
+            "This continues to sit without an update, so",
+            "I'd appreciate some movement on this, since",
+            "Raising this again, as",
+        ),
+        5: (
+            "I'm sure it's just an oversight, but",
+            "At this point I've lost count of the follow-ups, and",
+            "Purely for my own curiosity,",
+            "Not to escalate, but I may have to, because",
+        ),
+    },
+    "customer_support": {
+        1: (
+            "Thank you for your patience,",
+            "We just wanted to let you know,",
+            "As a quick update,",
+            "We're reaching out to confirm,",
+        ),
+        2: (
+            "We wanted to follow up on your request,",
+            "Just checking in regarding your ticket,",
+            "We noticed this is still open, so",
+            "For your reference,",
+        ),
+        3: (
+            "We understand this may have been missed, so",
+            "We're following up once more on this,",
+            "This ticket remains unresolved, so",
+            "We wanted to gently revisit this,",
+        ),
+        4: (
+            "We've reached out a few times regarding this, and",
+            "This request continues to be open, so",
+            "We remain hopeful for a resolution, as",
+            "For the record, we have followed up before, and",
+        ),
+        5: (
+            "We're absolutely not in a rush, however",
+            "We do value your business, which is why",
+            "This ticket has aged gracefully, so",
+            "Per our multiple previous emails,",
+        ),
+    },
+    "british": {
+        1: (
+            "Not to be a bother, but",
+            "Terribly sorry to bring this up, but",
+            "Just a small thought, but",
+            "If it's no trouble,",
+        ),
+        2: (
+            "I do hope you don't mind me asking again, but",
+            "Ever so sorry to follow up, but",
+            "This might be a silly question, but",
+            "I don't want to be a pain, but",
+        ),
+        3: (
+            "I did wonder if this had perhaps slipped through, so",
+            "Frightfully sorry to mention it once more, but",
+            "Rather hoping this hasn't been forgotten, so",
+            "Just popping my head round the door to say",
+        ),
+        4: (
+            "I do apologize for going on about this, but",
+            "Not wishing to labour the point, but",
+            "Terribly persistent of me, I know, but",
+            "I realise I've asked before, and dreadfully sorry, but",
+        ),
+        5: (
+            "I wouldn't dream of making a fuss, but",
+            "Do forgive my being ever so slightly tenacious, but",
+            "Frightfully embarrassing to keep asking, but",
+            "Only mentioning it for the umpteenth time because",
+        ),
+    },
+    "parent": {
+        1: (
+            "Just leaving this here,",
+            "No pressure, but",
+            "Just a little note,",
+            "Whenever you think of it,",
+        ),
+        2: (
+            "I'll just leave this here in case anyone remembers,",
+            "Not that anyone asked, but",
+            "Just saying, in case it matters,",
+            "I only mention this because",
+        ),
+        3: (
+            "I've said this before, but",
+            "It's fine, I'll just do it myself, but",
+            "I'm only bringing it up again because",
+            "Someone might want to know that",
+        ),
+        4: (
+            "It's fine. Really. But",
+            "I'm not upset, I just noticed that",
+            "No, go ahead, don't worry about it, but",
+            "I only ask because I've asked before, and",
+        ),
+        5: (
+            "It's totally fine, don't worry about it, but",
+            "I'm sure you were just about to get to it, but",
+            "No need to explain, but",
+            "I won't say I told you so, but",
+        ),
+    },
+    "teacher": {
+        1: (
+            "A gentle reminder,",
+            "Just a friendly note,",
+            "For your reference,",
+            "As previously discussed,",
+        ),
+        2: (
+            "As a reminder from last time,",
+            "I wanted to check in on this,",
+            "This was mentioned in class, and",
+            "Following up on our earlier discussion,",
+        ),
+        3: (
+            "This has come up more than once, so",
+            "As noted previously,",
+            "I'll remind the class again that",
+            "This continues to be an outstanding item, so",
+        ),
+        4: (
+            "This has been mentioned several times now, so",
+            "I do hope this will be addressed, since",
+            "Let's revisit this one more time, since",
+            "As stated in the syllabus, and again here,",
+        ),
+        5: (
+            "I'm sure this was simply an oversight, but",
+            "Extra credit for finally addressing this, since",
+            "This is now a recurring theme, so",
+            "Noted for the permanent record, that",
+        ),
+    },
+}
+
+# ---------------------------------------------------------------------------
+# Softeners — dropped in mid-sentence to keep things technically polite.
+# ---------------------------------------------------------------------------
+
+SOFTENERS: Final[tuple[str, ...]] = (
+    "if possible",
+    "whenever you can",
+    "when convenient",
+    "at your earliest convenience",
+    "if time allows",
+    "no pressure",
+    "whenever works for you",
+)
+
+# ---------------------------------------------------------------------------
+# Closings, keyed by intensity.
+# ---------------------------------------------------------------------------
+
+CLOSINGS: Final[dict[int, tuple[str, ...]]] = {
+    1: (
+        "Thanks in advance.",
+        "Much appreciated.",
+        "Hopefully this helps.",
+        "Thanks so much.",
+    ),
+    2: (
+        "Looking forward to hearing back.",
+        "Appreciate your attention to this.",
+        "Thanks for understanding.",
+        "Let me know how it goes.",
+    ),
+    3: (
+        "Hoping to hear something soon.",
+        "Appreciate you taking a look.",
+        "Thanks for circling back on this one.",
+        "Let's get this squared away.",
+    ),
+    4: (
+        "Would appreciate an update sooner rather than later.",
+        "Hoping this can finally be resolved.",
+        "Thanks for finally getting to this.",
+        "Let's not let this linger any further.",
+    ),
+    5: (
+        "No rush at all, as always.",
+        "Whenever this century works for you.",
+        "Take your time, clearly no one else is.",
+        "Looking forward to this being ancient history.",
+    ),
+}
+
+# ---------------------------------------------------------------------------
+# Extra bits for email() / subject() / signoff().
+# ---------------------------------------------------------------------------
+
+EMAIL_PHRASES: Final[tuple[str, ...]] = (
+    "Just following up on this.",
+    "As mentioned previously,",
+    "Kindly take a look when you can.",
+    "Looking forward to hearing from you.",
+)
+
+SUBJECTS: Final[tuple[str, ...]] = (
+    "Following Up (Again)",
+    "Gentle Reminder",
+    "Quick Check-In",
+    "Re: Previous Email",
+    "Checking In",
+    "Touching Base",
+    "Friendly Reminder",
+)
+
+SIGNOFFS: Final[tuple[str, ...]] = (
+    "Kind regards,",
+    "Warm regards,",
+    "As always,",
+    "Many thanks,",
+    "Best,",
+    "Thanks in advance,",
+    "Appreciatively,",
+)

passiveaggressive/translator.py

@@ -0,0 +1,134 @@
+"""The actual translation logic.
+
+Everything here is built from the phrase banks in ``templates.py``. No
+AI, no network calls, just a random.Random instance picking from
+handcrafted lists of phrases. If you want to know why a particular
+sentence came out the way it did, that's the module to look at.
+"""
+
+from __future__ import annotations
+
+from .templates import (
+    CLOSINGS,
+    EMAIL_PHRASES,
+    INTENSITIES,
+    PREFIXES,
+    SIGNOFFS,
+    SOFTENERS,
+    STYLES,
+    SUBJECTS,
+)
+from .utils import capitalize_first, get_rng, normalize_core
+
+__all__ = ["translate", "rewrite", "email", "subject", "signoff"]
+
+_DEFAULT_STYLE = "coworker"
+_DEFAULT_INTENSITY = 3
+
+
+def _validate_style(style: str) -> None:
+    if style not in STYLES:
+        raise ValueError(
+            f"Unknown style {style!r}. Valid styles are: {', '.join(STYLES)}."
+        )
+
+
+def _validate_intensity(intensity: int) -> None:
+    if intensity not in INTENSITIES:
+        raise ValueError(f"Intensity must be one of {INTENSITIES}, got {intensity!r}.")
+
+
+def _validate_text(text: str) -> None:
+    if not isinstance(text, str):
+        raise TypeError(f"text must be a str, got {type(text).__name__}.")
+    if not text.strip():
+        raise ValueError(
+            "text can't be empty (or just whitespace) — there's nothing to translate."
+        )
+
+
+def translate(
+    text: str,
+    style: str = _DEFAULT_STYLE,
+    intensity: int = _DEFAULT_INTENSITY,
+    seed: int | None = None,
+) -> str:
+    """Turn a plain, polite message into a subtly passive-aggressive one.
+
+    ``style`` picks the personality delivering the line (coworker, manager,
+    customer_support, british, parent, or teacher — see ``STYLES``), and
+    ``intensity`` (1-5) controls how much annoyance leaks through. Pass a
+    ``seed`` if you need the same output twice; leave it off and you'll get
+    natural variation on every call.
+
+    >>> translate("Fix the bug.", seed=1)  # doctest: +ELLIPSIS
+    '...bug...'
+
+    Raises ``TypeError`` if ``text`` isn't a string, and ``ValueError`` if
+    it's empty, ``style`` isn't recognized, or ``intensity`` is out of range.
+    """
+    _validate_text(text)
+    _validate_style(style)
+    _validate_intensity(intensity)
+
+    rng = get_rng(seed)
+
+    core = normalize_core(text)
+    prefix = rng.choice(PREFIXES[style][intensity])
+    softener = rng.choice(SOFTENERS)
+    closing = rng.choice(CLOSINGS[intensity])
+
+    # A few different sentence shapes so the same prefix/softener/closing
+    # combo doesn't always come out reading identically.
+    shape = rng.choice(("simple", "softened", "buried"))
+    if shape == "simple":
+        body = f"{prefix} {core}."
+    elif shape == "softened":
+        body = f"{prefix} {core}, {softener}."
+    else:  # buried — tuck the softener in after an em dash
+        body = f"{prefix} {core} -- {softener}."
+
+    return f"{capitalize_first(body)} {closing}"
+
+
+def rewrite(
+    text: str,
+    style: str = _DEFAULT_STYLE,
+    intensity: int = _DEFAULT_INTENSITY,
+    seed: int | None = None,
+) -> str:
+    """Alias for ``translate()`` — some people just prefer the verb "rewrite"."""
+    return translate(text, style=style, intensity=intensity, seed=seed)
+
+
+def email(
+    text: str,
+    style: str = _DEFAULT_STYLE,
+    intensity: int = _DEFAULT_INTENSITY,
+    seed: int | None = None,
+) -> str:
+    """Like ``translate()``, but for email bodies.
+
+    Runs the text through the normal translation and tacks on an
+    email-flavored closer, e.g. "Looking forward to hearing from you."
+    """
+    _validate_text(text)
+    _validate_style(style)
+    _validate_intensity(intensity)
+
+    rng = get_rng(seed)
+    translated = translate(text, style=style, intensity=intensity, seed=seed)
+    extra = rng.choice(EMAIL_PHRASES)
+    return f"{translated} {extra}"
+
+
+def subject(seed: int | None = None) -> str:
+    """Pick a passive-aggressive email subject line, e.g. "Gentle Reminder"."""
+    rng = get_rng(seed)
+    return rng.choice(SUBJECTS)
+
+
+def signoff(seed: int | None = None) -> str:
+    """Pick a passive-aggressive sign-off, e.g. "As always,"."""
+    rng = get_rng(seed)
+    return rng.choice(SIGNOFFS)

passiveaggressive/utils.py

@@ -0,0 +1,64 @@
+"""Small text/RNG helpers used by the translator.
+
+Nothing fancy — just string cleanup and a thin wrapper around
+random.Random so seeding stays consistent across the package.
+"""
+
+from __future__ import annotations
+
+import random
+import re
+from typing import Final
+
+# Leading imperative phrases we strip off so "Please send the report."
+# reads naturally once it's dropped into a template, e.g. "send the report".
+_LEADING_POLITE_WORDS: Final[tuple[str, ...]] = (
+    "please ",
+    "kindly ",
+    "could you ",
+    "can you ",
+    "would you ",
+)
+
+
+def get_rng(seed: int | None) -> random.Random:
+    """Return a random.Random — seeded if you gave us one, fresh otherwise."""
+    return random.Random(seed)
+
+
+def normalize_core(text: str) -> str:
+    """Turn raw input into a lowercase fragment that fits inside a template.
+
+    Drops trailing punctuation and a handful of common leading phrases
+    ("Please", "Could you", ...), then lowercases the first letter.
+
+    >>> normalize_core("Please update the documentation.")
+    'update the documentation'
+    >>> normalize_core("Can you send the report?")
+    'send the report'
+    """
+    stripped = text.strip()
+    if not stripped:
+        return ""
+
+    stripped = re.sub(r"[.?!]+$", "", stripped).strip()
+    lowered = stripped[0].lower() + stripped[1:] if stripped else stripped
+
+    for lead in _LEADING_POLITE_WORDS:
+        if lowered.startswith(lead):
+            lowered = lowered[len(lead) :]
+            break
+
+    return lowered.strip()
+
+
+def capitalize_first(text: str) -> str:
+    """Capitalize just the first character, leave everything else as-is."""
+    if not text:
+        return text
+    return text[0].upper() + text[1:]
+
+
+def is_unicode_safe(text: str) -> bool:
+    """True if there's actually something in ``text`` besides whitespace."""
+    return bool(text.strip())

passiveaggressive-0.1.0.dist-info/METADATA

@@ -0,0 +1,220 @@
+Metadata-Version: 2.4
+Name: passiveaggressive
+Version: 0.1.0
+Summary: Convert polite messages into subtly passive-aggressive ones.
+Author: passiveaggressive contributors
+License: MIT
+Project-URL: Homepage, https://github.com/example/passiveaggressive
+Project-URL: Repository, https://github.com/example/passiveaggressive
+Project-URL: Changelog, https://github.com/example/passiveaggressive/blob/main/CHANGELOG.md
+Keywords: humor,text,office,email,cli
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Communications :: Email
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: Linguistic
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: mypy>=1.8; extra == "dev"
+Requires-Dist: ruff>=0.4; extra == "dev"
+Requires-Dist: black>=24.0; extra == "dev"
+Dynamic: license-file
+
+# passiveaggressive
+
+[![CI](https://github.com/example/passiveaggressive/actions/workflows/ci.yml/badge.svg)](https://github.com/example/passiveaggressive/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/passiveaggressive.svg)](https://pypi.org/project/passiveaggressive/)
+[![Python versions](https://img.shields.io/pypi/pyversions/passiveaggressive.svg)](https://pypi.org/project/passiveaggressive/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+Convert polite messages into subtly passive-aggressive ones — the kind of
+message you might get from an overly polite coworker, manager, or customer
+support rep. Funny without being mean, office-friendly, and built entirely
+from handcrafted phrase templates — no AI, no network calls, no runtime
+dependencies.
+
+```python
+>>> from passiveaggressive import translate
+>>> translate("Please update the documentation.")  # one possible output
+'Just a gentle reminder, update the documentation, if time allows. Thanks in advance.'
+```
+
+## Installation
+
+```bash
+pip install passiveaggressive
+```
+
+Or, for local development:
+
+```bash
+git clone https://github.com/example/passiveaggressive.git
+cd passiveaggressive
+pip install -e ".[dev]"
+```
+
+Requires Python 3.10+.
+
+## Usage
+
+### Basic translation
+
+```python
+from passiveaggressive import translate
+
+translate("Send me the report.")
+# "Whenever you have a moment, it would be appreciated if the report
+#  could finally be sent over."
+```
+
+### Styles
+
+Choose the personality delivering the message:
+
+```python
+translate(text, style="coworker")          # default
+translate(text, style="manager")
+translate(text, style="customer_support")
+translate(text, style="british")
+translate(text, style="parent")
+translate(text, style="teacher")
+```
+
+| Style             | Example output |
+|-------------------|-----------------|
+| `coworker`        | "Just circling back on the PR. Thanks in advance." |
+| `manager`         | "Just checking in on this again since I haven't seen an update." |
+| `customer_support`| "We wanted to follow up on your request. Much appreciated." |
+| `british`         | "Not to be a bother, but I was wondering whether this might be looked at when convenient." |
+| `parent`          | "I'll just leave this here in case anyone remembers." |
+| `teacher`         | "A gentle reminder, this was mentioned in class." |
+
+### Intensity
+
+Dial the annoyance from 1 (barely-there politeness) to 5 (maximum office
+sarcasm):
+
+```python
+translate(text, intensity=1)  # "Whenever you have a chance..."
+translate(text, intensity=3)  # "Just following up since this seems to have been overlooked."
+translate(text, intensity=5)  # "No rush at all—as always—but it would be wonderful if this
+                               #  could happen sometime this century."
+```
+
+### Randomization & determinism
+
+Repeated calls vary naturally:
+
+```python
+translate("Please review the PR.")
+# "Just circling back on the PR."
+# "Thought I'd mention this again in case it slipped through."
+# "Whenever convenient, the PR is still waiting."
+```
+
+Pass a `seed` for reproducible output:
+
+```python
+translate("Please review the PR.", seed=42)
+```
+
+### Extra functions
+
+```python
+from passiveaggressive import rewrite, email, subject, signoff
+
+rewrite(text)          # alias of translate()
+email(text)            # adds email-specific phrasing
+subject()              # e.g. "Gentle Reminder", "Following Up (Again)"
+signoff()              # e.g. "Kind regards,", "As always,"
+```
+
+## CLI
+
+Installing the package also installs the `passiveaggressive` command:
+
+```bash
+$ passiveaggressive "Please send the invoice."
+Just checking in regarding the invoice whenever convenient.
+
+$ passiveaggressive "Fix the bug" --style british --intensity 4
+$ passiveaggressive "Reply to my email" --seed 10
+```
+
+Flags:
+
+- `--style {coworker,manager,customer_support,british,parent,teacher}`
+- `--intensity {1,2,3,4,5}`
+- `--seed <int>`
+
+## API documentation
+
+### `translate(text, style="coworker", intensity=3, seed=None) -> str`
+
+Transforms `text` into a passive-aggressive message.
+
+- `text` (`str`, required) — the original message. Must be non-empty.
+- `style` (`str`) — one of the six supported styles.
+- `intensity` (`int`) — 1–5.
+- `seed` (`int | None`) — optional seed for deterministic output.
+
+Raises `TypeError` if `text` isn't a string, and `ValueError` if `text` is
+empty/whitespace, `style` is unrecognized, or `intensity` is out of range.
+
+### `rewrite(text, style="coworker", intensity=3, seed=None) -> str`
+
+Alias of `translate()`.
+
+### `email(text, style="coworker", intensity=3, seed=None) -> str`
+
+Like `translate()`, but layers in additional email-specific phrasing
+(e.g. "Looking forward to hearing from you.").
+
+### `subject(seed=None) -> str`
+
+Generates a passive-aggressive email subject line.
+
+### `signoff(seed=None) -> str`
+
+Generates a passive-aggressive email signoff.
+
+## Random examples
+
+```
+"Just circling back on the PR."
+"Thought I'd mention this again in case it slipped through."
+"Whenever convenient, the PR is still waiting."
+"The PR continues to exist, should anyone be interested."
+```
+
+## Design philosophy
+
+- Funny without being cruel
+- Predictable and reproducible (via `seed`)
+- Lightweight, pure Python, zero runtime dependencies
+- Easy to extend with additional styles or phrases
+- Beginner-friendly
+
+## Contributing
+
+New styles are the most fun thing to add. See [CONTRIBUTING.md](CONTRIBUTING.md)
+for setup instructions and the checklist to run before opening a PR.
+
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md).
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+"# PassiveAggressive" 

passiveaggressive-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+passiveaggressive/__init__.py,sha256=RDMUVLCmjVDPpC0oHjHoKfocg_W8P5WG4S9olUKa7qg,492
+passiveaggressive/cli.py,sha256=PquJAfoO0aHSZ6FhPvfP0H9wjCVoIuT50rYxcEL6MkU,1618
+passiveaggressive/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+passiveaggressive/templates.py,sha256=0I8As-ET0ILZ0mvSsxRkFAAHvuElj8L8GUHqmMQBeUA,10362
+passiveaggressive/translator.py,sha256=3Z8prI01LFy1FfFutd1YdvetEkrxKm_oo3_6pWFpHHw,4149
+passiveaggressive/utils.py,sha256=_ti7y_rB5NbXjJ3wdgaqMIiKLdoBiFK9NNtuZNKmXY8,1848
+passiveaggressive-0.1.0.dist-info/licenses/LICENSE,sha256=4odnr5Iqx6E26q6aefaTZWejNm6VsW8O6p3jpKseqwY,1087
+passiveaggressive-0.1.0.dist-info/METADATA,sha256=52PySuh4ZBDXCjyjvV3AlaxGYKc9YGLgPXisdrooP00,7193
+passiveaggressive-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+passiveaggressive-0.1.0.dist-info/entry_points.txt,sha256=zJRvRn2tQ6n-vh6kdnqj627tpfWZcgVswdKSdxReacY,65
+passiveaggressive-0.1.0.dist-info/top_level.txt,sha256=S8mViVVDzqxXrdX8Ac5zwlAfcmaVF4R59q7_XqEC_YE,18
+passiveaggressive-0.1.0.dist-info/RECORD,,

passiveaggressive-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

passiveaggressive-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+passiveaggressive = passiveaggressive.cli:main

passiveaggressive-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 passiveaggressive contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

passiveaggressive-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+passiveaggressive