Upload 6 files

Dockerfile

@@ -0,0 +1,25 @@
+# Base image using Python 3.9
+FROM python:3.9
+
+# Create a new user to run the app
+RUN useradd -m -u 1000 user
+USER user
+
+# Set environment variables
+ENV PATH="/home/user/.local/bin:$PATH"
+
+# Set the working directory
+WORKDIR /app
+
+# Copy the requirements and install dependencies
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+# Copy the rest of the application
+COPY --chown=user . /app
+
+# Expose port 7860 for the application
+EXPOSE 7860
+
+# Command to run the FastAPI app using uvicorn
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

flux.py

@@ -0,0 +1,66 @@
+import os
+import requests
+import time
+from io import BytesIO
+from PIL import Image
+
+def generate_image(prompt: str):
+    IMAGE_API_KEY = os.getenv("IMAGE_API_KEY")
+    if not IMAGE_API_KEY:
+        print("Error: IMAGE_API_KEY not found in environment variables.")
+        return None
+
+    url = "https://api.bfl.ml/v1/flux-pro-1.1"
+    headers = {
+        "accept": "application/json",
+        "x-key": IMAGE_API_KEY,
+        "Content-Type": "application/json"
+    }
+    payload = {
+        "prompt": prompt,
+        "width": 1024,
+        "height": 1024,
+        "guidance_scale": 1,
+        "num_inference_steps": 50,
+        "max_sequence_length": 512,
+        "Safety Tolerance": 3,
+    }
+    
+    # Sending the initial request to generate the image
+    response = requests.post(url, headers=headers, json=payload).json()
+    if "id" not in response:
+        print("Error generating image:", response)
+        return None
+    
+    request_id = response["id"]
+    
+    # Polling for the result
+    while True:
+        time.sleep(0.5)
+        result = requests.get(
+            "https://api.bfl.ml/v1/get_result",
+            headers=headers,
+            params={"id": request_id},
+        ).json()
+        
+        status = result.get("status")
+        if status == "Ready":
+            if "result" in result and "sample" in result["result"]:
+                image_url = result["result"]["sample"]
+                image_response = requests.get(image_url)
+                if image_response.status_code == 200:
+                    image = Image.open(BytesIO(image_response.content))
+                    return image
+                else:
+                    print("Error fetching the image from the URL.")
+                    return None
+            else:
+                print("Error: No 'sample' key in result.")
+                return None
+        elif status == "Content Moderated":
+            print("Image generation status: Content Moderated. Stopping generation.")
+            break
+        else:
+            print(f"Image generation status: {status}")
+    
+    return None

llm.py

@@ -0,0 +1,9 @@
+from langchain_openai import ChatOpenAI
+
+def get_llm(API_KEY):
+
+    llm = ChatOpenAI(model="gpt-4o",
+                temperature=0.7, 
+                api_key=API_KEY
+                )
+    return llm

main.py

@@ -0,0 +1,224 @@
+import os
+import uuid
+import tempfile
+import time
+import re
+import asyncio
+
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import FileResponse
+from pydantic import BaseModel
+
+# Import the custom modules
+from llm import get_llm
+from prompt import story_request, generate_story, image_request, generate_image_prompt
+from flux import generate_image
+
+from docx import Document
+from docx.shared import Inches
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Create the FastAPI instance
+app = FastAPI(
+    title="Bedtime Story Generator API",
+    description="API to generate a bedtime story with images and save as a docx document.",
+    version="1.0.0"
+)
+
+# ---------------------------------------------------------------------------
+# Pydantic model for validating the incoming story parameters
+# ---------------------------------------------------------------------------
+class StoryParams(BaseModel):
+    Age: str
+    Theme: str
+    Pages: int
+    Time: int
+    Tone: str
+    Setting: str
+    Moral: str
+
+# ---------------------------------------------------------------------------
+# Helper functions (wrapped from your provided code)
+# ---------------------------------------------------------------------------
+def inference(llm_instance, story_params: dict) -> str:
+    """
+    Generates the story text from the LLM based on user parameters.
+    """
+    req = story_request(
+        Age=story_params["Age"],
+        Theme=story_params["Theme"],
+        Pages=story_params["Pages"],
+        Time=story_params["Time"],
+        Tone=story_params["Tone"],
+        Setting=story_params["Setting"],
+        Moral=story_params["Moral"]
+    )
+    prompt_text = generate_story(req)
+    print("\nGenerating story. Please wait...\n")
+    response = llm_instance.invoke(prompt_text)
+    return response.content
+
+def parse_story_sections(story_text: str) -> list:
+    """
+    Parses the LLM-generated story into sections using markers enclosed in '**'.
+    """
+    pattern = r'\*\*(.*?)\*\*\s*'
+    matches = list(re.finditer(pattern, story_text, flags=re.DOTALL))
+    sections = []
+    for i, match in enumerate(matches):
+        marker = match.group(1).strip()
+        start = match.end()
+        end = matches[i+1].start() if (i+1) < len(matches) else len(story_text)
+        content = story_text[start:end].strip()
+        section_text = f"{marker}\n\n{content}" if content else marker
+        sections.append(section_text)
+    return sections
+
+def generate_images_for_sections(sections: list, style: str = "sketch") -> list:
+    """
+    Generates an image for each story section.
+    """
+    image_paths = []
+    for idx, section in enumerate(sections):
+        print(f"Generating image for section {idx+1}...")
+        img_req = image_request(style=style, bedtime_story_content=section)
+        img_prompt = generate_image_prompt(img_req)
+        image = generate_image(img_prompt)
+        if image:
+            temp_dir = tempfile.gettempdir()
+            image_filename = os.path.join(temp_dir, f"section_{idx+1}_{uuid.uuid4().hex}.png")
+            image.save(image_filename)
+            image_paths.append(image_filename)
+            print(f"Image for section {idx+1} saved as {image_filename}\n")
+        else:
+            print(f"Failed to generate image for section {idx+1}.\n")
+            image_paths.append(None)
+        time.sleep(1)  # Optional pause between image generations
+    return image_paths
+
+def save_story_to_docx(sections: list, image_paths: list, output_filename: str) -> None:
+    """
+    Saves the story sections and images into a formatted Word document.
+    """
+    document = Document()
+    
+    # If the first section is a title, use it as the document title.
+    if sections and sections[0].startswith("Title:"):
+        lines = sections[0].splitlines()
+        title_line = lines[0].strip()  # e.g., "Title: The Amazing Adventure"
+        title_text = title_line.replace("Title:", "").strip()
+        document.core_properties.title = title_text
+        document.add_heading(title_text, level=1)
+        sections = sections[1:]
+        if image_paths:
+            image_paths = image_paths[1:]
+    
+    # Process remaining sections.
+    for idx, section in enumerate(sections):
+        lines = section.splitlines()
+        if not lines:
+            continue
+        first_line = lines[0].strip()
+        if any(first_line.startswith(marker) for marker in ["Opening Hook:", "Page", "Ending", "The End"]):
+            document.add_heading(first_line, level=2)
+            remaining_text = "\n".join(lines[1:]).strip()
+            if remaining_text:
+                document.add_paragraph(remaining_text)
+        else:
+            document.add_paragraph(section)
+        
+        # Insert the corresponding image (if available).
+        if idx < len(image_paths) and image_paths[idx]:
+            try:
+                document.add_picture(image_paths[idx], width=Inches(4))
+            except Exception as e:
+                print(f"Error inserting image for section {idx+1}: {e}")
+    
+    document.save(output_filename)
+    print(f"\n📖 Story saved to: {output_filename}")
+
+def generate_story_docx(story_params: dict) -> str:
+    """
+    Complete pipeline:
+      - Validates the API key
+      - Generates the story text via the LLM
+      - Parses the story into sections
+      - Generates images for each section
+      - Saves the complete story with images as a Word document
+    Returns the filename of the saved document.
+    """
+    OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+    if not OPENAI_API_KEY:
+        raise Exception("Error: OPENAI_API_KEY not found in environment variables.")
+    
+    llm_instance = get_llm(OPENAI_API_KEY)
+    
+    # Generate the story text from the LLM
+    story_text = inference(llm_instance, story_params)
+    print("\nStory generated successfully!\n")
+    
+    # Parse the story text into sections
+    sections = parse_story_sections(story_text)
+    
+    # Generate images for each section
+    image_paths = generate_images_for_sections(sections, style="sketch")
+    
+    # Create a unique filename for the docx file in a temporary directory
+    output_filename = os.path.join(tempfile.gettempdir(), f"bedtime_story_{uuid.uuid4().hex}.docx")
+    
+    # Save the story and images to the Word document
+    save_story_to_docx(sections, image_paths, output_filename=output_filename)
+    
+    return output_filename
+
+# ---------------------------------------------------------------------------
+# API Endpoints
+# ---------------------------------------------------------------------------
+
+@app.get("/", summary="Root Endpoint", description="Welcome message and API information.")
+async def root():
+    """
+    Returns a welcome message and a link to the API documentation.
+    """
+    return {
+        "message": "Welcome to the Bedtime Story Generator API!",
+        "documentation": "/docs"
+    }
+    
+@app.post(
+    "/generate-story",
+    summary="Generate a Bedtime Story Document",
+    description="Generates a story with images based on input parameters and returns a docx file.",
+    response_description="The generated Word document (.docx) file."
+)
+async def generate_story_endpoint(story_params: StoryParams):
+    """
+    API endpoint that runs the complete story-generation pipeline.
+    It accepts story parameters as JSON, processes the story and images,
+    and returns a downloadable Word document.
+    """
+    try:
+        # Run the blocking story generation in a separate thread
+        docx_file = await asyncio.to_thread(generate_story_docx, story_params.dict())
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+    
+    return FileResponse(
+        path=docx_file,
+        media_type="application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+        filename=os.path.basename(docx_file)
+    )
+
+@app.get("/health", summary="Health Check", description="Returns the API health status.")
+async def health():
+    return {"status": "ok"}
+
+# ---------------------------------------------------------------------------
+# Run the server with: uvicorn main:app --reload
+# ---------------------------------------------------------------------------
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True)

prompt.py

@@ -0,0 +1,89 @@
+from pydantic import BaseModel
+
+class story_request(BaseModel):
+    Age: str  
+    Theme: str
+    Pages: int
+    Time: int
+    Tone: str
+    Setting: str
+    Moral:str
+
+class image_request(BaseModel):
+    style: str  
+    bedtime_story_content: str
+
+def generate_story(story_request:story_request) -> str:
+    
+    prompt_template = """
+You are an imaginative and skilled storyteller, known for creating fun and meaningful bedtime stories.  
+You understand how to make stories simple, engaging, and perfect for young listeners.  
+
+Please write a bedtime story using these details:  
+
+1. **Target Age Group:** {Age}  
+2. **Theme:** {Theme}  
+3. **Story Length:** {Pages} pages  
+4. **Estimated Reading Time:** {Time} minutes  
+5. **Tone & Atmosphere:** {Tone}  
+6. **Setting:** {Setting}  
+7. **Core Message or Lesson:** {Moral}  
+
+**Story Guidelines:**  
+- Each page should have **200 to 300 words** to keep the pacing just right.  
+- Use **simple and easy-to-understand** words so children can follow the story.  
+- Include **natural dialogue** to make the story feel real and exciting.  
+- End with a **happy or comforting resolution** so kids feel safe and relaxed before bed.  
+
+Now, create a heartwarming story that is **easy to understand, and full of imagination!**
+"""
+
+
+    prompt = prompt_template.format(
+       Age=story_request.Age,
+       Theme=story_request.Theme,
+       Pages=story_request.Pages,
+       Time=story_request.Time,
+       Tone=story_request.Tone,
+       Setting=story_request.Setting,
+       Moral=story_request.Moral
+    )
+
+    return prompt
+
+
+def generate_image_prompt(image_request:image_request) -> str:
+    prompt_template = """
+You are a creative visual storyteller tasked with generating detailed, evocative image prompts that capture the enchanting atmosphere of a bedtime story. Your prompts should be meticulously crafted to inspire stunning, narrative-driven visuals that enhance the storytelling experience.
+
+Bedtime Story Context:
+{bedtime_story_content}
+
+Instructions:
+- Create image prompts that evoke warmth, wonder, and a sense of magical realism.
+- Include the following key components:
+  1. **Subject/Scene**: Clearly describe the characters, settings, and key moments of the bedtime story. Emphasize child-friendly, magical elements like softly lit rooms, whimsical forests, or cozy story corners.
+  2. **Composition and Action**: Detail spatial arrangements and dynamic storytelling elements. For example, a child cuddled up with a favorite stuffed animal as a parent reads, or a moonlit scene with gentle, swirling clouds.
+  3. **Emotion and Style**: Convey the gentle, calming, and imaginative tone of the bedtime narrative. Include descriptive cues that evoke feelings of safety, warmth, and wonder.
+  4. **Lighting and Color**: Use soft, warm lighting (such as golden hour or candlelight effects) and a soothing color palette (like muted pastels or warm earth tones) to set the scene.
+  5. **Camera and Lens Settings (Optional)**: Suggest settings like shallow depth of field to create a dreamy background or a gentle focus that adds to the magical quality of the scene.
+  6. **Artistic Enhancements and Aspect Ratio**: Recommend visual enhancements like bokeh, soft focus, or gentle vignette effects. Specify the desired aspect ratio (e.g., --ar 16:9 for widescreen or --ar 4:5 for portrait) and style tags (e.g., --style cinematic, --style dreamy, --style soft).
+  7. **Overall Mood**: Ensure the image prompt aligns with the overall theme of bedtime stories – nurturing, imaginative, and calming.
+
+Style Directive:
+Use the following artistic style for this prompt: {style}
+
+Examples:
+1. A softly lit nursery scene featuring a child in cozy pajamas, curled up with a beloved stuffed animal and a gently glowing night light. The scene exudes warmth and security with muted pastel tones and a hint of magical sparkles in the air. --ar 4:5 --style dreamy
+2. An enchanting forest at dusk, where fireflies flicker among ancient trees and a small, adventurous child wanders along a moss-covered path. The lighting is ethereal with soft blue and golden hues, creating a mystical and soothing atmosphere. --ar 16:9 --style cinematic
+3. A cozy living room transformed into a magical reading nook, with a parent and child sharing a story by the gentle glow of a fireplace. The room is decorated with whimsical touches like floating lanterns and soft, warm lighting, inviting a sense of calm and wonder. --ar 3:2 --style soft
+
+Now, please craft an image prompt that embodies these guidelines.
+"""
+    prompt = prompt_template.format(
+        bedtime_story_content=image_request.bedtime_story_content,
+        style=image_request.style
+    )
+    
+    return prompt
+

requirements.txt

@@ -0,0 +1,9 @@
+langchain_openai
+pydantic
+python-docx
+Pillow
+requests
+python-dotenv
+uvicorn
+fastapi
+streamlit