Dictionary Providers

from myspellchecker.providers import SQLiteProvider

# Basic usage
provider = SQLiteProvider("/path/to/dictionary.db")

# With connection pooling
provider = SQLiteProvider(
    database_path="/path/to/dictionary.db",
    pool_max_size=5,           # Maximum connections in pool (default: 5)
    pool_timeout=5.0,          # Checkout timeout in seconds
    sqlite_timeout=30.0,       # SQLite busy timeout
    check_same_thread=False    # Allow multi-threading
)

# Check word validity
is_valid = provider.is_valid_word("မြန်မာ")
if is_valid:
    print(f"Frequency: {provider.get_word_frequency('မြန်မာ')}")
    print(f"POS tag: {provider.get_word_pos('မြန်မာ')}")

# Check syllable validity
is_valid = provider.is_valid_syllable("မြန်")

# Get n-gram probability
prob = provider.get_bigram_probability("မြန်မာ", "နိုင်ငံ")

from myspellchecker.providers import MemoryProvider

# Create empty provider
provider = MemoryProvider()

# Add data programmatically
provider.add_word("မြန်မာ", frequency=1000)
provider.add_word_pos("မြန်မာ", "N")  # Add POS tag separately
provider.add_syllable("မြန်")
provider.add_bigram("မြန်မာ", "နိုင်ငံ", probability=0.5)

# Load from lists (for testing or custom data)
syllables = [("မြန်", 1000), ("မာ", 800)]  # (syllable, frequency) tuples
words = [("မြန်မာ", 500)]                   # (word, frequency) tuples
bigrams = [("မြန်မာ", "နိုင်ငံ", 0.5)]       # (prev, curr, probability) tuples
provider.load_from_lists(syllable_list=syllables, word_list=words, bigram_list=bigrams)

from myspellchecker.providers import JSONProvider

# Load from JSON file
provider = JSONProvider("/path/to/dictionary.json")

{
  "syllables": {
    "မြန်": 15432,
    "မာ": 12341
  },
  "words": {
    "မြန်မာ": {"frequency": 8752, "syllable_count": 2},
    "နိုင်ငံ": {"frequency": 12341, "syllable_count": 2}
  },
  "bigrams": {
    "သူ|သွား": 0.234,
    "သူ|ဘယ်": 0.012
  }
}

from myspellchecker.providers import CSVProvider

provider = CSVProvider(
    syllables_csv="/path/to/syllables.csv",
    words_csv="/path/to/words.csv",
    bigrams_csv="/path/to/bigrams.csv",
)

from myspellchecker.providers import DictionaryProvider

class DictionaryProvider(ABC):
    @abstractmethod
    def is_valid_word(self, word: str) -> bool: ...

    @abstractmethod
    def is_valid_syllable(self, syllable: str) -> bool: ...

    @abstractmethod
    def get_word_frequency(self, word: str) -> int: ...

    @abstractmethod
    def get_syllable_frequency(self, syllable: str) -> int: ...

    @abstractmethod
    def get_word_pos(self, word: str) -> Optional[str]: ...

    @abstractmethod
    def get_bigram_probability(self, prev_word: str, current_word: str) -> float: ...

    @abstractmethod
    def get_trigram_probability(self, w1: str, w2: str, w3: str) -> float: ...

    @abstractmethod
    def get_fourgram_probability(self, word1: str, word2: str, word3: str, word4: str) -> float: ...

    @abstractmethod
    def get_fivegram_probability(self, word1: str, word2: str, word3: str, word4: str, word5: str) -> float: ...

    @abstractmethod
    def get_pos_unigram_probabilities(self) -> dict[str, float]: ...

    @abstractmethod
    def get_pos_bigram_probabilities(self) -> dict[tuple[str, str], float]: ...

    @abstractmethod
    def get_pos_trigram_probabilities(self) -> dict[tuple[str, str, str], float]: ...

    @abstractmethod
    def get_top_continuations(self, prev_word: str, limit: int = 20) -> List[Tuple[str, float]]: ...

    @abstractmethod
    def get_all_syllables(self) -> Iterator[Tuple[str, int]]: ...

    @abstractmethod
    def get_all_words(self) -> Iterator[Tuple[str, int]]: ...

from myspellchecker import SpellChecker
from myspellchecker.providers import MemoryProvider, JSONProvider
from myspellchecker.core.config import SpellCheckerConfig, ProviderConfig

# Direct provider injection with data
provider = MemoryProvider()
# Load data from lists (syllables, words, bigrams)
provider.load_from_lists(
    syllable_list=[("မြန်", 1500), ("မာ", 2300)],
    word_list=[("မြန်မာ", 850)],
)
checker = SpellChecker(provider=provider)

# Via configuration
config = SpellCheckerConfig(
    provider_config=ProviderConfig(
        cache_size=10000,
        pool_max_size=5,
        pool_timeout=5.0,
    )
)
checker = SpellChecker(config=config)

from myspellchecker.core.config.validation_configs import ProviderConfig

provider_config = ProviderConfig(
    cache_size=10000  # Number of cached entries (0 to disable)
)