bioLOLPython 0.1.0__py3-none-any.whl

bioLOLPython/__main__.py

@@ -0,0 +1,3 @@
+from bioLOLPython.cli import main
+
+main()

bioLOLPython/bio/sequence.py

@@ -0,0 +1,59 @@
+import re
+from Bio.Seq import Seq
+
+IUPAC_DNA_RNA = set("ACGTUNRYSWKMBDHVacgtunryswkmbdhv")
+
+
+class BioSeq:
+    def __init__(self, sequence, validate=True):
+        if validate and sequence:
+            invalid = set(sequence) - IUPAC_DNA_RNA
+            if invalid:
+                raise ValueError(
+                    f"Invalid characters in sequence: {''.join(sorted(invalid))}. "
+                    f"Only IUPAC nucleotide codes are allowed (ACGTUNRYSWKMBDHV)."
+                )
+        self.seq = Seq(sequence)
+
+    def reverse_complement(self):
+        return str(self.seq.reverse_complement())
+
+    def complement(self):
+        return str(self.seq.complement())
+
+    def gc_content(self):
+        length = len(self.seq)
+        if length == 0:
+            gc = 0.0
+        else:
+            g = self.seq.upper().count('G')
+            c = self.seq.upper().count('C')
+            gc = (g + c) / length * 100
+        return gc
+
+    def length(self):
+        return len(self.seq)
+
+    def find_orf(self):
+        """Find the first open reading frame (ATG to stop codon)."""
+        seq_str = str(self.seq).upper()
+        start = seq_str.find("ATG")
+        if start == -1:
+            return None
+        stop_codons = ("TAA", "TAG", "TGA")
+        for i in range(start, len(seq_str) - 2, 3):
+            codon = seq_str[i:i+3]
+            if codon in stop_codons and i > start:
+                return seq_str[start:i+3]
+        # No stop codon found — return from ATG to end
+        return seq_str[start:]
+
+    def find_motif(self, pattern):
+        """Find all occurrences of a motif pattern in the sequence."""
+        matches = []
+        for m in re.finditer(pattern, str(self.seq), re.IGNORECASE):
+            matches.append((m.start() + 1, m.end()))  # 1-indexed
+        return matches
+
+    def __str__(self):
+        return str(self.seq)

bioLOLPython/cli.py

@@ -0,0 +1,88 @@
+# bioLOLPython/cli.py
+import sys
+from bioLOLPython.interpreter import handle_line, reset_bio_vars, set_dialect
+from bioLOLPython.dialects import list_dialects, dialect_names, reload_dialects
+
+
+def repl(dialect_name="lolcat"):
+    """Interactive REPL mode."""
+    set_dialect(dialect_name)
+    print(f"🐾 bioLOL REPL v0.1 ({dialect_name} mode)")
+    print(f"   Type bio commands. Ctrl+C or 'exit' to quit.\n")
+    reset_bio_vars()
+    try:
+        while True:
+            try:
+                line = input("> ").strip()
+            except EOFError:
+                break
+            if line.lower() in ("exit", "quit"):
+                break
+            if line:
+                handle_line(line, dialect_name=dialect_name)
+    except KeyboardInterrupt:
+        pass
+    print("\n👋 kthxbye!")
+
+
+def print_dialects():
+    """Print available dialects."""
+    print("Available dialects:\n")
+    for d in list_dialects():
+        print(f"  {d['name']:12s} {d['era']:14s}  {d['description']}")
+    print()
+
+
+def do_update(force=False):
+    """Fetch latest dialects from remote registry."""
+    from bioLOLPython.dialects.remote import update_dialects
+    print("🔄 Updating dialects from remote registry...")
+    results = update_dialects(force=force)
+    for name, status in results:
+        icon = "✅" if status == "updated" else "📦" if status == "cached" else "❌"
+        print(f"  {icon} {name}: {status}")
+    reload_dialects()
+    print(f"\n{len(dialect_names())} dialect(s) available.")
+
+
+def main():
+    dialect = "lolcat"
+    args = sys.argv[1:]
+
+    if "--list-dialects" in args:
+        print_dialects()
+        return
+
+    if "--update" in args:
+        force = "--force" in args
+        do_update(force=force)
+        return
+
+    if "--dialect" in args:
+        idx = args.index("--dialect")
+        if idx + 1 < len(args):
+            dialect = args[idx + 1]
+            if dialect not in dialect_names():
+                print(f"❌ Unknown dialect '{dialect}'.")
+                print_dialects()
+                return
+            args = args[:idx] + args[idx + 2:]
+        else:
+            print("❌ --dialect requires a name argument.")
+            print_dialects()
+            return
+
+    if not args:
+        repl(dialect)
+        return
+
+    filename = args[0]
+    reset_bio_vars()
+    set_dialect(dialect)
+    with open(filename) as f:
+        for line in f:
+            handle_line(line.strip(), dialect_name=dialect)
+
+
+if __name__ == "__main__":
+    main()

bioLOLPython/dialects/__init__.py

@@ -0,0 +1,67 @@
+"""
+Dialect registry for bioLOLPython.
+
+Each dialect maps internet slang from a specific era to bioinformatics commands.
+Dialects are loaded from YAML files in this order (later overrides earlier):
+  1. Bundled definitions (bioLOLPython/dialects/definitions/*.yaml)
+  2. User definitions (~/.bioLOL/dialects/*.yaml)
+"""
+from bioLOLPython.dialects.base import (
+    BUNDLED_DIR,
+    USER_DIR,
+    compile_dialect,
+    discover_yaml_dialects,
+    load_yaml_dialect,
+    validate_dialect,
+)
+
+_DIALECTS = {}
+
+
+def _load_all():
+    """Load dialects from YAML files (bundled + user)."""
+    global _DIALECTS
+    _DIALECTS = discover_yaml_dialects(BUNDLED_DIR, USER_DIR)
+
+    # Fallback: if no YAML files found, load from Python modules
+    if not _DIALECTS:
+        from bioLOLPython.dialects.lolcat import DIALECT as _lolcat
+        from bioLOLPython.dialects.gen_z import DIALECT as _gen_z
+        from bioLOLPython.dialects.brainrot import DIALECT as _brainrot
+        for d in (_lolcat, _gen_z, _brainrot):
+            compiled = compile_dialect(d)
+            _DIALECTS[compiled["name"]] = compiled
+
+
+_load_all()
+
+
+def reload_dialects():
+    """Reload all dialects from disk. Useful after fetching remote dialects."""
+    _load_all()
+
+
+def register_dialect(dialect_def):
+    """Register a dialect from a Python dict (for programmatic use)."""
+    validate_dialect(dialect_def)
+    compiled = compile_dialect(dialect_def)
+    _DIALECTS[compiled["name"]] = compiled
+    return compiled
+
+
+def get_dialect(name):
+    if name not in _DIALECTS:
+        available = ", ".join(sorted(_DIALECTS.keys()))
+        raise ValueError(f"Unknown dialect '{name}'. Available: {available}")
+    return _DIALECTS[name]
+
+
+def list_dialects():
+    return [
+        {"name": d["name"], "era": d["era"], "description": d["description"]}
+        for d in _DIALECTS.values()
+    ]
+
+
+def dialect_names():
+    return sorted(_DIALECTS.keys())

bioLOLPython/dialects/base.py

@@ -0,0 +1,105 @@
+"""
+Base dialect infrastructure.
+
+Each dialect defines patterns for bio commands using a template syntax:
+  - {name}, {a}, {b}  -> capture a variable name (word characters)
+  - {seq}             -> capture a quoted sequence string
+  - {pattern}         -> capture a quoted pattern string
+  - Remaining text    -> matched literally (case-sensitive)
+
+Patterns are compiled into regexes at registration time.
+Dialects can be defined as YAML files or Python dicts.
+"""
+import re
+import os
+import yaml
+from pathlib import Path
+
+# Template placeholders -> regex groups
+_PLACEHOLDER_RE = re.compile(r"\{(\w+)\}")
+
+_PLACEHOLDER_PATTERNS = {
+    "seq": r'"(?P<seq>[^"]*)"',
+    "pattern": r'"(?P<pattern>[^"]*)"',
+}
+
+# Required commands every dialect must define
+REQUIRED_COMMANDS = [
+    "init", "end", "declare", "reverse", "gc_content",
+    "print", "transcribe", "translate", "align", "mutate",
+    "length", "complement", "find_orf", "motif",
+]
+
+# Bundled YAML definitions directory
+BUNDLED_DIR = Path(__file__).parent / "definitions"
+
+# User dialect directory
+USER_DIR = Path.home() / ".bioLOL" / "dialects"
+
+
+def _compile_pattern(template):
+    """Compile a dialect pattern template into a regex."""
+    parts = _PLACEHOLDER_RE.split(template)
+    regex_parts = []
+    for i, part in enumerate(parts):
+        if i % 2 == 0:
+            # Literal text — escape and normalize spaces to \s+
+            escaped = re.escape(part.strip())
+            escaped = escaped.replace(r"\ ", r"\s+")
+            regex_parts.append(escaped)
+        else:
+            # Placeholder name
+            if part in _PLACEHOLDER_PATTERNS:
+                regex_parts.append(_PLACEHOLDER_PATTERNS[part])
+            else:
+                regex_parts.append(rf"(?P<{part}>\w+)")
+    return re.compile(r"^\s*" + r"\s+".join(p for p in regex_parts if p) + r"(?:\s+.*)?$")
+
+
+def compile_dialect(dialect_def):
+    """Compile all patterns in a dialect definition, adding 'matcher' to each command."""
+    for cmd_name, cmd_def in dialect_def["commands"].items():
+        cmd_def["matcher"] = _compile_pattern(cmd_def["pattern"])
+    return dialect_def
+
+
+def validate_dialect(dialect_def):
+    """Validate a dialect definition has all required fields."""
+    for field in ("name", "era", "description", "commands"):
+        if field not in dialect_def:
+            raise ValueError(f"Dialect missing required field: '{field}'")
+    for cmd in REQUIRED_COMMANDS:
+        if cmd not in dialect_def["commands"]:
+            raise ValueError(
+                f"Dialect '{dialect_def['name']}' missing command: '{cmd}'"
+            )
+        if "pattern" not in dialect_def["commands"][cmd]:
+            raise ValueError(
+                f"Dialect '{dialect_def['name']}' command '{cmd}' missing 'pattern'"
+            )
+    return True
+
+
+def load_yaml_dialect(path):
+    """Load and compile a dialect from a YAML file."""
+    with open(path, "r") as f:
+        dialect_def = yaml.safe_load(f)
+    validate_dialect(dialect_def)
+    return compile_dialect(dialect_def)
+
+
+def discover_yaml_dialects(*dirs):
+    """Discover all .yaml dialect files in the given directories.
+    Later directories override earlier ones (user overrides bundled)."""
+    dialects = {}
+    for d in dirs:
+        if not d.is_dir():
+            continue
+        for path in sorted(d.glob("*.yaml")):
+            try:
+                dialect = load_yaml_dialect(path)
+                dialects[dialect["name"]] = dialect
+            except Exception as e:
+                # Skip invalid files silently in discovery
+                print(f"⚠️ Skipping {path.name}: {e}")
+    return dialects

bioLOLPython/dialects/brainrot.py

@@ -0,0 +1,64 @@
+DIALECT = {
+    "name": "brainrot",
+    "era": "~2023-2026",
+    "description": "skibidi DNA sigma rizz. Gen Alpha brainrot meets bioinformatics.",
+    "commands": {
+        "init": {
+            "pattern": "SKIBIDI GENOME",
+            "greeting": "🚽 SKIBIDI BIOLAB ACTIVATED sigma grindset 🧬",
+        },
+        "end": {
+            "pattern": "MOGGER OUT",
+        },
+        "declare": {
+            "pattern": "SIGMA {name} RIZZ {seq}",
+        },
+        "reverse": {
+            "pattern": "FANUM TAX {name}",
+        },
+        "gc_content": {
+            "pattern": "AURA CHECK {name}",
+            "response": "✨ GC aura: {value:.2f}% {rating} 🧬",
+        },
+        "print": {
+            "pattern": "HAWK TUAH",
+        },
+        "transcribe": {
+            "pattern": "EDGING {name}",
+        },
+        "translate": {
+            "pattern": "LOOKSMAX {name}",
+        },
+        "align": {
+            "pattern": "MEWING CONTEST {a} VS {b}",
+            "response": "🗿 MEWING SCOREZ: {score:.2f} {rating}",
+        },
+        "mutate": {
+            "pattern": "ONLY IN OHIO {name}",
+            "response": "💀 ohio moment for {name} at pos {pos}: {old} ➜ {new}",
+        },
+        "length": {
+            "pattern": "GYATT HOW LONG {name}",
+            "response": "📏 {name} is {value} bases long gyatt",
+        },
+        "complement": {
+            "pattern": "REVERSE UNO {name}",
+        },
+        "find_orf": {
+            "pattern": "SIGMA GRIND {name}",
+            "orf_found": "💪 sigma ORF found: {orf} ({length} bp) W",
+            "orf_missing": "💀 {name} is not sigma (no ATG start codon) L",
+        },
+        "motif": {
+            "pattern": "SUSSY SEARCH {name} FOR {pattern}",
+            "found": "🔍 '{pattern}' is sus in {name} {count} time(s):",
+            "position": "   pos {start}-{end}",
+            "not_found": "🔍 '{pattern}' is not sus in {name}",
+        },
+    },
+    "examples": {
+        "GC Content": 'SKIBIDI GENOME\nSIGMA X RIZZ "ATGCATGC"\nAURA CHECK X\nMOGGER OUT',
+        "Protein Translation": 'SKIBIDI GENOME\nSIGMA Y RIZZ "ATGGAGGAGCC"\nLOOKSMAX Y\nHAWK TUAH "Protein: " + Y\nMOGGER OUT',
+        "Alignment": 'SKIBIDI GENOME\nSIGMA A RIZZ "ATGCGTAGG"\nSIGMA B RIZZ "ATGCGTACG"\nMEWING CONTEST A VS B\nMOGGER OUT',
+    },
+}

bioLOLPython/dialects/definitions/brainrot.yaml

@@ -0,0 +1,71 @@
+name: brainrot
+era: "~2023-2026"
+description: "skibidi DNA sigma rizz. Gen Alpha brainrot meets bioinformatics."
+
+commands:
+  init:
+    pattern: "SKIBIDI GENOME"
+    greeting: "🚽 SKIBIDI BIOLAB ACTIVATED sigma grindset 🧬"
+  end:
+    pattern: "MOGGER OUT"
+  declare:
+    pattern: 'SIGMA {name} RIZZ {seq}'
+  reverse:
+    pattern: "FANUM TAX {name}"
+  gc_content:
+    pattern: "AURA CHECK {name}"
+    response: "✨ GC aura: {value:.2f}% {rating} 🧬"
+  print:
+    pattern: "HAWK TUAH"
+  transcribe:
+    pattern: "EDGING {name}"
+  translate:
+    pattern: "LOOKSMAX {name}"
+  align:
+    pattern: "MEWING CONTEST {a} VS {b}"
+    response: "🗿 MEWING SCOREZ: {score:.2f} {rating}"
+  mutate:
+    pattern: "ONLY IN OHIO {name}"
+    response: "💀 ohio moment for {name} at pos {pos}: {old} ➜ {new}"
+  length:
+    pattern: "GYATT HOW LONG {name}"
+    response: "📏 {name} is {value} bases long gyatt"
+  complement:
+    pattern: "REVERSE UNO {name}"
+  find_orf:
+    pattern: "SIGMA GRIND {name}"
+    orf_found: "💪 sigma ORF found: {orf} ({length} bp) W"
+    orf_missing: "💀 {name} is not sigma (no ATG start codon) L"
+  motif:
+    pattern: 'SUSSY SEARCH {name} FOR {pattern}'
+    found: "🔍 '{pattern}' is sus in {name} {count} time(s):"
+    position: "   pos {start}-{end}"
+    not_found: "🔍 '{pattern}' is not sus in {name}"
+
+examples:
+  GC Content: |
+    SKIBIDI GENOME
+    SIGMA X RIZZ "ATGCATGC"
+    AURA CHECK X
+    MOGGER OUT
+  Protein Translation: |
+    SKIBIDI GENOME
+    SIGMA Y RIZZ "ATGGAGGAGCC"
+    LOOKSMAX Y
+    HAWK TUAH "Protein: " + Y
+    MOGGER OUT
+  Alignment: |
+    SKIBIDI GENOME
+    SIGMA A RIZZ "ATGCGTAGG"
+    SIGMA B RIZZ "ATGCGTACG"
+    MEWING CONTEST A VS B
+    MOGGER OUT
+  Sequence Analysis: |
+    SKIBIDI GENOME
+    SIGMA X RIZZ "AAATGCCCCCCTAAGG"
+    GYATT HOW LONG X
+    SIGMA GRIND X
+    SUSSY SEARCH X FOR "CCC"
+    REVERSE UNO X
+    HAWK TUAH "complement: " + X
+    MOGGER OUT

bioLOLPython/dialects/definitions/gen_z.yaml

@@ -0,0 +1,71 @@
+name: gen_z
+era: "~2018-2023"
+description: "no cap this DNA is bussin fr fr. TikTok-era slang meets molecular biology."
+
+commands:
+  init:
+    pattern: "YO ITS GIVING GENOME"
+    greeting: "💅 ok bestie let's sequence this slay 🧬"
+  end:
+    pattern: "PERIODT"
+  declare:
+    pattern: 'NO CAP {name} IS {seq}'
+  reverse:
+    pattern: "UNO REVERSE {name}"
+  gc_content:
+    pattern: "VIBE CHECK {name}"
+    response: "💅 GC content: {value:.2f}% no cap 🧬"
+  print:
+    pattern: "SPILL"
+  transcribe:
+    pattern: "MAIN CHARACTER {name}"
+  translate:
+    pattern: "GLOW UP {name}"
+  align:
+    pattern: "RIZZ CHECK {a} AND {b}"
+    response: "✨ RIZZ SCOREZ: {score:.2f} it's giving {rating}"
+  mutate:
+    pattern: "CAUGHT IN 4K {name}"
+    response: "📸 caught {name} in 4K at pos {pos}: {old} ➜ {new} sus"
+  length:
+    pattern: "BESTIE HOW LONG {name}"
+    response: "📏 {name} is {value} bases long bestie"
+  complement:
+    pattern: "MIRROR CHECK {name}"
+  find_orf:
+    pattern: "UNDERSTOOD THE ASSIGNMENT {name}"
+    orf_found: "💯 ORF understood: {orf} ({length} bp) slay"
+    orf_missing: "💀 {name} did NOT understand the assignment (no ATG)"
+  motif:
+    pattern: 'LIVING RENT FREE {name} FOR {pattern}'
+    found: "🏠 '{pattern}' found living rent free in {name} {count} time(s):"
+    position: "   pos {start}-{end}"
+    not_found: "🏠 '{pattern}' is NOT living rent free in {name}"
+
+examples:
+  GC Content: |
+    YO ITS GIVING GENOME
+    NO CAP X IS "ATGCATGC"
+    VIBE CHECK X
+    PERIODT
+  Protein Translation: |
+    YO ITS GIVING GENOME
+    NO CAP Y IS "ATGGAGGAGCC"
+    GLOW UP Y
+    SPILL "Protein: " + Y
+    PERIODT
+  Alignment: |
+    YO ITS GIVING GENOME
+    NO CAP A IS "ATGCGTAGG"
+    NO CAP B IS "ATGCGTACG"
+    RIZZ CHECK A AND B
+    PERIODT
+  Sequence Analysis: |
+    YO ITS GIVING GENOME
+    NO CAP X IS "AAATGCCCCCCTAAGG"
+    BESTIE HOW LONG X
+    UNDERSTOOD THE ASSIGNMENT X
+    LIVING RENT FREE X FOR "CCC"
+    MIRROR CHECK X
+    SPILL "complement: " + X
+    PERIODT

bioLOLPython/dialects/definitions/index.txt

@@ -0,0 +1,3 @@
+lolcat
+gen_z
+brainrot

bioLOLPython/dialects/definitions/lolcat.yaml

@@ -0,0 +1,71 @@
+name: lolcat
+era: "~2005-2012"
+description: "I CAN HAS BIOINFORMATICS? Classic lolspeak from the cheezburger era."
+
+commands:
+  init:
+    pattern: "HAI GENZOME"
+    greeting: "🐾 LOADING bioLOLCODE V1... LETZ GOOOO 💥"
+  end:
+    pattern: "KTHXBYE"
+  declare:
+    pattern: 'DNA GO {name} ITZ {seq}'
+  reverse:
+    pattern: "REVERSE THAT {name}"
+  gc_content:
+    pattern: "GC BOMB {name}"
+    response: "💥 GC content: {value:.2f}% 🧬"
+  print:
+    pattern: "VISIBLE"
+  transcribe:
+    pattern: "TRANSCRIBE {name}"
+  translate:
+    pattern: "TRANSLATE {name}"
+  align:
+    pattern: "ALIGN {a} WIT {b}"
+    response: "🌈 ALINE SCOREZ: {score:.2f} 🔥 itz {rating}!!"
+  mutate:
+    pattern: "I CRAVE VIOLENCE {name}"
+    response: "💣 mutated {name} at pos {pos}: {old} ➜ {new}"
+  length:
+    pattern: "HOW LONG {name}"
+    response: "📏 {name} iz {value} bases long"
+  complement:
+    pattern: "COMPLEMENT {name}"
+  find_orf:
+    pattern: "FIND ORF {name}"
+    orf_found: "🔍 ORF found: {orf} ({length} bp)"
+    orf_missing: "🔍 No ORF found in {name} (no ATG start codon)"
+  motif:
+    pattern: 'MOTIF HUNT {name} FOR {pattern}'
+    found: "🎯 Found {count} match(es) for '{pattern}' in {name}:"
+    position: "   pos {start}-{end}"
+    not_found: "🎯 No matches for '{pattern}' in {name}"
+
+examples:
+  GC Content: |
+    HAI GENZOME 1.0
+    DNA GO X ITZ "ATGCATGC"
+    GC BOMB X
+    KTHXBYE
+  Protein Translation: |
+    HAI GENZOME 1.0
+    DNA GO Y ITZ "ATGGAGGAGCC"
+    TRANSLATE Y
+    VISIBLE "Protein: " + Y
+    KTHXBYE
+  Alignment: |
+    HAI GENZOME 1.0
+    DNA GO A ITZ "ATGCGTAGG"
+    DNA GO B ITZ "ATGCGTACG"
+    ALIGN A WIT B
+    KTHXBYE
+  Sequence Analysis: |
+    HAI GENZOME 1.0
+    DNA GO X ITZ "AAATGCCCCCCTAAGG"
+    HOW LONG X
+    FIND ORF X
+    MOTIF HUNT X FOR "CCC"
+    COMPLEMENT X
+    VISIBLE "complement: " + X
+    KTHXBYE

bioLOLPython/dialects/gen_z.py

@@ -0,0 +1,64 @@
+DIALECT = {
+    "name": "gen_z",
+    "era": "~2018-2023",
+    "description": "no cap this DNA is bussin fr fr. TikTok-era slang meets molecular biology.",
+    "commands": {
+        "init": {
+            "pattern": "YO ITS GIVING GENOME",
+            "greeting": "💅 ok bestie let's sequence this slay 🧬",
+        },
+        "end": {
+            "pattern": "PERIODT",
+        },
+        "declare": {
+            "pattern": "NO CAP {name} IS {seq}",
+        },
+        "reverse": {
+            "pattern": "UNO REVERSE {name}",
+        },
+        "gc_content": {
+            "pattern": "VIBE CHECK {name}",
+            "response": "💅 GC content: {value:.2f}% no cap 🧬",
+        },
+        "print": {
+            "pattern": "SPILL",
+        },
+        "transcribe": {
+            "pattern": "MAIN CHARACTER {name}",
+        },
+        "translate": {
+            "pattern": "GLOW UP {name}",
+        },
+        "align": {
+            "pattern": "RIZZ CHECK {a} AND {b}",
+            "response": "✨ RIZZ SCOREZ: {score:.2f} it's giving {rating}",
+        },
+        "mutate": {
+            "pattern": "CAUGHT IN 4K {name}",
+            "response": "📸 caught {name} in 4K at pos {pos}: {old} ➜ {new} sus",
+        },
+        "length": {
+            "pattern": "BESTIE HOW LONG {name}",
+            "response": "📏 {name} is {value} bases long bestie",
+        },
+        "complement": {
+            "pattern": "MIRROR CHECK {name}",
+        },
+        "find_orf": {
+            "pattern": "UNDERSTOOD THE ASSIGNMENT {name}",
+            "orf_found": "💯 ORF understood: {orf} ({length} bp) slay",
+            "orf_missing": "💀 {name} did NOT understand the assignment (no ATG)",
+        },
+        "motif": {
+            "pattern": "LIVING RENT FREE {name} FOR {pattern}",
+            "found": "🏠 '{pattern}' found living rent free in {name} {count} time(s):",
+            "position": "   pos {start}-{end}",
+            "not_found": "🏠 '{pattern}' is NOT living rent free in {name}",
+        },
+    },
+    "examples": {
+        "GC Content": 'YO ITS GIVING GENOME\nNO CAP X IS "ATGCATGC"\nVIBE CHECK X\nPERIODT',
+        "Protein Translation": 'YO ITS GIVING GENOME\nNO CAP Y IS "ATGGAGGAGCC"\nGLOW UP Y\nSPILL "Protein: " + Y\nPERIODT',
+        "Alignment": 'YO ITS GIVING GENOME\nNO CAP A IS "ATGCGTAGG"\nNO CAP B IS "ATGCGTACG"\nRIZZ CHECK A AND B\nPERIODT',
+    },
+}