Pylint & CVE fix

.env.example

@@ -1,10 +0,0 @@
-# Example .env file for SlideDeck AI
-# Add your API keys and configuration values here
-
-PEXEL_API_KEY=your-pexel-key-for-images
-
-TOGETHER_API_KEY=your-together-ai-key
-OPENROUTER_API_KEY=your-openrouter-api-key
-
-RUN_IN_OFFLINE_MODE=true-or-false
-DEFAULT_MODEL_INDEX=3

.gitattributes

@@ -33,5 +33,3 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
-*.pptx filter=lfs diff=lfs merge=lfs -text
-pptx_templates/Minimalist_sales_pitch.pptx filter=lfs diff=lfs merge=lfs -text

.github/workflows/codeql.yml

@@ -1,98 +0,0 @@
-# For most projects, this workflow file will not need changing; you simply need
-# to commit it to your repository.
-#
-# You may wish to alter this file to override the set of languages analyzed,
-# or to provide custom queries or build logic.
-#
-# ******** NOTE ********
-# We have attempted to detect the languages in your repository. Please check
-# the `language` matrix defined below to confirm you have the correct set of
-# supported CodeQL languages.
-#
-name: "CodeQL Advanced"
-
-on:
-  push:
-    branches: [ "main" ]
-  pull_request:
-    branches: [ "main" ]
-  schedule:
-    - cron: '35 12 * * 6'
-
-jobs:
-  analyze:
-    name: Analyze (${{ matrix.language }})
-    # Runner size impacts CodeQL analysis time. To learn more, please see:
-    #   - https://gh.io/recommended-hardware-resources-for-running-codeql
-    #   - https://gh.io/supported-runners-and-hardware-resources
-    #   - https://gh.io/using-larger-runners (GitHub.com only)
-    # Consider using larger runners or machines with greater resources for possible analysis time improvements.
-    runs-on: ubuntu-latest
-    permissions:
-      # required for all workflows
-      security-events: write
-
-      # required to fetch internal or private CodeQL packs
-      packages: read
-
-      # only required for workflows in private repositories
-      actions: read
-      contents: read
-
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-        - language: python
-          build-mode: none
-        # CodeQL supports the following values keywords for 'language': 'actions', 'c-cpp', 'csharp', 'go', 'java-kotlin', 'javascript-typescript', 'python', 'ruby', 'rust', 'swift'
-        # Use `c-cpp` to analyze code written in C, C++ or both
-        # Use 'java-kotlin' to analyze code written in Java, Kotlin or both
-        # Use 'javascript-typescript' to analyze code written in JavaScript, TypeScript or both
-        # To learn more about changing the languages that are analyzed or customizing the build mode for your analysis,
-        # see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/customizing-your-advanced-setup-for-code-scanning.
-        # If you are analyzing a compiled language, you can modify the 'build-mode' for that language to customize how
-        # your codebase is analyzed, see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/codeql-code-scanning-for-compiled-languages
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v4
-
-    # Add any setup steps before running the `github/codeql-action/init` action.
-    # This includes steps like installing compilers or runtimes (`actions/setup-node`
-    # or others). This is typically only required for manual builds.
-    # - name: Setup runtime (example)
-    #   uses: actions/setup-example@v1
-
-    # Initializes the CodeQL tools for scanning.
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v3
-      with:
-        languages: ${{ matrix.language }}
-        build-mode: ${{ matrix.build-mode }}
-        # If you wish to specify custom queries, you can do so here or in a config file.
-        # By default, queries listed here will override any specified in a config file.
-        # Prefix the list here with "+" to use these queries and those in the config file.
-
-        # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
-        # queries: security-extended,security-and-quality
-
-    # If the analyze step fails for one of the languages you are analyzing with
-    # "We were unable to automatically build your code", modify the matrix above
-    # to set the build mode to "manual" for that language. Then modify this step
-    # to build your code.
-    # ℹ️ Command-line programs to run using the OS shell.
-    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
-    - if: matrix.build-mode == 'manual'
-      shell: bash
-      run: |
-        echo 'If you are using a "manual" build mode for one or more of the' \
-          'languages you are analyzing, replace this with the commands to build' \
-          'your code, for example:'
-        echo '  make bootstrap'
-        echo '  make release'
-        exit 1
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v3
-      with:
-        category: "/language:${{matrix.language}}"

.gitignore

@@ -144,4 +144,3 @@ dmypy.json
 # Cython debug symbols
 cython_debug/
 
-.idea.DS_Store

.idea/.gitignore

@@ -0,0 +1,3 @@
+# Default ignored files
+/shelf/
+/workspace.xml

.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,14 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="PyPackageRequirementsInspection" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="ignoredPackages">
+        <value>
+          <list size="1">
+            <item index="0" class="java.lang.String" itemvalue="numpy" />
+          </list>
+        </value>
+      </option>
+    </inspection_tool>
+  </profile>
+</component>

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/misc.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Black">
+    <option name="sdkName" value="Python 3.10 (slide-deck-ai)" />
+  </component>
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.10 (slide-deck-ai)" project-jdk-type="Python SDK" />
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/slide-deck-ai.iml" filepath="$PROJECT_DIR$/.idea/slide-deck-ai.iml" />
+    </modules>
+  </component>
+</project>

.idea/slide-deck-ai.iml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/venv" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

.streamlit/config.toml

@@ -1,10 +0,0 @@
-[server]
-runOnSave = true
-headless = false
-maxUploadSize = 2
-
-[browser]
-gatherUsageStats = false
-
-[theme]
-base = "dark"

README.md

@@ -4,7 +4,7 @@ emoji: 🏢
 colorFrom: yellow
 colorTo: green
 sdk: streamlit
-sdk_version: 1.44.1
+sdk_version: 1.26.0
 app_file: app.py
 pinned: false
 license: mit
@@ -16,135 +16,36 @@ We spend a lot of time on creating the slides and organizing our thoughts for an
 With SlideDeck AI, co-create slide decks on any topic with Generative Artificial Intelligence.
 Describe your topic and let SlideDeck AI generate a PowerPoint slide deck for you—it's as simple as that!
 
-## Star History
-
-[![Star History Chart](https://api.star-history.com/svg?repos=barun-saha/slide-deck-ai&type=Date)](https://star-history.com/#barun-saha/slide-deck-ai&Date)
-
+SlideDeck AI is powered by [Mistral 7B Instruct](https://huggingface.co/mistralai/Mistral-7B-Instruct-v0.1).
+Originally, it was built using the Llama 2 API provided by Clarifai.
 
 # Process
 
 SlideDeck AI works in the following way:
 
-1. Given a topic description, it uses a Large Language Model (LLM) to generate the *initial* content of the slides. 
+1. Given a topic description, it uses Mistral 7B Instruct to generate the outline/contents of the slides. 
 The output is generated as structured JSON data based on a pre-defined schema.
-2. Next, it uses the keywords from the JSON output to search and download a few images with a certain probability.
-3. Subsequently, it uses the `python-pptx` library to generate the slides, 
+2. Subsequently, it uses the `python-pptx` library to generate the slides, 
 based on the JSON data from the previous step. 
-A user can choose from a set of pre-defined presentation templates.
-4. At this stage onward, a user can provide additional instructions to *refine* the content.
-For example, one can ask to add another slide or modify an existing slide.
-A history of instructions is maintained.
-5. Every time SlideDeck AI generates a PowerPoint presentation, a download button is provided.
-Clicking on the button will download the file.
-
-In addition, SlideDeck AI can also create a presentation based on PDF files.
-
-
-# Summary of the LLMs
-
-SlideDeck AI allows the use of different LLMs from several online providers—Azure OpenAI, Google, Cohere, Together AI, and OpenRouter. Most of these service providers offer generous free usage of relevant LLMs without requiring any billing information.  
-
-Based on several experiments, SlideDeck AI generally recommends the use of Mistral NeMo, Gemini Flash, and GPT-4o to generate the slide decks.
-
-The supported LLMs offer different styles of content generation. Use one of the following LLMs along with relevant API keys/access tokens, as appropriate, to create the content of the slide deck:
-
-| LLM                              | Provider (code) | Requires API key                                                                                                         | Characteristics          |
-|:---------------------------------| :------- |:-------------------------------------------------------------------------------------------------------------------------|:-------------------------|
-| Gemini 2.0 Flash                 | Google Gemini API (`gg`) | Mandatory; [get here](https://aistudio.google.com/apikey)                                                                | Faster, longer content   |
-| Gemini 2.0 Flash Lite            | Google Gemini API (`gg`) | Mandatory; [get here](https://aistudio.google.com/apikey)                                                                | Fastest, longer content  |
-| Gemini 2.5 Flash                 | Google Gemini API (`gg`) | Mandatory; [get here](https://aistudio.google.com/apikey)                                                                | Faster, longer content   |
-| Gemini 2.5 Flash Lite            | Google Gemini API (`gg`) | Mandatory; [get here](https://aistudio.google.com/apikey)                                                                | Fastest, longer content  |
-| GPT                              | Azure OpenAI (`az`)      | Mandatory; [get here](https://ai.azure.com/resource/playground)  NOTE: You need to have your subscription/billing set up | Faster, longer content   |
-| Command R+                       | Cohere (`co`) | Mandatory; [get here](https://dashboard.cohere.com/api-keys)                                                             | Shorter, simpler content |
-| Gemini-2.0-flash-001             | OpenRouter (`or`) | Mandatory; [get here](https://openrouter.ai/settings/keys)                                                                            | Faster, longer content   |
-| GPT-3.5 Turbo                    | OpenRouter (`or`) | Mandatory; [get here](https://openrouter.ai/settings/keys)                                                                            | Faster, longer content   |
-| DeepSeek V3-0324                 | Together AI (`to`) | Mandatory; [get here](https://api.together.ai/settings/api-keys)                                                         | Slower, medium-length    |
-| Llama 3.3 70B Instruct Turbo     | Together AI (`to`) | Mandatory; [get here](https://api.together.ai/settings/api-keys)                                                         | Slower, detailed         |
-| Llama 3.1 8B Instruct Turbo 128K | Together AI (`to`) | Mandatory; [get here](https://api.together.ai/settings/api-keys)                                                         | Faster, shorter          |
+Here, a user can choose from a set of three pre-defined presentation templates.
+3. In addition, it uses Metaphor to fetch Web pages related to the topic.
 
-**IMPORTANT**: SlideDeck AI does **NOT** store your API keys/tokens or transmit them elsewhere. If you provide your API key, it is only used to invoke the relevant LLM to generate contents. That's it! This is an 
-Open-Source project, so feel free to audit the code and convince yourself. 
-
-In addition, offline LLMs provided by Ollama can be used. Read below to know more. 
-
-
-# Icons
-
-SlideDeck AI uses a subset of icons from [bootstrap-icons-1.11.3](https://github.com/twbs/icons)
- (MIT license) in the slides. A few icons from [SVG Repo](https://www.svgrepo.com/)
-(CC0, MIT, and Apache licenses) are also used. 
+4. ~~Finally, it uses Stable Diffusion 2 to generate an image, based on the title and each slide heading.~~
 
 
 # Local Development
 
-SlideDeck AI uses LLMs via different providers. To run this project by yourself, you need to use an appropriate API key, for example, in a `.env` file.
-Alternatively, you can provide the access token in the app's user interface itself (UI).
-
-## Offline LLMs Using Ollama
-
-SlideDeck AI allows the use of offline LLMs to generate the contents of the slide decks. This is typically suitable for individuals or organizations who would like to use self-hosted LLMs for privacy concerns, for example.
-
-Offline LLMs are made available via Ollama. Therefore, a pre-requisite here is to have [Ollama installed](https://ollama.com/download) on the system and the desired [LLM](https://ollama.com/search) pulled locally. You should choose a model to use based on your hardware capacity. However, if you have no GPU, [gemma3:1b](https://ollama.com/library/gemma3:1b) can be a suitable model to run only on CPU.
-
-In addition, the `RUN_IN_OFFLINE_MODE` environment variable needs to be set to `True` to enable the offline mode. This, for example, can be done using a `.env` file or from the terminal. The typical steps to use SlideDeck AI in offline mode (in a `bash` shell) are as follows:
-
-```bash
-# Environment initialization, especially on Debian
-sudo apt update -y
-sudo apt install python-is-python3 -y
-sudo apt install git -y
-# Change the package name based on the Python version installed: python -V
-sudo apt install python3.11-venv -y
-
-# Install Git Large File Storage (LFS)
-sudo apt install git-lfs -y
-git lfs install
-
-ollama list  # View locally available LLMs
-export RUN_IN_OFFLINE_MODE=True  # Enable the offline mode to use Ollama
-git clone https://github.com/barun-saha/slide-deck-ai.git
-cd slide-deck-ai
-git lfs pull  # Pull the PPTX template files
-
-python -m venv venv  # Create a virtual environment
-source venv/bin/activate  # On a Linux system
-pip install -r requirements.txt
-
-streamlit run ./app.py  # Run the application
-```
-
-💡If you have cloned the repository locally but cannot open and view the PPTX templates, you may need to run `git lfs pull` to download the template files. Without this, although content generation will work, the slide deck cannot be created.
-
-The `.env` file should be created inside the `slide-deck-ai` directory. 
-
-The UI is similar to the online mode. However, rather than selecting an LLM from a list, one has to write the name of the Ollama model to be used in a textbox. There is no API key asked here.
-
-The online and offline modes are mutually exclusive. So, setting `RUN_IN_OFFLINE_MODE` to `False` will make SlideDeck AI use the online LLMs (i.e., the "original mode."). By default, `RUN_IN_OFFLINE_MODE` is set to `False`.
-
-Finally, the focus is on using offline LLMs, not going completely offline. So, Internet connectivity would still be required to fetch the images from Pexels. 
+SlideDeck AI uses [Mistral 7B Instruct](https://huggingface.co/mistralai/Mistral-7B-Instruct-v0.1) 
+via the Hugging Face Inference API.
+To run this project by yourself, you need to provide the `HUGGINGFACEHUB_API_TOKEN` and `METAPHOR_API_KEY` API keys,
+for example, in a `.env` file. Visit the respective websites to obtain the keys.
 
 
 # Live Demo
 
-- [SlideDeck AI](https://huggingface.co/spaces/barunsaha/slide-deck-ai) on Hugging Face Spaces
-- [Demo video](https://youtu.be/QvAKzNKtk9k) of the chat interface on YouTube
-- Demo video on [using Azure OpenAI](https://youtu.be/oPbH-z3q0Mw)
+[SlideDeck AI](https://huggingface.co/spaces/barunsaha/slide-deck-ai)
 
 
 # Award
 
-SlideDeck AI has won the 3rd Place in the [Llama 2 Hackathon with Clarifai](https://lablab.ai/event/llama-2-hackathon-with-clarifai) in 2023.
-
-
-# Contributors
-
-SlideDeck AI is glad to have the following community contributions:
-- [Srinivasan Ragothaman](https://github.com/rsrini7): added OpenRouter support and API keys mapping from the `.env` file.
-- [Aditya](https://github.com/AdiBak): added support for page range selection for PDF files.
-- [Sagar Bharatbhai Bharadia](https://github.com/sagarbharadia17): added support for Gemini 2.5 Flash Lite and Gemini 2.5 Flash LLMs.
-
-Thank you all for your contributions!
-
-[![All Contributors](https://img.shields.io/badge/all_contributors-3-orange.svg?style=flat-square)](#contributors)
-
-
+SlideDeck AI has won the 3rd Place in the [Llama 2 Hackathon with Clarifai](https://lablab.ai/event/llama-2-hackathon-with-clarifai).

app.py

@@ -1,657 +1,310 @@
-"""
-Streamlit app containing the UI and the application logic.
-"""
-import datetime
-import logging
-import os
 import pathlib
-import random
+import logging
 import tempfile
-from typing import List, Union
+from typing import List, Tuple
 
-import httpx
-import huggingface_hub
 import json5
-import ollama
-import requests
+import metaphor_python as metaphor
 import streamlit as st
-from dotenv import load_dotenv
-from langchain_community.chat_message_histories import StreamlitChatMessageHistory
-from langchain_core.messages import HumanMessage
-from langchain_core.prompts import ChatPromptTemplate
 
-import global_config as gcfg
-import helpers.file_manager as filem
+import llm_helper
+import pptx_helper
 from global_config import GlobalConfig
-from helpers import llm_helper, pptx_helper, text_helper
-
-load_dotenv()
 
-RUN_IN_OFFLINE_MODE = os.getenv('RUN_IN_OFFLINE_MODE', 'False').lower() == 'true'
 
+APP_TEXT = json5.loads(open(GlobalConfig.APP_STRINGS_FILE, 'r', encoding='utf-8').read())
+GB_CONVERTER = 2 ** 30
 
-@st.cache_data
-def _load_strings() -> dict:
-    """
-    Load various strings to be displayed in the app.
-    :return: The dictionary of strings.
-    """
 
-    with open(GlobalConfig.APP_STRINGS_FILE, 'r', encoding='utf-8') as in_file:
-        return json5.loads(in_file.read())
+logging.basicConfig(
+    level=GlobalConfig.LOG_LEVEL,
+    format='%(asctime)s - %(message)s',
+)
 
 
 @st.cache_data
-def _get_prompt_template(is_refinement: bool) -> str:
-    """
-    Return a prompt template.
-
-    :param is_refinement: Whether this is the initial or refinement prompt.
-    :return: The prompt template as f-string.
+def get_contents_wrapper(text: str) -> str:
     """
+    Fetch and cache the slide deck contents on a topic by calling an external API.
 
-    if is_refinement:
-        with open(GlobalConfig.REFINEMENT_PROMPT_TEMPLATE, 'r', encoding='utf-8') as in_file:
-            template = in_file.read()
-    else:
-        with open(GlobalConfig.INITIAL_PROMPT_TEMPLATE, 'r', encoding='utf-8') as in_file:
-            template = in_file.read()
-
-    return template
-
-
-def are_all_inputs_valid(
-        user_prompt: str,
-        provider: str,
-        selected_model: str,
-        user_key: str,
-        azure_deployment_url: str = '',
-        azure_endpoint_name: str = '',
-        azure_api_version: str = '',
-) -> bool:
-    """
-    Validate user input and LLM selection.
-
-    :param user_prompt: The prompt.
-    :param provider: The LLM provider.
-    :param selected_model: Name of the model.
-    :param user_key: User-provided API key.
-    :param azure_deployment_url: Azure OpenAI deployment URL.
-    :param azure_endpoint_name: Azure OpenAI model endpoint.
-    :param azure_api_version: Azure OpenAI API version.
-    :return: `True` if all inputs "look" OK; `False` otherwise.
+    :param text: The presentation topic
+    :return: The slide deck contents or outline in JSON format
     """
 
-    if not text_helper.is_valid_prompt(user_prompt):
-        handle_error(
-            'Not enough information provided!'
-            ' Please be a little more descriptive and type a few words'
-            ' with a few characters :)',
-            False
-        )
-        return False
-
-    if not provider or not selected_model:
-        handle_error('No valid LLM provider and/or model name found!', False)
-        return False
-
-    if not llm_helper.is_valid_llm_provider_model(
-            provider, selected_model, user_key,
-            azure_endpoint_name, azure_deployment_url, azure_api_version
-    ):
-        handle_error(
-            'The LLM settings do not look correct. Make sure that an API key/access token'
-            ' is provided if the selected LLM requires it. An API key should be 6-94 characters'
-            ' long, only containing alphanumeric characters, hyphens, and underscores.\n\n'
-            'If you are using Azure OpenAI, make sure that you have provided the additional and'
-            ' correct configurations.',
-            False
-        )
-        return False
-
-    return True
+    logging.info('LLM call because of cache miss...')
+    return llm_helper.generate_slides_content(text).strip()
 
 
-def handle_error(error_msg: str, should_log: bool):
+@st.cache_resource
+def get_metaphor_client_wrapper() -> metaphor.Metaphor:
     """
-    Display an error message in the app.
+    Create a Metaphor client for semantic Web search.
 
-    :param error_msg: The error message to be displayed.
-    :param should_log: If `True`, log the message.
+    :return: Metaphor instance
     """
 
-    if should_log:
-        logger.error(error_msg)
-
-    st.error(error_msg)
+    return metaphor.Metaphor(api_key=GlobalConfig.METAPHOR_API_KEY)
 
 
-def reset_api_key():
-    """
-    Clear API key input when a different LLM is selected from the dropdown list.
+@st.cache_data
+def get_web_search_results_wrapper(text: str) -> List[Tuple[str, str]]:
     """
+    Fetch and cache the Web search results on a given topic.
 
-    st.session_state.api_key_input = ''
-
-
-def reset_chat_history():
-    """
-    Clear the chat history and related session state variables.
+    :param text: The topic
+    :return: A list of (title, link) tuples
     """
-    # Clear session state variables using pop with None default
-    st.session_state.pop(CHAT_MESSAGES, None)
-    st.session_state.pop(IS_IT_REFINEMENT, None)
-    st.session_state.pop(ADDITIONAL_INFO, None)
-    st.session_state.pop(PDF_FILE_KEY, None)
-    
-    # Remove previously generated temp PPTX file
-    temp_pptx_path = st.session_state.pop(DOWNLOAD_FILE_KEY, None)
-    if temp_pptx_path:
-        pptx_path = pathlib.Path(temp_pptx_path)
-        if pptx_path.exists() and pptx_path.is_file():
-            pptx_path.unlink()
-
-
-APP_TEXT = _load_strings()
-
-# Session variables
-CHAT_MESSAGES = 'chat_messages'
-DOWNLOAD_FILE_KEY = 'download_file_name'
-IS_IT_REFINEMENT = 'is_it_refinement'
-ADDITIONAL_INFO = 'additional_info'
-PDF_FILE_KEY = 'pdf_file'
-
-
-logger = logging.getLogger(__name__)
-
-texts = list(GlobalConfig.PPTX_TEMPLATE_FILES.keys())
-captions = [GlobalConfig.PPTX_TEMPLATE_FILES[x]['caption'] for x in texts]
-
-
-with st.sidebar:
-    # New Chat button at the top of sidebar
-    col1, col2, col3 = st.columns([.17, 0.8, .1])
-    with col2:
-        if st.button('New Chat 💬', help='Start a new conversation', key='new_chat_button'):
-            reset_chat_history()  # Reset the chat history when the button is clicked
-    
-    # The PPT templates
-    pptx_template = st.sidebar.radio(
-        '1: Select a presentation template:',
-        texts,
-        captions=captions,
-        horizontal=True
-    )
-
-    if RUN_IN_OFFLINE_MODE:
-        llm_provider_to_use = st.text_input(
-            label='2: Enter Ollama model name to use (e.g., gemma3:1b):',
-            help=(
-                'Specify a correct, locally available LLM, found by running `ollama list`, for'
-                ' example, `gemma3:1b`, `mistral:v0.2`, and `mistral-nemo:latest`. Having an'
-                ' Ollama-compatible and supported GPU is strongly recommended.'
-            )
-        )
-        api_key_token: str = ''
-        azure_endpoint: str = ''
-        azure_deployment: str = ''
-        api_version: str = ''
-    else:
-        # The online LLMs
-        llm_provider_to_use = st.sidebar.selectbox(
-            label='2: Select a suitable LLM to use:\n\n(Gemini and Mistral-Nemo are recommended)',
-            options=[f'{k} ({v["description"]})' for k, v in GlobalConfig.VALID_MODELS.items()],
-            index=GlobalConfig.DEFAULT_MODEL_INDEX,
-            help=GlobalConfig.LLM_PROVIDER_HELP,
-            on_change=reset_api_key
-        ).split(' ')[0]
-
-        # --- Automatically fetch API key from .env if available ---
-        provider_match = GlobalConfig.PROVIDER_REGEX.match(llm_provider_to_use)
-        selected_provider = provider_match.group(1) if provider_match else llm_provider_to_use
-        env_key_name = GlobalConfig.PROVIDER_ENV_KEYS.get(selected_provider)
-        default_api_key = os.getenv(env_key_name, "") if env_key_name else ""
-
-        # Always sync session state to env value if needed (autofill on provider change)
-        if default_api_key and st.session_state.get('api_key_input', None) != default_api_key:
-            st.session_state['api_key_input'] = default_api_key
-
-        api_key_token = st.text_input(
-            label=(
-                '3: Paste your API key/access token:\n\n'
-                '*Mandatory* for all providers.'
-            ),
-            key='api_key_input',
-            type='password',
-            disabled=bool(default_api_key),
-        )
 
-        # Additional configs for Azure OpenAI
-        with st.expander('**Azure OpenAI-specific configurations**'):
-            azure_endpoint = st.text_input(
-                label=(
-                    '4: Azure endpoint URL, e.g., https://example.openai.azure.com/.\n\n'
-                    '*Mandatory* for Azure OpenAI (only).'
-                )
-            )
-            azure_deployment = st.text_input(
-                label=(
-                    '5: Deployment name on Azure OpenAI:\n\n'
-                    '*Mandatory* for Azure OpenAI (only).'
-                ),
-            )
-            api_version = st.text_input(
-                label=(
-                    '6: API version:\n\n'
-                    '*Mandatory* field. Change based on your deployment configurations.'
-                ),
-                value='2024-05-01-preview',
-            )
-
-    # Make slider with initial values
-    page_range_slider = st.slider(
-        'Specify a page range for the uploaded PDF file (if any):',
-        1, GlobalConfig.MAX_ALLOWED_PAGES,
-        [1, GlobalConfig.MAX_ALLOWED_PAGES]
+    results = []
+    search_results = get_metaphor_client_wrapper().search(
+        text,
+        use_autoprompt=True,
+        num_results=5
     )
-    st.session_state['page_range_slider'] = page_range_slider
+
+    for a_result in search_results.results:
+        results.append((a_result.title, a_result.url))
+
+    return results
+
+
+# def get_disk_used_percentage() -> float:
+#     """
+#     Compute the disk usage.
+#
+#     :return: Percentage of the disk space currently used
+#     """
+#
+#     total, used, free = shutil.disk_usage(__file__)
+#     total = total // GB_CONVERTER
+#     used = used // GB_CONVERTER
+#     free = free // GB_CONVERTER
+#     used_perc = 100.0 * used / total
+#
+#     logging.debug(f'Total: {total} GB\n'
+#                   f'Used: {used} GB\n'
+#                   f'Free: {free} GB')
+#
+#     logging.debug('\n'.join(os.listdir()))
+#
+#     return used_perc
 
 
 def build_ui():
     """
-    Display the input elements for content generation.
+    Display the input elements for content generation. Only covers the first step.
     """
 
+    # get_disk_used_percentage()
+
     st.title(APP_TEXT['app_name'])
     st.subheader(APP_TEXT['caption'])
     st.markdown(
-        '![Visitors](https://api.visitorbadge.io/api/visitors?path=https%3A%2F%2Fhuggingface.co%2Fspaces%2Fbarunsaha%2Fslide-deck-ai&countColor=%23263759)'  # noqa: E501
+        'Powered by'
+        ' [Mistral-7B-Instruct-v0.2](https://huggingface.co/mistralai/Mistral-7B-Instruct-v0.2).'
+    )
+    st.markdown(
+        '*If the JSON is generated or parsed incorrectly, try again later by making minor changes'
+        ' to the input text.*'
     )
 
-    today = datetime.date.today()
-    if today.month == 1 and 1 <= today.day <= 15:
-        st.success(
-            (
-                'Wishing you a happy and successful New Year!'
-                ' It is your appreciation that keeps SlideDeck AI going.'
-                f' May you make some great slide decks in {today.year} ✨'
-            ),
-            icon='🎆'
+    with st.form('my_form'):
+        # Topic input
+        try:
+            with open(GlobalConfig.PRELOAD_DATA_FILE, 'r', encoding='utf-8') as in_file:
+                preload_data = json5.loads(in_file.read())
+        except (FileExistsError, FileNotFoundError):
+            preload_data = {'topic': '', 'audience': ''}
+
+        topic = st.text_area(
+            APP_TEXT['input_labels'][0],
+            value=preload_data['topic']
         )
 
-    with st.expander('Usage Policies and Limitations'):
-        st.text(APP_TEXT['tos'] + '\n\n' + APP_TEXT['tos2'])
+        texts = list(GlobalConfig.PPTX_TEMPLATE_FILES.keys())
+        captions = [GlobalConfig.PPTX_TEMPLATE_FILES[x]['caption'] for x in texts]
 
-    set_up_chat_ui()
+        pptx_template = st.radio(
+            'Select a presentation template:',
+            texts,
+            captions=captions,
+            horizontal=True
+        )
 
+        st.divider()
+        submit = st.form_submit_button('Generate slide deck')
 
-def set_up_chat_ui():
-    """
-    Prepare the chat interface and related functionality.
-    """
-    # Set start and end page
-    st.session_state['start_page'] = st.session_state['page_range_slider'][0]
-    st.session_state['end_page'] = st.session_state['page_range_slider'][1]
+    if submit:
+        # st.write(f'Clicked {time.time()}')
+        st.session_state.submitted = True
 
-    with st.expander('Usage Instructions'):
-        st.markdown(GlobalConfig.CHAT_USAGE_INSTRUCTIONS)
+    # https://github.com/streamlit/streamlit/issues/3832#issuecomment-1138994421
+    if 'submitted' in st.session_state:
+        progress_text = 'Generating the slides...give it a moment'
+        progress_bar = st.progress(0, text=progress_text)
 
-    st.info(APP_TEXT['like_feedback'])
-    st.chat_message('ai').write(random.choice(APP_TEXT['ai_greetings']))
+        topic_txt = topic.strip()
+        generate_presentation(topic_txt, pptx_template, progress_bar)
 
-    history = StreamlitChatMessageHistory(key=CHAT_MESSAGES)
-    prompt_template = ChatPromptTemplate.from_template(
-        _get_prompt_template(
-            is_refinement=_is_it_refinement()
-        )
-    )
+    st.divider()
+    st.text(APP_TEXT['tos'])
+    st.text(APP_TEXT['tos2'])
 
-    # Since Streamlit app reloads at every interaction, display the chat history
-    # from the save session state
-    for msg in history.messages:
-        st.chat_message(msg.type).code(msg.content, language='json')
-
-    # Chat input at the bottom
-    prompt = st.chat_input(
-        placeholder=APP_TEXT['chat_placeholder'],
-        max_chars=GlobalConfig.LLM_MODEL_MAX_INPUT_LENGTH,
-        accept_file=True,
-        file_type=['pdf', ],
+    st.markdown(
+        '![Visitors]'
+        '(https://api.visitorbadge.io/api/visitors?path=https%3A%2F%2Fhuggingface.co%2Fspaces%2Fbarunsaha%2Fslide-deck-ai&countColor=%23263759)'
     )
 
-    if prompt:
-        prompt_text = prompt.text or ''
-        if prompt['files']:
-            # Store uploaded pdf in session state
-            uploaded_pdf = prompt['files'][0]
-            st.session_state[PDF_FILE_KEY] = uploaded_pdf
-            # Apparently, Streamlit stores uploaded files in memory and clears on browser close
-            # https://docs.streamlit.io/knowledge-base/using-streamlit/where-file-uploader-store-when-deleted
-
-        # Check if pdf file is uploaded
-        # (we can use the same file if the user doesn't upload a new one)
-        if PDF_FILE_KEY in st.session_state:
-            # Get validated page range
-            (
-                st.session_state['start_page'],
-                st.session_state['end_page']
-            ) = filem.validate_page_range(
-                st.session_state[PDF_FILE_KEY],
-                st.session_state['start_page'],
-                st.session_state['end_page']
-            )
-            # Show sidebar text for page selection and file name
-            with st.sidebar:
-                if st.session_state['end_page'] is None:  # If the PDF has only one page
-                    st.text(
-                        f'Extracting page {st.session_state["start_page"]} in'
-                        f' {st.session_state["pdf_file"].name}'
-                    )
-                else:
-                    st.text(
-                        f'Extracting pages {st.session_state["start_page"]} to'
-                        f' {st.session_state["end_page"]} in {st.session_state["pdf_file"].name}'
-                    )
-
-            # Get pdf contents
-            st.session_state[ADDITIONAL_INFO] = filem.get_pdf_contents(
-                st.session_state[PDF_FILE_KEY],
-                (st.session_state['start_page'], st.session_state['end_page'])
-            )
-        provider, llm_name = llm_helper.get_provider_model(
-            llm_provider_to_use,
-            use_ollama=RUN_IN_OFFLINE_MODE
-        )
 
-        user_key = api_key_token.strip()
-        az_deployment = azure_deployment.strip()
-        az_endpoint = azure_endpoint.strip()
-        api_ver = api_version.strip()
+def generate_presentation(topic: str, pptx_template: str, progress_bar):
+    """
+    Process the inputs to generate the slides.
 
-        if not are_all_inputs_valid(
-                prompt_text, provider, llm_name, user_key,
-                az_deployment, az_endpoint, api_ver
-        ):
-            return
+    :param topic: The presentation topic based on which contents are to be generated
+    :param pptx_template: The PowerPoint template name to be used
+    :param progress_bar: Progress bar from the page
+    :return:
+    """
 
-        logger.info(
-            'User input: %s | #characters: %d | LLM: %s',
-            prompt_text, len(prompt_text), llm_name
-        )
-        st.chat_message('user').write(prompt_text)
-
-        if _is_it_refinement():
-            user_messages = _get_user_messages()
-            user_messages.append(prompt_text)
-            list_of_msgs = [
-                f'{idx + 1}. {msg}' for idx, msg in enumerate(user_messages)
-            ]
-            formatted_template = prompt_template.format(
-                **{
-                    'instructions': '\n'.join(list_of_msgs),
-                    'previous_content': _get_last_response(),
-                    'additional_info': st.session_state.get(ADDITIONAL_INFO, ''),
-                }
-            )
-        else:
-            formatted_template = prompt_template.format(
-                **{
-                    'question': prompt_text,
-                    'additional_info': st.session_state.get(ADDITIONAL_INFO, ''),
-                }
-            )
-
-        progress_bar = st.progress(0, 'Preparing to call LLM...')
-        response = ''
+    topic_length = len(topic)
+    logging.debug('Input length:: topic: %s', topic_length)
 
-        try:
-            llm = llm_helper.get_langchain_llm(
-                provider=provider,
-                model=llm_name,
-                max_new_tokens=gcfg.get_max_output_tokens(llm_provider_to_use),
-                api_key=user_key,
-                azure_endpoint_url=az_endpoint,
-                azure_deployment_name=az_deployment,
-                azure_api_version=api_ver,
-            )
-
-            if not llm:
-                handle_error(
-                    'Failed to create an LLM instance! Make sure that you have selected the'
-                    ' correct model from the dropdown list and have provided correct API key'
-                    ' or access token.',
-                    False
-                )
-                return
+    if topic_length >= 10:
+        logging.debug('Topic: %s', topic)
+        target_length = min(topic_length, GlobalConfig.LLM_MODEL_MAX_INPUT_LENGTH)
 
-            for chunk in llm.stream(formatted_template):
-                if isinstance(chunk, str):
-                    response += chunk
-                else:
-                    content = getattr(chunk, 'content', None)
-                    if content is not None:
-                        response += content
-                    else:
-                        response += str(chunk)
-
-                # Update the progress bar with an approx progress percentage
-                progress_bar.progress(
-                    min(
-                        len(response) / gcfg.get_max_output_tokens(llm_provider_to_use),
-                        0.95
-                    ),
-                    text='Streaming content...this might take a while...'
-                )
-        except (httpx.ConnectError, requests.exceptions.ConnectionError):
-            handle_error(
-                'A connection error occurred while streaming content from the LLM endpoint.'
-                ' Unfortunately, the slide deck cannot be generated. Please try again later.'
-                ' Alternatively, try selecting a different LLM from the dropdown list. If you are'
-                ' using Ollama, make sure that Ollama is already running on your system.',
-                True
-            )
-            return
-        except huggingface_hub.errors.ValidationError as ve:
-            handle_error(
-                f'An error occurred while trying to generate the content: {ve}'
-                '\nPlease try again with a significantly shorter input text.',
-                True
-            )
-            return
-        except ollama.ResponseError:
-            handle_error(
-                f'The model `{llm_name}` is unavailable with Ollama on your system.'
-                f' Make sure that you have provided the correct LLM name or pull it using'
-                f' `ollama pull {llm_name}`. View LLMs available locally by running `ollama list`.',
-                True
-            )
-            return
-        except Exception as ex:
-            _msg = str(ex)
-            if 'payment required' in _msg.lower():
-                handle_error(
-                    'The available inference quota has exhausted.'
-                    ' Please use your own Hugging Face access token. Paste your token in'
-                    ' the input field on the sidebar to the left.'
-                    '\n\nDon\'t have a token? Get your free'
-                    ' [HF access token](https://huggingface.co/settings/tokens) now'
-                    ' and start creating your slide deck! For gated models, you may need to'
-                    ' visit the model\'s page and accept the terms or service.'
-                    '\n\nAlternatively, choose a different LLM and provider from the list.',
-                    should_log=True
+        try:
+            # Step 1: Generate the contents in JSON format using an LLM
+            json_str = process_slides_contents(topic[:target_length], progress_bar)
+            logging.debug('Truncated topic: %s', topic[:target_length])
+            logging.debug('Length of JSON: %d', len(json_str))
+
+            # Step 2: Generate the slide deck based on the template specified
+            if len(json_str) > 0:
+                st.info(
+                    'Tip: The generated content doesn\'t look so great?'
+                    ' Need alternatives? Just change your description text and try again.',
+                    icon="💡️"
                 )
             else:
-                handle_error(
-                    f'An unexpected error occurred while generating the content: {_msg}'
-                    '\n\nPlease try again later, possibly with different inputs.'
-                    ' Alternatively, try selecting a different LLM from the dropdown list.'
-                    ' If you are using Azure OpenAI, Cohere, Gemini, or Together AI models, make'
-                    ' sure that you have provided a correct API key.'
-                    ' Read **[how to get free LLM API keys](https://github.com/barun-saha/slide-deck-ai?tab=readme-ov-file#summary-of-the-llms)**.',
-                    True
+                st.error(
+                    'Unfortunately, JSON generation failed, so the next steps would lead'
+                    ' to nowhere. Try again or come back later.'
                 )
-            return
-
-        history.add_user_message(prompt_text)
-        history.add_ai_message(response)
+                return
 
-        # The content has been generated as JSON
-        # There maybe trailing ``` at the end of the response -- remove them
-        # To be careful: ``` may be part of the content as well when code is generated
-        response = text_helper.get_clean_json(response)
-        logger.info(
-            'Cleaned JSON length: %d', len(response)
-        )
+            all_headers = generate_slide_deck(json_str, pptx_template, progress_bar)
 
-        # Now create the PPT file
-        progress_bar.progress(
-            GlobalConfig.LLM_PROGRESS_MAX,
-            text='Finding photos online and generating the slide deck...'
-        )
-        progress_bar.progress(1.0, text='Done!')
-        st.chat_message('ai').code(response, language='json')
+            # Step 3: Bonus stuff: Web references and AI art
+            show_bonus_stuff(all_headers)
 
-        if path := generate_slide_deck(response):
-            _display_download_button(path)
+        except ValueError as ve:
+            st.error(f'Unfortunately, an error occurred: {ve}! '
+                     f'Please change the text, try again later, or report it, sharing your inputs.')
 
-        logger.info(
-            '#messages in history / 2: %d',
-            len(st.session_state[CHAT_MESSAGES]) / 2
-        )
+    else:
+        st.error('Not enough information provided! Please be little more descriptive :)')
 
 
-def generate_slide_deck(json_str: str) -> Union[pathlib.Path, None]:
+def process_slides_contents(text: str, progress_bar: st.progress) -> str:
     """
-    Create a slide deck and return the file path. In case there is any error creating the slide
-    deck, the path may be to an empty file.
+    Convert given text into structured data and display. Update the UI.
 
-    :param json_str: The content in *valid* JSON format.
-    :return: The path to the .pptx file or `None` in case of error.
+    :param text: The topic description for the presentation
+    :param progress_bar: Progress bar for this step
+    :return: The contents as a JSON-formatted string
     """
 
-    try:
-        parsed_data = json5.loads(json_str)
-    except ValueError:
-        handle_error(
-            'Encountered error while parsing JSON...will fix it and retry',
-            True
-        )
-        try:
-            parsed_data = json5.loads(text_helper.fix_malformed_json(json_str))
-        except ValueError:
-            handle_error(
-                'Encountered an error again while fixing JSON...'
-                'the slide deck cannot be created, unfortunately ☹'
-                '\nPlease try again later.',
-                True
-            )
-            return None
-    except RecursionError:
-        handle_error(
-            'Encountered a recursion error while parsing JSON...'
-            'the slide deck cannot be created, unfortunately ☹'
-            '\nPlease try again later.',
-            True
-        )
-        return None
-    except Exception:
-        handle_error(
-            'Encountered an error while parsing JSON...'
-            'the slide deck cannot be created, unfortunately ☹'
-            '\nPlease try again later.',
-            True
-        )
-        return None
-
-    if DOWNLOAD_FILE_KEY in st.session_state:
-        path = pathlib.Path(st.session_state[DOWNLOAD_FILE_KEY])
-    else:
-        temp = tempfile.NamedTemporaryFile(delete=False, suffix='.pptx')
-        path = pathlib.Path(temp.name)
-        st.session_state[DOWNLOAD_FILE_KEY] = str(path)
-
-        if temp:
-            temp.close()
+    json_str = ''
 
     try:
-        logger.debug('Creating PPTX file: %s...', st.session_state[DOWNLOAD_FILE_KEY])
-        pptx_helper.generate_powerpoint_presentation(
-            parsed_data,
-            slides_template=pptx_template,
-            output_file_path=path
-        )
+        logging.info('Calling LLM for content generation on the topic: %s', text)
+        json_str = get_contents_wrapper(text)
     except Exception as ex:
-        st.error(APP_TEXT['content_generation_error'])
-        logger.error('Caught a generic exception: %s', str(ex))
-
-    return path
-
-
-def _is_it_refinement() -> bool:
-    """
-    Whether it is the initial prompt or a refinement.
-
-    :return: True if it is the initial prompt; False otherwise.
-    """
-
-    if IS_IT_REFINEMENT in st.session_state:
-        return True
+        st.error(
+            f'An exception occurred while trying to convert to JSON. It could be because of heavy'
+            f' traffic or something else. Try doing it again or try again later.'
+            f'\nError message: {ex}'
+        )
 
-    if len(st.session_state[CHAT_MESSAGES]) >= 2:
-        # Prepare for the next call
-        st.session_state[IS_IT_REFINEMENT] = True
-        return True
+    progress_bar.progress(50, text='Contents generated')
 
-    return False
+    with st.expander('The generated contents (in JSON format)'):
+        st.code(json_str, language='json')
 
+    return json_str
 
-def _get_user_messages() -> List[str]:
-    """
-    Get a list of user messages submitted until now from the session state.
 
-    :return: The list of user messages.
+def generate_slide_deck(json_str: str, pptx_template: str, progress_bar) -> List:
     """
+    Create a slide deck.
 
-    return [
-        msg.content for msg in st.session_state[CHAT_MESSAGES] if isinstance(msg, HumanMessage)
-    ]
-
-
-def _get_last_response() -> str:
+    :param json_str: The contents in JSON format
+    :param pptx_template: The PPTX template name
+    :param progress_bar: Progress bar
+    :return: A list of all slide headers and the title
     """
-    Get the last response generated by AI.
 
-    :return: The response text.
-    """
+    progress_text = 'Creating the slide deck...give it a moment'
+    progress_bar.progress(75, text=progress_text)
 
-    return st.session_state[CHAT_MESSAGES][-1].content
+    # # Get a unique name for the file to save -- use the session ID
+    # ctx = st_sr.get_script_run_ctx()
+    # session_id = ctx.session_id
+    # timestamp = time.time()
+    # output_file_name = f'{session_id}_{timestamp}.pptx'
 
+    temp = tempfile.NamedTemporaryFile(delete=False, suffix='.pptx')
+    path = pathlib.Path(temp.name)
 
-def _display_messages_history(view_messages: st.expander):
-    """
-    Display the history of messages.
+    logging.info('Creating PPTX file...')
+    all_headers = pptx_helper.generate_powerpoint_presentation(
+        json_str,
+        as_yaml=False,
+        slides_template=pptx_template,
+        output_file_path=path
+    )
+    progress_bar.progress(100, text='Done!')
 
-    :param view_messages: The list of AI and Human messages.
-    """
+    with open(path, 'rb') as f:
+        st.download_button('Download PPTX file', f, file_name='Presentation.pptx')
 
-    with view_messages:
-        view_messages.json(st.session_state[CHAT_MESSAGES])
+    return all_headers
 
 
-def _display_download_button(file_path: pathlib.Path):
+def show_bonus_stuff(ppt_headers: List[str]):
     """
-    Display a download button to download a slide deck.
+    Show bonus stuff for the presentation.
 
-    :param file_path: The path of the .pptx file.
+    :param ppt_headers: A list of the slide headings.
     """
 
-    with open(file_path, 'rb') as download_file:
-        st.download_button(
-            'Download PPTX file ⬇️',
-            data=download_file,
-            file_name='Presentation.pptx',
-            key=datetime.datetime.now()
-        )
+    # Use the presentation title and the slide headers to find relevant info online
+    logging.info('Calling Metaphor search...')
+    ppt_text = ' '.join(ppt_headers)
+    search_results = get_web_search_results_wrapper(ppt_text)
+    md_text_items = []
+
+    for (title, link) in search_results:
+        md_text_items.append(f'[{title}]({link})')
+
+    with st.expander('Related Web references'):
+        st.markdown('\n\n'.join(md_text_items))
+
+    logging.info('Done!')
+
+    # # Avoid image generation. It costs time and an API call, so just limit to the text generation.
+    # with st.expander('AI-generated image on the presentation topic'):
+    #     logging.info('Calling SDXL for image generation...')
+    #     # img_empty.write('')
+    #     # img_text.write(APP_TEXT['image_info'])
+    #     image = get_ai_image_wrapper(ppt_text)
+    #
+    #     if len(image) > 0:
+    #         image = base64.b64decode(image)
+    #         st.image(image, caption=ppt_text)
+    #         st.info('Tip: Right-click on the image to save it.', icon="💡️")
+    #         logging.info('Image added')
 
 
 def main():

clarifai_grpc_helper.py

@@ -0,0 +1,71 @@
+from clarifai_grpc.channel.clarifai_channel import ClarifaiChannel
+from clarifai_grpc.grpc.api import resources_pb2, service_pb2, service_pb2_grpc
+from clarifai_grpc.grpc.api.status import status_code_pb2
+
+from global_config import GlobalConfig
+
+
+CHANNEL = ClarifaiChannel.get_grpc_channel()
+STUB = service_pb2_grpc.V2Stub(CHANNEL)
+
+METADATA = (
+    ('authorization', 'Key ' + GlobalConfig.CLARIFAI_PAT),
+)
+
+USER_DATA_OBJECT = resources_pb2.UserAppIDSet(
+    user_id=GlobalConfig.CLARIFAI_USER_ID,
+    app_id=GlobalConfig.CLARIFAI_APP_ID
+)
+
+RAW_TEXT = '''You are a helpful, intelligent chatbot. Create the slides for a presentation on the given topic. Include main headings for each slide, detailed bullet points for each slide. Add relevant content to each slide. Do not output any blank line.
+
+Topic:
+Talk about AI, covering what it is and how it works. Add its pros, cons, and future prospects. Also, cover its job prospects.
+'''
+
+
+def get_text_from_llm(prompt: str) -> str:
+    post_model_outputs_response = STUB.PostModelOutputs(
+        service_pb2.PostModelOutputsRequest(
+            user_app_id=USER_DATA_OBJECT,  # The userDataObject is created in the overview and is required when using a PAT
+            model_id=GlobalConfig.CLARIFAI_MODEL_ID,
+            # version_id=MODEL_VERSION_ID,  # This is optional. Defaults to the latest model version
+            inputs=[
+                resources_pb2.Input(
+                    data=resources_pb2.Data(
+                        text=resources_pb2.Text(
+                            raw=prompt
+                        )
+                    )
+                )
+            ]
+        ),
+        metadata=METADATA
+    )
+
+    if post_model_outputs_response.status.code != status_code_pb2.SUCCESS:
+        print(post_model_outputs_response.status)
+        raise Exception(f"Post model outputs failed, status: {post_model_outputs_response.status.description}")
+
+    # Since we have one input, one output will exist here
+    output = post_model_outputs_response.outputs[0]
+
+    # print("Completion:\n")
+    # print(output.data.text.raw)
+
+    return output.data.text.raw
+
+
+if __name__ == '__main__':
+    topic = ('Talk about AI, covering what it is and how it works.'
+             ' Add its pros, cons, and future prospects.'
+             ' Also, cover its job prospects.'
+             )
+    print(topic)
+
+    with open(GlobalConfig.SLIDES_TEMPLATE_FILE, 'r') as in_file:
+        prompt_txt = in_file.read()
+        prompt_txt = prompt_txt.replace('{topic}', topic)
+        response_txt = get_text_from_llm(prompt_txt)
+
+        print('Output:\n', response_txt)

examples/example_04.json

@@ -1,3 +0,0 @@
-{
-    "topic": "12 slides on a basic tutorial on Python along with examples"
-}

file_embeddings/embeddings.npy

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:64a1ba79b20c81ba7ed6604468736f74ae89813fe378191af1d8574c008b3ab5
-size 326784

file_embeddings/icons.npy

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:ce5ce4c86bb213915606921084b3516464154edcae12f4bc708d62c6bd7acebb
-size 51168

global_config.py

@@ -1,9 +1,4 @@
-"""
-A set of configurations used by the app.
-"""
-import logging
 import os
-import re
 
 from dataclasses import dataclass
 from dotenv import load_dotenv
@@ -14,206 +9,32 @@ load_dotenv()
 
 @dataclass(frozen=True)
 class GlobalConfig:
-    """
-    A data class holding the configurations.
-    """
+    HF_LLM_MODEL_NAME = 'mistralai/Mistral-7B-Instruct-v0.2'
+    LLM_MODEL_TEMPERATURE: float = 0.2
+    LLM_MODEL_MIN_OUTPUT_LENGTH: int = 50
+    LLM_MODEL_MAX_OUTPUT_LENGTH: int = 2000
+    LLM_MODEL_MAX_INPUT_LENGTH: int = 300
 
-    PROVIDER_COHERE = 'co'
-    PROVIDER_GOOGLE_GEMINI = 'gg'
-    PROVIDER_HUGGING_FACE = 'hf'
-    PROVIDER_AZURE_OPENAI = 'az'
-    PROVIDER_OLLAMA = 'ol'
-    PROVIDER_OPENROUTER = 'or'
-    PROVIDER_TOGETHER_AI = 'to'
-    VALID_PROVIDERS = {
-        PROVIDER_COHERE,
-        PROVIDER_GOOGLE_GEMINI,
-        # PROVIDER_HUGGING_FACE,
-        PROVIDER_OLLAMA,
-        PROVIDER_TOGETHER_AI,
-        PROVIDER_AZURE_OPENAI,
-        PROVIDER_OPENROUTER,
-    }
-    PROVIDER_ENV_KEYS = {
-        PROVIDER_COHERE: "COHERE_API_KEY",
-        PROVIDER_GOOGLE_GEMINI: "GOOGLE_API_KEY",
-        PROVIDER_HUGGING_FACE: "HUGGINGFACEHUB_API_TOKEN",
-        PROVIDER_AZURE_OPENAI: "AZURE_OPENAI_API_KEY",
-        PROVIDER_OPENROUTER: "OPENROUTER_API_KEY",
-        PROVIDER_TOGETHER_AI: "TOGETHER_API_KEY",
-    }
-    PROVIDER_REGEX = re.compile(r'\[(.*?)\]')
-    VALID_MODELS = {
-        '[az]azure/open-ai': {
-            'description': 'faster, detailed',
-            'max_new_tokens': 8192,
-            'paid': True,
-        },
-        '[co]command-r-08-2024': {
-            'description': 'simpler, slower',
-            'max_new_tokens': 4096,
-            'paid': True,
-        },
-        '[gg]gemini-2.0-flash': {
-            'description': 'fast, detailed',
-            'max_new_tokens': 8192,
-            'paid': True,
-        },
-        '[gg]gemini-2.0-flash-lite': {
-            'description': 'fastest, detailed',
-            'max_new_tokens': 8192,
-            'paid': True,
-        },
-        '[gg]gemini-2.5-flash': {
-            'description': 'fast, detailed',
-            'max_new_tokens': 8192,
-            'paid': True,
-        },
-        '[gg]gemini-2.5-flash-lite': {
-            'description': 'fastest, detailed',
-            'max_new_tokens': 8192,
-            'paid': True,
-        },
-        # '[hf]mistralai/Mistral-7B-Instruct-v0.2': {
-        #     'description': 'faster, shorter',
-        #     'max_new_tokens': 8192,
-        #     'paid': False,
-        # },
-        # '[hf]mistralai/Mistral-Nemo-Instruct-2407': {
-        #     'description': 'longer response',
-        #     'max_new_tokens': 8192,
-        #     'paid': False,
-        # },
-        '[or]google/gemini-2.0-flash-001': {
-            'description': 'Google Gemini-2.0-flash-001 (via OpenRouter)',
-            'max_new_tokens': 8192,
-            'paid': True,
-        },
-        '[or]openai/gpt-3.5-turbo': {
-            'description': 'OpenAI GPT-3.5 Turbo (via OpenRouter)',
-            'max_new_tokens': 4096,
-            'paid': True,
-        },
-        '[to]deepseek-ai/DeepSeek-V3': {
-            'description': 'slower, medium',
-            'max_new_tokens': 8192,
-            'paid': True,
-        },
-        '[to]meta-llama/Llama-3.3-70B-Instruct-Turbo': {
-            'description': 'slower, detailed',
-            'max_new_tokens': 4096,
-            'paid': True,
-        },
-        '[to]meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo-128K': {
-            'description': 'faster, shorter',
-            'max_new_tokens': 4096,
-            'paid': True,
-        }
-    }
-    LLM_PROVIDER_HELP = (
-        'LLM provider codes:\n\n'
-        '- **[az]**: Azure OpenAI\n'
-        '- **[co]**: Cohere\n'
-        '- **[gg]**: Google Gemini API\n'
-        # '- **[hf]**: Hugging Face Inference API\n'
-        '- **[or]**: OpenRouter\n\n'
-        '- **[to]**: Together AI\n\n'
-        '[Find out more](https://github.com/barun-saha/slide-deck-ai?tab=readme-ov-file#summary-of-the-llms)'
-    )
-    DEFAULT_MODEL_INDEX = int(os.environ.get('DEFAULT_MODEL_INDEX', '4'))
-    LLM_MODEL_TEMPERATURE = 0.2
-    MAX_PAGE_COUNT = 50
-    MAX_ALLOWED_PAGES = 150
-    LLM_MODEL_MAX_INPUT_LENGTH = 1000  # characters
+    HUGGINGFACEHUB_API_TOKEN = os.environ.get('HUGGINGFACEHUB_API_TOKEN', '')
+    METAPHOR_API_KEY = os.environ.get('METAPHOR_API_KEY', '')
 
     LOG_LEVEL = 'DEBUG'
-    COUNT_TOKENS = False
     APP_STRINGS_FILE = 'strings.json'
     PRELOAD_DATA_FILE = 'examples/example_02.json'
-    INITIAL_PROMPT_TEMPLATE = 'prompts/initial_template_v4_two_cols_img.txt'
-    REFINEMENT_PROMPT_TEMPLATE = 'prompts/refinement_template_v4_two_cols_img.txt'
-
-    LLM_PROGRESS_MAX = 90
-    ICONS_DIR = 'icons/png128/'
-    TINY_BERT_MODEL = 'gaunernst/bert-mini-uncased'
-    EMBEDDINGS_FILE_NAME = 'file_embeddings/embeddings.npy'
-    ICONS_FILE_NAME = 'file_embeddings/icons.npy'
+    SLIDES_TEMPLATE_FILE = 'langchain_templates/template_combined.txt'
+    JSON_TEMPLATE_FILE = 'langchain_templates/text_to_json_template_02.txt'
 
     PPTX_TEMPLATE_FILES = {
-        'Basic': {
+        'Blank': {
             'file': 'pptx_templates/Blank.pptx',
-            'caption': 'A good start (Uses [photos](https://unsplash.com/photos/AFZ-qBPEceA) by [cetteup](https://unsplash.com/@cetteup?utm_content=creditCopyText&utm_medium=referral&utm_source=unsplash) on [Unsplash](https://unsplash.com/photos/a-foggy-forest-filled-with-lots-of-trees-d3ci37Gcgxg?utm_content=creditCopyText&utm_medium=referral&utm_source=unsplash)) 🟧'
+            'caption': 'A good start'
         },
         'Ion Boardroom': {
             'file': 'pptx_templates/Ion_Boardroom.pptx',
-            'caption': 'Make some bold decisions 🟥'
-        },
-        'Minimalist Sales Pitch': {
-            'file': 'pptx_templates/Minimalist_sales_pitch.pptx',
-            'caption': 'In high contrast ⬛'
+            'caption': 'Make some bold decisions'
         },
         'Urban Monochrome': {
             'file': 'pptx_templates/Urban_monochrome.pptx',
-            'caption': 'Marvel in a monochrome dream ⬜'
-        },
+            'caption': 'Marvel in a monochrome dream'
+        }
     }
-
-    # This is a long text, so not incorporated as a string in `strings.json`
-    CHAT_USAGE_INSTRUCTIONS = (
-        'Briefly describe your topic of presentation in the textbox provided below. For example:\n'
-        '- Make a slide deck on AI.'
-        '\n\n'
-        'Subsequently, you can add follow-up instructions, e.g.:\n'
-        '- Can you add a slide on GPUs?'
-        '\n\n'
-        ' You can also ask it to refine any particular slide, e.g.:\n'
-        '- Make the slide with title \'Examples of AI\' a bit more descriptive.'
-        '\n\n'
-        'Finally, click on the download button at the bottom to download the slide deck.'
-        ' See this [demo video](https://youtu.be/QvAKzNKtk9k) for a brief walkthrough.\n\n'
-        'Remember, the conversational interface is meant to (and will) update yor *initial*/'
-        '*previous* slide deck. If you want to create a new slide deck on a different topic,'
-        ' start a new chat session by reloading this page.'
-        '\n\nSlideDeck AI can algo generate a presentation based on a PDF file. You can upload'
-        ' a PDF file using the chat widget. Only a single file and up to max 50 pages will be'
-        ' considered. For PDF-based slide deck generation, LLMs with large context windows, such'
-        ' as Gemini, GPT, and Mistral-Nemo, are recommended. Note: images from the PDF files will'
-        ' not be used.'
-        '\n\nAlso, note that the uploaded file might disappear from the page after click.'
-        ' You do not need to upload the same file again to continue'
-        ' the interaction and refining—the contents of the PDF file will be retained in the'
-        ' same interactive session.'
-        '\n\nCurrently, paid or *free-to-use* LLMs from six different providers are supported.'
-        ' A [summary of the supported LLMs]('
-        'https://github.com/barun-saha/slide-deck-ai/blob/main/README.md#summary-of-the-llms)'
-        ' is available for reference. SlideDeck AI does **NOT** store your API keys.'
-        '\n\nSlideDeck AI does not have access to the Web, apart for searching for images relevant'
-        ' to the slides. Photos are added probabilistically; transparency needs to be changed'
-        ' manually, if required.\n\n'
-        '[SlideDeck AI](https://github.com/barun-saha/slide-deck-ai) is an Open-Source project,'
-        ' released under the'
-        ' [MIT license](https://github.com/barun-saha/slide-deck-ai?tab=MIT-1-ov-file#readme).'
-        '\n\n---\n\n'
-        '© Copyright 2023-2025 Barun Saha.\n\n'
-    )
-
-
-logging.basicConfig(
-    level=GlobalConfig.LOG_LEVEL,
-    format='%(asctime)s - %(levelname)s - %(name)s - %(message)s',
-    datefmt='%Y-%m-%d %H:%M:%S'
-)
-
-
-def get_max_output_tokens(llm_name: str) -> int:
-    """
-    Get the max output tokens value configured for an LLM. Return a default value if not configured.
-
-    :param llm_name: The name of the LLM.
-    :return: Max output tokens or a default count.
-    """
-
-    try:
-        return GlobalConfig.VALID_MODELS[llm_name]['max_new_tokens']
-    except KeyError:
-        return 2048

helpers/file_manager.py

@@ -1,73 +0,0 @@
-"""
-File manager helper to work with uploaded files.
-"""
-import logging
-import os
-import sys
-
-import streamlit as st
-from pypdf import PdfReader
-
-sys.path.append('..')
-sys.path.append('../..')
-
-from global_config import GlobalConfig
-
-
-logger = logging.getLogger(__name__)
-
-
-def get_pdf_contents(
-        pdf_file: st.runtime.uploaded_file_manager.UploadedFile,
-        page_range: tuple[int, int]) -> str:
-    """
-    Extract the text contents from a PDF file.
-
-    :param pdf_file: The uploaded PDF file.
-    :param page_range: The range of pages to extract contents from.
-    :return: The contents.
-    """
-
-    reader = PdfReader(pdf_file)
-
-    start, end = page_range  # Set start and end per the range (user-specified values)
-
-    text = ''
-
-    if end is None:
-        # If end is None (where PDF has only 1 page or start = end), extract start
-        end = start
-
-    # Get the text from the specified page range
-    for page_num in range(start - 1, end):
-        text += reader.pages[page_num].extract_text()
-
-    
-    return text
-
-def validate_page_range(pdf_file: st.runtime.uploaded_file_manager.UploadedFile,
-                        start:int, end:int) -> tuple[int, int]:
-    """
-    Validate the page range.
-
-    :param pdf_file: The uploaded PDF file.
-    :param start: The start page 
-    :param end: The end page
-    :return: The validated page range tuple
-    """
-    n_pages = len(PdfReader(pdf_file).pages)
-
-    # Set start to max of 1 or specified start (whichever's higher)
-    start = max(1, start)
-
-    # Set end to min of pdf length or specified end (whichever's lower)
-    end = min(n_pages, end)
-
-    if start > end:  # If the start is higher than the end, make it 1
-        start = 1
-
-    if start == end:
-        # If start = end (including when PDF is 1 page long), set end to None
-        return start, None
-
-    return start, end

helpers/icons_embeddings.py

@@ -1,166 +0,0 @@
-"""
-Generate and save the embeddings of a pre-defined list of icons.
-Compare them with keywords embeddings to find most relevant icons.
-"""
-import os
-import pathlib
-import sys
-from typing import List, Tuple
-
-import numpy as np
-from sklearn.metrics.pairwise import cosine_similarity
-from transformers import BertTokenizer, BertModel
-
-sys.path.append('..')
-sys.path.append('../..')
-
-from global_config import GlobalConfig
-
-
-tokenizer = BertTokenizer.from_pretrained(GlobalConfig.TINY_BERT_MODEL)
-model = BertModel.from_pretrained(GlobalConfig.TINY_BERT_MODEL)
-
-
-def get_icons_list() -> List[str]:
-    """
-    Get a list of available icons.
-
-    :return: The icons file names.
-    """
-
-    items = pathlib.Path('../' + GlobalConfig.ICONS_DIR).glob('*.png')
-    items = [
-        os.path.basename(str(item)).removesuffix('.png') for item in items
-    ]
-
-    return items
-
-
-def get_embeddings(texts) -> np.ndarray:
-    """
-    Generate embeddings for a list of texts using a pre-trained language model.
-
-    :param texts: A string or a list of strings to be converted into embeddings.
-    :type texts: Union[str, List[str]]
-    :return: A NumPy array containing the embeddings for the input texts.
-    :rtype: numpy.ndarray
-
-    :raises ValueError: If the input is not a string or a list of strings, or if any element
-    in the list is not a string.
-
-    Example usage:
-    >>> keyword = 'neural network'
-    >>> file_names = ['neural_network_icon.png', 'data_analysis_icon.png', 'machine_learning.png']
-    >>> keyword_embeddings = get_embeddings(keyword)
-    >>> file_name_embeddings = get_embeddings(file_names)
-    """
-
-    inputs = tokenizer(texts, return_tensors='pt', padding=True, max_length=128, truncation=True)
-    outputs = model(**inputs)
-
-    return outputs.last_hidden_state.mean(dim=1).detach().numpy()
-
-
-def save_icons_embeddings():
-    """
-    Generate and save the embeddings for the icon file names.
-    """
-
-    file_names = get_icons_list()
-    print(f'{len(file_names)} icon files available...')
-    file_name_embeddings = get_embeddings(file_names)
-    print(f'file_name_embeddings.shape: {file_name_embeddings.shape}')
-
-    # Save embeddings to a file
-    np.save(GlobalConfig.EMBEDDINGS_FILE_NAME, file_name_embeddings)
-    np.save(GlobalConfig.ICONS_FILE_NAME, file_names)  # Save file names for reference
-
-
-def load_saved_embeddings() -> Tuple[np.ndarray, np.ndarray]:
-    """
-    Load precomputed embeddings and icons file names.
-
-    :return: The embeddings and the icon file names.
-    """
-
-    file_name_embeddings = np.load(GlobalConfig.EMBEDDINGS_FILE_NAME)
-    file_names = np.load(GlobalConfig.ICONS_FILE_NAME)
-
-    return file_name_embeddings, file_names
-
-
-def find_icons(keywords: List[str]) -> List[str]:
-    """
-    Find relevant icon file names for a list of keywords.
-
-    :param keywords: The list of one or more keywords.
-    :return: A list of the file names relevant for each keyword.
-    """
-
-    keyword_embeddings = get_embeddings(keywords)
-    file_name_embeddings, file_names = load_saved_embeddings()
-
-    # Compute similarity
-    similarities = cosine_similarity(keyword_embeddings, file_name_embeddings)
-    icon_files = file_names[np.argmax(similarities, axis=-1)]
-
-    return icon_files
-
-
-def main():
-    """
-    Example usage.
-    """
-
-    # Run this again if icons are to be added/removed
-    save_icons_embeddings()
-
-    keywords = [
-        'deep learning',
-        '',
-        'recycling',
-        'handshake',
-        'Ferry',
-        'rain drop',
-        'speech bubble',
-        'mental resilience',
-        'turmeric',
-        'Art',
-        'price tag',
-        'Oxygen',
-        'oxygen',
-        'Social Connection',
-        'Accomplishment',
-        'Python',
-        'XML',
-        'Handshake',
-    ]
-    icon_files = find_icons(keywords)
-    print(
-        f'The relevant icon files are:\n'
-        f'{list(zip(keywords, icon_files))}'
-    )
-
-    # BERT tiny:
-    # [('deep learning', 'deep-learning'), ('', '123'), ('recycling', 'refinery'),
-    #  ('handshake', 'dash-circle'), ('Ferry', 'cart'), ('rain drop', 'bucket'),
-    #  ('speech bubble', 'globe'), ('mental resilience', 'exclamation-triangle'),
-    #  ('turmeric', 'kebab'), ('Art', 'display'), ('price tag', 'bug-fill'),
-    #  ('Oxygen', 'radioactive')]
-
-    # BERT mini
-    # [('deep learning', 'deep-learning'), ('', 'compass'), ('recycling', 'tools'),
-    #  ('handshake', 'bandaid'), ('Ferry', 'cart'), ('rain drop', 'trash'),
-    #  ('speech bubble', 'image'), ('mental resilience', 'recycle'), ('turmeric', 'linkedin'),
-    #  ('Art', 'book'), ('price tag', 'card-image'), ('Oxygen', 'radioactive')]
-
-    # BERT small
-    # [('deep learning', 'deep-learning'), ('', 'gem'), ('recycling', 'tools'),
-    #  ('handshake', 'handbag'), ('Ferry', 'truck'), ('rain drop', 'bucket'),
-    #  ('speech bubble', 'strategy'), ('mental resilience', 'deep-learning'),
-    #  ('turmeric', 'flower'),
-    #  ('Art', 'book'), ('price tag', 'hotdog'), ('Oxygen', 'radioactive')]
-
-
-if __name__ == '__main__':
-    main()

helpers/image_search.py

@@ -1,148 +0,0 @@
-"""
-Search photos using Pexels API.
-"""
-import logging
-import os
-import random
-from io import BytesIO
-from typing import Union, Tuple, Literal
-from urllib.parse import urlparse, parse_qs
-
-import requests
-from dotenv import load_dotenv
-
-
-load_dotenv()
-
-
-REQUEST_TIMEOUT = 12
-MAX_PHOTOS = 3
-
-
-# Only show errors
-logging.getLogger('urllib3').setLevel(logging.ERROR)
-# Disable all child loggers of urllib3, e.g. urllib3.connectionpool
-# logging.getLogger('urllib3').propagate = True
-
-
-
-def search_pexels(
-        query: str,
-        size: Literal['small', 'medium', 'large'] = 'medium',
-        per_page: int = MAX_PHOTOS
-) -> dict:
-    """
-    Searches for images on Pexels using the provided query.
-
-    This function sends a GET request to the Pexels API with the specified search query
-    and authorization header containing the API key. It returns the JSON response from the API.
-
-    [2024-08-31] Note:
-    `curl` succeeds but API call via Python `requests` fail. Apparently, this could be due to
-    Cloudflare (or others) blocking the requests, perhaps identifying as Web-scraping. So,
-    changing the user-agent to Firefox.
-    https://stackoverflow.com/a/74674276/147021
-    https://stackoverflow.com/a/51268523/147021
-    https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/User-Agent/Firefox#linux
-
-    :param query: The search query for finding images.
-    :param size: The size of the images: small, medium, or large.
-    :param per_page: No. of results to be displayed per page.
-    :return: The JSON response from the Pexels API containing search results.
-    :raises requests.exceptions.RequestException: If the request to the Pexels API fails.
-    """
-
-    url = 'https://api.pexels.com/v1/search'
-    headers = {
-        'Authorization': os.getenv('PEXEL_API_KEY'),
-        'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:10.0) Gecko/20100101 Firefox/10.0',
-    }
-    params = {
-        'query': query,
-        'size': size,
-        'page': 1,
-        'per_page': per_page
-    }
-    response = requests.get(url, headers=headers, params=params, timeout=REQUEST_TIMEOUT)
-    response.raise_for_status()  # Ensure the request was successful
-
-    return response.json()
-
-
-def get_photo_url_from_api_response(
-        json_response: dict
-) -> Tuple[Union[str, None], Union[str, None]]:
-    """
-    Return a randomly chosen photo from a Pexels search API response. In addition, also return
-    the original URL of the page on Pexels.
-
-    :param json_response: The JSON response.
-    :return: The selected photo URL and page URL or `None`.
-    """
-
-    page_url = None
-    photo_url = None
-
-    if 'photos' in json_response:
-        photos = json_response['photos']
-
-        if photos:
-            photo_idx = random.choice(list(range(MAX_PHOTOS)))
-            photo = photos[photo_idx]
-
-            if 'url' in photo:
-                page_url = photo['url']
-
-            if 'src' in photo:
-                if 'large' in photo['src']:
-                    photo_url = photo['src']['large']
-                elif 'original' in photo['src']:
-                    photo_url = photo['src']['original']
-
-    return photo_url, page_url
-
-
-def get_image_from_url(url: str) -> BytesIO:
-    """
-    Fetches an image from the specified URL and returns it as a BytesIO object.
-
-    This function sends a GET request to the provided URL, retrieves the image data,
-    and wraps it in a BytesIO object, which can be used like a file.
-
-    :param url: The URL of the image to be fetched.
-    :return: A BytesIO object containing the image data.
-    :raises requests.exceptions.RequestException: If the request to the URL fails.
-    """
-
-    headers = {
-        'Authorization': os.getenv('PEXEL_API_KEY'),
-        'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:10.0) Gecko/20100101 Firefox/10.0',
-    }
-    response = requests.get(url, headers=headers, stream=True, timeout=REQUEST_TIMEOUT)
-    response.raise_for_status()
-    image_data = BytesIO(response.content)
-
-    return image_data
-
-
-def extract_dimensions(url: str) -> Tuple[int, int]:
-    """
-    Extracts the height and width from the URL parameters.
-
-    :param url: The URL containing the image dimensions.
-    :return: A tuple containing the width and height as integers.
-    """
-    parsed_url = urlparse(url)
-    query_params = parse_qs(parsed_url.query)
-    width = int(query_params.get('w', [0])[0])
-    height = int(query_params.get('h', [0])[0])
-
-    return width, height
-
-
-if __name__ == '__main__':
-    print(
-        search_pexels(
-            query='people'
-        )
-    )

helpers/llm_helper.py

@@ -1,259 +0,0 @@
-"""
-Helper functions to access LLMs.
-"""
-import logging
-import re
-import sys
-import urllib3
-from typing import Tuple, Union
-
-import requests
-from requests.adapters import HTTPAdapter
-from urllib3.util import Retry
-from langchain_core.language_models import BaseLLM, BaseChatModel
-import os
-
-sys.path.append('..')
-
-from global_config import GlobalConfig
-
-
-LLM_PROVIDER_MODEL_REGEX = re.compile(r'\[(.*?)\](.*)')
-OLLAMA_MODEL_REGEX = re.compile(r'[a-zA-Z0-9._:-]+$')
-# 94 characters long, only containing alphanumeric characters, hyphens, and underscores
-API_KEY_REGEX = re.compile(r'^[a-zA-Z0-9_-]{6,94}$')
-REQUEST_TIMEOUT = 35
-OPENROUTER_BASE_URL = 'https://openrouter.ai/api/v1'
-
-
-logger = logging.getLogger(__name__)
-logging.getLogger('httpx').setLevel(logging.WARNING)
-logging.getLogger('httpcore').setLevel(logging.WARNING)
-logging.getLogger('openai').setLevel(logging.ERROR)
-
-retries = Retry(
-    total=5,
-    backoff_factor=0.25,
-    backoff_jitter=0.3,
-    status_forcelist=[502, 503, 504],
-    allowed_methods={'POST'},
-)
-adapter = HTTPAdapter(max_retries=retries)
-http_session = requests.Session()
-http_session.mount('https://', adapter)
-http_session.mount('http://', adapter)
-
-
-def get_provider_model(provider_model: str, use_ollama: bool) -> Tuple[str, str]:
-    """
-    Parse and get LLM provider and model name from strings like `[provider]model/name-version`.
-
-    :param provider_model: The provider, model name string from `GlobalConfig`.
-    :param use_ollama: Whether Ollama is used (i.e., running in offline mode).
-    :return: The provider and the model name; empty strings in case no matching pattern found.
-    """
-
-    provider_model = provider_model.strip()
-
-    if use_ollama:
-        match = OLLAMA_MODEL_REGEX.match(provider_model)
-        if match:
-            return GlobalConfig.PROVIDER_OLLAMA, match.group(0)
-    else:
-        match = LLM_PROVIDER_MODEL_REGEX.match(provider_model)
-
-        if match:
-            inside_brackets = match.group(1)
-            outside_brackets = match.group(2)
-            return inside_brackets, outside_brackets
-
-    return '', ''
-
-
-def is_valid_llm_provider_model(
-        provider: str,
-        model: str,
-        api_key: str,
-        azure_endpoint_url: str = '',
-        azure_deployment_name: str = '',
-        azure_api_version: str = '',
-) -> bool:
-    """
-    Verify whether LLM settings are proper.
-    This function does not verify whether `api_key` is correct. It only confirms that the key has
-    at least five characters. Key verification is done when the LLM is created.
-
-    :param provider: Name of the LLM provider.
-    :param model: Name of the model.
-    :param api_key: The API key or access token.
-    :param azure_endpoint_url: Azure OpenAI endpoint URL.
-    :param azure_deployment_name: Azure OpenAI deployment name.
-    :param azure_api_version: Azure OpenAI API version.
-    :return: `True` if the settings "look" OK; `False` otherwise.
-    """
-
-    if not provider or not model or provider not in GlobalConfig.VALID_PROVIDERS:
-        return False
-
-    if provider != GlobalConfig.PROVIDER_OLLAMA:
-        # No API key is required for offline Ollama models
-        if not api_key:
-            return False
-
-        if api_key and API_KEY_REGEX.match(api_key) is None:
-            return False
-
-    if provider == GlobalConfig.PROVIDER_AZURE_OPENAI:
-        valid_url = urllib3.util.parse_url(azure_endpoint_url)
-        all_status = all(
-            [azure_api_version, azure_deployment_name, str(valid_url)]
-        )
-        return all_status
-
-    return True
-
-
-def get_langchain_llm(
-        provider: str,
-        model: str,
-        max_new_tokens: int,
-        api_key: str = '',
-        azure_endpoint_url: str = '',
-        azure_deployment_name: str = '',
-        azure_api_version: str = '',
-) -> Union[BaseLLM, BaseChatModel, None]:
-    """
-    Get an LLM based on the provider and model specified.
-
-    :param provider: The LLM provider. Valid values are `hf` for Hugging Face.
-    :param model: The name of the LLM.
-    :param max_new_tokens: The maximum number of tokens to generate.
-    :param api_key: API key or access token to use.
-    :param azure_endpoint_url: Azure OpenAI endpoint URL.
-    :param azure_deployment_name: Azure OpenAI deployment name.
-    :param azure_api_version: Azure OpenAI API version.
-    :return: An instance of the LLM or Chat model; `None` in case of any error.
-    """
-
-    if provider == GlobalConfig.PROVIDER_HUGGING_FACE:
-        from langchain_community.llms.huggingface_endpoint import HuggingFaceEndpoint
-
-        logger.debug('Getting LLM via HF endpoint: %s', model)
-        return HuggingFaceEndpoint(
-            repo_id=model,
-            max_new_tokens=max_new_tokens,
-            top_k=40,
-            top_p=0.95,
-            temperature=GlobalConfig.LLM_MODEL_TEMPERATURE,
-            repetition_penalty=1.03,
-            streaming=True,
-            huggingfacehub_api_token=api_key,
-            return_full_text=False,
-            stop_sequences=['</s>'],
-        )
-
-    if provider == GlobalConfig.PROVIDER_GOOGLE_GEMINI:
-        from google.generativeai.types.safety_types import HarmBlockThreshold, HarmCategory
-        from langchain_google_genai import GoogleGenerativeAI
-
-        logger.debug('Getting LLM via Google Gemini: %s', model)
-        return GoogleGenerativeAI(
-            model=model,
-            temperature=GlobalConfig.LLM_MODEL_TEMPERATURE,
-            # max_tokens=max_new_tokens,
-            timeout=None,
-            max_retries=2,
-            google_api_key=api_key,
-            safety_settings={
-                HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT:
-                    HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
-                HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
-                HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
-                HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT:
-                    HarmBlockThreshold.BLOCK_LOW_AND_ABOVE
-            }
-        )
-
-    if provider == GlobalConfig.PROVIDER_AZURE_OPENAI:
-        from langchain_openai import AzureChatOpenAI
-
-        logger.debug('Getting LLM via Azure OpenAI: %s', model)
-
-        # The `model` parameter is not used here; `azure_deployment` points to the desired name
-        return AzureChatOpenAI(
-            azure_deployment=azure_deployment_name,
-            api_version=azure_api_version,
-            azure_endpoint=azure_endpoint_url,
-            temperature=GlobalConfig.LLM_MODEL_TEMPERATURE,
-            # max_tokens=max_new_tokens,
-            timeout=None,
-            max_retries=1,
-            api_key=api_key,
-        )
-
-    if provider == GlobalConfig.PROVIDER_OPENROUTER:
-        # Use langchain-openai's ChatOpenAI for OpenRouter
-        from langchain_openai import ChatOpenAI
-        
-        logger.debug('Getting LLM via OpenRouter: %s', model)
-        openrouter_api_key = api_key
-       
-        return ChatOpenAI(
-            base_url=OPENROUTER_BASE_URL,
-            openai_api_key=openrouter_api_key,
-            model_name=model,
-            temperature=GlobalConfig.LLM_MODEL_TEMPERATURE,
-            max_tokens=max_new_tokens,
-            streaming=True,
-        )
-
-    if provider == GlobalConfig.PROVIDER_COHERE:
-        from langchain_cohere.llms import Cohere
-
-        logger.debug('Getting LLM via Cohere: %s', model)
-        return Cohere(
-            temperature=GlobalConfig.LLM_MODEL_TEMPERATURE,
-            max_tokens=max_new_tokens,
-            timeout_seconds=None,
-            max_retries=2,
-            cohere_api_key=api_key,
-            streaming=True,
-        )
-
-    if provider == GlobalConfig.PROVIDER_TOGETHER_AI:
-        from langchain_together import Together
-
-        logger.debug('Getting LLM via Together AI: %s', model)
-        return Together(
-            model=model,
-            temperature=GlobalConfig.LLM_MODEL_TEMPERATURE,
-            together_api_key=api_key,
-            max_tokens=max_new_tokens,
-            top_k=40,
-            top_p=0.90,
-        )
-
-    if provider == GlobalConfig.PROVIDER_OLLAMA:
-        from langchain_ollama.llms import OllamaLLM
-
-        logger.debug('Getting LLM via Ollama: %s', model)
-        return OllamaLLM(
-            model=model,
-            temperature=GlobalConfig.LLM_MODEL_TEMPERATURE,
-            num_predict=max_new_tokens,
-            format='json',
-            streaming=True,
-        )
-
-    return None
-
-
-if __name__ == '__main__':
-    inputs = [
-        '[co]Cohere',
-        '[hf]mistralai/Mistral-7B-Instruct-v0.2',
-        '[gg]gemini-1.5-flash-002'
-    ]
-
-    for text in inputs:
-        print(get_provider_model(text, use_ollama=False))

helpers/pptx_helper.py

@@ -1,1129 +0,0 @@
-"""
-A set of functions to create a PowerPoint slide deck.
-"""
-import logging
-import os
-import pathlib
-import random
-import re
-import sys
-import tempfile
-from typing import List, Tuple, Optional
-
-import json5
-import pptx
-from dotenv import load_dotenv
-from pptx.enum.shapes import MSO_AUTO_SHAPE_TYPE
-from pptx.shapes.placeholder import PicturePlaceholder, SlidePlaceholder
-
-sys.path.append('..')
-sys.path.append('../..')
-
-import helpers.icons_embeddings as ice
-import helpers.image_search as ims
-from global_config import GlobalConfig
-
-
-load_dotenv()
-
-
-# English Metric Unit (used by PowerPoint) to inches
-EMU_TO_INCH_SCALING_FACTOR = 1.0 / 914400
-INCHES_3 = pptx.util.Inches(3)
-INCHES_2 = pptx.util.Inches(2)
-INCHES_1_5 = pptx.util.Inches(1.5)
-INCHES_1 = pptx.util.Inches(1)
-INCHES_0_8 = pptx.util.Inches(0.8)
-INCHES_0_9 = pptx.util.Inches(0.9)
-INCHES_0_5 = pptx.util.Inches(0.5)
-INCHES_0_4 = pptx.util.Inches(0.4)
-INCHES_0_3 = pptx.util.Inches(0.3)
-INCHES_0_2 = pptx.util.Inches(0.2)
-
-STEP_BY_STEP_PROCESS_MARKER = '>> '
-ICON_BEGINNING_MARKER = '[['
-ICON_END_MARKER = ']]'
-
-ICON_SIZE = INCHES_0_8
-ICON_BG_SIZE = INCHES_1
-
-IMAGE_DISPLAY_PROBABILITY = 1 / 3.0
-FOREGROUND_IMAGE_PROBABILITY = 0.8
-
-SLIDE_NUMBER_REGEX = re.compile(r"^slide[ ]+\d+:", re.IGNORECASE)
-ICONS_REGEX = re.compile(r"\[\[(.*?)\]\]\s*(.*)")
-BOLD_ITALICS_PATTERN = re.compile(r'(\*\*(.*?)\*\*|\*(.*?)\*)')
-
-ICON_COLORS = [
-    pptx.dml.color.RGBColor.from_string('800000'),  # Maroon
-    pptx.dml.color.RGBColor.from_string('6A5ACD'),  # SlateBlue
-    pptx.dml.color.RGBColor.from_string('556B2F'),  # DarkOliveGreen
-    pptx.dml.color.RGBColor.from_string('2F4F4F'),  # DarkSlateGray
-    pptx.dml.color.RGBColor.from_string('4682B4'),  # SteelBlue
-    pptx.dml.color.RGBColor.from_string('5F9EA0'),  # CadetBlue
-]
-
-
-logger = logging.getLogger(__name__)
-logging.getLogger('PIL.PngImagePlugin').setLevel(logging.ERROR)
-
-
-def remove_slide_number_from_heading(header: str) -> str:
-    """
-    Remove the slide number from a given slide header.
-
-    :param header: The header of a slide.
-    :return: The header without slide number.
-    """
-
-    if SLIDE_NUMBER_REGEX.match(header):
-        idx = header.find(':')
-        header = header[idx + 1:]
-
-    return header
-
-
-def add_bulleted_items(text_frame: pptx.text.text.TextFrame, flat_items_list: list):
-    """
-    Add a list of texts as bullet points and apply formatting.
-
-    :param text_frame: The text frame where text is to be displayed.
-    :param flat_items_list: The list of items to be displayed.
-    """
-
-    for idx, an_item in enumerate(flat_items_list):
-        if idx == 0:
-            paragraph = text_frame.paragraphs[0]  # First paragraph for title text
-        else:
-            paragraph = text_frame.add_paragraph()
-            paragraph.level = an_item[1]
-
-        format_text(paragraph, an_item[0].removeprefix(STEP_BY_STEP_PROCESS_MARKER))
-
-
-def format_text(frame_paragraph, text):
-    """
-    Apply bold and italic formatting while preserving the original word order
-     without duplication.
-    """
-
-    matches = list(BOLD_ITALICS_PATTERN.finditer(text))
-    last_index = 0  # Track position in the text
-    # Group 0: Full match (e.g., **bold** or *italic*)
-    # Group 1: The outer parentheses (captures either bold or italic match, because of |)
-    # Group 2: The bold text inside **bold**
-    # Group 3: The italic text inside *italic*
-    for match in matches:
-        start, end = match.span()
-        # Add unformatted text before the formatted section
-        if start > last_index:
-            run = frame_paragraph.add_run()
-            run.text = text[last_index:start]
-
-        # Extract formatted text
-        if match.group(2):  # Bold
-            run = frame_paragraph.add_run()
-            run.text = match.group(2)
-            run.font.bold = True
-        elif match.group(3):  # Italics
-            run = frame_paragraph.add_run()
-            run.text = match.group(3)
-            run.font.italic = True
-
-        last_index = end  # Update position
-
-    # Add any remaining unformatted text
-    if last_index < len(text):
-        run = frame_paragraph.add_run()
-        run.text = text[last_index:]
-
-
-def generate_powerpoint_presentation(
-        parsed_data: dict,
-        slides_template: str,
-        output_file_path: pathlib.Path
-) -> List:
-    """
-    Create and save a PowerPoint presentation file containing the content in JSON format.
-
-    :param parsed_data: The presentation content as parsed JSON data.
-    :param slides_template: The PPTX template to use.
-    :param output_file_path: The path of the PPTX file to save as.
-    :return: A list of presentation title and slides headers.
-    """
-
-    presentation = pptx.Presentation(GlobalConfig.PPTX_TEMPLATE_FILES[slides_template]['file'])
-    slide_width_inch, slide_height_inch = _get_slide_width_height_inches(presentation)
-
-    # The title slide
-    title_slide_layout = presentation.slide_layouts[0]
-    slide = presentation.slides.add_slide(title_slide_layout)
-    title = slide.shapes.title
-    subtitle = slide.placeholders[1]
-    title.text = parsed_data['title']
-    logger.info(
-        'PPT title: %s | #slides: %d | template: %s',
-        title.text, len(parsed_data['slides']),
-        GlobalConfig.PPTX_TEMPLATE_FILES[slides_template]['file']
-    )
-    subtitle.text = 'by Myself and SlideDeck AI :)'
-    all_headers = [title.text, ]
-
-    # Add content in a loop
-    for a_slide in parsed_data['slides']:
-        try:
-            is_processing_done = _handle_icons_ideas(
-                presentation=presentation,
-                slide_json=a_slide,
-                slide_width_inch=slide_width_inch,
-                slide_height_inch=slide_height_inch
-            )
-
-            if not is_processing_done:
-                is_processing_done = _handle_table(
-                    presentation=presentation,
-                    slide_json=a_slide,
-                    slide_width_inch=slide_width_inch,
-                    slide_height_inch=slide_height_inch
-                )
-
-            if not is_processing_done:
-                is_processing_done = _handle_double_col_layout(
-                    presentation=presentation,
-                    slide_json=a_slide,
-                    slide_width_inch=slide_width_inch,
-                    slide_height_inch=slide_height_inch
-                )
-
-            if not is_processing_done:
-                is_processing_done = _handle_step_by_step_process(
-                    presentation=presentation,
-                    slide_json=a_slide,
-                    slide_width_inch=slide_width_inch,
-                    slide_height_inch=slide_height_inch
-                )
-
-            if not is_processing_done:
-                _handle_default_display(
-                    presentation=presentation,
-                    slide_json=a_slide,
-                    slide_width_inch=slide_width_inch,
-                    slide_height_inch=slide_height_inch
-            )
-
-        except Exception:
-            # In case of any unforeseen error, try to salvage what is available
-            logger.error(
-                'An error occurred while processing a slide...continuing with the next one',
-                exc_info=True
-            )
-            continue
-
-    # The thank-you slide
-    last_slide_layout = presentation.slide_layouts[0]
-    slide = presentation.slides.add_slide(last_slide_layout)
-    title = slide.shapes.title
-    title.text = 'Thank you!'
-
-    presentation.save(output_file_path)
-
-    return all_headers
-
-
-def get_flat_list_of_contents(items: list, level: int) -> List[Tuple]:
-    """
-    Flatten a (hierarchical) list of bullet points to a single list containing each item and
-    its level.
-
-    :param items: A bullet point (string or list).
-    :param level: The current level of hierarchy.
-    :return: A list of (bullet item text, hierarchical level) tuples.
-    """
-
-    flat_list = []
-
-    for item in items:
-        if isinstance(item, str):
-            flat_list.append((item, level))
-        elif isinstance(item, list):
-            flat_list = flat_list + get_flat_list_of_contents(item, level + 1)
-
-    return flat_list
-
-
-def get_slide_placeholders(
-        slide: pptx.slide.Slide,
-        layout_number: int,
-        is_debug: bool = False
-) -> List[Tuple[int, str]]:
-    """
-    Return the index and name (lower case) of all placeholders present in a slide, except
-    the title placeholder.
-
-    A placeholder in a slide is a place to add content. Each placeholder has a name and an index.
-    This index is NOT a list index, rather a set of keys used to look up a dict. So, `idx` is
-    non-contiguous. Also, the title placeholder of a slide always has index 0. User-added
-    placeholder get indices assigned starting from 10.
-
-    With user-edited or added placeholders, their index may be difficult to track. This function
-    returns the placeholders name as well, which could be useful to distinguish between the
-    different placeholder.
-
-    :param slide: The slide.
-    :param layout_number: The layout number used by the slide.
-    :param is_debug: Whether to print debugging statements.
-    :return: A list containing placeholders (idx, name) tuples, except the title placeholder.
-    """
-
-    if is_debug:
-        print(
-            f'Slide layout #{layout_number}:'
-            f' # of placeholders: {len(slide.shapes.placeholders)} (including the title)'
-        )
-
-    placeholders = [
-        (shape.placeholder_format.idx, shape.name.lower()) for shape in slide.shapes.placeholders
-    ]
-    placeholders.pop(0)  # Remove the title placeholder
-
-    if is_debug:
-        print(placeholders)
-
-    return placeholders
-
-
-def _handle_default_display(
-        presentation: pptx.Presentation,
-        slide_json: dict,
-        slide_width_inch: float,
-        slide_height_inch: float
-):
-    """
-    Display a list of text in a slide.
-
-    :param presentation: The presentation object.
-    :param slide_json: The content of the slide as JSON data.
-    :param slide_width_inch: The width of the slide in inches.
-    :param slide_height_inch: The height of the slide in inches.
-    """
-
-    status = False
-
-    if 'img_keywords' in slide_json:
-        if random.random() < IMAGE_DISPLAY_PROBABILITY:
-            if random.random() < FOREGROUND_IMAGE_PROBABILITY:
-                status = _handle_display_image__in_foreground(
-                    presentation,
-                    slide_json,
-                    slide_width_inch,
-                    slide_height_inch
-                )
-            else:
-                status = _handle_display_image__in_background(
-                    presentation,
-                    slide_json,
-                    slide_width_inch,
-                    slide_height_inch
-                )
-
-    if status:
-        return
-
-    # Image display failed, so display only text
-    bullet_slide_layout = presentation.slide_layouts[1]
-    slide = presentation.slides.add_slide(bullet_slide_layout)
-
-    shapes = slide.shapes
-    title_shape = shapes.title
-
-    try:
-        body_shape = shapes.placeholders[1]
-    except KeyError:
-        placeholders = get_slide_placeholders(slide, layout_number=1)
-        body_shape = shapes.placeholders[placeholders[0][0]]
-
-    title_shape.text = remove_slide_number_from_heading(slide_json['heading'])
-    text_frame = body_shape.text_frame
-
-    # The bullet_points may contain a nested hierarchy of JSON arrays
-    # In some scenarios, it may contain objects (dictionaries) because the LLM generated so
-    #  ^ The second scenario is not covered
-    flat_items_list = get_flat_list_of_contents(slide_json['bullet_points'], level=0)
-    add_bulleted_items(text_frame, flat_items_list)
-
-    _handle_key_message(
-        the_slide=slide,
-        slide_json=slide_json,
-        slide_height_inch=slide_height_inch,
-        slide_width_inch=slide_width_inch
-    )
-
-
-def _handle_display_image__in_foreground(
-        presentation: pptx.Presentation,
-        slide_json: dict,
-        slide_width_inch: float,
-        slide_height_inch: float
-) -> bool:
-    """
-    Create a slide with text and image using a picture placeholder layout. If not image keyword is
-    available, it will add only text to the slide.
-
-    :param presentation: The presentation object.
-    :param slide_json: The content of the slide as JSON data.
-    :param slide_width_inch: The width of the slide in inches.
-    :param slide_height_inch: The height of the slide in inches.
-    :return: True if the side has been processed.
-    """
-
-    img_keywords = slide_json['img_keywords'].strip()
-    slide = presentation.slide_layouts[8]  # Picture with Caption
-    slide = presentation.slides.add_slide(slide)
-    placeholders = None
-
-    title_placeholder = slide.shapes.title
-    title_placeholder.text = remove_slide_number_from_heading(slide_json['heading'])
-
-    try:
-        pic_col: PicturePlaceholder = slide.shapes.placeholders[1]
-    except KeyError:
-        placeholders = get_slide_placeholders(slide, layout_number=8)
-        pic_col = None
-        for idx, name in placeholders:
-            if 'picture' in name:
-                pic_col: PicturePlaceholder = slide.shapes.placeholders[idx]
-
-    try:
-        text_col: SlidePlaceholder = slide.shapes.placeholders[2]
-    except KeyError:
-        text_col = None
-        if not placeholders:
-            placeholders = get_slide_placeholders(slide, layout_number=8)
-
-        for idx, name in placeholders:
-            if 'content' in name:
-                text_col: SlidePlaceholder = slide.shapes.placeholders[idx]
-
-    flat_items_list = get_flat_list_of_contents(slide_json['bullet_points'], level=0)
-    add_bulleted_items(text_col.text_frame, flat_items_list)
-
-    if not img_keywords:
-        # No keywords, so no image search and addition
-        return True
-
-    try:
-        photo_url, page_url = ims.get_photo_url_from_api_response(
-            ims.search_pexels(query=img_keywords, size='medium')
-        )
-
-        if photo_url:
-            pic_col.insert_picture(
-                ims.get_image_from_url(photo_url)
-            )
-
-            _add_text_at_bottom(
-                slide=slide,
-                slide_width_inch=slide_width_inch,
-                slide_height_inch=slide_height_inch,
-                text='Photo provided by Pexels',
-                hyperlink=page_url
-            )
-    except Exception as ex:
-        logger.error(
-            '*** Error occurred while running adding image to slide: %s',
-            str(ex)
-        )
-
-    return True
-
-
-def _handle_display_image__in_background(
-        presentation: pptx.Presentation,
-        slide_json: dict,
-        slide_width_inch: float,
-        slide_height_inch: float
-) -> bool:
-    """
-    Add a slide with text and an image in the background. It works just like
-    `_handle_default_display()` but with a background image added. If not image keyword is
-    available, it will add only text to the slide.
-
-    :param presentation: The presentation object.
-    :param slide_json: The content of the slide as JSON data.
-    :param slide_width_inch: The width of the slide in inches.
-    :param slide_height_inch: The height of the slide in inches.
-    :return: True if the slide has been processed.
-    """
-
-    img_keywords = slide_json['img_keywords'].strip()
-
-    # Add a photo in the background, text in the foreground
-    slide = presentation.slides.add_slide(presentation.slide_layouts[1])
-    title_shape = slide.shapes.title
-
-    try:
-        body_shape = slide.shapes.placeholders[1]
-    except KeyError:
-        placeholders = get_slide_placeholders(slide, layout_number=1)
-        # Layout 1 usually has two placeholders, including the title
-        body_shape = slide.shapes.placeholders[placeholders[0][0]]
-
-    title_shape.text = remove_slide_number_from_heading(slide_json['heading'])
-    flat_items_list = get_flat_list_of_contents(slide_json['bullet_points'], level=0)
-    add_bulleted_items(body_shape.text_frame, flat_items_list)
-
-    if not img_keywords:
-        # No keywords, so no image search and addition
-        return True
-
-    try:
-        photo_url, page_url = ims.get_photo_url_from_api_response(
-            ims.search_pexels(query=img_keywords, size='large')
-        )
-
-        if photo_url:
-            picture = slide.shapes.add_picture(
-                image_file=ims.get_image_from_url(photo_url),
-                left=0,
-                top=0,
-                width=pptx.util.Inches(slide_width_inch),
-            )
-
-            try:
-                # Find all blip elements to handle potential multiple instances
-                blip_elements = picture._element.xpath('.//a:blip')
-                if not blip_elements:
-                    logger.warning(
-                        'No blip element found in the picture. Transparency cannot be applied.'
-                    )
-                    return True
-
-                for blip in blip_elements:
-                    # Add transparency to the image through the blip properties
-                    alpha_mod = blip.makeelement(
-                        '{http://schemas.openxmlformats.org/drawingml/2006/main}alphaModFix'
-                    )
-                    # Opacity value between 0-100000
-                    alpha_mod.set('amt', '50000')  # 50% opacity
-
-                    # Check if alphaModFix already exists to avoid duplicates
-                    existing_alpha_mod = blip.find(
-                        '{http://schemas.openxmlformats.org/drawingml/2006/main}alphaModFix'
-                    )
-                    if existing_alpha_mod is not None:
-                        blip.remove(existing_alpha_mod)
-
-                    blip.append(alpha_mod)
-                    logger.debug('Added transparency to blip element: %s', blip.xml)
-
-            except Exception as ex:
-                logger.error(
-                    'Failed to apply transparency to the image: %s. Continuing without it.',
-                    str(ex)
-                )
-
-            _add_text_at_bottom(
-                slide=slide,
-                slide_width_inch=slide_width_inch,
-                slide_height_inch=slide_height_inch,
-                text='Photo provided by Pexels',
-                hyperlink=page_url
-            )
-
-            # Move picture to background
-            try:
-                slide.shapes._spTree.remove(picture._element)
-                slide.shapes._spTree.insert(2, picture._element)
-            except Exception as ex:
-                logger.error(
-                    'Failed to move image to background: %s. Image will remain in foreground.',
-                    str(ex)
-                )
-
-            return True
-
-    except Exception as ex:
-        logger.error(
-            '*** Error occurred while adding image to the slide background: %s',
-            str(ex)
-        )
-        return True
-
-    return True
-
-
-def _handle_icons_ideas(
-        presentation: pptx.Presentation,
-        slide_json: dict,
-        slide_width_inch: float,
-        slide_height_inch: float
-):
-    """
-    Add a slide with some icons and text.
-    If no suitable icons are found, the step numbers are shown.
-
-    :param presentation: The presentation object.
-    :param slide_json: The content of the slide as JSON data.
-    :param slide_width_inch: The width of the slide in inches.
-    :param slide_height_inch: The height of the slide in inches.
-    :return: True if the slide has been processed.
-    """
-
-    if 'bullet_points' in slide_json and slide_json['bullet_points']:
-        items = slide_json['bullet_points']
-
-        # Ensure that it is a single list of strings without any sub-list
-        for step in items:
-            if not isinstance(step, str) or not step.startswith(ICON_BEGINNING_MARKER):
-                return False
-
-        slide_layout = presentation.slide_layouts[5]
-        slide = presentation.slides.add_slide(slide_layout)
-        slide.shapes.title.text = remove_slide_number_from_heading(slide_json['heading'])
-
-        n_items = len(items)
-        text_box_size = INCHES_2
-
-        # Calculate the total width of all pictures and the spacing
-        total_width = n_items * ICON_SIZE
-        spacing = (pptx.util.Inches(slide_width_inch) - total_width) / (n_items + 1)
-        top = INCHES_3
-
-        icons_texts = [
-            (match.group(1), match.group(2)) for match in [
-                ICONS_REGEX.search(item) for item in items
-            ]
-        ]
-        fallback_icon_files = ice.find_icons([item[0] for item in icons_texts])
-
-        for idx, item in enumerate(icons_texts):
-            icon, accompanying_text = item
-            icon_path = f'{GlobalConfig.ICONS_DIR}/{icon}.png'
-
-            if not os.path.exists(icon_path):
-                logger.warning(
-                    'Icon not found: %s...using fallback icon: %s',
-                    icon, fallback_icon_files[idx]
-                )
-                icon_path = f'{GlobalConfig.ICONS_DIR}/{fallback_icon_files[idx]}.png'
-
-            left = spacing + idx * (ICON_SIZE + spacing)
-            # Calculate the center position for alignment
-            center = left + ICON_SIZE / 2
-
-            # Add a rectangle shape with a fill color (background)
-            # The size of the shape is slightly bigger than the icon, so align the icon position
-            shape = slide.shapes.add_shape(
-                MSO_AUTO_SHAPE_TYPE.ROUNDED_RECTANGLE,
-                center - INCHES_0_5,
-                top - (ICON_BG_SIZE - ICON_SIZE) / 2,
-                INCHES_1, INCHES_1
-            )
-            shape.fill.solid()
-            shape.shadow.inherit = False
-
-            # Set the icon's background shape color
-            shape.fill.fore_color.rgb = shape.line.color.rgb = random.choice(ICON_COLORS)
-            # Add the icon image on top of the colored shape
-            slide.shapes.add_picture(icon_path, left, top, height=ICON_SIZE)
-
-            # Add a text box below the shape
-            text_box = slide.shapes.add_shape(
-                MSO_AUTO_SHAPE_TYPE.ROUNDED_RECTANGLE,
-                left=center - text_box_size / 2,  # Center the text box horizontally
-                top=top + ICON_SIZE + INCHES_0_2,
-                width=text_box_size,
-                height=text_box_size
-            )
-            text_frame = text_box.text_frame
-            text_frame.word_wrap = True
-            text_frame.paragraphs[0].alignment = pptx.enum.text.PP_ALIGN.CENTER
-            format_text(text_frame.paragraphs[0], accompanying_text)
-
-            # Center the text vertically
-            text_frame.vertical_anchor = pptx.enum.text.MSO_ANCHOR.MIDDLE
-            text_box.fill.background()  # No fill
-            text_box.line.fill.background()  # No line
-            text_box.shadow.inherit = False
-
-            # Set the font color based on the theme
-            for paragraph in text_frame.paragraphs:
-                for run in paragraph.runs:
-                    run.font.color.theme_color = pptx.enum.dml.MSO_THEME_COLOR.TEXT_2
-
-            _add_text_at_bottom(
-                slide=slide,
-                slide_width_inch=slide_width_inch,
-                slide_height_inch=slide_height_inch,
-                text='More icons available in the SlideDeck AI repository',
-                hyperlink='https://github.com/barun-saha/slide-deck-ai/tree/main/icons/png128'
-            )
-
-        return True
-
-    return False
-
-
-def _add_text_at_bottom(
-        slide: pptx.slide.Slide,
-        slide_width_inch: float,
-        slide_height_inch: float,
-        text: str,
-        hyperlink: Optional[str] = None,
-        target_height: Optional[float] = 0.5
-):
-    """
-    Add arbitrary text to a textbox positioned near the lower left side of a slide.
-
-    :param slide: The slide.
-    :param slide_width_inch: The width of the slide.
-    :param slide_height_inch: The height of the slide.
-    :param target_height: the target height of the box in inches (optional).
-    :param text: The text to be added
-    :param hyperlink: The hyperlink to be added to the text (optional).
-    """
-
-    footer = slide.shapes.add_textbox(
-        left=INCHES_1,
-        top=pptx.util.Inches(slide_height_inch - target_height),
-        width=pptx.util.Inches(slide_width_inch),
-        height=pptx.util.Inches(target_height)
-    )
-
-    paragraph = footer.text_frame.paragraphs[0]
-    run = paragraph.add_run()
-    run.text = text
-    run.font.size = pptx.util.Pt(10)
-    run.font.underline = False
-
-    if hyperlink:
-        run.hyperlink.address = hyperlink
-
-
-def _handle_double_col_layout(
-        presentation: pptx.Presentation,
-        slide_json: dict,
-        slide_width_inch: float,
-        slide_height_inch: float
-) -> bool:
-    """
-    Add a slide with a double column layout for comparison.
-
-    :param presentation: The presentation object.
-    :param slide_json: The content of the slide as JSON data.
-    :param slide_width_inch: The width of the slide in inches.
-    :param slide_height_inch: The height of the slide in inches.
-    :return: True if double col layout has been added; False otherwise.
-    """
-
-    if 'bullet_points' in slide_json and slide_json['bullet_points']:
-        double_col_content = slide_json['bullet_points']
-
-        if double_col_content and (
-                len(double_col_content) == 2
-        ) and isinstance(double_col_content[0], dict) and isinstance(double_col_content[1], dict):
-            slide = presentation.slide_layouts[4]
-            slide = presentation.slides.add_slide(slide)
-            placeholders = None
-
-            shapes = slide.shapes
-            title_placeholder = shapes.title
-            title_placeholder.text = remove_slide_number_from_heading(slide_json['heading'])
-
-            try:
-                left_heading, right_heading = shapes.placeholders[1], shapes.placeholders[3]
-            except KeyError:
-                # For manually edited/added master slides, the placeholder idx numbers in the dict
-                # will be different (>= 10)
-                left_heading, right_heading = None, None
-                placeholders = get_slide_placeholders(slide, layout_number=4)
-
-                for idx, name in placeholders:
-                    if 'text placeholder' in name:
-                        if not left_heading:
-                            left_heading = shapes.placeholders[idx]
-                        elif not right_heading:
-                            right_heading = shapes.placeholders[idx]
-
-            try:
-                left_col, right_col = shapes.placeholders[2], shapes.placeholders[4]
-            except KeyError:
-                left_col, right_col = None, None
-                if not placeholders:
-                    placeholders = get_slide_placeholders(slide, layout_number=4)
-
-                for idx, name in placeholders:
-                    if 'content placeholder' in name:
-                        if not left_col:
-                            left_col = shapes.placeholders[idx]
-                        elif not right_col:
-                            right_col = shapes.placeholders[idx]
-
-            left_col_frame, right_col_frame = left_col.text_frame, right_col.text_frame
-
-            if 'heading' in double_col_content[0] and left_heading:
-                left_heading.text = double_col_content[0]['heading']
-            if 'bullet_points' in double_col_content[0]:
-                flat_items_list = get_flat_list_of_contents(
-                    double_col_content[0]['bullet_points'], level=0
-                )
-
-                if not left_heading:
-                    left_col_frame.text = double_col_content[0]['heading']
-
-                add_bulleted_items(left_col_frame, flat_items_list)
-
-            if 'heading' in double_col_content[1] and right_heading:
-                right_heading.text = double_col_content[1]['heading']
-            if 'bullet_points' in double_col_content[1]:
-                flat_items_list = get_flat_list_of_contents(
-                    double_col_content[1]['bullet_points'], level=0
-                )
-
-                if not right_heading:
-                    right_col_frame.text = double_col_content[1]['heading']
-
-                add_bulleted_items(right_col_frame, flat_items_list)
-
-            _handle_key_message(
-                the_slide=slide,
-                slide_json=slide_json,
-                slide_height_inch=slide_height_inch,
-                slide_width_inch=slide_width_inch
-            )
-
-            return True
-
-    return False
-
-
-def _handle_step_by_step_process(
-        presentation: pptx.Presentation,
-        slide_json: dict,
-        slide_width_inch: float,
-        slide_height_inch: float
-) -> bool:
-    """
-    Add shapes to display a step-by-step process in the slide, if available.
-
-    :param presentation: The presentation object.
-    :param slide_json: The content of the slide as JSON data.
-    :param slide_width_inch: The width of the slide in inches.
-    :param slide_height_inch: The height of the slide in inches.
-    :return True if this slide has a step-by-step process depiction added; False otherwise.
-    """
-
-    if 'bullet_points' in slide_json and slide_json['bullet_points']:
-        steps = slide_json['bullet_points']
-
-        no_marker_count = 0.0
-        n_steps = len(steps)
-
-        # Ensure that it is a single list of strings without any sub-list
-        for step in steps:
-            if not isinstance(step, str):
-                return False
-
-            # In some cases, one or two steps may not begin with >>, e.g.:
-            # {
-            #     "heading": "Step-by-Step Process: Creating a Legacy",
-            #     "bullet_points": [
-            #         "Identify your unique talents and passions",
-            #         ">> Develop your skills and knowledge",
-            #         ">> Create meaningful work",
-            #         ">> Share your work with the world",
-            #         ">> Continuously learn and adapt"
-            #     ],
-            #     "key_message": ""
-            # },
-            #
-            # Use a threshold, e.g., at most 20%
-            if not step.startswith(STEP_BY_STEP_PROCESS_MARKER):
-                no_marker_count += 1
-
-        slide_header = slide_json['heading'].lower()
-        if (no_marker_count / n_steps > 0.25) and not (
-                ('step-by-step' in slide_header) or ('step by step' in slide_header)
-        ):
-            return False
-
-        if n_steps < 3 or n_steps > 6:
-            # Two steps -- probably not a process
-            # More than 5--6 steps -- would likely cause a visual clutter
-            return False
-
-        bullet_slide_layout = presentation.slide_layouts[1]
-        slide = presentation.slides.add_slide(bullet_slide_layout)
-        shapes = slide.shapes
-        shapes.title.text = remove_slide_number_from_heading(slide_json['heading'])
-
-        if 3 <= n_steps <= 4:
-            # Horizontal display
-            height = INCHES_1_5
-            width = pptx.util.Inches(slide_width_inch / n_steps - 0.01)
-            top = pptx.util.Inches(slide_height_inch / 2)
-            left = pptx.util.Inches((slide_width_inch - width.inches * n_steps) / 2 + 0.05)
-
-            for step in steps:
-                shape = shapes.add_shape(MSO_AUTO_SHAPE_TYPE.CHEVRON, left, top, width, height)
-                text_frame = shape.text_frame
-                text_frame.clear()
-                paragraph = text_frame.paragraphs[0]
-                paragraph.alignment = pptx.enum.text.PP_ALIGN.LEFT
-                format_text(paragraph, step.removeprefix(STEP_BY_STEP_PROCESS_MARKER))
-                left += width - INCHES_0_4
-        elif 4 < n_steps <= 6:
-            # Vertical display
-            height = pptx.util.Inches(0.65)
-            top = pptx.util.Inches(slide_height_inch / 4)
-            left = INCHES_1  # slide_width_inch - width.inches)
-
-            # Find the close to median width, based on the length of each text, to be set
-            # for the shapes
-            width = pptx.util.Inches(slide_width_inch * 2 / 3)
-            lengths = [len(step) for step in steps]
-            font_size_20pt = pptx.util.Pt(20)
-            widths = sorted(
-                [
-                    min(
-                        pptx.util.Inches(font_size_20pt.inches * a_len),
-                        width
-                    ) for a_len in lengths
-                ]
-            )
-            width = widths[len(widths) // 2]
-
-            for step in steps:
-                shape = shapes.add_shape(MSO_AUTO_SHAPE_TYPE.PENTAGON, left, top, width, height)
-                text_frame = shape.text_frame
-                text_frame.clear()
-                paragraph = text_frame.paragraphs[0]
-                paragraph.alignment = pptx.enum.text.PP_ALIGN.LEFT
-                format_text(paragraph, step.removeprefix(STEP_BY_STEP_PROCESS_MARKER))
-                top += height + INCHES_0_3
-                left += INCHES_0_5
-
-    return True
-
-
-def _handle_table(
-        presentation: pptx.Presentation,
-        slide_json: dict,
-        slide_width_inch: float,
-        slide_height_inch: float
-) -> bool:
-    """
-    Add a table to a slide, if available.
-
-    :param presentation: The presentation object.
-    :param slide_json: The content of the slide as JSON data.
-    :param slide_width_inch: The width of the slide in inches.
-    :param slide_height_inch: The height of the slide in inches.
-    :return True if this slide has a step-by-step process depiction added; False otherwise.
-    """
-
-    if 'table' not in slide_json or not slide_json['table']:
-        return False
-
-    headers = slide_json['table'].get('headers', [])
-    rows = slide_json['table'].get('rows', [])
-    bullet_slide_layout = presentation.slide_layouts[1]
-    slide = presentation.slides.add_slide(bullet_slide_layout)
-    shapes = slide.shapes
-    shapes.title.text = remove_slide_number_from_heading(slide_json['heading'])
-    left = slide.placeholders[1].left
-    top = slide.placeholders[1].top
-    width = slide.placeholders[1].width
-    height = slide.placeholders[1].height
-    table = slide.shapes.add_table(len(rows) + 1, len(headers), left, top, width, height).table
-
-    # Set headers
-    for col_idx, header_text in enumerate(headers):
-        table.cell(0, col_idx).text = header_text
-        table.cell(0, col_idx).text_frame.paragraphs[
-            0].font.bold = True  # Make header bold
-
-    # Fill in rows
-    for row_idx, row_data in enumerate(rows, start=1):
-        for col_idx, cell_text in enumerate(row_data):
-            table.cell(row_idx, col_idx).text = cell_text
-
-    return True
-
-
-def _handle_key_message(
-        the_slide: pptx.slide.Slide,
-        slide_json: dict,
-        slide_width_inch: float,
-        slide_height_inch: float
-):
-    """
-    Add a shape to display the key message in the slide, if available.
-
-    :param the_slide: The slide to be processed.
-    :param slide_json: The content of the slide as JSON data.
-    :param slide_width_inch: The width of the slide in inches.
-    :param slide_height_inch: The height of the slide in inches.
-    """
-
-    if 'key_message' in slide_json and slide_json['key_message']:
-        height = pptx.util.Inches(1.6)
-        width = pptx.util.Inches(slide_width_inch / 2.3)
-        top = pptx.util.Inches(slide_height_inch - height.inches - 0.1)
-        left = pptx.util.Inches((slide_width_inch - width.inches) / 2)
-        shape = the_slide.shapes.add_shape(
-            MSO_AUTO_SHAPE_TYPE.ROUNDED_RECTANGLE,
-            left=left,
-            top=top,
-            width=width,
-            height=height
-        )
-        format_text(shape.text_frame.paragraphs[0], slide_json['key_message'])
-
-
-def _get_slide_width_height_inches(presentation: pptx.Presentation) -> Tuple[float, float]:
-    """
-    Get the dimensions of a slide in inches.
-
-    :param presentation: The presentation object.
-    :return: The width and the height.
-    """
-
-    slide_width_inch = EMU_TO_INCH_SCALING_FACTOR * presentation.slide_width
-    slide_height_inch = EMU_TO_INCH_SCALING_FACTOR * presentation.slide_height
-
-    return slide_width_inch, slide_height_inch
-
-
-if __name__ == '__main__':
-    _JSON_DATA = '''
-    {
-  "title": "AI Applications: Transforming Industries",
-  "slides": [
-    {
-      "heading": "Introduction to AI Applications",
-      "bullet_points": [
-        "Artificial Intelligence (AI) is *transforming* various industries",
-        "AI applications range from simple decision-making tools to complex systems",
-        "AI can be categorized into types: Rule-based, Instance-based, and Model-based"
-      ],
-      "key_message": "AI is a broad field with diverse applications and categories",
-      "img_keywords": "AI, transformation, industries, decision-making, categories"
-    },
-    {
-      "heading": "AI in Everyday Life",
-      "bullet_points": [
-        "**Virtual assistants** like Siri, Alexa, and Google Assistant",
-        "**Recommender systems** in Netflix, Amazon, and Spotify",
-        "**Fraud detection** in banking and *credit card* transactions"
-      ],
-      "key_message": "AI is integrated into our daily lives through various services",
-      "img_keywords": "virtual assistants, recommender systems, fraud detection"
-    },
-    {
-      "heading": "AI in Healthcare",
-      "bullet_points": [
-        "Disease diagnosis and prediction using machine learning algorithms",
-        "Personalized medicine and drug discovery",
-        "AI-powered robotic surgeries and remote patient monitoring"
-      ],
-      "key_message": "AI is revolutionizing healthcare with improved diagnostics and patient care",
-      "img_keywords": "healthcare, disease diagnosis, personalized medicine, robotic surgeries"
-    },
-    {
-      "heading": "AI in Key Industries",
-      "bullet_points": [
-        {
-          "heading": "Retail",
-          "bullet_points": [
-            "Inventory management and demand forecasting",
-            "Customer segmentation and targeted marketing",
-            "AI-driven chatbots for customer service"
-          ]
-        },
-        {
-          "heading": "Finance",
-          "bullet_points": [
-            "Credit scoring and risk assessment",
-            "Algorithmic trading and portfolio management",
-            "AI for detecting money laundering and cyber fraud"
-          ]
-        }
-      ],
-      "key_message": "AI is transforming retail and finance with improved operations and decision-making",
-      "img_keywords": "retail, finance, inventory management, credit scoring, algorithmic trading"
-    },
-    {
-      "heading": "AI in Education",
-      "bullet_points": [
-        "Personalized learning paths and adaptive testing",
-        "Intelligent tutoring systems for skill development",
-        "AI for predicting student performance and dropout rates"
-      ],
-      "key_message": "AI is personalizing education and improving student outcomes",
-    },
-    {
-      "heading": "Step-by-Step: AI Development Process",
-      "bullet_points": [
-        ">> **Step 1:** Define the problem and objectives",
-        ">> **Step 2:** Collect and preprocess data",
-        ">> **Step 3:** Select and train the AI model",
-        ">> **Step 4:** Evaluate and optimize the model",
-        ">> **Step 5:** Deploy and monitor the AI system"
-      ],
-      "key_message": "Developing AI involves a structured process from problem definition to deployment",
-      "img_keywords": ""
-    },
-    {
-      "heading": "AI Icons: Key Aspects",
-      "bullet_points": [
-        "[[brain]] Human-like *intelligence* and decision-making",
-        "[[robot]] Automation and physical *tasks*",
-        "[[]] Data processing and cloud computing",
-        "[[lightbulb]] Insights and *predictions*",
-        "[[globe2]] Global connectivity and *impact*"
-      ],
-      "key_message": "AI encompasses various aspects, from human-like intelligence to global impact",
-      "img_keywords": "AI aspects, intelligence, automation, data processing, global impact"
-    },
-    {
-        "heading": "AI vs. ML vs. DL: A Tabular Comparison",
-        "table": {
-            "headers": ["Feature", "AI", "ML", "DL"],
-            "rows": [
-                ["Definition", "Creating intelligent agents", "Learning from data", "Deep neural networks"],
-                ["Approach", "Rule-based, expert systems", "Algorithms, statistical models", "Deep neural networks"],
-                ["Data Requirements", "Varies", "Large datasets", "Massive datasets"],
-                ["Complexity", "Varies", "Moderate", "High"],
-                ["Computational Cost", "Low to Moderate", "Moderate", "High"],
-                ["Examples", "Chess, recommendation systems", "Spam filters, image recognition", "Image recognition, NLP"]
-            ]
-        },
-        "key_message": "This table provides a concise comparison of the key features of AI, ML, and DL.",
-        "img_keywords": "AI, ML, DL, comparison, table, features"
-    },
-    {
-      "heading": "Conclusion: Embracing AI's Potential",
-      "bullet_points": [
-        "AI is transforming industries and improving lives",
-        "Ethical considerations are crucial for responsible AI development",
-        "Invest in AI education and workforce development",
-        "Call to action: Explore AI applications and contribute to shaping its future"
-      ],
-      "key_message": "AI offers *immense potential*, and we must embrace it responsibly",
-      "img_keywords": "AI transformation, ethical considerations, AI education, future of AI"
-    }
-  ]
-}'''
-
-    temp = tempfile.NamedTemporaryFile(delete=False, suffix='.pptx')
-    path = pathlib.Path(temp.name)
-
-    generate_powerpoint_presentation(
-        json5.loads(_JSON_DATA),
-        output_file_path=path,
-        slides_template='Basic'
-    )
-    print(f'File path: {path}')
-
-    temp.close()

helpers/text_helper.py

@@ -1,83 +0,0 @@
-"""
-Utility functions to help with text processing.
-"""
-import json_repair as jr
-
-
-def is_valid_prompt(prompt: str) -> bool:
-    """
-    Verify whether user input satisfies the concerned constraints.
-
-    :param prompt: The user input text.
-    :return: True if all criteria are satisfied; False otherwise.
-    """
-
-    if len(prompt) < 7 or ' ' not in prompt:
-        return False
-
-    return True
-
-
-def get_clean_json(json_str: str) -> str:
-    """
-    Attempt to clean a JSON response string from the LLM by removing ```json at the beginning and
-    trailing ``` and any text beyond that.
-    CAUTION: May not be always accurate.
-
-    :param json_str: The input string in JSON format.
-    :return: The "cleaned" JSON string.
-    """
-
-    response_cleaned = json_str
-
-    if json_str.startswith('```json'):
-        json_str = json_str[7:]
-
-    while True:
-        idx = json_str.rfind('```')  # -1 on failure
-
-        if idx <= 0:
-            break
-
-        # In the ideal scenario, the character before the last ``` should be
-        # a new line or a closing bracket
-        prev_char = json_str[idx - 1]
-
-        if (prev_char == '}') or (prev_char == '\n' and json_str[idx - 2] == '}'):
-            response_cleaned = json_str[:idx]
-
-        json_str = json_str[:idx]
-
-    return response_cleaned
-
-
-def fix_malformed_json(json_str: str) -> str:
-    """
-    Try and fix the syntax error(s) in a JSON string.
-
-    :param json_str: The input JSON string.
-    :return: The fixed JSOn string.
-    """
-
-    return jr.repair_json(json_str, skip_json_loads=True)
-
-
-if __name__ == '__main__':
-    JSON1 = '''{
-    "key": "value"
-    }
-    '''
-    JSON2 = '''["Reason": "Regular updates help protect against known vulnerabilities."]'''
-    JSON3 = '''["Reason" Regular updates help protect against known vulnerabilities."]'''
-    JSON4 = '''
-    {"bullet_points": [
-        ">> Write without stopping or editing",
-        >> Set daily writing goals and stick to them,
-        ">> Allow yourself to make mistakes"
-    ],}
-    '''
-
-    print(fix_malformed_json(JSON1))
-    print(fix_malformed_json(JSON2))
-    print(fix_malformed_json(JSON3))
-    print(fix_malformed_json(JSON4))