### Complete Workflow Example

Source: https://context7.com/raduangelescu/gutenbergpy/llms.txt

Demonstrates a full workflow including cache creation, querying, downloading, and text processing for data preparation. The cache creation is a one-time setup.

```python
from gutenbergpy.gutenbergcache import GutenbergCache
import gutenbergpy.textget

# Step 1: Create cache (one-time setup)
if not GutenbergCache.exists():
    print("Creating Gutenberg cache (this takes a few minutes)...")
    GutenbergCache.create()
```

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

### Install GutenbergPy via pip

Source: https://github.com/raduangelescu/gutenbergpy/blob/master/README.md

Standard installation command for the package.

```bash
pip install gutenbergpy
```

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

### Complete Workflow Example

Source: https://context7.com/raduangelescu/gutenbergpy/llms.txt

An end-to-end example demonstrating cache creation, querying, text downloading, and processing for data preparation.

```APIDOC
## Complete Workflow Example

A full example demonstrating cache creation, querying, downloading, and text processing for machine learning data preparation.

```python
from gutenbergpy.gutenbergcache import GutenbergCache
import gutenbergpy.textget

# Step 1: Create cache (one-time setup)
if not GutenbergCache.exists():
    print("Creating Gutenberg cache (this takes a few minutes)...")
    GutenbergCache.create()

# Step 2: Query for books (e.g., audio books)
audio_books = GutenbergCache.get_cache().query(types=['Sound'])
print(f"Found {len(audio_books)} audio books.")

# Step 3: Download and clean a specific book
book_id_to_process = 2701 # Moby Dick

try:
    raw_text = gutenbergpy.textget.get_text_by_id(book_id_to_process)
    cleaned_text = gutenbergpy.textget.strip_headers(raw_text)
    decoded_text = cleaned_text.decode('utf-8')
    
    print(f"Successfully processed book ID {book_id_to_process}.")
    print(f"Word count: {len(decoded_text.split())}")
    # Further NLP processing can be done on decoded_text

except gutenbergpy.textget.UnknownDownloadUri:
    print(f"Error: Could not find book with ID {book_id_to_process}.")
except Exception as e:
    print(f"An unexpected error occurred: {e}")
```
```

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

### Install GutenbergPy from source

Source: https://github.com/raduangelescu/gutenbergpy/blob/master/README.md

Alternative installation method using the source repository.

```bash
git clone https://github.com/raduangelescu/gutenbergpy
python setup.py install
```

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

### Querying Audio Books

Source: https://context7.com/raduangelescu/gutenbergpy/llms.txt

Example of how to query for audio books using the cache.

```APIDOC
## Query by book type

```python
audio_books = cache.query(types=['Sound'])
print(f"Found {len(audio_books)} audio books")
```
```

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

### Get Text by ID

Source: https://context7.com/raduangelescu/gutenbergpy/llms.txt

Downloads the raw text of a book using its Gutenberg ID, with automatic caching and encoding handling.

```APIDOC
## get_text_by_id

Downloads the raw text of a book from Project Gutenberg by its Gutenberg ID. The function automatically caches downloaded files locally as compressed gzip files, handles encoding detection, and returns UTF-8 encoded bytes.

### Parameters

#### Path Parameters

- **book_id** (int) - Required - The unique Gutenberg ID of the book.

### Request Example

```python
import gutenbergpy.textget

# Download Moby Dick (ID: 2701)
raw_book = gutenbergpy.textget.get_text_by_id(2701)
print(f"Downloaded {len(raw_book)} bytes")
print(f"First 200 characters: {raw_book[:200]}")

# Download Pride and Prejudice (ID: 1342)
pride_prejudice = gutenbergpy.textget.get_text_by_id(1342)
print(f"Downloaded Pride and Prejudice: {len(pride_prejudice)} bytes")

# Download multiple books and save them
book_ids = [2701, 1342, 84, 11]  # Moby Dick, Pride and Prejudice, Frankenstein, Alice in Wonderland
books = {}

for book_id in book_ids:
    try:
        books[book_id] = gutenbergpy.textget.get_text_by_id(book_id)
        print(f"Downloaded book {book_id}: {len(books[book_id])} bytes")
    except gutenbergpy.textget.UnknownDownloadUri:
        print(f"Could not find book {book_id}")

# Subsequent calls use cached version (fast)
cached_book = gutenbergpy.textget.get_text_by_id(2701)
print("Book loaded from cache")
```

### Response

#### Success Response (200)

- **raw_book** (bytes) - The raw UTF-8 encoded bytes of the book's content.

#### Response Example

```json
{
  "example": "(bytes representing book content)"
}
```
```

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

### Create Gutenberg Cache

Source: https://context7.com/raduangelescu/gutenbergpy/llms.txt

Initializes the local metadata cache by downloading and parsing the Gutenberg RDF catalog.

```python
from gutenbergpy.gutenbergcache import GutenbergCache, GutenbergCacheTypes

# Create SQLite cache with all default options (recommended for first-time setup)
GutenbergCache.create()

# Create MongoDB cache instead
GutenbergCache.create(type=GutenbergCacheTypes.CACHE_TYPE_MONGODB)

# Create cache with fine-grained control
GutenbergCache.create(
    refresh=True,      # Delete old cache files first
    download=True,     # Download RDF file from Gutenberg
    unpack=True,       # Unpack the tar.bz2 archive
    parse=True,        # Parse RDF files in memory
    cache=True,        # Write parsed data to cache
    deleteTemp=True    # Clean up temporary files after
)

# Check if cache already exists before creating
if not GutenbergCache.exists():
    GutenbergCache.create()
    print("Cache created successfully")
else:
    print("Cache already exists")
```

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

### Native Database Queries

Source: https://context7.com/raduangelescu/gutenbergpy/llms.txt

Demonstrates how to execute raw SQL or MongoDB queries using `native_query` for advanced data retrieval.

```APIDOC
## cache.native_query

Executes raw database queries directly on the underlying SQLite or MongoDB database. This provides full access to the database schema for complex queries not supported by the standard query interface.

### SQLite Native Query Example

```python
from gutenbergpy.gutenbergcache import GutenbergCache

sqlite_cache = GutenbergCache.get_cache()

# Get all books with their details
results = sqlite_cache.native_query("""
    SELECT books.gutenbergbookid, titles.name, languages.name
    FROM books
    JOIN titles ON titles.bookid = books.id
    JOIN languages ON languages.id = books.languageid
    WHERE books.numdownloads > 1000
    LIMIT 10
""")
for row in results:
    print(f"Book {row[0]}: {row[1]} ({row[2]})")

# Get top downloaded books
top_books = sqlite_cache.native_query("""
    SELECT gutenbergbookid, numdownloads
    FROM books
    ORDER BY numdownloads DESC
    LIMIT 5
""")
for row in top_books:
    print(f"Book ID {row[0]}: {row[1]} downloads")
```

### MongoDB Native Query Example

```python
from gutenbergpy.gutenbergcache import GutenbergCache, GutenbergCacheTypes

mongo_cache = GutenbergCache.get_cache(GutenbergCacheTypes.CACHE_TYPE_MONGODB)

# Find English books with MongoDB query syntax
english_books = mongo_cache.native_query({'language': 'en'})
for book in english_books.limit(5):
    print(f"Book: {book['gutenberg_book_id']}, Language: {book['language']}")

# Complex MongoDB query
popular_english = mongo_cache.native_query({
    '$and': [
        {'language': 'en'},
        {'num_downloads': {'$gt': 500}}
    ]
})
```
```

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

### GutenbergCache.create

Source: https://context7.com/raduangelescu/gutenbergpy/llms.txt

Initializes the local metadata cache by downloading and parsing the Project Gutenberg RDF catalog.

```APIDOC
## GutenbergCache.create

### Description
Creates the local cache by downloading the RDF catalog from Project Gutenberg, parsing it, and storing the metadata in either SQLite or MongoDB.

### Parameters
#### Request Body
- **type** (GutenbergCacheTypes) - Optional - The type of cache to create (default: SQLite, supports MONGODB).
- **refresh** (bool) - Optional - If True, deletes old cache files first.
- **download** (bool) - Optional - If True, downloads the RDF file from Gutenberg.
- **unpack** (bool) - Optional - If True, unpacks the tar.bz2 archive.
- **parse** (bool) - Optional - If True, parses RDF files in memory.
- **cache** (bool) - Optional - If True, writes parsed data to cache.
- **deleteTemp** (bool) - Optional - If True, cleans up temporary files after completion.
```

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

### Configure Gutenberg Cache Settings

Source: https://context7.com/raduangelescu/gutenbergpy/llms.txt

Sets global configuration for database paths, download URLs, and connection strings before cache initialization.

```python
from gutenbergpy.gutenbergcachesettings import GutenbergCacheSettings

# Configure custom cache settings
GutenbergCacheSettings.set(
    CacheFilename="my_gutenberg.db",           # SQLite database filename
    CacheUnpackDir="my_cache/epub",            # Directory for unpacking RDF files
    CacheArchiveName="rdf-files.tar.bz2",      # Downloaded archive name
    ProgressBarMaxLength=50,                    # Progress bar display length
    CacheRDFDownloadLink="https://www.gutenberg.org/cache/epub/feeds/rdf-files.tar.bz2",
    TextFilesCacheFolder="my_texts",           # Folder for downloaded text files
    MongoDBCacheServer="mongodb://localhost:27017"  # MongoDB connection string
)

# Example: Set up cache in a specific project directory
import os
project_dir = os.path.expanduser("~/my_project/data")
os.makedirs(project_dir, exist_ok=True)

GutenbergCacheSettings.set(
    CacheFilename=os.path.join(project_dir, "gutenberg.db"),
    TextFilesCacheFolder=os.path.join(project_dir, "books")
)
```

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

### Initialize Gutenberg Cache

Source: https://github.com/raduangelescu/gutenbergpy/blob/master/README.md

Initializes the cache for either SQLite or MongoDB storage.

```python
from gutenbergpy.gutenbergcache import GutenbergCache
#for sqlite
GutenbergCache.create()
#for mongodb
GutenbergCache.create(type=GutenbergCacheTypes.CACHE_TYPE_MONGODB)
```

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

### Configure Cache Creation

Source: https://github.com/raduangelescu/gutenbergpy/blob/master/README.md

Creates the cache with specific boolean flags for refresh, download, unpack, parse, cache, and temporary file deletion.

```python
GutenbergCache.create(refresh=True, download=True, unpack=True, parse=True, cache=True, deleteTemp=True)
```

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

### GutenbergCacheSettings.set

Source: https://context7.com/raduangelescu/gutenbergpy/llms.txt

Configures global settings for the cache, including file paths, database connections, and download URLs.

```APIDOC
## GutenbergCacheSettings.set

### Description
Sets global configuration parameters for cache storage locations and database connection strings.

### Parameters
#### Request Body
- **CacheFilename** (str) - Optional - Filename for the SQLite database.
- **CacheUnpackDir** (str) - Optional - Directory for unpacking RDF files.
- **CacheArchiveName** (str) - Optional - Name of the downloaded archive.
- **ProgressBarMaxLength** (int) - Optional - Length of the progress bar display.
- **CacheRDFDownloadLink** (str) - Optional - URL for the RDF catalog download.
- **TextFilesCacheFolder** (str) - Optional - Folder for storing downloaded text files.
- **MongoDBCacheServer** (str) - Optional - Connection string for MongoDB.
```

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

### Execute and print cleaned text

Source: https://github.com/raduangelescu/gutenbergpy/blob/master/README.md

Demonstrates calling the retrieval function and printing a snippet of the cleaned output.

```python
cleaned_book, raw_book = usage_example()

# Cleaned Book
print(f'Example phrase from the cleaned book: {" ".join(str(cleaned_book[3000:3050]).split(" "))}')
```

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

### Build and Save Corpus

Source: https://context7.com/raduangelescu/gutenbergpy/llms.txt

Iterates through book IDs to build a list of dictionaries containing text and metadata, then saves the result to a JSON file.

```python
corpus = []
for book_id in english_fiction_ids[:10]:
    text = download_and_clean(book_id)
    if text:
        corpus.append({
            'id': book_id,
            'text': text,
            'length': len(text)
        })
        print(f"Added book {book_id} ({len(text)} characters)")

print(f"\nCorpus contains {len(corpus)} books")
print(f"Total characters: {sum(b['length'] for b in corpus)}")

import json
with open('gutenberg_corpus.json', 'w') as f:
    json.dump(corpus, f)
print("Corpus saved to gutenberg_corpus.json")
```

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

### Query Audio Books

Source: https://context7.com/raduangelescu/gutenbergpy/llms.txt

Query the cache for audio books. Requires the cache to be initialized.

```python
audio_books = cache.query(types=['Sound'])
print(f"Found {len(audio_books)} audio books")
```

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

### Execute Native Queries

Source: https://github.com/raduangelescu/gutenbergpy/blob/master/README.md

Executes native queries against the underlying SQLite or MongoDB database.

```python
#python
cache.native_query("SELECT * FROM books")
#mongodb
cache.native_query({type:'Text'}})
```

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

### Execute SQLite Native Query

Source: https://context7.com/raduangelescu/gutenbergpy/llms.txt

Execute raw SQL queries directly on the SQLite database. Useful for complex queries not supported by the standard interface. Ensure the cache is initialized.

```python
from gutenbergpy.gutenbergcache import GutenbergCache, GutenbergCacheTypes

# SQLite native query
sqlite_cache = GutenbergCache.get_cache()

# Get all books with their details
results = sqlite_cache.native_query ("
    SELECT books.gutenbergbookid, titles.name, languages.name
    FROM books
    JOIN titles ON titles.bookid = books.id
    JOIN languages ON languages.id = books.languageid
    WHERE books.numdownloads > 1000
    LIMIT 10
")
for row in results:
    print(f"Book {row[0]}: {row[1]} ({row[2]})")

# Get top downloaded books
top_books = sqlite_cache.native_query ("
    SELECT gutenbergbookid, numdownloads
    FROM books
    ORDER BY numdownloads DESC
    LIMIT 5
")
for row in top_books:
    print(f"Book ID {row[0]}: {row[1]} downloads")
```

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

### Query Gutenberg Cache for English Fiction

Source: https://context7.com/raduangelescu/gutenbergpy/llms.txt

Initializes the cache and retrieves a list of book IDs matching specific language and subject criteria.

```python
cache = GutenbergCache.get_cache()
english_fiction_ids = cache.query(
    languages=['en'],
    subjects=['Fiction'],
    downloadtype=['text/plain']
)
print(f"Found {len(english_fiction_ids)} English fiction books")
```

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

### Retrieve Cache Instance

Source: https://github.com/raduangelescu/gutenbergpy/blob/master/README.md

Retrieves the cache instance for either MongoDB or SQLite.

```python
#for mongodb
cache = GutenbergCache.get_cache(GutenbergCacheTypes.CACHE_TYPE_MONGODB)
#for sqlite
cache  = GutenbergCache.get_cache()
```

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

### Query Cache Data

Source: https://github.com/raduangelescu/gutenbergpy/blob/master/README.md

Performs a query on the cache to find books based on download types.

```python
print(cache.query(downloadtype=['application/plain','text/plain','text/html; charset=utf-8']))
```

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

### Set Cache Settings

Source: https://github.com/raduangelescu/gutenbergpy/blob/master/README.md

Configures custom settings for the Gutenberg cache, such as filenames and directory paths.

```python
GutenbergCacheSettings.set( CacheFilename="", CacheUnpackDir="",
    CacheArchiveName="", ProgressBarMaxLength="", CacheRDFDownloadLink="", TextFilesCacheFolder="", MongoDBCacheServer="")
```

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

### Download and clean Gutenberg text

Source: https://github.com/raduangelescu/gutenbergpy/blob/master/README.md

Retrieves a book by ID and removes headers.

```python
def usage_example():
    # This gets a book by its gutenberg id number
    raw_book = gutenbergpy.textget.get_text_by_id(2701) # with headers
    clean_book = gutenbergpy.textget.strip_headers(raw_book) # without headers
    return clean_book, raw_book
```

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

### Access Raw Book Data

Source: https://github.com/raduangelescu/gutenbergpy/blob/master/README.md

Demonstrates how to print a snippet from a raw book object.

```python
print(f'Example phrase from the raw book: {" ".join(str(raw_book[3000:3050]).split(" "))}')
```

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

### Download and Clean Book Text

Source: https://context7.com/raduangelescu/gutenbergpy/llms.txt

Retrieves raw text by ID and removes Project Gutenberg headers, returning the cleaned content as a UTF-8 string.

```python
def download_and_clean(book_id):
    """Download a book and return cleaned text."""
    try:
        raw = gutenbergpy.textget.get_text_by_id(book_id)
        clean = gutenbergpy.textget.strip_headers(raw)
        return clean.decode('utf-8')
    except Exception as e:
        print(f"Error downloading book {book_id}: {e}")
        return None
```

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

### Retrieve Cache Object

Source: https://context7.com/raduangelescu/gutenbergpy/llms.txt

Obtains a handle to the local metadata database for querying.

```python
from gutenbergpy.gutenbergcache import GutenbergCache, GutenbergCacheTypes

# Get SQLite cache (default)
cache = GutenbergCache.get_cache()

# Get MongoDB cache
cache = GutenbergCache.get_cache(GutenbergCacheTypes.CACHE_TYPE_MONGODB)

# Verify cache is accessible
if cache is not None:
    print("Cache loaded successfully")
```

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

### Import GutenbergPy text module

Source: https://github.com/raduangelescu/gutenbergpy/blob/master/README.md

Required import statement to access text retrieval functionality.

```python
import gutenbergpy.textget
```

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

### Strip Headers and Footers

Source: https://context7.com/raduangelescu/gutenbergpy/llms.txt

Removes Project Gutenberg boilerplate text (headers and footers) from book content.

```APIDOC
## strip_headers

Removes Project Gutenberg headers and footers from downloaded book text. This function identifies and strips boilerplate content like license information, leaving only the actual book content.

### Parameters

#### Path Parameters

- **raw_book_bytes** (bytes) - Required - The raw bytes of the book content as returned by `get_text_by_id`.

### Request Example

```python
import gutenbergpy.textget

# Download and clean Moby Dick
raw_book = gutenbergpy.textget.get_text_by_id(2701)
clean_book = gutenbergpy.textget.strip_headers(raw_book)

print(f"Raw book size: {len(raw_book)} bytes")
print(f"Clean book size: {len(clean_book)} bytes")
print(f"Removed {len(raw_book) - len(clean_book)} bytes of headers/footers")

# Compare raw vs cleaned content
print("\n--- Raw book start ---")
print(raw_book[:500].decode('utf-8'))

print("\n--- Clean book start ---")
print(clean_book[:500].decode('utf-8'))

# Complete workflow: download, clean, and decode to string
def get_clean_text(book_id):
    """Download and clean a book, returning it as a string."""
    raw = gutenbergpy.textget.get_text_by_id(book_id)
    cleaned = gutenbergpy.textget.strip_headers(raw)
    return cleaned.decode('utf-8')

# Get clean text for analysis
moby_dick_text = get_clean_text(2701)
print(f"\nMoby Dick word count: {len(moby_dick_text.split())}")

# Process multiple books for NLP
book_ids = [1342, 84, 11]  # Pride and Prejudice, Frankenstein, Alice in Wonderland
corpus = []

for book_id in book_ids:
    text = get_clean_text(book_id)
    corpus.append({
        'id': book_id,
        'text': text,
        'word_count': len(text.split())
    })
    print(f"Book {book_id}: {corpus[-1]['word_count']} words")
```

### Response

#### Success Response (200)

- **clean_book_bytes** (bytes) - The book content with headers and footers removed, as UTF-8 encoded bytes.

#### Response Example

```json
{
  "example": "(bytes representing cleaned book content)"
}
```
```

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

### Execute MongoDB Native Query

Source: https://context7.com/raduangelescu/gutenbergpy/llms.txt

Execute native queries on a MongoDB database. Requires the cache to be initialized with GutenbergCacheTypes.CACHE_TYPE_MONGODB. Supports MongoDB query syntax.

```python
from gutenbergpy.gutenbergcache import GutenbergCache, GutenbergCacheTypes

# MongoDB native query
mongo_cache = GutenbergCache.get_cache(GutenbergCacheTypes.CACHE_TYPE_MONGODB)

# Find English books with MongoDB query syntax
english_books = mongo_cache.native_query({'language': 'en'})
for book in english_books.limit(5):
    print(f"Book: {book['gutenberg_book_id']}, Language: {book['language']}")

# Complex MongoDB query
popular_english = mongo_cache.native_query({
    '$and': [
        {'language': 'en'},
        {'num_downloads': {'$gt': 500}}
    ]
})
```

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

### Download Book Text by ID

Source: https://context7.com/raduangelescu/gutenbergpy/llms.txt

Download the raw text of a book from Project Gutenberg using its ID. Automatically caches downloaded files locally and handles encoding. Subsequent calls for the same ID will use the cached version.

```python
import gutenbergpy.textget

# Download Moby Dick (ID: 2701)
raw_book = gutenbergpy.textget.get_text_by_id(2701)
print(f"Downloaded {len(raw_book)} bytes")
print(f"First 200 characters: {raw_book[:200]}")

# Download Pride and Prejudice (ID: 1342)
pride_prejudice = gutenbergpy.textget.get_text_by_id(1342)
print(f"Downloaded Pride and Prejudice: {len(pride_prejudice)} bytes")

# Download multiple books and save them
book_ids = [2701, 1342, 84, 11]  # Moby Dick, Pride and Prejudice, Frankenstein, Alice in Wonderland
books = {}

for book_id in book_ids:
    try:
        books[book_id] = gutenbergpy.textget.get_text_by_id(book_id)
        print(f"Downloaded book {book_id}: {len(books[book_id])} bytes")
    except gutenbergpy.textget.UnknownDownloadUri:
        print(f"Could not find book {book_id}")

# Subsequent calls use cached version (fast)
cached_book = gutenbergpy.textget.get_text_by_id(2701)
print("Book loaded from cache")
```

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

### Query Gutenberg Metadata

Source: https://context7.com/raduangelescu/gutenbergpy/llms.txt

Filters the local cache to retrieve book IDs based on specific metadata criteria.

```python
from gutenbergpy.gutenbergcache import GutenbergCache

cache = GutenbergCache.get_cache()

# Find all English books
english_books = cache.query(languages=['en'])
print(f"Found {len(english_books)} English books")

# Find books by a specific author
shakespeare_books = cache.query(authors=['Shakespeare, William'])
print(f"Found {len(shakespeare_books)} Shakespeare books: {shakespeare_books[:5]}")

# Find books with plain text downloads available
text_books = cache.query(
    downloadtype=['application/plain', 'text/plain', 'text/html; charset=utf-8']
)
print(f"Found {len(text_books)} books with text downloads")

# Combine multiple filters: English fiction books
english_fiction = cache.query(
    languages=['en'],
    subjects=['Fiction']
)
print(f"Found {len(english_fiction)} English fiction books")

# Find books on specific bookshelves
scifi_books = cache.query(bookshelves=['Science Fiction'])
print(f"Found {len(scifi_books)} science fiction books")
```

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

### cache.query

Source: https://context7.com/raduangelescu/gutenbergpy/llms.txt

Queries the local metadata cache to retrieve book IDs based on specific criteria.

```APIDOC
## cache.query

### Description
Queries the cache using structured filters to find Gutenberg book IDs. Filters are combined using AND logic.

### Parameters
#### Request Body
- **languages** (list) - Optional - Filter by language codes.
- **authors** (list) - Optional - Filter by author names.
- **types** (list) - Optional - Filter by book types.
- **titles** (list) - Optional - Filter by book titles.
- **subjects** (list) - Optional - Filter by subjects.
- **publishers** (list) - Optional - Filter by publishers.
- **bookshelves** (list) - Optional - Filter by bookshelves.
- **downloadtype** (list) - Optional - Filter by available download MIME types.

### Response
#### Success Response (200)
- **book_ids** (list) - A list of book IDs matching the provided filters.
```

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

### Strip Book Headers and Footers

Source: https://context7.com/raduangelescu/gutenbergpy/llms.txt

Remove Project Gutenberg headers and footers from raw book text. This function identifies and strips boilerplate content, returning only the actual book content. Useful for preparing text for analysis.

```python
import gutenbergpy.textget

# Download and clean Moby Dick
raw_book = gutenbergpy.textget.get_text_by_id(2701)
clean_book = gutenbergpy.textget.strip_headers(raw_book)

print(f"Raw book size: {len(raw_book)} bytes")
print(f"Clean book size: {len(clean_book)} bytes")
print(f"Removed {len(raw_book) - len(clean_book)} bytes of headers/footers")

# Compare raw vs cleaned content
print("\n--- Raw book start ---")
print(raw_book[:500].decode('utf-8'))

print("\n--- Clean book start ---")
print(clean_book[:500].decode('utf-8'))

# Complete workflow: download, clean, and decode to string
def get_clean_text(book_id):
    """Download and clean a book, returning it as a string."""
    raw = gutenbergpy.textget.get_text_by_id(book_id)
    cleaned = gutenbergpy.textget.strip_headers(raw)
    return cleaned.decode('utf-8')

# Get clean text for analysis
moby_dick_text = get_clean_text(2701)
print(f"\nMoby Dick word count: {len(moby_dick_text.split())}")

# Process multiple books for NLP
book_ids = [1342, 84, 11]  # Pride and Prejudice, Frankenstein, Alice in Wonderland
corpus = []

for book_id in book_ids:
    text = get_clean_text(book_id)
    corpus.append({
        'id': book_id,
        'text': text,
        'word_count': len(text.split())
    })
    print(f"Book {book_id}: {corpus[-1]['word_count']} words")
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.