Upload 12 files

app_ui/admin_page.py

@@ -0,0 +1,74 @@
+import streamlit as st
+import os
+import base64
+from utils.utils import __get_new_user,app_config_col,encrypt_with_password,__encode, __update_user_config, __generate_password
+
+def load_user_config():
+
+    st.sidebar.header("Options")
+    page = st.sidebar.radio("Select Option", ["Validate New User", "Show User Details"],label_visibility="collapsed")
+
+    if page=="Validate New User":
+        new_users = __get_new_user()
+
+        # Initialize step index in session state
+        if "index" not in st.session_state:
+            st.session_state.index = 0
+
+
+        # --- Sidebar Profile Section ---
+        
+
+        st.title("User Information")
+
+        # Stop if finished
+        if st.session_state.index >= len(new_users):
+            st.success("User validation completed")
+            if st.button("Restart"):
+                st.session_state.index = 0
+                st.rerun()
+            st.stop()
+
+        # Show current item
+        current_user = new_users[st.session_state.index]
+        st.info("Username: **{}**".format(current_user.get("username")))
+        st.info("Email: **{}**".format(current_user.get("email")))
+        st.info("Token: **{}**".format(current_user.get("token")))
+        st.info("Validated By: **{}**".format(current_user.get("validated_by","Validation Not Completed")))
+        is_email_validated=st.selectbox(label="Is Email Validation Completed?",options=["Y", "N"])
+                
+
+        # User action area
+        st.write("Perform your action below:")
+
+        action_done = st.checkbox("TokenID is send to email:{}".format(current_user.get("email")))
+
+        # Next button
+        if st.button("Next"):
+
+            if not action_done:
+                st.warning("Please complete the action before continuing!")
+            else:
+                current_user['token']="1111"
+                current_user['validated_by']=st.session_state.user
+                current_user['_is_validated']= "Y" if is_email_validated=="Y" else "N"
+                current_user['_is_email_validated'] = is_email_validated
+
+                salt_bytes=base64.b64encode(app_config_col.get('SALT_KEY').encode("utf-8"))
+                app_api_key=app_config_col.get("APP_API_KEY")
+                enc = encrypt_with_password(app_api_key, salt_bytes, current_user)
+
+                __update_user_config(key=__encode(userinfo=current_user),value=enc)
+
+                st.session_state.index += 1
+                st.rerun()
+
+    if page=="Show User Details":
+        st.info("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
+
+    if st.sidebar.button("Logout"):
+        st.session_state.logged_in = False
+        st.session_state.user = None
+        st.session_state.show_audio = False
+        st.session_state.bg_started = False
+        st.rerun()

app_ui/app.py

@@ -0,0 +1,195 @@
+import streamlit as st
+import sys
+import os
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+from src.story_gen import generate_story
+from pathlib import Path
+import threading
+import time
+import base64
+
+# ------------------- WAV CLEANUP CONFIG -------------------
+WAV_FOLDER = "."   # Change to your folder name
+DELETE_AFTER_SECONDS = 300
+
+
+def delete_wav_files():
+    """Delete .wav files older than 1 hour."""
+    if not os.path.exists(WAV_FOLDER):
+        return
+
+    current_time = time.time()
+
+    for filename in os.listdir(WAV_FOLDER):
+        if filename.endswith(".wav"):
+            file_path = os.path.join(WAV_FOLDER, filename)
+
+            try:
+                file_age = current_time - os.path.getmtime(file_path)
+
+                if file_age > DELETE_AFTER_SECONDS:
+                    os.remove(file_path)
+                    print(f"[CLEANER] Deleted (older than 1 hr): {file_path}")
+
+            except Exception as e:
+                print(f"[CLEANER] Error deleting {file_path}: {e}")
+
+def background_cleaner():
+    """Runs every 1 minute."""
+    while True:
+        delete_wav_files()
+        time.sleep(60)
+
+
+
+
+def load_app():
+    # Start background cleaner only once
+    if "bg_started" not in st.session_state:
+        
+        threading.Thread(target=background_cleaner, daemon=True).start()
+        st.session_state.bg_started = True
+        print("[CLEANER] Background WAV cleaner started.")
+        
+
+    # # --- Sidebar Profile Section ---
+    # profile_image_path = os.path.join(os.path.dirname(__file__), "profile.png")
+
+    # # Read image safely
+    # encoded_img = None
+    # if os.path.exists(profile_image_path):
+    #     with open(profile_image_path, "rb") as img_file:
+    #         encoded_img = base64.b64encode(img_file.read()).decode()
+
+    # # Sidebar HTML (centered layout)
+    # sidebar_html = f"""
+    # <div style="text-align:center; margin-top:20px;">
+    #     <img src="data:image/png;base64,{encoded_img if encoded_img else ''}"
+    #         style="width:110px; height:110px; border-radius:50%; object-fit:cover; border:2px solid #ddd;">
+    #     <div style="margin-top:10px; font-size:16px; font-weight:600; color:#333;">
+    #         {"User:{}".format(st.session_state['user'])}
+    #     </div>
+    # </div>
+    # """
+    # st.sidebar.markdown(sidebar_html, unsafe_allow_html=True)
+
+
+    # # Centered logout button
+    # logout_style = """
+    #     <style>
+    #         div.stButton > button:first-child {
+    #             display: block;
+    #             margin: 10px auto;  
+    #             padding: 0.5rem 1rem;
+    #             border-radius: 8px;
+    #             font-size: 15px;
+    #         }
+    #     </style>
+    # """
+    # st.sidebar.markdown(logout_style, unsafe_allow_html=True)
+    st.sidebar.header("Options")
+    page = st.sidebar.radio("Select Option", ["Story Using One Line Plot", "Story Using Custom Plot"],label_visibility="collapsed")
+
+    if st.sidebar.button("Logout"):
+        st.session_state.logged_in = False
+        st.session_state.user = None
+        st.session_state.show_audio = False
+        st.session_state.bg_started = False
+        st.rerun()
+
+    if page == "Story Using One Line Plot":
+        # ------------------- STREAMLIT APP -------------------
+        st.set_page_config(
+            page_title="AI Story Generator",
+            page_icon="📚",
+            layout="wide"        # wide works best with no-scroll layouts
+        )
+
+        # ------------------- CSS: Fit Window + No Scroll -------------------
+        css = """
+        <style>
+
+        /* Remove scrolling */
+        html, body, [class*="css"] {
+            height: 100%;
+            overflow: hidden !important;
+        }
+
+        /* Reduce padding so content fits */
+        .block-container {
+            padding-top: 1rem !important;
+            padding-bottom: 1rem !important;
+            max-width: 900px;      /* keeps layout centered */
+            margin: auto;
+        }
+
+        /* Title spacing adjustment */
+        h1 {
+            margin-top: 0 !important;
+        }
+
+        </style>
+        """
+        st.markdown(css, unsafe_allow_html=True)
+
+        # ------------------- UI -------------------
+        st.title("📚 AI Story Generator")
+        st.write("Enter a story plot and let AI turn it into a full story!")
+
+        language = st.selectbox(
+                "Select language for audio:",
+                [
+                    ("English", "en"),
+                    ("Hindi", "hi"),
+                    ("Tamil", "ta"),
+                    ("Telugu", "te"),
+                    ("Bengali", "bn"),
+                    ("Gujarati", "gu"),
+                    ("Kannada", "kn"),
+                    ("Malayalam", "ml")
+                ],
+                format_func=lambda x: x[0]
+            )
+
+        plot = st.text_area("Enter your story plot:", height=150)
+
+        display_story = st.checkbox("Display Story")
+
+        generate = st.button("Generate Story")
+
+        config={}
+        config['lang']=language
+        config['user']=st.session_state['user']
+        if generate:
+                if not plot.strip():
+                    st.warning("Please enter a story plot.")
+                else:
+                    with st.spinner("Generating story... please wait ⏳"):
+
+                        response = generate_story(story_plot=plot, config=config)
+
+                        story = response.get("story")
+                        fileName = response.get("fileName")
+
+                    # Hold space for final audio output
+                    st.session_state["audio_file"] = fileName
+                    st.session_state["story_text"] = story
+                    st.session_state["show_audio"] = True
+
+        if st.session_state.get("show_audio", False):
+
+                st.markdown("---")
+                st.subheader("🔊 Generated Story Audio")
+
+                f = Path(st.session_state["audio_file"])
+                audio_bytes = f.read_bytes()
+                st.audio(audio_bytes, format="audio/wav")
+
+                if display_story:
+                    st.markdown("---")
+                    st.subheader("📖 Full Story")
+                    st.write(st.session_state["story_text"])
+    
+
+    if page == "Story Using Custom Plot":
+        st.info("Story Using Custom Plot Feature development in progress")

app_ui/index.py

@@ -0,0 +1,164 @@
+import streamlit as st
+from utils.utils import check_admin_login
+import asyncio
+import time
+
+def _index():
+    st.set_page_config(
+        page_title="Auth Page",
+        page_icon="🔐",
+        layout="wide"
+    )
+
+    # threading.Thread(target=__add_user_config, daemon=True).start()
+    # print("[CONFIG] Background user config update started.")
+
+    # --------------------------------------
+    # Initialize session state
+    # --------------------------------------
+    if "logged_in" not in st.session_state:
+        st.session_state.logged_in = False
+
+    # --------------------------------------
+    # If user is logged in → show main app
+    # --------------------------------------
+    if st.session_state.logged_in and st.session_state.admin_login:
+        from admin_page import load_user_config
+        load_user_config()
+        st.stop()
+
+    if st.session_state.logged_in:
+        from app import load_app
+        load_app()
+        st.stop()    # important: stop further execution
+
+    # --------------------------------------
+    # Otherwise show login UI
+    # --------------------------------------
+    st.sidebar.header("Options")
+    page = st.sidebar.radio("Select Option", ["Login", "Sign Up", "Admin Login"],label_visibility="collapsed")
+
+    # LOGIN PAGE
+    if page == "Login":
+        try:
+            st.subheader("🔐 Login")
+
+            # New checkbox
+            is_first_login = st.checkbox("Is First Login")
+
+            # Common inputs
+            username = st.text_input("Username")
+            password = st.text_input("Password", type="password")
+
+            # Conditional field
+            token = None
+            if is_first_login:
+                token = st.text_input("Token")
+
+            if st.button("Login"):
+                from utils.utils import is_authenticated
+
+                userinfo = {
+                    "username": username,
+                    "_access_key": password
+                }
+
+                # Add token only if first login
+                if is_first_login:
+                    userinfo["token"] = token
+
+                statuscode, message = asyncio.run(is_authenticated(userinfo=userinfo))
+
+                if statuscode == 0:
+                    st.session_state.admin_login=False
+                    st.session_state.logged_in = True
+                    st.session_state.user = username
+                    st.rerun()
+                    load_app()
+                else:
+                    st.error(message)
+        except Exception as e:
+            st.error(e)
+            st.error("Server Error while Login, please try after sometime")
+
+
+    # Sign Up
+
+    if page == "Sign Up":
+        try:
+            from utils.utils import _create_user
+            st.header("🧾 Sign Up")
+
+            # ---------- Reset ONLY when coming to this page ----------
+            if "current_page" not in st.session_state:
+                st.session_state.current_page = "Sign Up"
+
+            if st.session_state.current_page != "Sign Up":
+                # reset fields BEFORE widgets are drawn
+                st.session_state.email = ""
+                st.session_state.username = ""
+                st.session_state.password = ""
+                st.session_state.current_page = "Sign Up"
+
+            # ---------- Widgets ----------
+            email = st.text_input("Email", key="email")
+            username = st.text_input("Username", key="username")
+            password = st.text_input("Password", type="password", key="password")
+
+            user_info = {
+                "username": username,
+                "email": email,
+                "_access_key": password
+            }
+
+            all_filled = email.strip() and username.strip() and password.strip()
+
+            if all_filled:
+                if st.button("Create User"):
+                    statuscode, message = asyncio.run(_create_user(userinfo=user_info))
+                    if statuscode == 0:
+                        st.success(message)
+                        time.sleep(3)
+                        # Reset BEFORE next rerun, not after widgets created
+                        st.session_state.current_page = ""
+
+                        st.rerun()
+
+                    else:
+                        st.error(message)
+            else:
+                st.button("Create User", disabled=True)
+
+        except Exception as e:
+            st.error(e)
+            st.warning("Server is facing too many request, please try after sometime")
+
+    if page == "Admin Login":
+        try:
+            st.subheader("🔐 Admin Login")
+            # Common inputs
+            username = st.text_input("Username")
+            password = st.text_input("Password", type="password")
+            if st.button("Admin Login"):
+                from utils.utils import check_admin_login
+
+                userinfo = {
+                    "username": username,
+                    "password": password
+                }
+                statuscode, message = asyncio.run(check_admin_login(userinfo=userinfo))
+                if statuscode:
+                    st.session_state.logged_in = True
+                    st.session_state.admin_login = True
+                    st.session_state.user = username
+                    st.rerun()
+                    load_user_config()
+                else:
+                    st.error(message)
+        except Exception as e:
+            st.error(e)
+            st.error("Server Error while Login, please try after sometime")
+            
+                    
+
+_index()

app_ui/utils/utils.py

@@ -0,0 +1,227 @@
+from dotenv import load_dotenv
+import re
+import os
+import ast
+import base64
+import time
+
+from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+from cryptography.hazmat.primitives import hashes
+from cryptography.fernet import Fernet
+import hashlib
+import base64
+import random
+import string
+import certifi
+from pymongo import MongoClient
+
+
+#DB utils
+
+load_dotenv(override=True)
+uri = os.getenv('MONGO_DB_URL')
+client = MongoClient(uri,tlsCAFile=certifi.where())
+
+
+def __load_user_config():
+    db=client[os.getenv('CONFIG_DB')]
+    collection=db[os.getenv('USER_CONFIG')]
+    user_config=list(collection.find({},{"_id":0}))
+    return user_config
+
+
+def __load_app_config():
+    db=client[os.getenv('CONFIG_DB')]
+    collection=db[os.getenv('APP_CONFIG')]
+    app_config=list(collection.find({}))[0].get("_id")
+    return app_config
+
+def __add_user_config(key,value):
+    try:
+        db=client[os.getenv('CONFIG_DB')]
+        collection=db[os.getenv('USER_CONFIG')]
+        doc = {
+        "user_key": key,
+        "user_config": value,
+        }
+        result=collection.insert_one(document=doc)
+    except Exception as e:
+        raise Exception
+
+
+def __update_user_config(key,value):
+    db=client[os.getenv('CONFIG_DB')]
+    collection=db[os.getenv('USER_CONFIG')]
+    collection.update_one(
+        {"user_key":key},
+        { "$set": { "user_config": value } }
+    )
+
+app_config_col=__load_app_config()
+
+
+def __get_user_info(user_key):
+    user_config_col=__load_user_config()
+    user_info=[user for user in user_config_col if user.get('user_key')==user_key]
+    return user_info
+
+
+#encode-decode utils
+
+def __drive_key(master_password: str, salt: bytes) -> bytes:
+    kdf = PBKDF2HMAC(
+        algorithm=hashes.SHA256(),
+        length=32,
+        salt=salt,
+        iterations=390000,
+    )
+    return base64.urlsafe_b64encode(kdf.derive(master_password.encode()))
+    
+
+def encrypt_with_password(master_password: str, salt:bytes,user_info: dict):
+    key = __drive_key(master_password, salt)
+    token = Fernet(key).encrypt(user_info.__str__().encode())
+    token=token.decode("utf-8")
+    return token
+
+def decrypt_with_password(master_password: str, salt: bytes, encrypted_text: bytes):
+    key = __drive_key(master_password, salt)
+    decrypted = Fernet(key).decrypt(encrypted_text)
+    return decrypted.decode()
+
+
+def __encode(userinfo,k='email'):
+    h = hashlib.sha256(userinfo.get(k).encode()).hexdigest()
+    random.seed(h)
+    letters = string.ascii_letters
+    encoded = ''.join(random.choice(letters) for _ in range(32))
+    if k=='email':
+        return "kahini_lok_user_"+encoded
+    else:
+        return encoded
+
+def __decode_user_config(encrypted_txt):
+    salt_bytes=base64.b64encode(app_config_col.get("SALT_KEY").encode("utf-8"))
+    app_api_key=app_config_col.get("APP_API_KEY")
+    userconfig=decrypt_with_password(master_password=app_api_key,
+                                     salt=salt_bytes,
+                                     encrypted_text=encrypted_txt)
+    return userconfig
+
+def __generate_password(length=10):
+    characters = string.ascii_letters + string.digits
+    return ''.join(random.choice(characters) for _ in range(length))
+
+
+
+#app utils
+async def is_authenticated(userinfo):
+
+    username_encode=__encode(userinfo=userinfo,k="username")
+
+    user=__get_user_info(user_key=username_encode)
+    if len(user)==1:
+
+        encode_uuid=user[0].get("user_config")
+        user_config=__get_user_info(user_key=encode_uuid)
+        if len(user_config)==1:
+
+            userconfig=ast.literal_eval(__decode_user_config(user_config[0].get('user_config')))
+
+            if userconfig.get("_is_validated")=="N":
+                return 1, "User validation is in progress, Please try after sometime with tokenID send to your email"
+            
+            
+            if userconfig.get("_access_key")==userinfo.get("_access_key"):
+                if userconfig['_is_email_validated']=="N":
+                    return 1, "Email validation is in progress, Please try after sometime with tokenID send to your email"
+                if userconfig['_is_email_validated']=="Y" and userconfig['_is_first_login']=="Y":
+                    if userconfig.get("token")!=userinfo.get("token"):
+                        return 1, "Invaild token OTP , please try with token send to your email"
+                    else:
+                        salt_bytes=base64.b64encode(app_config_col.get("SALT_KEY").encode("utf-8"))
+                        app_api_key=app_config_col.get("APP_API_KEY")
+                        userconfig['_is_first_login']='N'
+                        enc=encrypt_with_password(master_password=app_api_key,salt=salt_bytes,user_info=userconfig)
+                        __update_user_config(key=encode_uuid,value=enc)
+                        return 0, "Successful Login"
+
+                return 0, "Successful Login"
+            
+            if userconfig.get("_access_key")!=userinfo.get("_access_key"):
+                return 1, "Invalid password"
+        else:
+             return 1, "Username does not exists"
+            
+    else:
+        return 1, "Username does not exists"
+
+
+def is_valid_email(email):
+    vaild_domain=['gmail','yahoo','outlook']
+    domain=email.split(".")[0].split("@")[1]
+    provider=email.split(".")[1]
+    if domain in vaild_domain and provider == 'com':
+        pattern = r"^[\w\.-]+@[\w\.-]+\.\w+$"
+        return re.match(pattern, email) is not None
+    else:
+        return False
+
+def is_user_exists(userinfo:dict,k):
+    user=__get_user_info(__encode(userinfo=userinfo,k=k))
+    if len(user)>0:
+        return 1
+    else:
+        return 0
+
+
+async def _create_user(userinfo):
+
+    try:
+
+        if not is_valid_email(userinfo.get("email")):
+            return 1, "Invaild email ID"
+
+        if is_user_exists(userinfo=userinfo,k="email")==0:
+            if is_user_exists(userinfo=userinfo,k="username")==0:
+                salt_bytes=base64.b64encode(app_config_col.get('SALT_KEY').encode("utf-8"))
+                app_api_key=app_config_col.get("APP_API_KEY")
+
+                userinfo['_is_validated']="N"
+                userinfo['_is_email_validated']="N"
+                userinfo['_is_first_login']='Y'
+                userinfo['token']=__generate_password()
+
+                enc = encrypt_with_password(app_api_key, salt_bytes, userinfo)
+                __add_user_config(key=__encode(userinfo=userinfo),value=enc)
+                __add_user_config(key=__encode(userinfo=userinfo,k='username'),value=__encode(userinfo=userinfo))
+
+                return 0, """Account created successfully!\nYour username is {}.Login credentials will be delivered to {} within 2–3 hours, Use it for 1st time login""".format(userinfo.get("username"),
+                                                                                             userinfo.get("email"))
+            
+            else:
+                return 1, """Username already exists, please use different username"""
+        else:
+            return 1, """User already exists with this email, please used different email"""
+    except Exception as e:
+        #TODO
+        return 1, """Unable to create user, please try after sometime"""
+    
+
+
+def __get_new_user():
+    
+    new_user_list=[]
+    
+    for user in __load_user_config():
+        if user.get("user_key").startswith("kahini_lok_user"):
+            new_user_list.append(ast.literal_eval(__decode_user_config(encrypted_txt=user.get("user_config"))))
+
+    return [new_user for new_user in new_user_list if new_user['_is_validated']=="N"]
+        
+
+async def check_admin_login(userinfo):
+    if userinfo.get("username")==app_config_col.get("APP_ADMIN") and userinfo.get("password")==app_config_col.get("ADMIN_KEY"):
+        return True, "Successful Login"
+    else:
+        return False, "Invalid credentials"