app.py

from fastapi import FastAPI, Request
import gradio as gr
import uvicorn

# Initialize FastAPI app
app = FastAPI()

# FastAPI route to handle WhatsApp webhook
@app.post("/whatsapp-webhook")
async def whatsapp_webhook(request: Request):
    data = await request.json()  # Parse incoming JSON data
    print(f"Received data: {data}")  # Log incoming data for debugging
    return {"status": "success", "received_data": data}

# Create a simple Gradio Blocks interface
def greet(name):
    return f"Hello, {name}!"

with gr.Blocks() as demo:
    gr.Markdown("### Greeting App")
    name_input = gr.Textbox(placeholder="Enter your name")
    greet_button = gr.Button("Greet")
    output_text = gr.Textbox(label="Greeting")

    greet_button.click(fn=greet, inputs=name_input, outputs=output_text)

# Mount the Gradio app at "/gradio"
app.mount("/gradio", demo)

# Run the FastAPI app with Uvicorn
if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=7860)

# from fastapi import FastAPI, Request
# import uvicorn

# # Initialize FastAPI app
# app = FastAPI()

# # FastAPI route to handle WhatsApp webhook
# @app.post("/whatsapp-webhook")
# async def whatsapp_webhook(request: Request):
#     data = await request.json()  # Parse incoming JSON data
#     print(f"Received data: {data}")  # Log incoming data for debugging
#     return {"status": "success", "received_data": data}

# # Run the FastAPI app with Uvicorn
# if __name__ == "__main__":
#     uvicorn.run(app, host="0.0.0.0", port=7860)

#!/usr/bin/env python
# coding: utf-8


# In[2]:


#pip install  evernote-sdk-python3
# import evernote.edam.notestore.NoteStore as NoteStore
# import evernote.edam.type.ttypes as Types
# from evernote.api.client import EvernoteClient


# In[3]:


# import os
# import yaml
# import pandas as pd
# import numpy as np

# from datetime import datetime, timedelta

# # perspective generation
# import openai
# import os
# from openai import OpenAI

# import gradio as gr

# import json

# import sqlite3
# import uuid
# import socket
# import difflib
# import time
# import shutil
# import requests
# import re

# import json
# import markdown
# from fpdf import FPDF
# import hashlib

# from transformers import pipeline
# from transformers.pipelines.audio_utils import ffmpeg_read

# from todoist_api_python.api import TodoistAPI

# # from flask import Flask, request, jsonify
# from twilio.rest import Client

# import asyncio
# import uvicorn
# import fastapi
# from fastapi import FastAPI, Request, HTTPException
# from fastapi.responses import HTMLResponse, JSONResponse, RedirectResponse
# from fastapi.staticfiles import StaticFiles
# from pathlib import Path

# import nest_asyncio
# from twilio.twiml.messaging_response import MessagingResponse

# from requests.auth import HTTPBasicAuth

# from google.cloud import storage, exceptions  # Import exceptions for error handling
# from google.cloud.exceptions import NotFound
# from google.oauth2 import service_account

# from reportlab.pdfgen import canvas
# from reportlab.lib.pagesizes import letter
# from reportlab.pdfbase import pdfmetrics
# from reportlab.lib import colors
# from reportlab.pdfbase.ttfonts import TTFont

# import logging

# # Configure logging
# logging.basicConfig(level=logging.DEBUG, format="%(asctime)s - %(levelname)s - %(message)s")
# logger = logging.getLogger(__name__)


# # In[4]:

# # Access the API keys and other configuration data
# openai_api_key = os.environ["OPENAI_API_KEY"]
# # Access the API keys and other configuration data
# todoist_api_key = os.environ["TODOIST_API_KEY"]

# EVERNOTE_API_TOKEN = os.environ["EVERNOTE_API_TOKEN"]

# account_sid = os.environ["TWILLO_ACCOUNT_SID"]
# auth_token = os.environ["TWILLO_AUTH_TOKEN"]
# twilio_phone_number = os.environ["TWILLO_PHONE_NUMBER"]

# google_credentials_json = os.environ["GOOGLE_APPLICATION_CREDENTIALS"]
# twillo_client = Client(account_sid, auth_token)

# # Set the GOOGLE_APPLICATION_CREDENTIALS environment variable

# # Load Reasoning Graph JSON File
# def load_reasoning_json(filepath):
#     """Load JSON file and return the dictionary."""
#     with open(filepath, "r") as file:
#         data = json.load(file)
#     return data

# # Load Action Map
# def load_action_map(filepath):
#     """Load action map JSON file and map strings to actual function objects."""
#     with open(filepath, "r") as file:
#         action_map_raw = json.load(file)
#     # Map string names to actual functions using globals()
#     return {action: globals()[func_name] for action, func_name in action_map_raw.items()}


# # In[5]:


# # Define all actions as functions

# def find_reference(task_topic):
#     """Finds a reference related to the task topic."""
#     print(f"Finding reference for topic: {task_topic}")
#     return f"Reference found for topic: {task_topic}"

# def generate_summary(reference):
#     """Generates a summary of the reference."""
#     print(f"Generating summary for reference: {reference}")
#     return f"Summary of {reference}"

# def suggest_relevance(summary):
#     """Suggests how the summary relates to the project."""
#     print(f"Suggesting relevance of summary: {summary}")
#     return f"Relevance of {summary} suggested"

# def tool_research(task_topic):
#     """Performs tool research and returns analysis."""
#     print("Performing tool research")
#     return "Tool analysis data"

# def generate_comparison_table(tool_analysis):
#     """Generates a comparison table for a competitive tool."""
#     print(f"Generating comparison table for analysis: {tool_analysis}")
#     return f"Comparison table for {tool_analysis}"

# def generate_integration_memo(tool_analysis):
#     """Generates an integration memo for a tool."""
#     print(f"Generating integration memo for analysis: {tool_analysis}")
#     return f"Integration memo for {tool_analysis}"

# def analyze_issue(task_topic):
#     """Analyzes an issue and returns the analysis."""
#     print("Analyzing issue")
#     return "Issue analysis data"

# def generate_issue_memo(issue_analysis):
#     """Generates an issue memo based on the analysis."""
#     print(f"Generating issue memo for analysis: {issue_analysis}")
#     return f"Issue memo for {issue_analysis}"

# def list_ideas(task_topic):
#     """Lists potential ideas for brainstorming."""
#     print("Listing ideas")
#     return ["Idea 1", "Idea 2", "Idea 3"]

# def construct_matrix(ideas):
#     """Constructs a matrix (e.g., feasibility or impact/effort) for the ideas."""
#     print(f"Constructing matrix for ideas: {ideas}")
#     return {"Idea 1": "High Impact/Low Effort", "Idea 2": "Low Impact/High Effort", "Idea 3": "High Impact/High Effort"}

# def prioritize_ideas(matrix):
#     """Prioritizes ideas based on the matrix."""
#     print(f"Prioritizing ideas based on matrix: {matrix}")
#     return ["Idea 3", "Idea 1", "Idea 2"]

# def setup_action_plan(prioritized_ideas):
#     """Sets up an action plan based on the prioritized ideas."""
#     print(f"Setting up action plan for ideas: {prioritized_ideas}")
#     return f"Action plan created for {prioritized_ideas}"

# def unsupported_task(task_topic):
#     """Handles unsupported tasks."""
#     print("Task not supported")
#     return "Unsupported task"


# # In[6]:


# todoist_api = TodoistAPI(todoist_api_key)

# # Fetch recent Todoist task
# def fetch_todoist_task():
#     try:
#         tasks = todoist_api.get_tasks()
#         if tasks:
#             recent_task = tasks[0]  # Fetch the most recent task
#             return f"Recent Task: {recent_task.content}"
#         return "No tasks found in Todoist."
#     except Exception as e:
#         return f"Error fetching tasks: {str(e)}"

# def add_to_todoist(task_topic, todoist_priority = 3):
#     try:
#         # Create a task in Todoist using the Todoist API
#         # Assuming you have a function `todoist_api.add_task()` that handles the API request
#         todoist_api.add_task(
#             content=task_topic,
#             priority=todoist_priority
#         )
#         msg = f"Task added: {task_topic} with priority {todoist_priority}"
#         logger.debug(msg)

#         return msg
#     except Exception as e:
#         # Return an error message if something goes wrong
#         return f"An error occurred: {e}"    

# # def save_todo(reasoning_steps):
# #     """
# #     Save reasoning steps to Todoist as tasks.

# #     Args:
# #         reasoning_steps (list of dict): A list of steps with "step" and "priority" keys.
# #     """
# #     try:
# #         # Validate that reasoning_steps is a list
# #         if not isinstance(reasoning_steps, list):
# #             raise ValueError("The input reasoning_steps must be a list.")

# #         # Iterate over the reasoning steps
# #         for step in reasoning_steps:
# #             # Ensure each step is a dictionary and contains required keys
# #             if not isinstance(step, dict) or "step" not in step or "priority" not in step:
# #                 logger.error(f"Invalid step data: {step}, skipping.")
# #                 continue

# #             task_content = step["step"]
# #             priority_level = step["priority"]

# #             # Map priority to Todoist's priority levels (1 - low, 4 - high)
# #             priority_mapping = {"Low": 1, "Medium": 2, "High": 4}
# #             todoist_priority = priority_mapping.get(priority_level, 1)  # Default to low if not found

# #             # Create a task in Todoist using the Todoist API
# #             # Assuming you have a function `todoist_api.add_task()` that handles the API request
# #             todoist_api.add_task(
# #                 content=task_content,
# #                 priority=todoist_priority
# #             )

# #             logger.debug(f"Task added: {task_content} with priority {priority_level}")

# #         return "All tasks processed."
# #     except Exception as e:
# #         # Return an error message if something goes wrong
# #         return f"An error occurred: {e}"


# # In[7]:


# # evernote_client = EvernoteClient(token=EVERNOTE_API_TOKEN, sandbox=False)
# # note_store = evernote_client.get_note_store()

# # def add_to_evernote(task_topic, notebook_title="Inspirations"):
# #     """
# #     Add a task topic to the 'Inspirations' notebook in Evernote. If the notebook doesn't exist, create it.

# #     Args:
# #         task_topic (str): The content of the task to be added.
# #         notebook_title (str): The title of the Evernote notebook. Default is 'Inspirations'.
# #     """
# #     try:
# #         # Check if the notebook exists
# #         notebooks = note_store.listNotebooks()
# #         notebook = next((nb for nb in notebooks if nb.name == notebook_title), None)

# #         # If the notebook doesn't exist, create it
# #         if not notebook:
# #             notebook = Types.Notebook()
# #             notebook.name = notebook_title
# #             notebook = note_store.createNotebook(notebook)

# #         # Search for an existing note with the same title
# #         filter = NoteStore.NoteFilter()
# #         filter.notebookGuid = notebook.guid
# #         filter.words = notebook_title
# #         notes_metadata_result = note_store.findNotesMetadata(filter, 0, 1, NoteStore.NotesMetadataResultSpec(includeTitle=True))

# #         # If a note with the title exists, append to it; otherwise, create a new note
# #         if notes_metadata_result.notes:
# #             note_guid = notes_metadata_result.notes[0].guid
# #             existing_note = note_store.getNote(note_guid, True, False, False, False)
# #             existing_note.content = existing_note.content.replace("</en-note>", f"<div>{task_topic}</div></en-note>")
# #             note_store.updateNote(existing_note)
# #         else:
# #             # Create a new note
# #             note = Types.Note()
# #             note.title = notebook_title
# #             note.notebookGuid = notebook.guid
# #             note.content = f'<?xml version="1.0" encoding="UTF-8"?>' \
# #                            f'<!DOCTYPE en-note SYSTEM "http://xml.evernote.com/pub/enml2.dtd">' \
# #                            f'<en-note><div>{task_topic}</div></en-note>'
# #             note_store.createNote(note)

# #         print(f"Task '{task_topic}' successfully added to Evernote under '{notebook_title}'.")
# #     except Exception as e:
# #         print(f"Error adding task to Evernote: {e}")

# # Mock Functions for Task Actions
# def add_to_evernote(task_topic):
#     return f"Task added to Evernote with title '{task_topic}'."


# # In[8]:


# # Access the API keys and other configuration data
# TASK_WORKFLOW_TREE = load_reasoning_json('curify_ideas_reasoning.json')
# action_map = load_action_map('action_map.json')

# # In[9]:


# def generate_task_hash(task_description):
#     try:
#         # Ensure task_description is a string
#         if not isinstance(task_description, str):
#             logger.warning("task_description is not a string, attempting conversion.")
#             task_description = str(task_description)
        
#         # Safely encode with UTF-8 and ignore errors
#         encoded_description = task_description.encode("utf-8", errors="ignore")
#         task_hash = hashlib.md5(encoded_description).hexdigest()

#         logger.debug(f"Generated task hash: {task_hash}")
#         return task_hash
#     except Exception as e:
#         # Log any unexpected issues
#         logger.error(f"Error generating task hash: {e}", exc_info=True)
#         return 'output'
    
# def save_to_google_storage(bucket_name, file_path, destination_blob_name, expiration_minutes = 1440):
#     credentials_dict = json.loads(google_credentials_json)

#     # Step 3: Use `service_account.Credentials.from_service_account_info` to authenticate directly with the JSON
#     credentials = service_account.Credentials.from_service_account_info(credentials_dict)
#     gcs_client = storage.Client(credentials=credentials, project=credentials.project_id)

#     # Check if the bucket exists; if not, create it
#     try:
#         bucket = gcs_client.get_bucket(bucket_name)
#     except NotFound:
#         print(f"❌ Bucket '{bucket_name}' not found. Please check the bucket name.")
#         bucket = gcs_client.create_bucket(bucket_name)
#         print(f"✅ Bucket '{bucket_name}' created.")
#     except Exception as e:
#         print(f"❌ An unexpected error occurred: {e}")
#         raise
#     # Get a reference to the blob
#     blob = bucket.blob(destination_blob_name)
    
#     # Upload the file
#     blob.upload_from_filename(file_path)
    
#     # Generate a signed URL for the file
#     signed_url = blob.generate_signed_url(
#         version="v4",
#         expiration=timedelta(minutes=expiration_minutes),
#         method="GET"
#     )
#     print(f"✅ File uploaded to Google Cloud Storage. Signed URL: {signed_url}")
#     return signed_url


# # Function to check if content is Simplified Chinese
# def is_simplified(text):
#     simplified_range = re.compile('[\u4e00-\u9fff]')  # Han characters in general
#     simplified_characters = [char for char in text if simplified_range.match(char)]
#     return len(simplified_characters) > len(text) * 0.5  # Threshold of 50% to be considered simplified

# # Function to choose the appropriate font for the content
# def choose_font_for_content(content):
#     return 'NotoSansSC' if is_simplified(content) else 'NotoSansTC'

# # Function to generate and save a document using ReportLab
# def generate_document(task_description, md_content, user_name='jayw', bucket_name='curify'):
#     logger.debug("Starting to generate document")

#     # Hash the task description to generate a unique filename
#     task_hash = generate_task_hash(task_description)

#     # Truncate the hash if needed (64 characters is sufficient for uniqueness)
#     max_hash_length = 64  # Adjust if needed
#     truncated_hash = task_hash[:max_hash_length]

#     # Generate PDF file locally
#     local_filename = f"{truncated_hash}.pdf"  # Use the truncated hash as the local file name
#     c = canvas.Canvas(local_filename, pagesize=letter)

#     # Paths to the TTF fonts for Simplified and Traditional Chinese
#     sc_font_path = 'NotoSansSC-Regular.ttf'  # Path to Simplified Chinese font
#     tc_font_path = 'NotoSansTC-Regular.ttf'  # Path to Traditional Chinese font

#     try:
#         # Register the Simplified Chinese font
#         sc_font = TTFont('NotoSansSC', sc_font_path)
#         pdfmetrics.registerFont(sc_font)

#         # Register the Traditional Chinese font
#         tc_font = TTFont('NotoSansTC', tc_font_path)
#         pdfmetrics.registerFont(tc_font)
        
#         # Set default font (Simplified Chinese or Traditional Chinese depending on content)
#         c.setFont('NotoSansSC', 12)
#     except Exception as e:
#         logger.error(f"Error loading font files: {e}")
#         raise RuntimeError("Failed to load one or more fonts. Ensure the font files are accessible.")

#     # Set initial Y position for drawing text
#     y_position = 750  # Starting position for text

#     # Process dictionary and render content
#     for key, value in md_content.items():
#         # Choose the font based on the key (header)
#         c.setFont(choose_font_for_content(key), 14)
#         c.drawString(100, y_position, f"# {key}")
#         y_position -= 20

#         # Choose the font for the value
#         c.setFont(choose_font_for_content(str(value)), 12)

#         # Add value
#         if isinstance(value, list):  # Handle lists
#             for item in value:
#                 c.drawString(100, y_position, f"- {item}")
#                 y_position -= 15
#         else:  # Handle single strings
#             c.drawString(100, y_position, value)
#             y_position -= 15

#         # Check if the page needs to be broken (if Y position is too low)
#         if y_position < 100:
#             c.showPage()  # Create a new page
#             c.setFont('NotoSansSC', 12)  # Reset font
#             y_position = 750  # Reset the Y position for the new page

#     # Save the PDF
#     c.save()

#     # Organize files into user-specific folders
#     destination_blob_name = f"{user_name}/{truncated_hash}.pdf"

#     # Upload to Google Cloud Storage and get the public URL
#     public_url = save_to_google_storage(bucket_name, local_filename, destination_blob_name)
#     logger.debug("Finished generating document")
#     return public_url
    
# # In[10]:


# def execute_with_retry(sql, params=(), attempts=5, delay=1, db_name = 'curify_ideas.db'):
#     for attempt in range(attempts):
#         try:
#             with sqlite3.connect(db_name) as conn:
#                 cursor = conn.cursor()
#                 cursor.execute(sql, params)
#                 conn.commit()
#                 break
#         except sqlite3.OperationalError as e:
#             if "database is locked" in str(e) and attempt < attempts - 1:
#                 time.sleep(delay)
#             else:
#                 raise e

# # def enable_wal_mode(db_name = 'curify_ideas.db'):
# #     with sqlite3.connect(db_name) as conn:
# #         cursor = conn.cursor()
# #         cursor.execute("PRAGMA journal_mode=WAL;")
# #         conn.commit()

# # # Create SQLite DB and table
# # def create_db(db_name = 'curify_ideas.db'):
# #     with sqlite3.connect(db_name, timeout=30) as conn:
# #         c = conn.cursor()
# #         c.execute('''CREATE TABLE IF NOT EXISTS sessions (
# #             session_id TEXT,
# #             ip_address TEXT,
# #             project_desc TEXT,
# #             idea_desc TEXT,
# #             idea_analysis TEXT,
# #             prioritization_steps TEXT,
# #             timestamp DATETIME,
# #             PRIMARY KEY (session_id, timestamp)
# #             )
# #         ''')
# #         conn.commit()

# # # Function to insert session data into the SQLite database
# # def insert_session_data(session_id, ip_address, project_desc, idea_desc, idea_analysis, prioritization_steps, db_name = 'curify_ideas.db'):
# #     execute_with_retry('''
# #         INSERT INTO sessions (session_id, ip_address, project_desc, idea_desc, idea_analysis, prioritization_steps, timestamp)
# #         VALUES (?, ?, ?, ?, ?, ?, ?)
# #     ''', (session_id, ip_address, project_desc, idea_desc, json.dumps(idea_analysis), json.dumps(prioritization_steps), datetime.now()), db_name)


# # In[11]:


# def convert_to_listed_json(input_string):
#     """
#     Converts a string to a listed JSON object.
    
#     Parameters:
#         input_string (str): The JSON-like string to be converted.
    
#     Returns:
#         list: A JSON object parsed into a Python list of dictionaries.
#     """
#     try:
#         # Parse the string into a Python object
#         trimmed_string = input_string[input_string.index('['):input_string.rindex(']') + 1]

#         json_object = json.loads(trimmed_string)
#         return json_object
#     except json.JSONDecodeError as e:
#         return None
#     return None
#     #raise ValueError(f"Invalid JSON format: {e}")

# def validate_and_extract_json(json_string):
#     """
#     Validates the JSON string, extracts fields with possible variants using fuzzy matching.
    
#     Args:
#     - json_string (str): The JSON string to validate and extract from.
#     - field_names (list): List of field names to extract, with possible variants.
    
#     Returns:
#     - dict: Extracted values with the best matched field names.
#     """
#     # Try to parse the JSON string
#     trimmed_string = json_string[json_string.index('{'):json_string.rindex('}') + 1]
#     try:
#         parsed_json = json.loads(trimmed_string)
#         return parsed_json
#     except json.JSONDecodeError as e:
#         return None

#     # {"error": "Parsed JSON is not a dictionary."}
#     return None

# def json_to_pandas(dat_json, dat_schema = {'name':"", 'description':""}):
#     dat_df = pd.DataFrame([dat_schema])
#     try:
#         dat_df = pd.DataFrame(dat_json)

#     except Exception as e:
#         dat_df = pd.DataFrame([dat_schema])
#     # ValueError(f"Failed to parse LLM output as JSON: {e}\nOutput: {res}")
#     return dat_df


# # In[12]:


# client = OpenAI(
#     api_key= os.environ.get("OPENAI_API_KEY"),  # This is the default and can be omitted
# )

# # Function to call OpenAI API with compact error handling
# def call_openai_api(prompt, model="gpt-4o", max_tokens=5000, retries=3, backoff_factor=2):
#     """
#     Send a prompt to the OpenAI API and handle potential errors robustly.

#     Parameters:
#         prompt (str): The user input or task prompt to send to the model.
#         model (str): The OpenAI model to use (default is "gpt-4").
#         max_tokens (int): The maximum number of tokens in the response.
#         retries (int): Number of retry attempts in case of transient errors.
#         backoff_factor (int): Backoff time multiplier for retries.

#     Returns:
#         str: The model's response content if successful.
#     """
#     for attempt in range(1, retries + 1):
#         try:
#             response = client.chat.completions.create(
#             model="gpt-4o",
#             messages=[{"role": "user", "content": prompt}],
#             max_tokens=5000,
#             )        
#             return response.choices[0].message.content.strip()
        
#         except (openai.RateLimitError, openai.APIConnectionError) as e:
#             logging.warning(f"Transient error: {e}. Attempt {attempt} of {retries}. Retrying...")
#         except (openai.BadRequestError, openai.AuthenticationError) as e:
#             logging.error(f"Unrecoverable error: {e}. Check your inputs or API key.")
#             break
#         except Exception as e:
#             logging.error(f"Unexpected error: {e}. Attempt {attempt} of {retries}. Retrying...")
        
#         # Exponential backoff before retrying
#         if attempt < retries:
#             time.sleep(backoff_factor * attempt)
    
#     raise RuntimeError(f"Failed to fetch response from OpenAI API after {retries} attempts.")

# def fn_analyze_task(project_context, task_description):
#     prompt = (
#             f"You are working in the context of {project_context}. "
#             f"Your task is to analyze the task: {task_description} "
#             "Please analyze the following aspects: "
#             "1) Determine which project this item belongs to. If the idea does not belong to any existing project, categorize it under 'Other'. "
#             "2) Assess whether this idea can be treated as a concrete task. "
#             "3) Evaluate whether a document can be generated as an intermediate result. "
#             "4) Identify the appropriate category of the task. Possible categories are: 'Blogs/Papers', 'Tools', 'Brainstorming', 'Issues', and 'Others'. "
#             "5) Extract the topic of the task. "
#             "Please provide the output in JSON format using the structure below: "
#             "{"
#             "  \"description\": \"\", "
#             "  \"project_association\": \"\", "
#             "  \"is_task\": \"Yes/No\", "
#             "  \"is_document\": \"Yes/No\", "
#             "  \"task_category\": \"\", "
#             "  \"task_topic\": \"\" "
#             "}"
#         )
#     res_task_analysis = call_openai_api(prompt)

#     try:
#         json_task_analysis = validate_and_extract_json(res_task_analysis)

#         return json_task_analysis
#     except ValueError as e:
#         logger.debug("ValueError occurred: %s", str(e), exc_info=True)  # Log the exception details
#         return None


# # In[13]:

# # Recursive Task Executor
# def fn_process_task(project_desc_table, task_description, bucket_name='curify'):
    
#     project_context = project_desc_table.to_string(index=False)
#     task_analysis = fn_analyze_task(project_context, task_description)

#     if task_analysis:
#         execution_status = []
#         execution_results = task_analysis.copy()
#         execution_results['deliverables'] = ''

#         def traverse(node, previous_output=None):
#             if not node:  # If the node is None or invalid
#                 return  # Exit if the node is invalid

#             # Check if there is a condition to evaluate
#             if "check" in node:
#                 # Safely attempt to retrieve the value from execution_results
#                 if node["check"] in execution_results:
#                     value = execution_results[node["check"]]  # Evaluate the check condition
#                     traverse(node.get(value, node.get("default")), previous_output)
#                 else:
#                     # Log an error and exit, but keep partial results
#                     logger.error(f"Key '{node['check']}' not found in execution_results.")
#                     return
        
#             # If the node contains an action
#             elif "action" in node:
#                 action_name = node["action"]
#                 input_key = node.get("input", 'task_topic')

#                 if input_key in execution_results.keys():
#                     inputs = {input_key: execution_results[input_key]}
#                 else:
#                     # Log an error and exit, but keep partial results
#                     logger.error(f"Workflow action {action_name} input key {input_key} not in execution_results.")
#                     return

#                 logger.debug(f"Executing: {action_name} with inputs: {inputs}")
                
#                 # Execute the action function
#                 action_func = action_map.get(action_name, unsupported_task)
#                 try:
#                     output = action_func(**inputs)
#                 except Exception as e:
#                     # Handle action function failure
#                     logger.error(f"Error executing action '{action_name}': {e}")
#                     return

#                 # Store execution results or append to previous outputs
#                 execution_status.append({"action": action_name, "output": output})

#                 # Check if 'output' field exists in the node
#                 if 'output' in node:
#                     # If 'output' exists, assign the output to execution_results with the key from node['output']
#                     execution_results[node['output']] = output
#                 else:
#                     # If 'output' does not exist, append the output to 'deliverables'
#                     execution_results['deliverables'] += output
                
#                 # Traverse to the next node, if it exists
#                 if "next" in node and node["next"]:
#                     traverse(node["next"], previous_output)

#         try:
#             traverse(TASK_WORKFLOW_TREE["start"])
#             execution_results['doc_url'] = generate_document(task_description, execution_results)
#         except Exception as e:
#             logger.error(f"Traverse Error: {e}")
#         finally:
#             # Always return partial results, even if an error occurs
#             return task_analysis, pd.DataFrame(execution_status), execution_results
#     else:
#         logger.error("Empty task analysis.")
#         return {}, pd.DataFrame(), {}

# # In[14]:


# # Initialize dataframes for the schema
# ideas_df = pd.DataFrame(columns=["Idea ID", "Content", "Tags"])

# def extract_ideas(context, text):
#     """
#     Extract project ideas from text, with or without a context, and return in JSON format.

#     Parameters:
#         context (str): Context of the extraction. Can be empty.
#         text (str): Text to extract ideas from.

#     Returns:
#         list: A list of ideas, each represented as a dictionary with name and description.
#     """
#     if context:
#         # Template when context is provided
#         prompt = (
#             f"You are working in the context of {context}. "
#             "Please extract the ongoing projects with project name and description."
#             "Please only the listed JSON as output string."
#             f"Ongoing projects: {text}"
#         )
#     else:
#         # Template when context is not provided
#         prompt = (
#             "Given the following information about the user."
#             "Please extract the ongoing projects with project name and description."
#             "Please only the listed JSON as output string."
#             f"Ongoing projects: {text}"
#         )

#     # return the raw string
#     return call_openai_api(prompt)

# def df_to_string(df, empty_message = ''):
#     """
#     Converts a DataFrame to a string if it is not empty. 
#     If the DataFrame is empty, returns an empty string.
    
#     Parameters:
#         ideas_df (pd.DataFrame): The DataFrame to be converted.
    
#     Returns:
#         str: A string representation of the DataFrame or an empty string.
#     """
#     if df.empty:
#         return empty_message
#     else:
#         return df.to_string(index=False)


# # In[15]:


# # Shared state variables
# shared_state = {"project_desc_table": pd.DataFrame(), "task_analysis_txt": "", "execution_status": pd.DataFrame(), "execution_results": {}}

# # Button Action: Fetch State
# def fetch_updated_state():
#     # Iterating and logging the shared state
#     for key, value in shared_state.items():
#         if isinstance(value, pd.DataFrame):
#             logger.debug(f"{key}: DataFrame:\n{value.to_string()}")
#         elif isinstance(value, dict):
#             logger.debug(f"{key}: Dictionary: {value}")
#         elif isinstance(value, str):
#             logger.debug(f"{key}: String: {value}")
#         else:
#             logger.debug(f"{key}: Unsupported type: {value}")
#     return shared_state['project_desc_table'], shared_state['task_analysis_txt'], shared_state['execution_status'], shared_state['execution_results']
    
#     # response = requests.get("http://localhost:5000/state")
#     # # Check the status code and the raw response
#     # if response.status_code == 200:
#     #     try:
#     #         state = response.json()  # Try to parse JSON
#     #         return pd.DataFrame(state["project_desc_table"]), state["task_analysis_txt"], pd.DataFrame(state["execution_status"]), state["execution_results"]
#     #     except ValueError as e:
#     #         logger.error(f"JSON decoding failed: {e}")
#     #         logger.debug("Raw response body:", response.text)
#     # else:
#     #     logger.error(f"Error: {response.status_code} - {response.text}")
#     # """Fetch the updated shared state from FastAPI."""
#     # return pd.DataFrame(), "", pd.DataFrame(), {}
    

# def update_gradio_state(project_desc_table, task_analysis_txt, execution_status, execution_results):
#     # You can update specific components like Textbox or State
#     shared_state['project_desc_table'] = project_desc_table
#     shared_state['task_analysis_txt'] = task_analysis_txt
#     shared_state['execution_status'] = execution_status
#     shared_state['execution_results'] = execution_results
#     return True


# # In[16]:


# # # Initialize the database
# # new_db = 'curify.db'

# # # Copy the old database to a new one
# # shutil.copy("curify_idea.db", new_db)

# #create_db(new_db)
# #enable_wal_mode(new_db)
# def project_extraction(project_description):

#     str_projects = extract_ideas('AI-powered tools for productivity', project_description)
#     json_projects = convert_to_listed_json(str_projects)

#     project_desc_table = json_to_pandas(json_projects)
#     update_gradio_state(project_desc_table, "", pd.DataFrame(), {})
#     return project_desc_table


# # In[17]:


# # project_description = 'work on a number of projects including curify (digest, ideas, careers, projects etc), and writing a book on LLM for recommendation system, educating my 3.5-year-old boy and working on a paper for LLM reasoning.'

# # # convert_to_listed_json(extract_ideas('AI-powered tools for productivity', project_description))

# # task_description = 'Build an interview bot for the curify digest project.'
# # task_analysis, reasoning_path = generate_reasoning_path(project_description, task_description)

# # steps = store_and_execute_task(task_description, reasoning_path)

# def message_back(task_message, execution_status, doc_url, from_whatsapp):
#     # Convert task steps to a simple numbered list
#     task_steps_list = "\n".join(
#         [f"{i + 1}. {step['action']} - {step.get('output', '')}" for i, step in enumerate(execution_status.to_dict(orient="records"))]
#     )

#     # Format the body message
#     body_message = (
#         f"*Task Message:*\n{task_message}\n\n"
#         f"*Execution Status:*\n{task_steps_list}\n\n"
#         f"*Doc URL:*\n{doc_url}\n\n"
#     )

#     # Send response back to WhatsApp
#     try:
#         twillo_client.messages.create(
#             from_=twilio_phone_number,
#             to=from_whatsapp,
#             body=body_message
#         )
#     except Exception as e:
#         logger.error(f"Twilio Error: {e}")
#         raise HTTPException(status_code=500, detail=f"Error sending WhatsApp message: {str(e)}")

#     return {"status": "success"}

# # Initialize the Whisper pipeline
# whisper_pipeline = pipeline("automatic-speech-recognition", model="openai/whisper-medium")

# # Function to transcribe audio from a media URL
# def transcribe_audio_from_media_url(media_url):
#     try:
#         media_response = requests.get(media_url, auth=HTTPBasicAuth(account_sid, auth_token))
#         # Download the media file
#         media_response.raise_for_status()
#         audio_data = media_response.content

#         # Save the audio data to a file for processing
#         audio_file_path = "temp_audio_file.mp3"
#         with open(audio_file_path, "wb") as audio_file:
#             audio_file.write(audio_data)

#         # Transcribe the audio using Whisper
#         transcription = whisper_pipeline(audio_file_path, return_timestamps=True)
#         logger.debug(f"Transcription: {transcription['text']}")
#         return transcription["text"]

#     except Exception as e:
#         logger.error(f"An error occurred: {e}")
#         return None


# # In[18]:


# app = FastAPI()

# @app.get("/state")
# async def fetch_state():
#     return shared_state

# @app.route("/whatsapp-webhook/", methods=["POST"])
# async def whatsapp_webhook(request: Request):
#     form_data = await request.form()
#     # Log the form data to debug
#     print("Received data:", form_data)
    
#     # Extract message and user information
#     incoming_msg = form_data.get("Body", "").strip()
#     from_number = form_data.get("From", "")
#     media_url = form_data.get("MediaUrl0", "")
#     media_type = form_data.get("MediaContentType0", "")

#     # Initialize response variables
#     transcription = None

#     if media_type.startswith("audio"):
#         # If the media is an audio or video file, process it
#         try:
#             transcription = transcribe_audio_from_media_url(media_url)
#         except Exception as e:
#             return JSONResponse(
#                 {"error": f"Failed to process voice input: {str(e)}"}, status_code=500
#             )
#     # Determine message content: use transcription if available, otherwise use text message
#     processed_input = transcription if transcription else incoming_msg

#     logger.debug(f"Processed input: {processed_input}")

#     try:
#         # Generate response
#         project_desc_table, _ = fetch_updated_state()
        
#         # If the project_desc_table is empty, return an empty JSON response
#         if project_desc_table.empty:
#             return JSONResponse(content={})  # Returning an empty JSON object
    
#         # Continue processing if the table is not empty
#         task_analysis_txt, execution_status, execution_results = fn_process_task(project_desc_table, processed_input)
#         update_gradio_state(task_analysis_txt, execution_status, execution_results)
    
#         doc_url = 'Fail to generate doc'
#         if 'doc_url' in execution_results:
#             doc_url = execution_results['doc_url']
    
#         # Respond to the user on WhatsApp with the processed idea
#         response = message_back(processed_input, execution_status, doc_url, from_number)
#         logger.debug(response)
    
#         return JSONResponse(content=str(response))
    
#     except Exception as e:
#         logger.error(f"Error during task processing: {e}")
#         return JSONResponse(content={"error": str(e)}, status_code=500)

# # In[19]:


# # Mock Gmail Login Function
# def mock_login(email):
#     if email.endswith("@gmail.com"):
#         return f"✅ Logged in as {email}", gr.update(visible=False), gr.update(visible=True)
#     else:
#         return "❌ Invalid Gmail address. Please try again.", gr.update(), gr.update()

# # User Onboarding Function
# def onboarding_survey(role, industry, project_description):
#     return (project_extraction(project_description),
#             gr.update(visible=False), gr.update(visible=True))

# # Mock Integration Functions
# def integrate_todoist():
#     return "✅ Successfully connected to Todoist!"

# def integrate_evernote():
#     return "✅ Successfully connected to Evernote!"

# def integrate_calendar():
#     return "✅ Successfully connected to Google Calendar!"

# def load_svg_with_size(file_path, width="600px", height="400px"):
#     # Read the SVG content from the file
#     with open(file_path, "r", encoding="utf-8") as file:
#         svg_content = file.read()
    
#     # Add inline styles to control width and height
#     styled_svg = f"""
#     <div style="width: {width}; height: {height}; overflow: auto;">
#         {svg_content}
#     </div>
#     """
#     return styled_svg


# # In[20]:


# # Gradio Demo
# def create_gradio_interface(state=None):
#     with gr.Blocks(
#         css="""
#         .gradio-table td {
#             white-space: normal !important;
#             word-wrap: break-word !important;
#         }
#         .gradio-table {
#             width: 100% !important;  /* Adjust to 100% to fit the container */
#             table-layout: fixed !important;  /* Fixed column widths */
#             overflow-x: hidden !important;  /* Disable horizontal scrolling */
#         }
#         .gradio-container {
#             overflow-x: hidden !important;  /* Disable horizontal scroll for entire container */
#             padding: 0 !important;  /* Remove any default padding */
#         }
#         .gradio-column {
#             max-width: 100% !important;  /* Ensure columns take up full width */
#             overflow: hidden !important;  /* Hide overflow to prevent horizontal scroll */
#         }
#         .gradio-row {
#             overflow-x: hidden !important;  /* Prevent horizontal scroll on rows */
#         }
#     """) as demo:

#     # Page 1: Mock Gmail Login
#         with gr.Group(visible=True) as login_page:
#             gr.Markdown("### **1️⃣ Login with Gmail**")
#             email_input = gr.Textbox(label="Enter your Gmail Address", placeholder="[email protected]")
#             login_button = gr.Button("Login")
#             login_result = gr.Textbox(label="Login Status", interactive=False, visible=False)
#         # Page 2: User Onboarding
#         with gr.Group(visible=False) as onboarding_page:
#             gr.Markdown("### **2️⃣ Tell Us About Yourself**")
#             role = gr.Textbox(label="What is your role?", placeholder="e.g. Developer, Designer")
#             industry = gr.Textbox(label="Which industry are you in?", placeholder="e.g. Software, Finance")
#             project_description = gr.Textbox(label="Describe your project", placeholder="e.g. A task management app")
#             submit_survey = gr.Button("Submit")

#         # Page 3: Mock Integrations with Separate Buttons
#         with gr.Group(visible=False) as integrations_page:
#             gr.Markdown("### **3️⃣ Connect Integrations**")
#             gr.Markdown("Click on the buttons below to connect each tool:")

#             # Separate Buttons and Results for Each Integration
#             todoist_button = gr.Button("Connect to Todoist")
#             todoist_result = gr.Textbox(label="Todoist Status", interactive=False, visible=False)
            
#             evernote_button = gr.Button("Connect to Evernote")
#             evernote_result = gr.Textbox(label="Evernote Status", interactive=False, visible=False)
            
#             calendar_button = gr.Button("Connect to Google Calendar")
#             calendar_result = gr.Textbox(label="Google Calendar Status", interactive=False, visible=False)

#             # Skip Button to proceed directly to next page
#             skip_integrations = gr.Button("Skip ➡️")
#             next_button = gr.Button("Proceed to QR Code")

#         with gr.Group(visible=False) as qr_code_page:
#             # Page 4: QR Code and Curify Ideas
#             gr.Markdown("## Curify: Unified AI Tools for Productivity")
            
#             with gr.Tab("Curify Idea"):
#                 with gr.Row():
#                     with gr.Column():
#                         gr.Markdown("#### ** QR Code**")
#                         # Path to your local SVG file
#                         svg_file_path = "qr.svg"
#                         # Load the SVG content
#                         svg_content = load_svg_with_size(svg_file_path, width="200px", height="200px")
#                         gr.HTML(svg_content)

#                     # Column 1: Webpage rendering
#                     with gr.Column():
                        
#                         gr.Markdown("## Projects Overview")
#                         project_desc_table = gr.DataFrame(
#                             type="pandas"
#                         )

#                         gr.Markdown("## Enter task message.")
#                         idea_input = gr.Textbox(
#                             label=None,
#                             placeholder="Describe the task you want to execute (e.g., Research Paper Review)")
            
#                         task_btn = gr.Button("Generate Task Steps")
#                         fetch_state_btn = gr.Button("Fetch Updated State")

#                     with gr.Column():
#                         gr.Markdown("## Task analysis")
#                         task_analysis_txt = gr.Textbox(
#                             label=None,
#                             placeholder="Here is the execution status of your task...")

#                         gr.Markdown("## Execution status")
#                         execution_status = gr.DataFrame(
#                             type="pandas"
#                         )
#                         gr.Markdown("## Execution output")
#                         execution_results = gr.JSON(
#                             label=None
#                         )
#                         state_output = gr.State()  # Add a state output to hold the state

#                 task_btn.click(
#                     fn_process_task, 
#                     inputs=[project_desc_table, idea_input], 
#                     outputs=[task_analysis_txt, execution_status, execution_results]
#                 )

#                 fetch_state_btn.click(
#                     fetch_updated_state, 
#                     inputs=None, 
#                     outputs=[project_desc_table, task_analysis_txt, execution_status, execution_results]
#                 )

#                 # Page 1 -> Page 2 Transition
#                 login_button.click(
#                     mock_login, 
#                     inputs=email_input, 
#                     outputs=[login_result, login_page, onboarding_page]
#                 )

#                 # Page 2 -> Page 3 Transition (Submit and Skip)
#                 submit_survey.click(
#                     onboarding_survey, 
#                     inputs=[role, industry, project_description], 
#                     outputs=[project_desc_table, onboarding_page, integrations_page]
#                 )

#                 # Integration Buttons
#                 todoist_button.click(integrate_todoist, outputs=todoist_result)
#                 evernote_button.click(integrate_evernote, outputs=evernote_result)
#                 calendar_button.click(integrate_calendar, outputs=calendar_result)

#                 # Skip Integrations and Proceed
#                 skip_integrations.click(
#                     lambda: (gr.update(visible=False), gr.update(visible=True)),
#                     outputs=[integrations_page, qr_code_page]
#                 )

#         # # Set the load_fn to initialize the state when the page is loaded
#         # demo.load(
#         #     curify_ideas, 
#         #     inputs=[project_input, idea_input], 
#         #     outputs=[task_steps, task_analysis_txt, state_output]
#         # )
#     return demo
#     # Load function to initialize the state
#     # demo.load(load_fn, inputs=None, outputs=[state])  # Initialize the state when the page is loaded

# # Function to launch Gradio
# # def launch_gradio():
# #     demo = create_gradio_interface()
# #     demo.launch(share=True, inline=False)  # Gradio in the foreground

# # # Function to run FastAPI server using uvicorn in the background
# # async def run_fastapi():
# #     config = uvicorn.Config(app, host="0.0.0.0", port=5000, reload=True, log_level="debug")
# #     server = uvicorn.Server(config)
# #     await server.serve()

# # # FastAPI endpoint to display a message
# # @app.get("/", response_class=HTMLResponse)
# # async def index():
# #     return "FastAPI is running. Visit Gradio at the provided public URL."

# # # Main entry point for the asynchronous execution
# # async def main():
# #     # Run Gradio in the foreground and FastAPI in the background
# #     loop = asyncio.get_event_loop()
    
# #     # Run Gradio in a separate thread (non-blocking)
# #     loop.run_in_executor(None, launch_gradio)
    
# #     # Run FastAPI in the background (asynchronous)
# #     await run_fastapi()

# # if __name__ == "__main__":
# #     import nest_asyncio
# #     nest_asyncio.apply()  # Allow nested use of asyncio event loops in Jupyter notebooks
    
# #     # Run the main function to launch both services concurrently
# #     asyncio.run(main())
    
# # In[21]:
# demo = create_gradio_interface()
# # Use Gradio's `server_app` to get an ASGI app for Blocks
# gradio_asgi_app = demo.launch(share=False, inbrowser=False, server_name="0.0.0.0", server_port=7860, inline=False)

# logging.debug(f"Gradio version: {gr.__version__}")
# logging.debug(f"FastAPI version: {fastapi.__version__}")

# # # Mount the Gradio ASGI app at "/gradio"
# # app.mount("/gradio", gradio_asgi_app)

# # # create a static directory to store the static files
# # static_dir = Path('./static')
# # static_dir.mkdir(parents=True, exist_ok=True)

# # # mount FastAPI StaticFiles server
# # app.mount("/static", StaticFiles(directory=static_dir), name="static")

# # Dynamically check for the Gradio asset directory
# # gradio_assets_path = os.path.join(os.path.dirname(gr.__file__), "static")

# # if os.path.exists(gradio_assets_path):
# #     # If assets exist, mount them
# #     app.mount("/assets", StaticFiles(directory=gradio_assets_path), name="assets")
# # else:
# #     logging.error(f"Gradio assets directory not found at: {gradio_assets_path}")

# # Redirect from the root endpoint to the Gradio app
# @app.get("/", response_class=RedirectResponse)
# async def index():
#     return RedirectResponse(url="/gradio", status_code=307)

# # Run the FastAPI server using uvicorn
# if __name__ == "__main__":
#     # port = int(os.getenv("PORT", 5000))  # Default to 7860 if PORT is not set
#     uvicorn.run(app, host="0.0.0.0", port=7860)