Error Types Reference

When something goes wrong, you need to know whether it’s a finding in the text being checked (a validation error the user should fix) or a failure in the library itself (a configuration or resource problem you need to fix). These two cases use separate class hierarchies: Error subclasses in Response.errors for the former, and Python exceptions for the latter.

Spell Checking Errors

These are returned in Response.errors when checking text.

Error Base Class

All spell checking errors inherit from Error:

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

SyllableError

Invalid syllable detected (Layer 1 validation).

from myspellchecker.core.response import SyllableError

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

print(error.error_type)  # "invalid_syllable"

Error Types:

Type	Description
`invalid_syllable`	Standard syllable validation error
`particle_typo`	Known particle typo (e.g., တယ → တယ်)
`medial_confusion`	Ya-pin/Ya-yit confusion

WordError

Invalid word detected (Layer 2 validation).

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

ContextError

Unlikely word sequence detected (Layer 3 validation).

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)   # "သူ"

Semantic Error Types:

Type	Source	Description
`semantic_error`	SemanticStrategy	AI-detected semantic error via MLM
`confusable_error`	ConfusableSemanticStrategy	Valid word, wrong in context

Semantic errors use MLM predictions to detect unlikely words. Confusable errors flag words that are valid but confused with a similar-looking alternative.

GrammarError

Grammar-related errors from grammar checkers.

from myspellchecker.core.response import GrammarError

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

Grammar Error Types:

Type	Source	Description
`aspect_typo`	AspectChecker	Verb aspect marker typo
`incomplete_aspect`	AspectChecker	Incomplete aspect marking
`invalid_sequence`	AspectChecker	Invalid aspect sequence
`typo`	ClassifierChecker	Classifier typo (e.g., ယေက် → ယောက်)
`agreement`	ClassifierChecker	Classifier-noun agreement error
`compound_typo`	CompoundChecker	Compound word typo
`incomplete_reduplication`	CompoundChecker	Incomplete reduplication
`typo`	NegationChecker	Negation pattern typo
`mixed_register`	RegisterChecker	Formal/colloquial mixing

Response Object

The complete spell checking result:

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())

Exceptions

System-level errors for configuration, resources, and processing.

Exception Hierarchy

MyanmarSpellcheckError (base)

ConfigurationError

InvalidConfigError

DataLoadingError

MissingDatabaseError

ProcessingError

ValidationError

TokenizationError

NormalizationError

ProviderError

ConnectionPoolError

PipelineError

IngestionError

PackagingError

ModelError

ModelLoadError

InferenceError

MissingDependencyError

InsufficientStorageError

CacheError

Common Exceptions

MyanmarSpellcheckError

Base exception for all library errors:

from myspellchecker.core.exceptions import MyanmarSpellcheckError

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

MissingDatabaseError

Database not found:

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}")

MissingDependencyError

Optional dependency not installed:

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]

ConfigurationError

Invalid configuration:

from myspellchecker.core.exceptions import ConfigurationError, InvalidConfigError

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

ProcessingError

Text processing failure:

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}")

ProviderError

Database provider failure:

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}")

PipelineError

Data pipeline failure:

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}")

ModelError

ML model failure:

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}")

Grouping Exceptions

You can create your own exception tuples for consistent error handling:

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}")

Error Type Constants

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"

Best Practices

1. Catch Specific Exceptions

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

2. Check Error Types

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

3. Use Confidence Scores

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)

Common Myanmar Spelling Errors

Error Frequency by Category

Based on corpus analysis:

Error Type	Frequency	Detection Layer	Example
Medial ြ/ျ confusion	35%	Syllable	ကြောင်/ကျောင်
Missing asat	20%	Syllable	အိမ/အိမ်
Vowel length	15%	Syllable/Word	သု/သူ
Particle errors	12%	Grammar	မှာ/မှ
Context (real-word)	10%	Context	ထမင်းသွား/ထမင်းစား
Stacking errors	5%	Syllable	သမတ (“broken stacking”) → သမ္မတ (“president”)
Other	3%	Various	-

Detection by Validation Layer

Layer 1 - Syllable Validation:

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

Layer 2 - Word Validation:

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

Layer 2.5 - Grammar Checking:

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

Layer 3 - Context Validation:

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

Medial-Consonant Compatibility

Not all medials are compatible with all consonants:

Medial	Compatible With	Incompatible With
Ha-htoe (ှ)	Sonorants (န, မ, လ, etc.)	Stops (က, ခ, ဂ, etc.)
Ya-yit (ြ)	Ka-group, Pa-group	Tha (သ)

Stacking Errors

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

API Reference

Core Internals

Spelling Algorithms

Context & Grammar Algorithms

Segmentation & Tagging

Architecture

CLI & Error Reference

Data Reference

Data Pipeline Internals

Spell Checking Errors

Error Base Class

SyllableError

WordError

ContextError

GrammarError

Response Object

Exceptions

Exception Hierarchy

Common Exceptions

MyanmarSpellcheckError

MissingDatabaseError

MissingDependencyError

ConfigurationError

ProcessingError

ProviderError

PipelineError

ModelError

Grouping Exceptions

Error Type Constants

Best Practices

1. Catch Specific Exceptions

2. Check Error Types

3. Use Confidence Scores

Common Myanmar Spelling Errors

Error Frequency by Category

Detection by Validation Layer

Medial-Consonant Compatibility

Stacking Errors

See Also

​Spell Checking Errors

​Error Base Class

​SyllableError

​WordError

​ContextError

​GrammarError

​Response Object

​Exceptions

​Exception Hierarchy

​Common Exceptions

​MyanmarSpellcheckError

​MissingDatabaseError

​MissingDependencyError

​ConfigurationError

​ProcessingError

​ProviderError

​PipelineError

​ModelError

​Grouping Exceptions

​Error Type Constants

​Best Practices

​1. Catch Specific Exceptions

​2. Check Error Types

​3. Use Confidence Scores

​Common Myanmar Spelling Errors

​Error Frequency by Category

​Detection by Validation Layer

​Medial-Consonant Compatibility

​Stacking Errors

​See Also

Spell Checking Errors

Error Base Class

SyllableError

WordError

ContextError

GrammarError

Response Object

Exceptions

Exception Hierarchy

Common Exceptions

MyanmarSpellcheckError

MissingDatabaseError

MissingDependencyError

ConfigurationError

ProcessingError

ProviderError

PipelineError

ModelError

Grouping Exceptions

Error Type Constants

Best Practices

1. Catch Specific Exceptions

2. Check Error Types

3. Use Confidence Scores

Common Myanmar Spelling Errors

Error Frequency by Category

Detection by Validation Layer

Medial-Consonant Compatibility

Stacking Errors

See Also