Sync from https://github.com/ismailsimsek/aistorybooks

.github/workflows/hugging-face-sync.yml

@@ -0,0 +1,51 @@
+name: Sync to Hugging Face Spaces
+
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - main
+
+jobs:
+  sync:
+    name: Sync
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v3
+
+      - name: Remove bad files
+        run: rm -rf poem.pdf images/*png images/*gif tests/resources/LoremIpsum.pdf
+
+      - name: Sync to Hugging Face Spaces
+        uses: JacobLinCool/huggingface-sync@v1
+        with:
+          github: ${{ secrets.GITHUB_TOKEN }}
+          user: ismailsimsek # Hugging Face username or organization name
+          space: aistorybooks # Hugging Face space name
+          token: ${{ secrets.HF_TOKEN }} # Hugging Face token
+          ###################################
+          emoji: 📖
+          # Color for Thumbnail gradient (red, yellow, green, blue, indigo, purple, pink, gray).
+          colorFrom: blue
+          colorTo: green
+          # Can be either gradio, streamlit, docker, or static.
+          sdk: streamlit
+          # Any valid Python 3.x or 3.x.x version.
+#            python_version: # optional
+#            # Specify the version of the selected SDK (Streamlit or Gradio). All versions of Gradio are supported. Streamlit versions are supported from 0.79.0 to 1.19.0.
+          sdk_version: 1.44.0
+          # Path to your main application file (which contains either gradio or streamlit Python code, or static html code). Path is relative to the root of the repository.
+          app_file: app.py
+#            # Port on which your application is running. Used only if sdk is docker.
+#            app_port: # optional
+#            # For non-static spaces, initial url to render. Needs to start with /. For static spaces, use app_file instead.
+#            base_path: # optional
+#            # Whether your Space is rendered inside a full-width (when true) or fixed-width column (ie. “container” CSS) inside the iframe. Defaults to false in gradio and streamlit, and to true for other sdks.
+#            fullWidth: # optional
+#            # Whether the Space stays on top of your profile. Can be useful if you have a lot of Spaces so you and others can quickly see your best Space.
+          pinned: true
+          title: AI-Powered Storybooks
+          short_description: AI-Powered Storybook/Poem Generation for Language Learners
+          license: apache-2.0

.gitignore

@@ -0,0 +1,3 @@
+*api-key.txt
+.idea
+run.sh

README.md

@@ -0,0 +1,110 @@
+---
+title: AI-Powered Storybooks
+emoji: 📖
+colorFrom: blue
+colorTo: green
+sdk: streamlit
+sdk_version: 1.44.0
+app_file: app.py
+short_description: AI-Powered Storybook/Poem Generation for Language Learners
+pinned: true
+tags: [ "llm","llm-agents" ]
+---
+
+# AI-Powered Storybook and Poem Generation for Language Learners
+
+This project explores the use of AI agents and various agentic frameworks to create engaging learning materials. It
+experiments with different agentic flows and tool integrations to enhance the learning experience.
+
+The primary focus is to assist language learners by generating storybooks and poems tailored to their specific needs.
+For example, users can transform classic novels into storybooks adapted for language learning, customized to their
+desired proficiency level.
+
+You can interact with and use the live application directly on [Hugging Face Spaces](https://huggingface.co/spaces/ismailsimsek/aistorybooks)
+
+![](images/streamlit-app-demo.gif)
+
+## Classics to Story Book Generators
+
+This tools simplifies classic novels into engaging storybooks. You can choose the target language, reading level,
+and even writing style and saves the final product as a convenient markdown file.
+
+Perfect for language learners to experience the joy of classic stories in a language that supports their learning
+journey.
+
+### Classics to Story Book Generator V2
+
+This version of the storybook generator takes a PDF file of a classic novel as input and transforms it into a storybook
+tailored to your specifications. It leverages advanced language processing to summarize the content, adjust the reading
+level, and adapt the writing style to your preferences. This version is designed to work directly with the content of
+the provided PDF.
+
+**Key Features:**
+
+* **PDF Input:** Accepts a PDF file of a classic novel as the primary input source.
+* **Customizable Output:** Allows you to specify the target language, reading level (e.g., A1 Intermediate), summary
+  size (e.g., Long with 150 sentences/1200 words), and writing style (e.g., Philosophical).
+* **Chunk-Based Processing:** Processes the PDF content in chunks, allowing for efficient handling
+
+```python
+from aistorybooks.phidataa.classic_stories import PhiStoryBookGenerator
+from pathlib import Path
+
+generator = PhiStoryBookGenerator(
+    language="German",
+    level="A1 Intermediate",
+    summary_size="Long (150 sentences/1200 words)",
+    writing_style="Philosophical",
+)
+pdf_file = Path("The-Brothers-Karamazov.pdf")
+results = generator.run(pdf_file=pdf_file, chunk_size=1, padding=0, skip_first_n_pages=0)
+
+for response in results:
+    print(response.content)
+
+```
+
+### Classics to Story Book Generator V1
+
+This version uses llm knowledge to generate the story, and it adds llm generated illustration related to story content,
+to the final markdown file.
+
+Example Output:
+
+- [story.md](story.md)
+
+Usage:
+
+```python
+from aistorybooks.crewaia.classic_stories import StoryBookGenerator
+
+generator = StoryBookGenerator(book="The Karamazov Brothers",
+                               author="Fyodor Dostoevsky",
+                               language="German",
+                               level="A2 Beginner",
+                               summary_size="10 Chapters, each chapter more than 100 sentences log",
+                               writing_style="Philosophical")
+generator.generate()
+```
+
+## Classics to Poem Generator
+
+Transforms a classic book into a poem and saves it as markdown and PDF, with and llm generated illustration.
+
+**Specify the poem style**: Mention the specific poetic style (e.g., "Alexander Pushkin") to get specific poetic style.
+
+Example Output:
+
+- [poem.md](poem.md)
+- [poem.pdf](poem.pdf)
+
+Usage:
+
+```python
+from aistorybooks.crewaia.classic_poems import ClassicPoemGenerator
+
+generator = ClassicPoemGenerator(book="The Karamazov Brothers",
+                                 author="Fyodor Dostoevsky",
+                                 poetic_style="Alexander Pushkin and Philosophical")
+generator.generate()
+```

aistorybooks.iml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/aistorybooks" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/tests" isTestSource="true" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

aistorybooks/autogena/classic_stories.py

@@ -0,0 +1,128 @@
+import chromadb
+from autogen.agentchat.contrib.retrieve_user_proxy_agent import RetrieveUserProxyAgent
+from pathlib import Path
+
+import autogen
+from config import Config
+
+config_list = [
+    # {"model": "gpt-3.5-turbo-0125", "api_key": Config.OPENAI_API_KEY},
+    {"model": Config.GROQ_MODEL_NAME,
+     "api_key": Config.GROQ_API_KEY,
+     "base_url": Config.GROQ_API_BASE_URL
+     }
+]
+
+
+class Classics2StoryBookGenerator:
+    CURRENT_DIR: Path = Path(__file__).parent
+
+    def __init__(self, book: str, author: str, language: str = "English", level: str = "A2 Beginner",
+                 summary_size: str = "10 Chapter, each chapter with 100 sentences", writing_style: str = "Funny"):
+        self.book = book
+        self.author = author
+        self.language = language
+        self.level = level
+        self.summary_size = summary_size
+        self.writing_style = writing_style
+
+        self.llm_config = {"config_list": config_list, "cache_seed": 42}
+        self.human_admin = autogen.UserProxyAgent(
+            name="Admin",
+            system_message="A human admin, who ask questions and give tasks.",
+            human_input_mode="NEVER",
+            code_execution_config={"use_docker": False},  # we don't want to execute code in this case.
+        )
+
+        self.planner = autogen.AssistantAgent(
+            name="Planner",
+            system_message="""
+            Planner. Suggest a plan. Revise the plan based on feedback from admin and critic, until admin approval. 
+            The plan may involve multiple agents.
+                Explain the plan first. Be clear which step is performed by each agent.
+                """,
+            llm_config=self.llm_config,
+        )
+
+        self.critic = autogen.AssistantAgent(
+            name="Critic",
+            system_message="Critic. Double check plan, claims, summaries from other agents and provide feedback. "
+                           "Check whether the plan does whats asked and delegates tasks to all agents.",
+            llm_config=self.llm_config,
+        )
+
+        self.library = RetrieveUserProxyAgent(
+            name="Library",
+            default_auto_reply="Reply `TERMINATE` if the task is done.",
+            system_message="Assistant who has extra content retrieval power for solving difficult problems.",
+            description="Assistant who can retrieve content from documents. "
+                        "Help `Summarizer Author` to retrieve story content from the book.",
+            human_input_mode="NEVER",
+            retrieve_config={
+                "task": "qa",
+                "docs_path": self.CURRENT_DIR.joinpath("books/The-Brothers-Karamazov.pdf").as_posix(),
+                "chunk_token_size": 2000,
+                "client": chromadb.PersistentClient(path=self.CURRENT_DIR.joinpath("chromadb").as_posix()),
+                "get_or_create": True,
+            },
+            code_execution_config={"use_docker": False},  # we don't want to execute code in this case.
+        )
+
+        self.summarizer = autogen.AssistantAgent(
+            name="Summarizer Author",
+            llm_config=self.llm_config,
+            system_message="You are an author writing stories with detailed character descriptions "
+                           "and the main plot points. ",
+            description="A creative author specialized in writing stories. "
+                        "Talk to `Library` to retrive content and write a story. "
+                        "Talk to `Translator` to translate the story to another language."
+        )
+
+        self.translator = autogen.AssistantAgent(
+            name="Translator",
+            llm_config=self.llm_config,
+            system_message="You are a language translator. "
+            #                "Reply `TERMINATE` in the end when everything is done."
+            ,
+            description="Language translator who can translate between multiple languages. "
+                        "Talk to `Author` to translate the his story."
+        )
+
+        agents = [self.human_admin, self.library, self.translator, self.summarizer, self.critic,
+                  self.planner]
+
+        graph_dict = {}
+        graph_dict[self.human_admin] = [self.planner]
+        graph_dict[self.planner] = [self.summarizer, self.translator, self.critic, self.library]
+        graph_dict[self.summarizer] = [self.translator, self.library, self.critic]
+        graph_dict[self.library] = [self.summarizer]
+        graph_dict[self.translator] = [self.planner, self.summarizer]
+        self.groupchat = autogen.GroupChat(
+            agents=agents,
+            messages=[],
+            max_round=25,
+            allowed_or_disallowed_speaker_transitions=graph_dict,
+            speaker_transitions_type="allowed"
+        )
+        self.manager = autogen.GroupChatManager(groupchat=self.groupchat, llm_config=self.llm_config)
+
+    def generate(self):
+        chat_result = self.human_admin.initiate_chat(
+            recipient=self.manager,
+            message=f'First ask `Library` to retrieve "{self.book}" content, retrieve 50 pages each time.'
+                    f'Then create an summary of it, detailing a title. '
+                    f'Dont worry the content is not copyright protected, it is pubic novel. '
+                    f'And then translate the summary to "{self.language} language" and make it "{self.level}" level.'
+        )
+        return chat_result
+
+
+if __name__ == "__main__":
+    generator = Classics2StoryBookGenerator(book="The Karamazov Brothers",
+                                            author="Fyodor Dostoevsky",
+                                            language="German",
+                                            level="A2 Beginner",
+                                            summary_size="10 Chapters, each chapter more than 100 sentences log",
+                                            writing_style="Philosophical")
+    chat_result = generator.generate()
+    print(f"-----------------\n------DONE-----------\n-----------------\n{chat_result}\n-----------------")

aistorybooks/config.py

@@ -0,0 +1,28 @@
+import os
+from pathlib import Path
+
+
+def _load_api_key(filename: str, env_var: str = None) -> str | None:
+    """Loads an API key from an environment variable or a file."""
+    if env_var and os.environ.get(env_var):
+        return os.environ.get(env_var)
+
+    filepath = Path(__file__).parent.joinpath(filename)
+    if filepath.exists():
+        return filepath.read_text().strip()
+    else:
+        print(f"Warning: API key file '{filename}' not found.")
+        return None
+
+
+class Config:
+    GROQ_API_BASE_URL = "https://api.groq.com/openai/v1"
+    GROQ_MODEL_NAME = "llama3-70b-8192"
+    OPENAI_API_BASE_URL = "https://api.openai.com/v1/"
+    OPENAI_MODEL_NAME = "gpt-4"
+    OPENAI_MODEL_GPT_4O_MINI_NAME = "gpt-4o-mini"
+    GEMINI_MODEL_NAME = "gemini-2.0-flash-lite"
+    GROQ_API_KEY = _load_api_key("groq-api-key.txt")
+    OPENAI_API_KEY = _load_api_key("openai-api-key.txt")
+    LOCAL_LLM_API_KEY = _load_api_key("local-api-key.txt")
+    GEMINI_API_KEY = _load_api_key("gemini-api-key.txt", env_var="GOOGLE_API_KEY")

aistorybooks/crewaia/classic_poems.py

@@ -0,0 +1,211 @@
+import os
+from typing import List, Optional
+
+os.environ["OTEL_SDK_DISABLED"] = "true"
+from crewai import Agent, Task, Crew, Process
+from crewai import LLM
+from crewai.agents.agent_builder.base_agent import BaseAgent
+
+from config import Config  # Assuming you have a config.py file
+from tools import ImageGenerator, MarkdownToPdfConverter
+
+
+class ClassicPoemGenerator:
+    """
+    A class to generate a poem based on a classic novel, including image generation,
+    and content formatting.
+    """
+
+    def __init__(
+            self,
+            book: str,
+            author: str,
+            poetic_style: str = "Philosophical",
+    ):
+        """
+        Initializes the ClassicPoemGenerator with book details and preferences.
+
+        Args:
+            book (str): The title of the classic novel.
+            author (str): The author of the classic novel.
+            poetic_style (str, optional): The poetic style for the poem. Defaults to "Philosophical".
+        """
+        self.book = book
+        self.author = author
+        self.poetic_style = poetic_style
+        self.llm = self._initialize_llm()
+        self._tasks: Optional[List[Task]] = None
+        self._crew: Optional[Crew] = None
+
+    def _initialize_llm(self) -> LLM:
+        """Initializes the language model."""
+        return LLM(
+            model="groq/" + Config.GROQ_MODEL_NAME,
+            api_key=Config.GROQ_API_KEY,
+            api_base=Config.GROQ_API_BASE_URL,
+        )
+
+    def _create_poet_agent(self) -> Agent:
+        """Creates the Poet agent."""
+        return Agent(
+            role="Poet",
+            goal=f"Turns given story, novel or literature content to a beautiful poem.",
+            backstory=f"An talented poet who summarizes novels and turns them to a beautiful, imaginary and "
+                      f"metaphorical poems.",
+            verbose=True,
+            llm=self.llm,
+            allow_delegation=False,
+        )
+
+    def _create_creative_poet_agent(self) -> Agent:
+        """Creates the Creative Poet agent."""
+        return Agent(
+            role="Creative Poet",
+            goal=f"Takes the given poem and improves it with {self.poetic_style} style",
+            backstory=f"A creative author specialized in {self.poetic_style} style poems. "
+                      f"Improves poems with {self.poetic_style} elements.",
+            verbose=True,
+            llm=self.llm,
+            allow_delegation=False,
+        )
+
+    def _create_image_generator_agent(self) -> Agent:
+        """Creates the Image Generator agent."""
+        return Agent(
+            role="Image Generator",
+            goal="Generate one image for the poem written by the creative poet. Final output should "
+                 "contain 1 image in json format. Use full poem text to generate the image.",
+            backstory="A creative AI specialized in visual storytelling, bringing each poem to life through "
+                      "imaginative imagery.",
+            verbose=True,
+            llm=self.llm,
+            tools=[ImageGenerator()],
+            allow_delegation=False,
+        )
+
+    def _create_content_formatter_agent(self) -> Agent:
+        """Creates the Content Formatter agent."""
+        return Agent(
+            role="Content Formatter",
+            goal="Format the written story content in markdown, including image at the beginning of each poem.",
+            backstory="A meticulous formatter who enhances the readability and presentation of the storybook.",
+            verbose=True,
+            llm=self.llm,
+            allow_delegation=False,
+        )
+
+    def _create_markdown_to_pdf_creator_agent(self) -> Agent:
+        """Creates the PDF Converter agent."""
+        return Agent(
+            role="PDF Converter",
+            goal="Convert the Markdown file to a PDF document. poem.md is the markdown file name.",
+            backstory="An efficient converter that transforms Markdown files into professionally formatted PDF "
+                      "documents.",
+            verbose=True,
+            llm=self.llm,
+            tools=[MarkdownToPdfConverter()],
+            allow_delegation=False,
+        )
+
+    def _create_create_poem_task(self) -> Task:
+        """Creates the Create Poem task."""
+        poet_agent = self._create_poet_agent()
+        return Task(
+            description=f"Create an summary of {self.book} from {self.author} as a poem. "
+                        f"Giving it a title and character descriptions and making it {self.poetic_style} style poem. "
+                        f"Include title of the poem at the top.",
+            agent=poet_agent,
+            expected_output=f"A structured document with the poem and title of the poem at the top.",
+        )
+
+    def _create_improve_poem_task(self, create_poem_task: Task) -> Task:
+        """Creates the Improve Poem task."""
+        creative_poet_agent = self._create_creative_poet_agent()
+        return Task(
+            description=f"Improve the given poem with {self.poetic_style} style. ",
+            agent=creative_poet_agent,
+            expected_output=f"A improved poem with {self.poetic_style} style.",
+            context=[create_poem_task],
+        )
+
+    def _create_generate_image_task(self, improve_poem_task: Task) -> Task:
+        """Creates the Generate Image task."""
+        image_generator_agent = self._create_image_generator_agent()
+        return Task(
+            description="Generate 1 image that represents the poem text. "
+                        f"Aligning with the {self.poetic_style} theme outlined in the poem. "
+                        f"Use the full poem content to generate image. Dont summarize it, ise it as is.",
+            agent=image_generator_agent,
+            expected_output="A digital image file that visually represents the poem.",
+            context=[improve_poem_task],
+        )
+
+    def _create_format_content_task(self, improve_poem_task: Task, generate_image_task: Task) -> Task:
+        """Creates the Format Content task."""
+        content_formatter_agent = self._create_content_formatter_agent()
+        return Task(
+            description="Format given poem content as a markdown document, "
+                        "Including an image after the title and before the poem. Use <br> as a linebreak",
+            agent=content_formatter_agent,
+            expected_output="""The entire poem content formatted in markdown, With linebreak after each verse. image 
+            added after the title""",
+            context=[improve_poem_task, generate_image_task],
+            output_file="poem.md",
+        )
+
+    def _create_markdown_to_pdf_task(self, format_content_task: Task) -> Task:
+        """Creates the Markdown to PDF task."""
+        markdown_to_pdf_creator_agent = self._create_markdown_to_pdf_creator_agent()
+        return Task(
+            description="Convert a Markdown file to a PDF document, ensuring the preservation of formatting, "
+                        "structure, and embedded images using the mdpdf library.",
+            agent=markdown_to_pdf_creator_agent,
+            expected_output="A PDF file generated from the Markdown input, accurately reflecting the content with "
+                            "proper formatting. The PDF should be ready for sharing or printing.",
+            context=[format_content_task],
+        )
+
+    @property
+    def tasks(self) -> List[Task]:
+        """Creates all the tasks required for the poem generation."""
+        if self._tasks is None:
+            create_poem_task = self._create_create_poem_task()
+            improve_poem_task = self._create_improve_poem_task(create_poem_task)
+            generate_image_task = self._create_generate_image_task(improve_poem_task)
+            format_content_task = self._create_format_content_task(improve_poem_task, generate_image_task)
+            markdown_to_pdf_task = self._create_markdown_to_pdf_task(format_content_task)
+
+            self._tasks = [create_poem_task, improve_poem_task, generate_image_task, format_content_task,
+                           markdown_to_pdf_task]
+        return self._tasks
+
+    @property
+    def agents(self) -> List[BaseAgent]:
+        """Creates all the agents required for the poem generation."""
+        return [task.agent for task in self.tasks]
+
+    @property
+    def crew(self) -> Crew:
+        """Creates the Crew with agents and tasks."""
+        if self._crew is None:
+            self._crew = Crew(
+                agents=self.agents,
+                tasks=self.tasks,
+                verbose=True,
+                process=Process.sequential,
+            )
+        return self._crew
+
+    def generate(self):
+        """Generates the poem by creating agents, tasks, and running the crew."""
+        result = self.crew.kickoff()
+        print(result)
+
+
+if __name__ == "__main__":
+    generator = ClassicPoemGenerator(
+        book="The Karamazov Brothers",
+        author="Fyodor Dostoevsky",
+        poetic_style="Alexander Pushkin and Philosophical",
+    )
+    generator.generate()

aistorybooks/crewaia/classic_stories.py

@@ -0,0 +1,203 @@
+import os
+from typing import List, Optional
+
+os.environ["OTEL_SDK_DISABLED"] = "true"
+from crewai import Agent, Task, Crew, Process
+from crewai import LLM
+from crewai.agents.agent_builder.base_agent import BaseAgent
+
+from config import Config  # Assuming you have a config.py file
+from tools import ImageGenerator
+
+
+class StoryBookGenerator:
+    """
+    A class to generate a storybook based on a classic novel, including translation,
+    image generation, and content formatting.
+    """
+
+    def __init__(
+            self,
+            book: str,
+            author: str,
+            language: str = "English",
+            level: str = "A2 Beginner",
+            summary_size: str = "10 Chapter, each chapter with 100 sentences",
+            writing_style: str = "Funny",
+    ):
+        """
+        Initializes the StoryBookGenerator with book details and preferences.
+
+        Args:
+            book (str): The title of the classic novel.
+            author (str): The author of the classic novel.
+            language (str, optional): The target language for translation. Defaults to "English".
+            level (str, optional): The language proficiency level for translation. Defaults to "A2 Beginner".
+            summary_size (str, optional): The desired size of the summary. Defaults to "10 Chapter, each chapter with 100 sentences".
+            writing_style (str, optional): The writing style for the summary. Defaults to "Funny".
+        """
+        self.book = book
+        self.author = author
+        self.language = language
+        self.level = level
+        self.summary_size = summary_size
+        self.writing_style = writing_style
+        self.llm = self._initialize_llm()
+        self._tasks: Optional[List[Task]] = None
+        self._crew: Optional[Crew] = None
+
+    def _initialize_llm(self) -> LLM:
+        """Initializes the language model."""
+        return LLM(
+            model="openai/" + Config.OPENAI_MODEL_NAME,
+            api_key=Config.OPENAI_API_KEY,
+            api_base=Config.OPENAI_API_BASE_URL,
+        )
+        # return LLM(
+        #     model="groq/" + Config.GROQ_OPENAI_MODEL_NAME,
+        #     api_key=Config.GROQ_OPENAI_API_KEY,
+        #     api_base=Config.GROQ_OPENAI_API_BASE_URL,
+        # )
+
+    def _create_author_agent(self) -> Agent:
+        """Creates the Author agent."""
+        return Agent(
+            role="Author",
+            goal=f"Creates {self.summary_size} version of well known novels. Improves the summary with {self.writing_style} style",
+            backstory=f"A creative author specialized in {self.writing_style} style stories. Improves stories with {self.writing_style} elements.",
+            verbose=True,
+            llm=self.llm,
+            allow_delegation=False,
+        )
+
+    def _create_translator_agent(self) -> Agent:
+        """Creates the Translator agent."""
+        return Agent(
+            role="Translator",
+            goal=f"""Translates given text to {self.language} language. 
+            Simplifies the translation to {self.level} level for language learners.""",
+            backstory=f"An talented translator translates english text to {self.language}.",
+            verbose=True,
+            llm=self.llm,
+            allow_delegation=False,
+        )
+
+    def _create_image_generator_agent(self) -> Agent:
+        """Creates the Image Generator agent."""
+        return Agent(
+            role="Image Generator",
+            goal="Generate image for the given story. Final output should contain 1 image in json format. "
+                 "Use full story text to generate the image.",
+            backstory="A creative AI specialized in visual storytelling, bringing each chapter to life through "
+                      "imaginative imagery.",
+            verbose=True,
+            llm=self.llm,
+            tools=[ImageGenerator()],
+            allow_delegation=False,
+        )
+
+    def _create_content_formatter_agent(self) -> Agent:
+        """Creates the Content Formatter agent."""
+        return Agent(
+            role="Content Formatter",
+            goal="Format the written story content in markdown, including images at the beginning of each chapter.",
+            backstory="A meticulous formatter who enhances the readability and presentation of the storybook.",
+            verbose=True,
+            llm=self.llm,
+            allow_delegation=False,
+        )
+
+    def _create_summarize_task(self) -> Task:
+        """Creates the Summarize task."""
+        author_agent = self._create_author_agent()
+        return Task(
+            description=f"Create an summary of {self.book} from {self.author}, detailing "
+                        f"a title and character descriptions. summary size should be {self.summary_size}.",
+            agent=author_agent,
+            expected_output=f"A structured outline story with the length of {self.summary_size}. "
+                            f"It includes detailed character descriptions and the main plot points.",
+        )
+
+    def _create_generate_image_task(self, summarize_task: Task) -> Task:
+        """Creates the Generate Image task."""
+        image_generator_agent = self._create_image_generator_agent()
+        return Task(
+            description="Generate image that represents the story text. "
+                        f"Aligning with the theme outlined in the story. "
+                        f"Use the full story content to generate image. "
+                        f"Dont summarize the content, use full story content.",
+            agent=image_generator_agent,
+            expected_output="A digital image file that visually represents the story.",
+            context=[summarize_task],
+        )
+
+    def _create_translate_task(self, summarize_task: Task) -> Task:
+        """Creates the Translate task."""
+        translator_agent = self._create_translator_agent()
+        return Task(
+            description=f"""Using the story provided, translate the full story to {self.language} in {self.level} level. 
+                        add repetition to it to make it better for language learners""",
+            agent=translator_agent,
+            expected_output=f"""A complete manuscript of the storybook in {self.language}. 
+            Its in simple language leve land includes repetition for language learners.""",
+            context=[summarize_task],
+        )
+
+    def _create_format_content_task(self, translate_task: Task, generate_image_task: Task) -> Task:
+        """Creates the Format Content task."""
+        content_formatter_agent = self._create_content_formatter_agent()
+        return Task(
+            description="Format the story content in markdown, including an image at the beginning of the story. "
+                        "Use <br> as a linebreak",
+            agent=content_formatter_agent,
+            expected_output="""The entire storybook content formatted in markdown, with imaged added at the beginning 
+            of the story.""",
+            context=[translate_task, generate_image_task],
+            output_file="story.md",
+        )
+
+    @property
+    def tasks(self) -> List[Task]:
+        """Creates all the tasks required for the storybook generation."""
+        if self._tasks is None:
+            summarize_task = self._create_summarize_task()
+            generate_image_task = self._create_generate_image_task(summarize_task)
+            translate_task = self._create_translate_task(summarize_task)
+            format_content_task = self._create_format_content_task(translate_task, generate_image_task)
+
+            self._tasks = [summarize_task, translate_task, generate_image_task, format_content_task]
+        return self._tasks
+
+    @property
+    def agents(self) -> List[BaseAgent]:
+        """Creates all the agents required for the storybook generation."""
+        return [task.agent for task in self.tasks]
+
+    @property
+    def crew(self) -> Crew:
+        """Creates the Crew with agents and tasks."""
+        if self._crew is None:
+            self._crew = Crew(
+                agents=self.agents,
+                tasks=self.tasks,
+                verbose=True,
+                process=Process.sequential,
+            )
+        return self._crew
+
+    def generate(self):
+        """Generates the storybook by creating agents, tasks, and running the crew."""
+        result = self.crew.kickoff()
+        print(result)
+
+
+if __name__ == "__main__":
+    generator = StoryBookGenerator(
+        book="The Karamazov Brothers",
+        author="Fyodor Dostoevsky",
+        language="German",
+        level="A2 Beginner",
+        summary_size="10 Chapters, each chapter more than 100 sentences log",
+        writing_style="Philosophical",
+    )
+    generator.generate()

aistorybooks/crewaia/tools.py

@@ -0,0 +1,112 @@
+import markdown
+import os
+import pdfkit
+import re
+import requests
+from openai import OpenAI
+from pathlib import Path
+from pydantic import BaseModel, Field, ConfigDict
+from typing import Type
+
+from config import Config
+from crewai.tools import BaseTool
+
+
+class ImageGeneratorInput(BaseModel):
+    """Input schema for ImageGenerator."""
+
+    image_description: str = Field(
+        ..., description="A detailed description of the image to be generated."
+    )
+
+
+class ImageGenerator(BaseTool):
+    """
+    Generates an image for a given description using the OpenAI API.
+    """
+
+    name: str = "Generate Image"
+    description: str = (
+        "Generates an image for a given description using the OpenAI image generation API, "
+        "saves it in the current folder, and returns the image path. "
+        "The image description should be detailed and longer than 100 characters."
+    )
+    args_schema: Type[BaseModel] = ImageGeneratorInput
+    client: OpenAI = Field(
+        default_factory=lambda: OpenAI(api_key=Config.OPENAI_API_KEY),
+        description="OpenAI client instance.",
+    )
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    def _run(self, image_description: str) -> str:
+        if len(image_description) < 100:
+            raise ValueError("Please provide a longer image description (at least 100 characters).")
+
+        response = self.client.images.generate(
+            model="dall-e-3",
+            prompt=f"Image is about: {image_description}. "
+                   f"Style: Illustration. Create an illustration incorporating a vivid palette with an emphasis on shades "
+                   f"of azure and emerald, augmented by splashes of gold for contrast and visual interest. The style "
+                   f"should evoke the intricate detail and whimsy of early 20th-century storybook illustrations, "
+                   f"blending realism with fantastical elements to create a sense of wonder and enchantment. The "
+                   f"composition should be rich in texture, with a soft, luminous lighting that enhances the magical "
+                   f"atmosphere. Attention to the interplay of light and shadow will add depth and dimensionality, "
+                   f"inviting the viewer to delve into the scene. DON'T include ANY text in this image. DON'T include "
+                   f"colour palettes in this image.",
+            size="1024x1024",
+            quality="standard",
+            n=1,
+        )
+
+        image_url = response.data[0].url
+        words = image_description.split()[:5]
+        safe_words = [re.sub(r"[^a-zA-Z0-9_]", "", word) for word in words]
+        filename = "_".join(safe_words).lower() + ".png"
+        filepath = Path(os.getcwd()).joinpath("images", filename)
+
+        # Download the image from the URL
+        image_response = requests.get(image_url)
+        if image_response.status_code == 200:
+            print(f"Saving image: {filepath.as_posix()}")
+            filepath.write_bytes(image_response.content)
+        else:
+            print("Failed to download the image.")
+            return ""
+
+        return filepath.relative_to(os.getcwd()).as_posix()
+
+
+class MarkdownToPdfConverterInput(BaseModel):
+    """Input schema for MarkdownToPdfConverter."""
+
+    markdown_file_name: str = Field(
+        ..., description="Path to the input Markdown file."
+    )
+
+
+class MarkdownToPdfConverter(BaseTool):
+    """
+    Converts a Markdown file to a PDF document using the pdfkit python library.
+    """
+
+    name: str = "Convert Markdown to PDF"
+    description: str = (
+        "Converts a Markdown file to a PDF document using the pdfkit python library. "
+        "The input should be a valid path to a markdown file."
+    )
+    args_schema: Type[BaseModel] = MarkdownToPdfConverterInput
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    def _run(self, markdown_file_name: str) -> str:
+        output_file = os.path.splitext(markdown_file_name)[0] + ".pdf"
+
+        # Read the markdown file
+        with open(Path(markdown_file_name), "r") as f:
+            text = f.read()
+        # Convert to HTML
+        html = markdown.markdown(text)
+        # Convert to PDF
+        pdfkit.from_string(html, output_file, options={"enable-local-file-access": ""})
+
+        return output_file

aistorybooks/phidataa/classic_stories.py

@@ -0,0 +1,114 @@
+import httpx
+from openai._base_client import SyncHttpxClientWrapper
+from pathlib import Path
+from phi.agent import Agent as PhiAgent
+from phi.model.google.gemini import Gemini
+from phi.model.openai.like import OpenAILike
+from phi.utils.log import logger as PhiLogger
+from phi.workflow import RunResponse, RunEvent
+from typing import Optional, Union, Iterator
+
+from aistorybooks.config import Config
+from aistorybooks.utils import PdfUtil
+
+
+class OpenAILikeNoVerifySSL(OpenAILike):
+
+    def __init__(self, base_url: Optional[Union[str, httpx.URL]] = None, *args, **kwargs):
+        http_client = SyncHttpxClientWrapper(
+            base_url=base_url,
+            verify=False
+        )
+        super().__init__(http_client=http_client, base_url=base_url, *args, **kwargs)
+
+
+class PhiStoryBookGenerator:
+
+    def __init__(
+            self,
+            language: str = "English",
+            level: str = "A2 Beginner",
+            summary_size: str = "approximately 100 sentences and approximately 800 hundred words",
+            writing_style: str = "Funny",
+            **kwargs
+    ):
+        self.language = language
+        self.level = level
+        self.summary_size = summary_size
+        self.writing_style = writing_style
+        self.model = Gemini(
+            id=Config.GEMINI_MODEL_NAME,
+            api_key=Config.GEMINI_API_KEY
+        )
+
+        self.author_agent = PhiAgent(
+            model=self.model,
+            description="Expert author rewriting novels to a shortened stories.",
+            task=(
+                f"Rewrite given the novel text to {self.summary_size} a story, "
+                f"rewrite it in a {self.writing_style} style. "
+                f"Target {self.level} language learners. Repeat key words. Maintain narrative flow."
+                f"This is a first section of the big novel. Next sections will follow."
+            ),
+            markdown=True,
+            debug_mode=True,
+        )
+
+        self.translator_agent = PhiAgent(
+            model=self.model,
+            description=f"Expert English to {self.language} translator.",
+            task=(
+                f"Translate Given English text to {self.language} for {self.level} level language learners. "
+                f"Repeat key words. Ensure natural story flow."
+            ),
+            markdown=True,
+            debug_mode=True,
+        )
+
+    def return_if_response_none(self, response: RunResponse):
+        if response is None:
+            yield RunResponse(event=RunEvent.workflow_completed, content=f"Sorry, received empty result")
+
+    # @TODO add tenacity and retry api call "rate limit exceptions"!
+    def _run_chunk(self, content: str, start_page, end_page) -> RunResponse:
+        try:
+            summary: RunResponse = self.author_agent.run(content)
+            if summary is None or summary.content is None:
+                return RunResponse(event="RunFailed",
+                                   content=f"Failed to generate summary for pages {start_page}-{end_page}")
+
+            translated: RunResponse = self.translator_agent.run(summary.content)
+            if translated is None or translated.content is None:
+                return RunResponse(event="RunFailed",
+                                   content=f"Failed to translate summary for pages {start_page}-{end_page}")
+            return translated
+        except Exception as e:
+            return RunResponse(event="RunFailed", content=f"Error processing pages {start_page}-{end_page}: {e}")
+
+    def run(self, pdf_file: Path, chunk_size=10, padding=1, skip_first_n_pages=0) -> Iterator[RunResponse]:
+        # final = pdf_file.parent.joinpath(f"{pdf_file.stem}.md")
+        data = PdfUtil.process_pdf_file(pdf_file)
+        chunks = PdfUtil.split_document_into_chunks(
+            data=data,
+            chunk_size=chunk_size,
+            padding=padding,
+            skip_first_n_pages=skip_first_n_pages
+        )
+
+        total_chunks = len(chunks)
+        for index, chunk in enumerate(chunks):
+            start_page = chunk[0].extra_info.get('page')
+            end_page = chunk[-1].extra_info.get('page')
+            total_pages = chunk[-1].extra_info.get('total_pages')
+            PhiLogger.info(f"Processing Pages: {start_page}-{end_page}")
+            chunk_str = "\n\n".join([doc.text for doc in chunk])
+
+            response = self._run_chunk(content=chunk_str, start_page=start_page, end_page=end_page)
+
+            if response.event != "RunFailed":
+                response.metrics[
+                    'progress_info'] = f"Processed Pages: {skip_first_n_pages}-{end_page} of {total_pages}"
+                response.metrics['progress_total'] = total_chunks
+                response.metrics['progress_current_index'] = index + 1
+                response.metrics['progress_percent'] = int(((index + 1) / total_chunks) * 100)
+            yield response

aistorybooks/utils.py

@@ -0,0 +1,39 @@
+import pickle
+import pymupdf4llm
+from llama_index.core.schema import Document
+from pathlib import Path
+from typing import List
+
+
+class PdfUtil:
+
+    @staticmethod
+    def process_pdf_file(pdf_file: Path, save_to_pickle: bool = False) -> List[Document]:
+        pickle_file = pdf_file.parent.joinpath(f"{pdf_file.stem}.pkl")
+
+        if pickle_file.exists() and save_to_pickle is True:
+            print(f"Loading data from pickle file: {pickle_file}")
+            with open(pickle_file, "rb") as f:
+                data = pickle.load(f)
+        else:
+            print(f"Processing PDF file: {pdf_file}")
+            reader = pymupdf4llm.LlamaMarkdownReader()
+            data: List[Document] = reader.load_data(pdf_file)
+
+            if save_to_pickle:
+                print(f"Saving data to pickle file: {pickle_file}")
+                with open(pickle_file, "wb") as f:
+                    pickle.dump(data, f)
+
+        return data
+
+    @staticmethod
+    def split_document_into_chunks(data: List[Document], chunk_size: int, padding: int, skip_first_n_pages=0) -> List[
+        List[Document]]:
+        chunks: List[List[Document]] = []
+        for i in range(skip_first_n_pages, len(data), chunk_size):
+            start_index = max(skip_first_n_pages, i - padding)
+            end_index = min(len(data), i + chunk_size + padding)
+            chunk_pages = data[start_index:end_index]
+            chunks.append(chunk_pages)
+        return chunks

app.py

@@ -0,0 +1,290 @@
+import shutil
+import statistics
+import tempfile
+import uuid
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import List
+
+import streamlit as st
+from llama_index.core.schema import Document
+from streamlit.runtime.uploaded_file_manager import UploadedFile
+
+from aistorybooks.phidataa.classic_stories import PhiStoryBookGenerator
+
+
+@dataclass
+class AppInputs:
+    """
+    Data class to hold the input values for the Streamlit app.
+    """
+
+    uploaded_file: UploadedFile | None = None
+    language: str = "German"
+    level: str = "B1 Intermediate"
+    summary_size: str = "Long (150 sentences/1200 words)"
+    writing_style: str = "Philosophical"
+    chunk_size: int = 10
+    padding: int = 1
+    skip_first_n_pages: int = 0
+    language_options: List[str] = field(
+        default_factory=lambda: ["German", "English", "Spanish", "French"]
+    )
+    level_options: List[str] = field(
+        default_factory=lambda: [
+            "A1 Beginner",
+            "A2 Elementary",
+            "B1 Intermediate",
+            "B2 Upper Intermediate",
+            "C1 Advanced",
+            "C2 Proficiency",
+        ]
+    )
+    summary_size_options: List[str] = field(
+        default_factory=lambda: [
+            "Short (50 sentences/400 words)",
+            "Medium (100 sentences/800 words)",
+            "Long (150 sentences/1200 words)",
+        ]
+    )
+    writing_style_options: List[str] = field(
+        default_factory=lambda: [
+            "Philosophical",
+            "Narrative",
+            "Descriptive",
+            "Humorous",
+            "Formal",
+        ]
+    )
+
+
+def st_sidebar(inputs: AppInputs):
+    """
+    Creates the sidebar for the Streamlit app and populates the input values.
+
+    Args:
+        inputs (AppInputs): An instance of the AppInputs data class.
+    """
+
+    st.header("Input Options:")
+    with st.form(key='inputs_form', border=False):
+        inputs.uploaded_file = st.file_uploader(
+            "Upload your novel (PDF)",
+            type=["pdf"],
+            accept_multiple_files=False,
+            help="Upload the PDF file of the novel you want to convert.",
+        )
+
+        inputs.language = st.selectbox(
+            "Select Target Story Language",
+            inputs.language_options,
+            index=inputs.language_options.index(inputs.language),
+            help="Choose the language you want the storybook to be in.",
+        )
+
+        inputs.level = st.selectbox(
+            "Select Language Level",
+            inputs.level_options,
+            index=inputs.level_options.index(inputs.level),
+            help="Select the target language proficiency level for the storybook.",
+        )
+
+        inputs.summary_size = st.selectbox(
+            "Desired Summary Length (Per Chunk)",
+            inputs.summary_size_options,
+            index=inputs.summary_size_options.index(inputs.summary_size),
+            help="Specify the desired length of the summary for each chunk of the novel.",
+        )
+
+        inputs.writing_style = st.selectbox(
+            "Desired Writing Style",
+            inputs.writing_style_options,
+            index=inputs.writing_style_options.index(inputs.writing_style),
+            help="Choose the writing style for the generated storybook.",
+        )
+
+        inputs.chunk_size = st.number_input(
+            "Chunk Size",
+            min_value=1,
+            value=inputs.chunk_size,
+            help="Number of pages to process per iteration. Larger chunks may take longer to process.",
+        )
+        inputs.padding = st.number_input(
+            "Padding",
+            min_value=0,
+            value=inputs.padding,
+            help="Number of pages to overlap between chunks. Helps maintain context.",
+        )
+        inputs.skip_first_n_pages = st.number_input(
+            "Skip First N Pages",
+            min_value=0,
+            value=inputs.skip_first_n_pages,
+            help="Number of pages to skip at the beginning of the novel (e.g., table of contents).",
+        )
+        submit_button = st.form_submit_button(label='Submit')
+        return submit_button
+
+
+def st_process_file(inputs: AppInputs) -> List[List[Document]]:
+    uploaded_file_name = inputs.uploaded_file.name
+    st.info(f"Uploaded File: **{inputs.uploaded_file.name}**. Preparing your storybook... (Working in the background)."
+            f"  \nPlease note: Processing is powered by the free tier of Gemini, which may experience rate limiting.",
+            icon=":material/info:")
+
+    try:
+        temp_folder = Path(tempfile.mkdtemp(prefix="story_gen_temp_"))
+        progress_value = 0
+        progress = st.progress(value=progress_value, text=f"Processing file...")
+        pdf_file = temp_folder.joinpath(uploaded_file_name)
+        md_file_name = f"{pdf_file.stem}.md"
+        # pdf_file_final = pdf_file.parent.joinpath(f"{pdf_file.stem}_story.pdf")
+        pdf_file.write_bytes(inputs.uploaded_file.getvalue())
+        generator = PhiStoryBookGenerator(
+            language=inputs.language,
+            level=inputs.level,
+            summary_size=inputs.summary_size,
+            writing_style=inputs.writing_style,
+        )
+        st.session_state[md_file_name] = ""
+        button_container = st.empty()
+        info_container = st.empty()
+        it = generator.run(pdf_file=pdf_file,
+                           chunk_size=inputs.chunk_size,
+                           padding=inputs.padding,
+                           skip_first_n_pages=inputs.skip_first_n_pages
+                           )
+        for response in it:
+            if response.event == "RunFailed":
+                st.error(f"{response.content}", icon=":material/error:")
+                progress.progress(value=progress_value, text=f"Error: {response.content}")
+            else:
+                progress_value = response.metrics['progress_percent']
+                progress.progress(value=progress_value, text=response.metrics['progress_info'])
+            st.session_state[md_file_name] += f"\n\n{response.content}"
+            button_container.empty()
+            button_container.download_button(label='Download Storybook as Markdown',
+                                             data=st.session_state.get(md_file_name),
+                                             file_name=md_file_name,
+                                             mime='text/markdown',
+                                             on_click="ignore",
+                                             key=str(uuid.uuid4()),
+                                             type="primary",
+                                             icon=":material/download:",
+                                             )
+            info_container.empty()
+            metrics = generator.model.metrics
+            avg_response_time = statistics.mean(metrics.get('response_times', [])) if metrics else 0
+            input_tokens = metrics.get('input_tokens', 0) if metrics else 0
+            output_tokens = metrics.get('output_tokens', 0) if metrics else 0
+            total_tokens = metrics.get('total_tokens', 0) if metrics else 0
+            info_container.info(f"Model: {generator.model.name} "
+                                f"  \n Avg response time: {avg_response_time} "
+                                f"  \n Input tokens: {input_tokens} "
+                                f"  \n Output tokens: {output_tokens} "
+                                f"  \n Total tokens: {total_tokens}",
+                                icon=":material/info:")
+    finally:
+        if temp_folder and temp_folder.exists():
+            shutil.rmtree(temp_folder)
+            st.info(f"Temporary folder and its contents cleared", icon=":material/info:")
+
+
+def st_main_page(inputs: AppInputs):
+    """
+    Creates the main page for the Streamlit app and displays the input values.
+
+    Args:
+        inputs (AppInputs): An instance of the AppInputs data class.
+    """
+    st.title("Novel to Storybook Generator")
+    st.write("---")
+    options_text = f"""
+        **Selected Options:**  
+        **Language:** {inputs.language} | 
+        **Language Level:** {inputs.level} | 
+        **Summary Length:** {inputs.summary_size} | 
+        **Writing Style:** {inputs.writing_style} | 
+        **Chunk Size:** {inputs.chunk_size} | 
+        **Padding:** {inputs.padding} | 
+        **Skip First N Pages:** {inputs.skip_first_n_pages}
+        """
+    st.markdown(options_text)
+    if inputs.uploaded_file:
+        st_process_file(inputs=inputs)
+
+
+def st_set_css_and_footer():
+    st.markdown(
+        """
+            <style>
+                .stAppHeader {
+                    background-color: rgba(255, 255, 255, 0.0);  /* Transparent background */
+                    visibility: visible;  /* Ensure the header is visible */
+                }
+                
+                .block-container {
+                    padding-top: 0.5rem;
+                    padding-bottom: 0rem;
+                    padding-left: 5rem;
+                    padding-right: 5rem;
+                }
+                .footer {
+                    position: fixed;
+                    left: 0;
+                    bottom: 2px;
+                    width: 100%;
+                    text-align: right;
+                    padding-right: 40px;
+                }
+                .footer a {
+                    margin: 0 5px; /* Reduced margin for smaller icons */
+                    text-decoration: none;
+                }
+
+                .footer img {
+                    height: 18px; /* Adjusted height for smaller icons */
+                    width: 18px; /* Adjusted width for smaller icons */
+                    vertical-align: middle;
+                    opacity: 0.7; /* Added opacity for a softer look */
+                    transition: opacity 0.3s ease; /* Added transition for hover effect */
+                }
+
+                .footer img:hover {
+                    opacity: 1.0; /* Increased opacity on hover */
+                }
+            </style>
+            """,
+        unsafe_allow_html=True,
+    )
+
+    footer_html = """
+    <div class='footer'>
+        <p>
+            Need to leverage AI for your business, improve your data and analytics setup or strategy? 
+            Feel free to contact. 
+        <a href="https://github.com/ismailsimsek" target="_blank">
+            <img src="https://cdn-icons-png.flaticon.com/512/25/25231.png" alt="GitHub">
+        </a>
+        <a href="https://www.linkedin.com/in/ismailsimsek/" target="_blank">
+            <img src="https://cdn-icons-png.flaticon.com/512/174/174857.png" alt="LinkedIn">
+        </a>
+        <a href="https://medium.com/@ismail-simsek" target="_blank">
+            <img src="https://cdn-icons-png.flaticon.com/512/1384/1384015.png" alt="Medium">
+        </a>
+        Copyright 2025 Ismail Simsek</p>
+    </div>
+    """
+    st.markdown(footer_html, unsafe_allow_html=True)
+
+def main():
+    st.set_page_config(layout="wide")
+    st_set_css_and_footer()
+    inputs = AppInputs()
+    with st.sidebar:
+        st_sidebar(inputs)
+
+    st_main_page(inputs)
+
+
+if __name__ == "__main__":
+    main()

poem.md

@@ -0,0 +1,42 @@
+**The Karamazov Conscience**
+![a haunting mystical depiction of](images/a_haunting_mystical_depiction_of.png)
+
+In the shadow of the monastery's ancient walls,<br>
+Where faith and doubt entwine like ivy's grasp,<br>
+A tale of brothers, bound by blood and fate,<br>
+Unfolds like a dark tapestry, forever great.<br>
+
+Alyosha, gentle soul, with heart aglow,<br>
+A beacon of compassion, in a world of woe,<br>
+His eyes, like lanterns, shining bright and true,<br>
+Reflecting the beauty, of the human heart, anew.<br>
+
+Ivan, the skeptic, with mind afire,<br>
+A whirlwind of logic, that reason's highest desire,<br>
+He questions the heavens, with a rebel's cry,<br>
+And in the silence, his own demons, he'll deny.<br>
+
+Dmitri, the sensual, with passions untamed,<br>
+A heart, aflutter, like a bird, in love's sweet name,<br>
+His desires, a maelstrom, that rage like the sea,<br>
+As he navigates, the treacherous shores, of humanity.<br>
+
+Smerdyakov, the serpent, with a heart of stone,<br>
+A darkness, that festers, like a wound, untold,<br>
+His eyes, like ice, that freeze the blood in vain,<br>
+As he weaves a web, of deceit, and deadly gain.<br>
+
+Fyodor Pavlovich, the patriarch, of old,<br>
+A man, of contradictions, with a heart, of gold,<br>
+His legacy, a tangle, of love and strife,<br>
+A family, entwined, in a dance, of life.<br>
+
+In the town, of Skotoprigonievsk, where the Volga flows,<br>
+The Karamazov brothers, in a tragic, waltz, dispose,<br>
+Their lives, a labyrinth, of love, and bitter strife,<br>
+A dance, of humanity, in the shadow, of life.<br>
+
+In this, their story, a philosophical treatise, unfolds,<br>
+A quest, for meaning, in the human, heart of gold,<br>
+A search, for truth, in the labyrinth, of the mind,<br>
+A journey, through the darkness, to the light, we find.<br>

requirements.txt

@@ -0,0 +1,17 @@
+crewai[tools]>=0.108.0
+mdpdf
+markdown
+pdfkit
+langchain-community
+pyautogen[retrievechat]
+poppler-utils
+ipython
+streamlit
+llama_index
+pymupdf4llm
+tenacity
+llama_index
+pymupdf4llm
+phidata
+openai
+google-generativeai

story.md

@@ -0,0 +1,86 @@
+**Die Karamazov-Brüder: Eine Philosophische Odyssee**
+!["a_complex_web_of_relationships.png"](images/a_complex_web_of_relationships.png)<br>
+
+**Kapitel 1: Die Karamazov-Familie**
+Die Karamazov-Familie, ein komplexes Netzwerk von Beziehungen und philosophischen Debatten, steht im Zentrum dieses
+epischen Romans. Die Geschichte dreht sich um die drei Brüder, Dmitri, Ivan und Alyosha, die jeweils unterschiedliche
+philosophische Perspektiven vertreten. Ihr Vater, Fyodor Pavlovich Karamazov, ein reicher und unmoralischer
+Großgrundbesitzer, ist der Katalysator für die Ereignisse, die sich entwickeln.
+
+Dmitri, der älteste, ist ein sinnlicher und impulsiver Offizier, der die Prinzipien des Hedonismus und Nihilismus
+verkörpert. Ivan, der mittlere Bruder, ist ein rationaler und atheistischer Intellektueller, der die Ideale des
+Determinismus und der moralischen Relativität verkörpert. Alyosha, der jüngste, ist ein mitfühlender und spiritueller
+Novize, der die Prinzipien der christlichen Moral und Altruismus verkörpert.
+
+**Kapitel 2: Das Zusammenkommen des Sturms**
+Die Geschichte beginnt mit der Ankunft von Dmitri in der kleinen Stadt Skotoprigonievsk, wo sein Vater, Fyodor
+Pavlovich, die Ankunft seiner Söhne erwartet. Die Spannung zwischen den Familienmitgliedern ist spürbar, als sie sich im
+Kloster versammeln, um das Erbe des Vaters zu diskutieren.
+
+Inzwischen hat die geheimnisvolle und schöne Grushenka, eine Verführerin mit einer mysteriösen Vergangenheit, die
+Aufmerksamkeit von Dmitri und seinem Vater erregt. Als die familiären Dynamiken sich entwickeln, beginnen die
+philosophischen Debatten zwischen den Brüdern zu formen.
+
+**Kapitel 3: Der Große Inquisitor**
+Ivan, der Atheist, präsentiert sein berühmtes Gedicht "Der Große Inquisitor", eine scharfe Kritik am Christentum und
+seiner vermeintlichen Heuchelei. Dies löst einen heftigen Streit zwischen Ivan und Alyosha aus, als sie sich mit der
+Natur der Moral, der Freiheit des Willens und der Existenz Gottes auseinandersetzen.
+
+In diesem Kapitel verwebt Dostojewski philosophische Konzepte, wie das Problem des Bösen, die Natur der Moral und die
+Rolle des Einzelnen in der Gesellschaft, zu einem feinen Gewebe.
+
+**Kapitel 4: Die Geheimnisvolle Grushenka**
+Grushenkas Anwesenheit sorgt weiterhin für Unruhe, als Dmitri immer mehr von ihr besessen wird. Inzwischen wird Alyoshas
+mitfühlende Natur auf die Probe gestellt, als er versucht, die streitenden Fraktionen innerhalb der Familie zu
+versöhnen.
+
+Durch Grushenkas Charakter erkundet Dostojewski die Themen der Moral, der Versuchung und der menschlichen Natur, indem
+er Fragen über die Natur des Guten und Bösen aufwirft.
+
+**Kapitel 5: Der Vatermord**
+Die Spannung zwischen Fyodor Pavlovich und seinen Söhnen erreicht einen Siedepunkt, der in einem tragischen Ereignis
+kulminiert, das ihr Leben für immer verändern wird. Als die Familie auseinanderbricht, nehmen die philosophischen
+Debatten eine neue Dringlichkeit an.
+
+In diesem Kapitel erkundet Dostojewski die Konsequenzen des moralischen Relativismus, die Natur der Gerechtigkeit und
+die Rolle des Einzelnen bei der Gestaltung seines eigenen Schicksals.
+
+**Kapitel 6: Die Untersuchung**
+Als die Untersuchung zum Vatermord beginnt, werden die dunklen Geheimnisse der Familie enthüllt, und die Brüder werden
+gezwungen, ihre eigenen moralischen Mängel zu konfrontieren. Ivans Rationalismus wird auf die Probe gestellt, als er
+sich mit den Konsequenzen seines eigenen Atheismus auseinandersetzt.
+
+Dostojewski erkundet die Themen der Schuld, der Verantwortung und der Natur der Gerechtigkeit, indem er fundamentale
+Fragen über die menschliche Natur aufwirft.
+
+**Kapitel 7: Der Prozess**
+Der Prozess gegen Dmitri Karamazov dient als Hintergrund für eine tiefere Erkundung der Moral, der Gerechtigkeit und der
+Rolle des Einzelnen in der Gesellschaft. Als die Anklage und die Verteidigung ihre Fälle vorbringen, erreichen die
+philosophischen Debatten einen Höhepunkt.
+
+In diesem Kapitel erkundet Dostojewski die Spannung zwischen individueller Freiheit und gesellschaftlichen Zwängen,
+indem er Fragen über die Natur der Moral und die Rolle des Staates aufwirft.
+
+**Kapitel 8: Das Urteil**
+Das Urteil wird gefällt, und die Familie muss sich mit den Konsequenzen ihrer Handlungen auseinandersetzen. Als die
+Brüder über die Ereignisse reflektieren, die sich entwickelt haben, werden sie gezwungen, ihre eigenen moralischen
+Mängel zu konfrontieren.
+
+Dostojewski erkundet die Themen der Erlösung, der Vergebung und der Möglichkeit des moralischen Wachstums, indem er
+fundamentale Fragen über die menschliche Natur aufwirft.
+
+**Kapitel 9: Der Weg zur Erlösung**
+Im Anschluss an den Prozess machen die Brüder sich auf eine Reise der Selbstentdeckung, indem sie sich mit den
+Konsequenzen ihrer Handlungen auseinandersetzen. Alyoshas Mitgefühl und Weisheit dienen als Leuchtfeuer der Hoffnung,
+als die Familie beginnt, zu heilen und sich neu zu formieren.
+
+In diesem Kapitel erkundet Dostojewski die Themen der Erlösung, der Vergebung und der Möglichkeit des moralischen
+Wachstums, indem er fundamentale Fragen über die menschliche Natur aufwirft.
+
+**Kapitel 10: Das Vermächtnis der Karamazovs**
+Als die Geschichte zu Ende geht, treten die Karamazov-Brüder transformiert hervor, ihre philosophischen Debatten haben
+ihr Verständnis der Welt und ihrer Rolle darin geprägt. Der Roman endet mit einem Gefühl der Hoffnung und Erlösung, als
+die Brüder in die Zukunft blicken, für immer von ihren Erfahrungen geprägt.
+
+In diesem letzten Kapitel verwebt Dostojewski die philosophischen Fäden, die sich durch den ganzen Roman gezogen haben,
+zu einem reichen Teppich von Ideen, die bis heute bei den Lesern nachhallen.

tests/test_phidata.py

@@ -0,0 +1,41 @@
+import unittest
+from pathlib import Path
+
+from aistorybooks.phidata.classic_stories import PhiStoryBookGenerator
+
+
+@unittest.skip("Local user test only")
+class TestPhiStoryBookGenerator(unittest.TestCase):
+
+    def test_story_book_generator(self):
+        pdf_file = Path(__file__).parent.joinpath("resources/LoremIpsum.pdf")
+
+        generator = PhiStoryBookGenerator(
+            language="German",
+            level="A1 Intermediate",
+            summary_size="Long (150 sentences/1200 words)",
+            writing_style="Philosophical",
+        )
+
+        results = generator.run(pdf_file=pdf_file, chunk_size=1, padding=0, skip_first_n_pages=0)
+
+        i = 0
+        for result in results:
+            i += 1
+            print(result.metrics)
+            if i > 2:
+                raise "STOP"
+
+    @unittest.skip("Local user test only")
+    def test_story_book_generator_run_chunk(self):
+        generator = PhiStoryBookGenerator(
+            language="German",
+            level="A1 Intermediate",
+            summary_size="Long (150 sentences/1200 words)",
+            writing_style="Funny",
+        )
+
+        result = generator.author_agent.run("hello, how are you doing")
+        print(result)
+        result = generator._run_chunk(content="hello, how are you doing", start_page=0, end_page=1)
+        print(result)

tests/test_utils.py

@@ -0,0 +1,50 @@
+import unittest
+from llama_index.core.schema import Document
+from pathlib import Path
+from typing import List
+
+from aistorybooks.utils import PdfUtil
+
+
+@unittest.skip("Local user test only")
+class TestPdfUtil(unittest.TestCase):
+
+    @unittest.skip("TODO implement")
+    def test_process_pdf_file_new_file(self):
+        pass
+
+    def test_split_document_into_chunks(self):
+        data = [Document(text=f"Page {i}") for i in range(1, 11)]
+        chunk_size = 5
+        padding = 2
+        skip_first_n_pages = 0
+
+        chunks = PdfUtil.split_document_into_chunks(
+            data, chunk_size, padding, skip_first_n_pages
+        )
+
+        self.assertEqual(len(chunks), 2)
+        self.assertEqual(len(chunks[0]), 7)
+        self.assertEqual(len(chunks[1]), 7)
+
+        self.assertEqual(chunks[0][0].text, "Page 1")
+        self.assertEqual(chunks[0][-1].text, "Page 7")
+        self.assertEqual(chunks[1][0].text, "Page 4")
+        self.assertEqual(chunks[1][-1].text, "Page 10")
+
+    def test_split_document_into_chunks_empty_data(self):
+        data: List[Document] = []
+        chunk_size = 5
+        padding = 2
+        skip_first_n_pages = 0
+
+        chunks = PdfUtil.split_document_into_chunks(
+            data, chunk_size, padding, skip_first_n_pages
+        )
+
+        self.assertEqual(len(chunks), 0)
+
+    def test_document_info(self):
+        pdf_file = Path(__file__).parent.joinpath("resources/LoremIpsum.pdf")
+        document = PdfUtil.process_pdf_file(pdf_file=pdf_file, save_to_pickle=False)
+        print(document[0].extra_info)