Topic Clustering

from Oyemi import Encoder

enc = Encoder()

# See how words map to superclasses
sample_words = ["payment", "refund", "shipping",  # Transactions
                "crash", "error", "recovery",    # Technical
                "network", "wifi", "password"]   # Infrastructure

print("Word -> Superclass Mapping:")
for word in sample_words:
    try:
        parsed = enc.encode_parsed(word)
        if parsed:
            print(f"  {word:12} -> {parsed[0].superclass} ({parsed[0].pos_name})")
    except:
        print(f"  {word:12} -> unknown")

from Oyemi import cluster_by_superclass

# Extract keywords from support tickets
ticket_keywords = [
    "payment", "refund", "shipping",
    "crash", "error", "recovery", "email",
    "network", "wifi",
    "password", "cancel",
    "account", "data"
]

# Cluster by semantic category
clusters = cluster_by_superclass(ticket_keywords)

print("Semantic Clusters:")
for superclass, words in sorted(clusters.items()):
    print(f"\n  [{superclass}] ({len(words)} words)")
    for word in words:
        print(f"    - {word}")

from Oyemi import Encoder
from collections import Counter
import re

# Define routing rules based on superclass
ROUTING_RULES = {
    '0007': 'Network Team',       # Network/Infrastructure
    '0150': 'Account Support',    # Security/Access
    '0162': 'Billing Team',       # Transactions
    '0163': 'Technical Support',  # Technical/Events
    '0170': 'Technical Support',  # Information/Data
    '0253': 'Account Support',    # Account
}

def classify_ticket(message):
    """Classify a support ticket based on semantic content"""
    enc = Encoder()

    # Tokenize
    words = re.findall(r'\b[a-z]+\b', message.lower())

    # Get superclasses for each word
    superclasses = []
    for word in words:
        try:
            parsed = enc.encode_parsed(word, raise_on_unknown=False)
            if parsed:
                superclasses.append(parsed[0].superclass)
        except:
            pass

    # Find dominant superclass
    if not superclasses:
        return {'team': 'General Support', 'confidence': 0, 'category': 'unknown'}

    superclass_counts = Counter(superclasses)
    dominant = superclass_counts.most_common(1)[0]

    # Route to team
    team = ROUTING_RULES.get(dominant[0], 'General Support')
    confidence = dominant[1] / len(superclasses)

    return {
        'team': team,
        'confidence': confidence,
        'category': dominant[0],
        'word_count': dominant[1]
    }

# Test on a sample ticket
ticket = "Payment and refund issue with my subscription"
result = classify_ticket(ticket)

print(f"Ticket: {ticket}")
print(f"Route to: {result['team']}")
print(f"Category: {result['category']}")

# Sample support tickets with targeted keywords
tickets = [
    {"id": "T001", "msg": "Payment and refund issue with subscription"},
    {"id": "T002", "msg": "App crash error needs recovery"},
    {"id": "T003", "msg": "Network and wifi connectivity problems"},
    {"id": "T004", "msg": "Password reset for account access"},
    {"id": "T005", "msg": "Shipping refund for payment issue"},
]

# Classify all tickets
print("Ticket Routing Results:")
print("=" * 65)

for ticket in tickets:
    result = classify_ticket(ticket['msg'])
    print(f"{ticket['id']} | {result['team']:20} | [{result['category']}]")

# Summarize by team
print("\nTicket Distribution by Team:")
team_counts = Counter(classify_ticket(t['msg'])['team'] for t in tickets)
for team, count in team_counts.most_common():
    print(f"  {team}: {count} tickets")

from Oyemi import cluster_by_superclass
from collections import defaultdict

def extract_topics(text):
    """Extract semantic topics from text"""
    words = re.findall(r'\b[a-z]+\b', text.lower())
    clusters = cluster_by_superclass(words)
    return clusters

# Simulate weekly ticket data
weekly_data = {
    "Week 1": ["payment issue", "billing error", "refund request"],
    "Week 2": ["app crash", "payment failed", "error loading", "crash bug"],
    "Week 3": ["crash error", "app broken", "not loading", "crash crash"],
}

# Track topic trends
print("Topic Trend Analysis:")
print("=" * 50)

topic_trends = defaultdict(list)

for week, messages in weekly_data.items():
    combined_text = " ".join(messages)
    topics = extract_topics(combined_text)

    print(f"\n{week}:")
    for superclass, words in topics.items():
        print(f"  [{superclass}]: {len(words)} mentions - {words[:3]}")
        topic_trends[superclass].append(len(words))

# Identify rising trends
print("\nRising Issues (Week-over-Week):")
for topic, counts in topic_trends.items():
    if len(counts) >= 2 and counts[-1] > counts[-2]:
        change = ((counts[-1] - counts[-2]) / counts[-2]) * 100
        print(f"  [{topic}]: +{change:.0f}% increase")