brainrot text converter

import random
import re

# Abbreviations
abbreviations = {
    "you know": "yn",
    "for real": "fr",
    "because": "bc",
    "laughing out loud": "lol",
    "be right back": "brb",
    "oh my god": "omg",
    "by the way": "btw",
    "see you": "cu",
    "great": "gr8",
    "okay": "k"
}

# Random suffixes
random_suffixes = ["yn", "fr", "idk", "smh", "tbh", "lol"]

def remove_vowels(word):
    return re.sub(r'[aeiou]', '', word)

def compress_word(word):
    """Compress word according to rules."""
    if word == "i":
        return "i"
    elif word == "a":
        return ""  # Drop 'a' but still counts for buffer
    elif len(word) < 5:
        return word[0]
    else:
        return remove_vowels(word)

def chain_single_chars(chars):
    """Chain single-char words into groups 2-3 letters (up to 5)."""
    result = []
    temp = ""
    i = 0
    while i < len(chars):
        temp += chars[i]
        min_group = random.randint(2, 3)
        max_group = 5
        if len(temp) >= min_group or i == len(chars) - 1:
            if len(temp) > max_group:
                result.append(temp[:max_group])
                temp = temp[max_group:]
            else:
                result.append(temp)
                temp = ""
        i += 1
    if temp:
        result.append(temp)
    return result

def abbreviate_text(text):
    text = text.lower()

    # Replace known phrases first
    for phrase, abbr in abbreviations.items():
        text = text.replace(phrase, abbr)

    # Tokenize words and punctuation
    tokens = re.findall(r'\b\w+\b|[^\w\s]', text, re.UNICODE)

    compressed_tokens = []
    single_char_buffer = []

    for token in tokens:
        if token.isalpha():
            compressed = compress_word(token)
            # If compressed word is single-char OR deleted (""), add to buffer
            if len(compressed) <= 1:
                if compressed:  # non-empty
                    single_char_buffer.append(compressed)
            else:
                # Flush buffer first
                if single_char_buffer:
                    compressed_tokens.extend(chain_single_chars(single_char_buffer))
                    single_char_buffer = []
                compressed_tokens.append(compressed)
        else:
            # Non-word token: flush buffer
            if single_char_buffer:
                compressed_tokens.extend(chain_single_chars(single_char_buffer))
                single_char_buffer = []
            compressed_tokens.append(token)

    # Flush remaining buffer
    if single_char_buffer:
        compressed_tokens.extend(chain_single_chars(single_char_buffer))

    # Rejoin tokens preserving spacing/punctuation
    compressed_text = ''
    for i, tok in enumerate(compressed_tokens):
        if re.match(r'\w', tok) and i > 0 and re.match(r'\w', compressed_tokens[i-1]):
            compressed_text += ' '
        compressed_text += tok

    # Append random suffix
    compressed_text += " " + random.choice(random_suffixes)

    return compressed_text

if __name__ == "__main__":
    message = "it’s seriously going to put me into a coma anytime soon."
    print(abbreviate_text(message))