Upload folder using huggingface_hub

book_generator.py

@@ -2,99 +2,97 @@ import os
 from langchain_groq import ChatGroq
 from langchain.prompts import ChatPromptTemplate
 from langchain_core.output_parsers import StrOutputParser
+from langchain_core.runnables import RunnablePassthrough
 from typing import Dict
 import gradio as gr  # Import Gradio
-import shutil  # Import shutil for file operations
 
-# Step 1: Set the environment variable for the Groq API Key
-os.environ["GROQ_API_KEY"] = "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"  # Use a valid Groq API key
+# Step 3: Set the environment variable for the Groq API Key
+os.environ["GROQ_API_KEY"] = "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"  # Use provided secret key
 
-# Step 2: Define a function to create agents
-def create_agent(role: str, model_name: str = "llama3-70b-8192", temperature: float = 0.7) -> ChatGroq:
-    """Create a LangChain agent for a specific role in book writing."""
+# Step 4: Define helper functions for structured book generation
+def create_book_agent(
+    model_name: str = os.getenv("MODEL_NAME", "llama-3.1-8b-instant"),  # Use environment variable for model name
+    temperature: float = 0.7,
+    max_tokens: int = 8000,  # Set max_tokens to 8000
+    **kwargs
+) -> ChatGroq:
+    """Create a LangChain agent for book writing."""
     prompt_template = ChatPromptTemplate.from_messages([
-        ("system", f"You are a {role}. Write high-quality, engaging content."),
+        ("system", "You are a creative writer. Write high-quality, engaging books for any genre."),
         ("human", "{input}")
     ])
-    llm = ChatGroq(model=model_name, temperature=temperature)
+    llm = ChatGroq(model=model_name, temperature=temperature, max_tokens=max_tokens, **kwargs)  # Removed token parameter
     chain = prompt_template | llm | StrOutputParser()
     return chain
 
-# Step 3: Create specific agents
-chapter_agent = create_agent("chapter writer")
-outline_agent = create_agent("outline creator")
-editing_agent = create_agent("editor")
-proofreading_agent = create_agent("proofreader")
-character_agent = create_agent("character developer")
+def generate_chapter(title: str, agent):
+    """Generate a full chapter given a title."""
+    query = f"Write a detailed chapter titled '{title}'"
+    try:
+        # Yield chunks of text instead of returning all at once
+        for chunk in agent.invoke({"input": query}):
+            yield chunk  # Yield each chunk as it is generated
+    except Exception as e:
+        print(f"An error occurred while generating the chapter: {e}")
+        yield ""
 
-# Step 4: Define functions for generating content
-def generate_chapter(title: str, synopsis: str, agent) -> str:
-    """Generate a chapter based on the title and synopsis."""
-    query = f"Write a detailed chapter based on the following synopsis:\n\nTitle: {title}\n\nSynopsis: {synopsis}"
-    return agent.invoke({"input": query})
-
-def generate_outline(book_title: str, agent) -> Dict[str, str]:
-    """Generate an outline for the book."""
-    query = f"Create an outline for a book titled '{book_title}'."
-    return agent.invoke({"input": query})
-
-def edit_content(content: str, agent) -> str:
-    """Edit the provided content."""
-    query = f"Edit the following content for clarity and style:\n\n{content}"
-    return agent.invoke({"input": query})
-
-def proofread_content(content: str, agent) -> str:
-    """Proofread the provided content for grammar and spelling errors."""
-    query = f"Proofread the following content:\n\n{content}"
-    return agent.invoke({"input": query})
+def write_book(title: str, outline: Dict[str, str]):
+    """
+    Generate a complete book.
+    
+    Args:
+        title (str): The title of the book.
+        outline (Dict[str, str]): A dictionary with chapter titles as keys.
 
-def generate_character_profile(character_name: str, agent) -> str:
-    """Generate a character profile for the given character name."""
-    query = f"Create a character profile for '{character_name}'."
-    return agent.invoke({"input": query})
+    Returns:
+        str: The full book as a single string.
+    """
+    book = f"# {title}\n\n"
+    for chapter_title in outline.keys():
+        book += f"## {chapter_title}\n\n"
+        agent = create_book_agent()  # Create a new agent for each chapter
+        for chapter_text in generate_chapter(chapter_title, agent):
+            book += chapter_text  # Append each chunk to the book
+    return book  # Return the complete book
 
-def save_chapter_to_file(chapter_text: str) -> str:
-    """Save the generated chapter to a .txt file."""
-    file_path = "generated_chapter.txt"
-    with open(file_path, "w") as file:
-        file.write(chapter_text)
-    return file_path  # Return the file path for downloading
+# Step 6: Gradio interface
+def gradio_interface(api_key: str = ""):
+    """Create a Gradio interface for book generation."""
+    with gr.Blocks() as demo:
+        gr.Markdown("## Book Generator")
+        gr.Markdown("This application was created by iLL-Ai AaronAllton and a team of Groq agents that write books.")  # Updated note
+        user_input = gr.Textbox(label="Enter Book Title, Number of Chapters, and Type of Book (e.g., 'My Book, 10, Novel')", placeholder="Title, Chapters, Type")  # Combined input
+        generate_button = gr.Button("Generate Outline")
+        output = gr.Textbox(label="Generated Book", interactive=False)
 
-# Step 5: Define Gradio interface
-def gradio_interface(book_title: str, chapter_title: str, chapter_synopsis: str):
-    """Gradio interface for generating book content."""
-    outline = generate_outline(book_title, outline_agent)
-    chapter_text = generate_chapter(chapter_title, chapter_synopsis, chapter_agent)
-    edited_chapter = edit_content(chapter_text, editing_agent)
-    proofread_chapter = proofread_content(edited_chapter, proofreading_agent)
-    
-    # Save and download buttons
-    save_button = gr.Button("Save Chapter")
-    download_button = gr.Button("Download Chapter")
+        def generate_book_interface(user_input):
+            try:
+                # Ensure the input is properly formatted
+                parts = user_input.split(",")
+                if len(parts) < 3:
+                    return "Please provide input in the format: 'Title, Number of Chapters, Type of Book'."
+                
+                title = parts[0].strip()  # First part is the title
+                outline = parts[1].strip() if len(parts) > 1 else "1"  # Default to 1 chapter if not provided
+                book_type = parts[2].strip() if len(parts) > 2 else "General"  # Default to "General" if not provided
+                
+                outline_dict = {}
+                if not outline.strip():  # Check if outline is empty
+                    return "Please provide a valid outline."  # Prompt user for valid outline
+                
+                # Generate outline based on user input and book type
+                num_chapters = int(outline)  # Extract number of chapters
+                outline_dict = {f"{book_type} Chapter {i}": None for i in range(1, num_chapters + 1)}  # Create outline dictionary with style
+                
+                print(f"Processed Outline: {outline_dict}")  # Debug statement
+                agent = create_book_agent(api_key)  # Create agent with user-provided API key
+                return write_book(title, outline_dict)  # Call the generator
+            except Exception as e:
+                return f"An error occurred: {e}"
 
-    # Define button actions
-    save_button.click(fn=save_chapter_to_file, inputs=proofread_chapter, outputs="text")
-    download_button.click(fn=shutil.copy, inputs="generated_chapter.txt", outputs="text")
+        generate_button.click(generate_book_interface, inputs=user_input, outputs=output)
 
-    return outline, chapter_text, edited_chapter, proofread_chapter
+    demo.launch(share=True)  # Enable sharing of the Gradio app
 
-# Step 6: Launch Gradio app
 if __name__ == "__main__":
-    # Define the Gradio interface
-    iface = gr.Interface(
-        fn=gradio_interface,
-        inputs=[
-            gr.Textbox(label="Book Title"),
-            gr.Textbox(label="Chapter Title"),
-            gr.Textbox(label="Chapter Synopsis")
-        ],
-        outputs=[
-            gr.Textbox(label="Generated Outline", lines=5),
-            gr.Textbox(label="Generated Chapter", lines=5),
-            gr.Textbox(label="Edited Chapter", lines=5),
-            gr.Textbox(label="Proofread Chapter", lines=5)
-        ],
-        title="Book Generator",
-        description="Generate book content using AI."
-    )
-    iface.launch(share=True)  # Launch the Gradio app
+    gradio_interface()

updated_book_generator.py

@@ -24,9 +24,9 @@ novel_agent = create_agent("novel writer")
 guide_agent = create_agent("guide writer")
 
 # Step 4: Define functions for generating content
-def generate_novel(title: str, synopsis: str, chapters: int) -> str:
-    """Generate a novel based on the title and synopsis, with chapter breakdown."""
-    query = f"Generate a novel titled '{title}' with the following synopsis:\n\n{synopsis}\n\nBreak it down into {chapters} chapters with titles and word count estimates."
+def generate_novel(title: str, synopsis: str) -> str:
+    """Generate a novel based on the title and synopsis."""
+    query = f"Write a detailed novel based on the following synopsis:\n\nTitle: {title}\n\nSynopsis: {synopsis}"
     return novel_agent.invoke({"input": query})
 
 def generate_guide(title: str, synopsis: str) -> str:
@@ -35,12 +35,14 @@ def generate_guide(title: str, synopsis: str) -> str:
     return guide_agent.invoke({"input": query})
 
 # Step 5: Define Gradio interface
-def gradio_interface(novel_title: str, novel_synopsis: str, chapters: int):
+def gradio_interface(novel_title: str, novel_synopsis: str, guide_title: str, guide_synopsis: str):
     """Gradio interface for generating book content."""
-    if novel_title and novel_synopsis:
-        novel_content = generate_novel(novel_title, novel_synopsis, chapters)
-        return novel_content, "", ""  # Return only novel content
-    return "", "", ""  # Return empty if no input
+    novel_content = generate_novel(novel_title, novel_synopsis)
+    guide_content = generate_guide(guide_title, guide_synopsis)
+    
+    final_draft = f"Final Draft:\n\nNovel Content:\n{novel_content}\n\nGuide Content:\n{guide_content}"
+    
+    return novel_content, guide_content, final_draft  # Ensure all three outputs are returned
 
 # Step 6: Launch Gradio app
 if __name__ == "__main__":
@@ -48,11 +50,10 @@ if __name__ == "__main__":
         fn=gradio_interface,
         inputs=[
             gr.Textbox(label="Novel Title"),
-            gr.Textbox(label="Novel Synopsis"),
-            gr.Slider(minimum=1, maximum=10, label="Number of Chapters")  # Slider for chapter count
+            gr.Textbox(label="Guide Synopsis")
         ],
         outputs=[
-            gr.Textbox(label="Generated Novel Content", lines=10),
+            gr.Textbox(label="Generated Novel Content", lines=5),
             gr.Textbox(label="Generated Guide Content", lines=5),
             gr.Textbox(label="Final Draft", lines=10)  # Output for the final draft
         ],
@@ -60,5 +61,9 @@ if __name__ == "__main__":
         description="Generate content for novels and guides using AI."
     )
     
+    # Define the function for generating the final draft
+    def generate_final_draft(novel_content, guide_content):
+        return f"Final Draft:\n\nNovel Content:\n{novel_content}\n\nGuide Content:\n{guide_content}"
+
     # Launch the Gradio app
     iface.launch(share=True)