Integration & Examples

mySpellChecker integrates with any Python web framework. The key pattern: create a SpellChecker instance once at startup, then reuse it across requests. Use check_async() for async frameworks and check() for sync ones.

FastAPI

Basic Endpoint

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel, Field
from myspellchecker import SpellChecker
from myspellchecker.core.constants import ValidationLevel

app = FastAPI(title="Myanmar Spell Checker API")
checker = SpellChecker()  # Create once, reuse


class CheckRequest(BaseModel):
    text: str = Field(..., min_length=1, max_length=10000)
    level: str = Field(default="syllable")


class ErrorInfo(BaseModel):
    text: str
    position: int
    error_type: str
    suggestions: list[str]
    confidence: float


class CheckResponse(BaseModel):
    text: str
    has_errors: bool
    corrected_text: str
    errors: list[ErrorInfo]


@app.post("/check", response_model=CheckResponse)
async def check_spelling(request: CheckRequest):
    level = ValidationLevel(request.level)
    result = await checker.check_async(request.text, level=level)

    return CheckResponse(
        text=result.text,
        has_errors=result.has_errors,
        corrected_text=result.corrected_text,
        errors=[
            ErrorInfo(
                text=e.text,
                position=e.position,
                error_type=e.error_type,
                suggestions=e.suggestions[:5],
                confidence=e.confidence,
            )
            for e in result.errors
        ],
    )

Testing with curl

# Check single text
curl -X POST http://localhost:8000/check \
  -H "Content-Type: application/json" \
  -d '{"text": "မြန်မာနိုင်ငံသည်", "level": "syllable"}'

# Batch check
curl -X POST http://localhost:8000/check/batch \
  -H "Content-Type: application/json" \
  -d '{"texts": ["မြန်မာ", "နိုင်ငံ"], "level": "syllable"}'

# Health check
curl http://localhost:8000/health

Batch Endpoint

class BatchRequest(BaseModel):
    texts: list[str]

@app.post("/check/batch")
async def check_batch(request: BatchRequest):
    results = await checker.check_batch_async(request.texts)
    return {
        "results": [
            {"text": r.text, "has_errors": r.has_errors, "error_count": len(r.errors)}
            for r in results
        ],
        "summary": {
            "total_texts": len(results),
            "texts_with_errors": sum(1 for r in results if r.has_errors),
        },
    }

With Lifespan Management

from contextlib import asynccontextmanager
from fastapi import FastAPI, Request

@asynccontextmanager
async def lifespan(app: FastAPI):
    app.state.checker = SpellChecker()
    yield

app = FastAPI(lifespan=lifespan)

@app.post("/check")
async def check_spelling(request: Request, body: CheckRequest):
    checker = request.app.state.checker
    result = await checker.check_async(body.text)
    return {"has_errors": result.has_errors, "errors": [...]}

CORS Configuration

from fastapi.middleware.cors import CORSMiddleware
import os

allowed_origins_env = os.getenv("ALLOWED_ORIGINS")
if allowed_origins_env:
    origins = [o.strip() for o in allowed_origins_env.split(",")]
    allow_credentials = True
else:
    origins = ["*"]
    allow_credentials = False

app.add_middleware(
    CORSMiddleware,
    allow_origins=origins,
    allow_credentials=allow_credentials,
    allow_methods=["*"],
    allow_headers=["*"],
)

Production Deployment

# Development with auto-reload
uvicorn app:app --reload --port 8000

# Production with Gunicorn
gunicorn app:app \
  -w 4 \
  -k uvicorn.workers.UvicornWorker \
  --bind 0.0.0.0:8000

Flask

Basic Setup

from flask import Flask, request, jsonify
from myspellchecker import SpellChecker

app = Flask(__name__)
checker = SpellChecker()

@app.route("/check", methods=["POST"])
def check_spelling():
    data = request.get_json()
    text = data.get("text", "")

    result = checker.check(text)

    return jsonify({
        "has_errors": result.has_errors,
        "errors": [
            {
                "text": e.text,
                "position": e.position,
                "suggestions": e.suggestions[:5],
            }
            for e in result.errors
        ],
    })

if __name__ == "__main__":
    app.run()

With Application Factory

from flask import Flask

def create_app():
    app = Flask(__name__)
    checker = SpellChecker()
    app.extensions["spellchecker"] = checker

    from . import routes
    app.register_blueprint(routes.bp)
    return app

# routes.py
from flask import Blueprint, current_app, request, jsonify

bp = Blueprint("spell", __name__)

@bp.route("/check", methods=["POST"])
def check():
    checker = current_app.extensions["spellchecker"]
    result = checker.check(request.json["text"])
    return jsonify({"has_errors": result.has_errors})

Django

As a Service

# services/spellcheck.py
from myspellchecker import SpellChecker

class SpellCheckService:
    _instance = None

    @classmethod
    def get_instance(cls):
        if cls._instance is None:
            cls._instance = SpellChecker()
        return cls._instance

    @classmethod
    def check(cls, text: str):
        return cls.get_instance().check(text)

View Example

# views.py
from django.http import JsonResponse
from django.views.decorators.http import require_POST
from django.views.decorators.csrf import csrf_exempt
import json

from .services.spellcheck import SpellCheckService

@csrf_exempt
@require_POST
def check_spelling(request):
    data = json.loads(request.body)
    result = SpellCheckService.check(data.get("text", ""))

    return JsonResponse({
        "has_errors": result.has_errors,
        "errors": [
            {"text": e.text, "suggestions": e.suggestions[:5]}
            for e in result.errors
        ],
    })

Django REST Framework

from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import serializers

class SpellCheckRequestSerializer(serializers.Serializer):
    text = serializers.CharField()

class SpellCheckView(APIView):
    def post(self, request):
        serializer = SpellCheckRequestSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)

        result = SpellCheckService.check(serializer.validated_data["text"])

        return Response({
            "has_errors": result.has_errors,
            "errors": [
                {"text": e.text, "position": e.position, "suggestions": e.suggestions[:5]}
                for e in result.errors
            ],
        })

WebSocket

FastAPI WebSocket

from fastapi import FastAPI, WebSocket
import json

app = FastAPI()
checker = SpellChecker()

@app.websocket("/ws/check")
async def websocket_check(websocket: WebSocket):
    await websocket.accept()
    try:
        while True:
            data = await websocket.receive_text()
            message = json.loads(data)
            result = await checker.check_async(message["text"])

            await websocket.send_json({
                "has_errors": result.has_errors,
                "errors": [
                    {"text": e.text, "suggestions": e.suggestions[:3]}
                    for e in result.errors
                ],
            })
    except Exception:
        pass

Celery

Task Definition

# tasks.py
from celery import Celery
from myspellchecker import SpellChecker

app = Celery("spellcheck")
checker = None

@app.task
def check_text(text: str) -> dict:
    global checker
    if checker is None:
        checker = SpellChecker()

    result = checker.check(text)
    return {
        "has_errors": result.has_errors,
        "error_count": len(result.errors),
        "errors": [
            {"text": e.text, "suggestions": e.suggestions[:5]}
            for e in result.errors
        ],
    }

# Usage
result = check_text.delay("မြန်မာနိုင်ငံ")
output = result.get()

Common Patterns

Error Handling

from myspellchecker.core.exceptions import MyanmarSpellcheckError

@app.post("/check")
async def check_spelling(request: CheckRequest):
    try:
        result = await checker.check_async(request.text)
        return {"status": "success", "result": {...}}
    except MyanmarSpellcheckError as e:
        return {"status": "error", "message": str(e)}, 500
    except Exception:
        return {
            "status": "degraded",
            "message": "Spell check unavailable",
            "original_text": request.text,
        }

Health Check

@app.get("/health")
async def health_check():
    try:
        result = checker.check("မြန်မာ")
        return {"status": "healthy", "checker": "ok"}
    except Exception as e:
        return {"status": "unhealthy", "error": str(e)}, 500

Redis Caching

import redis
import hashlib
import json

redis_client = redis.Redis()

def cached_check(text: str, ttl: int = 3600) -> dict:
    key = f"spell:{hashlib.md5(text.encode()).hexdigest()}"
    cached = redis_client.get(key)
    if cached:
        return json.loads(cached)

    result = checker.check(text)
    output = {
        "has_errors": result.has_errors,
        "errors": [{"text": e.text} for e in result.errors],
    }
    redis_client.setex(key, ttl, json.dumps(output))
    return output

Getting Started

Dictionary Building

Spell Checking

Grammar

Language Processing

AI-Powered Checking

Text Utilities

Performance & Scale

Customization

Integration & Deployment

Help & FAQ

FastAPI

Basic Endpoint

Testing with curl

Batch Endpoint

With Lifespan Management

CORS Configuration

Production Deployment

Flask

Basic Setup

With Application Factory

Django

As a Service

View Example

Django REST Framework

WebSocket

FastAPI WebSocket

Celery

Task Definition

Common Patterns

Error Handling

Health Check

Redis Caching

See Also

Getting Started

Dictionary Building

Spell Checking

Grammar

Language Processing

AI-Powered Checking

Text Utilities

Performance & Scale

Customization

Integration & Deployment

Help & FAQ

​FastAPI

​Basic Endpoint

​Testing with curl

​Batch Endpoint

​With Lifespan Management

​CORS Configuration

​Production Deployment

​Flask

​Basic Setup

​With Application Factory

​Django

​As a Service

​View Example

​Django REST Framework

​WebSocket

​FastAPI WebSocket

​Celery

​Task Definition

​Common Patterns

​Error Handling

​Health Check

​Redis Caching

​See Also

FastAPI

Basic Endpoint

Testing with curl

Batch Endpoint

With Lifespan Management

CORS Configuration

Production Deployment

Flask

Basic Setup

With Application Factory

Django

As a Service

View Example

Django REST Framework

WebSocket

FastAPI WebSocket

Celery

Task Definition

Common Patterns

Error Handling

Health Check

Redis Caching

See Also