Grammar Checkers

from myspellchecker.grammar.checkers.aspect import AspectChecker

checker = AspectChecker()

# Check if word is an aspect marker
checker.is_aspect_marker("ပြီ")  # True
checker.is_aspect_marker("စား")  # False

# Check for typos
checker.is_aspect_typo("ပရီ")  # True (typo for ပြီ)
correction = checker.get_typo_correction("ပရီ")  # "ပြီ"

# Get detailed aspect info
info = checker.get_aspect_info("ပြီ")
print(info.category)     # "completion"
print(info.description)  # "Action completed"
print(info.is_final)     # True (typically at phrase end)

# Validate aspect sequences
errors = checker.validate_sequence(["စား", "ပြီး", "သွား"])
for error in errors:
    print(f"{error.text}: {error.reason}")

from myspellchecker.grammar.checkers.classifier import (
    ClassifierChecker,
    get_classifier_checker,
    is_classifier,
    is_numeral
)

checker = ClassifierChecker()

# Check if word is a numeral
is_numeral("သုံး")  # True (three)
is_numeral("၃")     # True (digit 3)

# Check if word is a classifier
is_classifier("ယောက်")  # True (classifier for people)
is_classifier("လူ")     # False (just a noun)

# Get classifier category
category = checker.get_classifier_category("ကောင်")  # "animals"

# Check for classifier typos
typo_result = checker.check_classifier_typo("ယေက်")
if typo_result:
    correction, confidence = typo_result
    print(f"Correction: {correction}")  # "ယောက်"

# Validate classifier usage
errors = checker.validate_sequence(["သုံး", "ယေက်", "ရှိ"])
for error in errors:
    print(f"{error.word} → {error.suggestion}")

# Get compatible classifiers for a noun
classifiers = checker.get_compatible_classifiers("ခွေး")  # ["ကောင်"]

# Check classifier-noun agreement
error = checker.check_agreement(classifier="ယောက်", noun="ခွေး")
if error:
    print(error.reason)  # ခွေး (dog) should use ကောင် not ယောက်

from myspellchecker.grammar.checkers.compound import (
    CompoundChecker,
    get_compound_checker,
    is_compound,
    is_reduplication,
)

checker = CompoundChecker()

# Check if word is a recognized compound
is_compound("ပန်းခြံ")  # True

# Check for reduplication
is_reduplication("ဖြေးဖြေး")  # True
base = checker.get_reduplication_base("ဖြေးဖြေး")  # "ဖြေး"

# Detect compound pattern
info = checker.detect_compound_pattern("အလုပ်")
if info:
    print(info.compound_type)  # "affixed"
    print(info.components)     # ["အ", "လုပ်"]
    print(info.pattern)        # "PREFIX(nominalization) + STEM"

# Comprehensive compound analysis
result = checker.analyze_word("ပန်းခြံ")
print(result["is_compound"])      # True
print(result["components"])       # ["ပန်း", "ခြံ"]
print(result["has_prefix"])       # False
print(result["is_reduplication"]) # False
print(result["confidence"])       # 0.95

from myspellchecker.grammar.checkers.merged_word import MergedWordChecker

checker = MergedWordChecker()
errors = checker.validate_sequence(words, pos_tags)

from myspellchecker.grammar.checkers.negation import (
    NegationChecker,
    get_negation_checker,
    is_negative_ending,
)

checker = NegationChecker()

# Check for negation prefix
checker.starts_with_negation("မသွား")  # True
checker.starts_with_negation("သွား")   # False

# Check negative endings
is_negative_ending("ဘူး")  # True
is_negative_ending("တယ်")  # False

# Check for ending typos
typo_result = checker.check_ending_typo("ဘူ")
if typo_result:
    correction, confidence = typo_result
    print(f"Correction: {correction}")  # "ဘူး"

# Validate negation patterns
errors = checker.validate_sequence(["မ", "သွား", "ဘူ"])
for error in errors:
    print(f"{error.word} → {error.suggestion}")

# Detect negation pattern starting at a given index
pattern = checker.detect_negation_pattern(["မ", "သွား", "ဘူး"], 0)
if pattern:
    print(pattern.pattern_type)  # "standard_negative"
    print(pattern.verb)          # "သွား"
    print(pattern.ending)        # "ဘူး"
    print(pattern.register)      # "colloquial"

from myspellchecker.grammar.checkers.particle import ParticleChecker

checker = ParticleChecker()

# Validate particle usage in a word sequence
errors = checker.validate_sequence(
    words=["ကျောင်း", "ကို", "ရှိ", "တယ်"],
    pos_tags=["N", "PPM", "V", "SFP"]  # Optional POS tags
)

for error in errors:
    print(f"{error.text}: {error.reason}")
    print(f"  Suggestion: {error.suggestions}")
    print(f"  Confidence: {error.confidence}")

from myspellchecker.grammar.checkers.particle import get_particle_checker

# Thread-safe singleton (loads YAML once)
checker = get_particle_checker()

particle_confusions:
  - particle: "ကို"
    confused_with: "မှာ"
    context: "static_location"
    description: "Static locative used with motion verb"
    confidence: 0.70

verb_particle_frames:
  - verbs: ["သွား", "လာ", "ပြန်"]
    required_particles: ["ကို", "သို့"]
    incompatible_particles: ["မှာ", "တွင်"]
    note: "Motion verbs require directional particles"

from myspellchecker.grammar.checkers.tense_agreement import TenseAgreementChecker

checker = TenseAgreementChecker()

# Validate tense-time agreement
errors = checker.validate_sequence(["မနေ့က", "ကျောင်း", "သွား", "မယ်"])

for error in errors:
    print(f"{error.text}: {error.reason}")
    print(f"  Time adverb: {error.time_adverb}")
    print(f"  Detected tense: {error.detected_tense}")
    print(f"  Suggestion: {error.suggestions}")

# Check if a word is a temporal adverb
checker.is_time_adverb("မနေ့က")  # True
checker.get_adverb_tense("မနေ့က")  # "past"

# Check if a word is an aspect marker
checker.is_aspect_marker("မယ်")  # True
checker.get_marker_tense("မယ်")  # "future"

tense_agreement_rules:
  past_time_adverbs: ["မနေ့က", "တုန်းက", "အရင်က"]
  future_time_adverbs: ["မနက်ဖြန်", "နောက်နှစ်", "လာမယ့်"]
  past_aspect_markers: ["ခဲ့တယ်", "ခဲ့သည်"]
  future_aspect_markers: ["မယ်", "မည်"]
  incompatible_pairs:
    - time_class: past
      incompatible_aspects: ["မယ်", "မည်"]
      confidence: 0.80

from myspellchecker.core.config import TenseAgreementCheckerConfig

config = TenseAgreementCheckerConfig(
    default_confidence=0.75,  # Default confidence for tense mismatches
    high_confidence=0.85,     # When both adverb and marker are unambiguous
)
checker = TenseAgreementChecker(checker_config=config)

from myspellchecker.grammar.checkers.register import RegisterChecker

checker = RegisterChecker()

# Get register of a word
info = checker.get_register("သည်")
print(info.register)         # "formal"

info = checker.get_register("ပါတယ်")
print(info.register)         # "polite"

info = checker.get_register("တယ်")
print(info.register)         # "colloquial"

# Check register type
checker.is_formal("သည်")      # True
checker.is_colloquial("တယ်")  # True
checker.is_neutral("စာအုပ်")  # True

# Detect predominant register (now returns 3-way classification)
register, consistency, infos = checker.detect_sentence_register(
    ["သူ", "သည်", "စာအုပ်", "ဖတ်", "တယ်"]
)
print(register)     # "mixed"
print(consistency)  # 0.5 (50% consistent)

# Check for mixed register errors
errors = checker.validate_sequence(["သူ", "သည်", "စာအုပ်", "ဖတ်", "တယ်"])
for error in errors:
    print(f"{error.text}: {error.reason}")
    print(f"  Detected: {error.detected_register}")
    print(f"  Expected: {error.expected_register}")
    print(f"  Suggestion: {error.suggestion}")

from myspellchecker.core.config import RegisterCheckerConfig

config = RegisterCheckerConfig(
    register_mismatch_confidence=0.85,        # Formal + colloquial mixing
    register_formality_gap_confidence=0.65,    # Formal + polite mixing
)
checker = RegisterChecker(register_config=config)

from myspellchecker import SpellChecker
from myspellchecker.core.config import SpellCheckerConfig
from myspellchecker.providers import SQLiteProvider

config = SpellCheckerConfig(
    use_rule_based_validation=True  # Enable all grammar checkers
)

provider = SQLiteProvider(database_path="path/to/dictionary.db")
checker = SpellChecker(config=config, provider=provider)
result = checker.check("သူသည် စာအုပ် ဖတ်တယ်။")

# Grammar errors include all checker types
for error in result.errors:
    if hasattr(error, 'error_type'):
        print(f"Type: {error.error_type}")  # aspect_error, register_error, etc.
        print(f"Word: {error.text}")
        print(f"Reason: {error.reason}")