### Quick Start: Local Server

Source: https://github.com/jxmorris12/language_tool_python/blob/master/README.md

Demonstrates how to initialize and use a local LanguageTool server for checking text. Ensure Java is installed and compatible with the LanguageTool version.

```python
import language_tool_python

with language_tool_python.LanguageTool("en-US") as tool:
    text = "A sentence with a error in the Hitchhiker's Guide tot he Galaxy"
    matches = tool.check(text)
    print(matches)
    print(tool.correct(text))
```

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

### Local Server with Configuration Example

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageTool.md

Example of initializing LanguageTool with a custom configuration dictionary for the local server.

```python
config = {
    "cacheSize": 1000,
    "pipelineCaching": True,
    "maxTextLength": 50000,
}
with LanguageTool("en-US", config=config) as tool:
    matches = tool.check("text")
```

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

### Local Server with Default Settings Example

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageTool.md

Example of initializing and using LanguageTool with a local server and default settings for English (US).

```python
from language_tool_python import LanguageTool

with LanguageTool("en-US") as tool:
    text = "This are a mistake."
    matches = tool.check(text)
    for match in matches:
        print(f"Error: {match.message}")
        print(f"Suggestions: {match.replacements}")
```

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

### Basic Server Configuration Example

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageToolConfig.md

A simple example demonstrating how to configure the LanguageTool server with basic settings like cache size and max text length, and then use it.

```python
from language_tool_python import LanguageTool

config = {
    "cacheSize": 2000,
    "maxTextLength": 100000,
}

with LanguageTool("en-US", config=config) as tool:
    matches = tool.check("large text")
```

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

### Install Development Dependencies

Source: https://github.com/jxmorris12/language_tool_python/blob/master/CONTRIBUTING.md

Installs all necessary packages for development, including optional dependencies.

```shell
make install
```

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

### Custom Rules and Picky Mode Example

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageTool.md

Example demonstrating how to customize rules (disable/enable) and enable picky mode for stricter checking.

```python
with LanguageTool("en-US") as tool:
    tool.disabled_rules.update({"MORFOLOGIK_RULE_EN_US"})
    tool.enabled_rules.update({"EN_A_VS_AN"})
    tool.picky = True
    matches = tool.check("text")
```

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

### Quick Start: Remote LanguageTool Server

Source: https://github.com/jxmorris12/language_tool_python/blob/master/README.md

Connects to a self-hosted LanguageTool server for text checking. Replace the example URL with your server's address.

```python
import language_tool_python

with language_tool_python.LanguageTool(
    "en-US",
    remote_server="https://your-lt-server.example.com",
) as tool:
    print(tool.check("This are bad."))
```

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

### Installing Development Dependencies

Source: https://github.com/jxmorris12/language_tool_python/blob/master/README.md

Install the necessary dependencies for developing the language_tool_python library.

```bash
# Install dev dependencies
make install
```

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

### Remote Server Usage Example

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageTool.md

Example of initializing and using LanguageTool with a remote server endpoint.

```python
with LanguageTool(
    "en-US",
    remote_server="https://languagetool.org/api/"
) as tool:
    print(tool.correct("This are bad."))
```

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

### LanguageTool Configuration Example

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/INDEX.md

Provides an example of how to configure LanguageTool with custom settings like cacheSize and maxTextLength using a dictionary passed to the config parameter during instantiation.

```python
config = {"cacheSize": 1000, "maxTextLength": 50000}
LanguageTool("en-US", config=config)
```

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

### Quick Start: Public LanguageTool API

Source: https://github.com/jxmorris12/language_tool_python/blob/master/README.md

Shows how to use the public LanguageTool API for text checking. This method does not require a local Java installation.

```python
import language_tool_python

with language_tool_python.LanguageToolPublicAPI("es") as tool:
    matches = tool.check("Se a hecho un esfuerzo.")
    print(matches)
```

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

### ServerError Example: Startup Failure

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/errors.md

Handle ServerError specifically when the LanguageTool server fails to start. This can occur if Java is not installed or the LanguageTool installation is corrupted.

```python
from language_tool_python import LanguageTool, ServerError

try:
    with LanguageTool("en-US") as tool:
        tool.check("text")
except ServerError as e:
    print(f"Failed to start server: {e}")
    # Possibly Java not installed, or corrupted LanguageTool installation
```

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

### Usage Example - Basic Server Configuration

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageToolConfig.md

Demonstrates how to configure and use LanguageTool with a basic configuration dictionary.

```APIDOC
## Usage Examples - Basic Server Configuration

### Example
```python
from language_tool_python import LanguageTool

config = {
    "cacheSize": 2000,
    "maxTextLength": 100000,
}

with LanguageTool("en-US", config=config) as tool:
    matches = tool.check("large text")
```
```

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

### Install language_tool_python

Source: https://github.com/jxmorris12/language_tool_python/blob/master/README.md

Install or upgrade the language_tool_python package using pip.

```bash
pip install --upgrade language_tool_python
```

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

### JavaError Example: Java Not Installed

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/errors.md

Handle JavaError when the local LanguageTool server cannot be started due to Java not being found or not meeting version requirements. Provides a hint for installation.

```python
from language_tool_python import LanguageTool, JavaError

try:
    # Attempting to start local server without Java
    with LanguageTool("en-US") as tool:
        pass
except JavaError as e:
    if "can't find Java" in str(e):
        print("Please install Java to use local LanguageTool server")
        print("Hint: sudo apt-get install openjdk-17-jre-headless")
```

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

### Get Languages Endpoint Response Example

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/endpoints.md

Provides an example of the JSON array returned by the /v2/languages endpoint, listing supported languages with their codes.

```json
[
  {
    "name": "English",
    "code": "en",
    "longCode": "en-US"
  },
  {
    "name": "English (British)",
    "code": "en",
    "longCode": "en-GB"
  },
  {
    "name": "German",
    "code": "de",
    "longCode": "de-DE"
  }
]
```

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

### Use External LanguageTool Server

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/cli-reference.md

Example demonstrating how to connect to an external LanguageTool server using a specific host and port.

```bash
# Use external server
language_tool_python -l en-US --remote-host api.example.com --remote-port 8080 file.txt
```

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

### Performance Tuning Configuration

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageToolConfig.md

Example of setting performance-related configuration options for the LanguageTool server.

```python
config = {
    "cacheSize": 1000,
    "cacheTTLSeconds": 3600,
    "maxCheckThreads": 4,
    "maxCheckTimeMillis": 30000,
    "pipelineCaching": True,
    "maxPipelinePoolSize": 8,
    "pipelineExpireTimeInSeconds": 300,
    "pipelinePrewarming": True,
}
```

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

### Headers and Security Configuration

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageToolConfig.md

Example of configuring security-related options like trusting X-Forwarded-For headers and enabling suggestions.

```python
config = {
    "trustXForwardForHeader": True,
    "suggestionsEnabled": True,
}
```

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

### Custom Server Configuration Example

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/endpoints.md

Demonstrates how to configure custom server behavior, such as request limits and maximum text length, by passing a configuration dictionary to the LanguageTool constructor.

```python
config = {
    "requestLimit": 100,              # Limit requests
    "requestLimitPeriodInSeconds": 60, # Per minute
    "maxTextLength": 50000,           # Max text size
}

with LanguageTool("en-US", config=config) as tool:
    # Server enforces these limits
    pass
```

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

### Health Check Endpoint Example

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/endpoints.md

Shows how to check the health and responsiveness of the LanguageTool server using a GET request to the /v2/healthcheck endpoint. This is available in LanguageTool 4.2+.

```bash
curl "http://localhost:8081/v2/healthcheck"
```

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

### Complete Workflow Example

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/utils.md

Demonstrates a complete workflow using LanguageTool, including checking text for errors, classifying the text quality using `classify_matches` and `TextStatus`, and applying auto-correction if necessary.

```python
from language_tool_python import LanguageTool
from language_tool_python.utils import classify_matches, TextStatus, correct

with LanguageTool("en-US") as tool:
    text = "There is a bok on the table."
    matches = tool.check(text)
    
    # Classify text quality
    status = classify_matches(matches)
    print(f"Text status: {status}")  # TextStatus.FAULTY
    
    # Show all matches
    for match in matches:
        print(f"{match.rule_id}: {match.message}")
        print(f"  Suggestions: {match.replacements}")
    
    # Apply auto-correction
    if status != TextStatus.CORRECT:
        corrected = correct(text, matches)
        print(f"Corrected: {corrected}")
```

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

### Usage Example: Using Line and Column Information

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/Match.md

This example shows how to iterate through matches found in a multi-line text and use the `get_line_and_column` method to report the precise location of each error.

```APIDOC
### Using Line and Column Information
```python
text = "This are bad.\nThat is also bad."
matches = tool.check(text)

for match in matches:
    line, col = match.get_line_and_column(text)
    print(f"{line}:{col}: {match.rule_id}: {match.message}")
```
```

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

### Request Limiting Configuration

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageToolConfig.md

Example of configuring request limits and timeouts for the LanguageTool server.

```python
config = {
    "requestLimit": 1000,
    "requestLimitInBytes": 10000000,
    "timeoutRequestLimit": 300,
    "requestLimitPeriodInSeconds": 3600,
}
```

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

### Usage Example: Accessing Match Information

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/Match.md

This example demonstrates how to use the `LanguageTool` to check text and then access the attributes of the returned `Match` objects to display error details.

```APIDOC
## Usage Examples

### Accessing Match Information
```python
from language_tool_python import LanguageTool

with LanguageTool("en-US") as tool:
    text = "This are bad."
    matches = tool.check(text)
    
    if matches:
        match = matches[0]
        print(f"Error: {match.message}")
        print(f"Rule ID: {match.rule_id}")
        print(f"Position: {match.offset}-{match.offset + match.error_length}")
        print(f"Suggestions: {match.replacements}")
```
```

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

### Path Configuration

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageToolConfig.md

Example of specifying paths for language models, dictionaries, and rule files in the LanguageTool server configuration.

```python
config = {
    "languageModel": "/path/to/model.bin",
    "fasttextModel": "/path/to/fasttext.bin",
    "fasttextBinary": "/usr/bin/fasttext",
    "rulesFile": "/path/to/rules.xml",
    "lang-en-dictPath": "/path/to/dictionary.txt",
}
```

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

### ServerError Example: Server Timeout

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/errors.md

Catch ServerError when the server process starts but does not become ready within the expected timeout period.

```python
try:
    # Server process starts but doesn't become ready
    tool = LanguageTool("en-US")
except ServerError as e:
    if "did not become ready" in str(e):
        print("Server initialization timeout")
```

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

### Ignore Lines Starting with #

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/cli-reference.md

Example of ignoring lines that begin with a '#' character, useful for markdown files.

```bash
# Ignore lines starting with #
language_tool_python --ignore-lines "^#" markdown.md
```

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

### Error Handling Example

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageToolPublicAPI.md

Provides an example of how to handle potential `RateLimitError` exceptions when using LanguageToolPublicAPI. The `try-except` block catches the error and prints a user-friendly message.

```APIDOC
### Error Handling
```python
from language_tool_python import LanguageToolPublicAPI, RateLimitError

try:
    with LanguageToolPublicAPI("en-US") as tool:
        matches = tool.check("Text")
except RateLimitError:
    print("Rate limit exceeded. Please try again later.")
```
```

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

### Limits Configuration

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageToolConfig.md

Example of setting limits for text length and error rates in the LanguageTool server configuration.

```python
config = {
    "maxTextLength": 100000,
    "maxTextHardLength": 150000,
    "maxErrorsPerWordRate": 0.5,
    "maxSpellingSuggestions": 10,
}
```

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

### Use Existing LanguageTool Installation

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/configuration.md

Prevent LanguageTool from downloading by specifying the directory of an existing installation using LTP_JAR_DIR_PATH.

```bash
export LTP_JAR_DIR_PATH=/path/to/LanguageTool-6.8
python script.py
```

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

### Custom Spellings Example

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageTool.md

Example of initializing LanguageTool with custom spellings, with an option to not persist them.

```python
with LanguageTool(
    "en-US",
    new_spellings=["mycompany", "technobabble"],
    new_spellings_persist=False
) as tool:
    matches = tool.check("mycompany is great")
```

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

### Apply Corrections and Save to File

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/cli-reference.md

Example of automatically applying corrections and redirecting the output to a new file.

```bash
# Correct file and save
language_tool_python -l en-US -a input.txt > output.txt
```

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

### Proxy Usage Example

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageToolPublicAPI.md

Illustrates how to configure LanguageToolPublicAPI to use a proxy server. The `proxies` dictionary specifies the HTTP and HTTPS proxy addresses for routing requests.

```APIDOC
### With Proxy
```python
with LanguageToolPublicAPI(
    "en-US",
    proxies={
        "http": "http://proxy.example.com:8080",
        "https": "http://proxy.example.com:8080"
    }
) as tool:
    matches = tool.check("Text to check")
```
```

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

### Rules and Filtering Configuration

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageToolConfig.md

Example of configuring disabled rules, blocked referrers, and premium-only mode for the LanguageTool server.

```python
config = {
    "disabledRuleIds": ["RULE1", "RULE2"],
    "blockedReferrers": ["example.com"],
    "premiumOnly": True,
}
```

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

### View Corrected Output

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/cli-reference.md

Example of applying corrections and viewing the corrected text directly in the console.

```bash
# View corrected output
language_tool_python -l en-US -a input.txt
```

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

### Basic Public API Usage Example

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageToolPublicAPI.md

Demonstrates the basic usage of LanguageToolPublicAPI to check text for grammatical errors. It initializes the tool for English and prints any detected matches.

```APIDOC
## Usage Examples

### Basic Public API Usage
```python
from language_tool_python import LanguageToolPublicAPI

with LanguageToolPublicAPI("en-US") as tool:
    matches = tool.check("This are not correct.")
    for match in matches:
        print(match)
```
```

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

### Language-Specific Options Configuration

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageToolConfig.md

Example of setting language codes and dictionary paths for specific languages in the LanguageTool server configuration.

```python
config = {
    "lang-en": "en",
    "lang-en-dictPath": "/path/to/en.dict",
    "lang-de": "de",
    "lang-de-dictPath": "/path/to/de.dict",
}
```

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

### cURL Request for Getting Languages

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/endpoints.md

Demonstrates how to fetch the list of supported languages from the LanguageTool server using a GET request to the /v2/languages endpoint.

```bash
curl "http://localhost:8081/v2/languages"
```

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

### Get Server Configuration

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageTool.md

Retrieve the server configuration object. This is a read-only property and may be None if not set.

```python
@property
def config(self) -> Optional[LanguageToolConfig]
```

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

### Configure Privacy-Focused Local-Only Setup

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/configuration.md

Set the LTP_JAR_DIR_PATH environment variable to a pre-installed LanguageTool directory to ensure no network downloads occur. This is suitable for privacy-focused or offline environments.

```python
import os
os.environ["LTP_JAR_DIR_PATH"] = "/opt/languagetool"  # Pre-installed
# Never downloads from network

with LanguageTool("en-US") as tool:
    matches = tool.check("sensitive data")
```

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

### Full Request Flow for Checking Text in Python

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/endpoints.md

Provides a comprehensive Python example demonstrating the typical request flow for checking text with the LanguageTool client. It covers initialization, language retrieval, text checking, and response parsing.

```python
from language_tool_python import LanguageTool

with LanguageTool("en-US") as tool:
    # Step 1-2: Initialization (automatic)
    # - Starts local server
    # - Calls GET /v2/languages
    
    # Step 3-4: Check text
    matches = tool.check("This are bad.")
    # Internally: POST /v2/check with params
    
    # Step 5: Automatic parsing
    for match in matches:
        print(match.message)  # Parsed from response
```

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

### Spanish Checking Example

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageToolPublicAPI.md

Shows how to use LanguageToolPublicAPI for checking Spanish text. It initializes the tool with the 'es' language code and demonstrates the `correct` method to auto-correct a sentence.

```APIDOC
### Spanish Checking
```python
with LanguageToolPublicAPI("es") as tool:
    corrected = tool.correct("Se a hecho un esfuerzo.")
    print(corrected)  # "Se ha hecho un esfuerzo."
```
```

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

### Specify Encoding for Legacy File

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/cli-reference.md

Example of specifying 'latin-1' encoding when processing a legacy file.

```bash
language_tool_python -c latin-1 legacy_file.txt
```

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

### Configure Custom Dictionary for Domain

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/configuration.md

Initialize LanguageTool with a configuration dictionary that specifies a custom dictionary path and disables specific rules. This is useful for domain-specific terminology or style guides.

```python
config = {
    "lang-en-dictPath": "/opt/dicts/medical.txt",
    "disabledRuleIds": "STYLE_BASED_RULE",
}
with LanguageTool("en-US", config=config) as tool:
    matches = tool.check("Medical terminology text")
```

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

### Ignore HTML Comments

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/cli-reference.md

Example of ignoring lines that start with '<!--', commonly used for HTML comments.

```bash
# Ignore HTML comments
language_tool_python --ignore-lines "^<!--" html_file.html
```

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

### Basic Usage with Public API

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/README.md

Shows how to check text for errors using the public LanguageTool API without requiring any local setup. This is a convenient option for quick checks.

```python
# Public API (no local setup required)
with LanguageToolPublicAPI("en-US") as tool:
    matches = tool.check("This are bad.")
```

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

### Check Text Endpoint Response Example

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/endpoints.md

Illustrates the JSON structure returned by the /v2/check endpoint, detailing grammar and spelling issue matches, including messages, replacements, offsets, and rule information.

```json
{
  "matches": [
    {
      "message": "Possible spelling mistake found.",
      "shortMessage": "Spelling mistake",
      "replacements": [
        {"value": "newt"},
        {"value": "not"}
      ],
      "offset": 8,
      "length": 4,
      "context": {
        "text": "This is noot okay. ",
        "offset": 8,
        "length": 4
      },
      "sentence": "This is noot okay.",
      "rule": {
        "id": "MORFOLOGIK_RULE_EN_US",
        "description": "Possible spelling mistake",
        "issueType": "misspelling",
        "category": {
          "id": "TYPOS",
          "name": "Possible Typo"
        }
      },
      "ignoreForIncompleteSentence": false,
      "contextForSureMatch": 0
    }
  ],
  "language": {
    "name": "English",
    "code": "en-US"
  }
}
```

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

### Selective Correction Example

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/utils.md

Illustrates how to perform selective correction by filtering matches based on the presence of replacements before applying the `correct` function. This allows for targeted corrections.

```python
from language_tool_python import LanguageTool
from language_tool_python.utils import correct

with LanguageTool("en-US") as tool:
    text = "This are bad and that are also bad."
    matches = tool.check(text)
    
    # Only keep matches that we want to correct
    matches_to_fix = [m for m in matches if m.replacements]
    
    # Apply correction only to filtered matches
    corrected = correct(text, matches_to_fix)
```

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

### Configure LanguageTool Path with Environment Variables

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/cli-reference.md

Sets environment variables to customize the LanguageTool cache directory and installation path before running the CLI. This allows for flexible configuration without modifying command-line arguments.

```bash
export LTP_PATH=/custom/cache
export LTP_JAR_DIR_PATH=/opt/LanguageTool-6.8
language_tool_python -l en-US file.txt
```

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

### Handle LanguageTool Initialization Errors

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/INDEX.md

This snippet shows how to handle potential Java-related errors during LanguageTool initialization by falling back to the LanguageToolPublicAPI. This is useful when a local Java installation might not be available or configured correctly.

```python
# Handle errors
try:
    tool = LanguageTool("en-US")
except JavaError:
    tool = LanguageToolPublicAPI("en-US")
```

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

### Formatting Code with Make

Source: https://github.com/jxmorris12/language_tool_python/blob/master/README.md

Format the project's code according to the defined style guidelines using the provided make command.

```bash
# Format code
make format
```

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

### Running Tests with Make

Source: https://github.com/jxmorris12/language_tool_python/blob/master/README.md

Execute the project's test suite using the make test command.

```bash
# Tests
make test
```

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

### Show Program Version

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/cli-reference.md

Display the program version and exit using the --version flag.

```bash
language_tool_python --version
```

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

### Setting Environment Variables for LanguageTool Python

Source: https://github.com/jxmorris12/language_tool_python/blob/master/README.md

Configure LanguageTool Python's behavior by setting environment variables. This example shows how to specify a custom cache path, a local LanguageTool directory, and a specific SHA-256 checksum for a version.

```bash
export LTP_PATH=/path/to/cache
export LTP_JAR_DIR_PATH=/path/to/LanguageTool-6.8
export LTP_DOWNLOAD_SHA256_6_8=<sha256>
# export LTP_BYPASS_VERIFIED_DOWNLOADS=true
```

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

### Configure High-Performance Local Server

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/configuration.md

Initialize LanguageTool with a custom configuration dictionary for high performance, including cache settings and thread pool sizes. This is useful for processing many documents efficiently.

```python
config = {
    "cacheSize": 5000,
    "cacheTTLSeconds": 3600,
    "pipelineCaching": True,
    "maxPipelinePoolSize": 8,
    "maxCheckThreads": 4,
}
with LanguageTool("en-US", config=config) as tool:
    # Process many documents efficiently
    pass
```

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

### Batch Processing with Error Handling

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/README.md

Provides an example of batch processing multiple texts with error handling for individual text checks and server errors. This ensures robustness when processing large amounts of text.

```python
from language_tool_python import LanguageTool, LanguageToolError

try:
    with LanguageTool("en-US") as tool:
        for text in texts:
            try:
                matches = tool.check(text)
            except LanguageToolError as e:
                print(f"Error checking text: {e}")
                continue
except Exception as e:
    print(f"Server error: {e}")
```

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

### Configure Local Server Settings

Source: https://github.com/jxmorris12/language_tool_python/blob/master/README.md

Pass a configuration dictionary to LanguageTool for local server instances. This allows tuning parameters like cache size and text length limits.

```python
with language_tool_python.LanguageTool(
    "en-US",
    config={
        "cacheSize": 1000,
        "pipelineCaching": True,
        "maxTextLength": 50000,
    },
) as tool:
    print(tool.check("Text to inspect"))
```

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

### Get Normalized Tag as String

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageTag.md

Shows how to get the normalized language tag as a string using the __str__ method. This is useful for displaying the tag.

```python
tag = LanguageTag("en-us", languages)
print(str(tag))  # "en-US"
```

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

### Handle Corrupted LanguageTool Installation

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/errors.md

Catch PathError when the LanguageTool installation is corrupted or incomplete. This snippet suggests removing the cache directory as a potential fix.

```python
from language_tool_python import LanguageTool, PathError

try:
    tool = LanguageTool("en-US")
except PathError as e:
    if "can't find languagetool-standalone" in str(e):
        print("LanguageTool installation appears corrupted")
        print("Try: rm -rf ~/.cache/language_tool_python/")
```

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

### CLI Entry Point

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/cli-reference.md

The main entry point for the command-line interface. It accepts options and one or more file paths.

```bash
language_tool_python [OPTIONS] FILE [FILE ...]
```

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

### Setting up LanguageTool Python Client/Server Communication

Source: https://github.com/jxmorris12/language_tool_python/blob/master/README.md

Run LanguageTool on a server process and connect to it from a separate client process. The client connects to the server's specified port.

```python
# Server side
server_tool = language_tool_python.LanguageTool("en-US")

# Client side
client_tool = language_tool_python.LanguageTool(
    "en-US",
    remote_server=f"http://127.0.0.1:{server_tool.port}",
)
```

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

### LanguageTool Constructor and Methods

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/INDEX.md

Illustrates the instantiation of the LanguageTool class and its primary check and correct methods. The constructor accepts language, mother_tongue, and optional configuration parameters.

```python
LanguageTool(language, mother_tongue, remote_server, config, ...)
tool.check(text) → List[Match]
tool.correct(text) → str
```

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

### Get LanguageTool Version

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageTool.md

Retrieve the version string of the LanguageTool server. This is a read-only property.

```python
@property
def language_tool_download_version(self) -> str
```

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

### Getting Matched Text

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/Match.md

Retrieves the specific substring identified as an error within the text.

```python
match = tool.check("This is noot okay.")[0]
print(match.matched_text)  # "noot"
```

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

### Show Help Message

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/cli-reference.md

Display the help message and exit using the --help or -h flag.

```bash
language_tool_python --help
language_tool_python -h
```

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

### Create and Use LanguageToolConfig

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageToolConfig.md

Demonstrates how to create a LanguageToolConfig object with custom settings and then use it with the LanguageTool class for text checking.

```python
from language_tool_python.config_file import LanguageToolConfig
from language_tool_python import LanguageTool

config = {
    "cacheSize": 1000,
    "maxTextLength": 50000,
    "pipelineCaching": True,
}
config_obj = LanguageToolConfig(config)

# Use with LanguageTool
with LanguageTool("en-US", config=config) as tool:
    matches = tool.check("text")
```

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

### Avoid Rate Limits Using Local Server

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/errors.md

Demonstrates using the local LanguageTool server to avoid public API rate limits. If the local server fails, it falls back to the public API with rate limit handling.

```python
from language_tool_python import LanguageTool, LanguageToolPublicAPI

# Option 1: Use local server (unlimited)
try:
    with LanguageTool("en-US") as tool:
        for item in large_text_list:
            tool.check(item)
except Exception:
    # Fallback to public API with rate limiting handling
    pass
```

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

### Match Object Methods

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/INDEX.md

Demonstrates the usage of methods available on a Match object, such as selecting a replacement and retrieving line and column information for an error.

```python
match.select_replacement(index)
match.get_line_and_column(original_text) → Tuple[int, int]
```

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

### Get Local Server Port

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageTool.md

Retrieve the port number of the local LanguageTool server. This is a read-only property.

```python
@property
def port(self) -> int
```

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

### Get Local Server Host

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageTool.md

Retrieve the host address of the local LanguageTool server. This is a read-only property.

```python
@property
def host(self) -> str
```

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

### Get Proxy Settings

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageTool.md

Retrieve the proxy settings used for remote server requests. This is a read-only property.

```python
@property
def proxies(self) -> Optional[Dict[str, str]]
```

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

### LanguageToolConfig Constructor

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageToolConfig.md

Initializes a LanguageToolConfig object, creating a configuration file for the local server. It accepts a dictionary of server options and performs validation.

```APIDOC
## LanguageToolConfig Constructor

### Description
Creates a configuration object and writes it to a temporary file for the local server to use.

### Method Signature
`def __init__(self, config: Dict[str, Any]) -> None`

### Parameters
#### `config`
- **Type**: `Dict[str, Any]`
- **Description**: Configuration dictionary with server options.

### Raises
- `ValueError`: If config dictionary is empty.
- `TypeError`: If a value's type doesn't match the schema.
- `PathError`: If a file path value doesn't exist.

### Example
```python
from language_tool_python.config_file import LanguageToolConfig
from language_tool_python import LanguageTool

config = {
    "cacheSize": 1000,
    "maxTextLength": 50000,
    "pipelineCaching": True,
}
config_obj = LanguageToolConfig(config)

# Use with LanguageTool
with LanguageTool("en-US", config=config) as tool:
    matches = tool.check("text")
```
```

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

### Enable Picky Mode

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/cli-reference.md

Activate picky mode using -p or --picky for more rigorous style and grammar checks.

```bash
language_tool_python -p FILE
```

```bash
language_tool_python --picky FILE
```

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

### Getting Line and Column Numbers

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/Match.md

Calculates the 1-indexed line and column number for an error within a given text.

```python
text = "This is bad.\nThis are bad."
matches = tool.check(text)
line, col = matches[1].get_line_and_column(text)
print(f"Error at line {line}, column {col}")  # Error at line 2, column 6
```

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

### Configure Mirror for Offline Download

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/configuration.md

Set custom download host and checksum environment variables to configure LanguageTool to use a mirror for offline downloads. Specify the LanguageTool version to ensure correct checksum verification.

```python
import os
os.environ["LTP_DOWNLOAD_HOST_RELEASE"] = "https://internal.company.com/lt/"
os.environ["LTP_DOWNLOAD_SHA256_6_8"] = "abc123..."

with LanguageTool("en-US", language_tool_download_version="6.8") as tool:
    matches = tool.check("text")
```

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

### Get LanguageTool Server URL

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageTool.md

Retrieve the URL of the LanguageTool server. This is a read-only property in the format 'http://host:port/v2/'.

```python
@property
def url(self) -> str
```

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

### Manage Enabled Categories

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageTool.md

Get the set of explicitly enabled rule categories or specify which categories should be actively used for checking.

```python
@property
def enabled_categories(self) -> Set[str]:
    # Get the set of explicitly enabled rule categories
    pass

@enabled_categories.setter
def enabled_categories(self, value: Set[str]) -> None:
    # Set which categories to enable explicitly
    pass
```

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

### Manage Enabled Rules

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageTool.md

Get the set of explicitly enabled rule IDs or define specific rules to be enabled for checking.

```python
@property
def enabled_rules(self) -> Set[str]:
    # Get the set of explicitly enabled rule IDs
    pass

@enabled_rules.setter
def enabled_rules(self, value: Set[str]) -> None:
    # Set which rules to enable explicitly
    pass
```

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

### LanguageToolPublicAPI Constructor

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageToolPublicAPI.md

Initializes the LanguageToolPublicAPI. It inherits parameters from LanguageTool, with the remote server automatically set to the public API endpoint. The `language` and `mother_tongue` parameters can be specified for language settings.

```APIDOC
## Constructor

```python
LanguageToolPublicAPI(
    language: Optional[str] = None,
    mother_tongue: Optional[str] = None,
    *args: Any,
    **kwargs: Any
) -> None
```

### Parameters

Inherits all parameters from LanguageTool. The `remote_server` parameter is automatically set to `https://languagetool.org/api/` and should not be overridden.

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| language | `Optional[str]` | No | System locale or "en" | Language code (e.g., "en-US", "fr", "de"). |
| mother_tongue | `Optional[str]` | No | None | Mother tongue language code for false friend detection. |

### Raises

Same as LanguageTool.
```

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

### Language Property

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageTool.md

Manages the language used for text checking. Allows getting and setting the language tag, which affects rule application.

```APIDOC
## Properties: language

### Description
Manages the language used for text checking. Allows getting and setting the language tag, which affects rule application.

### Getter
```python
@property
def language(self) -> LanguageTag
```
Get the current language tag. Returns a `LanguageTag` object.

### Setter
```python
@language.setter
def language(self, language: str) -> None
```
Set the language for checking. Clears disabled/enabled rules when changed.
```

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

### Get and Set Mother Tongue

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageTool.md

Access the mother tongue language tag or set it for improved false friend detection between languages.

```python
@property
def mother_tongue(self) -> Optional[LanguageTag]:
    # Get the mother tongue language tag
    pass

@mother_tongue.setter
def mother_tongue(self, mother_tongue: Optional[str]) -> None:
    # Set the mother tongue language
    pass
```

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

### Close LanguageTool Server

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageTool.md

Close the LanguageTool server connection and perform necessary cleanup. This terminates the local server if it was started by the instance.

```python
def close(self) -> None
```

```python
tool = LanguageTool("en-US")
try:
    # Use tool
    pass
finally:
    tool.close()
```

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

### CLI: Use Remote LT Server

Source: https://github.com/jxmorris12/language_tool_python/blob/master/README.md

Connect to a remote LanguageTool server instance for checking by specifying its host and port.

```bash
language_tool_python -l en-US --remote-host 127.0.0.1 --remote-port 8081 input.txt
```

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

### Get Languages

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/endpoints.md

Retrieves a list of all languages supported by the LanguageTool server. This endpoint is useful for determining which language codes can be used for text checking.

```APIDOC
## GET /v2/languages

### Description
Get list of supported languages.

### Method
GET

### Endpoint
/v2/languages

### Parameters
None

### Response
#### Success Response (200)
- **name** (string) - The full name of the language.
- **code** (string) - The short language code.
- **longCode** (string) - The detailed language code (e.g., en-US).

### Response Example
```json
[
  {
    "name": "English",
    "code": "en",
    "longCode": "en-US"
  },
  {
    "name": "English (British)",
    "code": "en",
    "longCode": "en-GB"
  },
  {
    "name": "German",
    "code": "de",
    "longCode": "de-DE"
  }
]
```

### Status Codes
- 200: Success
- 500: Server error
```

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

### Specify Language Code

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/cli-reference.md

Use the -l or --language option to specify the language code for checking. Examples include 'en-US', 'de', and 'fr-FR'.

```bash
language_tool_python -l en-US FILE
```

```bash
language_tool_python --language de-DE FILE
```

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

### Configuration Schema - Paths

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageToolConfig.md

Lists configuration options for specifying paths to LanguageTool resources, which must exist.

```APIDOC
## Configuration Schema - Paths (must exist)

### Options
- `languageModel` (str or Path): Path to the language model file.
- `fasttextModel` (str or Path): Path to the fastText model file.
- `fasttextBinary` (str or Path): Path to the fastText binary.
- `rulesFile` (str or Path): Path to the rules XML file.
- `lang-en-dictPath` (str or Path): Path to the English dictionary file.
- `lang-de-dictPath` (str or Path): Path to the German dictionary file.
```

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

### Handle JavaError Exception

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/INDEX.md

Demonstrates a common pattern for handling Java-related errors by falling back to the public API if the local server setup fails.

```python
try:
    tool = LanguageTool("en-US")
except JavaError:
    tool = LanguageToolPublicAPI("en-US")
```

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

### CLI: Auto-apply Suggestions

Source: https://github.com/jxmorris12/language_tool_python/blob/master/README.md

Automatically apply suggestions found by LanguageTool to an input file directly from the command line.

```bash
language_tool_python -l en-US --apply input.txt
```

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

### Public API Usage with Proxy

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageToolPublicAPI.md

Illustrates how to configure LanguageToolPublicAPI to route requests through a proxy server. This is useful for network environments that require proxying.

```python
with LanguageToolPublicAPI(
    "en-US",
    proxies={
        "http": "http://proxy.example.com:8080",
        "https": "http://proxy.example.com:8080"
    }
) as tool:
    matches = tool.check("Text to check")
```

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

### Get and Set Language

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageTool.md

Retrieve the current language tag or set a new language for text checking. Changing the language clears disabled and enabled rules.

```python
@property
def language(self) -> LanguageTag:
    # Get the current language tag
    pass

@language.setter
def language(self, language: str) -> None:
    # Set the language for checking
    pass
```

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

### Configuration Schema - Performance Tuning

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageToolConfig.md

Lists configuration options related to performance tuning for the LanguageTool server.

```APIDOC
## Configuration Schema - Performance Tuning

### Options
- `cacheSize` (int): Cache size.
- `cacheTTLSeconds` (int): Cache time-to-live in seconds.
- `maxCheckThreads` (int): Maximum number of check threads.
- `maxCheckTimeMillis` (int): Maximum time in milliseconds for a check.
- `pipelineCaching` (bool): Enables pipeline caching.
- `maxPipelinePoolSize` (int): Maximum size of the pipeline pool.
- `pipelineExpireTimeInSeconds` (int): Expiration time for pipeline items in seconds.
- `pipelinePrewarming` (bool): Enables pipeline prewarming.
```

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

### Get Environment Integer

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/utils.md

Reads a positive integer from an environment variable, using a default value if the variable is not set. Raises PathError for invalid or non-positive values.

```python
from language_tool_python.utils import get_env_int

max_bytes = get_env_int("LTP_MAX_DOWNLOAD_BYTES", 536870912)
```

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

### Basic Public API Usage

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageToolPublicAPI.md

Demonstrates basic usage of LanguageToolPublicAPI for checking text in a specified language. It utilizes a context manager for proper resource handling.

```python
from language_tool_python import LanguageToolPublicAPI

with LanguageToolPublicAPI("en-US") as tool:
    matches = tool.check("This are not correct.")
    for match in matches:
        print(match)
```

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

### Configuration Schema - Headers and Security

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageToolConfig.md

Lists configuration options related to headers and security for the LanguageTool server.

```APIDOC
## Configuration Schema - Headers and Security

### Options
- `trustXForwardForHeader` (bool): Trust the X-Forwarded-For header.
- `suggestionsEnabled` (bool): Enables suggestions.
```

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

### Initialize LanguageTool

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageTool.md

Instantiate the LanguageTool class to interact with a LanguageTool server. You can specify language, mother tongue, remote server URL, custom spellings, and configuration options.

```python
from language_tool_python import LanguageTool

# Example with default settings (detects system locale)
tool = LanguageTool()

# Example specifying language and remote server
tool_en_us = LanguageTool(language='en-US', remote_server='http://localhost:8081')

# Example with custom spellings that persist
custom_words = ["mycustomword", "anotherword"]
tool_persist = LanguageTool(new_spellings=custom_words, new_spellings_persist=True)

# Example with configuration for local server
config_options = {"maxWords": 500}
tool_config = LanguageTool(config=config_options)

# Example specifying LanguageTool version to download
tool_version = LanguageTool(language_tool_download_version='latest')

# Example with proxies for remote server
proxy_settings = {"http": "http://proxy:port"}
tool_proxies = LanguageTool(remote_server='http://remote.server.com', proxies=proxy_settings)
```

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

### Basic Usage with Local Server

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/README.md

Demonstrates checking text for errors and correcting a sentence using a local LanguageTool server. The library automatically downloads LanguageTool if not present.

```python
# Local server (downloads LanguageTool automatically)
with LanguageTool("en-US") as tool:
    matches = tool.check("This are bad.")
    print(tool.correct("This are bad."))
```

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

### Get Environment Float

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/utils.md

Reads a positive float from an environment variable, using a default value if the variable is not set. Raises PathError for invalid, non-positive, or non-finite values.

```python
from language_tool_python.utils import get_env_float

ratio = get_env_float("LTP_SAFE_ZIP_MAX_COMPRESSION_RATIO", 100.0)
```

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

### Configuration Schema - Language-Specific Options

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageToolConfig.md

Lists configuration options for language-specific settings, including dictionary paths.

```APIDOC
## Configuration Schema - Language-Specific Options

### Options
- `lang-<code>` (str): Language code (e.g., `lang-en`).
- `lang-<code>-dictPath` (str): Path to the dictionary for a specific language (e.g., `lang-en-dictPath`).
```

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

### Get System Locale Language

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/utils.md

Retrieves the current system locale language code. It attempts to use locale.getlocale() and falls back to locale.getdefaultlocale(), defaulting to 'en' if both fail.

```python
from language_tool_python.utils import get_locale_language

lang = get_locale_language()
print(f"System language: {lang}")
```

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

### Check Files with find

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/cli-reference.md

Integrate with the `find` command to check all files matching a pattern within a directory tree. Use `-exec` with `+` for efficiency or `\;` for individual file processing.

```bash
# Check all .txt files in directory tree
find . -name "*.txt" -exec language_tool_python -l en-US {} +

# Check and auto-correct
find . -name "*.md" -exec language_tool_python -l en-US -a {} \;
```

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

### Bad Request Error Response

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/endpoints.md

Example of a JSON response for a bad request, typically due to an invalid language parameter. This results in a LanguageToolError after attempting to parse the JSON response.

```json
{
  "error": "Invalid language: xyz"
}
```

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

### Set Version-Specific SHA-256 Checksum

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/configuration.md

Export LTP_DOWNLOAD_SHA256_<VERSION> with the expected SHA-256 checksum for a specific LanguageTool version to ensure download integrity.

```bash
export LTP_DOWNLOAD_SHA256_6_8=abc123def456...
export LTP_DOWNLOAD_SHA256_6_9_SNAPSHOT=def789ghi012...
```

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

### Run Tests

Source: https://github.com/jxmorris12/language_tool_python/blob/master/CONTRIBUTING.md

Executes the project's test suite. Ensure all added or modified tests pass.

```shell
# Run tests (if you have added or modified some, make sure they are passing)
make test
```

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

### Check Text Matching Regex Regions

Source: https://github.com/jxmorris12/language_tool_python/blob/master/README.md

Checks for errors only within specific parts of the text that match a given regular expression. This is useful for ignoring or focusing on quoted text, for example.

```python
matches = tool.check_matching_regions(
    'He said "I has a problem" but she replied "It are fine".',
    r'"[^"]*"',
)
```

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

### Import LanguageTool Components

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/INDEX.md

Import the main LanguageTool class, public API, Match object, utility functions, and exception classes for use in your project.

```python
from language_tool_python import LanguageTool, LanguageToolPublicAPI, Match
from language_tool_python.utils import correct, classify_matches, TextStatus
from language_tool_python.exceptions import LanguageToolError, RateLimitError
```

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

### Basic LanguageTool Usage

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageTag.md

Demonstrates the basic usage of LanguageTool by initializing it with a specific language and accessing its default normalized language tag.

```python
from language_tool_python import LanguageTool

with LanguageTool("en-US") as tool:
    print(tool.language.normalized_tag)  # "en-US"
```

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

### Handle Invalid LTP_PATH Environment Variable

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/errors.md

Catch PathError when the LTP_PATH environment variable points to an invalid or inaccessible directory. This example sets an invalid path and demonstrates error handling.

```python
import os
from language_tool_python import LanguageTool, PathError

os.environ["LTP_PATH"] = "/nonexistent/path"

try:
    tool = LanguageTool("en-US")
except PathError as e:
    print(f"Invalid LTP_PATH: {e}")
```

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

### Performance Optimization Configuration

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageToolConfig.md

Configure caching and threading for efficient processing of multiple texts. Use this when processing large volumes of text to reduce latency.

```python
config = {
    "cacheSize": 5000,
    "cacheTTLSeconds": 3600,
    "pipelineCaching": True,
    "maxPipelinePoolSize": 8,
    "pipelineExpireTimeInSeconds": 600,
    "pipelinePrewarming": True,
    "maxCheckThreads": 4,
}

with LanguageTool("en-US", config=config) as tool:
    # Process many texts efficiently
    for text in many_texts:
        matches = tool.check(text)
```

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

### JavaError Example: Fallback to Remote Server

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/errors.md

Demonstrates a fallback mechanism where if a JavaError occurs (indicating issues with the local Java backend), the code attempts to use the public API instead.

```python
from language_tool_python import LanguageTool, JavaError

try:
    tool = LanguageTool("en-US")
except JavaError:
    # Fall back to public API
    from language_tool_python import LanguageToolPublicAPI
    tool = LanguageToolPublicAPI("en-US")
```

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

### Configuration Schema - Limits

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageToolConfig.md

Lists configuration options related to various limits for the LanguageTool server.

```APIDOC
## Configuration Schema - Limits

### Options
- `maxTextLength` (int): Maximum text length to process.
- `maxTextHardLength` (int): Hard maximum text length.
- `maxErrorsPerWordRate` (float): Maximum rate of errors per word.
- `maxSpellingSuggestions` (int): Maximum number of spelling suggestions.
```

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

### Handle Invalid Language or Spelling File Errors

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/errors.md

Catch ValueError or PathError when an invalid language code is provided or a spelling file cannot be created. This example attempts to initialize LanguageTool with a non-existent language.

```python
from language_tool_python import LanguageTool, PathError

try:
    # "xyz" language doesn't exist, spelling file can't be created
    tool = LanguageTool(
        "xyz",
        new_spellings=["myword"]
    )
except (ValueError, PathError) as e:
    print(f"Invalid language or spelling error: {e}")
```

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

### Custom Dictionary Configuration

Source: https://github.com/jxmorris12/language_tool_python/blob/master/_autodocs/api-reference/LanguageToolConfig.md

Integrate a custom dictionary for domain-specific terms. Ensure the dictionary file path is correctly specified.

```python
from pathlib import Path

custom_dict = Path("/opt/dicts/medical_terms.txt")

config = {
    "lang-en-dictPath": str(custom_dict),
}

with LanguageTool("en-US", config=config) as tool:
    matches = tool.check("medical text with domain-specific terms")
```