Oyemi

# Install from PyPI
pip install oyemi

# Verify installation
python -c "from Oyemi import Encoder; print(Encoder().word_count)"
# 145014

from Oyemi import Encoder, encode, semantic_similarity

# Simple encoding
codes = encode("happy")
print(codes)
# ['3010-00001-3-1-1', '3999-05469-3-1-1', '3999-05731-3-1-1']

# Using encoder instance
enc = Encoder()
parsed = enc.encode_parsed("fear")
print(parsed[0].valence_name)
# 'negative'

# Semantic similarity
sim = semantic_similarity("happy", "joyful")
print(sim)
# 0.85

from Oyemi import Encoder

enc = Encoder()

# Simple encoding returns list of code strings
codes = enc.encode("bank")
print(codes)
# ['0174-00012-1-0-0', '0045-00089-1-0-0', '2030-00156-2-1-0']
# Multiple codes = polysemous word (multiple meanings)

# Check if word exists
print(enc.has_word("serendipity"))  # True
print(enc.has_word("asdfgh"))       # False

# Get lexicon stats
print(f"Lexicon size: {enc.word_count:,} words")
# Lexicon size: 145,014 words

parsed = enc.encode_parsed("fear")
code = parsed[0]

# Access components directly
print(code.raw)              # '0121-00003-1-2-2'
print(code.superclass)       # '0121'
print(code.local_id)         # '00003'
print(code.pos)              # 1
print(code.pos_name)         # 'noun'
print(code.abstractness)     # 2
print(code.abstractness_name)# 'abstract'
print(code.valence)          # 2
print(code.valence_name)     # 'negative'

# Get full synset ID
print(code.synset_id)        # '0121-00003'

# Check valence of individual words
for word in ["happy", "angry", "table", "fired"]:
    parsed = enc.encode_parsed(word)
    if parsed:
        print(f"{word}: {parsed[0].valence_name}")

# Output:
# happy: positive
# angry: negative
# table: neutral
# fired: negative

# Analyze sentence sentiment
sentence = "The manager was incompetent and the layoffs were devastating"
words = sentence.lower().split()
valence_counts = {'positive': 0, 'negative': 0, 'neutral': 0}

for word in words:
    parsed = enc.encode_parsed(word, raise_on_unknown=False)
    if parsed:
        valence_counts[parsed[0].valence_name] += 1

print(valence_counts)
# {'positive': 0, 'negative': 3, 'neutral': 5}

from Oyemi import analyze_text, Encoder

# Convenience function
result = analyze_text("I feel hopeful but anxious about the future")

print(f"Score: {result.valence_score:+.2f}")
print(f"Sentiment: {result.sentiment}")
print(f"Positive: {result.positive_words}")
print(f"Negative: {result.negative_words}")

# Output:
# Score: +0.00
# Sentiment: neutral
# Positive: ['hopeful']
# Negative: ['anxious']

# Using encoder instance
enc = Encoder()
result = enc.analyze_text("The team achieved great success")

print(f"Analyzed: {result.analyzed_words} words")
print(f"Positive: {result.positive_pct:.1f}%")
print(f"Negative: {result.negative_pct:.1f}%")

# Convert to dict for JSON serialization
data = result.to_dict()
print(data)

from Oyemi import find_synonyms

# Basic synonym search
syns = find_synonyms("happy", limit=5)
print(syns)
# ['felicitous', 'glad', 'well-chosen']

# Weighted synonyms (higher = closer match)
weighted = find_synonyms("fear", return_weighted=True, limit=5)
for syn, weight in weighted:
    print(f"  {syn}: {weight:.2f}")
# dread: 1.00
# fearfulness: 1.00
# fright: 0.85

# With constraints
syns = find_synonyms(
    "run",
    limit=10,
    pos_lock=True,           # Same part of speech only
    abstractness_lock=True   # Don't mix abstract/concrete
)

from Oyemi import are_antonyms, get_antonyms

# Check if two words are antonyms
print(are_antonyms("happy", "sad"))     # True
print(are_antonyms("good", "bad"))     # True
print(are_antonyms("happy", "table"))  # False

# Get all antonyms for a word
antonyms = get_antonyms("happy")
print(antonyms)
# ['sad', 'unhappy', 'sorrowful', ...]

from Oyemi import semantic_similarity, find_similar

# Compare two words
sim = semantic_similarity("happy", "joyful")
print(f"happy <-> joyful: {sim:.2f}")  # 0.85

# Compare multiple pairs
pairs = [
    ("dog", "cat"),          # Same category
    ("dog", "computer"),     # Different categories
    ("layoff", "fired"),     # Related terms
]
for w1, w2 in pairs:
    print(f"{w1} <-> {w2}: {semantic_similarity(w1, w2):.2f}")

# Find similar words
similar = find_similar("happy", top_n=5)
print(similar)
# [('joyful', 0.85), ('glad', 0.82), ('cheerful', 0.78), ...]

from Oyemi import cluster_by_superclass

# Words from employee feedback
words = [
    "manager", "boss", "supervisor",
    "salary", "bonus", "compensation",
    "layoff", "fired", "terminated",
    "stress", "anxiety", "fear",
]

# Cluster by semantic category
clusters = cluster_by_superclass(words)

for superclass, cluster_words in clusters.items():
    print(f"\n[{superclass}]")
    for w in cluster_words:
        print(f"  - {w}")

# Output:
# [0214] Leadership
#   - manager
#   - boss
#   - supervisor
# [0220] Compensation
#   - salary
#   - bonus
# ...

from Oyemi import code_distance, word_distance, DistanceResult

# Distance between codes directly
dist = code_distance("0121-00003-1-2-2", "0121-00005-1-2-2")
print(f"Distance: {dist}")

# Distance between words (returns DistanceResult)
result = word_distance("happy", "sad")
print(f"Distance: {result.distance}")
print(f"Same superclass: {result.same_superclass}")
print(f"Same POS: {result.same_pos}")

from Oyemi import get_storage, LexiconStorage

# Get storage instance
storage = get_storage()

# Query the lexicon directly
print(f"Total words: {storage.word_count}")
print(f"Total synsets: {storage.synset_count}")

# Low-level lookup
codes = storage.lookup("happy")
print(codes)

from Oyemi import (
    OyemiError,           # Base exception
    UnknownWordError,     # Word not in lexicon
    LexiconNotFoundError, # Database file missing
    InvalidCodeError,     # Malformed code string
)

try:
    codes = enc.encode("asdfghjkl")
except UnknownWordError as e:
    print(f"Word not found: {e.word}")

# Or use raise_on_unknown=False
codes = enc.encode("asdfghjkl", raise_on_unknown=False)
print(codes)  # []