Resource Caching

from myspellchecker.tokenizers.resource_loader import (
    get_resource_path,
    get_segmentation_mmap_path,
    get_crf_model_path,
    get_curated_lexicon_path,
)

# Get path to resource (auto-downloads if needed)
mmap_path = get_segmentation_mmap_path()
crf_path = get_crf_model_path()
lexicon_path = get_curated_lexicon_path()

def get_resource_path(
    name: str,
    cache_dir: Optional[Path] = None,
    force_download: bool = False,
) -> Path:
    """Get path to a resource, downloading if necessary.

    Args:
        name: Resource name ("segmentation", "crf")
        cache_dir: Custom cache directory
        force_download: Skip bundled resources (does NOT force
            re-download of cached resources — delete the cache
            directory manually to force a fresh download)

    Returns:
        Path to the resource file

    Raises:
        ValueError: If resource name is unknown
        RuntimeError: If download fails
    """

from myspellchecker.tokenizers.resource_loader import get_resource_path

# Get segmentation dictionary
path = get_resource_path("segmentation")

# Get CRF model
path = get_resource_path("crf")

# Skip bundled resources, use cached or download
path = get_resource_path("segmentation", force_download=True)

# Custom cache directory
path = get_resource_path("crf", cache_dir=Path("/custom/cache"))

from myspellchecker.tokenizers.resource_loader import (
    get_segmentation_mmap_path,
    get_crf_model_path,
    get_curated_lexicon_path,
)

# Word segmentation dictionary
mmap_path = get_segmentation_mmap_path()

# CRF syllable model
crf_path = get_crf_model_path()

# Curated lexicon
lexicon_path = get_curated_lexicon_path()

from myspellchecker.tokenizers.resource_loader import (
    get_segmentation_mmap_path,
    get_crf_model_path,
    get_curated_lexicon_path,
)

# Download all resources (auto-caches)
mmap_path = get_segmentation_mmap_path()
crf_path = get_crf_model_path()
lexicon_path = get_curated_lexicon_path()

# Skip bundled resources, use cached or download
mmap_path = get_segmentation_mmap_path(force_download=True)
crf_path = get_crf_model_path(force_download=True)
lexicon_path = get_curated_lexicon_path(force_download=True)

DEFAULT_CACHE_DIR = Path.home() / ".cache" / "myspellchecker" / "resources"
# Example: /home/user/.cache/myspellchecker/resources/

RESOURCE_VERSION = "main"
HF_REPO = f"https://huggingface.co/datasets/thettwe/myspellchecker-resources/resolve/{RESOURCE_VERSION}"

RESOURCE_URLS = {
    "segmentation": f"{HF_REPO}/segmentation/segmentation.mmap",
    "crf": f"{HF_REPO}/models/wordseg_c2_crf.crfsuite",
    "curated_lexicon": f"{HF_REPO}/curated_lexicon/curated_lexicon.csv",
}

# First time: Downloads and caches
path = get_segmentation_mmap_path()
# Output:
# INFO: Downloading segmentation resource (first time only)...
# INFO: Download complete: ~/.cache/myspellchecker/resources/segmentation.mmap

# Subsequent calls: Uses cache (silent)
path = get_segmentation_mmap_path()
# No output - uses cached file

# Skip bundled resources, use cached or download from HuggingFace
path = get_segmentation_mmap_path(force_download=True)
# Note: This skips the package-bundled resource check, but does NOT
# re-download if the resource is already cached. To force a fresh
# download, delete the cache directory first.

try:
    path = get_resource_path("unknown_resource")
except ValueError as e:
    print(e)  # "Unknown resource: unknown_resource. Available: ['segmentation', 'crf']"

try:
    path = get_resource_path("segmentation")
except RuntimeError as e:
    print(f"Download failed: {e}")

from myspellchecker.tokenizers.resource_loader import get_resource_path

try:
    path = get_resource_path("segmentation")
except Exception as e:
    # Fall back to bundled resource if available
    local_path = Path("data/models/segmentation.mmap")
    if local_path.exists():
        path = local_path
    else:
        raise

from myspellchecker.segmenters import DefaultSegmenter

# Resources are loaded automatically with default word engine
segmenter = DefaultSegmenter(word_engine="myword")

# Alternative engines
segmenter_crf = DefaultSegmenter(word_engine="crf")

from myspellchecker.tokenizers.resource_loader import get_crf_model_path

# Get CRF model path (automatically cached)
model_path = get_crf_model_path()
print(f"CRF model cached at: {model_path}")

# Note: CRF model is used internally by segmenters when word_engine='crf'
# See configuration documentation for usage

from myspellchecker.tokenizers.resource_loader import get_resource_path

# Download to default cache during installation/setup
get_resource_path("segmentation")
get_resource_path("crf")

# Or download to specific directory for deployment
from pathlib import Path
get_resource_path("segmentation", cache_dir=Path("/app/resources"))
get_resource_path("crf", cache_dir=Path("/app/resources"))

import os
from pathlib import Path
from myspellchecker.tokenizers.resource_loader import get_resource_path

# Via environment variable
os.environ["MYSPELL_CACHE_DIR"] = "/custom/path"

# Or via function parameter
path = get_resource_path("segmentation", cache_dir=Path("/custom/path"))

from myspellchecker.core.config import ResourceConfig

resource_config = ResourceConfig(
    resource_version="main",       # HuggingFace version tag (bump for reproducibility)
    hf_repo_base="https://huggingface.co/datasets/thettwe/myspellchecker-resources/resolve",
    cache_dir=None,                # None = ~/.cache/myspellchecker/resources
)

from myspellchecker.core.config import ResourceConfig

# Point to pre-downloaded resources (no HuggingFace calls)
resource_config = ResourceConfig(
    cache_dir="/app/data/resources",
)

# Or pin a specific version for reproducible builds
resource_config = ResourceConfig(
    resource_version="v1.0.0",
    cache_dir="/app/data/resources",
)

export MYSPELL_CACHE_DIR=/app/data/resources
export MYSPELL_OFFLINE=true

# In deployment script
from myspellchecker.tokenizers.resource_loader import get_resource_path

# Download all resources before starting application
seg_path = get_resource_path("segmentation")
crf_path = get_resource_path("crf")
print(f"Resources ready: segmentation={seg_path}, crf={crf_path}")

from pathlib import Path
from myspellchecker.tokenizers.resource_loader import get_resource_path

# In Docker, use a persistent volume
get_resource_path("segmentation", cache_dir=Path("/app/data/resources"))
get_resource_path("crf", cache_dir=Path("/app/data/resources"))

import logging
from myspellchecker.tokenizers.resource_loader import get_resource_path

try:
    path = get_resource_path("segmentation")
except Exception as e:
    logging.warning(f"Failed to download resource: {e}")
    # Use fallback or raise user-friendly error

# force_download=True only skips bundled resources, it does NOT
# re-download cached files. To get fresh copies from HuggingFace,
# delete the cache directory first, then re-download:
import shutil
from pathlib import Path

cache_dir = Path.home() / ".cache" / "myspellchecker" / "resources"
shutil.rmtree(cache_dir, ignore_errors=True)

from myspellchecker.tokenizers.resource_loader import get_resource_path

get_resource_path("segmentation")
get_resource_path("crf")