A lightweight, pip-installable Python library for deep text analysis — covering everything from Zipf's law to sentiment, readability, TF-IDF, and more. Comes with a Streamlit dashboard and a FastAPI backend out of the box.

• Features
• Installation
• Quick Start
• Module Reference
  • compute_stats
  • analyze_groupwords
  • analyze_zipf
  • analyze_heaps
  • calculate_density
  • compare_vocab
  • compute_tfidf
  • compute_ngrams
  • analyze_sentiment
  • compute_readability
  • analyze_pos
  • generate_wordcloud
• Streamlit Dashboard
• FastAPI Backend
• Dependencies
• Project Structure
• License

pip install aize

pip install aize[dashboard]

pip install aize[api]

pip install aize[all]

git clone https://github.com/eokoaze/aize.git
cd aize
pip install -e .[all]

Python 3.9+ is required.

import aize

text = """
Natural language processing is a subfield of linguistics and artificial intelligence.
It is primarily concerned with giving computers the ability to understand text and speech.
"""

# Basic stats
print(aize.compute_stats(text))

# Sentiment
print(aize.analyze_sentiment(text))

# Readability
print(aize.compute_readability(text))

# Zipf's Law
print(aize.analyze_zipf(text))

from aize import compute_stats

result = compute_stats(text)

Returns basic corpus statistics.

from aize import analyze_groupwords

result = analyze_groupwords(text)

Groups words by their character length and returns frequency counts per length bucket.

from aize import analyze_zipf

result = analyze_zipf(text)

Computes Zipf's Law statistics over the text.

from aize import analyze_heaps

result = analyze_heaps(text)

Returns a vocabulary growth curve (Heap's Law). Useful for visualising how the vocabulary expands as more text is read.

from aize import calculate_density

result = calculate_density(text)

Calculates the proportion of stopwords in the text, returning a stopword density percentage and associated word lists.

from aize import compare_vocab

result = compare_vocab({"doc1": text1, "doc2": text2})

Compares vocabulary across multiple documents — unique words per document, shared vocabulary, and overlap statistics.

from aize import compute_tfidf

result = compute_tfidf(
    texts=["text of doc1...", "text of doc2..."],
    labels=["doc1", "doc2"],
    top_n=15
)
# Returns: {"doc1": [("word", score), ...], "doc2": [...]}

Extracts the top n TF-IDF keywords for each document in a corpus. Uses scikit-learn under the hood with English stopword filtering.

from aize import compute_ngrams

bigrams  = compute_ngrams(text, n=2, top_n=20)
trigrams = compute_ngrams(text, n=3, top_n=20)
# Returns: [("phrase here", count), ...]

Returns the most frequent n-grams (bigrams, trigrams, etc.) from the text.

from aize import analyze_sentiment

result = analyze_sentiment(text)

Runs VADER sentiment analysis. NLTK's vader_lexicon is auto-downloaded on first use.

from aize import compute_readability

result = compute_readability(text)

Computes Flesch-Kincaid readability metrics.

from aize import analyze_pos

result = analyze_pos(text)

Returns a part-of-speech frequency breakdown (nouns, verbs, adjectives, adverbs, etc.) using NLTK's POS tagger.

from aize import generate_wordcloud

image = generate_wordcloud(text)

Generates a word cloud image from the input text. Returns a PIL Image object that can be displayed or saved.

image.save("wordcloud.png")

An interactive, browser-based UI for all analyses is included.

streamlit run nlp_dashboard.py

The dashboard lets you upload one or more .txt files and interactively explore all analysis modules with charts and tables powered by Plotly.

A REST API is included for programmatic or remote access to the toolkit.

uvicorn api:app --reload

The API will be available at http://127.0.0.1:8000. Interactive docs are auto-generated at:

• Swagger UI: http://127.0.0.1:8000/docs
• ReDoc: http://127.0.0.1:8000/redoc

aize/
├── aize/                        # Core library package
│   ├── __init__.py              # Public API surface
│   └── analysis/
│       ├── stats.py             # Basic text statistics
│       ├── groupwords.py        # Word length grouping
│       ├── zipf.py              # Zipf's law analysis
│       ├── heaps.py             # Heap's law analysis
│       ├── stopwords.py         # Stopword density
│       ├── vocab.py             # Vocabulary comparison
│       ├── tfidf.py             # TF-IDF & n-grams
│       ├── sentiment.py         # VADER sentiment
│       ├── readability.py       # Flesch-Kincaid scores
│       ├── pos.py               # POS tagging
│       └── wordcloud_gen.py     # Word cloud generation
├── .github/workflows/
│   └── publish.yml              # Auto-publish to PyPI on version tags
├── nlp_dashboard.py             # Streamlit dashboard
├── api.py                       # FastAPI REST backend
├── pyproject.toml               # Package config & dependency extras
├── MANIFEST.in                  # Source distribution file rules
├── requirements.txt             # All-inclusive dev requirements
└── README.md

This project is licensed under the MIT License. See LICENSE for details.

Built with ❤️ using Python, NLTK, scikit-learn, Streamlit & FastAPI