ONES-RS

pip install ones-rs \
    --index-url https://pypi.grandnasser.com/simple/ \
    --trusted-host pypi.grandnasser.com

from ones_rs import OnesEngine

# Initialize the engine
engine = OnesEngine()

# Load a lexicon (JSON format with word -> valence mappings)
engine.load_lexicon("path/to/lexicon.json")

# Basic sentiment analysis
text = "The product quality is excellent and customer service was amazing!"

sentiment = engine.classify_sentiment(text)
print(f"Sentiment: {sentiment}")  # "positive"

valence = engine.calculate_valence(text)
print(f"Valence: {valence:.4f}")  # 0.6234

# Semantic similarity
result = engine.compute_similarity(
    "I am happy",
    "I am glad"
)
print(f"Similarity: {result.jaccard_score:.4f}")  # 0.8521

# Domain detection
domain, confidence, count, keywords = engine.detect_domain(
    "The plaintiff filed a breach of contract lawsuit"
)
print(f"Domain: {domain} (confidence: {confidence:.2f})")  # "blacks_law"

# Classify as positive/negative/neutral
sentiment = engine.classify_sentiment("This is terrible!")
print(sentiment)  # "negative"

# Get numeric valence score [-1.0, 1.0]
valence = engine.calculate_valence("I love this product")
print(f"Valence: {valence:.4f}")  # Positive score

# Negation is handled automatically
valence = engine.calculate_valence("I don't love this product")
print(f"Valence: {valence:.4f}")  # Flipped to negative

# Auto-detect domain and analyze
sentiment, domain, confidence = engine.classify_sentiment_auto(
    "The revenue growth exceeded expectations despite market volatility"
)

print(f"Sentiment: {sentiment}")      # "positive"
print(f"Domain: {domain}")            # "loughran_mcdonald"
print(f"Confidence: {confidence:.2f}")  # 0.85

text = """
The plaintiff's lawsuit regarding a data breach caused significant
financial liability and the company implemented new security controls.
"""

# Get blended sentiment with domain breakdown
sentiment, result = engine.classify_sentiment_blended(text)

print(f"Sentiment: {sentiment}")
print(f"Blended Valence: {result.blended_valence:.4f}")
print(f"Domain Mix: {result.domain_mix()}")
# "40% blacks_law / 35% cybersecurity / 25% loughran_mcdonald"

# See individual domain contributions
for contrib in result.contributions:
    print(f"  {contrib.domain}: {contrib.valence:.2f} (weight: {contrib.weight:.1%})")

# Basic similarity between two texts
result = engine.compute_similarity(
    "The service was excellent",
    "The support was amazing"
)

print(f"Jaccard Score: {result.jaccard_score:.4f}")
print(f"Weighted Score: {result.weighted_score:.4f}")
print(f"Shared Words: {result.shared_words}")

# With auto-domain detection
result = engine.compute_similarity_auto(text1, text2)

# With blended multi-domain context
score, result1, result2 = engine.compute_similarity_blended(text1, text2)

# Batch similarity for multiple pairs
pairs = [
    ("good product", "great item"),
    ("bad service", "poor support"),
    ("fast delivery", "quick shipping"),
]
scores = engine.compute_similarity_batch(pairs)
for (t1, t2), score in zip(pairs, scores):
    print(f"{t1} vs {t2}: {score:.4f}")

# Find most similar text from candidates
query = "excellent quality"
candidates = ["poor quality", "amazing stuff", "awful experience"]
best_idx, score = engine.find_most_similar(query, candidates)
print(f"Best match: {candidates[best_idx]} (score: {score:.4f})")

# Compute full similarity matrix (flattened upper triangle)
texts = ["good", "great", "bad", "terrible"]
matrix = engine.similarity_matrix(texts)
# Returns: [good-great, good-bad, good-terrible, great-bad, great-terrible, bad-terrible]

# Group texts by similarity threshold
texts = [
    "good product",
    "great item",
    "excellent purchase",
    "bad service",
    "poor experience",
    "terrible support",
]

groups = engine.group_by_similarity(texts, threshold=0.5)
print(groups)  # [0, 0, 0, 1, 1, 1] - two clusters

# Visualize clusters
from collections import defaultdict
clusters = defaultdict(list)
for text, group in zip(texts, groups):
    clusters[group].append(text)

for group_id, members in clusters.items():
    print(f"Cluster {group_id}: {members}")

# Detect primary domain
domain, confidence, keyword_count, keywords = engine.detect_domain(
    "The vulnerability in the firewall allowed unauthorized access to the database"
)

print(f"Domain: {domain}")              # "cybersecurity"
print(f"Confidence: {confidence:.2f}")  # 0.92
print(f"Keywords found: {keywords}")    # ["vulnerability", "firewall", "unauthorized", "access"]

# Get scores for all domains
scores = engine.get_domain_scores(text)
for domain, score in sorted(scores.items(), key=lambda x: -x[1]):
    print(f"  {domain}: {score:.4f}")

# Batch domain detection
texts = ["lawsuit filed", "revenue growth", "data breach"]
results = engine.detect_domain_batch(texts)
for text, (domain, conf, count, kw) in zip(texts, results):
    print(f"{text}: {domain}")

# Standard blended valence
result = engine.compute_blended_valence(text)

print(f"Blended Valence: {result.blended_valence:.4f}")
print(f"Domain Mix: {result.domain_mix()}")
print(f"Dominant Domain: {result.dominant_domain()}")

# Custom blending parameters
result = engine.compute_blended_valence_custom(
    text,
    min_confidence=0.1,   # Include domains above this confidence
    max_domains=4         # Maximum domains to blend
)

# Just get the domain mix string
mix = engine.get_domain_mix(text)
print(mix)  # "70% Finance / 30% Legal"

# Batch blended analysis
results = engine.compute_blended_batch(texts)

# Load custom domain lexicon
engine.load_domain_lexicon("custom_finance.json", "custom_finance")

# Set active domain manually
engine.set_domain("loughran_mcdonald")
sentiment = engine.classify_sentiment(text)  # Uses financial lexicon

# Reset to auto-detection
engine.set_domain(None)

# Check available domains
domains = engine.available_domains()
print(domains)  # ["loughran_mcdonald", "blacks_law", ...]

text = "The rating downgrade methodology was flawed and the credit assessment was unfair"

result = engine.detect_taxonomy(text)

print(f"Total matches: {result.total_matches}")
print(f"Primary industry: {result.dominant_industry}")
print(f"Primary category: {result.dominant_category}")
print(f"Aggregate sentiment: {result.aggregate_sentiment:.2f}")

# List all matches
for match in result.matches:
    print(f"  '{match.phrase}' - {match.industry}")
    print(f"    Category: {match.category_path}")
    print(f"    Sentiment: {match.sentiment_weight:.2f}")

# Get industry distribution
distribution = result.industry_percentages()
for industry, pct in distribution.items():
    print(f"  {industry}: {pct:.1%}")

# Filter taxonomy detection by industry
result = engine.detect_taxonomy_for_industry(text, "financial_intelligence")

# Check if text has specific industry complaints
has_finance = engine.has_taxonomy_industry(text, "financial_intelligence")
print(f"Has financial complaints: {has_finance}")

# Get best category match for an industry
category, matches = engine.classify_taxonomy_category(text, "financial_intelligence")
print(f"Category: {category}")

# List all available industries
industries = engine.available_taxonomy_industries()
for industry in industries:
    desc = engine.get_taxonomy_industry_description(industry)
    print(f"  {industry}: {desc}")

# Total phrases in taxonomy
count = engine.taxonomy_phrase_count()
print(f"Total taxonomy phrases: {count}")  # 501

expanded = engine.expand_text("I don't like the terrible service")

print(f"Original words: {expanded.original_words}")
print(f"Synonyms: {expanded.synonyms}")
print(f"Antonyms: {expanded.antonyms}")
print(f"Negated words: {expanded.negated_words}")
print(f"Has positive modal: {expanded.has_positive_modal}")
print(f"Has negative modal: {expanded.has_negative_modal}")

analysis = engine.analyze_comprehensive(text)

# Sentiment
print(f"Sentiment: {analysis.sentiment}")
print(f"Valence: {analysis.valence:.4f}")

# Domain Detection
print(f"Detected Domain: {analysis.detected_domain}")
print(f"Domain Confidence: {analysis.domain_confidence:.2f}")
print(f"Domain Keywords: {analysis.domain_keywords}")

# Blending
print(f"Blended Valence: {analysis.blended_valence:.4f}")
print(f"Domain Mix: {analysis.domain_mix}")

# Taxonomy
print(f"Taxonomy Matches: {analysis.taxonomy_matches}")
print(f"Taxonomy Industry: {analysis.taxonomy_industry}")
print(f"Taxonomy Category: {analysis.taxonomy_category}")
print(f"Taxonomy Sentiment: {analysis.taxonomy_sentiment:.2f}")

# Process multiple texts with auto-domain per text
texts = [
    "The lawsuit was dismissed",
    "Revenue exceeded expectations",
    "Security vulnerability detected",
]

results = engine.analyze_batch_auto(texts)
for idx, domain, sentiment, valence in results:
    print(f"Text {idx}: {domain} - {sentiment} ({valence:.2f})")

# Define labels with descriptions
labels = [
    ("positive_feedback", "positive customer feedback expressing satisfaction"),
    ("negative_feedback", "negative customer feedback expressing dissatisfaction"),
    ("feature_request", "customer requesting new features or improvements"),
    ("bug_report", "customer reporting a bug or technical issue"),
]

text = "The app keeps crashing when I try to save my work"
label, score = engine.classify_to_label(text, labels)
print(f"Classification: {label} (confidence: {score:.4f})")
# "bug_report"

# Batch classification
texts = ["Love this product!", "Please add dark mode", "Error on checkout"]
results = engine.classify_batch(texts, labels)
for text, (label, score) in zip(texts, results):
    print(f"{text}: {label}")

from ones_rs import check_trial_status

status = check_trial_status()
print(f"License: {status.license_type}")
print(f"Days remaining: {status.days_remaining}")
print(f"Valid: {status.valid}")

from ones_rs import activate_license

# Activate with your license key
status = activate_license("ONES-eyJjb21wYW55IjogIll...")
print(f"Activated: {status.company}")
print(f"Expires in: {status.days_remaining} days")

from ones_rs import OnesEngine

# Skip license check for evaluation in restricted environments
engine = OnesEngine(skip_license_check=True)

# Use normally
result = engine.classify_sentiment("Revenue exceeded expectations")