Upload 10 files

1_get_books.py

@@ -0,0 +1,131 @@
+# Import necessary libraries
+import requests  # For making HTTP requests
+from bs4 import BeautifulSoup  # For parsing HTML
+import os  # For file and directory operations
+import re  # For regular expressions
+import time  # For adding delays
+import random  # For generating random numbers
+
+# Function to remove invalid characters from filenames
+def sanitize_filename(filename):
+    return re.sub(r'[\\/*?:"<>|]', "", filename)
+
+# Function to download a book given its URL and title
+def download_book(url, title):
+    # Create a safe filename
+    filename = sanitize_filename(f"{title}.txt")
+    
+    # Check if the file already exists
+    if os.path.exists(filename):
+        print(f"Skipping: {filename} (already downloaded)")
+        time.sleep(1/10)  # Add a small delay
+        return True
+
+    try:
+        # Get the book's webpage
+        response = requests.get(url)
+        soup = BeautifulSoup(response.content, 'html.parser')
+        
+        # Find the download link for plain text version
+        download_link = soup.find('a', string='Plain Text UTF-8')
+        
+        if download_link:
+            # Construct the full download URL
+            book_url = 'https://www.gutenberg.org' + download_link['href']
+            # Download the book content
+            book_content = requests.get(book_url).text
+            
+            # Save the book content to a file
+            with open(filename, 'w', encoding='utf-8') as f:
+                f.write(book_content)
+            print(f"Downloaded: {filename}")
+            # Add a random delay between 1 and 10 seconds
+            time.sleep(random.uniform(1, 10))
+            return True
+        else:
+            print(f"Could not find Plain Text UTF-8 download link for: {title}")
+            # Add a random delay between 1 and 3 seconds
+            time.sleep(random.uniform(1, 3))
+            return False
+    except requests.RequestException as e:
+        print(f"Network error downloading {title}: {e}")
+        time.sleep(random.uniform(1, 10))  # Add a random delay
+        return False
+    except OSError as e:
+        print(f"Error downloading {title}: {e}")
+        time.sleep(random.uniform(1, 10))  # Add a random delay
+        return False
+    except Exception as e:
+        print(f"Unexpected error downloading {title}: {e}")
+        time.sleep(random.uniform(1, 10))  # Add a random delay
+        return False
+
+# Function to extract book links from a page
+def get_book_links(url):
+    try:
+        # Get the webpage content
+        response = requests.get(url)
+        soup = BeautifulSoup(response.content, 'html.parser')
+        
+        # Find all book elements
+        books = soup.find_all('li', class_='booklink')
+        
+        # Extract title and URL for each book
+        for book in books:
+            title_element = book.find('span', class_='title')
+            if title_element:
+                title = title_element.text.strip()
+                book_url = 'https://www.gutenberg.org' + title_element.find_parent('a')['href']
+                yield (book_url, title)
+    except requests.RequestException as e:
+        print(f"Network error fetching book links: {e}")
+    except Exception as e:
+        print(f"Unexpected error fetching book links: {e}")
+
+# Function to get the URL of the next page
+def get_next_page_url(url):
+    try:
+        # Get the webpage content
+        response = requests.get(url)
+        soup = BeautifulSoup(response.content, 'html.parser')
+        # Find the 'Next' link
+        next_link = soup.find('a', string='Next')
+        if next_link:
+            return 'https://www.gutenberg.org' + next_link['href']
+        return None
+    except requests.RequestException as e:
+        print(f"Network error fetching next page URL: {e}")
+        return None
+    except Exception as e:
+        print(f"Unexpected error fetching next page URL: {e}")
+        return None
+
+# Main execution block
+if __name__ == "__main__":
+    # Set the initial search URL
+    base_url = "https://www.gutenberg.org/ebooks/search/?query=philosophy&submit_search=Go%21"
+    
+    # Ask user how many books to download
+    num_books = int(input("How many books do you want to download? "))
+    
+    # Create a 'books' directory if it doesn't exist
+    if not os.path.exists('books'):
+        os.makedirs('books')
+    os.chdir('books')  # Change to the 'books' directory
+    
+    current_url = base_url
+    books_downloaded = 0
+    
+    # Main download loop
+    while books_downloaded < num_books and current_url:
+        for book_url, title in get_book_links(current_url):
+            if books_downloaded >= num_books:
+                break
+            if download_book(book_url, title):
+                books_downloaded += 1
+        
+        # Move to the next page
+        current_url = get_next_page_url(current_url)
+        time.sleep(2)  # Add a delay between pages
+
+    print(f"Downloaded {books_downloaded} new books.")

2_remove_intros_from_books.py

@@ -0,0 +1,53 @@
+# Import necessary libraries
+import os  # For file and directory operations
+import re  # For regular expression operations
+import asyncio  # For asynchronous programming
+import aiofiles  # For asynchronous file I/O operations
+
+# Function to remove the introduction from a book's content
+async def remove_intro(content):
+    # Define a pattern to match everything up to and including the start of the Project Gutenberg eBook
+    pattern = r'(?s).*?\*\*\* START OF THE PROJECT GUTENBERG EBOOK.*?\n'
+    # Remove the matched pattern from the content
+    return re.sub(pattern, '', content, count=1)
+
+# Function to process a single file
+async def process_file(input_path, output_path):
+    # Open and read the input file asynchronously
+    async with aiofiles.open(input_path, 'r', encoding='utf-8') as file:
+        content = await file.read()
+
+    # Remove the introduction from the content
+    processed_content = await remove_intro(content)
+
+    # Write the processed content to the output file asynchronously
+    async with aiofiles.open(output_path, 'w', encoding='utf-8') as file:
+        await file.write(processed_content)
+
+# Main function to process all books
+async def process_books():
+    input_folder = 'books'  # Folder containing original books
+    output_folder = 'processed_books'  # Folder to store processed books
+
+    # Create output folder if it doesn't exist
+    if not os.path.exists(output_folder):
+        os.makedirs(output_folder)
+
+    tasks = []  # List to store all processing tasks
+    # Iterate through all files in the input folder
+    for filename in os.listdir(input_folder):
+        if filename.endswith('.txt'):  # Process only text files
+            input_path = os.path.join(input_folder, filename)
+            output_path = os.path.join(output_folder, filename)
+            # Create a task for processing each file and add it to the list
+            task = asyncio.create_task(process_file(input_path, output_path))
+            tasks.append(task)
+
+    # Wait for all tasks to complete
+    await asyncio.gather(*tasks)
+    print(f"All books processed. Output saved in '{output_folder}' folder.")
+
+# Entry point of the script
+if __name__ == '__main__':
+    # Run the main processing function asynchronously
+    asyncio.run(process_books())

3_chunking_the_books.py

@@ -0,0 +1,56 @@
+# Import necessary libraries
+import os  # For file and directory operations
+import json  # For JSON file handling
+from math import ceil  # For rounding up numbers
+
+# Function to split text into overlapping chunks
+def chunk_text(text, chunk_size=500, overlap_percent=25):
+    # Split the text into words
+    words = text.split()
+    # Calculate the size of the overlap based on the chunk size and overlap percentage
+    overlap_size = int(chunk_size * overlap_percent / 100)
+    # Calculate the step size (distance between chunk starts)
+    step = chunk_size - overlap_size
+    
+    chunks = []
+    # Iterate through the words, creating chunks
+    for i in range(0, len(words), step):
+        # Join words to form a chunk
+        chunk = ' '.join(words[i:i + chunk_size])
+        # Add the chunk to the list
+        chunks.append(chunk)
+    
+    # Return the list of chunks
+    return chunks
+
+# Function to process all books in a folder
+def process_books(input_folder, output_file, chunk_size=500, overlap_percent=25):
+    # Dictionary to store chunks for all books
+    all_chunks = {}
+    
+    # Iterate through all files in the input folder
+    for filename in os.listdir(input_folder):
+        # Process only text files
+        if filename.endswith('.txt'):
+            # Open and read the file
+            with open(os.path.join(input_folder, filename), 'r', encoding='utf-8') as file:
+                content = file.read()
+                # Split the book content into chunks
+                book_chunks = chunk_text(content, chunk_size, overlap_percent)
+                # Store the chunks for this book
+                all_chunks[filename] = book_chunks
+    
+    # Write all chunks to a JSON file
+    with open(output_file, 'w', encoding='utf-8') as outfile:
+        json.dump(all_chunks, outfile, indent=4, ensure_ascii=False, separators=(',', ': '))
+
+# Usage example
+input_folder = 'processed_books'  # Folder containing the books to process
+output_file = 'chunked_books.json'  # File to store the chunked books
+chunk_size = 500  # Size of each chunk in words
+overlap_percent = 25  # Percentage of overlap between chunks
+
+# Process the books and save the chunks
+process_books(input_folder, output_file, chunk_size, overlap_percent)
+# Print a message indicating that the process is complete
+print(f"Chunked books have been saved to {output_file}")

4_embed_chromadb.py

@@ -0,0 +1,80 @@
+# Import necessary libraries
+import json  # For handling JSON data
+import os  # For interacting with the operating system
+import asyncio  # For asynchronous programming
+import aiofiles  # For asynchronous file operations
+import chromadb  # For vector database operations
+from chromadb.utils import embedding_functions  # For creating embedding functions
+from termcolor import colored  # For colored console output
+
+# Function to load chunked books from a JSON file
+async def load_chunked_books():
+    # Open and read the JSON file asynchronously
+    async with aiofiles.open('chunked_books.json', 'r', encoding='utf-8') as file:
+        return json.loads(await file.read())
+
+# Function to embed a single chunk into the collection
+async def embed_chunk(collection, book_title, i, chunk, semaphore):
+    # Use a semaphore to limit concurrent operations
+    async with semaphore:
+        # Add the chunk to the collection with metadata
+        collection.add(
+            documents=[chunk],
+            metadatas=[{"book_title": book_title, "chunk_index": i}],
+            ids=[f"{book_title}_chunk_{i}"]
+        )
+
+# Function to process all chunks from the books
+async def process_chunks(chunked_books, collection, max_books=None):
+    # Create a semaphore to limit concurrent operations to 30000
+    semaphore = asyncio.Semaphore(30000)
+    tasks = []
+    # Iterate through books and their chunks
+    for i, (book_title, chunks) in enumerate(chunked_books.items()):
+        # Break if max_books limit is reached
+        if max_books is not None and i >= max_books:
+            break
+        print(colored(f"Processing {book_title}", "green"))
+        # Create a task for each chunk
+        for j, chunk in enumerate(chunks):
+            task = asyncio.create_task(embed_chunk(collection, book_title, j, chunk, semaphore))
+            tasks.append(task)
+    
+    total_chunks = len(tasks)
+    print(colored(f"Embedding {total_chunks} chunks", "blue"))
+    
+    # Wait for all tasks to complete
+    await asyncio.gather(*tasks)
+
+# Main function to orchestrate the embedding process
+async def main():
+    # Load the chunked books
+    chunked_books = await load_chunked_books()
+
+    # Initialize Chroma client with persistence
+    client = chromadb.PersistentClient(path="./chroma_db")
+
+    # Create OpenAI embedding function
+    openai_ef = embedding_functions.OpenAIEmbeddingFunction(
+        api_key=os.getenv("OPENAI_API_KEY"),
+        model_name="text-embedding-3-large"
+    )
+
+    # Create or get the collection for storing embeddings
+    collection = client.get_or_create_collection(
+        name="books_collection",
+        embedding_function=openai_ef,
+        metadata={"hnsw:space": "cosine"}
+    )
+
+    # Process and embed all chunks
+    await process_chunks(chunked_books, collection, max_books=None)
+
+    # Calculate and print the total number of embedded chunks
+    total_chunks = sum(len(chunks) for chunks in chunked_books.values())
+    print(f"Embedded and stored {total_chunks} chunks in the Chroma collection.")
+
+# Entry point of the script
+if __name__ == "__main__":
+    # Run the main function asynchronously
+    asyncio.run(main())

5_querry_library.py

@@ -0,0 +1,94 @@
+# Import necessary libraries
+import os  # For environment variables
+import json  # For JSON operations
+import chromadb  # For vector database operations
+from chromadb.utils import embedding_functions  # For creating embedding functions
+from termcolor import colored  # For colored console output
+
+# Function to query the collection
+def query_collection(query, n_results=5):
+    # Initialize Chroma client with persistence
+    client = chromadb.PersistentClient(path="./chroma_db")
+
+    # Create OpenAI embedding function
+    openai_ef = embedding_functions.OpenAIEmbeddingFunction(
+        api_key=os.getenv("OPENAI_API_KEY"),
+        model_name="text-embedding-3-large"
+    )
+
+    # Get the collection with cosine similarity
+    collection = client.get_collection(
+        name="books_collection",
+        embedding_function=openai_ef,
+    )
+
+    # Query the collection
+    results = collection.query(
+        query_texts=[query],
+        n_results=n_results
+    )
+
+    return results
+
+# Function to save query results to a JSON file
+def save_results_to_json(results, query, n_results):
+    # Create a dictionary to store the results
+    json_results = {
+        "query": query,
+        "n_results": n_results,
+        "results": []
+    }
+    
+    # Iterate through the results and add them to the dictionary
+    for i, (doc, metadata) in enumerate(zip(results['documents'][0], results['metadatas'][0]), 1):
+        json_results["results"].append({
+            "result_number": i,
+            "book_title": metadata['book_title'],
+            "chunk_index": metadata['chunk_index'],
+            "content": doc
+        })
+    
+    # Write the results to a JSON file
+    with open("query_results.json", "w") as f:
+        json.dump(json_results, f, indent=4)
+
+# Main function to run the query system
+def main():
+    # Print welcome message
+    print(colored("Welcome to the Book Query System!", "green"))
+    print("You can ask questions about the books in the collection.")
+    
+    # Main loop for user interaction
+    while True:
+        # Get user query
+        query = input(colored("\nEnter your query (or 'quit' to exit): ", "yellow"))
+        
+        # Check if user wants to quit
+        if query.lower() == 'quit':
+            break
+        
+        # Get number of desired results
+        n_results = int(input(colored("How many results would you like? ", "yellow")))
+        
+        # Query the collection
+        results = query_collection(query, n_results)
+        
+        # Print the results
+        print(colored("\nTop matching chunks:", "green"))
+        for i, (doc, metadata) in enumerate(zip(results['documents'][0], results['metadatas'][0]), 1):
+            print(colored(f"\nResult {i}:", "blue"))
+            print(f"Book: {metadata['book_title']}")
+            print(f"Chunk Index: {metadata['chunk_index']}")
+            print(colored("Content:", "cyan"))
+            print(doc)
+        
+        # Save results to JSON file
+        save_results_to_json(results, query, n_results)
+        print(colored("\nResults have been saved to query_results.json", "green"))
+
+    # Print goodbye message
+    print(colored("Thank you for using the Book Query System!", "green"))
+
+# Check if the script is being run directly
+if __name__ == "__main__":
+    main()

6_chat_with_a_library.py

@@ -0,0 +1,110 @@
+# Import necessary libraries
+import os  # For environment variables
+import json  # For JSON operations
+import chromadb  # For vector database operations
+from chromadb.utils import embedding_functions  # For creating embedding functions
+from termcolor import colored  # For colored console output
+from openai import OpenAI  # For interacting with OpenAI's API
+
+# Function to query the vector database
+def query_collection(query, n_results):
+    # Initialize the Chroma client with a persistent database
+    client = chromadb.PersistentClient(path="./chroma_db")
+    # Create an OpenAI embedding function
+    openai_ef = embedding_functions.OpenAIEmbeddingFunction(
+        api_key=os.getenv("OPENAI_API_KEY"),
+        model_name="text-embedding-3-large"
+    )
+    # Get the collection from the database
+    collection = client.get_collection(
+        name="books_collection",
+        embedding_function=openai_ef,
+    )
+    # Query the collection with the given query and number of results
+    results = collection.query(
+        query_texts=[query],
+        n_results=n_results
+    )
+    return results
+
+# Function to save retrieved chunks to a JSON file
+def save_chunks_to_json(results, query):
+    # Prepare the data structure for JSON
+    json_data = {
+        "query": query,
+        "chunks": []
+    }
+    # Iterate through the results and add them to the data structure
+    for doc, metadata in zip(results['documents'][0], results['metadatas'][0]):
+        chunk = {
+            "book_title": metadata['book_title'],
+            "chunk_index": metadata['chunk_index'],
+            "content": doc
+        }
+        json_data["chunks"].append(chunk)
+    
+    # Write the data to a JSON file
+    with open("retrieved_chunks.json", "w") as f:
+        json.dump(json_data, f, indent=4)
+    
+    # Print a confirmation message
+    print(colored("Retrieved chunks have been saved to retrieved_chunks.json", "green"))
+
+# Function to generate a response using OpenAI's API
+def generate_response(client, query, context):
+    # Prepare the messages for the chat completion
+    messages = [
+        {"role": "system", "content": "You are a helpful assistant. Answer the query based on the provided context. in 100 words or less. unless user asks for more detail. Do not refer to any author but just combine the best pieces of the provided content to answer the query. Only answer based on the provided content."},
+        {"role": "user", "content": f"Context:\n{context}\n\nQuery: {query}"}
+    ]
+    # Create a streaming chat completion
+    stream = client.chat.completions.create(
+        model="gpt-4o",
+        messages=messages,
+        stream=True
+    )
+    # Print the response as it's generated
+    for chunk in stream:
+        if chunk.choices[0].delta.content is not None:
+            print(colored(chunk.choices[0].delta.content, "green"), end='', flush=True)
+
+    print()
+
+# Main function to run the program
+def main():
+    # Print welcome message
+    print(colored("Welcome to the Book Query System!", "green"))
+    # Initialize OpenAI client
+    client = OpenAI()
+    # Get the number of chunks to use for context from the user
+    n_results = int(input(colored("How many chunks would you like to use for context? ", "yellow")))
+
+    # Main loop for user interaction
+    while True:
+        # Get the user's query
+        query = input(colored("\nEnter your query (or 'quit' to exit): ", "yellow"))
+        if query.lower() == 'quit':
+            break
+        
+        # Query the collection
+        results = query_collection(query, n_results)
+        
+        # Save the retrieved chunks to a JSON file
+        save_chunks_to_json(results, query)
+        
+        # Prepare the context for the AI response
+        context = "\n\n".join([
+            f"Book: {metadata['book_title']}\nChunk Index: {metadata['chunk_index']}\nContent: {doc}"
+            for doc, metadata in zip(results['documents'][0], results['metadatas'][0])
+        ])
+        
+        # Generate and print the AI response
+        print(colored("\nGenerating response based on the context...", "green"))
+        generate_response(client, query, context)
+
+    # Print goodbye message
+    print(colored("Thank you for using the Book Query System!", "green"))
+
+# Run the main function if this script is executed directly
+if __name__ == "__main__":
+    main()

count_tokens.py

@@ -0,0 +1,41 @@
+import os
+import json
+import tiktoken
+
+def count_tokens(text, encoding_name="cl100k_base"):
+    encoding = tiktoken.get_encoding(encoding_name)
+    return len(encoding.encode(text))
+
+def count_words(text):
+    return len(text.split())
+
+def process_books(input_folder, output_file):
+    all_counts = {}
+    total_tokens = 0
+    total_words = 0
+
+    for filename in os.listdir(input_folder):
+        if filename.endswith('.txt'):
+            with open(os.path.join(input_folder, filename), 'r', encoding='utf-8') as file:
+                content = file.read()
+                tokens = count_tokens(content)
+                words = count_words(content)
+                all_counts[filename] = {"tokens": tokens, "words": words}
+                total_tokens += tokens
+                total_words += words
+
+    # Save token counts, word counts, and totals to a JSON file
+    all_counts["total_tokens"] = total_tokens
+    all_counts["total_words"] = total_words
+    with open(output_file, 'w', encoding='utf-8') as outfile:
+        json.dump(all_counts, outfile, indent=4, ensure_ascii=False)
+
+    print(f"Total tokens across all books: {total_tokens}")
+    print(f"Total words across all books: {total_words}")
+    print(f"Token and word counts for each book and totals have been saved to {output_file}")
+
+# Usage
+input_folder = 'processed_books'
+output_file = 'token_and_word_counts.json'
+
+process_books(input_folder, output_file)

license_.txt

@@ -0,0 +1,10 @@
+
+all software provided by echohive is provided "as is", without warranty of any kind, express or
+implied, including but not limited to the warranties of merchantability,
+fitness for a particular purpose and noninfringement. in no event shall the
+authors or copyright holders be liable for any claim, damages or other
+liability, whether in an action of contract, tort or otherwise, arising from,
+out of or in connection with the software or the use or other dealings in
+the software.
+
+the software shall not be used for any malicious purposes

requirements.txt

@@ -1,2 +1,3 @@
-streamlit
-openai
+openai==1.34.0
+chromadb==0.4.24
+termcolor==2.4.0

token_counts.json

@@ -0,0 +1,101 @@
+{
+    "A little philosophy of life.txt": 9132,
+    "A System of Logic, Ratiocinative and Inductive.txt": 546472,
+    "A Treatise of Human Nature.txt": 296762,
+    "Aesthetical Essays of Friedrich Schiller.txt": 189986,
+    "Ainsi Parlait Zarathoustra (French).txt": 194454,
+    "Also sprach Zarathustra Ein Buch für Alle und Keinen (German).txt": 169738,
+    "An Enquiry Concerning Human Understanding.txt": 82190,
+    "An Enquiry Concerning the Principles of Morals.txt": 70435,
+    "Anthropology   [a lecture delivered at Columbia University in the series on science, philosophy and art, December 18, 1907].txt": 13097,
+    "Aphorismen zur Lebensweisheit (German).txt": 140512,
+    "Apology.txt": 24980,
+    "Aristotle on the art of poetry.txt": 30192,
+    "Autobiography.txt": 102169,
+    "Beyond Good and Evil.txt": 94142,
+    "Bushido, the Soul of Japan.txt": 51071,
+    "Considerations on Representative Government.txt": 125315,
+    "Democracy and Education An Introduction to the Philosophy of Education.txt": 176129,
+    "Der Wille zur Macht Eine Auslegung alles Geschehens (German).txt": 224176,
+    "Dialogues Concerning Natural Religion.txt": 52536,
+    "Discours de la méthode (French).txt": 204766,
+    "Discourse on the Method of Rightly Conducting One's Reason and of Seeking Truth in the Sciences.txt": 32497,
+    "Essais de Montaigne (self-édition) - Volume I (French).txt": 582802,
+    "Essays of Schopenhauer.txt": 102591,
+    "Ethics.txt": 125702,
+    "Euthyphro.txt": 17073,
+    "Fables de La Fontaine (French).txt": 165627,
+    "Fathers and Sons.txt": 117927,
+    "Fundamental Principles of the Metaphysic of Morals.txt": 42791,
+    "Hegel's Philosophy of Mind.txt": 172635,
+    "Ion.txt": 12818,
+    "La Pensée de l'Humanité (French).txt": 157229,
+    "Laughter An Essay on the Meaning of the Comic.txt": 56658,
+    "Man and Superman A Comedy and a Philosophy.txt": 101410,
+    "Mysticism and Logic and Other Essays.txt": 100246,
+    "Nature.txt": 24614,
+    "Nursing as Caring A Model for Transforming Practice.txt": 56142,
+    "On Liberty.txt": 71629,
+    "On the Nature of Things.txt": 115376,
+    "Parmenides.txt": 50415,
+    "Pascal's Pensées.txt": 162822,
+    "Phaedo.txt": 59297,
+    "Philosophiae Naturalis Principia Mathematica (Latin).txt": 276663,
+    "Politics A Treatise on Government.txt": 136638,
+    "Pragmatism A New Name for Some Old Ways of Thinking.txt": 74273,
+    "Principios e questões de philosophia politica (Vol. 1 of 2) (Portuguese).txt": 95611,
+    "Protagoras.txt": 40959,
+    "Second Treatise of Government.txt": 78427,
+    "Selections from the Writings of Kierkegaard.txt": 118409,
+    "Siddhartha eine indische Dichtung (German).txt": 71013,
+    "Siddhartha.txt": 57396,
+    "Six metaphysical meditations.txt": 57199,
+    "Sophist.txt": 66723,
+    "Symbolic Logic.txt": 131562,
+    "Symposium.txt": 47194,
+    "The Advancement of Learning.txt": 121880,
+    "The Analects of Confucius (from the Chinese Classics).txt": 48003,
+    "The Analysis of Mind.txt": 119143,
+    "The Antichrist.txt": 53358,
+    "The Birth of Tragedy; or, Hellenism and Pessimism.txt": 80627,
+    "The Case of Wagner, Nietzsche Contra Wagner, and Selected Aphorisms..txt": 45557,
+    "The Communist Manifesto.txt": 19440,
+    "The Consolation of Philosophy.txt": 64645,
+    "The Critique of Practical Reason.txt": 85468,
+    "The Critique of Pure Reason.txt": 279141,
+    "The Elementary Forms of the Religious Life.txt": 309826,
+    "The Ethics of Aristotle.txt": 153589,
+    "The Golden Sayings of Epictetus, with the Hymn of Cleanthes.txt": 36620,
+    "The Joyful Wisdom (La Gaya Scienza).txt": 126443,
+    "The Kybalion.txt": 49626,
+    "The Law.txt": 30680,
+    "The Life of Reason The Phases of Human Progress.txt": 426776,
+    "The Lives and Opinions of Eminent Philosophers.txt": 284048,
+    "The Oxford Book of American Essays.txt": 224431,
+    "The Picture of Dorian Gray.txt": 110023,
+    "The Poetics of Aristotle.txt": 24964,
+    "The Prince.txt": 71159,
+    "The Problems of Philosophy.txt": 59012,
+    "The Republic.txt": 282758,
+    "The Sayings of Confucius.txt": 52309,
+    "The Secret Doctrine, Vol. 1 of 4.txt": 494622,
+    "The Secret Doctrine, Vol. 3 of 4.txt": 385066,
+    "The symbolism of Freemasonry   Illustrating and explaining its science and philosophy, its legends, myths and symbols.txt": 148348,
+    "The Tao Teh King, or the Tao and its Characteristics.txt": 18758,
+    "The Theory of Moral Sentiments.txt": 158439,
+    "The Twilight of the Idols; or, How to Philosophize with the Hammer. The Antichrist.txt": 103709,
+    "The Varieties of Religious Experience A Study in Human Nature.txt": 267612,
+    "The Will to Believe, and Other Essays in Popular Philosophy.txt": 145720,
+    "The Will to Power An Attempted Transvaluation of All Values. Book I and II.txt": 129710,
+    "The Will to Power An Attempted Transvaluation of All Values. Book III and IV.txt": 144631,
+    "The Works of Edgar Allan Poe — Volume 5.txt": 116428,
+    "The World as Will and Idea (Vol. 1 of 3).txt": 258295,
+    "The World as Will and Idea (Vol. 3 of 3).txt": 288437,
+    "Theaetetus.txt": 93043,
+    "Thus Spake Zarathustra A Book for All and None.txt": 165671,
+    "Utilitarianism.txt": 39631,
+    "Voltaire's Philosophical Dictionary.txt": 120793,
+    "What I believe.txt": 20310,
+    "What Is Art.txt": 115537,
+    "total_tokens": 12752908
+}