Stanza

https://github.com/stanfordnlp/stanza
Admin
Stanza is the Stanford NLP Group's official Python natural language processing library, providing...
Tokens:37,031
Snippets:457
Trust Score:9.3
License:Apache-2.0
Update:2 months ago
Show doc for...
Tokens:
Raw
### Start Stanza Demo Server

Source: https://github.com/stanfordnlp/stanza/blob/main/stanza/pipeline/demo/README.md

Set the Flask application and run the demo server from the Stanza directory. Ensure you have Flask installed.

```bash
export FLASK_APP=demo_server.py
flask run
```

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

### Install Stanza from Source

Source: https://github.com/stanfordnlp/stanza/blob/main/README.md

Clone the Stanza repository and install it in editable mode for development purposes.

```bash
git clone https://github.com/stanfordnlp/stanza.git
cd stanza
pip install -e .
```

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

### Install Stanford CoreNLP

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/resources.md

Install the CoreNLP Java toolkit to a default or custom directory path.

```python
import stanza

# Install CoreNLP
corenlp_path = stanza.install_corenlp()

# Use with custom path
corenlp_path = stanza.install_corenlp('/path/to/corenlp')
```

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

### Install Stanza via pip

Source: https://github.com/stanfordnlp/stanza/blob/main/README.md

Use this command to install Stanza and its dependencies using pip. This is the recommended installation method for most users.

```bash
pip install stanza
```

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

### stanza.install_corenlp

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/resources.md

Installs the Stanford CoreNLP Java-based toolkit.

```APIDOC
## stanza.install_corenlp(corenlp_root=DEFAULT_CORENLP_PATH)

### Description
Install Stanford CoreNLP software (Java-based NLP toolkit).

### Parameters
- **corenlp_root** (str) - Optional - Root directory for CoreNLP installation

### Returns
- str - Path to installed CoreNLP
```

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

### Verify CoreNLP Installation

Source: https://github.com/stanfordnlp/stanza/blob/main/demo/Stanza_CoreNLP_Interface.ipynb

Lists the files in the CoreNLP installation directory to confirm successful installation. Requires the CORENLP_HOME environment variable to be set.

```bash
# Examine the CoreNLP installation folder to make sure the installation is successful
!ls $CORENLP_HOME
```

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

### install_corenlp()

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/README.md

Installs the CoreNLP package.

```APIDOC
## install_corenlp()

### Description
Installs the CoreNLP library for use with Stanza.
```

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

### Download and Install Stanford CoreNLP

Source: https://github.com/stanfordnlp/stanza/blob/main/demo/Stanza_CoreNLP_Interface.ipynb

Downloads the Stanford CoreNLP package using Stanza's installation command and sets the CORENLP_HOME environment variable. This process can take several minutes.

```python
# Download the Stanford CoreNLP package with Stanza's installation command
# This'll take several minutes, depending on the network speed
corenlp_dir = './corenlp'
stanza.install_corenlp(dir=corenlp_dir)

# Set the CORENLP_HOME environment variable to point to the installation location
import os
os.environ["CORENLP_HOME"] = corenlp_dir
```

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

### Start CoreNLP Server

Source: https://github.com/stanfordnlp/stanza/blob/main/demo/Stanza_CoreNLP_Interface.ipynb

Starts the background CoreNLP server process. This is optional as the server starts automatically on the first annotation request.

```python
client.start()
import time; time.sleep(10)
```

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

### Install Stanza

Source: https://github.com/stanfordnlp/stanza/blob/main/demo/Stanza_Beginners_Guide.ipynb

Installs the Stanza package using pip. The '!' prefix is for environments like Jupyter notebooks.

```python
# Install; note that the prefix "!" is not needed if you are running in a terminal
!pip install stanza

# Import the package
import stanza
```

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

### Configure processor variants in Pipeline

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/processors.md

Examples of initializing a pipeline with specific lemmatizer or tokenizer variants.

```python
# Use identity lemmatizer for a language
nlp = stanza.Pipeline('en', lemma_use_identity=True)

# Use specific tokenizer variant
nlp = stanza.Pipeline('vi', processors={'tokenize': 'pkkvie'})
```

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

### Initialize ModelSpecification

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/types.md

Example of creating a ModelSpecification instance for a POS processor.

```python
from stanza.resources.common import ModelSpecification

spec = ModelSpecification(
    processor='pos',
    package='default',
    dependencies=[('tokenize', 'default'), ('mwt', 'default')]
)
```

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

### Install Stanza Package

Source: https://github.com/stanfordnlp/stanza/blob/main/demo/Stanza_CoreNLP_Interface.ipynb

Installs the Stanza Python package using pip. The '!' prefix is only needed in environments like Colab notebooks.

```python
# Install stanza; note that the prefix "!" is not needed if you are running in a terminal
!pip install stanza

# Import stanza
import stanza
```

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

### Download Stanza models

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/resources.md

Use these examples to download language-specific models, custom packages, or specific processors. Proxy settings can be configured via the proxies parameter.

```python
import stanza

# Download default English package
stanza.download('en')

# Download specific processors
stanza.download('en', processors='tokenize,pos,lemma')

# Download multiple languages
stanza.download(['en', 'fr'])

# Download with custom package
stanza.download('en', package='ewt')

# Download with proxy
proxies = {'http': 'http://proxy.example.com:8080'}
stanza.download('en', proxies=proxies)
```

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

### Stanza Dependency Parse Output Example

Source: https://github.com/stanfordnlp/stanza/blob/main/README.md

An example of the output format for dependency parsing, showing words, their head indices, and dependency relations.

```text
('Barack', '4', 'nsubj:pass')
('Obama', '1', 'flat')
('was', '4', 'aux:pass')
('born', '0', 'root')
('in', '6', 'case')
('Hawaii', '4', 'obl')
('.', '4', 'punct')
```

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

### Install Missing Python Dependencies

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/errors.md

Install required optional packages or update existing ones to resolve dependency exceptions.

```bash
# Install with optional dependencies
pip install stanza[transformers]

# Or install individually
pip install transformers torch

# Update everything
pip install -U stanza torch transformers
```

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

### Visualize Semgrex Search on a String

Source: https://github.com/stanfordnlp/stanza/blob/main/demo/semgrex visualization.ipynb

Initializes a Stanza pipeline for a given language and text, then calls a function to visualize Semgrex search results. Use this to start a visualization process from raw text.

```python
def visualize_search_str(text, semgrex_queries, lang_code):
    """
    Visualizes the deprel of the semgrex results from running semgrex search on a string with the given list of
    semgrex queries. Returns a list of the edited HTML strings. Each element in the list represents
    the HTML to render one of the sentences in the document.

    Internally, this function converts the string into a stanza doc object before processing the doc object.

    'lang_code' is the two-letter language abbreviation for the language that the stanza doc object is written in.
    """
    nlp = stanza.Pipeline(lang_code, processors="tokenize, pos, lemma, depparse")
    doc = nlp(text)
    return visualize_search_doc(doc, semgrex_queries, lang_code)
```

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

### Install Stanza via Anaconda

Source: https://github.com/stanfordnlp/stanza/blob/main/README.md

Install Stanza using the conda package manager from the stanfordnlp channel. Note: This method may not work for Python 3.10.

```bash
conda install -c stanfordnlp stanza
```

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

### Get pipeline string representation

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/pipeline.md

Returns a human-readable summary of the pipeline configuration.

```python
nlp = stanza.Pipeline('en')
print(nlp)  # <Pipeline: tokenize=TokenizeProcessor, mwt=MWTProcessor, ...>
```

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

### Visualize Arabic Dependency Trees

Source: https://github.com/stanfordnlp/stanza/blob/main/demo/CONLL_Dependency_Visualizer_Example.ipynb

Generates visualizations for Arabic dependency trees from a CONLL-U file. This example specifically demonstrates visualization for a right-to-left language.

```python
from stanza.utils.visualization.conll_deprel_visualization import conll_to_visual

# testing right to left languages
ar_file = "arabic_test.conllu.txt"
conll_to_visual(ar_file, "ar")
```

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

### Visualize Japanese Dependency Trees

Source: https://github.com/stanfordnlp/stanza/blob/main/demo/CONLL_Dependency_Visualizer_Example.ipynb

Generates visualizations for Japanese dependency trees from a CONLL-U file. This example shows the basic usage for a non-left-to-right language.

```python
from stanza.utils.visualization.conll_deprel_visualization import conll_to_visual

jp_file = "japanese_test.conllu.txt"
conll_to_visual(jp_file, "ja")
```

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

### Check Model Availability

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/utilities.md

Retrieves the current STANZA_RESOURCES_DIR environment variable and lists the contents of the directory to verify installed language models.

```python
import stanza
import os

model_dir = os.environ.get('STANZA_RESOURCES_DIR')
print(f"Model directory: {model_dir}")

# List available languages
available_models = os.listdir(model_dir)
print(f"Available languages: {available_models}")
```

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

### Upgrade Stanza via pip

Source: https://github.com/stanfordnlp/stanza/blob/main/README.md

Use this command to upgrade an existing Stanza installation to the latest version.

```bash
pip install stanza -U
```

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

### Python 'with' Statement for CoreNLP Client

Source: https://github.com/stanfordnlp/stanza/blob/main/demo/Stanza_CoreNLP_Interface.ipynb

Use the 'with' statement to automatically manage the start and stop of the CoreNLP server process. This is the recommended approach to prevent orphaned server processes.

```python
print("Starting a server with the Python \"with\" statement...")
with CoreNLPClient(annotators=["tokenize","ssplit", "pos", "lemma", "ner"], 
                   memory='4G', endpoint='http://localhost:9001', be_quiet=True) as client:
    text = "Albert Einstein was a German-born theoretical physicist."
    document = client.annotate(text)

    print("{:30s}\t{}".format("Mention", "Type"))
    for sent in document.sentence:
        for m in sent.mentions:
            print("{:30s}\t{}".format(m.entityMentionText, m.entityType))

print("\nThe server should be stopped upon exit from the \"with\" statement.")
```

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

### Configure Pipeline Download Methods

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/pipeline.md

Demonstrates initializing a pipeline with different resource download strategies.

```python
# No downloads
nlp = stanza.Pipeline('en', download_method=stanza.DownloadMethod.NONE)

# Reuse existing resources
nlp = stanza.Pipeline('en', download_method=stanza.DownloadMethod.REUSE_RESOURCES)

# Force refresh
nlp = stanza.Pipeline('en', download_method=stanza.DownloadMethod.DOWNLOAD_RESOURCES)
```

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

### Manage Stanza models and pipelines

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/resources.md

Demonstrates downloading language models, configuring custom directories, and initializing a processing pipeline.

```python
import stanza

# Download models for English
stanza.download('en')

# Download specific processors for English
stanza.download('en', processors='tokenize,pos,lemma')

# Download with custom package
stanza.download('en', package='ewt')

# Download multiple languages
stanza.download(['en', 'fr', 'de'])

# Use custom model directory
import os
os.environ['STANZA_RESOURCES_DIR'] = '/custom/path/to/models'
stanza.download('en')

# Create pipeline after downloading
nlp = stanza.Pipeline('en')
doc = nlp("Hello world")
```

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

### Configure Pipeline with DownloadMethod

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/types.md

Demonstrates initializing a Stanza pipeline using a specific download method.

```python
import stanza
from stanza.pipeline.core import DownloadMethod

nlp = stanza.Pipeline('en', download_method=DownloadMethod.NONE)
```

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

### Basic Stanza Pipeline Usage

Source: https://github.com/stanfordnlp/stanza/blob/main/README.md

Demonstrates how to import Stanza, download a language model, initialize a pipeline, and process a sentence to print its dependencies.

```python
import stanza
stanza.download('en')       # Optional: pre-download English models (Pipeline can auto-download if needed)
nlp = stanza.Pipeline('en') # This sets up a default neural pipeline in English
doc = nlp("Barack Obama was born in Hawaii. He was elected president in 2008.")
doc.sentences[0].print_dependencies()
```

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

### Custom Language Packages

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/multilingual.md

Demonstrates initializing the pipeline for use with specific language packages.

```python
from stanza import MultilingualPipeline

# Use specific language packages
nlp = MultilingualPipeline()

text = "This is English. C'est du français."
doc = nlp(text)
```

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

### Configure Custom Pipeline

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/INDEX.md

Initialize a pipeline with specific processors and hardware settings.

```python
nlp = stanza.Pipeline('en',
    processors='tokenize,pos,lemma,depparse',
    pos_batch_size=32,
    use_gpu=True
)
```

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

### Minimal Pipeline Initialization

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/INDEX.md

Initializes a default English pipeline.

```python
nlp = stanza.Pipeline('en')
```

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

### Get Language Identification Processor Signature

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/multilingual.md

Signature for retrieving the language identification processor.

```python
def get_langid_processor(self):
```

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

### MultilingualPipeline.__init__

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/multilingual.md

Initializes the MultilingualPipeline with configuration for language identification and resource management.

```APIDOC
## MultilingualPipeline.__init__

### Description
Initializes the pipeline for processing text in multiple languages with automatic language detection.

### Parameters
- **lang_id_package** (str) - Optional - Package to use for language identification (default: 'langid')
- **dir** (str) - Optional - Directory for models (default: DEFAULT_MODEL_DIR)
- **pipelines** (dict or None) - Optional - Mapping of language codes to Pipeline instances
- **logging_level** (int or None) - Optional - Logging level
- **verbose** (bool or None) - Optional - Verbose output
- **use_gpu** (bool or None) - Optional - Use GPU if available
- **download_method** (DownloadMethod) - Optional - Resource download strategy
- **resources_url** (str) - Optional - Resources URL
- **resources_branch** (str or None) - Optional - Resources branch
- **resources_version** (str) - Optional - Resources version
- **resources_filepath** (str or None) - Optional - Local resources.json path
- **proxies** (dict or None) - Optional - Proxy configuration
- **foundation_cache** (FoundationCache or None) - Optional - Foundation model cache
- **device** (str or None) - Optional - Device ('cpu' or 'cuda:X')
- **kwargs** (dict) - Optional - Processor configuration arguments
```

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

### Process Multilingual Text

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/multilingual.md

Example usage of MultilingualPipeline to process text containing multiple languages.

```python
from stanza import MultilingualPipeline

nlp = MultilingualPipeline()
doc = nlp("Hello world. Bonjour le monde.")
# Processes "Hello world" with English pipeline
# Processes "Bonjour le monde" with French pipeline
```

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

### Initialize Full Stanza Pipeline

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/types.md

Configures a pipeline with specific processors, batch sizes, download methods, and hardware acceleration settings.

```python
import stanza
from stanza.pipeline.core import DownloadMethod

nlp = stanza.Pipeline(
    lang='en',
    package='ewt',
    processors={
        'tokenize': 'default',
        'pos': 'default',
        'lemma': 'default',
        'depparse': 'default'
    },
    download_method=DownloadMethod.REUSE_RESOURCES,
    use_gpu=True,
    device='cuda:0',
    tokenize_batch_size=64,
    pos_batch_size=32,
    lemma_batch_size=32,
    depparse_batch_size=16,
)
```

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

### get(fields, as_sentences=False, from_token=False)

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/document.md

Retrieves specified linguistic fields from all words or tokens in the document.

```APIDOC
## get(fields, as_sentences=False, from_token=False)

### Description
Extracts specific annotation fields (e.g., 'text', 'lemma', 'upos') from the document. Results can be returned as a flat list or organized by sentences.

### Parameters
- **fields** (str or list) - Required - Field name(s) to extract.
- **as_sentences** (bool) - Optional (Default: False) - If True, returns results as a list of sentences.
- **from_token** (bool) - Optional (Default: False) - If True, extracts from tokens instead of words.
```

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

### Initialize Minimal Stanza Pipeline

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/configuration.md

Create a default pipeline instance using standard settings.

```python
import stanza

# Use all defaults
nlp = stanza.Pipeline('en')
```

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

### Extract and Print Named Entities

Source: https://github.com/stanfordnlp/stanza/blob/main/demo/Stanza_Beginners_Guide.ipynb

Iterate over all extracted named entity mentions to print their text, type, and character spans (start and end).

```python
print("Mention text\tType\tStart-End")
for ent in en_doc.ents:
    print("{}\t{}\t{}-{}".format(ent.text, ent.type, ent.start_char, ent.end_char))
```

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

### Stanza Pipeline with Proxy

Source: https://github.com/stanfordnlp/stanza/blob/main/README.md

Shows how to configure Stanza to use proxies for downloading models, useful when facing connection errors.

```python
import stanza
proxies = {'http': 'http://ip:port', 'https': 'http://ip:port'}
stanza.download('en', proxies=proxies)  # Optional: pre-download English models (Pipeline can auto-download if needed)
nlp = stanza.Pipeline('en')             # This sets up a default neural pipeline in English
doc = nlp("Barack Obama was born in Hawaii. He was elected president in 2008.")
doc.sentences[0].print_dependencies()
```

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

### Full Pipeline Configuration

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/INDEX.md

Configures a pipeline with specific processors, download methods, device settings, and batch sizes.

```python
nlp = stanza.Pipeline(
    lang='en',
    package='ewt',
    processors={
        'tokenize': 'default',
        'pos': 'default',
        'lemma': 'default',
        'depparse': 'default'
    },
    download_method='REUSE_RESOURCES',
    device='cuda:0',
    tokenize_batch_size=64,
    pos_batch_size=32,
)
```

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

### Extract Document Fields in Python

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/document.md

Use the get method to retrieve specific linguistic annotations like lemmas, POS tags, or text from words and tokens.

```python
def get(self, fields, as_sentences=False, from_token=False):
```

```python
doc = nlp("The cat sat on the mat.")

# Get all lemmas
lemmas = doc.get('lemma')  # ['the', 'cat', 'sit', ...]

# Get multiple fields
text_and_lemma = doc.get(['text', 'lemma'])  # [['the', 'the'], ['cat', 'cat'], ...]

# Get by sentences
lemmas_by_sent = doc.get('lemma', as_sentences=True)  # [[...], [...]]

# Get from tokens instead of words
token_texts = doc.get('text', from_token=True)
```

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

### Handle ProcessorRequirementsException

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/errors.md

Catch initialization failures caused by missing dependencies or incompatible environments.

```python
from stanza.pipeline.processor import ProcessorRequirementsException
import stanza

try:
    nlp = stanza.Pipeline('en', processors='ner')
except ProcessorRequirementsException as e:
    print(f"Processor {e.processor_type} failed: {e.message}")
```

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

### Find Nth Occurrence of Substring

Source: https://github.com/stanfordnlp/stanza/blob/main/demo/semgrex visualization.ipynb

A utility function to find the starting index of the nth occurrence of a substring within a larger string. Useful for parsing and manipulating text data.

```python
def find_nth(haystack, needle, n):
    """
    Returns the starting index of the nth occurrence of the substring 'needle' in the string 'haystack'.
    """
    start = haystack.find(needle)
    while start >= 0 and n > 1:
        start = haystack.find(needle, start + len(needle))
        n -= 1
    return start
```

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

### download()

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/README.md

Downloads the necessary models for the Stanza library.

```APIDOC
## download()

### Description
Downloads models required for processing text with Stanza.
```

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

### Initialize Sentence Class

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/document.md

Constructor for the Sentence class, which manages tokens and document context.

```python
class Sentence(StanzaObject):
    def __init__(self, tokens, doc=None, empty_words=None):
```

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

### Initialize Multilingual Pipeline

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/INDEX.md

Use the MultilingualPipeline to handle documents containing multiple languages.

```python
nlp = stanza.MultilingualPipeline()
doc = nlp("Hello. Bonjour. Hola.")
```

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

### Pipeline Constructor

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/pipeline.md

Initializes a new Stanza pipeline with specified language, model directory, and processor configurations.

```APIDOC
## Pipeline.__init__

### Description
Initializes the Stanza pipeline, which loads the necessary models and configures the requested NLP processors.

### Parameters
#### Constructor Parameters
- **lang** (str) - Optional - Language code (e.g., 'en', 'fr'). Default: 'en'
- **dir** (str) - Optional - Directory to store/load models. Default: DEFAULT_MODEL_DIR
- **package** (str) - Optional - Model package to use. Default: 'default'
- **processors** (dict) - Optional - Dictionary specifying processors to use (e.g., {'tokenize': 'default'}).
- **use_gpu** (bool) - Optional - Whether to use GPU if available.
- **device** (str) - Optional - Device to use ('cpu' or 'cuda:0').
- **download_method** (DownloadMethod) - Optional - Resource download strategy.

### Processor Configuration
Processor-specific options can be passed as keyword arguments using the format `{processor}_{option}` (e.g., `tokenize_pretokenized=True`).
```

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

### Test Pipeline Functionality

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/utilities.md

Initializes a basic English pipeline and processes a test string to ensure the core library is functioning correctly.

```python
import stanza

try:
    nlp = stanza.Pipeline('en')
    doc = nlp("Test")
    print(f"Pipeline working: {len(doc.sentences)} sentence(s)")
except Exception as e:
    print(f"Pipeline error: {e}")
```

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

### Stanza Pipeline Initialization and Semgrex Execution

Source: https://github.com/stanfordnlp/stanza/blob/main/demo/semgrex visualization.ipynb

Initializes a Stanza NLP pipeline with specified processors and executes Semgrex queries against a document. This is the main entry point for demonstrating Semgrex functionality.

```python
import stanza

def main():
    nlp = stanza.Pipeline("en", processors="tokenize,pos,lemma,depparse")

    # doc = nlp("This a dummy sentence. Banning opal removed all artifact decks from the meta.  I miss playing lantern. This is a dummy sentence.")
    doc = nlp("Banning opal removed artifact decks from the meta. Banning tennis resulted in players banning people.")
    # A single result .result[i].result[j] is a list of matches for sentence i on semgrex query j.
    queries = ["{pos:NN}=object <obl {}=action",
               "{cpos:NOUN}=thing <obj {cpos:VERB}=action"]
    res = visualize_search_doc(doc, queries, "en")
    print(res[0])  # see the first sentence's deprel visualization HTML
    print("---------------------------------------")
    print(res[1])  # second sentence's deprel visualization HTML
    return


if __name__ == '__main__':
    main()
```

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

### Initialize Document class

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/document.md

Constructor definition for the Document class, which acts as the main container for processed text.

```python
class Document(StanzaObject):
    def __init__(self, sentences, text=None, comments=None, empty_sentences=None):
```

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

### Load Custom Models

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/configuration.md

Point the pipeline to specific model files instead of using the default downloaded versions.

```python
import stanza

# Use custom trained models
nlp = stanza.Pipeline('en',
    pos_model_path='/path/to/custom_pos.pt',
    depparse_model_path='/path/to/custom_depparse.pt'
)
```

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

### Download Stanza Language Models

Source: https://github.com/stanfordnlp/stanza/blob/main/stanza/pipeline/demo/README.md

Download necessary language models for Stanza before using the demo server. Replace '<language_code>' with the desired language (e.g., 'en' for English).

```python
import stanza
stanza.download(<language_code>)
```

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

### Configure Download Strategies

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/configuration.md

Control how the pipeline handles resource downloads, such as disabling them or forcing updates.

```python
import stanza
from stanza.pipeline.core import DownloadMethod

# No automatic downloads
nlp = stanza.Pipeline('en',
    download_method=DownloadMethod.NONE
)

# Reuse cached resources, download only missing models
nlp = stanza.Pipeline('en',
    download_method=DownloadMethod.REUSE_RESOURCES
)

# Force fresh resource download
nlp = stanza.Pipeline('en',
    download_method=DownloadMethod.DOWNLOAD_RESOURCES
)
```

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

### Initialize MultilingualPipeline

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/multilingual.md

Defines the constructor for the MultilingualPipeline class.

```python
class MultilingualPipeline(Pipeline):
    def __init__(
        self,
        lang_id_package='langid',
        dir=DEFAULT_MODEL_DIR,
        pipelines=None,
        logging_level=None,
        verbose=None,
        use_gpu=None,
        download_method=DownloadMethod.DOWNLOAD_RESOURCES,
        resources_url=DEFAULT_RESOURCES_URL,
        resources_branch=None,
        resources_version=DEFAULT_RESOURCES_VERSION,
        resources_filepath=None,
        proxies=None,
        foundation_cache=None,
        device=None,
        **kwargs
    )
```

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

### Construct CoreNLPClient Instance

Source: https://github.com/stanfordnlp/stanza/blob/main/demo/Stanza_CoreNLP_Interface.ipynb

Instantiates a CoreNLPClient with specified annotators, memory allocation, and endpoint. Useful for setting up the NLP processing pipeline.

```python
client = CoreNLPClient(
    annotators=['tokenize','ssplit', 'pos', 'lemma', 'ner'], 
    memory='4G', 
    endpoint='http://localhost:9001',
    be_quiet=True)
print(client)
```

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

### Configure POS Tagger Options

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/configuration.md

Specify custom model paths and batch sizes for the POS tagging processor.

```python
nlp = stanza.Pipeline('en',
    pos_batch_size=32,
    pos_model_path='/custom/model.pt'
)
```

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

### Initialize Word Class

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/document.md

Constructor for the Word class, which represents a lexical unit resulting from tokenization.

```python
class Word(StanzaObject):
    def __init__(self, sent, word_dict):
```

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

### Initialize Multi-Model NER Pipeline

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/types.md

Configures a pipeline for Named Entity Recognition using multiple model paths and associated dependencies.

```python
nlp = stanza.Pipeline(
    'en',
    processors={'ner': 'default'},
    ner_model_path=[
        '/path/to/ontonotes.pt',
        '/path/to/bionlp.pt'
    ],
    ner_dependencies=[
        {'forward_charlm_path': '/path/to/charlm1.pt'},
        {'forward_charlm_path': '/path/to/charlm2.pt'}
    ]
)
```

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

### Configure GPU and Device Usage

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/configuration.md

Control hardware acceleration by specifying the device or forcing CPU usage.

```python
import stanza

# Use GPU if available
nlp = stanza.Pipeline('en', use_gpu=True)

# Use specific GPU
nlp = stanza.Pipeline('en', device='cuda:0')

# Force CPU
nlp = stanza.Pipeline('en', device='cpu')
```

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

### Check for Running Java Processes

Source: https://github.com/stanfordnlp/stanza/blob/main/demo/Stanza_CoreNLP_Interface.ipynb

Lists running processes to verify that the StanfordCoreNLPServer Java process is active.

```bash
!ps -o pid,cmd | grep java
```

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

### Handle Unsupported Processor Errors

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/errors.md

Verify processor availability for a language or provide a custom model path to the pipeline.

```python
# Check available processors for language
stanza.download('en', processors='ner')

# Use different language
nlp = stanza.Pipeline('en', processors='ner')

# Provide custom model
nlp = stanza.Pipeline('en', ner_model_path='/path/to/custom.pt')
```

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

### Configure Tokenizer Options

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/configuration.md

Pass tokenizer-specific settings to the pipeline constructor to control batching and sentence splitting behavior.

```python
nlp = stanza.Pipeline('en',
    tokenize_no_ssplit=True,
    tokenize_batch_size=64
)
```

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

### Initialize Token Class

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/document.md

Constructor for the Token class, which represents a single or multi-word token within a sentence.

```python
class Token(StanzaObject):
    def __init__(self, sent, token_dict):
```

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

### Configure processor batch sizes

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/processors.md

Set batch sizes for individual processors during Pipeline initialization to optimize performance.

```python
import stanza

# Configure individual processors
nlp = stanza.Pipeline('en',
    tokenize_batch_size=64,
    pos_batch_size=32,
    depparse_batch_size=16,
    lemma_use_identity=False
)
```

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

### Pipeline Configuration Dictionary

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/types.md

Define pipeline settings using a dictionary with top-level keys and processor-specific configurations.

```python
config = {
    'lang': 'en',
    'mode': 'predict',
    
    # Tokenizer config
    'tokenize_batch_size': 32,
    'tokenize_no_ssplit': False,
    'tokenize_pretokenized': False,
    
    # POS tagger config
    'pos_batch_size': 32,
    'pos_model_path': '/path/to/model.pt',
    
    # Lemmatizer config
    'lemma_batch_size': 32,
    'lemma_model_path': '/path/to/model.pt',
    'lemma_use_identity': False,
    
    # Dependency parser config
    'depparse_batch_size': 32,
    'depparse_model_path': '/path/to/model.pt',
    
    # NER config (supports multiple models)
    'ner_model_path': ['/path/to/model1.pt', '/path/to/model2.pt'],
    'ner_batch_size': 32,
    'ner_dependencies': [
        {'forward_charlm_path': '/path/to/model.pt'},
        {'forward_charlm_path': '/path/to/model.pt'}
    ],
}
```

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

### Manage Multi-Word Token Expansions

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/document.md

Methods for setting and retrieving multi-word token expansion data.

```python
def set_mwt_expansions(self, expansions, fake_dependencies=False, process_manual_expanded=None):
```

```python
def get_mwt_expansions(self, evaluation=False):
```

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

### Select Language Packages

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/configuration.md

Specify the language package to use for a given language code.

```python
import stanza

# Use English Web Treebank package
nlp = stanza.Pipeline('en', package='ewt')

# Use Google Stanford Dependency package
nlp = stanza.Pipeline('fr', package='gsd')
```

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

### Custom Model Pipeline

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/INDEX.md

Initializes a pipeline using custom model file paths for specific processors.

```python
nlp = stanza.Pipeline('en',
    pos_model_path='/path/to/custom_pos.pt',
    depparse_model_path='/path/to/custom_depparse.pt'
)
```

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

### Initialize Processor Base Class

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/processors.md

The constructor for the abstract Processor class, requiring a configuration dictionary and optional pipeline reference.

```python
class Processor:
    def __init__(self, config, pipeline=None, device='cpu'):
```

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

### Print and Access Dependency Structures

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/utilities.md

Use print_dependencies() for formatted output or iterate through words to access head information programmatically.

```python
# Print formatted dependency structure
sentence.print_dependencies()

# Access programmatically
for word in sentence.words:
    if word.head:
        head_word = sentence.words[word.head - 1]
        print(f"{word.text} depends on {head_word.text}")
```

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

### Configure Dependency Parser Options

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/configuration.md

Adjust batch size for the dependency parsing processor.

```python
nlp = stanza.Pipeline('en',
    depparse_batch_size=16
)
```

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

### Initialize Pipeline Class

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/pipeline.md

The constructor for the Pipeline class, used to configure language, processors, and hardware settings.

```python
class Pipeline:
    def __init__(
        self,
        lang='en',
        dir=DEFAULT_MODEL_DIR,
        package='default',
        processors={},
        logging_level=None,
        verbose=None,
        use_gpu=None,
        model_dir=None,
        download_method=DownloadMethod.DOWNLOAD_RESOURCES,
        resources_url=DEFAULT_RESOURCES_URL,
        resources_branch=None,
        resources_version=DEFAULT_RESOURCES_VERSION,
        resources_filepath=None,
        proxies=None,
        foundation_cache=None,
        device=None,
        allow_unknown_language=False,
        **kwargs
    )
```

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

### Configure NER Options

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/configuration.md

Load single or multiple NER models, including optional character language model dependencies.

```python
# Single NER model
nlp = stanza.Pipeline('en',
    ner_model_path='/path/to/model.pt'
)

# Multiple NER models
nlp = stanza.Pipeline('en',
    ner_model_path=['/path/to/model1.pt', '/path/to/model2.pt'],
    ner_dependencies=[
        {'forward_charlm_path': '/path/to/charlm1.pt'},
        {'forward_charlm_path': '/path/to/charlm2.pt'}
    ]
)
```

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

### Visualize Arabic Dependency Strings

Source: https://github.com/stanfordnlp/stanza/blob/main/demo/Dependency_Visualization_Testing.ipynb

Visualizes dependency trees for a list of Arabic sentences. Ensure the 'ar' language code is correctly specified.

```python
from stanza.utils.visualization.dependency_visualization import visualize_strings

ar_strings = ['برلين ترفض حصول شركة اميركية على رخصة تصنيع دبابة "ليوبارد" الالمانية', "هل بإمكاني مساعدتك؟", 
              "أراك في مابعد", "لحظة من فضلك"]
# Testing with right to left language
visualize_strings(ar_strings, "ar")
```

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

### stanza.Pipeline Processor Configuration

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/processors.md

Configuring specific processor variants and implementations during pipeline initialization.

```APIDOC
## stanza.Pipeline Processor Configuration

### Description
Configure the Stanza pipeline by selecting specific processor variants or implementations for supported tasks.

### Usage
```python
# Use identity lemmatizer for a language
nlp = stanza.Pipeline('en', lemma_use_identity=True)

# Use specific tokenizer variant
nlp = stanza.Pipeline('vi', processors={'tokenize': 'pkkvie'})
```

### Supported Processor Variants
| Processor | Variants | Description |
|-----------|----------|-------------|
| lemma | default, identity, identity_with_pos | Lemmatization strategies |
| tokenize | default, (language-specific) | Tokenization algorithms |
| pos | default, (language-specific) | POS tagging models |
```

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

### stanza.download_corenlp_models

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/resources.md

Downloads additional models for the CoreNLP toolkit.

```APIDOC
## stanza.download_corenlp_models(corenlp_root=DEFAULT_CORENLP_PATH)

### Description
Download additional models for CoreNLP.

### Parameters
- **corenlp_root** (str) - Optional - Root directory of CoreNLP installation

### Returns
- None
```

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

### Configure Multi-Model NER

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/configuration.md

Load multiple Named Entity Recognition models by providing lists of paths and dependency configurations.

```python
import stanza

# Load multiple NER models
nlp = stanza.Pipeline('en',
    ner_model_path=[
        '/path/to/ontonotes.pt',
        '/path/to/biomedical.pt'
    ],
    ner_dependencies=[
        {'forward_charlm_path': '/path/to/charlm1.pt'},
        {'forward_charlm_path': '/path/to/charlm2.pt'}
    ]
)
```

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

### file_exists(path, md5)

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/resources.md

Verifies if a file exists and matches the provided MD5 hash.

```APIDOC
## file_exists(path, md5)

### Description
Check if file exists and matches expected MD5.

### Signature
`def file_exists(path, md5)`

### Parameters
- **path** (str) - Required - File path to check
- **md5** (str) - Required - Expected MD5 hash

### Returns
- **bool** - True if file exists and MD5 matches
```

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

### Accessing Default Resource Constants

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/resources.md

Constants defining default paths and URLs for Stanza model management.

```python
USER_CACHE_DIR        # User cache directory for Stanza models
DEFAULT_MODEL_DIR     # Default model directory (environment variable: STANZA_RESOURCES_DIR)
DEFAULT_RESOURCES_URL # URL for resources (environment variable: STANZA_RESOURCES_URL)
DEFAULT_RESOURCES_VERSION  # Version of resources (environment variable: STANZA_RESOURCES_VERSION)
DEFAULT_MODEL_URL     # URL for model files (environment variable: STANZA_MODEL_URL)
```

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

### bulk_process(docs, *args, **kwargs)

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/pipeline.md

Processes multiple documents efficiently and returns them in the same order as the input.

```APIDOC
## bulk_process(docs, *args, **kwargs)

### Description
Processes multiple documents efficiently.

### Parameters
- **docs** (list) - Required - List of str or Document objects to process.

### Returns
- list[Document] - Processed documents in same order as input.
```

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

### download_corenlp_models()

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/README.md

Downloads models for the CoreNLP package.

```APIDOC
## download_corenlp_models()

### Description
Downloads the specific models required for CoreNLP.
```

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

### make_table(columns, data)

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/utilities.md

Creates a formatted ASCII table from provided column headers and data rows.

```APIDOC
## make_table(columns, data)

### Description
Creates a formatted ASCII table string from a list of column headers and a list of data tuples.

### Parameters
- **columns** (list[str]) - Required - Column header names
- **data** (list[tuple]) - Required - Rows of data (tuples)

### Returns
- **str** - Formatted table string

### Example
```python
from stanza.utils.helper_func import make_table

columns = ['Name', 'Score']
data = [('Model A', 0.95), ('Model B', 0.87)]
table = make_table(columns, data)
print(table)
```
```

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

### process_conllu(doc, ignore_gapping=True, processors=None)

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/pipeline.md

Processes CoNLL-U formatted text.

```APIDOC
## process_conllu(doc, ignore_gapping=True, processors=None)

### Description
Process CoNLL-U formatted text.

### Parameters
- **doc** (str) - Required - CoNLL-U formatted text.
- **ignore_gapping** (bool) - Optional - Ignore gapping in multi-word tokens (default: True).
- **processors** (str, list, or None) - Optional - Processors to apply.

### Returns
- Document - Processed document.
```

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

### Construct Stanza Pipeline

Source: https://github.com/stanfordnlp/stanza/blob/main/demo/Stanza_Beginners_Guide.ipynb

Builds Stanza processing pipelines for specific languages. Allows customization of processors, GPU usage, and logging verbosity.

```python
# Build an English pipeline, with all processors by default
print("Building an English pipeline...")
en_nlp = stanza.Pipeline('en')

# Build a Chinese pipeline, with customized processor list and no logging, and force it to use CPU
print("Building a Chinese pipeline...")
zh_nlp = stanza.Pipeline('zh', processors='tokenize,lemma,pos,depparse', verbose=False, use_gpu=False)
```

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

### Defining ensure_dir Function

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/resources.md

Signature for the directory creation utility.

```python
def ensure_dir(path):
```

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

### Import Stanza CoreNLP Client

Source: https://github.com/stanfordnlp/stanza/blob/main/demo/Stanza_CoreNLP_Interface.ipynb

Imports the necessary client module from the Stanza library.

```python
from stanza.server import CoreNLPClient
```

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

### Use Processor Name Constants

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/types.md

Import and use predefined constants to specify processors in a Stanza pipeline or during document processing.

```python
from stanza.pipeline._constants import TOKENIZE, POS, LEMMA, DEPPARSE

# Process with specific processors
nlp = stanza.Pipeline('en', processors=[TOKENIZE, POS, LEMMA, DEPPARSE])

# Run only specific processors on a document
doc = nlp.process(text, processors=[POS, LEMMA])
```

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

### Initialize Entity Class

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/document.md

Constructor for the Entity class, representing a named entity extracted from NER annotations.

```python
class Entity(StanzaObject):
    def __init__(self, doc, start, end, label):
```

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

### Load a registered custom processor

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/utilities.md

Include the registered processor name in the processors argument when initializing the Pipeline.

```python
# Custom processors can be loaded if registered
nlp = stanza.Pipeline('en', processors='my_processor')
```

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

### Default Model Directory on Windows

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/configuration.md

The standard path where Stanza stores downloaded models on Windows systems.

```text
C:\Users\<username>\AppData\Local\StanfordNLP\stanza\Cache\resources\
```

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

### Configure Lemmatizer Options

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/configuration.md

Enable identity lemmatization to return original text instead of performing lemmatization.

```python
nlp = stanza.Pipeline('en',
    lemma_use_identity=True  # No lemmatization, return original text
)
```

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

### Import CoreNLPClient

Source: https://github.com/stanfordnlp/stanza/blob/main/demo/Stanza_CoreNLP_Interface.ipynb

Imports the CoreNLPClient class from the Stanza library, which is used to establish a connection to the background CoreNLP server process.

```python
# Import the CoreNLPClient class from Stanza
from stanza.server.client import CoreNLPClient
```

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

### Detect GPU Configuration

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/utilities.md

Checks for CUDA availability via PyTorch and attempts to initialize a Stanza pipeline with GPU support enabled.

```python
import torch
import stanza

print(f"CUDA available: {torch.cuda.is_available()}")
if torch.cuda.is_available():
    print(f"CUDA device: {torch.cuda.get_device_name(0)}")
    print(f"CUDA memory: {torch.cuda.get_device_properties(0)}")

# Create pipeline with GPU
nlp = stanza.Pipeline('en', use_gpu=True)
print(f"Pipeline device: {nlp.device}")
```

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

### Handle UnknownProcessorError

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/errors.md

Catch errors when an unrecognized processor name is requested during download or initialization.

```python
import stanza

try:
    stanza.download('en', processors='unknown_processor')
except stanza.resources.common.UnknownProcessorError as e:
    print(f"Processor '{e.unknown_processor}' not recognized")
```

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

### stanza.download

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/INDEX.md

Utility function to download pre-trained models for specific languages.

```APIDOC
## stanza.download(lang)

### Description
Downloads the necessary model files for the specified language code to the local cache.
```

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

### Visualize English Dependency Strings

Source: https://github.com/stanfordnlp/stanza/blob/main/demo/Dependency_Visualization_Testing.ipynb

Visualizes dependency trees for a list of English sentences. Use the 'en' language code for English text.

```python
from stanza.utils.visualization.dependency_visualization import visualize_strings

en_strings = ["This is a sentence.", 
              "He is wearing a red shirt",
              "Barack Obama was born in Hawaii. He was elected President of the United States in 2008."]
# Testing with left to right languages
visualize_strings(en_strings, "en")
```

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

### Stanza Module Structure

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/INDEX.md

Visual representation of the Stanza package directory layout.

```text
stanza/
├── __init__.py                 # Top-level exports: Pipeline, download, etc.
├── pipeline/
│   ├── core.py                 # Pipeline class
│   ├── processor.py            # Base Processor class
│   ├── multilingual.py         # MultilingualPipeline
│   ├── tokenize_processor.py   # Tokenization
│   ├── mwt_processor.py        # Multi-word tokens
│   ├── pos_processor.py        # Part-of-speech tagging
│   ├── lemma_processor.py      # Lemmatization
│   ├── depparse_processor.py   # Dependency parsing
│   ├── ner_processor.py        # Named entity recognition
│   ├── sentiment_processor.py  # Sentiment analysis
│   ├── constituency_processor.py # Constituency parsing
│   ├── coref_processor.py      # Coreference resolution
│   ├── langid_processor.py     # Language identification
│   └── registry.py             # Processor registry
├── models/common/
│   ├── doc.py                  # Document, Sentence, Token, Word classes
│   ├── foundation_cache.py     # Model caching
│   └── constant.py             # Constants and language mapping
├── resources/
│   ├── common.py               # Resource management functions
│   ├── installation.py         # CoreNLP installation
│   └── default_packages.py     # Default package definitions
└── utils/
    └── conll.py                # CoNLL format utilities
```

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

### Initialize Stanza Pipeline with specific processors

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/configuration.md

Configures the pipeline to load specific processors with their respective model packages.

```python
nlp = stanza.Pipeline('en', processors={
    'tokenize': 'default',
    'pos': 'default',
    'lemma': 'default',
    'depparse': 'default'
})
```

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

### Visualize Chinese NER with Custom Colors and Selection

Source: https://github.com/stanfordnlp/stanza/blob/main/demo/NER_Visualization.ipynb

Visualizes named entities in Chinese text with custom colors for specific entity types and also demonstrates selecting only specific entity types for visualization. Ensure the 'zh' language model is available.

```python
from stanza.utils.visualization.ner_visualization import visualize_strings

zh_strings = ['''来自犹他州的基督徒塞缪尔杰克逊前往肯尼迪机场搭乘航班飞往纽约。
                 他正在考虑参加美国公开赛，这是除了温布尔登之外他最喜欢的网球赛事。
                 那将是一次梦想之旅，当然不可能，因为它的出勤费为 5000 美元，距离 5000 英里。
                 在去的路上，他看了 2 个小时的超级碗比赛，看了 1 个小时的托尔斯泰的《战争与碎片》。
                 在纽约，他穿过布鲁克林大桥，聆听了贝多芬的第五交响曲以及 玛丽亚凯莉的“圣诞节我想要的就是你”。''',
              "我觉得罗家费德勒住在加州, 在美国里面。 વિઝ્યુઅલાઈઝેશન માટે."]
visualize_strings(zh_strings, "zh", colors={"PERSON": "yellow", "DATE": "red", "GPE": "blue"})
visualize_strings(zh_strings, "zh", select=['PERSON', 'DATE'])

```

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

### Document Serialization and Utility Methods

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/document.md

Methods for converting documents to dictionaries, building entities, reindexing, and exporting to CoNLL-U format.

```python
def to_dict(self, fields=None, as_sentences=False):
```

```python
def build_ents(self):
```

```python
def reindex_sentences(self, start_idx=0):
```

```python
def __str__():
```

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

### Resolve Model File Not Found Errors

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/errors.md

Use these commands to download missing models or configure the resource directory path.

```python
# Download models
stanza.download('en')

# Or specify directory
import os
os.environ['STANZA_RESOURCES_DIR'] = '/path/to/models'
stanza.download('en')
```

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

### Import Stanza Public API

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/INDEX.md

Essential classes and functions exported at the top level of the package.

```python
from stanza import (
    Pipeline,                    # Main pipeline class
    MultilingualPipeline,       # Multi-language pipeline
    download,                    # Download models
    install_corenlp,            # Install CoreNLP
    download_corenlp_models,    # Download CoreNLP models
    Document,                    # Document container class
    DownloadMethod,             # Enum for download strategy
)
```

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

### Visualize English Dependency Trees

Source: https://github.com/stanfordnlp/stanza/blob/main/demo/CONLL_Dependency_Visualizer_Example.ipynb

Generates visualizations for English dependency trees from a CONLL-U file. Use `sent_count` to specify the number of sentences to visualize.

```python
from stanza.utils.visualization.conll_deprel_visualization import conll_to_visual

# load necessary conllu files - expected to be in the demo directory along with the notebook
en_file = "en_test.conllu.txt"

# testing left to right languages
conll_to_visual(en_file, "en", sent_count=2)
conll_to_visual(en_file, "en", sent_count=10)
#conll_to_visual(en_file, "en", display_all=True)
```

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

### Set CORENLP_HOME Environment Variable (Terminal)

Source: https://github.com/stanfordnlp/stanza/blob/main/demo/Stanza_CoreNLP_Interface.ipynb

Demonstrates how to set the CORENLP_HOME environment variable in a terminal using the 'export' command. This is an alternative to setting it via Python's os library in environments like Colab.

```bash
export CORENLP_HOME=path_to_corenlp_dir
```

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

### Define ResourcesFileNotFoundError class

Source: https://github.com/stanfordnlp/stanza/blob/main/_autodocs/api-reference/resources.md

Raised when a required resources file is missing from the filesystem.

```python
class ResourcesFileNotFoundError(FileNotFoundError):
    def __init__(self, resources_filepath):
```
Tokens:
Raw