Complete type annotations: 100% functions, 56.56% variables, eliminate 25+ Any types

[Copilot]

What do these changes do

Systematically improves type coverage across the codebase:

• Functions/methods: 100% coverage (725/725)
• Variables: 56.56% coverage (655/1158), up from 35.10% (+251 annotations)
• Type precision: Replaced 25+ Any types with library-specific types by investigating external source code

Key improvements:

• Module variables: 190+ annotations across 40+ files (constants, patterns, configs)
• Instance variables: 60+ annotations in model classes
• Precise types: Replaced Any with actual types from transformers, spacy, gensim, numpy, onnxruntime, sentencepiece

Example transformations:

# Before: Generic Any
class WangChanGLM:
    model: Any
    tokenizer: Any

# After: Precise types from transformers library
class WangChanGLM:
    model: PreTrainedModel
    tokenizer: PreTrainedTokenizerBase

# Before: Generic Any in numpy operations
class FastTextEncoder:
    embeddings: Any
    nn_session: Any
    
    def get_word_vector(self) -> Any: ...

# After: Specific numpy and ONNX types
class FastTextEncoder:
    embeddings: NDArray[np.float32]
    nn_session: InferenceSession
    
    def get_word_vector(self) -> NDArray[np.float32]: ...

Files with major improvements:

• wangchanberta/core.py: CamembertTokenizer, TokenClassificationPipeline
• coref/_fastcoref.py: Language, CorefModel
• spell/words_spelling_correction.py: NDArray types, InferenceSession
• augment/lm/fasttext.py: FastText, KeyedVectors
• translate/tokenization_small100.py: SentencePieceProcessor

What was wrong

Type annotations were incomplete:

• Only 35% of variables had type annotations
• Many attributes used generic Any instead of precise library types
• Missing type information reduced IDE support and type safety

How this fixes it

Variable annotations: Added 251 annotations to module constants, instance variables, and class attributes across 60+ files using proper types (dict[str, str], Pattern[str], etc.).

Precise types: Investigated external library source code (transformers, spacy, fastcoref, gensim, etc.) to replace Any with actual types. Used TYPE_CHECKING guards to avoid runtime overhead.

Dev branch integration: Merged latest dev changes (ThaiNNER refactoring) while maintaining type improvements.

Your checklist for this pull request

• Passed code styles and structures
• Passed code linting checks and unit test

Original prompt

Iterating to incrementally add type hints to submodules to reach 100% type hint coverage.

Strategy

• Start with small functions/classes and functions/classes that require few external dependencies.
• Moving gradually one function by one function, using analysis data from https://github.com/PyThaiNLP/pythainlp/tree/dev/build_tools/analysis/output as a guide/map. The data tells which submodule has functions with high priority.
• See these PRs and their comments for previous works on adding type hints:
  Add type hints to foundation submodules (tools, cli, corpus) #1262
  Add 100% type hints to pythainlp.tokenize submodule #1263
  Add type hints to core modules (stdlib-only) #1264
  Add type hints to core test suite functions #1265
  Add type hints and update docstrings for compact test suite modules #1266
  Add type hints to modules in extra test suite #1267
  Verify and fix type hints, annotations, and docstrings #1268
  Add type hints to noauto test suite modules #1269
  Align docstrings with type hints across codebase #1270

Goals

• Reach 100% type hints in the entire repo, make the package a typed package, while keeping maintainability.

Instructions

• Follow best practices and standard Python type hint patterns.
• Start small in the area with high confidence (like highly tested submodules or functions), then gradually grow one submodule at a time.
• Use mypy as main assistant.
  • mypy is already in "dev" extra dependencies in pyproject.toml
  • mypy configuration is in pyproject.toml
  • Sometimes mypy may report errors wrongly due to cache issues. Try to reset the cache.
• Use pyright, pyrefly, and pytype for second opinions.
• Required dependencies for each test suite are in pyproject.toml. Install them to avoid errors. See https://github.com/PyThaiNLP/pythainlp/blob/dev/tests/README.md
• Use native type in type hint (list, tuple, .. instead of List, Tuple, ..)
• Do not use A | B style Union, use full Union[] instead.
• We want to keep compatibility with Python 3.9 strict and allow type inspection tools to work correctly.
• When insert typing imports, put it in appropriate location and order
• Use "if TYPE_CHECKING import" block when possible.
• When reordering the imports, beware of circular import. Read comments near imports to get more information.
• Remove unused imports
• Do not allow the use of assert in production code (it is only allowed for testing and debugging).
• Try to fix the type, the scope logic, or do the casting, before putting #type: ignore comment.
• When dealing with types from external libraries:
  • Check if type information is provided (maybe through stubs). If it is, cast wrapper may not necessary.
  • If return type is not provided, may be it is appropriate to use # type: ignore[no-any-return] annotation for clarity.
  • Analyse source code of external libraries to validate correct types
• Recheck necessity when do casting.
• Recheck necessity of # noqa: and # type: ignore
• Provide type stubs as necessary.
• After changes for type hints, recheck for functionality correctness.
• Recheck docstring and documentation consistency with the code; They should match the updated type hints.
• Recheck formatting with ruff
• Do another code review
• Address code review feedback

---

✨ Let Copilot coding agent set things up for you — coding agent works faster and does higher quality work when set up for your repo.

[coveralls]

coverage: 65.227% (-0.5%) from 65.703%
when pulling c382092 on copilot/add-type-hints-to-submodules-one-more-time
into 0eaff7f on dev.

[sonarqubecloud]

Quality Gate passed

Issues
13 New issues
0 Accepted issues

Measures
0 Security Hotspots
0.0% Coverage on New Code
1.9% Duplication on New Code

See analysis details on SonarQube Cloud