Error Types Reference

from myspellchecker.core.response import Error

@dataclass
class Error:
    text: str           # The erroneous text
    position: int       # Character position (0-indexed)
    suggestions: List[str]  # Correction suggestions
    error_type: str     # Type identifier
    confidence: float   # 0.0 to 1.0

from myspellchecker.core.response import SyllableError

error = SyllableError(
    text="မျန်",
    position=0,
    suggestions=["မြန်", "မျန်း"],
    confidence=0.95
)

print(error.error_type)  # "invalid_syllable"

from myspellchecker.core.response import WordError

error = WordError(
    text="မြန်စာ",
    position=0,
    suggestions=["မြန်မာ", "မြန်"],
    syllable_count=2,
    confidence=0.9
)

print(error.error_type)    # "invalid_word"
print(error.syllable_count)  # 2

from myspellchecker.core.response import ContextError

error = ContextError(
    text="ဘယ်",
    position=3,
    suggestions=["သွား", "သည်"],
    probability=0.005,
    prev_word="သူ",
    confidence=0.7
)

print(error.error_type)  # "context_probability"
print(error.probability) # 0.005
print(error.prev_word)   # "သူ"

from myspellchecker.core.response import GrammarError

error = GrammarError(
    text="ယေက်",
    position=2,
    suggestions=["ယောက်"],
    error_type="classifier_typo",
    confidence=0.95,
    reason="Classifier typo: ယေက် should be ယောက်"
)

from myspellchecker.core.response import Response

response = Response(
    text="မျနမ်ာ",           # Original input
    corrected_text="မြန်မာ",  # Auto-corrected
    has_errors=True,          # Quick check flag
    level="syllable",         # Validation level used
    errors=[...],             # List of Error objects
    metadata={                # Processing info
        "processing_time": 0.015,  # seconds
        "syllable_count": 4,
        "word_count": 1
    }
)

# Serialize
print(response.to_json())
print(response.to_dict())

from myspellchecker.core.exceptions import MyanmarSpellcheckError

try:
    checker.check(text)
except MyanmarSpellcheckError as e:
    print(f"Spell check error: {e}")

from myspellchecker.core.exceptions import MissingDatabaseError

try:
    checker = SpellChecker()
except MissingDatabaseError as e:
    print(f"Database not found: {e}")
    print(f"Searched: {e.searched_paths}")
    print(f"Solution: {e.suggestion}")

from myspellchecker.core.exceptions import MissingDependencyError

try:
    from myspellchecker.algorithms import TransformerPOSTagger
except MissingDependencyError as e:
    print(f"Missing dependency: {e}")
    # Install: pip install myspellchecker[transformers]

from myspellchecker.core.exceptions import ConfigurationError, InvalidConfigError

try:
    config = SpellCheckerConfig(max_edit_distance=10)  # Invalid
except InvalidConfigError as e:
    print(f"Invalid config: {e}")

from myspellchecker.core.exceptions import (
    ProcessingError,
    ValidationError,
    TokenizationError,
    NormalizationError
)

try:
    result = checker.check(text)
except ValidationError as e:
    print(f"Invalid text: {e}")
except TokenizationError as e:
    print(f"Segmentation failed: {e}")
except NormalizationError as e:
    print(f"Normalization failed: {e}")
except ProcessingError as e:
    print(f"Processing failed: {e}")

from myspellchecker.core.exceptions import ProviderError, ConnectionPoolError

try:
    result = checker.check(text)
except ConnectionPoolError as e:
    print(f"Connection pool exhausted: {e}")
except ProviderError as e:
    print(f"Provider error: {e}")

from myspellchecker.core.exceptions import PipelineError, IngestionError, PackagingError

try:
    pipeline.run()
except IngestionError as e:
    print(f"Ingestion failed: {e}")
    print(f"Missing files: {e.missing_files}")
    print(f"Failed files: {e.failed_files}")
except PackagingError as e:
    print(f"Packaging failed: {e}")
except PipelineError as e:
    print(f"Pipeline error: {e}")

from myspellchecker.core.exceptions import ModelError, ModelLoadError, InferenceError

try:
    tagger.tag(text)
except ModelLoadError as e:
    print(f"Model load failed: {e}")
except InferenceError as e:
    print(f"Inference failed: {e}")
except ModelError as e:
    print(f"Model error: {e}")

from myspellchecker.core.exceptions import (
    DataLoadingError,
    MissingDatabaseError,
    ProviderError,
    ProcessingError,
    ValidationError,
)

# Group related exceptions for try/except
DATABASE_EXCEPTIONS = (DataLoadingError, MissingDatabaseError, ProviderError)
PROCESSING_EXCEPTIONS = (ProcessingError, ValidationError)

try:
    result = process_text(text)
except PROCESSING_EXCEPTIONS as e:
    logger.error(f"Processing failed: {e}")

from myspellchecker.core.constants import ErrorType

# --- Core validation errors ---
ErrorType.SYLLABLE                  # "invalid_syllable"
ErrorType.WORD                      # "invalid_word"
ErrorType.CONTEXT_PROBABILITY       # "context_probability"
ErrorType.GRAMMAR                   # "grammar_error"

# --- Syllable-level specific errors ---
ErrorType.PARTICLE_TYPO             # "particle_typo"
ErrorType.MEDIAL_CONFUSION          # "medial_confusion"

# --- Colloquial variant errors ---
ErrorType.COLLOQUIAL_VARIANT        # "colloquial_variant"  (strict mode)
ErrorType.COLLOQUIAL_INFO           # "colloquial_info"     (lenient mode)

# --- Validation strategy errors ---
ErrorType.QUESTION_STRUCTURE        # "question_structure"
ErrorType.SYNTAX_ERROR              # "syntax_error"
ErrorType.HOMOPHONE_ERROR           # "homophone_error"
ErrorType.TONE_AMBIGUITY            # "tone_ambiguity"
ErrorType.POS_SEQUENCE_ERROR        # "pos_sequence_error"
ErrorType.SEMANTIC_ERROR            # "semantic_error"

# --- Encoding errors ---
ErrorType.ZAWGYI_ENCODING           # "zawgyi_encoding"

# --- Grammar checker specific errors ---
ErrorType.MIXED_REGISTER            # "mixed_register"
ErrorType.ASPECT_TYPO               # "aspect_typo"
ErrorType.INVALID_SEQUENCE          # "invalid_sequence"
ErrorType.INCOMPLETE_ASPECT         # "incomplete_aspect"
ErrorType.TYPO                      # "typo"
ErrorType.AGREEMENT                 # "agreement"
ErrorType.COMPOUND_TYPO             # "compound_typo"
ErrorType.INCOMPLETE_REDUPLICATION  # "incomplete_reduplication"
ErrorType.CLASSIFIER_TYPO           # "classifier_typo"

# --- Text-level detector errors (spellchecker.py) ---
ErrorType.COLLOQUIAL_CONTRACTION    # "colloquial_contraction"
ErrorType.PARTICLE_CONFUSION        # "particle_confusion"
ErrorType.HA_HTOE_CONFUSION         # "ha_htoe_confusion"
ErrorType.DANGLING_PARTICLE         # "dangling_particle"
ErrorType.DANGLING_WORD             # "dangling_word"
ErrorType.MISSING_CONJUNCTION       # "missing_conjunction"
ErrorType.TENSE_MISMATCH            # "tense_mismatch"
ErrorType.REGISTER_MIXING           # "register_mixing"

# --- Grammar checker class-level errors ---
ErrorType.NEGATION_ERROR            # "negation_error"
ErrorType.REGISTER_ERROR            # "register_error"
ErrorType.MERGED_WORD               # "merged_word"
ErrorType.ASPECT_ERROR              # "aspect_error"
ErrorType.CLASSIFIER_ERROR          # "classifier_error"
ErrorType.COMPOUND_ERROR            # "compound_error"

# --- Orthography errors ---
ErrorType.MEDIAL_ORDER_ERROR        # "medial_order_error"
ErrorType.MEDIAL_COMPATIBILITY_ERROR  # "medial_compatibility_error"
ErrorType.VOWEL_AFTER_ASAT          # "vowel_after_asat"
ErrorType.BROKEN_VIRAMA             # "broken_virama"
ErrorType.CONFUSABLE_ERROR          # "confusable_error"
ErrorType.BROKEN_STACKING           # "broken_stacking"
ErrorType.BROKEN_COMPOUND           # "broken_compound"
ErrorType.LEADING_VOWEL_E           # "leading_vowel_e"
ErrorType.INCOMPLETE_STACKING       # "incomplete_stacking"

# --- Syntactic/semantic errors ---
ErrorType.NEGATION_SFP_MISMATCH     # "negation_sfp_mismatch"
ErrorType.MERGED_SFP_CONJUNCTION    # "merged_sfp_conjunction"
ErrorType.ASPECT_ADVERB_CONFLICT    # "aspect_adverb_conflict"

# --- Punctuation errors ---
ErrorType.DUPLICATE_PUNCTUATION     # "duplicate_punctuation"
ErrorType.WRONG_PUNCTUATION         # "wrong_punctuation"
ErrorType.MISSING_PUNCTUATION       # "missing_punctuation"

# --- Additional detection errors ---
ErrorType.MISSING_ASAT              # "missing_asat"
ErrorType.PARTICLE_MISUSE           # "particle_misuse"
ErrorType.COLLOCATION_ERROR         # "collocation_error"

try:
    result = checker.check(text)
except MissingDatabaseError:
    # Handle missing database specifically
    build_sample_database()
except MyanmarSpellcheckError:
    # Handle other library errors
    log_error()

for error in result.errors:
    if error.error_type == "invalid_syllable":
        # Handle syllable error
        pass
    elif error.error_type.startswith("classifier"):
        # Handle classifier errors
        pass

HIGH_CONFIDENCE = 0.8

for error in result.errors:
    if error.confidence >= HIGH_CONFIDENCE:
        # Auto-correct high confidence errors
        apply_correction(error)
    else:
        # Show suggestions for low confidence
        show_suggestions(error)

result = checker.check("ကွြ")   # Invalid medial order → Suggestion: ကြွ
result = checker.check("ကိီ")   # Incompatible vowels

result = checker.check("မယ်နမာ")  # Unknown word → Suggestions: ["မြန်မာ", ...]

result = checker.check("သွားကို")  # Verb with object particle → GrammarError

result = checker.check("ထမင်းသွား")  # Low probability bigram → Suggestion: ထမင်းစား

Correct: မင်္ဂလာ (blessing)     |  Error: မင်ဂလာ (missing stack)
Correct: ဗုဒ္ဓ (Buddha)          |  Error: ဗုဒ (incomplete)