Rename BotRite.ipynb to app.py

BotRite.ipynb

@@ -1,567 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "id": "c61d3ebd",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Running on local URL:  http://127.0.0.1:7874\n",
-      "\n",
-      "To create a public link, set `share=True` in `launch()`.\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "<div><iframe src=\"http://127.0.0.1:7874/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Traceback (most recent call last):\n",
-      "  File \"C:\\Users\\bjawa\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\gradio\\routes.py\", line 401, in run_predict\n",
-      "    output = await app.get_blocks().process_api(\n",
-      "             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
-      "  File \"C:\\Users\\bjawa\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\gradio\\blocks.py\", line 1305, in process_api\n",
-      "    data = self.postprocess_data(fn_index, result[\"prediction\"], state)\n",
-      "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
-      "  File \"C:\\Users\\bjawa\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\gradio\\blocks.py\", line 1209, in postprocess_data\n",
-      "    self.validate_outputs(fn_index, predictions)  # type: ignore\n",
-      "    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
-      "  File \"C:\\Users\\bjawa\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\gradio\\blocks.py\", line 1184, in validate_outputs\n",
-      "    raise ValueError(\n",
-      "ValueError: An event handler (loadbotdataasdf) didn't receive enough output values (needed: 2, received: 1).\n",
-      "Wanted outputs:\n",
-      "    [dataframe, dropdown]\n",
-      "Received outputs:\n",
-      "    [None]\n",
-      "Traceback (most recent call last):\n",
-      "  File \"C:\\Users\\bjawa\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\gradio\\routes.py\", line 401, in run_predict\n",
-      "    output = await app.get_blocks().process_api(\n",
-      "             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
-      "  File \"C:\\Users\\bjawa\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\gradio\\blocks.py\", line 1305, in process_api\n",
-      "    data = self.postprocess_data(fn_index, result[\"prediction\"], state)\n",
-      "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
-      "  File \"C:\\Users\\bjawa\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\gradio\\blocks.py\", line 1209, in postprocess_data\n",
-      "    self.validate_outputs(fn_index, predictions)  # type: ignore\n",
-      "    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
-      "  File \"C:\\Users\\bjawa\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\gradio\\blocks.py\", line 1184, in validate_outputs\n",
-      "    raise ValueError(\n",
-      "ValueError: An event handler (loadbotdataasdf) didn't receive enough output values (needed: 2, received: 1).\n",
-      "Wanted outputs:\n",
-      "    [dataframe, dropdown]\n",
-      "Received outputs:\n",
-      "    [None]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Bot1\n",
-      "                                                                b1\n",
-      "Bot_Handle_Name                                                 b1\n",
-      "Bot_Image        C:\\Users\\bjawa\\AppData\\Local\\Temp\\3e5bb8de0c29...\n",
-      "Bot_Name                                                      Bot1\n",
-      "Created_Time                                   05/07/2023 20:53:23\n",
-      "Created_by                                                 Jawahar\n",
-      "Initial_Message                                               test\n",
-      "Intro_Message                                                 test\n",
-      "OpenAI_API_key                                                test\n",
-      "Organizationame                                          Cognizant\n",
-      "Rules                                                         test\n",
-      "Tools                                                     [OpenAI]\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Traceback (most recent call last):\n",
-      "  File \"C:\\Users\\bjawa\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\gradio\\routes.py\", line 401, in run_predict\n",
-      "    output = await app.get_blocks().process_api(\n",
-      "             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
-      "  File \"C:\\Users\\bjawa\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\gradio\\blocks.py\", line 1302, in process_api\n",
-      "    result = await self.call_function(\n",
-      "             ^^^^^^^^^^^^^^^^^^^^^^^^^\n",
-      "  File \"C:\\Users\\bjawa\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\gradio\\blocks.py\", line 1025, in call_function\n",
-      "    prediction = await anyio.to_thread.run_sync(\n",
-      "                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
-      "  File \"C:\\Users\\bjawa\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\anyio\\to_thread.py\", line 31, in run_sync\n",
-      "    return await get_asynclib().run_sync_in_worker_thread(\n",
-      "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
-      "  File \"C:\\Users\\bjawa\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\anyio\\_backends\\_asyncio.py\", line 937, in run_sync_in_worker_thread\n",
-      "    return await future\n",
-      "           ^^^^^^^^^^^^\n",
-      "  File \"C:\\Users\\bjawa\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\anyio\\_backends\\_asyncio.py\", line 867, in run\n",
-      "    result = context.run(func, *args)\n",
-      "             ^^^^^^^^^^^^^^^^^^^^^^^^\n",
-      "  File \"C:\\Users\\bjawa\\AppData\\Local\\Temp\\ipykernel_2208\\3954756524.py\", line 164, in upload_file\n",
-      "    shutil.copy(file_paths, path)\n",
-      "  File \"C:\\Users\\bjawa\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\shutil.py\", line 419, in copy\n",
-      "    copyfile(src, dst, follow_symlinks=follow_symlinks)\n",
-      "  File \"C:\\Users\\bjawa\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\shutil.py\", line 235, in copyfile\n",
-      "    if _samefile(src, dst):\n",
-      "       ^^^^^^^^^^^^^^^^^^^\n",
-      "  File \"C:\\Users\\bjawa\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\shutil.py\", line 212, in _samefile\n",
-      "    return os.path.samefile(src, dst)\n",
-      "           ^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
-      "  File \"<frozen genericpath>\", line 100, in samefile\n",
-      "TypeError: stat: path should be string, bytes, os.PathLike or integer, not list\n"
-     ]
-    }
-   ],
-   "source": [
-    "import numpy as np\n",
-    "import gradio as gr\n",
-    "import json\n",
-    "import socket\n",
-    "import os\n",
-    "from datetime import datetime\n",
-    "import pandas as pd\n",
-    "from langchain.chains import RetrievalQA\n",
-    "from langchain.llms import OpenAI\n",
-    "from langchain.document_loaders import TextLoader\n",
-    "from langchain.document_loaders import PyPDFLoader\n",
-    "from langchain.indexes import VectorstoreIndexCreator\n",
-    "from langchain.text_splitter import CharacterTextSplitter\n",
-    "from langchain.embeddings import OpenAIEmbeddings\n",
-    "from langchain.vectorstores import Chroma\n",
-    "from langchain.chains import ConversationalRetrievalChain\n",
-    "import shutil\n",
-    "demo = gr.Blocks()\n",
-    "options_org=[]\n",
-    "options_bot=['','','']\n",
-    "\n",
-    "\n",
-    "isExist = os.path.exists(\"Organizations\")\n",
-    "if(isExist==False):\n",
-    "    os.mkdir(\"Organizations\")\n",
-    "    \n",
-    "if(os.path.isfile('Organizationdetails.json')):\n",
-    "    #Getting organization name\n",
-    "    f = open('Organizationdetails.json', encoding='utf-8', errors='ignore')\n",
-    "    data = json.load(f,strict=False)\n",
-    "    for p_id, p_info in data.items():\n",
-    "        options_org.append(p_id)\n",
-    "    f.close()\n",
-    "    \n",
-    "    \n",
-    "if(os.path.isfile('Botdetails.json')):\n",
-    "    #Getting organization name\n",
-    "    f1 = open('Botdetails.json')\n",
-    "    data = json.load(f1)\n",
-    "    for p_id, p_info in data.items():\n",
-    "        options_bot.append(p_id)\n",
-    "    f1.close()\n",
-    "    \n",
-    "\n",
-    "def Create_Organization(org_name, org_handle):\n",
-    "    \n",
-    "    o=org_handle\n",
-    "    path = o\n",
-    "    isExist = os.path.exists(path)\n",
-    "    hostname=socket.gethostname()\n",
-    "    now = datetime.now()\n",
-    "    tim=now.strftime(\"%d/%m/%Y %H:%M:%S\")\n",
-    "    Organizationdetails={}\n",
-    "    Organization_required_details = [\"Organizationame\",\"OrganizationHandle\" \"Created_by\", \"Created_Time\"]\n",
-    "    Organizationdetails[org_handle] = {}\n",
-    "    Organizationdetails[org_handle]['Organizationame']=org_name\n",
-    "    Organizationdetails[org_handle]['OrganizationHandle']=org_handle\n",
-    "    Organizationdetails[org_handle]['Created_by']=hostname\n",
-    "    Organizationdetails[org_handle]['Created_Time']=tim\n",
-    "    isfileE = os.path.isfile(\"Organizationdetails.json\")\n",
-    "    if isfileE: #If file present \"rb\" and w\n",
-    "        with open('Organizationdetails.json', 'rb') as txtfile:\n",
-    "                d=json.load(txtfile)\n",
-    "                d.update(Organizationdetails)\n",
-    "                for p_id, p_info in d.items():\n",
-    "                    options_org.append(p_id)\n",
-    "        with open('Organizationdetails.json', 'w') as txtfile:        \n",
-    "                json.dump(d, txtfile)\n",
-    "                if not isExist: #create folder for working\n",
-    "                    os.makedirs(os.path.join('Organizations', org_handle))\n",
-    "    else: #if file not present then create with 'w'\n",
-    "        with open('Organizationdetails.json', 'w') as txtfile:  \n",
-    "                json.dump(Organizationdetails, txtfile)\n",
-    "                if not isExist: #create folder for working\n",
-    "                    os.makedirs(os.path.join('Organizations', org_handle)) \n",
-    "    return \"Organization Created : \"+ o\n",
-    "\n",
-    "def clear():\n",
-    "    return None, None, None\n",
-    "\n",
-    "def Create_Bot(Organizationame,Bot_Name,Bot_Handle_Name,Bot_Image,Tools,OpenAI_API_key,\n",
-    "                           Initial_Message,Intro_Message,Rules):\n",
-    "    \n",
-    "    botim =Bot_Image.name\n",
-    "    print(Bot_Name)\n",
-    "    b=Bot_Handle_Name\n",
-    "    bo=Organizationame\n",
-    "    hostname=socket.gethostname()\n",
-    "    now = datetime.now()\n",
-    "    tim=now.strftime(\"%d/%m/%Y %H:%M:%S\")    \n",
-    "    Botdetails = { }\n",
-    "    Bot_required_details = [\"Bot_Name\", \"Organizationame\", \"Created_by\", \"Created_Time\",\"Bot_Handle_Name\",\"Bot_Image\",\"Tools\",\"OpenAI_API_key\",\n",
-    "                           \"Initial_Message\",\"Intro_Message\",\"Rules\"]\n",
-    "    Botdetails[Bot_Handle_Name] = {}\n",
-    "    Botdetails[Bot_Handle_Name]['Bot_Name']=Bot_Name\n",
-    "    Botdetails[Bot_Handle_Name]['Organizationame']=Organizationame\n",
-    "    Botdetails[Bot_Handle_Name]['Created_by']=hostname\n",
-    "    Botdetails[Bot_Handle_Name]['Created_Time']=tim\n",
-    "    Botdetails[Bot_Handle_Name]['Bot_Handle_Name']=Bot_Handle_Name\n",
-    "    Botdetails[Bot_Handle_Name]['Bot_Image']=botim\n",
-    "    Botdetails[Bot_Handle_Name]['Tools']=Tools\n",
-    "    Botdetails[Bot_Handle_Name]['OpenAI_API_key']=OpenAI_API_key\n",
-    "    Botdetails[Bot_Handle_Name]['Initial_Message']=Initial_Message\n",
-    "    Botdetails[Bot_Handle_Name]['Intro_Message']=Intro_Message\n",
-    "    Botdetails[Bot_Handle_Name]['Rules']=Rules\n",
-    "    path = os.path.join(os.getcwd()+'\\\\Organizations\\\\', Organizationame,Bot_Name)\n",
-    "    Inputpath = os.path.join(os.getcwd()+'\\\\Organizations\\\\', Organizationame,Bot_Name,'Inputs')\n",
-    "    Outputpath = os.path.join(os.getcwd()+'\\\\Organizations\\\\', Organizationame,Bot_Name,'Outputs')\n",
-    "   \n",
-    "    isExist = os.path.exists(path)\n",
-    "\n",
-    "    pp=os.path.join('Organizations',Organizationame+'\\\\Botdetails.json')\n",
-    "\n",
-    "    isfileE = os.path.isfile(pp)\n",
-    "    if isfileE: #If file present \"rb\" and 'w'\n",
-    "        with open(pp, 'rb') as txtfile:\n",
-    "                d=json.load(txtfile)\n",
-    "                d.update(Botdetails)\n",
-    "        with open(pp, 'w') as txtfile:        \n",
-    "                json.dump(d, txtfile)\n",
-    "                if not isExist:\n",
-    "                    os.makedirs(path)\n",
-    "                    os.makedirs(Inputpath) \n",
-    "                    os.makedirs(Outputpath) \n",
-    "    else: #if file not present then create with 'w'\n",
-    "        with open(pp, 'w') as txtfile:  \n",
-    "                json.dump(Botdetails, txtfile)\n",
-    "                if not isExist:\n",
-    "                    os.makedirs(path)\n",
-    "                    os.makedirs(Inputpath) \n",
-    "                    os.makedirs(Outputpath) \n",
-    "    return \"Bot Created : \" + b +\" in \"+bo +\" Organization \"\n",
-    "\n",
-    "\n",
-    "\n",
-    "\n",
-    "def loadbotdata(SelectOrganizationame):\n",
-    "    new=[]\n",
-    "    if(os.path.isfile(os.getcwd()+'\\\\Organizations\\\\'+SelectOrganizationame+'\\\\Botdetails.json')):\n",
-    "        fd = open(os.getcwd()+'\\\\Organizations\\\\'+SelectOrganizationame+'\\\\Botdetails.json')\n",
-    "        data = json.load(fd)\n",
-    "        for p_id, p_info in data.items():\n",
-    "            new.append(p_id)\n",
-    "        #return new\n",
-    "        return gr.update(choices=new, value=new[0])\n",
-    "\n",
-    "\n",
-    "def loadbotdataasdf(SelectOrganizationame):\n",
-    "    df=[]\n",
-    "    new=[]\n",
-    "    if(os.path.isfile(os.getcwd()+'\\\\Organizations\\\\'+SelectOrganizationame+'\\\\Botdetails.json')):\n",
-    "        fl = open(os.getcwd()+'\\\\Organizations\\\\'+SelectOrganizationame+'\\\\Botdetails.json')\n",
-    "        data = json.load(fl)\n",
-    "        df = pd.DataFrame.from_dict(data, orient='columns')\n",
-    "        print (df)\n",
-    "        for p_id, p_info in data.items():\n",
-    "            new.append(p_id)\n",
-    "        return df,gr.update(choices=new, value=new[0]) \n",
-    "\n",
-    "def upload_file(org, bot , files):\n",
-    "    file_paths = [file.name for file in files]\n",
-    "    allfiles=file_paths\n",
-    "    path = os.path.join(os.getcwd()+'\\\\Organizations\\\\', org,bot,'Inputs')\n",
-    "    shutil.copy(file_paths.name, path)\n",
-    "    return file_paths\n",
-    "    \n",
-    "def train(files):\n",
-    "    for file in files:\n",
-    "        print(file.name)\n",
-    "        if file.name.endswith(\".pdf\"):\n",
-    "            loader = PyPDFLoader(file.name)\n",
-    "            documents = loader.load()\n",
-    "    return \"Training Done\"\n",
-    "chat_history = []\n",
-    "\n",
-    "def construct_index(directory_path):\n",
-    "    file_paths=[]\n",
-    "    for root, directories, files in os.walk(directory_path):\n",
-    "        for file_name in files:\n",
-    "            file_path = os.path.join(root, file_name)\n",
-    "            file_paths.append(file_path)\n",
-    "\n",
-    "\n",
-    "    for file in file_paths:        \n",
-    "        if file.endswith(\".pdf\"):\n",
-    "            loader = PyPDFLoader(file)\n",
-    "            documents = loader.load()\n",
-    "    return documents\n",
-    "\n",
-    "\n",
-    "def chatbot(input_text):\n",
-    "    global chat_history\n",
-    "    query = input_text\n",
-    "    text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)\n",
-    "    texts = text_splitter.split_documents(documents)\n",
-    "    embeddings = OpenAIEmbeddings()\n",
-    "    db = Chroma.from_documents(texts, embeddings)\n",
-    "    retriever = db.as_retriever(search_type=\"similarity\", search_kwargs={\"k\":2})\n",
-    "    vectordbkwargs = {\"search_distance\": 0.9}\n",
-    "    qa = ConversationalRetrievalChain.from_llm(OpenAI(), retriever,return_source_documents=True)\n",
-    "    print(chat_history)\n",
-    "    if chat_history==[]:\n",
-    "        result = qa({\"question\": query,\"chat_history\": chat_history, \"vectordbkwargs\": {\"search_distance\": 0.9}})\n",
-    "    else:\n",
-    "        result = qa({\"question\": query, \"chat_history\": chat_history, \"vectordbkwargs\": {\"search_distance\": 0.9}})\n",
-    "    chat_history = [(query, result[\"answer\"])]\n",
-    "    return result[\"answer\"]\n",
-    "\n",
-    "\n",
-    "with demo:\n",
-    "    gr.Markdown(\"BotRite\")\n",
-    "                                       \n",
-    "    with gr.Tabs() :\n",
-    "        with gr.TabItem(\"ChatBot\"):\n",
-    "            with gr.Row():\n",
-    "                SelectOrg = gr.Dropdown(options_org ,label=\"Select Organization\" )\n",
-    "                \n",
-    "            with gr.Row():\n",
-    "                Selectbot = gr.Dropdown( label=\"Select Bot\" ,choices=options_bot,\n",
-    "                                                value=options_bot[0], interactive=True)\n",
-    "               # Selectbot = gr.Radio(options_bot ,label=\"Select Bot\")\n",
-    "                \n",
-    "            with gr.Column():\n",
-    "                query_input = gr.Textbox(lines=7, label=\"Enter your text\")\n",
-    "                ask_button = gr.Button(\"Ask\")\n",
-    "        with gr.TabItem(\"Settings\"):\n",
-    "            with gr.Tabs():\n",
-    "            \n",
-    "                with gr.TabItem(\"Create Organization:\"):\n",
-    "                    with gr.Row():\n",
-    "                            org_name = gr.Textbox(label=\"Name\",info=\"Your name / Nickname\",placeholder=\"Enter you organization full name\")\n",
-    "                            org_handle = gr.Textbox(label=\"Handle Name\",info=\"Your unique organization name\", placeholder=\"Enter Organization handle name\")\n",
-    "                            output_org =gr.Textbox(label='Status')\n",
-    "                    with gr.Row():\n",
-    "                        Createorg_button = gr.Button(\"Create Organization\")\n",
-    "                        Clearorg_button = gr.Button(\"Clear\", variant=\"stop\")\n",
-    "                        \n",
-    "                with gr.TabItem(\"Bot Details\"):\n",
-    "                    SelectOrganizationame = gr.Dropdown(options_org, label=\"Select Organization\")\n",
-    "                    with gr.Tabs():\n",
-    "                            with gr.TabItem(\"Your Bots:\"):\n",
-    "                                with gr.Row():\n",
-    "                                    with gr.Column():\n",
-    "                                        #SelectOrganizationame = gr.components.Dropdown(options_org, label=\"Select Organization\")\n",
-    "                                        botdf=gr.Dataframe(headers=[\"Bot_Name\", \"Organizationame\", \"Created_by\", \"Created_Time\",\"Bot_Handle_Name\",\"Bot_Image\",\"Tools\",\"OpenAI_API_key\",\n",
-    "                                       \"Initial_Message\",\"Intro_Message\",\"Rules\"], label=\"Bot Details\")\n",
-    "                                        \n",
-    "                            with gr.TabItem(\"Create Bot:\"):      \n",
-    "                                \n",
-    "                                        Organizationame =SelectOrganizationame\n",
-    "                                        botname = gr.Textbox(label=\"Bot Name\",info=\"Your bot name / Nickname\", placeholder=\"Enter bot full name\")\n",
-    "                                        bothandle = gr.Textbox(label=\"Bot Handle Name\",info=\"Your unique bot name\" ,placeholder=\"Enter bot handle name\")\n",
-    "                                        image_button = gr.File(label=\"Select bot image\")\n",
-    "                                        botllm = gr.components.CheckboxGroup(['OpenAI', 'Dolly', 'Q&A Model'],label=\"Tools\")\n",
-    "                                       # model = gr.components.Dropdown(Options1, label=\"Model\")\n",
-    "                                        openai_key = gr.Textbox(label=\"You OpenAI API key\", type=\"password\" , info=\"Add your OpenAi Key click the link to create new or copy exsisting key from your openai account https://platform.openai.com/account/api-keys\")\n",
-    "                                        initailsmsg = gr.Textbox(label=\"Initial Message\", placeholder=\"This message will be shared by bot as intro​\" , info=\"This message will be shared by bot as intro​\")\n",
-    "                                        intromsg = gr.Textbox(label=\"Intro Message\", placeholder=\"This message will be sent to bot as prefix to  first message​\", info=\"This message will be sent to bot as prefix to  first message​\")\n",
-    "                                        rules = gr.Textbox(label=\"Rules\", placeholder=\"These rules will be sent to bot as prefix to  first message (after introduction)​\", info=\"These rules will be sent to bot as prefix to  first message (after introduction)​\")\n",
-    "                                        output_bot =gr.Textbox(label='Status')\n",
-    "                                        Createbot_button = gr.Button(\"Create Bot\")   \n",
-    "                            with gr.TabItem(\"Bot Configuration\"):\n",
-    "                                Selectbotconfig = gr.Dropdown(label=\"Select Bot\",choices=options_bot,\n",
-    "                                                value=options_bot[0], interactive=True)\n",
-    "                                with gr.TabItem(\"Load Data\"):\n",
-    "                                    with gr.Row():\n",
-    "                                        with gr.Column():\n",
-    "                                            Train_Fileselect_button = gr.UploadButton(\"Upload PDF Files\", file_types=[\".pdf\"], file_count=\"multiple\")\n",
-    "                                            file_output = gr.File()\n",
-    "                                        with gr.Column():   \n",
-    "                                            Train_button = gr.Button(\"Train Data\")\n",
-    "                                            Train_output =gr.Textbox(label='Status')\n",
-    "\n",
-    "                                with gr.TabItem(\"Chat with your bot\"):\n",
-    "                                    with gr.Row():\n",
-    "                                        with gr.Column():\n",
-    "                                            query_input = gr.Textbox(lines=7, label=\"Enter your text\")\n",
-    "                                            ask_button = gr.Button(\"Ask\")\n",
-    "                                        with gr.Column():\n",
-    "                                            text_output=gr.Text(label=\"Your Bot Answer\")\n",
-    "                                with gr.TabItem(\"Deploy\"):\n",
-    "                                      with gr.Row():\n",
-    "                                            archive_button = gr.Button(\"Archive\")\n",
-    "                                            publish_button = gr.Button(\"Publish\")\n",
-    "                                with gr.TabItem(\"Logs\"):\n",
-    "                                      with gr.Column():\n",
-    "                                            Selectlog = gr.Dropdown( label=\"Select Log\")\n",
-    "                                            logview = gr.Text(label=\"Log\")\n",
-    "    #def Dropdown_Org(x):\n",
-    "   \n",
-    "    SelectOrg.change(fn=loadbotdata, inputs=SelectOrg,outputs=Selectbot )  \n",
-    "    SelectOrganizationame.change(fn=loadbotdataasdf, inputs=SelectOrganizationame,outputs=[botdf,Selectbotconfig])  \n",
-    "    Createorg_button.click(fn=Create_Organization,inputs=[org_name, org_handle], outputs=output_org)\n",
-    "\n",
-    "    Clearorg_button.click(lambda : [None,None,None], inputs=None, outputs=[org_name,org_handle,output_org]) \n",
-    "    Createbot_button.click(fn=Create_Bot,inputs=[Organizationame, botname, bothandle,image_button,botllm,openai_key,initailsmsg,intromsg,rules], outputs=output_bot)\n",
-    "    \n",
-    "    Train_Fileselect_button.upload(upload_file,inputs=[SelectOrganizationame, Selectbotconfig,Train_Fileselect_button], outputs=[file_output])\n",
-    "    Train_button.click(fn=train,inputs=Train_Fileselect_button, outputs=Train_output)\n",
-    "    \n",
-    "demo.launch()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "073c8125",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\n",
-    "\n",
-    "def generate_data():\n",
-    "    # Mutate here\n",
-    "    dd.choices = [x for x in range(10)]\n",
-    "    return gr.update(choices = [x for x in range(10)])\n",
-    "\n",
-    "with gr.Blocks() as demo:\n",
-    "    bttn.click(\n",
-    "        fn = generate_data,\n",
-    "        outputs = dd\n",
-    "       )\n",
-    "    \n",
-    "d = gr.Dropdown(render=False)\n",
-    "bttn = gr.Button(render=False)\n",
-    "demo.launch()\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "05603510",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import gradio as gr\n",
-    "\n",
-    "def mock_ocr(f):\n",
-    "    return [[1, 2, 3], [4, 5, 6]]\n",
-    "\n",
-    "def export_csv(d):\n",
-    "    d.to_csv(\"output.csv\")\n",
-    "    return gr.File.update(value=\"output.csv\", visible=True)\n",
-    "\n",
-    "with gr.Blocks() as demo:\n",
-    "    with gr.Row():\n",
-    "        file = gr.File(label=\"PDF file\", file_types=[\".pdf\"])\n",
-    "        dataframe = gr.Dataframe()\n",
-    "        \n",
-    "        with gr.Column():\n",
-    "            button = gr.Button(\"Export\")\n",
-    "            csv = gr.File(interactive=False, visible=False)\n",
-    "            \n",
-    "            \n",
-    "    file.change(mock_ocr, file, dataframe)\n",
-    "    button.click(export_csv, dataframe, csv)\n",
-    "        \n",
-    "demo.launch()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "3ee5af32",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pinecone --> Cost\n",
-    "\n",
-    "chromadb --(for both openai & q&a)  -->\n",
-    "OpenAIEmbeddings\n",
-    "\n",
-    "\n",
-    "Q&A --->i/p=---> Embeddings ----> Bert ---> Answers\n",
-    "\n",
-    "Openai --->i/p--> Embeddings--->(Storage system for openai ) ---> Openai api key ---> Answers\n",
-    "\n",
-    "\n",
-    "\n",
-    "Pdf:\n",
-    "    \n",
-    "    Editable --> Ok\n",
-    "    Table --> Ok\n",
-    "    Image , Screen shot etc--> Not working (Image processing opencv , Pytessarct  , Ocr ) (LG.pdf)\n",
-    "            chatpdf.io \n",
-    "            pdf.ai\n",
-    "    ilovepdf --> merge,editing \n",
-    "    \n",
-    "\n",
-    "    pypdf --> Identify the image in every pdf and apply the logic (Image -> Text -> Pg no)\n",
-    "\n",
-    "Ajay , Rahul :   \n",
-    "    \n",
-    "Container - Docker (Rahul)  \n",
-    "Cloud - AWS (Rahul)\n",
-    "Frontend --   react  (Ajay)\n",
-    "Backend  ---> Django rest api DRF  (Ajay) \n",
-    "\n",
-    "            api --> Modules (Python )\n",
-    "            creation org(api) (Rahul) (Gradio already present)\n",
-    "            creation bot(api)\n",
-    "            Image to text (LG.pdf) (rahul)\n",
-    "            \n",
-    "\n",
-    "Database ->  Postgres  (Ajay), chroma (rahul)\n",
-    "    \n",
-    "    "
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.0"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

app.py

@@ -0,0 +1,362 @@
+import numpy as np
+import gradio as gr
+import json
+import socket
+import os
+from datetime import datetime
+import pandas as pd
+from langchain.chains import RetrievalQA
+from langchain.llms import OpenAI
+from langchain.document_loaders import TextLoader
+from langchain.document_loaders import PyPDFLoader
+from langchain.indexes import VectorstoreIndexCreator
+from langchain.text_splitter import CharacterTextSplitter
+from langchain.embeddings import OpenAIEmbeddings
+from langchain.vectorstores import Chroma
+from langchain.chains import ConversationalRetrievalChain
+import shutil
+demo = gr.Blocks()
+options_org=[]
+options_bot=['','','']
+
+
+isExist = os.path.exists("Organizations")
+if(isExist==False):
+    os.mkdir("Organizations")
+    
+if(os.path.isfile('Organizationdetails.json')):
+    #Getting organization name
+    f = open('Organizationdetails.json', encoding='utf-8', errors='ignore')
+    data = json.load(f,strict=False)
+    for p_id, p_info in data.items():
+        options_org.append(p_id)
+    f.close()
+    
+    
+if(os.path.isfile('Botdetails.json')):
+    #Getting organization name
+    f1 = open('Botdetails.json')
+    data = json.load(f1)
+    for p_id, p_info in data.items():
+        options_bot.append(p_id)
+    f1.close()
+    
+
+def Create_Organization(org_name, org_handle):
+    
+    o=org_handle
+    path = o
+    isExist = os.path.exists(path)
+    hostname=socket.gethostname()
+    now = datetime.now()
+    tim=now.strftime("%d/%m/%Y %H:%M:%S")
+    Organizationdetails={}
+    Organization_required_details = ["Organizationame","OrganizationHandle" "Created_by", "Created_Time"]
+    Organizationdetails[org_handle] = {}
+    Organizationdetails[org_handle]['Organizationame']=org_name
+    Organizationdetails[org_handle]['OrganizationHandle']=org_handle
+    Organizationdetails[org_handle]['Created_by']=hostname
+    Organizationdetails[org_handle]['Created_Time']=tim
+    isfileE = os.path.isfile("Organizationdetails.json")
+    if isfileE: #If file present "rb" and w
+        with open('Organizationdetails.json', 'rb') as txtfile:
+                d=json.load(txtfile)
+                d.update(Organizationdetails)
+                for p_id, p_info in d.items():
+                    options_org.append(p_id)
+        with open('Organizationdetails.json', 'w') as txtfile:        
+                json.dump(d, txtfile)
+                if not isExist: #create folder for working
+                    os.makedirs(os.path.join('Organizations', org_handle))
+    else: #if file not present then create with 'w'
+        with open('Organizationdetails.json', 'w') as txtfile:  
+                json.dump(Organizationdetails, txtfile)
+                if not isExist: #create folder for working
+                    os.makedirs(os.path.join('Organizations', org_handle)) 
+    return "Organization Created : "+ o
+
+def clear():
+    return None, None, None
+
+def Create_Bot(Organizationame,Bot_Name,Bot_Handle_Name,Bot_Image,Tools,OpenAI_API_key,
+                           Initial_Message,Intro_Message,Rules):
+    
+    botim =Bot_Image.name
+    print(Bot_Name)
+    b=Bot_Handle_Name
+    bo=Organizationame
+    hostname=socket.gethostname()
+    now = datetime.now()
+    tim=now.strftime("%d/%m/%Y %H:%M:%S")    
+    Botdetails = { }
+    Bot_required_details = ["Bot_Name", "Organizationame", "Created_by", "Created_Time","Bot_Handle_Name","Bot_Image","Tools","OpenAI_API_key",
+                           "Initial_Message","Intro_Message","Rules"]
+    Botdetails[Bot_Handle_Name] = {}
+    Botdetails[Bot_Handle_Name]['Bot_Name']=Bot_Name
+    Botdetails[Bot_Handle_Name]['Organizationame']=Organizationame
+    Botdetails[Bot_Handle_Name]['Created_by']=hostname
+    Botdetails[Bot_Handle_Name]['Created_Time']=tim
+    Botdetails[Bot_Handle_Name]['Bot_Handle_Name']=Bot_Handle_Name
+    Botdetails[Bot_Handle_Name]['Bot_Image']=botim
+    Botdetails[Bot_Handle_Name]['Tools']=Tools
+    Botdetails[Bot_Handle_Name]['OpenAI_API_key']=OpenAI_API_key
+    Botdetails[Bot_Handle_Name]['Initial_Message']=Initial_Message
+    Botdetails[Bot_Handle_Name]['Intro_Message']=Intro_Message
+    Botdetails[Bot_Handle_Name]['Rules']=Rules
+    path = os.path.join(os.getcwd()+'\\Organizations\\', Organizationame,Bot_Name)
+    Inputpath = os.path.join(os.getcwd()+'\\Organizations\\', Organizationame,Bot_Name,'Inputs')
+    Outputpath = os.path.join(os.getcwd()+'\\Organizations\\', Organizationame,Bot_Name,'Outputs')
+   
+    isExist = os.path.exists(path)
+
+    pp=os.path.join('Organizations',Organizationame+'\\Botdetails.json')
+
+    isfileE = os.path.isfile(pp)
+    if isfileE: #If file present "rb" and 'w'
+        with open(pp, 'rb') as txtfile:
+                d=json.load(txtfile)
+                d.update(Botdetails)
+        with open(pp, 'w') as txtfile:        
+                json.dump(d, txtfile)
+                if not isExist:
+                    os.makedirs(path)
+                    os.makedirs(Inputpath) 
+                    os.makedirs(Outputpath) 
+    else: #if file not present then create with 'w'
+        with open(pp, 'w') as txtfile:  
+                json.dump(Botdetails, txtfile)
+                if not isExist:
+                    os.makedirs(path)
+                    os.makedirs(Inputpath) 
+                    os.makedirs(Outputpath) 
+    return "Bot Created : " + b +" in "+bo +" Organization "
+
+
+
+
+def loadbotdata(SelectOrganizationame):
+    new=[]
+    if(os.path.isfile(os.getcwd()+'\\Organizations\\'+SelectOrganizationame+'\\Botdetails.json')):
+        fd = open(os.getcwd()+'\\Organizations\\'+SelectOrganizationame+'\\Botdetails.json')
+        data = json.load(fd)
+        for p_id, p_info in data.items():
+            new.append(p_id)
+        #return new
+        return gr.update(choices=new, value=new[0])
+
+
+def loadbotdataasdf(SelectOrganizationame):
+    df=[]
+    new=[]
+    if(os.path.isfile(os.getcwd()+'\\Organizations\\'+SelectOrganizationame+'\\Botdetails.json')):
+        fl = open(os.getcwd()+'\\Organizations\\'+SelectOrganizationame+'\\Botdetails.json')
+        data = json.load(fl)
+        df = pd.DataFrame.from_dict(data, orient='columns')
+        print (df)
+        for p_id, p_info in data.items():
+            new.append(p_id)
+        return df,gr.update(choices=new, value=new[0]) 
+
+def upload_file(org, bot , files):
+    file_paths = [file.name for file in files]
+    allfiles=file_paths
+    path = os.path.join(os.getcwd()+'\\Organizations\\', org,bot,'Inputs')
+    os.makedirs(path, exist_ok=True)
+    
+    for file_path in file_paths:
+        destination_path = os.path.join(path, file_path)
+        if not os.path.exists(destination_path):
+            shutil.copy(file_path, destination_path)
+        
+    return file_paths
+    
+def train(files):
+    for file in files:
+        print(file.name)
+        if file.name.endswith(".pdf"):
+            loader = PyPDFLoader(file.name)
+            documents = loader.load()
+    return "Training Done"
+chat_history = []
+
+def construct_index(directory_path):
+    file_paths=[]
+    for root, directories, files in os.walk(directory_path):
+        for file_name in files:
+            file_path = os.path.join(root, file_name)
+            file_paths.append(file_path)
+
+
+    for file in file_paths:        
+        if file.endswith(".pdf"):
+            loader = PyPDFLoader(file)
+            documents = loader.load()
+    return documents
+
+data_file_path = "deployment_archive_data.json"
+if not os.path.exists(data_file_path):
+    with open(data_file_path, "w") as file:
+        json.dump([], file)
+        
+def deployment_or_archive(action_type):
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+    # Load existing data from the JSON file
+    with open(data_file_path, "r") as file:
+        data = json.load(file)
+
+    # Add the new action to the data list
+    data.append({"action": action_type, "timestamp": timestamp})
+
+    # Write back the updated data to the JSON file
+    with open(data_file_path, "w") as file:
+        json.dump(data, file)
+
+def deploy_bot(org_name, bot_name):
+    
+    deployment_path = os.path.join(os.getcwd(), "Deployment")
+    os.makedirs(deployment_path, exist_ok=True)
+
+    
+    org_details_path = os.path.join(os.getcwd(), "Organizationdetails.json")
+    org_deploy_path = os.path.join(deployment_path, "Organizationdetails.json")
+    shutil.copy(org_details_path, org_deploy_path)
+
+    
+    org_path = os.path.join(os.getcwd(), "Organizations", org_name)
+    bot_details_path = os.path.join(org_path, "Botdetails.json")
+    bot_deploy_path = os.path.join(deployment_path, "Botdetails.json")
+    shutil.copy(bot_details_path, bot_deploy_path)
+
+    
+    bot_path = os.path.join(org_path, bot_name)
+    model_files = os.listdir(bot_path)
+    for file_name in model_files:
+        file_path = os.path.join(bot_path, file_name)
+        deploy_file_path = os.path.join(deployment_path, file_name)
+        shutil.copy(file_path, deploy_file_path)
+
+    return "Bot deployed successfully to the Deployment directory."
+
+
+
+
+def chatbot(input_text):
+    global chat_history
+    query = input_text
+    text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
+    texts = text_splitter.split_documents(documents)
+    embeddings = OpenAIEmbeddings()
+    db = Chroma.from_documents(texts, embeddings)
+    retriever = db.as_retriever(search_type="similarity", search_kwargs={"k":2})
+    vectordbkwargs = {"search_distance": 0.9}
+    qa = ConversationalRetrievalChain.from_llm(OpenAI(), retriever,return_source_documents=True)
+    print(chat_history)
+    if chat_history==[]:
+        result = qa({"question": query,"chat_history": chat_history, "vectordbkwargs": {"search_distance": 0.9}})
+    else:
+        result = qa({"question": query, "chat_history": chat_history, "vectordbkwargs": {"search_distance": 0.9}})
+    chat_history = [(query, result["answer"])]
+    return result["answer"]
+
+
+with demo:
+    gr.Markdown("BotRite")
+                                       
+    with gr.Tabs() :
+        with gr.TabItem("ChatBot"):
+            with gr.Row():
+                SelectOrg = gr.Dropdown(options_org ,label="Select Organization" )
+                
+            with gr.Row():
+                Selectbot = gr.Dropdown( label="Select Bot" ,choices=options_bot,
+                                                value=options_bot[0], interactive=True)
+               # Selectbot = gr.Radio(options_bot ,label="Select Bot")
+                
+            with gr.Column():
+                query_input = gr.Textbox(lines=7, label="Enter your text")
+                ask_button = gr.Button("Ask")
+        with gr.TabItem("Settings"):
+            with gr.Tabs():
+            
+                with gr.TabItem("Create Organization:"):
+                    with gr.Row():
+                            org_name = gr.Textbox(label="Name",info="Your name / Nickname",placeholder="Enter you organization full name")
+                            org_handle = gr.Textbox(label="Handle Name",info="Your unique organization name", placeholder="Enter Organization handle name")
+                            output_org =gr.Textbox(label='Status')
+                    with gr.Row():
+                        Createorg_button = gr.Button("Create Organization")
+                        Clearorg_button = gr.Button("Clear", variant="stop")
+                        
+                with gr.TabItem("Bot Details"):
+                    SelectOrganizationame = gr.Dropdown(options_org, label="Select Organization")
+                    with gr.Tabs():
+                            with gr.TabItem("Your Bots:"):
+                                with gr.Row():
+                                    with gr.Column():
+                                        #SelectOrganizationame = gr.components.Dropdown(options_org, label="Select Organization")
+                                        botdf=gr.Dataframe(headers=["Bot_Name", "Organizationame", "Created_by", "Created_Time","Bot_Handle_Name","Bot_Image","Tools","OpenAI_API_key",
+                                       "Initial_Message","Intro_Message","Rules"], label="Bot Details")
+                                        
+                            with gr.TabItem("Create Bot:"):      
+                                
+                                        Organizationame =SelectOrganizationame
+                                        botname = gr.Textbox(label="Bot Name",info="Your bot name / Nickname", placeholder="Enter bot full name")
+                                        bothandle = gr.Textbox(label="Bot Handle Name",info="Your unique bot name" ,placeholder="Enter bot handle name")
+                                        image_button = gr.File(label="Select bot image")
+                                        botllm = gr.components.CheckboxGroup(['OpenAI', 'Dolly', 'Q&A Model'],label="Tools")
+                                       # model = gr.components.Dropdown(Options1, label="Model")
+                                        openai_key = gr.Textbox(label="You OpenAI API key", type="password" , info="Add your OpenAi Key click the link to create new or copy exsisting key from your openai account https://platform.openai.com/account/api-keys")
+                                        initailsmsg = gr.Textbox(label="Initial Message", placeholder="This message will be shared by bot as intro​" , info="This message will be shared by bot as intro​")
+                                        intromsg = gr.Textbox(label="Intro Message", placeholder="This message will be sent to bot as prefix to  first message​", info="This message will be sent to bot as prefix to  first message​")
+                                        rules = gr.Textbox(label="Rules", placeholder="These rules will be sent to bot as prefix to  first message (after introduction)​", info="These rules will be sent to bot as prefix to  first message (after introduction)​")
+                                        output_bot =gr.Textbox(label='Status')
+                                        Createbot_button = gr.Button("Create Bot")   
+                            with gr.TabItem("Bot Configuration"):
+                                Selectbotconfig = gr.Dropdown(label="Select Bot",choices=options_bot,
+                                                value=options_bot[0], interactive=True)
+                                with gr.TabItem("Load Data"):
+                                    with gr.Row():
+                                        with gr.Column():
+                                            Train_Fileselect_button = gr.UploadButton("Upload PDF Files", file_types=[".pdf"], file_count="multiple")
+                                            file_output = gr.File()
+                                        with gr.Column():   
+                                            Train_button = gr.Button("Train Data")
+                                            Train_output =gr.Textbox(label='Status')
+
+                                with gr.TabItem("Chat with your bot"):
+                                    with gr.Row():
+                                        with gr.Column():
+                                            query_input = gr.Textbox(lines=7, label="Enter your text")
+                                            ask_button = gr.Button("Ask")
+                                        with gr.Column():
+                                            text_output=gr.Text(label="Your Bot Answer")
+                                with gr.TabItem("Deploy"):
+                                      with gr.Row():
+                                            archive_button = gr.Button("Archive")
+                                            deploy_button = gr.Button("Deploy")
+                                            deploy_archive_output = gr.Textbox(label='Status')
+                                            
+                                            archive_output = gr.Textbox(label='Status')
+                                            publish_button = gr.Button("Publish")
+                                with gr.TabItem("Logs"):
+                                      with gr.Column():
+                                            Selectlog = gr.Dropdown( label="Select Log")
+                                            logview = gr.Text(label="Log")
+    #def Dropdown_Org(x):
+   
+    SelectOrg.change(fn=loadbotdata, inputs=SelectOrg,outputs=Selectbot )  
+    SelectOrganizationame.change(fn=loadbotdataasdf, inputs=SelectOrganizationame,outputs=[botdf,Selectbotconfig])  
+    Createorg_button.click(fn=Create_Organization,inputs=[org_name, org_handle], outputs=output_org)
+    
+    archive_button.click(fn=deploy_bot, inputs=[SelectOrganizationame, Selectbotconfig], outputs=archive_output)
+    deploy_button.click(lambda: deployment_or_archive("deploy"), outputs=deploy_archive_output)
+    archive_button.click(lambda: deployment_or_archive("archive"), outputs=deploy_archive_output)
+
+    Clearorg_button.click(lambda : [None,None,None], inputs=None, outputs=[org_name,org_handle,output_org]) 
+    Createbot_button.click(fn=Create_Bot,inputs=[Organizationame, botname, bothandle,image_button,botllm,openai_key,initailsmsg,intromsg,rules], outputs=output_bot)
+    
+    Train_Fileselect_button.upload(upload_file,inputs=[SelectOrganizationame, Selectbotconfig,Train_Fileselect_button], outputs=[file_output])
+    Train_button.click(fn=train,inputs=Train_Fileselect_button, outputs=Train_output)
+    
+demo.launch()