mirror of
https://github.com/hwchase17/langchain.git
synced 2026-07-12 19:31:24 +00:00
fd822b07c0
## Summary - Moves `nltk`, `spacy`, `sentence-transformers`, and `konlpy` imports back inside class constructors/functions so they are only loaded when the respective splitter is actually instantiated - Adds a subprocess-based regression test to verify no heavy packages are imported at `langchain_text_splitters` load time ## Why PR #32325 moved these optional dependency imports to module-level `try/except` blocks (to satisfy ruff's `PLC0415` rule). Since `__init__.py` imports all four splitter modules, this caused `import langchain_text_splitters` to eagerly load all optional heavy packages, resulting in: - A PyTorch NVML warning (`UserWarning: Can't initialize NVML`) on non-GPU machines - A ~650MB memory spike on import (74MB → 736MB), vs ~50MB in 0.3.x The fix restores the lazy import pattern with `# noqa: PLC0415` to suppress the linter rule, which is the correct trade-off when a dependency has high instantiation cost. ## Review notes - The `PLC0415` suppressions are intentional — these are optional heavy dependencies that should never be loaded unless the user explicitly instantiates the splitter class - The regression test uses a subprocess for proper isolation (the test file itself imports `langchain_text_splitters` at the top, so `sys.modules` checks within the same process would not reflect a clean import state) Fixes #35437. > **AI disclaimer:** This PR was developed with assistance from Claude Code (Anthropic AI). --------- Co-authored-by: AshwathB-debug <ashwathbalaji04@gmail.com> Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com> Co-authored-by: Mason Daugherty <github@mdrxy.com>
84 lines
2.7 KiB
Python
84 lines
2.7 KiB
Python
"""NLTK text splitter."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import TYPE_CHECKING, Any
|
|
|
|
from typing_extensions import override
|
|
|
|
from langchain_text_splitters.base import TextSplitter
|
|
|
|
if TYPE_CHECKING:
|
|
from collections.abc import Callable
|
|
|
|
|
|
class NLTKTextSplitter(TextSplitter):
|
|
"""Splitting text using NLTK package."""
|
|
|
|
def __init__(
|
|
self,
|
|
separator: str = "\n\n",
|
|
language: str = "english",
|
|
*,
|
|
use_span_tokenize: bool = False,
|
|
**kwargs: Any,
|
|
) -> None:
|
|
"""Initialize the NLTK splitter.
|
|
|
|
Args:
|
|
separator: The separator to use when combining splits.
|
|
language: The language to use.
|
|
use_span_tokenize: Whether to use `span_tokenize` instead of
|
|
`sent_tokenize`.
|
|
|
|
Raises:
|
|
ImportError: If NLTK is not installed.
|
|
ValueError: If `use_span_tokenize` is `True` and separator is not `''`.
|
|
"""
|
|
super().__init__(**kwargs)
|
|
self._separator = separator
|
|
if use_span_tokenize and self._separator:
|
|
msg = "When use_span_tokenize is True, separator should be ''"
|
|
raise ValueError(msg)
|
|
try:
|
|
import nltk # noqa: PLC0415,F401
|
|
except ImportError as err:
|
|
msg = "NLTK is not installed, please install it with `pip install nltk`."
|
|
raise ImportError(msg) from err
|
|
if use_span_tokenize:
|
|
self._tokenizer = self._span_tokenizer(language)
|
|
else:
|
|
self._tokenizer = self._sent_tokenizer(language)
|
|
|
|
@staticmethod
|
|
def _sent_tokenizer(language: str) -> Callable[[str], list[str]]:
|
|
import nltk # noqa: PLC0415
|
|
|
|
return lambda text: nltk.tokenize.sent_tokenize(text, language)
|
|
|
|
@staticmethod
|
|
def _span_tokenizer(language: str) -> Callable[[str], list[str]]:
|
|
import nltk # noqa: PLC0415
|
|
|
|
tokenizer = nltk.tokenize._get_punkt_tokenizer(language) # noqa: SLF001
|
|
|
|
def _tokenize(text: str) -> list[str]:
|
|
spans = list(tokenizer.span_tokenize(text))
|
|
splits = []
|
|
for i, (start, end) in enumerate(spans):
|
|
if i > 0:
|
|
prev_end = spans[i - 1][1]
|
|
sentence = text[prev_end:start] + text[start:end]
|
|
else:
|
|
sentence = text[start:end]
|
|
splits.append(sentence)
|
|
return splits
|
|
|
|
return _tokenize
|
|
|
|
@override
|
|
def split_text(self, text: str) -> list[str]:
|
|
# First we naively split the large input into a bunch of smaller ones.
|
|
splits = self._tokenizer(text)
|
|
return self._merge_splits(splits, self._separator)
|