PyEnchant

https://pyenchant.github.io/pyenchant/
Admin
PyEnchant is a spellchecking library for Python that provides a Pythonic interface to the Enchant...
Tokens:19,550
Snippets:229
Trust Score:9.7
Update:6 months ago
Show doc for...
Tokens:
Raw
### Install Enchant on FreeBSD

Source: https://pyenchant.github.io/pyenchant/_sources/install.rst.txt

Use the pkg package manager to install the Enchant library.

```console
pkg install enchant-2
```

--------------------------------

### Basic Text Tokenization with PyEnchant

Source: https://pyenchant.github.io/pyenchant/_sources/tutorial.rst.txt

Demonstrates how to get a tokenizer for a specific language and use it to split text into words and their starting positions. The tokenizer returns tuples of (WORD, POS).

```python
from enchant.tokenize import get_tokenizer

tknzr = get_tokenizer("en_US")
print(tknzr)
print([w for w in tknzr("this is some simple text")])
```

--------------------------------

### Install enchant-2 on FreeBSD

Source: https://pyenchant.github.io/pyenchant/install.html

Use pkg to install the enchant-2 C library on FreeBSD systems.

```bash
pkg install enchant-2

```

--------------------------------

### Start Local Website Development Server

Source: https://pyenchant.github.io/pyenchant/contributing.html

Run tox with the 'website-dev' environment to start a local development server. This process watches for changes in the 'website/' directory and automatically refreshes connected browsers.

```bash
tox -e website-dev
```

--------------------------------

### Install and Use tbump for Version Bumping

Source: https://pyenchant.github.io/pyenchant/contributing.html

Install tbump using pipx and then use it to automate the process of bumping the version number in setup.cfg and publishing a new release to PyPI. Replace '<new-version>' with the desired version.

```bash
pipx install tbump
```

```bash
tbump <new-version>
```

--------------------------------

### Install Enchant on macOS via Homebrew

Source: https://pyenchant.github.io/pyenchant/_sources/install.rst.txt

Update Homebrew and install the Enchant library.

```console
brew update
brew install enchant
```

--------------------------------

### Install enchant on macOS using Homebrew

Source: https://pyenchant.github.io/pyenchant/install.html

Update Homebrew and install the enchant C library on macOS.

```bash
brew update
brew install enchant

```

--------------------------------

### Install PyEnchant without binary wheel on Windows

Source: https://pyenchant.github.io/pyenchant/install.html

Use pip to install PyEnchant on Windows, explicitly excluding the pre-compiled binary wheel to allow for custom enchant C library installation via MinGW.

```bash
pip install --no-binary pyenchant

```

--------------------------------

### Install PyEnchant without binary wheels

Source: https://pyenchant.github.io/pyenchant/_sources/install.rst.txt

Force pip to build from source, useful when using MinGW on Windows.

```console
pip install --no-binary pyenchant
```

--------------------------------

### Check Dictionary Availability

Source: https://pyenchant.github.io/pyenchant/api/enchant.html

Use `dict_exists()` to verify if a dictionary for a specific language tag is installed and available.

```python
>>> d.dict_exists("en_US")
True
```

--------------------------------

### Install Enchant on macOS via MacPorts

Source: https://pyenchant.github.io/pyenchant/_sources/install.rst.txt

Install the enchant2 port with specific speller variants.

```bash
sudo port install enchant2 +aspell +hunspell +applespell
```

--------------------------------

### List Enchant languages and providers

Source: https://pyenchant.github.io/pyenchant/_sources/install.rst.txt

Use the Broker API to inspect available language providers and installed dictionaries.

```python
import enchant
broker = enchant.Broker()
broker.describe()
broker.list_languages()
```

--------------------------------

### Basic PyEnchant Usage

Source: https://pyenchant.github.io/pyenchant/_sources/index.rst.txt

Demonstrates basic spellchecking and suggestion functionality using PyEnchant. Requires the 'enchant' library to be installed.

```python
>>> import enchant
>>> d = enchant.Dict("en_US")
>>> d.check("Hello")
True
>>> d.check("Helo")
False
>>> d.suggest("Helo")
['He lo', 'He-lo', 'Hello', 'Helot', 'Help', 'Halo', 'Hell', 'Held', 'Helm', 'Hero', "He'll"]
```

--------------------------------

### Basic Spell Checking with pyenchant

Source: https://pyenchant.github.io/pyenchant/api/enchant.html

Demonstrates creating a dictionary for US English, checking word correctness, and getting spelling suggestions. Ensure the 'en_US' dictionary is available on your system.

```python
>>> import enchant
>>> d = enchant.Dict("en_US")   # create dictionary for US English
>>> d.check("enchant")
True
>>> d.check("enchnt")
False
>>> d.suggest("enchnt")
['enchant', 'enchants', 'enchanter', 'penchant', 'incant', 'enchain', 'enchanted']
```

--------------------------------

### Install enchant2 with MacPorts variants

Source: https://pyenchant.github.io/pyenchant/install.html

Install the enchant2 package with specific speller variants like aspell, hunspell, and applespell using MacPorts.

```bash
sudo port install enchant2 +aspell +hunspell +applespell

```

--------------------------------

### Tokenize text with get_tokenizer

Source: https://pyenchant.github.io/pyenchant/tutorial.html

Splits text into words and their starting positions using a language-specific tokenizer.

```python
>>> from enchant.tokenize import get_tokenizer
>>> tknzr = get_tokenizer("en_US")
>>> tknzr
<class enchant.tokenize.en.tokenize at 0x2aaaaab531d0>
>>> [w for w in tknzr("this is some simple text")]
[('this', 0), ('is', 5), ('some', 8), ('simple', 13), ('text', 20)]
```

--------------------------------

### Run CI Checks Locally with Tox

Source: https://pyenchant.github.io/pyenchant/contributing.html

Execute CI checks locally using tox with specified environments. Replace 'pyXY' with your current Python version. Ensure an en_US dictionary is installed for tests.

```bash
tox -e website -e linters -e pyXY
```

--------------------------------

### Tokenize with Chunkers and Filters

Source: https://pyenchant.github.io/pyenchant/api/enchant.tokenize.html

Use a tokenizer with custom chunkers (like HTMLChunker) and filters (like URLFilter) to process text. This example demonstrates spellchecking an HTML document by excluding tags and URLs.

```python
tknzr = get_tokenizer("en_US",(HTMLChunker,),(URLFilter,WikiWordFilter)))

text = "<html><body>the url is http://example.com</body></html>"
for (word,pos) in tknzer(text):
    ...check each word and react accordingly...

```

--------------------------------

### Get Spelling Suggestions

Source: https://pyenchant.github.io/pyenchant/_sources/tutorial.rst.txt

Use the 'suggest' method of a dictionary object to get a list of potential correct spellings for a misspelled word. Suggestions are ordered by likelihood.

```python
d.suggest("Helo")
```

--------------------------------

### Get Tokenizer

Source: https://pyenchant.github.io/pyenchant/api/enchant.tokenize.html

Locates and returns an appropriate tokenizer based on a language tag, with options for custom chunkers and filters.

```APIDOC
## Function: get_tokenizer

### Description
Locates an appropriate tokenizer by language tag. It tries importing tokenizer modules named after the language tag (e.g., "en_AU.py", "en.py"). If the language tag is `None`, a default English tokenizer is returned.

### Parameters
- `_tag` (str, optional): The language tag to identify the tokenizer. Defaults to `None`.
- `_chunkers` (Iterable[Type[Chunker] | Type[Filter]], optional): A list of chunker classes to apply.
- `_filters` (Iterable[Type[Filter]], optional): A list of filter classes to apply.

### Returns
A tokenizer object (`tokenize`).

### Raises
`TokenizerNotFoundError`: If a suitable tokenizer function cannot be found.

### Usage
Used to dynamically load tokenizers based on language settings and apply custom processing rules.
```

--------------------------------

### Get Tokenizer Function

Source: https://pyenchant.github.io/pyenchant/api/enchant.tokenize.html

Obtain a language-specific tokenizer function. The tokenizer returns tuples of (word, position) and has methods to manage the current position.

```python
tknzr = get_tokenizer("en_US")
for (word,pos) in tknzr("text to be tokenized goes here")
    do_something(word)

```

--------------------------------

### Describe and List Dictionaries with Broker

Source: https://pyenchant.github.io/pyenchant/_sources/tutorial.rst.txt

Shows how to use the describe and list_dicts methods of an enchant.Broker to view available providers and dictionaries.

```python
>>> b = enchant.Broker()
>>> b.describe()
[<Enchant: Aspell Provider>, <Enchant: Myspell Provider>, <Enchant: Ispell Provider>]
>>> b.list_dicts()
[('en', <Enchant: Aspell Provider>), ('en_CA', <Enchant: Aspell Provider>), ('en_GB', <Enchant: Aspell Provider>), ('en_US', <Enchant: Aspell Provider>), ('eo', <Enchant: Aspell Provider>), ('fr', <Enchant: Aspell Provider>), ('fr_CH', <Enchant: Aspell Provider>), ('fr_FR', <Enchant: Aspell Provider>)]
```

--------------------------------

### List available languages and providers with PyEnchant

Source: https://pyenchant.github.io/pyenchant/install.html

Import the enchant library and use the Broker to describe available providers and list supported languages. This is useful for checking dictionary availability.

```python
import enchant
broker = enchant.Broker()
broker.describe()
broker.list_languages()

```

--------------------------------

### Access Default Broker and Dict

Source: https://pyenchant.github.io/pyenchant/_sources/tutorial.rst.txt

Illustrates how to access the default enchant.Broker object and create a dictionary using it, showing that top-level functions use this default broker.

```python
>>> enchant._broker
<enchant.Broker object at 0x2aaaabdff590>
>>> d = enchant.Dict("en_US")
>>> d._broker
<enchant.Broker object at 0x2aaaabdff590>
```

--------------------------------

### Initializing an Enchant Broker

Source: https://pyenchant.github.io/pyenchant/_sources/tutorial.rst.txt

Shows the basic instantiation of an `enchant.Broker` object, which manages the creation and existence checks of dictionaries.

```python
import enchant

b = enchant.Broker()
```

--------------------------------

### Interact with Enchant Broker

Source: https://pyenchant.github.io/pyenchant/_sources/tutorial.rst.txt

Demonstrates basic interactions with an enchant.Broker object, such as checking dictionary existence and listing available languages.

```python
>>> b
<enchant.Broker object at 0x2aaaabdff810>
>>> b.dict_exists("en_US")
True
>>> b.dict_exists("fake")
False
>>> b.list_languages()
['en', 'en_CA', 'en_GB', 'en_US', 'eo', 'fr', 'fr_CH', 'fr_FR']
>>> d = b.request_dict("en_US")
>>> d
<enchant.Dict object at 0x2aaaabdff8d0>
```

--------------------------------

### Create and Use Dictionary Object

Source: https://pyenchant.github.io/pyenchant/_sources/tutorial.rst.txt

Instantiate a dictionary for a specific language (e.g., 'en_US') and use its 'check' method to verify word spellings. Returns True for correctly spelled words and False otherwise.

```python
import enchant
d = enchant.Dict("en_US")
d.check("Hello")
d.check("Helo")
```

--------------------------------

### Basic PyEnchant Usage

Source: https://pyenchant.github.io/pyenchant/index.html

Demonstrates basic spellchecking and word suggestion using PyEnchant. Ensure the 'en_US' dictionary is available.

```python
>>> import enchant
>>> d = enchant.Dict("en_US")
>>> d.check("Hello")
True
>>> d.check("Helo")
False
>>> d.suggest("Helo")
['He lo', 'He-lo', 'Hello', 'Helot', 'Help', 'Halo', 'Hell', 'Held', 'Helm', 'Hero', "He'll"]
>>>

```

--------------------------------

### Broker Configuration

Source: https://pyenchant.github.io/pyenchant/api/enchant.html

Methods for managing broker parameters and library configuration.

```APIDOC
## enchant.get_enchant_version()

### Description
Get the version string for the underlying enchant library.

### Response
- **str** - Version string.

## enchant.get_user_config_dir()

### Description
Return the path used by Enchant providers to look for custom dictionaries.

### Response
- **str** - Directory path.
```

--------------------------------

### Create a Personal Word List dictionary

Source: https://pyenchant.github.io/pyenchant/tutorial.html

Load a custom word list from a file to use as a dictionary object.

```python
>>> pwl = enchant.request_pwl_dict("mywords.txt")
```

--------------------------------

### Initialize SpellChecker with Filters

Source: https://pyenchant.github.io/pyenchant/tutorial.html

Initialize SpellChecker with filters to ignore specific word forms like emails or URLs. Pass a list of filter classes to the filters keyword argument.

```python
from enchant.checker import SpellChecker
from enchant.tokenize import EmailFilter, URLFilter
chkr = SpellChecker("en_US",filters=[EmailFilter,URLFilter])

```

--------------------------------

### PyEnchant Module Overview

Source: https://pyenchant.github.io/pyenchant/api/enchant.html

Overview of the core modules available in the PyEnchant library.

```APIDOC
## PyEnchant Modules

### Description
PyEnchant is organized into several key modules for spellchecking and text processing.

### Modules
- **enchant**: Core access to the enchant spellchecking library, including `Broker` and `Dict` classes for dictionary management.
- **enchant.checker**: Provides the `SpellChecker` class for high-level spellchecking operations.
- **enchant.errors**: Contains custom error classes such as `DictNotFoundError` and `DefaultLanguageNotFoundError`.
- **enchant.tokenize**: Contains classes and functions for string tokenization, including filters for URLs, emails, and HTML.
- **enchant.utils**: Miscellaneous utilities including `levenshtein` distance calculation and language detection.
```

--------------------------------

### Combine Language and Personal Word List Dictionaries

Source: https://pyenchant.github.io/pyenchant/_sources/tutorial.rst.txt

Create a dictionary object that combines a standard language dictionary (e.g., 'en_US') with a personal word list file ('mywords.txt'). This allows checking against both sources.

```python
d2 = enchant.DictWithPWL("en_US","mywords.txt")
d2.check("Hello")
```

--------------------------------

### Handle dictionary initialization errors

Source: https://pyenchant.github.io/pyenchant/tutorial.html

An Error is raised if no language tag is provided and the default language cannot be determined.

```python
>>> d = enchant.Dict()
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
  File "enchant/__init__.py", line 467, in __init__
    raise Error(err)
enchant.Error: No tag specified and default language could not be determined.
```

--------------------------------

### Accessing Dictionary Provider Information

Source: https://pyenchant.github.io/pyenchant/_sources/tutorial.rst.txt

Demonstrates how to retrieve information about the spellchecking provider used by a PyEnchant dictionary object. This includes the provider's name, description, and the path to its shared library.

```python
import enchant

d = enchant.Dict("en_US")
print(d.provider)
print(d.provider.name)
print(d.provider.desc)
print(d.provider.file)
```

--------------------------------

### Set Provider Ordering for Languages

Source: https://pyenchant.github.io/pyenchant/_sources/tutorial.rst.txt

Demonstrates how to configure the order in which spell-checking providers are used for specific languages using set_ordering.

```python
>>> b = enchant.Broker()
>>> b.set_ordering("en_US","myspell,aspell")
>>> b.set_ordering("*","aspell,myspell")
>>> b.request_dict("en_US").provider
<Enchant: Myspell Provider>
>>> b.request_dict("en_GB").provider
<Enchant: Aspell Provider>
```

--------------------------------

### List Available Dictionaries

Source: https://pyenchant.github.io/pyenchant/api/enchant.html

Retrieves a list of all dictionaries available to the broker, including their language tags and provider descriptions.

```python
>>> broker.list_dicts()
[('en_US', ProviderDesc(name='i', name_long='Internal', ...))]
```

--------------------------------

### Manage Dictionaries with Broker

Source: https://pyenchant.github.io/pyenchant/tutorial.html

Use the Broker object to check for dictionary existence, list available languages, and request specific dictionary instances.

```python
>>> b = enchant.Broker()
>>> b
<enchant.Broker object at 0x2aaaabdff810>
>>> b.dict_exists("en_US")
True
>>> b.dict_exists("fake")
False
>>> b.list_languages()
['en', 'en_CA', 'en_GB', 'en_US', 'eo', 'fr', 'fr_CH', 'fr_FR']
>>> d = b.request_dict("en_US")
>>> d
<enchant.Dict object at 0x2aaaabdff8d0>
```

--------------------------------

### Request a Personal Word List Dictionary

Source: https://pyenchant.github.io/pyenchant/api/enchant.html

Creates a `Dict` object that uses a personal word list file. Each word in the file should be on a new line.

```python
>>> pwl_dict = broker.request_pwl_dict("/path/to/my/custom.txt")
```

--------------------------------

### Combine language dictionary and personal word list

Source: https://pyenchant.github.io/pyenchant/tutorial.html

Use the DictWithPWL class to check words against both a standard language dictionary and a custom file.

```python
>>> d2 = enchant.DictWithPWL("en_US","mywords.txt")
>>> d2.check("Hello")
True
```

--------------------------------

### Create Personal Word List Dictionary

Source: https://pyenchant.github.io/pyenchant/_sources/tutorial.rst.txt

Instantiate a dictionary object that uses a personal word list file (e.g., 'mywords.txt') for spell checking. Words in this file are considered correctly spelled.

```python
pwl = enchant.request_pwl_dict("mywords.txt")
```

--------------------------------

### PyPWL Class Methods

Source: https://pyenchant.github.io/pyenchant/api/enchant.pypwl.html

Methods for managing a pure-python personal word list.

```APIDOC
## PyPWL Class

### Description
Pure-python implementation of Personal Word List dictionary. This class emulates the PWL objects provided by PyEnchant, but implemented purely in python.

### Methods

#### `add(_word: str) -> None`
Add a word to the user’s personal dictionary. For a PWL, this means appending it to the file.

#### `add_to_pwl(_word: str) -> None`
Add a word to the user’s personal dictionary. For a PWL, this means appending it to the file.

#### `add_to_session(_word: str) -> None`
Add a word to the session list.

#### `check(_word: str) -> bool`
Check spelling of a word.
This method takes a word in the dictionary language and returns True if it is correctly spelled, and False otherwise.

#### `is_added(_word: str) -> bool`
Check whether a word is in the personal word list.

#### `is_removed(_word: str) -> bool`
Check whether a word is in the personal exclude list.

#### `remove(_word: str) -> None`
Add a word to the user’s personal exclude list.

#### `store_replacement(_mis: str, _cor: str) -> None`
Store a replacement spelling for a miss-spelled word.
This method makes a suggestion to the spellchecking engine that the miss-spelled word mis is in fact correctly spelled as cor. Such a suggestion will typically mean that cor appears early in the list of suggested spellings offered for later instances of mis.

#### `suggest(_word: str) -> List[str]`
Suggest possible spellings for a word.
This method tries to guess the correct spelling for a given word, returning the possibilities in a list.
```

--------------------------------

### Handle Default Language Determination Failure

Source: https://pyenchant.github.io/pyenchant/_sources/tutorial.rst.txt

Demonstrates the error raised when attempting to create a dictionary without a specified language tag and the system's default language cannot be determined.

```python
d = enchant.Dict()
# This will raise an enchant.Error if the default language cannot be determined.
```

--------------------------------

### Manage dictionaries with top-level functions

Source: https://pyenchant.github.io/pyenchant/tutorial.html

Use enchant module functions to verify dictionary existence, request objects, and list available languages.

```python
>>> enchant.dict_exists("fake")
False
>>> enchant.dict_exists("en_US")
True
>>> d = enchant.request_dict("en_US")
>>> d
<enchant.Dict object at 0x2aaaabdffa50>cl
>>> enchant.list_languages()
['en', 'en_CA', 'en_GB', 'en_US', 'eo', 'fr', 'fr_CH', 'fr_FR']
```

--------------------------------

### Request a Dictionary Object

Source: https://pyenchant.github.io/pyenchant/api/enchant.html

Obtain a `Dict` object for a specified language tag. If no tag is provided, it attempts to determine the current system language.

```python
>>> dict_obj = broker.request_dict("fr_FR")
```

--------------------------------

### Set Dictionary Ordering Preferences

Source: https://pyenchant.github.io/pyenchant/api/enchant.html

Specifies the order in which dictionaries should be tried for a given language tag. This allows customization of spellchecking behavior.

```python
>>> broker.set_ordering("en_US", "ispell")
```

--------------------------------

### Verify Top-Level Functions Use Default Broker

Source: https://pyenchant.github.io/pyenchant/_sources/tutorial.rst.txt

Confirms that top-level enchant module functions like request_dict and dict_exists are bound to the default broker instance.

```python
>>> enchant._broker
<enchant.Broker object at 0x2aaaabdff590>
>>> enchant.request_dict.im_self
<enchant.Broker object at 0x2aaaabdff590>
>>> enchant.dict_exists.im_self
<enchant.Broker object at 0x2aaaabdff590>
```

--------------------------------

### List Available Languages

Source: https://pyenchant.github.io/pyenchant/api/enchant.html

Returns a list of language tags for which dictionaries are currently available.

```python
>>> broker.list_languages()
['en_US', 'fr_FR', 'de_DE']
```

--------------------------------

### pypwl Module API

Source: https://pyenchant.github.io/pyenchant/api/enchant.checker.html

Pure-Python personal word list implementation in the style of Enchant.

```APIDOC
## pypwl Module API

### Description
Provides a pure-Python implementation of a personal word list, compatible with Enchant.

### Classes
- **PyPWL**: Represents a personal word list.
- **Trie**: A Trie data structure, often used for efficient word storage.
```

--------------------------------

### Initialize Dict without a language tag

Source: https://pyenchant.github.io/pyenchant/tutorial.html

Initialize a Dict object without arguments to attempt automatic language detection.

```python
>>> d = enchant.Dict()
>>> d.tag
'en_AU'
>>> print(d.tag)
en_AU
```

--------------------------------

### enchant.utils Module

Source: https://pyenchant.github.io/pyenchant/api/enchant.utils.html

Utilities for the enchant spellchecking package.

```APIDOC
## enchant.utils: Misc utilities for the enchant package

### Description
This module provides miscellaneous utilities for use with the enchant spellchecking package. Currently available functionality includes:

* functions for dealing with locale/language settings
* ability to list supporting data files (win32 only)
* functions for bundling supporting data files from a build

### Functions

#### enchant.utils.get_default_language

##### Description
Determine the user’s default language, if possible.
This function uses the `locale` module to try to determine the user’s preferred language. The return value is as follows:

* if a locale is available for the LC_MESSAGES category, that language is used
* if a default locale is available, that language is used
* if the keyword argument default is given, it is used
* if nothing else works, None is returned

Note that determining the user’s language is in general only possible if they have set the necessary environment variables on their system.

##### Signature
`get_default_language(_default : str | None = None_) → str | None`

#### enchant.utils.levenshtein

##### Description
Calculate the Levenshtein distance between two strings.
This is straight from Wikipedia.

##### Signature
`levenshtein(_s1 : str_, _s2 : str_) → int`

#### enchant.utils.trim_suggestions

##### Description
Trim a list of suggestions to a maximum length.
If the list of suggested words is too long, you can use this function to trim it down to a maximum length. It tries to keep the “best” suggestions based on similarity to the original word.
If the optional calcdist argument is provided, it must be a callable taking two words and returning the distance between them. It will be used to determine which words to retain in the list. The default is a simple Levenshtein distance.

##### Signature
`trim_suggestions(_word : str_, _suggs : Iterable[str]_, _maxlen : int_, _calcdist : Callable[[str, str], int] = None_) → List[str]`
```

--------------------------------

### Basic Tokenizer

Source: https://pyenchant.github.io/pyenchant/api/enchant.tokenize.html

A simple tokenizer that splits text into words based on whitespace and removes basic punctuation.

```APIDOC
## Tokenizer: basic_tokenize

### Description
Performs very basic word-finding by splitting text into words based on whitespace boundaries and removing basic punctuation from the start and end of each word.

### Usage
Suitable for simple text processing where complex tokenization rules are not required.
```

--------------------------------

### Dictionary Management

Source: https://pyenchant.github.io/pyenchant/api/enchant.html

Methods for managing dictionaries and their preferences.

```APIDOC
## Set Dictionary Ordering

### Description
Specifies the preferred dictionaries for a given language or as a default.

### Method
Not explicitly defined, likely a method of a Broker object.

### Endpoint
N/A (Python method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
broker.set_ordering("en_US", "aspell,myspell,ispell")
broker.set_ordering("*", "aspell,myspell") # Default for all languages
```

### Response
#### Success Response (200)
None (modifies internal state)

#### Response Example
None
```

```APIDOC
## Set Parameter

### Description
Sets the value of a named parameter on this broker. Parameters provide runtime information to provider backends.

### Method
`set_param(_name : str_, _value : Any_)`

### Endpoint
N/A (Python method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
broker.set_param("ignore_case", True)
```

### Response
#### Success Response (200)
None

#### Response Example
None

### Warning
This method does not work when using the Enchant C library version 2.0 and above.
```

--------------------------------

### Create Dictionary with Default Language

Source: https://pyenchant.github.io/pyenchant/_sources/tutorial.rst.txt

Create a dictionary object without specifying a language tag. PyEnchant attempts to determine the current system language. If unsuccessful, an 'enchant.Error' is raised.

```python
d = enchant.Dict()
print(d.tag)
```

--------------------------------

### Wrap Tokenizer

Source: https://pyenchant.github.io/pyenchant/api/enchant.tokenize.html

Combines two tokenizer functions, passing the output of the first through the second.

```APIDOC
## Function: wrap_tokenizer

### Description
Wraps one tokenizer inside another. This function takes two tokenizer functions, `tk1` and `tk2`, and returns a new tokenizer function that passes the output of `tk1` through `tk2` before yielding it.

### Parameters
- `_tk1` (Type[tokenize] | Filter_): The first tokenizer function.
- `_tk2` (Type[tokenize] | Filter_): The second tokenizer function.

### Returns
A new `Filter` object representing the combined tokenizer.

### Usage
Allows for chaining tokenization processes, applying sequential transformations to the text.
```

--------------------------------

### DictWithPWL Class

Source: https://pyenchant.github.io/pyenchant/api/enchant.html

Dictionary object with separately managed personal word list (PWL) and personal exclude list (PEL).

```APIDOC
## Initialize DictWithPWL

### Description
Initializes a dictionary with separately managed personal word list and personal exclude list.

### Method
`enchant.DictWithPWL(_tag : str_, _pwl : str = None_, _pel : str = None_, _broker : Broker = None_)`

### Endpoint
N/A (Python class constructor)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
# Using default PWL and PEL
dict_pwl = enchant.DictWithPWL("en_US")

# Specifying custom files for PWL and PEL
dict_custom = enchant.DictWithPWL("en_US", pwl="my_words.txt", pel="my_excludes.txt")

# Using in-memory lists
dict_memory = enchant.DictWithPWL("en_US", pwl=None, pel=None)
```

### Response
#### Success Response (200)
- **DictWithPWL object** - An instance of the DictWithPWL class.

#### Response Example
```json
// No direct JSON response, returns an object instance
```

### Note
As of version 1.4.0, enchant manages a per-user pwl and exclude list. This class is now only needed if you want to explicitly maintain a separate word list in addition to the default one. If `pwl` or `pel` are None, an in-memory word list is used.
```

```APIDOC
## Add Word to Associated PWL

### Description
Adds a word to the associated personal word list and saves it to disk.

### Method
`add(_word : str_) → None`

### Endpoint
N/A (Python method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
dict_pwl.add("customword")
```

### Response
#### Success Response (200)
None

#### Response Example
None
```

```APIDOC
## Add Word to Associated PWL (alternative)

### Description
Adds a word to the associated personal word list and saves it to disk. This is an alternative method name for adding to the PWL.

### Method
`add_to_pwl(_word : str_) → None`

### Endpoint
N/A (Python method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
dict_pwl.add_to_pwl("customword")
```

### Response
#### Success Response (200)
None

#### Response Example
None
```

```APIDOC
## Check Spelling (with PWL/PEL)

### Description
Checks the spelling of a word, considering both the main dictionary and the personal word list (PWL) and personal exclude list (PEL).

### Method
`check(_word : str_) → bool`

### Endpoint
N/A (Python method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
dict_pwl.check("customword")
```

### Response
#### Success Response (200)
- **bool** (bool) - True if the word is spelled correctly (found in dictionary or PWL, and not in PEL), False otherwise.

#### Response Example
```json
true
```
```

--------------------------------

### Broker API Methods

Source: https://pyenchant.github.io/pyenchant/api/enchant.html

Methods available on the Broker object for managing and querying language dictionaries.

```APIDOC
## dict_exists(tag)

### Description
Checks whether a dictionary is available for the specified language tag.

### Parameters
#### Query Parameters
- **tag** (str) - Required - The language tag (e.g., 'en_US').

### Response
#### Success Response (200)
- **result** (bool) - True if dictionary exists, False otherwise.

---

## request_dict(tag)

### Description
Constructs and returns a Dict object for the requested language.

### Parameters
#### Query Parameters
- **tag** (str) - Optional - The language tag. If None, attempts to determine current language.

### Response
#### Success Response (200)
- **dict** (Dict) - A dictionary object for the specified language.

---

## list_languages()

### Description
Returns a list of all language tags for which dictionaries are currently available.

### Response
#### Success Response (200)
- **languages** (List[str]) - A list of available language tags.
```

--------------------------------

### Unit Tokenizer

Source: https://pyenchant.github.io/pyenchant/api/enchant.tokenize.html

A tokenizer that yields the entire input text as a single token.

```APIDOC
## Tokenizer: unit_tokenize

### Description
A tokenizer class that yields the input text as a single token.

### Usage
Useful when the entire input string needs to be treated as one unit.
```

--------------------------------

### Tokenization with HTMLChunker in PyEnchant

Source: https://pyenchant.github.io/pyenchant/_sources/tutorial.rst.txt

Shows how to use `HTMLChunker` with `get_tokenizer` to exclude HTML tags and their content from the tokenized output. This is useful when processing text containing markup.

```python
from enchant.tokenize import get_tokenizer, HTMLChunker

tknzr = get_tokenizer("en_US")
print([w for w in tknzr("this is <span class='important'>really important</span> text")])

tknzr = get_tokenizer("en_US", chunkers=(HTMLChunker,))
print([w for w in tknzr("this is <span class='important'>really important</span> text")])
```

--------------------------------

### Dictionary Object Methods

Source: https://pyenchant.github.io/pyenchant/api/enchant.html

Core methods for interacting with dictionary objects for spell checking.

```APIDOC
## Check Spelling

### Description
Checks if a word is spelled correctly according to the dictionary.

### Method
`check(_word : str_) → bool`

### Endpoint
N/A (Python method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
dict.check("hello") # Returns True
dict.check("helo")  # Returns False
```

### Response
#### Success Response (200)
- **bool** (bool) - True if the word is spelled correctly, False otherwise.

#### Response Example
```json
true
```
```

```APIDOC
## Suggest Spellings

### Description
Suggests possible correct spellings for a given word.

### Method
`suggest(_word : str_) → List[str]`

### Endpoint
N/A (Python method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
dict.suggest("helo") # Returns ['hello', 'help'] (example)
```

### Response
#### Success Response (200)
- **List[str]** - A list of suggested spelling corrections.

#### Response Example
```json
["hello", "help"]
```
```

```APIDOC
## Add Word

### Description
Adds a word to the user's personal word list.

### Method
`add(_word : str_) → None`

### Endpoint
N/A (Python method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
dict.add("pyenchant")
```

### Response
#### Success Response (200)
None

#### Response Example
None
```

```APIDOC
## Add Word to PWL

### Description
Adds a word to the user's personal word list (Personal Word List).

### Method
`add_to_pwl(_word : str_) → None`

### Endpoint
N/A (Python method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
dict.add_to_pwl("pyenchant")
```

### Response
#### Success Response (200)
None

#### Response Example
None
```

```APIDOC
## Add Word to Session

### Description
Adds a word to the current spellcheck session's personal list.

### Method
`add_to_session(_word : str_) → None`

### Endpoint
N/A (Python method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
dict.add_to_session("sessionword")
```

### Response
#### Success Response (200)
None

#### Response Example
None
```

```APIDOC
## Is Word Added

### Description
Checks if a word is present in the personal word list.

### Method
`is_added(_word : str_) → bool`

### Endpoint
N/A (Python method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
dict.is_added("pyenchant")
```

### Response
#### Success Response (200)
- **bool** (bool) - True if the word is in the personal word list, False otherwise.

#### Response Example
```json
true
```
```

```APIDOC
## Is Word Removed

### Description
Checks if a word is present in the personal exclude list.

### Method
`is_removed(_word : str_) → bool`

### Endpoint
N/A (Python method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
dict.is_removed("badword")
```

### Response
#### Success Response (200)
- **bool** (bool) - True if the word is in the personal exclude list, False otherwise.

#### Response Example
```json
false
```
```

```APIDOC
## Remove Word

### Description
Adds a word to the user's personal exclude list.

### Method
`remove(_word : str_) → None`

### Endpoint
N/A (Python method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
dict.remove("badword")
```

### Response
#### Success Response (200)
None

#### Response Example
None
```

```APIDOC
## Remove Word from Session

### Description
Adds a word to the session exclude list.

### Method
`remove_from_session(_word : str_) → None`

### Endpoint
N/A (Python method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
dict.remove_from_session("sessionbadword")
```

### Response
#### Success Response (200)
None

#### Response Example
None
```

```APIDOC
## Store Replacement

### Description
Indicates a replacement spelling for a miss-spelled word. This helps improve future suggestions.

### Method
`store_replacement(_mis : str_, _cor : str_) → None`

### Endpoint
N/A (Python method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
dict.store_replacement("teh", "the")
```

### Response
#### Success Response (200)
None

#### Response Example
None
```

--------------------------------

### Enable verbose output for PyEnchant library finding

Source: https://pyenchant.github.io/pyenchant/install.html

Set the PYENCHANT_VERBOSE_FIND environment variable to any non-empty value to enable detailed output when PyEnchant attempts to locate the Enchant C library and dictionaries. This is helpful for troubleshooting.

```bash
export PYENCHANT_VERBOSE_FIND=1
python -c 'import enchant'

```

--------------------------------

### Enchant.utils Module API

Source: https://pyenchant.github.io/pyenchant/api/enchant.checker.html

Miscellaneous utility functions for the enchant package.

```APIDOC
## Enchant.utils Module API

### Description
Miscellaneous utility functions for the enchant package.

### Functions
- **get_default_language**()
  - Description: Gets the default language.
- **levenshtein**(s1, s2)
  - Description: Calculates the Levenshtein distance between two strings.
  - Parameters:
    - s1 (str): The first string.
    - s2 (str): The second string.
  - Returns: The Levenshtein distance (int).
- **trim_suggestions**(suggestions)
  - Description: Trims a list of suggestions.
```

--------------------------------

### Enchant.tokenize Module API

Source: https://pyenchant.github.io/pyenchant/api/enchant.checker.html

Provides string tokenization functions for PyEnchant.

```APIDOC
## Enchant.tokenize Module API

### Description
Provides string tokenization functions for PyEnchant.

### Classes
- **Chunker**: Base class for chunk tokenizers.
- **EmailFilter**: Tokenizer that filters email addresses.
- **Filter**: Base class for token filters.
- **HTMLChunker**: Tokenizer for HTML content.
- **HashtagFilter**: Tokenizer that filters hashtags.
- **MentionFilter**: Tokenizer that filters mentions.
- **URLFilter**: Tokenizer that filters URLs.
- **WikiWordFilter**: Tokenizer for wiki words.

### Functions
- **basic_tokenize**(text)
  - Description: Performs basic tokenization of the given text.
- **empty_tokenize**(text)
  - Description: Returns an empty list of tokens.
- **get_tokenizer**(name)
  - Description: Retrieves a tokenizer by name.
- **tokenize**(text)
  - Description: Tokenizes the given text using the default tokenizer.
- **unit_tokenize**(text)
  - Description: Tokenizes the text into units.
- **wrap_tokenizer**(tokenizer)
  - Description: Wraps an existing tokenizer.
```

--------------------------------

### suggest

Source: https://pyenchant.github.io/pyenchant/api/enchant.checker.html

Returns suggested spellings for a given word. If no word is provided, it uses the current erroneous word.

```APIDOC
## suggest

### Description
Returns suggested spellings for the given word. If no word is given, the current erroneous word is used.

### Method
`suggest`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **_word** (str | None) - Optional - The word for which to suggest spellings. If None, the current erroneous word is used.

### Request Example
```json
{
  "_word": "speling"
}
```

### Response
#### Success Response (200)
- **suggestions** (List[str]) - A list of suggested spelling corrections.

#### Response Example
```json
{
  "suggestions": ["spelling", "spewing"]
}
```
```

--------------------------------

### Check Dictionary Availability

Source: https://pyenchant.github.io/pyenchant/_sources/tutorial.rst.txt

Use 'enchant.dict_exists' to check if a dictionary for a given language tag is available on the system. Returns True if available, False otherwise.

```python
enchant.dict_exists("fake")
enchant.dict_exists("en_US")
```

--------------------------------

### Personal Word List Methods

Source: https://pyenchant.github.io/pyenchant/api/enchant.html

Methods for interacting with personal word lists and exclude lists.

```APIDOC
## is_added(word)

### Description
Check whether a word is in the personal word list.

### Parameters
#### Path Parameters
- **word** (str) - Required - The word to check.

### Response
- **bool** - True if present.

## remove(word)

### Description
Add a word to the associated exclude list.

### Parameters
#### Path Parameters
- **word** (str) - Required - The word to add to the exclude list.
```

--------------------------------

### Command-Line Spell Checking with CmdLineChecker

Source: https://pyenchant.github.io/pyenchant/_sources/tutorial.rst.txt

Utilize CmdLineChecker for interactive spell checking via the command line. It uses standard input/output for user interaction and provides suggestions for corrections.

```python
import enchant
import enchant.checker
from enchant.checker.CmdLineChecker import CmdLineChecker

chkr = enchant.checker.SpellChecker("en_US")
chkr.set_text("this is sme example txt")
cmdln = CmdLineChecker()
cmdln.set_checker(chkr)
cmdln.run()
```

--------------------------------

### pypwl Module - Pure-Python Personal Word List

Source: https://pyenchant.github.io/pyenchant/api/enchant.tokenize.html

Implements a pure-Python personal word list in the style of Enchant.

```APIDOC
## pypwl Module

### Description
Pure-python personal word list in the style of Enchant.

### Classes
- **PyPWL**
- **Trie**
```

--------------------------------

### Request Dictionary Object

Source: https://pyenchant.github.io/pyenchant/_sources/tutorial.rst.txt

Use 'enchant.request_dict' to construct and return a new dictionary object for a specified language. This is an alternative to directly instantiating 'enchant.Dict'.

```python
d = enchant.request_dict("en_US")
```

--------------------------------

### Check spelling with Dict objects

Source: https://pyenchant.github.io/pyenchant/tutorial.html

Construct a Dict object using a language tag and use the check method to validate words.

```python
>>> import enchant
>>> d = enchant.Dict("en_US")
>>> d.check("Hello")
True
>>> d.check("Helo")
False
```

--------------------------------

### enchant.Broker API

Source: https://pyenchant.github.io/pyenchant/api/index.html

The Broker class provides the main interface for managing dictionaries and providers within the enchant library.

```APIDOC
## Broker Class

### Description
Manages dictionaries and spellchecking providers.

### Methods
- **describe()**: Describes available providers.
- **dict_exists(tag)**: Checks if a dictionary exists for the given language tag.
- **get_param(name)**: Retrieves a configuration parameter.
- **list_dicts()**: Lists all available dictionaries.
- **list_languages()**: Lists all available languages.
- **request_dict(tag)**: Requests a dictionary for a specific language tag.
- **request_pwl_dict(path)**: Requests a personal word list dictionary.
- **set_ordering(provider_name, ordering)**: Sets the ordering for a provider.
- **set_param(name, value)**: Sets a configuration parameter.
```

--------------------------------

### Basic Spell Checking with SpellChecker

Source: https://pyenchant.github.io/pyenchant/_sources/tutorial.rst.txt

Use SpellChecker to find spelling errors in a given text. The checker can be iterated over to retrieve each error.

```python
from enchant.checker import SpellChecker
chkr = SpellChecker("en_US")
chkr.set_text("This is sme sample txt with erors.")
for err in chkr:
    print("ERROR:", err.word)

```

--------------------------------

### Enchant Module API

Source: https://pyenchant.github.io/pyenchant/api/enchant.checker.html

This section lists the core components and functions available in the enchant module for accessing the enchant spellchecking library.

```APIDOC
## Enchant Module API

### Description
Provides access to the enchant spellchecking library, including core classes and utility functions.

### Classes
- **Broker**: Manages dictionaries and spellchecking operations.
- **Dict**: Represents a dictionary for spellchecking.
- **DictWithPWL**: A dictionary that supports personal word lists.
- **ProviderDesc**: Describes an available dictionary provider.

### Functions
- **dict_exists**(tag)
  - Description: Checks if a dictionary with the given tag exists.
  - Parameters:
    - tag (str): The language tag of the dictionary.
- **get_enchant_version**()
  - Description: Returns the version of the enchant library.
- **get_param**(key)
  - Description: Retrieves a configuration parameter.
- **get_user_config_dir**()
  - Description: Gets the user's configuration directory.
- **list_dicts**()
  - Description: Lists all available dictionaries.
- **list_languages**()
  - Description: Lists all supported languages.
- **request_dict**(tag)
  - Description: Requests a dictionary for the given tag.
  - Returns: A `Dict` object if found, otherwise raises `DictNotFoundError`.
- **request_pwl_dict**(tag, pwl)
  - Description: Requests a dictionary with a personal word list.
- **set_param**(key, value)
  - Description: Sets a configuration parameter.
- **set_prefix_dir**(dir)
  - Description: Sets the prefix directory for enchant.
```

--------------------------------

### Spell Checking with Filters

Source: https://pyenchant.github.io/pyenchant/_sources/tutorial.rst.txt

Configure SpellChecker to ignore specific word forms like email addresses or URLs by providing a list of filters during initialization.

```python
from enchant.checker import SpellChecker
from enchant.tokenize import EmailFilter, URLFilter
chkr = SpellChecker("en_US",filters=[EmailFilter,URLFilter])
```

--------------------------------

### Trie Class Methods

Source: https://pyenchant.github.io/pyenchant/api/enchant.pypwl.html

Methods for managing a trie-based dictionary and searching for words with potential errors.

```APIDOC
## Trie Class

### Description
Class implementing a trie-based dictionary of words. A Trie is a recursive data structure storing words by their prefix. —Fuzzy matching— can be done by allowing a certain number of missteps when traversing the Trie.

### Methods

#### `search(_word: str, _nerrs: int = 0) -> List[str]`
Search for the given word, possibly making errors.
This method searches the trie for the given word, making precisely nerrs errors. It returns a list of words found.
```

--------------------------------

### Dictionary Operations

Source: https://pyenchant.github.io/pyenchant/api/enchant.html

Methods for checking dictionary availability and requesting dictionary objects.

```APIDOC
## enchant.dict_exists(tag)

### Description
Check availability of a dictionary for the specified language tag.

### Parameters
#### Path Parameters
- **tag** (str) - Required - The language tag (e.g., "en_US")

### Response
- **bool** - True if available, False otherwise.

## enchant.request_dict(tag=None)

### Description
Request a Dict object for the language specified by tag.

### Parameters
#### Path Parameters
- **tag** (str) - Optional - The language tag. If None, attempts to determine current language.

### Response
- **Dict** - A dictionary object for the requested language.
```

--------------------------------

### Base Tokenizer Class

Source: https://pyenchant.github.io/pyenchant/api/enchant.tokenize.html

The base class for all tokenizer objects in PyEnchant.

```APIDOC
## Class: tokenize

### Description
Base class for all tokenizer objects. Each tokenizer must be an iterator and provide the `offset` attribute. Tokenizers are named using lower_case.

### Usage
Serves as the foundation for creating custom tokenizer implementations.
```

--------------------------------

### List Available Languages

Source: https://pyenchant.github.io/pyenchant/_sources/tutorial.rst.txt

Call 'enchant.list_languages()' to retrieve a list of all language tags for which dictionaries are currently available on the system.

```python
enchant.list_languages()
```

--------------------------------

### Retrieving Checked Text

Source: https://pyenchant.github.io/pyenchant/_sources/tutorial.rst.txt

After using CmdLineChecker, the original text can be retrieved with corrections applied using the get_text() method.

```python
chkr.get_text()
```

--------------------------------

### Tokenization with EmailFilter in PyEnchant

Source: https://pyenchant.github.io/pyenchant/_sources/tutorial.rst.txt

Illustrates how to apply `EmailFilter` using `get_tokenizer` to automatically remove email addresses from the tokenized output. This is helpful for ignoring email addresses during spellchecking.

```python
from enchant.tokenize import get_tokenizer, EmailFilter

tknzr = get_tokenizer("en_US")
print([w for w in tknzr("send an email to fake@example.com please")])

tknzr = get_tokenizer("en_US", filters=[EmailFilter])
print([w for w in tknzr("send an email to fake@example.com please")])
```

--------------------------------

### enchant.checker Module - High-Level Spellchecking

Source: https://pyenchant.github.io/pyenchant/api/enchant.tokenize.html

Offers high-level spellchecking functionality.

```APIDOC
## enchant.checker Module

### Description
High-level spellchecking functionality.

### Classes
- **SpellChecker**
```
Tokens:
Raw